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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "1.1.0"
+version = "1.1.1"
 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.1.1}/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]:

{sarj_python_lint-1.1.0 → sarj_python_lint-1.1.1}/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.1.1}/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.1.1}/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.1.1}/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.1.1}/src/sarj_python_lint/rules/no_nested_pydantic_field_validator.py

@@ -14,14 +14,14 @@ from sarj_python_lint.rule_base import (
     RuleDocumentation,
     RuleExample,
 )
-from sarj_python_lint.rules._ast_index import walk as walk_ast
 from sarj_python_lint.rules._imports import ImportIndex
 from sarj_python_lint.rules._paths import is_test_path
 
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping
+
     from sarj_python_lint._file_context import PythonFileContext
-    from sarj_python_lint.rules._ast_index import NodeIndex
 
 
 _PYDANTIC_BASE_MODEL_SOURCES = frozenset({"pydantic", "pydantic.main", "pydantic.v1", "pydantic.v1.main"})
@@ -108,7 +108,7 @@ class NoNestedPydanticFieldValidator(Rule):
         if tree is None:
             return []
         imports = _module_scope_imports(tree)
-        parents = _parent_index(tree, node_index=context.node_index)
+        parents = context.parents
         diagnostics: list[Diagnostic] = []
 
         def collect_nested_validators(outer: ast.ClassDef, nested: ast.ClassDef, outer_fields: frozenset[str]) -> None:
@@ -148,7 +148,7 @@ class NoNestedPydanticFieldValidator(Rule):
         return diagnostics
 
 
-def _is_direct_model(node: ast.ClassDef, imports: ImportIndex, parents: dict[ast.AST, ast.AST]) -> bool:
+def _is_direct_model(node: ast.ClassDef, imports: ImportIndex, parents: Mapping[ast.AST, ast.AST]) -> bool:
     return any(
         (
             imports.resolves(base, sources=_PYDANTIC_BASE_MODEL_SOURCES, symbol="BaseModel")
@@ -174,7 +174,7 @@ def _direct_fields(node: ast.ClassDef, imports: ImportIndex) -> frozenset[str]:
 def _field_validators(
     node: ast.FunctionDef | ast.AsyncFunctionDef,
     imports: ImportIndex,
-    parents: dict[ast.AST, ast.AST],
+    parents: Mapping[ast.AST, ast.AST],
 ) -> tuple[tuple[ast.Call, frozenset[str]], ...]:
     validators: list[tuple[ast.Call, frozenset[str]]] = []
     for decorator in node.decorator_list:
@@ -221,14 +221,10 @@ def _module_scope_imports(tree: ast.Module) -> ImportIndex:
     return ImportIndex.from_tree(ast.Module(body=body, type_ignores=[]))
 
 
-def _parent_index(tree: ast.Module, *, node_index: NodeIndex | None = None) -> dict[ast.AST, ast.AST]:
-    return {child: owner for owner in walk_ast(tree, index=node_index) for child in ast.iter_child_nodes(owner)}
-
-
 def _shadowed_in_enclosing_function(
     reference: ast.expr,
     owner: ast.AST,
-    parents: dict[ast.AST, ast.AST],
+    parents: Mapping[ast.AST, ast.AST],
 ) -> bool:
     root = _root_name(reference)
     if root is None:

{sarj_python_lint-1.1.0 → sarj_python_lint-1.1.1}/src/sarj_python_lint/rules/no_select_star.py

@@ -21,6 +21,8 @@ from sarj_python_lint.rules._sql import sql_string_value, strip_sql_noise
 
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping
+
     from sarj_python_lint._file_context import PythonFileContext
     from sarj_python_lint.rules._ast_index import NodeIndex
 
@@ -176,7 +178,7 @@ class NoSelectStar(Rule):
             return []
 
         diags: list[Diagnostic] = []
-        parents = {id(child): parent for parent in context.nodes(ast.AST) for child in ast.iter_child_nodes(parent)}
+        parents = context.parents
         docstrings = _docstring_value_ids(tree, node_index=context.node_index)
         consumed: set[int] = set()
         for node in context.nodes(ast.Constant, ast.BinOp, ast.JoinedStr):
@@ -221,9 +223,9 @@ def _docstring_value_ids(tree: ast.AST, *, node_index: NodeIndex | None = None)
     }
 
 
-def _is_query_context(node: ast.expr, parents: dict[int, ast.AST]) -> bool:
+def _is_query_context(node: ast.expr, parents: Mapping[ast.AST, ast.AST]) -> bool:
     current: ast.AST = node
-    while (parent := parents.get(id(current))) is not None:
+    while (parent := parents.get(current)) is not None:
         match parent:
             case ast.Assign() | ast.AnnAssign() | ast.NamedExpr():
                 return any(_is_query_binding(target) for target in _assignment_targets(parent))

{sarj_python_lint-1.1.0 → sarj_python_lint-1.1.1}/src/sarj_python_lint/rules/no_typed_doc_sections.py

@@ -14,14 +14,12 @@ from sarj_python_lint.rule_base import (
     RuleDocumentation,
     RuleExample,
     Severity,
-    parse_or_none,
 )
-from sarj_python_lint.rules._ast_index import walk as walk_ast
 from sarj_python_lint.rules._prose_budget import groups
 
 
 if TYPE_CHECKING:
-    from pathlib import Path
+    from collections.abc import Mapping
 
     from sarj_python_lint._file_context import PythonFileContext
 
@@ -87,7 +85,7 @@ class NoTypedDocSections(Rule):
     def check_context(self, context: PythonFileContext) -> list[Diagnostic]:
         path = context.path
         source = context.source
-        excluded_lines = _public_contract_docstring_lines(path, source)
+        excluded_lines = _public_contract_docstring_lines(context)
         return [
             Diagnostic(
                 path,
@@ -110,14 +108,14 @@ _PUBLIC_CONTRACT_DECORATORS = frozenset({"abstractmethod", "cached_property", "o
 _PUBLIC_CONTRACT_BASES = frozenset({"Protocol"})
 
 
-def _public_contract_docstring_lines(path: Path, source: str) -> frozenset[int]:
-    tree = parse_or_none(path, source)
+def _public_contract_docstring_lines(context: PythonFileContext) -> frozenset[int]:
+    tree = context.tree
     if tree is None:
         return frozenset()
-    parents = {id(child): parent for parent in walk_ast(tree) for child in ast.iter_child_nodes(parent)}
+    parents = context.parents
     excluded: set[int] = set()
-    for node in walk_ast(tree):
-        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) or not node.body:
+    for node in context.nodes(ast.FunctionDef, ast.AsyncFunctionDef):
+        if not node.body:
             continue
         first = node.body[0]
         if not (isinstance(first, ast.Expr) and isinstance(first.value, ast.Constant)):
@@ -127,9 +125,9 @@ def _public_contract_docstring_lines(path: Path, source: str) -> frozenset[int]:
     return frozenset(excluded)
 
 
-def _is_public_contract(node: ast.FunctionDef | ast.AsyncFunctionDef, parents: dict[int, ast.AST]) -> bool:
+def _is_public_contract(node: ast.FunctionDef | ast.AsyncFunctionDef, parents: Mapping[ast.AST, ast.AST]) -> bool:
     decorators = {_terminal_name(item.func if isinstance(item, ast.Call) else item) for item in node.decorator_list}
-    owner = parents.get(id(node))
+    owner = parents.get(node)
     protocol_method = isinstance(owner, ast.ClassDef) and any(
         _terminal_name(base) in _PUBLIC_CONTRACT_BASES for base in owner.bases
     )

{sarj_python_lint-1.1.0 → sarj_python_lint-1.1.1}/src/sarj_python_lint/rules/no_unique_violation_message_match.py

@@ -22,7 +22,7 @@ from sarj_python_lint.rules._paths import is_test_path
 
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator
+    from collections.abc import Iterator, Mapping
 
     from sarj_python_lint._file_context import PythonFileContext
 
@@ -108,7 +108,7 @@ class NoUniqueViolationMessageMatch(Rule):
         if tree is None:
             return []
         imports = _module_import_index(tree)
-        parents = {id(child): parent for parent in context.nodes(ast.AST) for child in ast.iter_child_nodes(parent)}
+        parents = context.parents
         findings: list[tuple[ast.expr, _HandlerContext]] = []
         for handler in (node for node in context.nodes(ast.AST) if isinstance(node, ast.ExceptHandler)):
             driver = _caught_driver(handler.type, imports)
@@ -194,11 +194,11 @@ def _statement_bound_names(statement: ast.stmt) -> frozenset[str]:
 def _locally_shadows_exception(
     caught: ast.expr | None,
     handler: ast.ExceptHandler,
-    parents: dict[int, ast.AST],
+    parents: Mapping[ast.AST, ast.AST],
 ) -> bool:
     roots = _exception_root_names(caught)
     owner: ast.AST = handler
-    while (parent := parents.get(id(owner))) is not None:
+    while (parent := parents.get(owner)) is not None:
         owner = parent
         if isinstance(owner, (ast.FunctionDef, ast.AsyncFunctionDef)):
             return any(
@@ -244,10 +244,10 @@ def _walk_same_scope(node: ast.AST) -> Iterator[ast.AST]:
 def _builtins_are_available(
     tree: ast.Module,
     handler: ast.ExceptHandler,
-    parents: dict[int, ast.AST],
+    parents: Mapping[ast.AST, ast.AST],
 ) -> bool:
     owner: ast.AST = handler
-    while (parent := parents.get(id(owner))) is not None:
+    while (parent := parents.get(owner)) is not None:
         owner = parent
         if isinstance(owner, (ast.FunctionDef, ast.AsyncFunctionDef)):
             return not any(

{sarj_python_lint-1.1.0 → sarj_python_lint-1.1.1}/src/sarj_python_lint/rules/no_unnecessary_docstring.py

@@ -16,7 +16,7 @@ from sarj_python_lint.rule_base import (
     RuleExample,
     Severity,
 )
-from sarj_python_lint.rules._ast_index import walk as walk_ast
+from sarj_python_lint.rules._ast_index import parent_map, walk as walk_ast
 from sarj_python_lint.rules._docstrings import docstring_expression
 
 
@@ -365,15 +365,13 @@ def _owner_index(owners: frozenset[str]) -> dict[str, tuple[str, ...]]:
 
 
 def _bare_module_docstring_consumed(tree: ast.Module, *, node_index: NodeIndex | None = None) -> bool:
-    parents = {
-        id(child): parent for parent in walk_ast(tree, index=node_index) for child in ast.iter_child_nodes(parent)
-    }
+    parents = parent_map(tree, index=node_index)
     for node in walk_ast(tree, index=node_index):
         if not (isinstance(node, ast.Name) and isinstance(node.ctx, ast.Load) and node.id == "__doc__"):
             continue
         current: ast.AST = node
         inside_function = False
-        while (parent := parents.get(id(current))) is not None:
+        while (parent := parents.get(current)) is not None:
             if isinstance(parent, (ast.FunctionDef, ast.AsyncFunctionDef, ast.Lambda)):
                 inside_function = True
                 if _function_binds_docstring_name(parent):

{sarj_python_lint-1.1.0 → sarj_python_lint-1.1.1}/src/sarj_python_lint/rules/no_unused_value_marker.py

@@ -20,6 +20,8 @@ from sarj_python_lint.rules._ast_index import walk as walk_ast
 
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping
+
     from sarj_python_lint._file_context import PythonFileContext
 
 
@@ -136,8 +138,8 @@ class NoUnusedValueMarker(Rule):
         ]
         if not markers:
             return []
-        parents = (
-            {child: parent for parent in context.nodes(ast.AST) for child in ast.iter_child_nodes(parent)}
+        parents: Mapping[ast.AST, ast.AST] = (
+            context.parents
             if any(isinstance(node, ast.Assign) and isinstance(node.value, (ast.Name, ast.Tuple)) for node in markers)
             else {}
         )
@@ -166,7 +168,7 @@ def _is_unused_value_marker(node: ast.Assign | ast.AnnAssign) -> bool:
 
 def _is_pure_parameter_marker(
     node: ast.Assign | ast.AnnAssign,
-    parents: dict[ast.AST, ast.AST],
+    parents: Mapping[ast.AST, ast.AST],
 ) -> bool:
     if not isinstance(node, ast.Assign) or len(node.targets) != 1:
         return False
@@ -193,7 +195,7 @@ def _marker_reference_names(value: ast.expr) -> set[str] | None:
 
 
 def _enclosing_function(
-    node: ast.AST, parents: dict[ast.AST, ast.AST]
+    node: ast.AST, parents: Mapping[ast.AST, ast.AST]
 ) -> ast.FunctionDef | ast.AsyncFunctionDef | None:
     current = node
     while current in parents:

{sarj_python_lint-1.1.0 → sarj_python_lint-1.1.1}/src/sarj_python_lint/rules/no_whole_request_response_payload_in_log.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import ast
 from collections import Counter
+from collections.abc import Mapping
 from dataclasses import dataclass
 from pathlib import PurePosixPath
 from typing import TYPE_CHECKING, final, override
@@ -26,7 +27,6 @@ if TYPE_CHECKING:
     from pathlib import Path
 
     from sarj_python_lint._file_context import PythonFileContext
-    from sarj_python_lint.rules._ast_index import NodeIndex
 
 
 _PAYLOAD_TERMINALS = frozenset({"body", "bodies", "content", "data", "json", "payload", "payloads", "text"})
@@ -60,7 +60,7 @@ class _SuiteFacts:
 class _AnalysisFacts:
     suites: dict[int, _SuiteFacts]
     statement_suites: dict[int, int]
-    parents: dict[int, ast.AST]
+    parents: Mapping[ast.AST, ast.AST]
 
 
 def _reference_tokens(value: ast.expr) -> tuple[str, ...]:
@@ -171,7 +171,7 @@ class NoWholeRequestResponsePayloadInLog(Rule):
         tree = context.tree
         if tree is None:
             return []
-        facts = _analysis_facts(tree, node_index=context.node_index)
+        facts = _analysis_facts(context)
         diagnostics: list[Diagnostic] = []
         for node in context.nodes(ast.Call):
             if not _is_logging_call(node):
@@ -295,13 +295,11 @@ def _is_payload_reference(value: ast.expr, *, label: str | None = None) -> bool:
     return bool(_REQUEST_RESPONSE.intersection(tokens) and _PAYLOAD_TERMINALS.intersection(tokens))
 
 
-def _analysis_facts(tree: ast.Module, *, node_index: NodeIndex | None = None) -> _AnalysisFacts:
+def _analysis_facts(context: PythonFileContext) -> _AnalysisFacts:
     suites: dict[int, _SuiteFacts] = {}
     statement_suites: dict[int, int] = {}
-    parents = {
-        id(child): parent for parent in walk_ast(tree, index=node_index) for child in ast.iter_child_nodes(parent)
-    }
-    for owner in walk_ast(tree, index=node_index):
+    parents = context.parents
+    for owner in context.nodes(ast.AST):
         for field_name in owner._fields:
             statements = _statement_list(getattr(owner, field_name, None))
             if statements is None:
@@ -387,10 +385,10 @@ def _root_name(node: ast.expr) -> str | None:
     return node.id if isinstance(node, ast.Name) else None
 
 
-def _containing_statement(node: ast.AST, parents: dict[int, ast.AST]) -> ast.stmt | None:
+def _containing_statement(node: ast.AST, parents: Mapping[ast.AST, ast.AST]) -> ast.stmt | None:
     current: ast.AST | None = node
     while current is not None and not isinstance(current, ast.stmt):
-        current = parents.get(id(current))
+        current = parents.get(current)
     return current
 
 

{sarj_python_lint-1.1.0 → sarj_python_lint-1.1.1}/src/sarj_python_lint/rules/prefer_constant_time_secret_compare.py

@@ -22,7 +22,7 @@ from sarj_python_lint.rules._paths import is_test_path, is_test_support_path
 
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable, Iterator
+    from collections.abc import Iterable, Iterator, Mapping
 
     from sarj_python_lint._file_context import PythonFileContext
     from sarj_python_lint.rules._ast_index import NodeIndex
@@ -156,7 +156,7 @@ class PreferConstantTimeSecretCompare(Rule):
         tree = context.tree
         if tree is None:
             return []
-        parents = {id(child): parent for parent in context.nodes(ast.AST) for child in ast.iter_child_nodes(parent)}
+        parents = context.parents
         role_cache: dict[int, _Roles] = {}
         environment_names = _environment_names(tree)
         dunder_compares = _equality_dunder_compares(tree, source, node_index=context.node_index)
@@ -427,13 +427,13 @@ def _bound_names(scope: ast.FunctionDef | ast.AsyncFunctionDef) -> frozenset[str
 
 def _dominating_walrus_roles(
     comparison: ast.Compare,
-    parents: dict[int, ast.AST],
+    parents: Mapping[ast.AST, ast.AST],
     roles: _Roles,
     position: tuple[int, int],
 ) -> dict[str, _Role]:
     result: dict[str, _Role] = {}
     current: ast.AST = comparison
-    while (parent := parents.get(id(current))) is not None:
+    while (parent := parents.get(current)) is not None:
         if isinstance(parent, ast.If) and current in parent.body:
             for named in nodes(parent.test, ast.NamedExpr):
                 result[named.target.id] = _operand_role(named.value, roles, position, result)
@@ -459,11 +459,11 @@ def _terminal_name(node: ast.expr) -> str | None:
 
 def _enclosing_scope(
     node: ast.AST,
-    parents: dict[int, ast.AST],
+    parents: Mapping[ast.AST, ast.AST],
     module: ast.Module,
 ) -> ast.Module | ast.FunctionDef | ast.AsyncFunctionDef:
     current: ast.AST = node
-    while (parent := parents.get(id(current))) is not None:
+    while (parent := parents.get(current)) is not None:
         if isinstance(parent, (ast.Module, ast.FunctionDef, ast.AsyncFunctionDef)):
             return parent
         current = parent