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
