entangled-cli 2.0.0b2__tar.gz → 2.0.0b5__tar.gz

{entangled_cli-2.0.0b2 → entangled_cli-2.0.0b5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: entangled-cli
-Version: 2.0.0b2
+Version: 2.0.0b5
 Summary: Literate Programming toolbox
 Home-page: https://entangled.github.io/
 License: Apache 2
@@ -10,11 +10,10 @@ Requires-Python: >=3.11,<4.0
 Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
-Provides-Extra: rich
 Requires-Dist: argh (>=0.28.1,<0.29.0)
 Requires-Dist: filelock (>=3.12.0,<4.0.0)
 Requires-Dist: mawk (>=0.1.4,<0.2.0)
-Requires-Dist: rich (>=13.3.5,<14.0.0) ; extra == "rich"
+Requires-Dist: rich (>=13.3.5,<14.0.0)
 Requires-Dist: watchdog (>=3.0.0,<4.0.0)
 Project-URL: Repository, https://github.com/entangled/entangled.py
 Description-Content-Type: text/markdown
@@ -148,6 +147,11 @@ And so on...
 ~~~
 
 ### Using the `build` hook
+
+:::warning
+The `build` hook has changed from version 2.0.0b3 to 2.0.0b4; Previously you would have to enter Makefile code yourself. Now, `target` and `deps` are specified as attributes to the codeblock, and the Makefile is generated for you. This means less features, but also a simpler interface that may be backed by other build systems than Make.
+:::
+
 Entangled has a system of *hooks*, of which there exists currently only one: `build`. You can enable this hook in `entangled.toml`:
 
 ```toml
@@ -156,30 +160,34 @@ watch_list = ["docs/**/*.md"]
 hooks = ["build"]
 ```
 
-Then in your Markdown, you may enter Make code tagged with the `#build` id.
+Then in your Markdown, you may enter code tagged with the `.build` tag.
 
 ~~~markdown
-``` {.make #build target=docs/fig/plot.svg}
-docs/fig/plot.svg: src/plot.gnuplot
-> gnuplot $< > $@
+``` {.python .build target=docs/fig/plot.svg}
+from matplotlib import pyplot as plt
+import numpy as np
+
+x = np.linspace(-np.pi, np.pi, 100)
+y = np.sin(x)
+plt.plot(x, y)
+plt.savefig("docs/fig/plot.svg")
 ```
 ~~~
 
-Here, `$<` is the Make variable for the first dependency, and `$@` is the Make variable for the target. So, running this through `make` will create `plot.svg` if it doesn't exist yet or if it is older than `plot.gnuplot`.
+This code will be saved into a Python script in the `.entangled/build` directory, or if you specify the `file=` attribute some other location. Second, a `Makefile` is generated in `.entangled/build`, that can be invoked as,
 
-Entangled adds a preamble to `#build`,
-
-```make
-.RECIPEPREFIX = >
-.PHONY = all
+```shell
+make -f .entangled/build/Makefile
+```
 
-all: {targets}
+You may configure how code from different languages is evaluated in `entangled.toml`. For example, to add Gnuplot support, and also make Julia code run through `DaemonMode.jl`, you may do the following:
 
-{rules}
+```toml
+[hook.build.runners]
+Gnuplot = "gnuplot {script}"
+Julia = "julia --project=. --startup-file=no -e 'using DaemonMode; runargs()' {script}"
 ```
 
-changing the prefix from `TAB` to `>` (you really want this), and collecting all `target=...` attributes into the `all` target.
-
 Once you have the code in place to generate figures and markdown tables, you can use the syntax at your disposal to include those into your Markdown. In this example that would be
 
 ~~~markdown
@@ -188,6 +196,29 @@ Once you have the code in place to generate figures and markdown tables, you can
 
 In the case of tables or other rich content, Standard Markdown (or CommonMark) has no syntax for including other Markdown files, so you'll have to check with your own document generator how to do that. In MkDocs, you could use `mkdocs-macro-plugin`, Pandoc has `pandoc-include`, etc.
 
+You can also specify intermediate data generation like so:
+
+~~~markdown
+``` {.python .build target="data/result.csv"}
+import numpy as np
+import pandas as pd
+
+result = np.random.normal(0.0, 1.0, (100, 2))
+df = pd.DataFrame(result, columns=["x", "y"])
+df.to_csv("data/result.csv")
+```
+
+``` {.python .build target="fig/plot.svg" deps="data/result.csv"}
+import pandas as pd
+
+df = pd.read_csv("data/result.csv")
+plot = df.plot()
+plot.savefig("fig/plot.svg")
+```
+~~~
+
+The snippet for generating the data is given as a dependency for that data; to generate the figure, both `result.csv` and the code snippet are dependencies.
+
 #### Ideas for other hooks
 
 > A: Did you hack it together?

{entangled_cli-2.0.0b2 → entangled_cli-2.0.0b5}/README.md

@@ -127,6 +127,11 @@ And so on...
 ~~~
 
 ### Using the `build` hook
+
+:::warning
+The `build` hook has changed from version 2.0.0b3 to 2.0.0b4; Previously you would have to enter Makefile code yourself. Now, `target` and `deps` are specified as attributes to the codeblock, and the Makefile is generated for you. This means less features, but also a simpler interface that may be backed by other build systems than Make.
+:::
+
 Entangled has a system of *hooks*, of which there exists currently only one: `build`. You can enable this hook in `entangled.toml`:
 
 ```toml
@@ -135,30 +140,34 @@ watch_list = ["docs/**/*.md"]
 hooks = ["build"]
 ```
 
-Then in your Markdown, you may enter Make code tagged with the `#build` id.
+Then in your Markdown, you may enter code tagged with the `.build` tag.
 
 ~~~markdown
-``` {.make #build target=docs/fig/plot.svg}
-docs/fig/plot.svg: src/plot.gnuplot
-> gnuplot $< > $@
+``` {.python .build target=docs/fig/plot.svg}
+from matplotlib import pyplot as plt
+import numpy as np
+
+x = np.linspace(-np.pi, np.pi, 100)
+y = np.sin(x)
+plt.plot(x, y)
+plt.savefig("docs/fig/plot.svg")
 ```
 ~~~
 
-Here, `$<` is the Make variable for the first dependency, and `$@` is the Make variable for the target. So, running this through `make` will create `plot.svg` if it doesn't exist yet or if it is older than `plot.gnuplot`.
+This code will be saved into a Python script in the `.entangled/build` directory, or if you specify the `file=` attribute some other location. Second, a `Makefile` is generated in `.entangled/build`, that can be invoked as,
 
-Entangled adds a preamble to `#build`,
-
-```make
-.RECIPEPREFIX = >
-.PHONY = all
+```shell
+make -f .entangled/build/Makefile
+```
 
-all: {targets}
+You may configure how code from different languages is evaluated in `entangled.toml`. For example, to add Gnuplot support, and also make Julia code run through `DaemonMode.jl`, you may do the following:
 
-{rules}
+```toml
+[hook.build.runners]
+Gnuplot = "gnuplot {script}"
+Julia = "julia --project=. --startup-file=no -e 'using DaemonMode; runargs()' {script}"
 ```
 
-changing the prefix from `TAB` to `>` (you really want this), and collecting all `target=...` attributes into the `all` target.
-
 Once you have the code in place to generate figures and markdown tables, you can use the syntax at your disposal to include those into your Markdown. In this example that would be
 
 ~~~markdown
@@ -167,6 +176,29 @@ Once you have the code in place to generate figures and markdown tables, you can
 
 In the case of tables or other rich content, Standard Markdown (or CommonMark) has no syntax for including other Markdown files, so you'll have to check with your own document generator how to do that. In MkDocs, you could use `mkdocs-macro-plugin`, Pandoc has `pandoc-include`, etc.
 
+You can also specify intermediate data generation like so:
+
+~~~markdown
+``` {.python .build target="data/result.csv"}
+import numpy as np
+import pandas as pd
+
+result = np.random.normal(0.0, 1.0, (100, 2))
+df = pd.DataFrame(result, columns=["x", "y"])
+df.to_csv("data/result.csv")
+```
+
+``` {.python .build target="fig/plot.svg" deps="data/result.csv"}
+import pandas as pd
+
+df = pd.read_csv("data/result.csv")
+plot = df.plot()
+plot.savefig("fig/plot.svg")
+```
+~~~
+
+The snippet for generating the data is given as a dependency for that data; to generate the figure, both `result.csv` and the code snippet are dependencies.
+
 #### Ideas for other hooks
 
 > A: Did you hack it together?

{entangled_cli-2.0.0b2 → entangled_cli-2.0.0b5}/entangled/commands/__init__.py

@@ -2,6 +2,7 @@ from .tangle import tangle
 from .stitch import stitch
 from .sync import sync
 from .watch import watch
+from .status import status
 
 
-__all__ = ["tangle", "stitch", "sync", "watch"]
+__all__ = ["tangle", "stitch", "sync", "watch", "status"]

entangled_cli-2.0.0b5/entangled/commands/status.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+from ..status import find_watch_dirs, list_input_files, list_dependent_files
+from ..config import config
+from pathlib import Path
+
+try:
+    from rich.console import Console, Group
+    from rich.columns import Columns
+    from rich.table import Table
+    from rich.panel import Panel
+    from rich.tree import Tree
+
+    def tree_from_files(files):
+        tree = Tree(label=".")
+        dirs = { Path("."): tree }
+        for f in sorted(files):
+            for p in reversed(f.parents):
+                if p not in dirs:
+                    dirs[p] = dirs[p.parent].add(p.name, style="repr.path")
+            dirs[f.parent].add(f.name, style="repr.filename")
+        return tree
+
+
+    def files_panel(file_list: list[str], title: str) -> Panel:
+        tree = tree_from_files(file_list)
+        return Panel(tree, title=title, border_style="dark_cyan")
+
+
+    def rich_status():
+        cfg = config.config
+        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 cfg.watch_list))
+        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([str(f) for f in list_input_files()], "input files"),
+                files_panel([str(f) for f in list_dependent_files()], "dependent files"),
+            ]),
+        )
+
+        console.print(group)
+
+
+    WITH_RICH = True
+except ImportError:
+    WITH_RICH = False
+
+
+def status():
+    if WITH_RICH:
+        rich_status()
+    else:
+        print(config)
+        print("---")
+        print("input files:", sorted(list_input_files()))

{entangled_cli-2.0.0b2 → entangled_cli-2.0.0b5}/entangled/commands/stitch.py

@@ -50,7 +50,7 @@ def stitch(*, force: bool = False, show: bool = False):
         with transaction(mode) as t:
             for path in t.db.managed:
                 logging.debug("reading `%s`", path)
-                t.db.update(path)
+                t.update(path)
                 with open(path, "r") as f:
                     CodeReader(str(path), refs).run(f.read())
 

{entangled_cli-2.0.0b2 → entangled_cli-2.0.0b5}/entangled/commands/tangle.py

@@ -44,17 +44,19 @@ def tangle(*, annotate: Optional[str] = None, force: bool = False, show: bool =
         with transaction(mode) as t:
             for path in input_file_list:
                 logging.debug("reading `%s`", path)
-                t.db.update(path)
+                t.update(path)
                 with open(path, "r") as f:
                     MarkdownReader(str(path), refs, hooks).run(f.read())
 
             for tgt in refs.targets:
                 result, deps = tangle_ref(refs, tgt, annotation_method)
                 t.write(Path(tgt), result, list(map(Path, deps)))
+
             t.clear_orphans()
 
         for h in hooks:
             h.post_tangle(refs)
 
+
     except UserError as e:
         logging.error(str(e))

{entangled_cli-2.0.0b2 → entangled_cli-2.0.0b5}/entangled/commands/watch.py

@@ -8,25 +8,26 @@ from watchdog.events import FileSystemEventHandler, FileSystemEvent
 
 from .sync import sync
 from ..config import config
-from ..filedb import file_db
+from ..status import find_watch_dirs
 
 
 class EventHandler(FileSystemEventHandler):
     def __init__(self):
-        input_file_list = chain.from_iterable(map(Path(".").glob, config.watch_list))
-        markdown_dirs = set(p.parent for p in input_file_list)
-        with file_db(readonly=True) as db:
-            code_dirs = set(p.parent for p in db.managed)
-        self.watched = code_dirs.union(markdown_dirs)
+        self.update_watched()
+
+    def update_watched(self):
+        self.watched = find_watch_dirs()
 
     def on_any_event(self, event: FileSystemEvent):
         if event.event_type == "opened":
             return
+        config.read()
         path = Path(event.src_path)
         if path.is_relative_to(Path("./.entangled")):
             return
         if any(path.is_relative_to(p) for p in self.watched):
             sync()
+        self.update_watched()
 
 
 def _watch(_stop_event: Optional[Event] = None):

{entangled_cli-2.0.0b2 → entangled_cli-2.0.0b5}/entangled/config/__init__.py

@@ -4,7 +4,7 @@ defaults and config loaded from `entangled.toml` in the work directory.
 
 from __future__ import annotations
 
-from typing import Optional, ClassVar, TypeVar
+from typing import Any, Optional, ClassVar, TypeVar
 from enum import Enum
 from dataclasses import dataclass, field
 from copy import copy
@@ -67,6 +67,7 @@ class Config(threading.local):
     annotation: AnnotationMethod = AnnotationMethod.STANDARD
     use_line_directives: bool = False
     hooks: list[str] = field(default_factory=list)
+    hook: dict = field(default_factory=dict)
 
     def __post_init__(self):
         self.languages = languages + self.languages
@@ -82,16 +83,42 @@ class Config(threading.local):
 default = Config(Version.from_string("2.0"))
 
 
-def read_config():
-    if not Path("./entangled.toml").exists():
-        return default
+def read_config_from_toml(path: Path, section: Optional[str] = None) -> Optional[Config]:
+    """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
+    that section is decoded to a `Config` object. The `section` string may contain
+    periods to indicate deeper nesting.
+
+    Example:
+
+    ```python
+    read_config_from_toml(Path("./pyproject.toml"), "tool.entangled")
+    ```
+    """
+    if not path.exists():
+        return None
     try:
-        with open(Path("./entangled.toml"), "rb") as f:
+        with open(path, "rb") as f:
             json = tomllib.load(f)
-        return construct(Config, json)
+            if section is not None:
+                for s in section.split("."):
+                    json = json[s]
+            return construct(Config, json)
     except ValueError as e:
         logging.error("Could not read config: %s", e)
-        return default
+        return None
+    except KeyError as e:
+        logging.debug("%s", e)
+        logging.debug("The config file %s should contain a section %s", path, section)
+        return None
+
+
+def read_config():
+    if Path("./entangled.toml").exists():
+        return read_config_from_toml(Path("./entangled.toml")) or default
+    if Path("./pyproject.toml").exists():
+        return read_config_from_toml(Path("./pyproject.toml"), "tool.entangled") or default
+    return default
 
 
 class ConfigWrapper:
@@ -120,3 +147,4 @@ class ConfigWrapper:
 config = ConfigWrapper(read_config())
 """The `config.config` variable is changed when the `config` module is loaded.
 Config is read from `entangled.toml` file."""
+

{entangled_cli-2.0.0b2 → entangled_cli-2.0.0b5}/entangled/config/language.py

@@ -26,7 +26,7 @@ class Language:
 
 
 languages = [
-    Language("Shell", ["sh", "bash", "fish", "zsh"], Comment("#")),
+    Language("Bash", ["sh", "bash"], Comment("#")),
     Language("C", ["c", "cpp", "c++"], Comment("/*", "*/")),
     Language("Python", ["python"], Comment("#")),
     Language("Rust", ["rust"], Comment("//")),
@@ -36,9 +36,10 @@ languages = [
     ),
     Language("Julia", ["julia"], Comment("#")),
     Language("Java", ["java"], Comment("//")),
-    Language("PureScritp", ["pure", "purs", "purescript"], Comment("--")),
+    Language("PureScript", ["pure", "purs", "purescript"], Comment("--")),
     Language("CSS", ["css"], Comment("/*", "*/")),
     Language("Lua", ["lua"], Comment("--")),
     Language("Make", ["make", "makefile"], Comment("#")),
     Language("Gnuplot", ["gnuplot"], Comment("#")),
+    Language("TOML", ["toml"], Comment("#")),
 ]

{entangled_cli-2.0.0b2 → entangled_cli-2.0.0b5}/entangled/construct.py

@@ -28,6 +28,9 @@ def construct(annot, json):
     if isinstance(json, str) and isinstance(annot, Parser):
         result, _ = annot.read(json)
         return result
+    if annot is dict or isgeneric(annot) and typing.get_origin(annot) is dict:
+        assert isinstance(json, dict)
+        return json
     if isgeneric(annot) and typing.get_origin(annot) is list:
         assert isinstance(json, list)
         return [construct(typing.get_args(annot)[0], item) for item in json]

{entangled_cli-2.0.0b2 → entangled_cli-2.0.0b5}/entangled/document.py

@@ -51,6 +51,12 @@ class CodeBlock:
 
 @dataclass
 class ReferenceMap:
+    """
+    Members:
+        `map`: maps references to actual code block content
+        `index`: maps names to list of references
+        `targets`: lists filenames; a target should be in `index`
+    """
     map: dict[ReferenceId, CodeBlock] = field(default_factory=dict)
     index: defaultdict[str, list[ReferenceId]] = field(
         default_factory=lambda: defaultdict(list)

{entangled_cli-2.0.0b2 → entangled_cli-2.0.0b5}/entangled/filedb.py

@@ -16,6 +16,14 @@ from .version import __version__
 from .utility import normal_relative, ensure_parent
 
 
+def hexdigest(s: str) -> str:
+    """Creates a MD5 hash digest from a string. Before hashing, the string has
+    linefeed `\\r` characters and trailing newlines removed, and the string
+    is encoded as UTF-8."""
+    content = s.replace("\r", "").rstrip("\n").encode()
+    return hashlib.sha256(content).hexdigest()
+
+
 @dataclass
 class FileStat:
     path: Path
@@ -26,10 +34,10 @@ class FileStat:
     @staticmethod
     def from_path(path: Path, deps: Optional[list[Path]]):
         stat = os.stat(path)
-        with open(path, "rb") as f:
-            hash = hashlib.sha256(f.read())
+        with open(path, "r") as f:
+            digest = hexdigest(f.read())
         return FileStat(
-            path, deps, datetime.fromtimestamp(stat.st_mtime), hash.hexdigest()
+            path, deps, datetime.fromtimestamp(stat.st_mtime), digest
         )
 
     def __lt__(self, other: FileStat) -> bool:
@@ -136,9 +144,7 @@ class FileDB:
         return self._files.keys()
 
     def check(self, path: Path, content: str) -> bool:
-        return (
-            hashlib.sha256(content.encode()).hexdigest() == self._files[path].hexdigest
-        )
+        return hexdigest(content) == self._files[path].hexdigest
 
     @staticmethod
     def initialize() -> FileDB:

{entangled_cli-2.0.0b2 → entangled_cli-2.0.0b5}/entangled/hooks/__init__.py

@@ -1,10 +1,12 @@
 import logging
-from .base import HookBase
-from .build import BuildHook, PrerequisitesFailed
+from typing import Any
+from .base import HookBase, PrerequisitesFailed
+from . import build
 from ..config import config
+from ..construct import construct
 
 
-hooks: dict[str, type[HookBase]] = {"build": BuildHook}
+hooks: dict[str, type[HookBase]] = {"build": build.Hook}
 
 
 def get_hooks() -> list[HookBase]:
@@ -12,8 +14,10 @@ def get_hooks() -> list[HookBase]:
     for h in config.hooks:
         if h in hooks:
             try:
-                hooks[h].check_prerequisites()
-                active_hooks.append(hooks[h]())
+                hook_cfg = construct(hooks[h].Config, config.hook.get(h, {}))
+                hook_instance = hooks[h](hook_cfg)
+                hook_instance.check_prerequisites()
+                active_hooks.append(hook_instance)
             except PrerequisitesFailed as e:
                 logging.error("hook `%s`: %s", h, str(e))
         else:

{entangled_cli-2.0.0b2 → entangled_cli-2.0.0b5}/entangled/hooks/base.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from typing import Any
 
 from ..properties import Property
 from ..document import ReferenceMap, ReferenceId, CodeBlock
@@ -13,16 +14,24 @@ class PrerequisitesFailed(Exception):
 
 
 class HookBase:
-    @staticmethod
-    def check_prerequisites():
+    class Config:
+        pass
+
+    def __init__(self, config: Config):
+        pass
+
+    def check_prerequisites(self):
         """When prerequisites aren't met, raise PrerequisitesFailed."""
         return
 
     def condition(self, props: list[Property]):
         raise NotImplementedError()
 
-    def on_read(self, refs: ReferenceId, code: CodeBlock):
+    def on_read(self, refs: ReferenceMap, ref: ReferenceId, code: CodeBlock):
         raise NotImplementedError()
 
+    def pre_tangle(self, refs: ReferenceMap):
+        pass
+
     def post_tangle(self, refs: ReferenceMap):
         pass

entangled_cli-2.0.0b5/entangled/hooks/build.py

@@ -0,0 +1,104 @@
+"""
+The `build` hook collects code blocks that are tagged with the `#build`
+identifier and have a `target=` attribute defined.  These code blocks are put
+together into a temporary Makefile that is run from the current working
+directory.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from pathlib import Path
+from subprocess import run, SubprocessError, DEVNULL
+
+from entangled.config.language import Language
+
+from ..properties import Property, get_attribute, get_classes
+from ..document import ReferenceId, ReferenceMap, CodeBlock
+
+from .base import HookBase, PrerequisitesFailed
+
+"""
+The Makefile is generated with `preamble` as a format string.  The
+`.RECIPEPREFIX` is set to `>` , and `target` attributes are collected into an
+`all` target.
+"""
+preamble = """
+# This Makefile is generated by Entangled. Modifications will be overwritten.
+
+.RECIPEPREFIX = >
+.PHONY = all
+
+all: {targets}
+
+{rules}
+"""
+
+EXEC_CMDS = {
+    "Python": "python {script}",
+    "Bash": "bash {script}",
+    "Julia": "julia -O0 --project=. {script}",
+}
+
+
+class Hook(HookBase):
+    @dataclass
+    class Config(HookBase.Config):
+        runners: dict[str, str] = field(default_factory=dict)
+
+        def __post_init__(self):
+            for k, v in EXEC_CMDS.items():
+                if k not in self.runners:
+                    self.runners[k] = v
+
+    @dataclass
+    class Recipe:
+        target: str
+        dependencies: list[str]
+        language: Language
+        scriptfile: str
+
+        def to_makefile(self, config: Hook.Config):
+            dep_str = " ".join(self.dependencies)
+            exec_cmd = config.runners[self.language.name].format(script=self.scriptfile)
+            return f"{self.target}: {self.scriptfile} {dep_str}\n" \
+                   f"> {exec_cmd}"
+
+    def __init__(self, config: Hook.Config):
+        self.recipes: list[Hook.Recipe] = []
+        self.config = config
+
+    def check_prerequisites(self):
+        """Check that `make` is installed."""
+        try:
+            run(["make", "--version"], stdout=DEVNULL)
+        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):
+        """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):
+        """After all code is tangled: retrieve the build scripts and run it."""
+        targets = " ".join([r.target for r in self.recipes])
+        makefile = preamble.format(targets=targets, rules="\n\n".join(r.to_makefile(self.config) for r in self.recipes))
+        Path(".entangled/build").mkdir(exist_ok=True, parents=True)
+        Path(".entangled/build/Makefile").write_text(makefile)
+

{entangled_cli-2.0.0b2 → entangled_cli-2.0.0b5}/entangled/main.py

@@ -12,7 +12,7 @@ except ImportError:
     WITH_RICH = False
 
 
-from .commands import tangle, stitch, sync, watch
+from .commands import tangle, stitch, sync, watch, status
 from .errors.internal import bug_contact
 from .errors.user import UserError
 from .version import __version__
@@ -57,7 +57,7 @@ def cli():
         parser.add_argument(
             "-v", "--version", action="store_true", help="show version number"
         )
-        argh.add_commands(parser, [tangle, stitch, sync, watch])
+        argh.add_commands(parser, [tangle, stitch, sync, watch, status])
         args = parser.parse_args()
 
         if args.version:

{entangled_cli-2.0.0b2 → entangled_cli-2.0.0b5}/entangled/markdown_reader.py

@@ -87,10 +87,17 @@ class MarkdownReader(mawk.RuleSet):
         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")
-        ref_name = block_id or target_file
         language = config.get_language(language_class) if language_class else None
 
-        if ref_name is None or language is 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}"
+
+        if language is None:
             self.flush_plain_text()
         else:
             ref = self.reference_map.new_id(
@@ -100,13 +107,10 @@ class MarkdownReader(mawk.RuleSet):
                 language,
                 self.current_codeblock_properties,
                 self.current_codeblock_indent,
-                "\n".join(
-                    line.removeprefix(self.current_codeblock_indent)
-                    for line in self.current_content
-                ),
+                content,
                 self.current_codeblock_location,
             )
-            logging.debug(repr(code))
+            # logging.debug(repr(code))
             self.reference_map[ref] = code
             if target_file is not None:
                 self.reference_map.targets.add(target_file)
@@ -115,7 +119,7 @@ class MarkdownReader(mawk.RuleSet):
 
             for h in self.hooks:
                 if h.condition(self.current_codeblock_properties):
-                    h.on_read(ref, code)
+                    h.on_read(self.reference_map, ref, code)
 
         self.current_content.append(m[0])
         self.inside_codeblock = False

entangled_cli-2.0.0b5/entangled/status.py

@@ -0,0 +1,25 @@
+from .config import config
+from .filedb import file_db
+
+from itertools import chain
+from pathlib import Path
+
+
+def find_watch_dirs():
+    """List all directories that contain files that need watching."""
+    input_file_list = list_input_files()
+    markdown_dirs = set(p.parent for p in input_file_list)
+    with file_db(readonly=True) as db:
+        code_dirs = set(p.parent for p in db.managed)
+    return code_dirs.union(markdown_dirs)
+
+
+def list_input_files():
+    """List all input files."""
+    return chain.from_iterable(map(Path(".").glob, config.watch_list))
+
+
+def list_dependent_files():
+    with file_db(readonly=True) as db:
+        result = list(db.managed)
+    return result

{entangled_cli-2.0.0b2 → entangled_cli-2.0.0b5}/entangled/transaction.py

@@ -105,9 +105,13 @@ class Delete(Action):
 @dataclass
 class Transaction:
     db: FileDB
+    updates: list[Path] = field(default_factory=list)
     actions: list[Action] = field(default_factory=list)
     passed: set[Path] = field(default_factory=set)
 
+    def update(self, path: Path):
+        self.updates.append(path)
+
     def write(self, path: Path, content: str, sources: list[Path]):
         if path in self.passed:
             raise InternalError("Path is being written to twice", [path])
@@ -147,6 +151,8 @@ class Transaction:
     def run(self):
         for a in self.actions:
             a.run(self.db)
+        for f in self.updates:
+            self.db.update(f)
 
 
 class TransactionMode(Enum):

{entangled_cli-2.0.0b2 → entangled_cli-2.0.0b5}/entangled/utility.py

@@ -11,12 +11,6 @@ import types
 T = TypeVar("T")
 
 
-@contextmanager
-def pushd(wd: Path):
-    olddir = os.getcwd()
-    os.chdir(wd)
-    yield wd
-    os.chdir(olddir)
 
 
 def first(it: Iterable[T]) -> Optional[T]:

{entangled_cli-2.0.0b2 → entangled_cli-2.0.0b5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "entangled-cli"
-version = "2.0.0-beta-2"
+version = "2.0.0-beta-5"
 description = "Literate Programming toolbox"
 repository = "https://github.com/entangled/entangled.py"
 homepage = "https://entangled.github.io/"
@@ -17,7 +17,7 @@ mawk = "^0.1.4"           # use mawk as line parsing engine
 watchdog = "^3.0.0"       # file watching
 filelock = "^3.12.0"      # file lock for json db
 argh = "^0.28.1"
-rich = { version = "^13.3.5", optional = true }
+rich = "^13.3.5"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.3.1"
@@ -29,9 +29,6 @@ mkdocs-material = "^9.1.13"
 mkdocstrings = {extras = ["python"], version = "^0.21.2"}
 twine = "^4.0.2"
 
-[tool.poetry.extras]
-rich = ["rich"]
-
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"

entangled_cli-2.0.0b2/entangled/hooks/build.py

@@ -1,73 +0,0 @@
-"""
-The `build` hook collects code blocks that are tagged with the `#build`
-identifier and have a `target=` attribute defined.  These code blocks are put
-together into a temporary Makefile that is run from the current working
-directory.
-"""
-
-from tempfile import TemporaryDirectory
-from pathlib import Path
-from subprocess import run, SubprocessError, DEVNULL
-
-import logging
-import os
-
-from ..properties import Property, get_id, get_attribute
-from ..tangle import tangle_ref
-from ..document import ReferenceMap, CodeBlock
-
-from .base import HookBase, PrerequisitesFailed
-
-"""
-The Makefile is generated with `preamble` as a format string.  The
-`.RECIPEPREFIX` is set to `>` , and `target` attributes are collected into an
-`all` target.
-"""
-preamble = """
-.RECIPEPREFIX = >
-.PHONY = all
-
-all: {targets}
-
-{rules}
-"""
-
-
-class BuildHook(HookBase):
-    def __init__(self):
-        self.targets = []
-
-    @staticmethod
-    def check_prerequisites():
-        """Check that `make` is installed."""
-        try:
-            run(["make", "--version"], stdout=DEVNULL)
-        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` id
-        and `target=` attribute."""
-        return get_id(props) == "build" and get_attribute(props, "target") is not None
-
-    def on_read(self, _, code: CodeBlock):
-        """Add a CodeBlock's target attribute to the list of targets."""
-        target = get_attribute(code.properties, "target")
-        if target is None:
-            return
-        self.targets.append(target)
-
-    def post_tangle(self, refs: ReferenceMap):
-        """After all code is tangled: retrieve the `#build` script and run it."""
-        if "CI" in os.environ:
-            logging.info("CI run detected, skipping `build` hook.")
-            return
-
-        logging.info("Building artifacts with `make`.")
-        with TemporaryDirectory() as _pwd:
-            pwd = Path(_pwd)
-            script = preamble.format(
-                targets=" ".join(self.targets), rules=tangle_ref(refs, "build")[0]
-            )
-            (pwd / "Makefile").write_text(script)
-            run(["make", "-f", str(pwd / "Makefile")], stdout=DEVNULL)