making-with-code-cli 5.2.1__tar.gz → 5.4.0__tar.gz

{making_with_code_cli-5.2.1 → making_with_code_cli-5.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: making-with-code-cli
-Version: 5.2.1
+Version: 5.4.0
 Summary: Courseware for Making With Code
 Author: Chris Proctor
 Author-email: Chris Proctor <chris@chrisproctor.net>
@@ -42,7 +42,7 @@ Making With Code, there is a separate bootstrapping process you should follow.
 Please consult your curriculum website (or ask your teacher) for detailed instructions 
 on how and why to use this tool. 
 
-    pip3 install making-with-code-cli
+    uv tool install making-with-code-cli
 
 Once installed, you can set up your computer using the `mwc setup` command. Run 
 `mwc --help` to see all the commands available.  

{making_with_code_cli-5.2.1 → making_with_code_cli-5.4.0}/README.md

@@ -17,7 +17,7 @@ Making With Code, there is a separate bootstrapping process you should follow.
 Please consult your curriculum website (or ask your teacher) for detailed instructions 
 on how and why to use this tool. 
 
-    pip3 install making-with-code-cli
+    uv tool install making-with-code-cli
 
 Once installed, you can set up your computer using the `mwc setup` command. Run 
 `mwc --help` to see all the commands available.  

{making_with_code_cli-5.2.1 → making_with_code_cli-5.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "making-with-code-cli"
-version = "5.2.1"
+version = "5.4.0"
 description = "Courseware for Making With Code"
 authors = [{ name = "Chris Proctor", email = "chris@chrisproctor.net" }]
 requires-python = ">=3.11,<4.0"

{making_with_code_cli-5.2.1 → making_with_code_cli-5.4.0}/src/making_with_code_cli/curriculum.py

@@ -11,7 +11,7 @@ def get_curriculum(mwc_site_url, course_name=None):
     """Fetches curriculum metadata from the site url specified in settings.
     Returns the curriculum metadata for course_name.
     """
-    url = mwc_site_url + "/manifest"
+    url = mwc_site_url.rstrip("/") + "/manifest"
     try:
         response = requests.get(url, timeout=15)
     except requests.exceptions.RequestException as e:

{making_with_code_cli-5.2.1 → making_with_code_cli-5.4.0}/src/making_with_code_cli/errors.py

@@ -26,3 +26,15 @@ class SoftwareInstallationError(MWCError):
 
 class NoCurriculaAvailable(MWCError):
     pass
+
+class GitError(MWCError):
+    pass
+
+class GitNetworkError(GitError):
+    pass
+
+class GitAuthError(GitError):
+    pass
+
+class GitCorruptError(GitError):
+    pass

{making_with_code_cli-5.2.1 → making_with_code_cli-5.4.0}/src/making_with_code_cli/git_backend/base_backend.py

@@ -2,7 +2,6 @@ from pathlib import Path
 from subprocess import run, CalledProcessError
 import click
 from making_with_code_cli.helpers import cd
-from making_with_code_cli.setup.tasks import WORK_DIR_PERMISSIONS
 from making_with_code_cli.styles import (
     address,
     info,

making_with_code_cli-5.4.0/src/making_with_code_cli/git_backend/mwc_backend.py

@@ -0,0 +1,299 @@
+from .base_backend import GitBackend
+from subprocess import run, CalledProcessError
+import traceback
+from pathlib import Path
+from urllib.parse import urlparse
+import click
+import json
+import os
+import requests
+from making_with_code_cli.helpers import cd
+from making_with_code_cli.git_wrapper import (
+    abort_in_progress_operation,
+    recover_detached_head,
+    clear_stale_index_lock,
+    _get_default_branch,
+)
+from making_with_code_cli.styles import (
+    address,
+    confirm,
+    debug,
+    error,
+    info,
+)
+from making_with_code_cli.errors import (
+    MissingSetting,
+    GitServerNotAvailable,
+    GitError,
+    GitNetworkError,
+    GitAuthError,
+    GitCorruptError,
+)
+
+EDITOR_COMMANDS = {
+    "atom": "atom --wait",
+    "code": "code --wait",
+    "subl": "subl -n -w",
+    "mate": "mate -w",
+    "vim": "vim",
+    "emacs": "emacs",
+}
+
+# Phrases in git stderr that identify each failure mode
+_NETWORK_PHRASES = [
+    "Could not resolve host",
+    "Connection timed out",
+    "unable to connect",
+    "Failed to connect",
+    "network is unreachable",
+    "Connection refused",
+]
+_AUTH_PHRASES = [
+    "Authentication failed",
+    "403",
+    "invalid credentials",
+    "could not read Username",
+    "terminal prompts disabled",
+    "Repository not found",
+]
+_CORRUPT_PHRASES = [
+    "corrupt",
+    "bad object",
+    "loose object",
+    "fatal: bad",
+    "object file is empty",
+]
+_NO_UPSTREAM_PHRASES = [
+    "no tracking information",
+    "has no upstream",
+    "There is no tracking information",
+]
+
+
+class MWCBackend(GitBackend):
+    """A Github backend. Students own their own repos and grant teachers access via token."""
+
+    MWC_GIT_PROTOCOL = "https"
+    MWC_GIT_SERVER = "git.makingwithcode.org"
+    COMMIT_TEMPLATE = ".commit_template"
+
+    @property
+    def git_server(self):
+        """Returns the git server hostname, respecting git_server_url setting if set."""
+        url = self.settings.get('git_server_url')
+        if url:
+            parsed = urlparse(url)
+            return parsed.netloc
+        return self.MWC_GIT_SERVER
+
+    def init_module(self, module, modpath):
+        """Creates the named repo from a template."""
+        self.check_settings()
+        server, repo_owner, repo_name = self.parse_repo_url(module["repo_url"])
+
+        if modpath.exists():
+            self.relocate_existing_directory(modpath)
+        if not self.user_has_repo(repo_name):
+            self.create_from_template(repo_owner, repo_name)
+        with cd(modpath.parent):
+            self.clone_repo(repo_name)
+        self.configure_git(modpath)
+        if (modpath / self.COMMIT_TEMPLATE).exists():
+            run(["git", "config", "--local", "commit.template", self.COMMIT_TEMPLATE],
+                    check=True, cwd=modpath)
+        if self.settings.get('manage_python_environment', True):
+            run("uv venv", shell=True, check=True, cwd=modpath, capture_output=True)
+            self.init_direnv(modpath)
+
+    def configure_git(self, modpath):
+        """Configures git user settings locally for the repo."""
+        name = self.settings['mwc_username']
+        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 = self.settings.get('editor')
+        if editor in EDITOR_COMMANDS:
+            run(["git", "config", "--local", "core.editor", EDITOR_COMMANDS[editor]],
+                check=True, cwd=modpath)
+
+    def update(self, module, modpath, install=True):
+        if (modpath / ".git").is_dir():
+            relpath = self.relative_path(modpath)
+            click.echo(address(f"Checking {relpath} for updates.", preformatted=True))
+            pull_output = self.safe_pull(modpath)
+            if pull_output:
+                click.echo(info(pull_output))
+            if install and (modpath / "pyproject.toml").exists() and self.settings.get('manage_python_environment', True):
+                result = run("uv sync", shell=True, capture_output=True, text=True, cwd=modpath)
+                if result.returncode != 0:
+                    click.echo(debug("Error running uv sync:"))
+                    click.echo(debug(result.stderr, preformatted=True))
+                    click.echo(error(f"There was a problem updating {relpath}. Ask a teacher."))
+                else:
+                    self.init_direnv(modpath)
+
+    def safe_pull(self, modpath):
+        """Pulls from origin with robust recovery for common git error states.
+        Returns the git output string on success. Raises GitError subclasses on
+        unrecoverable failures.
+        """
+        # Fix bad repo states before attempting the pull
+        aborted = abort_in_progress_operation(modpath)
+        if aborted:
+            click.echo(confirm(
+                f"Cleared an incomplete git {aborted} — this shouldn't affect your work."
+            ))
+
+        branch = recover_detached_head(modpath)
+        if branch:
+            click.echo(confirm(
+                f"Your repo was not on any branch. Switched back to '{branch}'."
+            ))
+
+        clear_stale_index_lock(modpath)
+
+        # U1: uncommitted changes that would be overwritten — auto-commit first
+        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
+            )
+            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:
+            return result.stdout
+
+        combined = result.stderr + result.stdout
+
+        # U8: no upstream tracking branch — set it and retry
+        if any(p in combined for p in _NO_UPSTREAM_PHRASES):
+            default_branch = _get_default_branch(modpath)
+            run(
+                f"git branch --set-upstream-to=origin/{default_branch} {default_branch}",
+                shell=True, capture_output=True, cwd=modpath
+            )
+            result = self._run_pull(modpath)
+            if result.returncode == 0:
+                return result.stdout
+            combined = result.stderr + result.stdout
+
+        click.echo(debug(combined.strip(), preformatted=True))
+        self._raise_pull_error(combined)
+
+    def _run_pull(self, modpath):
+        # -X theirs resolves merge conflicts in favor of incoming (teacher) changes,
+        # and also handles diverged-history cases (U2, U3) without extra configuration.
+        return run(
+            "git pull -X theirs",
+            shell=True, capture_output=True, text=True, cwd=modpath
+        )
+
+    def _raise_pull_error(self, stderr):
+        if any(p in stderr for p in _NETWORK_PHRASES):
+            raise GitNetworkError(
+                "Could not connect to the MWC server. "
+                "Check your internet connection and try again."
+            )
+        if any(p in stderr for p in _AUTH_PHRASES):
+            raise GitAuthError(
+                "Your login credentials are no longer valid. "
+                "Run `mwc setup` to refresh them, then run `mwc update` again."
+            )
+        if any(p in stderr for p in _CORRUPT_PHRASES):
+            raise GitCorruptError(
+                "Your local copy of this module appears to be damaged. "
+                "Ask your teacher for help."
+            )
+        raise GitError(
+            "Could not update this module. "
+            "The details are shown above. If you're not sure what to do, ask your teacher."
+        )
+
+    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)
+
+    def user_has_repo(self, repo_name, username=None):
+        """Checks to see whether a user already has the named repo."""
+        username = username or self.settings['mwc_username']
+        url = f"/repos/{username}/{repo_name}"
+        response = self.authenticated_mwc_request('get', url)
+        return response.ok
+
+    def create_from_template(self, template_owner, template_name):
+        url = f"/repos/{template_owner}/{template_name}/generate"
+        data = {
+            "name": template_name,
+            "owner": self.settings['mwc_username'],
+            "git_content": True
+        }
+        response = self.authenticated_mwc_request('post', url, data=data)
+        return response
+
+    def clone_repo(self, repo_name):
+        user = self.settings['mwc_username']
+        auth = user + ':' + self.settings['mwc_git_token']
+        url = f"{self.MWC_GIT_PROTOCOL}://{auth}@{self.git_server}/{user}/{repo_name}.git"
+        run(["git", "clone", url], check=True, capture_output=True)
+
+    def check_settings(self):
+        if "mwc_username" not in self.settings:
+            raise MissingSetting('mwc_username')
+        if "mwc_git_token" not in self.settings:
+            raise MissingSetting('mwc_git_token')
+
+    def parse_repo_url(self, url):
+        """Parses a MWC url like "https://git.makingwithcode.org/mwc/lab_pipes.git"
+        Returns ("https://git.makingwithcode.org", "mwc", "lab_pipes")
+        """
+        result = urlparse(url)
+        server = f"{result.scheme}://{result.netloc}"
+        path, suffix = result.path.split('.')
+        repo_owner, repo_name = path.strip('/').split('/')
+        return (server, repo_owner, repo_name)
+
+    def authenticated_mwc_request(self, method_name, urlpath, data=None, params=None):
+        server = self.MWC_GIT_PROTOCOL + '://' + self.git_server
+        args = {
+            'url': server + "/api/v1" + urlpath,
+            'auth': (self.settings['mwc_username'], self.settings['mwc_git_token']),
+        }
+        if data:
+            args['data'] = data
+        if params:
+            args['params'] = params
+        method = getattr(requests, method_name)
+        response = method(**args)
+        if response.status_code >= 500 or response.status_code == 403:
+            raise GitServerNotAvailable(server)
+        return response
+
+    def relocate_existing_directory(self, path):
+        """Moves an existing directory out of the way."""
+        new_path = path.parent / path.name + '_old'
+        while new_path.exists():
+            new_path = new_path.parent / new_path.name + '_old'
+        click.echo(confirm(f"Moving existing directory {path} to {new_path}."))
+        os.rename(path, new_path)

making_with_code_cli-5.4.0/src/making_with_code_cli/git_wrapper.py

@@ -0,0 +1,124 @@
+from pathlib import Path
+from subprocess import run, CalledProcessError
+from making_with_code_cli.helpers import cd
+
+
+def in_repo():
+    """Checks whether currently in repo"""
+    try:
+        run("git status", shell=True, capture_output=True, check=True)
+        return True
+    except CalledProcessError:
+        return False
+
+
+def repo_has_changes():
+    return len(changed_files()) > 0
+
+
+def changed_files():
+    "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
+    files = []
+    if result:
+        for line in result.split('\n'):
+            files.append((line[:2], line[3:]))
+        return files
+    else:
+        return []
+
+
+def has_unpushed_commits(cwd=None):
+    """Returns True if there are committed but unpushed local changes."""
+    result = run(
+        "git log @{u}..HEAD --oneline",
+        shell=True, capture_output=True, text=True, cwd=cwd
+    )
+    if result.returncode != 0:
+        return False
+    return bool(result.stdout.strip())
+
+
+def get_repo_state(cwd=None):
+    """Returns 'merge', 'rebase', 'cherry-pick', 'detached', or 'clean'."""
+    git_dir = _git_dir(cwd)
+    if (git_dir / "MERGE_HEAD").exists():
+        return "merge"
+    if (git_dir / "rebase-merge").exists() or (git_dir / "rebase-apply").exists():
+        return "rebase"
+    if (git_dir / "CHERRY_PICK_HEAD").exists():
+        return "cherry-pick"
+    result = run(
+        "git branch --show-current",
+        shell=True, capture_output=True, text=True, cwd=cwd
+    )
+    if result.returncode == 0 and not result.stdout.strip():
+        return "detached"
+    return "clean"
+
+
+def abort_in_progress_operation(cwd=None):
+    """Aborts any in-progress merge, rebase, or cherry-pick.
+    Returns the operation name that was aborted, or None if nothing to abort.
+    """
+    state = get_repo_state(cwd)
+    commands = {
+        "merge": "git merge --abort",
+        "rebase": "git rebase --abort",
+        "cherry-pick": "git cherry-pick --abort",
+    }
+    if state in commands:
+        run(commands[state], shell=True, capture_output=True, cwd=cwd)
+        return state
+    return 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.
+    """
+    if get_repo_state(cwd) != "detached":
+        return None
+    branch = _get_default_branch(cwd)
+    # Stash any uncommitted work so the checkout doesn't fail
+    stash_result = run(
+        "git stash", shell=True, capture_output=True, text=True, cwd=cwd
+    )
+    had_stash = "No local changes to save" not in stash_result.stdout
+    run(["git", "checkout", branch], capture_output=True, cwd=cwd)
+    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_result.returncode != 0:
+            run("git stash drop", shell=True, capture_output=True, cwd=cwd)
+    return branch
+
+
+def clear_stale_index_lock(cwd=None):
+    """Removes .git/index.lock if present. Returns True if a lock was cleared."""
+    lock = _git_dir(cwd) / "index.lock"
+    if lock.exists():
+        lock.unlink()
+        return True
+    return False
+
+
+def _get_default_branch(cwd=None):
+    """Returns the remote default branch name, falling back to 'main'."""
+    result = run(
+        "git symbolic-ref refs/remotes/origin/HEAD",
+        shell=True, capture_output=True, text=True, cwd=cwd
+    )
+    if result.returncode == 0:
+        return result.stdout.strip().replace("refs/remotes/origin/", "")
+    return "main"
+
+
+def _git_dir(cwd=None):
+    """Returns the Path to the .git directory for the given working dir."""
+    if cwd is None:
+        return Path(".git")
+    return Path(cwd) / ".git"

{making_with_code_cli-5.2.1 → making_with_code_cli-5.4.0}/src/making_with_code_cli/mwc_accounts_api.py

@@ -45,6 +45,26 @@ class MWCAccountsAPI:
         response = self.put("/students", data=params, token=token)
         return self.handle_response(response)
 
+    def sync_workspace(self, token, workspace_id):
+        response = self.post(f"/workspaces/{workspace_id}/sync", token=token)
+        return self.handle_response(response)
+
+    def list_workspaces(self, token):
+        response = self.get("/workspaces", token=token)
+        return self.handle_response(response)
+
+    def create_workspace(self, token, params):
+        response = self.post("/workspaces", data=params, token=token)
+        return self.handle_response(response)
+
+    def update_workspace(self, token, workspace_id, params):
+        response = self.put(f"/workspaces/{workspace_id}", data=params, token=token)
+        return self.handle_response(response)
+
+    def delete_workspace(self, token, workspace_id):
+        response = self.delete(f"/workspaces/{workspace_id}", 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)

{making_with_code_cli-5.2.1 → making_with_code_cli-5.4.0}/src/making_with_code_cli/settings.py

@@ -5,7 +5,7 @@ import os
 
 def get_settings_path(settings_path=None):
     """Determines the settings path, based on what is passed and environment.
-    "The default location for the MWC configuration file is ~/.mwc.
+    "The default location for the MWC configuration file is ~/.config/mwc/settings.toml.
     This can be specified (e.g. to support parallel installations) using
     the MWC_CONFIG environment variable or the --config flag.
     """

{making_with_code_cli-5.2.1 → making_with_code_cli-5.4.0}/src/making_with_code_cli/setup/__init__.py

@@ -4,7 +4,6 @@ from pprint import pformat
 import traceback
 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,
@@ -86,6 +85,8 @@ def setup(ctx, config, debug, mwc_accounts_url):
             token = prompt_mwc_password(settings['mwc_username'], api)
             settings['mwc_accounts_token'] = token
     settings['mwc_git_token'] = status['git_token']
+    if status.get('git_server_url'):
+        settings['git_server_url'] = status['git_server_url']
     settings['work_dir'] = str(choose_work_dir(settings.get("work_dir")).resolve())
     settings['editor'] = choose_editor(settings.get('editor', 'code'))
     if debug:
@@ -128,4 +129,5 @@ def setup(ctx, config, debug, mwc_accounts_url):
         for task in errors:
             click.echo(error(f"- {task.description}"))
     else:
+        from making_with_code_cli.update import update
         ctx.invoke(update, config=config)

making_with_code_cli-5.4.0/src/making_with_code_cli/submit.py

@@ -0,0 +1,162 @@
+import click
+from subprocess import run, CalledProcessError
+from making_with_code_cli.git_wrapper import (
+    in_repo,
+    repo_has_changes,
+    has_unpushed_commits,
+    abort_in_progress_operation,
+    recover_detached_head,
+    clear_stale_index_lock,
+)
+from making_with_code_cli.styles import (
+    address,
+    info,
+    confirm,
+    debug as debug_fmt,
+    error,
+)
+
+_NETWORK_PHRASES = [
+    "Could not resolve host",
+    "Connection timed out",
+    "unable to connect",
+    "Failed to connect",
+    "network is unreachable",
+]
+_AUTH_PHRASES = [
+    "Authentication failed",
+    "403",
+    "invalid credentials",
+    "could not read Username",
+    "terminal prompts disabled",
+]
+
+
+@click.command()
+def submit():
+    """Submit your work.
+    (This is a wrapper for the basic git workflow.)
+    """
+    if not in_repo():
+        click.echo(error("You are not in a lab, problem set, or project folder."))
+        return
+
+    _preflight_repo()
+    clear_stale_index_lock()
+
+    # S1: committed but not yet pushed — skip straight to push
+    if not repo_has_changes() and has_unpushed_commits():
+        click.echo(confirm(
+            "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."))
+        return
+
+    if not repo_has_changes():
+        click.echo(info("Everything is already up to date."))
+        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
+        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:
+            click.echo(error(
+                "You didn't write a commit message. "
+                "Run `mwc submit` again and describe what you worked on before saving."
+            ))
+        else:
+            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."
+            ))
+        return
+
+    _push()
+    click.echo(address("Nice job! All your work in this module has been submitted."))
+
+
+def _preflight_repo():
+    """Abort any in-progress git operations and recover from detached HEAD."""
+    aborted = abort_in_progress_operation()
+    if aborted:
+        click.echo(confirm(
+            f"Your repo was in an incomplete state (interrupted {aborted}). "
+            "This has been cleared automatically."
+        ))
+    branch = recover_detached_head()
+    if branch:
+        click.echo(confirm(
+            f"Your repo was not on any branch. Switched back to '{branch}'."
+        ))
+
+
+def _push():
+    """Push to origin, with automatic recovery from non-fast-forward rejection."""
+    push_result = run("git push", shell=True, capture_output=True, text=True)
+
+    if push_result.returncode == 0:
+        return
+
+    combined = push_result.stderr + push_result.stdout
+
+    # S3: teacher pushed changes since the student last pulled
+    if "non-fast-forward" in combined or (
+        "rejected" in combined and "fetch first" in combined
+    ):
+        click.echo(confirm(
+            "Your teacher made some changes while you were working. "
+            "Merging them in and resubmitting..."
+        ))
+        # -X ours: student's committed code wins any content conflict
+        pull_result = run(
+            "git pull -X ours", shell=True, capture_output=True, text=True
+        )
+        if pull_result.returncode != 0:
+            click.echo(debug_fmt(pull_result.stderr.strip(), preformatted=True))
+            click.echo(error(
+                "Could not automatically merge your teacher's changes. "
+                "Ask your teacher for help."
+            ))
+            return
+        retry = run("git push", shell=True, capture_output=True, text=True)
+        if retry.returncode == 0:
+            return
+        combined = retry.stderr + retry.stdout
+
+    # S4: network error — commit is safe locally, tell them so
+    if any(p in combined for p in _NETWORK_PHRASES):
+        click.echo(error(
+            "Your work was saved locally but could not be sent to the server "
+            "(network error). Check your internet connection and run "
+            "`mwc submit` again — you won't lose any work."
+        ))
+        return
+
+    # S5: authentication error
+    if any(p in combined for p in _AUTH_PHRASES):
+        click.echo(error(
+            "Your login credentials are no longer valid. "
+            "Run `mwc setup` to refresh them, then run `mwc submit` again."
+        ))
+        return
+
+    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."
+    ))

{making_with_code_cli-5.2.1 → making_with_code_cli-5.4.0}/src/making_with_code_cli/teach/__init__.py

@@ -7,6 +7,7 @@ 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
+from making_with_code_cli.teach.workspace import workspace
 
 @click.group()
 def teach():
@@ -20,3 +21,4 @@ teach.add_command(patch)
 teach.add_command(check)
 teach.add_command(section)
 teach.add_command(student)
+teach.add_command(workspace)

{making_with_code_cli-5.2.1 → making_with_code_cli-5.4.0}/src/making_with_code_cli/teach/setup.py

@@ -72,6 +72,8 @@ def setup(config, debug, mwc_accounts_url):
             token = prompt_mwc_password(settings['mwc_username'], api)
             settings['mwc_accounts_token'] = token
     settings['mwc_git_token'] = status['git_token']
+    if status.get('git_server_url'):
+        settings['git_server_url'] = status['git_server_url']
     settings['work_dir'] = str(choose_work_dir(settings.get("work_dir")))
     settings['editor'] = choose_editor(settings.get('editor', 'code'))
     settings['teacher_work_dir'] = str(choose_work_dir(

{making_with_code_cli-5.2.1 → making_with_code_cli-5.4.0}/src/making_with_code_cli/teach/student/create.py

@@ -16,18 +16,39 @@ def create_student(username, password, section, config):
     "Create a student user"
     settings = read_settings(config)
     api = MWCAccountsAPI(settings.get('mwc_accounts_url'))
+    token = settings.get('mwc_accounts_token')
     params = {
-        "username": username, 
-        "password": password, 
+        "username": username,
+        "password": password,
         "section": section,
     }
     try:
-        response = api.create_student(settings.get('mwc_accounts_token'), params)
+        response = api.create_student(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)}"))
+        return
+
+    workspace_id = _get_section_workspace_id(api, token, section)
+    if workspace_id:
+        try:
+            api.sync_workspace(token, workspace_id)
+            click.echo(info(f"Provisioned {username} on workspace."))
+        except (api.RequestFailed, api.ServerError) as err:
+            click.echo(error(f"Could not provision {username} on workspace: {err}"))
+
+
+def _get_section_workspace_id(api, token, section_slug):
+    try:
+        roster = api.get_roster(token)
+        for sec in roster.get('teacher_sections', []):
+            if sec['slug'] == section_slug:
+                return sec.get('workspace_id')
+    except Exception:
+        pass
+    return None
 
 

making_with_code_cli-5.4.0/src/making_with_code_cli/teach/workspace/__init__.py

@@ -0,0 +1,31 @@
+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, question
+from making_with_code_cli.teach.setup import check_required_teacher_settings
+from making_with_code_cli.teach.workspace.create import create_workspace
+from making_with_code_cli.teach.workspace.edit import edit_workspace
+from making_with_code_cli.teach.workspace.delete import delete_workspace
+
+
+@click.group(invoke_without_command=True)
+@click.pass_context
+@click.option("--config", help="Path to config file (default: ~/.mwc)")
+def workspace(ctx, config):
+    "Manage workspaces"
+    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'))
+        workspaces = api.list_workspaces(settings['mwc_accounts_token'])
+        if workspaces:
+            click.echo(info(tabulate(workspaces, headers="keys"), preformatted=True))
+        else:
+            click.echo(info("You have no workspaces."))
+
+
+workspace.add_command(create_workspace)
+workspace.add_command(edit_workspace)
+workspace.add_command(delete_workspace)

making_with_code_cli-5.4.0/src/making_with_code_cli/teach/workspace/create.py

@@ -0,0 +1,28 @@
+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, question
+
+
+@click.command('create')
+@click.option("--config", help="Path to config file (default: ~/.mwc)")
+@click.option("--name", help="Workspace name")
+@click.option("--url", help="JupyterHub URL (e.g. https://hub.example.org)")
+@click.option("--api-token", help="JupyterHub API token")
+def create_workspace(config, name, url, api_token):
+    "Create a new workspace"
+    settings = read_settings(config)
+    api = MWCAccountsAPI(settings.get('mwc_accounts_url'))
+    params = {
+        "name": name or click.prompt(question("Workspace name")),
+        "url": url or click.prompt(question("JupyterHub URL")),
+        "api_token": api_token or click.prompt(question("JupyterHub API token"), hide_input=True),
+    }
+    try:
+        response = api.create_workspace(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 workspace:"))
+        for field, problems in err.data.items():
+            click.echo(error(f" - {field}: {'; '.join(problems)}"))

making_with_code_cli-5.4.0/src/making_with_code_cli/teach/workspace/delete.py

@@ -0,0 +1,21 @@
+import click
+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, confirm as confirm_fmt
+
+
+@click.command('delete')
+@click.argument("workspace_id", type=int)
+@click.option("--config", help="Path to config file (default: ~/.mwc)")
+@click.option("--yes", is_flag=True, help="Skip confirmation prompt")
+def delete_workspace(workspace_id, config, yes):
+    "Delete a workspace"
+    settings = read_settings(config)
+    api = MWCAccountsAPI(settings.get('mwc_accounts_url'))
+    if not yes:
+        click.confirm(confirm_fmt(f"Delete workspace {workspace_id}?"), abort=True)
+    try:
+        api.delete_workspace(settings.get('mwc_accounts_token'), workspace_id)
+        click.echo(info(f"Deleted workspace {workspace_id}."))
+    except api.RequestFailed as err:
+        click.echo(error(f"Could not delete workspace {workspace_id}."))

making_with_code_cli-5.4.0/src/making_with_code_cli/teach/workspace/edit.py

@@ -0,0 +1,34 @@
+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, question
+
+
+@click.command('edit')
+@click.argument("workspace_id", type=int)
+@click.option("--config", help="Path to config file (default: ~/.mwc)")
+@click.option("--name", help="Workspace name")
+@click.option("--url", help="JupyterHub URL")
+@click.option("--api-token", help="JupyterHub API token")
+def edit_workspace(workspace_id, config, name, url, api_token):
+    "Edit a workspace"
+    settings = read_settings(config)
+    api = MWCAccountsAPI(settings.get('mwc_accounts_url'))
+    params = {}
+    if name:
+        params["name"] = name
+    if url:
+        params["url"] = url
+    if api_token:
+        params["api_token"] = api_token
+    if not params:
+        click.echo(error("No fields to update. Provide at least one option."))
+        return
+    try:
+        response = api.update_workspace(settings.get('mwc_accounts_token'), workspace_id, params)
+        click.echo(info(tabulate([response], headers="keys"), preformatted=True))
+    except api.RequestFailed as err:
+        click.echo(error("Could not update workspace:"))
+        for field, problems in err.data.items():
+            click.echo(error(f" - {field}: {'; '.join(problems)}"))

{making_with_code_cli-5.2.1 → making_with_code_cli-5.4.0}/src/making_with_code_cli/update/__init__.py

@@ -7,6 +7,7 @@ from making_with_code_cli.curriculum import get_curriculum
 from making_with_code_cli.git_backend import get_backend
 from making_with_code_cli.mwc_accounts_api import MWCAccountsAPI
 from making_with_code_cli.setup.tasks import WORK_DIR_PERMISSIONS
+from making_with_code_cli.errors import GitError
 from making_with_code_cli.styles import (
     address,
     question,
@@ -61,8 +62,10 @@ def update(config, debug):
                 if module_dir.exists():
                     try:
                         git_backend.update(module, module_dir)
+                    except GitError as e:
+                        click.echo(error(str(e)))
                     except Exception as e:
-                        msg =  traceback.format_exception(type(e), e, e.__traceback__)
+                        msg = traceback.format_exception(type(e), e, e.__traceback__)
                         click.echo(error(''.join(msg), preformatted=True))
                 else:
                     rel_dir = module_dir.resolve().relative_to(mwc_home)
@@ -70,6 +73,8 @@ def update(config, debug):
                     click.echo(info(f"See {module['url']} for details."))
                     try:
                         git_backend.init_module(module, module_dir)
+                    except GitError as e:
+                        click.echo(error(str(e)))
                     except Exception as e:
-                        msg =  traceback.format_exception(type(e), e, e.__traceback__)
+                        msg = traceback.format_exception(type(e), e, e.__traceback__)
                         click.echo(error(''.join(msg), preformatted=True))

making_with_code_cli-5.2.1/src/making_with_code_cli/git_backend/mwc_backend.py

@@ -1,160 +0,0 @@
-from .base_backend import GitBackend
-from subprocess import run, CalledProcessError
-import traceback
-from pathlib import Path
-from urllib.parse import urlparse
-import click
-import json
-import os
-import requests
-from making_with_code_cli.helpers import cd
-from making_with_code_cli.styles import (
-    address,
-    confirm,
-    debug,
-    error,
-    info,
-)
-from making_with_code_cli.errors import (
-    MissingSetting,
-    GitServerNotAvailable,
-)
-
-EDITOR_COMMANDS = {
-    "atom": "atom --wait",
-    "code": "code --wait",
-    "subl": "subl -n -w",
-    "mate": "mate -w",
-    "vim": "vim",
-    "emacs": "emacs",
-}
-
-class MWCBackend(GitBackend):
-    """A Github backend. Students own their own repos and grant teachers access via token.
-    """
-
-    MWC_GIT_PROTOCOL = "https"
-    MWC_GIT_SERVER = "git.makingwithcode.org"
-    COMMIT_TEMPLATE = ".commit_template"
-
-    def init_module(self, module, modpath):
-        """Creates the named repo from a template.
-        """
-        self.check_settings()
-        server, repo_owner, repo_name = self.parse_repo_url(module["repo_url"])
-
-        if modpath.exists():
-            self.relocate_existing_directory(modpath)
-        if not self.user_has_repo(repo_name):
-            self.create_from_template(repo_owner, repo_name)
-        with cd(modpath.parent):
-            self.clone_repo(repo_name)
-        self.configure_git(modpath)
-        if (modpath / self.COMMIT_TEMPLATE).exists():
-            run(["git", "config", "--local", "commit.template", self.COMMIT_TEMPLATE],
-                    check=True, cwd=modpath)
-        run("uv venv", shell=True, check=True, cwd=modpath, capture_output=True)
-        self.init_direnv(modpath)
-
-    def configure_git(self, modpath):
-        """Configures git user settings locally for the repo."""
-        name = self.settings['mwc_username']
-        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 = self.settings.get('editor')
-        if editor in EDITOR_COMMANDS:
-            run(["git", "config", "--local", "core.editor", EDITOR_COMMANDS[editor]],
-                check=True, cwd=modpath)
-
-    def update(self, module, modpath, install=True):
-        if (modpath / ".git").is_dir():
-            with cd(modpath):
-                relpath = self.relative_path(modpath)
-                click.echo(address(f"Checking {relpath} for updates.", preformatted=True))
-                gitresult = run("git pull", shell=True, capture_output=True, text=True)
-                if gitresult.returncode != 0:
-                    click.echo(error(
-                        f"Could not update {relpath}: {gitresult.stderr.strip()}\n"
-                        "You may have local changes that conflict. Ask a teacher for help."
-                    ))
-                    return
-                click.echo(info(gitresult.stdout))
-                if install and Path("pyproject.toml").exists():
-                    result = run("uv sync", shell=True, capture_output=True, text=True, cwd=modpath)
-                    if result.returncode != 0:
-                        click.echo(debug("Error running uv sync:"))
-                        click.echo(debug(result.stderr, preformatted=True))
-                        click.echo(error(f"There was a problem updating {relpath}. Ask a teacher."))
-                    else:
-                        self.init_direnv(modpath)
-
-    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)
-
-    def user_has_repo(self, repo_name, username=None):
-        """Checks to see whether a user already has the named repo.
-        """
-        username = username or self.settings['mwc_username']
-        url = f"/repos/{username}/{repo_name}"
-        response = self.authenticated_mwc_request('get', url)
-        return response.ok
-
-    def create_from_template(self, template_owner, template_name):
-        url = f"/repos/{template_owner}/{template_name}/generate"
-        data = {
-            "name": template_name,
-            "owner": self.settings['mwc_username'],
-            "git_content": True
-        }
-        response = self.authenticated_mwc_request('post', url, data=data)
-        return response
-
-    def clone_repo(self, repo_name):
-        user = self.settings['mwc_username']
-        auth = user + ':' + self.settings['mwc_git_token']
-        url = f"{self.MWC_GIT_PROTOCOL}://{auth}@{self.MWC_GIT_SERVER}/{user}/{repo_name}.git"
-        run(["git", "clone", url], check=True, capture_output=True)
-
-    def check_settings(self):
-        if "mwc_username" not in self.settings:
-            raise MissingSetting('mwc_username')
-        if "mwc_git_token" not in self.settings:
-            raise MissingSetting('mwc_git_token')
-
-    def parse_repo_url(self, url):
-        """Parses a MWC url like "https://git.makingwithcode.org/mwc/lab_pipes.git"
-        Returns ("https://git.makingwithcode.org", "mwc", "lab_pipes")
-        """
-        result = urlparse(url)
-        server = f"{result.scheme}://{result.netloc}"
-        path, suffix = result.path.split('.')
-        repo_owner, repo_name = path.strip('/').split('/')
-        return (server, repo_owner, repo_name)
-
-    def authenticated_mwc_request(self, method_name, urlpath, data=None, params=None):
-        server = self.MWC_GIT_PROTOCOL + '://' + self.MWC_GIT_SERVER
-        args = {
-            'url': server + "/api/v1" + urlpath,
-            'auth': (self.settings['mwc_username'], self.settings['mwc_git_token']),
-        }
-        if data:
-            args['data'] = data
-        if params:
-            args['params'] = params
-        method = getattr(requests, method_name)
-        response = method(**args)
-        if response.status_code >= 500 or response.status_code == 403:
-            raise GitServerNotAvailable(server)
-        return response
-
-    def relocate_existing_directory(self, path):
-        """Moves an existing directory out of the way.
-        """
-        new_path = path.parent / path.name + '_old'
-        while new_path.exists():
-            new_path = new_path.parent / new_path.name + '_old'
-        click.echo(confirm(f"Moving existing directory {path} to {new_path}."))
-        os.rename(path, new_path)

making_with_code_cli-5.2.1/src/making_with_code_cli/git_wrapper.py

@@ -1,25 +0,0 @@
-from subprocess import run, CalledProcessError
-from making_with_code_cli.helpers import cd
-
-def in_repo():
-    """Checks whether currently in repo"""
-    try:
-        run("git status", shell=True, capture_output=True, check=True)
-        return True
-    except CalledProcessError:
-        return False
-
-def repo_has_changes():
-    return len(changed_files()) > 0
-
-def changed_files():
-    "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
-    files = []
-    if result:
-        for line in result.split('\n'):
-            files.append((line[:2], line[3:]))
-        return files
-    else:
-        return []

making_with_code_cli-5.2.1/src/making_with_code_cli/submit.py

@@ -1,37 +0,0 @@
-import click
-from subprocess import run, CalledProcessError
-from making_with_code_cli.git_wrapper import (
-    in_repo,
-    repo_has_changes,
-)
-from making_with_code_cli.styles import (
-    address,
-    question,
-    info,
-    debug as debug_fmt,
-    confirm,
-    error,
-)
-
-@click.command()
-def submit():
-    """Submit your work.
-    (This is a wrapper for the basic git workflow.)
-    """
-    if not in_repo():
-        click.echo(error("You are not in a lab, problem set, or project folder."))
-        return
-    if not repo_has_changes():
-        click.echo(info("Everything is already up to date."))
-        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?")):
-        click.echo(info("Cancelled the submit for now."))
-        return
-    click.echo(info("Write your commit message, then save and exit the window..."))
-    run("git commit", shell=True, capture_output=True, check=True)
-    run("git push", shell=True, capture_output=True, check=True)
-    click.echo(address("Nice job! All your work in this module has been submitted."))
-
-