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

entangled_cli-2.0.0b2/PKG-INFO

@@ -0,0 +1,258 @@
+Metadata-Version: 2.1
+Name: entangled-cli
+Version: 2.0.0b2
+Summary: Literate Programming toolbox
+Home-page: https://entangled.github.io/
+License: Apache 2
+Author: Johan Hidding
+Author-email: j.hidding@esciencecenter.nl
+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: watchdog (>=3.0.0,<4.0.0)
+Project-URL: Repository, https://github.com/entangled/entangled.py
+Description-Content-Type: text/markdown
+
+# Entangled
+[![Upload Python Package](https://github.com/entangled/entangled.py/actions/workflows/deploy.yml/badge.svg)](https://github.com/entangled/entangled.py/actions/workflows/deploy.yml)
+[![Python package](https://github.com/entangled/entangled.py/actions/workflows/python-package.yml/badge.svg)](https://github.com/entangled/entangled.py/actions/workflows/python-package.yml)
+
+Entangled is a solution for Literate Programming, a technique in which the programmer writes a human narrative first, then implementing the program in code blocks.
+Literate programming was introduced by Donald Knuth in 1984 and has since then found several surges in popularity. One thing holding back the popularity of literate programming is the lack of maintainability under increasing program complexity. Entangled solves this issue by offering a two-way synchronisation mechanism. You can edit and debug your code as normal in your favourite IDE or text editor. Entangled will make sure that your Markdown files stay up-to-date with your code and vice-versa. Because Entangled works with Markdown, you can use it with most static document generators. To summarise, you keep using:
+
+- your favourite **editor**: Entangled runs as a daemon in the background, keeping your text files synchronised.
+- your favourite **programming language**: Entangled is agnostic to programming languages.
+- your favourite **document generator**: Entangled is configurable to any dialect of Markdown.
+
+We’re trying to increase the visibility of Entangled. If you like Entangled, please consider adding this badge [![Entangled badge](https://img.shields.io/badge/entangled-Use%20the%20source!-%2300aeff)](https://entangled.github.io/) to the appropriate location in your project:
+
+```markdown
+[![Entangled badge](https://img.shields.io/badge/entangled-Use%20the%20source!-%2300aeff)](https://entangled.github.io/)
+```
+
+## Get started
+To install Entangled, all you need is a Python installation. If you use [`poetry`](https://python-poetry.org),
+
+```
+poetry add entangled-cli[rich]
+```
+
+Or, if you prefer `pip`,
+
+```
+pip install entangled-cli[rich]
+```
+
+## 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
+``` {.rust #hello file="src/world.rs"}
+...
+```
+~~~
+
+The syntax of code block properties is the same as CSS properties: `#hello` gives the block the `hello` identifier, `.rust` adds the `rust` class and the `file` attribute is set to `src/world.rs` (quotes are optional). For Entangled to know how to tangle this block, you need to specify a language and a target file. However, now comes the cool stuff. We can split our code in meaningful components by cross-refrences.
+
+### Hello World in C++
+The combined code-blocks in this example compose a compilable source code for "Hello World". For didactic reasons we don't always give the listing of an entire source file in one go. In stead, we use a system of references known as *noweb* (after Ramsey 1994).
+
+Inside source fragments you may encounter a line with `<<...>>` marks like,
+
+~~~markdown
+``` {.cpp file=hello_world.cc}
+#include <cstdlib>
+#include <iostream>
+
+<<example-main-function>>
+```
+~~~
+
+which is then elsewhere specified. Order doesn't matter,
+
+~~~markdown
+``` {.cpp #hello-world}
+std::cout << "Hello, World!" << std::endl;
+```
+~~~
+
+So we can reference the `<<hello-world>>` code block later on.
+
+~~~markdown
+``` {.cpp #example-main-function}
+int main(int argc, char **argv)
+{
+    <<hello-world>>
+}
+```
+~~~
+
+A definition can be appended with more code as follows (in this case, order does matter!):
+
+~~~markdown
+``` {.cpp #hello-world}
+return EXIT_SUCCESS;
+```
+~~~
+
+These blocks of code can be *tangled* into source files.
+
+### Configuring
+Entangled is configured by putting a `entangled.toml` in the root of your project.
+
+```toml
+# required: the minimum version of Entangled
+version = "2.0"            
+
+# default watch_list is ["**/*.md"]
+watch_list = ["docs/**/*.md"]
+```
+
+You may add languages as follows:
+
+```toml
+[[languages]]
+name = "Java"
+identifiers = ["java"]
+comment = { open = "//" }
+
+# Some languages have comments that are not terminated by
+# newlines, like XML or CSS.
+[[languages]]
+name = "XML"
+identifiers = ["xml", "html", "svg"]
+comment = { open = "<!--", close = "-->" }
+```
+
+The `identifiers` are the tags that you may use in your code block header to identify the language. Using the above config, you should be able to write:
+
+~~~markdown
+``` {.html file=index.html}
+<!DOCTYPE html>
+<html lang="en">
+    <<header>>
+    <<body>>
+</html>
+```
+
+And so on...
+~~~
+
+### Using the `build` hook
+Entangled has a system of *hooks*, of which there exists currently only one: `build`. You can enable this hook in `entangled.toml`:
+
+```toml
+version = "2.0"
+watch_list = ["docs/**/*.md"]
+hooks = ["build"]
+```
+
+Then in your Markdown, you may enter Make code tagged with the `#build` id.
+
+~~~markdown
+``` {.make #build target=docs/fig/plot.svg}
+docs/fig/plot.svg: src/plot.gnuplot
+> gnuplot $< > $@
+```
+~~~
+
+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`.
+
+Entangled adds a preamble to `#build`,
+
+```make
+.RECIPEPREFIX = >
+.PHONY = all
+
+all: {targets}
+
+{rules}
+```
+
+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
+![My awesome plot](fig/plot.svg)
+~~~
+
+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.
+
+#### Ideas for other hooks
+
+> A: Did you hack it together?
+
+> B: No, its hooked into the system.
+
+> A: That's clever!
+
+In principle, you could do a lot of things with the `build` hook, supposing that you're well versed in the secrets of GNU Make. However, I also want to make things easier to use. As a principle I would like Entangled to be as much independent of choice of document generator as possible. That means that some of the features you may want are actually best implemented as plugins for these document generators. One obvious example of an add-on that doesn't belong in the core of Entangled would be support for Jupyter. If your work is anything serious, meaning your computations take somewhat longer, you'll be much happier with a build system anyway :smile:!
+
+That being said, candidates for hooks could be: 
+
+- *Code metadata*. Some code could use more meta data than just a name and language. One way to include metadata is by having a header that is separated with a three hyphen line `---` from the actual code content. A hook could change the way the code is tangled, possibly injecting the metadata as a docstring, or leaving it out of the tangled code and have the document generator use it for other purposes.
+- *She-bang lines*. When you're coding scripts, it may be desirable to have `#!/bin/bash` equivalent line at the top. This is currently not supported in the Python port of Entangled.
+- *Integration with package managers* like `cargo`, `cabal`, `poetry` etc. These are usually configured in a separate file. A hook could be used to specify dependencies. That way you could also document why a certain dependency is needed, or why it needs to have the version you specify.
+
+## Support for Document Generators
+Entangled has been used successfully with the following document generators. Note that some of these examples were built using older versions of Entangled, but they should work just the same.
+
+### Pandoc
+[Pandoc](https://pandoc.org/) is a very versatile tool for converting documents in any format. It specifically has very wide support for different forms of Markdown syntax out in the wild, including a filter system that lets you extend the workings of Pandoc. Those filters can be written in any language through an API, for instance Python filters can be written using `panflute`, but there is also native support for Lua.
+
+To work with Entangled style literate documents, there is a set of [Pandoc filters](https://github.com/entangled/filters) available. The major downside of Pandoc, is that it offers no help in making your output HTML look beautiful. One option is to use the [Bootstrap template](https://github.com/entangled/bootstrap), but you may wan't to try out others as well, or design your own. These days a lot can be done with a single well designed CSS file.
+
+- :heavy_plus_sign: dynamic
+- :heavy_plus_sign: supports most Markdown syntax out of the box
+- :heavy_plus_sign: excellent for science: citation, numbered figures, tables and equations
+- :heavy_plus_sign: support for LaTeX
+- :heavy_minus_sign: harder to setup
+- :heavy_minus_sign: takes work to make look good
+
+Example: [Hello World in C++](https://entangled.github.io/examples/hello-world.html)
+
+### MkDocs
+[MkDocs](https://www.mkdocs.org/) is specifically taylored towards converting Markdown into good looking, easy to navigate HTML, especially when used in combination with the [`mkdocs-material`](https://squidfunk.github.io/mkdocs-material/) theme. To use Entangled style code blocks with MkDocs, you'll need to install the [`mkdocs-entangled-plugin`](https://github.com/entangled/mkdocs-plugin) as well.
+
+- :heavy_plus_sign: specifically designed for Markdown to HTML, i.e. software documentation
+- :heavy_plus_sign: pretty output, out of the box
+- :heavy_plus_sign: easy to install
+- :heavy_minus_sign: not intended for scientific use: numbering and referencing equations, figures and tables is hard to setup
+- :heavy_minus_sign: documentation is on par with most Python projects: Ok for most things, but really hard if you want specifics
+
+Example: TBD
+
+### Documenter.jl
+[Documenter.jl]() is the standard tool to write Julia documention in. It has internal support for evaluating code block contents.
+
+Example: [Intro to code generation in Julia](https://jhidding.github.io/MacroExercises.jl/dev/)
+
+### PDoc
+[PDoc]() is a tool for documenting smaller Python projects. It grabs all documentation from the doc-strings in your Python library and generates a page from that. To have it include its own literate source, I had to use some very ugly hacks.
+
+Example: [check-deps, a Universal dependency checker in Python](https://jhidding.github.io/check-deps/checkdeps.html)
+
+### Docsify
+[Docsify](https://docsify.js.org/#/) serves the markdown files and does the conversion to HTML in a Javascript library (in browser).
+
+Example: [Guide to C++ on the web through WASM](https://nlesc-jcer.github.io/cpp2wasm/#/)
+
+## History
+This is a rewrite of Entangled in Python. Older versions were written in Haskell. The rewrite in Python was motivated by ease of installation, larger community and quite frankly, a fit of mental derangement.
+
+## Contributing
+If you have an idea for improving Entangled, please file an issue before creating a pull request. Code in this repository is formatted using `black` and type checked using `mypy`.
+
+## License
+Copyright 2023 Netherlands eScience Center, written by Johan Hidding, licensed under the Apache 2 license, see LICENSE.
+

entangled_cli-2.0.0b2/README.md

@@ -0,0 +1,236 @@
+# Entangled
+[![Upload Python Package](https://github.com/entangled/entangled.py/actions/workflows/deploy.yml/badge.svg)](https://github.com/entangled/entangled.py/actions/workflows/deploy.yml)
+[![Python package](https://github.com/entangled/entangled.py/actions/workflows/python-package.yml/badge.svg)](https://github.com/entangled/entangled.py/actions/workflows/python-package.yml)
+
+Entangled is a solution for Literate Programming, a technique in which the programmer writes a human narrative first, then implementing the program in code blocks.
+Literate programming was introduced by Donald Knuth in 1984 and has since then found several surges in popularity. One thing holding back the popularity of literate programming is the lack of maintainability under increasing program complexity. Entangled solves this issue by offering a two-way synchronisation mechanism. You can edit and debug your code as normal in your favourite IDE or text editor. Entangled will make sure that your Markdown files stay up-to-date with your code and vice-versa. Because Entangled works with Markdown, you can use it with most static document generators. To summarise, you keep using:
+
+- your favourite **editor**: Entangled runs as a daemon in the background, keeping your text files synchronised.
+- your favourite **programming language**: Entangled is agnostic to programming languages.
+- your favourite **document generator**: Entangled is configurable to any dialect of Markdown.
+
+We’re trying to increase the visibility of Entangled. If you like Entangled, please consider adding this badge [![Entangled badge](https://img.shields.io/badge/entangled-Use%20the%20source!-%2300aeff)](https://entangled.github.io/) to the appropriate location in your project:
+
+```markdown
+[![Entangled badge](https://img.shields.io/badge/entangled-Use%20the%20source!-%2300aeff)](https://entangled.github.io/)
+```
+
+## Get started
+To install Entangled, all you need is a Python installation. If you use [`poetry`](https://python-poetry.org),
+
+```
+poetry add entangled-cli[rich]
+```
+
+Or, if you prefer `pip`,
+
+```
+pip install entangled-cli[rich]
+```
+
+## 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
+``` {.rust #hello file="src/world.rs"}
+...
+```
+~~~
+
+The syntax of code block properties is the same as CSS properties: `#hello` gives the block the `hello` identifier, `.rust` adds the `rust` class and the `file` attribute is set to `src/world.rs` (quotes are optional). For Entangled to know how to tangle this block, you need to specify a language and a target file. However, now comes the cool stuff. We can split our code in meaningful components by cross-refrences.
+
+### Hello World in C++
+The combined code-blocks in this example compose a compilable source code for "Hello World". For didactic reasons we don't always give the listing of an entire source file in one go. In stead, we use a system of references known as *noweb* (after Ramsey 1994).
+
+Inside source fragments you may encounter a line with `<<...>>` marks like,
+
+~~~markdown
+``` {.cpp file=hello_world.cc}
+#include <cstdlib>
+#include <iostream>
+
+<<example-main-function>>
+```
+~~~
+
+which is then elsewhere specified. Order doesn't matter,
+
+~~~markdown
+``` {.cpp #hello-world}
+std::cout << "Hello, World!" << std::endl;
+```
+~~~
+
+So we can reference the `<<hello-world>>` code block later on.
+
+~~~markdown
+``` {.cpp #example-main-function}
+int main(int argc, char **argv)
+{
+    <<hello-world>>
+}
+```
+~~~
+
+A definition can be appended with more code as follows (in this case, order does matter!):
+
+~~~markdown
+``` {.cpp #hello-world}
+return EXIT_SUCCESS;
+```
+~~~
+
+These blocks of code can be *tangled* into source files.
+
+### Configuring
+Entangled is configured by putting a `entangled.toml` in the root of your project.
+
+```toml
+# required: the minimum version of Entangled
+version = "2.0"            
+
+# default watch_list is ["**/*.md"]
+watch_list = ["docs/**/*.md"]
+```
+
+You may add languages as follows:
+
+```toml
+[[languages]]
+name = "Java"
+identifiers = ["java"]
+comment = { open = "//" }
+
+# Some languages have comments that are not terminated by
+# newlines, like XML or CSS.
+[[languages]]
+name = "XML"
+identifiers = ["xml", "html", "svg"]
+comment = { open = "<!--", close = "-->" }
+```
+
+The `identifiers` are the tags that you may use in your code block header to identify the language. Using the above config, you should be able to write:
+
+~~~markdown
+``` {.html file=index.html}
+<!DOCTYPE html>
+<html lang="en">
+    <<header>>
+    <<body>>
+</html>
+```
+
+And so on...
+~~~
+
+### Using the `build` hook
+Entangled has a system of *hooks*, of which there exists currently only one: `build`. You can enable this hook in `entangled.toml`:
+
+```toml
+version = "2.0"
+watch_list = ["docs/**/*.md"]
+hooks = ["build"]
+```
+
+Then in your Markdown, you may enter Make code tagged with the `#build` id.
+
+~~~markdown
+``` {.make #build target=docs/fig/plot.svg}
+docs/fig/plot.svg: src/plot.gnuplot
+> gnuplot $< > $@
+```
+~~~
+
+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`.
+
+Entangled adds a preamble to `#build`,
+
+```make
+.RECIPEPREFIX = >
+.PHONY = all
+
+all: {targets}
+
+{rules}
+```
+
+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
+![My awesome plot](fig/plot.svg)
+~~~
+
+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.
+
+#### Ideas for other hooks
+
+> A: Did you hack it together?
+
+> B: No, its hooked into the system.
+
+> A: That's clever!
+
+In principle, you could do a lot of things with the `build` hook, supposing that you're well versed in the secrets of GNU Make. However, I also want to make things easier to use. As a principle I would like Entangled to be as much independent of choice of document generator as possible. That means that some of the features you may want are actually best implemented as plugins for these document generators. One obvious example of an add-on that doesn't belong in the core of Entangled would be support for Jupyter. If your work is anything serious, meaning your computations take somewhat longer, you'll be much happier with a build system anyway :smile:!
+
+That being said, candidates for hooks could be: 
+
+- *Code metadata*. Some code could use more meta data than just a name and language. One way to include metadata is by having a header that is separated with a three hyphen line `---` from the actual code content. A hook could change the way the code is tangled, possibly injecting the metadata as a docstring, or leaving it out of the tangled code and have the document generator use it for other purposes.
+- *She-bang lines*. When you're coding scripts, it may be desirable to have `#!/bin/bash` equivalent line at the top. This is currently not supported in the Python port of Entangled.
+- *Integration with package managers* like `cargo`, `cabal`, `poetry` etc. These are usually configured in a separate file. A hook could be used to specify dependencies. That way you could also document why a certain dependency is needed, or why it needs to have the version you specify.
+
+## Support for Document Generators
+Entangled has been used successfully with the following document generators. Note that some of these examples were built using older versions of Entangled, but they should work just the same.
+
+### Pandoc
+[Pandoc](https://pandoc.org/) is a very versatile tool for converting documents in any format. It specifically has very wide support for different forms of Markdown syntax out in the wild, including a filter system that lets you extend the workings of Pandoc. Those filters can be written in any language through an API, for instance Python filters can be written using `panflute`, but there is also native support for Lua.
+
+To work with Entangled style literate documents, there is a set of [Pandoc filters](https://github.com/entangled/filters) available. The major downside of Pandoc, is that it offers no help in making your output HTML look beautiful. One option is to use the [Bootstrap template](https://github.com/entangled/bootstrap), but you may wan't to try out others as well, or design your own. These days a lot can be done with a single well designed CSS file.
+
+- :heavy_plus_sign: dynamic
+- :heavy_plus_sign: supports most Markdown syntax out of the box
+- :heavy_plus_sign: excellent for science: citation, numbered figures, tables and equations
+- :heavy_plus_sign: support for LaTeX
+- :heavy_minus_sign: harder to setup
+- :heavy_minus_sign: takes work to make look good
+
+Example: [Hello World in C++](https://entangled.github.io/examples/hello-world.html)
+
+### MkDocs
+[MkDocs](https://www.mkdocs.org/) is specifically taylored towards converting Markdown into good looking, easy to navigate HTML, especially when used in combination with the [`mkdocs-material`](https://squidfunk.github.io/mkdocs-material/) theme. To use Entangled style code blocks with MkDocs, you'll need to install the [`mkdocs-entangled-plugin`](https://github.com/entangled/mkdocs-plugin) as well.
+
+- :heavy_plus_sign: specifically designed for Markdown to HTML, i.e. software documentation
+- :heavy_plus_sign: pretty output, out of the box
+- :heavy_plus_sign: easy to install
+- :heavy_minus_sign: not intended for scientific use: numbering and referencing equations, figures and tables is hard to setup
+- :heavy_minus_sign: documentation is on par with most Python projects: Ok for most things, but really hard if you want specifics
+
+Example: TBD
+
+### Documenter.jl
+[Documenter.jl]() is the standard tool to write Julia documention in. It has internal support for evaluating code block contents.
+
+Example: [Intro to code generation in Julia](https://jhidding.github.io/MacroExercises.jl/dev/)
+
+### PDoc
+[PDoc]() is a tool for documenting smaller Python projects. It grabs all documentation from the doc-strings in your Python library and generates a page from that. To have it include its own literate source, I had to use some very ugly hacks.
+
+Example: [check-deps, a Universal dependency checker in Python](https://jhidding.github.io/check-deps/checkdeps.html)
+
+### Docsify
+[Docsify](https://docsify.js.org/#/) serves the markdown files and does the conversion to HTML in a Javascript library (in browser).
+
+Example: [Guide to C++ on the web through WASM](https://nlesc-jcer.github.io/cpp2wasm/#/)
+
+## History
+This is a rewrite of Entangled in Python. Older versions were written in Haskell. The rewrite in Python was motivated by ease of installation, larger community and quite frankly, a fit of mental derangement.
+
+## Contributing
+If you have an idea for improving Entangled, please file an issue before creating a pull request. Code in this repository is formatted using `black` and type checked using `mypy`.
+
+## License
+Copyright 2023 Netherlands eScience Center, written by Johan Hidding, licensed under the Apache 2 license, see LICENSE.

{entangled_cli-2.0.0b1 → entangled_cli-2.0.0b2}/entangled/code_reader.py

@@ -8,15 +8,6 @@ from .document import ReferenceId, TextLocation, ReferenceMap
 from .errors.user import IndentationError
 
 
-@dataclass
-class StitchError(Exception):
-    path: Path
-    msg: str
-
-    def __str__(self):
-        return f"indentation error in `{self.path}`"
-
-
 @dataclass
 class Frame:
     ref: ReferenceId

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

@@ -56,6 +56,6 @@ def stitch(*, force: bool = False, show: bool = False):
 
             for path in input_file_list:
                 t.write(path, stitch_markdown(refs, content[path]), [])
-                
+
     except UserError as e:
         logging.error(str(e))

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

@@ -24,8 +24,10 @@ from ..errors.user import UserError
 @argh.arg("-s", "--show", help="only show, don't act")
 def tangle(*, annotate: Optional[str] = None, force: bool = False, show: bool = False):
     """Tangle codes from Markdown"""
-    if annotate is not None:
-        config.annotation = AnnotationMethod[annotate.upper()]
+    if annotate is None:
+        annotation_method = config.annotation
+    else:
+        annotation_method = AnnotationMethod[annotate.upper()]
 
     input_file_list = chain.from_iterable(map(Path(".").glob, config.watch_list))
     refs = ReferenceMap()
@@ -47,7 +49,7 @@ def tangle(*, annotate: Optional[str] = None, force: bool = False, show: bool =
                     MarkdownReader(str(path), refs, hooks).run(f.read())
 
             for tgt in refs.targets:
-                result, deps = tangle_ref(refs, tgt)
+                result, deps = tangle_ref(refs, tgt, annotation_method)
                 t.write(Path(tgt), result, list(map(Path, deps)))
             t.clear_orphans()
 
@@ -55,4 +57,4 @@ def tangle(*, annotate: Optional[str] = None, force: bool = False, show: bool =
             h.post_tangle(refs)
 
     except UserError as e:
-        logging.error(str(e))
+        logging.error(str(e))

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

@@ -1,7 +1,6 @@
 from typing import Optional
 from pathlib import Path
 from itertools import chain
-import logging
 from threading import Event
 
 from watchdog.observers import Observer
@@ -37,7 +36,7 @@ def _watch(_stop_event: Optional[Event] = None):
 
     def stop() -> bool:
         return _stop_event is not None and _stop_event.is_set()
-    
+
     sync()
 
     event_handler = EventHandler()

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

@@ -9,12 +9,15 @@ from enum import Enum
 from dataclasses import dataclass, field
 from copy import copy
 from pathlib import Path
+from contextlib import contextmanager
 
 from ..construct import construct
 from .version import Version
 from .language import Language, languages
 
+import threading
 import tomllib
+import logging
 
 
 class AnnotationMethod(Enum):
@@ -47,13 +50,14 @@ markers = Markers(
     r"^(?P<indent>\s*)```\s*{(?P<properties>[^{}]*)}\s*$",
     r"^(?P<indent>\s*)```\s*$",
     r"^\s*\~\~\~markdown\s*$",
-    r"^\s*\~\~\~\s*$"
+    r"^\s*\~\~\~\s*$",
 )
 
 
 @dataclass
-class Config:
-    """Main config class."""
+class Config(threading.local):
+    """Main config class. This class is made thread-local to make
+    it possible to test in parallel."""
 
     version: Version
     languages: list[Language] = field(default_factory=list)
@@ -74,9 +78,6 @@ class Config:
             for i in l.identifiers:
                 self.language_index[i] = l
 
-    def get_language(self, lang_name: str) -> Optional[Language]:
-        return self.language_index.get(lang_name, None)
-
 
 default = Config(Version.from_string("2.0"))
 
@@ -84,11 +85,38 @@ default = Config(Version.from_string("2.0"))
 def read_config():
     if not Path("./entangled.toml").exists():
         return default
-    with open(Path("./entangled.toml"), "rb") as f:
-        json = tomllib.load(f)
-    return construct(Config, json)
+    try:
+        with open(Path("./entangled.toml"), "rb") as f:
+            json = tomllib.load(f)
+        return construct(Config, json)
+    except ValueError as e:
+        logging.error("Could not read config: %s", e)
+        return default
+
+
+class ConfigWrapper:
+    def __init__(self, config):
+        self.config = config
+
+    def read(self):
+        self.config = read_config()
+
+    def __getattr__(self, attr):
+        return getattr(self.config, attr)
+
+    @contextmanager
+    def __call__(self, **kwargs):
+        backup = {k: getattr(self.config, k) for k in kwargs}
+        for k, v in kwargs.items():
+            setattr(self.config, k, v)
+        yield
+        for k in kwargs.keys():
+            setattr(self.config, k, backup[k])
+
+    def get_language(self, lang_name: str) -> Optional[Language]:
+        return self.config.language_index.get(lang_name, None)
 
 
-config = read_config()
+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.0b1 → entangled_cli-2.0.0b2}/entangled/config/language.py

@@ -26,6 +26,7 @@ class Language:
 
 
 languages = [
+    Language("Shell", ["sh", "bash", "fish", "zsh"], Comment("#")),
     Language("C", ["c", "cpp", "c++"], Comment("/*", "*/")),
     Language("Python", ["python"], Comment("#")),
     Language("Rust", ["rust"], Comment("//")),
@@ -39,5 +40,5 @@ languages = [
     Language("CSS", ["css"], Comment("/*", "*/")),
     Language("Lua", ["lua"], Comment("--")),
     Language("Make", ["make", "makefile"], Comment("#")),
-    Language("Gnuplot", ["gnuplot"], Comment("#"))
+    Language("Gnuplot", ["gnuplot"], Comment("#")),
 ]