lms.backend.canvas.backend

  1# pylint: disable=abstract-method
  2
  3import typing
  4
  5import lms.backend.canvas.courses.assignments.list
  6import lms.backend.canvas.courses.assignments.scores.list
  7import lms.backend.canvas.courses.assignments.scores.upload
  8import lms.backend.canvas.courses.gradebook.fetch
  9import lms.backend.canvas.courses.groupsets.create
 10import lms.backend.canvas.courses.groupsets.delete
 11import lms.backend.canvas.courses.groupsets.list
 12import lms.backend.canvas.courses.groupsets.memberships.list
 13import lms.backend.canvas.courses.groups.create
 14import lms.backend.canvas.courses.groups.delete
 15import lms.backend.canvas.courses.groups.list
 16import lms.backend.canvas.courses.groups.memberships.add
 17import lms.backend.canvas.courses.groups.memberships.list
 18import lms.backend.canvas.courses.groups.memberships.subtract
 19import lms.backend.canvas.courses.list
 20import lms.backend.canvas.courses.quizzes.list
 21import lms.backend.canvas.courses.quizzes.groups.list
 22import lms.backend.canvas.courses.quizzes.questions.list
 23import lms.backend.canvas.courses.syllabus.fetch
 24import lms.backend.canvas.courses.users.list
 25import lms.backend.canvas.courses.users.scores.list
 26import lms.model.assignments
 27import lms.model.backend
 28import lms.model.constants
 29import lms.model.courses
 30import lms.model.groups
 31import lms.model.groupsets
 32import lms.model.quizzes
 33import lms.model.scores
 34import lms.model.users
 35import lms.util.parse
 36
 37class CanvasBackend(lms.model.backend.APIBackend):
 38    """ An API backend for Instructure's Canvas LMS. """
 39
 40    def __init__(self,
 41            server: str,
 42            auth_token: typing.Union[str, None] = None,
 43            **kwargs: typing.Any) -> None:
 44        super().__init__(server, lms.model.constants.BACKEND_TYPE_CANVAS, **kwargs)
 45
 46        if (auth_token is None):
 47            raise ValueError("Canvas backends require a token.")
 48
 49        self.auth_token: str = auth_token
 50        """ The token to authenticate with. """
 51
 52    def get_standard_headers(self) -> typing.Dict[str, str]:
 53        headers = super().get_standard_headers()
 54
 55        headers['Authorization'] = f"Bearer {self.auth_token}"
 56
 57        return headers
 58
 59    def courses_list(self,
 60            **kwargs: typing.Any) -> typing.List[lms.model.courses.Course]:
 61        return lms.backend.canvas.courses.list.request(self)
 62
 63    def courses_assignments_list(self,
 64            course_id: str,
 65            **kwargs: typing.Any) -> typing.List[lms.model.assignments.Assignment]:
 66        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
 67        return lms.backend.canvas.courses.assignments.list.request(self, parsed_course_id)
 68
 69    def courses_assignments_scores_list(self,
 70            course_id: str,
 71            assignment_id: str,
 72            **kwargs: typing.Any) -> typing.List[lms.model.scores.AssignmentScore]:
 73        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
 74        parsed_assignment_id = lms.util.parse.required_int(assignment_id, 'assignment_id')
 75        return lms.backend.canvas.courses.assignments.scores.list.request(self, parsed_course_id, parsed_assignment_id)
 76
 77    def courses_assignments_scores_upload(self,
 78            course_id: str,
 79            assignment_id: str,
 80            scores: typing.Dict[str, lms.model.scores.ScoreFragment],
 81            **kwargs: typing.Any) -> int:
 82        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
 83        parsed_assignment_id = lms.util.parse.required_int(assignment_id, 'assignment_id')
 84        parsed_scores = {lms.util.parse.required_int(user_id, 'user_id'): score for (user_id, score) in scores.items()}
 85        return lms.backend.canvas.courses.assignments.scores.upload.request(self, parsed_course_id, parsed_assignment_id, parsed_scores)
 86
 87    def courses_gradebook_fetch(self,
 88            course_id: str,
 89            assignment_ids: typing.Collection[str],
 90            user_ids: typing.Collection[str],
 91            **kwargs: typing.Any) -> lms.model.scores.Gradebook:
 92        if ((len(assignment_ids) == 0) or (len(user_ids) == 0)):
 93            assignment_queries = [lms.model.assignments.AssignmentQuery(id = id) for id in assignment_ids]
 94            user_queries = [lms.model.users.UserQuery(id = id) for id in user_ids]
 95            return lms.model.scores.Gradebook(assignment_queries, user_queries)
 96
 97        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
 98        parsed_assignment_ids = [lms.util.parse.required_int(assignment_id, 'assignment_id') for assignment_id in assignment_ids]
 99        parsed_user_ids = [lms.util.parse.required_int(user_id, 'user_id') for user_id in user_ids]
100
101        return lms.backend.canvas.courses.gradebook.fetch.request(self, parsed_course_id, parsed_assignment_ids, parsed_user_ids)
102
103    def courses_groupsets_create(self,
104            course_id: str,
105            name: str,
106            **kwargs: typing.Any) -> lms.model.groupsets.GroupSet:
107        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
108        return lms.backend.canvas.courses.groupsets.create.request(self, parsed_course_id, name)
109
110    def courses_groupsets_delete(self,
111            course_id: str,
112            groupset_id: str,
113            **kwargs: typing.Any) -> bool:
114        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
115        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
116        return lms.backend.canvas.courses.groupsets.delete.request(self, parsed_course_id, parsed_groupset_id)
117
118    def courses_groupsets_list(self,
119            course_id: str,
120            **kwargs: typing.Any) -> typing.List[lms.model.groupsets.GroupSet]:
121        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
122        return lms.backend.canvas.courses.groupsets.list.request(self, parsed_course_id)
123
124    def courses_groupsets_memberships_list(self,
125            course_id: str,
126            groupset_id: str,
127            **kwargs: typing.Any) -> typing.List[lms.model.groupsets.GroupSetMembership]:
128        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
129        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
130        return lms.backend.canvas.courses.groupsets.memberships.list.request(self, parsed_course_id, parsed_groupset_id)
131
132    def courses_groups_create(self,
133            course_id: str,
134            groupset_id: str,
135            name: str,
136            **kwargs: typing.Any) -> lms.model.groups.Group:
137        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
138        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
139        return lms.backend.canvas.courses.groups.create.request(self, parsed_course_id, parsed_groupset_id, name)
140
141    def courses_groups_delete(self,
142            course_id: str,
143            groupset_id: str,
144            group_id: str,
145            **kwargs: typing.Any) -> bool:
146        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
147        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
148        parsed_group_id = lms.util.parse.required_int(group_id, 'group_id')
149        return lms.backend.canvas.courses.groups.delete.request(self, parsed_course_id, parsed_groupset_id, parsed_group_id)
150
151    def courses_groups_list(self,
152            course_id: str,
153            groupset_id: str,
154            **kwargs: typing.Any) -> typing.List[lms.model.groups.Group]:
155        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
156        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
157        return lms.backend.canvas.courses.groups.list.request(self, parsed_course_id, parsed_groupset_id)
158
159    def courses_groups_memberships_add(self,
160            course_id: str,
161            groupset_id: str,
162            group_id: str,
163            user_ids: typing.Collection[str],
164            **kwargs: typing.Any) -> int:
165        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
166        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
167        parsed_group_id = lms.util.parse.required_int(group_id, 'group_id')
168        parsed_user_ids = [lms.util.parse.required_int(user_id, 'user_id') for user_id in user_ids]
169        return lms.backend.canvas.courses.groups.memberships.add.request(self, parsed_course_id, parsed_groupset_id, parsed_group_id, parsed_user_ids)
170
171    def courses_groups_memberships_list(self,
172            course_id: str,
173            groupset_id: str,
174            group_id: str,
175            **kwargs: typing.Any) -> typing.List[lms.model.groupsets.GroupSetMembership]:
176        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
177        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
178        parsed_group_id = lms.util.parse.required_int(group_id, 'group_id')
179        return lms.backend.canvas.courses.groups.memberships.list.request(self, parsed_course_id, parsed_groupset_id, parsed_group_id)
180
181    def courses_groups_memberships_subtract(self,
182            course_id: str,
183            groupset_id: str,
184            group_id: str,
185            user_ids: typing.Collection[str],
186            **kwargs: typing.Any) -> int:
187        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
188        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
189        parsed_group_id = lms.util.parse.required_int(group_id, 'group_id')
190        parsed_user_ids = [lms.util.parse.required_int(user_id, 'user_id') for user_id in user_ids]
191        return lms.backend.canvas.courses.groups.memberships.subtract.request(self,
192                parsed_course_id, parsed_groupset_id, parsed_group_id, parsed_user_ids)
193
194    def courses_quizzes_list(self,
195            course_id: str,
196            fetch_resources: bool = False,
197            **kwargs: typing.Any) -> typing.List[lms.model.quizzes.Quiz]:
198        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
199        return lms.backend.canvas.courses.quizzes.list.request(self, parsed_course_id, fetch_resources)
200
201    def courses_quizzes_groups_list(self,
202            course_id: str,
203            quiz_id: str,
204            **kwargs: typing.Any) -> typing.List[lms.model.quizzes.QuestionGroup]:
205        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
206        parsed_quiz_id = lms.util.parse.required_int(quiz_id, 'quiz_id')
207        return lms.backend.canvas.courses.quizzes.groups.list.request(self, parsed_course_id, parsed_quiz_id)
208
209    def courses_quizzes_questions_list(self,
210            course_id: str,
211            quiz_id: str,
212            fetch_resources: bool = False,
213            **kwargs: typing.Any) -> typing.List[lms.model.quizzes.Question]:
214        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
215        parsed_quiz_id = lms.util.parse.required_int(quiz_id, 'quiz_id')
216        return lms.backend.canvas.courses.quizzes.questions.list.request(self, parsed_course_id, parsed_quiz_id, fetch_resources)
217
218    def courses_syllabus_fetch(self,
219            course_id: str,
220            **kwargs: typing.Any) -> typing.Union[str, None]:
221        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
222        return lms.backend.canvas.courses.syllabus.fetch.request(self, parsed_course_id)
223
224    def courses_users_list(self,
225            course_id: str,
226            **kwargs: typing.Any) -> typing.List[lms.model.users.CourseUser]:
227        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
228        return lms.backend.canvas.courses.users.list.request(self, parsed_course_id)
229
230    def courses_users_scores_list(self,
231            course_id: str,
232            user_id: str,
233            **kwargs: typing.Any) -> typing.List[lms.model.scores.AssignmentScore]:
234        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
235        parsed_user_id = lms.util.parse.required_int(user_id, 'user_id')
236        return lms.backend.canvas.courses.users.scores.list.request(self, parsed_course_id, parsed_user_id)
class CanvasBackend(lms.model.backend.APIBackend):
 38class CanvasBackend(lms.model.backend.APIBackend):
 39    """ An API backend for Instructure's Canvas LMS. """
 40
 41    def __init__(self,
 42            server: str,
 43            auth_token: typing.Union[str, None] = None,
 44            **kwargs: typing.Any) -> None:
 45        super().__init__(server, lms.model.constants.BACKEND_TYPE_CANVAS, **kwargs)
 46
 47        if (auth_token is None):
 48            raise ValueError("Canvas backends require a token.")
 49
 50        self.auth_token: str = auth_token
 51        """ The token to authenticate with. """
 52
 53    def get_standard_headers(self) -> typing.Dict[str, str]:
 54        headers = super().get_standard_headers()
 55
 56        headers['Authorization'] = f"Bearer {self.auth_token}"
 57
 58        return headers
 59
 60    def courses_list(self,
 61            **kwargs: typing.Any) -> typing.List[lms.model.courses.Course]:
 62        return lms.backend.canvas.courses.list.request(self)
 63
 64    def courses_assignments_list(self,
 65            course_id: str,
 66            **kwargs: typing.Any) -> typing.List[lms.model.assignments.Assignment]:
 67        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
 68        return lms.backend.canvas.courses.assignments.list.request(self, parsed_course_id)
 69
 70    def courses_assignments_scores_list(self,
 71            course_id: str,
 72            assignment_id: str,
 73            **kwargs: typing.Any) -> typing.List[lms.model.scores.AssignmentScore]:
 74        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
 75        parsed_assignment_id = lms.util.parse.required_int(assignment_id, 'assignment_id')
 76        return lms.backend.canvas.courses.assignments.scores.list.request(self, parsed_course_id, parsed_assignment_id)
 77
 78    def courses_assignments_scores_upload(self,
 79            course_id: str,
 80            assignment_id: str,
 81            scores: typing.Dict[str, lms.model.scores.ScoreFragment],
 82            **kwargs: typing.Any) -> int:
 83        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
 84        parsed_assignment_id = lms.util.parse.required_int(assignment_id, 'assignment_id')
 85        parsed_scores = {lms.util.parse.required_int(user_id, 'user_id'): score for (user_id, score) in scores.items()}
 86        return lms.backend.canvas.courses.assignments.scores.upload.request(self, parsed_course_id, parsed_assignment_id, parsed_scores)
 87
 88    def courses_gradebook_fetch(self,
 89            course_id: str,
 90            assignment_ids: typing.Collection[str],
 91            user_ids: typing.Collection[str],
 92            **kwargs: typing.Any) -> lms.model.scores.Gradebook:
 93        if ((len(assignment_ids) == 0) or (len(user_ids) == 0)):
 94            assignment_queries = [lms.model.assignments.AssignmentQuery(id = id) for id in assignment_ids]
 95            user_queries = [lms.model.users.UserQuery(id = id) for id in user_ids]
 96            return lms.model.scores.Gradebook(assignment_queries, user_queries)
 97
 98        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
 99        parsed_assignment_ids = [lms.util.parse.required_int(assignment_id, 'assignment_id') for assignment_id in assignment_ids]
100        parsed_user_ids = [lms.util.parse.required_int(user_id, 'user_id') for user_id in user_ids]
101
102        return lms.backend.canvas.courses.gradebook.fetch.request(self, parsed_course_id, parsed_assignment_ids, parsed_user_ids)
103
104    def courses_groupsets_create(self,
105            course_id: str,
106            name: str,
107            **kwargs: typing.Any) -> lms.model.groupsets.GroupSet:
108        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
109        return lms.backend.canvas.courses.groupsets.create.request(self, parsed_course_id, name)
110
111    def courses_groupsets_delete(self,
112            course_id: str,
113            groupset_id: str,
114            **kwargs: typing.Any) -> bool:
115        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
116        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
117        return lms.backend.canvas.courses.groupsets.delete.request(self, parsed_course_id, parsed_groupset_id)
118
119    def courses_groupsets_list(self,
120            course_id: str,
121            **kwargs: typing.Any) -> typing.List[lms.model.groupsets.GroupSet]:
122        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
123        return lms.backend.canvas.courses.groupsets.list.request(self, parsed_course_id)
124
125    def courses_groupsets_memberships_list(self,
126            course_id: str,
127            groupset_id: str,
128            **kwargs: typing.Any) -> typing.List[lms.model.groupsets.GroupSetMembership]:
129        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
130        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
131        return lms.backend.canvas.courses.groupsets.memberships.list.request(self, parsed_course_id, parsed_groupset_id)
132
133    def courses_groups_create(self,
134            course_id: str,
135            groupset_id: str,
136            name: str,
137            **kwargs: typing.Any) -> lms.model.groups.Group:
138        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
139        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
140        return lms.backend.canvas.courses.groups.create.request(self, parsed_course_id, parsed_groupset_id, name)
141
142    def courses_groups_delete(self,
143            course_id: str,
144            groupset_id: str,
145            group_id: str,
146            **kwargs: typing.Any) -> bool:
147        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
148        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
149        parsed_group_id = lms.util.parse.required_int(group_id, 'group_id')
150        return lms.backend.canvas.courses.groups.delete.request(self, parsed_course_id, parsed_groupset_id, parsed_group_id)
151
152    def courses_groups_list(self,
153            course_id: str,
154            groupset_id: str,
155            **kwargs: typing.Any) -> typing.List[lms.model.groups.Group]:
156        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
157        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
158        return lms.backend.canvas.courses.groups.list.request(self, parsed_course_id, parsed_groupset_id)
159
160    def courses_groups_memberships_add(self,
161            course_id: str,
162            groupset_id: str,
163            group_id: str,
164            user_ids: typing.Collection[str],
165            **kwargs: typing.Any) -> int:
166        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
167        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
168        parsed_group_id = lms.util.parse.required_int(group_id, 'group_id')
169        parsed_user_ids = [lms.util.parse.required_int(user_id, 'user_id') for user_id in user_ids]
170        return lms.backend.canvas.courses.groups.memberships.add.request(self, parsed_course_id, parsed_groupset_id, parsed_group_id, parsed_user_ids)
171
172    def courses_groups_memberships_list(self,
173            course_id: str,
174            groupset_id: str,
175            group_id: str,
176            **kwargs: typing.Any) -> typing.List[lms.model.groupsets.GroupSetMembership]:
177        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
178        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
179        parsed_group_id = lms.util.parse.required_int(group_id, 'group_id')
180        return lms.backend.canvas.courses.groups.memberships.list.request(self, parsed_course_id, parsed_groupset_id, parsed_group_id)
181
182    def courses_groups_memberships_subtract(self,
183            course_id: str,
184            groupset_id: str,
185            group_id: str,
186            user_ids: typing.Collection[str],
187            **kwargs: typing.Any) -> int:
188        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
189        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
190        parsed_group_id = lms.util.parse.required_int(group_id, 'group_id')
191        parsed_user_ids = [lms.util.parse.required_int(user_id, 'user_id') for user_id in user_ids]
192        return lms.backend.canvas.courses.groups.memberships.subtract.request(self,
193                parsed_course_id, parsed_groupset_id, parsed_group_id, parsed_user_ids)
194
195    def courses_quizzes_list(self,
196            course_id: str,
197            fetch_resources: bool = False,
198            **kwargs: typing.Any) -> typing.List[lms.model.quizzes.Quiz]:
199        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
200        return lms.backend.canvas.courses.quizzes.list.request(self, parsed_course_id, fetch_resources)
201
202    def courses_quizzes_groups_list(self,
203            course_id: str,
204            quiz_id: str,
205            **kwargs: typing.Any) -> typing.List[lms.model.quizzes.QuestionGroup]:
206        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
207        parsed_quiz_id = lms.util.parse.required_int(quiz_id, 'quiz_id')
208        return lms.backend.canvas.courses.quizzes.groups.list.request(self, parsed_course_id, parsed_quiz_id)
209
210    def courses_quizzes_questions_list(self,
211            course_id: str,
212            quiz_id: str,
213            fetch_resources: bool = False,
214            **kwargs: typing.Any) -> typing.List[lms.model.quizzes.Question]:
215        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
216        parsed_quiz_id = lms.util.parse.required_int(quiz_id, 'quiz_id')
217        return lms.backend.canvas.courses.quizzes.questions.list.request(self, parsed_course_id, parsed_quiz_id, fetch_resources)
218
219    def courses_syllabus_fetch(self,
220            course_id: str,
221            **kwargs: typing.Any) -> typing.Union[str, None]:
222        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
223        return lms.backend.canvas.courses.syllabus.fetch.request(self, parsed_course_id)
224
225    def courses_users_list(self,
226            course_id: str,
227            **kwargs: typing.Any) -> typing.List[lms.model.users.CourseUser]:
228        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
229        return lms.backend.canvas.courses.users.list.request(self, parsed_course_id)
230
231    def courses_users_scores_list(self,
232            course_id: str,
233            user_id: str,
234            **kwargs: typing.Any) -> typing.List[lms.model.scores.AssignmentScore]:
235        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
236        parsed_user_id = lms.util.parse.required_int(user_id, 'user_id')
237        return lms.backend.canvas.courses.users.scores.list.request(self, parsed_course_id, parsed_user_id)

An API backend for Instructure's Canvas LMS.

CanvasBackend(server: str, auth_token: Optional[str] = None, **kwargs: Any)
41    def __init__(self,
42            server: str,
43            auth_token: typing.Union[str, None] = None,
44            **kwargs: typing.Any) -> None:
45        super().__init__(server, lms.model.constants.BACKEND_TYPE_CANVAS, **kwargs)
46
47        if (auth_token is None):
48            raise ValueError("Canvas backends require a token.")
49
50        self.auth_token: str = auth_token
51        """ The token to authenticate with. """
auth_token: str

The token to authenticate with.

def get_standard_headers(self) -> Dict[str, str]:
53    def get_standard_headers(self) -> typing.Dict[str, str]:
54        headers = super().get_standard_headers()
55
56        headers['Authorization'] = f"Bearer {self.auth_token}"
57
58        return headers

Get standard headers for this backend. Children should take care to set the write header when performing a write operation.

def courses_list(self, **kwargs: Any) -> List[lms.model.courses.Course]:
60    def courses_list(self,
61            **kwargs: typing.Any) -> typing.List[lms.model.courses.Course]:
62        return lms.backend.canvas.courses.list.request(self)

List the courses associated with the context user.

def courses_assignments_list( self, course_id: str, **kwargs: Any) -> List[lms.model.assignments.Assignment]:
64    def courses_assignments_list(self,
65            course_id: str,
66            **kwargs: typing.Any) -> typing.List[lms.model.assignments.Assignment]:
67        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
68        return lms.backend.canvas.courses.assignments.list.request(self, parsed_course_id)

List the assignments associated with the given course.

def courses_assignments_scores_list( self, course_id: str, assignment_id: str, **kwargs: Any) -> List[lms.model.scores.AssignmentScore]:
70    def courses_assignments_scores_list(self,
71            course_id: str,
72            assignment_id: str,
73            **kwargs: typing.Any) -> typing.List[lms.model.scores.AssignmentScore]:
74        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
75        parsed_assignment_id = lms.util.parse.required_int(assignment_id, 'assignment_id')
76        return lms.backend.canvas.courses.assignments.scores.list.request(self, parsed_course_id, parsed_assignment_id)

List the scores associated with the given assignment.

def courses_assignments_scores_upload( self, course_id: str, assignment_id: str, scores: Dict[str, lms.model.scores.ScoreFragment], **kwargs: Any) -> int:
78    def courses_assignments_scores_upload(self,
79            course_id: str,
80            assignment_id: str,
81            scores: typing.Dict[str, lms.model.scores.ScoreFragment],
82            **kwargs: typing.Any) -> int:
83        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
84        parsed_assignment_id = lms.util.parse.required_int(assignment_id, 'assignment_id')
85        parsed_scores = {lms.util.parse.required_int(user_id, 'user_id'): score for (user_id, score) in scores.items()}
86        return lms.backend.canvas.courses.assignments.scores.upload.request(self, parsed_course_id, parsed_assignment_id, parsed_scores)

Upload assignment scores (indexed by user id). A None score (ScoreFragment.score) indicates that the score should be cleared. Return the number of scores sent to the LMS.

def courses_gradebook_fetch( self, course_id: str, assignment_ids: Collection[str], user_ids: Collection[str], **kwargs: Any) -> lms.model.scores.Gradebook:
 88    def courses_gradebook_fetch(self,
 89            course_id: str,
 90            assignment_ids: typing.Collection[str],
 91            user_ids: typing.Collection[str],
 92            **kwargs: typing.Any) -> lms.model.scores.Gradebook:
 93        if ((len(assignment_ids) == 0) or (len(user_ids) == 0)):
 94            assignment_queries = [lms.model.assignments.AssignmentQuery(id = id) for id in assignment_ids]
 95            user_queries = [lms.model.users.UserQuery(id = id) for id in user_ids]
 96            return lms.model.scores.Gradebook(assignment_queries, user_queries)
 97
 98        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
 99        parsed_assignment_ids = [lms.util.parse.required_int(assignment_id, 'assignment_id') for assignment_id in assignment_ids]
100        parsed_user_ids = [lms.util.parse.required_int(user_id, 'user_id') for user_id in user_ids]
101
102        return lms.backend.canvas.courses.gradebook.fetch.request(self, parsed_course_id, parsed_assignment_ids, parsed_user_ids)

Get a gradebook with the specified users and assignments. If either the assignments or users is empty, an empty gradebook will be returned.

def courses_groupsets_create( self, course_id: str, name: str, **kwargs: Any) -> lms.model.groupsets.GroupSet:
104    def courses_groupsets_create(self,
105            course_id: str,
106            name: str,
107            **kwargs: typing.Any) -> lms.model.groupsets.GroupSet:
108        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
109        return lms.backend.canvas.courses.groupsets.create.request(self, parsed_course_id, name)

Create a group set.

def courses_groupsets_delete(self, course_id: str, groupset_id: str, **kwargs: Any) -> bool:
111    def courses_groupsets_delete(self,
112            course_id: str,
113            groupset_id: str,
114            **kwargs: typing.Any) -> bool:
115        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
116        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
117        return lms.backend.canvas.courses.groupsets.delete.request(self, parsed_course_id, parsed_groupset_id)

Delete a group set.

def courses_groupsets_list( self, course_id: str, **kwargs: Any) -> List[lms.model.groupsets.GroupSet]:
119    def courses_groupsets_list(self,
120            course_id: str,
121            **kwargs: typing.Any) -> typing.List[lms.model.groupsets.GroupSet]:
122        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
123        return lms.backend.canvas.courses.groupsets.list.request(self, parsed_course_id)

List the group sets associated with the given course.

def courses_groupsets_memberships_list( self, course_id: str, groupset_id: str, **kwargs: Any) -> List[lms.model.groupsets.GroupSetMembership]:
125    def courses_groupsets_memberships_list(self,
126            course_id: str,
127            groupset_id: str,
128            **kwargs: typing.Any) -> typing.List[lms.model.groupsets.GroupSetMembership]:
129        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
130        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
131        return lms.backend.canvas.courses.groupsets.memberships.list.request(self, parsed_course_id, parsed_groupset_id)

List the membership of the group sets associated with the given course.

def courses_groups_create( self, course_id: str, groupset_id: str, name: str, **kwargs: Any) -> lms.model.groups.Group:
133    def courses_groups_create(self,
134            course_id: str,
135            groupset_id: str,
136            name: str,
137            **kwargs: typing.Any) -> lms.model.groups.Group:
138        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
139        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
140        return lms.backend.canvas.courses.groups.create.request(self, parsed_course_id, parsed_groupset_id, name)

Create a group.

def courses_groups_delete( self, course_id: str, groupset_id: str, group_id: str, **kwargs: Any) -> bool:
142    def courses_groups_delete(self,
143            course_id: str,
144            groupset_id: str,
145            group_id: str,
146            **kwargs: typing.Any) -> bool:
147        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
148        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
149        parsed_group_id = lms.util.parse.required_int(group_id, 'group_id')
150        return lms.backend.canvas.courses.groups.delete.request(self, parsed_course_id, parsed_groupset_id, parsed_group_id)

Delete a group.

def courses_groups_list( self, course_id: str, groupset_id: str, **kwargs: Any) -> List[lms.model.groups.Group]:
152    def courses_groups_list(self,
153            course_id: str,
154            groupset_id: str,
155            **kwargs: typing.Any) -> typing.List[lms.model.groups.Group]:
156        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
157        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
158        return lms.backend.canvas.courses.groups.list.request(self, parsed_course_id, parsed_groupset_id)

List the groups associated with the given course.

def courses_groups_memberships_add( self, course_id: str, groupset_id: str, group_id: str, user_ids: Collection[str], **kwargs: Any) -> int:
160    def courses_groups_memberships_add(self,
161            course_id: str,
162            groupset_id: str,
163            group_id: str,
164            user_ids: typing.Collection[str],
165            **kwargs: typing.Any) -> int:
166        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
167        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
168        parsed_group_id = lms.util.parse.required_int(group_id, 'group_id')
169        parsed_user_ids = [lms.util.parse.required_int(user_id, 'user_id') for user_id in user_ids]
170        return lms.backend.canvas.courses.groups.memberships.add.request(self, parsed_course_id, parsed_groupset_id, parsed_group_id, parsed_user_ids)

Add the specified users to the group.

def courses_groups_memberships_list( self, course_id: str, groupset_id: str, group_id: str, **kwargs: Any) -> List[lms.model.groupsets.GroupSetMembership]:
172    def courses_groups_memberships_list(self,
173            course_id: str,
174            groupset_id: str,
175            group_id: str,
176            **kwargs: typing.Any) -> typing.List[lms.model.groupsets.GroupSetMembership]:
177        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
178        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
179        parsed_group_id = lms.util.parse.required_int(group_id, 'group_id')
180        return lms.backend.canvas.courses.groups.memberships.list.request(self, parsed_course_id, parsed_groupset_id, parsed_group_id)

List the membership of the group associated with the given group set.

def courses_groups_memberships_subtract( self, course_id: str, groupset_id: str, group_id: str, user_ids: Collection[str], **kwargs: Any) -> int:
182    def courses_groups_memberships_subtract(self,
183            course_id: str,
184            groupset_id: str,
185            group_id: str,
186            user_ids: typing.Collection[str],
187            **kwargs: typing.Any) -> int:
188        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
189        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
190        parsed_group_id = lms.util.parse.required_int(group_id, 'group_id')
191        parsed_user_ids = [lms.util.parse.required_int(user_id, 'user_id') for user_id in user_ids]
192        return lms.backend.canvas.courses.groups.memberships.subtract.request(self,
193                parsed_course_id, parsed_groupset_id, parsed_group_id, parsed_user_ids)

Subtract the specified users from the group.

def courses_quizzes_list( self, course_id: str, fetch_resources: bool = False, **kwargs: Any) -> List[lms.model.quizzes.Quiz]:
195    def courses_quizzes_list(self,
196            course_id: str,
197            fetch_resources: bool = False,
198            **kwargs: typing.Any) -> typing.List[lms.model.quizzes.Quiz]:
199        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
200        return lms.backend.canvas.courses.quizzes.list.request(self, parsed_course_id, fetch_resources)

List the quizzes associated with the given course. If specified, additional resources associated with the quiz (e.g., images) may also be fetched.

def courses_quizzes_groups_list( self, course_id: str, quiz_id: str, **kwargs: Any) -> List[lms.model.quizzes.QuestionGroup]:
202    def courses_quizzes_groups_list(self,
203            course_id: str,
204            quiz_id: str,
205            **kwargs: typing.Any) -> typing.List[lms.model.quizzes.QuestionGroup]:
206        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
207        parsed_quiz_id = lms.util.parse.required_int(quiz_id, 'quiz_id')
208        return lms.backend.canvas.courses.quizzes.groups.list.request(self, parsed_course_id, parsed_quiz_id)

List the quiz question groups associated with the given course and quiz.

def courses_quizzes_questions_list( self, course_id: str, quiz_id: str, fetch_resources: bool = False, **kwargs: Any) -> List[lms.model.quizzes.Question]:
210    def courses_quizzes_questions_list(self,
211            course_id: str,
212            quiz_id: str,
213            fetch_resources: bool = False,
214            **kwargs: typing.Any) -> typing.List[lms.model.quizzes.Question]:
215        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
216        parsed_quiz_id = lms.util.parse.required_int(quiz_id, 'quiz_id')
217        return lms.backend.canvas.courses.quizzes.questions.list.request(self, parsed_course_id, parsed_quiz_id, fetch_resources)

List the quiz questions associated with the given course and quiz. If specified, additional resources associated with the questions (e.g., images) may also be fetched.

def courses_syllabus_fetch(self, course_id: str, **kwargs: Any) -> Optional[str]:
219    def courses_syllabus_fetch(self,
220            course_id: str,
221            **kwargs: typing.Any) -> typing.Union[str, None]:
222        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
223        return lms.backend.canvas.courses.syllabus.fetch.request(self, parsed_course_id)

Get the syllabus for a course, or None if no syllabus exists.

def courses_users_list(self, course_id: str, **kwargs: Any) -> List[lms.model.users.CourseUser]:
225    def courses_users_list(self,
226            course_id: str,
227            **kwargs: typing.Any) -> typing.List[lms.model.users.CourseUser]:
228        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
229        return lms.backend.canvas.courses.users.list.request(self, parsed_course_id)

List the users associated with the given course.

def courses_users_scores_list( self, course_id: str, user_id: str, **kwargs: Any) -> List[lms.model.scores.AssignmentScore]:
231    def courses_users_scores_list(self,
232            course_id: str,
233            user_id: str,
234            **kwargs: typing.Any) -> typing.List[lms.model.scores.AssignmentScore]:
235        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
236        parsed_user_id = lms.util.parse.required_int(user_id, 'user_id')
237        return lms.backend.canvas.courses.users.scores.list.request(self, parsed_course_id, parsed_user_id)

List the scores associated with the given user.

Inherited Members
lms.model.backend.APIBackend
server
backend_type
testing
is_testing
not_found
courses_get
courses_fetch
courses_assignments_get
courses_assignments_fetch
courses_assignments_resolve_and_list
courses_assignments_scores_get
courses_assignments_scores_fetch
courses_assignments_scores_resolve_and_list
courses_assignments_scores_resolve_and_upload
courses_gradebook_get
courses_gradebook_list
courses_gradebook_resolve_and_list
courses_gradebook_resolve_and_upload
courses_gradebook_upload
courses_groupsets_resolve_and_create
courses_groupsets_resolve_and_delete
courses_groupsets_get
courses_groupsets_fetch
courses_groupsets_resolve_and_list
courses_groupsets_memberships_resolve_and_add
courses_groupsets_memberships_resolve_and_set
courses_groupsets_memberships_resolve_and_subtract
courses_groupsets_memberships_resolve_and_list
courses_groups_resolve_and_create
courses_groups_resolve_and_delete
courses_groups_get
courses_groups_fetch
courses_groups_resolve_and_list
courses_groups_memberships_resolve_and_add
courses_groups_memberships_resolve_and_list
courses_groups_memberships_resolve_and_set
courses_groups_memberships_resolve_and_subtract
courses_quizzes_get
courses_quizzes_fetch
courses_quizzes_resolve_and_list
courses_quizzes_groups_get
courses_quizzes_groups_fetch
courses_quizzes_groups_resolve_and_list
courses_quizzes_questions_get
courses_quizzes_questions_fetch
courses_quizzes_questions_resolve_and_list
courses_syllabus_get
courses_users_get
courses_users_fetch
courses_users_resolve_and_list
courses_users_scores_get
courses_users_scores_fetch
courses_users_scores_resolve_and_list
parse_assignment_query
parse_assignment_queries
parse_course_query
parse_course_queries
parse_groupset_query
parse_groupset_queries
parse_group_query
parse_group_queries
parse_quiz_query
parse_quiz_queries
parse_quiz_question_query
parse_quiz_question_queries
parse_quiz_question_group_query
parse_quiz_question_group_queries
parse_user_query
parse_user_queries
resolve_assignment_query
resolve_assignment_queries
resolve_course_query
resolve_course_queries
resolve_group_queries
resolve_group_query
resolve_groupset_queries
resolve_groupset_query
resolve_quiz_query
resolve_quiz_queries
resolve_user_queries