making-with-code-cli 1.2.10__tar.gz → 1.3.1__tar.gz

{making_with_code_cli-1.2.10 → making_with_code_cli-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: making-with-code-cli
-Version: 1.2.10
+Version: 1.3.1
 Summary: Courseware for Making With Code
 Home-page: https://github.com/cproctor/making-with-code-courseware
 License: MIT
@@ -13,7 +13,10 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: PyYAML (>=6.0,<7.0)
 Requires-Dist: click (>=8.0.3,<9.0.0)
+Requires-Dist: dateparser (>=1.1.8,<2.0.0)
+Requires-Dist: gitpython (>=3.1.32,<4.0.0)
 Requires-Dist: requests (>=2.27.1,<3.0.0)
+Requires-Dist: tabulate (>=0.9.0,<0.10.0)
 Requires-Dist: toml (>=0.10.2,<0.11.0)
 Project-URL: issues, https://github.com/cproctor/making-with-code-courseware/issues
 Description-Content-Type: text/markdown

making_with_code_cli-1.3.1/making_with_code_cli/cli.py

@@ -0,0 +1,16 @@
+import click
+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.teach import teach
+
+@click.group()
+def cli():
+    "Command line interface for Making with Code"
+
+cli.add_command(version)
+cli.add_command(setup)
+cli.add_command(update)
+cli.add_command(submit)
+cli.add_command(teach)

making_with_code_cli-1.3.1/making_with_code_cli/curriculum.py

@@ -0,0 +1,24 @@
+import requests
+import json
+from making_with_code_cli.errors import (
+    CurriculumSiteNotAvailable,
+    CurriculumNotFound,
+)
+
+LIVE_RELOAD = '<script src="/livereload.js?port=1024&amp;mindelay=10"></script>'
+
+def get_curriculum(mwc_site_url, course_name):
+    """Fetches curriculum metadata from the site url specified in settings.
+    Returns the curriculum metadata for course_name.
+    """
+    url = mwc_site_url + "/manifest"
+    response = requests.get(url)
+    if response.ok:
+        text = response.text.strip(LIVE_RELOAD)
+        metadata = json.loads(text)
+        for course in metadata["courses"]:
+            if course["name"] == course_name:
+                return course
+        raise CurriculumNotFound(mwc_site_url, course_name)
+    else:
+        raise CurriculumSiteNotAvailable(mwc_site_url)

{making_with_code_cli-1.2.10 → making_with_code_cli-1.3.1}/making_with_code_cli/errors.py

@@ -6,6 +6,11 @@ class CurriculumSiteNotAvailable(MWCError):
         msg = f"Error reading curriculum metadata from {site_url}"
         super().__init__(msg)
 
+class CurriculumNotFound(MWCError):
+    def __init__(self, site_url, course_name, *args, **kwargs):
+        msg = f"The curriculum site for {course_name} ({site_url}) does not have curriculum metadata for {course_name}. Ask your teacher for help."
+        super().__init__(msg)
+
 class GitServerNotAvailable(MWCError):
     def __init__(self, server_url, *args, **kwargs):
         msg = f"Error connecting to the git server at {server_url}"

making_with_code_cli-1.3.1/making_with_code_cli/git_backend/__init__.py

@@ -0,0 +1,6 @@
+from .mwc_backend import MWCBackend
+
+def get_backend(name):
+    return {
+        'mwc': MWCBackend,
+    }[name]

{making_with_code_cli-1.2.10 → making_with_code_cli-1.3.1}/making_with_code_cli/git_backend/base_backend.py

@@ -2,7 +2,7 @@ from pathlib import Path
 from subprocess import run, CalledProcessError
 import click
 from making_with_code_cli.helpers import cd
-from making_with_code_cli.cli_setup import WORK_DIR_PERMISSIONS
+from making_with_code_cli.setup.tasks import WORK_DIR_PERMISSIONS
 from making_with_code_cli.styles import (
     address,
     info,
@@ -16,18 +16,13 @@ class GitBackend:
     server and the strategies for completing tasks vary by backend. 
     """
 
-    @classmethod
-    def extend_settings(self, settings):
-        "A hook for git backends to collect additional information from the user"
-        return settings
-
     def __init__(self, settings):
         self.settings = settings
 
     def init_module(self, module, modpath):
         raise NotImplemented()
 
-    def update(self, module, modpath):
+    def update(self, module, modpath, install=True):
         if (modpath / ".git").is_dir():
             with cd(modpath):
                 relpath = self.relative_path(modpath)
@@ -36,7 +31,7 @@ class GitBackend:
                     gitresult = run("git pull", shell=True, check=True, capture_output=True,
                             text=True)
                     click.echo(info(gitresult.stdout))
-                    if Path("pyproject.toml").exists():
+                    if install and Path("pyproject.toml").exists():
                         result = run("poetry install", shell=True, check=True, 
                                 capture_output=True, text=True)
                         click.echo(info(result.stdout, preformatted=True))

{making_with_code_cli-1.2.10 → making_with_code_cli-1.3.1}/making_with_code_cli/git_backend/mwc_backend.py

@@ -15,8 +15,6 @@ from making_with_code_cli.errors import (
     GitServerNotAvailable,
 )
 
-COMMIT_TEMPLATE = ".commit_template"
-
 class MWCBackend(GitBackend):
     """A Github backend. Students own their own repos and grant teachers access via token.
     Note that this gives the teacher account access to the student's entire github account, 
@@ -25,6 +23,7 @@ class MWCBackend(GitBackend):
 
     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. 
@@ -38,14 +37,15 @@ class MWCBackend(GitBackend):
             self.create_from_template(repo_owner, repo_name)
         with cd(modpath.parent):
             self.clone_repo(repo_name)
-        if (modpath / COMMIT_TEMPLATE).exists():
+        if (modpath / self.COMMIT_TEMPLATE).exists():
             with cd(modpath):
-                run(f"git config commit.template {COMMIT_TEMPLATE}", shell=True, check=True)
+                run(f"git config commit.template {self.COMMIT_TEMPLATE}", shell=True, check=True)
 
-    def user_has_repo(self, repo_name):
+    def user_has_repo(self, repo_name, username=None):
         """Checks to see whether a user already has the named repo.
         """
-        url = f"/repos/{self.settings['mwc_username']}/{repo_name}"
+        username = username or self.settings['mwc_username']
+        url = f"/repos/{username}/{repo_name}"
         response = self.authenticated_mwc_request('get', url)
         return response.ok
 
@@ -63,7 +63,7 @@ class MWCBackend(GitBackend):
         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(f"git clone {url}", shell=True, check=True)
+        run(f"git clone {url}", shell=True, check=True, capture_output=True)
 
     def check_settings(self):
         if "mwc_username" not in self.settings:

{making_with_code_cli-1.2.10 → making_with_code_cli-1.3.1}/making_with_code_cli/mwc_accounts_api.py

@@ -31,6 +31,12 @@ class MWCAccountsAPI:
         response = requests.get(url, headers=headers)
         return self.handle_response(response)
 
+    def get_roster(self, token):
+        url = self.mwc_accounts_server + "/roster"
+        headers = {"Authorization": f"Token {token}"}
+        response = requests.get(url, headers=headers)
+        return self.handle_response(response)
+
     def handle_response(self, response):
         if response.ok:
             return response.json()

{making_with_code_cli-1.2.10 → making_with_code_cli-1.3.1}/making_with_code_cli/settings.py

@@ -41,7 +41,7 @@ def iter_settings(settings, prefix=None):
 def check_settings(settings):
     """Checks that all settings match SETTINGS_FORMAT"""
     errors = []
-    
+
 def write_settings(settings, settings_path=None):
     """Writes the settings to the settings file."""
     sp = get_settings_path(settings_path)

making_with_code_cli-1.3.1/making_with_code_cli/setup/__init__.py

@@ -0,0 +1,117 @@
+import click
+from subprocess import run
+import traceback
+import yaml
+from making_with_code_cli.mwc_accounts_api import MWCAccountsAPI
+from making_with_code_cli.git_backend import get_backend
+from making_with_code_cli.update import update
+from making_with_code_cli.settings import (
+    get_settings_path,
+    read_settings, 
+    write_settings,
+)
+from making_with_code_cli.styles import (
+    address,
+    question,
+    info,
+    debug as debug_fmt,
+    confirm,
+    error,
+)
+from making_with_code_cli.setup.tasks import (
+    INTRO_MESSAGE,
+    INTRO_NOTES,
+    WORK_DIR_PERMISSIONS,
+    Platform,
+    choose_mwc_username,
+    prompt_mwc_password,
+    choose_work_dir,
+    choose_course,
+    choose_editor,
+    MWCShellConfig,
+    InstallCurl,
+    InstallHomebrew,
+    InstallXCode,
+    WriteShellConfig,
+    InstallPoetry,
+    InstallGit,
+    InstallTree,
+    InstallVSCode,
+    InstallImageMagick,
+    InstallHttpie,
+    InstallScipy,
+    GitConfiguration,
+)
+
+@click.command()
+@click.option("--config", help="Path to config file (default: ~/.mwc)")
+@click.option("--debug", is_flag=True, help="Show debug-level output")
+@click.pass_context
+def setup(ctx, config, debug):
+    """Set up the MWC command line interface"""
+    settings = read_settings(config)
+    if debug:
+        sp = get_settings_path(config)
+        click.echo(debug_fmt(f"Reading settings from {sp}"))
+    rc_tasks = []
+    click.echo(address(INTRO_MESSAGE))
+    for note in INTRO_NOTES:
+        click.echo(address(note, list_format=True))
+    click.echo()
+    settings['mwc_username'] = choose_mwc_username(settings.get("mwc_username"))
+    api = MWCAccountsAPI()
+    if settings.get('mwc_accounts_token'):
+        try:
+            status = api.get_status(settings['mwc_accounts_token'])
+        except api.RequestFailed as bad_token:
+            token = prompt_mwc_password(settings['mwc_username'])
+            settings['mwc_accounts_token'] = token
+            status = api.get_status(token)
+    else:
+        token = prompt_mwc_password(settings['mwc_username'])
+        settings['mwc_accounts_token'] = token
+        status = api.get_status(token)
+    if debug:
+        click.echo(debug_fmt("MWC Accounts Server status:"))
+        click.echo(debug_fmt(str(status)))
+    settings['mwc_git_token'] = status['git_token']
+    settings['work_dir'] = str(choose_work_dir(settings.get("work_dir")).resolve())
+    if Platform.detect() & (Platform.MAC | Platform.UBUNTU):
+        settings['editor'] = choose_editor(settings.get('editor', 'code'))
+    if debug:
+        click.echo(info("MWC settings:"))
+        click.echo(info(yaml.dump(settings), preformatted=True))
+    write_settings(settings, config)
+
+    task_classes = [
+        MWCShellConfig,
+        InstallCurl,
+        InstallHomebrew,
+        InstallXCode,
+        InstallPoetry,
+        WriteShellConfig,
+        InstallGit,
+        InstallTree,
+        InstallVSCode,
+        InstallImageMagick,
+        InstallHttpie,
+        #InstallScipy,
+        GitConfiguration,
+    ]
+    errors = []
+    for task_class in task_classes:
+        try:
+            task = task_class(settings, debug=debug)
+            task.run_task_if_needed()
+        except Exception as e:
+            errors.append(task)
+            click.echo(error('-' * 80))
+            click.echo(error(f"{task.description} failed"))
+            if debug:
+                click.echo(debug_fmt(traceback.format_exc(), preformatted=True))
+    if errors:
+        click.echo(error(f"{len(errors)} setup tasks failed:"))
+        for task in errors:
+            click.echo(error(f"- {task.description}"))
+    else:
+        ctx.invoke(update, config=config)

making_with_code_cli-1.2.10/making_with_code_cli/cli_setup.py → making_with_code_cli-1.3.1/making_with_code_cli/setup/tasks.py

@@ -85,11 +85,12 @@ class Platform(Flag):
         else:
             raise cls.NotSupported()
 
-def default_work_dir():
+def default_work_dir(teacher=False):
+    dirname = "making_with_code_teacher" if teacher else "making_with_code"
     if (Path.home() / "Desktop").exists():
-        return Path.home() / "Desktop" / "making_with_code"
+        return Path.home() / "Desktop" / dirname
     else:
-        return Path.home() / "making_with_code"
+        return Path.home() / dirname
 
 def choose_mwc_username(default=None):
     """Asks the user to choose their MWC username."""
@@ -109,17 +110,22 @@ def prompt_mwc_password(username):
         except api.RequestFailed:
             click.echo(error(f"Sorry, that's not the right password for {username}."))
 
-def choose_work_dir(default=None):
+def choose_work_dir(default=None, teacher=False):
     """Asks the user to choose where to save their work. 
     Loops until a valid choice is made, prompts if the directory is to be created, 
     and sets file permissions to 755 (u+rwx, g+x, o+x).
     """
+    if teacher:
+        prompt_text = "Where do you want to save MWC student repositories?"
+    else:
+        prompt_text = "Where do you want to save your MWC work?"
     while True:
         work_dir = click.prompt(
-            question("Where do you want to save your MWC work?"),
-            default=default or default_work_dir(),
+            question(prompt_text),
+            default=default or default_work_dir(teacher=teacher),
             type=click.Path(path_type=Path),
         )
+        work_dir = work_dir.expanduser()
         if work_dir.is_file():
             click.echo(error("There's already a file at that location."))
         elif work_dir.exists():

{making_with_code_cli-1.2.10 → making_with_code_cli-1.3.1}/making_with_code_cli/styles.py

@@ -7,6 +7,7 @@ def formatter(**style_args):
     """A factory function which returns a formatting function.
     """
     def format_message(message, preformatted=False, list_format=False):
+        message = str(message)
         if preformatted:
             if list_format: 
                 raise ValueError("preformatted and list_format are incompatible options")

making_with_code_cli-1.3.1/making_with_code_cli/submit.py

@@ -0,0 +1,37 @@
+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."))
+
+

making_with_code_cli-1.3.1/making_with_code_cli/teach/__init__.py

@@ -0,0 +1,16 @@
+import click
+from making_with_code_cli.teach.setup import setup
+from making_with_code_cli.teach.update import update
+from making_with_code_cli.teach.status import status
+from making_with_code_cli.teach.log import log
+from making_with_code_cli.teach.test import test
+
+@click.group()
+def teach():
+    "Commands for teachers"
+
+teach.add_command(setup)
+teach.add_command(update)
+teach.add_command(status)
+teach.add_command(log)
+teach.add_command(test)

making_with_code_cli-1.3.1/making_with_code_cli/teach/check.py

@@ -0,0 +1,25 @@
+# Checks setup of 
+
+# - Curriculum
+#   - Check out each template directory
+#      - Main branch?
+#      - Has .commit_template?
+#      - Is template?
+
+class MWCModuleTests:
+
+{'teacher_groups': [{'code': 'lai676',
+                     'course_name': 'Making With Code I',
+                     'curriculum_site_url': 'https://makingwithcode.org',
+                     'group_name': 'LAI 676 Summer 2023',
+                     'student_tokens': {'cchung': 'b6f7bbeb34a076c1da7c6a58c9d41e1c1faecb9e',
+                            'finn': '320abfad1c97c78a274a66d1f7cbd651151d7f7d',
+                            'jtoombs': 'aae00b2af1722517efadd5cfc58156696de9626c',
+                            'kodell-hamilton': '66054d1f27ff7b793c3d19b96a1e207105938149',
+                            'lcooper': '31d0d64ecb7182eef437fd33f8eeb7e45f4c32ad',
+                            'mgunsolus': '1f9549e36f44fc710bac82153d972e41b0df2b0f',
+                            'mhall': '8dbab4a23a988bbfab71ff96ee673a03224f90ac',
+                            'pwick': '3e28563be3eba4e9fcd8e9d8ce5abb494fe27d94',
+                            'test_user_lai676': '87bbf8e278b6fa5ead76467810f8e48d93b1b46e',
+                            'tnaber': '00456bd8df3e513e787d113df8992d5c66475c3f'}}],
+ 'username': 'chris'}

making_with_code_cli-1.3.1/making_with_code_cli/teach/gitea_api/api.py

@@ -0,0 +1,75 @@
+# teach/gitea_api/api.py
+# ------------------
+# Offers an api to gitea. 
+# Currently, this api competes with git_backend. The tension 
+# reflects uncertainty on whether MWC will support multiple backends. 
+
+import requests
+from making_with_code_cli.teach.gitea_api.exceptions import (
+    GiteaServerUnavailable,
+    RequestFailed,
+)
+
+class GiteaTeacherApi:
+    """Provides an API to the Gitea instance. 
+    Initialize with a username and token, or by default the admin values
+    will be used from settings.
+    """
+    GITEA_URL = "https://git.makingwithcode.org"
+
+    GET = "GET"
+    POST = "POST"
+    PATCH = "PATCH"
+    DELETE = "DELETE"
+
+    methods = {
+        "GET": requests.get,
+        "POST": requests.post, 
+        "PATCH": requests.patch,
+        "DELETE": requests.delete,
+    }
+    def __init__(self, debug=False):
+        self.debug = debug
+
+    def user_has_repo(self, username, repo_name, token):
+        response = self.get(f"/repos/{username}/{repo_name}", username, token)
+        return response.ok
+
+    def get_user_repos(self, username, token):
+        response = self.get(f"/users/{username}/repos", username, token)
+        return response
+
+    def get(self, url, username, token, params=None, sudo=None, check=False):
+        return self.authenticated_request(self.GET, url, username, token, params=params, sudo=sudo, check=check)
+
+    def authenticated_request(self, method_name, url, username, token, 
+            data=None, params=None, sudo=None, check=True):
+        msg = f"Gitea request: {method_name} {url}"
+        if data: 
+            msg += f" data={data}"
+        if params: 
+            msg += f" params={params}"
+        if data and method_name not in (self.POST, self.PATCH, self.DELETE):
+            raise ValueError("Data is only supported on POST, PATCH, or DELETE requests")
+        if params and method_name != self.GET:
+            raise ValueError("Params are only supported on GET requests")
+        args = {
+            'url': self.GITEA_URL + "/api/v1" + url,
+            'auth': (username, token),
+        }
+        if data:
+            args['data'] = data
+        if params:
+            args['params'] = params
+        if sudo:
+            args['headers'] = {'Sudo': sudo}
+        method = self.methods[method_name]
+        response = method(**args)
+        if response.status_code >= 500 or response.status_code == 403:
+            raise GiteaServerUnavailable()
+        if check and not response.ok:
+            raise RequestFailed(response)
+        if self.debug:
+            print(msg)
+            print(response)
+        return response

making_with_code_cli-1.3.1/making_with_code_cli/teach/gitea_api/exceptions.py

@@ -0,0 +1,10 @@
+class GiteaServerUnavailable(Exception):
+    pass
+
+class RequestFailed(Exception):
+    def __init__(self, response, *args, **kwargs):
+        status_code = response.status_code
+        detail = response.content
+        msg = f"Gitea server request failed ({status_code}): {detail}"
+        super().__init__(msg)
+

making_with_code_cli-1.3.1/making_with_code_cli/teach/log.py

@@ -0,0 +1,82 @@
+# teach/log.py
+# ---------------
+# Implements `mwc teach log`.
+# This task iterates over all student repos and clones or pulls them 
+# as appropriate.
+
+import click
+from git import Repo
+from pathlib import Path
+from threading import Thread, Semaphore
+from textwrap import wrap
+import dateparser
+from making_with_code_cli.teach.student_repos import StudentRepos
+from making_with_code_cli.settings import read_settings
+from making_with_code_cli.teach.setup import check_required_teacher_settings
+from making_with_code_cli.styles import (
+    address,
+    question,
+    info,
+    debug as debug_fmt,
+    confirm,
+    error,
+)
+
+def date_string(arg):
+    return dateparser.parse(arg, settings={'RETURN_AS_TIMEZONE_AWARE': True})
+
+@click.command()
+@click.option("--config", help="Path to config file (default: ~/.mwc)")
+@click.option("--group", help="Filter by group name")
+@click.option("--course", help="Filter by course name")
+@click.option("--user", help="Filter by username")
+@click.option("--unit", help="Filter by unit name/slug")
+@click.option("--module", help="Filter by module name/slug")
+@click.option("--start", type=date_string, help="Start datetime")
+@click.option("--end", type=date_string, help="End datetime")
+@click.option("--update", is_flag=True, help="Update repos first")
+@click.option("--threads", type=int, default=8, help="Maximum simultaneous threads")
+def log(config, group, course, user, unit, module, start, end, update, threads):
+    "Show repo logs"
+    if update:
+        from making_with_code_cli.teach.update import update as update_task
+        update_task.callback(config, group, course, user, unit, module, threads)
+    settings = read_settings(config)
+    if not check_required_teacher_settings(settings):
+        return
+    repos = StudentRepos(settings, threads)
+    get_commits = get_repo_commits_factory(start, end)
+    results = repos.apply(get_commits, group=group, course=course, user=user, 
+            unit=unit, module=module, status_message="Collecting logs")
+    for repo in results:
+        click.echo(address('-' * 80))
+        click.echo(address(repo['path'], preformatted=True))
+        for commit in repo['commits']:
+            click.echo(info(format_commit(commit), preformatted=True))
+
+def get_repo_commits_factory(start, end):
+    def get_repo_commits(semaphore, results, group, username, path, token):
+        "Gets commits from repo"
+        semaphore.acquire()
+        if path.exists():
+            repo = Repo(path)
+            commits = []
+            for commit in repo.iter_commits():
+                if in_bounds(commit.committed_datetime, start, end):
+                    commits.append(commit)
+            if commits:
+                results.append({"path": path, "commits": commits})
+        semaphore.release()
+    return get_repo_commits
+
+def in_bounds(value, minimum=None, maximum=None):
+    return (not minimum or value >= minimum) and (not maximum or value <= maximum)
+
+def format_commit(commit):
+    return '\n'.join([
+        f"Author: {commit.author}",
+        f"Date: {commit.committed_datetime.isoformat()}",
+        "",
+        '\n'.join('    ' + line for line in commit.message.split('\n'))
+    ])
+