PyPI - uEdition - Versions diffs - 1.3.2__py3-none-any.whl → 2.0.0a1__py3-none-any.whl - Mend

uEdition 1.3.2py3-none-any.whl → 2.0.0a1py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of uEdition might be problematic. Click here for more details.

Files changed (18) hide show

uedition/__about__.py +2 -1
uedition/cli/__init__.py +0 -7
uedition/cli/build.py +75 -68
uedition/cli/language.py +6 -0
uedition/cli/serve.py +3 -1
uedition/cli/update.py +6 -0
uedition/ext/config.py +9 -175
uedition/ext/settings.py +131 -0
uedition/ext/tei/builder.py +2 -3
uedition/ext/tei/parser.py +88 -102
uedition/settings.py +16 -7
{uedition-1.3.2.dist-info → uedition-2.0.0a1.dist-info}/METADATA +9 -4
uedition-2.0.0a1.dist-info/RECORD +25 -0
{uedition-1.3.2.dist-info → uedition-2.0.0a1.dist-info}/WHEEL +1 -1
uedition/cli/check.py +0 -183
uedition-1.3.2.dist-info/RECORD +0 -25
{uedition-1.3.2.dist-info → uedition-2.0.0a1.dist-info}/entry_points.txt +0 -0
{uedition-1.3.2.dist-info → uedition-2.0.0a1.dist-info}/licenses/LICENSE.txt +0 -0

uedition/__about__.py CHANGED Viewed

@@ -2,4 +2,5 @@
 #
 # SPDX-License-Identifier: MIT
 """About this package."""
-__version__ = "1.3.2"
+__version__ = "2.0.0a1"

uedition/cli/__init__.py CHANGED Viewed

@@ -7,7 +7,6 @@ from rich import print as print_cli
 from uedition.__about__ import __version__
 from uedition.cli import build as build_module
-from uedition.cli import check as check_module
 from uedition.cli import create as create_module
 from uedition.cli import language as language_module
 from uedition.cli import serve as serve_module
@@ -37,12 +36,6 @@ def serve() -> None:
     serve_module.run()
-@app.command()
-def check() -> None:
-    """Check that the μEdition is set up correctly."""
-    check_module.run()
 @app.command()
 def update() -> None:
     """Update the μEdition."""

uedition/cli/build.py CHANGED Viewed

@@ -2,15 +2,15 @@
 #
 # SPDX-License-Identifier: MIT
 """Build functionality."""
 import json
 import subprocess
-from copy import deepcopy
 from os import makedirs, path
 from shutil import copytree, ignore_patterns, rmtree
 from yaml import safe_dump, safe_load
-from uedition.settings import reload_settings, settings
+from uedition.settings import NoConfigError, reload_settings, settings
 LANDING_PAGE_TEMPLATE = """\
 <!DOCTYPE html>
@@ -103,41 +103,50 @@ def toc_build(lang: dict) -> None:
 def config_build(lang: dict) -> None:
-    """Build the language-specific JupyterBook config based on the main config."""
-    config = deepcopy(settings["jb_config"])
-    config["author"] = settings["author"]["name"]
-    # Set the language-specific title
+    """Build the language-specific Sphinx config based on the main config."""
+    with open("toc.yml") as in_f:
+        toc = safe_load(in_f)
+    # Build the default configuration
+    config = {
+        "needs_sphinx": "8",
+        "language": lang["code"],
+        "root_doc": toc["root"],
+        "html_theme": "sphinx_book_theme",
+        "html_theme_options": {},
+        "extensions": ["myst_parser", "sphinx_external_toc", "uedition"],
+        "myst_enable_extensions": [
+            "amsmath",
+            "attrs_inline",
+            "colon_fence",
+            "deflist",
+            "dollarmath",
+            "fieldlist",
+            "html_admonition",
+            "html_image",
+            "replacements",
+            "smartquotes",
+            "strikethrough",
+            "substitution",
+            "tasklist",
+        ],
+    }
+    # Load in any sphinx configuration
+    config.update(settings["sphinx_config"])
+    # Set settings-based
     if lang["code"] in settings["title"]:
-        config["title"] = settings["title"][lang["code"]]
+        config["project"] = settings["title"][lang["code"]]
     elif len(settings["languages"]) > 0 and settings["languages"][0]["code"] in settings["title"]:
-        config["title"] = settings["title"][settings["languages"][0]["code"]]
+        config["project"] = settings["title"][settings["languages"][0]["code"]]
     else:
-        config["title"] = f"Missing title for {lang['label']}"
-    # Set the repository information
-    if settings["repository"]["url"] and "repository" not in config:
-        config["repository"] = {
-            "url": settings["repository"]["url"],
-            "path": lang["path"],
-            "branch": settings["repository"]["branch"],
-        }
-        if "html" not in config:
-            config["html"] = {}
-        if "use_repository_button" not in config["html"]:
-            config["html"]["use_repository_button"] = True
-    # Set the Sphinx language
-    if "sphinx" not in config:
-        config["sphinx"] = {}
-    if "config" not in config["sphinx"]:
-        config["sphinx"]["config"] = {}
-    config["sphinx"]["config"]["language"] = lang["code"]
-    # Add the uEdition extension
-    if "extra_extensions" not in config["sphinx"]:
-        config["sphinx"]["extra_extensions"] = []
-    if "uedition" not in config["sphinx"]["extra_extensions"]:
-        config["sphinx"]["extra_extensions"].append("uedition")
-    with open(path.join(lang["path"], "_config.yml"), "w") as out_f:
-        safe_dump(config, out_f, encoding="utf-8")
+        config["project"] = f"Missing title for {lang['label']}"
+    config["author"] = settings["author"]["name"]
+    if settings["repository"]["url"]:
+        config["html_theme_options"]["repository_url"] = f"{settings['repository']['url']}"
+        config["html_theme_options"]["use_repository_button"] = True
+    with open(path.join(lang["path"], "conf.py"), "w") as out_f:
+        for name, value in config.items():
+            out_f.write(f"{name} = {value!a}\n")
 def static_build(lang: dict) -> None:
@@ -153,41 +162,39 @@ def full_build(lang: dict) -> None:
     toc_build(lang)
     config_build(lang)
     static_build(lang)
-    subprocess.run(
-        [  # noqa: S603, S607
-            "jupyter-book",
-            "build",
-            "--all",
-            "--path-output",
-            path.join("_build", lang["path"]),
+    subprocess.run(  # noqa:S603
+        [  # noqa:  S607
+            "sphinx-build",
+            "--builder",
+            "html",
+            "--fresh-env",
             lang["path"],
+            path.join("_build", lang["path"], "html"),
         ],
         check=False,
+        shell=False,
     )
     if settings["output"]["tei"]:
-        subprocess.run(
-            [  # noqa: S603, S607
-                "jupyter-book",
-                "build",
-                "--all",
-                "--path-output",
-                path.join("_build", lang["path"]),
+        subprocess.run(  # noqa: S603
+            [  # noqa:S607
+                "sphinx-build",
                 "--builder",
-                "custom",
-                "--custom-builder",
                 "tei",
+                "--fresh-env",
                 lang["path"],
+                path.join("_build", lang["path"], "tei"),
             ],
             check=False,
+            shell=False,
         )
     copytree(
-        path.join("_build", lang["path"], "_build", "html"),
+        path.join("_build", lang["path"], "html"),
         path.join(settings["output"]["path"], lang["path"]),
         dirs_exist_ok=True,
     )
     if settings["output"]["tei"]:
         copytree(
-            path.join("_build", lang["path"], "_build", "tei"),
+            path.join("_build", lang["path"], "tei"),
             path.join(settings["output"]["path"], lang["path"]),
             ignore=ignore_patterns("_sphinx_design_static"),
             dirs_exist_ok=True,
@@ -197,39 +204,37 @@ def full_build(lang: dict) -> None:
 def partial_build(lang: dict) -> None:
     """Run the as-needed build process for a single language."""
     landing_build()
-    subprocess.run(
-        [  # noqa: S603, S607
-            "jupyter-book",
-            "build",
-            "--path-output",
-            path.join("_build", lang["path"]),
+    subprocess.run(  # noqa: S603
+        [  # noqa: S607
+            "sphinx-build",
+            "--builder",
+            "html",
             lang["path"],
+            path.join("_build", lang["path"], "html"),
         ],
         check=False,
+        shell=False,
     )
     if settings["output"]["tei"]:
-        subprocess.run(
-            [  # noqa: S603, S607
-                "jupyter-book",
-                "build",
-                "--path-output",
-                path.join("_build", lang["path"]),
+        subprocess.run(  # noqa:S603
+            [  # noqa: S607
+                "sphinx-build",
                 "--builder",
-                "custom",
-                "--custom-builder",
                 "tei",
                 lang["path"],
+                path.join("_build", lang["path"], "tei"),
             ],
             check=False,
+            shell=False,
         )
     copytree(
-        path.join("_build", lang["path"], "_build", "html"),
+        path.join("_build", lang["path"], "html"),
         path.join(settings["output"]["path"], lang["path"]),
         dirs_exist_ok=True,
     )
     if settings["output"]["tei"]:
         copytree(
-            path.join("_build", lang["path"], "_build", "tei"),
+            path.join("_build", lang["path"], "tei"),
             path.join(settings["output"]["path"], lang["path"]),
             ignore=ignore_patterns("_sphinx_design_static"),
             dirs_exist_ok=True,
@@ -238,6 +243,8 @@ def partial_build(lang: dict) -> None:
 def run() -> None:
     """Build the full uEdition."""
+    if not path.exists("uEdition.yml") and not path.exists("uEdition.yaml"):
+        raise NoConfigError()
     if path.exists(settings["output"]["path"]):
         rmtree(settings["output"]["path"])
     for lang in settings["languages"]:

uedition/cli/language.py CHANGED Viewed

@@ -7,9 +7,13 @@ import os
 from copier import run_copy, run_update
 from yaml import dump, safe_load
+from uedition.settings import NoConfigError
 def add(path: str) -> None:
     """Add a language to the μEdition using Copier."""
+    if not os.path.exists("uEdition.yml") and not os.path.exists("uEdition.yaml"):
+        raise NoConfigError()
     run_copy("gh:uEdition/uEdition-language-template", path, data={"path": path})
     with open(os.path.join(path, ".uEdition.answers")) as in_f:
         answers = safe_load(in_f)
@@ -32,6 +36,8 @@ def add(path: str) -> None:
 def update(path: str) -> None:
     """Update a language to the latest template."""
+    if not os.path.exists("uEdition.yml") and not os.path.exists("uEdition.yaml"):
+        raise NoConfigError()
     run_update(path, answers_file=".uEdition.answers", overwrite=True, data={"path": path})
     with open(os.path.join(path, ".uEdition.answers")) as in_f:
         answers = safe_load(in_f)

uedition/cli/serve.py CHANGED Viewed

@@ -8,7 +8,7 @@ from typing import Callable
 from livereload import Server
 from uedition.cli.build import full_build, partial_build
-from uedition.settings import settings
+from uedition.settings import NoConfigError, settings
 def build_cmd(lang: dict, full: bool = True) -> Callable[[], None]:  # noqa: FBT001, FBT002
@@ -29,6 +29,8 @@ def build_cmd(lang: dict, full: bool = True) -> Callable[[], None]:  # noqa: FBT
 def run() -> None:
     """Run the development server."""
+    if not path.exists("uEdition.yml") and not path.exists("uEdition.yaml"):
+        raise NoConfigError()
     full_rebuilds = [build_cmd(lang, full=True) for lang in settings["languages"]]
     partial_rebuilds = [build_cmd(lang, full=False) for lang in settings["languages"]]
     for cmd in full_rebuilds:

uedition/cli/update.py CHANGED Viewed

@@ -2,9 +2,15 @@
 #
 # SPDX-License-Identifier: MIT
 """The μEdition check functionality for validating a μEdition and its files."""
+from os import path
 from copier import run_update
+from uedition.settings import NoConfigError
 def run() -> None:
     """Update the μEdition using Copier."""
+    if not path.exists("uEdition.yml") and not path.exists("uEdition.yaml"):
+        raise NoConfigError()
     run_update(".", answers_file=".uEdition.answers", overwrite=True, skip_answered=True)

uedition/ext/config.py CHANGED Viewed

@@ -1,197 +1,31 @@
 # SPDX-FileCopyrightText: 2023-present Mark Hall <mark.hall@work.room3b.eu>
 #
 # SPDX-License-Identifier: MIT
-"""uEdition configuration handling.
+"""
+uEdition configuration handling.
 This module handles reading the uEdition-specific configuration settings, validating them and
 adding any required default values.
 """
-from typing import Annotated, Any, Literal, Optional, Union
-from pydantic import BaseModel, ValidationError
-from pydantic.functional_validators import BeforeValidator
 from sphinx.application import Sphinx
+from sphinx.config import Config
 from sphinx.util import logging
-logger = logging.getLogger(__name__)
-class RuleSelectorAttribute(BaseModel):
-    """Validation rule for selecting based on an attribute with a given value."""
-    attr: str
-    value: str
-def expand_tei_namespace(value: str) -> str:
-    """Expand any ```tei:``` namespace prefixes."""
-    return value.replace("tei:", "{http://www.tei-c.org/ns/1.0}")
-def force_list(value: Any) -> list:  # noqa: ANN401
-    """Force the value into a list form."""
-    if isinstance(value, list):
-        return value
-    return [value]
-class RuleSelector(BaseModel):
-    """Validation rule for the selector for matching a TEI tag."""
-    tag: Annotated[str, BeforeValidator(expand_tei_namespace)]
-    attributes: Annotated[list[RuleSelectorAttribute], BeforeValidator(force_list)] = []
-class RuleText(BaseModel):
-    """Validation rule for retrieving the text content from an attribute."""
-    action: Literal["from-attribute"]
-    attr: str
-class RuleAttributeCopy(BaseModel):
-    """Validation rule for copying and attribute."""
-    action: Literal["copy"] = "copy"
-    attr: str
-    source: str
-class RuleAttributeSet(BaseModel):
-    """Validation rule for settings an attribute to a specific value."""
-    action: Literal["set"]
-    attr: str
-    value: str
-class RuleAttributeDelete(BaseModel):
-    """Validation rule for deleting an attribute."""
-    action: Literal["delete"]
-    attr: str
-def convert_string_to_selector_dict(value: str | dict) -> dict:
-    """Convert a simple string selector into the dictionary representation."""
-    if isinstance(value, str):
-        return {"tag": value}
-    return value
+from uedition.ext.settings import TEISettings
-class Rule(BaseModel):
-    """Validation model for a rule transforming a TEI tag into a HTML tag."""
-    selector: Annotated[RuleSelector, BeforeValidator(convert_string_to_selector_dict)]
-    tag: Union[str, None] = "div"
-    text: Union[RuleText, None] = None
-    attributes: list[Union[RuleAttributeCopy, RuleAttributeSet, RuleAttributeDelete]] = []
-class TextSection(BaseModel):
-    """Validation model for a TEI text section."""
-    title: str
-    type: Literal["text"] = "text"
-    content: str
-    sort: str | None = None
-    mappings: list[Rule] = []
-class SingleFieldRule(BaseModel):
-    """Validation model for a TEI field rule with a single value."""
-    title: str
-    type: Literal["single"] = "single"
-    content: str
-class ListFieldRule(BaseModel):
-    """Validation model for a TEI field rule with a list of values."""
-    title: str
-    type: Literal["list"]
-    content: str
-class DownloadFieldRule(BaseModel):
-    """Validation model for a TEI field rule that creates a download link."""
-    title: str
-    type: Literal["download"]
-    content: str
-    target: str
-class FieldsSection(BaseModel):
-    """Validation model for a TEI fields section."""
-    title: str
-    type: Literal["fields"]
-    fields: list[SingleFieldRule | ListFieldRule | DownloadFieldRule]
-class TEIConfig(BaseModel):
-    """Validation model for the TEI-specific settings."""
-    text_only_in_leaf_nodes: bool = False
-    mappings: list[Rule] = []
-    sections: list[TextSection | FieldsSection] = []
-class Config(BaseModel):
-    """Configuration validation model."""
-    tei: Optional[TEIConfig]
-BASE_RULES = [
-    {"selector": "tei:body", "tag": "section"},
-    {"selector": "tei:head", "tag": "h1"},
-    {"selector": "tei:p", "tag": "p"},
-    {"selector": "tei:seg", "tag": "span"},
-    {"selector": "tei:pb", "tag": "span"},
-    {"selector": "tei:hi", "tag": "span"},
-    {
-        "selector": "tei:ref",
-        "tag": "a",
-        "attributes": [{"attr": "href", "source": "target"}],
-    },
-    {"selector": "tei:citedRange", "tag": "span"},
-    {"selector": "tei:q", "tag": "span"},
-    {"selector": "tei:hi", "tag": "span"},
-    {"selector": "tei:foreign", "tag": "span"},
-    {"selector": "tei:speaker", "tag": "span"},
-    {"selector": "tei:stage", "tag": "span"},
-    {"selector": "tei:lem", "tag": "span"},
-    {"selector": "tei:sic", "tag": "span"},
-]
-"""Base mapping rules for mapping TEI tags to default HTML elements."""
+logger = logging.getLogger(__name__)
 def validate_config(app: Sphinx, config: Config) -> None:  # noqa: ARG001
     """Validate the configuration and add any default values."""
-    if config.uEdition:
-        if "tei" in config.uEdition:
-            if "sections" in config.uEdition["tei"] and isinstance(config.uEdition["tei"]["sections"], list):
-                if "mappings" in config.uEdition["tei"] and isinstance(config.uEdition["tei"]["mappings"], list):
-                    for section in config.uEdition["tei"]["sections"]:
-                        if "mappings" in section and isinstance(section["mappings"], list):
-                            section["mappings"] = section["mappings"] + config.uEdition["tei"]["mappings"] + BASE_RULES
-                        else:
-                            section["mappings"] = config.uEdition["tei"]["mappings"] + BASE_RULES
-        try:
-            config.uEdition = Config(**config.uEdition).dict()
-        except ValidationError as e:
-            for error in e.errors():
-                logger.error(" -> ".join([str(loc) for loc in error["loc"]]))
-                logger.error(f'  {error["msg"]}')
-            config.uEdition = {}
+    if config.tei:
+        config.tei = TEISettings(**config.tei).model_dump()
     else:
-        config.uEdition = {}
+        config.tei = {"blocks": [], "marks": "", "sections": []}
 def setup(app: Sphinx) -> None:
     """Set up the Sphinx configuration handling for the uEdition."""
-    app.add_config_value("uEdition", default=None, rebuild="html", types=[dict])
+    app.add_config_value("tei", default=None, rebuild="html", types=[dict])
     app.connect("config-inited", validate_config)

uedition/ext/settings.py ADDED Viewed

@@ -0,0 +1,131 @@
+# SPDX-FileCopyrightText: 2023-present Mark Hall <mark.hall@work.room3b.eu>
+#
+# SPDX-License-Identifier: MIT
+"""Additional settings validation."""
+from typing import Literal
+from pydantic import BaseModel
+class ValueTitlePair(BaseModel):
+    """A simple pair of value and title."""
+    value: str
+    """The value for the pair."""
+    title: str
+    """The title to show for the pair."""
+class TEINodeAttribute(BaseModel):
+    """Single attribute for a TEINode."""
+    name: str
+    """The name of the attribute."""
+    value: str | None = None
+    """A fixed value to use for the attribute."""
+    type: Literal["string"] | Literal["static"] | Literal["id-ref"] | Literal["text"] | Literal["html-attribute"] = (
+        "string"
+    )
+    """The type of attribute this is."""
+    default: str = ""
+    """The default value to use if none is set."""
+    target: str | None = None
+    """The target HTML attribute."""
+class TEINode(BaseModel):
+    """A single node in a TEI document."""
+    name: str
+    """The name to use to address this node."""
+    selector: str
+    """The selector to identify this node."""
+    attributes: list[TEINodeAttribute] = []
+    """A list of attributes that are used on this node."""
+    tag: str | None = None
+    """The HTML tag to use to render the node."""
+    text: str | None = None
+    """Where to get the text from."""
+    content: str | None = None
+    """Allowed child nodes. Only relevant for block nodes."""
+class TEIMetadataSectionSingleFieldRule(BaseModel):
+    """Validation model for a TEI field rule with a single value."""
+    title: str
+    type: Literal["single"] = "single"
+    selector: str
+class TEIMetadataSectionListFieldRule(BaseModel):
+    """Validation model for a TEI field rule with a list of values."""
+    title: str
+    type: Literal["list"]
+    selector: str
+class TEIMetadataSectionDownloadFieldRule(BaseModel):
+    """Validation model for a TEI field rule that creates a download link."""
+    title: str
+    type: Literal["download"]
+    selector: str
+    target: str
+class TEIMetadataSection(BaseModel):
+    """A metadata section in the TEI document."""
+    name: str
+    """The name of the section."""
+    title: str | None = None
+    """The title to show in the UI."""
+    type: Literal["metadata"]
+    """The type must be set to metadata."""
+    selector: str
+    """The XPath selector to retrieve this section."""
+    fields: list[
+        TEIMetadataSectionSingleFieldRule | TEIMetadataSectionListFieldRule | TEIMetadataSectionDownloadFieldRule
+    ]
+    """Fields to display."""
+class TEITextSection(BaseModel):
+    """A section in the TEI document containing a single text."""
+    name: str
+    """The name of the section."""
+    title: str | None = None
+    """The title to show in the UI."""
+    type: Literal["text"]
+    """The type must be set to text."""
+    selector: str
+    """The XPath selector to retrieve this section."""
+class TEITextListSection(BaseModel):
+    """A section in the TEI document containing multiple texts."""
+    name: str
+    """The name of the section."""
+    title: str | None = None
+    """The title to show in the UI."""
+    type: Literal["textlist"]
+    """The type must be set to textlist."""
+    selector: str
+    """The XPath selector to retrieve the texts in this section."""
+    sort: str | None = None
+class TEISettings(BaseModel):
+    """Settings for the TEI processing."""
+    blocks: list[TEINode] = []
+    """List of blocks supported in the TEI document."""
+    marks: list[TEINode] = []
+    """List of inline marks supported in the TEI document."""
+    sections: list[TEIMetadataSection | TEITextSection | TEITextListSection] = []
+    """List of sections within the TEI document."""

uedition/ext/tei/builder.py CHANGED Viewed

@@ -6,7 +6,6 @@ import xml.sax.saxutils
 from collections.abc import Iterator
 import sphinx
-import sphinx_jupyterbook_latex
 from docutils import nodes
 from docutils.io import StringOutput
 from sphinx.application import Sphinx
@@ -37,6 +36,7 @@ MAPPINGS = [
         "attrs": [{"target": "type", "value": "literal-block"}, {"source": "language", "target": "subtype"}],
     },
     {"cls": nodes.compound, "tagname": "div", "type": "block"},
+    {"cls": nodes.admonition, "tagname": "div", "type": "block"},
     {"cls": sphinx.addnodes.toctree},
     {
         "cls": nodes.footnote,
@@ -47,7 +47,6 @@ MAPPINGS = [
             {"target": "target", "source": "backrefs", "format": "#{value}", "join": " "},
         ],
     },
-    {"cls": sphinx_jupyterbook_latex.nodes.HiddenCellNode},
     {
         "cls": nodes.transition,
         "tagname": "div",
@@ -204,7 +203,7 @@ class TEITranslator(nodes.GenericNodeVisitor):
             else:
                 self.output.append(text)
         else:
-            self.output.append(f"{self.indent*self.level}<tei:span>{text}</tei:span>\n")
+            self.output.append(f"{self.indent * self.level}<tei:span>{text}</tei:span>\n")
     def depart_Text(self, node: nodes.TextElement) -> None:  # noqa: N802
         """Unused."""

uedition/ext/tei/parser.py CHANGED Viewed

@@ -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,35 +80,49 @@ 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[tuple[int, ...], ...]]:
@@ -130,70 +149,53 @@ class TEIParser(SphinxParser):
         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."""
@@ -211,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)
@@ -237,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 CHANGED Viewed

@@ -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.2.dist-info → uedition-2.0.0a1.dist-info}/METADATA RENAMED Viewed

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: uEdition
-Version: 1.3.2
+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 ADDED Viewed

@@ -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.2.dist-info → uedition-2.0.0a1.dist-info}/WHEEL RENAMED Viewed

@@ -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 DELETED Viewed

@@ -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.2.dist-info/RECORD DELETED Viewed

@@ -1,25 +0,0 @@
-uedition/__about__.py,sha256=qc1tq_AqKfnOrx88PfqDhfox8UD5GLclkXNzDTGwgaQ,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=QpDZ0D9ai4JCvtpBzfimI83rCdDQsD2ey4-_cW9Llv0,14291
-uedition/ext/tei/tei_download.js,sha256=5_IPCuamZGPXWriPPPz5wA-zo0Y0Oy1858S6ltxSdQ8,2151
-uedition-1.3.2.dist-info/METADATA,sha256=WlCa6UH0dUY63Mwwk6HPUFr5ltvei2KwXmObxB883YM,2358
-uedition-1.3.2.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
-uedition-1.3.2.dist-info/entry_points.txt,sha256=cDOOVBb1SZ072ZkY1hW4Y7I_WKKGCtCJtDY1XST1Hr4,96
-uedition-1.3.2.dist-info/licenses/LICENSE.txt,sha256=MhLJl8GE8mnuO5i_pvKaobpIGnhiAEdkY-a6LKiuwCE,1101
-uedition-1.3.2.dist-info/RECORD,,

{uedition-1.3.2.dist-info → uedition-2.0.0a1.dist-info}/entry_points.txt RENAMED Viewed

File without changes

{uedition-1.3.2.dist-info → uedition-2.0.0a1.dist-info}/licenses/LICENSE.txt RENAMED Viewed

File without changes

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

Potentially problematic release.

uEdition 1.3.2py3-none-any.whl → 2.0.0a1py3-none-any.whl