codd-dev 2.61.0__tar.gz → 2.63.0__tar.gz

{codd_dev-2.61.0 → codd_dev-2.63.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.61.0
+Version: 2.63.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.61.0 → codd_dev-2.63.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.61.0"
+__version__ = "2.63.0"

{codd_dev-2.61.0 → codd_dev-2.63.0}/codd/implement_oracle.py

@@ -1812,12 +1812,23 @@ def normalize_python_tool_output(
     command: str,
     project_root: Path,
     profile: LayoutProfile,
+    is_first_party: Callable[[str], bool] | None = None,
 ) -> tuple[list[ImplementOracleFinding], list[str]]:
     """Normalize ``pytest --collect-only`` output → (findings, failed paths).
 
     Parses every collection error (ModuleNotFoundError / cannot-import-name /
     SyntaxError / generic ERROR-collecting) into a language-neutral finding. Used
     by the collect layer; also reachable via :func:`normalize_oracle_output`.
+
+    ``is_first_party`` (when supplied) gates module-resolution findings to
+    FIRST-PARTY targets only: a collection ``ModuleNotFoundError`` / cannot-import
+    -name whose target module is third-party / stdlib is an IMPLEMENT-TIME
+    ENVIRONMENT concern (the dependency is simply not installed yet), NOT a
+    coherence failure — first-party importability is already proven by the static
+    first-party import resolver layer. Emitting it would be a false-RED. A
+    first-party target (the SUT genuinely missing a module/symbol) is always
+    reported. When ``is_first_party`` is None the legacy behaviour (emit every
+    parsed error) is preserved for callers without a module index.
     """
     text = output or ""
     findings: list[ImplementOracleFinding] = []
@@ -1838,20 +1849,26 @@ def normalize_python_tool_output(
 
     primary_path = failed_paths[0] if failed_paths else None
     for m in _PYTEST_MOD_NOT_FOUND.finditer(text):
+        module = m.group("module")
+        if is_first_party is not None and not is_first_party(module):
+            continue  # third-party / stdlib not installed at implement time — env, not coherence
         findings.append(
             ImplementOracleFinding(
                 category=EVIDENCE_MODULE_RESOLUTION,
                 code="PY_MODULE_NOT_FOUND",
-                message=f"No module named {m.group('module')!r} (pytest collection)",
+                message=f"No module named {module!r} (pytest collection)",
                 path=primary_path,
             )
         )
     for m in _PYTEST_CANNOT_IMPORT_NAME.finditer(text):
+        source_module = m.group("module")
+        if is_first_party is not None and not is_first_party(source_module):
+            continue  # symbol missing from a third-party module — env/version, not SUT coherence
         findings.append(
             ImplementOracleFinding(
                 category=EVIDENCE_MISSING_SYMBOL,
                 code="PY_IMPORT_NAME_NOT_FOUND",
-                message=f"cannot import name {m.group('symbol')!r} from {m.group('module')!r}",
+                message=f"cannot import name {m.group('symbol')!r} from {source_module!r}",
                 path=primary_path,
             )
         )
@@ -1880,9 +1897,47 @@ def _python_collect_timeout_seconds(config: Mapping[str, Any] | None) -> float:
     return DEFAULT_PYTHON_COLLECT_TIMEOUT_SECONDS
 
 
+def _collection_failure_is_third_party_only(
+    output: str, is_first_party: Callable[[str], bool], errored_file_count: int
+) -> bool:
+    """True iff EVERY pytest collection error is an uninstalled third-party / stdlib
+    import — so the non-zero collect exit is an implement-time ENV concern, not a
+    coherence failure.
+
+    ``errored_file_count`` is the number of DISTINCT errored test files (the
+    deduped, project-relative ``failed_paths`` the normalizer already computed —
+    parsing it here would double-count, since one file surfaces both an
+    ``ERROR collecting <rel>`` header and an absolute ``importing test module`` line).
+
+    Anti-false-green (conservative by construction): returns False — i.e. let the
+    honest ``pytest_collect_exit_N`` failure stand — UNLESS every errored file is
+    accounted for by a non-first-party ``ModuleNotFoundError``, AND there is NO
+    first-party module-not-found, NO cannot-import-name from a first-party module,
+    and NO SyntaxError. First-party importability/coherence is independently proven
+    by the static first-party import-resolver layer (the keystone layer), so a real
+    SUT defect cannot hide behind a benign verdict here.
+    """
+    text = output or ""
+    if errored_file_count <= 0:
+        return False  # non-zero exit with no identifiable errored file — stay honest
+    if _PYTEST_SYNTAX_ERROR.search(text):
+        return False
+    for m in _PYTEST_CANNOT_IMPORT_NAME.finditer(text):
+        if is_first_party(m.group("module")):
+            return False
+    third_party_module_errors = 0
+    for m in _PYTEST_MOD_NOT_FOUND.finditer(text):
+        if is_first_party(m.group("module")):
+            return False
+        third_party_module_errors += 1
+    # every errored file must be accounted for by a third-party module-not-found
+    return third_party_module_errors >= errored_file_count
+
+
 def _run_python_pytest_collect_layer(
     project_root: Path,
     profile: LayoutProfile,
+    scope: PythonOracleScope,
     config: Mapping[str, Any] | None,
 ) -> PythonToolRun:
     """``python -m pytest <test_root> --collect-only -q`` — test importability.
@@ -1891,7 +1946,10 @@ def _run_python_pytest_collect_layer(
     absent / un-spawnable is an ``environment_build_error`` (NEVER a silent skip —
     a generated system whose tests cannot even be collected is not verified).
     Exit 0 ⇒ the test surface imports cleanly. Non-zero ⇒ parse the collection
-    errors; a non-zero exit with no parseable error is still an honest failure.
+    errors; a collection failure caused ONLY by uninstalled third-party imports is
+    an env concern (benign — first-party coherence is proven by the resolver
+    layer); a non-zero exit with no parseable / unattributable error is still an
+    honest failure.
     """
     timeout = _python_collect_timeout_seconds(config)
     test_root = _py_norm(profile.test_root) or "."
@@ -1952,10 +2010,23 @@ def _run_python_pytest_collect_layer(
         )
     if completed.returncode == 0:
         return PythonToolRun(name="pytest_collect", executed=True, output=output)
+    index = _build_python_module_index(project_root, profile, scope)
     findings, failed_paths = normalize_python_tool_output(
-        output, command=command, project_root=project_root, profile=profile
+        output,
+        command=command,
+        project_root=project_root,
+        profile=profile,
+        is_first_party=index.is_first_party_prefix,
     )
     if not findings:
+        if _collection_failure_is_third_party_only(
+            output, index.is_first_party_prefix, len(failed_paths)
+        ):
+            # Collection failed ONLY because a third-party dependency is not
+            # installed at implement time. First-party importability is proven by
+            # the static resolver layer; this is an environment concern, not a
+            # coherence failure → benign (never a false-RED on uninstalled deps).
+            return PythonToolRun(name="pytest_collect", executed=True, output=output)
         findings = [
             ImplementOracleFinding(
                 category=EVIDENCE_TEST_NOT_COLLECTED,
@@ -2161,7 +2232,7 @@ def _run_python_composite_oracle(
     tools: list[PythonToolRun] = [
         _run_python_compile_layer(project_root, all_files),
         _run_python_first_party_import_layer(project_root, profile, scope, all_files),
-        _run_python_pytest_collect_layer(project_root, profile, config),
+        _run_python_pytest_collect_layer(project_root, profile, scope, config),
     ]
     lint_mode = _python_lint_mode(config)
     if lint_mode != "off":

{codd_dev-2.61.0 → codd_dev-2.63.0}/codd/vb_marker_authenticity.py

@@ -1762,15 +1762,37 @@ _PY_SKIP_DECORATOR_RE = re.compile(
 #: ``self.assert*`` / ``self.fail`` call, or ``np.testing.assert*``. A bare call
 #: to a named helper (``assert_that(...)``, ``verify(...)``) is NOT primitive — it
 #: is resolved via the evidence graph so a no-op helper cannot pass on its name.
+#: unittest assertion can be called on a TestCase reference that is NOT ``self`` — a
+#: shared assert helper takes the TestCase as a parameter and calls ``testcase.assertX``.
+#: A NARROW receiver allowlist (not any ``X.assertY``) keeps a namespace helper
+#: (``helpers.assert_token_values(...)``) from being mis-read as a primitive.
+_PY_TESTCASE_RECEIVER_PATTERN = r"(?:self|cls|testcase|test_case|tc|case)"
+#: A ``<testcase-receiver>.assert<CamelCase>(`` call — the unittest assert-method form.
+#: CamelCase (``assert[A-Z]``) on purpose: a snake helper name (``assert_token_values``)
+#: is NOT a unittest assert method, so it stays helper-resolution-only.
+_PY_TESTCASE_ASSERT_CALL_RE = re.compile(
+    rf"\b(?P<recv>{_PY_TESTCASE_RECEIVER_PATTERN})\.assert[A-Z][A-Za-z0-9_]*\s*\("
+)
 _PY_PRIMITIVE_ASSERT_RE = re.compile(
     r"(^|[^A-Za-z0-9_])(assert\b|pytest\.(?:raises|warns)\b|pytest\.fail\s*\(|"
-    r"self\.assert[A-Za-z]+\s*\(|self\.fail\s*\(|np\.testing\.assert)"
+    rf"{_PY_TESTCASE_RECEIVER_PATTERN}\.assert[A-Z][A-Za-z0-9_]*\s*\(|self\.fail\s*\(|np\.testing\.assert)"
     # ``raise AssertionError`` (the explicit form of ``assert``) — LINE-ANCHORED so a
     # ``raise AssertionError`` inside a string/comment does not match (the AST-first
     # ``_python_body_has_primitive_assertion`` is the primary guard; this is fallback).
     r"|^[ \t]*raise\s+AssertionError\b",
     re.MULTILINE,
 )
+
+
+def _testcase_assert_receivers_in(text: str) -> set[str]:
+    """Receiver names used as ``<recv>.assert<CamelCase>(`` in ``text`` (e.g. ``testcase``).
+
+    These are the assertion API ``器`` (the TestCase), NOT observed values — so they must
+    be EXCLUDED from the argument-anchor (otherwise ``testcase.assertEqual(1, 1)`` would
+    anchor via ``testcase`` and a constant-only helper would falsely pass). A no-op for
+    TS bodies (no ``self|tc|...\\.assertX`` patterns), so it is safe in the shared anchor."""
+
+    return {m.group("recv") for m in _PY_TESTCASE_ASSERT_CALL_RE.finditer(text)}
 #: A python ``def helper(...):`` header (captures name + the parameter list so the
 #: argument-anchor check can confirm the helper references its own arguments).
 _PY_DEF_RE = re.compile(
@@ -3277,6 +3299,14 @@ def _params_and_derived_locals(body: str, param_set: set[str]) -> set[str]:
     crediting fake coverage.
     """
 
+    if not param_set:
+        return set()
+    # A TestCase passed as a parameter (``def helper(testcase, ...): testcase.assertEqual(...)``)
+    # is the assertion API ``器``, NOT an observed value — exclude it from the anchor so a
+    # constant-only helper (``testcase.assertEqual(1, 1)``) stays unanchored ⇒ FAIL. No-op
+    # for TS / non-unittest bodies (no ``<recv>.assertX`` calls). Cross-language: the
+    # detector only matches the unittest assert-method form, so other stacks are untouched.
+    param_set = param_set - _testcase_assert_receivers_in(body)
     if not param_set:
         return set()
     derived = set(param_set)

{codd_dev-2.61.0 → codd_dev-2.63.0}/pyproject.toml

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