uEdition 0.8.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

uedition/CHANGELOG.md

@@ -0,0 +1,75 @@
+# Changelog
+
+## Dev
+
+* **New**: Add a switch to turn off the TEI generation
+* **Update**: Don't enable the language switcher when only one language is configured
+* **Bugfix**: Fixed a bug in the TEI generation
+* **Bugfix**: Fixed the builder output paths
+
+## 0.9.0
+
+* **New**: Added TEI output
+* **Update**: Don't re-ask answered questions on updates
+
+# 0.8.0
+
+* **New**: Add support for publishing via Read the Docs
+* **Documentation**: Added basic documentation
+* **Update**: Updated dependencies
+
+# 0.7.0
+
+* **New**: Add support for static files
+* **Bugfix**: Fix a missing progress update
+
+# 0.6.1
+
+* **Update**: Fixes for changes in the JupyterBook
+
+# 0.6.0
+
+* **New**: Switch to having a central configuration and table of contents
+* **Bugfix**: Added a missing content watch
+
+# 0.5.0
+
+* **New**: Integrate copier into the CLI
+
+# 0.4.0
+
+* **New**: Added a language-switcher extension
+
+# 0.3.1
+
+* **Bugfix**: Ensure that the output folder exists
+
+# 0.3.0
+
+* **New**: Support automatic landing page redirects
+* **Update**: Clean up the build commands
+
+# 0.2.1
+
+* **Bugfix**: Fixed a bug in the section wrapping
+
+# 0.2.0
+
+* **New**: Added a serve command
+* **Update**: Updated the TEI layout
+
+# 0.1.0
+
+* **New**: Added basic TEI parsing
+
+# 0.0.3
+
+* **Bugfix**: Workflow fixes
+
+# 0.0.2
+
+* **Bugfix**: Fix output path handling
+
+# 0.0.1
+
+* Initial release

uedition/__about__.py

@@ -2,4 +2,4 @@
 #
 # SPDX-License-Identifier: MIT
 """About this package."""
-__version__ = "0.8.0"
+__version__ = "1.0.0"

uedition/__init__.py

@@ -4,9 +4,9 @@
 """The uEdition toolkit."""
 from sphinx.application import Sphinx
 
-from . import ext
+from uedition import ext
 
 
-def setup(app: Sphinx):
-    """Setup the theme and its extensions."""
+def setup(app: Sphinx) -> None:
+    """Set up the theme and its extensions."""
     ext.setup(app)

uedition/__main__.py

@@ -2,7 +2,6 @@
 #
 # SPDX-License-Identifier: MIT
 """Run the CLI via `python -m uedition`."""
-from .cli import app
-
+from uedition.cli import app
 
 app()

uedition/cli/__init__.py

@@ -3,20 +3,16 @@
 # SPDX-License-Identifier: MIT
 """uEdtion Command-line Tool."""
 import typer
-
 from rich import print as print_cli
 
-from . import (
-    check as check_module,
-    build as build_module,
-    serve as serve_module,
-    create as create_module,
-    update as update_module,
-    language as language_module,
-)
-from ..__about__ import __version__
-from ..settings import settings
-
+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
+from uedition.cli import update as update_module
+from uedition.settings import settings
 
 app = typer.Typer()
 language_app = typer.Typer()

uedition/cli/build.py

@@ -4,22 +4,22 @@
 """Build functionality."""
 import json
 import subprocess
-
 from copy import deepcopy
-from os import path, makedirs
-from shutil import rmtree, copytree
-from yaml import safe_load, safe_dump
+from os import makedirs, path
+from shutil import copytree, ignore_patterns, rmtree
+
+from yaml import safe_dump, safe_load
 
-from ..settings import settings, reload_settings
+from uedition.settings import reload_settings, settings
 
 
 def landing_build() -> None:
     """Build the landing page."""
-    if not path.exists(settings["output"]):
-        makedirs(settings["output"], exist_ok=True)
-    with open(path.join(settings["output"], "config.json"), "w") as out_f:
+    if not path.exists(settings["output"]["path"]):
+        makedirs(settings["output"]["path"], exist_ok=True)
+    with open(path.join(settings["output"]["path"], "config.json"), "w") as out_f:
         json.dump(settings, out_f)
-    with open(path.join(settings["output"], "index.html"), "w") as out_f:
+    with open(path.join(settings["output"]["path"], "index.html"), "w") as out_f:
         out_f.write(
             """\
 <!DOCTYPE html>
@@ -74,16 +74,13 @@ def toc_build(lang: dict) -> None:
     with open("toc.yml") as in_f:
         toc = safe_load(in_f)
 
-    def walk(input: dict) -> dict:
+    def walk(source: dict) -> dict:
         output = {}
-        for key, value in input.items():
+        for key, value in source.items():
             if isinstance(value, dict):
                 if lang["code"] in value:
                     output[key] = value[lang["code"]]
-                elif (
-                    len(settings["languages"]) > 0
-                    and settings["languages"][0]["code"] in value
-                ):
+                elif len(settings["languages"]) > 0 and settings["languages"][0]["code"] in value:
                     output[key] = value[settings["languages"][0]["code"]]
                 else:
                     output[key] = ""
@@ -104,10 +101,7 @@ def config_build(lang: dict) -> None:
     # Set the language-specific title
     if lang["code"] in settings["title"]:
         config["title"] = settings["title"][lang["code"]]
-    elif (
-        len(settings["languages"]) > 0
-        and settings["languages"][0]["code"] in settings["title"]
-    ):
+    elif len(settings["languages"]) > 0 and settings["languages"][0]["code"] in settings["title"]:
         config["title"] = settings["title"][settings["languages"][0]["code"]]
     else:
         config["title"] = f"Missing title for {lang['label']}"
@@ -152,44 +146,91 @@ def full_build(lang: dict) -> None:
     config_build(lang)
     static_build(lang)
     subprocess.run(
-        [
+        [  # noqa: S603, S607
             "jupyter-book",
             "build",
             "--all",
             "--path-output",
-            path.join("_build", lang["code"]),
+            path.join("_build", lang["path"]),
             lang["path"],
-        ]
+        ],
+        check=False,
     )
+    if settings["output"]["tei"]:
+        subprocess.run(
+            [  # noqa: S603, S607
+                "jupyter-book",
+                "build",
+                "--all",
+                "--path-output",
+                path.join("_build", lang["path"]),
+                "--builder",
+                "custom",
+                "--custom-builder",
+                "tei",
+                lang["path"],
+            ],
+            check=False,
+        )
     copytree(
-        path.join("_build", lang["code"], "_build", "html"),
-        path.join(settings["output"], lang["code"]),
+        path.join("_build", lang["path"], "_build", "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(settings["output"]["path"], lang["path"]),
+            ignore=ignore_patterns("_sphinx_design_static"),
+            dirs_exist_ok=True,
+        )
 
 
 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["code"]),
+            path.join("_build", lang["path"]),
             lang["path"],
-        ]
+        ],
+        check=False,
     )
+    if settings["output"]["tei"]:
+        subprocess.run(
+            [  # noqa: S603, S607
+                "jupyter-book",
+                "build",
+                "--path-output",
+                path.join("_build", lang["path"]),
+                "--builder",
+                "custom",
+                "--custom-builder",
+                "tei",
+                lang["path"],
+            ],
+            check=False,
+        )
     copytree(
-        path.join("_build", lang["code"], "_build", "html"),
-        path.join(settings["output"], lang["code"]),
+        path.join("_build", lang["path"], "_build", "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(settings["output"]["path"], lang["path"]),
+            ignore=ignore_patterns("_sphinx_design_static"),
+            dirs_exist_ok=True,
+        )
 
 
 def run() -> None:
     """Build the full uEdition."""
-    if path.exists(settings["output"]):
-        rmtree(settings["output"])
+    if path.exists(settings["output"]["path"]):
+        rmtree(settings["output"]["path"])
     for lang in settings["languages"]:
         full_build(lang)

uedition/cli/check.py

@@ -3,14 +3,14 @@
 # SPDX-License-Identifier: MIT
 """The uEdition check functionality for validating a uEdition and its files."""
 import os
-import typer
+from threading import Thread
 
+import typer
 from rich import print as print_cli
 from rich.progress import Progress
-from threading import Thread
 from yaml import safe_load
 
-from ..settings import settings
+from uedition.settings import settings
 
 
 def collect_files(toc: dict) -> list[str]:
@@ -29,9 +29,7 @@ def collect_files(toc: dict) -> list[str]:
     return files
 
 
-def compare_tocs(
-    prefix: str, toc_a: dict, toc_b: dict
-) -> list[tuple[str | None, str | None]]:
+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:
@@ -41,20 +39,18 @@ def compare_tocs(
     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"))
+        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"))
+        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"))
+        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:
+    def __init__(self: "ConfigurationFileChecks", progress: Progress, task: int) -> None:
         """Initialise the thread."""
         super().__init__(group=None)
         self._progress = progress
@@ -97,17 +93,11 @@ class TocFileChecks(Thread):
                         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'
-                                )
+                                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}"
-                                    )
+                                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:
@@ -120,9 +110,7 @@ class TocFileChecks(Thread):
 class LanguageConsistencyChecks(Thread):
     """Multi-language consistency checks."""
 
-    def __init__(
-        self: "LanguageConsistencyChecks", progress: Progress, task: int
-    ) -> None:
+    def __init__(self: "LanguageConsistencyChecks", progress: Progress, task: int) -> None:
         """Initialise the thread."""
         super().__init__(group=None)
         self._progress = progress
@@ -148,20 +136,16 @@ class LanguageConsistencyChecks(Thread):
             try:
                 with open(lang_toc_path) as in_f:
                     lang_toc = safe_load(in_f)
-            except Exception:
-                continue
-            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)
+                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:
@@ -171,15 +155,11 @@ def run() -> None:
         threads = [
             ConfigurationFileChecks(
                 progress,
-                progress.add_task(
-                    "[green]Configuration file checks", total=len(settings["languages"])
-                ),
+                progress.add_task("[green]Configuration file checks", total=len(settings["languages"])),
             ),
             TocFileChecks(
                 progress,
-                progress.add_task(
-                    "[green]TOC file checks", total=len(settings["languages"])
-                ),
+                progress.add_task("[green]TOC file checks", total=len(settings["languages"])),
             ),
             LanguageConsistencyChecks(
                 progress,

uedition/cli/language.py

@@ -5,7 +5,7 @@
 import os
 
 from copier import run_copy, run_update
-from yaml import safe_load, dump
+from yaml import dump, safe_load
 
 
 def add(path: str) -> None:
@@ -25,18 +25,14 @@ def add(path: str) -> None:
     else:
         config["languages"] = []
     if not found:
-        config["languages"].append(
-            {"code": answers["code"], "label": answers["label"], "path": path}
-        )
+        config["languages"].append({"code": answers["code"], "label": answers["label"], "path": path})
     with open("uEdition.yml", "w") as out_f:
         dump(config, out_f)
 
 
 def update(path: str) -> None:
     """Update a language to the latest template."""
-    run_update(
-        path, answers_file=".uEdition.answers", overwrite=True, data={"path": path}
-    )
+    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)
     with open("uEdition.yml") as in_f:
@@ -51,8 +47,6 @@ def update(path: str) -> None:
     else:
         config["languages"] = []
     if not found:
-        config["languages"].append(
-            {"code": answers["code"], "label": answers["label"], "path": path}
-        )
+        config["languages"].append({"code": answers["code"], "label": answers["label"], "path": path})
     with open("uEdition.yml", "w") as out_f:
         dump(config, out_f)

uedition/cli/serve.py

@@ -2,15 +2,16 @@
 #
 # SPDX-License-Identifier: MIT
 """Local server that automatically rebuilds on changes."""
-from livereload import Server
 from os import path
 from typing import Callable
 
-from .build import full_build, partial_build
-from ..settings import settings
+from livereload import Server
+
+from uedition.cli.build import full_build, partial_build
+from uedition.settings import settings
 
 
-def build_cmd(lang: dict, full: bool = True) -> Callable[[], None]:
+def build_cmd(lang: dict, full: bool = True) -> Callable[[], None]:  # noqa: FBT001, FBT002
     """Create a function that (re-)builds one of the sub-sites."""
     if full:
 
@@ -33,11 +34,9 @@ def run() -> None:
     for cmd in full_rebuilds:
         cmd()
     server = Server()
-    for lang, full_cmd, partial_cmd in zip(
-        settings["languages"], full_rebuilds, partial_rebuilds
-    ):
+    for lang, full_cmd, partial_cmd in zip(settings["languages"], full_rebuilds, partial_rebuilds):
         server.watch("*.yml", full_cmd)
         server.watch(path.join("static", "**", "*.*"), full_cmd)
         server.watch(path.join(lang["path"], "**", "*.*"), partial_cmd)
     server.watch("uEdition.*", lambda: [cmd() for cmd in full_rebuilds])
-    server.serve(root="site", port=8000)
+    server.serve(root=settings["output"]["path"], port=8000)

uedition/cli/update.py

@@ -7,4 +7,4 @@ from copier import run_update
 
 def run() -> None:
     """Update the μEdition using Copier."""
-    run_update(".", answers_file=".uEdition.answers", overwrite=True)
+    run_update(".", answers_file=".uEdition.answers", overwrite=True, skip_answered=True)

uedition/ext/__init__.py

@@ -4,7 +4,7 @@
 """Sphinx extensions for the uEdition."""
 from sphinx.application import Sphinx
 
-from . import config, tei, language_switcher
+from uedition.ext import config, language_switcher, tei
 
 
 def setup(app: Sphinx) -> None:

uedition/ext/config.py

@@ -6,11 +6,12 @@
 This module handles reading the uEdition-specific configuration settings, validating them and
 adding any required default values.
 """
-from pydantic import BaseModel, validator, ValidationError
+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.util import logging
-from typing import Union, Literal, Optional
-
 
 logger = logging.getLogger(__name__)
 
@@ -22,27 +23,23 @@ class RuleSelectorAttribute(BaseModel):
     value: str
 
 
-class RuleSelector(BaseModel):
-    """Validation rule for the selector for matching a TEI tag."""
+def expand_tei_namespace(value: str) -> str:
+    """Expand any ```tei:``` namespace prefixes."""
+    return value.replace("tei:", "{http://www.tei-c.org/ns/1.0}")
 
-    tag: str
-    attributes: list[RuleSelectorAttribute] = []
 
-    @validator("tag", pre=True)
-    def expand_tag_namespace(
-        cls: "RuleSelector", v: str, values: dict, **kwargs: dict
-    ) -> str:
-        """Expand any ```tei:``` namespace prefixes."""
-        return v.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]
 
-    @validator("attributes", pre=True)
-    def convert_dict_attributes_to_list(
-        cls: "RuleSelector", v: dict | list, values: dict, **kwargs: dict
-    ) -> list[dict]:
-        """Convert a single attributes dictionary to a list with that dictionary."""
-        if isinstance(v, dict):
-            return [v]
-        return v
+
+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):
@@ -75,24 +72,20 @@ class RuleAttributeDelete(BaseModel):
     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
+
+
 class Rule(BaseModel):
     """Validation model for a rule transforming a TEI tag into a HTML tag."""
 
-    selector: RuleSelector
+    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]
-    ] = []
-
-    @validator("selector", pre=True)
-    def convert_str_selector_to_dict(
-        cls: "Rule", v: str | dict, values: dict, **kwargs: dict
-    ) -> dict:
-        """Convert a simple string selector into the dictionary representation."""
-        if isinstance(v, str):
-            return {"tag": v}
-        return v
+    attributes: list[Union[RuleAttributeCopy, RuleAttributeSet, RuleAttributeDelete]] = []
 
 
 class TextSection(BaseModel):
@@ -166,29 +159,17 @@ BASE_RULES = [
 """Base mapping rules for mapping TEI tags to default HTML elements."""
 
 
-def validate_config(app: Sphinx, config: Config) -> None:
+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
-                ):
+            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
-                            )
+                        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
-                            )
+                            section["mappings"] = config.uEdition["tei"]["mappings"] + BASE_RULES
         try:
             config.uEdition = Config(**config.uEdition).dict()
         except ValidationError as e: