sarj-python-lint 1.1.0__tar.gz → 1.2.0__tar.gz

{sarj_python_lint-1.1.0 → sarj_python_lint-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.1.0
+Version: 1.2.0
 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-1.1.0 → sarj_python_lint-1.2.0}/pyproject.toml

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

{sarj_python_lint-1.1.0 → sarj_python_lint-1.2.0}/src/sarj_python_lint/__main__.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import ast
 from collections import Counter
 from dataclasses import dataclass
+from fnmatch import fnmatch
 import json
 from pathlib import Path
 import sys
@@ -66,19 +67,21 @@ def expand_paths(paths: list[Path]) -> list[Path]:
 
 
 def _python_files(p: Path) -> list[Path]:
+    if not SKIP_DIR_NAMES.isdisjoint(p.parts):
+        return []
     out: list[Path] = []
-    for child in p.rglob("*.py"):
-        if not child.is_file():
-            continue
-        if any(part in SKIP_DIR_NAMES for part in child.parts):
-            continue
-        try:
-            if child.stat().st_size > _MAX_FILE_BYTES:
+    for directory, directories, filenames in p.walk():
+        directories[:] = [name for name in directories if name not in SKIP_DIR_NAMES]
+        for name in filenames:
+            if not fnmatch(name, "*.py"):
                 continue
-        except OSError:
-            continue
-        out.append(child)
-    return out
+            child = directory / name
+            try:
+                if child.is_file() and child.stat().st_size <= _MAX_FILE_BYTES:
+                    out.append(child)
+            except OSError:
+                continue
+    return sorted(out)
 
 
 def _check(rule_ids: list[str], paths: list[Path]) -> list[Diagnostic]:
@@ -157,6 +160,7 @@ _DIAGNOSTIC_PRECEDENCE = MappingProxyType(
         # still owns every fixed dictionary return when selected alone, while
         # an all-rules run emits one actionable diagnostic for this overlap.
         "SARJ447": frozenset({"SARJ008"}),
+        "SARJ457": frozenset({"SARJ045"}),
     }
 )
 
@@ -171,6 +175,7 @@ class _OwnerLocation(NamedTuple):
 
 
 def deduplicate_diagnostics(diags: list[Diagnostic], *, source: str | None = None) -> list[Diagnostic]:
+    diags = _deduplicate_test_composition(diags, source)
     codes = frozenset(diagnostic.code for diagnostic in diags)
     needs_docstring_owners = ("SARJ092" in codes and not codes.isdisjoint(_DIAGNOSTIC_PRECEDENCE["SARJ092"])) or (
         "SARJ420" in codes and not codes.isdisjoint(_DOCSTRING_PRECEDENCE_CODES)
@@ -218,6 +223,32 @@ def deduplicate_diagnostics(diags: list[Diagnostic], *, source: str | None = Non
     ]
 
 
+def _deduplicate_test_composition(diags: list[Diagnostic], source: str | None) -> list[Diagnostic]:
+    codes = {diagnostic.code for diagnostic in diags}
+    if source is None or not {"SARJ066", "SARJ457"} <= codes:
+        return diags
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return diags
+    whole_tests = {
+        (diagnostic.path, diagnostic.line): diagnostic.severity for diagnostic in diags if diagnostic.code == "SARJ066"
+    }
+    functions = [node for node in ast.walk(tree) if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))]
+
+    def redundant(diagnostic: Diagnostic) -> bool:
+        if diagnostic.code != "SARJ457":
+            return False
+        owners = [node for node in functions if node.lineno <= diagnostic.line <= (node.end_lineno or node.lineno)]
+        if not owners:
+            return False
+        owner = max(owners, key=lambda node: node.lineno)
+        severity = whole_tests.get((diagnostic.path, owner.lineno))
+        return severity is not None and (severity is Severity.ERROR or diagnostic.severity is Severity.WARNING)
+
+    return [diagnostic for diagnostic in diags if not redundant(diagnostic)]
+
+
 def _suppressed_diagnostics(
     present: dict[tuple[Path, int, int], dict[str, set[Severity]]],
 ) -> set[tuple[tuple[Path, int, int], str, Severity]]:

{sarj_python_lint-1.1.0 → sarj_python_lint-1.2.0}/src/sarj_python_lint/_file_context.py

@@ -12,6 +12,7 @@ from sarj_python_lint.rules._paths import is_generated
 
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping
     from pathlib import Path
 
 
@@ -48,6 +49,10 @@ class PythonFileContext:
     def nodes[NodeT: ast.AST](self, *types: type[NodeT]) -> list[NodeT]:
         return [node for node in self.node_index.query(types) if isinstance(node, types)]
 
+    @property
+    def parents(self) -> Mapping[ast.AST, ast.AST]:
+        return self.node_index.parents
+
     @cached_property
     def imports(self) -> ImportIndex:
         return ImportIndex.from_tree(self._valid_tree())

{sarj_python_lint-1.1.0 → sarj_python_lint-1.2.0}/src/sarj_python_lint/rules/_ast_index.py

@@ -3,11 +3,12 @@
 from __future__ import annotations
 
 import ast
+from types import MappingProxyType
 from typing import TYPE_CHECKING, TypeIs, final
 
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator
+    from collections.abc import Iterator, Mapping
 
 
 _AST = ast.AST
@@ -43,7 +44,7 @@ def walk(node: ast.AST, *, index: NodeIndex | None = None) -> Iterator[ast.AST]:
 
 @final
 class NodeIndex:
-    __slots__ = ("_buckets", "_flat", "_queries", "tree")
+    __slots__ = ("_buckets", "_flat", "_parents", "_queries", "tree")
 
     def __init__(self, tree: ast.AST) -> None:
         self.tree = tree
@@ -62,8 +63,15 @@ class NodeIndex:
             flat += children(current)
         self._buckets: dict[type[ast.AST], list[ast.AST]] = buckets
         self._flat: list[ast.AST] = flat
+        self._parents: Mapping[ast.AST, ast.AST] | None = None
         self._queries: dict[tuple[type[ast.AST], ...], list[ast.AST]] = {}
 
+    @property
+    def parents(self) -> Mapping[ast.AST, ast.AST]:
+        if self._parents is None:
+            self._parents = MappingProxyType({child: parent for parent in self._flat for child in children(parent)})
+        return self._parents
+
     def query(self, types: tuple[type[ast.AST], ...]) -> list[ast.AST]:
         hit = self._queries.get(types)
         if hit is not None:
@@ -87,3 +95,8 @@ class NodeIndex:
 def nodes[NodeT: ast.AST](tree: ast.AST, *types: type[NodeT], index: NodeIndex | None = None) -> list[NodeT]:
     selected = index if index is not None and index.tree is tree else NodeIndex(tree)
     return [node for node in selected.query(types) if isinstance(node, types)]
+
+
+def parent_map(tree: ast.AST, *, index: NodeIndex | None = None) -> Mapping[ast.AST, ast.AST]:
+    selected = index if index is not None and index.tree is tree else NodeIndex(tree)
+    return selected.parents

{sarj_python_lint-1.1.0 → sarj_python_lint-1.2.0}/src/sarj_python_lint/rules/_registry.py

@@ -145,6 +145,7 @@ from sarj_python_lint.rules.redundant_docstring import RedundantDocstring
 from sarj_python_lint.rules.redundant_module_docstring import RedundantModuleDocstring
 from sarj_python_lint.rules.repeated_kwarg_heavy_call_in_test import RepeatedKwargHeavyCallInTest
 from sarj_python_lint.rules.repeated_static_call_cases import RepeatedStaticCallCases
+from sarj_python_lint.rules.repeated_test_composition import RepeatedTestComposition
 from sarj_python_lint.rules.require_keyword_only_swap_prone_params import (
     RequireKeywordOnlySwapProneParams,
 )
@@ -225,6 +226,7 @@ REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
         PytestFixtureReturnsBareTuple.id: PytestFixtureReturnsBareTuple,
         StoreGetDelegatesToBulkRead.id: StoreGetDelegatesToBulkRead,
         RepeatedKwargHeavyCallInTest.id: RepeatedKwargHeavyCallInTest,
+        RepeatedTestComposition.id: RepeatedTestComposition,
         DefectXfailRequiresExplicitStrict.id: DefectXfailRequiresExplicitStrict,
         NoFirstPartyPrivateImport.id: NoFirstPartyPrivateImport,
         NoRestatedComment.id: NoRestatedComment,

sarj_python_lint-1.2.0/src/sarj_python_lint/rules/_test_composition.py

@@ -0,0 +1,286 @@
+from __future__ import annotations
+
+import ast
+from collections import Counter
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from sarj_python_lint.rules._project_index import ProjectIndexSet, SourceUnit, SymbolRef
+
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from sarj_python_lint._file_context import PythonFileContext
+
+
+type Function = ast.FunctionDef | ast.AsyncFunctionDef
+_PORT_BASES = frozenset({"abc.ABC", "typing.Protocol", "typing_extensions.Protocol"})
+_MIN_COLLABORATORS = 2
+
+
+@dataclass(frozen=True)
+class Constructor:
+    symbol: SymbolRef
+    positional: tuple[str, ...]
+    collaborators: frozenset[str]
+
+
+@dataclass(frozen=True)
+class WiringScope:
+    parameters: frozenset[str]
+    aliases: dict[str, ast.expr]
+    blocked: frozenset[str]
+
+
+def direct_nodes(node: ast.AST) -> Iterator[ast.AST]:
+    for child in ast.iter_child_nodes(node):
+        yield child
+        if not isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)):
+            yield from direct_nodes(child)
+
+
+def _class_owner(
+    context: PythonFileContext, expression: ast.expr, project: ProjectIndexSet
+) -> tuple[SourceUnit, ast.ClassDef] | None:
+    qualified = context.module_imports.resolved_qualified_name(expression)
+    unit = project.unit(context.path)
+    if qualified is not None:
+        module, _, name = qualified.rpartition(".")
+        unit = project.source_unit(module)
+    elif isinstance(expression, ast.Name):
+        name = expression.id
+    else:
+        return None
+    if unit is None or unit.tree is None or unit.module is None:
+        return None
+    owner = next((node for node in unit.tree.body if isinstance(node, ast.ClassDef) and node.name == name), None)
+    if owner is None:
+        return None
+    if any(
+        isinstance(node, ast.Name) and node.id == name and isinstance(node.ctx, (ast.Store, ast.Del))
+        for node in direct_nodes(unit.tree)
+    ):
+        return None
+    return unit, owner
+
+
+def constructor(context: PythonFileContext, expression: ast.expr, project: ProjectIndexSet) -> Constructor | None:
+    resolved = _class_owner(context, expression, project)
+    if resolved is None:
+        return None
+    unit, owner = resolved
+    if unit.module is None:
+        return None
+    initializer = next(
+        (node for node in owner.body if isinstance(node, ast.FunctionDef) and node.name == "__init__"), None
+    )
+    if initializer is None:
+        return None
+    parameters = (*initializer.args.posonlyargs, *initializer.args.args, *initializer.args.kwonlyargs)
+    invoked = _invoked_fields(owner)
+    stored = _stored_parameters(initializer)
+    collaborators = frozenset(
+        parameter.arg
+        for parameter in parameters
+        if parameter.annotation is not None
+        and _is_port(project, unit, parameter.annotation)
+        and stored.get(parameter.arg) in invoked
+    )
+    if len(collaborators) < _MIN_COLLABORATORS:
+        return None
+    return Constructor(
+        SymbolRef(unit.module, owner.name),
+        tuple(arg.arg for arg in (*initializer.args.posonlyargs, *initializer.args.args)[1:]),
+        collaborators,
+    )
+
+
+def _is_port(project: ProjectIndexSet, unit: SourceUnit, annotation: ast.expr) -> bool:
+    if isinstance(annotation, ast.Constant) and isinstance(annotation.value, str):
+        try:
+            annotation = ast.parse(annotation.value, mode="eval").body
+        except SyntaxError:
+            return False
+    summary = project.class_for(unit, annotation)
+    if summary is None:
+        return False
+    owner = project.source_unit(summary.symbol.module)
+    return owner is not None and project.class_inherits_from(owner, summary.symbol.name, _PORT_BASES)
+
+
+def _stored_parameters(initializer: Function) -> dict[str, str]:
+    stored: dict[str, str] = {}
+    writes = Counter(
+        node.attr
+        for node in direct_nodes(initializer)
+        if isinstance(node, ast.Attribute) and _is_self(node.value) and isinstance(node.ctx, (ast.Store, ast.Del))
+    )
+    for statement in initializer.body:
+        if isinstance(statement, ast.Assign) and len(statement.targets) == 1:
+            target, value = statement.targets[0], statement.value
+        elif isinstance(statement, ast.AnnAssign):
+            target, value = statement.target, statement.value
+        else:
+            continue
+        if (
+            isinstance(value, ast.Name)
+            and isinstance(target, ast.Attribute)
+            and _is_self(target.value)
+            and writes[target.attr] == 1
+        ):
+            stored[value.id] = target.attr
+    return stored
+
+
+def _is_self(node: ast.expr) -> bool:
+    return isinstance(node, ast.Name) and node.id == "self"
+
+
+def _invoked_fields(owner: ast.ClassDef) -> frozenset[str]:
+    invoked: set[str] = set()
+    for method in owner.body:
+        if isinstance(method, (ast.FunctionDef, ast.AsyncFunctionDef)) and method.name != "__init__":
+            invoked.update(_method_fields(method))
+    return frozenset(invoked)
+
+
+def _method_fields(method: Function) -> Iterator[str]:
+    for node in direct_nodes(method):
+        if not isinstance(node, ast.Call) or not isinstance(node.func, ast.Attribute):
+            continue
+        target = node.func.value
+        if isinstance(target, ast.Attribute) and _is_self(target.value):
+            yield target.attr
+
+
+def bindings(function: Function) -> dict[str, ast.expr]:
+    candidates: dict[str, list[ast.expr]] = {}
+    for statement in function.body:
+        if (
+            isinstance(statement, ast.Assign)
+            and len(statement.targets) == 1
+            and isinstance(statement.targets[0], ast.Name)
+        ):
+            candidates.setdefault(statement.targets[0].id, []).append(statement.value)
+        elif (
+            isinstance(statement, ast.AnnAssign)
+            and isinstance(statement.target, ast.Name)
+            and statement.value is not None
+        ):
+            candidates.setdefault(statement.target.id, []).append(statement.value)
+    writes = [
+        node.id
+        for node in direct_nodes(function)
+        if isinstance(node, ast.Name) and isinstance(node.ctx, (ast.Store, ast.Del))
+    ]
+    return {name: values[0] for name, values in candidates.items() if len(values) == 1 and writes.count(name) == 1}
+
+
+def local_names(function: Function) -> set[str]:
+    names: set[str] = set()
+    for node in direct_nodes(function):
+        if isinstance(node, ast.Name) and isinstance(node.ctx, (ast.Store, ast.Del)):
+            names.add(node.id)
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            names.add(node.name)
+        elif isinstance(node, (ast.Import, ast.ImportFrom)):
+            names.update(alias.asname or alias.name.partition(".")[0] for alias in node.names)
+    return names
+
+
+def changed_before(function: Function, call: ast.Call) -> set[str]:
+    changed: set[str] = set()
+    for node in direct_nodes(function):
+        if not isinstance(node, (ast.Call, ast.Attribute)) or node.lineno >= call.lineno:
+            continue
+        target = node.func.value if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) else None
+        if isinstance(node, ast.Attribute) and isinstance(node.ctx, (ast.Store, ast.Del)):
+            target = node.value
+        if isinstance(target, ast.Name):
+            changed.add(target.id)
+    return changed
+
+
+def unalias(node: ast.expr, aliases: dict[str, ast.expr]) -> ast.expr:
+    seen: set[str] = set()
+    while isinstance(node, ast.Name) and node.id in aliases and node.id not in seen:
+        seen.add(node.id)
+        node = aliases[node.id]
+    return node
+
+
+def shadowed(node: ast.expr, names: frozenset[str]) -> bool:
+    while isinstance(node, ast.Attribute):
+        node = node.value
+    return isinstance(node, ast.Name) and node.id in names
+
+
+def wiring(
+    context: PythonFileContext,
+    project: ProjectIndexSet,
+    call: ast.Call,
+    spec: Constructor,
+    scope: WiringScope,
+) -> tuple[tuple[str, str], ...] | None:
+    if any(isinstance(arg, ast.Starred) for arg in call.args) or any(keyword.arg is None for keyword in call.keywords):
+        return None
+    if len(call.args) > len(spec.positional):
+        return None
+    values = dict(zip(spec.positional, call.args, strict=False))
+    for keyword in call.keywords:
+        if keyword.arg is None or keyword.arg in values:
+            return None
+        values[keyword.arg] = keyword.value
+    result: list[tuple[str, str]] = []
+    for name in sorted(spec.collaborators):
+        value = values.get(name)
+        if value is None or not isinstance(unalias(value, scope.aliases), (ast.Name, ast.Call)):
+            return None
+        identity = _value_key(context, project, value, scope)
+        if identity is None:
+            return None
+        result.append((name, identity))
+    return tuple(result)
+
+
+def _value_key(
+    context: PythonFileContext,
+    project: ProjectIndexSet,
+    value: ast.expr,
+    scope: WiringScope,
+    seen: frozenset[str] = frozenset(),
+) -> str | None:
+    if isinstance(value, ast.Name):
+        if value.id in seen or value.id in scope.blocked:
+            return None
+        if value.id in scope.aliases:
+            return _value_key(
+                context,
+                project,
+                scope.aliases[value.id],
+                scope,
+                seen=seen | {value.id},
+            )
+        return f"fixture:{value.id}" if value.id in scope.parameters else None
+    if isinstance(value, ast.Constant):
+        return ast.dump(value)
+    if not isinstance(value, ast.Call):
+        return None
+    callee = unalias(value.func, scope.aliases)
+    if shadowed(callee, scope.parameters | scope.blocked):
+        return None
+    owner = _class_owner(context, callee, project)
+    if owner is None or any(keyword.arg is None for keyword in value.keywords):
+        return None
+    positional = [_value_key(context, project, argument, scope, seen=seen) for argument in value.args]
+    keywords = [
+        (
+            keyword.arg,
+            _value_key(context, project, keyword.value, scope, seen=seen),
+        )
+        for keyword in value.keywords
+    ]
+    if any(key is None for key in positional) or any(key is None for _, key in keywords):
+        return None
+    return f"{owner[0].module}.{owner[1].name}:{positional!r}:{sorted(keywords)!r}"

{sarj_python_lint-1.1.0 → sarj_python_lint-1.2.0}/src/sarj_python_lint/rules/async_mock_call_without_await_assertion.py

@@ -69,7 +69,7 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
     id = "async-mock-call-without-await-assertion"
     code = "SARJ456"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Pair positive AsyncMock call assertions with evidence that the mock was awaited.",
         rationale=(
             "Calling an AsyncMock records a call before its coroutine is awaited. A positive call assertion can "
@@ -150,7 +150,7 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
                 line=call.lineno,
                 col=call.col_offset + 1,
                 code=self.code,
-                severity=Severity.WARNING,
+                severity=Severity.ERROR,
                 message="AsyncMock call assertions do not prove awaiting; keep this assertion and add an await assertion",
             )
             for test in _collected_tests(tree.body)

{sarj_python_lint-1.1.0 → sarj_python_lint-1.2.0}/src/sarj_python_lint/rules/complex_postgres_query_requires_architecture_review.py

@@ -23,7 +23,7 @@ from sarj_python_lint.rules.no_analytical_aggregation_in_postgres_store import a
 
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
+    from collections.abc import Callable, Mapping
     from pathlib import Path
 
     from sqlglot import exp
@@ -83,18 +83,18 @@ def _docstring_node_ids(tree: ast.AST, *, node_index: NodeIndex | None = None) -
     return result
 
 
-def _is_query_context(node: ast.expr, parents: dict[int, ast.AST], roots: frozenset[int]) -> bool:
+def _is_query_context(node: ast.expr, parents: Mapping[ast.AST, ast.AST], roots: frozenset[int]) -> bool:
     current: ast.AST = node
     while True:
         if id(current) in roots:
             return True
-        if (parent := parents.get(id(current))) is None:
+        if (parent := parents.get(current)) is None:
             return False
         current = parent
 
 
 def _query_roots(
-    tree: ast.Module, parents: dict[int, ast.AST], *, node_index: NodeIndex | None = None
+    tree: ast.Module, parents: Mapping[ast.AST, ast.AST], *, node_index: NodeIndex | None = None
 ) -> frozenset[int]:
     binding_counts: dict[tuple[int, str], int] = {}
     binding_values: dict[tuple[int, str], ast.expr] = {}
@@ -133,10 +133,10 @@ def _query_roots(
     return frozenset(roots)
 
 
-def _scope(node: ast.AST, parents: dict[int, ast.AST]) -> ast.AST:
+def _scope(node: ast.AST, parents: Mapping[ast.AST, ast.AST]) -> ast.AST:
     current = node
     while not isinstance(current, (ast.Module, ast.FunctionDef, ast.AsyncFunctionDef, ast.Lambda, ast.ClassDef)):
-        parent = parents.get(id(current))
+        parent = parents.get(current)
         if parent is None:
             return current
         current = parent
@@ -169,7 +169,7 @@ def _call_name(function: ast.expr) -> str:
 
 
 def _postgres_sql_constructors(
-    tree: ast.Module, parents: dict[int, ast.AST], *, node_index: NodeIndex | None = None
+    tree: ast.Module, parents: Mapping[ast.AST, ast.AST], *, node_index: NodeIndex | None = None
 ) -> frozenset[_ConstructorImport]:
     constructors: set[_ConstructorImport] = set()
     for node in nodes(tree, ast.Import, ast.ImportFrom, index=node_index):
@@ -204,7 +204,7 @@ def _qualified_name(node: ast.expr) -> str:
 def _visible_constructors(
     owner: ast.AST,
     imports: frozenset[_ConstructorImport],
-    parents: dict[int, ast.AST],
+    parents: Mapping[ast.AST, ast.AST],
     binding_counts: dict[tuple[int, str], int],
     wildcard_scopes: set[int],
 ) -> frozenset[str]:
@@ -212,7 +212,7 @@ def _visible_constructors(
     current = owner
     while True:
         scope_chain.append(id(current))
-        parent = parents.get(id(current))
+        parent = parents.get(current)
         if parent is None:
             break
         current = _scope(parent, parents)
@@ -380,7 +380,7 @@ class ComplexPostgresQueryRequiresArchitectureReview(Rule):
             return []
 
         docstrings = _docstring_node_ids(tree, node_index=context.node_index)
-        parents = {id(child): parent for parent in context.nodes(ast.AST) for child in ast.iter_child_nodes(parent)}
+        parents = context.parents
         query_roots = _query_roots(tree, parents, node_index=context.node_index)
         diagnostics: list[Diagnostic] = []
         consumed: set[int] = set()
@@ -417,7 +417,7 @@ class ComplexPostgresQueryRequiresArchitectureReview(Rule):
 
 def _count_query_bindings(
     tree: ast.Module,
-    parents: dict[int, ast.AST],
+    parents: Mapping[ast.AST, ast.AST],
     count: Callable[[ast.AST, str], None],
     wildcard_scopes: set[int],
     *,
@@ -430,7 +430,7 @@ def _count_query_bindings(
         count(_scope(argument, parents), argument.arg)
     _count_import_bindings(tree, parents, count, wildcard_scopes, node_index=node_index)
     for definition in nodes(tree, ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, index=node_index):
-        parent = parents.get(id(definition))
+        parent = parents.get(definition)
         if parent is not None:
             count(_scope(parent, parents), definition.name)
     for handler in nodes(tree, ast.ExceptHandler, index=node_index):
@@ -447,7 +447,7 @@ def _count_query_bindings(
 
 def _query_binding_values(
     tree: ast.Module,
-    parents: dict[int, ast.AST],
+    parents: Mapping[ast.AST, ast.AST],
     binding_values: dict[tuple[int, str], ast.expr],
     *,
     node_index: NodeIndex | None = None,
@@ -461,7 +461,7 @@ def _query_binding_values(
         if not isinstance(target, ast.Name) or assignment.value is None:
             continue
         owner = _scope(assignment, parents)
-        if parents.get(id(assignment)) is owner:
+        if parents.get(assignment) is owner:
             binding_values[id(owner), target.id] = assignment.value
 
 
@@ -591,7 +591,7 @@ def _maximum_query_joins(statement: exp.Query) -> int:
 
 def _count_import_bindings(
     tree: ast.Module,
-    parents: dict[int, ast.AST],
+    parents: Mapping[ast.AST, ast.AST],
     count: Callable[[ast.AST, str], None],
     wildcard_scopes: set[int],
     *,

{sarj_python_lint-1.1.0 → sarj_python_lint-1.2.0}/src/sarj_python_lint/rules/fastapi_class_router_contract.py

@@ -20,6 +20,7 @@ from sarj_python_lint.rules._paths import is_test_path
 
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping
     from pathlib import Path
 
     from sarj_python_lint._file_context import PythonFileContext
@@ -92,7 +93,7 @@ class FastapiClassRouterContract(Rule):
         if tree is None:
             return []
         index = context.fastapi
-        parents = _parents(tree, node_index=context.node_index)
+        parents = context.parents
         findings = _router_construction_findings(path, tree, index, parents, node_index=context.node_index)
         for function in (
             node for node in context.nodes(ast.AST) if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
@@ -109,7 +110,7 @@ def _router_construction_findings(
     path: Path,
     tree: ast.Module,
     index: FastapiIndex,
-    parents: dict[int, ast.AST],
+    parents: Mapping[ast.AST, ast.AST],
     *,
     node_index: NodeIndex | None = None,
 ) -> list[Diagnostic]:
@@ -187,16 +188,12 @@ def _is_collection_or_scalar(annotation: ast.expr) -> bool:
     return flat_name(target) in _TOP_LEVEL_COLLECTIONS | _SCALARS
 
 
-def _parents(tree: ast.Module, *, node_index: NodeIndex | None = None) -> dict[int, ast.AST]:
-    return {id(child): parent for parent in walk_ast(tree, index=node_index) for child in ast.iter_child_nodes(parent)}
-
-
 def _ancestor(
-    node: ast.AST, parents: dict[int, ast.AST], kind: type[ast.AST] | tuple[type[ast.AST], ...]
+    node: ast.AST, parents: Mapping[ast.AST, ast.AST], kind: type[ast.AST] | tuple[type[ast.AST], ...]
 ) -> ast.AST | None:
-    current = parents.get(id(node))
+    current = parents.get(node)
     while current is not None:
         if isinstance(current, kind):
             return current
-        current = parents.get(id(current))
+        current = parents.get(current)
     return None

{sarj_python_lint-1.1.0 → sarj_python_lint-1.2.0}/src/sarj_python_lint/rules/mock_without_spec.py

@@ -121,7 +121,7 @@ class MockWithoutSpec(Rule):
     id: str = "mock-without-spec"
     code: str = "SARJ040"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Unrestricted mock permits attributes outside the collaborator contract.",
         rationale=(
             "A mock without a spec permits removed or misspelled attributes; a callable mock without autospec may "
@@ -234,7 +234,7 @@ class MockWithoutSpec(Rule):
                 col=node.col_offset + 1,
                 code=self.code,
                 message=_diagnostic_message(label),
-                severity=Severity.WARNING,
+                severity=Severity.ERROR,
             )
             for node, label in _unspecced_calls(
                 tree, names, pytest_mocker, _FileFacts.from_tree(tree), node_index=context.node_index