entangled-cli 2.4.0__tar.gz → 2.4.3__tar.gz

{entangled_cli-2.4.0 → entangled_cli-2.4.3}/PKG-INFO

@@ -1,29 +1,26 @@
 Metadata-Version: 2.4
 Name: entangled-cli
-Version: 2.4.0
+Version: 2.4.3
 Summary: Literate Programming toolbox
 Project-URL: Homepage, https://entangled.github.io/
 Project-URL: Repository, https://github.com/entangled/entangled.py
 Author-email: Johan Hidding <j.hidding@esciencecenter.nl>
 License-Expression: Apache-2.0
 License-File: LICENSE
-Requires-Python: <4,>=3.12
-Requires-Dist: argh<0.31,>=0.30
+Requires-Python: <4,>=3.13
 Requires-Dist: brei<0.3,>=0.2.3
 Requires-Dist: click>=8.3.0
 Requires-Dist: copier<10,>=9
 Requires-Dist: filelock<4,>=3.12.0
-Requires-Dist: mawk<0.2,>=0.1.7
 Requires-Dist: msgspec>=0.20.0
-Requires-Dist: pexpect<5,>=4.9.0
 Requires-Dist: pyyaml<7,>=6.0.1
 Requires-Dist: repl-session>=0.2.0
 Requires-Dist: rich-argparse<2,>=1.4.0
 Requires-Dist: rich-click>=1.9.4
-Requires-Dist: rich<14,>=13.3.5
+Requires-Dist: rich<15,>=13
 Requires-Dist: tomlkit<0.13,>=0.12.1
 Requires-Dist: typeguard>=4.4.4
-Requires-Dist: watchdog>=6.0.0
+Requires-Dist: watchfiles>=1.1.1
 Description-Content-Type: text/markdown
 
 # Entangled
@@ -61,6 +58,12 @@ Or, if you prefer plain old `pip`,
 pip install entangled-cli
 ```
 
+Or, if you prefer the nix package manager:
+
+```
+nix run github:entangled/entangled.py
+```
+
 ## Use
 
 Run the `entangled watch` daemon in the root of your project folder. By default all Markdown files are monitored for fenced code blocks like so:

{entangled_cli-2.4.0 → entangled_cli-2.4.3}/README.md

@@ -33,6 +33,12 @@ Or, if you prefer plain old `pip`,
 pip install entangled-cli
 ```
 
+Or, if you prefer the nix package manager:
+
+```
+nix run github:entangled/entangled.py
+```
+
 ## Use
 
 Run the `entangled watch` daemon in the root of your project folder. By default all Markdown files are monitored for fenced code blocks like so:

{entangled_cli-2.4.0 → entangled_cli-2.4.3}/entangled/commands/brei.py

@@ -5,6 +5,7 @@ import asyncio
 import textwrap
 
 from ..config import Config, read_config
+from ..io import FileCache
 from brei import resolve_tasks, Phony
 from ..logging import logger
 from .main import main
@@ -18,7 +19,7 @@ async def brei_main(target_strs: list[str], force_run: bool, throttle: int | Non
     if not Path(".entangled").exists():
         Path(".entangled").mkdir()
 
-    cfg = Config() | read_config()
+    cfg = Config() | read_config(FileCache())
     db = await resolve_tasks(cfg.brei, Path(".entangled/brei_history"))
     if throttle:
         db.throttle = asyncio.Semaphore(throttle)

{entangled_cli-2.4.0 → entangled_cli-2.4.3}/entangled/commands/main.py

@@ -20,5 +20,4 @@ def main(version: bool = False, debug: bool = False):
         sys.exit(0)
 
     configure(debug)
-    logger().debug(f"Welcome to Entangled v{__version__}!")
-
+    logger().info(f"Welcome to Entangled v{__version__}!")

{entangled_cli-2.4.0 → entangled_cli-2.4.3}/entangled/commands/reset.py

@@ -6,12 +6,9 @@ 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 ..errors.user import UserError
-from ..interface import Document
+from ..io import TransactionMode
 from .main import main
-
-import logging
+from .tangle import do_tangle
 
 
 @main.command(short_help="Reset the file database.")
@@ -20,15 +17,4 @@ def reset():
     Resets the file database. This performs a tangle without actually
     writing output to the files, but updating the database as if we were.
     """
-    
-    try:
-        doc = Document()
-        mode = TransactionMode.RESETDB
-
-        with transaction(mode) as t:
-            doc.load(t)
-            doc.tangle(t)
-            t.clear_orphans()
-
-    except UserError as e:
-        logging.error(str(e))
+    do_tangle(mode=TransactionMode.RESETDB)

{entangled_cli-2.4.0 → entangled_cli-2.4.3}/entangled/commands/status.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 from collections.abc import Iterable
 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
@@ -30,7 +31,8 @@ def files_panel(file_list: Iterable[Path], title: str) -> Panel:
 
 
 def rich_status():
-    cfg = Config() | read_config()
+    fs = FileCache()
+    cfg = Config() | read_config(fs)
     config_table = Table()
     config_table.add_column("name")
     config_table.add_column("value")
@@ -47,7 +49,7 @@ def rich_status():
         Panel(config_table, title="config", border_style="dark_cyan"),
         Columns(
             [
-                files_panel(get_input_files(cfg), "input files"),
+                files_panel(get_input_files(fs, cfg), "input files"),
                 files_panel(list_dependent_files(), "dependent files"),
             ]
         ),

{entangled_cli-2.4.0 → entangled_cli-2.4.3}/entangled/commands/stitch.py

@@ -19,13 +19,9 @@ def stitch(*, force: bool = False, show: bool = False):
     else:
         mode = TransactionMode.FAIL
 
-    try:
-        doc = Document()
+    doc = Document()
 
-        with transaction(mode) as t:
-            doc.load(t)
-            doc.load_all_code(t)
-            doc.stitch(t)
-
-    except UserError as e:
-        e.handle()
+    with transaction(mode) as t:
+        doc.load(t)
+        doc.load_all_code(t)
+        doc.stitch(t)

{entangled_cli-2.4.0 → entangled_cli-2.4.3}/entangled/commands/sync.py

@@ -17,10 +17,9 @@ class Action(Enum):
 
 def sync_action(doc: Document) -> Action:
     input_file_list = doc.input_files()
-    fs = FileCache()
 
-    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 Action.TANGLE
@@ -59,29 +58,24 @@ def stitch(doc: Document):
         doc.tangle(t)
         for h in doc.context.all_hooks:
             h.post_tangle(doc.reference_map)
-        
 
-def run_sync():
-    try:
-        doc = Document()
-        match sync_action(doc):
-            case Action.TANGLE:
-                logging.info("Tangling.")
-                tangle(doc)
 
-            case Action.STITCH:
-                logging.info("Stitching.")
-                stitch(doc)
+def run_sync():
+    doc = Document()
+    match sync_action(doc):
+        case Action.TANGLE:
+            logging.info("Tangling.")
+            tangle(doc)
 
-            case Action.NOTHING:
-                pass
+        case Action.STITCH:
+            logging.info("Stitching.")
+            stitch(doc)
 
-    except UserError as e:
-        e.handle()
+        case Action.NOTHING:
+            pass
 
 
 @main.command()
 def sync():
     """Be smart wether to tangle or stich"""
     run_sync()
-

entangled_cli-2.4.3/entangled/commands/tangle.py

@@ -0,0 +1,48 @@
+import rich_click as click
+
+from .main import main
+
+from ..config import AnnotationMethod, Config
+from ..io import AbstractFileCache, FileCache, transaction, TransactionMode
+from ..errors.user import UserError
+from ..interface import Context, Document
+
+
+@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 force:
+        mode = TransactionMode.FORCE
+    else:
+        mode = TransactionMode.FAIL
+
+    do_tangle(annotate=annotate, mode=mode, skip_post_tangle=False)
+
+
+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."""
+
+    if fs is None:
+        fs = FileCache()
+
+    doc = Document(context=Context(fs=fs))
+
+    with transaction(mode, fs=fs) as t:
+        doc.load(t)
+        doc.tangle(t, annotate)
+        t.clear_orphans()
+
+    if skip_post_tangle:
+        return
+
+    for h in doc.context.all_hooks:
+        h.post_tangle(doc.reference_map)

entangled_cli-2.4.3/entangled/commands/watch.py

@@ -0,0 +1,51 @@
+from threading import Event
+from pathlib import Path
+
+from ..status import find_watch_dirs
+from ..logging import logger
+
+from .sync import run_sync
+from .main import main
+from ..errors.user import UserError
+
+import watchfiles
+
+
+log = logger()
+
+
+def watch_filter(change: watchfiles.Change, path: str) -> bool:
+    if Path(path).relative_to(Path.cwd()).as_posix().startswith(".entangled"):
+        return False
+    return True
+
+
+def _watch(_stop_event: Event | None = None, _start_event: Event | None = None):
+    """Keep a loop running, watching for changes. This interface is separated
+    from the CLI one, so that it can be tested using threading instead of
+    subprocess."""
+
+    def stop() -> bool:
+        return _stop_event is not None and _stop_event.is_set()
+
+    log.debug("Running daemon")
+    run_sync()
+
+    if _start_event is not None:
+        log.debug("Setting start event")
+        _start_event.set()
+
+    dirs = "."  # find_watch_dirs()
+
+    for changes in watchfiles.watch(dirs, stop_event=_stop_event, watch_filter=watch_filter):
+        log.debug(changes)
+        try:
+            run_sync()
+        except UserError as e:
+            logger().error(e, exc_info=False)
+
+
+@main.command()
+def watch():
+    """Keep a loop running, watching for changes."""
+    _watch()

{entangled_cli-2.4.0 → entangled_cli-2.4.3}/entangled/config/__init__.py

@@ -20,13 +20,13 @@ from .namespace_default import NamespaceDefault
 from ..logging import logger
 from ..version import __version__
 from ..errors.user import HelpfulUserError
-
+from ..io import AbstractFileCache
 
 log = logger()
 
 
 def read_config_from_toml(
-    path: Path, section: str | None = None
+    fs: AbstractFileCache, path: Path, section: str | None = None
 ) -> ConfigUpdate | None:
     """Read a config from given `path` in given `section`. The path should refer to
     a TOML file that should decode to a `Config` object. If `section` is given, only
@@ -39,17 +39,17 @@ def read_config_from_toml(
     read_config_from_toml(Path("./pyproject.toml"), "tool.entangled")
     ```
     """
-    if not path.exists():
+    if path not in fs:
         return None
     try:
-        with open(path, "rb") as f:
-            json: Any = tomllib.load(f)  # pyright: ignore[reportExplicitAny]
-            if section is not None:
-                for s in section.split("."):
-                    json = json[s]  # pyright: ignore[reportAny]
-            update = msgspec.convert(json, type=ConfigUpdate)
-            log.debug("Read config from `%s`", path)
-            return update
+        content = fs[path].content
+        json: Any = tomllib.loads(content)
+        if section is not None:
+            for s in section.split("."):
+                json = json[s]  # pyright: ignore[reportAny]
+        update = msgspec.convert(json, type=ConfigUpdate)
+        log.debug("Read config from `%s`", path)
+        return update
 
     except (msgspec.ValidationError, tomllib.TOMLDecodeError) as e:
         raise HelpfulUserError(f"Could not read config: {e}")
@@ -59,25 +59,35 @@ def read_config_from_toml(
         return None
 
 
-def read_config() -> ConfigUpdate | None:
-    if Path("./entangled.toml").exists():
-        return read_config_from_toml(Path("./entangled.toml"))
-    if Path("./pyproject.toml").exists():
+def read_config(fs: AbstractFileCache) -> ConfigUpdate | None:
+    """
+    Read configuration from any of the possible hard-coded locations:
+
+    - `./entangled.toml`
+    - `./pyproject.toml` section `[tool.entangled]`.
+
+    Returns a `ConfigUpdate` or `None`. To get the full `Config` object,
+    run `Config() | read_config(fs)`.
+    """
+    if Path("./entangled.toml") in fs:
+        return read_config_from_toml(fs, Path("./entangled.toml"))
+    if Path("./pyproject.toml") in fs:
         return (
-            read_config_from_toml(Path("./pyproject.toml"), "tool.entangled")
+            read_config_from_toml(fs, Path("./pyproject.toml"), "tool.entangled")
         )
     return None
 
 
-def get_input_files(cfg: Config) -> list[Path]:
+def get_input_files(fs: AbstractFileCache, cfg: Config) -> list[Path]:
+    """
+    Get a sorted list of all input files for this project.
+    """
     log.debug("watch list: %s; ignoring: %s", cfg.watch_list, cfg.ignore_list)
-    include_file_list = chain.from_iterable(map(Path(".").glob, cfg.watch_list))
-    input_file_list = [
-        path for path in include_file_list
-        if not any(path.match(pat) for pat in cfg.ignore_list) and path.is_file()
-    ]
+    input_file_list = sorted(filter(
+        lambda p: not any(p.match(pat) for pat in cfg.ignore_list),
+        chain.from_iterable(map(fs.glob, cfg.watch_list))))
     log.debug("input file list %s", input_file_list)
-    return sorted(input_file_list)
+    return input_file_list
 
 
 __all__ = ["Config", "ConfigUpdate", "AnnotationMethod", "Markers", "NamespaceDefault"]

{entangled_cli-2.4.0 → entangled_cli-2.4.3}/entangled/hooks/__init__.py

@@ -25,14 +25,15 @@ hooks: dict[str, type[HookBase]] = {
 } | external_hooks
 
 
-def create_hook(cfg: Config, h: str) -> HookBase | None:
+def create_hook(cfg: Config, h: str, state: HookBase.State) -> HookBase | None:
     if h not in hooks:
         logging.error("hook `%s` not found", h)
         return None
 
     try:
-        hook_cfg = msgspec.convert(cfg.hook.get(h, {}), type=hooks[h].Config)
-        hook_instance = hooks[h](hook_cfg)
+        hook_cls = hooks[h]
+        hook_cfg = msgspec.convert(cfg.hook.get(h, {}), type=hook_cls.Config)
+        hook_instance = hook_cls(hook_cfg, state)
         hook_instance.check_prerequisites()
         return hook_instance
     except PrerequisitesFailed as e:

{entangled_cli-2.4.0 → entangled_cli-2.4.3}/entangled/hooks/base.py

@@ -19,7 +19,10 @@ class HookBase:
     class Config(Struct):
         pass
 
-    def __init__(self, config: Config):
+    class State:
+        pass
+
+    def __init__(self, config: Config, state: State):
         pass
 
     @staticmethod

{entangled_cli-2.4.0 → entangled_cli-2.4.3}/entangled/hooks/build.py

@@ -6,13 +6,14 @@ directory.
 """
 
 from __future__ import annotations
-from dataclasses import dataclass
-from msgspec import field
+from dataclasses import dataclass, field
 from pathlib import Path, PurePath
 from subprocess import run, SubprocessError, DEVNULL
 import logging
 from typing import final, override
 
+import msgspec
+
 from ..config.language import Language
 from ..io import Transaction
 from ..model.properties import Property, get_attribute, get_attribute_string, get_classes
@@ -45,7 +46,7 @@ EXEC_CMDS = {
 @final
 class Hook(HookBase):
     class Config(HookBase.Config):
-        runners: dict[str, str] = field(default_factory=dict)
+        runners: dict[str, str] = msgspec.field(default_factory=dict)
 
         def __post_init__(self):
             for k, v in EXEC_CMDS.items():
@@ -64,9 +65,13 @@ class Hook(HookBase):
             exec_cmd = config.runners[self.language.name].format(script=self.scriptfile)
             return f"{self.target}: {self.scriptfile} {dep_str}\n" + f"\t{exec_cmd}"
 
-    def __init__(self, config: Hook.Config):
-        super().__init__(config)
-        self.recipes: list[Hook.Recipe] = []
+    @dataclass
+    class State(HookBase.State):
+        recipes: list[Hook.Recipe] = field(default_factory=list)
+
+    def __init__(self, config: Hook.Config, state: Hook.State):
+        super().__init__(config, state)
+        self.recipes: list[Hook.Recipe] = state.recipes
         self.config = config
 
     @override
@@ -108,4 +113,3 @@ class Hook(HookBase):
             rules="\n\n".join(r.to_makefile(self.config) for r in self.recipes),
         )
         t.write(Path(".entangled/build/Makefile"), makefile, [])
-

{entangled_cli-2.4.0 → entangled_cli-2.4.3}/entangled/hooks/quarto_attributes.py

@@ -14,16 +14,27 @@ from ..logging import logger
 
 log = logger()
 
+# Cache for compiled regex patterns (keyed by comment opener)
+_yaml_header_pattern_cache: dict[str, re.Pattern[str]] = {}
+
+
+def _get_yaml_header_pattern(comment_open: str) -> re.Pattern[str]:
+    """Get or create a cached compiled pattern for YAML header matching."""
+    if comment_open not in _yaml_header_pattern_cache:
+        pattern = re.escape(comment_open) + r"\s*\|(.*)"
+        _yaml_header_pattern_cache[comment_open] = re.compile(pattern)
+    return _yaml_header_pattern_cache[comment_open]
+
 
 def split_yaml_header(language: Language, source: str) -> tuple[str, str, object]:
     """Split source into YAML header and body."""
-    trigger: str = re.escape(language.comment.open) + r"\s*\|(.*)"
+    pattern = _get_yaml_header_pattern(language.comment.open)
     lines = source.splitlines(keepends=True)
     header_lines: list[str] = []
     body_start: int = 0
 
     for i, line in enumerate(lines):
-        if m := re.match(trigger, line):
+        if m := pattern.match(line):
             header_lines.append(m.group(1))
             continue
 
@@ -80,8 +91,8 @@ def amend_code_properties(code_block: CodeBlock):
 
 @final
 class Hook(HookBase):
-    def __init__(self, config: Hook.Config):
-        super().__init__(config)
+    def __init__(self, config: Hook.Config, state: Hook.State):
+        super().__init__(config, state)
         self.config = config
 
     @override

{entangled_cli-2.4.0 → entangled_cli-2.4.3}/entangled/hooks/repl.py

@@ -1,3 +1,4 @@
+from dataclasses import dataclass, field
 import json
 from typing import final, override
 
@@ -6,7 +7,7 @@ import msgspec
 from entangled.config.language import Language
 from .base import HookBase
 from repl_session import ReplConfig, ReplSession, ReplCommand
-from msgspec import Struct, field
+from msgspec import Struct
 from pathlib import Path
 
 from ..logging import logger
@@ -34,12 +35,17 @@ def strip_comments(code: str, language: Language) -> str:
 @final
 class Hook(HookBase):
     class Config(HookBase.Config):
-        config: dict[str, ReplConfig] = field(default_factory=dict)
+        config: dict[str, ReplConfig] = msgspec.field(default_factory=dict)
 
-    def __init__(self, config: Config):
-        super().__init__(config)
+    @dataclass
+    class State(HookBase.State):
+        sessions: dict[str, Session] = field(default_factory=dict)
+
+    def __init__(self, config: Config, state: State):
+        super().__init__(config, state)
+        log.debug(f"REPL hook config: {config}")
         self.config = config.config
-        self.sessions: dict[str, Session] = {}
+        self.sessions: dict[str, Session] = state.sessions
 
     @override
     def on_read(self, code: CodeBlock):

{entangled_cli-2.4.0 → entangled_cli-2.4.3}/entangled/hooks/task.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 from collections import defaultdict
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 import json
 from pathlib import Path
 from typing import final, override
@@ -48,12 +48,18 @@ class Hook(HookBase):
                 "path": path
             }
 
-    def __init__(self, config: Hook.Config):
-        super().__init__(config)
-        self.recipes: list[Hook.Recipe] = []
-        self.collections: dict[str, list[str]] = defaultdict(list)
+    @dataclass
+    class State(HookBase.State):
+        recipes: list[Hook.Recipe] = field(default_factory=list)
+        collections: dict[str, list[str]] = field(default_factory=lambda: defaultdict(list))
+        sources: list[Path] = field(default_factory=list)
+
+    def __init__(self, config: Hook.Config, state: Hook.State):
+        super().__init__(config, state)
+        self.recipes: list[Hook.Recipe] = state.recipes
+        self.collections: dict[str, list[str]] = state.collections
         self.config = config
-        self.sources: list[Path] = []
+        self.sources: list[Path] = state.sources
 
     @override
     def pre_tangle(self, refs: ReferenceMap):

{entangled_cli-2.4.0 → entangled_cli-2.4.3}/entangled/interface/context.py

@@ -3,31 +3,39 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from collections.abc import Generator, Iterable
 
+from ..io import AbstractFileCache, FileCache
 from ..config import Config, ConfigUpdate
-from ..hooks import HookBase, create_hook
+from ..hooks import HookBase, hooks, create_hook
 from ..model import Content, ReferenceMap
 from ..readers.yaml_header import get_config
 from ..readers import read_yaml_header, process_token, collect_plain_text, raw_markdown, InputStream, run_reader
 
 from functools import partial
-import logging
+from ..logging import logger
+
+log = logger()
 
 @dataclass
 class Context:
+    fs: AbstractFileCache = field(default_factory=FileCache)
     config: Config = Config()
+    _hook_states: dict[str, HookBase.State] = field(default_factory=dict)
     _hooks: dict[str, HookBase] = field(default_factory=dict)
-    
+
     def __post_init__(self):
+        log.debug(f"context: hook config: {self.config.hook}")
         for h in self.config.hooks:
-            if h not in self._hooks:
-                logging.debug("context: loading hook %s", h)
-                hook = create_hook(self.config, h)
-                if hook is None:
-                    continue
-                self._hooks[h] = hook
+            if h not in self._hook_states:
+                self._hook_states[h] = hooks[h].State()
+
+            log.debug("context: loading hook %s", h)
+            hook = create_hook(self.config, h, self._hook_states[h])
+            if hook is None:
+                continue
+            self._hooks[h] = hook
 
     def __or__(self, update: ConfigUpdate | None) -> Context:
-        return Context(self.config | update, self._hooks)
+        return Context(self.fs, self.config | update, self._hook_states)
 
     @property
     def hooks(self) -> list[HookBase]:
@@ -53,4 +61,3 @@ def markdown(context: Context, refs: ReferenceMap, input: InputStream) -> Genera
 
 def read_markdown(context: Context, refs: ReferenceMap, input: str) -> tuple[list[Content], ConfigUpdate | None]:
     return run_reader(partial(markdown, context, refs), input)
-