python-interactive-courses 1.0.0__py3-none-any.whl

pyics/notebook/sections.py

@@ -0,0 +1,189 @@
+"""
+Sections of a notebook, which link a task to the part of a notebook it is about, e.g.
+when several tasks share one (lecture-style) notebook.
+
+A section starts at its **anchor** cell, and runs up to just before the next section's
+anchor (or to the end of the notebook). A cell is the anchor of the section ``<name>``
+
+- if it is tagged ``pyics:<name>`` (in its ``metadata.tags``), or
+- if its first line is the marker ``# pyics: <name>`` (a code cell) or
+  ``<!-- pyics: <name> -->`` (a markdown cell).
+
+Tags are Jupyter's own way to mark cells, but are hidden in most frontends. Markers are
+visible everywhere, and students can restore one they deleted. Authors usually anchor a
+section on the exercise's description (a markdown cell), which students have no reason
+to change: the cells they add below it belong to the section.
+
+Section names consist of letters, digits, ``_``, ``.`` and ``-`` (see ``NAME_PATTERN``),
+e.g. ``ex2``. If several cells start a section of the same name (e.g. after an anchor
+cell was copied), the first of them does, and the others are ordinary cells of the
+section they are in. A cell can start several sections, which then have the same cells.
+Cells above the first anchor belong to no section.
+"""
+
+import re
+from dataclasses import dataclass
+from typing import Any
+
+from pyics.notebook import cells
+from pyics.notebook.cells import Cell
+
+# the prefix of the tags that start a section: ``pyics:<name>`` in ``metadata.tags``
+TAG_PREFIX = "pyics:"
+# what a section's name may consist of: letters, digits, "_", "." and "-"
+NAME_PATTERN = r"[\w.-]+"
+
+_NAME = re.compile(NAME_PATTERN)
+# the marker on the first line of a code cell, and of a markdown cell
+_CODE_MARKER = re.compile(rf"#\s*pyics:\s*({NAME_PATTERN})\s*")
+_MARKDOWN_MARKER = re.compile(rf"<!--\s*pyics:\s*({NAME_PATTERN})\s*-->\s*")
+# markdown headings (CommonMark): an ATX heading ("## Title", with an optional closing
+# sequence of "#"), the underline of a setext heading ("Title" above "=====" or
+# "-----"), and the fence of a code block, whose lines aren't headings
+_ATX_HEADING = re.compile(r" {0,3}#{1,6}(?:[ \t]+(.*?))?(?:[ \t]+#+)?[ \t]*")
+_SETEXT_UNDERLINE = re.compile(r" {0,3}(?:=+|-+)[ \t]*")
+_FENCE = re.compile(r" {0,3}(`{3,}|~{3,})")
+
+
+class SectionNotFound(LookupError):
+    """A notebook has no section of a name, e.g. because the cell that started it was
+    removed, or its tag changed."""
+
+    def __init__(self, name: str):
+        self.name = name
+        super().__init__(
+            f"Section '{name}' not found: the cell that starts it (tagged "
+            f"'{TAG_PREFIX}{name}', or starting with the marker '# pyics: {name}') was "
+            "removed or its tag changed."
+        )
+
+
+@dataclass(frozen=True)
+class Section:
+    """A section of a notebook (see the module's docstring)."""
+
+    name: str
+    # the first markdown heading of its anchor cell (as written, without the "#"
+    # markers), or its name if that cell has no heading
+    title: str
+    # the cell that starts it
+    anchor: Cell
+    # its cells, from its anchor to just before the next section's anchor, in order
+    cells: list[Cell]
+
+    @property
+    def code_cells(self) -> list[Cell]:
+        """Its code cells, in order."""
+        return [cell for cell in self.cells if cell.cell_type == "code"]
+
+
+def is_name(name: object) -> bool:
+    """Whether ``name`` can be the name of a section (see ``NAME_PATTERN``)."""
+    return isinstance(name, str) and _NAME.fullmatch(name) is not None
+
+
+def check_name(name: object) -> str:
+    """
+    Return ``name`` if it can be the name of a section, raise otherwise.
+
+    Raises
+    ------
+    ValueError
+        If ``name`` isn't a string of letters, digits, "_", "." and "-".
+    """
+    if not is_name(name):
+        raise ValueError(
+            f"{name!r} can't be the name of a section: it may only consist of letters, "
+            "digits, '_', '.' and '-'"
+        )
+    assert isinstance(name, str)
+    return name
+
+
+def anchor_names(cell: Cell) -> list[str]:
+    """The names of the sections ``cell`` starts by its tags and its marker (see the
+    module's docstring), in this order, whether or not an earlier cell starts them."""
+    names = [
+        tag.removeprefix(TAG_PREFIX)
+        for tag in cell.tags
+        if tag.startswith(TAG_PREFIX) and is_name(tag.removeprefix(TAG_PREFIX))
+    ]
+    first_line = cell.source.split("\n", 1)[0].strip()
+    marker = {"code": _CODE_MARKER, "markdown": _MARKDOWN_MARKER}.get(cell.cell_type)
+    if marker is not None and (match := marker.fullmatch(first_line)):
+        names.append(match[1])
+    return list(dict.fromkeys(names))
+
+
+def heading(cell: Cell) -> str | None:
+    """The text of the first heading of the markdown cell ``cell``, as written but
+    without the "#" markers, or None if it has none (or isn't a markdown cell)."""
+    if cell.cell_type != "markdown":
+        return None
+    fence: str | None = None
+    previous = ""
+    for line in cell.source.splitlines():
+        if (opening := _FENCE.match(line)) is not None:
+            if fence is None:
+                fence = opening[1][0] * 3
+            elif opening[1].startswith(fence):
+                fence = None
+            previous = ""
+            continue
+        if fence is not None:
+            continue
+        if (atx := _ATX_HEADING.fullmatch(line)) is not None:
+            if text := (atx[1] or "").strip():
+                return text
+        elif _SETEXT_UNDERLINE.fullmatch(line) and _paragraph(previous):
+            return previous.strip()
+        previous = line
+    return None
+
+
+def _paragraph(line: str) -> bool:
+    """Whether ``line`` can be the text of a setext heading, rather than e.g. blank, a
+    list item, or a marker."""
+    text = line.strip()
+    return bool(text) and not text.startswith(("#", "<", "-", "*", "+", ">", "|"))
+
+
+def _find(all_cells: list[Cell]) -> dict[str, Section]:
+    """The sections of a notebook of ``all_cells`` (see ``find_sections``)."""
+    # the position of each anchor among all cells, and the sections it starts
+    anchors: list[tuple[int, list[str]]] = []
+    seen: set[str] = set()
+    for position, cell in enumerate(all_cells):
+        # a name taken by an earlier cell doesn't make this one an anchor
+        if names := [name for name in anchor_names(cell) if name not in seen]:
+            seen.update(names)
+            anchors.append((position, names))
+
+    found: dict[str, Section] = {}
+    for i, (start, names) in enumerate(anchors):
+        end = anchors[i + 1][0] if i + 1 < len(anchors) else len(all_cells)
+        anchor = all_cells[start]
+        title = heading(anchor)
+        for name in names:
+            found[name] = Section(name, title or name, anchor, all_cells[start:end])
+    return found
+
+
+def find_sections(nb: dict[str, Any]) -> dict[str, Section]:
+    """The sections of the notebook ``nb`` (as read by ``cells.parse``), by name, in the
+    order they start in."""
+    return _find(cells.cells(nb))
+
+
+def get_section(nb: dict[str, Any], name: str) -> Section:
+    """
+    The section ``name`` of the notebook ``nb`` (as read by ``cells.parse``).
+
+    Raises
+    ------
+    SectionNotFound
+        If the notebook has no section ``name``.
+    """
+    if (section := find_sections(nb).get(name)) is None:
+        raise SectionNotFound(name)
+    return section

pyics/plugins.py

@@ -0,0 +1,90 @@
+"""
+Plugins: packages installed next to pyics that extend it through pluggy hooks (see
+``HookSpecs``). A plugin registers a module or object with ``hookimpl``-marked functions
+as an entry point of the group "pyics", e.g. in its ``pyproject.toml``::
+
+    [project.entry-points.pyics]
+    jupyter = "pyics_jupyter.plugin"
+
+e.g. ``pyics-jupyter``, which shows the results of tests run in a notebook's kernel
+whenever a cell runs.
+"""
+
+import functools
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Protocol
+
+import pluggy
+from rich.console import RenderableType
+
+from pyics.tests.results import TestResult
+
+if TYPE_CHECKING:
+    from pyics.data.task import Task
+
+hookspec = pluggy.HookspecMarker("pyics")
+hookimpl = pluggy.HookimplMarker("pyics")
+
+
+@dataclass(frozen=True)
+class Overlay:
+    """What a task's status shows instead of the results of its saved files (see
+    ``ResultsOverlay.apply``)."""
+
+    # the results to show, e.g. the saved ones, of which some are replaced by newer
+    # ones, relabelled by their nodeid (e.g. "::adds (live)")
+    results: list[TestResult]
+    # lines shown below the result summary, e.g. where the results come from
+    lines: list[RenderableType] = field(default_factory=list)
+
+
+class ResultsOverlay(Protocol):
+    """
+    Results of a task's tests that the TUI shows over those of its saved files, e.g.
+    from runs on code that isn't saved yet (see ``HookSpecs.pyics_results_overlay``).
+    They never count as progress: whether a task is solved only depends on its saved
+    files.
+    """
+
+    def poll(self) -> bool:
+        """Whether there are new results since the last call, so that the task's
+        status is updated (see ``Task.check_overlay``). Called at every tick of the
+        TUI, so it must be cheap."""
+        ...
+
+    def apply(self, saved: list[TestResult], saved_time: float | None) -> Overlay:
+        """
+        What the task's status shows, given the results of its ``saved`` files, which
+        were saved at ``saved_time`` (a ``time.time()``, see
+        ``Task.test_results_time``).
+        """
+        ...
+
+
+class HookSpecs:
+    """The hooks pyics calls, which plugins implement with ``hookimpl``."""
+
+    @hookspec(firstresult=True)
+    def pyics_results_overlay(
+        self,
+        # quoted, as pluggy reads the signature, which evaluates the annotations
+        task: "Task",  # noqa: UP037
+    ) -> ResultsOverlay | None:
+        """
+        The results overlay of ``task``, or None if the plugin has none for it. Called
+        once for each task the TUI shows, on the TUI's thread. The first plugin that
+        returns an overlay wins.
+        """
+
+
+@functools.cache
+def manager() -> pluggy.PluginManager:
+    """
+    The plugin manager, which loads the installed plugins (the entry points of the group
+    "pyics") the first time it is asked for. Tests register their own plugins with it,
+    and forget it with ``manager.cache_clear()``.
+    """
+    plugin_manager = pluggy.PluginManager("pyics")
+    plugin_manager.add_hookspecs(HookSpecs)
+    plugin_manager.load_setuptools_entrypoints("pyics")
+    return plugin_manager

pyics/scripts/console.py

@@ -0,0 +1,86 @@
+"""
+Plain console input and output for the scripts that don't run in the fullscreen
+interface, e.g. ``pull``.
+"""
+
+import sys
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import NoReturn
+
+from pyics.distribution import dependencies
+from pyics.distribution.dependencies import Problem
+from pyics.util import paths
+
+TRUST_WARNING = (
+    "Courses run code on your computer: their tests run your code together with "
+    "theirs. Only use courses from people you trust."
+)
+
+
+def fail(message: object) -> NoReturn:
+    """Exit with ``message`` as the error."""
+    sys.exit(f"error: {message}")
+
+
+def confirm(question: str, *, default: bool = False) -> bool:
+    """Ask a yes/no ``question``. Without an answer (e.g. without a terminal to ask
+    in), the ``default``."""
+    suffix = " [Y/n] " if default else " [y/N] "
+    try:
+        answer = input(question + suffix).strip().lower()
+    except EOFError:
+        print()
+        return default
+    if not answer:
+        return default
+    return answer in ("y", "yes")
+
+
+def warn_differing_notebooks(
+    differing: Mapping[Path, Sequence[Path]], base: Path
+) -> None:
+    """Warn that tasks share notebooks, but store different contents for them (see
+    ``archive.differing_notebooks``). Paths are shown relative to ``base``."""
+    for notebook, task_files in differing.items():
+        tasks = ", ".join(paths.relative_to(f, base).as_posix() for f in task_files)
+        print(
+            f"Warning: the tasks {tasks} share the notebook "
+            f"{paths.relative_to(notebook, base).as_posix()}, but store different "
+            "contents for it. Students get the contents of the task they start first: "
+            "store the same notebook in all of them (choose Update for it in "
+            "edit_task)."
+        )
+
+
+def report_problems(title: str, problems: Sequence[Problem]) -> None:
+    """Tell which requirements of the course ``title`` aren't met, and how to meet
+    them."""
+    if problems:
+        print(f"{title} needs {dependencies.describe(problems)}.")
+        print(dependencies.install_hint(problems))
+
+
+def install_requirements(
+    problems: Sequence[Problem], *, yes: bool = False
+) -> list[Problem]:
+    """
+    Install the requirements of ``problems`` that can be installed, if the user agrees
+    (or ``yes``).
+
+    Returns
+    -------
+    list[Problem]
+        The problems that remain.
+    """
+    requirements = [p.requirement for p in problems if p.installable]
+    if not requirements:
+        return list(problems)
+    command = dependencies.format_command(dependencies.install_command(requirements))
+    if not yes and not confirm(f"Install {', '.join(requirements)} with: {command}?"):
+        return list(problems)
+    if dependencies.install(requirements) != 0:
+        print(f"Installing {', '.join(requirements)} failed.")
+    return dependencies.check([p.requirement for p in problems if p.installable]) + [
+        p for p in problems if not p.installable
+    ]

pyics/scripts/create_course.py

@@ -0,0 +1,301 @@
+from collections.abc import Mapping
+from os import PathLike
+from pathlib import Path
+from typing import Any, NamedTuple
+
+from rich.console import Group
+from rich.markup import escape
+from rich.text import Text
+
+import pyics.util.json_handling as json
+from pyics.app.cli import CLI
+from pyics.app.key_listener import KeyListener
+from pyics.app.prompts import (
+    PathInput,
+    PromptCancelled,
+    PromptSession,
+    ReorderInput,
+    SelectInput,
+    TextInput,
+)
+from pyics.data.course import Course
+from pyics.data.task import Task
+from pyics.scripts.create_task import _EDIT, _KEEP, _REMOVE, _check_name, _task_flow
+from pyics.util import paths
+from pyics.util.discovery import TASK_SUFFIX, find_task_files
+from pyics.util.terminal import fullscreen
+
+_TOTAL_STEPS = 3
+_INFO = "Creating a new course..."
+
+_ADD_EXISTING = "Add an existing task"
+_ADD_NEW = "Create a new task"
+_NO_MORE_TASKS = "Done"
+
+_TASK_HINTS = {
+    _KEEP: "Keep the task as it is.",
+    _EDIT: "Go through the task-creation flow, prefilled with the task. Its task file is "
+    "rewritten once the course is done.",
+    _REMOVE: "Remove the task from the course. Its task file is kept.",
+}
+
+# A task of the course: its file path, and for tasks created or edited in the flow (not
+# yet written), the keyword arguments for ``Task.create_task_json``.
+_Entry = tuple[Path, dict[str, Any] | None]
+
+
+class _CourseTask(NamedTuple):
+    """A task of a course that is being edited."""
+
+    path: Path
+    # the task's name, or its name in the course manifest if its task file can't be read
+    name: str
+    # the task's fields (see ``Task.read_task_json``), None if its task file can't be read
+    fields: dict[str, Any] | None
+    # names the task can't be renamed to: those of the other tasks in other courses that
+    # include it
+    taken_elsewhere: frozenset[str] = frozenset()
+    # why the task file can't be read
+    problem: str = ""
+
+
+def _course_tasks(fp: Path, manifest: Mapping[str, Any]) -> dict[str, Path]:
+    """The tasks of the course ``manifest`` read from ``fp``, by name, with their task
+    files' absolute paths."""
+    base = Path(fp).parent
+    return {
+        k: paths.absolute(paths.resolve(v, base)) for k, v in manifest["tasks"].items()
+    }
+
+
+def _names_taken_elsewhere(
+    task_file: PathLike, courses: Mapping[Path, Mapping[str, Any]]
+) -> frozenset[str]:
+    """The names of the other tasks in the ``courses`` (see ``find_courses``) that
+    include ``task_file``, which the task can't be renamed to."""
+    task = paths.absolute(task_file)
+    taken: set[str] = set()
+    for fp, manifest in courses.items():
+        tasks = _course_tasks(fp, manifest)
+        if task in tasks.values():
+            taken.update(k for k, v in tasks.items() if v != task)
+    return frozenset(taken)
+
+
+def _rename_in_courses(
+    task_file: PathLike, name: str, courses: dict[Path, dict[str, Any]]
+) -> list[Path]:
+    """
+    Rename the task ``task_file`` to ``name`` in the ``courses`` (see ``find_courses``)
+    that include it under another name, keeping its position in them, and rewrite their
+    manifests. ``courses`` is updated to match.
+
+    Returns
+    -------
+    list[Path]
+        The rewritten manifests.
+    """
+    task = paths.absolute(task_file)
+    renamed: list[Path] = []
+    for fp, manifest in courses.items():
+        tasks = _course_tasks(fp, manifest)
+        if not any(v == task and k != name for k, v in tasks.items()):
+            continue
+        manifest["tasks"] = {
+            name if tasks[k] == task else k: v for k, v in manifest["tasks"].items()
+        }
+        # serialized before the file is opened, so it isn't left empty if that fails
+        text = json.dumps(manifest, indent=4)
+        with open(fp, "w", encoding="utf-8") as f:
+            f.write(text)
+        renamed.append(fp)
+    return renamed
+
+
+def _prompt_task_file(
+    s: PromptSession, found: dict[Path, str], tasks: dict[str, _Entry]
+) -> Path:
+    """Ask for one of the ``found`` task files that isn't in the course yet. Its task name
+    must be new to the course, too."""
+    selected = {paths.absolute(p) for p, _ in tasks.values()}
+    labels = {
+        f"{n} ({p})": p for p, n in found.items() if paths.absolute(p) not in selected
+    }
+
+    def check(label: str) -> Path:
+        _check_name(found[labels[label]], tasks)
+        return labels[label]
+
+    return s.ask(SelectInput("Task file", list(labels)), check)
+
+
+def _check_path(raw: str, tasks: Mapping[str, _Entry]) -> Path:
+    """Return ``raw`` as a path if a new task file can be written there, raise
+    otherwise."""
+    path = Path(raw)
+    if not path.name or path.is_dir():
+        raise ValueError(f"{raw!r} is not a file path")
+    if paths.absolute(path) in {paths.absolute(p) for p, _ in tasks.values()}:
+        raise ValueError(f"the course already has a task at {raw!r}")
+    return path
+
+
+def _prompt_tasks(
+    s: PromptSession, found: dict[Path, str], current: list[_CourseTask] | None = None
+) -> dict[str, _Entry]:
+    """
+    Interactively collect at least one task, each either one of the ``found`` task files
+    or created on the fly with the task-creation flow. When editing a course, its
+    ``current`` tasks are kept, edited or removed first, and adding more is not
+    preselected.
+
+    Returns
+    -------
+    dict[str, _Entry]
+        The tasks by name, in the order they were added.
+    """
+    tasks: dict[str, _Entry] = {}
+    for i, task in enumerate(current or [], 1):
+        s.cli.update_progress(1 / _TOTAL_STEPS)
+
+        options, problem = [_KEEP, _EDIT, _REMOVE], task.problem
+        if task.fields is None:
+            options = [_REMOVE]
+        elif task.name in tasks:
+            options = [_EDIT, _REMOVE]
+            problem = (
+                f"Another task of the course is named {task.name!r}, so the task needs "
+                "to be renamed or removed."
+            )
+        lines = [Text(problem, style="red")] if problem else []
+        lines.append(Text(str(task.path), style="dim"))
+
+        label = f"Task {i} of {len(current or [])}: {escape(task.name)}"
+        details = Group(*lines)
+        choice = s.ask(SelectInput(label, options, hints=_TASK_HINTS, details=details))
+        if choice == _REMOVE:
+            continue
+
+        fields = None
+        if choice == _EDIT:
+            # not the name of another task of the course, including those still to come
+            # (which are most likely kept), nor of one in another course with the task
+            taken = {*tasks, *(t.name for t in (current or [])[i:])}
+            taken |= task.taken_elsewhere
+            fields = _task_flow(s, taken_names=taken, current=task.fields)
+        tasks[fields["name"] if fields else task.name] = (task.path, fields)
+
+    hints = {
+        _ADD_EXISTING: "Pick one of the task files found below the working directory.",
+        _ADD_NEW: "Define a new task, written to a task file once the course is done.",
+    }
+    while True:
+        # the task-creation flow moves the progress bar through its own steps
+        s.cli.update_progress(1 / _TOTAL_STEPS)
+
+        # offered only while some found task file isn't in the course yet
+        selected = {paths.absolute(p) for p, _ in tasks.values()}
+        unselected = any(paths.absolute(p) not in selected for p in found)
+        options = [_ADD_EXISTING] if unselected else []
+        options.append(_ADD_NEW)
+        if tasks:  # a course can't be empty
+            options.append(_NO_MORE_TASKS)
+        hints[_NO_MORE_TASKS] = f"Finish adding tasks ({len(tasks)} added so far)."
+
+        prompt = SelectInput("How do you want to add a task?", options, hints=hints)
+        if current is not None:
+            prompt.set_answer(_NO_MORE_TASKS)
+        kind = s.ask(prompt)
+        if kind == _NO_MORE_TASKS:
+            return tasks
+
+        if kind == _ADD_EXISTING:
+            path = _prompt_task_file(s, found, tasks)
+            tasks[found[path]] = (path, None)
+            continue
+
+        fields = _task_flow(s, taken_names=tasks)
+        prompt = PathInput(
+            "Task file path", initial=f"./{fields['name']}{TASK_SUFFIX}"
+        )
+        tasks[fields["name"]] = (s.ask(prompt, lambda p: _check_path(p, tasks)), fields)
+
+
+def _course_flow(
+    s: PromptSession,
+    found: dict[Path, str],
+    current: Mapping[str, Any] | None = None,
+) -> dict[str, Any]:
+    """
+    The full course-creation flow. Replayed by ``PromptSession`` whenever the user goes
+    back, so it must ask the same prompts given the same answers, and must not write any
+    files.
+
+    With ``current``, the ``name`` and ``tasks`` (as ``_CourseTask``) of an existing
+    course, the course is edited instead: every prompt is prefilled with its current
+    value, so that confirming all of them leaves the course as it was.
+
+    Returns
+    -------
+    dict[str, Any]
+        The course ``name``, and its ``tasks`` as ``_Entry`` tuples, in course order.
+    """
+    s.cli.update_progress(0 / _TOTAL_STEPS)
+    prompt = TextInput("Course name", initial=current["name"] if current else "")
+    name = s.ask(prompt, lambda n: _check_name(n, ()))
+
+    tasks = _prompt_tasks(s, found, current["tasks"] if current else None)
+
+    s.cli.update_progress(2 / _TOTAL_STEPS)
+    order = list(tasks)
+    if len(order) > 1:
+        order = s.ask(ReorderInput("Task order", order))
+
+    s.cli.update_progress(3 / _TOTAL_STEPS)
+    return {"name": name, "tasks": [tasks[n] for n in order]}
+
+
+def _create_course(fp: PathLike | None = None, max_depth: int = 3) -> None:
+    """
+    Console script to collect task files and construct a course manifest from them.
+    Tasks are either picked from the task files below the working directory, or created
+    on the fly.
+
+    Parameters
+    ----------
+    fp: PathLike
+        Output path for the resulting ``.pyicscourse.json`` file.
+    max_depth: int
+        How many directory levels below the working directory are searched for task
+        files, so the search stays short when run in e.g. the home directory.
+    """
+    with fullscreen():
+        cli = CLI()
+        cli()
+        cli.update_info("Searching for task files...")
+
+        try:
+            # searched once up front, since the flow is replayed whenever the user
+            # goes back
+            found = find_task_files(Path.cwd(), max_depth)
+            cli.update_info(_INFO)
+
+            with KeyListener() as q:
+                fields = PromptSession(cli, q, info=_INFO).run(
+                    lambda s: _course_flow(s, found)
+                )
+
+            task_files: list[PathLike] = []
+            for path, task_fields in fields["tasks"]:
+                if task_fields is not None:
+                    path = Task.create_task_json(path, **task_fields)
+                task_files.append(path.absolute())
+
+            fp = Course.create_course_manifest(
+                fp or Path(f"./{fields['name']}"), task_files, name=fields["name"]
+            )
+            cli.update_info(f"Course written to {escape(str(fp))}")
+        except PromptCancelled:
+            cli.update_info("Cancelled, no course was created.")
+        finally:
+            cli.stop()