texpkg 0.2.0__tar.gz → 0.2.1__tar.gz

{texpkg-0.2.0 → texpkg-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: texpkg
-Version: 0.2.0
+Version: 0.2.1
 Summary: LaTeX package management.
 Author-Email: Ilja Orlovs <ilja@release.art>
 License-Expression: MIT

{texpkg-0.2.0 → texpkg-0.2.1}/pyproject.toml

@@ -20,7 +20,7 @@ dependencies = [
     "texmodel>=0.7.0",
     "pydantic>=2.14.1",
 ]
-version = "0.2.0"
+version = "0.2.1"
 
 [project.optional-dependencies]
 build = [

{texpkg-0.2.0 → texpkg-0.2.1}/src/texpkg/_internal/handedits.py

@@ -19,13 +19,14 @@ _SETTING = re.compile(r"settings\[(\d+)\]")
 _ENTRY = re.compile(r"preamble\.(before_class|before_package|after_package)\[(\d+)\]")
 
 
-def extra_path(plan_path: str, *, locked: int, layout: PreambleSlots) -> str:
+def extra_path(plan_path: str, *, locked: int, leading: PreambleSlots) -> str:
     """The data path of a line that a setting or a preamble entry of the document wrote (D10), or `""`: the kind's own
-    `locked` settings come first in the plan, then the document's, and the layout's lines lead each preamble slot."""
+    `locked` settings come first in the plan, then the document's, and the `leading` entries (the layout's and the
+    kind's locked ones) lead each preamble slot."""
     if found := _SETTING.fullmatch(plan_path):
         return f"/settings/{int(found[1]) - locked}" if int(found[1]) >= locked else ""
     if found := _ENTRY.fullmatch(plan_path):
-        own = int(found[2]) - len(getattr(layout, found[1]))
+        own = int(found[2]) - len(getattr(leading, found[1]))
         return f"/preamble/{found[1]}/{own}" if own >= 0 else ""
     return ""
 

{texpkg-0.2.0 → texpkg-0.2.1}/src/texpkg/_internal/release.py

@@ -79,21 +79,32 @@ class Release:
         """The lines that find the payload, which come before a document's own entries (A5)."""
         return self.dist.layout.preamble(graphics=self._has_graphics(kind))
 
+    def fixed_preamble(self, kind: Kind) -> PreambleSlots:
+        """What leads each preamble slot of every document of `kind`: the layout's lines, then the entries the base kind
+        locks (a profile's), then the kind's own (K020)."""
+        base = self.dist.base_kind(kind)
+        slots = [self.layout_preamble(kind), *([base.locked_preamble] if base else []), kind.locked_preamble]
+        return PreambleSlots(
+            before_class=tuple(e for s in slots for e in s.before_class),
+            before_package=tuple(e for s in slots for e in s.before_package),
+            after_package=tuple(e for s in slots for e in s.after_package),
+        )
+
     def plan(self, kind: Kind, tree: Node, variant: str | None, extras: Extras = Extras()) -> Plan:  # noqa: B008
         """The `.tex` of `tree` as lines with provenance: the kind's presets, then the variant's settings (L8), then the
-        document's own settings (D10).
+        document's own settings (D10); in each preamble slot the fixed entries, then the document's own.
 
         An exposed base kind is written by the base's package; the directory's layout is this distribution's."""
         body = tree if kind.expand is None else kind.expand(tree)
         package = self.dist.owner(kind.name).package
-        found, own = self.layout_preamble(kind), extras.preamble
+        found, own = self.fixed_preamble(kind), extras.preamble
         return package.plan(
             TexDocument(
                 body,
                 options=extras.options,
                 settings=(*self.settings(kind, variant), *extras.settings),
                 preamble=PreambleSlots(
-                    before_class=own.before_class,
+                    before_class=(*found.before_class, *own.before_class),
                     before_package=(*found.before_package, *own.before_package),
                     after_package=(*found.after_package, *own.after_package),
                 ),

{texpkg-0.2.0 → texpkg-0.2.1}/src/texpkg/_internal/state.py

@@ -84,6 +84,7 @@ def not_allowed(kind: Kind, extras: Extras) -> list[dict[str, Any]]:
     data = extras_state(extras)
     settable = {c.__name__ for c in kind.settable}
     entries = {c.__name__ for c in kind.preamble}
+    locked = set(kind.locked_classes())
     found = [
         (f"/settings/{i}", f"{type(v).__name__} is not settable in kind {kind.name}", data["settings"][i])
         for i, v in enumerate(extras.settings)
@@ -97,7 +98,9 @@ def not_allowed(kind: Kind, extras: Extras) -> list[dict[str, Any]]:
     found += [
         (
             f"/preamble/{slot}/{i}",
-            f"{type(item).__name__} is not an allowed preamble entry in kind {kind.name}",
+            f"{type(item).__name__} is locked by kind {kind.name}"
+            if type(item).__name__ in locked
+            else f"{type(item).__name__} is not an allowed preamble entry in kind {kind.name}",
             data["preamble"][slot][i],
         )
         for slot, i, item in extras.preamble.items()

{texpkg-0.2.0 → texpkg-0.2.1}/src/texpkg/declaration.py

@@ -19,7 +19,7 @@ from texmodel.components import AnyValue, Command, Environment, Node, Passthroug
 from texmodel.document import OPTION
 from texmodel.interface import Body, BodyKind
 from texmodel.package import Package
-from texmodel.preamble import Entry
+from texmodel.preamble import Entry, PreambleSlots
 
 from .assets import Asset, Resolved
 from .errors import DeclarationError
@@ -105,7 +105,8 @@ class Kind:
 
     A document may carry what the kind allows and nothing else: `settable` (values a document sets, after `presets`,
     which every document is written with), `options` (class options) and `preamble` (entry classes). A value is a preset
-    or settable, not both."""
+    or settable, not both. `locked_preamble` holds entries every document is written with, in the slots given, after
+    the layout's lines and before the document's own: a document may not carry an entry class that is locked."""
 
     name: str
     model: Model
@@ -120,6 +121,7 @@ class Kind:
     settable: tuple[type[Value[Any]], ...] = ()
     options: tuple[str, ...] = ()
     preamble: tuple[type[Entry], ...] = ()
+    locked_preamble: PreambleSlots = dataclasses.field(default_factory=PreambleSlots)
 
     def __post_init__(self) -> None:
         for field in ("presets", "migrations", "allow_raw", "variants", "settable", "options", "preamble"):
@@ -173,6 +175,7 @@ class Kind:
         """What a document may carry (D10): no name twice, real class options, nothing both written and settable."""
         self._unique("settable value", [c.__name__ for c in self.settable])
         self._unique("preamble entry", [c.__name__ for c in self.preamble])
+        self._check_locked()
         self._unique("option", list(self.options))
         if bad := next((o for o in self.options if not OPTION.fullmatch(o)), None):
             raise DeclarationError(
@@ -198,6 +201,34 @@ class Kind:
                 hint="letters, digits, '_' and '-', e.g. stem='brand-deck' for brand-deck.tex",
             )
 
+    def locked_classes(self) -> tuple[str, ...]:
+        """The names of the entry classes the kind writes into every document."""
+        return tuple(type(item).__name__ for _, _, item in self.locked_preamble.items())
+
+    def _check_locked(self) -> None:
+        """Locked entries are typed, in a slot they fit, each class once, and not also allowed to a document (K020)."""
+        for slot, _, item in self.locked_preamble.items():
+            slots = getattr(item, "slots", ())
+            if slot not in slots:
+                raise self.locked_error(
+                    f"{type(item).__name__} cannot sit in {slot}" if slots else "is not a typed entry",
+                    f"a typed entry (RequireMetadata, PdfInfo, ...) in a slot it fits: {list(slots) or 'none'}",
+                    item,
+                )
+        names = self.locked_classes()
+        if twice := next((n for n in names if names.count(n) > 1), None):
+            raise self.locked_error("is locked twice", "lock each entry class once", twice)
+        if both := next((c for c in self.preamble if c.__name__ in names), None):
+            raise self.locked_error(
+                "is locked and also allowed to a document", "a class is locked or allowed, not both", both.__name__
+            )
+
+    def locked_error(self, what: str, hint: str, entry: object) -> DeclarationError:
+        name = entry if isinstance(entry, str) else type(entry).__name__
+        return DeclarationError(
+            f"kind {self.name}: locked preamble entry {name} {what}", code="TP-K020", path=self.name, hint=hint
+        )
+
     def _unique(self, what: str, names: list[str]) -> None:
         if twice := next((n for n in names if names.count(n) > 1), None):
             raise DeclarationError(
@@ -347,6 +378,15 @@ class Distribution:
             )
         if problem := self.expansion_problem(kind, kind.example()):
             raise self._bad_expansion(kind, problem)
+        base = offered[kind.over]
+        if clash := next((n for n in kind.locked_classes() if n in base.locked_classes()), None):
+            raise kind.locked_error(
+                "is locked by the base kind too", "the base kind's locked entries are written first", clash
+            )
+        if clash := next((c for c in kind.preamble if c.__name__ in base.locked_classes()), None):
+            raise kind.locked_error(
+                "is locked by the base kind", "a profile cannot allow what its base locks", clash.__name__
+            )
 
     def expansion_problem(self, kind: Kind, tree: Node) -> str | None:
         """Why `tree` of a profile kind does not expand to a valid tree of the base kind (L3); `None` if it does."""

{texpkg-0.2.0 → texpkg-0.2.1}/src/texpkg/document.py

@@ -169,7 +169,7 @@ class Document[T: Command | Environment]:
         own = handedits.extra_path(
             plan_path,
             locked=len(self._release.settings(self._kind, variant)),
-            layout=self._release.layout_preamble(self._kind),
+            leading=self._release.fixed_preamble(self._kind),
         )
         if own:
             return own

{texpkg-0.2.0 → texpkg-0.2.1}/src/texpkg_build/_internal/generate.py

@@ -155,9 +155,11 @@ def _tuple(items: list[str]) -> str:
     return "(" + "".join(f"{item!r}, " for item in items).strip() + ")"
 
 
-def sources(dist: Distribution, pointer_attr: str, version: str, contracts: Contracts) -> dict[str, str]:
-    """The generated files by path inside the module, for `dist` released at `version`. `pointer_attr` is the name
-    `[tool.texpkg] distribution` gives the declaration inside its package."""
+def sources(dist: Distribution, pointer: str, version: str, contracts: Contracts) -> dict[str, str]:
+    """The generated files by path inside the module, for `dist` released at `version`. `pointer` is the
+    `module:attribute` of `[tool.texpkg] distribution`: where the declaring package holds the declaration."""
+    module, _, pointer_attr = pointer.partition(":")
+    where = module.removeprefix(dist.declared_in)  # "" when the declaration is the package's `__init__`
     offered = dist.kinds_offered()
     names = [k.name for k in offered]
     sty = render_sty(dist, version)
@@ -233,7 +235,7 @@ def sources(dist: Distribution, pointer_attr: str, version: str, contracts: Cont
 
                 from texpkg._internal.release import Release
 
-                from ._declaration import {pointer_attr}
+                from ._declaration{where} import {pointer_attr}
                 from ._version import CONTRACTS, VERSION
                 {base_import}
 

{texpkg-0.2.0 → texpkg-0.2.1}/src/texpkg_build/_internal/generated.py

@@ -3,7 +3,9 @@
 `[tool.texpkg] generate = "module:function"` names a pure `function(root) -> {path: source}`, where `root` is the
 declaring package's directory and each path is relative to it. `texpkg-build generate` writes the files; the build runs
 the function again and refuses a file that is missing, differs (stale or hand-edited), or is left over from an earlier
-run. The function must not import the declaring package, whose `__init__` imports the files it produces.
+run. The function must not import a module that imports the files it produces, as the declaration does: keep the
+declaration in a module of its own (`pkg.declaration:dist`) and `pkg/__init__.py` free of imports, and the function can
+share the package's pure modules.
 """
 
 import importlib
@@ -20,8 +22,10 @@ HEADER = "# Generated by texpkg-build generate. Do not edit.\n# fmt: off\n"
 
 
 def package_directory(source: pathlib.Path, module: str) -> pathlib.Path:
-    """The directory of the declaring package `module`, found without importing it."""
-    return source.joinpath(*module.split("."))
+    """The directory of the declaring package, found without importing it: `module` itself when it is a package
+    (`pkg:dist`), else the package that holds it (`pkg.declaration:dist`), as `Distribution(declared_in)` is."""
+    path = source.joinpath(*module.split("."))
+    return path if path.is_dir() else path.parent
 
 
 def _function(pointer: str, isolation: Isolation) -> Callable[[pathlib.Path], Mapping[str, str]]:

{texpkg-0.2.0 → texpkg-0.2.1}/src/texpkg_build/hook.py

@@ -73,7 +73,7 @@ def pdm_build_update_files(context: Context, files: dict[str, pathlib.Path]) ->
         loaded = load_declaration(f"{module}:{attr}", version=version)
         checks.module_satisfies_the_protocols(loaded)
         contracts, held = checks.contract_gate(context.root, dist, loaded._bound.RELEASE, version)  # pyright: ignore[reportAttributeAccessIssue]
-        module_files = generate.sources(dist, attr, version, contracts)
+        module_files = generate.sources(dist, f"{module}:{attr}", version, contracts)
         files.clear()  # a wheel holds the generated module, not the author's sources
         embed.embed(
             context.build_dir / dist.module, dist, declaration, module_files, held

{texpkg-0.2.0 → texpkg-0.2.1}/src/texpkg_build/testing.py

@@ -54,7 +54,7 @@ def load_declaration(pointer: str, *, version: str = "0.0.0", contracts: Contrac
     root = pathlib.Path(scratch.name) / dist.module
     for loaded in [n for n in sys.modules if _is_under(n, dist.module)]:
         del sys.modules[loaded]
-    _write(dist, attr, version, contracts or Contracts(), root)
+    _write(dist, pointer, version, contracts or Contracts(), root)
     spec = importlib.util.spec_from_file_location(
         dist.module, root / "__init__.py", submodule_search_locations=[str(root)]
     )
@@ -102,16 +102,24 @@ class _Flatten(importlib.abc.MetaPathFinder, importlib.abc.Loader):
         """The module is the nested one, already running."""
 
 
-def _attribute_of(dist: Distribution) -> str:
-    """The name the declaration package gives `dist`, which a base's generated module imports it by."""
-    namespace = vars(importlib.import_module(dist.declared_in))
-    return next(name for name, value in namespace.items() if value is dist)
+def _pointer_of(dist: Distribution) -> str:
+    """The `module:attribute` a base's declaration is imported by: the module of its package that holds it."""
+    for name, module in sorted(sys.modules.items()):
+        if _is_under(name, dist.declared_in):
+            if attr := next((n for n, value in vars(module).items() if value is dist), None):
+                return f"{name}:{attr}"
+    raise DeclarationError(
+        f"{dist.name} is not held by a module of {dist.declared_in}",
+        code="TP-B003",
+        path=dist.name,
+        hint="declare the distribution at the top level of a module of its package",
+    )
 
 
-def _write(dist: Distribution, attr: str, version: str, contracts: Contracts, root: pathlib.Path) -> None:
+def _write(dist: Distribution, pointer: str, version: str, contracts: Contracts, root: pathlib.Path) -> None:
     """The generated module of `dist` in `root`, and in `root/_embedded/<base>` that of each base: embedding without
     copying, since the declarations are the modules already imported."""
-    for path, text in generate.sources(dist, attr, version, contracts).items():
+    for path, text in generate.sources(dist, pointer, version, contracts).items():
         (root / path).parent.mkdir(parents=True, exist_ok=True)
         (root / path).write_text(text, encoding="utf-8")
     if dist.base:
@@ -119,7 +127,7 @@ def _write(dist: Distribution, attr: str, version: str, contracts: Contracts, ro
         (root / "_embedded" / "__init__.py").write_text("", encoding="utf-8")
         _write(
             dist.base,
-            _attribute_of(dist.base),
+            _pointer_of(dist.base),
             dist.base.package.version,
             contracts,
             root / "_embedded" / dist.base.module,

{texpkg-0.2.0 → texpkg-0.2.1}/tests/fixtures/acme_deck/__init__.py

@@ -6,6 +6,7 @@ import pathlib
 # exported by its kinds).
 import acme_brand_tex  # pyright: ignore[reportMissingImports]
 from acme_brand_tex._declaration.model import FactGap, Ink  # pyright: ignore[reportMissingImports]
+from texmodel.preamble import PassOption, PreambleSlots, RequireMetadata
 from texmodel.types import Length
 
 from texpkg import Asset, Distribution, Kind, Role
@@ -27,7 +28,14 @@ dist = Distribution(
     package=pkg,
     assets=(Asset("assets/DECK.txt", Role.NOTE, "what the deck package is"),),
     kinds=(
-        Kind("slide", Slide, presets=(), example=slide_example),
+        Kind(
+            "slide",
+            Slide,
+            presets=(),
+            example=slide_example,
+            preamble=(PassOption,),
+            locked_preamble=PreambleSlots(before_class=(RequireMetadata(pdfversion="2.0"),)),  # every slide has it
+        ),
         Kind(
             "brief",
             Brief,

{texpkg-0.2.0 → texpkg-0.2.1}/tests/test_declaration.py

@@ -10,7 +10,7 @@ import pytest
 from acme_brand import Card, Compact, Deck, Fact, FactGap, Glossary, Ink, Mark, Term, Title, dist, expert_example
 from texmodel.components import Command, Environment, Passthrough, Value
 from texmodel.package import Package
-from texmodel.preamble import PdfInfo
+from texmodel.preamble import PassOption, PdfInfo, PreambleSlots, RequireMetadata
 from texmodel.types import Length, Raw, Text
 
 from texpkg import Asset, DefaultChange, Distribution, Kind, Migrated, Role, Variant, migration
@@ -262,12 +262,23 @@ def test_a_distribution_declared_in_a_zipped_package_checks_its_root_through_the
         ({"options": ("!",)}, "TP-K016"),
         ({"settable": (FactGap,)}, "TP-K017"),  # a preset of the kind
         ({"settable": (Compact,)}, "TP-K017"),  # a variant's setting
+        ({"locked_preamble": PreambleSlots(before_class=(Raw(r"\\x"),))}, "TP-K020"),  # not a typed entry
+        ({"locked_preamble": PreambleSlots(before_package=(RequireMetadata(lang="en"),))}, "TP-K020"),  # wrong slot
+        ({"locked_preamble": PreambleSlots(before_class=(PassOption("a", "b"), PassOption("c", "d")))}, "TP-K020"),
+        ({"locked_preamble": PreambleSlots(before_class=(RequireMetadata(lang="en"),))}, "TP-K020"),  # also allowed
     ],
 )
 def test_what_a_kind_lets_a_document_carry_is_checked(changes, code):
     assert code_of(dataclasses.replace, dist.kind("expert"), **changes) == code
 
 
+def test_a_kind_locks_entries_of_classes_it_does_not_also_allow():
+    locked = PreambleSlots(before_class=(PassOption("xcolor", "table"),), before_package=(PassOption("a", "b"),))
+    assert code_of(dataclasses.replace, dist.kind("expert"), locked_preamble=locked) == "TP-K020"  # twice, in two slots
+    kind = dataclasses.replace(dist.kind("expert"), locked_preamble=PreambleSlots(before_class=locked.before_class))
+    assert kind.locked_classes() == ("PassOption",) and dist.kind("expert").locked_classes() == ()
+
+
 def test_a_settable_value_is_registered_by_the_package_that_reads_it_back():
     other = Package("other", prefix="ot", version="1.0.0", date="2026/10/22", description="Another")
 

{texpkg-0.2.0 → texpkg-0.2.1}/tests/test_generated.py

@@ -165,6 +165,31 @@ def test_generate_check_reports_drift_and_generate_repairs_it(project):
     assert ".times(1, 4)" in (project / "src/acme_series/_kinds/short.py").read_text()
 
 
+def test_the_declaration_may_be_a_module_of_its_package_and_the_package_import_free(project, tmp_path):
+    package = project / "src/acme_series"
+    (package / "declaration.py").write_text((package / "__init__.py").read_text())
+    (package / "__init__.py").write_text("")
+    pyproject = project / "pyproject.toml"
+    pyproject.write_text(pyproject.read_text().replace("acme_series:dist", "acme_series.declaration:dist"))
+    assert run_cli(project, "--check").exit_code == 0
+    change_data(project)
+    assert run_cli(project, "--check").exit_code == 1 and run_cli(project).exit_code == 0
+    assert "acme_series_tex/kinds/short.py" in projects.names(projects.wheel(project, tmp_path / "dist"))
+
+
+def test_a_base_no_module_holds_is_refused_by_name(tmp_path):
+    import dataclasses  # noqa: PLC0415
+
+    import acme_brand  # noqa: PLC0415
+
+    from texpkg_build import testing  # noqa: PLC0415
+
+    copy = dataclasses.replace(acme_brand.dist)  # equal, but no module holds this one
+    with pytest.raises(DeclarationError) as raised:
+        testing._pointer_of(copy)  # noqa: SLF001
+    assert raised.value.code == "TP-B003" and "acme-brand-tex" in str(raised.value)
+
+
 def test_generate_reports_a_bad_pointer_and_a_failing_generator(project):
     pyproject = project / "pyproject.toml"
     pyproject.write_text(pyproject.read_text().replace('generate = "acme_series_gen:sources"', 'generate = "nothing"'))

{texpkg-0.2.0 → texpkg-0.2.1}/tests/test_profile.py

@@ -12,10 +12,11 @@ from hypothesis import (
     given,
     strategies as st,
 )
+from texmodel.preamble import PassOption, PreambleSlots, RequireMetadata
 from texmodel.types import CMYK
 
 from texpkg import Design, Kind
-from texpkg.errors import DeclarationError
+from texpkg.errors import DeclarationError, MigrationError, NotAllowedError
 from texpkg_build._internal import checks
 from texpkg_build.testing import check_expansion, load_declaration
 
@@ -205,3 +206,86 @@ def test_a_profile_kind_is_declared_whole(deck):
         with pytest.raises(DeclarationError) as raised:
             dataclasses.replace(deck_dist, kinds=(dataclasses.replace(brief, **changes),))
         assert raised.value.code == code
+
+
+# -- locked preamble entries (K020) ----------------------------------------------------------------------------------
+
+LOCK = PreambleSlots(before_class=(RequireMetadata(lang="en"),))
+BASE_LOCK = PreambleSlots(before_class=(PassOption("graphicx", "draft"),))  # what a base kind locks
+OWN = PreambleSlots(before_class=(PassOption("xcolor", "table"),))
+
+
+def test_a_kind_writes_its_locked_entries_before_the_documents_own(deck, tmp_path):
+    slide = deck.kinds.modules()["slide"]
+    lines = slide.create(tmp_path, slide.example(), preamble=OWN).render().splitlines()
+    wanted = ["\\DocumentMetadata{pdfversion=2.0}", "\\PassOptionsToPackage{table}{xcolor}"]
+    at = [lines.index(line) for line in wanted]
+    assert at == sorted(at) and at[1] < next(i for i, line in enumerate(lines) if "\\documentclass" in line)
+
+
+def test_a_document_may_not_carry_an_entry_class_the_kind_locks(deck, tmp_path):
+    slide = deck.kinds.modules()["slide"]
+    with pytest.raises(NotAllowedError) as raised:
+        slide.create(tmp_path, slide.example(), preamble=LOCK)
+    (item,) = raised.value.items
+    assert item["path"] == "/preamble/before_class/0" and "locked by kind slide" in item["reason"]
+
+
+def test_locked_entries_are_in_no_documents_data_and_a_stored_one_is_unresolved(deck, tmp_path):
+    slide = deck.kinds.modules()["slide"]
+    slide.create(tmp_path, slide.example(), preamble=OWN).save()
+    path = tmp_path / "_texpkg/state.json"
+    stored = json.loads(path.read_text())
+    assert [e["type"] for e in stored["preamble"]["before_class"]] == ["PassOption"]  # not the lock
+    stored["preamble"]["before_class"].append({"type": "RequireMetadata", "entries": {"lang": "en"}})
+    path.write_text(json.dumps(stored))
+    with pytest.raises(MigrationError) as raised:
+        slide.load(tmp_path)
+    assert raised.value.code == "TP-M003" and "locked by kind slide" in str(raised.value)
+
+
+def test_a_hand_edit_of_the_documents_own_entry_is_found_at_its_data_path(deck, tmp_path):
+    slide = deck.kinds.modules()["slide"]
+    doc = slide.create(tmp_path, slide.example(), preamble=OWN)
+    doc.save()
+    tex = tmp_path / "slide.tex"
+    tex.write_text(
+        tex.read_text().replace("{table}{xcolor}", "{x11names}{xcolor}").replace("pdfversion=2.0", "pdfversion=1.7")
+    )
+    paths = {e.path for e in doc.hand_edits()}
+    assert paths == {"/preamble/before_class/0", "preamble.before_class[0]"}  # the own entry, and the locked line
+
+
+@pytest.mark.tex
+@pytest.mark.timeout(300)
+def test_a_document_with_a_locked_entry_compiles(deck, compiler, tmp_path):
+    slide = deck.kinds.modules()["slide"]
+    slide.create(tmp_path / "doc", slide.example(), preamble=OWN).save()
+    compiler.compile(tmp_path / "doc/slide.tex", tmp_path / "out").raise_for_status()
+
+
+def locked_deck(deck, **changes):  # noqa: ANN001, ANN003, ANN201
+    """The deck declaration over a brand whose `expert` kind locks `LOCK`; `changes` go to its `brief` profile."""
+    import acme_deck  # noqa: PLC0415  # importable once the `deck` fixture has built the brand
+
+    expert = dataclasses.replace(acme_brand.dist.kinds[0], locked_preamble=BASE_LOCK)
+    base = dataclasses.replace(acme_brand.dist, kinds=(expert, *acme_brand.dist.kinds[1:]))
+    brief = dataclasses.replace(acme_deck.dist.kind("brief"), **changes)
+    return dataclasses.replace(acme_deck.dist, base=base, kinds=(acme_deck.dist.kinds[0], brief))
+
+
+def test_a_profile_writes_the_locked_entries_of_its_base_kind(deck):
+    wide = locked_deck(deck)
+    release = dataclasses.replace(deck._bound.RELEASE, dist=wide)  # noqa: SLF001
+    brief = wide.kind("brief")
+    text = release.plan(brief, brief.example(), None).text
+    assert text.index("\\PassOptionsToPackage{draft}{graphicx}") < text.index("\\documentclass")
+
+
+def test_a_profile_may_not_lock_or_allow_what_its_base_kind_locks(deck):
+    with pytest.raises(DeclarationError) as raised:
+        locked_deck(deck, locked_preamble=BASE_LOCK)
+    assert raised.value.code == "TP-K020" and "locked by the base kind too" in str(raised.value)
+    with pytest.raises(DeclarationError) as raised:
+        locked_deck(deck, preamble=(PassOption,))
+    assert raised.value.code == "TP-K020" and "locked by the base kind" in str(raised.value)

{texpkg-0.2.0 → texpkg-0.2.1}/tests/test_typing.py

@@ -64,7 +64,7 @@ nothing_settable = vocab.create("v", vocab.example(), settings=[expert.Ink(CMYK(
 def wheel_like(tmp_path_factory: pytest.TempPathFactory) -> pathlib.Path:
     root = tmp_path_factory.mktemp("typing")
     module = root / dist.module
-    for path, text in generate.sources(dist, "dist", "1.2.0", Contracts()).items():
+    for path, text in generate.sources(dist, "acme_brand:dist", "1.2.0", Contracts()).items():
         (module / path).parent.mkdir(parents=True, exist_ok=True)
         (module / path).write_text(text, encoding="utf-8")
     shutil.copytree(FIXTURES / "acme_brand", module / "_declaration", ignore=shutil.ignore_patterns("__pycache__"))