def __init__(self, api_url, api_key):
"""
Creates an instance of this class.
:param api_url: The url of the Canvas API
:param api_key: The token to use with the API
"""
self.canvas = Canvas(api_url, api_key)
class App:
"""
A container class for the logic of this program.
"""
def __init__(self, api_url, api_key):
"""
Creates an instance of this class.
:param api_url: The url of the Canvas API
:param api_key: The token to use with the API
"""
self.canvas = Canvas(api_url, api_key)
def ask_user_for_course(self):
"""
Prints the user's courses and asks which he would like to choose.
:return: The course
"""
courses = tuple(self.canvas.get_courses())
print('Choose a course:')
for number, course in enumerate(courses):
print('{number}\t{course_name}'.format(number=number, course_name=str(course)))
selected_course_number = ''
while type(selected_course_number) != int or not 0 < selected_course_number < len(courses):
selected_course_number = input('Which course would you like to choose? ')
try:
selected_course_number = int(selected_course_number)
except ValueError:
pass
selected_course = courses[selected_course_number]
return selected_course
@staticmethod
def ask_user_for_download_directory(selected_course):
"""
Asks the user where he would like the downloaded files to be placed.
:return: The directory the user specified or a default location in Downloads
"""
download_directory = Path.home() / 'Downloads/{course_name}'.format(course_name=str(selected_course))
user_input = input('In what folder would you like to download the files? Default: {default_path}'.format(
default_path=download_directory))
if user_input:
download_directory = Path(user_input)
if not download_directory.exists():
download_directory.mkdir()
return download_directory
@staticmethod
def download_files_from_canvas_folder(canvas_folder, parent_directory):
"""
Takes a Canvas Folder and writes its files in the given directory.
:param canvas_folder: The Canvas folder
:param parent_directory: The parent directory
:return: ``None``
"""
for canvas_file in : # TODO: Do something
file_path
# TIP: For every file in the Canvas folder, make a responding Path and write it to the filesystem
web_request = requests.get(canvas_file.url)
file_content = web_request.content
file_path.write_bytes(file_content)
def run(self):
"""
Starts the program.
This program should ask the user which course he would like to download.
It should also let him specify where he would like them downloaded.
Then, it should download all the course's files into the user's filesystem
:return: ``None``
"""
selected_course = self.ask_user_for_course()
print('You selected {course_name}'.format(course_name=str(selected_course)))
download_directory = self.ask_user_for_download_directory(selected_course)
for folder in selected_course.list_folders():
pass # TODO: Do something
class TestGroup(unittest.TestCase):
def setUp(self):
warnings.simplefilter("always", DeprecationWarning)
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
register_uris({"course": ["get_by_id"], "group": ["get_by_id"]}, m)
self.course = self.canvas.get_course(1)
self.group = self.canvas.get_group(1)
# __str__()
def test__str__(self, m):
string = str(self.group)
self.assertIsInstance(string, str)
# show_front_page()
def test_show_front_page(self, m):
register_uris({"group": ["show_front_page"]}, m)
front_page = self.group.show_front_page()
self.assertIsInstance(front_page, Page)
self.assertTrue(hasattr(front_page, "url"))
self.assertTrue(hasattr(front_page, "title"))
# create_front_page()
def test_edit_front_page(self, m):
register_uris({"group": ["edit_front_page"]}, m)
new_front_page = self.group.edit_front_page()
self.assertIsInstance(new_front_page, Page)
self.assertTrue(hasattr(new_front_page, "url"))
self.assertTrue(hasattr(new_front_page, "title"))
# get_pages()
def test_get_pages(self, m):
register_uris({"group": ["get_pages", "get_pages2"]}, m)
pages = self.group.get_pages()
page_list = [page for page in pages]
self.assertEqual(len(page_list), 4)
self.assertIsInstance(page_list[0], Page)
self.assertTrue(hasattr(page_list[0], "id"))
self.assertEqual(page_list[0].group_id, self.group.id)
# create_page()
def test_create_page(self, m):
register_uris({"group": ["create_page"]}, m)
title = "New Page"
new_page = self.group.create_page(wiki_page={"title": title})
self.assertIsInstance(new_page, Page)
self.assertTrue(hasattr(new_page, "title"))
self.assertEqual(new_page.title, title)
self.assertTrue(hasattr(new_page, "id"))
self.assertEqual(new_page.group_id, self.group.id)
def test_create_page_fail(self, m):
with self.assertRaises(RequiredFieldMissing):
self.group.create_page(settings.INVALID_ID)
# get_page()
def test_get_page(self, m):
register_uris({"group": ["get_page"]}, m)
url = "my-url"
page = self.group.get_page(url)
self.assertIsInstance(page, Page)
# edit()
def test_edit(self, m):
register_uris({"group": ["edit"]}, m)
new_title = "New Group"
response = self.group.edit(description=new_title)
self.assertIsInstance(response, Group)
self.assertTrue(hasattr(response, "description"))
self.assertEqual(response.description, new_title)
# delete()
def test_delete(self, m):
register_uris({"group": ["delete"]}, m)
group = self.group.delete()
self.assertIsInstance(group, Group)
self.assertTrue(hasattr(group, "name"))
self.assertTrue(hasattr(group, "description"))
# invite()
def test_invite(self, m):
register_uris({"group": ["invite"]}, m)
user_list = ["1", "2"]
response = self.group.invite(user_list)
gmembership_list = [groupmembership for groupmembership in response]
self.assertIsInstance(gmembership_list[0], GroupMembership)
self.assertEqual(len(gmembership_list), 2)
# list_users()
def test_list_users(self, m):
register_uris({"group": ["list_users", "list_users_p2"]}, m)
with warnings.catch_warnings(record=True) as warning_list:
from canvasapi.user import User
users = self.group.list_users()
user_list = [user for user in users]
self.assertIsInstance(user_list[0], User)
self.assertEqual(len(user_list), 4)
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
# get_users()
def test_get_users(self, m):
register_uris({"group": ["list_users", "list_users_p2"]}, m)
from canvasapi.user import User
users = self.group.get_users()
user_list = [user for user in users]
self.assertIsInstance(user_list[0], User)
self.assertEqual(len(user_list), 4)
# remove_user()
def test_remove_user(self, m):
register_uris(
{"group": ["list_users", "list_users_p2", "remove_user"]}, m)
from canvasapi.user import User
user_by_id = self.group.remove_user(1)
self.assertIsInstance(user_by_id, User)
users = self.group.get_users()
user_by_obj = self.group.remove_user(users[0])
self.assertIsInstance(user_by_obj, User)
# upload()
def test_upload(self, m):
register_uris({"group": ["upload", "upload_final"]}, m)
filename = "testfile_group_{}".format(uuid.uuid4().hex)
try:
with open(filename, "w+") as file:
response = self.group.upload(file)
self.assertTrue(response[0])
self.assertIsInstance(response[1], dict)
self.assertIn("url", response[1])
finally:
cleanup_file(filename)
# preview_processed_html()
def test_preview_processed_html(self, m):
register_uris({"group": ["preview_processed_html"]}, m)
html_str = "<p>processed html</p>"
response = self.group.preview_html(html_str)
self.assertEqual(response, html_str)
# get_activity_stream_summary()
def test_get_activity_stream_summary(self, m):
register_uris({"group": ["activity_stream_summary"]}, m)
response = self.group.get_activity_stream_summary()
self.assertEqual(len(response), 2)
self.assertIn("type", response[0])
# list_memberships()
def test_list_memberships(self, m):
register_uris({"group": ["list_memberships", "list_memberships_p2"]},
m)
with warnings.catch_warnings(record=True) as warning_list:
response = self.group.list_memberships()
membership_list = [membership for membership in response]
self.assertEqual(len(membership_list), 4)
self.assertIsInstance(membership_list[0], GroupMembership)
self.assertTrue(hasattr(membership_list[0], "id"))
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
# get_memberships()
def test_get_memberships(self, m):
register_uris({"group": ["list_memberships", "list_memberships_p2"]},
m)
response = self.group.get_memberships()
membership_list = [membership for membership in response]
self.assertEqual(len(membership_list), 4)
self.assertIsInstance(membership_list[0], GroupMembership)
self.assertTrue(hasattr(membership_list[0], "id"))
# get_membership()
def test_get_membership(self, m):
register_uris(
{"group": ["get_membership", "list_users", "list_users_p2"]}, m)
membership_by_id = self.group.get_membership(1, "users")
self.assertIsInstance(membership_by_id, GroupMembership)
users = self.group.get_users()
membership_by_obj = self.group.get_membership(users[0], "users")
self.assertIsInstance(membership_by_obj, GroupMembership)
# create_membership()
def test_create_membership(self, m):
register_uris(
{"group": ["create_membership", "list_users", "list_users_p2"]}, m)
response = self.group.create_membership(1)
self.assertIsInstance(response, GroupMembership)
users = self.group.get_users()
response = self.group.create_membership(users[0])
self.assertIsInstance(response, GroupMembership)
# update_membership()
def test_update_membership(self, m):
register_uris(
{
"group":
["list_users", "list_users_p2", "update_membership_user"]
}, m)
updated_membership_by_id = self.group.update_membership(1)
self.assertIsInstance(updated_membership_by_id, GroupMembership)
users = self.group.get_users()
updated_membership_by_obj = self.group.update_membership(users[0])
self.assertIsInstance(updated_membership_by_obj, GroupMembership)
# get_discussion_topic()
def test_get_discussion_topic(self, m):
register_uris(
{"group": ["get_discussion_topic", "get_discussion_topics"]}, m)
group_id = 1
discussion_by_id = self.group.get_discussion_topic(group_id)
self.assertIsInstance(discussion_by_id, DiscussionTopic)
self.assertTrue(hasattr(discussion_by_id, "group_id"))
self.assertEqual(group_id, discussion_by_id.id)
self.assertEqual(discussion_by_id.group_id, 1)
discussion_topic = self.group.get_discussion_topics()[0]
discussion_by_obj = self.group.get_discussion_topic(discussion_topic)
self.assertIsInstance(discussion_by_obj, DiscussionTopic)
self.assertTrue(hasattr(discussion_by_obj, "group_id"))
self.assertEqual(group_id, discussion_by_obj.id)
self.assertEqual(discussion_by_obj.group_id, 1)
# get_file()
def test_get_file(self, m):
register_uris({"group": ["get_file"]}, m)
file_by_id = self.group.get_file(1)
self.assertIsInstance(file_by_id, File)
self.assertEqual(file_by_id.display_name, "Group_File.docx")
self.assertEqual(file_by_id.size, 4096)
file_by_obj = self.group.get_file(file_by_id)
self.assertIsInstance(file_by_obj, File)
self.assertEqual(file_by_obj.display_name, "Group_File.docx")
self.assertEqual(file_by_obj.size, 4096)
# get_full_discussion_topic
def test_get_full_discussion_topic(self, m):
register_uris(
{"group": ["get_full_discussion_topic", "get_discussion_topics"]},
m)
discussion_by_id = self.group.get_full_discussion_topic(1)
self.assertIsInstance(discussion_by_id, dict)
self.assertIn("view", discussion_by_id)
self.assertIn("participants", discussion_by_id)
self.assertIn("id", discussion_by_id)
self.assertEqual(discussion_by_id["id"], 1)
discussion_topic = self.group.get_discussion_topics()[0]
discussion_by_obj = self.group.get_full_discussion_topic(
discussion_topic)
self.assertIsInstance(discussion_by_obj, dict)
self.assertIn("view", discussion_by_obj)
self.assertIn("participants", discussion_by_obj)
self.assertIn("id", discussion_by_obj)
self.assertEqual(discussion_by_obj["id"], 1)
# get_discussion_topics()
def test_get_discussion_topics(self, m):
register_uris({"group": ["get_discussion_topics"]}, m)
response = self.group.get_discussion_topics()
discussion_list = [discussion for discussion in response]
self.assertIsInstance(discussion_list[0], DiscussionTopic)
self.assertTrue(hasattr(discussion_list[0], "group_id"))
self.assertEqual(2, len(discussion_list))
# create_discussion_topic()
def test_create_discussion_topic(self, m):
register_uris({"group": ["create_discussion_topic"]}, m)
title = "Topic 1"
discussion = self.group.create_discussion_topic()
self.assertTrue(hasattr(discussion, "group_id"))
self.assertIsInstance(discussion, DiscussionTopic)
self.assertEqual(discussion.title, title)
self.assertEqual(discussion.group_id, 1)
# reorder_pinned_topics()
def test_reorder_pinned_topics(self, m):
# Custom matcher to test that params are set correctly
def custom_matcher(request):
match_text = "1,2,3"
if request.text == "order={}".format(quote(match_text)):
resp = requests.Response()
resp._content = b'{"reorder": true, "order": [1, 2, 3]}'
resp.status_code = 200
return resp
m.add_matcher(custom_matcher)
order = [1, 2, 3]
discussions = self.group.reorder_pinned_topics(order=order)
self.assertTrue(discussions)
def test_reorder_pinned_topics_tuple(self, m):
register_uris({"group": ["reorder_pinned_topics"]}, m)
order = (1, 2, 3)
discussions = self.group.reorder_pinned_topics(order=order)
self.assertTrue(discussions)
def test_reorder_pinned_topics_comma_separated_string(self, m):
register_uris({"group": ["reorder_pinned_topics"]}, m)
order = "1,2,3"
discussions = self.group.reorder_pinned_topics(order=order)
self.assertTrue(discussions)
def test_reorder_pinned_topics_invalid_input(self, m):
order = "invalid string"
with self.assertRaises(ValueError):
self.group.reorder_pinned_topics(order=order)
# list_external_feeds()
def test_list_external_feeds(self, m):
register_uris({"group": ["list_external_feeds"]}, m)
with warnings.catch_warnings(record=True) as warning_list:
feeds = self.group.list_external_feeds()
feed_list = [feed for feed in feeds]
self.assertEqual(len(feed_list), 2)
self.assertTrue(hasattr(feed_list[0], "url"))
self.assertIsInstance(feed_list[0], ExternalFeed)
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
# get_external_feeds()
def test_get_external_feeds(self, m):
register_uris({"group": ["list_external_feeds"]}, m)
feeds = self.group.get_external_feeds()
feed_list = [feed for feed in feeds]
self.assertEqual(len(feed_list), 2)
self.assertTrue(hasattr(feed_list[0], "url"))
self.assertIsInstance(feed_list[0], ExternalFeed)
# create_external_feed()
def test_create_external_feed(self, m):
register_uris({"group": ["create_external_feed"]}, m)
url_str = "https://example.com/myblog.rss"
response = self.group.create_external_feed(url=url_str)
self.assertIsInstance(response, ExternalFeed)
# delete_external_feed()
def test_delete_external_feed(self, m):
register_uris({"group": ["delete_external_feed"]}, m)
deleted_ef_by_id = self.group.delete_external_feed(1)
self.assertIsInstance(deleted_ef_by_id, ExternalFeed)
self.assertTrue(hasattr(deleted_ef_by_id, "url"))
self.assertEqual(deleted_ef_by_id.display_name, "My Blog")
deleted_ef_by_obj = self.group.delete_external_feed(deleted_ef_by_id)
self.assertIsInstance(deleted_ef_by_obj, ExternalFeed)
self.assertTrue(hasattr(deleted_ef_by_obj, "url"))
self.assertEqual(deleted_ef_by_obj.display_name, "My Blog")
# list_files()
def test_list_files(self, m):
register_uris({"group": ["list_group_files", "list_group_files2"]}, m)
with warnings.catch_warnings(record=True) as warning_list:
files = self.group.list_files()
file_list = [file for file in files]
self.assertEqual(len(file_list), 4)
self.assertIsInstance(file_list[0], File)
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
# get_files()
def test_get_files(self, m):
register_uris({"group": ["list_group_files", "list_group_files2"]}, m)
files = self.group.get_files()
file_list = [file for file in files]
self.assertEqual(len(file_list), 4)
self.assertIsInstance(file_list[0], File)
# get_folder()
def test_get_folder(self, m):
register_uris({"group": ["get_folder"]}, m)
folder_by_id = self.group.get_folder(1)
self.assertEqual(folder_by_id.name, "Folder 1")
self.assertIsInstance(folder_by_id, Folder)
folder_by_obj = self.group.get_folder(folder_by_id)
self.assertEqual(folder_by_obj.name, "Folder 1")
self.assertIsInstance(folder_by_obj, Folder)
# list_folders()
def test_list_folders(self, m):
register_uris({"group": ["list_folders"]}, m)
with warnings.catch_warnings(record=True) as warning_list:
folders = self.group.list_folders()
folder_list = [folder for folder in folders]
self.assertEqual(len(folder_list), 2)
self.assertIsInstance(folder_list[0], Folder)
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
# get_folders()
def test_get_folders(self, m):
register_uris({"group": ["list_folders"]}, m)
folders = self.group.get_folders()
folder_list = [folder for folder in folders]
self.assertEqual(len(folder_list), 2)
self.assertIsInstance(folder_list[0], Folder)
# create_folder()
def test_create_folder(self, m):
register_uris({"group": ["create_folder"]}, m)
name_str = "Test String"
response = self.group.create_folder(name=name_str)
self.assertIsInstance(response, Folder)
# list_tabs()
def test_list_tabs(self, m):
register_uris({"group": ["list_tabs"]}, m)
with warnings.catch_warnings(record=True) as warning_list:
tabs = self.group.list_tabs()
tab_list = [tab for tab in tabs]
self.assertEqual(len(tab_list), 2)
self.assertIsInstance(tab_list[0], Tab)
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
# get_tabs()
def test_get_tabs(self, m):
register_uris({"group": ["list_tabs"]}, m)
tabs = self.group.get_tabs()
tab_list = [tab for tab in tabs]
self.assertEqual(len(tab_list), 2)
self.assertIsInstance(tab_list[0], Tab)
# create_content_migration
def test_create_content_migration(self, m):
register_uris({"group": ["create_content_migration"]}, m)
content_migration = self.group.create_content_migration(
"dummy_importer")
self.assertIsInstance(content_migration, ContentMigration)
self.assertTrue(hasattr(content_migration, "migration_type"))
def test_create_content_migration_migrator(self, m):
register_uris(
{
"group":
["create_content_migration", "get_migration_systems_multiple"]
}, m)
migrators = self.group.get_migration_systems()
content_migration = self.group.create_content_migration(migrators[0])
self.assertIsInstance(content_migration, ContentMigration)
self.assertTrue(hasattr(content_migration, "migration_type"))
def test_create_content_migration_bad_migration_type(self, m):
register_uris({"group": ["create_content_migration"]}, m)
with self.assertRaises(TypeError):
self.group.create_content_migration(1)
# get_collaborations
def test_get_collaborations(self, m):
register_uris({"group": ["get_collaborations"]}, m)
from canvasapi.collaboration import Collaboration
collab_list = self.group.get_collaborations()
self.assertIsInstance(collab_list, PaginatedList)
self.assertIsInstance(collab_list[0], Collaboration)
self.assertIsInstance(collab_list[1], Collaboration)
self.assertEqual(collab_list[0].id, 1)
self.assertEqual(collab_list[1].id, 2)
self.assertEqual(collab_list[0].document_id,
"oinwoenfe8w8ef_onweufe89fef")
self.assertEqual(collab_list[1].document_id,
"oinwoenfe8w8ef_onweufe89zzz")
# get_content_migration
def test_get_content_migration(self, m):
register_uris({"group": ["get_content_migration_single"]}, m)
content_migration = self.group.get_content_migration(1)
self.assertIsInstance(content_migration, ContentMigration)
self.assertTrue(hasattr(content_migration, "migration_type"))
# get_content_migrations
def test_get_content_migrations(self, m):
register_uris({"group": ["get_content_migration_multiple"]}, m)
content_migrations = self.group.get_content_migrations()
self.assertEqual(len(list(content_migrations)), 2)
self.assertIsInstance(content_migrations[0], ContentMigration)
self.assertEqual(content_migrations[0].id, 1)
self.assertEqual(content_migrations[0].migration_type,
"dummy_importer")
self.assertIsInstance(content_migrations[1], ContentMigration)
self.assertEqual(content_migrations[1].id, 2)
self.assertEqual(content_migrations[1].migration_type,
"dummy_importer")
# get_migration_systems
def test_get_migration_systems(self, m):
register_uris({"group": ["get_migration_systems_multiple"]}, m)
migration_systems = self.group.get_migration_systems()
self.assertEqual(len(list(migration_systems)), 2)
self.assertIsInstance(migration_systems[0], Migrator)
self.assertEqual(migration_systems[0].type, "dummy_importer")
self.assertEqual(migration_systems[0].requires_file_upload, True)
self.assertEqual(migration_systems[0].name, "Dummy Importer 01")
self.assertIsInstance(migration_systems[1], Migrator)
self.assertEqual(migration_systems[1].type, "dummy_importer_02")
self.assertEqual(migration_systems[1].requires_file_upload, False)
self.assertEqual(migration_systems[1].name, "Dummy Importer 02")
# get_assignment_override
def test_get_assignment_override(self, m):
register_uris({"assignment": ["override_group_alias"]}, m)
override = self.group.get_assignment_override(1)
self.assertIsInstance(override, AssignmentOverride)
self.assertEqual(override.group_id, self.group.id)
# get_content_exports()
def test_list_content_exports(self, m):
register_uris({"group": ["multiple_content_exports"]}, m)
content_exports = self.group.get_content_exports()
content_export_list = [
content_export for content_export in content_exports
]
self.assertEqual(len(content_export_list), 2)
self.assertEqual(content_export_list[0].id, 2)
self.assertEqual(content_export_list[1].export_type, "b")
self.assertIsInstance(content_export_list[0], ContentExport)
# get_content_export()
def test_show_content_export(self, m):
register_uris({"group": ["single_content_export"]}, m)
content_export = self.group.get_content_export(11)
self.assertTrue(hasattr(content_export, "export_type"))
self.assertIsInstance(content_export, ContentExport)
# export_content()
def test_export_content(self, m):
register_uris({"group": ["export_content"]}, m)
content_export = self.group.export_content("d")
self.assertIsInstance(content_export, ContentExport)
self.assertTrue(hasattr(content_export, "export_type"))
# set_usage_rights()
def test_set_usage_rights(self, m):
register_uris({"group": ["set_usage_rights"]}, m)
usage_rights = self.group.set_usage_rights(
file_ids=[1, 2],
usage_rights={
"use_justification": "fair_use",
"license": "private"
},
)
self.assertIsInstance(usage_rights, UsageRights)
self.assertEqual(usage_rights.use_justification, "fair_use")
self.assertEqual(usage_rights.message, "2 files updated")
self.assertEqual(usage_rights.license, "private")
self.assertEqual(usage_rights.file_ids, [1, 2])
# remove_usage_rights()
def test_remove_usage_rights(self, m):
register_uris({"group": ["remove_usage_rights"]}, m)
retval = self.group.remove_usage_rights(file_ids=[1, 2])
self.assertIsInstance(retval, dict)
self.assertIn("message", retval)
self.assertEqual(retval["file_ids"], [1, 2])
self.assertEqual(retval["message"], "2 files updated")
# get_licenses()
def test_get_licenses(self, m):
register_uris({"group": ["get_licenses"]}, m)
licenses = self.group.get_licenses()
self.assertIsInstance(licenses, PaginatedList)
licenses = list(licenses)
for l in licenses:
self.assertIsInstance(l, License)
self.assertTrue(hasattr(l, "id"))
self.assertTrue(hasattr(l, "name"))
self.assertTrue(hasattr(l, "url"))
self.assertEqual(2, len(licenses))
class TestCourse(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
'course': ['get_assignment_by_id', 'get_by_id', 'get_page'],
'quiz': ['get_by_id'],
'user': ['get_by_id']
}
register_uris(requires, m)
self.course = self.canvas.get_course(1)
self.page = self.course.get_page('my-url')
self.quiz = self.course.get_quiz(1)
self.user = self.canvas.get_user(1)
self.assignment = self.course.get_assignment('5')
# __str__()
def test__str__(self, m):
string = str(self.course)
self.assertIsInstance(string, str)
# conclude()
def test_conclude(self, m):
register_uris({'course': ['conclude']}, m)
success = self.course.conclude()
self.assertTrue(success)
# delete()
def test_delete(self, m):
register_uris({'course': ['delete']}, m)
success = self.course.delete()
self.assertTrue(success)
# update()
def test_update(self, m):
register_uris({'course': ['update']}, m)
new_name = 'New Name'
self.course.update(course={'name': new_name})
self.assertEqual(self.course.name, new_name)
# get_user()
def test_get_user(self, m):
register_uris({'course': ['get_user']}, m)
user_by_id = self.course.get_user(1)
self.assertIsInstance(user_by_id, User)
self.assertTrue(hasattr(user_by_id, 'name'))
user_by_obj = self.course.get_user(user_by_id)
self.assertIsInstance(user_by_obj, User)
self.assertTrue(hasattr(user_by_obj, 'name'))
def test_get_user_id_type(self, m):
register_uris({'course': ['get_user_id_type']}, m)
user = self.course.get_user("LOGINID", "login_id")
self.assertIsInstance(user, User)
self.assertTrue(hasattr(user, 'name'))
# get_users()
def test_get_users(self, m):
register_uris({'course': ['get_users', 'get_users_p2']}, m)
users = self.course.get_users()
user_list = [user for user in users]
self.assertEqual(len(user_list), 4)
self.assertIsInstance(user_list[0], User)
# enroll_user()
def test_enroll_user(self, m):
requires = {'course': ['enroll_user'], 'user': ['get_by_id']}
register_uris(requires, m)
enrollment_type = 'TeacherEnrollment'
user_by_id = self.canvas.get_user(1)
enrollment_by_id = self.course.enroll_user(user_by_id, enrollment_type)
self.assertIsInstance(enrollment_by_id, Enrollment)
self.assertTrue(hasattr(enrollment_by_id, 'type'))
self.assertEqual(enrollment_by_id.type, enrollment_type)
user_by_obj = self.canvas.get_user(self.user)
enrollment_by_obj = self.course.enroll_user(user_by_obj,
enrollment_type)
self.assertIsInstance(enrollment_by_obj, Enrollment)
self.assertTrue(hasattr(enrollment_by_obj, 'type'))
self.assertEqual(enrollment_by_obj.type, enrollment_type)
# get_recent_students()
def test_get_recent_students(self, m):
recent = {'course': ['get_recent_students', 'get_recent_students_p2']}
register_uris(recent, m)
students = self.course.get_recent_students()
student_list = [student for student in students]
self.assertEqual(len(student_list), 4)
self.assertIsInstance(student_list[0], User)
self.assertTrue(hasattr(student_list[0], 'name'))
# preview_html()
def test_preview_html(self, m):
register_uris({'course': ['preview_html']}, m)
html_str = "<script></script><p>hello</p>"
prev_html = self.course.preview_html(html_str)
self.assertIsInstance(prev_html, text_type)
self.assertEqual(prev_html, "<p>hello</p>")
# get_settings()
def test_get_settings(self, m):
register_uris({'course': ['settings']}, m)
settings = self.course.get_settings()
self.assertIsInstance(settings, dict)
# update_settings()
def test_update_settings(self, m):
register_uris({'course': ['update_settings']}, m)
settings = self.course.update_settings()
self.assertIsInstance(settings, dict)
self.assertTrue(settings['hide_final_grades'])
# upload()
def test_upload(self, m):
register_uris({'course': ['upload', 'upload_final']}, m)
filename = 'testfile_course_{}'.format(uuid.uuid4().hex)
try:
with open(filename, 'w+') as file:
response = self.course.upload(file)
self.assertTrue(response[0])
self.assertIsInstance(response[1], dict)
self.assertIn('url', response[1])
finally:
cleanup_file(filename)
# reset()
def test_reset(self, m):
register_uris({'course': ['reset']}, m)
course = self.course.reset()
self.assertIsInstance(course, Course)
self.assertTrue(hasattr(course, 'name'))
# create_quiz()
def test_create_quiz(self, m):
register_uris({'course': ['create_quiz']}, m)
title = 'Newer Title'
new_quiz = self.course.create_quiz({'title': title})
self.assertIsInstance(new_quiz, Quiz)
self.assertTrue(hasattr(new_quiz, 'title'))
self.assertEqual(new_quiz.title, title)
self.assertTrue(hasattr(new_quiz, 'course_id'))
self.assertEqual(new_quiz.course_id, self.course.id)
def test_create_quiz_fail(self, m):
with self.assertRaises(RequiredFieldMissing):
self.course.create_quiz({})
# get_quiz()
def test_get_quiz(self, m):
register_uris({'course': ['get_quiz']}, m)
target_quiz_by_id = self.course.get_quiz(1)
self.assertIsInstance(target_quiz_by_id, Quiz)
self.assertTrue(hasattr(target_quiz_by_id, 'course_id'))
self.assertEqual(target_quiz_by_id.course_id, self.course.id)
target_quiz_by_obj = self.course.get_quiz(target_quiz_by_id)
self.assertIsInstance(target_quiz_by_obj, Quiz)
self.assertTrue(hasattr(target_quiz_by_obj, 'course_id'))
self.assertEqual(target_quiz_by_obj.course_id, self.course.id)
def test_get_quiz_fail(self, m):
register_uris({'generic': ['not_found']}, m)
with self.assertRaises(ResourceDoesNotExist):
self.course.get_quiz(settings.INVALID_ID)
# get_quizzes()
def test_get_quizzes(self, m):
register_uris({'course': ['list_quizzes', 'list_quizzes2']}, m)
quizzes = self.course.get_quizzes()
quiz_list = [quiz for quiz in quizzes]
self.assertEqual(len(quiz_list), 4)
self.assertIsInstance(quiz_list[0], Quiz)
self.assertTrue(hasattr(quiz_list[0], 'course_id'))
self.assertEqual(quiz_list[0].course_id, self.course.id)
# get_modules()
def test_get_modules(self, m):
register_uris({'course': ['list_modules', 'list_modules2']}, m)
modules = self.course.get_modules()
module_list = [module for module in modules]
self.assertEqual(len(module_list), 4)
self.assertIsInstance(module_list[0], Module)
self.assertTrue(hasattr(module_list[0], 'course_id'))
self.assertEqual(module_list[0].course_id, self.course.id)
# get_module()
def test_get_module(self, m):
register_uris({'course': ['get_module_by_id']}, m)
target_module_by_id = self.course.get_module(1)
self.assertIsInstance(target_module_by_id, Module)
self.assertTrue(hasattr(target_module_by_id, 'course_id'))
self.assertEqual(target_module_by_id.course_id, self.course.id)
target_module_by_obj = self.course.get_module(target_module_by_id)
self.assertIsInstance(target_module_by_obj, Module)
self.assertTrue(hasattr(target_module_by_obj, 'course_id'))
self.assertEqual(target_module_by_obj.course_id, self.course.id)
# create_module()
def test_create_module(self, m):
register_uris({'course': ['create_module']}, m)
name = 'Name'
new_module = self.course.create_module(module={'name': name})
self.assertIsInstance(new_module, Module)
self.assertTrue(hasattr(new_module, 'name'))
self.assertTrue(hasattr(new_module, 'course_id'))
self.assertEqual(new_module.course_id, self.course.id)
def test_create_module_fail(self, m):
with self.assertRaises(RequiredFieldMissing):
self.course.create_module(module={})
# get_enrollments()
def test_get_enrollments(self, m):
register_uris({'course': ['list_enrollments', 'list_enrollments_2']},
m)
enrollments = self.course.get_enrollments()
enrollment_list = [enrollment for enrollment in enrollments]
self.assertEqual(len(enrollment_list), 4)
self.assertIsInstance(enrollment_list[0], Enrollment)
# get_section
def test_get_section(self, m):
register_uris({'course': ['get_section']}, m)
section_by_id = self.course.get_section(1)
self.assertIsInstance(section_by_id, Section)
section_by_obj = self.course.get_section(section_by_id)
self.assertIsInstance(section_by_obj, Section)
# create_assignment()
def test_create_assignment(self, m):
register_uris({'course': ['create_assignment']}, m)
name = 'Newly Created Assignment'
assignment = self.course.create_assignment(assignment={'name': name})
self.assertIsInstance(assignment, Assignment)
self.assertTrue(hasattr(assignment, 'name'))
self.assertEqual(assignment.name, name)
self.assertEqual(assignment.id, 5)
def test_create_assignment_fail(self, m):
with self.assertRaises(RequiredFieldMissing):
self.course.create_assignment(assignment={})
# get_assignment()
def test_get_assignment(self, m):
register_uris({'course': ['get_assignment_by_id']}, m)
assignment_by_id = self.course.get_assignment('5')
self.assertIsInstance(assignment_by_id, Assignment)
self.assertTrue(hasattr(assignment_by_id, 'name'))
assignment_by_obj = self.course.get_assignment(self.assignment)
self.assertIsInstance(assignment_by_obj, Assignment)
self.assertTrue(hasattr(assignment_by_obj, 'name'))
# get_assignments()
def test_get_assignments(self, m):
requires = {'course': ['get_all_assignments', 'get_all_assignments2']}
register_uris(requires, m)
assignments = self.course.get_assignments()
assignment_list = [assignment for assignment in assignments]
self.assertIsInstance(assignments[0], Assignment)
self.assertEqual(len(assignment_list), 4)
# show_front_page()
def test_show_front_page(self, m):
register_uris({'course': ['show_front_page']}, m)
front_page = self.course.show_front_page()
self.assertIsInstance(front_page, Page)
self.assertTrue(hasattr(front_page, 'url'))
self.assertTrue(hasattr(front_page, 'title'))
# create_front_page()
def test_edit_front_page(self, m):
register_uris({'course': ['edit_front_page']}, m)
new_front_page = self.course.edit_front_page()
self.assertIsInstance(new_front_page, Page)
self.assertTrue(hasattr(new_front_page, 'url'))
self.assertTrue(hasattr(new_front_page, 'title'))
# get_page()
def test_get_page(self, m):
register_uris({'course': ['get_page']}, m)
url = 'my-url'
page = self.course.get_page(url)
self.assertIsInstance(page, Page)
# get_pages()
def test_get_pages(self, m):
register_uris({'course': ['get_pages', 'get_pages2']}, m)
pages = self.course.get_pages()
page_list = [page for page in pages]
self.assertEqual(len(page_list), 4)
self.assertIsInstance(page_list[0], Page)
self.assertTrue(hasattr(page_list[0], 'course_id'))
self.assertEqual(page_list[0].course_id, self.course.id)
# create_page()
def test_create_page(self, m):
register_uris({'course': ['create_page']}, m)
title = "Newest Page"
new_page = self.course.create_page(wiki_page={'title': title})
self.assertIsInstance(new_page, Page)
self.assertTrue(hasattr(new_page, 'title'))
self.assertEqual(new_page.title, title)
self.assertTrue(hasattr(new_page, 'course_id'))
self.assertEqual(new_page.course_id, self.course.id)
def test_create_page_fail(self, m):
with self.assertRaises(RequiredFieldMissing):
self.course.create_page(settings.INVALID_ID)
# get_external_tool()
def test_get_external_tool(self, m):
register_uris({'external_tool': ['get_by_id_course']}, m)
tool_by_id = self.course.get_external_tool(1)
self.assertIsInstance(tool_by_id, ExternalTool)
self.assertTrue(hasattr(tool_by_id, 'name'))
tool_by_obj = self.course.get_external_tool(tool_by_id)
self.assertIsInstance(tool_by_obj, ExternalTool)
self.assertTrue(hasattr(tool_by_obj, 'name'))
# get_external_tools()
def test_get_external_tools(self, m):
requires = {'course': ['get_external_tools', 'get_external_tools_p2']}
register_uris(requires, m)
tools = self.course.get_external_tools()
tool_list = [tool for tool in tools]
self.assertIsInstance(tool_list[0], ExternalTool)
self.assertEqual(len(tool_list), 4)
def test_list_sections(self, m):
register_uris({'course': ['list_sections', 'list_sections2']}, m)
sections = self.course.list_sections()
section_list = [sect for sect in sections]
self.assertIsInstance(section_list[0], Section)
self.assertEqual(len(section_list), 4)
def test_create_course_section(self, m):
register_uris({'course': ['create_section']}, m)
section = self.course.create_course_section()
self.assertIsInstance(section, Section)
def test_list_groups(self, m):
requires = {'course': ['list_groups_context', 'list_groups_context2']}
register_uris(requires, m)
groups = self.course.list_groups()
group_list = [group for group in groups]
self.assertIsInstance(group_list[0], Group)
self.assertEqual(len(group_list), 4)
# create_group_category()
def test_create_group_category(self, m):
register_uris({'course': ['create_group_category']}, m)
name_str = "Test String"
response = self.course.create_group_category(name=name_str)
self.assertIsInstance(response, GroupCategory)
# list_group_categories()
def test_list_group_categories(self, m):
register_uris({'course': ['list_group_categories']}, m)
response = self.course.list_group_categories()
category_list = [category for category in response]
self.assertIsInstance(category_list[0], GroupCategory)
# get_discussion_topic()
def test_get_discussion_topic(self, m):
register_uris({'course': ['get_discussion_topic']}, m)
topic_id = 1
discussion_by_id = self.course.get_discussion_topic(topic_id)
self.assertIsInstance(discussion_by_id, DiscussionTopic)
self.assertTrue(hasattr(discussion_by_id, 'course_id'))
self.assertEqual(discussion_by_id.course_id, 1)
discussion_by_obj = self.course.get_discussion_topic(discussion_by_id)
self.assertIsInstance(discussion_by_obj, DiscussionTopic)
self.assertTrue(hasattr(discussion_by_obj, 'course_id'))
self.assertEqual(discussion_by_obj.course_id, 1)
# get_file()
def test_get_file(self, m):
register_uris({'course': ['get_file']}, m)
file_by_id = self.course.get_file(1)
self.assertIsInstance(file_by_id, File)
self.assertEqual(file_by_id.display_name, 'Course_File.docx')
self.assertEqual(file_by_id.size, 2048)
file_by_obj = self.course.get_file(file_by_id)
self.assertIsInstance(file_by_obj, File)
self.assertEqual(file_by_obj.display_name, 'Course_File.docx')
self.assertEqual(file_by_obj.size, 2048)
# get_full_discussion_topic()
def test_get_full_discussion_topic(self, m):
register_uris(
{'course': ['get_discussion_topics', 'get_full_discussion_topic']},
m)
topic_id = 1
discussion_by_id = self.course.get_full_discussion_topic(topic_id)
self.assertIsInstance(discussion_by_id, dict)
self.assertIn('view', discussion_by_id)
self.assertIn('participants', discussion_by_id)
self.assertIn('id', discussion_by_id)
self.assertEqual(discussion_by_id['id'], topic_id)
discussion_topics = self.course.get_discussion_topics()
discussion_by_obj = self.course.get_full_discussion_topic(
discussion_topics[0])
self.assertIsInstance(discussion_by_obj, dict)
self.assertIn('view', discussion_by_obj)
self.assertIn('participants', discussion_by_obj)
self.assertIn('id', discussion_by_obj)
self.assertEqual(discussion_by_obj['id'], topic_id)
# get_discussion_topics()
def test_get_discussion_topics(self, m):
register_uris({'course': ['get_discussion_topics']}, m)
response = self.course.get_discussion_topics()
discussion_list = [discussion for discussion in response]
self.assertIsInstance(discussion_list[0], DiscussionTopic)
self.assertTrue(hasattr(discussion_list[0], 'course_id'))
self.assertEqual(2, len(discussion_list))
# create_discussion_topic()
def test_create_discussion_topic(self, m):
register_uris({'course': ['create_discussion_topic']}, m)
title = "Topic 1"
discussion = self.course.create_discussion_topic()
self.assertIsInstance(discussion, DiscussionTopic)
self.assertTrue(hasattr(discussion, 'course_id'))
self.assertEqual(title, discussion.title)
self.assertEqual(discussion.course_id, 1)
# reorder_pinned_topics()
def test_reorder_pinned_topics(self, m):
# Custom matcher to test that params are set correctly
def custom_matcher(request):
match_text = '1,2,3'
if request.text == 'order={}'.format(quote(match_text)):
resp = requests.Response()
resp._content = b'{"reorder": true, "order": [1, 2, 3]}'
resp.status_code = 200
return resp
m.add_matcher(custom_matcher)
order = [1, 2, 3]
discussions = self.course.reorder_pinned_topics(order=order)
self.assertTrue(discussions)
def test_reorder_pinned_topics_tuple(self, m):
register_uris({'course': ['reorder_pinned_topics']}, m)
order = (1, 2, 3)
discussions = self.course.reorder_pinned_topics(order=order)
self.assertTrue(discussions)
def test_reorder_pinned_topics_comma_separated_string(self, m):
register_uris({'course': ['reorder_pinned_topics']}, m)
order = "1,2,3"
discussions = self.course.reorder_pinned_topics(order=order)
self.assertTrue(discussions)
def test_reorder_pinned_topics_invalid_input(self, m):
order = "invalid string"
with self.assertRaises(ValueError):
self.course.reorder_pinned_topics(order=order)
# get_assignment_group()
def test_get_assignment_group(self, m):
register_uris({'assignment': ['get_assignment_group']}, m)
assignment_group_by_id = self.course.get_assignment_group(5)
self.assertIsInstance(assignment_group_by_id, AssignmentGroup)
self.assertTrue(hasattr(assignment_group_by_id, 'id'))
self.assertTrue(hasattr(assignment_group_by_id, 'name'))
self.assertTrue(hasattr(assignment_group_by_id, 'course_id'))
self.assertEqual(assignment_group_by_id.course_id, 1)
assignment_group_by_obj = self.course.get_assignment_group(
assignment_group_by_id)
self.assertIsInstance(assignment_group_by_obj, AssignmentGroup)
self.assertTrue(hasattr(assignment_group_by_obj, 'id'))
self.assertTrue(hasattr(assignment_group_by_obj, 'name'))
self.assertTrue(hasattr(assignment_group_by_obj, 'course_id'))
self.assertEqual(assignment_group_by_obj.course_id, 1)
# list_group_categories()
def test_list_assignment_groups(self, m):
register_uris(
{'assignment': ['list_assignment_groups', 'get_assignment_group']},
m)
response = self.course.list_assignment_groups()
asnt_group_list = [assignment_group for assignment_group in response]
self.assertIsInstance(asnt_group_list[0], AssignmentGroup)
self.assertTrue(hasattr(asnt_group_list[0], 'id'))
self.assertTrue(hasattr(asnt_group_list[0], 'name'))
self.assertTrue(hasattr(asnt_group_list[0], 'course_id'))
self.assertEqual(asnt_group_list[0].course_id, 1)
# create_assignment_group()
def test_create_assignment_group(self, m):
register_uris({'assignment': ['create_assignment_group']}, m)
response = self.course.create_assignment_group()
self.assertIsInstance(response, AssignmentGroup)
self.assertTrue(hasattr(response, 'id'))
self.assertEqual(response.id, 3)
# create_external_tool()
def test_create_external_tool(self, m):
register_uris({'external_tool': ['create_tool_course']}, m)
response = self.course.create_external_tool(
name="External Tool - Course",
privacy_level="public",
consumer_key="key",
shared_secret="secret")
self.assertIsInstance(response, ExternalTool)
self.assertTrue(hasattr(response, 'id'))
self.assertEqual(response.id, 20)
# get_course_level_participation_data()
def test_get_course_level_participation_data(self, m):
register_uris({'course': ['get_course_level_participation_data']}, m)
response = self.course.get_course_level_participation_data()
self.assertIsInstance(response, list)
# get_course_level_assignment_data()
def test_get_course_level_assignment_data(self, m):
register_uris({'course': ['get_course_level_assignment_data']}, m)
response = self.course.get_course_level_assignment_data()
self.assertIsInstance(response, list)
# get_course_level_student_summary_data()
def test_get_course_level_student_summary_data(self, m):
register_uris({'course': ['get_course_level_student_summary_data']}, m)
response = self.course.get_course_level_student_summary_data()
self.assertIsInstance(response, list)
# get_user_in_a_course_level_participation_data()
def test_get_user_in_a_course_level_participation_data(self, m):
register_uris(
{'course': ['get_user_in_a_course_level_participation_data']}, m)
response = self.course.get_user_in_a_course_level_participation_data(1)
self.assertIsInstance(response, list)
response = self.course.get_user_in_a_course_level_participation_data(
self.user)
self.assertIsInstance(response, list)
# get_user_in_a_course_level_assignment_data()
def test_get_user_in_a_course_level_assignment_data(self, m):
register_uris(
{'course': ['get_user_in_a_course_level_assignment_data']}, m)
response = self.course.get_user_in_a_course_level_assignment_data(1)
self.assertIsInstance(response, list)
response = self.course.get_user_in_a_course_level_assignment_data(
self.user)
self.assertIsInstance(response, list)
# get_user_in_a_course_level_messaging_data()
def test_get_user_in_a_course_level_messaging_data(self, m):
register_uris(
{'course': ['get_user_in_a_course_level_messaging_data']}, m)
response = self.course.get_user_in_a_course_level_messaging_data(1)
self.assertIsInstance(response, list)
response = self.course.get_user_in_a_course_level_messaging_data(
self.user)
self.assertIsInstance(response, list)
# submit_assignment()
def test_submit_assignment(self, m):
register_uris({'course': ['submit_assignment', 'submit_assignment_2']},
m)
assignment_id = 1
sub_type = "online_upload"
sub_dict = {'submission_type': sub_type}
submission_by_id = self.course.submit_assignment(
assignment_id, sub_dict)
self.assertIsInstance(submission_by_id, Submission)
self.assertTrue(hasattr(submission_by_id, 'submission_type'))
self.assertEqual(submission_by_id.submission_type, sub_type)
submission_by_obj = self.course.submit_assignment(
self.assignment, sub_dict)
self.assertIsInstance(submission_by_obj, Submission)
self.assertTrue(hasattr(submission_by_obj, 'submission_type'))
self.assertEqual(submission_by_obj.submission_type, sub_type)
def test_subit_assignment_fail(self, m):
with self.assertRaises(RequiredFieldMissing):
self.course.submit_assignment(1, {})
# list_submissions()
def test_list_submissions(self, m):
register_uris({'course': ['list_submissions', 'list_submissions_2']},
m)
assignment_id = 1
submissions_by_id = self.course.list_submissions(assignment_id)
submission_list_by_id = [
submission for submission in submissions_by_id
]
self.assertEqual(len(submission_list_by_id), 2)
self.assertIsInstance(submission_list_by_id[0], Submission)
submissions_by_obj = self.course.list_submissions(self.assignment)
submission_list_by_obj = [
submission for submission in submissions_by_obj
]
self.assertEqual(len(submission_list_by_obj), 2)
self.assertIsInstance(submission_list_by_obj[0], Submission)
# list_multiple_submission()
def test_list_multiple_submissions(self, m):
register_uris({'course': ['list_multiple_submissions']}, m)
submissions = self.course.list_multiple_submissions()
submission_list = [submission for submission in submissions]
self.assertEqual(len(submission_list), 2)
self.assertIsInstance(submission_list[0], Submission)
def test_list_multiple_submissions_grouped_param(self, m):
register_uris({'course': ['list_multiple_submissions']}, m)
with warnings.catch_warnings(record=True) as warning_list:
warnings.simplefilter('always')
submissions = self.course.list_multiple_submissions(grouped=True)
submission_list = [submission for submission in submissions]
# Ensure using the `grouped` param raises a warning
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, UserWarning)
self.assertEqual(
text_type(warning_list[-1].message),
'The `grouped` parameter must be empty. Removing kwarg `grouped`.'
)
self.assertEqual(len(submission_list), 2)
self.assertIsInstance(submission_list[0], Submission)
# get_submission()
def test_get_submission(self, m):
register_uris({'course': ['get_assignment_by_id_2', 'get_submission']},
m)
assignment_for_id = 1
user_id = 1
submission_by_id = self.course.get_submission(assignment_for_id,
user_id)
self.assertIsInstance(submission_by_id, Submission)
self.assertTrue(hasattr(submission_by_id, 'submission_type'))
assignment_for_obj = self.course.get_assignment(1)
submission_by_obj = self.course.get_submission(assignment_for_obj,
self.user)
self.assertIsInstance(submission_by_obj, Submission)
self.assertTrue(hasattr(submission_by_obj, 'submission_type'))
# update_submission()
def test_update_submission(self, m):
register_uris(
{
'course': [
'get_assignment_by_id_2', 'update_submission',
'get_submission'
]
}, m)
assignment_for_id = 1
user_id = 1
submission = self.course.update_submission(assignment_for_id,
user_id,
submission={'excuse': True})
self.assertIsInstance(submission, Submission)
self.assertTrue(hasattr(submission, 'excused'))
assignment_for_obj = self.course.get_assignment(1)
submission = self.course.update_submission(assignment_for_obj,
self.user,
submission={'excuse': True})
self.assertIsInstance(submission, Submission)
self.assertTrue(hasattr(submission, 'excused'))
# list_gradeable_students()
def test_list_gradeable_students(self, m):
register_uris(
{'course': ['get_assignment_by_id_2', 'list_gradeable_students']},
m)
assignment_for_id = 1
students_by_id = self.course.list_gradeable_students(assignment_for_id)
student_list_by_id = [student for student in students_by_id]
self.assertEqual(len(student_list_by_id), 2)
self.assertIsInstance(student_list_by_id[0], UserDisplay)
assignment_for_obj = self.course.get_assignment(1)
students_by_id = self.course.list_gradeable_students(
assignment_for_obj)
student_list_by_id = [student for student in students_by_id]
self.assertEqual(len(student_list_by_id), 2)
self.assertIsInstance(student_list_by_id[0], UserDisplay)
# mark_submission_as_read
def test_mark_submission_as_read(self, m):
register_uris(
{'course': ['get_assignment_by_id_2', 'mark_submission_as_read']},
m)
assignment_for_id = 1
user_for_id = 1
submission_by_id = self.course.mark_submission_as_read(
assignment_for_id, user_for_id)
self.assertTrue(submission_by_id)
assignment_for_obj = self.course.get_assignment(1)
submission_by_obj = self.course.mark_submission_as_read(
assignment_for_obj, self.user)
self.assertTrue(submission_by_obj)
# mark_submission_as_unread
def test_mark_submission_as_unread(self, m):
register_uris(
{
'course':
['get_assignment_by_id_2', 'mark_submission_as_unread']
}, m)
assignment_for_id = 1
user_for_id = 1
submission_by_id = self.course.mark_submission_as_unread(
assignment_for_id, user_for_id)
self.assertTrue(submission_by_id)
assignment_for_obj = self.course.get_assignment(1)
submission_by_obj = self.course.mark_submission_as_unread(
assignment_for_obj, self.user)
self.assertTrue(submission_by_obj)
# list_external_feeds()
def test_list_external_feeds(self, m):
register_uris({'course': ['list_external_feeds']}, m)
feeds = self.course.list_external_feeds()
feed_list = [feed for feed in feeds]
self.assertEqual(len(feed_list), 2)
self.assertTrue(hasattr(feed_list[0], 'url'))
self.assertIsInstance(feed_list[0], ExternalFeed)
# create_external_feed()
def test_create_external_feed(self, m):
register_uris({'course': ['create_external_feed']}, m)
url_str = "http://example.com/myblog.rss"
response = self.course.create_external_feed(url=url_str)
self.assertIsInstance(response, ExternalFeed)
# delete_external_feed()
def test_delete_external_feed(self, m):
register_uris({'course': ['delete_external_feed']}, m)
ef_id = 1
deleted_ef_by_id = self.course.delete_external_feed(ef_id)
self.assertIsInstance(deleted_ef_by_id, ExternalFeed)
self.assertTrue(hasattr(deleted_ef_by_id, 'url'))
self.assertEqual(deleted_ef_by_id.display_name, "My Blog")
deleted_ef_by_obj = self.course.delete_external_feed(deleted_ef_by_id)
self.assertIsInstance(deleted_ef_by_obj, ExternalFeed)
self.assertTrue(hasattr(deleted_ef_by_obj, 'url'))
self.assertEqual(deleted_ef_by_obj.display_name, "My Blog")
# list_files()
def test_course_files(self, m):
register_uris({'course': ['list_course_files', 'list_course_files2']},
m)
files = self.course.list_files()
file_list = [file for file in files]
self.assertEqual(len(file_list), 4)
self.assertIsInstance(file_list[0], File)
# get_folder()
def test_get_folder(self, m):
register_uris({'course': ['get_folder']}, m)
folder_by_id = self.course.get_folder(1)
self.assertEqual(folder_by_id.name, "Folder 1")
self.assertIsInstance(folder_by_id, Folder)
folder_by_obj = self.course.get_folder(folder_by_id)
self.assertEqual(folder_by_obj.name, "Folder 1")
self.assertIsInstance(folder_by_obj, Folder)
# list_folders()
def test_list_folders(self, m):
register_uris({'course': ['list_folders']}, m)
folders = self.course.list_folders()
folder_list = [folder for folder in folders]
self.assertEqual(len(folder_list), 2)
self.assertIsInstance(folder_list[0], Folder)
# create_folder()
def test_create_folder(self, m):
register_uris({'course': ['create_folder']}, m)
name_str = "Test String"
response = self.course.create_folder(name=name_str)
self.assertIsInstance(response, Folder)
# list_tabs()
def test_list_tabs(self, m):
register_uris({'course': ['list_tabs']}, m)
tabs = self.course.list_tabs()
tab_list = [tab for tab in tabs]
self.assertEqual(len(tab_list), 2)
self.assertIsInstance(tab_list[0], Tab)
# update_tab()
def test_update_tab(self, m):
register_uris({'course': ['update_tab']}, m)
tab_id = "pages"
new_position = 3
tab = self.course.update_tab(tab_id, position=new_position)
self.assertIsInstance(tab, Tab)
self.assertEqual(tab.position, 3)
# get_rubric
def test_get_rubric(self, m):
register_uris({'course': ['get_rubric_single']}, m)
rubric_id = 1
rubric = self.course.get_rubric(rubric_id)
self.assertIsInstance(rubric, Rubric)
self.assertEqual(rubric.id, rubric_id)
self.assertEqual(rubric.title, "Course Rubric 1")
# list_rubrics
def test_list_rubrics(self, m):
register_uris({'course': ['get_rubric_multiple']}, m)
rubrics = self.course.list_rubrics()
self.assertEqual(len(list(rubrics)), 2)
self.assertIsInstance(rubrics[0], Rubric)
self.assertEqual(rubrics[0].id, 1)
self.assertEqual(rubrics[0].title, "Course Rubric 1")
self.assertIsInstance(rubrics[1], Rubric)
self.assertEqual(rubrics[1].id, 2)
self.assertEqual(rubrics[1].title, "Course Rubric 2")
# get_root_outcome_group()
def test_get_root_outcome_group(self, m):
register_uris({'outcome': ['course_root_outcome_group']}, m)
outcome_group = self.course.get_root_outcome_group()
self.assertIsInstance(outcome_group, OutcomeGroup)
self.assertEqual(outcome_group.id, 1)
self.assertEqual(outcome_group.title, "ROOT")
# get_outcome_group()
def test_get_outcome_group(self, m):
register_uris({'outcome': ['course_get_outcome_group']}, m)
outcome_group_by_id = self.course.get_outcome_group(1)
self.assertIsInstance(outcome_group_by_id, OutcomeGroup)
self.assertEqual(outcome_group_by_id.id, 1)
self.assertEqual(outcome_group_by_id.title,
"Course outcome group title")
outcome_group_by_obj = self.course.get_outcome_group(
outcome_group_by_id)
self.assertIsInstance(outcome_group_by_obj, OutcomeGroup)
self.assertEqual(outcome_group_by_obj.id, 1)
self.assertEqual(outcome_group_by_obj.title,
"Course outcome group title")
# get_outcome_groups_in_context()
def test_get_outcome_groups_in_context(self, m):
register_uris({'outcome': ['course_outcome_groups_in_context']}, m)
outcome_group_list = self.course.get_outcome_groups_in_context()
self.assertIsInstance(outcome_group_list[0], OutcomeGroup)
self.assertEqual(outcome_group_list[0].id, 1)
self.assertEqual(outcome_group_list[0].title, "ROOT")
# get_all_outcome_links_in_context()
def test_get_outcome_links_in_context(self, m):
register_uris({'outcome': ['course_outcome_links_in_context']}, m)
outcome_link_list = self.course.get_all_outcome_links_in_context()
self.assertIsInstance(outcome_link_list[0], OutcomeLink)
self.assertEqual(outcome_link_list[0].outcome_group['id'], 2)
self.assertEqual(outcome_link_list[0].outcome_group['title'],
"test outcome")
# get_outcome_results()
def test_get_outcome_results(self, m):
register_uris({'outcome': ['course_get_outcome_results']}, m)
result = self.course.get_outcome_results()
self.assertIsInstance(result, dict)
self.assertIsInstance(result['outcome_results'], list)
# get_outcome_result_rollups()
def test_get_outcome_result_rollups(self, m):
register_uris({'outcome': ['course_get_outcome_result_rollups']}, m)
result = self.course.get_outcome_result_rollups()
self.assertIsInstance(result, dict)
self.assertIsInstance(result['rollups'], list)
# add_grading_standards()
def test_add_grading_standards(self, m):
register_uris({'course': ['add_grading_standards']}, m)
title = "Grading Standard 1"
grading_scheme = []
grading_scheme.append({"name": "A", "value": 90})
grading_scheme.append({"name": "B", "value": 80})
grading_scheme.append({"name": "C", "value": 70})
response = self.course.add_grading_standards(title, grading_scheme)
self.assertIsInstance(response, GradingStandard)
self.assertTrue(hasattr(response, 'title'))
self.assertEqual(title, response.title)
self.assertTrue(hasattr(response, "grading_scheme"))
self.assertEqual(response.grading_scheme[0].get('name'), "A")
self.assertEqual(response.grading_scheme[0].get('value'), 0.9)
# add_grading_standards()
def test_add_grading_standards_empty_list(self, m):
register_uris({'course': ['add_grading_standards']}, m)
with self.assertRaises(ValueError):
self.course.add_grading_standards("title", [])
def test_add_grading_standards_non_dict_list(self, m):
register_uris({'course': ['add_grading_standards']}, m)
with self.assertRaises(ValueError):
self.course.add_grading_standards("title", [1, 2, 3])
def test_add_grading_standards_missing_value_key(self, m):
register_uris({'course': ['add_grading_standards']}, m)
with self.assertRaises(ValueError):
self.course.add_grading_standards("title", [{'name': "test"}])
def test_add_grading_standards_missing_name_key(self, m):
register_uris({'course': ['add_grading_standards']}, m)
with self.assertRaises(ValueError):
self.course.add_grading_standards("title", [{'value': 2}])
# get_grading_standards()
def test_get_grading_standards(self, m):
register_uris({'course': ['get_grading_standards']}, m)
standards = self.course.get_grading_standards()
standard_list = [standard for standard in standards]
self.assertEqual(len(standard_list), 2)
self.assertIsInstance(standard_list[0], GradingStandard)
self.assertIsInstance(standard_list[1], GradingStandard)
# get_single_grading_standards()
def test_get_single_grading_standard(self, m):
register_uris({'course': ['get_single_grading_standard']}, m)
response = self.course.get_single_grading_standard(1)
self.assertIsInstance(response, GradingStandard)
self.assertTrue(hasattr(response, 'id'))
self.assertEqual(1, response.id)
self.assertTrue(hasattr(response, 'title'))
self.assertEqual("Grading Standard 1", response.title)
self.assertTrue(hasattr(response, "grading_scheme"))
self.assertEqual(response.grading_scheme[0].get('name'), "A")
self.assertEqual(response.grading_scheme[0].get('value'), 0.9)
def get_canvas_course():
url, api_key, course_id = canvas_configs()
canvas = Canvas(url, api_key)
return canvas.get_course(course_id)
new_lines.append(code_line.replace("utils.", ""))
nb_json["cells"][i]["source"] = new_lines
if submit_file.exists():
print("deleting")
submit_file.unlink()
with open(submit_file, "w") as f:
json.dump(nb_json, f)
if __name__ == "__main__":
url = os.getenv("CANVAS_URL")
token = os.getenv("CANVAS_TOKEN")
course_id = 33395
canvas = Canvas(url, token)
course = canvas.get_course(course_id)
write_submit_file()
if True:
assignment = course.get_assignment(357291)
submission = assignment.submit(
dict(submission_type="online_upload", ),
file=submit_file,
comment=dict(text_comment="Submittting notebook."),
)
class TestFolder(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
register_uris({"folder": ["get_by_id"]}, m)
self.folder = self.canvas.get_folder(1)
# __str__()
def test__str__(self, m):
string = str(self.folder)
self.assertIsInstance(string, str)
# get_files()
def test_get_files(self, m):
register_uris({"folder": ["list_folder_files", "list_folder_files2"]}, m)
files = self.folder.get_files()
file_list = [file for file in files]
self.assertEqual(len(file_list), 4)
self.assertIsInstance(file_list[0], File)
# delete()
def test_delete_file(self, m):
register_uris({"folder": ["delete_folder"]}, m)
deleted_folder = self.folder.delete()
self.assertIsInstance(deleted_folder, Folder)
self.assertTrue(hasattr(deleted_folder, "name"))
self.assertEqual(deleted_folder.full_name, "course_files/Folder 1")
# get_folders()
def test_get_folders(self, m):
register_uris({"folder": ["list_folders"]}, m)
folders = self.folder.get_folders()
folder_list = [folder for folder in folders]
self.assertEqual(len(folder_list), 2)
self.assertIsInstance(folder_list[0], Folder)
# create_folder()
def test_create_folder(self, m):
register_uris({"folder": ["create_folder"]}, m)
name_str = "Test String"
response = self.folder.create_folder(name=name_str)
self.assertIsInstance(response, Folder)
# upload()
def test_upload(self, m):
register_uris({"folder": ["upload", "upload_final"]}, m)
filename = "testfile_course_{}".format(uuid.uuid4().hex)
try:
with open(filename, "w+") as file:
response = self.folder.upload(file)
self.assertTrue(response[0])
self.assertIsInstance(response[1], dict)
self.assertIn("url", response[1])
finally:
cleanup_file(filename)
# update()
def test_update(self, m):
register_uris({"folder": ["update"]}, m)
new_name = "New Name"
response = self.folder.update(name=new_name)
self.assertIsInstance(response, Folder)
self.assertEqual(self.folder.name, new_name)
# copy_file()
def test_copy_file(self, m):
register_uris({"folder": ["copy_file"]}, m)
new_file = self.folder.copy_file(1)
self.assertIsInstance(new_file, File)
self.assertEqual(new_file.display_name, "Dummy File-1")
self.assertEqual(new_file.id, 1)
class TestAssignment(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
register_uris({'course': ['get_by_id', 'get_assignment_by_id']}, m)
self.course = self.canvas.get_course(1)
self.assignment = self.course.get_assignment(1)
# create_override()
def test_create_override(self, m):
register_uris({'assignment': ['create_override']}, m)
override = self.assignment.create_override(
assignment_override={
'student_ids': [1, 2, 3],
'title': 'New Assignment Override'
}
)
self.assertIsInstance(override, AssignmentOverride)
self.assertEqual(override.title, 'New Assignment Override')
# delete()
def test_delete_assignments(self, m):
register_uris({'assignment': ['delete_assignment']}, m)
deleted_assignment = self.assignment.delete()
self.assertIsInstance(deleted_assignment, Assignment)
# edit()
def test_edit_assignment(self, m):
register_uris({'assignment': ['edit_assignment']}, m)
name = 'New Name'
edited_assignment = self.assignment.edit(assignment={'name': name})
self.assertIsInstance(edited_assignment, Assignment)
self.assertTrue(hasattr(edited_assignment, 'name'))
self.assertEqual(edited_assignment.name, name)
# get_gradeable_students()
def test_get_gradeable_students(self, m):
register_uris({'course': ['list_gradeable_students']}, m)
students = self.assignment.get_gradeable_students()
student_list = [student for student in students]
self.assertEqual(len(student_list), 2)
self.assertIsInstance(student_list[0], UserDisplay)
# get_override()
def test_get_override(self, m):
register_uris({'assignment': ['get_assignment_override']}, m)
override = self.assignment.get_override(1)
self.assertIsInstance(override, AssignmentOverride)
# get_overrides()
def test_get_overrides(self, m):
register_uris({'assignment': [
'list_assignment_overrides',
'list_assignment_overrides_p2'
]}, m)
overrides = self.assignment.get_overrides()
override_list = [override for override in overrides]
self.assertEqual(len(override_list), 4)
self.assertIsInstance(override_list[0], AssignmentOverride)
self.assertIsInstance(override_list[3], AssignmentOverride)
# get_submission()
def test_get_submission(self, m):
register_uris({
'submission': ['get_by_id_course'],
'user': ['get_by_id']
}, m)
user_id = 1
submission_by_id = self.assignment.get_submission(user_id)
self.assertIsInstance(submission_by_id, Submission)
self.assertTrue(hasattr(submission_by_id, 'submission_type'))
user = self.canvas.get_user(user_id)
submission_by_obj = self.assignment.get_submission(user)
self.assertIsInstance(submission_by_obj, Submission)
self.assertTrue(hasattr(submission_by_obj, 'submission_type'))
# get_submissions()
def test_get_submissions(self, m):
register_uris({'submission': ['list_submissions']}, m)
submissions = self.assignment.get_submissions()
submission_list_by_id = [submission for submission in submissions]
self.assertEqual(len(submission_list_by_id), 2)
self.assertIsInstance(submission_list_by_id[0], Submission)
# submit()
def test_submit(self, m):
register_uris({'assignment': ['submit']}, m)
sub_type = "online_upload"
sub_dict = {'submission_type': sub_type}
submission = self.assignment.submit(sub_dict)
self.assertIsInstance(submission, Submission)
self.assertTrue(hasattr(submission, 'submission_type'))
self.assertEqual(submission.submission_type, sub_type)
def test_submit_fail(self, m):
with self.assertRaises(RequiredFieldMissing):
self.assignment.submit({})
def test_submit_file(self, m):
register_uris({'assignment': ['submit', 'upload', 'upload_final']}, m)
filename = 'testfile_assignment_{}'.format(uuid.uuid4().hex)
try:
with open(filename, 'w+') as file:
sub_type = "online_upload"
sub_dict = {'submission_type': sub_type}
submission = self.assignment.submit(sub_dict, file)
self.assertIsInstance(submission, Submission)
self.assertTrue(hasattr(submission, 'submission_type'))
self.assertEqual(submission.submission_type, sub_type)
finally:
cleanup_file(filename)
def test_submit_file_wrong_type(self, m):
filename = 'testfile_assignment_{}'.format(uuid.uuid4().hex)
sub_type = "online_text_entry"
sub_dict = {'submission_type': sub_type}
with self.assertRaises(ValueError):
self.assignment.submit(sub_dict, filename)
def test_submit_file_upload_failure(self, m):
register_uris({'assignment': ['submit', 'upload', 'upload_fail']}, m)
filename = 'testfile_assignment_{}'.format(uuid.uuid4().hex)
try:
with open(filename, 'w+') as file:
sub_type = "online_upload"
sub_dict = {'submission_type': sub_type}
with self.assertRaises(CanvasException):
self.assignment.submit(sub_dict, file)
finally:
cleanup_file(filename)
# __str__()
def test__str__(self, m):
string = str(self.assignment)
self.assertIsInstance(string, str)
# submissions_bulk_update()
def test_submissions_bulk_update(self, m):
register_uris({'assignment': ['update_submissions']}, m)
register_uris({'progress': ['course_progress']}, m)
progress = self.assignment.submissions_bulk_update(grade_data={
'1': {
'posted_grade': 97
},
'2': {
'posted_grade': 98
}
})
self.assertIsInstance(progress, Progress)
self.assertTrue(progress.context_type == "Course")
progress = progress.query()
self.assertTrue(progress.context_type == "Course")
# upload_to_submission()
def test_upload_to_submission_self(self, m):
register_uris({'assignment': ['upload', 'upload_final']}, m)
filename = 'testfile_assignment_{}'.format(uuid.uuid4().hex)
try:
with open(filename, 'w+') as file:
response = self.assignment.upload_to_submission(file)
self.assertTrue(response[0])
self.assertIsInstance(response[1], dict)
self.assertIn('url', response[1])
finally:
cleanup_file(filename)
def test_upload_to_submission_user(self, m):
register_uris({'assignment': ['upload_by_id', 'upload_final']}, m)
filename = 'testfile_assignment_{}'.format(uuid.uuid4().hex)
user_id = 1
try:
with open(filename, 'w+') as file:
response = self.assignment.upload_to_submission(file, user_id)
self.assertTrue(response[0])
self.assertIsInstance(response[1], dict)
self.assertIn('url', response[1])
finally:
cleanup_file(filename)
def disable_course_shopping(inputfile, outputfile):
# once the enabled script has been tested , just copy n paste...
# REMEBER TO FILL IN ANY BLANKS FOR THE COURSE_ID/NOTES!!!
# sub accounts that have opt-ed out these should be filtered out before
# running the script MEHP 132097 132098 132100 132099 PSOM 99242
# SUB_ACCOUNTS = [132097, 132098, 132100, 132099, 99242] # you should remove
# these before running the script -- but i'll code it anyways just in
# case...
canvas = Canvas(API_URL, API_KEY)
my_path = os.path.dirname(os.path.abspath(sys.argv[0]))
file_path = os.path.join(my_path, "ACP/data", inputfile)
dataFile = open(file_path, "r")
dataFile.readline() # THIS SKIPS THE FIRST LINE
outFile = open(os.path.join(my_path, "ACP/data", outputfile), "w+")
outFile.write("sis_id, canvas_id, visibility_status, published, notes\n")
total = 692 # HARDCODED !!!
counter = 0
for line in dataFile:
counter += 1
if counter % 25 == 0:
print("%s/%s done" % (counter, total))
# sis_id canvas_id visibility_status published
# print(line)
canvas_id, sis_id, status = line.replace("\n", "").split(",")
notes = ""
try:
canvas_course = canvas.get_course(canvas_id)
published = status
except:
notes = "couldnt find course"
published = "ERROR"
# if int(account_id) in SUB_ACCOUNTS: # then we should not update this
# site!!!! notes += "/ subaccount opt out" outFile.write("%s, %s,
# %s, %s, %s\n" % (sis_id, canvas_id, status, published, notes))
# else: # lets update this site babie
try:
# print('\t',visibility_status, visibility_status=='public_to_auth_users')
# if visibility_status == ' public_to_auth_users' or
# visibility_status='public_to_auth_users':
canvas_course.update(
course={
"is_public": False,
"is_public_to_auth_users": False,
"public_syllabus": False,
"public_syllabus_to_auth": False,
}
)
status = "to_enrolled_users" # change this please
# else:
# print("not updating %s course" % sis_id)
# status = visibility_status
except:
status = "ERROR"
print(sis_id, canvas_id, status, published, notes)
outFile.write(
"%s, %s, %s, %s, %s\n" % (sis_id, canvas_id, status, published, notes)
)
def enable_course_shopping(inputfile, outputfile="2020C_courses_shopping_enabled.csv"):
# REMEBER TO FILL IN ANY BLANKS FOR THE COURSE_ID!!!
# sub accounts that have opt-ed IN
canvas = Canvas(API_URL, API_KEY)
# sub Accounts to ignore
SAS_ONL_ACCOUNT = 132413
ADMIN_ACCOUNT = 131963
# WHARTON_ACCOUNT_ID = 81471
# WHARTON_ACCOUNTS = find_accounts_subaccounts(WHARTON_ACCOUNT_ID)
SAS_ACCOUNT_ID = 99237
SAS_ACCOUNTS = find_accounts_subaccounts(SAS_ACCOUNT_ID)
SAS_ACCOUNTS.remove(SAS_ONL_ACCOUNT)
SAS_ACCOUNTS.remove(ADMIN_ACCOUNT)
SEAS_ACCOUNT_ID = 99238
SEAS_ACCOUNTS = find_accounts_subaccounts(SEAS_ACCOUNT_ID)
NURS_ACCOUNT_ID = 99239
NURS_ACCOUNTS = find_accounts_subaccounts(NURS_ACCOUNT_ID)
AN_ACCOUNT_ID = 99243
AN_ACCOUNTS = find_accounts_subaccounts(AN_ACCOUNT_ID)
SUB_ACCOUNTS = (
SAS_ACCOUNTS + SEAS_ACCOUNTS + NURS_ACCOUNTS + AN_ACCOUNTS
) # WHARTON_ACCOUNTS +
print(SUB_ACCOUNTS)
# SUBJECTS TO IGNORE
SUBJ_TO_IGNORE = ["MAPP", "IMPA", "DYNM"]
# INDIVIDUAL SITES TO IGNORE
SINGLE_SITES_TO_IGNORE = ["1529220"]
# canvas = Canvas("https://upenn.beta.instructure.com",
# "25~SEUFg2kAnCcarRFHAKTH1H7NIEFu7cEGeKrf2gNGkjAZTzElglrqGiVOlq5BfdKK")
my_path = os.path.dirname(os.path.abspath(sys.argv[0]))
file_path = os.path.join(my_path, "ACP/data", inputfile)
dataFile = open(file_path, "r")
dataFile.readline() # THIS SKIPS THE FIRST LINE
outFile = open(os.path.join(my_path, "ACP/data", outputfile), "w+")
outFile.write("sis_id, canvas_id, visibility_status, published, notes\n")
total = 3145 # HARDCODED !!!
counter = 0
for line in dataFile:
counter += 1
if counter % 25 == 0:
print("%s/%s done" % (counter, total))
# canvas_course_id, course_id, short_name, canvas_account_id, status
# ASSUMES ALL FIELDS ARE POPULATED ###
canvas_id, sis_id, short_name, account_id, status = line.replace(
"\n", ""
).split(",")
notes = ""
canvas_course = None
try:
canvas_course = canvas.get_course(canvas_id)
published = status
except:
notes = "couldnt find course"
published = "ERROR"
if canvas_course:
if (
int(account_id) not in SUB_ACCOUNTS
): # then we should not update this site!!!!
print("\t school not participating")
notes += "/ subaccount opt out"
outFile.write(
"%s, %s, %s, %s, %s\n"
% (sis_id, canvas_id, status, published, notes)
)
else: # lets update this site babie
try:
print("\t", canvas_id, sis_id, short_name, account_id, status)
update = False
in_SRS = linked_to_SRS(sis_id)
if not in_SRS:
print("\t not in SRS")
update = False
elif int(canvas_id) in SINGLE_SITES_TO_IGNORE:
print("\t single site to ignore")
update = False
else:
course_number = sis_id.split("-")[
1
] # need a way to double check this...!
subj = sis_id.split("-")[0][4:]
print("\t COURSE NUMBER: ", course_number)
print("\t SUBJ : ", subj)
# check if SEAS
if int(account_id) in SEAS_ACCOUNTS:
# SEAS wants to enable shopping for all courses
update = True
else: # not SEAS
if int(account_id) in NURS_ACCOUNTS:
# check course number - if course >= 600 then
# ignore course_number = sis_id.split("-")[1] #
# need a way to double check this...!
if int(course_number) <= 600:
update = True
elif (
int(account_id) in SAS_ACCOUNTS
and int(course_number) <= 500
): # in SAS and undergrad
# check if subject in ignore list
if subj in SUBJ_TO_IGNORE:
print("\t subj to ignore")
update = False
else:
update = True
elif (
int(account_id) in AN_ACCOUNTS
and int(course_number) <= 500
):
if subj == "COMM": # only update these
update = True
else:
update = False
else:
update = False
except:
print("ERROR WITH COURSE: ", sis_id, canvas_id)
outFile.write(
"%s, %s, %s, %s, %s\n"
% (sis_id, canvas_id, "err", "err", "err")
)
if update:
print("\t\tshould update course")
try:
canvas_course.update(course={"is_public_to_auth_users": True})
status = "public_to_auth_users"
except:
status = "ERROR"
print(sis_id, canvas_id, status, published, notes)
outFile.write(
"%s, %s, %s, %s, %s\n"
% (sis_id, canvas_id, status, published, notes)
)
class TestPollChoice(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {'poll_choice': ['get_choice'], 'poll': ['get_poll']}
register_uris(requires, m)
self.poll = self.canvas.get_poll(1)
self.poll.poll_choice = self.poll.get_choice(1)
# __str__()
def test__str__(self, m):
string = str(self.poll.poll_choice)
self.assertIsInstance(string, str)
# get_choices()
def test_get_choices(self, m):
register_uris({'poll_choice': ['get_choices']}, m)
choices_list = self.poll.get_choices()
self.assertIsInstance(choices_list[0], PollChoice)
self.assertIsInstance(choices_list[1], PollChoice)
# get_choice()
def test_get_choice(self, m):
register_uris({'poll_choice': ['get_choice']}, m)
choice_by_id = self.poll.get_choice(1)
self.assertIsInstance(choice_by_id, PollChoice)
self.assertTrue(choice_by_id.is_correct)
self.assertEqual(choice_by_id.text, 'Example choice')
self.assertEqual(choice_by_id.position, 1)
choice_by_obj = self.poll.get_choice(choice_by_id)
self.assertIsInstance(choice_by_obj, PollChoice)
self.assertTrue(choice_by_obj.is_correct)
self.assertEqual(choice_by_obj.text, 'Example choice')
self.assertEqual(choice_by_obj.position, 1)
# create_choice()
def test_create_choice(self, m):
register_uris({'poll_choice': ['create_choice']}, m)
new_choice_t = self.poll.create_choice([{'text': 'Example choice'}])
self.assertIsInstance(new_choice_t, PollChoice)
self.assertTrue(hasattr(new_choice_t, 'text'))
new_choice_t_ic = self.poll.create_choice([{
'text': 'Example choice'
}, {
'is_correct': True
}])
self.assertIsInstance(new_choice_t_ic, PollChoice)
self.assertTrue(hasattr(new_choice_t_ic, 'text'))
self.assertTrue(hasattr(new_choice_t_ic, 'is_correct'))
new_choice_t_p = self.poll.create_choice([{
'text': 'Example choice'
}, {
'position': 1
}])
self.assertIsInstance(new_choice_t_p, PollChoice)
self.assertTrue(hasattr(new_choice_t_p, 'text'))
self.assertTrue(hasattr(new_choice_t_p, 'position'))
new_choice_t_ic_p = self.poll.create_choice([{
'text': 'Example choice'
}, {
'is_correct': True
}, {
'position': 1
}])
self.assertIsInstance(new_choice_t_ic_p, PollChoice)
self.assertTrue(hasattr(new_choice_t_ic_p, 'text'))
self.assertTrue(hasattr(new_choice_t_ic_p, 'is_correct'))
self.assertTrue(hasattr(new_choice_t_ic_p, 'position'))
# create_choice()
def test_create_choice_fail(self, m):
with self.assertRaises(RequiredFieldMissing):
self.poll.create_choice(poll_choice={})
# update()
def test_update(self, m):
register_uris({'poll_choice': ['update']}, m)
updated_choice_t = self.poll.poll_choice.update([{
'text':
'Changed example'
}])
self.assertIsInstance(updated_choice_t, PollChoice)
self.assertEqual(updated_choice_t.text, 'Changed example')
updated_choice_t_ic = self.poll.poll_choice.update([{
'text':
'Changed example'
}, {
'is_correct': False
}])
self.assertIsInstance(updated_choice_t_ic, PollChoice)
self.assertEqual(updated_choice_t_ic.text, 'Changed example')
self.assertFalse(updated_choice_t_ic.is_correct)
updated_choice_t_p = self.poll.poll_choice.update([{
'text':
'Changed example'
}, {
'position': 2
}])
self.assertIsInstance(updated_choice_t_p, PollChoice)
self.assertEqual(updated_choice_t_p.text, 'Changed example')
self.assertEqual(updated_choice_t_p.position, 2)
updated_choice_t_ic_p = self.poll.poll_choice.update([{
'text':
'Changed example'
}, {
'is_correct':
False
}, {
'position': 2
}])
self.assertIsInstance(updated_choice_t_ic_p, PollChoice)
self.assertEqual(updated_choice_t_ic_p.text, 'Changed example')
self.assertFalse(updated_choice_t_ic.is_correct)
self.assertEqual(updated_choice_t_p.position, 2)
# update_choice()
def test_update_choice_fail(self, m):
with self.assertRaises(RequiredFieldMissing):
self.poll.poll_choice.update(poll_choice={})
# delete()
def test_delete(self, m):
register_uris({'poll_choice': ['delete']}, m)
result = self.poll.poll_choice.delete()
self.assertTrue(result)
class TestUser(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
register_uris({"user": ["get_by_id"]}, m)
self.user = self.canvas.get_user(1)
# __str__()
def test__str__(self, m):
string = str(self.user)
self.assertIsInstance(string, str)
# get_profile()
def test_get_profile(self, m):
register_uris({"user": ["profile"]}, m)
profile = self.user.get_profile()
self.assertIsInstance(profile, dict)
self.assertIn("name", profile)
# get_page_views()
def test_get_page_views(self, m):
register_uris({"user": ["page_views", "page_views_p2"]}, m)
page_views = self.user.get_page_views()
page_view_list = [view for view in page_views]
self.assertEqual(len(page_view_list), 4)
self.assertIsInstance(page_view_list[0], PageView)
# get_courses()
def test_get_courses(self, m):
register_uris({"user": ["courses", "courses_p2"]}, m)
courses = self.user.get_courses()
course_list = [course for course in courses]
self.assertEqual(len(course_list), 4)
self.assertIsInstance(course_list[0], Course)
# get_missing_submissions()
def test_get_missing_submissions(self, m):
register_uris({"user": ["missing_sub", "missing_sub_p2"]}, m)
missing_assigments = self.user.get_missing_submissions()
assignment_list = [assignment for assignment in missing_assigments]
self.assertEqual(len(assignment_list), 4)
self.assertIsInstance(assignment_list[0], Assignment)
# update_settings()
def test_update_settings(self, m):
register_uris({"user": ["update_settings"]}, m)
settings = self.user.update_settings(manual_mark_as_read=True)
self.assertIsInstance(settings, dict)
self.assertIn("manual_mark_as_read", settings)
self.assertTrue(settings["manual_mark_as_read"])
# get_color()
def test_get_color(self, m):
register_uris({"user": ["color"]}, m)
color = self.user.get_color("course_1")
self.assertIsInstance(color, dict)
self.assertIn("hexcode", color)
self.assertEqual(color["hexcode"], "#abc123")
# get_colors()
def test_get_colors(self, m):
register_uris({"user": ["colors"]}, m)
colors = self.user.get_colors()
self.assertIsInstance(colors, dict)
self.assertIn("custom_colors", colors)
self.assertIsInstance(colors["custom_colors"], dict)
# update_color()
def test_update_color(self, m):
register_uris({"user": ["color_update"]}, m)
new_hexcode = "#f00f00"
color = self.user.update_color("course_1", new_hexcode)
self.assertIsInstance(color, dict)
self.assertIn("hexcode", color)
self.assertEqual(color["hexcode"], new_hexcode)
def test_update_color_no_hashtag(self, m):
register_uris({"user": ["color_update"]}, m)
new_hexcode = "f00f00"
color = self.user.update_color("course_1", new_hexcode)
self.assertIsInstance(color, dict)
self.assertIn("hexcode", color)
self.assertEqual(color["hexcode"], "#" + new_hexcode)
# edit()
def test_edit(self, m):
register_uris({"user": ["edit"]}, m)
new_name = "New User Name"
self.user.edit(user={"name": new_name})
self.assertIsInstance(self.user, User)
self.assertTrue(hasattr(self.user, "name"))
self.assertEqual(self.user.name, new_name)
# merge_into()
def test_merge_into_id(self, m):
register_uris({"user": ["merge"]}, m)
self.user.merge_into(2)
self.assertIsInstance(self.user, User)
self.assertTrue(hasattr(self.user, "name"))
self.assertEqual(self.user.name, "John Smith")
def test_merge_into_user(self, m):
register_uris({"user": ["get_by_id_2", "merge"]}, m)
other_user = self.canvas.get_user(2)
self.user.merge_into(other_user)
self.assertIsInstance(self.user, User)
self.assertTrue(hasattr(self.user, "name"))
self.assertEqual(self.user.name, "John Smith")
# get_avatars()
def test_get_avatars(self, m):
register_uris({"user": ["avatars", "avatars_p2"]}, m)
avatars = self.user.get_avatars()
avatar_list = [avatar for avatar in avatars]
self.assertEqual(len(avatar_list), 4)
self.assertIsInstance(avatar_list[0], Avatar)
# get_assignments()
def test_user_get_assignments(self, m):
register_uris(
{
"course": ["get_by_id"],
"user": ["get_user_assignments", "get_user_assignments2"],
},
m,
)
assignments_by_id = self.user.get_assignments(1)
assignment_list = [assignment for assignment in assignments_by_id]
self.assertIsInstance(assignments_by_id[0], Assignment)
self.assertEqual(len(assignment_list), 4)
course_obj = self.canvas.get_course(1)
assignments_by_obj = self.user.get_assignments(course_obj)
assignment_list = [assignment for assignment in assignments_by_obj]
self.assertIsInstance(assignments_by_obj[0], Assignment)
self.assertEqual(len(assignment_list), 4)
# get_enrollments()
def test_get_enrollments(self, m):
register_uris({"user": ["list_enrollments", "list_enrollments_2"]}, m)
enrollments = self.user.get_enrollments()
enrollment_list = [enrollment for enrollment in enrollments]
self.assertEqual(len(enrollment_list), 4)
self.assertIsInstance(enrollment_list[0], Enrollment)
# upload()
def test_upload(self, m):
register_uris({"user": ["upload", "upload_final"]}, m)
filename = "testfile_user_{}".format(uuid.uuid4().hex)
try:
with open(filename, "w+") as file:
response = self.user.upload(file)
self.assertTrue(response[0])
self.assertIsInstance(response[1], dict)
self.assertIn("url", response[1])
finally:
cleanup_file(filename)
# get_calendar_events_for_user()
def test_get_calendar_events_for_user(self, m):
register_uris({"user": ["list_calendar_events_for_user"]}, m)
cal_events = self.user.get_calendar_events_for_user()
cal_event_list = [cal_event for cal_event in cal_events]
self.assertEqual(len(cal_event_list), 2)
self.assertIsInstance(cal_event_list[0], CalendarEvent)
# get_communication_channels()
def test_get_communication_channels(self, m):
register_uris({"user": ["list_comm_channels", "list_comm_channels2"]},
m)
comm_channels = self.user.get_communication_channels()
channel_list = [channel for channel in comm_channels]
self.assertEqual(len(channel_list), 4)
self.assertIsInstance(channel_list[0], CommunicationChannel)
# create_communication_channel()
def test_create_communication_channels(self, m):
register_uris({"user": ["create_comm_channel"]}, m)
channel = {"type": "email", "address": "*****@*****.**"}
new_channel = self.user.create_communication_channel(
communication_channel=channel)
self.assertIsInstance(new_channel, CommunicationChannel)
# get_files()
def test_get_files(self, m):
register_uris({"user": ["get_user_files", "get_user_files2"]}, m)
files = self.user.get_files()
file_list = [file for file in files]
self.assertEqual(len(file_list), 4)
self.assertIsInstance(file_list[0], File)
# get_file()
def test_get_file(self, m):
register_uris({"user": ["get_file"]}, m)
file_by_id = self.user.get_file(1)
self.assertIsInstance(file_by_id, File)
self.assertEqual(file_by_id.display_name, "User_File.docx")
self.assertEqual(file_by_id.size, 1024)
file_by_obj = self.user.get_file(file_by_id)
self.assertIsInstance(file_by_obj, File)
self.assertEqual(file_by_obj.display_name, "User_File.docx")
self.assertEqual(file_by_obj.size, 1024)
# get_folder()
def test_get_folder(self, m):
register_uris({"user": ["get_folder"]}, m)
folder_by_id = self.user.get_folder(1)
self.assertEqual(folder_by_id.name, "Folder 1")
self.assertIsInstance(folder_by_id, Folder)
folder_by_obj = self.user.get_folder(folder_by_id)
self.assertEqual(folder_by_obj.name, "Folder 1")
self.assertIsInstance(folder_by_obj, Folder)
# get_folders()
def test_get_folders(self, m):
register_uris({"user": ["list_folders"]}, m)
folders = self.user.get_folders()
folder_list = [folder for folder in folders]
self.assertEqual(len(folder_list), 2)
self.assertIsInstance(folder_list[0], Folder)
# create_folder()
def test_create_folder(self, m):
register_uris({"user": ["create_folder"]}, m)
name_str = "Test String"
response = self.user.create_folder(name=name_str)
self.assertIsInstance(response, Folder)
# get_user_logins()
def test_get_user_logins(self, m):
requires = {"user": ["list_user_logins", "list_user_logins_2"]}
register_uris(requires, m)
response = self.user.get_user_logins()
login_list = [login for login in response]
self.assertIsInstance(login_list[0], Login)
self.assertEqual(len(login_list), 2)
# get_observees()
def test_get_observees(self, m):
requires = {"user": ["list_observees", "list_observees_2"]}
register_uris(requires, m)
response = self.user.get_observees()
observees_list = [observees for observees in response]
self.assertIsInstance(observees_list[0], User)
self.assertEqual(len(observees_list), 4)
# add_observee_with_credentials()
def test_add_observee_with_credentials(self, m):
register_uris({"user": ["add_observee_with_credentials"]}, m)
response = self.user.add_observee_with_credentials()
self.assertIsInstance(response, User)
# show_observee()
def test_show_observee(self, m):
register_uris({"user": ["show_observee"]}, m)
response = self.user.show_observee(6)
self.assertIsInstance(response, User)
# add_observee()
def test_add_observee(self, m):
register_uris({"user": ["add_observee"]}, m)
response = self.user.add_observee(7)
self.assertIsInstance(response, User)
# remove_observee()
def test_remove_observee(self, m):
register_uris({"user": ["remove_observee"]}, m)
response = self.user.remove_observee(8)
self.assertIsInstance(response, User)
# create_content_migration
def test_create_content_migration(self, m):
register_uris({"user": ["create_content_migration"]}, m)
content_migration = self.user.create_content_migration(
"dummy_importer")
self.assertIsInstance(content_migration, ContentMigration)
self.assertTrue(hasattr(content_migration, "migration_type"))
def test_create_content_migration_migrator(self, m):
register_uris(
{
"user":
["create_content_migration", "get_migration_systems_multiple"]
}, m)
migrators = self.user.get_migration_systems()
content_migration = self.user.create_content_migration(migrators[0])
self.assertIsInstance(content_migration, ContentMigration)
self.assertTrue(hasattr(content_migration, "migration_type"))
def test_create_content_migration_bad_migration_type(self, m):
register_uris({"user": ["create_content_migration"]}, m)
with self.assertRaises(TypeError):
self.user.create_content_migration(1)
# get_content_migration
def test_get_content_migration(self, m):
register_uris({"user": ["get_content_migration_single"]}, m)
content_migration = self.user.get_content_migration(1)
self.assertIsInstance(content_migration, ContentMigration)
self.assertTrue(hasattr(content_migration, "migration_type"))
# get_content_migrations
def test_get_content_migrations(self, m):
register_uris({"user": ["get_content_migration_multiple"]}, m)
content_migrations = self.user.get_content_migrations()
self.assertEqual(len(list(content_migrations)), 2)
self.assertIsInstance(content_migrations[0], ContentMigration)
self.assertEqual(content_migrations[0].id, 1)
self.assertEqual(content_migrations[0].migration_type,
"dummy_importer")
self.assertIsInstance(content_migrations[1], ContentMigration)
self.assertEqual(content_migrations[1].id, 2)
self.assertEqual(content_migrations[1].migration_type,
"dummy_importer")
# get_migration_systems
def test_get_migration_systems(self, m):
register_uris({"user": ["get_migration_systems_multiple"]}, m)
migration_systems = self.user.get_migration_systems()
self.assertEqual(len(list(migration_systems)), 2)
self.assertIsInstance(migration_systems[0], Migrator)
self.assertEqual(migration_systems[0].type, "dummy_importer")
self.assertEqual(migration_systems[0].requires_file_upload, True)
self.assertEqual(migration_systems[0].name, "Dummy Importer 01")
self.assertIsInstance(migration_systems[1], Migrator)
self.assertEqual(migration_systems[1].type, "dummy_importer_02")
self.assertEqual(migration_systems[1].requires_file_upload, False)
self.assertEqual(migration_systems[1].name, "Dummy Importer 02")
# get_content_exports()
def test_list_content_exports(self, m):
register_uris({"user": ["multiple_content_exports"]}, m)
content_exports = self.user.get_content_exports()
content_export_list = [
content_export for content_export in content_exports
]
self.assertEqual(len(content_export_list), 2)
self.assertEqual(content_export_list[0].id, 2)
self.assertEqual(content_export_list[1].export_type, "b")
self.assertIsInstance(content_export_list[0], ContentExport)
# get_content_export()
def test_show_content_export(self, m):
register_uris({"user": ["single_content_export"]}, m)
content_export = self.user.get_content_export(11)
self.assertTrue(hasattr(content_export, "export_type"))
self.assertIsInstance(content_export, ContentExport)
# export_content()
def test_export_content(self, m):
register_uris({"user": ["export_content"]}, m)
content_export = self.user.export_content("d")
self.assertIsInstance(content_export, ContentExport)
self.assertTrue(hasattr(content_export, "export_type"))
# get_features()
def test_get_features(self, m):
register_uris({"user": ["get_features"]}, m)
features = self.user.get_features()
self.assertIsInstance(features, PaginatedList)
self.assertIsInstance(features[0], Feature)
# get_enabled_features()
def test_get_enabled_features(self, m):
register_uris({"user": ["get_enabled_features"]}, m)
features = self.user.get_enabled_features()
self.assertIsInstance(features, PaginatedList)
self.assertIsInstance(features[0], Feature)
# get_feature_flag()
def test_get_feature_flag(self, m):
register_uris({"user": ["get_features", "get_feature_flag"]}, m)
feature = self.user.get_features()[0]
feature_flag = self.user.get_feature_flag(feature)
self.assertIsInstance(feature_flag, FeatureFlag)
self.assertEqual(feature_flag.feature, "high_contrast")
# get_authentication_events()
def test_get_authentication_events(self, m):
register_uris({"user": ["get_authentication_events"]}, m)
authentication_event = self.user.get_authentication_events()
event_list = [event for event in authentication_event]
self.assertEqual(len(event_list), 2)
self.assertIsInstance(event_list[0], AuthenticationEvent)
self.assertEqual(event_list[0].event_type, "login")
self.assertEqual(event_list[0].pseudonym_id, 9478)
self.assertIsInstance(event_list[1], AuthenticationEvent)
self.assertEqual(event_list[1].created_at, "2012-07-20T15:00:00-06:00")
self.assertEqual(event_list[1].event_type, "logout")
# set_usage_rights()
def test_set_usage_rights(self, m):
register_uris({"user": ["set_usage_rights"]}, m)
usage_rights = self.user.set_usage_rights(
file_ids=[1, 2],
usage_rights={
"use_justification": "fair_use",
"license": "private"
},
)
self.assertIsInstance(usage_rights, UsageRights)
self.assertEqual(usage_rights.use_justification, "fair_use")
self.assertEqual(usage_rights.message, "2 files updated")
self.assertEqual(usage_rights.license, "private")
self.assertEqual(usage_rights.file_ids, [1, 2])
# remove_usage_rights()
def test_remove_usage_rights(self, m):
register_uris({"user": ["remove_usage_rights"]}, m)
retval = self.user.remove_usage_rights(file_ids=[1, 2])
self.assertIsInstance(retval, dict)
self.assertIn("message", retval)
self.assertEqual(retval["file_ids"], [1, 2])
self.assertEqual(retval["message"], "2 files updated")
# get_licenses()
def test_get_licenses(self, m):
register_uris({"user": ["get_licenses"]}, m)
licenses = self.user.get_licenses()
self.assertIsInstance(licenses, PaginatedList)
licenses = list(licenses)
for lic in licenses:
self.assertIsInstance(lic, License)
self.assertTrue(hasattr(lic, "id"))
self.assertTrue(hasattr(lic, "name"))
self.assertTrue(hasattr(lic, "url"))
self.assertEqual(2, len(licenses))
class TestOutcomeGroup(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
register_uris(
{
'account': ['get_by_id'],
'course': ['get_by_id'],
'outcome': [
'account_root_outcome_group',
'canvas_root_outcome_group',
'course_root_outcome_group',
'course_outcome_links_in_context', 'outcome_example'
]
}, m)
self.canvas_outcome_group = self.canvas.get_root_outcome_group()
self.account = self.canvas.get_account(1)
self.account_outcome_group = self.account.get_root_outcome_group()
self.account_outcome_groups = self.account.get_outcome_groups_in_context(
)
self.account_outcome_links = self.account.get_all_outcome_links_in_context(
)
self.course = self.canvas.get_course(1)
self.course_outcome_group = self.course.get_root_outcome_group()
self.course_outcome_groups = self.course.get_outcome_groups_in_context(
)
self.course_outcome_links = self.course.get_all_outcome_links_in_context(
)
self.example_outcome = self.course_outcome_links[0].get_outcome()
# __str__()
def test__str__(self, m):
string = str(self.canvas_outcome_group)
self.assertIsInstance(string, str)
# update()
def test_update(self, m):
register_uris(
{
'outcome': [
'outcome_group_update_global',
'outcome_group_update_account',
'outcome_group_update_course'
]
}, m)
new_title = "New Outcome Group Title"
self.assertEqual(self.account_outcome_group.title, 'ROOT')
result = self.account_outcome_group.update(title=new_title)
self.assertTrue(result)
self.assertIsInstance(self.account_outcome_group, OutcomeGroup)
self.assertEqual(self.account_outcome_group.title, new_title)
self.assertEqual(self.canvas_outcome_group.title, 'ROOT')
result = self.canvas_outcome_group.update(title=new_title)
self.assertTrue(result)
self.assertIsInstance(self.canvas_outcome_group, OutcomeGroup)
self.assertEqual(self.canvas_outcome_group.title, new_title)
self.assertEqual(self.course_outcome_group.title, 'ROOT')
result = self.course_outcome_group.update(title=new_title)
self.assertTrue(result)
self.assertIsInstance(self.course_outcome_group, OutcomeGroup)
self.assertEqual(self.course_outcome_group.title, new_title)
# delete()
def test_delete(self, m):
register_uris(
{
'outcome': [
'outcome_group_delete_global',
'outcome_group_delete_account',
'outcome_group_delete_course'
]
}, m)
self.assertEqual(self.account_outcome_group.title, 'ROOT')
result = self.account_outcome_group.delete()
self.assertTrue(result)
self.assertEqual(self.canvas_outcome_group.title, 'ROOT')
result = self.canvas_outcome_group.delete()
self.assertTrue(result)
self.assertEqual(self.course_outcome_group.title, 'ROOT')
result = self.course_outcome_group.delete()
self.assertTrue(result)
# list_linked_outcomes()
def test_list_linked_outcomes(self, m):
register_uris(
{
'outcome': [
'outcome_group_list_linked_outcomes_account',
'outcome_group_list_linked_outcomes_global',
'outcome_group_list_linked_outcomes_courses'
]
}, m)
with warnings.catch_warnings(record=True) as warning_list:
result = self.account_outcome_group.list_linked_outcomes()
self.assertIsInstance(result[0], OutcomeLink)
self.assertEqual(result[0].outcome_group['id'], 2)
self.assertEqual(result[0].outcome_group['title'],
"Account Test Outcome Group")
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
with warnings.catch_warnings(record=True) as warning_list:
result = self.canvas_outcome_group.list_linked_outcomes()
self.assertIsInstance(result[0], OutcomeLink)
self.assertEqual(result[0].outcome_group['id'], 2)
self.assertEqual(result[0].outcome_group['title'],
"Global Test Outcome Group")
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
with warnings.catch_warnings(record=True) as warning_list:
result = self.course_outcome_group.list_linked_outcomes()
self.assertIsInstance(result[0], OutcomeLink)
self.assertEqual(result[0].outcome_group['id'], 2)
self.assertEqual(result[0].outcome_group['title'],
"Course Test Outcome Group")
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
# get_linked_outcomes()
def test_get_linked_outcomes(self, m):
register_uris(
{
'outcome': [
'outcome_group_list_linked_outcomes_account',
'outcome_group_list_linked_outcomes_global',
'outcome_group_list_linked_outcomes_courses'
]
}, m)
result = self.account_outcome_group.get_linked_outcomes()
self.assertIsInstance(result[0], OutcomeLink)
self.assertEqual(result[0].outcome_group['id'], 2)
self.assertEqual(result[0].outcome_group['title'],
"Account Test Outcome Group")
result = self.canvas_outcome_group.get_linked_outcomes()
self.assertIsInstance(result[0], OutcomeLink)
self.assertEqual(result[0].outcome_group['id'], 2)
self.assertEqual(result[0].outcome_group['title'],
"Global Test Outcome Group")
result = self.course_outcome_group.get_linked_outcomes()
self.assertIsInstance(result[0], OutcomeLink)
self.assertEqual(result[0].outcome_group['id'], 2)
self.assertEqual(result[0].outcome_group['title'],
"Course Test Outcome Group")
# link_existing()
def test_link_existing(self, m):
register_uris(
{
'outcome': [
'outcome_example', 'outcome_group_link_existing_global',
'outcome_group_link_existing_account',
'outcome_group_link_existing_course'
]
}, m)
result = self.canvas_outcome_group.link_existing(self.example_outcome)
self.assertIsInstance(result, OutcomeLink)
self.assertEqual(result.outcome_group['id'], 2)
result = self.account_outcome_group.link_existing(self.example_outcome)
self.assertIsInstance(result, OutcomeLink)
self.assertEqual(result.outcome_group['id'], 2)
result = self.course_outcome_group.link_existing(self.example_outcome)
self.assertIsInstance(result, OutcomeLink)
self.assertEqual(result.outcome_group['id'], 2)
result = self.canvas_outcome_group.link_existing(3)
self.assertIsInstance(result, OutcomeLink)
self.assertEqual(result.outcome_group['id'], 2)
result = self.account_outcome_group.link_existing(3)
self.assertIsInstance(result, OutcomeLink)
self.assertEqual(result.outcome_group['id'], 2)
result = self.course_outcome_group.link_existing(3)
self.assertIsInstance(result, OutcomeLink)
self.assertEqual(result.outcome_group['id'], 2)
# link_new()
def test_link_new(self, m):
register_uris(
{
'outcome': [
'outcome_group_link_new_global',
'outcome_group_link_new_account',
'outcome_group_link_new_course'
]
}, m)
new_title = "New Outcome"
result = self.canvas_outcome_group.link_new(title=new_title)
self.assertIsInstance(result, OutcomeLink)
self.assertEqual(result.outcome_group['id'], 1)
self.assertEqual(result.outcome['id'], 2)
self.assertEqual(result.outcome['context_type'], None)
result = self.account_outcome_group.link_new(title=new_title)
self.assertIsInstance(result, OutcomeLink)
self.assertEqual(result.outcome_group['id'], 1)
self.assertEqual(result.outcome['id'], 2)
self.assertEqual(result.outcome['context_type'], 'Account')
result = self.course_outcome_group.link_new(title=new_title)
self.assertIsInstance(result, OutcomeLink)
self.assertEqual(result.outcome_group['id'], 1)
self.assertEqual(result.outcome['id'], 2)
self.assertEqual(result.outcome['context_type'], 'Course')
# unlink_outcome()
def test_unlink_outcome(self, m):
register_uris(
{
'outcome': [
'outcome_example', 'outcome_group_unlink_outcome_global',
'outcome_group_unlink_outcome_account',
'outcome_group_unlink_outcome_course'
]
}, m)
result = self.canvas_outcome_group.unlink_outcome(self.example_outcome)
self.assertTrue(result)
result = self.account_outcome_group.unlink_outcome(
self.example_outcome)
self.assertTrue(result)
result = self.course_outcome_group.unlink_outcome(self.example_outcome)
self.assertTrue(result)
result = self.canvas_outcome_group.unlink_outcome(3)
self.assertTrue(result)
result = self.account_outcome_group.unlink_outcome(3)
self.assertTrue(result)
result = self.course_outcome_group.unlink_outcome(3)
self.assertTrue(result)
# list_subgroups()
def test_list_subgroups(self, m):
register_uris(
{
'outcome': [
'outcome_group_list_subgroups_global',
'outcome_group_list_subgroups_account',
'outcome_group_list_subgroups_course'
]
}, m)
with warnings.catch_warnings(record=True) as warning_list:
result = self.canvas_outcome_group.list_subgroups()
self.assertIsInstance(result[0], OutcomeGroup)
self.assertEqual(result[0].id, 2)
self.assertEqual(result[0].title, "Global Listed Subgroup Title 1")
self.assertIsInstance(result[1], OutcomeGroup)
self.assertEqual(result[1].id, 3)
self.assertEqual(result[1].title, "Global Listed Subgroup Title 2")
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
with warnings.catch_warnings(record=True) as warning_list:
result = self.account_outcome_group.list_subgroups()
self.assertIsInstance(result[0], OutcomeGroup)
self.assertEqual(result[0].id, 2)
self.assertEqual(result[0].title,
"Account Listed Subgroup Title 1")
self.assertIsInstance(result[1], OutcomeGroup)
self.assertEqual(result[1].id, 3)
self.assertEqual(result[1].title,
"Account Listed Subgroup Title 2")
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
with warnings.catch_warnings(record=True) as warning_list:
result = self.course_outcome_group.list_subgroups()
self.assertIsInstance(result[0], OutcomeGroup)
self.assertEqual(result[0].id, 2)
self.assertEqual(result[0].title, "Course Listed Subgroup Title 1")
self.assertIsInstance(result[1], OutcomeGroup)
self.assertEqual(result[1].id, 3)
self.assertEqual(result[1].title, "Course Listed Subgroup Title 2")
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
# get_subgroups()
def test_get_subgroups(self, m):
register_uris(
{
'outcome': [
'outcome_group_list_subgroups_global',
'outcome_group_list_subgroups_account',
'outcome_group_list_subgroups_course'
]
}, m)
result = self.canvas_outcome_group.get_subgroups()
self.assertIsInstance(result[0], OutcomeGroup)
self.assertEqual(result[0].id, 2)
self.assertEqual(result[0].title, "Global Listed Subgroup Title 1")
self.assertTrue(hasattr(result[0], 'context_type'))
self.assertEqual(result[0].context_type, None)
self.assertTrue(hasattr(result[0], 'context_id'))
self.assertEqual(result[0].context_id, None)
self.assertIsInstance(result[1], OutcomeGroup)
self.assertEqual(result[1].id, 3)
self.assertEqual(result[1].title, "Global Listed Subgroup Title 2")
self.assertTrue(hasattr(result[0], 'context_type'))
self.assertEqual(result[0].context_type, None)
self.assertTrue(hasattr(result[0], 'context_id'))
self.assertEqual(result[0].context_id, None)
result = self.account_outcome_group.get_subgroups()
self.assertIsInstance(result[0], OutcomeGroup)
self.assertEqual(result[0].id, 2)
self.assertEqual(result[0].title, "Account Listed Subgroup Title 1")
self.assertTrue(hasattr(result[0], 'context_type'))
self.assertEqual(result[0].context_type, 'Account')
self.assertTrue(hasattr(result[0], 'context_id'))
self.assertEqual(result[0].context_id, self.account.id)
self.assertIsInstance(result[1], OutcomeGroup)
self.assertEqual(result[1].id, 3)
self.assertEqual(result[1].title, "Account Listed Subgroup Title 2")
self.assertTrue(hasattr(result[0], 'context_type'))
self.assertEqual(result[0].context_type, 'Account')
self.assertTrue(hasattr(result[0], 'context_id'))
self.assertEqual(result[0].context_id, self.account.id)
result = self.course_outcome_group.get_subgroups()
self.assertIsInstance(result[0], OutcomeGroup)
self.assertEqual(result[0].id, 2)
self.assertEqual(result[0].title, "Course Listed Subgroup Title 1")
self.assertTrue(hasattr(result[0], 'context_type'))
self.assertEqual(result[0].context_type, 'Course')
self.assertTrue(hasattr(result[0], 'context_id'))
self.assertEqual(result[0].context_id, self.course.id)
self.assertIsInstance(result[1], OutcomeGroup)
self.assertEqual(result[1].id, 3)
self.assertEqual(result[1].title, "Course Listed Subgroup Title 2")
self.assertTrue(hasattr(result[0], 'context_type'))
self.assertEqual(result[0].context_type, 'Course')
self.assertTrue(hasattr(result[0], 'context_id'))
self.assertEqual(result[0].context_id, self.course.id)
# create_subgroup()
def test_create_subgroup(self, m):
register_uris(
{
'outcome': [
'outcome_group_create_subgroup_global',
'outcome_group_create_subgroup_account',
'outcome_group_create_subgroup_course'
]
}, m)
new_title = "New Subgroup Title"
result = self.canvas_outcome_group.create_subgroup(new_title)
self.assertEqual(self.canvas_outcome_group.id,
result.parent_outcome_group['id'])
self.assertEqual(result.parent_outcome_group['title'],
"Parent of Subgroup")
self.assertEqual(result.title, "New Subgroup Title")
result = self.account_outcome_group.create_subgroup(new_title)
self.assertEqual(self.canvas_outcome_group.id,
result.parent_outcome_group['id'])
self.assertEqual(result.parent_outcome_group['title'],
"Parent of Subgroup")
self.assertEqual(result.title, "New Subgroup Title")
result = self.course_outcome_group.create_subgroup(new_title)
self.assertEqual(self.canvas_outcome_group.id,
result.parent_outcome_group['id'])
self.assertEqual(result.parent_outcome_group['title'],
"Parent of Subgroup")
self.assertEqual(result.title, "New Subgroup Title")
# import_outcome_group()
def test_import_outcome_group(self, m):
register_uris(
{
'outcome': [
'outcome_group_import_outcome_group_global',
'outcome_group_import_outcome_group_account',
'outcome_group_import_outcome_group_course'
]
}, m)
result = self.canvas_outcome_group.import_outcome_group(3)
self.assertEqual(result.id, 4)
self.assertEqual(result.title, "Global Imported Subgroup Title")
self.assertEqual(result.parent_outcome_group['id'],
self.canvas_outcome_group.id)
self.assertEqual(result.parent_outcome_group['title'],
self.canvas_outcome_group.title)
result = self.account_outcome_group.import_outcome_group(3)
self.assertEqual(result.id, 4)
self.assertEqual(result.title, "Account Imported Subgroup Title")
self.assertEqual(result.parent_outcome_group['id'],
self.account_outcome_group.id)
self.assertEqual(result.parent_outcome_group['title'],
self.account_outcome_group.title)
result = self.course_outcome_group.import_outcome_group(3)
self.assertEqual(result.id, 4)
self.assertEqual(result.title, "Course Imported Subgroup Title")
self.assertEqual(result.parent_outcome_group['id'],
self.course_outcome_group.id)
self.assertEqual(result.parent_outcome_group['title'],
self.course_outcome_group.title)
result_by_obj = self.course_outcome_group.import_outcome_group(result)
self.assertEqual(result_by_obj.id, 4)
self.assertEqual(result_by_obj.title, "Course Imported Subgroup Title")
self.assertEqual(result_by_obj.parent_outcome_group['id'],
self.course_outcome_group.id)
self.assertEqual(result_by_obj.parent_outcome_group['title'],
self.course_outcome_group.title)
from canvasapi import Canvas
import config
import csv
canvas = Canvas(config.API_URL, config.API_KEY)
filename = "DOE_Account_Import.csv"
csv_file = open(filename, 'w')
csv_file.write('course_id,short_name,long_name,account_id,status\n')
line_count = 0
def buildLine(courseID, accountID):
#print(courseID)
try:
course = canvas.get_course(courseID, True)
line = courseID
line += ',' + course.course_code
line += ',' + course.name
line += ',' + accountID
line += ',active\n'
return line
except:
print("Course Not Found: " + str(courseID))
with open('all_dce_courses.csv', 'r', newline='') as course_list:
reader = csv.reader(course_list, delimiter=',')
for row in reader:
def updateTodoist(todoist_email, todoist_password, canvas_url, canvas_api_key,
system_time, data):
global fileData
#establish time
today = str(datetime.today()).split(" ")[0]
tDate = datetime(int(today.split("-")[0]), int(today.split("-")[1]),
int(today.split("-")[2])).timestamp()
#establish canvas
try:
canvas = Canvas(canvas_url, canvas_api_key)
user = canvas.get_current_user()
courses = user.get_courses()
except:
return 1
# establish todoist
try:
user = todoist.login(todoist_email, todoist_password)
except:
return 2
projectsTemp = user.get_projects()
names = []
projects = {}
projectsList = []
for project in projectsTemp:
projects.update({project.name: project})
projectsList.append([project.name, project])
#establish data
fileData = json.loads(data)
for task in fileData:
# check for expired
#print(task[2])
aDate = datetime(int(task[2].split("-")[0]),
int(task[2].split("-")[1]),
int(task[2].split("-")[2])).timestamp()
if (aDate < tDate):
fileData.remove(task)
tasksAddedCount = 0
fullAssignments = []
for course in courses:
print(course.name)
for assignment in course.get_assignments():
try:
tDate2 = datetime.utcnow()
d = str(system_time).split(" ")[0]
t = str(system_time).split(" ")[1]
system_time = datetime(int(d.split("-")[0]),
int(d.split("-")[1]),
int(d.split("-")[2]),
int(t.split(":")[0]),
int(t.split(":")[1]),
round(float(t.split(":")[2])))
offset = (tDate2 - system_time)
if (str(tDate2 - system_time)[0] == "-"):
offset = (system_time - tDate)
d = str(assignment.due_at_date).split(" ")[0]
t = str(assignment.due_at_date).split(" ")[1]
due_date_UTC = datetime(int(d.split("-")[0]),
int(d.split("-")[1]),
int(d.split("-")[2]),
int(t.split(":")[0]),
int(t.split(":")[1]),
int(t.split(":")[2].split("+")[0]))
aDate = (due_date_UTC - offset).timestamp()
if (aDate >= tDate):
flag = False
for task in fileData:
if (str(task[1]) == str(assignment.name)):
flag = True
if (flag):
break
tempData = [
course.name, assignment.name,
str(datetime.fromtimestamp(aDate)).split(" ")[0]
]
projects[tempData[0]].add_task(content=tempData[1],
date=tempData[2])
fullAssignments.append(tempData)
fileData.append(tempData)
tasksAddedCount += 1
except:
pass
return [tasksAddedCount, fileData]
assignment_id = env.int("CANVAS_ASSIGNMENT_ID")
quiz_id = env.int("CANVAS_QUIZ_ID")
as_user_id = env.int("CANVAS_AS_USER_ID", 0) # Optional - for test student
if as_user_id:
masquerade = dict(as_user_id=as_user_id)
else:
masquerade = {}
if repo.is_dirty() and not env.bool("ALLOW_DIRTY", False):
raise RuntimeError(
"Must submit from a clean working directory - commit your code and rerun"
)
# Load canvas objects
canvas = Canvas(env.str("CANVAS_URL"), env.str("CANVAS_TOKEN"))
course = canvas.get_course(course_id, **masquerade)
assignment = course.get_assignment(assignment_id, **masquerade)
quiz = course.get_quiz(quiz_id, **masquerade)
# Begin submissions
url = "https://github.com/csci-e-29/{}/commit/{}".format(
os.path.basename(repo.working_dir), repo.head.commit.hexsha
) # you MUST push to the classroom org, even if CI/CD runs elsewhere (you can push anytime before peer review begins)
qsubmission = None
try:
# Attempt quiz submission first - only submit assignment if successful
qsubmission = quiz.create_submission(**masquerade)
questions = qsubmission.get_submission_questions(**masquerade)
class TestCommunicationChannel(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
register_uris({'user': ['get_by_id', 'list_comm_channels']}, m)
self.user = self.canvas.get_user(1)
self.comm_chan = self.user.list_communication_channels()[0]
# __str__()
def test__str__(self, m):
string = str(self.comm_chan)
self.assertIsInstance(string, str)
# list_preferences()
def test_list_preferences(self, m):
register_uris({'communication_channel': ['list_preferences']}, m)
preferences = self.comm_chan.list_preferences()
preference_list = [preference for preference in preferences]
self.assertEqual(len(preference_list), 2)
self.assertEqual(preference_list[0]['notification'],
'new_announcement')
# list_preference_categories()
def test_list_preference_categories(self, m):
register_uris(
{'communication_channel': ['list_preference_categories']}, m)
categories = self.comm_chan.list_preference_categories()
self.assertEqual(len(categories), 2)
self.assertIsInstance(categories, list)
self.assertEqual(categories[0], 'announcement')
# get_preference()
def test_get_preference(self, m):
register_uris({'communication_channel': ['get_preference']}, m)
preference = self.comm_chan.get_preference('new_announcement')
self.assertIsInstance(preference, NotificationPreference)
self.assertTrue(hasattr(preference, 'notification'))
self.assertEqual(preference.notification, 'new_announcement')
# update_preference()
def test_update_preference(self, m):
register_uris({'communication_channel': ['update_preference']}, m)
notification = 'new_announcement'
frequency = 'daily'
updated_pref = self.comm_chan.update_preference(
notification=notification, frequency=frequency)
self.assertIsInstance(updated_pref, NotificationPreference)
self.assertEqual(updated_pref.frequency, frequency)
self.assertEqual(updated_pref.notification, notification)
self.assertEqual(updated_pref.category, 'announcement')
# update_preferences_by_category()
def test_update_preferences_by_category(self, m):
register_uris(
{'communication_channel': ['update_preferences_by_category']}, m)
category = 'course_content'
frequency = 'daily'
updated_prefs = self.comm_chan.update_preferences_by_catagory(
category=category, frequency=frequency)
self.assertEqual(len(updated_prefs), 3)
self.assertEqual(updated_prefs[0]['frequency'], frequency)
self.assertEqual(updated_prefs[0]['category'], category)
self.assertEqual(updated_prefs[0]['notification'],
'assignment_changed')
# update_multiple_preferences()
def test_update_multiple_preferences(self, m):
register_uris(
{'communication_channel': ['update_multiple_preferences']}, m)
notification_preferences = {
"assignment_due_date_changed": {
"frequency": "daily"
},
"assignment_changed": {
"frequency": "daily"
}
}
updated_prefs = self.comm_chan.update_multiple_preferences(
notification_preferences=notification_preferences)
self.assertEqual(len(updated_prefs), 2)
self.assertEqual(updated_prefs[0]['frequency'], "daily")
empty_notification_preferences = {}
self.assertFalse(
self.comm_chan.update_multiple_preferences(
notification_preferences=empty_notification_preferences))
frequency_empty_notification_preferences = {
"got_no_freq": {
"frequency": ""
}
}
self.assertFalse(
self.comm_chan.update_multiple_preferences(
notification_preferences=
frequency_empty_notification_preferences))
no_frequency_notification_preferences = {
"got_no_freq": {
"nope": "no_way"
}
}
self.assertFalse(
self.comm_chan.update_multiple_preferences(
notification_preferences=no_frequency_notification_preferences)
)
def temp():
canvas = Canvas(API_URL, API_KEY)
courses = [
1518389,
1518464,
1518556,
1518692,
1519015,
1519016,
1519358,
1519359,
1527911,
1528276,
1528494,
1528495,
1528538,
1528539,
1528714,
1528717,
1528769,
1528800,
1528854,
1528855,
1528866,
1528877,
1528878,
1528893,
1528894,
1528944,
1529105,
1529106,
1529107,
1529110,
1529111,
1529350,
1529352,
1530003,
1530004,
1530159,
1530184,
1530348,
1530421,
1532011,
1532085,
1532956,
1533156,
1533331,
1533332,
1533591,
1533785,
1534102,
1539616,
1540027,
1518482,
1534103,
1539964,
1540025,
1540026,
1540054,
1540055,
1541437,
1541438,
1541702,
1541703,
1542284,
1542285,
]
intern = canvas.get_user(5607930)
for course in courses:
canvas_course = canvas.get_course(course)
section = canvas_course.get_sections()[0]
canvas_course.enroll_user(
intern.id,
"DesignerEnrollment",
enrollment={
"course_section_id": section.id,
"role_id": "1383",
"enrollment_state": "active",
},
)
class TestFavorite(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
"current_user": [
"get_by_id",
]
}
register_uris(requires, m)
self.user = self.canvas.get_current_user()
# __str__()
def test_uncapitalized___str__(self, m):
register_uris(
{"current_user": [
"add_favorite_course",
"add_favorite_group",
]},
m,
)
favorite_course = self.user.add_favorite_course(1)
favorite_group = self.user.add_favorite_group(1)
string = str(favorite_course)
self.assertIsInstance(string, str)
string = str(favorite_group)
self.assertIsInstance(string, str)
def test_capitalized___str__(self, m):
register_uris(
{
"current_user": [
"add_favorite_course_cap_context_type",
"add_favorite_group_cap_context_type",
]
},
m,
)
favorite_course = self.user.add_favorite_course(1)
favorite_group = self.user.add_favorite_group(1)
string = str(favorite_course)
self.assertIsInstance(string, str)
string = str(favorite_group)
self.assertIsInstance(string, str)
# remove()
def test_remove_uncapitalized_favorite_course(self, m):
register_uris(
{
"current_user": [
"add_favorite_course",
"remove_favorite_course",
]
},
m,
)
favorite_course = self.user.add_favorite_course(1)
evnt = favorite_course.remove()
self.assertIsInstance(evnt, Favorite)
self.assertEqual(evnt.context_type, "course")
self.assertEqual(evnt.context_id, 1)
def test_remove_uncapitalized_favorite_group(self, m):
register_uris(
{
"current_user": [
"add_favorite_group",
"remove_favorite_group",
]
},
m,
)
favorite_group = self.user.add_favorite_group(1)
evnt = favorite_group.remove()
self.assertIsInstance(evnt, Favorite)
self.assertEqual(evnt.context_type, "group")
self.assertEqual(evnt.context_id, 1)
def test_remove_capitalized_favorite_course(self, m):
register_uris(
{
"current_user": [
"add_favorite_course_cap_context_type",
"remove_favorite_course_cap_context_type",
]
},
m,
)
favorite_course = self.user.add_favorite_course(1)
evnt = favorite_course.remove()
self.assertIsInstance(evnt, Favorite)
self.assertEqual(evnt.context_type, "Course")
self.assertEqual(evnt.context_id, 1)
def test_remove_capitalized_favorite_group(self, m):
register_uris(
{
"current_user": [
"add_favorite_group_cap_context_type",
"remove_favorite_group_cap_context_type",
]
},
m,
)
favorite_group = self.user.add_favorite_group(1)
evnt = favorite_group.remove()
self.assertIsInstance(evnt, Favorite)
self.assertEqual(evnt.context_type, "Group")
self.assertEqual(evnt.context_id, 1)
def add_reserves(inputfile="reserves.csv", outputfile="RESULT_Reserves.csv"):
# this script will enable reserves given an input file that contains only
# one column ( the sis id)
# if reserves are already enabled it wil note that and not update the site.
RESERVES = "context_external_tool_139969"
SUB_ACCOUNTS = [99237, 128877, 99244, 99238, 99239, 99240, 99242]
canvas = Canvas(API_URL, API_KEY)
my_path = os.path.dirname(os.path.abspath(sys.argv[0]))
file_path = os.path.join(my_path, "ACP/data", inputfile)
dataFile = open(file_path, "r")
dataFile.readline() # THIS SKIPS THE FIRST LINE
outFile = open(os.path.join(my_path, "ACP/data", outputfile), "w+")
outFile.write(
"%s,%s,%s,%s\n" % ("canvas_course_id", "course_id", "account", "Reserves")
)
# build a list of sub account's sub accounts
SUB_SUB_ACCOUNTS = []
for sub in SUB_ACCOUNTS:
SUB_SUB_ACCOUNTS += find_accounts_subaccounts(sub)
print(SUB_SUB_ACCOUNTS)
# return SUB_SUB_ACCOUNTS
for line in dataFile:
# canvas_course_id course_id canvas_account_id
canvas_course_id, sis_id, canvas_account_id = line.replace("\n", "").split(",")
outFile.write("%s, %s, %s" % (canvas_course_id, sis_id, canvas_account_id))
if int(canvas_account_id) in SUB_SUB_ACCOUNTS:
try:
canvas_course = canvas.get_course(canvas_course_id)
print("\t found course ", canvas_course)
except:
print("\t didnt find course %s" % canvas_course_id)
canvas_course = None
else:
print("course %s not in opt in school" % (canvas_account_id))
canvas_course = False
if canvas_course:
print("canvas course: %s" % canvas_course.id)
tabs = canvas_course.get_tabs()
for tab in tabs:
# CONFIGURING RESERVES
if tab.id == RESERVES:
print("\tfound Reserves")
# outFile.write(",%s\n" % 'already added')
try:
if tab.visibility != "public":
tab.update(hidden=False, position=3)
print("\t enabled reserves")
outFile.write(",%s\n" % "added")
else:
print("\t already enabled reserves ")
outFile.write(",%s\n" % "already added")
except:
print("\tfailed reserves %s" % canvas_course_id)
outFile.write(",%s\n" % "failed to add")
else:
# skip this tab
pass
# outFile.write("\n")
elif canvas_course is None: # no site
outFile.write(",%s\n" % "couldnt find")
elif not canvas_course: # not in program
outFile.write(",%s\n" % "not in program")
else:
print("HEY YOU SHOULDNT GET TO THIS CASE", canvas_course_id)
print("be sure to add the RESULT_.csv to the Master file")
import collections
import statistics
import os
p = os.path.abspath(os.curdir)
if os.path.exists(p + '\\reports') == False:
os.makedirs(p + '\\reports')
# Canvas API URL
API_URL = "https://uncc.instructure.com/"
# Canvas API key
file = open('token.txt', 'r')
API_KEY = str(file.read())
file.close()
# Initialize a new Canvas object
canvas = Canvas(API_URL, API_KEY)
course_id = int(input('enter course id: '))
quiz_id = int(input('enter quiz id: '))
course = canvas.get_course(course_id)
print('Extracting from: ' + course.name)
quiz = course.get_quiz(quiz_id)
quiz_json = quiz.to_json()
r = requests.get("https://uncc.instructure.com/api/v1/courses/" +
str(course_id) + "/quizzes/" + str(quiz_id) +
"/submissions/?per_page=100",
headers={'Authorization': 'Bearer ' + API_KEY})
quiz_submissions = r.json()['quiz_submissions']
print('# Submissions: ' + str(len(quiz_submissions)))
output = {}
def count_surveys(inputfile="survey_input.csv", outputfile="RESULT_surveys.csv"):
# canvas_course_id course_id short_name canvas_account_id term_id status
canvas = Canvas(API_URL, API_KEY)
my_path = os.path.dirname(os.path.abspath(sys.argv[0]))
file_path = os.path.join(my_path, "ACP/data", inputfile)
dataFile = open(file_path, "r")
dataFile.readline() # THIS SKIPS THE FIRST LINE
outFile = open(os.path.join(my_path, "ACP/data", outputfile), "w+")
outFile.write(
"%s,%s,%s,%s,%s,%s,%s,%s,%s,%s\n"
% (
"canvas_course_id",
"course_id",
"account",
"term",
"status",
"ungraded_surveys_published",
"ungraded_surveys_unpublished",
"graded_surveys_published",
"graded_surveys_unpublished",
"total_quizzes",
)
)
# 'ungraded_surveys_published', 'ungraded_surveys_unpublished',
# 'graded_surveys_published','graded_surveys_unpublished'
COUNTER = 0
TOTAL = 11786
for line in dataFile:
COUNTER += 1
if COUNTER % 25 == 0:
print("%s/%s done" % (COUNTER, TOTAL))
canvas_course_id, course_id, short_name, account, term, status = line.replace(
"\n", ""
).split(",")
course = canvas.get_course(canvas_course_id)
ungraded_published = 0
ungraded_unpublished = 0
graded_published = 0
graded_unpublished = 0
total_quizzes = 0
quizzes = course.get_quizzes()
for quiz in quizzes:
total_quizzes += 1
if quiz.quiz_type == "survey":
# check if published
if quiz.published:
ungraded_published += 1
else:
ungraded_unpublished += 1
elif quiz.quiz_type == "graded_survey":
# check if published
if quiz.published:
graded_published += 1
else:
graded_unpublished += 1
else: # quiz is not a survey
pass
outFile.write(
"%s,%s,%s,%s,%s,%s,%s,%s,%s,%s\n"
% (
canvas_course_id,
course_id,
account,
term,
status,
ungraded_published,
ungraded_unpublished,
graded_published,
graded_unpublished,
total_quizzes,
)
)
def get_user_inputs():
"""Prompt user for required inputs. Queries Canvas API throughout to check for
access and validity errors. Errors stop execution and print to screen.
Returns:
Dictionary containing inputs
"""
# prompt user for url and token
url = input('Canvas Instance URL: ')
token = getpass.getpass('Please enter your token: ')
auth_header = {'Authorization': f'Bearer {token}'}
# Canvas object to provide access to Canvas API
canvas = Canvas(url, token)
# get user object
try:
user = canvas.get_user('self')
cprint(f'\nHello, {user.name}!', 'green')
except Exception:
shut_down("""
ERROR: could not get user from server.
Please ensure token is correct and valid and ensure using the correct instance url.
""")
# get course object
try:
course_id = input('Course ID: ')
course = canvas.get_course(course_id)
except Exception:
shut_down(
f'ERROR: Course not found [ID: {course_id}]. Please check course number.'
)
# get students from course
try:
students = course.get_users(enrollment_type='student')
except Exception:
shut_down(
'ERROR: Not able to get students from course. Ensure course has enrolled students.'
)
# get the quiz from course
try:
quiz_id = input('Quiz ID: ')
quiz = course.get_quiz(quiz_id)
except Exception:
shut_down(
f'ERROR: Quiz not found [ID: {quiz_id}]. Please check quiz number.'
)
question_bank_input = input('Does this quiz use Question Bank(s)? [y/n]: ')
if question_bank_input == 'y' or question_bank_input == 'Y':
has_question_bank = True
else:
has_question_bank = False
# prompt user for confirmation
_prompt_for_confirmation(user.name, course.name, quiz.title,
has_question_bank)
# set course, quiz, students and auth_header as global variables
settings.course = course
settings.quiz = quiz
settings.students = students
settings.auth_header = auth_header
settings.has_question_bank = has_question_bank
# return inputs dictionary
return url, course_id, quiz_id
def recent_course_activity(
inputfile="course_list.csv", outputfile="recent_activity.csv"
):
canvas = Canvas(API_URL, API_KEY)
my_path = os.path.dirname(os.path.abspath(sys.argv[0]))
file_path = os.path.join(my_path, "ACP/data", inputfile)
dataFile = open(file_path, "r")
dataFile.readline() # THIS SKIPS THE FIRST LINE
outFile = open(os.path.join(my_path, "ACP/data", outputfile), "w+")
outFile.write(
"course_id, account_id, account_name, storage, last_activity_instructor, "
"last_activity_student, end_at\n"
)
for line in dataFile:
overall_last_activity_inst = "0"
overall_last_activity_stud = "0"
course_id, account_id, account_name, storage_used = line.replace(
"\n", ""
).split(",")
canvas_site = canvas.get_course(course_id)
s_users = canvas_site.get_enrollments(type=["StudentEnrollment"])
i_users = canvas_site.get_enrollments(type=["TeacherEnrollment"])
if canvas_site.end_at:
end_at = canvas_site.end_at
else:
end_at = "None"
for student in s_users:
last_activity = student.last_activity_at
try:
# print("\t",overall_last_activity,last_activity)
if last_activity > overall_last_activity_stud:
overall_last_activity_stud = last_activity
except:
pass
# print("\t",course_id, user.user_id,last_activity)
for instructor in i_users:
last_activity = instructor.last_activity_at
try:
# print("\t",overall_last_activity,last_activity)
if last_activity > overall_last_activity_inst:
overall_last_activity_inst = last_activity
except:
pass
# print("\t",course_id, user.user_id,last_activity)
print(
course_id,
account_id,
account_name,
storage_used,
overall_last_activity_stud,
overall_last_activity_inst,
)
outFile.write(
"%s,%s,%s,%s,%s,%s,%s\n"
% (
course_id,
account_id,
account_name,
storage_used,
overall_last_activity_inst,
overall_last_activity_stud,
end_at,
)
)
return
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
register_uris({'user': ['course_nickname']}, m)
self.nickname = self.canvas.get_course_nickname(1)
def WHARTON_enable_course_shopping(
inputfile, outputfile="WH_2020C_courses_shopping_enabled.csv"
):
canvas = Canvas(API_URL, API_KEY)
# Do feel free to target account id 81471, SIS ID WHARTON
WHARTON_ACCOUNT_ID = 81471
WHARTON_ACCOUNTS = find_accounts_subaccounts(WHARTON_ACCOUNT_ID)
WH_EXCLUDE = [
1533534,
1544662,
1545833,
1546333,
1546334,
1546014,
1534322,
1545633,
1545551,
1545538,
1530182,
1541427,
1545959,
1528661,
1533373,
1541391,
1541392,
1541393,
1541394,
1541395,
1541396,
1541397,
1541398,
1541399,
1541400,
1541401,
1541402,
1540185,
1540186,
1532920,
1540130,
1539621,
1540008,
1544660,
1541461,
1533499,
1533500,
1540120,
1527591,
1546010,
1542201,
1544821,
1542311,
1545547,
1544274,
1540000,
1539655,
1544059,
1533358,
1544488,
1533036,
1531945,
1529286,
1544482,
1534136,
1544273,
1540001,
1544321,
1533037,
1540131,
1539623,
1541203,
1529372,
1527672,
1543902,
1534137,
1518420,
1532973,
1532776,
1533100,
1532958,
1518436,
1532774,
1533171,
1532959,
1534144,
1542115,
1512130,
1545744,
1542523,
1542524,
1542525,
1542526,
1542527,
1543845,
1542530,
1542531,
1542532,
1542533,
1542534,
1542535,
1543846,
1542540,
1532930,
1512304,
1526396,
1527421,
1527428,
1507562,
]
my_path = os.path.dirname(os.path.abspath(sys.argv[0]))
file_path = os.path.join(my_path, "ACP/data", inputfile)
dataFile = open(file_path, "r")
dataFile.readline() # THIS SKIPS THE FIRST LINE
outFile = open(os.path.join(my_path, "ACP/data", outputfile), "w+")
outFile.write("sis_id, canvas_id, visibility_status, published, notes\n")
total = 3145 # HARDCODED !!!
counter = 0
for line in dataFile:
counter += 1
if counter % 25 == 0:
print("%s/%s done" % (counter, total))
# ASSUMES ALL FIELDS ARE POPULATED ###
canvas_id, sis_id, short_name, account_id, status = line.replace(
"\n", ""
).split(",")
notes = ""
canvas_course = None
try:
canvas_course = canvas.get_course(canvas_id)
published = status
except:
notes = "couldnt find course"
published = "ERROR"
if canvas_course:
if (
int(account_id) not in WHARTON_ACCOUNTS
): # then we should not update this site!!!!
print("\t school not participating")
notes += "/ NOT WHARTON"
outFile.write(
"%s, %s, %s, %s, %s\n"
% (sis_id, canvas_id, status, published, notes)
)
else: # account id in WHARTON_ACCOUNTS
update = False
try:
# see if the course is connected to SRS
print("\t", canvas_id, sis_id, short_name, account_id, status)
update = False
in_SRS = WH_linked_to_SRS(canvas_id)
if not in_SRS:
print("\t not in SRS")
notes += " not liked to SRS"
update = False
elif int(canvas_id) in WH_EXCLUDE:
print("\t single site to ignore")
notes += " in exclude list"
update = False
else:
update = True
except:
print("ERROR WITH COURSE: ", sis_id, canvas_id)
outFile.write(
"%s, %s, %s, %s, %s\n"
% (sis_id, canvas_id, "err", "err", "err")
)
if update:
print("\t\tshould update course")
try:
canvas_course.update(course={"is_public_to_auth_users": True})
status = "public_to_auth_users"
except:
status = "ERROR"
print(sis_id, canvas_id, status, published, notes)
outFile.write(
"%s, %s, %s, %s, %s\n"
% (sis_id, canvas_id, status, published, notes)
)
"""
return
# print("Start " + filename)
subprocess.run(["curl", "-Lo", filename, "--create-dirs", url],
stdin=subprocess.DEVNULL,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL)
self.q.task_done()
pb.update()
# print("End " + filename)
except queue.Empty:
time.sleep(1)
# Start Main Script
canvas = Canvas("https://lhps.instructure.com/", os.getenv("CANVAS_TOKEN"))
terms = canvas.get_account(1).get_enrollment_terms()
courses = []
folder = "2018-2019/MS"
start = datetime(2018, 7, 1, tzinfo=timezone.utc)
end = datetime(2019, 7, 1, tzinfo=timezone.utc)
school = "MS"
skip_dates = False
for t in terms:
# print(t)
if school in str(t) and (skip_dates or (t.start_at_date > start
and t.end_at_date < end)):
print(t)
# .06 Added more error checking
# .07 Added even more error checking and messaging (will now include in email if it skipped any classes in skip list)
#load configs
home = Path.home() / ".ASAPCanvas" / "ASAPCanvas.json"
confighome = Path.home() / ".ASAPCanvas" / "ASAPCanvas.json"
with open(confighome) as f:
configs = json.load(f)
# Logging
logfilename = Path.home() / ".ASAPCanvas" / configs['logfilename']
logging.basicConfig(filename=str(logfilename), level=logging.INFO)
lastrunplacefilename = Path.home() / ".ASAPCanvas" / configs['ASAPlastposfile']
logging.info('Loaded config file and logfile started')
#-----Canvas Info
Canvas_API_URL = configs['CanvasAPIURL']
Canvas_API_KEY = configs['CanvasAPIKey']
canvas = Canvas(Canvas_API_URL, Canvas_API_KEY)
account = canvas.get_account(1)
emailaddr = '*****@*****.**'
olduseremail = '*****@*****.**'
try:
user = canvas.get_user('agent007','sis_user_id')
print(user.name)
# User has changed their email, take existing email, add it as a login, and make the this new email the sis_login_id
olduseremail = user.login_id #get the current email address
old_profile = user.get_profile()
old_primary_email = old_profile['primary_email']
old_login_id = old_profile['login_id']
# old_login_id = user.get_profile('login_id')
# print(olduseremail)
print(old_primary_email)
print(old_login_id)
class TestGroupCategory(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
register_uris({"course": ["get_by_id", "create_group_category"]},
m)
self.course = self.canvas.get_course(1)
self.group_category = self.course.create_group_category(
"Test String")
# __str__()
def test__str__(self, m):
string = str(self.group_category)
self.assertIsInstance(string, str)
# create_group()
def test_create_group(self, m):
register_uris({"group": ["category_create_group"]}, m)
test_str = "Test Create Group"
response = self.group_category.create_group(name=test_str)
self.assertIsInstance(response, Group)
self.assertTrue(hasattr(response, "name"))
self.assertEqual(response.name, test_str)
# update()
def test_update(self, m):
register_uris({"group": ["category_update"]}, m)
new_name = "Test Update Category"
response = self.group_category.update(name=new_name)
self.assertIsInstance(response, GroupCategory)
# delete_category()
def test_delete_category(self, m):
register_uris({"group": ["category_delete_category"]}, m)
response = self.group_category.delete()
self.assertIsInstance(response, dict)
self.assertEqual(len(response), 0)
# list_groups()
def test_list_groups(self, m):
register_uris({"group": ["category_list_groups"]}, m)
with warnings.catch_warnings(record=True) as warning_list:
response = self.group_category.list_groups()
group_list = [group for group in response]
self.assertEqual(len(group_list), 2)
self.assertIsInstance(group_list[0], Group)
self.assertTrue(hasattr(group_list[0], "id"))
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
# get_groups()
def test_get_groups(self, m):
register_uris({"group": ["category_list_groups"]}, m)
response = self.group_category.get_groups()
group_list = [group for group in response]
self.assertEqual(len(group_list), 2)
self.assertIsInstance(group_list[0], Group)
self.assertTrue(hasattr(group_list[0], "id"))
# list_users()
def test_list_users(self, m):
from canvasapi.user import User
register_uris({"group": ["category_list_users"]}, m)
with warnings.catch_warnings(record=True) as warning_list:
response = self.group_category.list_users()
user_list = [user for user in response]
self.assertEqual(len(user_list), 4)
self.assertIsInstance(user_list[0], User)
self.assertTrue(hasattr(user_list[0], "user_id"))
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
# get_users()
def test_get_users(self, m):
from canvasapi.user import User
register_uris({"group": ["category_list_users"]}, m)
response = self.group_category.get_users()
user_list = [user for user in response]
self.assertEqual(len(user_list), 4)
self.assertIsInstance(user_list[0], User)
self.assertTrue(hasattr(user_list[0], "user_id"))
# assign_members()
def test_assign_members(self, m):
from canvasapi.progress import Progress
from canvasapi.paginated_list import PaginatedList
requires = {
"group":
["category_assign_members_true", "category_assign_members_false"]
}
register_uris(requires, m)
result_true = self.group_category.assign_members(sync=True)
return_false = self.group_category.assign_members()
self.assertIsInstance(result_true, PaginatedList)
self.assertIsInstance(return_false, Progress)
class TestAssignment(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
register_uris({"course": ["get_by_id", "get_assignment_by_id"]}, m)
self.course = self.canvas.get_course(1)
self.assignment = self.course.get_assignment(1)
def test__init__overrides(self, m):
register_uris({"assignment": ["get_assignment_with_overrides"]}, m)
assignment = self.course.get_assignment(1)
self.assertTrue(hasattr(assignment, "overrides"))
self.assertIsInstance(assignment.overrides, list)
self.assertEqual(len(assignment.overrides), 1)
self.assertIsInstance(assignment.overrides[0], AssignmentOverride)
# create_override()
def test_create_override(self, m):
register_uris({"assignment": ["create_override"]}, m)
override = self.assignment.create_override(
assignment_override={
"student_ids": [1, 2, 3],
"title": "New Assignment Override",
})
self.assertIsInstance(override, AssignmentOverride)
self.assertEqual(override.title, "New Assignment Override")
# delete()
def test_delete_assignments(self, m):
register_uris({"assignment": ["delete_assignment"]}, m)
deleted_assignment = self.assignment.delete()
self.assertIsInstance(deleted_assignment, Assignment)
# edit()
def test_edit_assignment(self, m):
register_uris({"assignment": ["edit_assignment"]}, m)
name = "New Name"
edited_assignment = self.assignment.edit(assignment={"name": name})
self.assertIsInstance(edited_assignment, Assignment)
self.assertTrue(hasattr(edited_assignment, "name"))
self.assertEqual(edited_assignment.name, name)
# get_gradeable_students()
def test_get_gradeable_students(self, m):
register_uris({"course": ["list_gradeable_students"]}, m)
students = self.assignment.get_gradeable_students()
student_list = [student for student in students]
self.assertEqual(len(student_list), 2)
self.assertIsInstance(student_list[0], UserDisplay)
# get_override()
def test_get_override(self, m):
register_uris({"assignment": ["get_assignment_override"]}, m)
override = self.assignment.get_override(1)
self.assertIsInstance(override, AssignmentOverride)
# get_overrides()
def test_get_overrides(self, m):
register_uris(
{
"assignment": [
"list_assignment_overrides",
"list_assignment_overrides_p2",
]
},
m,
)
overrides = self.assignment.get_overrides()
override_list = [override for override in overrides]
self.assertEqual(len(override_list), 4)
self.assertIsInstance(override_list[0], AssignmentOverride)
self.assertIsInstance(override_list[3], AssignmentOverride)
# get_peer_reviews()
def test_get_peer_reviews(self, m):
register_uris({"assignment": ["list_peer_reviews"]}, m)
peer_reviews = self.assignment.get_peer_reviews()
peer_review_list = [peer_review for peer_review in peer_reviews]
self.assertEqual(len(peer_review_list), 2)
self.assertIsInstance(peer_review_list[0], PeerReview)
# get_submission()
def test_get_submission(self, m):
register_uris(
{
"submission": ["get_by_id_course"],
"user": ["get_by_id"]
}, m)
user_id = 1
submission_by_id = self.assignment.get_submission(user_id)
self.assertIsInstance(submission_by_id, Submission)
self.assertTrue(hasattr(submission_by_id, "submission_type"))
user = self.canvas.get_user(user_id)
submission_by_obj = self.assignment.get_submission(user)
self.assertIsInstance(submission_by_obj, Submission)
self.assertTrue(hasattr(submission_by_obj, "submission_type"))
# get_submissions()
def test_get_submissions(self, m):
register_uris({"submission": ["list_submissions"]}, m)
submissions = self.assignment.get_submissions()
submission_list_by_id = [submission for submission in submissions]
self.assertEqual(len(submission_list_by_id), 2)
self.assertIsInstance(submission_list_by_id[0], Submission)
# set_extensions()
def test_set_extensions(self, m):
register_uris({"assignment": ["set_extensions"]}, m)
extension = self.assignment.set_extensions([{
"user_id": 3,
"extra_attempts": 2
}, {
"user_id": 2,
"extra_attempts": 2
}])
self.assertIsInstance(extension, list)
self.assertEqual(len(extension), 2)
self.assertIsInstance(extension[0], AssignmentExtension)
self.assertEqual(extension[0].user_id, 3)
self.assertTrue(hasattr(extension[0], "extra_attempts"))
self.assertEqual(extension[0].extra_attempts, 2)
self.assertIsInstance(extension[1], AssignmentExtension)
self.assertEqual(extension[1].user_id, 2)
self.assertTrue(hasattr(extension[1], "extra_attempts"))
self.assertEqual(extension[1].extra_attempts, 2)
def test_set_extensions_not_list(self, m):
with self.assertRaises(ValueError):
self.assignment.set_extensions({"user_id": 3, "exrra_attempts": 2})
def test_set_extensions_empty_list(self, m):
with self.assertRaises(ValueError):
self.assignment.set_extensions([])
def test_set_extensions_non_dicts(self, m):
with self.assertRaises(ValueError):
self.assignment.set_extensions([("user_id", 1),
("extra_attempts", 2)])
def test_set_extensions_missing_key(self, m):
with self.assertRaises(RequiredFieldMissing):
self.assignment.set_extensions([{"extra_attempts": 3}])
# submit()
def test_submit(self, m):
register_uris({"assignment": ["submit"]}, m)
sub_type = "online_upload"
sub_dict = {"submission_type": sub_type}
submission = self.assignment.submit(sub_dict)
self.assertIsInstance(submission, Submission)
self.assertTrue(hasattr(submission, "submission_type"))
self.assertEqual(submission.submission_type, sub_type)
def test_submit_fail(self, m):
with self.assertRaises(RequiredFieldMissing):
self.assignment.submit({})
def test_submit_file(self, m):
register_uris({"assignment": ["submit", "upload", "upload_final"]}, m)
filename = "testfile_assignment_{}".format(uuid.uuid4().hex)
try:
with open(filename, "w+") as file:
sub_type = "online_upload"
sub_dict = {"submission_type": sub_type}
submission = self.assignment.submit(sub_dict, file)
self.assertIsInstance(submission, Submission)
self.assertTrue(hasattr(submission, "submission_type"))
self.assertEqual(submission.submission_type, sub_type)
finally:
cleanup_file(filename)
def test_submit_file_wrong_type(self, m):
filename = "testfile_assignment_{}".format(uuid.uuid4().hex)
sub_type = "online_text_entry"
sub_dict = {"submission_type": sub_type}
with self.assertRaises(ValueError):
self.assignment.submit(sub_dict, filename)
def test_submit_file_upload_failure(self, m):
register_uris({"assignment": ["submit", "upload", "upload_fail"]}, m)
filename = "testfile_assignment_{}".format(uuid.uuid4().hex)
try:
with open(filename, "w+") as file:
sub_type = "online_upload"
sub_dict = {"submission_type": sub_type}
with self.assertRaises(CanvasException):
self.assignment.submit(sub_dict, file)
finally:
cleanup_file(filename)
# __str__()
def test__str__(self, m):
string = str(self.assignment)
self.assertIsInstance(string, str)
# submissions_bulk_update()
def test_submissions_bulk_update(self, m):
register_uris({"assignment": ["update_submissions"]}, m)
register_uris({"progress": ["course_progress"]}, m)
progress = self.assignment.submissions_bulk_update(grade_data={
"1": {
"posted_grade": 97
},
"2": {
"posted_grade": 98
}
})
self.assertIsInstance(progress, Progress)
self.assertTrue(progress.context_type == "Course")
progress = progress.query()
self.assertTrue(progress.context_type == "Course")
# upload_to_submission()
def test_upload_to_submission_self(self, m):
register_uris({"assignment": ["upload", "upload_final"]}, m)
filename = "testfile_assignment_{}".format(uuid.uuid4().hex)
try:
with open(filename, "w+") as file:
response = self.assignment.upload_to_submission(file)
self.assertTrue(response[0])
self.assertIsInstance(response[1], dict)
self.assertIn("url", response[1])
finally:
cleanup_file(filename)
def test_upload_to_submission_user(self, m):
register_uris({"assignment": ["upload_by_id", "upload_final"]}, m)
filename = "testfile_assignment_{}".format(uuid.uuid4().hex)
user_id = 1
try:
with open(filename, "w+") as file:
response = self.assignment.upload_to_submission(file, user_id)
self.assertTrue(response[0])
self.assertIsInstance(response[1], dict)
self.assertIn("url", response[1])
finally:
cleanup_file(filename)
for d in dictionary:
list1.append(d[0:8])
if (dictionary[d[0:8]] >= 80):
list2.append(dictionary[d[0:8]] / 4)
else:
list2.append(dictionary[d[0:8]])
# In[6]:
API_KEY = open(".canvas_api_key").readline().rstrip('\n')
API_URL = "https://canvas.ubc.ca"
# In[15]:
canvas = Canvas(API_URL, API_KEY)
dict = {}
dict2 = {}
dict3 = {}
list1 = []
list2 = []
all_courses = list(canvas.get_courses())
curr_courses = list(
filter(lambda c: hasattr(c, 'name') and isCourse(c), all_courses))
#Get submissions and assignments
for c in curr_courses:
dict[c.name[0:8]] = list(c.get_assignments())
dict2[c.name[0:8]] = list(c.get_multiple_submissions())
for c in curr_courses:
import pandas as pd
import numpy as np
from iki.models import User
from canvasapi import Canvas
from utils.AccessRights import can_use_data, load_access_file
from django.conf import settings
API_URL = open(settings.API_DIR + 'api_url.txt', 'r').readlines()[0].strip()
# Canvas API key
API_KEY = open(settings.API_DIR + 'api_key.txt', 'r').readlines()[0].strip()
# Initialize a new Canvas object
canvas = Canvas(API_URL, API_KEY)
def create_training_set(n_assessments, graded_assignments_names):
"""
Loads the previous years grades and final grades from csv files and turns it into trainable data
:param n_assessments: how many assignments have been graded so far for a user
:return: train_data containing the historical assignment grades, train_grades containing the historical final grades.
"""
# todo: change position of presentation assignments accordingly to the release date of the grade
data2018 = pd.read_csv(settings.FILES_DIR + "grades2018.csv")
data2017 = pd.read_csv(settings.FILES_DIR + "grades2017.csv")
data2019 = pd.read_csv(settings.FILES_DIR + "grades2019.csv")
# data = np.append(np.append(data2018.values, data2017.values, 0), data2019.values, 0)
# data = np.append(data2018.values, data2017.values, 0)
# train_grades = data[:, -1]
data = pd.concat([data2018, data2017], ignore_index=True)
train_data = data[graded_assignments_names].values
