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

The token to authenticate with.

def get_standard_headers(self) -> Dict[str, str]: 
49    def get_standard_headers(self) -> typing.Dict[str, str]:
50        headers = super().get_standard_headers()
51
52        headers['Authorization'] = f"Bearer {self.auth_token}"
53
54        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]: 
56    def courses_list(self,
57            **kwargs: typing.Any) -> typing.List[lms.model.courses.Course]:
58        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]: 
60    def courses_assignments_list(self,
61            course_id: str,
62            **kwargs: typing.Any) -> typing.List[lms.model.assignments.Assignment]:
63        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
64        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]: 
66    def courses_assignments_scores_list(self,
67            course_id: str,
68            assignment_id: str,
69            **kwargs: typing.Any) -> typing.List[lms.model.scores.AssignmentScore]:
70        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
71        parsed_assignment_id = lms.util.parse.required_int(assignment_id, 'assignment_id')
72        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: 
74    def courses_assignments_scores_upload(self,
75            course_id: str,
76            assignment_id: str,
77            scores: typing.Dict[str, lms.model.scores.ScoreFragment],
78            **kwargs: typing.Any) -> int:
79        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
80        parsed_assignment_id = lms.util.parse.required_int(assignment_id, 'assignment_id')
81        parsed_scores = {lms.util.parse.required_int(user_id, 'user_id'): score for (user_id, score) in scores.items()}
82        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: 
84    def courses_gradebook_fetch(self,
85            course_id: str,
86            assignment_ids: typing.Collection[str],
87            user_ids: typing.Collection[str],
88            **kwargs: typing.Any) -> lms.model.scores.Gradebook:
89        if ((len(assignment_ids) == 0) or (len(user_ids) == 0)):
90            assignment_queries = [lms.model.assignments.AssignmentQuery(id = id) for id in assignment_ids]
91            user_queries = [lms.model.users.UserQuery(id = id) for id in user_ids]
92            return lms.model.scores.Gradebook(assignment_queries, user_queries)
93
94        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
95        parsed_assignment_ids = [lms.util.parse.required_int(assignment_id, 'assignment_id') for assignment_id in assignment_ids]
96        parsed_user_ids = [lms.util.parse.required_int(user_id, 'user_id') for user_id in user_ids]
97
98        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: 
100    def courses_groupsets_create(self,
101            course_id: str,
102            name: str,
103            **kwargs: typing.Any) -> lms.model.groupsets.GroupSet:
104        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
105        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: 
107    def courses_groupsets_delete(self,
108            course_id: str,
109            groupset_id: str,
110            **kwargs: typing.Any) -> bool:
111        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
112        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
113        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]: 
115    def courses_groupsets_list(self,
116            course_id: str,
117            **kwargs: typing.Any) -> typing.List[lms.model.groupsets.GroupSet]:
118        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
119        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]: 
121    def courses_groupsets_memberships_list(self,
122            course_id: str,
123            groupset_id: str,
124            **kwargs: typing.Any) -> typing.List[lms.model.groupsets.GroupSetMembership]:
125        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
126        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
127        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: 
129    def courses_groups_create(self,
130            course_id: str,
131            groupset_id: str,
132            name: str,
133            **kwargs: typing.Any) -> lms.model.groups.Group:
134        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
135        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
136        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: 
138    def courses_groups_delete(self,
139            course_id: str,
140            groupset_id: str,
141            group_id: str,
142            **kwargs: typing.Any) -> bool:
143        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
144        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
145        parsed_group_id = lms.util.parse.required_int(group_id, 'group_id')
146        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]: 
148    def courses_groups_list(self,
149            course_id: str,
150            groupset_id: str,
151            **kwargs: typing.Any) -> typing.List[lms.model.groups.Group]:
152        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
153        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
154        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: 
156    def courses_groups_memberships_add(self,
157            course_id: str,
158            groupset_id: str,
159            group_id: str,
160            user_ids: typing.Collection[str],
161            **kwargs: typing.Any) -> int:
162        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
163        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
164        parsed_group_id = lms.util.parse.required_int(group_id, 'group_id')
165        parsed_user_ids = [lms.util.parse.required_int(user_id, 'user_id') for user_id in user_ids]
166        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]: 
168    def courses_groups_memberships_list(self,
169            course_id: str,
170            groupset_id: str,
171            group_id: str,
172            **kwargs: typing.Any) -> typing.List[lms.model.groupsets.GroupSetMembership]:
173        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
174        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
175        parsed_group_id = lms.util.parse.required_int(group_id, 'group_id')
176        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: 
178    def courses_groups_memberships_subtract(self,
179            course_id: str,
180            groupset_id: str,
181            group_id: str,
182            user_ids: typing.Collection[str],
183            **kwargs: typing.Any) -> int:
184        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
185        parsed_groupset_id = lms.util.parse.required_int(groupset_id, 'groupset_id')
186        parsed_group_id = lms.util.parse.required_int(group_id, 'group_id')
187        parsed_user_ids = [lms.util.parse.required_int(user_id, 'user_id') for user_id in user_ids]
188        return lms.backend.canvas.courses.groups.memberships.subtract.request(self,
189                parsed_course_id, parsed_groupset_id, parsed_group_id, parsed_user_ids)

Subtract the specified users from the group.

def courses_syllabus_fetch(self, course_id: str, **kwargs: Any) -> Optional[str]: 
191    def courses_syllabus_fetch(self,
192            course_id: str,
193            **kwargs: typing.Any) -> typing.Union[str, None]:
194        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
195        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]: 
197    def courses_users_list(self,
198            course_id: str,
199            **kwargs: typing.Any) -> typing.List[lms.model.users.CourseUser]:
200        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
201        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]: 
203    def courses_users_scores_list(self,
204            course_id: str,
205            user_id: str,
206            **kwargs: typing.Any) -> typing.List[lms.model.scores.AssignmentScore]:
207        parsed_course_id = lms.util.parse.required_int(course_id, 'course_id')
208        parsed_user_id = lms.util.parse.required_int(user_id, 'user_id')
209        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_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_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_user_queries