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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entangled-cli
-Version: 2.4.2
+Version: 2.4.3
 Summary: Literate Programming toolbox
 Project-URL: Homepage, https://entangled.github.io/
 Project-URL: Repository, https://github.com/entangled/entangled.py
@@ -58,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.2 → 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.2 → entangled_cli-2.4.3}/entangled/commands/watch.py

@@ -6,6 +6,7 @@ from ..logging import logger
 
 from .sync import run_sync
 from .main import main
+from ..errors.user import UserError
 
 import watchfiles
 
@@ -38,7 +39,10 @@ def _watch(_stop_event: Event | None = None, _start_event: Event | None = None):
 
     for changes in watchfiles.watch(dirs, stop_event=_stop_event, watch_filter=watch_filter):
         log.debug(changes)
-        run_sync()
+        try:
+            run_sync()
+        except UserError as e:
+            logger().error(e, exc_info=False)
 
 
 @main.command()

{entangled_cli-2.4.2 → 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
 

{entangled_cli-2.4.2 → entangled_cli-2.4.3}/entangled/interface/document.py

@@ -35,14 +35,15 @@ class Document:
         return get_input_files(self.context.fs, self.config)
 
     def source_text(self, path: Path) -> tuple[str, set[PurePath]]:
-        deps = set()
-        text = ""
+        deps: set[PurePath] = set()
+        # Use list for O(n) instead of O(n²) string concatenation
+        text_parts: list[str] = []
         for content in self.content[path]:
             t, d = content_to_text(self.reference_map, content)
             if d is not None:
                 deps.add(d)
-            text += t
-        return text, deps
+            text_parts.append(t)
+        return "".join(text_parts), deps
 
     def target_text(self, path: PurePath) -> tuple[str, set[PurePath]]:
         ref_name = self.reference_map.select_by_target(path)

{entangled_cli-2.4.2 → entangled_cli-2.4.3}/entangled/io/filedb.py

@@ -50,8 +50,11 @@ class FileDB(Struct):
         return {Path(p) for p in self.targets}
 
     def changed_files(self, fs: AbstractFileCache) -> Generator[Path]:
+        # A tracked file that no longer exists (e.g. a source that was moved or
+        # deleted) counts as changed. Without this guard `fs[Path(p)]` would
+        # raise `FileNotFoundError` and crash, see issue #88.
         return (Path(p) for p, known_stat in self.files.items()
-                if fs[Path(p)].stat != known_stat)
+                if Path(p) not in fs or fs[Path(p)].stat != known_stat)
 
     def create_target(self, fs: AbstractFileCache, path: Path):
         if path.is_absolute():

{entangled_cli-2.4.2 → entangled_cli-2.4.3}/entangled/io/transaction.py

@@ -93,12 +93,15 @@ class Write(WriterBase):
     def conflict(self, fs: AbstractFileCache, db: FileDB) -> Conflict | None:
         if self.target not in fs:
             return None
+        # If the file on disk matches the filedb record, it is exactly what
+        # Entangled wrote last time and was not edited outside of Entangled, so
+        # it is safe to overwrite. Comparing against the filedb is more reliable
+        # than comparing modification times against the current set of sources:
+        # the latter gives false positives when the dependency graph changes,
+        # e.g. when a target no longer depends on one of its former sources
+        # (see issue #96).
         if fs[self.target].stat != db[self.target]:
             return Conflict(self.target, "changed outside the control of Entangled")
-        if self.sources:
-            if all(fs[s].stat < fs[self.target].stat for s in self.sources):
-                return Conflict(self.target, "newer than all of its sources: " + ", ".join(
-                    f"`{s}`" for s in set(self.sources)))
         return None
 
     @override

{entangled_cli-2.4.2 → entangled_cli-2.4.3}/entangled/iterators/lines.py

@@ -10,19 +10,16 @@ type InputToken = tuple[TextLocation, str]
 
 
 def lines(text: str) -> Generator[str]:
+    """Iterate over lines in text, preserving newlines."""
     pos = 0
     while (next_pos := text.find("\n", pos)) != -1:
         yield text[pos:next_pos + 1]
         pos = next_pos + 1
-
     yield text[pos:]
 
 
 @peekable
 def numbered_lines(filename: PurePath, text: str) -> Generator[InputToken]:
-    """
-    Iterate the lines in a file. Doesn't strip newlines. Works with both
-    Windows and Unix line endings.
-    """
+    """Iterate the lines in a file. Doesn't strip newlines."""
     for n, line in enumerate(lines(text)):
         yield (TextLocation(filename, n+1), line)

{entangled_cli-2.4.2 → entangled_cli-2.4.3}/entangled/model/tangle.py

@@ -4,7 +4,6 @@ from contextlib import contextmanager
 from pathlib import PurePath
 
 import re
-import os
 from typing import override
 
 
@@ -21,6 +20,10 @@ from .reference_name import ReferenceName
 
 log = logger()
 
+# Pre-compiled regex for reference detection (e.g., "    <<refname>>")
+_REF_PATTERN = re.compile(r"^(?P<indent>\s*)<<(?P<refname>[\w:/_.-]+)>>\s*$")
+
+
 @dataclass
 class CyclicReference(UserError):
     ref_name: str
@@ -89,7 +92,7 @@ def naked_tangler(refs: ReferenceMap) -> Tangler:
 
         with visitor.visit(ref):
             for line in lines(code_block.source):
-                if m := re.match(r"^(?P<indent>\s*)<<(?P<refname>[\w:/_.-]+)>>\s*$", line.rstrip()):
+                if m := _REF_PATTERN.match(line.rstrip()):
                     ref_name = ReferenceName.from_str(m["refname"], code_block.namespace)
                     log.debug(f"tangling reference `{ref_name}`")
                     if not refs.has_name(ref_name):
@@ -146,13 +149,14 @@ def tangle_ref(
         raise KeyError(name)
     tangler = tanglers[annotation](refs)
     deps: set[PurePath] = set()
-    out = ""
-
-    ref_lst = refs.select_by_name(name)
-    for line in tangler(tangler, deps, ref_lst[0], False, True):
-        out += line
-    for ref in ref_lst[1:]:
-        for line in tangler(tangler, deps, ref, False, False):
-            out += line
+
+    def all_lines():
+        ref_lst = refs.select_by_name(name)
+        yield from tangler(tangler, deps, ref_lst[0], False, True)
+        for ref in ref_lst[1:]:
+            yield from tangler(tangler, deps, ref, False, False)
+
+    # Use join for O(n) instead of O(n²) string concatenation
+    out = "".join(all_lines())
 
     return out, deps

{entangled_cli-2.4.2 → entangled_cli-2.4.3}/entangled/parsing.py

@@ -14,6 +14,17 @@ from typing import (
 import re
 
 
+# Cache for compiled regex patterns (avoids re-compilation)
+_pattern_cache: dict[str, re.Pattern[str]] = {}
+
+
+def _cached_pattern(regex: str) -> re.Pattern[str]:
+    """Get or create a cached compiled pattern."""
+    if regex not in _pattern_cache:
+        _pattern_cache[regex] = re.compile(f"^{regex}")
+    return _pattern_cache[regex]
+
+
 @dataclass
 class Failure(Exception):
     """Base class for parser failures."""
@@ -198,7 +209,7 @@ def many[T](p: Parser[T]) -> Parser[list[T]]:
 
 
 def matching(regex: str) -> Parser[tuple[str, ...]]:
-    pattern = re.compile(f"^{regex}")
+    pattern = _cached_pattern(regex)
 
     @parser
     def _matching(inp: str) -> tuple[tuple[str, ...], str]:
@@ -210,7 +221,7 @@ def matching(regex: str) -> Parser[tuple[str, ...]]:
 
 
 def fullmatch(regex: str) -> Parser[str]:
-    pattern = re.compile(f"^{regex}")
+    pattern = _cached_pattern(regex)
 
     @parser
     def _fullmatch(inp: str):

{entangled_cli-2.4.2 → entangled_cli-2.4.3}/entangled/readers/code.py

@@ -17,7 +17,11 @@ class Block:
     content: str
 
 
-OPEN_BLOCK_EXPR = r"^(?P<indent>\s*).* ~/~ begin <<(?P<source>[^#<>]+)#(?P<ref_name>[^#<>]+)>>\[(?P<ref_count>\d+|init)\]"
+# Pre-compile regex patterns at module level (avoid re-compilation on every call)
+_OPEN_BLOCK_PATTERN = re.compile(
+    r"^(?P<indent>\s*).* ~/~ begin <<(?P<source>[^#<>]+)#(?P<ref_name>[^#<>]+)>>\[(?P<ref_count>\d+|init)\]"
+)
+_CLOSE_BLOCK_PATTERN = re.compile(r"^(?P<indent>\s*).* ~/~ end")
 
 
 @dataclass
@@ -28,7 +32,7 @@ class OpenBlockData:
 
 
 def open_block(line: str) -> OpenBlockData | None:
-    if not (m := re.match(OPEN_BLOCK_EXPR, line)):
+    if not (m := _OPEN_BLOCK_PATTERN.match(line)):
         return None
 
     ref_name = ReferenceName.from_str(m["ref_name"])
@@ -38,16 +42,13 @@ def open_block(line: str) -> OpenBlockData | None:
     return OpenBlockData(ReferenceId(ref_name, md_source, ref_count), is_init, m["indent"])
 
 
-CLOSE_BLOCK_EXPR = r"^(?P<indent>\s*).* ~/~ end"
-
-
 @dataclass
 class CloseBlockData:
     indent: str
 
 
 def close_block(line: str) -> CloseBlockData | None:
-    if not (m := re.match(CLOSE_BLOCK_EXPR, line)):
+    if not (m := _CLOSE_BLOCK_PATTERN.match(line)):
         return None
     return CloseBlockData(m["indent"])
 
@@ -76,25 +77,26 @@ def read_block(namespace: tuple[str, ...], indent: str, input: InputStream) -> G
     if block_data.indent < indent:
         raise IndentationError(pos)
 
-    content = ""
+    # Use list for O(n) instead of O(n²) string concatenation
+    content_parts: list[str] = []
     while input:
         line = yield from read_block(block_data.ref.name.namespace, block_data.indent, input)
         if line is not None:
-            content += line
+            content_parts.append(line)
             continue
 
         pos, line = next(input)
         if (close_block_data := close_block(line)) is None:
             if not line.strip():
-                content += line.lstrip(" \t")
+                content_parts.append(line.lstrip(" \t"))
             elif not line.startswith(block_data.indent):
                 raise IndentationError(pos)
             else:
-                content += line.removeprefix(block_data.indent)
+                content_parts.append(line.removeprefix(block_data.indent))
         else:
             if close_block_data.indent != block_data.indent:
                 raise IndentationError(pos)
-            yield Block(block_data.ref, content)
+            yield Block(block_data.ref, "".join(content_parts))
 
             if block_data.is_init:
                 extra_indent = block_data.indent.removeprefix(indent)

{entangled_cli-2.4.2 → entangled_cli-2.4.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "entangled-cli"
-version = "2.4.2"
+version = "2.4.3"
 description = "Literate Programming toolbox"
 authors = [{ name = "Johan Hidding", email = "j.hidding@esciencecenter.nl" }]
 requires-python = ">=3.13,<4"