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

uEdition 1.3.2py3-none-any.whl → 2.0.0a2py3-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 +90 -104
uedition/settings.py +16 -7
{uedition-1.3.2.dist-info → uedition-2.0.0a2.dist-info}/METADATA +9 -4
uedition-2.0.0a2.dist-info/RECORD +25 -0
{uedition-1.3.2.dist-info → uedition-2.0.0a2.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.0a2.dist-info}/entry_points.txt +0 -0
{uedition-1.3.2.dist-info → uedition-2.0.0a2.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.0a2"

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 1.3.2__py3-none-any.whl → 2.0.0a2__py3-none-any.whl

Potentially problematic release.

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