def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
'poll': ['get_poll'],
'poll_session': ['get_session'],
'poll_submission': ['get_submission']
}
register_uris(requires, m)
self.poll = self.canvas.get_poll(1)
self.poll.poll_session = self.poll.get_session(1)
self.poll.poll_session.poll_submission = self.poll.poll_session.get_submission(
1)
def download_files(filename_frag: str):
"""Downloads files from Canvas with `filename_frag` in filename."""
url = os.getenv("CANVAS_URL")
token = os.getenv("CANVAS_TOKEN")
course_id = 33395
canvas = Canvas(url, token)
course = canvas.get_course(course_id)
for f in course.get_files():
if filename_frag in f.filename:
print(f.filename, f.id)
file = course.get_file(f.id)
file.download(file.filename)
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
"account": ["get_by_id"],
"course": ["get_by_id"],
"external_tool": ["get_by_id_account", "get_by_id_course"],
}
register_uris(requires, m)
self.course = self.canvas.get_course(1)
self.account = self.canvas.get_account(1)
self.ext_tool_course = self.course.get_external_tool(1)
self.ext_tool_account = self.account.get_external_tool(1)
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
'course': ['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)
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"],
"assignment": ["get_assignment_override"],
},
m,
)
self.course = self.canvas.get_course(1)
self.assignment = self.course.get_assignment(1)
self.assignment_override = self.assignment.get_override(1)
def student():
canvas = Canvas(
app.config["OAUTH_CREDENTIALS"]["canvas"]["base_url"],
app.config["API"]["canvas"]["token"],
)
data = request.args
try:
rollups = Outcomes.get_student_rollups(
canvas, data.get("course_id"), data.get("student_id")
)
return jsonify(rollups)
except exceptions.BadRequest as e:
app.logger.debug(e)
return json.dumps({"success": False}), 400, {"Content-Type": "application/json"}
def get_course_assignment(course: int, assignment: int):
API_URL = "https://canvas.ubc.ca/" # default is canvas.ubc
API_KEY = os.getenv("CANVAS_API") # canvas.ubc instructor token
canvas = Canvas(API_URL, API_KEY)
course = canvas.get_course(course)
assignment = course.get_assignment(assignment)
rubric = (pd.DataFrame(assignment.rubric).set_index('id'))
all_submissions = list(assignment.get_submissions())
valid_submissions = [
sub for sub in all_submissions if sub.submission_type is not None
]
invalid_submission = [
sub for sub in all_submissions if sub.submission_type is None
]
return course, assignment, rubric, valid_submissions, invalid_submission
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
"poll": ["get_poll"],
"poll_session": ["get_session"],
"poll_submission": ["get_submission"],
}
register_uris(requires, m)
self.poll = self.canvas.get_poll(1)
self.poll.poll_session = self.poll.get_session(1)
self.poll.poll_session.poll_submission = (
self.poll.poll_session.get_submission(1)
)
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
"current_user": [
"add_favorite_course",
"add_favorite_group",
"get_by_id",
]
}
register_uris(requires, m)
self.user = self.canvas.get_current_user()
self.favorite_course = self.user.add_favorite_course(1)
self.favorite_group = self.user.add_favorite_group(1)
def main():
# Initialize a new Canvas object
URL = "school email here"
TOKEN = "token here"
canvas = Canvas(URL, TOKEN)
flag = True
while flag:
choice = int(input("enter 1 for printclass or 2 for userlasses"))
if choice == 1:
printclass(canvas)
elif choice == 2:
userclasses(canvas)
choice2 = str(input("continue?"))
choice2.lower()
if choice2 == "n" or choice2 == "no":
flag = False
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 countEnrollments(
inputfile="NEW_NEWcanvasSitesFile.txt",
outputfile="ProvisionedSitesEnrollmentCount.csv",
):
canvas = Canvas(API_URL, API_KEY)
total = 3042
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\n" % ("canvas_id", "student_enrollments", "instructor_enrollments")
)
counter = 0
for line in dataFile:
counter += 1
if counter % 25 == 0:
print("%s/%s done" % (counter, total))
student_count = 0
instructor_count = 0
course_code, canvas_id = line.split(",")
try: # well if there is no Canvas course.
course = canvas.get_course(canvas_id)
try:
student_enrollments = course.get_enrollments(type=["StudentEnrollment"])
except:
student_enrollments = []
try:
instructor_enrollments = course.get_enrollments(
type=["TeacherEnrollment"]
)
except:
instructor_enrollments = []
for s_e in student_enrollments:
student_count += 1
for i_e in instructor_enrollments:
instructor_count += 1
print(canvas_id, student_count, instructor_count)
outFile.write("%s,%s,%s\n" % (canvas_id, student_count, instructor_count))
except:
outFile.write("%s,%s,%s\n" % (canvas_id, "ERR", "ERR"))
def main():
canvas = Canvas(API_URL, API_KEY)
# First, retrieve the Course object
course = canvas.get_course(COURSE_ID)
users = get_students(course)
for user in users:
# print (user.to_json()) # This calls the to_json method inside super canvasapi/canvasobject.py
# print(user.__repr__()) # This calls the __repr__ method inside super canvasobject.py and leaves nothing behind
# print(user) # This calls the __str__ method for the User object(see canvasapi/user.py) that prints out only name and id
print(user.id, end=" ") # could also print user.name
try:
print(user.login_id) # The beginning of the schools mail address
except AttributeError:
print("\nError: No login_id for:", user.id, user.name,"or your account does not have rights to view this content, Contact admin")
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
self.course_epub_export = CourseEpubExport(
self.canvas._Canvas__requester,
{
"name": "course1",
"id": 1,
"epub_export": {
"id": 1,
"created_at": "2019-01-01T00:00:00Z",
"progress_url": "https://dummyurl.com/api/v1/progress/4",
"user_id": 4,
"workflow_state": "exported",
},
},
)
def main(api_url, api_key, course_id, assignment_id, rubric_id, input, no_sum,
header):
canvas = Canvas(api_url, api_key)
course = canvas.get_course(course_id)
print('Course:', course)
assignment = course.get_assignment(assignment_id)
print('Assignment:', assignment)
rubric_criteria = None
if rubric_id:
rubric = course.get_rubric(rubric_id)
print('Rubric:', rubric)
rubric_detail = None
if 'data' in rubric.__dict__:
rubric_detail = rubric.data
else:
rubric_with_assessments = course.get_rubric(rubric_id,
include='assessments',
style='full')
if 'assessments' in rubric_with_assessments.__dict__:
rubric_detail = rubric_with_assessments.assessments[0]['data']
if rubric_detail:
rubric_criteria = [x['criterion_id'] for x in rubric_detail]
print('Rubric Criteria:', rubric_criteria)
else:
print('Fetch Rubric data failed.')
rubric_criteria = None
reader = csv.reader(input)
rubric_description = None
for row in reader:
if header:
rubric_description = row[1:]
header = False
continue
uid = row[0]
grades = row[1:]
if no_sum:
grade = grades[-1]
else:
grade = sum(map(float, grades))
update_grade(assignment=assignment,
uid=uid,
grade=grade,
grades=grades,
rubric_criteria=rubric_criteria,
rubric_description=rubric_description)
def enroll_instructors(sis_id, instructors):
# Initialize a new Canvas object
canvas = Canvas(API_URL, API_KEY)
canvas_course = canvas.get_course(sis_id)
section = canvas_course.get_sections()[0]
for instructor in instructors:
user = get_user_by_sis(instructor)
if user:
canvas_course.enroll_user(user.id,
'TeacherEnrollment',
enrollment={
'enrollment_state': 'active',
'course_section_id': section.id
})
else:
print("cant find %s" % instructor)
print(canvas_course)
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
"account": ["get_by_id", "get_features"],
"course": ["get_by_id", "get_features"],
"user": ["get_by_id", "get_features"],
}
register_uris(requires, m)
self.account = self.canvas.get_account(1)
self.course = self.canvas.get_course(1)
self.user = self.canvas.get_user(1)
self.feature_account = self.account.get_features()[0]
self.feature_course = self.course.get_features()[0]
self.feature_user = self.user.get_features()[0]
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
class CourseDict(dict):
pass
self.course = CourseDict()
self.course.id = 1
self.course.name = "Demo"
self.course.sis_course_id: None
self.course.uuid = "WvAHhY5FINzq5IyRIJybGeiXyFkG3SqHUPb7jZY5"
self.course.integration_id = None
self.course.sis_import_id = 34
self.course.start_at = "2018-06-01T00:00:00Z"
self.course.created_at = "2020-05-25T00:00:00Z"
def ok(self, _event=None):
self.token = self.e.get()
if not self.token:
self.display_error('Please enter a token from UC Scout.')
return
canvas = Canvas(API_URL, self.token)
try:
canvas.get_current_user()
except (ResourceDoesNotExist, InvalidAccessToken, ValueError) as error:
self.display_error(str(error))
return
save_token(self.token)
self.root.destroy()
def SAS_teacher_info(inputfile="test2.txt",
outputfile="SAS_teachers_2020B.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("canvas_id,name, email,pennkey\n")
for line in dataFile:
canvas_id = line.replace("\n", "")
try:
user = canvas.get_user(canvas_id)
outFile.write("%s,%s,%s,%s\n" %
(canvas_id, user.name, user.email, user.login_id))
except Exception:
outFile.write("%s,err,err,err\n" % (canvas_id))
def get_available_courses_for_user(selected_only=False):
canvas = Canvas(os.environ.get("API_URL"), os.environ.get("API_KEY"))
if selected_only == True:
user_config = fileUtils.load_config(values.config_path)
course_list = dict()
courses = canvas.get_courses(enrollment_state="active",
enrollment_type="student")
for course in courses:
if selected_only == True:
if course.id in user_config["courses"]:
course_list[course.course_code.replace(" ", "")] = course
else:
course_list[course.course_code.replace(" ", "")] = course
return course_list
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
self.submission = QuizSubmission(
self.canvas._Canvas__requester,
{
"id": 1,
"quiz_id": 1,
"user_id": 1,
"course_id": 1,
"submission_id": 1,
"attempt": 3,
"validation_token": "this is a validation token",
"manually_unlocked": None,
"score": 7,
},
)
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
'course':
['get_blueprint', 'get_by_id', 'list_blueprint_subscriptions'],
'blueprint': ['show_blueprint_migration']
}
register_uris(requires, m)
self.course = self.canvas.get_course(1)
self.blueprint = self.course.get_blueprint(1)
self.blueprint_migration = self.blueprint.show_blueprint_migration(
1)
self.blueprint_subscription = self.course.list_blueprint_subscriptions(
)[0]
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
"course": [
"get_blueprint",
"get_by_id",
"list_blueprint_subscriptions",
],
"blueprint": ["show_blueprint_migration"],
}
register_uris(requires, m)
self.course = self.canvas.get_course(1)
self.blueprint = self.course.get_blueprint(1)
self.blueprint_migration = self.blueprint.show_blueprint_migration(1)
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',
'list_gradeable_students'
]
}, m)
self.course = self.canvas.get_course(1)
self.assignment = self.course.get_assignment(1)
self.userDisplays = self.assignment.get_gradeable_students()
self.userDisplayList = [ud for ud in self.userDisplays]
self.userDisplay = self.userDisplayList[0]
def test():
canvas = Canvas(API_URL, API_KEY)
course = canvas.get_course(1494867)
tabs = course.get_tabs()
counter = 1
libguide=False
for tab in tabs:
print(counter)
if tab.id =='context_external_tool_89961':
print(tab.id,tab.label,tab.visibility)
if tab.visibility == 'admins':
pass # the tab is not active
else:
libguide = True
break
counter+=1
print(counter,libguide)
def run_export():
print("Welcome to the Canvas Student Data Export Tool\n")
# Initialize a new Canvas object
canvas = Canvas(API_URL, API_KEY)
print("Creating output directory: " + DL_LOCATION + "\n")
# Create directory if not present
if not os.path.exists(DL_LOCATION):
os.makedirs(DL_LOCATION)
all_courses_views = []
print("Getting list of all courses\n")
courses = canvas.get_courses(include="term")
for course in courses:
course_view = get_course_view(course)
all_courses_views.append(course_view)
print(" Getting modules and downloading module files")
course_view.modules = find_course_modules(course, course_view)
print(" Exporting all course data")
export_all_course_data(course_view)
print("Exporting data from all courses combined as one file: "
"all_output.json")
json_str = json.dumps(json.loads(
jsonpickle.encode(all_courses_views, unpicklable=False)),
indent=4)
all_output_path = os.path.join(DL_LOCATION, "all_output.json")
with open(all_output_path, "w") as out_file:
out_file.write(json_str)
print("\nProcess complete. All canvas data exported!")
#if __name__ == '__main__':
# run_export()
def raise_quota(
inputfile="storage_quota.csv",
outputfile="RESULT_storage_quota.csv",
incr=1000,
use_sis_id=False,
):
# quota raise step 2
# storage_quota_mb
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" % ("subaccount_id", "course_id", "old_quota", "new_quota")
)
for line in dataFile:
if use_sis_id and line[:4] != "SRS_":
canvas_course_id = code_to_sis(line.replace("\n", ""))
else:
canvas_course_id = line.replace("\n", "")
try:
canvas_course = canvas.get_course(canvas_course_id, use_sis_id=use_sis_id)
outFile.write("%s,%s," % (canvas_course.account_id, canvas_course_id))
except:
canvas_course = None
outFile.write("%s,%s," % ("ERR", canvas_course_id))
if canvas_course:
old_quota = canvas_course.storage_quota_mb
print("old quota ", old_quota)
new_quota = old_quota + incr
print("new quota ", new_quota)
try:
canvas_course.update(course={"storage_quota_mb": new_quota})
except:
new_quota = "ERROR"
print("\t failed to raise quota (%s)" % canvas_course_id)
outFile.write("%s,%s\n" % (old_quota, new_quota))
else:
# no canvas course
outFile.write("%s,%s\n" % ("NA", "NA"))
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
"course": ["get_by_id", "single_content_export"],
"group": ["get_by_id", "single_content_export"],
"user": ["get_by_id", "single_content_export"],
}
register_uris(requires, m)
self.course = self.canvas.get_course(1)
self.group = self.canvas.get_group(1)
self.user = self.canvas.get_user(1)
self.content_export_course = self.course.get_content_export(11)
self.content_export_group = self.group.get_content_export(11)
self.content_export_user = self.user.get_content_export(11)
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
self.grouped_submission = GroupedSubmission(
self.canvas._Canvas__requester,
{
'user_id':
1,
'submissions': [{
'id': 1,
'assignment_id': 1,
'user_id': 1,
"html_url":
"https://example.com/courses/1/assignments/1/submissions/1",
"submission_type": "online_upload",
}],
},
)
