making-with-code-cli 3.1.0__tar.gz → 4.0.0__tar.gz

{making_with_code_cli-3.1.0 → making_with_code_cli-4.0.0}/PKG-INFO

@@ -1,14 +1,13 @@
 Metadata-Version: 2.3
 Name: making-with-code-cli
-Version: 3.1.0
+Version: 4.0.0
 Summary: Courseware for Making With Code
 License: MIT
 Author: Chris Proctor
 Author-email: chris@chrisproctor.net
-Requires-Python: >=3.10,<4.0
+Requires-Python: >=3.11,<4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

making_with_code_cli-4.0.0/making_with_code_cli/decorators.py

@@ -0,0 +1,19 @@
+from functools import update_wrapper
+import click
+import sys
+from making_with_code_cli.styles import error
+from making_with_code_cli.errors import MWCError
+
+
+def handle_mwc_errors(f):
+    """Decorator declaring a click command. 
+    Wraps execution in a try/catch block, so that MWCErrors can be handled with 
+    graceful output.
+    """
+    def command(*args, **kwargs):
+        try:
+            return f(*args, **kwargs)
+        except MWCError as e:
+            click.echo(error(str(e), preformatted=True), err=True)
+            sys.exit(1)
+    return update_wrapper(command, f)

making_with_code_cli-4.0.0/making_with_code_cli/mwc_accounts_api.py

@@ -0,0 +1,89 @@
+import requests
+import json
+import os
+from pathlib import Path
+from urllib.parse import urljoin
+from getpass import getpass
+from making_with_code_cli.errors import MWCError
+
+MWC_ACCOUNTS_SERVER = "https://accounts.makingwithcode.org"
+
+class MWCAccountsAPI:
+    def __init__(self, mwc_accounts_server=None):
+        self.mwc_accounts_server = mwc_accounts_server or MWC_ACCOUNTS_SERVER
+
+    def login(self, username, password):
+        "Authenticates with a username and password, returning an auth token"
+        data = {"username": username, "password": password}
+        response = self.post("/login", data=data)
+        return self.handle_response(response)
+
+    def logout(self, token):
+        response = self.post("/logout", token=token)
+        return self.handle_response(response)
+
+    def get_status(self, token):
+        response = self.get("/status", token=token)
+        return self.handle_response(response)
+
+    def get_roster(self, token):
+        response = self.get("/roster", token=token)
+        return self.handle_response(response)
+
+    def create_student(self, token, params):
+        response = self.post("/students", data=params, token=token)
+        return self.handle_response(response)
+
+    def update_student(self, token, params):
+        response = self.put("/students", data=params, token=token)
+        return self.handle_response(response)
+
+    def create_section(self, token, params):
+        response = self.post("/sections", data=params, token=token)
+        return self.handle_response(response)
+
+    def update_section(self, token, params):
+        response = self.put("/sections", data=params, token=token)
+        return self.handle_response(response)
+
+    def get(self, url, data=None, token=None):
+        return self.http_request("get", url, data=data, token=token)
+
+    def post(self, url, data=None, token=None):
+        return self.http_request("post", url, data=data, token=token)
+
+    def put(self, url, data=None, token=None):
+        return self.http_request("put", url, data=data, token=token)
+
+    def http_request(self, method, url, data=None, token=None):
+        fn = getattr(requests, method)
+        headers = {"Authorization": f"Token {token}"} if token else None
+        try:
+            return fn(self.mwc_accounts_server + url, data=data, headers=headers)
+        except requests.exceptions.ConnectionError:
+            raise self.ServerError("Could not connect to server")
+
+    def handle_response(self, response):
+        if response.ok:
+            return response.json()
+        elif response.status_code == 500:
+            raise self.ServerError("Error 500")
+        else:
+            try:
+                rj = response.json()
+                raise self.RequestFailed(rj, data=rj)
+            except requests.exceptions.JSONDecodeError:
+                raise self.RequestFailed(response)
+
+    class RequestFailed(MWCError):
+        def __init__(self, *args, data=None, **kwargs):
+            super().__init__(*args, **kwargs)
+            self.data = data
+
+    class ServerError(MWCError):
+        pass
+
+
+
+
+

{making_with_code_cli-3.1.0 → making_with_code_cli-4.0.0}/making_with_code_cli/setup/__init__.py

@@ -5,6 +5,7 @@ import yaml
 from making_with_code_cli.mwc_accounts_api import MWCAccountsAPI
 from making_with_code_cli.git_backend import get_backend
 from making_with_code_cli.update import update
+from making_with_code_cli.decorators import handle_mwc_errors
 from making_with_code_cli.settings import (
     get_settings_path,
     read_settings, 
@@ -42,39 +43,57 @@ from making_with_code_cli.setup.tasks import (
 @click.command()
 @click.option("--config", help="Path to config file (default: ~/.mwc)")
 @click.option("--debug", is_flag=True, help="Show debug-level output")
+@click.option("--git-name", help="Set git name")
+@click.option("--git-email", help="Set git email address")
+@click.option("--mwc-accounts-url", help="Set URL for MWC accounts server")
 @click.pass_context
-def setup(ctx, config, debug):
+@handle_mwc_errors
+def setup(ctx, config, debug, git_name, git_email, mwc_accounts_url):
     """Set up the MWC command line interface"""
     settings = read_settings(config)
+    sp = get_settings_path(config)
     if debug:
-        sp = get_settings_path(config)
         click.echo(debug_fmt(f"Reading settings from {sp}"))
+    if not sp.parent.exists():
+        if click.confirm(confirm(f"Directory {sp.parent} doesn't exist. Create it?")):
+            sp.parent.mkdir(parents=True)
+        else:
+            click.error(f"Could not save config file at {sp}.")
+            return
     rc_tasks = []
     click.echo(address(INTRO_MESSAGE))
     for note in INTRO_NOTES:
         click.echo(address(note, list_format=True))
     click.echo()
+    if git_name:
+        settings['git_name'] = git_name
+    if git_email:
+        settings['git_email'] = git_email
+    if mwc_accounts_url:
+        settings['mwc_accounts_url'] = mwc_accounts_url
     settings['mwc_username'] = choose_mwc_username(settings.get("mwc_username"))
-    api = MWCAccountsAPI()
-    if settings.get('mwc_accounts_token'):
+    api = MWCAccountsAPI(settings.get('mwc_accounts_url'))
+    if not 'mwc_accounts_token' in settings:
+        token = prompt_mwc_password(settings['mwc_username'], api)
+        settings['mwc_accounts_token'] = token
+    while True:
         try:
             status = api.get_status(settings['mwc_accounts_token'])
+            break
         except api.RequestFailed as bad_token:
-            token = prompt_mwc_password(settings['mwc_username'])
+            click.echo(error("Sorry, there was an error logging in."))
+            if debug:
+                click.echo(debug_fmt(bad_token))
+            token = prompt_mwc_password(settings['mwc_username'], api)
             settings['mwc_accounts_token'] = token
-            status = api.get_status(token)
-    else:
-        token = prompt_mwc_password(settings['mwc_username'])
-        settings['mwc_accounts_token'] = token
-        status = api.get_status(token)
-    if debug:
-        click.echo(debug_fmt("MWC Accounts Server status:"))
-        click.echo(debug_fmt(str(status)))
     settings['mwc_git_token'] = status['git_token']
     settings['work_dir'] = str(choose_work_dir(settings.get("work_dir")).resolve())
-    if Platform.detect() & (Platform.MAC | Platform.UBUNTU):
-        settings['editor'] = choose_editor(settings.get('editor', 'code'))
+    settings['editor'] = choose_editor(settings.get('editor', 'code'))
     if debug:
+        if settings.get('mwc_accounts_url'):
+            click.echo(debug_fmt(f"Using custom MWC accounts server: {settings['mwc_accounts_url']}"))
+        click.echo(debug_fmt("MWC Accounts Server status:"))
+        click.echo(debug_fmt(str(status)))
         click.echo(info("MWC settings:"))
         click.echo(info(yaml.dump(settings), preformatted=True))
     write_settings(settings, config)

{making_with_code_cli-3.1.0 → making_with_code_cli-4.0.0}/making_with_code_cli/setup/tasks.py

@@ -94,9 +94,8 @@ def choose_mwc_username(default=None):
         default=default
     )
 
-def prompt_mwc_password(username):
+def prompt_mwc_password(username, api):
     "Asks for the password. Returns a token when successful."
-    api = MWCAccountsAPI()
     while True:
         password = click.prompt(question("What is your MWC password?"), hide_input=True)
         try:
@@ -464,8 +463,8 @@ class GitConfiguration(SetupTask):
             git_config["core.editor"] = self.editorcmds[self.settings.get('editor')]
         if self.settings.get('git_name'):
             git_config["user.name"] = self.settings['git_name']
-        if self.settings.get('github_email'):
-            git_config["user.email"] = self.settings['github_email']
+        if self.settings.get('git_email'):
+            git_config["user.email"] = self.settings['git_email']
         return git_config
 
 

{making_with_code_cli-3.1.0 → making_with_code_cli-4.0.0}/making_with_code_cli/teach/__init__.py

@@ -5,6 +5,8 @@ from making_with_code_cli.teach.status import status
 from making_with_code_cli.teach.log import log
 from making_with_code_cli.teach.patch import patch
 from making_with_code_cli.teach.check import check
+from making_with_code_cli.teach.section import section
+from making_with_code_cli.teach.student import student
 
 @click.group()
 def teach():
@@ -16,3 +18,5 @@ teach.add_command(status)
 teach.add_command(log)
 teach.add_command(patch)
 teach.add_command(check)
+teach.add_command(section)
+teach.add_command(student)

making_with_code_cli-4.0.0/making_with_code_cli/teach/section/__init__.py

@@ -0,0 +1,45 @@
+import click
+from csv import DictWriter
+from tabulate import tabulate
+from making_with_code_cli.settings import read_settings
+from making_with_code_cli.mwc_accounts_api import MWCAccountsAPI
+from making_with_code_cli.styles import (
+    info,
+)
+from making_with_code_cli.teach.setup import check_required_teacher_settings
+from making_with_code_cli.teach.section.create import create_section
+from making_with_code_cli.teach.section.edit import edit_section
+
+@click.group(invoke_without_command=True)
+@click.pass_context
+@click.option("--config", help="Path to config file (default: ~/.mwc)")
+@click.option("-o", "--outfile", help="Save results as csv")
+def section(ctx, config, outfile):
+    "Manage sections of students"
+    if ctx.invoked_subcommand is None:
+        settings = read_settings(config)
+        if not check_required_teacher_settings(settings):
+            return
+        api = MWCAccountsAPI(settings.get('mwc_accounts_url'))
+        roster = api.get_roster(settings['mwc_accounts_token'])
+        if roster['teacher_sections']:
+            data = summarize_sections(roster['teacher_sections'])
+            if outfile:
+                with open(outfile, "w") as fh:
+                    writer = DictWriter(fh, data[0].keys())
+                    writer.writeheader()
+                    writer.writerows(data)
+            else:
+                click.echo(info(tabulate(data, headers="keys"), preformatted=True))
+        else:
+            click.echo(info("You have no sections."))
+
+def summarize_sections(section_data):
+    for section in section_data:
+        section["students"] = len(section["student_tokens"])
+        del section["student_tokens"]
+    return section_data
+
+section.add_command(create_section)
+section.add_command(edit_section)
+

making_with_code_cli-4.0.0/making_with_code_cli/teach/section/create.py

@@ -0,0 +1,88 @@
+import click
+from tabulate import tabulate
+from making_with_code_cli.settings import read_settings
+from making_with_code_cli.mwc_accounts_api import MWCAccountsAPI
+from making_with_code_cli.curriculum import get_curriculum
+from making_with_code_cli.errors import CurriculumSiteNotAvailable, MWCError
+from making_with_code_cli.styles import (
+    address, 
+    error,
+    info,
+    question,
+)
+
+MWC_CURRICULUM_URL = "https://makingwithcode.org"
+
+@click.command('create')
+@click.option("--config", help="Path to config file (default: ~/.mwc)")
+@click.option("--slug", help="Unique short identifier for the section")
+@click.option("--name", help="Section name")
+@click.option("--curriculum-site-url", help="URL for curriculum website. e.g. https://makingwithcode.org")
+@click.option("--course-name", help="MWC course name")
+@click.option("--code", help="Code students can use to join the section")
+def create_section(config, slug, name, curriculum_site_url, course_name, code):
+    "Create a new student section"
+    settings = read_settings(config)
+    api = MWCAccountsAPI(settings.get('mwc_accounts_url'))
+    params = {
+        "name": name, 
+        "slug": slug, 
+        "curriculum_site_url": curriculum_site_url,
+        "course_name": course_name,
+        "code": code,
+    }
+    if not params_complete(params):
+        params = prompt_for_params(params)
+    try:
+        response = api.create_section(settings.get('mwc_accounts_token'), params)
+        click.echo(info(tabulate([response], headers="keys"), preformatted=True))
+    except api.RequestFailed as err:
+        click.echo(error("Could not create new section:"))
+        for field, problems in err.data.items():
+            click.echo(error(f" - {field}: {'; '.join(problems)}"))
+
+def params_complete(params):
+    """Check whether all params are present.
+    """
+    required_params = ["name", "slug", "curriculum_site_url", "course_name", "code"]
+    if all(params.get(p) for p in required_params):
+        curriculum = get_curriculum(params["curriculum_site_url"])
+        courses = [c["name"] for c in curriculum.get("courses", [])]
+        if params["course_name"] in courses:
+            return True
+    return False
+
+def prompt_for_params(params):
+    """Interactively prompt user for missing params.
+    """
+    params['name'] = click.prompt(question("Section name"), default=params.get('name'))
+    params['slug'] = click.prompt(question("Section slug"), default=params.get('slug'))
+    while True:
+        url = click.prompt(
+            question("Curriculum site URL"), 
+            default=params.get('curriculum_site_url') or  MWC_CURRICULUM_URL
+        )
+        try:
+            curriculum = get_curriculum(url)
+            params['curriculum_site_url'] = url
+            if not curriculum.get('courses'):
+                raise MWCError("Found the curriculum site, but no courses are published.")
+            break
+        except CurriculumSiteNotAvailable as err:
+            click.echo(error(err))
+    course_names = [c['name'] for c in curriculum['courses']]
+    if params.get('course_name') and params.get('course_name') not in course_names:
+        click.echo(info(f"Course name {params['course_name']} is invalid."))
+        del params['course_name']
+    if not params.get('course_name'):
+        click.echo(info(f"The following courses are published at {params['curriculum_site_url']}:"))
+        for name in course_names:
+            click.echo(info(f" - {name}"))
+        params['course_name'] = click.prompt(
+            question("Course name"), 
+            type=click.Choice(course_names), 
+            default=params.get('course_name')
+        )
+    params['code'] = click.prompt(question("Join code"), default=params.get("code"))
+    return params
+

making_with_code_cli-4.0.0/making_with_code_cli/teach/section/edit.py

@@ -0,0 +1,41 @@
+import click
+from tabulate import tabulate
+from making_with_code_cli.settings import read_settings
+from making_with_code_cli.mwc_accounts_api import MWCAccountsAPI
+from making_with_code_cli.curriculum import get_curriculum
+from making_with_code_cli.errors import CurriculumSiteNotAvailable, MWCError
+from making_with_code_cli.styles import (
+    address, 
+    error,
+    info,
+    question,
+)
+
+@click.command('edit')
+@click.argument("slug")
+@click.option("--config", help="Path to config file (default: ~/.mwc)")
+@click.option("--name", help="Section name")
+@click.option("--curriculum-site-url", help="URL for curriculum website. e.g. https://makingwithcode.org")
+@click.option("--course-name", help="MWC course name")
+@click.option("--code", help="Code students can use to join the section")
+@click.option("--roster", help="csv file containing student information")
+def edit_section(config, slug, name, curriculum_site_url, course_name, code, roster):
+    "Edit an existing section"
+    settings = read_settings(config)
+    api = MWCAccountsAPI(settings.get('mwc_accounts_url'))
+    params = {"slug": slug}
+    if name: 
+        params["name"] = name
+    if curriculum_site_url:
+        params["curriculum_site_url"] = curriculum_site_url
+    if course_name:
+        params["course_name"] = course_name
+    if code: 
+        params["code"] = code
+    try:
+        response = api.update_section(settings.get('mwc_accounts_token'), params)
+        click.echo(info(tabulate([response], headers="keys"), preformatted=True))
+    except api.RequestFailed as err:
+        click.echo(error(f"Could not edit section {params['slug']}:"))
+        for field, problems in err.data.items():
+            click.echo(error(f" - {field}: {'; '.join(problems)}"))

{making_with_code_cli-3.1.0 → making_with_code_cli-4.0.0}/making_with_code_cli/teach/setup.py

@@ -8,6 +8,7 @@ from making_with_code_cli.setup.tasks import (
     choose_mwc_username,
     prompt_mwc_password,
     choose_work_dir,
+    choose_editor,
 )
 from making_with_code_cli.settings import (
     get_settings_path,
@@ -45,33 +46,48 @@ def check_required_teacher_settings(settings):
 @click.command
 @click.option("--config", help="Path to config file (default: ~/.mwc)")
 @click.option("--debug", is_flag=True, help="Show debug-level output")
-def setup(config, debug):
+@click.option("--git-name", help="Set git name")
+@click.option("--git-email", help="Set git email address")
+@click.option("--mwc-accounts-url", help="Set URL for MWC accounts server")
+def setup(config, debug, git_name, git_email, mwc_accounts_url):
     """Configure teacher settings"""
-    click.echo(address(INTRO_MESSAGE))
-    click.echo()
     settings = read_settings(config)
     if debug:
         sp = get_settings_path(config)
         click.echo(debug_fmt(f"Reading settings from {sp}"))
+    click.echo(address(INTRO_MESSAGE))
+    click.echo()
+    if git_name:
+        settings['git_name'] = git_name
+    if git_email:
+        settings['git_email'] = git_email
+    if mwc_accounts_url:
+        settings['mwc_accounts_url'] = mwc_accounts_url
     settings['mwc_username'] = choose_mwc_username(settings.get("mwc_username"))
-    api = MWCAccountsAPI()
-    if settings.get('mwc_accounts_token'):
+    api = MWCAccountsAPI(settings.get('mwc_accounts_url'))
+    if not 'mwc_accounts_token' in settings:
+        token = prompt_mwc_password(settings['mwc_username'], api)
+        settings['mwc_accounts_token'] = token
+    while True:
         try:
             status = api.get_status(settings['mwc_accounts_token'])
+            break
         except api.RequestFailed as bad_token:
-            token = prompt_mwc_password(settings['mwc_username'])
+            if debug:
+                click.echo(debug_fmt(bad_token))
+            token = prompt_mwc_password(settings['mwc_username'], api)
             settings['mwc_accounts_token'] = token
-            status = api.get_status(token)
-    else:
-        token = prompt_mwc_password(settings['mwc_username'])
-        settings['mwc_accounts_token'] = token
-        status = api.get_status(token)
-    if debug:
-        click.echo(debug_fmt("MWC Accounts Server status:"))
-        click.echo(debug_fmt(str(status)))
+    settings['mwc_git_token'] = status['git_token']
+    settings['work_dir'] = str(choose_work_dir(settings.get("work_dir")).resolve())
+    settings['editor'] = choose_editor(settings.get('editor', 'code'))
     settings['teacher_work_dir'] = str(choose_work_dir(
         settings.get("teacher_work_dir"), 
         teacher=True
     ))
+    if debug:
+        if settings.get('mwc_accounts_url'):
+            click.echo(debug_fmt(f"Using custom MWC accounts server: {settings['mwc_accounts_url']}"))
+        click.echo(debug_fmt("MWC Accounts Server status:"))
+        click.echo(debug_fmt(str(status)))
     write_settings(settings, config)
 

{making_with_code_cli-3.1.0 → making_with_code_cli-4.0.0}/making_with_code_cli/teach/status.py

@@ -29,7 +29,7 @@ measures = {
 
 @click.command()
 @click.option("--config", help="Path to config file (default: ~/.mwc)")
-@click.option("-g", "--group", help="Filter by group name")
+@click.option("-s", "--section", help="Filter by section name/slug")
 @click.option("-c", "--course", help="Filter by course name")
 @click.option("-u", "--user", help="Filter by username")
 @click.option("-n", "--unit", help="Filter by unit name/slug")
@@ -37,37 +37,37 @@ measures = {
 @click.option("-v", "--measure", default="commits", type=click.Choice(measures.keys()), 
         help="Measure to show")
 @click.option("-a", "--anonymous", is_flag=True, help="Hide usernames")
-@click.option("-s", "--short", is_flag=True, help="Show short module names")
+@click.option("-x", "--short", is_flag=True, help="Show short module names")
 @click.option("-o", "--outfile", help="Save results as csv")
 @click.option('-U', "--update", is_flag=True, help="Update repos first")
 @click.option('-t', "--threads", type=int, default=8, help="Maximum simultaneous threads")
-def status(config, group, course, user, unit, module, measure, anonymous, short, 
+def status(config, section, course, user, unit, module, measure, anonymous, short, 
         outfile, update, threads):
     "Show status of student repos by module"
     if update:
         from making_with_code_cli.teach.update import update as update_task
-        update_task.callback(config, group, course, user, unit, module, threads)
+        update_task.callback(config, section, course, user, unit, module, threads)
     settings = read_settings(config)
     if not check_required_teacher_settings(settings):
         return
     repos = StudentRepos(settings, threads)
     measure_status_message, measure_fn = measures[measure]
-    results = repos.apply(measure_fn, group=group, course=course, user=user, 
+    results = repos.apply(measure_fn, section=section, course=course, user=user, 
             unit=unit, module=module, status_message=measure_status_message)
     recursive_dict = lambda: defaultdict(recursive_dict)
     results_dict = recursive_dict()
     for r in results:
-        g = r['group']['group_name'] + ' | ' + r['group']['course_name']
-        results_dict[g][r['username']][r['module']] = r['score']
+        s = r['section']['name'] + ' | ' + r['section']['course_name']
+        results_dict[s][r['username']][r['module']] = r['score']
     all_scores = []
-    for group, users in results_dict.items():
+    for section, users in results_dict.items():
         if users:
             headers = ['username'] + sorted(next(iter(users.values())).keys())
-            group_scores = format_user_scores(users, anonymous, short)
-            all_scores += group_scores
+            section_scores = format_user_scores(users, anonymous, short)
+            all_scores += section_scores
             if not outfile:
-                click.echo(address(group))
-                click.echo(address(tabulate(group_scores, headers='keys'), 
+                click.echo(address(section))
+                click.echo(address(tabulate(section_scores, headers='keys'), 
                         preformatted=True))
     if outfile and all_scores:
         with open(outfile, 'w') as fh:

making_with_code_cli-4.0.0/making_with_code_cli/teach/student/__init__.py

@@ -0,0 +1,10 @@
+import click
+from making_with_code_cli.teach.student.create import create_student
+from making_with_code_cli.teach.student.update import update_student
+
+@click.group()
+def student():
+    "Manage students"
+
+student.add_command(create_student)
+student.add_command(update_student)

making_with_code_cli-4.0.0/making_with_code_cli/teach/student/create.py

@@ -0,0 +1,33 @@
+import click
+from tabulate import tabulate
+from making_with_code_cli.settings import read_settings
+from making_with_code_cli.mwc_accounts_api import MWCAccountsAPI
+from making_with_code_cli.styles import (
+    info,
+    error,
+)
+
+@click.command("create")
+@click.argument("username")
+@click.argument("password")
+@click.argument("section")
+@click.option("--config", help="Path to config file (default: ~/.mwc)")
+def create_student(username, password, section, config):
+    "Create a student user"
+    settings = read_settings(config)
+    api = MWCAccountsAPI(settings.get('mwc_accounts_url'))
+    params = {
+        "username": username, 
+        "password": password, 
+        "section": section,
+    }
+    try:
+        response = api.create_student(settings.get('mwc_accounts_token'), params)
+        click.echo(info(f"Created student {response['username']} in {section}."))
+    except api.RequestFailed as err:
+        click.echo(error(f"Could not create {params['username']}:"))
+        print(err)
+        for field, problems in err.data.items():
+            click.echo(error(f" - {field}: {'; '.join(problems)}"))
+
+

making_with_code_cli-4.0.0/making_with_code_cli/teach/student/update.py

@@ -0,0 +1,29 @@
+import click
+from tabulate import tabulate
+from making_with_code_cli.settings import read_settings
+from making_with_code_cli.mwc_accounts_api import MWCAccountsAPI
+from making_with_code_cli.styles import (
+    info,
+    error,
+)
+
+@click.command("update")
+@click.argument("username")
+@click.argument("password")
+@click.option("--config", help="Path to config file (default: ~/.mwc)")
+def update_student(username, password, config):
+    "Update a student's password"
+    settings = read_settings(config)
+    api = MWCAccountsAPI(settings.get('mwc_accounts_url'))
+    params = {
+        "username": username, 
+        "password": password, 
+    }
+    try:
+        response = api.update_student(settings.get('mwc_accounts_token'), params)
+        click.echo(info(f"Updated student {response['username']}."))
+    except api.RequestFailed as err:
+        click.echo(error(f"Could not update {params['username']}:"))
+        for field, problems in err.data.items():
+            click.echo(error(f" - {field}: {'; '.join(problems)}"))
+

{making_with_code_cli-3.1.0 → making_with_code_cli-4.0.0}/making_with_code_cli/teach/student_repo_functions.py

@@ -9,7 +9,7 @@ MWC_GIT_SERVER = "git.makingwithcode.org"
 def run_in_repo(command, cwd):
     return run(command, cwd=cwd, shell=True, capture_output=True, text=True)
 
-def update_repo(semaphore, results, group, username, path, token):
+def update_repo(semaphore, results, section, username, path, token):
     semaphore.acquire()
     git_api = GiteaTeacherApi()
     if path.exists():
@@ -25,20 +25,20 @@ def update_repo(semaphore, results, group, username, path, token):
         results.append({"action": "clone", "path": path, "process": process})
     semaphore.release()
 
-def count_commits(semaphore, results, group, username, path, token):
+def count_commits(semaphore, results, section, username, path, token):
     "Counts commits in repo"
     semaphore.acquire()
     if path.exists():
         repo = Repo(path)
         results.append({
-            "group": group, 
+            "section": section, 
             "username": username, 
             "module": path.name, 
             "score": len(list(repo.iter_commits())) - 1
         })
     semaphore.release()
 
-def count_changed_py_lines(semaphore, results, group, username, path, token):
+def count_changed_py_lines(semaphore, results, section, username, path, token):
     "Counts lines changed in Python files across all commits in repo"
     semaphore.acquire()
     if path.exists():
@@ -51,14 +51,14 @@ def count_changed_py_lines(semaphore, results, group, username, path, token):
                 if f.endswith(".py"):
                     changed_lines += stats['lines']
         results.append({
-            "group": group, 
+            "section": section, 
             "username": username, 
             "module": path.name, 
             "score": changed_lines
         })
     semaphore.release()
 
-def count_changed_md_lines(semaphore, results, group, username, path, token):
+def count_changed_md_lines(semaphore, results, section, username, path, token):
     "Counts lines changed in Python files across all commits in repo"
     semaphore.acquire()
     if path.exists():
@@ -71,19 +71,19 @@ def count_changed_md_lines(semaphore, results, group, username, path, token):
                 if f.endswith(".md"):
                     changed_lines += stats['lines']
         results.append({
-            "group": group, 
+            "section": section, 
             "username": username, 
             "module": path.name, 
             "score": changed_lines
         })
     semaphore.release()
 
-def module_completion(semaphore, results, group, username, path, token):
+def module_completion(semaphore, results, section, username, path, token):
     "Returns a [0..1] ratio of module completion, based on tests."
     semaphore.acquire()
     if path.exists():
         results.append({
-            "group": group, 
+            "section": section, 
             "username": username, 
             "module": path.name, 
             "score": 0

{making_with_code_cli-3.1.0 → making_with_code_cli-4.0.0}/making_with_code_cli/teach/student_repos.py

@@ -13,7 +13,7 @@ class StudentRepos:
         self.settings = settings
         self.max_threads = max_threads
 
-    def apply(self, function, group=None, course=None, user=None, 
+    def apply(self, function, section=None, course=None, user=None, 
             unit=None, module=None, status_message=""):
         """Applies function to repo paths matching args, and returns the result.
         The function should take (sem, result, g, user, path, token).
@@ -22,7 +22,7 @@ class StudentRepos:
         sem = Semaphore(self.max_threads)
         results = []
         threads = []
-        for g, user, path, token in self.iter_repos(group, course, user, unit, module):
+        for g, user, path, token in self.iter_repos(section, course, user, unit, module):
             thread = Thread(target=function, args=(sem, results, g, user, path, token))
             thread.start()
             threads.append(thread)
@@ -32,17 +32,17 @@ class StudentRepos:
         print()
         return results
 
-    def iter_repos(self, group=None, course=None, user=None, unit=None, module=None):
+    def iter_repos(self, section=None, course=None, user=None, unit=None, module=None):
         root = Path(self.settings['teacher_work_dir']).resolve()
-        api = MWCAccountsAPI()
+        api = MWCAccountsAPI(self.settings.get('mwc_accounts_url'))
         roster = api.get_roster(self.settings['mwc_accounts_token'])
-        for g in roster['teacher_groups']:
-            if group and (group not in g['group_name']) and (group not in g['group_slug']):
+        for s in roster['teacher_sections']:
+            if section and (section not in s['name']) and (section not in s['slug']):
                 continue
-            if course and course not in g['course_name']:
+            if course and course not in s['course_name']:
                 continue
-            curriculum = get_curriculum(g['curriculum_site_url'], g['course_name'])
-            for username, token in g['student_tokens'].items():
+            curriculum = get_curriculum(s['curriculum_site_url'], s['course_name'])
+            for username, token in s['student_tokens'].items():
                 if user and user not in username:
                     continue
                 for u in curriculum['units']:
@@ -51,6 +51,6 @@ class StudentRepos:
                     for m in u['modules']: 
                         if module and (module not in m['name']) and (module not in m['slug']):
                             continue
-                        path = root / g['group_slug'] / username / u['slug'] / m['slug']
-                        yield g, username, path, token
+                        path = root / s['slug'] / username / u['slug'] / m['slug']
+                        yield s, username, path, token
 

{making_with_code_cli-3.1.0 → making_with_code_cli-4.0.0}/making_with_code_cli/teach/update.py

@@ -26,19 +26,19 @@ from making_with_code_cli.styles import (
 
 @click.command()
 @click.option("--config", help="Path to config file (default: ~/.mwc)")
-@click.option("--group", help="Filter by group name")
+@click.option("--section", help="Filter by section slug")
 @click.option("--course", help="Filter by course name")
 @click.option("--user", help="Filter by username")
 @click.option("--unit", help="Filter by unit name/slug")
 @click.option("--module", help="Filter by module name/slug")
 @click.option("--threads", type=int, default=8, help="Maximum simultaneous threads")
-def update(config, group, course, user, unit, module, threads):
+def update(config, section, course, user, unit, module, threads):
     "Update student repos"
     settings = read_settings(config)
     if not check_required_teacher_settings(settings):
         return
     repos = StudentRepos(settings, threads)
-    results = repos.apply(update_repo, group=group, course=course, user=user, 
+    results = repos.apply(update_repo, section=section, course=course, user=user, 
             unit=unit, module=module, status_message="Updating repos")
     for result in results:
         if result['process'].returncode != 0:

{making_with_code_cli-3.1.0 → making_with_code_cli-4.0.0}/making_with_code_cli/update/__init__.py

@@ -26,13 +26,13 @@ def update(config):
     mwc_home = Path(settings["work_dir"])
     if not mwc_home.exists():
         mwc_home.mkdir(mode=WORK_DIR_PERMISSIONS, parents=True)
-    api = MWCAccountsAPI()
+    api = MWCAccountsAPI(settings.get('mwc_accounts_url'))
     try:
         status = api.get_status(settings.get('mwc_accounts_token'))
     except api.RequestFailed as bad_token:
         click.echo(error(f"Error logging into MWC accounts server. Please run mwc setup."))
         return
-    for course in status['student_group_memberships']:
+    for course in status['student_section_memberships']:
         curr = get_curriculum(course['curriculum_site_url'], course['course_name'])
         git_backend = get_backend(curr['git_backend'])(settings)
         course_dir = mwc_home / curr['slug']

{making_with_code_cli-3.1.0 → making_with_code_cli-4.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "making-with-code-cli"
-version = "3.1.0"
+version = "4.0.0"
 description = "Courseware for Making With Code"
 authors = [
     {name = "Chris Proctor",email = "chris@chrisproctor.net"}
@@ -8,7 +8,7 @@ authors = [
 license = {text = "MIT"}
 readme = "README.md"
 homepage = "https://github.com/cproctor/making-with-code-courseware"
-requires-python = ">=3.10,<4.0"
+requires-python = ">=3.11,<4.0"
 dependencies = [
     "pyyaml (>=6.0.2,<7.0.0)",
     "click (>=8.1.8,<9.0.0)",
@@ -17,7 +17,7 @@ dependencies = [
     "tabulate (>=0.9.0,<0.10.0)",
     "gitpython (>=3.1.44,<4.0.0)",
     "dateparser (>=1.2.0,<2.0.0)",
-    "tqdm (>=4.67.1,<5.0.0)"
+    "tqdm (>=4.67.1,<5.0.0)",
 ]
 
 [project.urls]
@@ -34,5 +34,5 @@ build-backend = "poetry.core.masonry.api"
 optional = true
 
 [tool.poetry.group.docs.dependencies]
-sphinx = "^7.3.7"
-sphinx-rtd-theme = "^2.0.0"
+sphinx = "^8.2.3"
+sphinx-rtd-theme = "^3.0.2"

making_with_code_cli-3.1.0/making_with_code_cli/mwc_accounts_api.py

@@ -1,61 +0,0 @@
-import requests
-import json
-import os
-from pathlib import Path
-from urllib.parse import urljoin
-from getpass import getpass
-
-LOCALHOST = "http://localhost:8000"
-MWC_ACCOUNTS_SERVER = "https://accounts.makingwithcode.org"
-
-class MWCAccountsAPI:
-    def __init__(self, mwc_accounts_server=MWC_ACCOUNTS_SERVER):
-        self.mwc_accounts_server = mwc_accounts_server
-
-    def login(self, username, password):
-        "Authenticates with a username and password, returning an auth token"
-        url = self.mwc_accounts_server + "/login"
-        data = {"username": username, "password": password}
-        response = requests.post(url, data=data)
-        return self.handle_response(response)
-
-    def logout(self, token):
-        url = self.mwc_accounts_server + "/logout"
-        headers = {"Authorization": f"Token {token}"}
-        response = requests.post(url, headers=headers)
-        return self.handle_response(response)
-
-    def get_status(self, token):
-        url = self.mwc_accounts_server + "/status"
-        headers = {"Authorization": f"Token {token}"}
-        response = requests.get(url, headers=headers)
-        return self.handle_response(response)
-
-    def get_roster(self, token):
-        url = self.mwc_accounts_server + "/roster"
-        headers = {"Authorization": f"Token {token}"}
-        response = requests.get(url, headers=headers)
-        return self.handle_response(response)
-
-    def handle_response(self, response):
-        if response.ok:
-            return response.json()
-        elif response.status_code == 500:
-            raise self.ServerError("Error 500")
-        else:
-            try:
-                rj = response.json()
-                raise self.RequestFailed(rj)
-            except requests.exceptions.JSONDecodeError:
-                raise self.RequestFailed(response)
-
-    class RequestFailed(Exception):
-        pass
-
-    class ServerError(Exception):
-        pass
-
-
-
-
-