uEdition 1.3.1__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

uedition/ext/tei/parser.py

@@ -1,7 +1,9 @@
+# noqa: A005
 # SPDX-FileCopyrightText: 2023-present Mark Hall <mark.hall@work.room3b.eu>
 #
 # SPDX-License-Identifier: MIT
 """TEI parsing extension for Sphinx."""
+
 import re
 from typing import Callable
 
@@ -10,8 +12,10 @@ from lxml import etree
 from sphinx import addnodes
 from sphinx.application import Sphinx
 from sphinx.parsers import Parser as SphinxParser
+from sphinx.util import logging
 from sphinx.writers.html import HTMLWriter
 
+logger = logging.getLogger(__name__)
 namespaces = {"tei": "http://www.tei-c.org/ns/1.0", "uedition": "https://uedition.readthedocs.org"}
 
 
@@ -33,18 +37,18 @@ class TeiElement(nodes.Element):
 def tei_element_html_enter(self: "HTMLWriter", node: TeiElement) -> None:
     """Visit a TeiElement and generate the correct HTML."""
     if node.get("html_tag") is not None:
-        buffer = [f'<{node.get("html_tag")} data-tei-tag="{node.get("tei_tag")[29:]}"']
+        buffer = [f"<{node.get('html_tag')}"]
         if node.get("ids"):
             buffer.append(f' id="{node.get("ids")[0]}"')
         for key, value in node.get("tei_attributes").items():
             buffer.append(f' {key}="{value}"')
-        self.body.append(f'{"".join(buffer)}>')
+        self.body.append(f"{''.join(buffer)}>")
 
 
 def tei_element_html_exit(self: "HTMLWriter", node: TeiElement) -> None:
     """Close the HTML tag."""
     if node.get("html_tag") is not None:
-        self.body.append(f'</{node.get("html_tag")}>')
+        self.body.append(f"</{node.get('html_tag')}>")
 
 
 class TEIParser(SphinxParser):
@@ -54,7 +58,8 @@ class TEIParser(SphinxParser):
     """Specify that only .tei files are parsed"""
 
     def parse(self: "TEIParser", inputstring: str, document: nodes.document) -> None:
-        """Parse source TEI text.
+        """
+        Parse source TEI text.
 
         This function creates the basic structure and then the :func:`~uEdition.extensions.tei.TEIParser._walk_tree`
         function is used to actually process the XML.
@@ -75,43 +80,55 @@ class TEIParser(SphinxParser):
         doc_title = nodes.title()
         doc_title.append(nodes.Text(title if title else "[Untitled]"))
         doc_section.append(doc_title)
-        if "tei" in self.config.uEdition and "sections" in self.config.uEdition["tei"]:
-            for conf_section in self.config.uEdition["tei"]["sections"]:
-                section = nodes.section(ids=[nodes.make_id(conf_section["title"])])
+        for conf_section in self.config.tei["sections"]:
+            section = nodes.section(ids=[nodes.make_id(conf_section["name"])])
+            if conf_section["title"]:
                 section_title = nodes.title()
                 section_title.append(nodes.Text(conf_section["title"]))
                 section.append(section_title)
-                if conf_section["type"] == "text":
-                    # Process a text section
-                    source = root.xpath(conf_section["content"], namespaces=namespaces)
-                    if len(source) > 0:
-                        if conf_section["sort"]:
-                            source.sort(key=self._sort_key(conf_section["sort"]))
-                        doc_section.append(section)
-                        tmp = nodes.section()
+            if conf_section["type"] == "text":
+                # Process a text section
+                sources = root.xpath(conf_section["selector"], namespaces=namespaces)
+                if len(sources) > 0:
+                    doc_section.append(section)
+                    tmp = nodes.section()
+                    for source in sources:
                         for child in source:
-                            self._walk_tree(child, tmp, conf_section["mappings"])
-                        self._wrap_sections(section, tmp)
-                elif conf_section["type"] == "fields":
-                    # Process a field or metadata section
+                            self._walk_tree(child, tmp)
+                    self._wrap_sections(section, tmp)
+            elif conf_section["type"] == "textlist":
+                # Process a text section
+                sources = root.xpath(conf_section["selector"], namespaces=namespaces)
+                if len(sources) > 0:
+                    if conf_section["sort"]:
+                        source.sort(key=self._sort_key(conf_section["sort"]))
+                    doc_section.append(section)
+                    for source in sources:
+                        tmp = nodes.section(ids=[source.attrib["id"]])
+                        for child in source:
+                            self._walk_tree(child, tmp)
+                        section.append(tmp)
+                    # self._wrap_sections(section, tmp)
+            elif conf_section["type"] == "metadata":
+                # Process a field or metadata section
+                sources = root.xpath(conf_section["selector"], namespaces=namespaces)
+                if len(sources) > 0:
                     doc_section.append(section)
                     fields = nodes.definition_list()
                     section.append(fields)
                     for field in conf_section["fields"]:
                         if field["type"] == "single":
-                            self._parse_single_field(fields, field, root)
+                            self._parse_single_field(fields, field, sources[0])
                         elif field["type"] == "list":
-                            self._parse_list_field(fields, field, root)
+                            self._parse_list_field(fields, field, sources[0])
                         elif field["type"] == "download":
-                            self._parse_download_field(fields, field, root)
+                            self._parse_download_field(fields, field, sources[0])
         document.append(doc_section)
 
-    def _sort_key(
-        self: "TEIParser", xpath: str
-    ) -> Callable[[etree.Element], tuple[str, ...] | tuple[int, ...] | tuple[None]]:
+    def _sort_key(self: "TEIParser", xpath: str) -> Callable[[etree.Element], tuple[tuple[int, ...], ...]]:
         """Create a sortkey that understands about `page,line` patterns for sorting."""
 
-        def sorter(node: etree.Element) -> tuple[str, ...] | tuple[int, ...] | tuple[None]:
+        def sorter(node: etree.Element) -> tuple[tuple[int, ...], ...]:
             value = node.xpath(xpath, namespaces=namespaces)
             if value is not None and len(value) > 0:
                 if isinstance(value, list):
@@ -128,74 +145,57 @@ class TEIParser(SphinxParser):
                         else:
                             order.append(tpl)
                     return tuple(order)
-            return (0,)
+            return ((0,),)
 
         return sorter
 
-    def _walk_tree(self: "TEIParser", node: etree.Element, parent: nodes.Element, rules: list) -> None:
-        """Walk the XML tree and create the appropriate AST nodes.
+    def _walk_tree(self: "TEIParser", node: etree.Element, parent: nodes.Element) -> None:
+        """Walk the XML tree and create the appropriate AST nodes."""
+        for conf in self.config.tei["blocks"]:
+            if len(node.xpath(f"self::{conf['selector']}", namespaces=namespaces)) > 0:
+                attrs = self._parse_attributes(node, conf["attributes"])
+                attrs.update({f"data-tei-block-{conf['name']}": ""})
+                element = TeiElement(
+                    html_tag=conf["tag"] if conf["tag"] else "div", tei_tag=node.tag, tei_attributes=attrs
+                )
+                for child in node:
+                    self._walk_tree(child, element)
+                parent.append(element)
+                return
+        for conf in self.config.tei["marks"]:
+            if len(node.xpath(f"self::{conf['selector']}", namespaces=namespaces)) > 0:
+                attrs = self._parse_attributes(node, conf["attributes"])
+                attrs.update({f"data-tei-mark-{conf['name']}": ""})
+                element = TeiElement(
+                    html_tag=conf["tag"] if conf["tag"] else "span", tei_tag=node.tag, tei_attributes=attrs
+                )
+                if len(node) == 0 and node.text:
+                    element.append(nodes.Text(node.text))
+                else:
+                    for child in node:
+                        self._walk_tree(child, element)
+                parent.append(element)
+                return
+        if len(node) == 0:
+            parent.append(nodes.Text(node.text))
+        else:
+            logger.warning(f"No block or mark configured for {node.tag}")
 
-        Uses the mapping rules defined in :mod:`~uEdition.extensions.config` to determine what to
-        map the XML to.
-        """
-        is_leaf = len(node) == 0
-        text_only_in_leaf_nodes = (
-            self.config.uEdition["tei"]["text_only_in_leaf_nodes"] if "tei" in self.config.uEdition else False
-        )
-        attributes = {}
-        # Get the first matching rule for the current node
-        rule = self._rule_for_node(node, rules)
-        # Loop over the XML node attributes and apply any attribute transforms defined in the matching rule
-        for key, value in node.attrib.items():
-            # Always strip the namespace from the `id` attribute
-            if key == "{http://www.w3.org/XML/1998/namespace}id":
-                key = "id"  # noqa: PLW2901
-            if rule and "attributes" in rule:
-                processed = False
-                for attr_rule in rule["attributes"]:
-                    if attr_rule["action"] == "copy":
-                        if key == attr_rule["source"]:
-                            # Copied attributes are added without a `data-` prefix
-                            attributes[attr_rule["attr"]] = value
-                    elif attr_rule["action"] == "delete":
-                        if key == attr_rule["attr"]:
-                            processed = True
-                    elif attr_rule["action"] == "set":
-                        if key == attr_rule["attr"]:
-                            value = attr_rule["value"]  # noqa: PLW2901
-                # if the attribute did not match any attribute transform
-                if not processed:
-                    # The id attribute is always output as is, all other attributes are prefixed with `data-`
-                    if key == "id":
-                        attributes["id"] = value
-                    else:
-                        attributes[f"data-{key}"] = value
-            else:  # noqa: PLR5501
-                # The id attribute is always output as is, all other attributes are prefixed with `data-`
-                if key == "id":
-                    attributes["id"] = value
+    def _parse_attributes(self, node: etree.Element, attribute_configs: list) -> dict:
+        attrs = {}
+        for conf in attribute_configs:
+            if conf["name"] in node.attrib:
+                if conf["type"] == "id-ref" and node.attrib[conf["name"]].startswith("#"):
+                    attrs[f"data-tei-attribute-{conf['name']}"] = node.attrib[conf["name"]][1:]
+                elif conf["type"] == "static":
+                    attrs[f"data-tei-attribute-{conf['name']}"] = conf["value"]
+                elif conf["type"] == "html-attribute":
+                    attrs[conf["target"]] = node.attrib[conf["name"]]
                 else:
-                    attributes[f"data-{key}"] = value
-        # Create the docutils AST element
-        new_element = TeiElement(
-            html_tag=rule["tag"] if rule is not None and "tag" in rule else "div",
-            tei_tag=node.tag,
-            tei_attributes=attributes,
-        )
-        parent.append(new_element)
-        if rule is not None and "text" in rule and rule["text"]:
-            # If there is a `text` key in the rule, use that to set the text
-            if rule["text"]["action"] == "from-attribute" and rule["text"]["attr"] in node.attrib:
-                new_element.append(nodes.Text(node.attrib[rule["text"]["attr"]]))
-        elif node.text and (is_leaf or not text_only_in_leaf_nodes):
-            # Only create text content if there is text and we either are in a leaf node or are adding all text
-            new_element.append(nodes.Text(node.text))
-        # Process any children
-        for child in node:
-            self._walk_tree(child, new_element, rules)
-        # If there is text after this XML node and we are adding all text, then add text content to the parent
-        if node.tail and not text_only_in_leaf_nodes:
-            parent.append(nodes.Text(node.tail))
+                    attrs[f"data-tei-attribute-{conf['name']}"] = node.attrib[conf["name"]]
+            elif conf["default"]:
+                attrs[f"data-tei-attribute-{conf['name']}"] = conf["default"]
+        return attrs
 
     def _wrap_sections(self: "TEIParser", section: nodes.Element, tmp: nodes.Element) -> None:
         """Ensure that sections are correctly wrapped."""
@@ -213,7 +213,7 @@ class TEIParser(SphinxParser):
                 while section_level <= section_stack[-1][0]:
                     section_stack.pop()
                 new_section = nodes.section(ids=[nodes.make_id(node.astext())])
-                title = nodes.title()
+                title = nodes.title(attributes={"data-test": ""})
                 title.children = node.children
                 new_section.append(title)
                 section_stack[-1][1].append(new_section)
@@ -239,25 +239,9 @@ class TEIParser(SphinxParser):
                 if not in_heading:
                     section_stack[-1][1].append(node)
 
-    def _rule_for_node(self: "TEIParser", node: etree.Element, rules: list[dict]) -> dict:
-        """Determine the first matching mapping rule for the node from the configured rules."""
-        tei_tag = node.tag
-        for rule in rules:
-            if rule["selector"]["tag"] == tei_tag:
-                if "attributes" in rule["selector"]:
-                    attr_match = True
-                    for attr_rule in rule["selector"]["attributes"]:
-                        if attr_rule["attr"] not in node.attrib or node.attrib[attr_rule["attr"]] != attr_rule["value"]:
-                            attr_match = False
-                            break
-                    if not attr_match:
-                        continue
-                return rule
-        return None
-
     def _parse_single_field(self: "TEIParser", parent: etree.Element, field: dict, root: etree.Element) -> None:
         """Parse a single metadata field."""
-        content = root.xpath(field["content"], namespaces=namespaces)
+        content = root.xpath(field["selector"], namespaces=namespaces)
         if len(content) > 0:
             if isinstance(content, list):
                 content = content[0]

uedition/settings.py

@@ -5,6 +5,7 @@
 
 All application settings are accessed via the `settings` dictionary.
 """
+
 import os
 from typing import Annotated, Any, Dict, Tuple, Type
 
@@ -15,11 +16,21 @@ from pydantic_settings import BaseSettings, PydanticBaseSettingsSource
 from yaml import safe_load
 
 
+class NoConfigError(Exception):
+    """Exception to signal that no configuration file was found in the current directory."""
+
+    def __init__(self) -> None:
+        """Initialise the Exception with the default error message."""
+        super().__init__("No uEdition.yml or uEdition.yaml was found in the current directory")
+
+
 class YAMLConfigSettingsSource(PydanticBaseSettingsSource):
     """Loads the configuration settings from a YAML file."""
 
     def get_field_value(
-        self: "YAMLConfigSettingsSource", field: FieldInfo, field_name: str  # noqa: ARG002
+        self: "YAMLConfigSettingsSource",
+        field: FieldInfo,  # noqa: ARG002
+        field_name: str,
     ) -> Tuple[Any, str, bool]:
         """Get the value of a specific field."""
         encoding = self.config.get("env_file_encoding")
@@ -75,8 +86,6 @@ class RepositorySettings(BaseModel):
 
     url: str | None = None
     """The repository's URL."""
-    branch: str | None = None
-    """The repository's branch."""
 
 
 class AuthorSettings(BaseModel):
@@ -107,7 +116,7 @@ def convert_output_str_to_dict(value: str | dict) -> dict:
 class Settings(BaseSettings):
     """Application settings."""
 
-    version: str = "1"
+    version: str = "2"
     """The configuration file version."""
     author: AuthorSettings = AuthorSettings()
     """The author settings."""
@@ -119,8 +128,8 @@ class Settings(BaseSettings):
     """The repository settings."""
     title: dict = {}
     """The titles for the individual languages."""
-    jb_config: dict = {}
-    """Additional JupyterBook configuration."""
+    sphinx_config: dict = {}
+    """Sphinx configuration."""
 
     @classmethod
     def settings_customise_sources(
@@ -147,4 +156,4 @@ settings = Settings().model_dump()
 def reload_settings() -> None:
     """Reload the settings."""
     settings.clear()
-    settings.update(Settings().dict())
+    settings.update(Settings().model_dump())

{uedition-1.3.1.dist-info → uedition-2.0.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: uEdition
-Version: 1.3.1
+Version: 2.0.0a1
 Project-URL: Documentation, https://github.com/uEdition/uEdition#readme
 Project-URL: Issues, https://github.com/uEdition/uEdition/issues
 Project-URL: Source, https://github.com/uEdition/uEdition
@@ -11,17 +11,22 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
 Requires-Dist: copier<10.0.0,>=9.0.0
-Requires-Dist: jupyter-book<2.0.0,>=1.0.0
 Requires-Dist: livereload
 Requires-Dist: lxml<6.0.0,>=4.9.2
+Requires-Dist: myst-parser<5,>=4.0.1
 Requires-Dist: pydantic-settings<3.0.0,>=2.0.0
 Requires-Dist: pydantic<3.0.0,>=2.0.0
 Requires-Dist: pyyaml<7.0.0,>=6.0.0
-Requires-Dist: typer[all]<1.0.0
+Requires-Dist: sphinx-book-theme<2,>=1.1.4
+Requires-Dist: sphinx-external-toc<2,>=1.0.1
+Requires-Dist: sphinx<9,>=8.2.3
+Requires-Dist: typer<1.0.0
 Description-Content-Type: text/markdown
 
 # μEdition

uedition-2.0.0a1.dist-info/RECORD

@@ -0,0 +1,25 @@
+uedition/__about__.py,sha256=kq7WGmRyG7G8lDeopl9H4oZ4X9xtex9Qs3BryTuumU0,160
+uedition/__init__.py,sha256=xDDK2i5l1NLhxq6_LJH5g7UJDrFEjIJNmT2tcg7xNWI,301
+uedition/__main__.py,sha256=Pg_yGV-ndR2iiImDC3f017llSX6pSYMslIwZlw8vEpQ,189
+uedition/settings.py,sha256=G73r6muJmRzuENZ-2n51bBf88qS3tRv0kdxr2SRt1j4,5048
+uedition/cli/__init__.py,sha256=gnpl_N8uaw-4uF5ByWV3jXveJBvjLb_uay5YkYCUQWw,1478
+uedition/cli/build.py,sha256=L_-OsIEFBXQh-aTHLwLhOXJzXqRH61X2SgVIPxmUgQ0,8169
+uedition/cli/create.py,sha256=Q-SvDq9VtmUP4DQhuuvt1eZ_72sX8_tcFOj2Bt_T6J8,371
+uedition/cli/language.py,sha256=JAyUwNa4gwqMvrJDPPKGkMLm5Cx9sHJkU5r6xTAMb7M,2214
+uedition/cli/serve.py,sha256=FcKp0IbjcyCgn1XjU8VdhI59pGRMNCSXa5jbAS23nxs,1513
+uedition/cli/update.py,sha256=SmAcczHxj3j3X0QYplvXPoIHS8XEfXYVqgXBney0v9c,550
+uedition/ext/__init__.py,sha256=hAK3MB5il4tAkfWnZNVxIJhfJ5vN0Fdmmtz0ZAYsvo4,406
+uedition/ext/config.py,sha256=zu0XSH3Ca09n--umhUJ7k6611lVCecOTVZCWAFn4TRU,994
+uedition/ext/language_switcher.css,sha256=y4LzkCgCm6E_nHt15I4Ku5QzBNpjwda9bt9FsqD1ybM,132
+uedition/ext/language_switcher.js,sha256=HIgQiLg0WGS_G_VjpfEpTDLqb1HwHxcL3r6mdoSUix4,2697
+uedition/ext/language_switcher.py,sha256=tHpf4HsvMtatVn5dQ3EFlrk5urFaMzsZZY755cvgCu8,1425
+uedition/ext/settings.py,sha256=CCbvwlWjhikhoeRZ5E_SuA4zUIqDBMkRes_hjOUxjWk,3735
+uedition/ext/tei/__init__.py,sha256=8KgVi31bz8nI65m6u4EdT_f1qNCP45HrU0V7MSGlZxA,1074
+uedition/ext/tei/builder.py,sha256=LkLR3cu1M6lHHdcjhH5esZ9Qn6eFBXCZWkxVxdXv69E,11719
+uedition/ext/tei/parser.py,sha256=ebeqEiji2RZ-Gfszf0Yaa-Lqww-EPqLmxXiMBq-gj90,13216
+uedition/ext/tei/tei_download.js,sha256=5_IPCuamZGPXWriPPPz5wA-zo0Y0Oy1858S6ltxSdQ8,2151
+uedition-2.0.0a1.dist-info/METADATA,sha256=YquOplbaOq4Z17fRpMEQMK2S1imGpd0HS3TWeCaWXEk,2572
+uedition-2.0.0a1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uedition-2.0.0a1.dist-info/entry_points.txt,sha256=cDOOVBb1SZ072ZkY1hW4Y7I_WKKGCtCJtDY1XST1Hr4,96
+uedition-2.0.0a1.dist-info/licenses/LICENSE.txt,sha256=MhLJl8GE8mnuO5i_pvKaobpIGnhiAEdkY-a6LKiuwCE,1101
+uedition-2.0.0a1.dist-info/RECORD,,

{uedition-1.3.1.dist-info → uedition-2.0.0a1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.21.1
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

uedition/cli/check.py

@@ -1,183 +0,0 @@
-# SPDX-FileCopyrightText: 2023-present Mark Hall <mark.hall@work.room3b.eu>
-#
-# SPDX-License-Identifier: MIT
-"""The uEdition check functionality for validating a uEdition and its files."""
-import os
-from threading import Thread
-
-import typer
-from rich import print as print_cli
-from rich.progress import Progress
-from yaml import safe_load
-
-from uedition.settings import settings
-
-
-def collect_files(toc: dict) -> list[str]:
-    """Collect all files from a TOC."""
-    files = []
-    if "parts" in toc:
-        for part in toc["parts"]:
-            files.extend(collect_files(part))
-    elif "chapters" in toc:
-        for chapter in toc["chapters"]:
-            files.append(chapter["file"])
-            files.extend(collect_files(chapter))
-    elif "sections" in toc:
-        for sections in toc["sections"]:
-            files.append(sections["file"])
-    return files
-
-
-def compare_tocs(prefix: str, toc_a: dict, toc_b: dict) -> list[tuple[str | None, str | None]]:
-    """Recursively compare the structure of two TOCs."""
-    mismatches = []
-    if "parts" in toc_a and "parts" in toc_b:
-        pass
-    elif "chapters" in toc_a and "chapters" in toc_b:
-        pass
-    elif "sections" in toc_a and "sections" in toc_b:
-        pass
-    elif "parts" in toc_a:
-        mismatches.append(f"{prefix}has parts, which are missing from")
-    elif "chapters" in toc_a:
-        mismatches.append(f"{prefix}has chapters, which are missing from")
-    elif "sections" in toc_b:
-        mismatches.append(f"{prefix}has sections, which are missing from")
-    return mismatches
-
-
-class ConfigurationFileChecks(Thread):
-    """Basic configuration file checks."""
-
-    def __init__(self: "ConfigurationFileChecks", progress: Progress, task: int) -> None:
-        """Initialise the thread."""
-        super().__init__(group=None)
-        self._progress = progress
-        self._task = task
-        self.errors = []
-
-    def run(self: "ConfigurationFileChecks") -> None:
-        """Run the checks."""
-        for lang in settings["languages"]:
-            yaml_path = os.path.join(lang["path"], "_config.yml")
-            if os.path.exists(yaml_path):
-                with open(yaml_path) as in_f:
-                    try:
-                        safe_load(in_f)
-                    except Exception as e:
-                        self.errors.append(str(e))
-            else:
-                self.errors.append(f"Missing configuration file {yaml_path}")
-            self._progress.update(self._task, advance=1)
-
-
-class TocFileChecks(Thread):
-    """TOC file checks."""
-
-    def __init__(self: "TocFileChecks", progress: Progress, task: int) -> None:
-        """Initialise the thread."""
-        super().__init__(group=None)
-        self._progress = progress
-        self._task = task
-        self.errors = []
-
-    def run(self: "TocFileChecks") -> None:
-        """Run the checks."""
-        for lang in settings["languages"]:
-            yaml_path = os.path.join(lang["path"], "_toc.yml")
-            if os.path.exists(yaml_path):
-                with open(yaml_path) as in_f:
-                    try:
-                        toc = safe_load(in_f)
-                        if "root" in toc:
-                            root_path = os.path.join(lang["path"], f'{toc["root"]}.md')
-                            if not os.path.exists(root_path):
-                                self.errors.append(f'Root in {yaml_path} points to missing file {toc["root"]}.md')
-                            root_base = os.path.dirname(root_path)
-                            for filename in collect_files(toc):
-                                if not os.path.exists(os.path.join(root_base, f"{filename}.md")):
-                                    self.errors.append(f"File {filename}.md missing in {yaml_path}")
-                        else:
-                            self.errors.append(f"No root in {yaml_path}")
-                    except Exception as e:
-                        self.errors.append(str(e))
-            else:
-                self.errors.append(f"Missing toc file {yaml_path}")
-            self._progress.update(self._task, advance=1)
-
-
-class LanguageConsistencyChecks(Thread):
-    """Multi-language consistency checks."""
-
-    def __init__(self: "LanguageConsistencyChecks", progress: Progress, task: int) -> None:
-        """Initialise the thread."""
-        super().__init__(group=None)
-        self._progress = progress
-        self._task = task
-        self.errors = []
-
-    def run(self: "LanguageConsistencyChecks") -> None:
-        """Run the checks."""
-        if len(settings["languages"]) == 0:
-            return
-        base_toc_path = os.path.join(settings["languages"][0]["path"], "_toc.yml")
-        if not os.path.exists(base_toc_path):
-            return
-        with open(base_toc_path) as in_f:
-            try:
-                base_toc = safe_load(in_f)
-            except Exception:
-                return
-        for lang in settings["languages"][1:]:
-            lang_toc_path = os.path.join(lang["path"], "_toc.yml")
-            if not os.path.exists(lang_toc_path):
-                continue
-            try:
-                with open(lang_toc_path) as in_f:
-                    lang_toc = safe_load(in_f)
-                missmatches = compare_tocs("", base_toc, lang_toc)
-                if len(missmatches) > 0:
-                    for mismatch in missmatches:
-                        if mismatch[0] is None:
-                            self.errors.append(f"{base_toc_path} {mismatch[1]} {lang_toc_path}")
-                        elif mismatch[0] is None:
-                            self.errors.append(f"{lang_toc_path} {mismatch[0]} {base_toc_path}")
-                self._progress.update(self._task, advance=1)
-            except Exception as e:
-                self.errors.append(f"Fail to check langauge {lang}: {e!s}")
-
-
-def run() -> None:
-    """Check that the μEdition is correctly set up."""
-    errors = []
-    with Progress() as progress:
-        threads = [
-            ConfigurationFileChecks(
-                progress,
-                progress.add_task("[green]Configuration file checks", total=len(settings["languages"])),
-            ),
-            TocFileChecks(
-                progress,
-                progress.add_task("[green]TOC file checks", total=len(settings["languages"])),
-            ),
-            LanguageConsistencyChecks(
-                progress,
-                progress.add_task(
-                    "[green]Language consistency checks",
-                    total=len(settings["languages"]) - 1,
-                ),
-            ),
-        ]
-        for thread in threads:
-            thread.start()
-        for thread in threads:
-            thread.join()
-            errors.extend(thread.errors)
-    if len(errors) > 0:
-        print_cli("[red]:bug: The following errors were found:")
-        for error in errors:
-            print_cli(f"[red]* {error}")
-        raise typer.Exit(code=1)
-    else:
-        print_cli("[green]:+1: All checks successfully passed")

uedition-1.3.1.dist-info/RECORD

@@ -1,25 +0,0 @@
-uedition/__about__.py,sha256=prXHbrDuklWCBT07mMmChRQEDb1vRZGlN7s_X2peuB8,157
-uedition/__init__.py,sha256=xDDK2i5l1NLhxq6_LJH5g7UJDrFEjIJNmT2tcg7xNWI,301
-uedition/__main__.py,sha256=Pg_yGV-ndR2iiImDC3f017llSX6pSYMslIwZlw8vEpQ,189
-uedition/settings.py,sha256=4jWfjD1KmYTwzeD6DhP9taWS-zFp9XHxo1QqUqsSlrA,4774
-uedition/cli/__init__.py,sha256=h3N4ZwgRC72IlkCsTbke4PLTFv-_pn1-npXXPC7S78U,1642
-uedition/cli/build.py,sha256=qrpNP227DlTqa6pHX3NrDw1cohc1dHPi5J6pMFgxKsk,8135
-uedition/cli/check.py,sha256=Jlkyw6mgcz3HM-wJpmzCtKv054MFolCe7m6bSUDtsZA,7005
-uedition/cli/create.py,sha256=Q-SvDq9VtmUP4DQhuuvt1eZ_72sX8_tcFOj2Bt_T6J8,371
-uedition/cli/language.py,sha256=IqSJrZbrQzU-7TJqnCBeC2HUs1N01EAa7jFMvfXTsoA,1943
-uedition/cli/serve.py,sha256=UfVsY26OW9yAz7rnjjatz1gEDGIi1kaTYlkUAiVCuRw,1391
-uedition/cli/update.py,sha256=XKHnvorHqizsB5zP-8ifMrgnQuq6zRk6Tb03dBz_MI4,377
-uedition/ext/__init__.py,sha256=hAK3MB5il4tAkfWnZNVxIJhfJ5vN0Fdmmtz0ZAYsvo4,406
-uedition/ext/config.py,sha256=eEkBkAOaDQPzO_2Uj5OJxyAZiCG4I-TcOEqUyIY8IFY,6023
-uedition/ext/language_switcher.css,sha256=y4LzkCgCm6E_nHt15I4Ku5QzBNpjwda9bt9FsqD1ybM,132
-uedition/ext/language_switcher.js,sha256=HIgQiLg0WGS_G_VjpfEpTDLqb1HwHxcL3r6mdoSUix4,2697
-uedition/ext/language_switcher.py,sha256=tHpf4HsvMtatVn5dQ3EFlrk5urFaMzsZZY755cvgCu8,1425
-uedition/ext/tei/__init__.py,sha256=8KgVi31bz8nI65m6u4EdT_f1qNCP45HrU0V7MSGlZxA,1074
-uedition/ext/tei/builder.py,sha256=XLFM11Gnt_4G4H-2gaJyjOgko_aMmvgZnKftMsSk8qw,11743
-uedition/ext/tei/parser.py,sha256=dCtaYB8jTXKUdUzpEkoCEyRBIu5cDUpnu7TZSs7Ko0I,14342
-uedition/ext/tei/tei_download.js,sha256=5_IPCuamZGPXWriPPPz5wA-zo0Y0Oy1858S6ltxSdQ8,2151
-uedition-1.3.1.dist-info/METADATA,sha256=5vBeefaNrZ99Ep5y2B_A5FXXPolShaBqTCcrW5tVLHI,2358
-uedition-1.3.1.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
-uedition-1.3.1.dist-info/entry_points.txt,sha256=cDOOVBb1SZ072ZkY1hW4Y7I_WKKGCtCJtDY1XST1Hr4,96
-uedition-1.3.1.dist-info/licenses/LICENSE.txt,sha256=MhLJl8GE8mnuO5i_pvKaobpIGnhiAEdkY-a6LKiuwCE,1101
-uedition-1.3.1.dist-info/RECORD,,