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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "1.66.1"
+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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/no_loguru_exc_info.py

@@ -17,6 +17,7 @@ from sarj_python_lint.rule_base import (
     Severity,
     is_suppressed,
 )
+from sarj_python_lint.rules._imports import ambiguous_import_names as _ambiguous_import_names
 
 
 if TYPE_CHECKING:
@@ -114,17 +115,6 @@ class NoLoguruExcInfo(Rule):
         return diagnostics
 
 
-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 _is_unconfigured_loguru(receiver: ast.expr, context: PythonFileContext, shadowed: frozenset[str]) -> bool:
     opted = False
     while isinstance(receiver, ast.Call) and isinstance(receiver.func, ast.Attribute):

{sarj_python_lint-1.66.1 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/prefer_fstring_over_concat.py

@@ -21,7 +21,7 @@ from sarj_python_lint.rules._logging import LOG_METHODS, is_logger_expr
 
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping
+    from collections.abc import Mapping, Sequence
 
     from sarj_python_lint._file_context import PythonFileContext
 
@@ -101,6 +101,7 @@ _STRING_METHODS = frozenset(
     }
 )
 _REGEX_METHODS = frozenset({"compile", "findall", "finditer", "fullmatch", "match", "search", "split", "sub", "subn"})
+_REGEX_CALL_NAMES = frozenset(f"re.{name}" for name in _REGEX_METHODS)
 _COMPACT_UNITS = frozenset({"em", "ms", "pt", "px", "rem", "s"})
 _PRODUCER_NAMES = _STRING_CALLS | {"json", "re", "str"}
 
@@ -114,6 +115,7 @@ class _StringEvidence(NamedTuple):
 class _RegexBindings(NamedTuple):
     modules: frozenset[str]
     functions: frozenset[str]
+    scoped_names: frozenset[str]
 
 
 class PreferFstringOverConcat(Rule):
@@ -188,9 +190,9 @@ class PreferFstringOverConcat(Rule):
         excluded: set[int] = set()
         adds: list[ast.BinOp] = []
         parents = context.parents
-        regex_bindings = _regex_bindings(tree)
+        regex_bindings = _regex_bindings(context)
         for node in context.nodes(ast.BinOp, ast.Call, ast.JoinedStr):
-            _classify_concat_context(node, inner, excluded, adds, regex_bindings)
+            _classify_concat_context(node, inner, excluded, adds, regex_bindings, context=context)
 
         diags: list[Diagnostic] = []
         module_evidence: _StringEvidence | None = None
@@ -226,6 +228,8 @@ def _classify_concat_context(
     excluded: set[int],
     adds: list[ast.BinOp],
     regex_bindings: _RegexBindings,
+    *,
+    context: PythonFileContext,
 ) -> None:
     if isinstance(node, ast.BinOp) and isinstance(node.op, ast.Add):
         _collect_add_chain(node, adds, inner)
@@ -233,9 +237,9 @@ def _classify_concat_context(
         # `("%0" + width + "d") % args` builds a format template.
         excluded.add(id(node.left))
     elif isinstance(node, ast.Call) and _is_logging_call(node):
-        _exclude_logging_chains(node, excluded)
-    elif isinstance(node, ast.Call) and _is_regex_call(node, regex_bindings):
-        excluded.update(id(sub) for arg in node.args for sub in walk(arg))
+        _exclude_call_chains(node, excluded)
+    elif isinstance(node, ast.Call) and _is_regex_call(node, regex_bindings, context):
+        _exclude_regex_chains(node, excluded, context)
     elif isinstance(node, ast.JoinedStr):
         # Rewriting a concat already nested in an f-string merely
         # trades one interpolation expression for a nested f-string.
@@ -249,26 +253,75 @@ def _is_logging_call(node: ast.Call) -> bool:
     return is_logger_expr(func.value)
 
 
-def _is_regex_call(node: ast.Call, bindings: _RegexBindings) -> bool:
+def _is_regex_call(node: ast.Call, bindings: _RegexBindings, context: PythonFileContext) -> bool:
     func = node.func
-    return (isinstance(func, ast.Name) and func.id in bindings.functions) or (
+    if isinstance(func, ast.Name) and func.id in bindings.functions:
+        return True
+    if (
         isinstance(func, ast.Attribute)
         and isinstance(func.value, ast.Name)
         and func.value.id in bindings.modules
         and func.attr in _REGEX_METHODS
-    )
+    ):
+        return True
+    root = func.value if isinstance(func, ast.Attribute) else func
+    if not isinstance(root, ast.Name) or root.id not in bindings.scoped_names:
+        return False
+    return _proven_regex_call(node, context)
+
+
+def _proven_regex_call(node: ast.Call, context: PythonFileContext) -> bool:
+    arguments: list[ast.expr] = [*node.args, *(keyword.value for keyword in node.keywords)]
+    if not any(isinstance(part, ast.BinOp) and isinstance(part.op, ast.Add) for arg in arguments for part in walk(arg)):
+        return False
+    return context.static_resource_provenance.runtime_import_name(node.func) in _REGEX_CALL_NAMES
+
+
+def _exclude_regex_chains(node: ast.Call, excluded: set[int], context: PythonFileContext) -> None:
+    if node.keywords and _proven_regex_call(node, context):
+        _exclude_call_chains(node, excluded)
+    else:
+        excluded.update(id(sub) for arg in node.args for sub in walk(arg))
 
 
-def _regex_bindings(tree: ast.Module) -> _RegexBindings:
+def _regex_bindings(context: PythonFileContext) -> _RegexBindings:
+    imports = context.nodes(ast.Import, ast.ImportFrom)
+    module_imports = [node for node in imports if context.parents[node] is context.tree]
     modules = {
         alias.asname or alias.name
-        for statement in tree.body
+        for statement in module_imports
         if isinstance(statement, ast.Import)
         for alias in statement.names
         if alias.name == "re"
     }
-    functions = _regex_function_bindings(tree)
-    return _RegexBindings(frozenset(modules), frozenset(functions))
+    functions = _regex_function_bindings(module_imports)
+    return _RegexBindings(frozenset(modules), frozenset(functions), _scoped_regex_names(context, imports))
+
+
+def _regex_function_bindings(imports: Sequence[ast.Import | ast.ImportFrom]) -> set[str]:
+    return {
+        alias.asname or alias.name
+        for statement in imports
+        if isinstance(statement, ast.ImportFrom) and statement.module == "re"
+        for alias in statement.names
+        if alias.name in _REGEX_METHODS
+    }
+
+
+def _scoped_regex_names(context: PythonFileContext, imports: Sequence[ast.Import | ast.ImportFrom]) -> frozenset[str]:
+    return frozenset(
+        alias.asname or alias.name
+        for node in imports
+        if context.parents[node] is not context.tree
+        for alias in node.names
+        if (isinstance(node, ast.Import) and alias.name == "re")
+        or (
+            isinstance(node, ast.ImportFrom)
+            and node.module == "re"
+            and node.level == 0
+            and alias.name in _REGEX_METHODS
+        )
+    )
 
 
 def _in_callable_scope(node: ast.AST, parents: Mapping[ast.AST, ast.AST]) -> bool:
@@ -603,16 +656,6 @@ def _stored_names(node: ast.AST) -> set[str]:
     }
 
 
-def _regex_function_bindings(tree: ast.Module) -> set[str]:
-    return {
-        alias.asname or alias.name
-        for statement in tree.body
-        if isinstance(statement, ast.ImportFrom) and statement.module == "re"
-        for alias in statement.names
-        if alias.name in _REGEX_METHODS
-    }
-
-
 def _collect_string_parameters(
     scope: ast.FunctionDef | ast.AsyncFunctionDef | ast.Lambda, shadowed: frozenset[str], known: set[str]
 ) -> None:
@@ -657,7 +700,7 @@ def _update_string_bindings(
         known.difference_update(_bound_names(statement))
 
 
-def _exclude_logging_chains(node: ast.Call, excluded: set[int]) -> None:
+def _exclude_call_chains(node: ast.Call, excluded: set[int]) -> None:
     arguments: list[ast.expr] = [*node.args, *(kw.value for kw in node.keywords)]
     excluded.update(id(sub) for arg in arguments for sub in walk(arg))
 

{sarj_python_lint-1.66.1 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/prefer_match_exception_dispatch.py

@@ -16,6 +16,7 @@ from sarj_python_lint.rule_base import (
     RuleExample,
     Severity,
 )
+from sarj_python_lint.rules._annotation_semantics import bit_or_members as _flatten_union
 from sarj_python_lint.rules._ast_index import nodes, walk as walk_ast
 
 
@@ -349,12 +350,6 @@ def _exception_type_references(expression: ast.expr, imports: ImportIndex) -> fr
     return frozenset(reference for reference in references if reference is not None)
 
 
-def _flatten_union(expression: ast.expr) -> list[ast.expr]:
-    if isinstance(expression, ast.BinOp) and isinstance(expression.op, ast.BitOr):
-        return [*_flatten_union(expression.left), *_flatten_union(expression.right)]
-    return [expression]
-
-
 def _exception_type_reference(expression: ast.expr, imports: ImportIndex) -> str | None:
     if (
         isinstance(expression, ast.Name)

{sarj_python_lint-1.66.1 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/prefer_match_type_dispatch.py

@@ -15,6 +15,7 @@ from sarj_python_lint.rule_base import (
     RuleExample,
     Severity,
 )
+from sarj_python_lint.rules._annotation_semantics import bit_or_members as _flatten_union
 
 
 if TYPE_CHECKING:
@@ -703,12 +704,6 @@ def _type_references(
     return frozenset(reference for reference in references if reference is not None)
 
 
-def _flatten_union(expression: ast.expr) -> list[ast.expr]:
-    if isinstance(expression, ast.BinOp) and isinstance(expression.op, ast.BitOr):
-        return [*_flatten_union(expression.left), *_flatten_union(expression.right)]
-    return [expression]
-
-
 def _type_reference(
     expression: ast.expr,
     imports: ImportIndex,

{sarj_python_lint-1.66.1 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/prefer_nominal_id_types.py

@@ -20,6 +20,7 @@ from sarj_python_lint.rule_base import (
     Severity,
     is_suppressed,
 )
+from sarj_python_lint.rules._annotation_semantics import bit_or_members as _flatten_union
 from sarj_python_lint.rules._ast_index import nodes, parent_map, walk as walk_ast
 from sarj_python_lint.rules._inherited_contract import inherited_contract
 from sarj_python_lint.rules._nominal_project import NominalSource
@@ -805,18 +806,6 @@ def _union_carrier(members: list[ast.expr], imports: ImportIndex, facts: _TypeFa
     return _Carrier(carriers[0].shape, raw=any(carrier.raw for carrier in carriers))
 
 
-def _flatten_union(annotation: ast.expr) -> list[ast.expr]:
-    members: list[ast.expr] = []
-    pending = [annotation]
-    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 _is_none(annotation: ast.expr) -> bool:
     return (isinstance(annotation, ast.Constant) and annotation.value is None) or (
         isinstance(annotation, ast.Name) and annotation.id == "None"

{sarj_python_lint-1.66.1 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/prefer_non_nullable_collection.py

@@ -15,6 +15,7 @@ from sarj_python_lint.rule_base import (
     RuleExample,
     Severity,
 )
+from sarj_python_lint.rules._annotation_semantics import bit_or_members
 from sarj_python_lint.rules._ast_index import walk as walk_ast
 from sarj_python_lint.rules._paths import is_test_path, is_test_support_path
 
@@ -291,9 +292,10 @@ def _is_nullable_list(annotation: ast.expr, imports: ImportIndex) -> bool:
 
 def _union_members(annotation: ast.expr, imports: ImportIndex) -> list[ast.expr] | None:
     if isinstance(annotation, ast.BinOp) and isinstance(annotation.op, ast.BitOr):
-        left = _union_members(annotation.left, imports) or [annotation.left]
-        right = _union_members(annotation.right, imports) or [annotation.right]
-        return [*left, *right]
+        members: list[ast.expr] = []
+        for member in bit_or_members(annotation):
+            members.extend(_union_members(member, imports) or [member])
+        return members
     if not isinstance(annotation, ast.Subscript):
         return None
     if imports.resolves(annotation.value, sources=_TYPING_SOURCES, symbol="Optional"):

{sarj_python_lint-1.66.1 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/prefer_str_enum.py

@@ -19,6 +19,7 @@ from sarj_python_lint.rule_base import (
     Severity,
     is_suppressed,
 )
+from sarj_python_lint.rules._annotation_semantics import bit_or_members as _flatten_annotation_union
 from sarj_python_lint.rules._ast_index import children, walk, walk as walk_ast
 from sarj_python_lint.rules._imports import ImportIndex
 from sarj_python_lint.rules._paths import is_test_path
@@ -1408,18 +1409,6 @@ def _literal_string_values(node: ast.expr) -> list[str] | None:
     return [value for elt in elts if (value := _str_const(elt)) is not None]
 
 
-def _flatten_annotation_union(node: ast.expr) -> list[ast.expr]:
-    members: list[ast.expr] = []
-    pending = [node]
-    while pending:
-        current = pending.pop()
-        if isinstance(current, ast.BinOp) and isinstance(current.op, ast.BitOr):
-            pending.extend((current.right, current.left))
-        else:
-            members.append(current)
-    return members
-
-
 def _is_file_mode_key(key: str) -> bool:
     segment = key.rsplit(".", 1)[-1].lstrip("_").lower()
     return segment in _FILE_MODE_KEYS or segment.endswith("_mode")

{sarj_python_lint-1.66.1 → sarj_python_lint-1.66.2}/src/sarj_python_lint/rules/pytest_fixture_returns_bare_tuple.py

@@ -14,6 +14,7 @@ from sarj_python_lint.rule_base import (
     RuleExample,
     Severity,
 )
+from sarj_python_lint.rules._annotation_semantics import bit_or_members as _union_members
 from sarj_python_lint.rules._ast_index import children, walk as walk_ast
 from sarj_python_lint.rules._ast_names import terminal_name as _dotted_tail
 from sarj_python_lint.rules._paths import is_test_path
@@ -474,12 +475,6 @@ def _optional_member(annotation: ast.expr) -> ast.expr | None:
     return None
 
 
-def _union_members(annotation: ast.expr) -> list[ast.expr]:
-    if isinstance(annotation, ast.BinOp) and isinstance(annotation.op, ast.BitOr):
-        return [*_union_members(annotation.left), *_union_members(annotation.right)]
-    return [annotation]
-
-
 def _only_non_none(members: list[ast.expr]) -> ast.expr | None:
     concrete = [member for member in members if not (isinstance(member, ast.Constant) and member.value is None)]
     return concrete[0] if len(concrete) == 1 and len(concrete) < len(members) else None