def create_user_login(self, user, login, **kwargs): """ Create a new login for an existing user in the given account :calls: `POST /api/v1/accounts/:account_id/logins \ <https://canvas.instructure.com/doc/api/logins.html#method.pseudonyms.create>`_ :param user: The attributes of the user to create a login for :type user: `dict` :param login: The attributes of the login to create :type login: `dict` :rtype: :class:`canvasapi.login.Login` """ from canvasapi.login import Login if isinstance(user, dict) and 'id' in user: kwargs['user'] = user else: raise RequiredFieldMissing(("user must be a dictionary with keys " "'id'.")) if isinstance(login, dict) and 'unique_id' in login: kwargs['login'] = login else: raise RequiredFieldMissing(("login must be a dictionary with keys " "'unique_id'.")) response = self._requester.request('POST', 'accounts/{}/logins'.format( self.id), _kwargs=combine_kwargs(**kwargs)) return Login(self._requester, response.json())
def create_appointment_group(self, appointment_group, **kwargs): """ Create a new Appointment Group. :calls: `POST /api/v1/appointment_groups \ <https://canvas.instructure.com/doc/api/appointment_groups.html#method.appointment_groups.create>`_ :param appointment_group: The attributes of the appointment group. :type appointment_group: `dict` :param title: The title of the appointment group. :type title: `str` :rtype: :class:`canvasapi.appointment_group.AppointmentGroup` """ from canvasapi.appointment_group import AppointmentGroup if (isinstance(appointment_group, dict) and 'context_codes' in appointment_group and 'title' in appointment_group): kwargs['appointment_group'] = appointment_group elif (isinstance(appointment_group, dict) and 'context_codes' not in appointment_group): raise RequiredFieldMissing( "Dictionary with key 'context_codes' is missing.") elif isinstance(appointment_group, dict) and 'title' not in appointment_group: raise RequiredFieldMissing( "Dictionary with key 'title' is missing.") response = self.__requester.request('POST', 'appointment_groups', **combine_kwargs(**kwargs)) return AppointmentGroup(self.__requester, response.json())
def create_module_item(self, module_item, **kwargs): """ Create a module item. :calls: `POST /api/v1/courses/:course_id/modules/:module_id/items \ <https://canvas.instructure.com/doc/api/modules.html#method.context_module_items_api.create>`_ :param module_item: The attributes to create the module item with. :type module_item: dict :returns: The created module item. :rtype: :class:`canvasapi.module.ModuleItem` """ if isinstance(module_item, dict) and 'type' in module_item: if 'content_id' in module_item: kwargs['module_item'] = module_item else: raise RequiredFieldMissing( "Dictionary with key 'content_id' is required.") else: raise RequiredFieldMissing( "Dictionary with key 'type' is required.") response = self._requester.request( 'POST', 'courses/%s/modules/%s/items' % (self.course_id, self.id), **combine_kwargs(**kwargs)) module_item_json = response.json() module_item_json.update({'course_id': self.course_id}) return ModuleItem(self._requester, module_item_json)
def create_module_item(self, module_item, **kwargs): """ Create a module item. :calls: `POST /api/v1/courses/:course_id/modules/:module_id/items \ <https://canvas.instructure.com/doc/api/modules.html#method.context_module_items_api.create>`_ :param module_item: The attributes to create the module item with. :type module_item: dict :returns: The created module item. :rtype: :class:`canvasapi.module.ModuleItem` """ unrequired_types = ["ExternalUrl", "Page", "SubHeader"] if isinstance(module_item, dict) and "type" in module_item: # content_id is not required for unrequired_types if module_item["type"] in unrequired_types or "content_id" in module_item: kwargs["module_item"] = module_item else: raise RequiredFieldMissing( "Dictionary with key 'content_id' is required." ) else: raise RequiredFieldMissing("Dictionary with key 'type' is required.") response = self._requester.request( "POST", "courses/{}/modules/{}/items".format(self.course_id, self.id), _kwargs=combine_kwargs(**kwargs), ) module_item_json = response.json() module_item_json.update({"course_id": self.course_id}) return ModuleItem(self._requester, module_item_json)
def update(self, grading_period, **kwargs): """ Update a grading period for a course. :calls: `PUT /api/v1/courses/:course_id/grading_periods/:id \ <https://canvas.instructure.com/doc/api/grading_periods.html#method.grading_periods.update>`_ :param grading_period: List of nested paramameters. :type grading_period: list[dict] :rtype: :class:`canvasapi.grading_period.GradingPeriod` """ if isinstance(grading_period, list): kwargs["grading_periods"] = grading_period else: raise RequiredFieldMissing("List is required") if "start_date" not in kwargs["grading_periods"][0]: raise RequiredFieldMissing("start_date is missing") if "end_date" not in kwargs["grading_periods"][0]: raise RequiredFieldMissing("end_date is missing") response = self._requester.request( "PUT", "courses/{}/grading_periods/{}".format(self.course_id, self.id), _kwargs=combine_kwargs(**kwargs), ) response_json = response.json() grading_period = response_json["grading_periods"][0] grading_period.update({"course_id": self.course_id}) return GradingPeriod(self._requester, grading_period)
def create_planner_override(self, plannable_type, plannable_id, **kwargs): """ Create a planner override for the current user :calls: `POST /api/v1/planner/overrides \ <https://canvas.instructure.com/doc/api/planner.html#method.planner_overrides.create>`_ :param plannable_type: Type of the item that you are overriding in the planner :type plannable_type: str :param plannable_id: ID of the item that you are overriding in the planner :type plannable_id: int or :class:`canvasapi.planner.PlannerOverride` :rtype: :class:`canvasapi.planner.PlannerOverride` """ from canvasapi.planner import PlannerOverride from six import text_type, integer_types if isinstance(plannable_type, text_type): kwargs['plannable_type'] = plannable_type else: raise RequiredFieldMissing("plannable_type is required as a str.") if isinstance(plannable_id, integer_types): kwargs['plannable_id'] = plannable_id else: raise RequiredFieldMissing("plannable_id is required as an int.") response = self.__requester.request('POST', 'planner/overrides', _kwargs=combine_kwargs(**kwargs)) return PlannerOverride(self.__requester, response.json())
def create_assignment(self, assignment, **kwargs): """ Create a new assignment for this course. Note: The assignment is created in the active state. :calls: `POST /api/v1/courses/:course_id/assignments \ <https://canvas.instructure.com/doc/api/assignments.html#method.assignments_api.create>`_ :param assignment: The attributes of the assignment :type assignment: dict :rtype: :class:`canvasapi.assignment.Assignment` """ from canvasapi.assignment import Assignment if isinstance(assignment, dict) and 'name' in assignment: kwargs['assignment'] = assignment else: raise RequiredFieldMissing( "Dictionary with key 'name' is required.") response = self._requester.request( 'POST', 'courses/%s/assignments' % (self.id), **combine_kwargs(**kwargs)) return Assignment(self._requester, response.json())
def submit_assignment(self, assignment, submission, **kwargs): """ Makes a submission for an assignment. :calls: `POST /api/v1/sections/:section_id/assignments/:assignment_id/submissions \ <https://canvas.instructure.com/doc/api/submissions.html#method.submissions.create>`_ :param assignment: The object or ID of the assignment. :type assignment: :class:`canvasapi.assignment.Assignment` or int :param submission: The attributes of the submission. :type submission: dict :rtype: :class:`canvasapi.submission.Submission` """ from canvasapi.assignment import Assignment assignment_id = obj_or_id(assignment, "assignment", (Assignment, )) if isinstance(submission, dict) and 'submission_type' in submission: kwargs['submision'] = submission else: raise RequiredFieldMissing( "Dictionary with key 'submission_type' is required.") response = self._requester.request( 'POST', 'sections/{}/assignments/{}/submissions'.format( self.id, assignment_id), _kwargs=combine_kwargs(**kwargs)) response_json = response.json() response_json.update(section_id=self.id) return Submission(self._requester, response_json)
def create_page(self, wiki_page, **kwargs): """ Create a new wiki page. :calls: `POST /api/v1/groups/:group_id/pages \ <https://canvas.instructure.com/doc/api/pages.html#method.wiki_pages_api.create>`_ :param wiki_page: Details about the page to create. :type wiki_page: dict :returns: The created page. :rtype: :class:`canvasapi.page.Page` """ from canvasapi.course import Page if isinstance(wiki_page, dict) and 'title' in wiki_page: kwargs['wiki_page'] = wiki_page else: raise RequiredFieldMissing("Dictionary with key 'title' is required.") response = self._requester.request( 'POST', 'groups/{}/pages'.format(self.id), _kwargs=combine_kwargs(**kwargs) ) page_json = response.json() page_json.update({'group_id': self.id}) return Page(self._requester, page_json)
def broadcast_message(self, conversations, **kwargs): """ Send a message to unsubmitted or submitted users for the quiz. :calls: `POST /api/v1/courses/:course_id/quizzes/:id/submission_users/message \ <https://canvas.instructure.com/doc/api/quiz_submission_user_list.html#method.quizzes/quiz_submission_users.message>`_ :param conversations: A dictionary representing a Conversation. Requires `'body'`, `'recipients'`, and `'subject'` keys. :type conversations: dict :returns: True if the message was created, False otherwize :rtype: bool """ required_key_list = ["body", "recipients", "subject"] required_keys_present = all( (x in conversations for x in required_key_list)) if isinstance(conversations, dict) and required_keys_present: kwargs["conversations"] = conversations else: raise RequiredFieldMissing( ("conversations must be a dictionary with keys " "'body', 'recipients', and 'subject'.")) response = self._requester.request( "POST", "courses/{}/quizzes/{}/submission_users/message".format( self.course_id, self.id), _kwargs=combine_kwargs(**kwargs), ) return response.status_code == 201
def create_page(self, wiki_page, **kwargs): """ Create a new wiki page. :calls: `POST /api/v1/courses/:course_id/pages \ <https://canvas.instructure.com/doc/api/pages.html#method.wiki_pages_api.create>`_ :param title: The title for the page. :type title: dict :returns: The created page. :rtype: :class:`canvasapi.course.Course` """ if isinstance(wiki_page, dict) and 'title' in wiki_page: kwargs['wiki_page'] = wiki_page else: raise RequiredFieldMissing( "Dictionary with key 'title' is required.") response = self._requester.request('POST', 'courses/%s/pages' % (self.id), **combine_kwargs(**kwargs)) page_json = response.json() page_json.update({'course_id': self.id}) return Page(self._requester, page_json)
def create_choice(self, poll_choice, **kwargs): """ Create a new choice for the current poll. :calls: `POST /api/v1/polls/:poll_id/poll_choices \ <https://canvas.instructure.com/doc/api/poll_choices.html#method.polling/poll_choices.create>`_ :param poll_choice: 'text' is required, 'is_correct' and 'position' are optional. :type poll_choice: list :rtype: :class:`canvasapi.poll_choice.PollChoice` """ if ( isinstance(poll_choice, list) and isinstance(poll_choice[0], dict) and 'text' in poll_choice[0] ): kwargs['poll_choice'] = poll_choice else: raise RequiredFieldMissing( "Dictionary with key 'text' is required." ) response = self._requester.request( 'POST', 'polls/{}/poll_choices'.format(self.id), _kwargs=combine_kwargs(**kwargs) ) return PollChoice(self._requester, response.json()['poll_choices'][0])
def create_session(self, poll_session, **kwargs): """ Create a new poll session for this poll :calls: `POST /api/v1/polls/:poll_id/poll_sessions \ <https://canvas.instructure.com/doc/api/poll_sessions.html#method.polling/poll_sessions.create>`_ :param poll_session: List of arguments. course_id (required): id of the course for the session, course_section_id (optional): id of the course section for this session, has_public_results (optional): whether the results are viewable by students. :type poll_session: list :rtype: :class:`canvasapi.poll_session.PollSession` """ if ( isinstance(poll_session, list) and isinstance(poll_session[0], dict) and 'course_id' in poll_session[0] ): kwargs['poll_session'] = poll_session else: raise RequiredFieldMissing( "Dictionary with key 'course_id' is required." ) response = self._requester.request( 'POST', 'polls/{}/poll_sessions'.format(self.id), _kwargs=combine_kwargs(**kwargs) ) return PollSession(self._requester, response.json()['poll_sessions'][0])
def __update_wiki_page_body(self, wiki_page, **kwargs): # def create_page(self, wiki_page, **kwargs): """ update a wiki page. :calls: `POST /api/v1/courses/:course_id/pages \ <https://canvas.instructure.com/doc/api/pages.html#method.wiki_pages_api.update>`_ :param wiki_page: The title for the page. :type wiki_page: object, not dict :returns: The created page. :rtype: :class:`canvasapi.page.Page` """ print(wiki_page.title) # if isinstance(wiki_page, dict) and "title" in wiki_page: if isinstance(wiki_page, Page) and hasattr(wiki_page, 'title'): wiki_page_dict = vars(wiki_page) wiki_page_dict["body"] = "<h1>new wiki body</h1>" kwargs["wiki_page"] = wiki_page_dict print(kwargs) else: #raise RequiredFieldMissing("Dictionary with key 'title' is required.") raise RequiredFieldMissing( "Object of type Page with attribute 'title' is required.") response = self._requester.request("POST", "courses/{}/pages".format( self.COURSE_ID), _kwargs=combine_kwargs(**kwargs)) page_json = response.json() page_json.update({"course_id": self.COURSE_ID}) return Page(self._requester, page_json)
def edit(self, appointment_group, **kwargs): """ Modify this appointment group. :calls: `PUT /api/v1/appointment_groups/:id \ <https://canvas.instructure.com/doc/api/appointment_groups.html#method.appointment_groups.update>`_ :param appointment_group: Dict containing an array of context codes :type appointment_group: dict :rtype: :class:`canvasapi.appointment_group.AppointmentGroup` """ if isinstance(appointment_group, dict) and 'context_codes' in appointment_group: kwargs['appointment_group'] = appointment_group else: raise RequiredFieldMissing( "Dictionary with key 'context_codes' is required.") response = self._requester.request('PUT', 'appointment_groups/{}'.format( self.id), _kwargs=combine_kwargs(**kwargs)) if 'title' in response.json(): super(AppointmentGroup, self).set_attributes(response.json()) return AppointmentGroup(self._requester, response.json())
def submit_assignment(self, assignment_id, submission, **kwargs): """ Makes a submission for an assignment. :calls: `POST /api/v1/courses/:course_id/assignments/:assignment_id/submissions \ <https://canvas.instructure.com/doc/api/submissions.html#method.submissions.create>`_ :param submission: The attributes of the submission. :type submission: `dict` :rtype: :class:`canvasapi.submission.Submission` """ if isinstance(submission, dict) and 'submission_type' in submission: kwargs['submision'] = submission else: raise RequiredFieldMissing( "Dictionary with key 'submission_type' is required." ) response = self._requester.request( 'POST', 'courses/%s/assignments/%s/submissions' % (self.id, assignment_id), **combine_kwargs(**kwargs) ) return Submission(self._requester, response.json())
def create_quiz(self, quiz, **kwargs): """ Create a new quiz in this course. :calls: `POST /api/v1/courses/:course_id/quizzes \ <https://canvas.instructure.com/doc/api/quizzes.html#method.quizzes/quizzes_api.create>`_ :param quiz: The attributes for the quiz. :type quiz: dict :rtype: :class:`canvasapi.quiz.Quiz` """ from canvasapi.quiz import Quiz if isinstance(quiz, dict) and 'title' in quiz: kwargs['quiz'] = quiz else: raise RequiredFieldMissing( "Dictionary with key 'title' is required.") response = self._requester.request('POST', 'courses/%s/quizzes' % (self.id), **combine_kwargs(**kwargs)) quiz_json = response.json() quiz_json.update({'course_id': self.id}) return Quiz(self._requester, quiz_json)
def create_module(self, module, **kwargs): """ Create a new module. :calls: `POST /api/v1/courses/:course_id/modules \ <https://canvas.instructure.com/doc/api/modules.html#method.context_modules_api.create>`_ :param module: The attributes for the module. :type module: dict :returns: The created module. :rtype: :class:`canvasapi.module.Module` """ from canvasapi.module import Module if isinstance(module, dict) and 'name' in module: kwargs['module'] = module else: raise RequiredFieldMissing( "Dictionary with key 'name' is required.") response = self._requester.request('POST', 'courses/%s/modules' % (self.id), **combine_kwargs(**kwargs)) module_json = response.json() module_json.update({'course_id': self.id}) return Module(self._requester, module_json)
def create_notification(self, account_notification, **kwargs): """ Create and return a new global notification for an account. :calls: `POST /api/v1/accounts/:account_id/account_notifications \ <https://canvas.instructure.com/doc/api/account_notifications.html#method.account_notifications.create>`_ :param account_notification: The notification to create. :type account_notification: dict :rtype: :class:`canvasapi.account.AccountNotification` """ required_key_list = ['subject', 'message', 'start_at', 'end_at'] required_keys_present = all( (x in account_notification for x in required_key_list)) if isinstance(account_notification, dict) and required_keys_present: kwargs['account_notification'] = account_notification else: raise RequiredFieldMissing( ("account_notification must be a dictionary with keys " "'subject', 'message', 'start_at', and 'end_at'.")) response = self._requester.request( 'POST', 'accounts/{}/account_notifications'.format(self.id), _kwargs=combine_kwargs(**kwargs)) return AccountNotification(self._requester, response.json())
def get_planner_override(self, planner_override, **kwargs): """ Retrieve a planner override for the current user :calls: `GET /api/v1/planner/overrides/:id \ <https://canvas.instructure.com/doc/api/planner.html#method.planner_overrides.show>`_ :param planner_override: The override or the ID of the planner override to retrieve. :type planner_override: int or :class:`canvasapi.planner.PlannerOverride` :rtype: :class:`canvasapi.planner.PlannerOverride` """ from canvasapi.planner import PlannerOverride if isinstance(planner_override, int) or isinstance( planner_override, PlannerOverride): planner_override_id = obj_or_id(planner_override, "planner_override", (PlannerOverride, )) else: raise RequiredFieldMissing( "planner_override is required as an object or as an int.") response = self.__requester.request( 'GET', 'planner/overrides/{}'.format(planner_override_id), _kwargs=combine_kwargs(**kwargs)) return PlannerOverride(self.__requester, response.json())
def create_poll(self, poll, **kwargs): """ Create a new poll for the current user. :calls: `POST /api/v1/polls \ <https://canvas.instructure.com/doc/api/polls.html#method.polling/polls.create>`_ :param poll: List of polls to create. `'question'` key is required. :type poll: list of dict :rtype: :class:`canvasapi.poll.Poll` """ from canvasapi.poll import Poll if ( isinstance(poll, list) and isinstance(poll[0], dict) and "question" in poll[0] ): kwargs["poll"] = poll else: raise RequiredFieldMissing( "Dictionary with key 'question' and is required." ) response = self.__requester.request( "POST", "polls", _kwargs=combine_kwargs(**kwargs) ) return Poll(self.__requester, response.json()["polls"][0])
def create_calendar_event(self, calendar_event, **kwargs): """ Create a new Calendar Event. :calls: `POST /api/v1/calendar_events \ <https://canvas.instructure.com/doc/api/calendar_events.html#method.calendar_events_api.create>`_ :param calendar_event: The attributes of the calendar event. :type calendar_event: `dict` :rtype: :class:`canvasapi.calendar_event.CalendarEvent` """ from canvasapi.calendar_event import CalendarEvent if isinstance(calendar_event, dict) and 'context_code' in calendar_event: kwargs['calendar_event'] = calendar_event else: raise RequiredFieldMissing( "Dictionary with key 'context_codes' is required.") response = self.__requester.request('POST', 'calendar_events', _kwargs=combine_kwargs(**kwargs)) return CalendarEvent(self.__requester, response.json())
def submit_events(self, quiz_submission_events, **kwargs): """ Store a set of events which were captured during a quiz taking session. :calls: `POST /api/v1/courses/:course_id/quizzes/:quiz_id/submissions/:id/events \ <https://canvas.instructure.com/doc/api/quiz_submission_events.html#method.quizzes/quiz_submission_events_api.create>`_ :param quiz_submission_events: The submission events to be recorded. :type quiz_submission_events: list :returns: True if the submission was successful, false otherwise. :rtype: bool """ if isinstance(quiz_submission_events, list) and isinstance( quiz_submission_events[0], QuizSubmissionEvent): kwargs["quiz_submission_events"] = quiz_submission_events else: raise RequiredFieldMissing( "Required parameter quiz_submission_events missing.") response = self._requester.request( "POST", "courses/{}/quizzes/{}/submissions/{}/events".format( self.course_id, self.quiz_id, self.id), _kwargs=combine_kwargs(**kwargs), ) return response.status_code == 204
def create_submission(self, poll_submissions, **kwargs): """ Create a new poll submission for this poll session. :calls: `POST /api/v1/polls/:poll_id/poll_sessions/:poll_session_id/poll_submissions \ <https://canvas.instructure.com/doc/api/poll_submissions.html#method.polling/poll_submissions.create>`_ :param poll_submissions: List of arguments. poll_choice_id (required int): Chosen poll \ choice for this submission. :type poll_submissions: list :rtype: :class:`canvasapi.poll_submission.PollSubmission` """ if (isinstance(poll_submissions, list) and isinstance(poll_submissions[0], dict) and "poll_choice_id" in poll_submissions[0]): kwargs["poll_submissions"] = poll_submissions else: raise RequiredFieldMissing( "Dictionary with key 'poll_choice_id is required.") response = self._requester.request( "POST", "polls/{}/poll_sessions/{}/poll_submissions".format( self.poll_id, self.id), _kwargs=combine_kwargs(**kwargs), ) return PollSubmission(self._requester, response.json()["poll_submissions"][0])
def update(self, poll_session, **kwargs): """ Update an existing poll session for a poll based on poll id. :calls: `PUT /api/v1/polls/:poll_id/poll_sessions/:id \ <https://canvas.instructure.com/doc/api/poll_sessions.html#method.polling/poll_sessions.update>`_ :param poll_session: List of arguments. course_id (required): id of the course for the session, course_section_id (optional): id of the course section for this session, has_public_results (optional): whether the results are viewable by students. :type poll_session: list :rtype: :class:`canvasapi.poll_session.PollSession` """ if (isinstance(poll_session, list) and isinstance(poll_session[0], dict) and "course_id" in poll_session[0]): kwargs["poll_session"] = poll_session else: raise RequiredFieldMissing( "Dictionary with key 'course_id' is required.") response = self._requester.request( "PUT", "polls/{}/poll_sessions/{}".format(self.poll_id, self.id), _kwargs=combine_kwargs(**kwargs), ) return PollSession(self._requester, response.json()["poll_sessions"][0])
def update(self, poll_choice, **kwargs): """ Update an existing choice for this poll. :calls: `PUT /api/v1/polls/:poll_id/poll_choices/:id \ <https://canvas.instructure.com/doc/api/poll_choices.html#method.polling/poll_choices.update>`_ :param poll_choice: List of arguments. 'text' is required and 'is_correct' and 'position' \ are optional. :type poll_choice: list :rtype: :class:`canvasapi.poll_choice.PollChoice` """ if (isinstance(poll_choice, list) and isinstance(poll_choice[0], dict) and "text" in poll_choice[0]): kwargs["poll_choice"] = poll_choice else: raise RequiredFieldMissing( "Dictionary with key 'text' is required.") response = self._requester.request( "PUT", "polls/{}/poll_choices/{}".format(self.poll_id, self.id), _kwargs=combine_kwargs(**kwargs), ) return PollChoice(self._requester, response.json()["poll_choices"][0])
def set_extensions(self, quiz_extensions, **kwargs): """ Set extensions for student quiz submissions. :calls: `POST /api/v1/courses/:course_id/quizzes/:quiz_id/extensions <https://canvas.instructure.com/doc/api/quiz_extensions.html#method.quizzes/quiz_extensions.create>`_ :param quiz_extensions: List of dictionaries representing extensions. :type quiz_extensions: list :rtype: list of :class:`canvasapi.quiz.QuizExtension` Example Usage: >>> quiz.set_extensions([ ... { ... 'user_id': 1, ... 'extra_time': 60, ... 'extra_attempts': 1 ... }, ... { ... 'user_id': 2, ... 'extra_attempts': 3 ... }, ... { ... 'user_id': 3, ... 'extra_time': 20 ... } ... ]) """ if not isinstance(quiz_extensions, list) or not quiz_extensions: raise ValueError( "Param `quiz_extensions` must be a non-empty list.") if any(not isinstance(extension, dict) for extension in quiz_extensions): raise ValueError( "Param `quiz_extensions` must only contain dictionaries") if any("user_id" not in extension for extension in quiz_extensions): raise RequiredFieldMissing( "Dictionaries in `quiz_extensions` must contain key `user_id`") kwargs["quiz_extensions"] = quiz_extensions response = self._requester.request( "POST", "courses/{}/quizzes/{}/extensions".format(self.course_id, self.id), _kwargs=combine_kwargs(**kwargs), ) extension_list = response.json()["quiz_extensions"] return [ QuizExtension(self._requester, extension) for extension in extension_list ]
def set_extensions(self, assignment_extensions, **kwargs): """ Set extensions for student assignment submissions :calls: `POST /api/v1/courses/:course_id/assignments/:assignment_id/extensions \ <https://canvas.instructure.com/doc/api/assignment_extensions.html#method.assignment_extensions.create>`_ :param assignment_extensions: list of dictionaries representing extensions :type assignment_extensions: list :rtype: list of :class:`canvasapi.assignment.AssignmentExtension` Example Usage: >>> assignment.set_extensions([ ... { ... 'user_id': 3, ... 'extra_attempts: 2 ... }, ... { ... 'user_id': 2, ... 'extra_attempts: 2 ... } ... ]) """ if not isinstance(assignment_extensions, list) or not assignment_extensions: raise ValueError( "Param `assignment_extensions` must be a non-empty list.") if any(not isinstance(extension, dict) for extension in assignment_extensions): raise ValueError( "Param `assignment_extensions` must only contain dictionaries") if any("user_id" not in extension for extension in assignment_extensions): raise RequiredFieldMissing( "Dictionaries in `assignment_extensions` must contain key `user_id`" ) kwargs["assignment_extensions"] = assignment_extensions response = self._requester.request( "POST", "courses/{}/assignments/{}/extensions".format( self.course_id, self.id), _kwargs=combine_kwargs(**kwargs), ) extension_list = response.json()["assignment_extensions"] return [ AssignmentExtension(self._requester, extension) for extension in extension_list ]
def create_question_group(self, quiz_groups, **kwargs): """ Create a new question group for the given quiz id :calls: `POST /api/v1/courses/:course_id/quizzes/:quiz_id/groups \ <https://canvas.instructure.com/doc/api/quiz_question_groups.html#method.quizzes/quiz_groups.create>`_ :param quiz_groups: The name, pick count, question points, and/or assessment question bank id. All of these parameters are optional, but at least one must exist (even if empty) to receive a response. The request expects a list, but will only create 1 question group per request. :type quiz_groups: list[dict] :returns: `QuizGroup` object :rtype: :class:`canvasapi.quiz_group.QuizGroup` """ if not isinstance(quiz_groups, list) or not quiz_groups: raise ValueError("Param `quiz_groups` must be a non-empty list.") if not isinstance(quiz_groups[0], dict): raise ValueError("Param `quiz_groups must contain a dictionary") param_list = [ "name", "pick_count", "question_points", "assessment_question_bank_id", ] if not any(param in quiz_groups[0] for param in param_list): raise RequiredFieldMissing( "quiz_groups must contain at least 1 parameter.") kwargs["quiz_groups"] = quiz_groups response = self._requester.request( "POST", "courses/{}/quizzes/{}/groups".format(self.course_id, self.id), _kwargs=combine_kwargs(**kwargs), ) response_json = response.json() response_json["quiz_groups"][0].update({"course_id": self.id}) return QuizGroup(self._requester, response_json.get("quiz_groups")[0])
def update(self, id, quiz_groups, **kwargs): """ Update a question group given by id. :calls: `PUT /api/v1/courses/:course_id/quizzes/:quiz_id/groups/:id \ <https://canvas.instructure.com/doc/api/quiz_question_groups.html#method.quizzes/quiz_groups.update>`_ :param id: The ID of the question group. :type id: int :param quiz_groups: The name, pick count, and/or question points. All of these parameters are optional, but at least one must exist (even if empty) to recieve a response. The request expects a list, but will only update 1 question group per request. :type quiz_groups: list[dict] :returns: `True` if the QuizGroup was updated. `False` otherwise. :rtype: bool """ if not isinstance(quiz_groups, list) or len(quiz_groups) <= 0: raise ValueError("Param `quiz_groups` must be a non-empty list.") if not isinstance(quiz_groups[0], dict): raise ValueError("Param `quiz_groups` must contain a dictionary") param_list = ["name", "pick_count", "question_points"] if not any(param in quiz_groups[0] for param in param_list): raise RequiredFieldMissing( "quiz_groups must contain at least 1 parameter.") kwargs["quiz_groups"] = quiz_groups response = self._requester.request( "PUT", "courses/{}/quizzes/{}/groups/{}".format(self.course_id, self.quiz_id, id), _kwargs=combine_kwargs(**kwargs), ) successful = "name" in response.json().get("quiz_groups")[0] if successful: super(QuizGroup, self).set_attributes(response.json().get("quiz_groups")[0]) return successful