def test_get_merges_with_payload(self, call_mock, merge_mock):
"""
Test that the call to get method with a payload calls merge helper and passes
the payload as the value parameter.
"""
client.get(self.req_ctx, self.url, self.payload)
merge_mock.assert_called_once_with(mock.ANY, mock.ANY, self.payload)
def test_get_merges_with_request_kwargs(self, call_mock, merge_mock):
"""
Test that the call to get method calls merge helper with request_kwargs
dictionary as first positional parameter
"""
client.get(self.req_ctx, self.url, **self.request_kwargs)
merge_mock.assert_called_once_with(self.request_kwargs, mock.ANY, mock.ANY)
def test_get_with_request_kwargs_and_payload(self, call_mock, merge_mock):
"""
Test that the call to get method with a payload and request kwargs passes through
properly
"""
client.get(self.req_ctx, self.url, self.payload, **self.request_kwargs)
call_mock.assert_called_once_with(mock.ANY, mock.ANY, mock.ANY, **self.request_kwargs)
def test_get_merges_with_params_key(self, call_mock, merge_mock):
"""
Test that the call to get method calls merge helper with 'params' as
dictionary key (second positional parameter)
"""
client.get(self.req_ctx, self.url)
merge_mock.assert_called_once_with(mock.ANY, 'params', mock.ANY)
def test_get_merges_with_payload(self, call_mock, merge_mock):
"""
Test that the call to get method with a payload calls merge helper and
passes the payload as the value parameter.
"""
client.get(self.req_ctx, self.url, self.payload)
merge_mock.assert_called_once_with(mock.ANY, mock.ANY, self.payload)
def test_get_merges_with_params_key(self, call_mock, merge_mock):
"""
Test that the call to get method calls merge helper with 'params' as
dictionary key (second positional parameter)
"""
client.get(self.req_ctx, self.url)
merge_mock.assert_called_once_with(mock.ANY, "params", mock.ANY)
def test_get_makes_call_with_action_url_and_context(self, call_mock, merge_mock):
"""
Test that the call to get method sends expected action, url, and request
context.
"""
client.get(self.req_ctx, self.url)
call_mock.assert_called_once_with("GET", self.url, self.req_ctx)
def test_get_makes_call_with_action_url_and_context(
self, call_mock, merge_mock):
"""
Test that the call to get method sends expected action, url, and request
context.
"""
client.get(self.req_ctx, self.url)
call_mock.assert_called_once_with("GET", self.url, self.req_ctx)
def test_get_with_request_kwargs_and_payload(self, call_mock, merge_mock):
"""
Test that the call to get method with a payload and request kwargs passes
through properly.
"""
client.get(self.req_ctx, self.url, self.payload, **self.request_kwargs)
call_mock.assert_called_once_with(mock.ANY, mock.ANY, mock.ANY,
**self.request_kwargs)
def test_get_merges_with_request_kwargs(self, call_mock, merge_mock):
"""
Test that the call to get method calls merge helper with request_kwargs
dictionary as first positional parameter
"""
client.get(self.req_ctx, self.url, **self.request_kwargs)
merge_mock.assert_called_once_with(self.request_kwargs, mock.ANY,
mock.ANY)
def get_module_item_sequence(request_ctx, course_id, asset_type, asset_id, **request_kwargs):
"""
Given an asset in a course, find the ModuleItem it belongs to, and also the previous and next Module Items
in the course sequence.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:param asset_type: (required) The type of asset to find module sequence information for. Use the ModuleItem if it is known (e.g., the user navigated from a module item), since this will avoid ambiguity if the asset appears more than once in the module sequence.
:type asset_type: string
:param asset_id: (required) The id of the asset (or the url in the case of a Page)
:type asset_id: integer
:return: Get module item sequence
:rtype: requests.Response (with ModuleItemSequence data)
"""
asset_type_types = ('ModuleItem', 'File', 'Page', 'Discussion', 'Assignment', 'Quiz', 'ExternalTool')
utils.validate_attr_is_acceptable(asset_type, asset_type_types)
path = '/v1/courses/{course_id}/module_item_sequence'
payload = {
'asset_type' : asset_type,
'asset_id' : asset_id,
}
url = request_ctx.base_api_url + path.format(course_id=course_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_students(request_ctx, course_id, per_page=None, **request_kwargs):
"""
Returns the list of students enrolled in this course.
DEPRECATED: Please use the `CoursesController#users <https://github.com/instructure/canvas-lms/blob/master/app/controllers/courses_controller.rb>`_ endpoint
and pass "student" as the enrollment_type.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List students
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/courses/{course_id}/students'
payload = {
'per_page': per_page,
}
url = request_ctx.base_api_url + path.format(course_id=course_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_avatar_options(request_ctx, user_id, per_page=None, **request_kwargs):
"""
Retrieve the possible user avatar options that can be set with the user update endpoint. The response will be an array of avatar records. If the 'type' field is 'attachment', the record will include all the normal attachment json fields; otherwise it will include only the 'url' and 'display_name' fields. Additionally, all records will include a 'type' field and a 'token' field. The following explains each field in more detail
type:: ["gravatar"|"attachment"|"no_pic"] The type of avatar record, for categorization purposes.
url:: The url of the avatar
token:: A unique representation of the avatar record which can be used to set the avatar with the user update endpoint. Note: this is an internal representation and is subject to change without notice. It should be consumed with this api endpoint and used in the user update endpoint, and should not be constructed by the client.
display_name:: A textual description of the avatar record
id:: ['attachment' type only] the internal id of the attachment
content-type:: ['attachment' type only] the content-type of the attachment
filename:: ['attachment' type only] the filename of the attachment
size:: ['attachment' type only] the size of the attachment
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param user_id: (required) ID
:type user_id: string
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List avatar options
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/users/{user_id}/avatars'
payload = {
'per_page' : per_page,
}
url = request_ctx.base_api_url + path.format(user_id=user_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def show_module_item(request_ctx, course_id, module_id, id, include, student_id=None, **request_kwargs):
"""
Get information about a single module item
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:param module_id: (required) ID
:type module_id: string
:param id: (required) ID
:type id: string
:param include: (required) If included, will return additional details specific to the content associated with this item. Refer to the {api:Modules:Module%20Item Module Item specification} for more details. Includes standard lock information for each item.
:type include: string
:param student_id: (optional) Returns module completion information for the student with this id.
:type student_id: string or None
:return: Show module item
:rtype: requests.Response (with ModuleItem data)
"""
include_types = ('content_details')
utils.validate_attr_is_acceptable(include, include_types)
path = '/v1/courses/{course_id}/modules/{module_id}/items/{id}'
payload = {
'include' : include,
'student_id' : student_id,
}
url = request_ctx.base_api_url + path.format(course_id=course_id, module_id=module_id, id=id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_user_communication_channels(request_ctx, user_id, per_page=None, **request_kwargs):
"""
Returns a list of communication channels for the specified user, sorted by
position.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param user_id: (required) ID
:type user_id: string
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List user communication channels
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/users/{user_id}/communication_channels'
payload = {
'per_page' : per_page,
}
url = request_ctx.base_api_url + path.format(user_id=user_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def lists_submissions(request_ctx, course_id, date, grader_id, assignment_id, per_page=None, **request_kwargs):
"""
Gives a nested list of submission versions
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) The id of the contextual course for this API call
:type course_id: integer
:param date: (required) The date for which you would like to see submissions
:type date: string
:param grader_id: (required) The ID of the grader for which you want to see submissions
:type grader_id: integer
:param assignment_id: (required) The ID of the assignment for which you want to see submissions
:type assignment_id: integer
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: Lists submissions
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/courses/{course_id}/gradebook_history/{date}/graders/{grader_id}/assignments/{assignment_id}/submissions'
payload = {
'per_page' : per_page,
}
url = request_ctx.base_api_url + path.format(course_id=course_id, date=date, grader_id=grader_id, assignment_id=assignment_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_external_tools_accounts(request_ctx, account_id, search_term=None, selectable=None, per_page=None, **request_kwargs):
"""
Returns the paginated list of external tools for the current context.
See the get request docs for a single tool for a list of properties on an external tool.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param account_id: (required) ID
:type account_id: string
:param search_term: (optional) The partial name of the tools to match and return.
:type search_term: string or None
:param selectable: (optional) If true, then only tools that are meant to be selectable are returned
:type selectable: boolean or None
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List external tools
:rtype: requests.Response (with void data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/accounts/{account_id}/external_tools'
payload = {
'search_term' : search_term,
'selectable' : selectable,
'per_page' : per_page,
}
url = request_ctx.base_api_url + path.format(account_id=account_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def load_custom_data(request_ctx, user_id, scope, ns, **request_kwargs):
"""
Load custom user data.
Arbitrary JSON data can be stored for a User. This API call
retrieves that data for a (optional) given scope.
See `UsersController#set_custom_data <https://github.com/instructure/canvas-lms/blob/master/app/controllers/users_controller.rb>`_ for details and
examples.
On success, this endpoint returns an object containing the data that was requested.
Responds with status code 400 if the namespace parameter, +ns+, is missing or invalid,
or if the specified scope does not contain any data.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param user_id: (required) ID
:type user_id: string
:param scope: (required) ID
:type scope: string
:param ns: (required) The namespace from which to retrieve the data. This should be something other Canvas API apps aren't likely to use, such as a reverse DNS for your organization.
:type ns: string
:return: Load custom data
:rtype: requests.Response (with void data)
"""
path = '/v1/users/{user_id}/custom_data/{scope}'
payload = {
'ns' : ns,
}
url = request_ctx.base_api_url + path.format(user_id=user_id, scope=scope)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_folders(request_ctx, id, per_page=None, **request_kwargs):
"""
Returns the paginated list of folders in the folder.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param id: (required) ID
:type id: string
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List folders
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/folders/{id}/folders'
payload = {
'per_page': per_page,
}
url = request_ctx.base_api_url + path.format(id=id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def get_single_quiz_submission_question(request_ctx, quiz_submission_id, id, include, **request_kwargs):
"""
Get a single question record.
<b>200 OK</b> response code is returned if the request was successful.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param quiz_submission_id: (required) ID
:type quiz_submission_id: string
:param id: (required) ID
:type id: string
:param include: (required) Associations to include with the quiz submission question.
:type include: string
:return: Get a single quiz submission question.
:rtype: requests.Response (with void data)
"""
include_types = ('quiz_question')
utils.validate_attr_is_acceptable(include, include_types)
path = '/v1/quiz_submissions/{quiz_submission_id}/questions/{id}'
payload = {
'include' : include,
}
url = request_ctx.base_api_url + path.format(quiz_submission_id=quiz_submission_id, id=id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def resolve_path_groups(request_ctx,
group_id,
per_page=None,
**request_kwargs):
"""
Given the full path to a folder, returns a list of all Folders in the path hierarchy,
starting at the root folder, and ending at the requested folder. The given path is
relative to the context's root folder and does not include the root folder's name
(e.g., "course files"). If an empty path is given, the context's root folder alone
is returned. Otherwise, if no folder exists with the given full path, a Not Found
error is returned.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param group_id: (required) ID
:type group_id: string
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: Resolve path
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/groups/{group_id}/folders/by_path'
payload = {
'per_page': per_page,
}
url = request_ctx.base_api_url + path.format(group_id=group_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def query_by_user(request_ctx,
user_id,
start_time=None,
end_time=None,
**request_kwargs):
"""
List authentication events for a given user.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param user_id: (required) ID
:type user_id: string
:param start_time: (optional) The beginning of the time range from which you want events.
:type start_time: datetime or None
:param end_time: (optional) The end of the time range from which you want events.
:type end_time: datetime or None
:return: Query by user.
:rtype: requests.Response (with void data)
"""
path = '/v1/audit/authentication/users/{user_id}'
payload = {
'start_time': start_time,
'end_time': end_time,
}
url = request_ctx.base_api_url + path.format(user_id=user_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def index_of_reports(request_ctx, account_id, report, per_page=None, **request_kwargs):
"""
Shows all reports that have been run for the account of a specific type.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param account_id: (required) ID
:type account_id: string
:param report: (required) ID
:type report: string
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: Index of Reports
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/accounts/{account_id}/reports/{report}'
payload = {
'per_page' : per_page,
}
url = request_ctx.base_api_url + path.format(account_id=account_id, report=report)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def get_single_course_accounts(request_ctx, account_id, id, include,
**request_kwargs):
"""
Return information on a single course.
Accepts the same include[] parameters as the list action plus:
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param account_id: (required) ID
:type account_id: string
:param id: (required) ID
:type id: string
:param include: (required) - "all_courses": Also search recently deleted courses. - "permissions": Include permissions the current user has for the course.
:type include: string
:return: Get a single course
:rtype: requests.Response (with Course data)
"""
include_types = ('all_courses', 'permissions')
utils.validate_attr_is_acceptable(include, include_types)
path = '/v1/accounts/{account_id}/courses/{id}'
payload = {
'include[]': include,
}
url = request_ctx.base_api_url + path.format(account_id=account_id, id=id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_external_tools_accounts(request_ctx, account_id, search_term=None, selectable=None, per_page=None, **request_kwargs):
"""
Returns the paginated list of external tools for the current context.
See the get request docs for a single tool for a list of properties on an external tool.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param account_id: (required) ID
:type account_id: string
:param search_term: (optional) The partial name of the tools to match and return.
:type search_term: string or None
:param selectable: (optional) If true, then only tools that are meant to be selectable are returned
:type selectable: boolean or None
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List external tools
:rtype: requests.Response (with void data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/accounts/{account_id}/external_tools'
payload = {
'search_term' : search_term,
'selectable' : selectable,
'per_page' : per_page,
}
url = request_ctx.base_api_url + path.format(account_id=account_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def get_module_item_sequence(request_ctx, course_id, asset_type, asset_id,
**request_kwargs):
"""
Given an asset in a course, find the ModuleItem it belongs to, and also the previous and next Module Items
in the course sequence.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:param asset_type: (required) The type of asset to find module sequence information for. Use the ModuleItem if it is known (e.g., the user navigated from a module item), since this will avoid ambiguity if the asset appears more than once in the module sequence.
:type asset_type: string
:param asset_id: (required) The id of the asset (or the url in the case of a Page)
:type asset_id: integer
:return: Get module item sequence
:rtype: requests.Response (with ModuleItemSequence data)
"""
asset_type_types = ('ModuleItem', 'File', 'Page', 'Discussion',
'Assignment', 'Quiz', 'ExternalTool')
utils.validate_attr_is_acceptable(asset_type, asset_type_types)
path = '/v1/courses/{course_id}/module_item_sequence'
payload = {
'asset_type': asset_type,
'asset_id': asset_id,
}
url = request_ctx.base_api_url + path.format(course_id=course_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_user_page_views(request_ctx, user_id, start_time=None, end_time=None, per_page=None, **request_kwargs):
"""
Return the user's page view history in json format, similar to the
available CSV download. Pagination is used as described in API basics
section. Page views are returned in descending order, newest to oldest.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param user_id: (required) ID
:type user_id: string
:param start_time: (optional) The beginning of the time range from which you want page views.
:type start_time: datetime or None
:param end_time: (optional) The end of the time range from which you want page views.
:type end_time: datetime or None
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List user page views
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/users/{user_id}/page_views'
payload = {
'start_time' : start_time,
'end_time' : end_time,
'per_page' : per_page,
}
url = request_ctx.base_api_url + path.format(user_id=user_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def details_for_given_date_in_gradebook_history_for_this_course(request_ctx, course_id, date, per_page=None, **request_kwargs):
"""
Returns the graders who worked on this day, along with the assignments they worked on.
More details can be obtained by selecting a grader and assignment and calling the
'submissions' api endpoint for a given date.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) The id of the contextual course for this API call
:type course_id: integer
:param date: (required) The date for which you would like to see detailed information
:type date: string
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: Details for a given date in gradebook history for this course
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/courses/{course_id}/gradebook_history/{date}'
payload = {
'per_page' : per_page,
}
url = request_ctx.base_api_url + path.format(course_id=course_id, date=date)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_accounts(request_ctx,
per_page=None,
as_user_id=None,
**request_kwargs):
"""
List accounts that the current user can view or manage. Typically,
students and even teachers will get an empty list in response, only
account admins can view the accounts that they are in.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:param as_user_id: (optional) Masquerade as the given canvas user
:type as_user_id: integer or None
:return: List accounts
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/accounts'
payload = {
'per_page': per_page,
}
if as_user_id:
payload['as_user_id'] = as_user_id
url = request_ctx.base_api_url + path.format()
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def get_sessionless_launch_url_for_external_tool_courses(request_ctx, course_id, id=None, url=None, assignment_id=None, launch_type=None, **request_kwargs):
"""
Returns a sessionless launch url for an external tool.
Either the id or url must be provided.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:param id: (optional) The external id of the tool to launch.
:type id: string or None
:param url: (optional) The LTI launch url for the external tool.
:type url: string or None
:param assignment_id: (optional) The assignment id for an assignment launch.
:type assignment_id: string or None
:param launch_type: (optional) The type of launch to perform on the external tool.
:type launch_type: string or None
:return: Get a sessionless launch url for an external tool.
:rtype: requests.Response (with void data)
"""
path = '/v1/courses/{course_id}/external_tools/sessionless_launch'
payload = {
'id' : id,
'url' : url,
'assignment_id' : assignment_id,
'launch_type' : launch_type,
}
url = request_ctx.base_api_url + path.format(course_id=course_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_preferences_type(request_ctx,
user_id,
type,
address,
per_page=None,
**request_kwargs):
"""
Fetch all preferences for the given communication channel
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param user_id: (required) ID
:type user_id: string
:param type: (required) ID
:type type: string
:param address: (required) ID
:type address: string
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List preferences
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/users/{user_id}/communication_channels/{type}/{address}/notification_preferences'
payload = {
'per_page': per_page,
}
url = request_ctx.base_api_url + path.format(
user_id=user_id, type=type, address=address)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_enrollments_sections(request_ctx,
section_id,
type=None,
role=None,
role_id=None,
state=None,
user_id=None,
per_page=None,
**request_kwargs):
"""
Depending on the URL given, return either (1) all of the enrollments in
a course, (2) all of the enrollments in a section or (3) all of a user's
enrollments. This includes student, teacher, TA, and observer enrollments.
If a user has multiple enrollments in a context (e.g. as a teacher
and a student or in multiple course sections), each enrollment will be
listed separately.
note: Currently, only an admin user can return other users' enrollments. A
user can, however, return his/her own enrollments.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param section_id: (required) ID
:type section_id: string
:param type: (optional) A list of enrollment types to return. Accepted values are 'StudentEnrollment', 'TeacherEnrollment', 'TaEnrollment', 'DesignerEnrollment', and 'ObserverEnrollment.' If omitted, all enrollment types are returned. This argument is ignored if `role` is given.
:type type: string or None
:param role: (optional) A list of enrollment roles to return. Accepted values include course-level roles created by the {api:RoleOverridesController#add_role Add Role API} as well as the base enrollment types accepted by the `type` argument above.
:type role: string or None
:param role_id: (optional) A list of enrollment role IDs to return. Accepted values include course-level the numeric IDs of the roles created by the {api:RoleOverridesController#add_role Add Role API} as well as the base enrollment types accepted by the `type` argument above.
:type role_id: integer or None
:param state: (optional) Filter by enrollment state. If omitted, 'active' and 'invited' enrollments are returned. When querying a user's enrollments (either via user_id argument or via user enrollments endpoint), the following additional synthetic states are supported: "current_and_invited"|"current_and_future"|"current_and_concluded"
:type state: string or None
:param user_id: (optional) Filter by user_id (only valid for course or section enrollment queries). If set to the current user's id, this is a way to determine if the user has any enrollments in the course or section, independent of whether the user has permission to view other people on the roster.
:type user_id: string or None
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List enrollments
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
state_types = ('active', 'invited', 'creation_pending', 'deleted',
'rejected', 'completed', 'inactive')
utils.validate_attr_is_acceptable(state, state_types)
path = '/v1/sections/{section_id}/enrollments'
payload = {
'type[]': type,
'role[]': role,
'role_id[]': role_id,
'state[]': state,
'user_id': user_id,
'per_page': per_page,
}
url = request_ctx.base_api_url + path.format(section_id=section_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_recently_logged_in_students(request_ctx, course_id, per_page=None, **request_kwargs):
"""
Returns the list of users in this course, ordered by how recently they have
logged in. The records include the 'last_login' field which contains
a timestamp of the last time that user logged into canvas. The querying
user must have the 'View usage reports' permission.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List recently logged in students
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/courses/{course_id}/recent_students'
payload = {
'per_page' : per_page,
}
url = request_ctx.base_api_url + path.format(course_id=course_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_user_communication_channels(request_ctx,
user_id,
per_page=None,
**request_kwargs):
"""
Returns a list of communication channels for the specified user, sorted by
position.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param user_id: (required) ID
:type user_id: string
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List user communication channels
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/users/{user_id}/communication_channels'
payload = {
'per_page': per_page,
}
url = request_ctx.base_api_url + path.format(user_id=user_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_todo_items(request_ctx, **request_kwargs):
"""
Returns the current user's list of todo items, as seen on the user dashboard.
There is a limit to the number of items returned.
The `ignore` and `ignore_permanently` URLs can be used to update the user's
preferences on what items will be displayed.
Performing a DELETE request against the `ignore` URL will hide that item
from future todo item requests, until the item changes.
Performing a DELETE request against the `ignore_permanently` URL will hide
that item forever.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:return: List the TODO items
:rtype: requests.Response (with void data)
"""
path = '/v1/users/self/todo'
url = request_ctx.base_api_url + path.format()
response = client.get(request_ctx, url, **request_kwargs)
return response
def list_live_assessment_results(request_ctx,
course_id,
assessment_id,
user_id=None,
**request_kwargs):
"""
Returns a list of live assessment results
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:param assessment_id: (required) ID
:type assessment_id: string
:param user_id: (optional) If set, restrict results to those for this user
:type user_id: integer or None
:return: List live assessment results
:rtype: requests.Response (with void data)
"""
path = '/v1/courses/{course_id}/live_assessments/{assessment_id}/results'
payload = {
'user_id': user_id,
}
url = request_ctx.base_api_url + path.format(course_id=course_id,
assessment_id=assessment_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_features_users(request_ctx, user_id, per_page=None, **request_kwargs):
"""
List all features that apply to a given Account, Course, or User.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param user_id: (required) ID
:type user_id: string
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List features
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/users/{user_id}/features'
payload = {
'per_page' : per_page,
}
url = request_ctx.base_api_url + path.format(user_id=user_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def get_sub_accounts_of_account(request_ctx,
account_id,
recursive=None,
per_page=None,
as_user_id=None,
**request_kwargs):
"""
List accounts that are sub-accounts of the given account.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param account_id: (required) ID
:type account_id: string
:param recursive: (optional) If true, the entire account tree underneath this account will be returned (though still paginated). If false, only direct sub-accounts of this account will be returned. Defaults to false.
:type recursive: boolean or None
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: Get the sub-accounts of an account
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/accounts/{account_id}/sub_accounts'
payload = {
'recursive': recursive,
'per_page': per_page,
}
if as_user_id:
payload['as_user_id'] = as_user_id
url = request_ctx.base_api_url + path.format(account_id=account_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def fetching_latest_quiz_statistics(request_ctx, course_id, quiz_id, all_versions, **request_kwargs):
"""
This endpoint provides statistics for all quiz versions, or for a specific
quiz version, in which case the output is guaranteed to represent the
_latest_ and most current version of the quiz.
<b>200 OK</b> response code is returned if the request was successful.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:param quiz_id: (required) ID
:type quiz_id: string
:param all_versions: (required) Whether the statistics report should include all submissions attempts.
:type all_versions: boolean
:return: Fetching the latest quiz statistics
:rtype: requests.Response (with void data)
"""
path = '/v1/courses/{course_id}/quizzes/{quiz_id}/statistics'
payload = {
'all_versions' : all_versions,
}
url = request_ctx.base_api_url + path.format(course_id=course_id, quiz_id=quiz_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def get_preference_communication_channel_id(request_ctx, user_id,
communication_channel_id,
notification, **request_kwargs):
"""
Fetch the preference for the given notification for the given communicaiton channel
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param user_id: (required) ID
:type user_id: string
:param communication_channel_id: (required) ID
:type communication_channel_id: string
:param notification: (required) ID
:type notification: string
:return: Get a preference
:rtype: requests.Response (with NotificationPreference data)
"""
path = '/v1/users/{user_id}/communication_channels/{communication_channel_id}/notification_preferences/{notification}'
url = request_ctx.base_api_url + path.format(
user_id=user_id,
communication_channel_id=communication_channel_id,
notification=notification)
response = client.get(request_ctx, url, **request_kwargs)
return response
def retrieve_all_quiz_reports(request_ctx, course_id, quiz_id, includes_all_versions=None, per_page=None, **request_kwargs):
"""
Returns a list of all available reports.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:param quiz_id: (required) ID
:type quiz_id: string
:param includes_all_versions: (optional) Whether to retrieve reports that consider all the submissions or only the most recent. Defaults to false, ignored for item_analysis reports.
:type includes_all_versions: boolean or None
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: Retrieve all quiz reports
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/courses/{course_id}/quizzes/{quiz_id}/reports'
payload = {
'includes_all_versions' : includes_all_versions,
'per_page' : per_page,
}
url = request_ctx.base_api_url + path.format(course_id=course_id, quiz_id=quiz_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_students(request_ctx, course_id, per_page=None, **request_kwargs):
"""
Returns the list of students enrolled in this course.
DEPRECATED: Please use the `CoursesController#users <https://github.com/instructure/canvas-lms/blob/master/app/controllers/courses_controller.rb>`_ endpoint
and pass "student" as the enrollment_type.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List students
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/courses/{course_id}/students'
payload = {
'per_page' : per_page,
}
url = request_ctx.base_api_url + path.format(course_id=course_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def get_quiz_report(request_ctx, course_id, quiz_id, id, include=None, **request_kwargs):
"""
Returns the data for a single quiz report.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:param quiz_id: (required) ID
:type quiz_id: string
:param id: (required) ID
:type id: string
:param include: (optional) Whether the output should include documents for the file and/or progress objects associated with this report. (Note: JSON-API only)
:type include: string[] or None
:return: Get a quiz report
:rtype: requests.Response (with QuizReport data)
"""
include_types = ('file', 'progress')
utils.validate_attr_is_acceptable(include, include_types)
path = '/v1/courses/{course_id}/quizzes/{quiz_id}/reports/{id}'
payload = {
'include' : include,
}
url = request_ctx.base_api_url + path.format(course_id=course_id, quiz_id=quiz_id, id=id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def get_single_course_accounts(request_ctx, account_id, id, include, **request_kwargs):
"""
Return information on a single course.
Accepts the same include[] parameters as the list action plus:
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param account_id: (required) ID
:type account_id: string
:param id: (required) ID
:type id: string
:param include: (required) - "all_courses": Also search recently deleted courses. - "permissions": Include permissions the current user has for the course.
:type include: string
:return: Get a single course
:rtype: requests.Response (with Course data)
"""
include_types = ('all_courses', 'permissions')
utils.validate_attr_is_acceptable(include, include_types)
path = '/v1/accounts/{account_id}/courses/{id}'
payload = {
'include[]' : include,
}
url = request_ctx.base_api_url + path.format(account_id=account_id, id=id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_members_of_collaboration(request_ctx, id, per_page=None, **request_kwargs):
"""
Examples
curl https://<canvas>/api/v1/courses/1/collaborations/1/members
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param id: (required) ID
:type id: string
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List members of a collaboration.
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/collaborations/{id}/members'
payload = {
'per_page' : per_page,
}
url = request_ctx.base_api_url + path.format(id=id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def show_module(request_ctx, course_id, id, include, student_id=None, **request_kwargs):
"""
Get information about a single module
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:param id: (required) ID
:type id: string
:param include: (required) - "items": Return module items inline if possible. This parameter suggests that Canvas return module items directly in the Module object JSON, to avoid having to make separate API requests for each module when enumerating modules and items. Canvas is free to omit 'items' for any particular module if it deems them too numerous to return inline. Callers must be prepared to use the {api:ContextModuleItemsApiController#index List Module Items API} if items are not returned. - "content_details": Requires include['items']. Returns additional details with module items specific to their associated content items. Includes standard lock information for each item.
:type include: string
:param student_id: (optional) Returns module completion information for the student with this id.
:type student_id: string or None
:return: Show module
:rtype: requests.Response (with Module data)
"""
include_types = ('items', 'content_details')
utils.validate_attr_is_acceptable(include, include_types)
path = '/v1/courses/{course_id}/modules/{id}'
payload = {
'include' : include,
'student_id' : student_id,
}
url = request_ctx.base_api_url + path.format(course_id=course_id, id=id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def get_department_level_grade_data_completed(request_ctx, account_id, **request_kwargs):
"""
Returns the distribution of grades for students in courses in the
department. Each data point is one student's current grade in one course;
if a student is in multiple courses, he contributes one value per course,
but if he's enrolled multiple times in the same course (e.g. a lecture
section and a lab section), he only constributes on value for that course.
Grades are binned to the nearest integer score; anomalous grades outside
the 0 to 100 range are ignored. The raw counts are returned, not yet
normalized by the total count.
Shares the same variations on endpoint as the participation data.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param account_id: (required) ID
:type account_id: string
:return: Get department-level grade data
:rtype: requests.Response (with void data)
"""
path = '/v1/accounts/{account_id}/analytics/completed/grades'
url = request_ctx.base_api_url + path.format(account_id=account_id)
response = client.get(request_ctx, url, **request_kwargs)
return response
def list_roles(request_ctx, account_id, state, per_page=None, **request_kwargs):
"""
List the roles available to an account.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param account_id: (required) The id of the account to retrieve roles for.
:type account_id: string
:param state: (required) Filter by role state. If this argument is omitted, only 'active' roles are returned.
:type state: string
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List roles
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
state_types = ('active', 'inactive')
utils.validate_attr_is_acceptable(state, state_types)
path = '/v1/accounts/{account_id}/roles'
payload = {
'state[]' : state,
'per_page' : per_page,
}
url = request_ctx.base_api_url + path.format(account_id=account_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def get_course_level_student_summary_data(request_ctx, course_id, **request_kwargs):
"""
Returns a summary of per-user access information for all students in
a course. This includes total page views, total participations, and a
breakdown of on-time/late status for all homework submissions in the course.
The data is returned as a list in lexical order on the student name.
Each student's summary also includes the maximum number of page views and
participations by any student in the course, which may be useful for some
visualizations (since determining maximums client side can be tricky with
pagination).
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:return: Get course-level student summary data
:rtype: requests.Response (with void data)
"""
path = '/v1/courses/{course_id}/analytics/student_summaries'
url = request_ctx.base_api_url + path.format(course_id=course_id)
response = client.get(request_ctx, url, **request_kwargs)
return response
def list_recently_logged_in_students(request_ctx,
course_id,
per_page=None,
**request_kwargs):
"""
Returns the list of users in this course, ordered by how recently they have
logged in. The records include the 'last_login' field which contains
a timestamp of the last time that user logged into canvas. The querying
user must have the 'View usage reports' permission.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List recently logged in students
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/courses/{course_id}/recent_students'
payload = {
'per_page': per_page,
}
url = request_ctx.base_api_url + path.format(course_id=course_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_course_sections(request_ctx, course_id, include=None, per_page=None, **request_kwargs):
"""
Returns the list of sections for this course.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:param include: (optional) - "students": Associations to include with the group. Note: this is only available if you have permission to view users or grades in the course - "avatar_url": Include the avatar URLs for students returned.
:type include: string or None
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List course sections
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
include_types = ('students', 'avatar_url')
utils.validate_attr_is_acceptable(include, include_types)
path = '/v1/courses/{course_id}/sections'
payload = {
'include[]' : include,
'per_page' : per_page,
}
url = request_ctx.base_api_url + path.format(course_id=course_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def show_module(request_ctx,
course_id,
id,
include,
student_id=None,
**request_kwargs):
"""
Get information about a single module
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:param id: (required) ID
:type id: string
:param include: (required) - "items": Return module items inline if possible. This parameter suggests that Canvas return module items directly in the Module object JSON, to avoid having to make separate API requests for each module when enumerating modules and items. Canvas is free to omit 'items' for any particular module if it deems them too numerous to return inline. Callers must be prepared to use the {api:ContextModuleItemsApiController#index List Module Items API} if items are not returned. - "content_details": Requires include['items']. Returns additional details with module items specific to their associated content items. Includes standard lock information for each item.
:type include: string
:param student_id: (optional) Returns module completion information for the student with this id.
:type student_id: string or None
:return: Show module
:rtype: requests.Response (with Module data)
"""
include_types = ('items', 'content_details')
utils.validate_attr_is_acceptable(include, include_types)
path = '/v1/courses/{course_id}/modules/{id}'
payload = {
'include': include,
'student_id': student_id,
}
url = request_ctx.base_api_url + path.format(course_id=course_id, id=id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_users_in_group_category(request_ctx, group_category_id, search_term=None, unassigned=None, per_page=None, **request_kwargs):
"""
Returns a list of users in the group category.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param group_category_id: (required) ID
:type group_category_id: string
:param search_term: (optional) The partial name or full ID of the users to match and return in the results list. Must be at least 3 characters.
:type search_term: string or None
:param unassigned: (optional) Set this value to true if you wish only to search unassigned users in the group category.
:type unassigned: boolean or None
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List users in group category
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/group_categories/{group_category_id}/users'
payload = {
'search_term' : search_term,
'unassigned' : unassigned,
'per_page' : per_page,
}
url = request_ctx.base_api_url + path.format(group_category_id=group_category_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_quizzes_in_course(request_ctx, course_id, search_term=None, per_page=None, **request_kwargs):
"""
Returns the list of Quizzes in this course.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:param search_term: (optional) The partial title of the quizzes to match and return.
:type search_term: string or None
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List quizzes in a course
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = "/v1/courses/{course_id}/quizzes"
payload = {"search_term": search_term, "per_page": per_page}
url = request_ctx.base_api_url + path.format(course_id=course_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def list_group_categories_for_context_courses(request_ctx, course_id, per_page=None, **request_kwargs):
"""
Returns a list of group categories in a context
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: List group categories for a context
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/courses/{course_id}/group_categories'
payload = {
'per_page' : per_page,
}
url = request_ctx.base_api_url + path.format(course_id=course_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def get_sessionless_launch_url_for_external_tool_courses(request_ctx, course_id, id=None, url=None, assignment_id=None, launch_type=None, **request_kwargs):
"""
Returns a sessionless launch url for an external tool.
Either the id or url must be provided.
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param course_id: (required) ID
:type course_id: string
:param id: (optional) The external id of the tool to launch.
:type id: string or None
:param url: (optional) The LTI launch url for the external tool.
:type url: string or None
:param assignment_id: (optional) The assignment id for an assignment launch.
:type assignment_id: string or None
:param launch_type: (optional) The type of launch to perform on the external tool.
:type launch_type: string or None
:return: Get a sessionless launch url for an external tool.
:rtype: requests.Response (with void data)
"""
path = '/v1/courses/{course_id}/external_tools/sessionless_launch'
payload = {
'id' : id,
'url' : url,
'assignment_id' : assignment_id,
'launch_type' : launch_type,
}
url = request_ctx.base_api_url + path.format(course_id=course_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
def get_sis_import_list(request_ctx,
account_id,
per_page=None,
**request_kwargs):
"""
Returns the list of SIS imports for an account
Examples:
curl 'https://<canvas>/api/v1/accounts/<account_id>/sis_imports' \
-H "Authorization: Bearer <token>"
:param request_ctx: The request context
:type request_ctx: :class:RequestContext
:param account_id: (required) ID
:type account_id: string
:param per_page: (optional) Set how many results canvas should return, defaults to config.LIMIT_PER_PAGE
:type per_page: integer or None
:return: Get SIS import list
:rtype: requests.Response (with array data)
"""
if per_page is None:
per_page = request_ctx.per_page
path = '/v1/accounts/{account_id}/sis_imports'
payload = {
'per_page': per_page,
}
url = request_ctx.base_api_url + path.format(account_id=account_id)
response = client.get(request_ctx, url, payload=payload, **request_kwargs)
return response
