sarj-python-lint 0.80.6__tar.gz → 0.80.8__tar.gz

{sarj_python_lint-0.80.6 → sarj_python_lint-0.80.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 0.80.6
+Version: 0.80.8
 Summary: Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults
 Project-URL: Homepage, https://code-standards.sarj.ai/rules/python/
 Project-URL: Documentation, https://code-standards.sarj.ai/rules/python/

{sarj_python_lint-0.80.6 → sarj_python_lint-0.80.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "0.80.6"
+version = "0.80.8"
 description = "Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults"
 readme = "README.md"
 authors = [{ name = "sarj-ai" }]

sarj_python_lint-0.80.8/src/sarj_python_lint/rules/_fixed_record.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import ast
+
+from sarj_python_lint.rules._ast_index import children
+
+
+_RECORD_MUTATOR_METHODS = frozenset({"clear", "pop", "popitem", "setdefault", "update"})
+
+
+def builds_fixed_record(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+    returned: list[ast.expr] = []
+    record_names = {
+        target.id
+        for current in _owned_nodes(node)
+        if isinstance(current, ast.Assign) and _is_record_literal(current.value)
+        for target in current.targets
+        if isinstance(target, ast.Name)
+    }
+    record_names.update(
+        current.target.id
+        for current in _owned_nodes(node)
+        if isinstance(current, ast.AnnAssign)
+        and isinstance(current.target, ast.Name)
+        and current.value is not None
+        and _is_record_literal(current.value)
+    )
+    invalidated_names: set[str] = set()
+    aliases: dict[str, str] = {}
+    stack: list[ast.AST] = list(node.body)
+    while stack:
+        current = stack.pop()
+        if isinstance(current, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)):
+            continue
+        if isinstance(current, ast.Return) and current.value is not None:
+            returned.append(current.value)
+        elif isinstance(current, ast.Assign) and _is_record_literal(current.value):
+            for target in current.targets:
+                if isinstance(target, ast.Subscript):
+                    invalidated_names.update(_mutated_record_roots(target))
+        elif isinstance(current, ast.Assign):
+            if isinstance(current.value, ast.Name):
+                for target in current.targets:
+                    if not isinstance(target, ast.Name):
+                        continue
+                    if target.id in record_names:
+                        invalidated_names.add(target.id)
+                    else:
+                        aliases[target.id] = current.value.id
+            else:
+                invalidated_names.update(
+                    target.id for target in current.targets if isinstance(target, ast.Name)
+                )
+            for target in current.targets:
+                if isinstance(target, ast.Subscript):
+                    invalidated_names.update(_mutated_record_roots(target))
+        elif (
+            isinstance(current, ast.AnnAssign)
+            and isinstance(current.target, ast.Name)
+            and current.value is not None
+            and _is_record_literal(current.value)
+        ):
+            pass
+        elif (
+            isinstance(current, ast.AnnAssign)
+            and isinstance(current.target, ast.Name)
+            and isinstance(current.value, ast.Name)
+        ):
+            if current.target.id in record_names:
+                invalidated_names.add(current.target.id)
+            else:
+                aliases[current.target.id] = current.value.id
+        elif isinstance(current, (ast.AnnAssign, ast.AugAssign)):
+            invalidated_names.update(_mutated_record_roots(current.target))
+        elif isinstance(current, ast.Delete):
+            for target in current.targets:
+                invalidated_names.update(_mutated_record_roots(target))
+        elif (
+            isinstance(current, ast.Call)
+            and isinstance(current.func, ast.Attribute)
+            and current.func.attr in _RECORD_MUTATOR_METHODS
+            and isinstance(current.func.value, ast.Name)
+        ):
+            invalidated_names.add(current.func.value.id)
+        elif isinstance(current, ast.Call):
+            invalidated_names.update(
+                argument.id
+                for argument in (*current.args, *(keyword.value for keyword in current.keywords))
+                if isinstance(argument, ast.Name)
+            )
+        stack.extend(children(current))
+
+    changed = True
+    while changed:
+        changed = False
+        for alias, original in aliases.items():
+            if alias in invalidated_names and original not in invalidated_names:
+                invalidated_names.add(original)
+                changed = True
+            if original in invalidated_names and alias not in invalidated_names:
+                invalidated_names.add(alias)
+                changed = True
+
+    def original_name(name: str) -> str:
+        seen: set[str] = set()
+        while name in aliases and name not in seen:
+            seen.add(name)
+            name = aliases[name]
+        return name
+
+    intact_record_names = record_names - invalidated_names
+    if any(
+        isinstance(value, ast.Name) and original_name(value.id) in record_names & invalidated_names
+        for value in returned
+    ):
+        return False
+    return any(
+        _is_record_literal(value)
+        or (isinstance(value, ast.Name) and original_name(value.id) in intact_record_names)
+        for value in returned
+    )
+
+
+def _owned_nodes(node: ast.FunctionDef | ast.AsyncFunctionDef) -> list[ast.AST]:
+    owned: list[ast.AST] = []
+    stack: list[ast.AST] = list(node.body)
+    while stack:
+        current = stack.pop()
+        if isinstance(current, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)):
+            continue
+        owned.append(current)
+        stack.extend(children(current))
+    return owned
+
+
+def _is_record_literal(node: ast.expr) -> bool:
+    if isinstance(node, ast.List):
+        return bool(node.elts) and all(_is_record_literal(element) for element in node.elts)
+    if isinstance(node, ast.ListComp):
+        return _is_record_literal(node.elt)
+    if not isinstance(node, ast.Dict):
+        return False
+    return bool(node.keys) and all(
+        isinstance(key, ast.Constant) and isinstance(key.value, str) for key in node.keys
+    )
+
+
+def _mutated_record_roots(target: ast.AST) -> set[str]:
+    while isinstance(target, ast.Subscript):
+        target = target.value
+    return {target.id} if isinstance(target, ast.Name) else set()

sarj_python_lint-0.80.8/src/sarj_python_lint/rules/_imports.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import ast
+from collections.abc import Mapping
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import Self
+
+
+@dataclass(frozen=True, slots=True)
+class _ImportTarget:
+    module: str
+    symbol: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class ImportIndex:
+    bindings: Mapping[str, _ImportTarget]
+    shadowed_names: frozenset[str]
+
+    @classmethod
+    def from_tree(cls, tree: ast.Module, *, module_scope_only: bool = False) -> Self:
+        candidates: dict[str, set[_ImportTarget]] = {}
+        statements = _module_import_statements(tree) if module_scope_only else tree.body
+        for statement in statements:
+            match statement:
+                case ast.Import(names=names):
+                    for alias in names:
+                        local = alias.asname or alias.name.partition(".")[0]
+                        module = alias.name if alias.asname else alias.name.partition(".")[0]
+                        candidates.setdefault(local, set()).add(_ImportTarget(module, None))
+                case ast.ImportFrom(module=str(module), names=names, level=0):
+                    for alias in names:
+                        if alias.name == "*":
+                            continue
+                        local = alias.asname or alias.name
+                        candidates.setdefault(local, set()).add(_ImportTarget(module, alias.name))
+                case _:
+                    pass
+
+        imported_names = frozenset(candidates)
+        non_import_bindings = (
+            _module_non_import_bindings(tree) if module_scope_only else _non_import_bindings(tree)
+        )
+        rebound = non_import_bindings & imported_names
+        bindings = {
+            local: next(iter(targets))
+            for local, targets in candidates.items()
+            if len(targets) == 1 and local not in rebound
+        }
+        return cls(MappingProxyType(bindings), frozenset(non_import_bindings))
+
+    def resolves(self, node: ast.expr, *, sources: frozenset[str], symbol: str) -> bool:
+        resolved = self._resolve(node)
+        return resolved is not None and resolved.module in sources and resolved.symbol == symbol
+
+    def resolved_symbol(self, node: ast.expr, *, sources: frozenset[str]) -> str | None:
+        resolved = self._resolve(node)
+        if resolved is None or resolved.module not in sources:
+            return None
+        return resolved.symbol
+
+    def builtin_is_unshadowed(self, name: str) -> bool:
+        return name not in self.shadowed_names and name not in self.bindings
+
+    def _resolve(self, node: ast.expr) -> _ImportTarget | None:
+        match node:
+            case ast.Name(id=local):
+                target = self.bindings.get(local)
+                return target if target is not None and target.symbol is not None else None
+            case ast.Attribute():
+                parts: list[str] = []
+                current: ast.expr = node
+                while isinstance(current, ast.Attribute):
+                    parts.append(current.attr)
+                    current = current.value
+                if not isinstance(current, ast.Name):
+                    return None
+                target = self.bindings.get(current.id)
+                if target is None or target.symbol is not None or not parts:
+                    return None
+                ordered = list(reversed(parts))
+                return _ImportTarget(".".join((target.module, *ordered[:-1])), ordered[-1])
+            case _:
+                return None
+
+
+def _non_import_bindings(tree: ast.Module) -> set[str]:
+    names: set[str] = set()
+    for node in ast.walk(tree):
+        match node:
+            case ast.Name(id=name, ctx=(ast.Store() | ast.Del())) | ast.arg(arg=name):
+                names.add(name)
+            case ast.FunctionDef() | ast.AsyncFunctionDef() | ast.ClassDef():
+                names.add(node.name)
+            case ast.alias():
+                # Imports are the candidate bindings, not shadows of themselves.
+                continue
+            case _:
+                pass
+    return names
+
+
+def _module_non_import_bindings(tree: ast.Module) -> set[str]:
+    names: set[str] = set()
+    for statement in tree.body:
+        match statement:
+            case ast.FunctionDef() | ast.AsyncFunctionDef() | ast.ClassDef():
+                names.add(statement.name)
+            case ast.Assign(targets=targets):
+                for target in targets:
+                    names.update(_target_names(target))
+            case ast.AnnAssign(target=target) | ast.AugAssign(target=target):
+                names.update(_target_names(target))
+            case ast.TypeAlias(name=ast.Name(id=name)):
+                names.add(name)
+            case ast.Import() | ast.ImportFrom():
+                continue
+            case _:
+                # Module control flow can still bind names in the module namespace.
+                _collect_module_bindings(statement, names)
+    return names
+
+
+def _target_names(node: ast.expr) -> set[str]:
+    if isinstance(node, ast.Name):
+        return {node.id}
+    if isinstance(node, (ast.Tuple, ast.List)):
+        return {name for element in node.elts for name in _target_names(element)}
+    return set()
+
+
+def _collect_module_bindings(node: ast.AST, names: set[str]) -> None:
+    match node:
+        case ast.FunctionDef() | ast.AsyncFunctionDef() | ast.ClassDef():
+            names.add(node.name)
+            return
+        case ast.ListComp() | ast.SetComp() | ast.GeneratorExp():
+            _collect_module_bindings(node.elt, names)
+            _collect_comprehension_bindings(node.generators, names)
+            return
+        case ast.DictComp():
+            _collect_module_bindings(node.key, names)
+            _collect_module_bindings(node.value, names)
+            _collect_comprehension_bindings(node.generators, names)
+            return
+        case ast.Lambda():
+            return
+        case ast.Name(id=name, ctx=(ast.Store() | ast.Del())):
+            names.add(name)
+        case _:
+            pass
+    for child in ast.iter_child_nodes(node):
+        _collect_module_bindings(child, names)
+
+
+def _collect_comprehension_bindings(generators: list[ast.comprehension], names: set[str]) -> None:
+    for generator in generators:
+        _collect_module_bindings(generator.iter, names)
+        for condition in generator.ifs:
+            _collect_module_bindings(condition, names)
+
+
+def _module_import_statements(tree: ast.Module) -> list[ast.stmt]:
+    statements = list(tree.body)
+    for statement in tree.body:
+        if not isinstance(statement, ast.If) or not _is_type_checking_guard(statement.test):
+            continue
+        statements.extend(
+            child for child in statement.body if isinstance(child, (ast.Import, ast.ImportFrom))
+        )
+    return statements
+
+
+def _is_type_checking_guard(node: ast.expr) -> bool:
+    return (isinstance(node, ast.Name) and node.id == "TYPE_CHECKING") or (
+        isinstance(node, ast.Attribute)
+        and isinstance(node.value, ast.Name)
+        and node.value.id in {"typing", "typing_extensions"}
+        and node.attr == "TYPE_CHECKING"
+    )

{sarj_python_lint-0.80.6 → sarj_python_lint-0.80.8}/src/sarj_python_lint/rules/_registry.py

@@ -50,8 +50,13 @@ from sarj_python_lint.rules.no_hidden_constructor_fallback import (
 )
 from sarj_python_lint.rules.no_nested_pydantic_field_validator import NoNestedPydanticFieldValidator
 from sarj_python_lint.rules.no_offset_pagination import NoOffsetPagination
+from sarj_python_lint.rules.no_positional_psycopg_row_escape import NoPositionalPsycopgRowEscape
+from sarj_python_lint.rules.no_psycopg_execution_outside_injected_owner import (
+    NoPsycopgExecutionOutsideInjectedOwner,
+)
 from sarj_python_lint.rules.no_random_uuid_in_sql import NoRandomUuidInSql
 from sarj_python_lint.rules.no_raw_connection_in_tests import NoRawConnectionInTests
+from sarj_python_lint.rules.no_raw_source_text_test_oracle import NoRawSourceTextTestOracle
 from sarj_python_lint.rules.no_redundant_literal_description import NoRedundantLiteralDescription
 from sarj_python_lint.rules.no_repeated_string_literal import NoRepeatedStringLiteral
 from sarj_python_lint.rules.no_repeated_test_body import NoRepeatedTestBody
@@ -96,7 +101,6 @@ from sarj_python_lint.rules.prefer_nominal_id_types import PreferNominalIdTypes
 from sarj_python_lint.rules.prefer_non_nullable_collection import (
     PreferNonNullableCollection,
 )
-from sarj_python_lint.rules.prefer_one_for_required_row import PreferOneForRequiredRow
 from sarj_python_lint.rules.prefer_or_pattern import PreferOrPattern
 from sarj_python_lint.rules.prefer_self_documenting_constant import (
     PreferSelfDocumentingConstant,
@@ -107,17 +111,12 @@ from sarj_python_lint.rules.prefer_str_enum import PreferStrEnum
 from sarj_python_lint.rules.prefer_struct_over_namedtuple import (
     PreferStructOverNamedtuple,
 )
-from sarj_python_lint.rules.prefer_timedelta_for_durations import (
-    PreferTimedeltaForDurations,
-)
 from sarj_python_lint.rules.prefer_walrus_awaited_none_guard import PreferWalrusAwaitedNoneGuard
 from sarj_python_lint.rules.prefer_walrus_comprehension_filter import (
     PreferWalrusComprehensionFilter,
 )
 from sarj_python_lint.rules.prefer_walrus_regex_match import PreferWalrusRegexMatch
 from sarj_python_lint.rules.prefer_walrus_stream_loop import PreferWalrusStreamLoop
-from sarj_python_lint.rules.preserve_declared_nominal_id import PreserveDeclaredNominalId
-from sarj_python_lint.rules.preserve_enum_types import PreserveEnumTypes
 from sarj_python_lint.rules.production_derived_test_cases import ProductionDerivedTestCases
 from sarj_python_lint.rules.pydantic_at_boundaries import PydanticAtBoundaries
 from sarj_python_lint.rules.pytest_fixture_returns_bare_tuple import PytestFixtureReturnsBareTuple
@@ -139,10 +138,7 @@ from sarj_python_lint.rules.require_pydantic_for_external_json import (
 from sarj_python_lint.rules.require_pydantic_ordinal_lower_bound import (
     RequirePydanticOrdinalLowerBound,
 )
-from sarj_python_lint.rules.require_validated_row_factory import RequireValidatedRowFactory
 from sarj_python_lint.rules.restated_test_docstring import RestatedTestDocstring
-from sarj_python_lint.rules.source_coupled_test import SourceCoupledTest
-from sarj_python_lint.rules.sql_requires_injected_pool_owner import SqlRequiresInjectedPoolOwner
 from sarj_python_lint.rules.stepdown import Stepdown
 from sarj_python_lint.rules.store_get_delegates_to_bulk_read import StoreGetDelegatesToBulkRead
 from sarj_python_lint.rules.store_insert_requires_on_conflict import (
@@ -179,12 +175,11 @@ REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
         FakesInSharedLocation.id: FakesInSharedLocation,
         PreferConstantTimeSecretCompare.id: PreferConstantTimeSecretCompare,
         NoSecretInLog.id: NoSecretInLog,
-        PreferTimedeltaForDurations.id: PreferTimedeltaForDurations,
         PreferStructOverNamedtuple.id: PreferStructOverNamedtuple,
         NoCommentCruft.id: NoCommentCruft,
         NoConftestTestModuleImport.id: NoConftestTestModuleImport,
         StoreInsertRequiresOnConflict.id: StoreInsertRequiresOnConflict,
-        SourceCoupledTest.id: SourceCoupledTest,
+        NoRawSourceTextTestOracle.id: NoRawSourceTextTestOracle,
         IacSourceCoupledTest.id: IacSourceCoupledTest,
         NoRawConnectionInTests.id: NoRawConnectionInTests,
         NoAnalyticalAggregationInPostgresStore.id: NoAnalyticalAggregationInPostgresStore,
@@ -201,7 +196,6 @@ REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
         OpaqueParametrizeCaseNeedsId.id: OpaqueParametrizeCaseNeedsId,
         PytestFixtureReturnsBareTuple.id: PytestFixtureReturnsBareTuple,
         StoreGetDelegatesToBulkRead.id: StoreGetDelegatesToBulkRead,
-        PreferOneForRequiredRow.id: PreferOneForRequiredRow,
         RepeatedKwargHeavyCallInTest.id: RepeatedKwargHeavyCallInTest,
         DefectXfailRequiresExplicitStrict.id: DefectXfailRequiresExplicitStrict,
         NoFirstPartyPrivateImport.id: NoFirstPartyPrivateImport,
@@ -249,10 +243,8 @@ REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
         ProductionDerivedTestCases.id: ProductionDerivedTestCases,
         UncontrolledRandomnessInTest.id: UncontrolledRandomnessInTest,
         RepeatedStaticCallCases.id: RepeatedStaticCallCases,
-        RequireValidatedRowFactory.id: RequireValidatedRowFactory,
-        SqlRequiresInjectedPoolOwner.id: SqlRequiresInjectedPoolOwner,
-        PreserveDeclaredNominalId.id: PreserveDeclaredNominalId,
-        PreserveEnumTypes.id: PreserveEnumTypes,
+        NoPositionalPsycopgRowEscape.id: NoPositionalPsycopgRowEscape,
+        NoPsycopgExecutionOutsideInjectedOwner.id: NoPsycopgExecutionOutsideInjectedOwner,
         RequirePydanticOrdinalLowerBound.id: RequirePydanticOrdinalLowerBound,
         RequireNoDecodeForSplittingSettingsField.id: RequireNoDecodeForSplittingSettingsField,
         NoVagueSuppressionDescription.id: NoVagueSuppressionDescription,

{sarj_python_lint-0.80.6 → sarj_python_lint-0.80.8}/src/sarj_python_lint/rules/_sql.py

@@ -39,12 +39,28 @@ def sql_string_value(node: ast.expr, *, interpolation_placeholder: str = " ") ->
     return None
 
 
-def strip_sql_noise(text: str, *, mask_dollar_quotes: bool = True) -> str:
+def strip_sql_noise(
+    text: str,
+    *,
+    mask_dollar_quotes: bool = True,
+    mask_double_quotes: bool = True,
+) -> str:
     out = list(text)
     n = len(text)
     i = 0
     while i < n:
         ch = text[i]
+        if ch == '"' and not mask_double_quotes:
+            i += 1
+            while i < n:
+                if text[i] == '"':
+                    i += 1
+                    if i < n and text[i] == '"':
+                        i += 1
+                        continue
+                    break
+                i += 1
+            continue
         if ch in {"'", '"'}:
             out[i] = " "
             i += 1

{sarj_python_lint-0.80.6 → sarj_python_lint-0.80.8}/src/sarj_python_lint/rules/fastapi_explicit_openapi_contract.py

@@ -26,6 +26,7 @@ from sarj_python_lint.rules._fastapi import (
     Route,
     flat_name,
 )
+from sarj_python_lint.rules._fixed_record import builds_fixed_record
 from sarj_python_lint.rules._paths import is_generated, is_test_path
 
 
@@ -152,6 +153,42 @@ class FastapiExplicitOpenapiContract(Rule):
                 scenario="schema-integrity",
                 public=True,
             ),
+            RuleExample(
+                example_id="unannotated-record-response",
+                title="Unnamed record leaves the response schema implicit",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "api.py",
+                        "from fastapi import APIRouter\n\nrouter = APIRouter()\n\n"
+                        "@router.get('/health', status_code=200)\n"
+                        "async def health():\n    return {'status': 'ok'}\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("api.py"),
+                expected_count=1,
+                scenario="unannotated-record",
+                public=True,
+            ),
+            RuleExample(
+                example_id="named-record-response",
+                title="Named response type documents the record",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "api.py",
+                        "from fastapi import APIRouter\nfrom pydantic import BaseModel\n\n"
+                        "class HealthResponse(BaseModel):\n    status: str\n\n"
+                        "router = APIRouter()\n\n@router.get('/health', status_code=200)\n"
+                        "async def health() -> HealthResponse:\n"
+                        "    return HealthResponse(status='ok')\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("api.py"),
+                expected_count=0,
+                scenario="unannotated-record",
+                public=True,
+            ),
         ),
     )
     description: str = documentation.summary
@@ -386,10 +423,27 @@ def _check_return(
 ) -> list[_Finding]:
     annotation = index.resolve_annotation(function.returns)
     if annotation is None:
+        if not builds_fixed_record(function):
+            return []
+        for route in _operations(routes):
+            if route.has_unpack:
+                continue
+            response_model = route.keywords.get("response_model")
+            status = _status_code(route.keywords.get("status_code"), index) or HTTPStatus.OK
+            if (
+                _concrete_response_model(response_model, index)
+                or any(_documents_response_model(node, status, index) for node in _route_response_nodes(route))
+            ):
+                continue
+            return [
+                _Finding(
+                    function,
+                    "[return] fixed-shape dictionary requires a named return type or concrete response_model.",
+                )
+            ]
         return []
     problems: set[str] = set()
-    if _schema_erasing(annotation, index):
-        problems.add("response annotation erases its OpenAPI schema; define an output model")
+    annotation_erases_schema = _schema_erasing(annotation, index)
     is_response = index.is_response(annotation)
     is_none = _is_none_annotation(annotation, index)
     for route in _operations(routes):
@@ -398,6 +452,8 @@ def _check_return(
         keywords = route.keywords
         response_model = keywords.get("response_model")
         response_model_none = response_model is not None and _literal_none(response_model)
+        if annotation_erases_schema and not _concrete_response_model(response_model, index):
+            problems.add("response annotation erases its OpenAPI schema; define an output model")
         status = _status_code(keywords.get("status_code"), index)
         response_class = keywords.get("response_class") or route.inherited_response_class
         if is_response and status not in _NO_CONTENT_STATUSES and response_class is None:
@@ -464,6 +520,24 @@ def _documents_response_content(node: ast.expr | None, status: int | None, index
     return False
 
 
+def _documents_response_model(node: ast.expr | None, status: int | None, index: FastapiIndex) -> bool:
+    if not isinstance(node, ast.Dict):
+        return False
+    for key, value in zip(node.keys, node.values, strict=True):
+        if key is None or not isinstance(value, ast.Dict):
+            continue
+        if status is not None and status not in _response_codes(ast.Dict(keys=[key], values=[value]), index):
+            continue
+        for entry_key, entry_value in zip(value.keys, value.values, strict=True):
+            if (
+                isinstance(entry_key, ast.Constant)
+                and entry_key.value == "model"
+                and _concrete_response_model(entry_value, index)
+            ):
+                return True
+    return False
+
+
 def _route_response_nodes(route: Route) -> tuple[ast.expr, ...]:
     return tuple(node for node in (route.inherited_responses, route.keywords.get("responses")) if node is not None)
 

{sarj_python_lint-0.80.6 → sarj_python_lint-0.80.8}/src/sarj_python_lint/rules/iac_source_coupled_test.py

@@ -15,8 +15,9 @@ from sarj_python_lint.rule_base import (
     Severity,
     parse_or_none,
 )
+from sarj_python_lint.rules._imports import ImportIndex
 from sarj_python_lint.rules._paths import is_generated, is_test_path
-from sarj_python_lint.rules.source_coupled_test import FunctionAnalyzer, top_level_test_functions
+from sarj_python_lint.rules.no_raw_source_text_test_oracle import FunctionAnalyzer, top_level_test_functions
 
 
 if TYPE_CHECKING:
@@ -45,7 +46,7 @@ class IacSourceCoupledTest(Rule):
             "The rule follows local aliases, path collections, context-managed reads, and common normalization; interprocedural flows remain unreported.",
             "Files produced beneath recognized temporary-directory fixtures are generated outputs and remain unreported.",
             "The Python detector currently owns Terraform and HCL suffixes; YAML remains with the general source-coupled rule.",
-            "Golden, packaging, formatter, and compatibility representation contracts require an exact suppression.",
+            "Fixture, golden, and snapshot paths are treated as deliberate representation contracts; other packaging, formatter, and compatibility contracts require an exact suppression.",
         ),
         examples=(
             RuleExample(
@@ -72,7 +73,7 @@ class IacSourceCoupledTest(Rule):
                 files=(
                     ExampleFile.python(
                         "tests/test_policy.py",
-                        "def test_policy():\n    source = Path('main.tf').read_text()\n    assert 'prevent_destroy = true' in source\n",
+                        "from pathlib import Path\n\ndef test_policy():\n    source = Path('main.tf').read_text()\n    assert 'prevent_destroy = true' in source\n",
                     ),
                 ),
                 focus_path=PurePosixPath("tests/test_policy.py"),
@@ -90,10 +91,18 @@ class IacSourceCoupledTest(Rule):
         tree = parse_or_none(path, source)
         if not isinstance(tree, ast.Module):
             return []
+        imports = ImportIndex.from_tree(tree, module_scope_only=True)
+        source_lines = source.splitlines()
         assertions = [
             assertion
-            for function, unittest_style in top_level_test_functions(tree)
-            for assertion in FunctionAnalyzer(IAC_SOURCE_SUFFIXES, unittest_style=unittest_style).analyze(function)
+            for function, unittest_style in top_level_test_functions(tree, imports)
+            for assertion in FunctionAnalyzer(
+                IAC_SOURCE_SUFFIXES,
+                imports=imports,
+                suppression_code=self.code,
+                suppression_lines=source_lines,
+                unittest_style=unittest_style,
+            ).analyze(function)
         ]
         return [
             Diagnostic(