entangled-cli 2.3.2__py3-none-any.whl → 2.4.2__py3-none-any.whl

entangled/commands/__init__.py

@@ -1,19 +1,13 @@
-from .new import new
-from .status import status
+from .main import main
 from .stitch import stitch
-from .sync import sync
 from .tangle import tangle
+from .new import new
 from .reset import reset
+from .sync import sync
 from .watch import watch
+from .status import status
 from .brei import brei
 
 __all__ = [
-    "new",
-    "brei",
-    "reset",
-    "status",
-    "stitch",
-    "sync",
-    "tangle",
-    "watch",
+    "main", "stitch", "tangle", "new", "reset", "sync", "watch", "status", "brei"
 ]

entangled/commands/brei.py

@@ -1,22 +1,26 @@
 from pathlib import Path
 from collections.abc import Awaitable
 from typing import Any
-import argh  # type: ignore
 import asyncio
 import textwrap
 
-from ..config import config
+from ..config import Config, read_config
+from ..io import FileCache
 from brei import resolve_tasks, Phony
 from ..logging import logger
+from .main import main
+
+import click
 
 log = logger()
 
 
-async def main(target_strs: list[str], force_run: bool, throttle: int | None):
+async def brei_main(target_strs: list[str], force_run: bool, throttle: int | None):
     if not Path(".entangled").exists():
         Path(".entangled").mkdir()
 
-    db = await resolve_tasks(config.get.brei, Path(".entangled/brei_history"))
+    cfg = Config() | read_config(FileCache())
+    db = await resolve_tasks(cfg.brei, Path(".entangled/brei_history"))
     if throttle:
         db.throttle = asyncio.Semaphore(throttle)
     db.force_run = force_run
@@ -33,10 +37,13 @@ async def main(target_strs: list[str], force_run: bool, throttle: int | None):
                 log.error(msg)
 
 
-@argh.arg("targets", nargs="+", help="name of target to run")
-@argh.arg("-B", "--force-run", help="rebuild all dependencies")
-@argh.arg("-j", "--throttle", help="limit number of concurrent jobs")
+@main.command()
+@click.argument("targets", nargs=-1)
+@click.option("-B", "--force-run", is_flag=True, help="rebuild all dependencies")
+@click.option("-j", "--throttle", is_flag=True, help="limit number of concurrent jobs")
 def brei(targets: list[str], *, force_run: bool = False, throttle: int | None = None):
-    """Build one of the configured targets."""
-    config.read()
-    asyncio.run(main(targets, force_run, throttle))
+    """Build one of the configured targets.
+
+    TARGETS     Names of the targets to run.
+    """
+    asyncio.run(brei_main(targets, force_run, throttle))

entangled/commands/main.py

@@ -0,0 +1,23 @@
+from ..logging import configure, logger
+from ..version import __version__
+
+import sys
+import rich_click as click
+
+
+@click.group(
+    invoke_without_command=True,
+    epilog="See https://entangled.github.io/ for more help and tutorials."
+)
+@click.rich_config({"commands_before_options": True, "theme": "nord-modern"})
+@click.option("-v", "--version", is_flag=True, help="Show version.")
+@click.option("-d", "--debug", is_flag=True, help="Enable debugging.")
+def main(version: bool = False, debug: bool = False):
+    """Your literate programming toolkit.
+    """
+    if version:
+        print(f"Entangled {__version__}")
+        sys.exit(0)
+
+    configure(debug)
+    logger().info(f"Welcome to Entangled v{__version__}!")

entangled/commands/new.py

@@ -1,13 +1,11 @@
-import argh  # type: ignore
-from argh.utils import get_subparsers
-import argparse
+import click
 
 from pathlib import Path
-from rich_argparse import RichHelpFormatter
 from rich.console import Console
 from rich.table import Table
 
 from ..errors.user import HelpfulUserError
+from .main import main
 
 description = """Create a new entangled project from a template.
 
@@ -42,61 +40,52 @@ def print_help() -> None:
     For this we first have to create a parser and attach this `new` function
     to it. Then we have a parser object that we can `print_help()` from.
     """
-    parser = argparse.ArgumentParser(formatter_class=RichHelpFormatter)
-    argh.add_commands(parser, [new], func_kwargs={"formatter_class": RichHelpFormatter})
-    get_subparsers(parser).choices["new"].print_help()
+    ctx = click.get_current_context()
+    click.echo(ctx.get_help())
+    ctx.exit()
 
 
-@argh.arg(
-    "-a",
-    "--answers-file",
+@main.command(
+    epilog="This command, and the options provided are a front-end for `copier`. " +
+           "See https://copier.readthedocs.io/en/stable/ for more information."
+)
+@click.option(
+    "-a", "--answers-file",
     help="Update using this path (relative to [project_path]) to find the answers file for `copier`",
 )
-@argh.arg(
-    "-d",
-    "--data",
+@click.option(
+    "-d", "--data",
     help='"VARIABLE1=VALUE1;VARIABLE1=VALUE2" Make VARIABLEs available as VALUEs when rendering the template; make sure to use quotation marks for multiple variables/values',
 )
-@argh.arg(
-    "-D",
-    "--defaults",
+@click.option(
+    "-D", "--defaults", is_flag=True,
     help="Use default answers to questions, which might be null if not specified; overwrites when combined with -d!",
 )
-@argh.arg(
-    "-p",
-    "--pretend",
+@click.option(
+    "-p", "--pretend", is_flag=True,
     help="Run but do not make any changes",
 )
-@argh.arg(
-    "-o",
-    "--overwrite",
+@click.option(
+    "-o", "--overwrite", is_flag=True,
     help="Overwrite files that already exist, without asking.",
 )
-@argh.arg(
-    "-l",
-    "--list-templates",
+@click.option(
+    "-l", "--list-templates", is_flag=True,
     help="List all official templates and exit",
 )
-@argh.arg(
-    "-t",
-    "--trust",
+@click.option(
+    "-t", "--trust", is_flag=True,
     help='Allow templates with unsafe features (Jinja extensions, migrations, tasks); "True" for officially supported templates',
 )
-@argh.arg(
-    "template",
-    # default=None,
-    nargs="?",
-    help="Template handle or URL; initialize a new project from this template",
+@click.argument(
+    "template"
 )
-@argh.arg(
-    "project-path",
-    # default=None,
-    nargs="?",
-    help="Initialize a new project at this path",
+@click.argument(
+    "project-path"
 )
 def new(
-    template: str | None,
-    project_path: Path | None, *,
+    template: str,
+    project_path: Path, *,
     answers_file: str | None = None,
     data: str = "",
     defaults: bool = False,
@@ -105,7 +94,12 @@ def new(
     list_templates: bool = False,
     trust: bool = False,
 ) -> None:
-    """Create a new entangled project from a template."""
+    """Create a new entangled project from a template.
+
+    TEMPLATE      Template handle or URL; initialize a new project from this template.
+
+    PROJECT_PATH  Initialize a new project at this path.
+    """
 
     from ..config.templates import templates as AVAILABLE_TEMPLATES
     from ..config.templates import Template

entangled/commands/reset.py

@@ -6,57 +6,15 @@ This command will read the markdown sources, then pretend to be tangling
 without actually writing out to source files.
 """
 
-from ..io import TransactionMode, transaction
-from ..config import config, get_input_files
-from ..hooks import  get_hooks
-from ..document import ReferenceMap
-from ..errors.user import UserError
-
-import logging
-from pathlib import Path
+from ..io import TransactionMode
+from .main import main
+from .tangle import do_tangle
 
 
+@main.command(short_help="Reset the file database.")
 def reset():
     """
-    Resets the database. This performs a tangle without actually writing
-    output to the files, but updating the database as if we were.
+    Resets the file database. This performs a tangle without actually
+    writing output to the files, but updating the database as if we were.
     """
-    config.read()
-
-    # these imports depend on config being read
-    from ..markdown_reader import read_markdown_file
-    from ..tangle import tangle_ref
-
-    input_file_list = get_input_files()
-
-    refs = ReferenceMap()
-    hooks = get_hooks()
-    logging.debug("tangling with hooks: %s", [h.__module__ for h in hooks])
-    mode = TransactionMode.RESETDB
-    annotation_method = config.get.annotation
-
-    try:
-        with transaction(mode) as t:
-            for path in input_file_list:
-                logging.debug("reading `%s`", path)
-                t.update(path)
-                _, _ = read_markdown_file(t, path, refs=refs, hooks=hooks)
-
-            for h in hooks:
-                h.pre_tangle(refs)
-
-            for tgt in refs.targets:
-                result, deps = tangle_ref(refs, tgt, annotation_method)
-                mask = next(iter(refs.by_name(tgt))).mode
-                t.write(Path(tgt), result, list(map(Path, deps)), mask)
-
-            for h in hooks:
-                h.on_tangle(t, refs)
-
-            t.clear_orphans()
-
-        for h in hooks:
-            h.post_tangle(refs)
-
-    except UserError as e:
-        logging.error(str(e))
+    do_tangle(mode=TransactionMode.RESETDB)

entangled/commands/status.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 from collections.abc import Iterable
-from ..status import list_input_files, list_dependent_files
-from ..config import config
+from ..status import list_dependent_files
+from ..config import Config, read_config, get_input_files
+from ..io import FileCache
 from pathlib import Path
 
 from rich.console import Console, Group
@@ -10,6 +11,8 @@ from rich.table import Table
 from rich.panel import Panel
 from rich.tree import Tree
 
+from .main import main
+
 
 def tree_from_files(files: Iterable[Path]):
     tree = Tree(label=".")
@@ -28,23 +31,25 @@ def files_panel(file_list: Iterable[Path], title: str) -> Panel:
 
 
 def rich_status():
+    fs = FileCache()
+    cfg = Config() | read_config(fs)
     config_table = Table()
     config_table.add_column("name")
     config_table.add_column("value")
     config_table.add_row(
-        "Watch list", ", ".join(f"'{pat}'" for pat in config.get.watch_list)
+        "Watch list", ", ".join(f"'{pat}'" for pat in cfg.watch_list)
     )
     config_table.add_row(
-        "Ignore list", ", ".join(f"'{pat}'" for pat in config.get.ignore_list)
+        "Ignore list", ", ".join(f"'{pat}'" for pat in cfg.ignore_list)
     )
-    config_table.add_row("Hooks enabled", ", ".join(config.get.hooks))
+    config_table.add_row("Hooks enabled", ", ".join(cfg.hooks))
 
     console = Console(color_system="auto")
     group = Group(
         Panel(config_table, title="config", border_style="dark_cyan"),
         Columns(
             [
-                files_panel(list_input_files(), "input files"),
+                files_panel(get_input_files(fs, cfg), "input files"),
                 files_panel(list_dependent_files(), "dependent files"),
             ]
         ),
@@ -53,6 +58,7 @@ def rich_status():
     console.print(group)
 
 
+@main.command()
 def status():
-    config.read()
+    """Print a status overview."""
     rich_status()

entangled/commands/stitch.py

@@ -1,41 +1,17 @@
-from itertools import chain
-from pathlib import Path
+import rich_click as click
 
-import logging
-import argh  # type: ignore
+from .main import main
 
-from ..config import config
-from ..document import ReferenceMap, Content, PlainText, ReferenceId
+from ..interface import Document
 from ..io import transaction, TransactionMode
 from ..errors.user import UserError
-from ..config import get_input_files
 
 
-def stitch_markdown(reference_map: ReferenceMap, content: list[Content]) -> str:
-    def get(item: Content):
-        match item:
-            case PlainText(s):
-                return s
-            case ReferenceId():
-                return reference_map.get_codeblock(item).indented_text
-
-    return "\n".join(get(i) for i in content) + "\n"
-
-
-@argh.arg("--force", help="force overwrite on conflict")
-@argh.arg("-s", "--show", help="only show, don't act")
+@main.command()
+@click.option("-f", "--force", is_flag=True, help="force overwrite on conflict")
+@click.option("-s", "--show", is_flag=True, help="only show, don't act")
 def stitch(*, force: bool = False, show: bool = False):
-    """Stitch code changes back into the Markdown"""
-    config.read()
-
-    # these imports depend on config being read
-    from ..markdown_reader import read_markdown_file
-    from ..code_reader import CodeReader
-    from ..hooks import get_hooks
-
-    input_file_list = get_input_files()
-    hooks = get_hooks()
-
+    """Stitch code changes back into the documentation."""
     if show:
         mode = TransactionMode.SHOW
     elif force:
@@ -43,22 +19,9 @@ def stitch(*, force: bool = False, show: bool = False):
     else:
         mode = TransactionMode.FAIL
 
-    refs = ReferenceMap()
-    content: dict[Path, list[Content]] = {}
-    try:
-        with transaction(mode) as t:
-            for path in input_file_list:
-                logging.debug("reading `%s`", path)
-                _, c = read_markdown_file(t, path, refs=refs, hooks=hooks)
-                content[path] = c
-
-            for path in t.db.managed_files:
-                logging.debug("reading `%s`", path)
-                t.update(path)
-                _ = CodeReader(path, refs).run(t.read(path))
-
-            for path in input_file_list:
-                t.write(path, stitch_markdown(refs, content[path]), [])
+    doc = Document()
 
-    except UserError as e:
-        logging.error(str(e))
+    with transaction(mode) as t:
+        doc.load(t)
+        doc.load_all_code(t)
+        doc.stitch(t)

entangled/commands/sync.py

@@ -1,51 +1,81 @@
-from typing import Optional, Callable
-from itertools import chain
-from pathlib import Path
+from enum import Enum
 
-import logging
+from ..io import filedb, FileCache, transaction
+from ..interface import Document
+from ..errors.user import UserError
+
+from .main import main
 
-from ..io import filedb, FileCache
-from ..config import config
-from .stitch import stitch, get_input_files
-from .tangle import tangle
+import logging
 
 
-def _stitch_then_tangle():
-    stitch()
-    tangle()
+class Action(Enum):
+    NOTHING = 0
+    TANGLE = 1
+    STITCH = 2
 
 
-def sync_action() -> Callable[[], None] | None:
-    input_file_list = get_input_files()
-    fs = FileCache()
+def sync_action(doc: Document) -> Action:
+    input_file_list = doc.input_files()
 
-    with filedb(readonly=True) as db:
-        changed = set(db.changed_files(fs))
+    with filedb(readonly=True, fs=doc.context.fs) as db:
+        changed = set(db.changed_files(doc.context.fs))
 
         if not all(f in db for f in input_file_list):
-            return tangle
+            return Action.TANGLE
 
         if not changed:
-            return None
+            return Action.NOTHING
 
         if changed.isdisjoint(db.managed_files):
-            logging.info("Tangling")
-            return tangle
+            return Action.TANGLE
 
         if changed.issubset(db.managed_files):
-            logging.info("Stitching")
-            return _stitch_then_tangle
+            return Action.STITCH
 
         logging.error("changed: %s", [str(p) for p in changed])
         logging.error(
             "Both markdown and code seem to have changed, don't know what to do now."
         )
-        return None
+        return Action.NOTHING
+
+
+def tangle(doc: Document):
+    with transaction() as t:
+        doc.load(t)
+        doc.tangle(t)
+        t.clear_orphans()
+        for h in doc.context.all_hooks:
+            h.post_tangle(doc.reference_map)
+
+
+def stitch(doc: Document):
+    with transaction() as t:
+        doc.load(t)
+        doc.load_all_code(t)
+        doc.stitch(t)
+    with transaction() as t:
+        doc.tangle(t)
+        for h in doc.context.all_hooks:
+            h.post_tangle(doc.reference_map)
+
+
+def run_sync():
+    doc = Document()
+    match sync_action(doc):
+        case Action.TANGLE:
+            logging.info("Tangling.")
+            tangle(doc)
+
+        case Action.STITCH:
+            logging.info("Stitching.")
+            stitch(doc)
+
+        case Action.NOTHING:
+            pass
 
 
+@main.command()
 def sync():
     """Be smart wether to tangle or stich"""
-    config.read()
-    action = sync_action()
-    if action is not None:
-        action()
+    run_sync()

entangled/commands/tangle.py

@@ -1,74 +1,48 @@
-from pathlib import Path
+import rich_click as click
 
-import argh  # type: ignore
-import logging
+from .main import main
 
-from ..document import ReferenceMap
-from ..config import config, AnnotationMethod, get_input_files
-from ..io import transaction, TransactionMode
-from ..hooks import get_hooks
+from ..config import AnnotationMethod, Config
+from ..io import AbstractFileCache, FileCache, transaction, TransactionMode
 from ..errors.user import UserError
+from ..interface import Context, Document
 
 
-@argh.arg(
-    "-a",
-    "--annotate",
-    choices=[m.name.lower() for m in AnnotationMethod],
-    help="annotation method",
-)
-@argh.arg("--force", help="force overwrite on conflict")
-@argh.arg("-s", "--show", help="only show, don't act")
-@argh.arg("-r", "--reset-db", help="resets database")
-def tangle(*, annotate: str | None = None, force: bool = False, show: bool = False, reset_db: bool = False):
-    """Tangle codes from Markdown"""
-    config.read()
-
-    # these imports depend on config being read
-    from ..markdown_reader import read_markdown_file
-    from ..tangle import tangle_ref
-
-    if annotate is None:
-        annotation_method = config.get.annotation
-    else:
-        annotation_method = AnnotationMethod[annotate.upper()]
-
-    input_file_list = get_input_files()
-
-    refs = ReferenceMap()
-    hooks = get_hooks()
-    logging.debug("tangling with hooks: %s", [h.__module__ for h in hooks])
-
+@main.command()
+@click.option("-a", "--annotate", type=click.Choice(AnnotationMethod, case_sensitive=False),
+              help="annotation method")
+@click.option("-f", "--force", is_flag=True, help="force overwriting existing files")
+@click.option("-s", "--show", is_flag=True, help="only show what would happen")
+def tangle(*, annotate: AnnotationMethod | None = None, force: bool = False, show: bool = False):
     if show:
         mode = TransactionMode.SHOW
-    elif reset_db:
-        mode = TransactionMode.RESETDB
     elif force:
         mode = TransactionMode.FORCE
     else:
         mode = TransactionMode.FAIL
 
-    try:
-        with transaction(mode) as t:
-            for path in input_file_list:
-                logging.debug("reading `%s`", path)
-                t.update(path)
-                _, _ = read_markdown_file(t, path, refs=refs, hooks=hooks)
+    do_tangle(annotate=annotate, mode=mode, skip_post_tangle=False)
+
 
-            for h in hooks:
-                h.pre_tangle(refs)
+def do_tangle(*,
+    annotate: AnnotationMethod | None = None,
+    mode: TransactionMode = TransactionMode.FAIL,
+    fs: AbstractFileCache | None = None,
+    skip_post_tangle: bool = True):
+    """Tangle codes from the documentation."""
 
-            for tgt in refs.targets:
-                result, deps = tangle_ref(refs, tgt, annotation_method)
-                mask = next(iter(refs.by_name(tgt))).mode
-                t.write(Path(tgt), result, list(map(Path, deps)), mask)
+    if fs is None:
+        fs = FileCache()
 
-            for h in hooks:
-                h.on_tangle(t, refs)
+    doc = Document(context=Context(fs=fs))
 
-            t.clear_orphans()
+    with transaction(mode, fs=fs) as t:
+        doc.load(t)
+        doc.tangle(t, annotate)
+        t.clear_orphans()
 
-        for h in hooks:
-            h.post_tangle(refs)
+    if skip_post_tangle:
+        return
 
-    except UserError as e:
-        logging.error(str(e))
+    for h in doc.context.all_hooks:
+        h.post_tangle(doc.reference_map)