codd-dev 2.71.0__tar.gz → 2.72.0__tar.gz

{codd_dev-2.71.0 → codd_dev-2.72.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.71.0
+Version: 2.72.0
 Summary: CoDD: Coherence-Driven Development — cross-artifact change impact analysis
 Project-URL: Homepage, https://github.com/yohey-w/codd-dev
 Project-URL: Repository, https://github.com/yohey-w/codd-dev

{codd_dev-2.71.0 → codd_dev-2.72.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.71.0"
+__version__ = "2.72.0"

{codd_dev-2.71.0 → codd_dev-2.72.0}/codd/languages/__init__.py

@@ -33,6 +33,7 @@ from .profile import (
     TestSet,
     TestsSpec,
     ToolchainSpec,
+    VerifyObservationPolicy,
     VerifySpec,
 )
 from .loader import LanguageProfileError, load_language_profile
@@ -86,6 +87,7 @@ __all__ = [
     "TestSet",
     "TestsSpec",
     "ToolchainSpec",
+    "VerifyObservationPolicy",
     "VerifySpec",
     # loader
     "LanguageProfileError",

{codd_dev-2.71.0 → codd_dev-2.72.0}/codd/languages/loader.py

@@ -37,6 +37,7 @@ from .profile import (
     TestSet,
     TestsSpec,
     ToolchainSpec,
+    VerifyObservationPolicy,
     VerifySpec,
 )
 
@@ -238,8 +239,19 @@ def _parse_command(cmd_id: str, raw: Any) -> CommandSpec:
         "requires_materialized_deps",
         "report",
         "scope",
+        "observation",
     }
     extra = {k: v for k, v in m.items() if k not in known}
+    # An ``observation:`` block is validated STRICTLY at load time: any weakening
+    # of the anti-false-green invariant is a profile error, not a silent green.
+    observation = None
+    if "observation" in m:
+        try:
+            observation = VerifyObservationPolicy.from_mapping(
+                m.get("observation"), where=f"{where}.observation"
+            )
+        except ValueError as exc:
+            raise LanguageProfileError(str(exc)) from exc
     return CommandSpec(
         id=cmd_id,
         argv=argv,
@@ -249,6 +261,7 @@ def _parse_command(cmd_id: str, raw: Any) -> CommandSpec:
         requires_materialized_deps=bool(m.get("requires_materialized_deps", False)),
         report=_parse_report(m.get("report")),
         scope=_parse_scope(m.get("scope")),
+        observation=observation,
         extra=extra,
     )
 

{codd_dev-2.71.0 → codd_dev-2.72.0}/codd/languages/profile.py

@@ -210,6 +210,82 @@ class ScopeSpec:
     must_include_test_sets: tuple[str, ...] = ()
 
 
+@dataclass(frozen=True)
+class VerifyObservationPolicy:
+    """Unweakenable anti-false-green observation policy for a verify command.
+
+    The DEFAULTS are the invariant: a verify run is green ONLY if it observed at
+    least ``min_collected_tests`` real tests, produced a parseable report, and
+    had no failed/skipped tests. A profile may STRENGTHEN (raise
+    ``min_collected_tests``) but NEVER weaken — every weakening declaration
+    (``allow_zero_tests``, ``zero_tests: warn``, ``report_missing: pass``,
+    ``min_collected_tests: 0``, an unknown key, …) is rejected by
+    :meth:`from_mapping` at load time, so a profile cannot silently turn a
+    not-green verify outcome green (a profile is a contract, not a way to
+    disable the invariant).
+    """
+
+    min_collected_tests: int = 1
+    zero_tests: Literal["red"] = "red"
+    report_missing: Literal["red"] = "red"
+    report_parse_error: Literal["red"] = "red"
+    failed_tests: Literal["red"] = "red"
+    skipped_tests: Literal["red"] = "red"
+
+    #: Fields that may ONLY ever be "red" — they cannot be weakened by a profile.
+    RED_ONLY: ClassVar[tuple[str, ...]] = (
+        "zero_tests",
+        "report_missing",
+        "report_parse_error",
+        "failed_tests",
+        "skipped_tests",
+    )
+
+    @classmethod
+    def from_mapping(
+        cls, raw: Any, *, where: str = "commands.verify.observation"
+    ) -> "VerifyObservationPolicy":
+        """Parse + STRICTLY validate an ``observation:`` block; raise on weakening.
+
+        ``None`` → the strict defaults. Any weakening (a RED_ONLY field set to
+        anything but "red", ``min_collected_tests < 1``, or an unknown key such
+        as ``allow_zero_tests``) raises :class:`ValueError`.
+        """
+        if raw is None:
+            return cls()
+        if not isinstance(raw, Mapping):
+            raise ValueError(f"{where}: expected a mapping, got {type(raw).__name__}")
+        known = {"min_collected_tests", *cls.RED_ONLY}
+        unknown = sorted(k for k in raw if k not in known)
+        if unknown:
+            raise ValueError(
+                f"{where}: unknown observation key(s) {unknown} — the anti-false-green "
+                f"observation policy cannot be extended with weakening flags "
+                f"(e.g. allow_zero_tests). Permitted keys: {sorted(known)}."
+            )
+        for key in cls.RED_ONLY:
+            if key in raw and str(raw[key]).strip().lower() != "red":
+                raise ValueError(
+                    f"{where}: {key}={raw[key]!r} weakens an anti-false-green invariant; "
+                    f"only 'red' is permitted (a profile cannot turn a not-green verify "
+                    f"outcome green)."
+                )
+        mct_raw = raw.get("min_collected_tests", 1)
+        try:
+            mct = int(mct_raw)
+        except (TypeError, ValueError):
+            raise ValueError(
+                f"{where}: min_collected_tests must be an integer, got {mct_raw!r}"
+            )
+        if mct < 1:
+            raise ValueError(
+                f"{where}: min_collected_tests={mct} weakens the invariant; it must be "
+                f">= 1 (a verify that observed zero tests is never green). Profiles may "
+                f"raise it (stricter), never lower it."
+            )
+        return cls(min_collected_tests=mct)
+
+
 @dataclass(frozen=True)
 class CommandSpec:
     """A single runnable command (design §1.4).
@@ -227,6 +303,9 @@ class CommandSpec:
     requires_materialized_deps: bool = False
     report: ReportSpec | None = None
     scope: ScopeSpec | None = None
+    #: Unweakenable anti-false-green observation policy (verify commands). ``None``
+    #: ⇒ the strict defaults apply (see :meth:`VerifyObservationPolicy.from_mapping`).
+    observation: VerifyObservationPolicy | None = None
     #: Free-form leftover keys (e.g. ``pass_condition``) preserved for later phases.
     extra: Mapping[str, Any] = field(default_factory=lambda: MappingProxyType({}))
 

{codd_dev-2.71.0 → codd_dev-2.72.0}/codd/languages/verify_plan.py

@@ -25,6 +25,7 @@ from enum import Enum
 from typing import Mapping
 
 from .contract import ResolvedLanguageContract
+from .profile import VerifyObservationPolicy
 
 
 class VerifyClass(str, Enum):
@@ -54,6 +55,7 @@ class VerifyRunPlan:
     report_adapter: str | None
     report_required: bool
     must_include_test_sets: tuple[str, ...]
+    observation: VerifyObservationPolicy
 
     @property
     def command_str(self) -> str:
@@ -83,6 +85,8 @@ def build_verify_plan(contract: ResolvedLanguageContract) -> VerifyRunPlan | Non
         report_adapter=(report.adapter if report else None),
         report_required=bool(report and report.path),
         must_include_test_sets=(scope.must_include_test_sets if scope else ()),
+        # None on the command ⇒ the strict defaults (the invariant), never weaker.
+        observation=(cmd.observation or VerifyObservationPolicy()),
     )
 
 

{codd_dev-2.71.0 → codd_dev-2.72.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codd-dev"
-version = "2.71.0"
+version = "2.72.0"
 description = "CoDD: Coherence-Driven Development — cross-artifact change impact analysis"
 readme = "README.md"
 license = "MIT"