texpkg 0.2.1__tar.gz → 0.2.2__tar.gz

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

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

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

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

{texpkg-0.2.1 → texpkg-0.2.2}/src/texpkg/_internal/adopt.py

@@ -7,6 +7,7 @@ left aborts with the report.
 """
 
 import copy
+import dataclasses
 import re
 from collections.abc import Iterator, Mapping, Sequence
 from typing import Any, cast
@@ -110,6 +111,39 @@ def _extras_problems(kind: Kind, package: Package, data: dict[str, Any]) -> tupl
     return extras, state.not_allowed(kind, extras)
 
 
+def kind_default_changes(
+    package: Package,
+    extras: Extras,
+    saved: Mapping[str, Any],
+    current: Mapping[str, Any],
+    policy: DefaultChange | Mapping[str, DefaultChange],
+) -> tuple[Extras, list[dict[str, Any]]]:
+    """Apply the consumer's policy to every kind default this release changed (V22), for a value the document does
+    not set itself: following needs nothing (the kind writes the new default); a frozen one becomes a setting of the
+    document with the old value; one that asks is returned as unresolved. The key is the value's class name, the path
+    `/defaults/<class>`."""
+    own = {type(v).__name__ for v in extras.settings}
+    frozen: list[Any] = []
+    asked: list[dict[str, Any]] = []
+    for name in sorted(saved.keys() & current.keys()):
+        if saved[name] == current[name] or name in own:
+            continue
+        action = _policy(policy, f"/defaults/{name}", name)
+        if action is DefaultChange.FREEZE:
+            frozen.append(saved[name])
+        elif action is DefaultChange.ASK:
+            reason = f"the default of {name} changed from {saved[name]!r} to {current[name]!r}"
+            asked.append({"path": f"/defaults/{name}", "reason": reason, "value": saved[name], "boundary": "defaults"})
+    if not frozen:
+        return extras, asked
+    try:
+        kept = state.extras_from(package, {"settings": frozen}).settings
+    except ExceptionGroup as group:
+        reason = "; ".join(str(e) for e in group.exceptions)
+        return extras, [*asked, {"path": "/defaults", "reason": reason, "value": frozen, "boundary": "defaults"}]
+    return dataclasses.replace(extras, settings=(*extras.settings, *kept)), asked
+
+
 def adopt(
     *,
     kind: Kind,
@@ -120,6 +154,8 @@ def adopt(
     consumer: Sequence[Migration],
     policy: DefaultChange | Mapping[str, DefaultChange],
     saved_defaults: Mapping[str, Any] | None,
+    saved_kind_defaults: Mapping[str, Any] | None = None,
+    kind_defaults: Mapping[str, Any] | None = None,
     base_data: Mapping[int, int] | None = None,
 ) -> tuple[Node, Extras]:
     """The tree and extras of `kind` that `envelope` describes at `data` version `current`, or a `MigrationError` naming
@@ -141,6 +177,9 @@ def adopt(
     schema = state.tree_schema(kind.model, "validation")
     extras, found = _extras_problems(kind, package, extras_data)
     left += [{**p, "boundary": "validation"} for p in found]
+    if saved_kind_defaults is not None and not found:
+        extras, asked = kind_default_changes(package, extras, saved_kind_defaults, kind_defaults or {}, policy)
+        left += asked
     left += [{**p, "boundary": "validation"} for p in unplaced(tree, schema)]
     left += [{**p, "boundary": "validation"} for p in problems(kind.model, state.given(tree), schema)]
     if left:

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

@@ -69,7 +69,19 @@ class Release:
         """What a document of `kind` is written with (L8): for a profile kind, the base kind's presets first, then
         its own locks, then the variant's."""
         base = self.dist.base_kind(kind)
-        return (*(base.presets if base else ()), *kind.settings(variant))
+        return (*(base.presets if base else ()), *kind.settings(variant), *self.kind_defaults(kind))
+
+    def kind_defaults(self, kind: Kind) -> tuple[AnyValue, ...]:
+        """Where a document of `kind` starts for the values it may set: a profile's base kind's, then its own (V21)."""
+        base = self.dist.base_kind(kind)
+        return (*(base.defaults if base else ()), *kind.defaults)
+
+    def kind_defaults_state(self, kind: Kind) -> dict[str, Any]:
+        """The settable ones among them, by class name, in the data shape of a setting: what the template state keeps
+        to tell, at `load`, a default the kind has changed."""
+        found = tuple(v for v in self.kind_defaults(kind) if type(v) in kind.settable)
+        data = state.extras_state(Extras(settings=found)).get("settings", [])
+        return json.loads(dumps({type(v).__name__: d for v, d in zip(found, data, strict=True)}))
 
     def _has_graphics(self, kind: Kind) -> bool:
         kinds = (kind.name, *([kind.over] if kind.over else []))
@@ -101,7 +113,7 @@ class Release:
         return package.plan(
             TexDocument(
                 body,
-                options=extras.options,
+                options=kind.class_options(extras.options, variant),
                 settings=(*self.settings(kind, variant), *extras.settings),
                 preamble=PreambleSlots(
                     before_class=(*found.before_class, *own.before_class),
@@ -163,6 +175,7 @@ class Release:
                 for variant, name in kind.documents()
             },
             "defaults": state.defaults_table(kind.model),
+            "kind_defaults": self.kind_defaults_state(kind),
             "sty": state.sty_hashes(self.sty),
             "stack": self.stack(),
         }
@@ -300,6 +313,8 @@ class KindApi[T: Command | Environment]:
             consumer=migrations,
             policy=default_changes,
             saved_defaults=template.get("defaults"),
+            saved_kind_defaults=template.get("kind_defaults"),
+            kind_defaults=self.release.kind_defaults_state(self.kind),
             base_data=dict(self.release.contracts.base_data) if self.kind.name in self.release.dist.expose else None,
         )
         return Document(cast("T", tree), path, self.release, self.kind, extras)

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

@@ -36,10 +36,13 @@ type Model = type[Command] | type[Environment]
 
 @dataclasses.dataclass(frozen=True)
 class Variant:
-    """A named set of settings applied to the same document (K6): `doc.render(variant="compact")`."""
+    """A named set of settings and class options applied to the same document (K6): `doc.render(variant="compact")`.
+    The options are written after the document's own, and need not be among the kind's `options`: the variant is the
+    author's choice, not the document's."""
 
     name: str
     settings: tuple[AnyValue, ...] = ()
+    options: tuple[str, ...] = ()
 
     def __post_init__(self) -> None:
         if not _VARIANT.fullmatch(self.name):
@@ -50,6 +53,18 @@ class Variant:
                 hint="it is part of a file name: deck-<variant>.tex",
             )
         object.__setattr__(self, "settings", tuple(self.settings))
+        object.__setattr__(self, "options", tuple(self.options))
+        if bad := next((o for o in self.options if not OPTION.fullmatch(o)), None):
+            raise DeclarationError(
+                f"variant {self.name}: option {bad!r} is not a class option",
+                code="TP-K016",
+                path=self.name,
+                hint="letters, digits, '=', '.' and '-', starting with a letter or digit",
+            )
+        if twice := next((o for o in self.options if self.options.count(o) > 1), None):
+            raise DeclarationError(
+                f"variant {self.name}: option {twice!r} is declared twice", code="TP-K002", path=self.name
+            )
 
 
 @dataclasses.dataclass(frozen=True)
@@ -105,7 +120,9 @@ 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. `locked_preamble` holds entries every document is written with, in the slots given, after
+    or settable, not both. `defaults` are the kind's own start values for settable ones: written after the presets and
+    the variant's settings and before the document's own, so a document that sets the value overrides them (V21).
+    `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
@@ -122,9 +139,10 @@ class Kind:
     options: tuple[str, ...] = ()
     preamble: tuple[type[Entry], ...] = ()
     locked_preamble: PreambleSlots = dataclasses.field(default_factory=PreambleSlots)
+    defaults: tuple[AnyValue, ...] = ()
 
     def __post_init__(self) -> None:
-        for field in ("presets", "migrations", "allow_raw", "variants", "settable", "options", "preamble"):
+        for field in ("presets", "migrations", "allow_raw", "variants", "settable", "options", "preamble", "defaults"):
             object.__setattr__(self, field, tuple(getattr(self, field)))
         if not _KIND.fullmatch(self.name) or keyword.iskeyword(self.name):
             raise DeclarationError(
@@ -192,6 +210,14 @@ class Kind:
                 path=self.name,
                 hint="a value is written for every document or set by a document, not both",
             )
+        self._unique("default", [type(v).__name__ for v in self.defaults])
+        if loose := next((v for v in self.defaults if type(v) not in self.settable), None):
+            raise DeclarationError(
+                f"kind {self.name}: a default for {type(loose).__name__}, which is not settable",
+                code="TP-K021",
+                path=self.name,
+                hint="a default is where a document starts for a value it may set: add the class to settable",
+            )
         object.__setattr__(self, "stem", self.stem or self.model.__name__.lower())
         if not _STEM.fullmatch(self.stem):
             raise DeclarationError(
@@ -239,6 +265,11 @@ class Kind:
         """The `.tex` a save writes, as `(variant, file name)`: the kind's own, then one per variant (K7)."""
         return ((None, f"{self.stem}.tex"), *((v.name, f"{self.stem}-{v.name}.tex") for v in self.variants))
 
+    def class_options(self, own: tuple[str, ...], variant: str | None = None) -> tuple[str, ...]:
+        """The class options of a `.tex` (K6): the document's `own`, then the variant's that are not among them."""
+        found = next((v for v in self.variants if v.name == variant), None)
+        return (*own, *(o for o in (found.options if found else ()) if o not in own))
+
     def settings(self, variant: str | None = None) -> tuple[AnyValue, ...]:
         """What a document of the kind is written with (L8): the presets, then the settings of `variant`, if named."""
         if variant is None:

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

@@ -36,22 +36,17 @@ def _pointer(context: Context) -> tuple[str, str]:
 
 
 def pdm_build_initialize(context: Context) -> None:
-    """A wheel needs pydantic and nothing else: texmodel, texpkg and the bases are embedded in it (B7)."""
+    """A wheel needs pydantic and nothing else: texmodel, texpkg and the bases are embedded in it (B7). An editable
+    install embeds nothing, so it needs texpkg itself, which brings texmodel and pydantic."""
     metadata = context.config.metadata
-    metadata["dependencies"] = [PYDANTIC]
+    metadata["dependencies"] = ["texpkg"] if context.target == "editable" else [PYDANTIC]
     if "dynamic" in metadata and "dependencies" in metadata["dynamic"]:
         metadata["dynamic"].remove("dependencies")
 
 
 def pdm_build_update_files(context: Context, files: dict[str, pathlib.Path]) -> None:
-    if context.target == "sdist":
-        return
     if context.target != "wheel":
-        raise DeclarationError(
-            f"a {context.target} build of a texpkg package",
-            code="TP-B008",
-            hint="the module is generated from the declaration: test it with texpkg_build.testing.load_declaration",
-        )
+        return  # the sdist holds the sources, an editable install links them: the module is made for a wheel (B6)
     module, attr = _pointer(context)
     source = context.root / (context.config.build_config.package_dir or ".")
     with author_source(source) as isolation:

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

@@ -7,9 +7,9 @@ import pathlib
 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 texmodel.types import CMYK, Length
 
-from texpkg import Asset, Distribution, Kind, Role
+from texpkg import Asset, Distribution, Kind, Role, Variant
 
 from .model import Brief, Heading, Headline, Point, Slide, Tint, expand, pkg
 
@@ -34,6 +34,9 @@ dist = Distribution(
             presets=(),
             example=slide_example,
             preamble=(PassOption,),
+            settable=(Ink,),
+            defaults=(Ink(CMYK(0, 0, 0, 0.3)),),  # where a slide starts; a slide may set its own
+            variants=(Variant("review", options=("draft",)),),
             locked_preamble=PreambleSlots(before_class=(RequireMetadata(pdfversion="2.0"),)),  # every slide has it
         ),
         Kind(

{texpkg-0.2.1 → texpkg-0.2.2}/tests/test_build.py

@@ -179,11 +179,14 @@ def test_the_declaration_must_be_a_package(tmp_path):
     assert raised.value.code == "TP-B004"
 
 
-def test_an_editable_install_is_refused(project, tmp_path, monkeypatch):
+def test_an_editable_install_links_the_sources_and_needs_texpkg(project, tmp_path, monkeypatch):
     monkeypatch.chdir(project)
-    with pytest.raises(DeclarationError) as raised:
-        pdm.backend.build_editable(str(tmp_path / "dist"))
-    assert raised.value.code == "TP-B008"
+    built = tmp_path / "dist" / pdm.backend.build_editable(str(tmp_path / "dist"))
+    names = projects.names(built)
+    assert not any("acme_brand_tex" in n and n.endswith(".py") for n in names)  # no generated module
+    with zipfile.ZipFile(built) as z:
+        metadata = z.read(next(n for n in names if n.endswith("METADATA"))).decode()
+    assert "Requires-Dist: texpkg" in metadata and "pydantic" not in metadata
 
 
 def test_a_generated_module_that_breaks_the_protocol_is_refused(tmp_path, monkeypatch):

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

@@ -272,6 +272,15 @@ 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_variants_options_follow_the_documents_without_repeating_them():
+    expert = dist.kind("expert")
+    review = dataclasses.replace(expert, variants=(Variant("review", options=("draft", "a4paper")),))
+    assert review.class_options(("a4paper",), "review") == ("a4paper", "draft")
+    assert review.class_options(("a4paper",)) == ("a4paper",) and review.class_options((), "missing") == ()
+    assert code_of(Variant, "x", options=("two words",)) == "TP-K016"
+    assert code_of(Variant, "x", options=("draft", "draft")) == "TP-K002"
+
+
 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

{texpkg-0.2.1 → texpkg-0.2.2}/tests/test_embed.py

@@ -200,6 +200,7 @@ def test_a_wheel_installs_into_a_fresh_environment_that_has_only_pydantic(brand_
     report = json.loads(venvs.run(python, SCRIPT, tmp_path / "out", cwd=tmp_path))
     assert report["names"] == ["slide", "brief", "vocab"] and report["version"] == "0.1.0"
     assert report["slide"] == [
+        "_texpkg/plan-review.json",
         "_texpkg/plan.json",
         "_texpkg/state.json",
         "_texpkg/template.json",
@@ -210,6 +211,7 @@ def test_a_wheel_installs_into_a_fresh_environment_that_has_only_pydantic(brand_
         "res/texpkg/acme-brand.sty",
         "res/texpkg/acme-deck-provenance.sty",
         "res/texpkg/acme-deck.sty",
+        "slide-review.tex",
         "slide.tex",
     ]
     assert "res/texpkg/acme-brand.sty" in report["vocab"] and "glossary.tex" in report["vocab"]

{texpkg-0.2.1 → texpkg-0.2.2}/tests/test_end_to_end.py

@@ -122,8 +122,8 @@ def test_two_wheels_are_installed_used_saved_compiled_and_a_new_release_is_adopt
     ]
     sources = sorted((tmp_path / "docs").rglob("*.tex"))
     assert (
-        len(sources) == 3 + 1 + 1 + 1 + 1
-    )  # expert and its two variants, vocab, then the deck's brief, slide and vocab
+        len(sources) == 3 + 1 + 1 + 2 + 1
+    )  # expert and its two variants, vocab, then the deck's brief, slide and its variant, and vocab
     for source in sources:
         compiler.compile(
             source, tmp_path / "out" / source.parent.parent.name / source.parent.name / source.stem

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

@@ -15,7 +15,7 @@ from hypothesis import (
 from texmodel.preamble import PassOption, PreambleSlots, RequireMetadata
 from texmodel.types import CMYK
 
-from texpkg import Design, Kind
+from texpkg import DefaultChange, Design, Kind
 from texpkg.errors import DeclarationError, MigrationError, NotAllowedError
 from texpkg_build._internal import checks
 from texpkg_build.testing import check_expansion, load_declaration
@@ -223,6 +223,15 @@ def test_a_kind_writes_its_locked_entries_before_the_documents_own(deck, tmp_pat
     assert at == sorted(at) and at[1] < next(i for i, line in enumerate(lines) if "\\documentclass" in line)
 
 
+def test_a_variant_writes_its_class_options_into_its_own_tex(deck, tmp_path):
+    slide = deck.kinds.modules()["slide"]
+    doc = slide.create(tmp_path, slide.example())
+    assert "\\documentclass{" in doc.render() and "\\documentclass[draft]{" in doc.render("review")
+    doc.save()
+    assert "\\documentclass[draft]{" in (tmp_path / "slide-review.tex").read_text()
+    assert "\\documentclass{" in (tmp_path / "slide.tex").read_text()
+
+
 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:
@@ -261,7 +270,8 @@ def test_a_hand_edit_of_the_documents_own_entry_is_found_at_its_data_path(deck,
 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()
+    for name in ("slide", "slide-review"):  # the variant passes `draft` to the class
+        compiler.compile(tmp_path / f"doc/{name}.tex", tmp_path / "out" / name).raise_for_status()
 
 
 def locked_deck(deck, **changes):  # noqa: ANN001, ANN003, ANN201
@@ -289,3 +299,91 @@ def test_a_profile_may_not_lock_or_allow_what_its_base_kind_locks(deck):
     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)
+
+
+# -- a kind's own defaults for what a document may set (V21) -------------------------------------------------------
+
+OLD_INK = {"type": "Ink", "value": {"c": 0.0, "m": 0.0, "y": 0.0, "k": 0.9}}
+GREY = "\\definecolor{ab-ink}{cmyk}{0,0,0,0.3}"
+BLACK = "\\definecolor{ab-ink}{cmyk}{0,0,0,0.9}"
+
+
+def slide_saved_with(deck, tmp_path, *, settings=(), old=OLD_INK):  # noqa: ANN001, ANN002, ANN201
+    """A slide document whose saved template says the kind's default for `Ink` used to be `old`."""
+    slide = deck.kinds.modules()["slide"]
+    slide.create(tmp_path, slide.example(), settings=settings).save()
+    path = tmp_path / "_texpkg/template.json"
+    template = json.loads(path.read_text())
+    assert template["kind_defaults"] == {"Ink": {"type": "Ink", "value": {"c": 0.0, "m": 0.0, "y": 0.0, "k": 0.3}}}
+    template["kind_defaults"]["Ink"] = old
+    path.write_text(json.dumps(template))
+    return slide
+
+
+def test_a_kinds_default_is_written_before_what_the_document_sets(deck, tmp_path):
+    slide = deck.kinds.modules()["slide"]
+    lines = slide.create(tmp_path / "a", slide.example()).render().splitlines()
+    assert GREY in lines
+    own = slide.create(tmp_path / "b", slide.example(), settings=[Ink(CMYK(0, 0, 0, 0.6))])
+    lines = own.render().splitlines()
+    assert lines.index(GREY) < lines.index(
+        "\\definecolor{ab-ink}{cmyk}{0,0,0,0.6}"
+    )  # the document's comes last: it wins
+    own.save()
+    (tmp_path / "b/slide.tex").write_text((tmp_path / "b/slide.tex").read_text().replace("{0,0,0,0.6}", "{0,0,0,0.7}"))
+    assert {e.path for e in own.hand_edits()} == {"/settings/0"}  # the default is not mistaken for it
+
+
+def test_a_changed_default_is_followed_frozen_or_asked_for_when_the_document_sets_nothing(deck, tmp_path):
+    slide = slide_saved_with(deck, tmp_path)
+    followed = slide.load(tmp_path)
+    assert followed.settings == () and GREY in followed.render()
+    frozen = slide.load(tmp_path, default_changes=DefaultChange.FREEZE)
+    assert [type(v) for v in frozen.settings] == [Ink]
+    lines = frozen.render().splitlines()
+    assert lines.index(GREY) < lines.index(BLACK)  # the old value is written after the new default, so it wins
+    by_class = slide.load(tmp_path, default_changes={"Ink": DefaultChange.FREEZE})
+    assert [v.value for v in by_class.settings] == [v.value for v in frozen.settings]
+    with pytest.raises(MigrationError) as raised:
+        slide.load(tmp_path, default_changes=DefaultChange.ASK)
+    (item,) = raised.value.unresolved
+    assert item.path == "/defaults/Ink" and "changed from" in item.reason and item.boundary == "defaults"
+
+
+def test_a_value_the_document_sets_is_not_a_changed_default(deck, tmp_path):
+    slide = slide_saved_with(deck, tmp_path, settings=[Ink(CMYK(0, 0, 0, 0.6))])
+    kept = slide.load(tmp_path, default_changes=DefaultChange.ASK)
+    assert BLACK not in kept.render() and "{0,0,0,0.6}" in kept.render()
+    again = slide.load(tmp_path, default_changes=DefaultChange.FREEZE)
+    assert [v.value for v in again.settings] == [v.value for v in kept.settings]
+
+
+def test_a_default_that_did_not_change_or_was_not_saved_asks_nothing(deck, tmp_path):
+    slide = slide_saved_with(deck, tmp_path, old={"type": "Ink", "value": {"c": 0.0, "m": 0.0, "y": 0.0, "k": 0.3}})
+    assert slide.load(tmp_path, default_changes=DefaultChange.ASK).settings == ()
+    path = tmp_path / "_texpkg/template.json"
+    template = json.loads(path.read_text())
+    del template["kind_defaults"]  # saved before the kind had a default
+    path.write_text(json.dumps(template))
+    assert slide.load(tmp_path, default_changes=DefaultChange.ASK).settings == ()
+
+
+def test_a_frozen_default_the_class_no_longer_reads_is_unresolved(deck, tmp_path):
+    slide = slide_saved_with(deck, tmp_path, old={"type": "Ink", "value": "not a colour"})
+    with pytest.raises(MigrationError) as raised:
+        slide.load(tmp_path, default_changes=DefaultChange.FREEZE)
+    (item,) = raised.value.unresolved
+    assert item.path == "/defaults" and item.boundary == "defaults"
+
+
+def test_a_default_is_for_a_settable_value_once(acme_brand_tex):
+    from acme_brand import Compact, Ink  # noqa: PLC0415
+
+    expert = acme_brand.dist.kind("expert")
+    twice = (Ink(CMYK(0, 0, 0, 0.1)), Ink(CMYK(0, 0, 0, 0.2)))
+    with pytest.raises(DeclarationError) as raised:
+        dataclasses.replace(expert, defaults=twice)
+    assert raised.value.code == "TP-K002"
+    with pytest.raises(DeclarationError) as raised:
+        dataclasses.replace(expert, defaults=(Compact(True),))
+    assert raised.value.code == "TP-K021" and "Compact" in str(raised.value)