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

pyics/scripts/edit_course.py

@@ -0,0 +1,133 @@
+import sys
+from collections.abc import Mapping
+from os import PathLike
+from pathlib import Path
+from typing import Any
+
+from rich.markup import escape
+
+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 PromptCancelled, PromptSession
+from pyics.data.course import Course
+from pyics.data.task import Task
+from pyics.scripts.create_course import (
+    _course_flow,
+    _CourseTask,
+    _names_taken_elsewhere,
+    _rename_in_courses,
+)
+from pyics.util import paths
+from pyics.util.discovery import COURSE_SUFFIX, find_courses, find_task_files
+from pyics.util.terminal import fullscreen
+
+
+def _read_course(
+    fp: Path,
+    manifest: Mapping[str, Any],
+    courses: Mapping[Path, Mapping[str, Any]],
+) -> tuple[dict[str, Any], dict[Path, int]]:
+    """
+    Read the course ``manifest`` (read from ``fp``) and its tasks' task files for
+    ``_course_flow``. The tasks can't be renamed to the names of the other tasks in the
+    other ``courses`` (see ``find_courses``) that include them.
+
+    Returns
+    -------
+    tuple[dict[str, Any], dict[Path, int]]
+        The course's ``name`` and ``tasks`` (as ``_CourseTask``), and the progress of
+        its tasks, by their task files' absolute paths.
+    """
+    tasks: list[_CourseTask] = []
+    progress: dict[Path, int] = {}
+    solved = manifest.get("progress", [])
+    for i, (key, rel) in enumerate(manifest["tasks"].items()):
+        path = paths.resolve(rel, fp.parent)
+        progress[paths.absolute(path)] = solved[i] if i < len(solved) else 0
+        try:
+            fields = Task.read_task_json(path)
+        except Exception as err:  # noqa: BLE001
+            problem = f"The task file can't be read ({err}), so it can only be removed."
+            tasks.append(_CourseTask(path, key, None, problem=problem))
+            continue
+        taken = _names_taken_elsewhere(path, courses)
+        tasks.append(_CourseTask(path, fields["name"], fields, taken))
+    return {"name": manifest.get("name", ""), "tasks": tasks}, progress
+
+
+def _edit_course(course_file: PathLike, max_depth: int = 3) -> None:
+    """
+    Console script to interactively edit a course manifest, going through the
+    course-creation flow with every prompt prefilled from the course. Its tasks can be
+    kept, edited (rewriting their task files) or removed, and more added like when
+    creating a course. The manifest is rewritten in place, and each task keeps its
+    progress.
+
+    The other course manifests below the working directory that include a task that is
+    renamed are kept consistent with it, like in ``edit_task``.
+
+    Parameters
+    ----------
+    course_file: PathLike
+        The ``.pyicscourse.json`` file to edit.
+    max_depth: int
+        How many directory levels below the working directory are searched for task
+        files and course manifests, so the search stays short when run in e.g. the home
+        directory.
+    """
+    course_file = Path(course_file)
+    if not course_file.name.endswith(COURSE_SUFFIX):
+        sys.exit(f"error: {course_file} is not a course manifest (*{COURSE_SUFFIX})")
+    try:
+        manifest = json.load_plain(course_file)
+        if not isinstance(manifest["tasks"], dict):
+            raise TypeError("its tasks are not a mapping of names to task files")
+    except Exception as err:  # noqa: BLE001
+        sys.exit(f"error: can't read the course manifest {course_file}: {err}")
+
+    with fullscreen():
+        cli = CLI()
+        cli()
+        cli.update_info("Searching for task files and course manifests...")
+
+        try:
+            # searched once up front, since the flow is replayed whenever the user
+            # goes back
+            found = find_task_files(Path.cwd(), max_depth)
+            courses = find_courses(Path.cwd(), max_depth)
+            courses.pop(paths.absolute(course_file), None)  # rewritten as a whole
+            current, progress = _read_course(course_file, manifest, courses)
+            info = f"Editing the course {escape(str(current['name']))}..."
+            cli.update_info(info)
+
+            with KeyListener() as q:
+                fields = PromptSession(cli, q, info=info).run(
+                    lambda s: _course_flow(s, found, current)
+                )
+
+            task_files: list[PathLike] = []
+            renamed: dict[Path, None] = {}  # ordered set
+            for path, task_fields in fields["tasks"]:
+                if task_fields is not None:
+                    path = Task.create_task_json(path, **task_fields)
+                    for fp in _rename_in_courses(path, task_fields["name"], courses):
+                        renamed[fp] = None
+                task_files.append(path.absolute())
+
+            fp = Course.create_course_manifest(
+                course_file,
+                task_files,
+                name=fields["name"],
+                progress=[progress.get(paths.absolute(p), 0) for p in task_files],
+                metadata=manifest,  # e.g. its requires, which aren't edited here
+            )
+            message = f"Course written to {fp}"
+            if renamed:
+                message += f", and tasks renamed in {', '.join(map(str, renamed))}"
+        except PromptCancelled:
+            message = "Cancelled, the course was not changed."
+        finally:
+            cli.stop()
+    # after leaving the alternate screen, so that it stays visible
+    print(message)

pyics/scripts/edit_task.py

@@ -0,0 +1,109 @@
+import sys
+from collections.abc import Mapping
+from os import PathLike
+from pathlib import Path
+from typing import Any
+
+from rich.markup import escape
+
+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 PromptCancelled, PromptSession
+from pyics.data.task import Task
+from pyics.distribution import archive
+from pyics.scripts.console import warn_differing_notebooks
+from pyics.scripts.create_course import (
+    _course_tasks,
+    _names_taken_elsewhere,
+    _rename_in_courses,
+)
+from pyics.scripts.create_task import _task_flow
+from pyics.util import paths
+from pyics.util.discovery import TASK_SUFFIX, find_courses
+from pyics.util.terminal import fullscreen
+
+
+def _differing_notebooks(
+    task_file: PathLike, courses: Mapping[Path, Mapping[str, Any]]
+) -> dict[Path, list[Path]]:
+    """The exercise notebooks of the task ``task_file`` that other tasks of the
+    ``courses`` (see ``find_courses``) that include it share, but store different
+    contents for (see ``archive.differing_notebooks``)."""
+    task = paths.absolute(task_file)
+    tasks: dict[Path, dict[str, Any]] = {}
+    for fp, manifest in courses.items():
+        task_files = _course_tasks(fp, manifest).values()
+        if task not in task_files:
+            continue
+        for path in task_files:
+            try:
+                data = tasks.get(path) or json.load_plain(path)
+            except Exception:  # noqa: BLE001
+                continue  # its course can't be loaded either
+            if isinstance(data, dict):
+                tasks[path] = data
+    return {
+        notebook: sharing
+        for notebook, sharing in archive.differing_notebooks(tasks).items()
+        if task in sharing
+    }
+
+
+def _edit_task(task_file: PathLike, max_depth: int = 3) -> None:
+    """
+    Console script to interactively edit a task file, going through the task-creation
+    flow with every prompt prefilled from the task. The task file is rewritten in place.
+
+    The course manifests below the working directory that include the task are kept
+    consistent with it: if the task is renamed, so is its entry in them, and its new
+    name can't be that of another task in one of them. If other tasks in them share a
+    notebook with the task, but store different contents for it, that is warned about.
+
+    Parameters
+    ----------
+    task_file: PathLike
+        The ``.pyicstask.json`` file to edit.
+    max_depth: int
+        How many directory levels below the working directory are searched for course
+        manifests, so the search stays short when run in e.g. the home directory.
+    """
+    task_file = Path(task_file)
+    if not task_file.name.endswith(TASK_SUFFIX):
+        sys.exit(f"error: {task_file} is not a task file (*{TASK_SUFFIX})")
+    try:
+        current = Task.read_task_json(task_file)
+    except Exception as err:  # noqa: BLE001
+        sys.exit(f"error: can't read the task file {task_file}: {err}")
+
+    with fullscreen():
+        cli = CLI()
+        cli()
+        cli.update_info("Searching for course manifests...")
+
+        try:
+            # searched once up front, since the flow is replayed whenever the user
+            # goes back
+            courses = find_courses(Path.cwd(), max_depth)
+            taken = _names_taken_elsewhere(task_file, courses)
+            info = f"Editing the task {escape(str(current['name']))}..."
+            cli.update_info(info)
+
+            with KeyListener() as q:
+                fields = PromptSession(cli, q, info=info).run(
+                    lambda s: _task_flow(s, taken_names=taken, current=current)
+                )
+
+            Task.create_task_json(task_file, **fields)
+            message = f"Task written to {task_file}"
+            if renamed := _rename_in_courses(task_file, fields["name"], courses):
+                message += f", and renamed in {', '.join(map(str, renamed))}"
+            differing = _differing_notebooks(task_file, courses)
+        except PromptCancelled:
+            message = "Cancelled, the task was not changed."
+            differing = {}
+        finally:
+            cli.stop()
+    # after leaving the alternate screen, so that it stays visible
+    print(message)
+    warn_differing_notebooks(differing, Path.cwd())

pyics/scripts/main.py

@@ -0,0 +1,118 @@
+import inspect
+from os import PathLike
+from pathlib import Path
+
+import jsonargparse
+from jsonargparse import ActionYesNo
+
+from pyics.app.cli import CLI
+from pyics.util.logging import setup_logging
+from pyics.util.terminal import fullscreen
+from pyics.app.pyics import PyIC
+from pyics.scripts.create_course import _create_course
+from pyics.scripts.create_task import _create_task
+from pyics.scripts.edit_course import _edit_course
+from pyics.scripts.edit_task import _edit_task
+from pyics.scripts.pack import _build_index, _pack
+from pyics.scripts.pull import _pull, _update
+from pyics.scripts.sources import _add_source, _remove_source, _search, _sources
+
+
+def main(*, log_level: str | int = 50, log_file: PathLike = Path("./.pyics.log")):
+    # This is necessary because otherwise pytest.main() imports it and then subsequently
+    # breaks our shutdown mechanic by taking control of tty.
+    try:
+        import readline
+    except ImportError:
+        pass
+
+    setup_logging(log_level, log_file)
+
+    with fullscreen():
+        cli = CLI()
+
+        pyics = PyIC(cli)
+
+        try:
+            pyics()
+            pyics.thread.join()
+        finally:
+            cli.stop()
+    # after leaving the alternate screen, so that it stays visible
+    if pyics.exit_message:
+        print(pyics.exit_message)
+
+
+# Subcommands of the ``pyics`` script, run as e.g. ``pyics create_task``. Without one,
+# the app itself is run.
+_SUBCOMMANDS = {
+    "create_task": (_create_task, "Interactively create a task file."),
+    "create_course": (_create_course, "Interactively create a course manifest."),
+    "edit_task": (_edit_task, "Interactively edit a task file."),
+    "edit_course": (_edit_course, "Interactively edit a course manifest."),
+    "add_source": (_add_source, "Add a course library by the URL of its index."),
+    "remove_source": (_remove_source, "Remove a course library."),
+    "sources": (_sources, "List the course libraries."),
+    "search": (_search, "Find courses in the course libraries."),
+    "pull": (_pull, "Pull a course by its name, or a course archive by URL or path."),
+    "update": (_update, "Update a pulled course, keeping your work."),
+    "pack": (_pack, "Pack a course into an archive, to distribute it."),
+    "build_index": (_build_index, "Write the index of a course library."),
+}
+
+
+# parameters of subcommands that are given as optional positional arguments, e.g.
+# ``pyics search bfs`` rather than ``pyics search --term bfs``
+_OPTIONAL_POSITIONALS = {"term", "directory"}
+
+
+def _add_subcommand_arguments(parser: jsonargparse.ArgumentParser, fn) -> None:
+    """
+    Add the parameters of ``fn`` to ``parser``: those without a default, and those of
+    ``_OPTIONAL_POSITIONALS``, as positional arguments, boolean ones as flags, e.g.
+    ``--yes`` (and ``--no_yes``) rather than ``--yes true``, and lists of strings as
+    options that take one or more values, e.g. ``--tags a b`` or ``--tags a --tags b``.
+    """
+    params = inspect.signature(fn).parameters
+    flags = {name for name, param in params.items() if param.annotation is bool}
+    lists = {
+        name
+        for name, param in params.items()
+        if param.annotation in (list[str], list[str] | None)
+    }
+    positionals = _OPTIONAL_POSITIONALS & set(params)
+    parser.add_function_arguments(
+        fn, as_group=False, as_positional=True, skip=flags | lists | positionals
+    )
+    for name, param in params.items():
+        if name in positionals:
+            parser.add_argument(
+                name, nargs="?", type=param.annotation, default=param.default
+            )
+        elif name in flags:
+            parser.add_argument(f"--{name}", action=ActionYesNo, default=param.default)
+        elif name in lists:
+            parser.add_argument(
+                f"--{name}", nargs="+", action="extend", type=str, default=param.default
+            )
+
+
+def run():
+    parser = jsonargparse.ArgumentParser(prog="pyics")
+    parser.add_function_arguments(main, as_group=False)
+    subcommands = parser.add_subcommands(required=False)
+    for name, (fn, help) in _SUBCOMMANDS.items():
+        subparser = jsonargparse.ArgumentParser()
+        _add_subcommand_arguments(subparser, fn)
+        subcommands.add_subcommand(name, subparser, help=help)
+
+    cfg = parser.parse_args()
+    if cfg.subcommand is None:
+        main(log_level=cfg.log_level, log_file=cfg.log_file)
+    else:
+        fn, _ = _SUBCOMMANDS[cfg.subcommand]
+        fn(**cfg[cfg.subcommand].as_dict())
+
+
+if __name__ == "__main__":
+    run()

pyics/scripts/pack.py

@@ -0,0 +1,198 @@
+from os import PathLike
+from pathlib import Path
+from typing import Any
+
+from pyics.distribution import archive, dependencies
+from pyics.distribution.archive import ArchiveError
+from pyics.distribution.slugs import check_slug
+from pyics.distribution.sources import SourceError, build_index
+from pyics.scripts.console import confirm, fail, warn_differing_notebooks
+from pyics.util import paths
+
+
+def _text(value: Any) -> str:
+    """A field of a manifest as text, e.g. a list as its items."""
+    if isinstance(value, list):
+        return ", ".join(map(str, value))
+    return str(value)
+
+
+def _declare_requirements(
+    course: archive.CourseFiles, requires: list[str], *, yes: bool
+) -> list[str] | None:
+    """
+    Find the packages ``course`` uses that its ``requires`` don't declare, and offer to
+    add them (or add them if ``yes``). The lines of its notebooks that install packages
+    are shown as hints (see ``archive.pip_installs``).
+
+    Returns
+    -------
+    list[str] | None
+        Its requires with them added, or None if there are none, or they aren't added.
+    """
+    base = course.manifest_path.parent
+    tasks = {
+        paths.relative_to(path, base).as_posix(): data
+        for path, data in course.tasks.items()
+    }
+    used = dependencies.used_modules(tasks, archive.local_modules(course))
+    missing = dependencies.undeclared(used, requires)
+    if not missing:
+        return None
+    print("The course uses packages that its requires don't declare:")
+    for distribution, files in sorted(missing.items()):
+        installed = dependencies.installed_version(distribution)
+        note = "" if installed else ", not installed here"
+        print(f"  {distribution} (in {', '.join(sorted(files))}{note})")
+    if installs := archive.pip_installs(course.tasks):
+        print("Its notebooks install packages with:")
+        for notebook, cell, line in installs:
+            where = paths.relative_to(notebook, base).as_posix()
+            print(f"  {where} (cell {cell}): {line}")
+    if yes or confirm("Add them to its requires?", default=True):
+        return [*requires, *sorted(missing)]
+    print("Students will have to find out themselves which packages to install.")
+    return None
+
+
+def _pack(
+    manifest: PathLike,
+    out: PathLike | None = None,
+    version: str | None = None,
+    description: str | None = None,
+    slug: str | None = None,
+    tags: list[str] | None = None,
+    include: list[str] | None = None,
+    no_solutions: bool = False,
+    yes: bool = False,
+) -> None:
+    """
+    Console script to pack a course into an archive, which can be pulled by its path or
+    URL, or published in an index (see ``build_index``). The archive holds the course
+    manifest and its task files, but not the progress made on the course, nor the
+    exercise and solution files, which are created when the course is started.
+
+    The given version, description, slug and tags are stored in the manifest, so the
+    next pack reuses them. So are the packages the course uses that its requires don't
+    declare yet, once confirmed (with the ``%pip install`` lines of its notebooks as
+    hints). Tasks that share a notebook, but store different contents for it, are
+    warned about.
+
+    Parameters
+    ----------
+    manifest: PathLike
+        The course manifest (``.pyicscourse.json``).
+    out: PathLike | None
+        Where to write the archive, or the directory to write it to. By default,
+        ``./<slug>-<version>.zip``.
+    version: str | None
+        The course's version, e.g. ``1.2.0``. Give each version you publish a new one,
+        so that pulled courses can be updated.
+    description: str | None
+        A short description, shown when searching for courses.
+    slug: str | None
+        The name the course is pulled by, e.g. ``search-algorithms``. By default,
+        derived from its name when it is first packed.
+    tags: list[str] | None
+        Tags to find the course by.
+    include: list[str] | None
+        Other files the course needs, e.g. data its exercises read, or directories of
+        them.
+    no_solutions: bool
+        Leave the solutions out, e.g. for a course that is graded.
+    yes: bool
+        Don't ask for confirmation.
+    """
+    try:
+        course = archive.read_course(Path(manifest))
+        warn_differing_notebooks(
+            archive.differing_notebooks(course.tasks), course.manifest_path.parent
+        )
+        info = course.info
+        changes: dict[str, Any] = {}
+        if version is not None:
+            changes["version"] = version
+        if description is not None:
+            changes["description"] = description
+        if tags is not None:
+            changes["tags"] = tags
+        if slug is not None:
+            changes["slug"] = check_slug(slug, "course slug")
+        elif not course.manifest.get("slug"):
+            # fixed once the course is published, so that renaming it doesn't change
+            # the name it is pulled and updated by
+            changes["slug"] = info.slug
+        if not course.manifest.get("requires_pyics"):
+            changes["requires_pyics"] = f">={dependencies.pyics_version()}"
+        requires = _declare_requirements(course, info.requires, yes=yes)
+        if requires is not None:
+            changes["requires"] = requires
+
+        if changes:
+            archive.update_manifest(course.manifest_path, changes)
+            course = archive.read_course(course.manifest_path)
+            info = course.info
+            print(
+                f"Updated {course.manifest_path.name}: "
+                + ", ".join(f"{key} {_text(value)}" for key, value in changes.items())
+            )
+
+        name = f"{info.slug}-{info.version}.zip" if info.version else f"{info.slug}.zip"
+        out = Path(out) if out is not None else Path(name)
+        if out.is_dir():
+            out = out / name
+        files = archive.pack(
+            course,
+            out,
+            include=[Path(i) for i in include or []],
+            no_solutions=no_solutions,
+        )
+    except (ArchiveError, ValueError, OSError) as err:
+        fail(err)
+
+    version_text = f" {info.version}" if info.version else ""
+    print(f"Packed {info.title}{version_text} into {out} ({len(files)} files).")
+    if not info.version:
+        print("It has no version: give it one with --version, so it can be updated.")
+    print("Publish it in an index with: pyics build_index <directory of archives>")
+
+
+def _build_index(
+    directory: PathLike = Path("."),
+    out: PathLike | None = None,
+    name: str | None = None,
+) -> None:
+    """
+    Console script to write the index of a course library (a source): of the course
+    archives (see ``pack``) in a directory and its subdirectories, the newest version
+    of each course. Upload the directory to a web server, and add the index's URL
+    with ``pyics add_source``.
+
+    Parameters
+    ----------
+    directory: PathLike
+        The directory of the archives. The working directory by default.
+    out: PathLike | None
+        Where to write the index. By default, ``index.json`` in ``directory``.
+    name: str | None
+        The library's name, e.g. "Uni Bamberg AI courses". By default, the name of the
+        index it replaces, or else of ``directory``.
+    """
+    try:
+        fp, index = build_index(
+            Path(directory), Path(out) if out is not None else None, name=name
+        )
+    except (SourceError, OSError) as err:
+        fail(err)
+    courses = index["courses"]
+    listed = ", ".join(
+        f"{slug} {entry['version']}".rstrip() for slug, entry in courses.items()
+    )
+    count = f"{len(courses)} course" + ("" if len(courses) == 1 else "s")
+    print(f"Wrote the index {index['name']!r} of {count} to {fp}.")
+    if listed:
+        print(f"Courses: {listed}")
+    print(
+        "Upload the directory to a web server, and add the index's URL with: "
+        "pyics add_source <url>"
+    )

pyics/scripts/pull.py

@@ -0,0 +1,123 @@
+from os import PathLike
+from pathlib import Path
+
+from pyics.distribution.archive import ArchiveError
+from pyics.distribution.fetch import is_url
+from pyics.distribution.pull import Pulled, PullError, is_direct, pull, update
+from pyics.scripts.console import (
+    TRUST_WARNING,
+    confirm,
+    fail,
+    install_requirements,
+    report_problems,
+)
+from pyics.util import paths
+
+# how many directories below the working directory the course selector looks
+_SELECTOR_DEPTH = 2
+
+
+def _where_to_start(pulled: Pulled) -> str:
+    """How to start the course ``pulled`` from the working directory."""
+    try:
+        rel = pulled.manifest_path.relative_to(paths.absolute(Path.cwd()))
+    except ValueError:
+        rel = None
+    if rel is not None and len(rel.parent.parts) <= _SELECTOR_DEPTH:
+        return "Start it with: pyics"
+    return f"Start it by running pyics in {pulled.directory}"
+
+
+def _finish(pulled: Pulled, *, install_deps: bool, yes: bool) -> None:
+    """Report the course's unmet requirements, installing them if asked to."""
+    problems = pulled.problems
+    if problems and install_deps:
+        problems = install_requirements(problems, yes=yes)
+    report_problems(pulled.info.title, problems)
+
+
+def _pull(
+    course: str,
+    dest: PathLike | None = None,
+    install_deps: bool = False,
+    allow_http: bool = False,
+    yes: bool = False,
+) -> None:
+    """
+    Console script to pull a course into a directory of its own, ``./<name>`` by
+    default: a course from the course libraries (see ``add_source``) by its name, or
+    ``<source>/<name>`` if several have one of that name, or a course archive by its
+    URL or path.
+
+    Parameters
+    ----------
+    course: str
+        The course.
+    dest: PathLike | None
+        The directory to pull it into, which must be new or empty.
+    install_deps: bool
+        Install the packages the course needs that aren't installed (after asking).
+    allow_http: bool
+        Allow downloading a course archive by URL over plain http, which isn't secure.
+    yes: bool
+        Don't ask for confirmation.
+    """
+    if is_direct(course) and is_url(course):
+        print(TRUST_WARNING)
+        if not yes and not confirm(f"Pull the course at {course}?"):
+            print("Cancelled, no course was pulled.")
+            return
+    try:
+        pulled = pull(course, Path(dest) if dest else None, allow_http=allow_http)
+    except (PullError, ArchiveError, OSError) as err:
+        fail(err)
+    for warning in pulled.warnings:
+        print(f"warning: {warning}")
+    version = f" {pulled.info.version}" if pulled.info.version else ""
+    print(f"Pulled {pulled.info.title}{version} into {pulled.directory}.")
+    _finish(pulled, install_deps=install_deps, yes=yes)
+    print(_where_to_start(pulled))
+
+
+def _update(
+    directory: PathLike = Path("."),
+    install_deps: bool = False,
+    allow_http: bool = False,
+    force: bool = False,
+    yes: bool = False,
+) -> None:
+    """
+    Console script to update a pulled course to its latest version. Your exercise files
+    are kept as they are, and so is your progress.
+
+    Parameters
+    ----------
+    directory: PathLike
+        The course's directory, or a directory in it. The working directory by default.
+    install_deps: bool
+        Install the packages the course needs that aren't installed (after asking).
+    allow_http: bool
+        Allow downloading a course pulled by URL over plain http, which isn't secure.
+    force: bool
+        Update the course even if it is up to date, e.g. to restore its files.
+    yes: bool
+        Don't ask for confirmation.
+    """
+    try:
+        updated = update(Path(directory), allow_http=allow_http, force=force)
+    except (PullError, ArchiveError, OSError) as err:
+        fail(err)
+    title = updated.info.title
+    if updated.up_to_date:
+        version = f" ({updated.info.version})" if updated.info.version else ""
+        print(f"{title} is up to date{version}.")
+    else:
+        old, new = updated.old_version, updated.info.version
+        versions = f" from {old} to {new}" if old and new and old != new else ""
+        print(f"Updated {title}{versions}. Your exercise files were kept.")
+        if updated.kept:
+            print(
+                "These files of the new version weren't written, to keep yours: "
+                + ", ".join(updated.kept)
+            )
+    _finish(updated, install_deps=install_deps, yes=yes)