making-with-code-cli 5.4.0__py3-none-any.whl → 5.6.0__py3-none-any.whl

making_with_code_cli/assessment.py

@@ -0,0 +1,173 @@
+"""Shared spec and validation for assessment.md.
+
+A student module repo may contain `assessment.md`, written by a teacher (by hand or
+with a script -- assessment *tooling* is being designed and built separately from this
+spec) to record how the module was assessed. The file has TOML front matter (delimited
+with `+++`, matching the convention MWC's own site uses for module front matter)
+holding the *current* assessment -- evergreen, not a history. Re-assessment overwrites
+the front matter in place; the running history of what changed and why is written by
+the teacher as prose in the file's body (a letter to the student, in the style of the
+assessment-rubric skill), not as structured data.
+
+This module is the single place that knows the shape of that front matter, so that
+every reader and writer of `assessment.md` -- `mwc status` (student-facing),
+`mwc teach status` (teacher-facing), any future assessment tooling -- agrees on it and
+validates against the same rules, rather than each parsing it their own way.
+
+The front matter always has all four keys:
+- `assessment_type`: `"completion"` or `"score"`
+- `timestamp`: when the current assessment happened (authoritative for "how recent is
+  this assessment" -- deliberately the TOML value, not any git commit metadata, so
+  everything relevant stays in-band in the file itself)
+- `score`: an integer, `0 <= score <= points_possible`
+- `points_possible`: an integer; always `1` for `"completion"` (so score is `0` or `1`)
+
+Rubric-based assessment doesn't get its own structured type -- the rubric detail
+(per-criterion feedback) lives in the prose body, and the front matter just records
+a summary `"score"` that downstream consumers can turn into a grade.
+
+    +++
+    assessment_type = "score"
+    timestamp = 2026-03-15T09:30:00Z
+    score = 8
+    points_possible = 10
+    +++
+
+    Dear student, ...
+"""
+from dataclasses import dataclass
+from datetime import datetime
+from numbers import Real
+
+import tomlkit
+from tomlkit.exceptions import TOMLKitError
+
+from making_with_code_cli.errors import MWCError
+
+FRONT_MATTER_DELIMITER = "+++"
+ASSESSMENT_TYPES = ("completion", "score")
+
+
+class AssessmentValidationError(MWCError):
+    """Raised when assessment.md front matter doesn't conform to the spec."""
+
+
+@dataclass(frozen=True)
+class Assessment:
+    "A module's current assessment, evergreen (overwritten on re-assessment)."
+    assessment_type: str  # "completion" | "score"
+    timestamp: datetime
+    score: int
+    points_possible: int
+
+
+def extract_front_matter(markdown_text):
+    """Splits a +++...+++-delimited file into (front_matter_toml, body_markdown).
+    Returns ("", markdown_text) if there's no front matter at all -- a module that
+    hasn't been assessed yet may have no assessment.md, or an assessment.md with no
+    front matter yet, and that should parse as "not assessed," not an error.
+    """
+    lines = markdown_text.splitlines(keepends=True)
+    if not lines or lines[0].strip() != FRONT_MATTER_DELIMITER:
+        return "", markdown_text
+    for i, line in enumerate(lines[1:], start=1):
+        if line.strip() == FRONT_MATTER_DELIMITER:
+            return "".join(lines[1:i]), "".join(lines[i + 1:])
+    # Opening delimiter with no closing delimiter -- treat as malformed, not fatal;
+    # callers just get "not assessed" back rather than a crash.
+    return "", markdown_text
+
+
+def parse_assessment(toml_text):
+    """Parses assessment.md's front matter into an Assessment, or None if it's
+    empty/missing `assessment_type` (not assessed yet -- a valid, unremarkable
+    state, not an error). Raises AssessmentValidationError if `assessment_type`
+    is present but the rest of the data doesn't conform to the spec.
+    """
+    if not toml_text.strip():
+        return None
+    try:
+        doc = tomlkit.parse(toml_text)
+    except TOMLKitError as e:
+        raise AssessmentValidationError(f"assessment.md front matter is not valid TOML: {e}")
+
+    if "assessment_type" not in doc:
+        return None
+    return _parse_assessment_table(doc)
+
+
+def parse_assessment_file(markdown_text):
+    """extract_front_matter + parse_assessment, for reading a whole assessment.md
+    file (its text content, not a path -- callers decide whether that text comes
+    from the working tree or `git show <ref>:assessment.md`)."""
+    front_matter, _ = extract_front_matter(markdown_text)
+    return parse_assessment(front_matter)
+
+
+def format_score(assessment):
+    """Compact single-line rendering of an assessment's score, for table display.
+    ASCII only (no unicode symbols), matching mwc teach status's convention.
+    """
+    if assessment.assessment_type == "completion":
+        return "Y" if assessment.score else "N"
+    return f"{assessment.score}/{assessment.points_possible}"
+
+
+def set_assessment(markdown_text, assessment):
+    """Returns markdown_text with its front matter replaced by `assessment`
+    (creating the front matter if markdown_text has none). The body is left
+    untouched -- the teacher writes their own log of the (re-)assessment there;
+    this function only ever owns the evergreen front matter, never the prose.
+    Uses tomlkit so any other keys already in the front matter are preserved.
+    """
+    front_matter, body = extract_front_matter(markdown_text)
+    doc = tomlkit.parse(front_matter) if front_matter.strip() else tomlkit.document()
+    doc["assessment_type"] = assessment.assessment_type
+    doc["timestamp"] = assessment.timestamp
+    doc["score"] = assessment.score
+    doc["points_possible"] = assessment.points_possible
+    new_front_matter = tomlkit.dumps(doc)
+    return f"{FRONT_MATTER_DELIMITER}\n{new_front_matter}{FRONT_MATTER_DELIMITER}\n{body}"
+
+
+def _parse_assessment_table(raw):
+    "Validates and converts a raw TOML mapping into an Assessment."
+    assessment_type = raw.get("assessment_type")
+    if assessment_type not in ASSESSMENT_TYPES:
+        raise AssessmentValidationError(
+            f"assessment_type must be one of {ASSESSMENT_TYPES}, got {assessment_type!r}"
+        )
+
+    timestamp = raw.get("timestamp")
+    if not isinstance(timestamp, datetime):
+        raise AssessmentValidationError("timestamp is required and must be a date/time")
+
+    if "score" not in raw:
+        raise AssessmentValidationError("score is required")
+    score = raw["score"]
+    if isinstance(score, bool) or not isinstance(score, Real):
+        raise AssessmentValidationError(f"score must be a number, got {score!r}")
+
+    if "points_possible" not in raw:
+        raise AssessmentValidationError("points_possible is required")
+    points_possible = raw["points_possible"]
+    if isinstance(points_possible, bool) or not isinstance(points_possible, Real):
+        raise AssessmentValidationError(f"points_possible must be a number, got {points_possible!r}")
+    if points_possible <= 0:
+        raise AssessmentValidationError("points_possible must be positive")
+
+    if assessment_type == "completion" and points_possible != 1:
+        raise AssessmentValidationError(
+            f"points_possible must be 1 for a completion assessment, got {points_possible!r}"
+        )
+    if not (0 <= score <= points_possible):
+        raise AssessmentValidationError(
+            f"score ({score}) must be between 0 and points_possible ({points_possible})"
+        )
+
+    return Assessment(
+        assessment_type=assessment_type,
+        timestamp=timestamp,
+        score=score,
+        points_possible=points_possible,
+    )

making_with_code_cli/cli.py

@@ -3,6 +3,7 @@ from making_with_code_cli.version import version
 from making_with_code_cli.setup import setup
 from making_with_code_cli.update import update
 from making_with_code_cli.submit import submit
+from making_with_code_cli.status import status
 from making_with_code_cli.teach import teach
 
 @click.group()
@@ -13,4 +14,5 @@ cli.add_command(version)
 cli.add_command(setup)
 cli.add_command(update)
 cli.add_command(submit)
+cli.add_command(status)
 cli.add_command(teach)

making_with_code_cli/git_backend/mwc_backend.py

@@ -1,5 +1,6 @@
 from .base_backend import GitBackend
 from subprocess import run, CalledProcessError
+import re
 import traceback
 from pathlib import Path
 from urllib.parse import urlparse
@@ -111,13 +112,22 @@ class MWCBackend(GitBackend):
         run(["git", "config", "--local", "user.name", name], check=True, cwd=modpath)
         run(["git", "config", "--local", "user.email", "nobody@makingwithcode.org"],
             check=True, cwd=modpath)
+        # EDITOR_COMMANDS covers the GUI editors that need an explicit "wait for
+        # the tab to close" flag. Anything else the student typed at setup was
+        # already verified to resolve on $PATH (see choose_editor), so pass it
+        # through as-is -- students should be able to use editors we don't know
+        # about by name. Only fall back to nano if editor is somehow unset.
         editor = self.settings.get('editor')
-        if editor in EDITOR_COMMANDS:
-            run(["git", "config", "--local", "core.editor", EDITOR_COMMANDS[editor]],
-                check=True, cwd=modpath)
+        editor_command = EDITOR_COMMANDS.get(editor, editor) or "nano"
+        run(["git", "config", "--local", "core.editor", editor_command],
+            check=True, cwd=modpath)
 
     def update(self, module, modpath, install=True):
         if (modpath / ".git").is_dir():
+            # Idempotent -- re-applies user/editor config so repos created
+            # before this config existed (or with a stale editor choice)
+            # still get it.
+            self.configure_git(modpath)
             relpath = self.relative_path(modpath)
             click.echo(address(f"Checking {relpath} for updates.", preformatted=True))
             pull_output = self.safe_pull(modpath)
@@ -144,44 +154,57 @@ class MWCBackend(GitBackend):
                 f"Cleared an incomplete git {aborted} — this shouldn't affect your work."
             ))
 
-        branch = recover_detached_head(modpath)
-        if branch:
+        recovered = recover_detached_head(modpath)
+        if recovered:
+            branch, stash_unresolved = recovered
             click.echo(confirm(
                 f"Your repo was not on any branch. Switched back to '{branch}'."
             ))
+            if stash_unresolved:
+                click.echo(error(
+                    "Some of your uncommitted work couldn't be automatically restored "
+                    "and is saved in a git stash instead of your files. "
+                    "Ask your teacher for help recovering it."
+                ))
 
         clear_stale_index_lock(modpath)
 
-        # U1: uncommitted changes that would be overwritten — auto-commit first
+        run("git fetch origin", shell=True, capture_output=True, cwd=modpath)
+
+        # Detect (without applying) any genuine content conflicts between
+        # FETCH_HEAD and the repo's current state -- both the working tree
+        # (if dirty) and the student's committed history. -X ours/-X theirs
+        # auto-resolve conflicts silently, so this is the only way to know
+        # when that's about to happen.
+        conflicted = self._conflicting_files(modpath, "FETCH_HEAD")
+
+        # U1: uncommitted changes that would genuinely conflict with the
+        # update — cancel and have the student save their own work first,
+        # rather than guessing at a commit message on their behalf. Handling
+        # one thing at a time (submit, then update) is clearer for students
+        # than a merge that silently combines both, and avoids a commit
+        # showing up in their history that they didn't write.
         status = run(
             "git status --porcelain",
             shell=True, capture_output=True, text=True, cwd=modpath
         )
-        if status.stdout.strip():
-            probe = run(
-                "git fetch origin",
-                shell=True, capture_output=True, text=True, cwd=modpath
+        if status.stdout.strip() and conflicted:
+            raise GitError(
+                "You have unsaved changes here that would conflict with an "
+                "update. Run `mwc submit` to save your work, then run "
+                "`mwc update` again."
             )
-            merge_check = run(
-                "git merge --no-commit --no-ff FETCH_HEAD",
-                shell=True, capture_output=True, text=True, cwd=modpath
-            )
-            # Always abort the probe merge so we start clean
-            run("git merge --abort", shell=True, capture_output=True, cwd=modpath)
-            if "CONFLICT" in merge_check.stdout or "CONFLICT" in merge_check.stderr:
-                run(["git", "add", "--all"], capture_output=True, cwd=modpath)
-                run(
-                    ["git", "commit", "-m", "[auto-saved before update]"],
-                    capture_output=True, cwd=modpath
-                )
-                click.echo(confirm(
-                    "Your unsaved changes were auto-saved in git history "
-                    "before applying the update."
-                ))
 
         result = self._run_pull(modpath)
 
         if result.returncode == 0:
+            if conflicted:
+                files = ", ".join(f"`{f}`" for f in conflicted)
+                click.echo(error(
+                    f"Your changes to {files} conflicted with an update — the "
+                    "update's version was kept for the conflicting lines. Ask "
+                    "your teacher if you're not sure that's right."
+                ))
             return result.stdout
 
         combined = result.stderr + result.stdout
@@ -209,6 +232,43 @@ class MWCBackend(GitBackend):
             shell=True, capture_output=True, text=True, cwd=modpath
         )
 
+    def _conflicting_files(self, modpath, ref):
+        """Returns the list of files that can't be cleanly auto-merged when
+        merging `ref` into HEAD, without actually applying or committing
+        anything. -X ours/-X theirs auto-resolve conflicts and don't report
+        them, so this is the only way to tell whether an automatic merge is
+        about to silently pick a side on real conflicting content (as opposed
+        to just cleanly combining separate, non-overlapping changes).
+
+        Covers two distinct git failure modes: real textual conflicts
+        (reported as "CONFLICT", with the files showing up in
+        `git diff --diff-filter=U`), and a dirty working tree touching the
+        same file as the incoming change (git refuses outright with "local
+        changes ... would be overwritten by merge" and never starts a merge
+        at all, so there's nothing in the index to look up -- the filenames
+        have to be parsed out of that message instead).
+        """
+        merge_check = run(
+            f"git merge --no-commit --no-ff {ref}",
+            shell=True, capture_output=True, text=True, cwd=modpath
+        )
+        conflicts = []
+        if merge_check.returncode != 0:
+            diff = run(
+                "git diff --name-only --diff-filter=U",
+                shell=True, capture_output=True, text=True, cwd=modpath
+            )
+            conflicts = [f for f in diff.stdout.splitlines() if f.strip()]
+            if not conflicts:
+                combined = merge_check.stdout + merge_check.stderr
+                conflicts = re.findall(r"^\t(.+)$", combined, re.MULTILINE)
+        # Always abort the probe merge so we start clean. This is a no-op
+        # (and prints a harmless "no merge to abort" to stderr, which we
+        # discard) in the "would be overwritten" case, since no merge ever
+        # started there.
+        run("git merge --abort", shell=True, capture_output=True, cwd=modpath)
+        return conflicts
+
     def _raise_pull_error(self, stderr):
         if any(p in stderr for p in _NETWORK_PHRASES):
             raise GitNetworkError(
@@ -233,7 +293,15 @@ class MWCBackend(GitBackend):
     def init_direnv(self, modpath):
         if not (modpath / ".envrc").exists():
             (modpath / ".envrc").write_text("source .venv/bin/activate")
-        run("direnv allow", shell=True, check=True, cwd=modpath)
+        try:
+            run("direnv allow", shell=True, check=True, cwd=modpath, capture_output=True)
+        except CalledProcessError:
+            raise GitError(
+                "Could not run `direnv allow` -- direnv doesn't seem to be installed "
+                "or isn't on your PATH. Try closing and reopening your terminal (so it "
+                "picks up changes from setup), then run `mwc update` again. If that "
+                "doesn't help, run `mwc setup` again or ask your teacher for help."
+            )
 
     def user_has_repo(self, repo_name, username=None):
         """Checks to see whether a user already has the named repo."""

making_with_code_cli/git_wrapper.py

@@ -1,7 +1,12 @@
+from datetime import datetime
 from pathlib import Path
 from subprocess import run, CalledProcessError
 from making_with_code_cli.helpers import cd
 
+# Field separator for git log --format parsing below -- chosen because it can't
+# appear in an author name/email, unlike "|" or ",".
+_FIELD_SEP = "\x1f"
+
 
 def in_repo():
     """Checks whether currently in repo"""
@@ -12,14 +17,14 @@ def in_repo():
         return False
 
 
-def repo_has_changes():
-    return len(changed_files()) > 0
+def repo_has_changes(cwd=None):
+    return len(changed_files(cwd=cwd)) > 0
 
 
-def changed_files():
+def changed_files(cwd=None):
     "Returns a list of (status, filename) tuples for changed files"
     cmd = "git status --porcelain"
-    result = run(cmd, shell=True, capture_output=True, text=True).stdout
+    result = run(cmd, shell=True, capture_output=True, text=True, cwd=cwd).stdout
     files = []
     if result:
         for line in result.split('\n'):
@@ -76,7 +81,13 @@ def abort_in_progress_operation(cwd=None):
 
 def recover_detached_head(cwd=None):
     """If in detached HEAD, checks out the default branch and returns its name.
-    Returns None if no action was needed.
+    Returns None if no action was needed, otherwise (branch, stash_unresolved),
+    where stash_unresolved is True if uncommitted work couldn't be automatically
+    restored and was left in the stash rather than being discarded. Detached HEAD
+    is never something a student does on purpose (they never use branches) --
+    it comes from pasting a git command found online, or a GUI tool's "checkout
+    this commit" action, so there's no real "their branch" to speak of, just the
+    one branch every student repo has.
     """
     if get_repo_state(cwd) != "detached":
         return None
@@ -87,14 +98,22 @@ def recover_detached_head(cwd=None):
     )
     had_stash = "No local changes to save" not in stash_result.stdout
     run(["git", "checkout", branch], capture_output=True, cwd=cwd)
+    stash_unresolved = False
     if had_stash:
         pop_result = run(
             "git stash pop", shell=True, capture_output=True, text=True, cwd=cwd
         )
-        # If pop conflicts (extreme edge case), drop the stash
+        # If pop conflicts, leave the stash in place rather than dropping it --
+        # dropping it would silently and permanently destroy the student's
+        # uncommitted work with no way to recover it. A failed pop also
+        # leaves raw conflict markers in the working tree (git leaking
+        # through as confusing, not just destructive), so reset the tree back
+        # to a clean state; the stash is still intact and is the record of
+        # what didn't come back automatically.
         if pop_result.returncode != 0:
-            run("git stash drop", shell=True, capture_output=True, cwd=cwd)
-    return branch
+            stash_unresolved = True
+            run(["git", "reset", "--hard"], capture_output=True, cwd=cwd)
+    return (branch, stash_unresolved)
 
 
 def clear_stale_index_lock(cwd=None):
@@ -106,6 +125,29 @@ def clear_stale_index_lock(cwd=None):
     return False
 
 
+def commits_since(since, author_name, author_email, ref="HEAD", cwd=None):
+    """Returns True if there's a commit on `ref`, authored by exactly
+    (author_name, author_email), with an author date after `since` (a
+    timezone-aware datetime). Used to detect work submitted by a specific
+    student after a given cutoff -- e.g. "has anything been pushed since this
+    was last assessed" -- without caring about commits from anyone else
+    (a teacher, a co-author, etc.) that might also be on the same ref.
+    """
+    result = run(
+        f"git log {ref} --format=%an{_FIELD_SEP}%ae{_FIELD_SEP}%aI",
+        shell=True, capture_output=True, text=True, cwd=cwd
+    )
+    if result.returncode != 0:
+        return False
+    for line in result.stdout.strip().splitlines():
+        name, _, rest = line.partition(_FIELD_SEP)
+        email, _, when = rest.partition(_FIELD_SEP)
+        if name == author_name and email == author_email:
+            if datetime.fromisoformat(when) > since:
+                return True
+    return False
+
+
 def _get_default_branch(cwd=None):
     """Returns the remote default branch name, falling back to 'main'."""
     result = run(

making_with_code_cli/setup/__init__.py

@@ -39,9 +39,11 @@ from making_with_code_cli.setup.tasks import (
     InstallImageMagick,
     InstallHttpie,
     InstallScipy,
+    InstallZstd,
     InstallOllama,
     InstallPandoc,
     InstallPoppler,
+    InstallPythonBuildDeps,
 )
 
 @click.command()
@@ -109,9 +111,11 @@ def setup(ctx, config, debug, mwc_accounts_url):
         InstallVSCode,
         InstallImageMagick,
         InstallHttpie,
+        InstallZstd,
         InstallOllama,
         InstallPandoc,
         InstallPoppler,
+        InstallPythonBuildDeps,
     ]
     errors = []
     for task_class in task_classes:

making_with_code_cli/setup/tasks.py

@@ -84,7 +84,7 @@ class Platform(Flag):
             else:
                 return "brew install "
         elif p in (cls.UBUNTU, cls.WSL):
-            return "sudo apt install "
+            return "sudo apt install -y "
         else:
             raise PlatformNotSupported()
 
@@ -262,8 +262,10 @@ class WriteMWCShellConfig(SetupTask):
         "Generates the shell configuration file contents"
         f = ""
         shell = get_shell_name()
-        f += "# Making With Code RC File\n" 
+        f += "# Making With Code RC File\n"
         f += f"# See {self.docs_url}\n\n"
+        f += "## Make sure user-local installs (e.g. direnv) are on $PATH\n"
+        f += 'export PATH="$HOME/.local/bin:$PATH"\n\n'
         f += "## Hook direnv into shell\n"
         f += f'eval "$(direnv hook {shell})"\n\n'
 
@@ -388,7 +390,15 @@ class InstallPackageFromInstaller(InstallPackage):
 
 class InstallDirenv(InstallPackageFromInstaller):
     executable_name = "direnv"
-    install_command = "curl -sfL https://direnv.net/install.sh | bash"
+    # direnv's installer defaults to dropping the binary in "./bin", relative
+    # to whatever directory this happens to be run from, which usually isn't
+    # on $PATH. Pin bin_dir to ~/.local/bin, which WriteMWCShellConfig adds
+    # to $PATH, so the installed binary is reliably found afterward.
+    install_command = 'curl -sfL https://direnv.net/install.sh | bin_dir="$HOME/.local/bin" bash'
+
+    def run_task(self):
+        Path.home().joinpath(".local", "bin").mkdir(parents=True, exist_ok=True)
+        super().run_task()
 
 class InstallGit(InstallPackage):
     platform = Platform.MAC | Platform.UBUNTU
@@ -444,6 +454,14 @@ class InstallScipy(InstallPackage):
     def is_complete(self):
         return find_spec("scipy") is not None
 
+class InstallZstd(InstallPackage):
+    """zstd is a prerequisite for ollama's Linux install script, which
+    extracts a .tar.zst bundle. Not needed on Mac (ollama ships as a .zip
+    there, and the curl|sh installer isn't used).
+    """
+    platform = Platform.UBUNTU | Platform.WSL
+    executable_name = apt_name = "zstd"
+
 class InstallOllama(InstallPackage):
     executable_name = "ollama"
     brew_name = "ollama"
@@ -463,5 +481,23 @@ class InstallPoppler(InstallPackage):
     brew_name = "poppler"
     apt_name = "poppler-utils"
 
+class InstallPythonBuildDeps(InstallPackage):
+    """Installs system packages needed to compile Python C-extension
+    dependencies (lxml, Levenshtein) from source.
+
+    On Mac, prebuilt wheels are normally available, so this is a no-op there.
+    On Ubuntu/WSL, if no prebuilt wheel matches the student's Python version,
+    `uv`/`pip` falls back to building from source, which needs headers, a
+    compiler, and (for Levenshtein's rapidfuzz-cpp backend) cmake/ninja.
+    """
+    platform = Platform.UBUNTU | Platform.WSL
+    description = "Install build dependencies for lxml and Levenshtein"
+    apt_name = "libxml2-dev libxslt1-dev python3-dev build-essential cmake ninja-build"
+
+    def is_complete(self):
+        return all(
+            run(["dpkg", "-s", package], capture_output=True).returncode == 0
+            for package in self.apt_name.split()
+        )
 
 

making_with_code_cli/status.py

@@ -0,0 +1,156 @@
+import click
+from csv import DictWriter
+from datetime import datetime, timezone
+from pathlib import Path
+from subprocess import run
+from tabulate import tabulate
+
+from making_with_code_cli.settings import read_settings
+from making_with_code_cli.curriculum import get_curriculum
+from making_with_code_cli.mwc_accounts_api import MWCAccountsAPI
+from making_with_code_cli.assessment import (
+    parse_assessment_file,
+    format_score,
+    AssessmentValidationError,
+)
+from making_with_code_cli.git_wrapper import (
+    repo_has_changes,
+    has_unpushed_commits,
+    commits_since,
+    _get_default_branch,
+)
+from making_with_code_cli.styles import (
+    info,
+    error,
+    warn,
+    debug as debug_fmt,
+)
+
+# The identity configure_git() sets locally for every student -- matched as a
+# whitelist so we don't need to know anything about teacher/other identities
+# to tell whether a commit is the student's own work.
+STUDENT_EMAIL = "nobody@makingwithcode.org"
+EPOCH = datetime.min.replace(tzinfo=timezone.utc)
+
+
+@click.command()
+@click.option("--config", help="Path to config file (default: ~/.mwc)")
+@click.option("-c", "--course", help="Filter by course name/slug")
+@click.option("-n", "--unit", help="Filter by unit name/slug")
+@click.option("-o", "--outfile", help="Save results as csv")
+@click.option("--debug", is_flag=True, help="Show debug-level output")
+def status(config, course, unit, outfile, debug):
+    """Show the status of your labs, problem sets, and projects"""
+    settings = read_settings(config)
+    if not settings:
+        click.echo(error("Please run mwc setup first."))
+        return
+    mwc_home = Path(settings["work_dir"])
+    username = settings.get("mwc_username")
+    api = MWCAccountsAPI(settings.get("mwc_accounts_url"))
+    try:
+        api_status = api.get_status(settings.get("mwc_accounts_token"))
+    except api.RequestFailed:
+        click.echo(error("Error logging into MWC accounts server. Please run mwc setup."))
+        return
+
+    if len(api_status["student_section_memberships"]) == 0:
+        click.echo(info("You are not a student in any courses."))
+        return
+
+    rows = []
+    for membership in api_status["student_section_memberships"]:
+        curr = get_curriculum(membership["curriculum_site_url"], membership["course_name"])
+        if course and course not in curr["name"] and course not in curr["slug"]:
+            continue
+        course_dir = mwc_home / curr["slug"]
+        for u in curr["units"]:
+            if unit and unit not in u["name"] and unit not in u["slug"]:
+                continue
+            unit_dir = course_dir / u["slug"]
+            for module in u["modules"]:
+                module_dir = unit_dir / module["slug"]
+                label = f"{curr['slug']}/{u['slug']}/{module['slug']}"
+                rows.append(_module_row(label, module_dir, username, debug))
+
+    if not rows:
+        click.echo(info("No modules matched."))
+        return
+
+    if outfile:
+        _write_csv(rows, outfile)
+        click.echo(info(f"Saved to {outfile}"))
+    _print_table(rows)
+
+
+def _module_row(label, module_dir, username, debug=False):
+    """Computes one module's status: (label, score, not_yet_assessed, unsubmitted).
+    Read-only -- fetches (updates hidden refs only) but never merges, checks
+    out, or otherwise touches a module's working tree or history.
+    """
+    if not module_dir.exists():
+        return (label, "", False, False)
+
+    run("git fetch origin", shell=True, capture_output=True, cwd=module_dir)
+    branch = _get_default_branch(module_dir)
+    ref = f"origin/{branch}"
+
+    assessment = None
+    show = run(
+        f"git show {ref}:assessment.md",
+        shell=True, capture_output=True, text=True, cwd=module_dir,
+    )
+    score = ""
+    if show.returncode == 0:
+        try:
+            assessment = parse_assessment_file(show.stdout)
+            if assessment:
+                score = format_score(assessment)
+        except AssessmentValidationError as e:
+            score = "ERR"
+            if debug:
+                click.echo(debug_fmt(f"{label}: {e}"))
+
+    cutoff = assessment.timestamp if assessment else EPOCH
+    not_yet_assessed = commits_since(cutoff, username, STUDENT_EMAIL, ref=ref, cwd=module_dir)
+    unsubmitted = repo_has_changes(cwd=module_dir) or has_unpushed_commits(cwd=module_dir)
+
+    return (label, score, not_yet_assessed, unsubmitted)
+
+
+def _write_csv(rows, outfile):
+    with open(outfile, "w", newline="") as fh:
+        writer = DictWriter(fh, fieldnames=["module", "score", "not_yet_assessed", "unsubmitted_changes"])
+        writer.writeheader()
+        for label, score, not_yet_assessed, unsubmitted in rows:
+            writer.writerow({
+                "module": label,
+                "score": score,
+                "not_yet_assessed": not_yet_assessed,
+                "unsubmitted_changes": unsubmitted,
+            })
+
+
+def _print_table(rows):
+    table_rows = [
+        [label, score, "S" if not_yet_assessed else "", "U" if unsubmitted else ""]
+        for label, score, not_yet_assessed, unsubmitted in rows
+    ]
+    table = tabulate(table_rows, headers=["Module", "Score", "S", "U"])
+    # Color whole lines rather than individual cells: tabulate computes column
+    # widths from raw string length, so ANSI codes embedded in a single cell
+    # before tabulate runs would throw off its padding and misalign every
+    # column after it. Coloring a line *after* tabulate has already rendered
+    # it doesn't have this problem, since nothing re-measures it afterward.
+    # (Also: don't wrap the whole table in another style() call on top of
+    # this -- nesting click.style calls means the inner reset code cuts off
+    # the outer color partway through, breaking the styling on every line
+    # after the first colored one.)
+    lines = table.split("\n")
+    for i, (label, score, not_yet_assessed, unsubmitted) in enumerate(rows):
+        line_index = i + 2  # header + separator line
+        if unsubmitted:
+            lines[line_index] = error(lines[line_index], preformatted=True)
+        elif not_yet_assessed:
+            lines[line_index] = warn(lines[line_index], preformatted=True)
+    click.echo("\n".join(lines))

making_with_code_cli/submit.py

@@ -1,5 +1,5 @@
 import click
-from subprocess import run, CalledProcessError
+from subprocess import run, PIPE
 from making_with_code_cli.git_wrapper import (
     in_repo,
     repo_has_changes,
@@ -50,8 +50,8 @@ def submit():
             "Your work was already saved locally but not yet sent to the server. "
             "Submitting now..."
         ))
-        _push()
-        click.echo(address("Nice job! All your work in this module has been submitted."))
+        if _push():
+            click.echo(address("Nice job! All your work in this module has been submitted."))
         return
 
     if not repo_has_changes():
@@ -59,18 +59,20 @@ def submit():
         return
 
     run("git add --all", shell=True, capture_output=True, check=True)
-    run("git --no-pager diff --staged", shell=True, check=True)
-
-    if not click.confirm(address("Here are the current changes. Looks OK?")):
-        run("git restore --staged .", shell=True, capture_output=True)
-        click.echo(info("Cancelled the submit for now."))
-        return
 
     click.echo(info("Write your commit message, then save and exit the window..."))
-    commit_result = run("git commit", shell=True, capture_output=True, text=True)
-
-    if commit_result.returncode != 0:
-        combined = commit_result.stderr + commit_result.stdout
+    before_head = _current_head()
+    # Only stderr is captured here. Capturing stdout too (as this used to do)
+    # disconnects the interactive editor from the real terminal, which can
+    # break editing entirely depending on the student's editor. git's own
+    # post-editor messages (e.g. "Aborting commit...") go to stderr, so we
+    # can still detect that reliably.
+    commit_result = run("git commit", shell=True, stderr=PIPE, text=True)
+
+    # Never trust the editor/git return code alone -- confirm a commit was
+    # actually created before reporting success.
+    if _current_head() == before_head:
+        combined = commit_result.stderr or ""
         run("git restore --staged .", shell=True, capture_output=True)
         # S2: student saved without writing a message
         if "empty commit message" in combined or "Aborting commit" in combined:
@@ -78,16 +80,52 @@ def submit():
                 "You didn't write a commit message. "
                 "Run `mwc submit` again and describe what you worked on before saving."
             ))
+        # S6: configured editor is missing/broken (uninstalled, moved off PATH, ...)
+        elif "unable to start editor" in combined:
+            click.echo(error(
+                "Your configured code editor couldn't be launched -- it may have been "
+                "uninstalled or moved. Run `mwc setup` again to choose an editor, then "
+                "run `mwc submit` again."
+            ))
         else:
-            click.echo(debug_fmt(combined.strip(), preformatted=True))
+            if combined.strip():
+                click.echo(debug_fmt(combined.strip(), preformatted=True))
             click.echo(error(
-                "Could not save your work. "
-                "If you're not sure what to do, ask your teacher."
+                "Your work wasn't saved. "
+                "Run `mwc submit` again. If this keeps happening, ask your teacher for help."
             ))
         return
 
-    _push()
-    click.echo(address("Nice job! All your work in this module has been submitted."))
+    if _push():
+        click.echo(address("Nice job! All your work in this module has been submitted."))
+
+
+def _current_head():
+    """Returns the current commit hash, or None if there isn't one yet."""
+    result = run("git rev-parse HEAD", shell=True, capture_output=True, text=True)
+    return result.stdout.strip() if result.returncode == 0 else None
+
+
+def _conflicting_files(ref):
+    """Returns the list of files that can't be cleanly auto-merged when
+    merging `ref` into HEAD, without actually applying or committing
+    anything. -X ours auto-resolves conflicts and doesn't report them, so
+    this is the only way to tell whether the automatic merge is about to
+    silently pick a side on real conflicting content. (This is only called
+    once a commit already exists and the working tree is clean, so the only
+    failure mode possible here is a genuine textual conflict.)
+    """
+    merge_check = run(
+        f"git merge --no-commit --no-ff {ref}", shell=True, capture_output=True, text=True
+    )
+    conflicts = []
+    if merge_check.returncode != 0:
+        diff = run(
+            "git diff --name-only --diff-filter=U", shell=True, capture_output=True, text=True
+        )
+        conflicts = [f for f in diff.stdout.splitlines() if f.strip()]
+    run("git merge --abort", shell=True, capture_output=True)
+    return conflicts
 
 
 def _preflight_repo():
@@ -98,19 +136,28 @@ def _preflight_repo():
             f"Your repo was in an incomplete state (interrupted {aborted}). "
             "This has been cleared automatically."
         ))
-    branch = recover_detached_head()
-    if branch:
+    recovered = recover_detached_head()
+    if recovered:
+        branch, stash_unresolved = recovered
         click.echo(confirm(
             f"Your repo was not on any branch. Switched back to '{branch}'."
         ))
+        if stash_unresolved:
+            click.echo(error(
+                "Some of your uncommitted work couldn't be automatically restored "
+                "and is saved in a git stash instead of your files. "
+                "Ask your teacher for help recovering it."
+            ))
 
 
 def _push():
-    """Push to origin, with automatic recovery from non-fast-forward rejection."""
+    """Push to origin, with automatic recovery from non-fast-forward rejection.
+    Returns True only if the push was actually confirmed to succeed.
+    """
     push_result = run("git push", shell=True, capture_output=True, text=True)
 
     if push_result.returncode == 0:
-        return
+        return True
 
     combined = push_result.stderr + push_result.stdout
 
@@ -122,6 +169,8 @@ def _push():
             "Your teacher made some changes while you were working. "
             "Merging them in and resubmitting..."
         ))
+        run("git fetch origin", shell=True, capture_output=True)
+        conflicted = _conflicting_files("FETCH_HEAD")
         # -X ours: student's committed code wins any content conflict
         pull_result = run(
             "git pull -X ours", shell=True, capture_output=True, text=True
@@ -132,10 +181,17 @@ def _push():
                 "Could not automatically merge your teacher's changes. "
                 "Ask your teacher for help."
             ))
-            return
+            return False
+        if conflicted:
+            files = ", ".join(f"`{f}`" for f in conflicted)
+            click.echo(error(
+                f"Your teacher's changes to {files} conflicted with your own "
+                "changes to the same lines — your version was kept. Ask your "
+                "teacher if you're not sure that's right."
+            ))
         retry = run("git push", shell=True, capture_output=True, text=True)
         if retry.returncode == 0:
-            return
+            return True
         combined = retry.stderr + retry.stdout
 
     # S4: network error — commit is safe locally, tell them so
@@ -145,7 +201,7 @@ def _push():
             "(network error). Check your internet connection and run "
             "`mwc submit` again — you won't lose any work."
         ))
-        return
+        return False
 
     # S5: authentication error
     if any(p in combined for p in _AUTH_PHRASES):
@@ -153,10 +209,11 @@ def _push():
             "Your login credentials are no longer valid. "
             "Run `mwc setup` to refresh them, then run `mwc submit` again."
         ))
-        return
+        return False
 
     click.echo(debug_fmt(combined.strip(), preformatted=True))
     click.echo(error(
         "Could not send your work to the server. "
         "If the problem persists, ask your teacher for help."
     ))
+    return False

making_with_code_cli/teach/status.py

@@ -3,6 +3,7 @@ from csv import DictWriter
 from collections import defaultdict
 from tabulate import tabulate
 from making_with_code_cli.settings import read_settings
+from making_with_code_cli.curriculum import get_curriculum
 from making_with_code_cli.teach.setup import check_required_teacher_settings
 from making_with_code_cli.teach.student_repos import StudentRepos
 from making_with_code_cli.helpers import date_string
@@ -11,6 +12,8 @@ from making_with_code_cli.teach.student_repo_functions import (
     count_changed_py_lines,
     count_changed_md_lines,
     module_completion,
+    assessment_status,
+    unassessed,
 )
 from making_with_code_cli.styles import (
     address,
@@ -22,10 +25,12 @@ from making_with_code_cli.styles import (
 )
 
 measures = {
+    "assessment": ("Reading assessment status", assessment_status),
     "commits": ("Counting commits", count_commits),
     "py-lines": ("Counting changed lines in Python files", count_changed_py_lines),
     "md-lines": ("Counting changed lines in Markdown files", count_changed_md_lines),
     "completion": ("Running tests", module_completion),
+    "unassessed": ("Checking for unassessed work", unassessed),
 }
 
 @click.command()
@@ -35,8 +40,8 @@ measures = {
 @click.option("-u", "--user", help="Filter by username")
 @click.option("-n", "--unit", help="Filter by unit name/slug")
 @click.option("-m", "--module", help="Filter by module name/slug")
-@click.option("-v", "--measure", default="commits", type=click.Choice(measures.keys()), 
-        help="Measure to show")
+@click.option("-v", "--measure", default="assessment", type=click.Choice(measures.keys()),
+        help="Measure to show (default: current assessment status)")
 @click.option("-a", "--anonymous", is_flag=True, help="Hide usernames")
 @click.option("-x", "--short", is_flag=True, help="Show short module names")
 @click.option("-o", "--outfile", help="Save results as csv")
@@ -44,7 +49,7 @@ measures = {
 @click.option('-t', "--threads", type=int, default=8, help="Maximum simultaneous threads")
 @click.option('-B', "--begin", type=date_string, help="Begin date")
 @click.option('-C', "--end", type=date_string, help="End date")
-def status(config, section, course, user, unit, module, measure, anonymous, short, 
+def status(config, section, course, user, unit, module, measure, anonymous, short,
         outfile, update, threads, begin, end):
     "Show status of student repos by module"
     if update:
@@ -56,56 +61,82 @@ def status(config, section, course, user, unit, module, measure, anonymous, shor
     repos = StudentRepos(settings, threads)
     measure_status_message, measure_fn = measures[measure]
     results = repos.apply(
-        measure_fn, 
-        section=section, 
-        course=course, 
-        user=user, 
-        unit=unit, 
-        module=module, 
+        measure_fn,
+        section=section,
+        course=course,
+        user=user,
+        unit=unit,
+        module=module,
         begin=begin,
         end=end,
         status_message=measure_status_message
     )
     recursive_dict = lambda: defaultdict(recursive_dict)
     results_dict = recursive_dict()
+    section_objects = {}
     for r in results:
         s = r['section']['name'] + ' | ' + r['section']['course_name']
+        section_objects[s] = r['section']
         results_dict[s][r['username']][r['module']] = r['score']
     all_scores = []
-    for section, users in results_dict.items():
+    all_headers = None
+    for section_key, users in results_dict.items():
         if users:
-            headers = ['username'] + sorted(next(iter(users.values())).keys())
-            section_scores = format_user_scores(users, anonymous, short)
+            module_order = curriculum_module_order(section_objects[section_key])
+            ordered_modules = ordered_module_headers(users, module_order)
+            headers = ['username'] + [
+                shorten_module_name(m) if short else m for m in ordered_modules
+            ]
+            section_scores = format_user_scores(users, ordered_modules, anonymous, short)
             all_scores += section_scores
+            all_headers = headers
             if not outfile:
-                click.echo(address(section))
-                click.echo(address(tabulate(section_scores, headers='keys'), 
+                click.echo(address(section_key))
+                click.echo(address(tabulate(section_scores, headers='keys'),
                         preformatted=True))
     if outfile and all_scores:
         with open(outfile, 'w') as fh:
-            writer = DictWriter(fh, headers)
+            writer = DictWriter(fh, all_headers)
             writer.writeheader()
             writer.writerows(all_scores)
 
+def curriculum_module_order(section):
+    """Returns module slugs in curriculum (manifest) order for a section, so
+    tables can be sorted consistently with mwc status rather than by
+    whatever order threaded results happened to arrive in.
+    """
+    curr = get_curriculum(section['curriculum_site_url'], section['course_name'])
+    return [m['slug'] for u in curr['units'] for m in u['modules']]
+
+def ordered_module_headers(users, module_order):
+    """Returns every module slug that shows up for any user in `users`,
+    ordered to match `module_order` first, with anything not in the
+    curriculum (a stale/renamed module) appended alphabetically after.
+    """
+    present = set()
+    for user_scores in users.values():
+        present.update(user_scores.keys())
+    ordered = [m for m in module_order if m in present]
+    ordered += sorted(present - set(module_order))
+    return ordered
+
 def shorten_module_name(name):
     return name.replace("lab_", "").replace("project_", "").replace("problemset_", "")
 
-def format_user_scores(scores, anonymous=False, short=False):
+def format_user_scores(scores, ordered_modules, anonymous=False, short=False):
     formatted_scores = []
     for i, (username, user_scores) in enumerate(scores.items()):
-        if anonymous: 
+        if anonymous:
            username_dict  = {"username": f"student_{i}"}
         else:
             username_dict = {"username": username}
-        if short: 
-            formatted_user_scores = {
-                shorten_module_name(k): v 
-                for k, v in user_scores.items()
-            }
-        else:
-            formatted_user_scores = user_scores
-        formatted_scores.append(username_dict | formatted_user_scores)
+        # Every row gets the exact same keys, in the exact same order, so
+        # that tabulate's headers='keys' (which unions keys in first-seen
+        # order across rows) reflects curriculum order regardless of which
+        # specific modules any one student happens to have touched.
+        row = {
+            (shorten_module_name(m) if short else m): user_scores.get(m, "")
+            for m in ordered_modules
+        }
+        formatted_scores.append(username_dict | row)
     return sorted(formatted_scores, key=lambda user_scores_dict: user_scores_dict['username'])
-    
-
-

making_with_code_cli/teach/student_repo_functions.py

@@ -1,12 +1,24 @@
 import os
+from datetime import datetime, timezone
 from subprocess import run
 from git import Repo
 from making_with_code_cli.teach.gitea_api.api import GiteaTeacherApi
 from making_with_code_cli.helpers import in_bounds
+from making_with_code_cli.assessment import (
+    parse_assessment_file,
+    format_score,
+    AssessmentValidationError,
+)
+from making_with_code_cli.git_wrapper import commits_since
 
 MWC_GIT_PROTOCOL = "https"
 MWC_GIT_SERVER = "git.makingwithcode.org"
 
+# The identity configure_git() sets locally for every student -- matched as a
+# whitelist so "unassessed work" only ever means the student's own commits.
+STUDENT_EMAIL = "nobody@makingwithcode.org"
+EPOCH = datetime.min.replace(tzinfo=timezone.utc)
+
 def run_in_repo(command, cwd):
     return run(command, cwd=cwd, shell=True, capture_output=True, text=True)
 
@@ -92,10 +104,74 @@ def module_completion(semaphore, results, section, username, begin, end, path, t
     semaphore.acquire()
     if path.exists():
         results.append({
-            "section": section, 
-            "username": username, 
-            "module": path.name, 
+            "section": section,
+            "username": username,
+            "module": path.name,
             "score": 0
         })
     semaphore.release()
 
+def _read_local_assessment(path):
+    """Reads and parses assessment.md from a local module clone (the teacher's
+    own pulled copy, from `path` -- not a remote ref, unlike mwc status, since
+    the teacher already has an up-to-date local clone via `--update`).
+    Returns (assessment_or_None, error_bool).
+    """
+    assessment_path = path / "assessment.md"
+    if not assessment_path.exists():
+        return None, False
+    try:
+        return parse_assessment_file(assessment_path.read_text()), False
+    except AssessmentValidationError:
+        return None, True
+
+def _assessment_state(path, username):
+    "Returns (assessment_or_None, has_unassessed_work, error_bool) for one module."
+    assessment, err = _read_local_assessment(path)
+    if err:
+        return None, False, True
+    cutoff = assessment.timestamp if assessment else EPOCH
+    has_unassessed = commits_since(cutoff, username, STUDENT_EMAIL, cwd=path)
+    return assessment, has_unassessed, False
+
+def assessment_status(semaphore, results, section, username, begin, end, path, token):
+    """Default mwc teach status measure: the module's current assessment state.
+    A `*` after a score means there's unassessed work since that assessment
+    (the score is stale, not wrong). `U` alone means nothing has been
+    assessed yet, but something has been submitted. Blank means neither --
+    nothing to report, assessed or not.
+    """
+    semaphore.acquire()
+    if path.exists():
+        assessment, has_unassessed, err = _assessment_state(path, username)
+        if err:
+            score = "ERR"
+        elif assessment and has_unassessed:
+            score = format_score(assessment) + "*"
+        elif assessment:
+            score = format_score(assessment)
+        elif has_unassessed:
+            score = "U"
+        else:
+            score = ""
+        results.append({
+            "section": section,
+            "username": username,
+            "module": path.name,
+            "score": score,
+        })
+    semaphore.release()
+
+def unassessed(semaphore, results, section, username, begin, end, path, token):
+    "Boolean flag: does this module have work submitted since its last assessment?"
+    semaphore.acquire()
+    if path.exists():
+        _, has_unassessed, err = _assessment_state(path, username)
+        results.append({
+            "section": section,
+            "username": username,
+            "module": path.name,
+            "score": "ERR" if err else int(has_unassessed),
+        })
+    semaphore.release()
+

making_with_code_cli/update/__init__.py

@@ -65,8 +65,14 @@ def update(config, debug):
                     except GitError as e:
                         click.echo(error(str(e)))
                     except Exception as e:
-                        msg = traceback.format_exception(type(e), e, e.__traceback__)
-                        click.echo(error(''.join(msg), preformatted=True))
+                        if debug:
+                            msg = traceback.format_exception(type(e), e, e.__traceback__)
+                            click.echo(error(''.join(msg), preformatted=True))
+                        else:
+                            click.echo(error(
+                                f"There was a problem updating {module['slug']}. "
+                                "Run with --debug for details, or ask your teacher for help."
+                            ))
                 else:
                     rel_dir = module_dir.resolve().relative_to(mwc_home)
                     click.echo(confirm(f"Initializing {module['slug']} at {rel_dir}."))
@@ -76,5 +82,11 @@ def update(config, debug):
                     except GitError as e:
                         click.echo(error(str(e)))
                     except Exception as e:
-                        msg = traceback.format_exception(type(e), e, e.__traceback__)
-                        click.echo(error(''.join(msg), preformatted=True))
+                        if debug:
+                            msg = traceback.format_exception(type(e), e, e.__traceback__)
+                            click.echo(error(''.join(msg), preformatted=True))
+                        else:
+                            click.echo(error(
+                                f"There was a problem setting up {module['slug']}. "
+                                "Run with --debug for details, or ask your teacher for help."
+                            ))

{making_with_code_cli-5.4.0.dist-info → making_with_code_cli-5.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: making-with-code-cli
-Version: 5.4.0
+Version: 5.6.0
 Summary: Courseware for Making With Code
 Author: Chris Proctor
 Author-email: Chris Proctor <chris@chrisproctor.net>

{making_with_code_cli-5.4.0.dist-info → making_with_code_cli-5.6.0.dist-info}/RECORD

@@ -1,19 +1,21 @@
 making_with_code_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-making_with_code_cli/cli.py,sha256=KuSWKXYKK651tIXpeZ3nIVynRATal8NV-jSArYXEbo0,443
+making_with_code_cli/assessment.py,sha256=Ud00ATjt9V5qIcWutBK5L0yr_ciY1LvMpD22ZSXari4,7462
+making_with_code_cli/cli.py,sha256=PSrNB8kwkS7tGlpMTdHJoa4whUKDEYgANJaG37zNd7Q,514
 making_with_code_cli/curriculum.py,sha256=LewUkk2BHZsQhbZMXi3JiYm1ROcxpQL1u-nsd43x_hw,1192
 making_with_code_cli/decorators.py,sha256=d-fLMfi2BX6jaLAqaHbQFBUGyHaCijqq6EpSCAl3YCk,583
 making_with_code_cli/errors.py,sha256=V0JfwUPMEoU16cDxJh_SR-xQbLEtA5EwsV9RoI6l6C0,1152
 making_with_code_cli/git_backend/__init__.py,sha256=UleXH-1HbEglNL8y_d7-JpQfLRDZ2pBpLYzy9-eH_k0,112
 making_with_code_cli/git_backend/base_backend.py,sha256=zxk3PxI6y35s2pYh1nl5Rz9c2S9BPF2M6HSge63WGyo,841
-making_with_code_cli/git_backend/mwc_backend.py,sha256=O5_cz3eEK90yc4h5So9zmSGuCcEdCM2NKHdsClbVcQI,11358
-making_with_code_cli/git_wrapper.py,sha256=M2J5k9HheNPd91GR-sGaWiYgTnG9vNfjxSbEGswSjdo,3898
+making_with_code_cli/git_backend/mwc_backend.py,sha256=W0u63CRVaK3W1k9omS0qTcEzcyr64wNc824wJ2qi7Gg,15288
+making_with_code_cli/git_wrapper.py,sha256=1QYiPIsFuFzumYcujYMhRgSzGObImpyyM0mwXbbI23Q,6147
 making_with_code_cli/helpers.py,sha256=h4-gkT0y61GGzV08xcaEqLGJ9N9IQPEMa2P_7_g2sY0,1167
 making_with_code_cli/mwc_accounts_api.py,sha256=INq0ezDY3bDYTLt7cAFp5JmJ4rkr9LcDnz6YYp5d-VQ,4641
 making_with_code_cli/settings.py,sha256=c_sWjBgjrugXx-11rWOOVKFcxiU5WfFENR0WhZs7LLI,1809
-making_with_code_cli/setup/__init__.py,sha256=2mABWsAEhf7rx9Yx3WfxAOMce1A-AYQuByIWZboZaI0,4533
-making_with_code_cli/setup/tasks.py,sha256=jTlcDiviuzXyhIcdYhGhWLXH8zVvKqW_7i79GXZOtNg,16382
+making_with_code_cli/setup/__init__.py,sha256=RjNRrtBduvFmS6gNhxN03DtJ9Jb0qt7pPdVtQl1Vn08,4631
+making_with_code_cli/setup/tasks.py,sha256=9G7SI4jHORpGbs1ghf4sdRFthRAcCQj4NrqkEO1KrkI,18170
+making_with_code_cli/status.py,sha256=N7zaZ7xr-Oklh0Q76ektNulL0R8QLKSSh47YNRK7Zlg,6189
 making_with_code_cli/styles.py,sha256=ZKbs-Grq1aF3wV8scwQxMO1UjnphuIccdNzksLxAo_A,910
-making_with_code_cli/submit.py,sha256=3rit0F9ott27JezXhujYBUJSOopRJ_xEcm1oACigP88,5496
+making_with_code_cli/submit.py,sha256=pV4lCV_hQotFhk2LkKa5M1hlvOZ0FmbO9e5SJf8Ga00,8315
 making_with_code_cli/teach/__init__.py,sha256=qra5g986DFipl0GkYOW3Nnoi1QUGpatS_U9eFoVVsgw,779
 making_with_code_cli/teach/assess.py,sha256=2--XhfMRsyMoEaP7EAeRD4uk5tynB3wLE3KE5pdYC30,1625
 making_with_code_cli/teach/check/__init__.py,sha256=wlUNHdHI5NwUbGGTHCM87xdJ4Ts3bwMfBF8wXoK2Z68,1787
@@ -28,21 +30,21 @@ making_with_code_cli/teach/section/delete.py,sha256=Z9uljVCqaKDw4-SzoAl-jxs4SHCB
 making_with_code_cli/teach/section/edit.py,sha256=OKub7wJ7yINBw4qkf-L_urrkB4nlXRauIcNbxuLTjGk,2157
 making_with_code_cli/teach/section/show.py,sha256=YZ1fJr3LSQl0E9hgkV9-gndyYn0FnUbPa5ChO2CWbb8,2260
 making_with_code_cli/teach/setup.py,sha256=sF6j-aPOsQ4vJwOb7I_t57LZF5dDmOib15hpET9HAsI,3149
-making_with_code_cli/teach/status.py,sha256=HIMdHCG0JUrrQBu9EDKxOrg52_zYUNj1w6BfFYonds8,4520
+making_with_code_cli/teach/status.py,sha256=TNwZVF7nI5qKFcTW6Tg7QKRyWrQSPiWG03pba5aLZMs,6240
 making_with_code_cli/teach/student/__init__.py,sha256=VamqMDxH-ZuGZWTR5g8jYQ3XkgWYQqmunVorpZ00fbM,402
 making_with_code_cli/teach/student/create.py,sha256=Oa78OSUyeDGepjgg6ivycTpzYQl70anc6PEXrvT2s_s,1822
 making_with_code_cli/teach/student/edit.py,sha256=EhP-x7QNXFDh4YGnW8CNjggDbUOAyfZqxa9ZM2gpffY,1257
 making_with_code_cli/teach/student/remove.py,sha256=z6Y_n1Q53qGeauSCaqzjO852pRkMDoioVoPS1TChMcM,1300
-making_with_code_cli/teach/student_repo_functions.py,sha256=-Qm-SgkiCW_d1jnuNi5I5B3YBeWqBybqrL5sgXwQ77Q,3633
+making_with_code_cli/teach/student_repo_functions.py,sha256=HiwcqeBLB5GpMbUbnX0YP1HIKCutf2iDaPVGvW3v-uI,6617
 making_with_code_cli/teach/student_repos.py,sha256=TRUxpgyrGjsiY58dIpPLGOzytw9sL9zgS-kUquXd39Q,2614
 making_with_code_cli/teach/update.py,sha256=bhGpZudmTrH0pSq-hLfmKOAgMBsmMZG-nfB7zA79tkg,1860
 making_with_code_cli/teach/workspace/__init__.py,sha256=FDe1ggbBYVC5EWH1NBjWdyGgxqjlSQxf_iKDDYqyOgA,1298
 making_with_code_cli/teach/workspace/create.py,sha256=t0hIwJwU7ZEF3QJl0Cwbve3jD1ilYex680dRCvhbkr0,1320
 making_with_code_cli/teach/workspace/delete.py,sha256=126VQaFMvulpXY_ch1yXNN4fCLL_bQfAnkRwnOL9PYk,952
 making_with_code_cli/teach/workspace/edit.py,sha256=BndmJrItJMB3JzW6MNCfqyLPTV6UaPh2T6hQa73TcJQ,1369
-making_with_code_cli/update/__init__.py,sha256=13Sy6mYojZANKF6YOB5GkWvxwbPLWaZfvjCfqk9Nztw,3737
+making_with_code_cli/update/__init__.py,sha256=kNbCKchXDQZUsmwpLWkJDoacMm2fry5IK-NRnkcwgB0,4391
 making_with_code_cli/version.py,sha256=4t7TOR5OlBrLFy7jrtS_d6FtIReco1NDdVPQoCb6Jx8,286
-making_with_code_cli-5.4.0.dist-info/WHEEL,sha256=Qb5DWjqM6GZuPp3VmTlAFSGqNRK8vceyVqRFxrfa8YA,80
-making_with_code_cli-5.4.0.dist-info/entry_points.txt,sha256=0nHqTE6I8cKRoVK_tbRNYI9nY0GFYLDJDZemvDqIHeM,54
-making_with_code_cli-5.4.0.dist-info/METADATA,sha256=Z7qbd43JmUV2Aw75kw9Yy146keZY6Zx7wxporkZwra4,2321
-making_with_code_cli-5.4.0.dist-info/RECORD,,
+making_with_code_cli-5.6.0.dist-info/WHEEL,sha256=Qb5DWjqM6GZuPp3VmTlAFSGqNRK8vceyVqRFxrfa8YA,80
+making_with_code_cli-5.6.0.dist-info/entry_points.txt,sha256=0nHqTE6I8cKRoVK_tbRNYI9nY0GFYLDJDZemvDqIHeM,54
+making_with_code_cli-5.6.0.dist-info/METADATA,sha256=rXfrt7bK6BxY0KSm3RiBK9zXbCnjdE1jH7u0dmhgV3c,2321
+making_with_code_cli-5.6.0.dist-info/RECORD,,