canvas-sak 1.0.0__tar.gz

canvas_sak-1.0.0/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

canvas_sak-1.0.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: canvas-sak
+Version: 1.0.0
+Summary: Command‑line Swiss Army Knife for Canvas LMS
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: arrow==1.2.3
+Requires-Dist: beautifulsoup4==4.12.2
+Requires-Dist: canvasapi
+Requires-Dist: certifi==2023.7.22
+Requires-Dist: charset-normalizer==3.2.0
+Requires-Dist: click==8.1.3
+Requires-Dist: colorama==0.4.6
+Requires-Dist: idna==3.4
+Requires-Dist: lxml==4.9.3
+Requires-Dist: Markdown==3.4.4
+Requires-Dist: markdownify==0.11.6
+Requires-Dist: mosspy==1.0.9
+Requires-Dist: python-dateutil==2.8.2
+Requires-Dist: pytz==2023.3
+Requires-Dist: requests==2.28.2
+Requires-Dist: six==1.16.0
+Requires-Dist: soupsieve==2.4.1
+Requires-Dist: urllib3==1.26.16
+Dynamic: license-file
+
+# canvas_sak
+a command-line python based tool for teachers who use canvas. 
+
+you can download from canvas_sak from pip
+
+you will need to grab a "token" from your canvas account. go to the canvas webpage -> click on Account in the upper left -> click Settings -> scroll down and click the New Access Token button. you will need to put the token in a configuration file. `python3 canvas_sak.pyz help-me-setup` will tell you how and where to create that configuration file.
+
+at this point the main thing this tool does is grade discussion assignments for participation: 1 point for posting and 1 point for replying.
+
+it also will collect names and categories of assignments that past students excelled at for writing future letters of recommendation.

canvas_sak-1.0.0/README.md

@@ -0,0 +1,10 @@
+# canvas_sak
+a command-line python based tool for teachers who use canvas. 
+
+you can download from canvas_sak from pip
+
+you will need to grab a "token" from your canvas account. go to the canvas webpage -> click on Account in the upper left -> click Settings -> scroll down and click the New Access Token button. you will need to put the token in a configuration file. `python3 canvas_sak.pyz help-me-setup` will tell you how and where to create that configuration file.
+
+at this point the main thing this tool does is grade discussion assignments for participation: 1 point for posting and 1 point for replying.
+
+it also will collect names and categories of assignments that past students excelled at for writing future letters of recommendation.

canvas_sak-1.0.0/canvas_sak/canvas_sak.py

@@ -0,0 +1,8 @@
+import canvas_sak.core
+from canvas_sak.commands import *
+
+def main():
+    canvas_sak.core.canvas_sak()
+
+if __name__ == "__main__":
+    main()

canvas_sak-1.0.0/canvas_sak/commands/__init__.py

@@ -0,0 +1,17 @@
+__all__ = [
+    "code_similarity",
+    "collect_reference_info",
+    "download_canvas_course",
+    "download_submissions",
+    "export_letter_grade",
+    "grade_discussion",
+    "help_me_setup",
+    "list_courses",
+    "list_students",
+    "message_students",
+    "min_grade_analyzer",
+    "set_fudge_points",
+    "set_letter_grade",
+    "upload_canvas_course",
+    "quiz",
+]

canvas_sak-1.0.0/canvas_sak/commands/code_similarity.py

@@ -0,0 +1,64 @@
+from canvas_sak.core import *
+import glob
+
+@canvas_sak.command()
+@click.argument('course_name', metavar='course')
+@click.argument('assignment_name', metavar='assignment', default='')
+@click.argument('language', metavar='language')
+@click.option('--dryrun/--no-dryrun', default=True, show_default=True, help="only show the grade, don't actually set it")
+@click.option('--pause/--no-pause', default=False, show_default=True, help="pause before uploading")
+@click.option('--multiple/--no-multiple', default=False, show_default=True, help="collect submissions from multiple classes")
+def code_similarity(course_name, language, assignment_name, dryrun, pause, multiple):
+    '''
+    check submissions for code similarity using stanford MOSS.
+    '''
+    canvas = get_canvas_object()
+    courses = get_courses(canvas, course_name)
+    if len(courses) == 0:
+        error(f"no courses matched {course_name}")
+        exit(2)
+    if len(courses) > 1 and not multiple:
+        error(f"multiple matches for {course_name}")
+        for course in courses:
+            error(f"    {course.name}")
+        exit(2)
+
+    parser = ConfigParser()
+    parser.read([config_ini])
+    moss_userid = parser['MOSS']['userid']
+
+    moss = mosspy.Moss(moss_userid, language)
+    with tempfile.TemporaryDirectory("canvas_sak.attach") as tempdir:
+        for course in courses:
+            assignment = get_assignment(course, assignment_name)
+            usermap = {u.id: u.name for u in course.get_users()}
+            submissions = list(assignment.get_submissions())
+            with click.progressbar(length=len(submissions), label="downloading", item_show_func=lambda x: x) as bar:
+                for sub in assignment.get_submissions():
+                    if sub.user_id not in usermap:
+                        continue
+                    udir = f"{tempdir}/{usermap[sub.user_id]}"
+                    os.makedirs(udir)
+                    bar.update(1, usermap[sub.user_id])
+                    for attachment in sub.attachments:
+                        aname = f"{udir}/{attachment.filename}"
+                        with open(aname, "wb") as f:
+                            f.write(requests.get(attachment.url).content)
+                        if aname.endswith(".zip"):
+                            with zipfile.ZipFile(aname, "r") as zf:
+                                zf.extractall(udir)
+        files_to_upload = [x for x in glob.glob(f"{tempdir}/**/*.{language}") if '/__MACOSX/' not in x]
+        info(f"uploading {files_to_upload}")
+
+        if pause:
+            input(f"pausing. code is in {tempdir}. hit enter to continue")
+        if dryrun:
+            info(f"would upload {len(files_to_upload)} files to MOSS")
+        else:
+            for file in files_to_upload:
+                moss.addFile(file)
+            count = len(moss.files)
+            with click.progressbar(length=count, label="uploading", item_show_func=lambda x: x) as bar:
+                moss_url = moss.send(on_send=lambda fp, dn: bar.update(1, dn))
+            info(f"results at {moss_url}")
+            info(f"download with: wget -k -e robots=off -np -r {moss_url}")

canvas_sak-1.0.0/canvas_sak/commands/collect_reference_info.py

@@ -0,0 +1,52 @@
+from canvas_sak.core import *
+
+@canvas_sak.command()
+@click.argument("course")
+@click.option('-t', 'thresholds', metavar='threshold', multiple=True, default=[84, 90, 95], show_default=True,
+              type=click.INT, help="""
+              assignment groups with grades about the lowest threshold will have a +, the next
+              lowest gets ++, and so on. assignment groups below the lowest threshold will not
+              be printed.
+              """)
+@click.option('-s', 'skip', metavar='skip_assignment', multiple=True, default=['iclickr', 'ungraded', 'imported'],
+              show_default=True, help="""
+              assignment groups with the listed keywords will not be collected.
+              """)
+def collect_reference_info(course, thresholds, skip):
+    '''collect high level information about students of previous classes to help writing reference letters'''
+    Grade = namedtuple('Grade', ['category', 'grade'])
+    canvas = get_canvas_object()
+    for course in get_courses(canvas, course, is_active=False, is_finished=True):
+        results = canvas.graphql('query { course(id: "' + str(course.id) + '''") {
+              assignmentGroupsConnection {
+                  nodes { name
+                          gradesConnection {
+                              edges { node { currentScore
+                                             enrollment { user { name } }
+                                           } } } } } } }''')
+        grades_by_student = defaultdict(list)
+
+        for assignment_group in results['data']['course']['assignmentGroupsConnection']['nodes']:
+            category = assignment_group['name']
+            if any(x in category.lower() for x in skip):
+                continue
+            for grade in assignment_group['gradesConnection']['edges']:
+                score = grade['node']['currentScore']
+                name = grade['node']['enrollment']['user']['name']
+                if score:
+                    pluses = to_plus(score, thresholds)
+                    if pluses:
+                        grades_by_student[name].append(Grade(category, pluses))
+        for i in grades_by_student.items():
+            label = f'{i[0]}@{format_course_name(course.name)}'
+            output(f'{label} {" ".join([g.category + ":" + g.grade for g in i[1]])}')
+
+def to_plus(grade, levels):
+    """ convert a score to a list of pluses based on grade """
+    pluses = ""
+    for level in levels:
+        if grade >= level:
+            pluses += '+'
+    return pluses
+
+

canvas_sak-1.0.0/canvas_sak/commands/download_canvas_course.py

@@ -0,0 +1,200 @@
+from canvas_sak.commands.upload_canvas_course import page_name_to_url
+from canvas_sak.core import *
+from canvas_sak.md2fhtml import *
+
+
+def download_modules(course, target, dryrun):
+    def base_inner_module_to_str(module_item):
+        return f'{"  " * (module_item.indent + 1)}* {sanitize(module_item.title)}; {module_item.type}{"" if module_item.published else "; published=False"}'
+
+    def named_inner_module_to_str(module_item):
+        module_item_target_name = None
+        if hasattr(module_item, 'content_id'):
+            module_item_target_name = rr4id[module_item.type + str(module_item.content_id)].name
+        else:
+            module_item_target_name = rr4url[module_item.page_url].name
+
+        if module_item_target_name == module_item.title:
+            module_item_target_name = None
+
+        return f'{base_inner_module_to_str(module_item)}{f"; target={module_item_target_name}" if module_item_target_name else ""}'
+
+    def external_tool(mi):
+        return f'{base_inner_module_to_str(mi)}; newtab={"True" if mi.new_tab else "False"}; url={mi.external_url}'
+
+    module_renderers = {
+        "Assignment": named_inner_module_to_str,
+        "File": named_inner_module_to_str,
+        "Page": named_inner_module_to_str,
+        "Quiz": named_inner_module_to_str,
+        "Discussion": named_inner_module_to_str,
+        "SubHeader": base_inner_module_to_str,
+        "ExternalUrl": external_tool,
+        "ExternalTool": external_tool,
+    }
+
+    top_modules = []
+    id2name = {}
+    output = ''
+    for module in course.get_modules():
+        id2name[module.id] = module.name
+        ms = f"# {module.name}"
+        if module.unlock_at:
+            ms += f"; unlock={module.unlock_at}"
+        if module.require_sequential_progress:
+            ms += f"; sequential"
+        if module.prerequisite_module_ids:
+            ms += f"; prereqs={','.join([id2name[id] for id in module.prerequisite_module_ids])}"
+        if hasattr(module, "completed_at") and module.completed_at:
+            ms += f"; completed={module.completed_at}"
+        if not module.published:
+            ms += f"; published=False"
+        output += ms + '\n'
+        for item in module.get_module_items():
+            if item.type in module_renderers:
+                output += module_renderers[item.type](item) + '\n'
+            else:
+                warn(f"cannot render {item.__dict__}")
+
+    if dryrun:
+        info(f"would have written:\n{output}to {target}")
+    else:
+        with open(target, "w") as fd:
+            fd.write(output)
+
+
+def download_discussions(course, target, dryrun):
+    os.makedirs(target, exist_ok=True)
+    for discussion in course.get_discussion_topics():
+        # windows can't have : in the filename :'(
+        target_file = os.path.join(target, discussion.title.strip().replace("\\", "-").replace(":", ";") + ".md")
+        if os.path.exists(target_file):
+            info(f"{target_file} already exists for {discussion.title}")
+        else:
+            if dryrun:
+                info(f"would download {target_file} for {discussion.title}")
+            else:
+                info(f"downloading {target_file} for {discussion.title}")
+                with open(target_file, "w+") as fd:
+                    fd.write(f"# {discussion.title}\n")
+                    # todo: we need to fix up the links based on the rr maps
+                    fd.write(html2mdstr(discussion.message))
+
+
+def download_assignments(course, target, dryrun):
+    pass
+
+
+def fix_links(text):
+    # that funky ( [^\)]*) shouldn't be needed, but i do see trailing names after the URL
+    return re.sub(r"\(https://\w+.instructure.com/courses/\w+/pages/([^ )]+)( [^\)]*)\)", r"(\1)", text)
+
+
+def download_pages(course, target, dryrun):
+    os.makedirs(target, exist_ok=True)
+    for page in course.get_pages(include=["body"]):
+        url = page_name_to_url(page.title)
+        if page.url != url:
+            warn(f"calculated page url for {page.title} ({url}) does not equal {page.url}")
+        if dryrun:
+            info(f"would download {page.title} to {url}")
+        else:
+            with open(os.path.join(target, url) + ".md", "w+") as fd:
+                fd.write(f"published: {page.published}\n")
+                if page.publish_at:
+                    fd.write(f"publish_at: {page.publish_at}\n")
+                if page.front_page:
+                    fd.write(f"front_page: {page.front_page}\n")
+                fd.write(f"title: {page.title}\n")
+                fd.write(fix_links(html2mdstr(page.body)))
+
+
+def download_files(course, target, dryrun):
+    class ToDownload(NamedTuple):
+        file: canvasapi.file.File
+        target: str
+
+    error_seen = False
+    to_download = []
+    for folder in course.get_folders():
+        target_dir = os.path.join(target, str(folder))
+        if os.path.exists(target_dir):
+            if not os.path.isdir(target_dir):
+                error(f"{target_dir} is not a directory. skipping")
+                error_seen = True
+                continue
+        else:
+            if dryrun:
+                info(f"would create {target_dir}")
+            else:
+                os.makedirs(target_dir)
+
+        for file in folder.get_files():
+            full_name = os.path.join(str(folder), str(file))
+            target_file = os.path.join(target_dir, str(file))
+            if dryrun:
+                info(f"would download {full_name} to {target_file}")
+            else:
+                if os.path.exists(target_file):
+                    warn(f"{target_file} already exists. skipping")
+                else:
+                    to_download.append(ToDownload(file, target_file))
+
+    if to_download:
+        with click.progressbar(to_download, label="downloading",
+                               item_show_func=lambda i: str(i.file) if i else "") as tds:
+            for td in tds:
+                td.file.download(td.target)
+    if error_seen:
+        exit(2)
+
+
+def download_announcements(course, target, dryrun):
+    pass
+
+
+@canvas_sak.command()
+@click.argument('course_name', metavar='course')
+@click.option('--dryrun/--no-dryrun', default=True, show_default=True, help="show what would happen, but don't do it.")
+@click.option('--modules/--no-modules', default=False, show_default=True,
+              help=f"download modules to the {click.style('modules', underline=True, italic=True)} file.")
+@click.option('--discussions/--no-discussions', default=False, show_default=True,
+              help=f"download discussions to the {click.style('discussions', underline=True, italic=True)} subdirectory.")
+@click.option('--assignments', default=False, show_default=True,
+              help=f"download assignments to the {click.style('assignments', underline=True, italic=True)} subdirectory.")
+@click.option('--pages/--no-pages', default=False, show_default=True,
+              help=f"download pages to the {click.style('pages', underline=True, italic=True)} subdirectory.")
+@click.option('--files', default=False, show_default=True,
+              help=f"download files to the {click.style('files', underline=True, italic=True)} subdirectory.")
+@click.option('--announcements', default=False, show_default=True,
+              help=f"download announcements to the {click.style('announcements', underline=True, italic=True)} subdirectory.")
+@click.option('--all/--no-all', default=False, show_default=True,
+              help="download all content to corresponding directories")
+@click.option("--target", default='.', show_default=True, help="download content parent directory.")
+def download_course_content(course_name, dryrun, modules, discussions, assignments, pages, files, announcements, all,
+                            target):
+    """download course content from local files"""
+    canvas = get_canvas_object()
+    course = get_course(canvas, course_name, is_active=False)
+    output(f"found {course.name}")
+    map_course_resource_records(course)
+
+    if all:
+        modules = discussions = assignments = pages = files = announcements = True
+
+    if not (modules or discussions or assignments or pages or files or announcements):
+        error("nothing selected to download")
+        exit(1)
+
+    if modules:
+        download_modules(course, os.path.join(target, 'modules'), dryrun)
+    if discussions:
+        download_discussions(course, os.path.join(target, 'discussions'), dryrun)
+    if assignments:
+        download_assignments(course, os.path.join(target, 'assignments'), dryrun)
+    if pages:
+        download_pages(course, os.path.join(target, 'pages'), dryrun)
+    if files:
+        download_files(course, os.path.join(target, 'files'), dryrun)
+    if announcements:
+        download_announcements(course, os.path.join(target, 'announcements'), dryrun)

canvas_sak-1.0.0/canvas_sak/commands/download_submissions.py

@@ -0,0 +1,68 @@
+from canvas_sak.core import *
+
+@canvas_sak.command()
+@click.argument('course_name', metavar='course')
+@click.argument('assignment_name', metavar='assignment', default='')
+@click.option('--dryrun/--no-dryrun', default=True, show_default=True,
+              help="only show the grade, don't actually set it")
+def download_submissions(course_name, assignment_name, dryrun):
+    '''
+    download submissions for an assignment.
+    '''
+
+    canvas = get_canvas_object()
+
+    course = get_course(canvas, course_name)
+
+    assignment = get_assignment(course, assignment_name)
+
+    query = """
+    query submissions($assignmentid: ID!) {
+        assignment(id: $assignmentid) { submissionsConnection {
+            nodes { attachments { url displayName } user { name }
+                    commentsConnection { nodes { comment attachments { url displayName}}}
+            }
+        }}
+    }
+    """
+    result = canvas.graphql(query, {"assignmentid": assignment.id})
+    submissions = result['data']['assignment']['submissionsConnection']['nodes']
+
+    if dryrun:
+        info(f"{len(submissions)} submissions to download")
+        sys.exit(0)
+
+    with click.progressbar(length=len(submissions), label="downloading submission", show_pos=True) as bar:
+        for s in submissions:
+            count = 1
+            name = s['user']['name']
+            dir = os.path.join(assignment_name, name.replace(' ', '-'))
+            os.makedirs(dir, exist_ok=True)
+            for a in s['attachments']:
+                download_attachment(f'{dir}/submission{count}', a)
+                count += 1
+            count = 1
+            for c in s['commentsConnection']['nodes']:
+                with open(os.path.join(dir, f"comment{count}.txt"), 'w') as fd:
+                    fd.write(c['comment'])
+                subcount = 1
+                for ca in c['attachments']:
+                    download_attachment(f'{dir}/comment{count}attachment{subcount}', ca)
+                    subcount += 1
+                count += 1
+            bar.update(1)
+
+
+
+def download_attachment(basename, a):
+    fname = a['displayName']
+    suffix = os.path.splitext(fname)[1]
+    durl = a['url']
+    info(f'downloading {a}')
+    with requests.get(durl) as response:
+        if response.status_code != 200:
+            error(f'error {response.status_code} fetching {durl}')
+            return
+        with open(f"{basename}{suffix}", "wb") as fd:
+            for chunk in response.iter_content():
+                fd.write(chunk)

canvas_sak-1.0.0/canvas_sak/commands/export_letter_grade.py

@@ -0,0 +1,33 @@
+from canvas_sak.core import *
+
+@canvas_sak.command()
+@click.argument("course")
+@click.argument("csv_output_file", type=click.File("w"))
+def export_letter_grade(course, csv_output_file):
+    ''' export course letter grade to CSV
+
+    the "Reported Letter Grade" column must be setup in the gradebook.
+    this command will pull down the letter grades from that column an print a CSV record
+    with the student id and the corresponding letter grade.
+    output will got to the indicated csv_output_file.
+    an output file name of - will go to stdout.
+    '''
+
+    canvas = get_canvas_object()
+    course = get_course(canvas, course)
+
+    rlg_assignment = get_assignment(course, "Reported Letter Grade")
+    if not rlg_assignment:
+        error('the "Reported Letter Grade" assignment hasn\'t been set up')
+        exit(2)
+
+    count = 0
+    csv_output_file.write("Student ID,Grade\n")
+    for submission in rlg_assignment.get_submissions():
+        user = course.get_user(submission.user_id)
+        if user.sis_user_id:
+            csv_output_file.write(f"{user.sis_user_id}, {submission.grade}\n")
+            count += 1
+
+    info(f"{count} records written to {csv_output_file.name}")
+

canvas_sak-1.0.0/canvas_sak/commands/grade_discussion.py

@@ -0,0 +1,80 @@
+from canvas_sak.core import *
+
+@canvas_sak.command()
+@click.argument('course_name', metavar='course')
+@click.argument('assignment_name', metavar='assignment', default='')
+@click.option('--dryrun/--no-dryrun', default=True, show_default=True,
+              help="only show the grade, don't actually set it")
+@click.option('--min-words', default=5, show_default=True, help="the minimum number of valid words to get credit")
+@click.option('--points-comment', default=1, show_default=True, help="number of points for posting a comment")
+@click.option('--max-points', default=2, show_default=True, help="maximum number of points to give")
+def grade_discussion(course_name, assignment_name, dryrun, min_words, points_comment, max_points):
+    '''
+    grade a discussion assignment based on participation.
+
+    one point is added for a post and another for a reply for a total of 2.
+    this tool assumes that the student must post first to reply.
+
+    course_name - any part of an active course name. for example, 249 will match CS249.
+    the course must active (it has not passed the end date) to be eligible for matching.
+    only the first match will be used.
+
+    assignment_name - any part of an assigment's name will be matched. only the first
+    match will be used.
+    '''
+
+    canvas = get_canvas_object()
+
+    course = get_course(canvas, course_name)
+
+    now = datetime.datetime.now(datetime.timezone.utc)
+    assignments = get_assignments(course, assignment_name)
+    for assignment_data in assignments:
+        info(f"grading {assignment_data['title']}")
+        assignment = course.get_assignment(assignment_data['assignment_id'])
+        due_at_date = assignment.due_at_date
+        if due_at_date > now:
+            warn(f"{assignment_data['title']} not due: skipping")
+            continue
+        submissions = assignment.get_submissions()
+        grades = {}
+        skipped = 0
+        processed = 0
+
+        # we calculate the grades and upload them in two steps since the second
+        # step is slow so we want to do a progress bar. we could still do it all
+        # in one pass if we could get the count. i can't find a way to do that
+        # without going through the submissions
+        for s in submissions:
+            processed += 1
+            if not hasattr(s, "discussion_entries"):
+                skipped += 1
+                continue
+
+            grade = 0
+            for entry in s.discussion_entries:
+                entry = DiscussionEntry(None, entry)
+                if entry.created_at_date > due_at_date:
+                    info(
+                        f"skipping discussion from {s.user_id} submitted at {entry.created_at_date} but due {due_at_date}")
+                    continue
+                if count_words(entry.message) > 5:
+                    grade = min(grade + points_comment, max_points)
+
+            grades[s] = grade
+
+        if skipped == processed:
+            error(f"'{assignment.name}' doesn't appear to be a discussion assignment")
+            sys.exit(2)
+
+        info(f"processed {processed}, skipped {skipped}.")
+
+        if dryrun:
+            info("would have posted:")
+            for i in grades.items():
+                info(f"    {i[0]} {i[1]}")
+        else:
+            with click.progressbar(length=len(grades), label="updating grades", show_pos=True) as bar:
+                for i in grades.items():
+                    i[0].edit(submission={'posted_grade': i[1]})
+                    bar.update(1)

canvas_sak-1.0.0/canvas_sak/commands/help_me_setup.py

@@ -0,0 +1,53 @@
+from canvas_sak.core import *
+
+@canvas_sak.command()
+def help_me_setup():
+    """provide guidance through the setup process"""
+    if os.path.isfile(config_ini):
+        info(f"great! {config_ini} exists. let's check it!")
+    else:
+        error(f"""{config_ini} does not exist. you need to create it.
+it should have the form:""")
+        print_config_ini_format(True)
+        sys.exit(2)
+
+    parser = ConfigParser()
+    try:
+        parser.read([config_ini])
+    except:
+        error(f"there was a problem reading {config_ini}. make sure it has the format of:")
+        print_config_ini_format(False)
+
+    check_key("SERVER", parser)
+    url = check_key("url", parser["SERVER"])
+    p = urllib.parse.urlparse(url)
+    if p.scheme != "https":
+        error(f"url in {config_ini} must start with https://")
+        sys.exit(2)
+
+    if p.path:
+        error(f"url in {config_ini} must have the form http://hostname with no other /")
+        sys.exit(2)
+
+    try:
+        with urllib.request.urlopen(url) as con:
+            info(f"{url} is reachable.")
+    except Exception as e:
+        error(f"got '{e}' accessing {url}. please check the url in {config_ini}.")
+        sys.exit(2)
+
+    token = check_key("token", parser["SERVER"])
+    if token and len(token) > 20:
+        info(f"token found. checking to see if it is usable")
+    else:
+        error(f"token is too short. make sure you have copied it correctly from canvas.")
+        sys.exit(2)
+
+    try:
+        canvas = Canvas(url, token)
+        info(f"you are successfully able to use canvas as {canvas.get_current_user().name}")
+    except Exception as e:
+        error(f"problem accessing canvas: {e}")
+        sys.exit(2)
+
+    sys.exit(0)