sarj-python-lint 1.40.0__tar.gz → 1.40.2__tar.gz

{sarj_python_lint-1.40.0 → sarj_python_lint-1.40.2}/PKG-INFO

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

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

{sarj_python_lint-1.40.0 → sarj_python_lint-1.40.2}/src/sarj_python_lint/rules/_ast_index.py

@@ -33,6 +33,26 @@ def comprehension_results(node: ast.ListComp | ast.SetComp | ast.DictComp | ast.
     return [child for child in children(node) if isinstance(child, ast.expr)]
 
 
+def has_own_yield(function: ast.AsyncFunctionDef) -> bool:
+    pending: list[ast.AST] = list(function.body)
+    while pending:
+        match pending.pop():
+            case ast.Yield() | ast.YieldFrom():
+                return True
+            case ast.FunctionDef() | ast.AsyncFunctionDef() | ast.Lambda() as definition:
+                pending.extend(definition.args.defaults)
+                pending.extend(default for default in definition.args.kw_defaults if default is not None)
+                if not isinstance(definition, ast.Lambda):
+                    pending.extend(definition.decorator_list)
+            case ast.ClassDef() as definition:
+                pending.extend(definition.bases)
+                pending.extend(keyword.value for keyword in definition.keywords)
+                pending.extend(definition.decorator_list)
+            case node:
+                pending.extend(children(node))
+    return False
+
+
 def walk(node: ast.AST, *, index: NodeIndex | None = None) -> Iterator[ast.AST]:
     if index is not None and index.tree is node:
         yield from index.query((ast.AST,))

{sarj_python_lint-1.40.0 → sarj_python_lint-1.40.2}/src/sarj_python_lint/rules/_resource_provenance.py

@@ -6,6 +6,7 @@ from functools import cached_property
 from types import MappingProxyType
 from typing import TYPE_CHECKING, final
 
+from sarj_python_lint.rules._ast_index import has_own_yield
 from sarj_python_lint.rules._namespace_access import dynamic_namespace_access
 
 
@@ -74,7 +75,7 @@ class ResourceProvenance:
                 self.reads[node.id].append(node)
 
             for name in _bound_names(node):
-                self.bindings[self.scope(node)][name].append(node)
+                self.bindings[self._binding_scope(node)][name].append(node)
                 self.wildcard |= name == "*"
             if isinstance(node, ast.Global | ast.Nonlocal):
                 self.external_bindings.update(node.names)
@@ -98,6 +99,14 @@ class ResourceProvenance:
             parent = self.context.parents.get(parent)
         return parent
 
+    def _binding_scope(self, node: ast.AST) -> ast.AST | None:
+        scope = self.scope(node)
+        parent = self.context.parents.get(node)
+        if isinstance(parent, ast.NamedExpr) and parent.target is node:
+            while isinstance(scope, ast.ListComp | ast.SetComp | ast.DictComp | ast.GeneratorExp):
+                scope = self.scope(scope)
+        return scope
+
     def binding(self, name: str, at: ast.AST) -> ast.AST | None:
         scope = self.scope(at)
         while scope is not None:
@@ -251,7 +260,7 @@ class ResourceProvenance:
         owner = self.context.parents.get(function)
         if not isinstance(owner, ast.Module | ast.FunctionDef | ast.AsyncFunctionDef):
             return None
-        if function.decorator_list or any(isinstance(node, ast.Yield | ast.YieldFrom) for node in ast.walk(function)):
+        if function.decorator_list or has_own_yield(function):
             return None
         if function not in self.async_contract_cache:
             self.async_contract_cache[function] = self._async_aliases_untouched(function)

{sarj_python_lint-1.40.0 → sarj_python_lint-1.40.2}/src/sarj_python_lint/rules/no_async_function_cache.py

@@ -16,7 +16,7 @@ from sarj_python_lint.rule_base import (
     Severity,
     is_suppressed,
 )
-from sarj_python_lint.rules._ast_index import children
+from sarj_python_lint.rules._ast_index import has_own_yield
 
 
 if TYPE_CHECKING:
@@ -94,7 +94,7 @@ class NoAsyncFunctionCache(Rule):
             decorator = function.decorator_list[-1]
             if (
                 not _is_coroutine_cache(decorator, context.imports, shadowed)
-                or _has_own_yield(function)
+                or has_own_yield(function)
                 or is_suppressed(context.source_lines, decorator.lineno, self.code)
             ):
                 continue
@@ -157,23 +157,3 @@ def _is_coroutine_cache(decorator: ast.expr, imports: ImportIndex, shadowed: fro
             return size > 0
         case _:
             return False
-
-
-def _has_own_yield(function: ast.AsyncFunctionDef) -> bool:
-    pending: list[ast.AST] = list(function.body)
-    while pending:
-        match pending.pop():
-            case ast.Yield() | ast.YieldFrom():
-                return True
-            case ast.FunctionDef() | ast.AsyncFunctionDef() | ast.Lambda() as definition:
-                pending.extend(definition.args.defaults)
-                pending.extend(default for default in definition.args.kw_defaults if default is not None)
-                if not isinstance(definition, ast.Lambda):
-                    pending.extend(definition.decorator_list)
-            case ast.ClassDef() as definition:
-                pending.extend(definition.bases)
-                pending.extend(keyword.value for keyword in definition.keywords)
-                pending.extend(definition.decorator_list)
-            case node:
-                pending.extend(children(node))
-    return False

{sarj_python_lint-1.40.0 → sarj_python_lint-1.40.2}/src/sarj_python_lint/rules/prefer_constant_time_secret_compare.py

@@ -170,7 +170,9 @@ class PreferConstantTimeSecretCompare(Rule):
             if _is_password_confirmation_pair(operands):
                 continue
             scope = _enclosing_scope(comparison, parents, tree)
-            roles = role_cache.setdefault(id(scope), _roles_for_scope(scope, environment_names))
+            if id(scope) not in role_cache:
+                role_cache[id(scope)] = _roles_for_scope(scope, environment_names)
+            roles = role_cache[id(scope)]
             position = (comparison.lineno, comparison.col_offset)
             dominant_roles = _dominating_walrus_roles(comparison, parents, roles, position)
             operand_roles = [_operand_role(operand, roles, position, dominant_roles) for operand in operands]

{sarj_python_lint-1.40.0 → sarj_python_lint-1.40.2}/src/sarj_python_lint/rules/prefer_nominal_id_types.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import ast
+from collections import Counter
 from dataclasses import dataclass
 from pathlib import PurePosixPath
 import re
@@ -710,7 +711,8 @@ def _unambiguous_exports(tree: ast.Module, imports: ImportIndex, facts: _TypeFac
             assignments.setdefault(assignment.target, []).append(assignment)
     # Imports are re-exports only when their binding is unambiguous; local
     # aliases must have exactly one top-level assignment and no other writes.
-    unique = {name for name, values in assignments.items() if len(values) == 1 and _binding_count(tree, name) == 1}
+    bindings: Counter[str] = _binding_counts(tree) if assignments else Counter()
+    unique = {name for name, values in assignments.items() if len(values) == 1 and bindings.get(name, 0) == 1}
     allowed = unique | set(imports.bindings)
     return _TypeFacts(
         {name: shape for name, shape in facts.raw_aliases.items() if name in allowed},
@@ -718,15 +720,23 @@ def _unambiguous_exports(tree: ast.Module, imports: ImportIndex, facts: _TypeFac
     )
 
 
-def _binding_count(tree: ast.Module, name: str) -> int:
-    return sum(
-        1
-        for node in walk_ast(tree)
-        if (isinstance(node, ast.Name) and isinstance(node.ctx, (ast.Store, ast.Del)) and node.id == name)
-        or (isinstance(node, ast.arg) and node.arg == name)
-        or (isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)) and node.name == name)
-        or (isinstance(node, ast.alias) and (node.asname or node.name.partition(".")[0]) == name)
-    )
+def _binding_counts(tree: ast.Module) -> Counter[str]:
+    bindings: Counter[str] = Counter()
+    for node in walk_ast(tree):
+        match node:
+            case (
+                ast.Name(id=name, ctx=ast.Store() | ast.Del())
+                | ast.arg(arg=name)
+                | ast.FunctionDef(name=name)
+                | ast.AsyncFunctionDef(name=name)
+                | ast.ClassDef(name=name)
+            ):
+                bindings[name] += 1
+            case ast.alias(name=name, asname=alias):
+                bindings[alias or name.partition(".")[0]] += 1
+            case _:
+                continue
+    return bindings
 
 
 def _imported_facts(

{sarj_python_lint-1.40.0 → sarj_python_lint-1.40.2}/src/sarj_python_lint/rules/prefer_required_constructor_parameters.py

@@ -96,7 +96,7 @@ class PreferRequiredConstructorParameters(Rule):
                 continue
             if method.decorator_list:
                 if provenance is None:
-                    provenance = _overload_provenance(context)
+                    provenance = ResourceProvenance(context)
                 if _is_overload(context, provenance, method):
                     continue
             findings.extend(
@@ -134,24 +134,6 @@ def _scope(context: PythonFileContext, node: ast.AST) -> ast.AST | None:
     return parent
 
 
-def _overload_provenance(context: PythonFileContext) -> ResourceProvenance:
-    provenance = ResourceProvenance(context)
-    comprehensions = (ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)
-    for expression in context.nodes(ast.NamedExpr):
-        target = expression.target
-        original = provenance.scope(target)
-        if not isinstance(original, comprehensions):
-            continue
-        # Assignment expressions in comprehensions bind in the containing
-        # scope, unlike iteration targets, which stay comprehension-local.
-        containing = original
-        while isinstance(containing, comprehensions):
-            containing = provenance.scope(containing)
-        provenance.bindings[original][target.id].remove(target)
-        provenance.bindings[containing][target.id].append(target)
-    return provenance
-
-
 def _binding(provenance: ResourceProvenance, name: str, at: ast.AST) -> ast.AST | None:
     scope = provenance.scope(at)
     deferred = False