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

pyics/scripts/sources.py

@@ -0,0 +1,118 @@
+from pyics.distribution import dependencies, sources
+from pyics.distribution.sources import SourceError
+from pyics.scripts.console import TRUST_WARNING, confirm, fail
+
+
+def _add_source(
+    url: str, name: str | None = None, allow_http: bool = False, yes: bool = False
+) -> None:
+    """
+    Console script to add a course library (a source) by the URL of its index, so that
+    its courses can be pulled by name (see ``pull``).
+
+    Parameters
+    ----------
+    url: str
+        The URL of the index, or its path, e.g. on a network share.
+    name: str | None
+        The name to know the source by. By default, the index's name.
+    allow_http: bool
+        Allow fetching the index and the courses over plain http, which isn't secure.
+    yes: bool
+        Don't ask for confirmation.
+    """
+    try:
+        source, index, data = sources.prepare_source(url, name, allow_http=allow_http)
+    except SourceError as err:
+        fail(err)
+    count = f"{len(index.courses)} course" + ("" if len(index.courses) == 1 else "s")
+    courses = f": {', '.join(index.courses)}" if index.courses else ""
+    print(f"{index.name or source.url} lists {count}{courses}")
+    print(TRUST_WARNING)
+    if not yes and not confirm(f"Add it as {source.name!r}?"):
+        print("Cancelled, no source was added.")
+        return
+    try:
+        sources.save_source(source, data)
+    except (SourceError, OSError) as err:
+        fail(err)
+    print(f"Added the source {source.name!r}. Find its courses with: pyics search")
+
+
+def _remove_source(name: str) -> None:
+    """
+    Console script to remove a course library (see ``add_source``). Courses pulled from
+    it stay where they are.
+
+    Parameters
+    ----------
+    name: str
+        The name of the source.
+    """
+    try:
+        sources.remove_source(name)
+    except (SourceError, OSError) as err:
+        fail(err)
+    print(f"Removed the source {name!r}.")
+
+
+def _sources() -> None:
+    """Console script to list the course libraries (see ``add_source``)."""
+    try:
+        found = sources.load_sources()
+    except SourceError as err:
+        fail(err)
+    if not found:
+        print("You haven't added any sources. Add one with: pyics add_source <url>")
+        return
+    for source in found:
+        line = f"{source.name}  {source.url}"
+        if source.allow_http:
+            line += "  (plain http allowed)"
+        if source.site is not None:
+            line += f"  (for all users, in {source.site})"
+        print(line)
+
+
+def _search(term: str | None = None, offline: bool = False) -> None:
+    """
+    Console script to list the courses in the course libraries (see ``add_source``)
+    that match ``term`` in their name, title, description or tags, or all of them.
+
+    Parameters
+    ----------
+    term: str | None
+        What to look for.
+    offline: bool
+        Only look in the indexes fetched last, without fetching them anew.
+    """
+    try:
+        if not sources.load_sources():
+            print("You haven't added any sources. Add one with: pyics add_source <url>")
+            return
+        courses, warnings = sources.search(term, refresh=not offline)
+    except SourceError as err:
+        fail(err)
+    for warning in warnings:
+        print(f"warning: {warning}")
+    if not courses:
+        print("No course found." if term is None else f"No course matches {term!r}.")
+        return
+
+    slugs = [entry.slug for _, entry in courses]
+    for source, entry in courses:
+        # the source is needed to pull a course whose slug several sources have
+        name = (
+            entry.slug
+            if slugs.count(entry.slug) == 1
+            else f"{source.name}/{entry.slug}"
+        )
+        version = f" {entry.version}" if entry.version else ""
+        print(f"{name}{version}: {entry.title} (from {source.name})")
+        if entry.description:
+            print(f"    {entry.description}")
+        if entry.tags:
+            print(f"    tags: {', '.join(entry.tags)}")
+        if problems := dependencies.check(entry.requires, entry.requires_pyics):
+            print(f"    needs {dependencies.describe(problems)}")
+    print("Pull a course with: pyics pull <name>")

pyics/tests/__init__.py

@@ -0,0 +1,3 @@
+from .tests import Test, PrintTest, SimpleTest, SpecTest, StructureTest, SizeTest
+
+all = ["Test", "PrintTest", "SimpleTest", "SpecTest", "StructureTest", "SizeTest"]

pyics/tests/capture.py

@@ -0,0 +1,114 @@
+import builtins
+import io
+import sys
+import threading
+from collections.abc import Generator, Iterable, Iterator
+from contextlib import contextmanager
+
+
+class _ThreadLocalStdout:
+    """`sys.stdout` (or `sys.stderr`) replacement that only redirects the calling thread's
+    writes."""
+
+    def __init__(self, real):
+        self._real = real
+        self._local = threading.local()
+
+    def _stack(self) -> list[io.StringIO]:
+        return self._local.__dict__.setdefault("stack", [])
+
+    def write(self, s: str) -> int:
+        stack = self._stack()
+        return stack[-1].write(s) if stack else self._real.write(s)
+
+    def flush(self) -> None:
+        if not self._stack():
+            self._real.flush()
+
+    def __getattr__(self, name):
+        return getattr(self._real, name)
+
+
+_install_lock = threading.Lock()
+
+
+def _ensure_installed(stream: str = "stdout") -> _ThreadLocalStdout:
+    with _install_lock:
+        if not isinstance(getattr(sys, stream), _ThreadLocalStdout):
+            setattr(sys, stream, _ThreadLocalStdout(getattr(sys, stream)))
+        return getattr(sys, stream)
+
+
+@contextmanager
+def capture_stdout() -> Generator[io.StringIO]:
+    """Capture this thread's stdout writes only; other threads are unaffected."""
+    with _capture("stdout") as buf:
+        yield buf
+
+
+@contextmanager
+def capture_stderr() -> Generator[io.StringIO]:
+    """Capture this thread's stderr writes only; other threads are unaffected."""
+    with _capture("stderr") as buf:
+        yield buf
+
+
+@contextmanager
+def _capture(stream: str) -> Generator[io.StringIO]:
+    proxy = _ensure_installed(stream)
+    buf = io.StringIO()
+    stack = proxy._stack()
+    stack.append(buf)
+    try:
+        yield buf
+    finally:
+        stack.pop()
+
+
+class _ThreadLocalInput:
+    """`builtins.input` replacement that answers the calling thread's calls from provided
+    inputs, if any."""
+
+    def __init__(self, real):
+        self._real = real
+        self._local = threading.local()
+
+    def _stack(self) -> list[Iterator[str]]:
+        return self._local.__dict__.setdefault("stack", [])
+
+    def __call__(self, prompt: object = "") -> str:
+        stack = self._stack()
+        if not stack:
+            return self._real(prompt)
+
+        sys.stdout.write(str(prompt))
+        try:
+            answer = next(stack[-1])
+        except StopIteration:
+            raise EOFError("EOF when reading a line, no inputs left") from None
+        sys.stdout.write(answer + "\n")  # echoed, as when typed into a console
+        return answer
+
+
+def _ensure_input_installed() -> _ThreadLocalInput:
+    with _install_lock:
+        if not isinstance(builtins.input, _ThreadLocalInput):
+            builtins.input = _ThreadLocalInput(builtins.input)
+        return builtins.input
+
+
+@contextmanager
+def provide_input(inputs: Iterable[str]) -> Generator[None]:
+    """
+    Answer this thread's ``input()`` calls with ``inputs``, in order, writing each to
+    stdout after the prompt, like a console shows typed answers. Once they have run out,
+    ``input()`` raises ``EOFError``, like at the end of stdin. Other threads are
+    unaffected.
+    """
+    proxy = _ensure_input_installed()
+    stack = proxy._stack()
+    stack.append(iter(inputs))
+    try:
+        yield
+    finally:
+        stack.pop()