entangled-cli 2.0.4__tar.gz → 2.1.0__tar.gz

{entangled_cli-2.0.4 → entangled_cli-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: entangled-cli
-Version: 2.0.4
+Version: 2.1.0
 Summary: Literate Programming toolbox
 Home-page: https://entangled.github.io/
 License: Apache 2
@@ -17,6 +17,7 @@ Requires-Dist: copier (>=9,<10)
 Requires-Dist: filelock (>=3.12.0,<4.0.0)
 Requires-Dist: mawk (>=0.1.4,<0.2.0)
 Requires-Dist: pexpect (>=4.9.0,<5.0.0)
+Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
 Requires-Dist: rich (>=13.3.5,<14.0.0)
 Requires-Dist: rich-argparse (>=1.4.0,<2.0.0)
 Requires-Dist: tomlkit (>=0.12.1,<0.13.0)
@@ -58,9 +59,6 @@ pip install entangled-cli
 ```
 
 ## Use
-
-> :warning: **This version of Entangled is still in beta.** In general things are working as they should, but there may still be some rough edges in the user experience.
-
 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:
 
 ~~~markdown
@@ -171,9 +169,10 @@ Entangled has a system of *hooks*: these add actions to the tangling process:
 
 - `build` trigger actions in a generated `Makefile`
 - `brei` trigger actions (or tasks) using [Brei](https://entangled.github.io/brei), which is automatically installed along with Entangled. This is now prefered over the `build` hook.
-- `quatro_attributes` add attributes to the code block in Quatro style with `#|` comments at the top of the code block.
+- `quarto_attributes` add attributes to the code block in Quatro style with `#|` comments at the top of the code block.
+- `shebang` takes the first line if it starts with `#!` and puts it at the top of the file.
 
-## `build` hook
+### `build` hook
 You can enable this hook in `entangled.toml`:
 
 ```toml
@@ -259,6 +258,34 @@ plt.savefig("docs/fig/triangle.svg")
 ![](fig/triangle.svg)
 ~~~
 
+Using these attributes it is possible to write in Entangled using completely standard Markdown syntax. The following configuration disables the curly braces alltogether, though currently the quarto tags encoding the meta-data will end-up in the tangled code.
+
+```toml
+#| file: entangled.toml
+version="2.0"
+watch_list=["*.typ"]
+hooks=["quarto_attributes"]
+
+[markers]
+open="^(?P<indent>\\s*)```(?P<properties>.*)$"
+close="^(?P<indent>\\s*)```\\s*$"
+```
+
+Then you can write code like so:
+
+~~~markdown
+```python
+#| id: hello
+print("Hello, World!")
+```
+
+```python
+#| file: test.py
+if __name__ == "__main__":
+    <<hello>>
+```
+~~~
+
 ## Brei
 Entangled has a small build engine (similar to GNU Make) embedded, called Brei. You may give it a list of tasks (specified in TOML) that may depend on one another. Brei will run these when dependencies are newer than the target. Execution is lazy and in parallel. Brei supports:
 
@@ -389,6 +416,19 @@ Example: [Hello World in C++](https://entangled.github.io/examples/hello-world.h
 
 Example: TBD
 
+### Typst
+[Typst](https://typst.app/) has a syntax that is similar to Markdown when it comes to code blocks. Set the code block markers in `entangled.toml` like so:
+
+```toml
+version="2.0"
+watch_list=["*.typ"]
+hooks=["quarto_attributes"]
+
+[markers]
+open="^(?P<indent>\\s*)```(?P<properties>.*)$"
+close="^(?P<indent>\\s*)```\\s*$"
+```
+
 ### Documenter.jl
 [Documenter.jl]() is the standard tool to write Julia documention in. It has internal support for evaluating code block contents.
 

{entangled_cli-2.0.4 → entangled_cli-2.1.0}/README.md

@@ -32,9 +32,6 @@ pip install entangled-cli
 ```
 
 ## Use
-
-> :warning: **This version of Entangled is still in beta.** In general things are working as they should, but there may still be some rough edges in the user experience.
-
 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:
 
 ~~~markdown
@@ -145,9 +142,10 @@ Entangled has a system of *hooks*: these add actions to the tangling process:
 
 - `build` trigger actions in a generated `Makefile`
 - `brei` trigger actions (or tasks) using [Brei](https://entangled.github.io/brei), which is automatically installed along with Entangled. This is now prefered over the `build` hook.
-- `quatro_attributes` add attributes to the code block in Quatro style with `#|` comments at the top of the code block.
+- `quarto_attributes` add attributes to the code block in Quatro style with `#|` comments at the top of the code block.
+- `shebang` takes the first line if it starts with `#!` and puts it at the top of the file.
 
-## `build` hook
+### `build` hook
 You can enable this hook in `entangled.toml`:
 
 ```toml
@@ -233,6 +231,34 @@ plt.savefig("docs/fig/triangle.svg")
 ![](fig/triangle.svg)
 ~~~
 
+Using these attributes it is possible to write in Entangled using completely standard Markdown syntax. The following configuration disables the curly braces alltogether, though currently the quarto tags encoding the meta-data will end-up in the tangled code.
+
+```toml
+#| file: entangled.toml
+version="2.0"
+watch_list=["*.typ"]
+hooks=["quarto_attributes"]
+
+[markers]
+open="^(?P<indent>\\s*)```(?P<properties>.*)$"
+close="^(?P<indent>\\s*)```\\s*$"
+```
+
+Then you can write code like so:
+
+~~~markdown
+```python
+#| id: hello
+print("Hello, World!")
+```
+
+```python
+#| file: test.py
+if __name__ == "__main__":
+    <<hello>>
+```
+~~~
+
 ## Brei
 Entangled has a small build engine (similar to GNU Make) embedded, called Brei. You may give it a list of tasks (specified in TOML) that may depend on one another. Brei will run these when dependencies are newer than the target. Execution is lazy and in parallel. Brei supports:
 
@@ -363,6 +389,19 @@ Example: [Hello World in C++](https://entangled.github.io/examples/hello-world.h
 
 Example: TBD
 
+### Typst
+[Typst](https://typst.app/) has a syntax that is similar to Markdown when it comes to code blocks. Set the code block markers in `entangled.toml` like so:
+
+```toml
+version="2.0"
+watch_list=["*.typ"]
+hooks=["quarto_attributes"]
+
+[markers]
+open="^(?P<indent>\\s*)```(?P<properties>.*)$"
+close="^(?P<indent>\\s*)```\\s*$"
+```
+
 ### Documenter.jl
 [Documenter.jl]() is the standard tool to write Julia documention in. It has internal support for evaluating code block contents.
 

{entangled_cli-2.0.4 → entangled_cli-2.1.0}/entangled/commands/stitch.py

@@ -29,8 +29,9 @@ def stitch(*, force: bool = False, show: bool = False):
     config.read()
 
     # these imports depend on config being read
-    from ..markdown_reader import MarkdownReader
+    from ..markdown_reader import read_markdown_file
     from ..code_reader import CodeReader
+    from ..hooks import get_hooks
 
     include_file_list = chain.from_iterable(map(Path(".").glob, config.watch_list))
     exclude_file_list = list(
@@ -39,6 +40,7 @@ def stitch(*, force: bool = False, show: bool = False):
     input_file_list = [
         path for path in include_file_list if not path in exclude_file_list
     ]
+    hooks = get_hooks()
 
     if show:
         mode = TransactionMode.SHOW
@@ -52,10 +54,8 @@ def stitch(*, force: bool = False, show: bool = False):
     try:
         for path in input_file_list:
             logging.debug("reading `%s`", path)
-            with open(path, "r") as f:
-                mr = MarkdownReader(str(path), refs)
-                mr.run(f.read())
-                content[path] = mr.content
+            _, c = read_markdown_file(path, refs=refs, hooks=hooks)
+            content[path] = c
 
         with transaction(mode) as t:
             for path in t.db.managed:

{entangled_cli-2.0.4 → entangled_cli-2.1.0}/entangled/commands/tangle.py

@@ -25,7 +25,7 @@ def tangle(*, annotate: Optional[str] = None, force: bool = False, show: bool =
     config.read()
 
     # these imports depend on config being read
-    from ..markdown_reader import MarkdownReader
+    from ..markdown_reader import read_markdown_file
     from ..tangle import tangle_ref
 
     if annotate is None:
@@ -43,6 +43,7 @@ def tangle(*, annotate: Optional[str] = None, force: bool = False, show: bool =
 
     refs = ReferenceMap()
     hooks = get_hooks()
+    logging.debug("tangling with hooks: %s", [h.__module__ for h in hooks])
 
     if show:
         mode = TransactionMode.SHOW
@@ -56,8 +57,7 @@ def tangle(*, annotate: Optional[str] = None, force: bool = False, show: bool =
             for path in input_file_list:
                 logging.debug("reading `%s`", path)
                 t.update(path)
-                with open(path, "r") as f:
-                    MarkdownReader(str(path), refs, hooks).run(f.read())
+                read_markdown_file(path, refs=refs, hooks=hooks)
 
             for h in hooks:
                 h.pre_tangle(refs)

{entangled_cli-2.0.4 → entangled_cli-2.1.0}/entangled/config/__init__.py

@@ -83,11 +83,11 @@ class Config(threading.local):
     languages: list[Language] = field(default_factory=list)
     markers: Markers = field(default_factory=lambda: copy(markers))
     watch_list: list[str] = field(default_factory=lambda: ["**/*.md"])
-    ignore_list: list[str] = field(default_factory=lambda: ["**/README.md"])
+    ignore_list: list[str] = field(default_factory=lambda: ["README.md"])
     annotation_format: Optional[str] = None
     annotation: AnnotationMethod = AnnotationMethod.STANDARD
     use_line_directives: bool = False
-    hooks: list[str] = field(default_factory=list)
+    hooks: list[str] = field(default_factory=lambda: ["shebang"])
     hook: dict = field(default_factory=dict)
     brei: Program = field(default_factory=Program)
 

{entangled_cli-2.0.4 → entangled_cli-2.1.0}/entangled/document.py

@@ -29,18 +29,19 @@ class PlainText:
     content: str
 
 
-Content = Union[PlainText, ReferenceId]
-
-
 @dataclass
 class CodeBlock:
-    language: Language
     properties: list[Property]
     indent: str
-    header: Optional[str]
     source: str
     origin: TextLocation
-    mode: Optional[int]
+    language: Optional[Language] = None
+    header: Optional[str] = None
+    mode: Optional[int] = None
+
+
+Content = Union[PlainText, ReferenceId]
+RawContent = Union[PlainText, CodeBlock]
 
 
 @dataclass
@@ -57,11 +58,17 @@ class ReferenceMap:
         default_factory=lambda: defaultdict(list)
     )
     targets: set[str] = field(default_factory=set)
+    alias: dict[str, str] = field(default_factory=dict)
 
     def names(self) -> Iterable[str]:
         return self.index.keys()
 
     def by_name(self, n: str) -> Iterable[CodeBlock]:
+        if n not in self.index and n not in self.alias:
+            raise AttributeError(name=n, obj=self)
+        if n not in self.index:
+            return self.by_name(self.alias[n])
+
         return (self.map[r] for r in self.index[n])
 
     def new_id(self, filename: str, name: str) -> ReferenceId:

{entangled_cli-2.0.4 → entangled_cli-2.1.0}/entangled/hooks/__init__.py

@@ -2,11 +2,14 @@ import logging
 from importlib.metadata import entry_points
 
 from .base import HookBase, PrerequisitesFailed
-from . import build, task, quarto_attributes
+from . import build, task, quarto_attributes, shebang
 from ..config import config
 from ..construct import construct
+from typing import TypeVar
 
 
+AbstractHook = TypeVar('AbstractHook', bound=HookBase)
+
 discovered_hooks = entry_points(group="entangled.hooks")
 
 
@@ -18,6 +21,7 @@ external_hooks = {
 hooks: dict[str, type[HookBase]] = {
     "build": build.Hook,
     "brei": task.Hook,
+    "shebang": shebang.Hook,
     "quarto_attributes": quarto_attributes.Hook }
 
 
@@ -37,4 +41,4 @@ def get_hooks() -> list[HookBase]:
     return active_hooks
 
 
-__all__ = ["hooks", "PrerequisitesFailed"]
+__all__ = ["hooks", "PrerequisitesFailed", "get_hooks"]

{entangled_cli-2.0.4 → entangled_cli-2.1.0}/entangled/hooks/base.py

@@ -15,6 +15,7 @@ class PrerequisitesFailed(Exception):
 
 
 class HookBase:
+    @dataclass
     class Config:
         pass
 
@@ -25,13 +26,8 @@ class HookBase:
         """When prerequisites aren't met, raise PrerequisitesFailed."""
         return
 
-    def condition(self, props: list[Property]):
-        """Condition upon which the `on_read` is triggered. Maybe a bit superfluous
-        could be removed in the future."""
-        return True
-
-    def on_read(self, refs: ReferenceMap, ref: ReferenceId, code: CodeBlock):
-        """Called when the Markdown is being read, during the assembling of
+    def on_read(self, code: CodeBlock):
+        """Called when the Markdown is being read, before the assembling of
         the reference map."""
         pass
 

{entangled_cli-2.0.4 → entangled_cli-2.1.0}/entangled/hooks/build.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from pathlib import Path
 from subprocess import run, SubprocessError, DEVNULL
+import logging
 
 from entangled.config.language import Language
 
@@ -72,29 +73,29 @@ class Hook(HookBase):
         except (SubprocessError, FileNotFoundError):
             raise PrerequisitesFailed("GNU Make needs to be installed")
 
-    def condition(self, props: list[Property]):
-        """Condition by which a CodeBlock is processed: should have `.build` class
-        and `target=` attribute."""
-        return (
-            "build" in get_classes(props) and get_attribute(props, "target") is not None
-        )
-
-    def on_read(self, refs: ReferenceMap, ref: ReferenceId, cb: CodeBlock):
+    def pre_tangle(self, refs: ReferenceMap):
         """Add a CodeBlock's target attribute to the list of targets."""
-        target = get_attribute(cb.properties, "target")
-        if target is None:
-            return
-
-        script_file_name = get_attribute(cb.properties, "file")
-        if script_file_name is None:
-            script_file_name = f".entangled/build/{ref.name}".replace(":", "_")
-            refs.index[script_file_name].append(ref)
-            refs.targets.add(script_file_name)
-
-        deps = (get_attribute(cb.properties, "deps") or "").split()
-        self.recipes.append(Hook.Recipe(target, deps, cb.language, script_file_name))
-
-    def post_tangle(self, _: ReferenceMap):
+        for (ref, cb) in refs.map.items():
+            logging.debug("build hook: passing: %s", ref)
+            if "build" not in get_classes(cb.properties):
+                continue
+            target = get_attribute(cb.properties, "target")
+            if target is None:
+                continue
+            if cb.language is None:
+                continue
+
+            logging.debug("build hook: target: %s", target)
+            script_file_name = get_attribute(cb.properties, "file")
+            if script_file_name is None:
+                script_file_name = f".entangled/build/{ref.name}".replace(":", "_")
+                refs.index[script_file_name].append(ref)
+                refs.targets.add(script_file_name)
+
+            deps = (get_attribute(cb.properties, "deps") or "").split()
+            self.recipes.append(Hook.Recipe(target, deps, cb.language, script_file_name))
+
+    def post_tangle(self, refs: ReferenceMap):
         """After all code is tangled: retrieve the build scripts and run it."""
         targets = " ".join([r.target for r in self.recipes])
         makefile = preamble.format(

entangled_cli-2.1.0/entangled/hooks/quarto_attributes.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from itertools import takewhile
+import yaml
+
+from ..properties import Attribute, Id
+from ..document import ReferenceId, ReferenceMap, CodeBlock
+from .base import HookBase
+from ..logging import logger
+
+
+log = logger()
+
+
+class Hook(HookBase):
+    @dataclass
+    class Config(HookBase.Config):
+        pass
+
+    def __init__(self, config: Hook.Config):
+        self.config = config
+
+    def on_read(self, code: CodeBlock):
+        log.debug(f"quarto filter: %s", code)
+
+        if code.language is None:
+            return
+
+        trigger = f"{code.language.comment.open}|"
+        header = "\n".join(
+            line[len(trigger):] for line in code.source.splitlines()
+            if line.startswith(trigger))
+
+        attrs = yaml.safe_load(header)
+        if "id" in attrs:
+            code.properties.append(Id(attrs["id"]))
+        code.properties.extend(Attribute(k, v) for k, v in attrs.items())
+
+        log.debug(f"quarto attributes: {attrs}")

entangled_cli-2.1.0/entangled/hooks/shebang.py

@@ -0,0 +1,10 @@
+from ..document import CodeBlock
+from .base import HookBase
+
+
+class Hook(HookBase):
+    def on_read(self, code: CodeBlock):
+        lines = code.source.splitlines()
+        if lines[0].startswith("#!"):
+            code.header = lines[0]
+            code.source = "\n".join(lines[1:])

{entangled_cli-2.0.4 → entangled_cli-2.1.0}/entangled/hooks/task.py

@@ -56,41 +56,40 @@ class Hook(HookBase):
         self.config = config
         self.sources: list[Path] = []
 
-    def condition(self, props: list[Property]):
-        return (
-            "task" in get_classes(props)
-        )
+    def pre_tangle(self, refs: ReferenceMap):
+        for ref, cb in refs.map.items():
+            if "task" not in get_classes(cb.properties):
+                continue
 
-    def on_read(self, refs: ReferenceMap, ref: ReferenceId, cb: CodeBlock):
-        self.sources.append(Path(ref.file))
+            self.sources.append(Path(ref.file))
 
-        match cb.properties[0]:
-            case Class("task"):
-                runner = None
-            case Class(lang_id):
-                runner = lang_id
-            case _:
-                return
+            match cb.properties[0]:
+                case Class("task"):
+                    runner = None
+                case Class(lang_id):
+                    runner = lang_id
+                case _:
+                    continue
 
-        record: dict[str, Any] = {
-            f.name: get_attribute(cb.properties, f.name)
-            for f in fields(Hook.Recipe)
-        }
+            record: dict[str, Any] = {
+                f.name: get_attribute(cb.properties, f.name)
+                for f in fields(Hook.Recipe)
+            }
+
+            record["runner"] = record["runner"] or runner
+            record["creates"] = record["creates"].split() if record["creates"] else None
+            record["requires"] = record["requires"].split() if record["requires"] else None
+            record["ref"] = ref
 
-        record["runner"] = record["runner"] or runner
-        record["creates"] = record["creates"].split() if record["creates"] else None
-        record["requires"] = record["requires"].split() if record["requires"] else None
-        record["ref"] = ref
+            log.debug(f"task: {record}")
+            recipe = Hook.Recipe(**record)
+            self.recipes.append(recipe)
+            if recipe.collect:
+                targets = recipe.creates or []
+                if recipe.stdout:
+                    targets.append(recipe.stdout)
+                self.collections[recipe.collect].extend(targets)
 
-        log.debug(f"task: {record}")
-        recipe = Hook.Recipe(**record)
-        self.recipes.append(recipe)
-        if recipe.collect:
-            targets = recipe.creates or []
-            if recipe.stdout:
-                targets.append(recipe.stdout)
-            self.collections[recipe.collect].extend(targets)
-    
     def on_tangle(self, t: Transaction, refs: ReferenceMap):
         collect = [{
             "name": k,
@@ -100,4 +99,3 @@ class Hook(HookBase):
                 "task": [r.to_brei_task(refs) for r in self.recipes] + collect
             }, indent=2)
         t.write(Path(".entangled/tasks.json"), content, self.sources, mode=0o444)
-

{entangled_cli-2.0.4 → entangled_cli-2.1.0}/entangled/markdown_reader.py

@@ -8,35 +8,28 @@ import logging
 
 from .config import config
 from .utility import first
-from .document import TextLocation, CodeBlock, ReferenceMap, Content, PlainText
+from .document import TextLocation, CodeBlock, ReferenceMap, Content, PlainText, RawContent
 from .properties import read_properties, get_attribute, get_classes, get_id
 from .hooks.base import HookBase
 from .errors.user import ParseError, IndentationError
 from . import parsing
 
 
-class MarkdownReader(mawk.RuleSet):
+class MarkdownLexer(mawk.RuleSet):
     """Reads a Markdown file, and splits it up into code blocks and other
-    content. The contents of the code blocks get stored in `reference_map`.
-    """
-
+    content."""
     def __init__(
         self,
-        filename: str,
-        refs: Optional[ReferenceMap] = None,
-        hooks: Optional[list[HookBase]] = None,
+        filename: str
     ):
         self.location = TextLocation(filename)
-        self.reference_map = refs or ReferenceMap()
-        self.content: list[Content] = []
+        self.raw_content: list[RawContent] = []
         self.inside_codeblock: bool = False
         self.current_content: list[str] = []
-        self.current_header: list[str] = []
         self.ignore = False
-        self.hooks = hooks or []
 
     def flush_plain_text(self):
-        self.content.append(PlainText("\n".join(self.current_content)))
+        self.raw_content.append(PlainText("\n".join(self.current_content)))
         self.current_content = []
 
     @mawk.always
@@ -59,11 +52,13 @@ class MarkdownReader(mawk.RuleSet):
             return None
         if self.inside_codeblock:
             return None
+        logging.debug("triggered on codeblock: %s", m.group(0))
         self.current_codeblock_indent = m["indent"]
         self.current_codeblock_location = copy(self.location)
         self.current_content.append(m[0])
         try:
             self.current_codeblock_properties = read_properties(m["properties"])
+            logging.debug("properties: %s", self.current_codeblock_properties)
             self.flush_plain_text()
             self.inside_codeblock = True
         except parsing.Failure as f:
@@ -84,69 +79,32 @@ class MarkdownReader(mawk.RuleSet):
         if m["indent"] != self.current_codeblock_indent:
             return  # treat this as code-block content
 
-        # add block to reference-map
         language_class = first(get_classes(self.current_codeblock_properties))
-        block_id = get_id(self.current_codeblock_properties)
-        target_file = get_attribute(self.current_codeblock_properties, "file")
         language = config.get_language(language_class) if language_class else None
-
         if language_class and not language:
             logging.warning(f"Language `{language_class}` unknown at `{self.location}`.")
 
-        header = (
-            "\n".join(
-                line.removeprefix(self.current_codeblock_indent)
-                for line in self.current_header
-            )
-            if self.current_header
-            else None
-        )
+
         content = "\n".join(
             line.removeprefix(self.current_codeblock_indent)
             for line in self.current_content
         )
 
-        ref_name = block_id or target_file
-        if ref_name is None:
-            ref_name = f"unnamed-{self.location}"
+        code = CodeBlock(
+            self.current_codeblock_properties,
+            self.current_codeblock_indent,
+            content,
+            self.current_codeblock_location,
+            language
+        )
 
-        if language is None:
-            self.flush_plain_text()
-        else:
-            ref = self.reference_map.new_id(
-                self.current_codeblock_location.filename, ref_name
-            )
-            mode = get_attribute(self.current_codeblock_properties, "mode")
-            code = CodeBlock(
-                language,
-                self.current_codeblock_properties,
-                self.current_codeblock_indent,
-                header,
-                content,
-                self.current_codeblock_location,
-                int(mode, 8) if mode else None
-            )
-            # logging.debug(repr(code))
-            self.reference_map[ref] = code
-            if target_file is not None:
-                self.reference_map.targets.add(target_file)
-            self.content.append(ref)
-            self.current_content = []
-
-            for h in self.hooks:
-                if h.condition(self.current_codeblock_properties):
-                    h.on_read(self.reference_map, ref, code)
+        self.raw_content.append(code)
+        self.current_content = []
 
         self.current_content.append(m[0])
         self.inside_codeblock = False
         return []
 
-    @mawk.on_match(r"^\s*#!.*$")
-    def on_shebang(self, m: re.Match):
-        if self.inside_codeblock and not self.current_content:
-            self.current_header.append(m[0])
-            return []
-
     @mawk.always
     def add_line(self, line: str):
         self.current_content.append(line)
@@ -157,9 +115,54 @@ class MarkdownReader(mawk.RuleSet):
         return []
 
 
-def read_markdown(path: Path) -> tuple[ReferenceMap, list[Content]]:
+def read_markdown_file(
+    path: Path,
+    refs: ReferenceMap | None = None,
+    hooks: list[HookBase] | None = None) \
+    -> tuple[ReferenceMap, list[Content]]:
+
     with open(path, "r") as f:
         path_str = str(path.resolve().relative_to(Path.cwd()))
-        md = MarkdownReader(path_str)
-        md.run(f.read())
-    return md.reference_map, md.content
+        return read_markdown_string(f.read(), path_str, refs, hooks)
+
+
+def read_markdown_string(
+        text: str,
+        path_str: str = "-",
+        refs: ReferenceMap | None = None,
+        hooks: list[HookBase] | None = None) \
+        -> tuple[ReferenceMap, list[Content]]:
+    md = MarkdownLexer(path_str)
+    md.run(text)
+
+    hooks = hooks if hooks is not None else []
+    refs = refs if refs is not None else ReferenceMap()
+
+    def process(r: RawContent) -> Content:
+        match r:
+            case CodeBlock():
+                for h in hooks: h.on_read(r)
+                block_id = get_id(r.properties)
+                target_file = get_attribute(r.properties, "file")
+
+                if mode := get_attribute(r.properties, "mode"):
+                    r.mode = int(mode, 8)
+
+                ref_name = block_id or target_file
+                if ref_name is None:
+                    ref_name = f"unnamed-{r.origin}"
+                ref = refs.new_id(r.origin.filename, ref_name)
+
+                refs[ref] = r
+                if target_file is not None:
+                    refs.targets.add(target_file)
+                if target_file is not None and block_id is not None:
+                    refs.alias[target_file] = block_id
+
+                return ref
+
+            case PlainText(): return r
+
+    content = list(map(process, md.raw_content))
+    logging.debug("found ids: %s", list(refs.map.keys()))
+    return refs, content

{entangled_cli-2.0.4 → entangled_cli-2.1.0}/entangled/properties.py

@@ -35,7 +35,7 @@ class Id(Parsable):
 @dataclass
 class Class(Parsable):
     value: str
-    _pattern: ClassVar[Parser] = matching(r"\.([a-zA-Z]\S*)")
+    _pattern: ClassVar[Parser] = matching(r"\.?([a-zA-Z]\S*)")
 
     def __str__(self):
         return f".{self.value}"
@@ -74,7 +74,7 @@ def read_properties(inp: str) -> list[Property]:
     """
     # Explicit typing is needed to convince MyPy of correctness
     # parsers: list[Parser[Property]] = [Id, Class, Attribute]
-    result, _ = many(tokenize(choice(Id, Class, Attribute))).read(inp)
+    result, _ = many(tokenize(choice(Id, Attribute, Class))).read(inp)
     return result
 
 

{entangled_cli-2.0.4 → entangled_cli-2.1.0}/entangled/tangle.py

@@ -119,6 +119,9 @@ def tangle_ref(
     if annotation is None:
         annotation = config.annotation
 
+    if ref_name in refs.alias:
+        ref_name = refs.alias[ref_name]
+
     if ref_name not in refs:
         raise KeyError(ref_name)
     v = _visited or Visitor()

{entangled_cli-2.0.4 → entangled_cli-2.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "entangled-cli"
-version = "2.0.4"
+version = "2.1.0"
 description = "Literate Programming toolbox"
 repository = "https://github.com/entangled/entangled.py"
 homepage = "https://entangled.github.io/"
@@ -21,6 +21,7 @@ copier = "^9"            # project templates
 brei = "^0.2.3"          # build system
 rich-argparse = "^1.4.0" # colourful help messages
 pexpect = "^4.9.0"
+pyyaml = "^6.0.1"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.3.1"
@@ -33,6 +34,9 @@ mkdocstrings = { extras = ["python"], version = "^0.21.2" }
 twine = "^4.0.2"
 pytest-asyncio = "^0.21.1"
 ruff = "^0.4.4"
+types-pyyaml = "^6.0.12.20240311"
+types-pygments = "^2.18.0.20240506"
+types-colorama = "^0.4.15.20240311"
 
 [build-system]
 requires = ["poetry-core"]
@@ -43,7 +47,6 @@ testpaths = ["test"]
 
 [tool.mypy]
 packages = ["entangled"]
-enable_incomplete_feature = ["TypeVarTuple"]
 
 [tool.poetry.scripts]
 entangled = "entangled.main:cli"

entangled_cli-2.0.4/entangled/hooks/quarto_attributes.py

@@ -1,28 +0,0 @@
-from __future__ import annotations
-from dataclasses import dataclass
-from itertools import takewhile
-
-from ..properties import Attribute
-from ..document import ReferenceId, ReferenceMap, CodeBlock
-from .base import HookBase
-from ..logging import logger
-
-
-log = logger()
-
-
-class Hook(HookBase):
-    @dataclass
-    class Config(HookBase.Config):
-        pass
-
-    def __init__(self, config: Hook.Config):
-        self.config = config
-
-    def on_read(self, refs: ReferenceMap, ref: ReferenceId, cb: CodeBlock):
-        trigger = f"{cb.language.comment.open}|"
-        header = (line[len(trigger):] for line in cb.source.splitlines() if line.startswith(trigger))
-        attrs = [Attribute(k.strip(), v.strip()) for k, v in map(lambda line: line.split(":"), header)]
-        cb.properties.extend(attrs)
-        log.debug(f"quarto attrs on {ref}: {attrs}")
-