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

{making_with_code_cli-5.2.0 → 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.0
+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.0 → 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.0 → making_with_code_cli-5.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "making-with-code-cli"
-version = "5.2.0"
+version = "5.4.0"
 description = "Courseware for Making With Code"
 authors = [{ name = "Chris Proctor", email = "chris@chrisproctor.net" }]
 requires-python = ">=3.11,<4.0"
@@ -41,3 +41,5 @@ docs = [
     "sphinx>=8.2.3,<9",
     "sphinx-rtd-theme>=3.0.2,<4",
 ]
+[tool.uv]
+check-url = "https://pypi.org/simple/"

{making_with_code_cli-5.2.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.
     """
@@ -14,7 +14,7 @@ def get_settings_path(settings_path=None):
     elif "MWC_CONFIG" in os.environ:
         return Path(os.environ["MWC_CONFIG"])
     else:
-        xdg_config_home = os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config"))
+        xdg_config_home = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"))
         return xdg_config_home / "mwc" / "settings.toml"
 
 def read_settings(settings_path=None):

{making_with_code_cli-5.2.0 → 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.2.0 → making_with_code_cli-5.4.0}/src/making_with_code_cli/setup/tasks.py

@@ -403,10 +403,28 @@ class InstallVSCode(InstallPackage):
     brew_name = "visual-studio-code"
     brew_cask = True
 
+    def is_complete(self):
+        if Platform.detect() == Platform.MAC:
+            app_locations = [
+                Path("/Applications/Visual Studio Code.app"),
+                Path.home() / "Applications/Visual Studio Code.app",
+            ]
+            return self.executable_on_path("code") or any(p.exists() for p in app_locations)
+        return self.executable_on_path("code")
+
     def run_task(self):
         if Platform.detect() in (Platform.UBUNTU, Platform.WSL):
             run("sudo snap install --classic code", shell=True, check=True)
         else:
+            # If brew has a stale record of VS Code but the app is missing,
+            # the upgrade will fail. Zap the cask first to clear brew's state.
+            stale = run(
+                "brew list --cask visual-studio-code",
+                shell=True, capture_output=True
+            ).returncode == 0
+            if stale:
+                run("brew uninstall --cask --zap --force visual-studio-code",
+                    shell=True, check=True)
             super().run_task()
 
 class InstallImageMagick(InstallPackage):