draftwright 0.4.21__tar.gz → 0.4.22__tar.gz

{draftwright-0.4.21 → draftwright-0.4.22}/CHANGELOG.md

@@ -154,6 +154,9 @@
 
 ### Changed
 
+- Updated the exact Quiddity runtime and declared-inspection contract to 0.2.5 for the
+  provider's recognition performance improvements.
+
 - Production recognition now consumes published `quiddity==0.2.2`. Unified section-recess
   occurrences and their same-run patterns feed the existing pocket, channel and blind-slot
   drawing grammar. Original occurrence ownership, independent completeness and explicit

{draftwright-0.4.21 → draftwright-0.4.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.4.21
+Version: 0.4.22
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -690,7 +690,7 @@ Requires-Dist: build123d<0.12,>=0.11; python_full_version >= '3.13'
 Requires-Dist: numpy>=1.24
 Requires-Dist: pillow>=10
 Requires-Dist: pypdfium2>=4
-Requires-Dist: quiddity==0.2.4
+Requires-Dist: quiddity==0.2.5
 Requires-Dist: reportlab>=4.0
 Requires-Dist: steputils==0.1
 Requires-Dist: svglib>=1.5

{draftwright-0.4.21 → draftwright-0.4.22}/docs/reference/recogniser-capabilities.md

@@ -70,10 +70,10 @@ issue. The contract test derives package record outputs, converter registries, l
 and emitter branches independently, so copying a new name into the declaration alone cannot make CI
 pass.
 
-### Quiddity 0.2.4 runtime contract
+### Quiddity 0.2.5 runtime contract
 
-[#1486](https://github.com/pzfreo/draftwright/pull/1486) adopts the published
-`quiddity==0.2.4` package after the migration in
+The runtime pins the published `quiddity==0.2.5` package, following the 0.2.4 adoption in
+[#1486](https://github.com/pzfreo/draftwright/pull/1486) and the migration in
 [#1471](https://github.com/pzfreo/draftwright/issues/1471). Its public `quiddity`, `quiddity.evidence` and
 `quiddity.inspection` surfaces supply recognition, exact occurrence evidence and declared geometry
 reads. There is one recognition aggregate per build; consumers project that result rather than

{draftwright-0.4.21 → draftwright-0.4.22}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.4.21"
+version = "0.4.22"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -18,7 +18,7 @@ dependencies = [
     "build123d>=0.9.0,<0.11 ; python_full_version < '3.13'",
     "build123d>=0.11,<0.12 ; python_full_version >= '3.13'",
     "build123d-drafting-helpers>=0.14.2",
-    "quiddity==0.2.4",
+    "quiddity==0.2.5",
     "numpy>=1.24",
     # PNG raster export (SVG→PDF→PNG). Both permissively licensed (Pillow HPND; pypdfium2
     # Apache-2.0 wrapping Google PDFium BSD-3) and ship pre-built wheels with NO native system
@@ -167,6 +167,10 @@ dev = [
     "jsonschema>=4,<5",
     "mypy>=2.1.0",
     "pytest>=8",
+    # `coverage` is invoked directly by the CI `coverage-report` job (combine/xml/html/
+    # report); it arrives transitively via pytest-cov, but the job depends on the console
+    # script, so declare it.
+    "coverage>=7",
     "pytest-cov>=5",
     "pytest-split>=0.8",
     "pytest-timeout>=2",

{draftwright-0.4.21 → draftwright-0.4.22}/src/draftwright/inspection_contract.py

@@ -16,7 +16,7 @@ from quiddity.inspection import inspection_api_manifest
 CONSUMER_INSPECTION_FORMAT = "draftwright-inspection-api"
 CONSUMER_INSPECTION_FORMAT_VERSION = 1
 SUPPORTED_INSPECTION_API_MAJOR = 1
-SUPPORTED_RECOGNISER_VERSION = "0.2.4"
+SUPPORTED_RECOGNISER_VERSION = "0.2.5"
 _DISTRIBUTION = "quiddity"
 _PROVIDER_FORMAT = "quiddity-inspection-api"
 _NAMESPACE = "quiddity.inspection"

draftwright-0.4.22/tests/_evidence_contract.py

@@ -0,0 +1,61 @@
+"""Per-family evidence contracts that every `*_completeness_evidence` module asserts.
+
+These bodies were written out once per feature family — thirteen copies of the
+`_<family>_model_outcomes` check, eleven of the one-recognition check — differing only
+in which family symbol they named. That is the growth pattern `test_clone_budget.py`
+exists to stop: the same assertion re-paid on every CI run, and one more copy to write
+(and to get subtly wrong) with each new recogniser family.
+
+Each function here is the single body; the per-family test calls it with its own
+symbols, so the assertion still runs once per family and the evidence is unchanged.
+Adding a family should add a call, not a copy.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+
+def assert_missing_model_outcomes_fail_closed(
+    monkeypatch,
+    outcomes_attr: str,
+    states: Callable[..., object],
+) -> None:
+    """A family whose per-occurrence outcomes vanish scores `unknown`, never `supported`.
+
+    `outcomes_attr` is the family's `_<family>_model_outcomes` in
+    `draftwright.evaluation.step_analysis`; `states` is the module's own `_states`
+    reader, so each family still exercises its own observer and fixture part.
+    """
+    import draftwright.evaluation.step_analysis as step_analysis
+
+    monkeypatch.setattr(step_analysis, outcomes_attr, lambda *_args: [])
+    # `set(...)`: a few families' `_states` returns a list, the rest a set. Both mean
+    # "every observed boundary state", and both must be exactly `unknown` here.
+    assert set(states("ir_adapter")) == {"unknown"}
+
+
+def assert_observer_uses_one_build_owned_recognition(
+    monkeypatch,
+    family: str,
+    part: object,
+) -> None:
+    """ADR 3: the observer scores the build's OWN aggregate, recognising exactly once.
+
+    A second `build_recognition_evidence` call would mean the facts being scored and the
+    features they are matched against came from different recognition runs.
+    """
+    import draftwright.analysis as analysis
+    from draftwright.evaluation.step_analysis import _default_observers
+
+    original = analysis.build_recognition_evidence
+    calls = 0
+
+    def counted(*args, **kwargs):
+        nonlocal calls
+        calls += 1
+        return original(*args, **kwargs)
+
+    monkeypatch.setattr(analysis, "build_recognition_evidence", counted)
+    assert _default_observers()[family](part)
+    assert calls == 1

draftwright-0.4.22/tests/_mutation_corpus.py

@@ -0,0 +1,127 @@
+"""The smallest corpus subset that still exercises a provider mutation.
+
+The `weakening_provider_*` / `deleting_provider_*` tests damage the provider and assert
+that the benchmark's score falls. They read `detection` and `parameter_fidelity` only —
+never `downstream_usefulness`, `complete_cases` or `conformant_cases` — yet they scored
+every fixture in the family's corpus, and the drawing_consumer observer builds a full
+drawing per case. Measured on the groove corpus: 4.77 s to re-prove one direction across
+eight fixtures, of which 98% is `build_drawing`.
+
+Scoring two fixtures proves the same direction. What it must NOT do is prove it vacuously,
+so the subset is chosen rather than truncated, and chosen by TAG rather than by position:
+
+* **one negative case**, always. Without a fixture the family must NOT match,
+  `false_positives == 0` is satisfied by a corpus that cannot produce a false positive at
+  all, and `detection.recall == 1.0` is trivially true of nothing.
+
+  Which negative matters. Taking the first in file order picked `chamfer-plain-negative`
+  and `fillet-plain-negative` — plain blocks carrying no bevel geometry whatsoever — so a
+  recogniser mutated to accept any `overlapping-family` shape would still have scored
+  `false_positives == 0`. That is exactly the vacuity the negative is here to prevent, so
+  an `ambiguous` or `overlapping-family` negative is preferred: one that the family could
+  plausibly claim and must not. `_NO_CONFUSABLE_NEGATIVE` records the two corpora that
+  offer none, rather than letting the weaker choice pass unremarked.
+
+* **the positive expecting the most facts** (`BenchmarkCase.expected`), so the damaged
+  parameters are actually present to be scored. Ties are the norm — five positives tie in
+  pockets, six in polygonal-stock — so the tie is broken on `case_id`. Without that, the
+  exact ratios these tests assert would be pinned to JSON key order, and reformatting a
+  corpus file (touching no code) could silently re-point a test at different geometry.
+
+`assert_reduced_corpus_is_sound` is the precondition that keeps this honest: the same
+subset must score a clean 1.0. A subset that is already failing would let a damage
+assertion pass for the wrong reason. `reduced_baseline_fixture` builds the per-module
+fixture, so a new family adds a call rather than a tenth copy of the same body — the
+growth pattern `test_clone_budget.py` exists to stop.
+
+The full corpus is still scored in full by each module's `test_real_*_corpus_scores_*`,
+which is where the absolute per-family counts live.
+"""
+
+from __future__ import annotations
+
+from dataclasses import replace
+
+import pytest
+
+#: Corpora offering no `ambiguous` / `overlapping-family` negative, so the plain-block
+#: negative is the only one available. Their `false_positives == 0` assertions are
+#: correspondingly weaker, and adding a confusable negative fixture would strengthen them.
+_NO_CONFUSABLE_NEGATIVE = frozenset({"corpus-chamfers-v1.json", "corpus-turned-steps-v1.json"})
+
+#: Tags marking a negative the family could plausibly claim, and must not.
+_CONFUSABLE = ("ambiguous", "overlapping-family")
+
+
+def reduced_corpus(corpus):
+    """One confusable negative plus the fact-richest positive, chosen deterministically."""
+    negatives = [case for case in corpus.cases if "negative" in _tags(case)]
+    positives = [
+        case
+        for case in corpus.cases
+        if "positive" in _tags(case) and "negative" not in _tags(case)
+    ]
+    assert negatives, (
+        "no negative case: a corpus that cannot produce a false positive makes "
+        "`false_positives == 0` vacuous, so it cannot be reduced this way"
+    )
+    assert positives, "no positive case: `detection.recall` would be vacuous"
+
+    confusable = sorted(
+        (case for case in negatives if any(tag in _tags(case) for tag in _CONFUSABLE)),
+        key=lambda case: case.case_id,
+    )
+    negative = confusable[0] if confusable else sorted(negatives, key=lambda c: c.case_id)[0]
+
+    # `case_id` breaks the tie: `len(expected)` alone leaves the choice to JSON key order.
+    richest = max(positives, key=lambda case: (len(case.expected), case.case_id))
+    assert richest.expected, (
+        f"richest positive {richest.case_id!r} expects no facts, so parameter fidelity "
+        "would be scored over an empty denominator"
+    )
+    return replace(corpus, cases=(negative, richest))
+
+
+def _tags(case) -> tuple[str, ...]:
+    """The case's tags, which `load_corpus` joins into `classification`."""
+    return tuple(case.classification.split("+"))
+
+
+def assert_reduced_corpus_is_sound(evaluate, corpus) -> object:
+    """Score the subset CLEAN and require a perfect result; return it for denominators.
+
+    Every damage assertion in the module is relative to this. If the subset were already
+    imperfect, `score == 0.5` after damage could hold because the fixture was broken
+    rather than because the damage was detected.
+    """
+    clean = evaluate(reduced_corpus(corpus))
+    assert clean.detection.recall == 1.0, (
+        f"reduced corpus does not detect cleanly (recall {clean.detection.recall}); "
+        "damage assertions built on it would pass for the wrong reason"
+    )
+    assert clean.detection.false_positives == 0, (
+        f"reduced corpus false-positives cleanly ({clean.detection.false_positives})"
+    )
+    assert clean.parameter_fidelity.score == 1.0, (
+        f"reduced corpus scores {clean.parameter_fidelity.score} clean, not 1.0"
+    )
+    assert clean.parameter_fidelity.total > 0, "reduced corpus scores no parameters at all"
+    return clean
+
+
+def reduced_baseline_fixture(corpus_path):
+    """The per-module `reduced_baseline` fixture, as a call rather than a tenth copy.
+
+    Module scope, so the clean evaluation is paid once per module — note that under
+    `--dist worksteal` (which `scripts/pr-check --full` uses) xdist may distribute one
+    module across workers and set it up once per worker. CI runs `loadscope` and pays it
+    once.
+    """
+
+    @pytest.fixture(scope="module")
+    def reduced_baseline():
+        from draftwright.evaluation.step_analysis import evaluate_step_corpus, load_corpus
+
+        return assert_reduced_corpus_is_sound(evaluate_step_corpus, load_corpus(corpus_path))
+
+    return reduced_baseline

{draftwright-0.4.21 → draftwright-0.4.22}/tests/conftest.py

@@ -171,6 +171,7 @@ _UNIT_MODULES = frozenset(
         "test_api_docs.py",
         "test_architecture_docs.py",
         "test_carve_free_position_callers.py",
+        "test_clone_budget.py",
         "test_counting_calls.py",
         "test_deprecation_dates.py",
         "test_import_boundaries.py",
@@ -187,6 +188,7 @@ _UNIT_MODULES = frozenset(
         "test_recogniser_adoption.py",
         "test_registry.py",
         "test_workflows.py",
+        "test_version_bump_ci.py",
     }
 )
 

draftwright-0.4.22/tests/test_clone_budget.py

@@ -0,0 +1,149 @@
+"""The suite may not grow by copying a test body into another module.
+
+Between 2026-08-21 and 2026-09-07 the corpus went from 3,347 to 4,934 test
+functions and pull-request CI wall-clock went from ~31 to ~63 minutes. Sharding
+absorbed that once; it cannot absorb it again, because sharding is a one-time
+constant factor and cloning is not.
+
+The growth is not people writing new assertions. It is one templated module
+being copied per feature family: `test_missing_per_hole_boundary_outcomes_fail_closed`,
+`..._per_pad_...`, `..._per_plate_...` — twelve hand-written copies of one three-line
+body whose only difference is which `_<family>_model_outcomes` symbol it patches.
+Each copy costs a real `build_drawing`, forever, on every CI run.
+
+The two obvious ways to detect that both fail here, which is why it went unnoticed:
+identical test NAMES miss it (every clone is renamed for its family) and identical
+ASTs miss it (every clone substitutes its family's identifiers and literals). So this
+guard compares test bodies with identifiers, attributes, literals and argument names
+erased — the SHAPE — across modules, since same-module repetition is a much weaker smell
+and often a deliberate readability choice, and only where a shape recurs in at least
+`_MIN_GROUP_MEMBERS` places, since a bare pair is usually coincidence rather than a
+template.
+
+The fix when this fails is not to raise the budget. It is to parametrize over the
+one thing that varies, which keeps every assertion and deletes the copies. Lower the
+budget whenever you do. Raising it needs a reason in the pull request body, the same
+way `fail_under` in `[tool.coverage.report]` does.
+"""
+
+from __future__ import annotations
+
+import ast
+import collections
+import hashlib
+from pathlib import Path
+
+TESTS = Path(__file__).parent
+
+#: Cross-module structurally identical test bodies, counted as `group size - 1`, over
+#: groups of at least `_MIN_GROUP_MEMBERS`. Measured at 33 on 2026-09-07.
+#: RATCHET DOWN ONLY — see the module docstring.
+CLONE_BUDGET = 33
+
+#: A shape must recur in at least this many modules to count as templated cloning.
+#:
+#: At two, the guard was measuring coincidence. 61 of its 70 groups were pairs, and the
+#: pairs are ordinary tests that happen to share a shape once identifiers and literals are
+#: erased — `test_add_dimension.py::test_a_tuple_swap_invalidates_rather_than_retargets`
+#: against `test_sheet_identity_invariant.py::test_a_tuple_swap_raises`. With the budget
+#: sitting exactly on the measured count, the next PR adding any three-statement test that
+#: collided by accident would have failed CI telling its author to "parametrize and delete
+#: the copies", which would usually be wrong — and a gate that cries wolf gets raised
+#: rather than obeyed. Templated cloning shows up as a family, not a pair.
+_MIN_GROUP_MEMBERS = 3
+
+#: A body must have at least this many statements, and this many AST nodes, before it
+#: counts. Short bodies (`build; assert`) collide by chance and would make the guard
+#: noise rather than signal.
+#:
+#: The size gate counts NODES rather than the length of `ast.dump`. CI runs Python
+#: 3.10 through 3.14, and `ast.dump` text gains and loses optional fields between
+#: versions; 22 bodies sit within 15% of the equivalent character threshold, so any of
+#: them could be counted on one interpreter and skipped on another and fail the gate on
+#: one matrix leg only. A node count moves only when the grammar does.
+_MIN_STATEMENTS = 3
+_MIN_NODES = 16
+
+
+class _Shape(ast.NodeTransformer):
+    """Erase everything nameable, keep control flow and call structure."""
+
+    def visit_Name(self, node: ast.Name) -> ast.Name:
+        return ast.copy_location(ast.Name(id="_", ctx=node.ctx), node)
+
+    def visit_Attribute(self, node: ast.Attribute) -> ast.Attribute:
+        self.generic_visit(node)
+        return ast.copy_location(ast.Attribute(value=node.value, attr="_", ctx=node.ctx), node)
+
+    def visit_Constant(self, node: ast.Constant) -> ast.Constant:
+        return ast.copy_location(ast.Constant(value="_"), node)
+
+    def visit_arg(self, node: ast.arg) -> ast.arg:
+        return ast.copy_location(ast.arg(arg="_"), node)
+
+    def visit_keyword(self, node: ast.keyword) -> ast.keyword:
+        self.generic_visit(node)
+        return ast.copy_location(ast.keyword(arg="_", value=node.value), node)
+
+
+def _clone_groups() -> dict[str, list[tuple[str, str]]]:
+    """Structurally identical test bodies that span more than one module."""
+    shapes: dict[str, list[tuple[str, str]]] = collections.defaultdict(list)
+    for path in sorted(TESTS.glob("test_*.py")):
+        tree = ast.parse(path.read_text(encoding="utf-8"))
+        for node in ast.walk(tree):
+            if not (isinstance(node, ast.FunctionDef) and node.name.startswith("test_")):
+                continue
+            body = [
+                statement
+                for statement in node.body
+                # Drop the docstring: prose is where a clone legitimately differs.
+                if not (
+                    isinstance(statement, ast.Expr) and isinstance(statement.value, ast.Constant)
+                )
+            ]
+            if len(body) < _MIN_STATEMENTS:
+                continue
+            normalised = _Shape().visit(ast.Module(body=body, type_ignores=[]))
+            if sum(1 for _ in ast.walk(normalised)) < _MIN_NODES:
+                continue
+            digest = hashlib.md5(ast.dump(normalised).encode(), usedforsecurity=False).hexdigest()
+            shapes[digest].append((path.name, node.name))
+    return {
+        digest: members
+        for digest, members in shapes.items()
+        if len({module for module, _ in members}) > 1 and len(members) >= _MIN_GROUP_MEMBERS
+    }
+
+
+def test_the_suite_does_not_grow_by_cloning_test_bodies_across_modules() -> None:
+    groups = _clone_groups()
+    redundant = sum(len(members) - 1 for members in groups.values())
+
+    worst = sorted(groups.values(), key=len, reverse=True)[:5]
+    report = "\n".join(
+        f"  x{len(members)}  {members[0][1]}\n"
+        + "\n".join(f"        {module}" for module, _ in members[:4])
+        + ("\n        ..." if len(members) > 4 else "")
+        for members in worst
+    )
+    assert redundant <= CLONE_BUDGET, (
+        f"{redundant} cross-module clones, budget {CLONE_BUDGET}. The largest groups:\n"
+        f"{report}\n\n"
+        "A test body copied into another module with only its family's identifiers "
+        "changed is not new evidence — it is the same assertion paid for again on every "
+        "CI run. Parametrize over the symbol that varies and delete the copies, then "
+        "lower CLONE_BUDGET. Raising it needs a reason in the PR body."
+    )
+
+
+def test_the_budget_is_not_slack() -> None:
+    """A budget far above the real count silently permits the next wave of copies."""
+    redundant = sum(len(members) - 1 for members in _clone_groups().values())
+
+    assert redundant >= CLONE_BUDGET - 10, (
+        f"only {redundant} cross-module clones against a budget of {CLONE_BUDGET}: "
+        "consolidation happened without ratcheting the budget down, so the guard now "
+        f"permits {CLONE_BUDGET - redundant} new copies before it complains. "
+        f"Set CLONE_BUDGET = {redundant}."
+    )

{draftwright-0.4.21 → draftwright-0.4.22}/tests/test_inspection_contract.py

@@ -26,7 +26,7 @@ def _manifest() -> dict:
 def test_installed_pypi_wheel_satisfies_the_inspection_contract() -> None:
     distribution = importlib.metadata.distribution("quiddity")
 
-    assert distribution.version == "0.2.4"
+    assert distribution.version == "0.2.5"
     assert distribution.read_text("direct_url.json") is None
     assert (
         Path(inspect.getfile(inspection.inspection_api_manifest))

{draftwright-0.4.21 → draftwright-0.4.22}/tests/test_issue_1369_hole_completeness_evidence.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 from dataclasses import replace
 from pathlib import Path
 
+from _evidence_contract import assert_missing_model_outcomes_fail_closed
 from build123d import Box, Cylinder, Pos
 
 from draftwright.evaluation.step_analysis import (
@@ -31,8 +32,14 @@ def _states(boundary: str) -> set[str]:
 
 
 def test_every_hole_boundary_is_observed_supported_on_the_real_public_path() -> None:
+    # One observation for all four boundaries. `_states` re-runs the observer —
+    # a full `build_drawing` — on every call, so the loop paid for four identical
+    # builds of the same part to read four keys off the same facts.
+    observed = _default_observers()["holes"](_part())
+    assert observed, "fixture produced no hole observations"
     for boundary in ("ir_adapter", "dsl_declaration", "generated_code", "drawing_consumer"):
-        assert _states(boundary) == {"supported"}
+        states = {fact.downstream[boundary] for fact in observed}
+        assert states == {"supported"}
 
 
 def test_removing_holes_from_the_built_ir_loses_ir_adapter_credit(monkeypatch) -> None:
@@ -86,10 +93,7 @@ def test_deleting_generated_hole_lines_loses_generated_code_credit(monkeypatch)
 
 
 def test_a_boundary_with_missing_per_hole_outcomes_fails_closed(monkeypatch) -> None:
-    import draftwright.evaluation.step_analysis as step_analysis
-
-    monkeypatch.setattr(step_analysis, "_hole_model_outcomes", lambda *_args: [])
-    assert _states("ir_adapter") == {"unknown"}
+    assert_missing_model_outcomes_fail_closed(monkeypatch, "_hole_model_outcomes", _states)
 
 
 def test_a_post_build_model_access_failure_is_scored_not_raised(monkeypatch) -> None:

{draftwright-0.4.21 → draftwright-0.4.22}/tests/test_issue_1370_countersink_completeness_evidence.py

@@ -7,6 +7,8 @@ from pathlib import Path
 from types import SimpleNamespace
 
 import pytest
+from _evidence_contract import assert_missing_model_outcomes_fail_closed
+from _mutation_corpus import reduced_baseline_fixture, reduced_corpus
 from build123d import Box, Compound, Cone, Cylinder, Pos, import_step
 
 from draftwright.evaluation.step_analysis import (
@@ -19,6 +21,9 @@ from draftwright.evaluation.step_analysis import (
 
 CORPUS = Path(__file__).parent / "fixtures" / "evaluation" / "corpus-countersinks-v1.json"
 
+#: Clean score of the subset the damage tests below use, asserted perfect.
+reduced_baseline = reduced_baseline_fixture(CORPUS)
+
 
 def _single_part():
     return import_step(CORPUS.parent / "countersink-single.step")
@@ -71,18 +76,18 @@ def test_versioned_countersink_corpus_covers_every_required_case_class() -> None
 def test_real_countersink_corpus_scores_all_layers_and_topology_variants() -> None:
     corpus = load_corpus(CORPUS)
 
-    first = evaluate_step_corpus(corpus)
-    second = evaluate_step_corpus(corpus)
-
-    assert first == second
-    assert first.detection.recall == 1.0
-    assert first.detection.false_positive_rate == 0.0
-    assert (first.parameter_fidelity.passed, first.parameter_fidelity.total) == (28, 28)
-    assert first.parameter_fidelity.score == 1.0
-    assert (first.downstream_usefulness.passed, first.downstream_usefulness.total) == (28, 28)
-    assert first.downstream_usefulness.score == 1.0
-    assert first.conformant_cases == first.complete_cases == len(corpus.cases)
-    variants = [case for case in first.cases if "topology" in case.case_id]
+    evaluation = evaluate_step_corpus(corpus)
+    assert evaluation.detection.recall == 1.0
+    assert evaluation.detection.false_positive_rate == 0.0
+    assert (evaluation.parameter_fidelity.passed, evaluation.parameter_fidelity.total) == (28, 28)
+    assert evaluation.parameter_fidelity.score == 1.0
+    assert (evaluation.downstream_usefulness.passed, evaluation.downstream_usefulness.total) == (
+        28,
+        28,
+    )
+    assert evaluation.downstream_usefulness.score == 1.0
+    assert evaluation.conformant_cases == evaluation.complete_cases == len(corpus.cases)
+    variants = [case for case in evaluation.cases if "topology" in case.case_id]
     assert len(variants) == 2
     assert variants[0].detection == variants[1].detection
     assert variants[0].parameter_fidelity == variants[1].parameter_fidelity
@@ -214,8 +219,14 @@ def test_equal_seats_still_remain_two_physical_observations() -> None:
 
 
 def test_every_countersink_boundary_is_observed_supported_on_the_real_public_path() -> None:
+    # One observation for all four boundaries. `_states` re-runs the observer —
+    # a full `build_drawing` — on every call, so the loop paid for four identical
+    # builds of the same part to read four keys off the same facts.
+    observed = _default_observers()["countersinks"](_single_part())
+    assert len(observed) == 1, "fixture must produce one countersink observation"
     for boundary in ("ir_adapter", "dsl_declaration", "generated_code", "drawing_consumer"):
-        assert _states(boundary) == {"supported"}
+        states = {fact.downstream[boundary] for fact in observed}
+        assert states == {"supported"}
 
 
 def test_removing_the_seat_from_built_ir_loses_ir_adapter_credit(monkeypatch) -> None:
@@ -276,10 +287,7 @@ def test_deleting_generated_countersink_argument_loses_generated_code_credit(
 
 
 def test_a_boundary_with_missing_per_seat_outcomes_fails_closed(monkeypatch) -> None:
-    import draftwright.evaluation.step_analysis as step_analysis
-
-    monkeypatch.setattr(step_analysis, "_countersink_model_outcomes", lambda *_args: [])
-    assert _states("ir_adapter") == {"unknown"}
+    assert_missing_model_outcomes_fail_closed(monkeypatch, "_countersink_model_outcomes", _states)
 
 
 def test_removing_placed_countersink_ink_loses_drawing_credit(monkeypatch) -> None:
@@ -468,7 +476,7 @@ def test_countersink_observer_fails_closed_when_build_or_recognition_is_unavaila
 
 @pytest.mark.parametrize("corruption", ["nonnumeric-location", "missing-axis"])
 def test_malformed_public_countersink_records_become_missed_instead_of_aborting(
-    monkeypatch, corruption: str
+    monkeypatch, corruption: str, reduced_baseline
 ) -> None:
     from draftwright.drawing import Drawing
 
@@ -496,9 +504,11 @@ def test_malformed_public_countersink_records_become_missed_instead_of_aborting(
     monkeypatch.setattr(Drawing, "recognition", with_malformed_record)
 
     assert _default_observers()["countersinks"](_single_part()) == ()
-    damaged = evaluate_step_corpus(load_corpus(CORPUS))
+    damaged = evaluate_step_corpus(reduced_corpus(load_corpus(CORPUS)))
     assert damaged.detection.matched == 0
-    assert damaged.detection.missed == 7
+    # Every seat that matched cleanly is now missed, stated against the clean subset
+    # rather than the full corpus's count of 7.
+    assert damaged.detection.missed == reduced_baseline.detection.matched
     assert damaged.detection.false_positives == 0
 
 

{draftwright-0.4.21 → draftwright-0.4.22}/tests/test_issue_1370_double_d_completeness_evidence.py

@@ -7,6 +7,7 @@ from pathlib import Path
 from types import SimpleNamespace
 
 import pytest
+from _evidence_contract import assert_missing_model_outcomes_fail_closed
 from build123d import Align, Box, Compound, Cylinder, Pos, import_step
 
 from draftwright.evaluation.step_analysis import (
@@ -67,18 +68,18 @@ def test_versioned_double_d_corpus_covers_each_required_case_class() -> None:
 def test_real_double_d_corpus_scores_all_layers_and_topology_variants() -> None:
     corpus = load_corpus(CORPUS)
 
-    first = evaluate_step_corpus(corpus)
-    second = evaluate_step_corpus(corpus)
-
-    assert first == second
-    assert first.detection.recall == 1.0
-    assert first.detection.false_positive_rate == 0.0
-    assert (first.parameter_fidelity.passed, first.parameter_fidelity.total) == (50, 50)
-    assert first.parameter_fidelity.score == 1.0
-    assert (first.downstream_usefulness.passed, first.downstream_usefulness.total) == (40, 40)
-    assert first.downstream_usefulness.score == 1.0
-    assert first.conformant_cases == first.complete_cases == len(corpus.cases)
-    variants = [case for case in first.cases if "topology" in case.case_id]
+    evaluation = evaluate_step_corpus(corpus)
+    assert evaluation.detection.recall == 1.0
+    assert evaluation.detection.false_positive_rate == 0.0
+    assert (evaluation.parameter_fidelity.passed, evaluation.parameter_fidelity.total) == (50, 50)
+    assert evaluation.parameter_fidelity.score == 1.0
+    assert (evaluation.downstream_usefulness.passed, evaluation.downstream_usefulness.total) == (
+        40,
+        40,
+    )
+    assert evaluation.downstream_usefulness.score == 1.0
+    assert evaluation.conformant_cases == evaluation.complete_cases == len(corpus.cases)
+    variants = [case for case in evaluation.cases if "topology" in case.case_id]
     assert len(variants) == 2
     assert variants[0].detection == variants[1].detection
     assert variants[0].parameter_fidelity == variants[1].parameter_fidelity
@@ -187,8 +188,14 @@ def test_public_depth_quantization_allowance_is_independently_bracketed() -> Non
 
 
 def test_every_double_d_boundary_is_supported_on_the_real_public_path() -> None:
+    # One observation for all four boundaries. `_states` re-runs the observer —
+    # a full `build_drawing` — on every call, so the loop paid for four identical
+    # builds of the same part to read four keys off the same facts.
+    observed = _default_observers()["double-d-bores"](_part())
+    assert len(observed) == 1, "fixture must produce one Double-D observation"
     for boundary in ("ir_adapter", "dsl_declaration", "generated_code", "drawing_consumer"):
-        assert _states(boundary) == {"supported"}
+        states = {fact.downstream[boundary] for fact in observed}
+        assert states == {"supported"}
 
 
 @pytest.mark.parametrize(
@@ -629,10 +636,7 @@ def test_double_d_observer_fails_closed_when_build_or_recognition_is_unavailable
 
 
 def test_a_boundary_with_missing_per_bore_outcomes_fails_closed(monkeypatch) -> None:
-    import draftwright.evaluation.step_analysis as step_analysis
-
-    monkeypatch.setattr(step_analysis, "_double_d_model_outcomes", lambda *_args: [])
-    assert _states("ir_adapter") == {"unknown"}
+    assert_missing_model_outcomes_fail_closed(monkeypatch, "_double_d_model_outcomes", _states)
 
 
 @pytest.mark.parametrize(