sarj-python-lint 1.66.0__tar.gz → 1.66.2__tar.gz

{sarj_python_lint-1.66.0 → sarj_python_lint-1.66.2}/PKG-INFO

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

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

{sarj_python_lint-1.66.0 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/_annotation_semantics.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import ast
 from dataclasses import dataclass
 from types import MappingProxyType
-from typing import Self
+from typing import NamedTuple, Self
 
 from sarj_python_lint.rules._imports import ImportIndex
 
@@ -12,6 +12,23 @@ _TYPING_SOURCES = frozenset({"typing", "typing_extensions"})
 _TRANSPARENT_WRAPPERS = frozenset({"Annotated", "ClassVar", "Final", "NotRequired", "Optional", "ReadOnly", "Required"})
 
 
+def bit_or_members(expression: ast.expr) -> list[ast.expr]:
+    members: list[ast.expr] = []
+    pending = [expression]
+    while pending:
+        member = pending.pop()
+        if isinstance(member, ast.BinOp) and isinstance(member.op, ast.BitOr):
+            pending.extend((member.right, member.left))
+        else:
+            members.append(member)
+    return members
+
+
+class _AnnotationMember(NamedTuple):
+    node: ast.expr | None
+    seen: frozenset[str]
+
+
 @dataclass(frozen=True, slots=True)
 class AnnotationSemantics:
     imports: ImportIndex
@@ -75,35 +92,51 @@ class AnnotationSemantics:
         if resolved is None:
             return ()
         if isinstance(resolved, ast.Name) and resolved.id in self.aliases:
-            return self._alias_members(resolved.id, seen=seen)
-        if isinstance(resolved, ast.BinOp) and isinstance(resolved.op, ast.BitOr):
-            return self.transparent_members(resolved.left, seen=seen) + self.transparent_members(
-                resolved.right, seen=seen
-            )
-        if isinstance(resolved, ast.Subscript):
-            return self._subscript_members(resolved, seen=seen)
-        return (resolved,)
-
-    def _alias_members(self, name: str, *, seen: frozenset[str]) -> tuple[ast.expr, ...]:
-        if name in seen:
-            return ()
-        return self.transparent_members(self.aliases[name], seen=seen | {name})
+            pending = [_AnnotationMember(resolved, seen)]
+        else:
+            children = self._transparent_children(resolved)
+            if children is None:
+                return (resolved,)
+            pending = [_AnnotationMember(child, seen) for child in reversed(children)]
+        members: list[ast.expr] = []
+        while pending:
+            state = self._resolve_member(pending.pop())
+            if state.node is None:
+                continue
+            children = self._transparent_children(state.node)
+            if children is None:
+                members.append(state.node)
+            else:
+                pending.extend(_AnnotationMember(child, state.seen) for child in reversed(children))
+        return tuple(members)
 
-    def _subscript_members(self, node: ast.Subscript, *, seen: frozenset[str]) -> tuple[ast.expr, ...]:
+    def _resolve_member(self, state: _AnnotationMember) -> _AnnotationMember:
+        node = self.parse(state.node)
+        if not isinstance(node, ast.Name) or node.id not in self.aliases:
+            return _AnnotationMember(node, state.seen)
+        seen = set(state.seen)
+        while isinstance(node, ast.Name) and node.id in self.aliases:
+            if node.id in seen:
+                return _AnnotationMember(None, frozenset(seen))
+            seen.add(node.id)
+            node = self.parse(self.aliases[node.id])
+        return _AnnotationMember(node, frozenset(seen))
+
+    def _transparent_children(self, node: ast.expr) -> list[ast.expr] | None:
+        if isinstance(node, ast.BinOp) and isinstance(node.op, ast.BitOr):
+            return bit_or_members(node)
+        if not isinstance(node, ast.Subscript):
+            return None
         wrapper = self.imports.resolved_symbol(node.value, sources=_TYPING_SOURCES)
         if wrapper == "Union":
-            members = node.slice.elts if isinstance(node.slice, ast.Tuple) else [node.slice]
-            return self._flatten_members(members, seen=seen)
+            return list(node.slice.elts) if isinstance(node.slice, ast.Tuple) else [node.slice]
         if wrapper not in _TRANSPARENT_WRAPPERS:
-            return (node,)
-        inner = node.slice.elts[0] if isinstance(node.slice, ast.Tuple) else node.slice
-        return self.transparent_members(inner, seen=seen)
-
-    def _flatten_members(self, nodes: list[ast.expr], *, seen: frozenset[str]) -> tuple[ast.expr, ...]:
-        members: list[ast.expr] = []
-        for node in nodes:
-            members.extend(self.transparent_members(node, seen=seen))
-        return tuple(members)
+            return None
+        if isinstance(node.slice, ast.Tuple):
+            if not node.slice.elts:
+                return None
+            return [node.slice.elts[0]]
+        return [node.slice]
 
 
 def _module_rebindings(tree: ast.Module) -> set[str]:

sarj_python_lint-1.66.2/src/sarj_python_lint/rules/_ast_names.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import ast
+
+
+def root_name(node: ast.expr) -> str | None:
+    while isinstance(node, ast.Attribute):
+        node = node.value
+    return node.id if isinstance(node, ast.Name) else None
+
+
+def expression_root(node: ast.expr) -> str | None:
+    while isinstance(node, (ast.Attribute, ast.Subscript)):
+        node = node.value
+    return node.id if isinstance(node, ast.Name) else None
+
+
+def terminal_name(node: ast.expr) -> str | None:
+    match node:
+        case ast.Name(id=name) | ast.Attribute(attr=name):
+            return name
+        case _:
+            return None
+
+
+def unqualified_name(node: ast.expr) -> str:
+    match node:
+        case ast.Name(id=name) | ast.Attribute(attr=name):
+            return name
+        case _:
+            return ""
+
+
+def dotted_parts(node: ast.expr) -> tuple[str, ...] | None:
+    parts: list[str] = []
+    current = node
+    while isinstance(current, ast.Attribute):
+        parts.append(current.attr)
+        current = current.value
+    if not isinstance(current, ast.Name):
+        return None
+    parts.append(current.id)
+    return tuple(reversed(parts))
+
+
+def dotted_name(node: ast.expr) -> str | None:
+    parts = dotted_parts(node)
+    return ".".join(parts) if parts is not None else None
+
+
+def assignment_names(node: ast.AST) -> set[str]:
+    match node:
+        case ast.Name(id=name):
+            return {name}
+        case ast.Tuple() | ast.List():
+            names: set[str] = set()
+            for element in node.elts:
+                names.update(assignment_names(element))
+            return names
+        case ast.Starred(value=value):
+            return assignment_names(value)
+        case _:
+            return set()

{sarj_python_lint-1.66.0 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/_closed_helpers.py

@@ -183,3 +183,13 @@ def _plain_decorator(
         and not (keyword.arg == "mode" and isinstance(keyword.value, ast.Constant) and keyword.value.value == "wrap")
         for keyword in decorator.keywords
     )
+
+
+def closed_owner(function: ast.FunctionDef | ast.AsyncFunctionDef, context: PythonFileContext) -> bool:
+    if not isinstance(function, ast.FunctionDef) or not function.name.startswith("_"):
+        return False
+    references = closed_references(context, function, context.resource_provenance)
+    return bool(references) and all(
+        (call := direct_call(reference, context)) is not None and call_matches(function, call)
+        for reference in references
+    )

{sarj_python_lint-1.66.0 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/_comments.py

@@ -326,7 +326,13 @@ class _Scan(NamedTuple):
     ordered: _Ordered
 
 
-_last_scan: tuple[str, _Scan] | None = None
+class _ScanMemo(NamedTuple):
+    source: str
+    scan: _Scan | None
+    comment_lines: frozenset[int] | None
+
+
+_last_scan: _ScanMemo | None = None
 
 
 def all_comments(source: str) -> _CommentScan[_Ordered]:
@@ -334,15 +340,35 @@ def all_comments(source: str) -> _CommentScan[_Ordered]:
     return _CommentScan(scan.ordered, scan.first_code_line)
 
 
+def comment_line_numbers(source: str) -> frozenset[int]:
+    global _last_scan  # ruff: ignore[global-statement] -- retain the existing single-source memo for both comment projections.
+    cached = _last_scan
+    scan = cached.scan if cached is not None and cached.source is source else None
+    if cached is not None and cached.source is source and cached.comment_lines is not None:
+        return cached.comment_lines
+    lines: frozenset[int]
+    if scan is not None:
+        lines = frozenset(comment.line for comment in scan.ordered)
+    else:
+        try:
+            tokens = tokenize.generate_tokens(io.StringIO(source).readline)
+            lines = frozenset(token.start[0] for token in tokens if token.type == tokenize.COMMENT)
+        except IndentationError, tokenize.TokenError:
+            lines = frozenset()
+    _last_scan = _ScanMemo(source, scan, lines)
+    return lines
+
+
 def _scan_memo(source: str) -> _Scan:
     global _last_scan  # ruff: ignore[global-statement] — single-slot memo; the CLI runs rules per file sequentially
-    if _last_scan is not None and _last_scan[0] is source:
-        return _last_scan[1]
+    cached = _last_scan if _last_scan is not None and _last_scan.source is source else None
+    if cached is not None and cached.scan is not None:
+        return cached.scan
     try:
         result = _scan(source)
     except UnicodeError:
         result = _Scan([], [], set(), 1 << 30, [])
-    _last_scan = (source, result)
+    _last_scan = _ScanMemo(source, result, cached.comment_lines if cached is not None else None)
     return result
 
 

{sarj_python_lint-1.66.0 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/_docstrings.py

@@ -13,9 +13,16 @@ if TYPE_CHECKING:
     from collections.abc import Iterable
 
     from sarj_python_lint.rules._ast_index import NodeIndex
+    from sarj_python_lint.rules._imports import ImportIndex
 
 
 _GETATTR_MIN_ARGS = 2
+_RUNTIME_DOC_DECORATORS = (
+    (frozenset({"agents"}), "function_tool"),
+    (frozenset({"click"}), "command"),
+    (frozenset({"typer"}), "command"),
+)
+_OVERLOAD_MODULES = frozenset({"typing", "typing_extensions"})
 
 # Docstring filler that says nothing about *which* thing is being described.
 _BASE_STOPWORDS = frozenset(
@@ -259,6 +266,18 @@ def decorator_markers(node: ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDe
     return markers
 
 
+def is_runtime_consumed_or_overload(node: ast.FunctionDef | ast.AsyncFunctionDef, imports: ImportIndex) -> bool:
+    if decorator_markers(node) & PROMPT_DECORATOR_MARKERS:
+        return True
+    for decorator in node.decorator_list:
+        target = decorator.func if isinstance(decorator, ast.Call) else decorator
+        if imports.resolves(target, sources=_OVERLOAD_MODULES, symbol="overload"):
+            return True
+        if any(imports.resolves(target, sources=sources, symbol=symbol) for sources, symbol in _RUNTIME_DOC_DECORATORS):
+            return True
+    return False
+
+
 def docstring_expression(
     node: ast.Module | ast.ClassDef | ast.FunctionDef | ast.AsyncFunctionDef,
 ) -> ast.Expr | None:

{sarj_python_lint-1.66.0 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/_imports.py

@@ -4,11 +4,15 @@ import ast
 from collections.abc import Mapping
 from dataclasses import dataclass
 from types import MappingProxyType
-from typing import Self
+from typing import TYPE_CHECKING, Self
 
 from sarj_python_lint.rules._ast_index import comprehension_results, walk as walk_ast
 
 
+if TYPE_CHECKING:
+    from sarj_python_lint._file_context import PythonFileContext
+
+
 ABC_SOURCES = frozenset({"abc"})
 TYPING_SOURCES = frozenset({"typing", "typing_extensions"})
 
@@ -81,6 +85,17 @@ class ImportIndex:
                 return None
 
 
+def ambiguous_import_names(context: PythonFileContext) -> frozenset[str]:
+    return frozenset(
+        alias.asname or alias.name.partition(".")[0]
+        for node in context.nodes(ast.Import, ast.ImportFrom)
+        for alias in node.names
+        if context.parents[node] is not context.tree
+        or (isinstance(node, ast.ImportFrom) and node.level > 0)
+        or alias.name == "*"
+    )
+
+
 def _non_import_bindings(tree: ast.Module) -> set[str]:
     names: set[str] = set()
     for node in walk_ast(tree):

{sarj_python_lint-1.66.0 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/_resource_provenance.py

@@ -12,6 +12,7 @@ from sarj_python_lint.rules._runtime_bindings import RuntimeBindings
 
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
     from pathlib import Path
 
     from sarj_python_lint._file_context import PythonFileContext
@@ -82,6 +83,8 @@ class ResourceProvenance:
         self.bindings: dict[ast.AST | None, dict[str, list[ast.AST]]] = defaultdict(lambda: defaultdict(list))
         self.reads: dict[str, list[ast.Name]] = defaultdict(list)
         self._reads_by_binding: dict[str, dict[ast.AST, list[ast.Name]]] = {}
+        self._runtime_reads_by_binding: dict[str, dict[ast.AST, list[ast.Name]]] = {}
+        self._import_read_safety: dict[str, bool] = {}
         self.escape_cache: dict[tuple[ast.AST, bool], bool] = {}
         self.async_contract_cache: dict[ast.AsyncFunctionDef, bool] = {}
         self.import_contract_cache: dict[str, bool] = {}
@@ -172,10 +175,10 @@ class ResourceProvenance:
         if qualified is None or not self._owner_namespace_untouched(qualified.partition(".")[0]):
             return None
         if binding not in self.runtime_import_cache:
-            self.runtime_import_cache[binding] = all(
-                self.runtime_binding(root, read) is not binding or self._safe_import_use(read)
-                for read in self.reads.get(root, ())
+            reads = self._indexed_reads(
+                root, binding, cache=self._runtime_reads_by_binding, resolve=self.runtime_binding
             )
+            self.runtime_import_cache[binding] = all(self._safe_import_use(read) for read in reads)
         return qualified if self.runtime_import_cache[binding] else None
 
     @cached_property
@@ -283,18 +286,22 @@ class ResourceProvenance:
         ):
             return False
         binding = self.binding(root, node)
-        for read in self.reads.get(root, ()):
-            parent = self.parents.get(read)
-            if isinstance(parent, ast.Attribute | ast.ExceptHandler):
-                continue
-            if not self._safe_import_use(read):
-                return False
+        if not self._import_reads_safe(root):
+            return False
         return (
             isinstance(binding, ast.alias)
             and isinstance(self.scope(binding), ast.Module)
             and self.context.imports.resolved_qualified_name(node) == qualified
         )
 
+    def _import_reads_safe(self, name: str) -> bool:
+        if name not in self._import_read_safety:
+            self._import_read_safety[name] = all(
+                isinstance(self.parents.get(read), ast.Attribute | ast.ExceptHandler) or self._safe_import_use(read)
+                for read in self.reads.get(name, ())
+            )
+        return self._import_read_safety[name]
+
     def _owner_namespace_untouched(self, module: str) -> bool:
         if module not in _RESOURCE_OWNERS:
             return True
@@ -459,13 +466,23 @@ class ResourceProvenance:
         )
 
     def _binding_reads(self, name: str, binding: ast.AST) -> list[ast.Name]:
-        if name not in self._reads_by_binding:
+        return self._indexed_reads(name, binding, cache=self._reads_by_binding, resolve=self.binding)
+
+    def _indexed_reads(
+        self,
+        name: str,
+        binding: ast.AST,
+        *,
+        cache: dict[str, dict[ast.AST, list[ast.Name]]],
+        resolve: Callable[[str, ast.AST], ast.AST | None],
+    ) -> list[ast.Name]:
+        if name not in cache:
             grouped: dict[ast.AST, list[ast.Name]] = defaultdict(list)
             for read in self.reads.get(name, ()):
-                if (owner := self.binding(read.id, read)) is not None:
+                if (owner := resolve(read.id, read)) is not None:
                     grouped[owner].append(read)
-            self._reads_by_binding[name] = grouped
-        return self._reads_by_binding[name].get(binding, [])
+            cache[name] = grouped
+        return cache[name].get(binding, [])
 
     def unescaped(self, name: ast.Name, at: ast.AST, *, allow_context: bool = False) -> bool:
         binding = self.binding(name.id, at)

{sarj_python_lint-1.66.0 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/complex_postgres_query_requires_architecture_review.py

@@ -17,6 +17,7 @@ from sarj_python_lint.rule_base import (
     Severity,
 )
 from sarj_python_lint.rules._ast_index import nodes, walk
+from sarj_python_lint.rules._ast_names import unqualified_name as _call_name
 from sarj_python_lint.rules._paths import is_test_path
 from sarj_python_lint.rules._sql import is_store_module, sql_string_value, strip_sql_noise
 from sarj_python_lint.rules.no_analytical_aggregation_in_postgres_store import analytical_signal
@@ -148,14 +149,6 @@ def _query_argument(call: ast.Call) -> ast.expr | None:
     return next((keyword.value for keyword in call.keywords if keyword.arg in _QUERY_KEYWORDS), None)
 
 
-def _call_name(function: ast.expr) -> str:
-    match function:
-        case ast.Name(id=name) | ast.Attribute(attr=name):
-            return name
-        case _:
-            return ""
-
-
 def _postgres_sql_constructors(
     tree: ast.Module, parents: Mapping[ast.AST, ast.AST], *, node_index: NodeIndex | None = None
 ) -> frozenset[_ConstructorImport]:

{sarj_python_lint-1.66.0 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/docstring_args_restate_signature.py

@@ -20,13 +20,12 @@ from sarj_python_lint.rule_base import (
 from sarj_python_lint.rules._ast_index import children
 from sarj_python_lint.rules._comments import is_protected, stem
 from sarj_python_lint.rules._docstrings import (
-    PROMPT_DECORATOR_MARKERS,
     VALUE_MARKER_RE,
     annotation_tokens,
     arg_entries,
     arg_section,
-    decorator_markers,
     identifier_stems,
+    is_runtime_consumed_or_overload,
     restates,
 )
 
@@ -40,14 +39,6 @@ if TYPE_CHECKING:
 
 _ARGUMENT_CONSTRAINT_RE = re.compile(r"\b(available|current|existing|optional|required|supported)\b", re.IGNORECASE)
 
-_RUNTIME_DOC_DECORATORS = (
-    (frozenset({"agents"}), "function_tool"),
-    (frozenset({"click"}), "command"),
-    (frozenset({"typer"}), "command"),
-)
-
-_OVERLOAD_MODULES = frozenset({"typing", "typing_extensions"})
-
 
 @dataclass(frozen=True, slots=True)
 class _ParameterFacts:
@@ -151,7 +142,7 @@ class DocstringArgsRestateSignature(Rule):
         block = arg_section(docstring)
         if block is None or VALUE_MARKER_RE.search(block) or is_protected(block):
             return
-        if _is_runtime_consumed_or_overload(node, imports):
+        if is_runtime_consumed_or_overload(node, imports):
             return
         entries = arg_entries(block)
         if not entries:
@@ -202,15 +193,3 @@ def _parameter_stems(
         known = callable_stems | identifier_stems(argument.arg) | annotation_stems
         parameters[argument.arg] = _ParameterFacts(frozenset(known), frozenset(annotation_stems))
     return parameters
-
-
-def _is_runtime_consumed_or_overload(node: ast.FunctionDef | ast.AsyncFunctionDef, imports: ImportIndex) -> bool:
-    if decorator_markers(node) & PROMPT_DECORATOR_MARKERS:
-        return True
-    for decorator in node.decorator_list:
-        target = decorator.func if isinstance(decorator, ast.Call) else decorator
-        if imports.resolves(target, sources=_OVERLOAD_MODULES, symbol="overload"):
-            return True
-        if any(imports.resolves(target, sources=sources, symbol=symbol) for sources, symbol in _RUNTIME_DOC_DECORATORS):
-            return True
-    return False

{sarj_python_lint-1.66.0 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/docstring_returns_restate_signature.py

@@ -20,11 +20,10 @@ from sarj_python_lint.rule_base import (
 from sarj_python_lint.rules._ast_index import children
 from sarj_python_lint.rules._comments import is_protected, stem
 from sarj_python_lint.rules._docstrings import (
-    PROMPT_DECORATOR_MARKERS,
     VALUE_MARKER_RE,
     annotation_tokens,
-    decorator_markers,
     identifier_stems,
+    is_runtime_consumed_or_overload,
     restates,
     sections,
 )
@@ -51,12 +50,6 @@ _RESULT_SEMANTIC_RE = re.compile(
     re.IGNORECASE,
 )
 
-_RUNTIME_DOC_DECORATORS = (
-    (frozenset({"agents"}), "function_tool"),
-    (frozenset({"click"}), "command"),
-    (frozenset({"typer"}), "command"),
-)
-_OVERLOAD_MODULES = frozenset({"typing", "typing_extensions"})
 _GENERATOR_TYPES = frozenset({"AsyncGenerator", "AsyncIterable", "AsyncIterator", "Generator", "Iterable", "Iterator"})
 _BROAD_RETURN_TYPES = frozenset({"Any", "object"})
 
@@ -228,7 +221,7 @@ class DocstringReturnsRestateSignature(Rule):
             or _TYPED_RESULT_RE.search(block)
         ):
             return
-        if _is_runtime_consumed_or_overload(node, imports):
+        if is_runtime_consumed_or_overload(node, imports):
             return
         annotation = _result_annotation(node, section.name)
         if annotation is None or _is_broad_annotation(annotation):
@@ -313,15 +306,3 @@ def _contains_yield(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
 
 def _is_broad_annotation(annotation: ast.expr) -> bool:
     return _annotation_name(annotation) in _BROAD_RETURN_TYPES
-
-
-def _is_runtime_consumed_or_overload(node: ast.FunctionDef | ast.AsyncFunctionDef, imports: ImportIndex) -> bool:
-    if decorator_markers(node) & PROMPT_DECORATOR_MARKERS:
-        return True
-    for decorator in node.decorator_list:
-        target = decorator.func if isinstance(decorator, ast.Call) else decorator
-        if imports.resolves(target, sources=_OVERLOAD_MODULES, symbol="overload"):
-            return True
-        if any(imports.resolves(target, sources=sources, symbol=symbol) for sources, symbol in _RUNTIME_DOC_DECORATORS):
-            return True
-    return False

{sarj_python_lint-1.66.0 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/invalid_pydantic_field_default.py

@@ -16,6 +16,7 @@ from sarj_python_lint.rule_base import (
     RuleDocumentation,
     RuleExample,
 )
+from sarj_python_lint.rules._annotation_semantics import bit_or_members as _bit_union_members
 from sarj_python_lint.rules._imports import ImportIndex
 from sarj_python_lint.rules._paths import is_test_path
 
@@ -314,18 +315,6 @@ def _literal_key(value: object) -> _LiteralKey:
     return _LiteralKey(type(value), value)
 
 
-def _bit_union_members(node: ast.expr) -> list[ast.expr]:
-    members: list[ast.expr] = []
-    pending = [node]
-    while pending:
-        member = pending.pop()
-        if isinstance(member, ast.BinOp) and isinstance(member.op, ast.BitOr):
-            pending.extend((member.right, member.left))
-        else:
-            members.append(member)
-    return members
-
-
 def _literal_domain(node: ast.expr, imports: ImportIndex) -> _LiteralDomain | None:
     node = _parse_forward_annotation(node)
     if isinstance(node, ast.Constant) and node.value is None:

{sarj_python_lint-1.66.0 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/no_any_mapping_types.py

@@ -21,6 +21,7 @@ from sarj_python_lint.rule_base import (
 )
 from sarj_python_lint.rules._annotation_semantics import AnnotationSemantics, scope_bound_names
 from sarj_python_lint.rules._ast_index import walk as walk_ast
+from sarj_python_lint.rules._ast_names import expression_root as _expression_root
 from sarj_python_lint.rules._namespace_access import dynamic_namespace_access
 
 
@@ -568,12 +569,6 @@ def _type_attribute_mutation(call: ast.Call, imports: ImportIndex, sensitive: se
     return known and _expression_root(call.args[0]) in sensitive
 
 
-def _expression_root(node: ast.expr) -> str | None:
-    while isinstance(node, (ast.Attribute, ast.Subscript)):
-        node = node.value
-    return node.id if isinstance(node, ast.Name) else None
-
-
 def _unshadowed_type_expression(
     node: ast.expr, parents: Mapping[ast.AST, ast.AST], scope_cache: dict[int, frozenset[str]]
 ) -> bool:

{sarj_python_lint-1.66.0 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/no_async_function_cache.py

@@ -17,6 +17,7 @@ from sarj_python_lint.rule_base import (
     is_suppressed,
 )
 from sarj_python_lint.rules._ast_index import has_own_yield
+from sarj_python_lint.rules._imports import ambiguous_import_names as _nested_import_names
 
 
 if TYPE_CHECKING:
@@ -114,17 +115,6 @@ class NoAsyncFunctionCache(Rule):
         return diagnostics
 
 
-def _nested_import_names(context: PythonFileContext) -> frozenset[str]:
-    return frozenset(
-        alias.asname or alias.name.partition(".")[0]
-        for node in context.nodes(ast.Import, ast.ImportFrom)
-        for alias in node.names
-        if context.parents[node] is not context.tree
-        or (isinstance(node, ast.ImportFrom) and node.level > 0)
-        or alias.name == "*"
-    )
-
-
 def _is_coroutine_cache(decorator: ast.expr, imports: ImportIndex, shadowed: frozenset[str]) -> bool:
     target = decorator.func if isinstance(decorator, ast.Call) else decorator
     root = target

{sarj_python_lint-1.66.0 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/no_contradictory_type_guard.py

@@ -16,6 +16,7 @@ from sarj_python_lint.rule_base import (
     Severity,
     is_suppressed,
 )
+from sarj_python_lint.rules._closed_helpers import executable_body
 from sarj_python_lint.rules._imports import TYPING_SOURCES
 from sarj_python_lint.rules._type_guard_symbols import (
     builtin_guard_symbol,
@@ -189,14 +190,7 @@ def _sole_parameter(function: ast.FunctionDef) -> ast.arg | None:
 
 
 def _single_return(function: ast.FunctionDef) -> ast.Return | None:
-    body = function.body
-    if (
-        body
-        and isinstance(body[0], ast.Expr)
-        and isinstance(body[0].value, ast.Constant)
-        and isinstance(body[0].value.value, str)
-    ):
-        body = body[1:]
+    body = executable_body(function)
     return body[0] if len(body) == 1 and isinstance(body[0], ast.Return) else None
 
 

{sarj_python_lint-1.66.0 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/no_generic_single_export_module.py

@@ -15,6 +15,7 @@ from sarj_python_lint.rule_base import (
     RuleExample,
 )
 from sarj_python_lint.rules._ast_index import walk as walk_ast
+from sarj_python_lint.rules._ast_names import unqualified_name as _annotation_name
 from sarj_python_lint.rules._exports import mentions_dunder_all
 
 
@@ -164,14 +165,6 @@ def _dunder_all_matches_primary(tree: ast.Module, primary_name: str) -> bool:
     return isinstance(entry, ast.Constant) and entry.value == primary_name
 
 
-def _annotation_name(node: ast.expr) -> str:
-    match node:
-        case ast.Name(id=name) | ast.Attribute(attr=name):
-            return name
-        case _:
-            return ""
-
-
 def _is_skipped_path(path: Path) -> bool:
     return "tests" in path.parts