sarj-python-lint 1.48.0__tar.gz → 1.49.0__tar.gz

{sarj_python_lint-1.48.0 → sarj_python_lint-1.49.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.48.0
+Version: 1.49.0
 Summary: Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults
 Project-URL: Homepage, https://code-standards.sarj.ai/rules/python/
 Project-URL: Documentation, https://code-standards.sarj.ai/rules/python/

{sarj_python_lint-1.48.0 → sarj_python_lint-1.49.0}/pyproject.toml

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

{sarj_python_lint-1.48.0 → sarj_python_lint-1.49.0}/src/sarj_python_lint/rules/_registry.py

@@ -43,6 +43,7 @@ from sarj_python_lint.rules.no_cors_wildcard_with_credentials import (
 )
 from sarj_python_lint.rules.no_database_programmability import NoDatabaseProgrammability
 from sarj_python_lint.rules.no_delete_statement import NoDeleteStatement
+from sarj_python_lint.rules.no_discarded_validation_result import NoDiscardedValidationResult
 from sarj_python_lint.rules.no_dunder_all import NoDunderAll
 from sarj_python_lint.rules.no_duplicate_dunder_all_entry import NoDuplicateDunderAllEntry
 from sarj_python_lint.rules.no_excessive_cognitive_complexity import NoExcessiveCognitiveComplexity
@@ -249,6 +250,7 @@ REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
         NoFixedSleepInLoop.id: NoFixedSleepInLoop,
         NoInterpreterSourceArguments.id: NoInterpreterSourceArguments,
         NoUnusedCopyResult.id: NoUnusedCopyResult,
+        NoDiscardedValidationResult.id: NoDiscardedValidationResult,
         NoBeforeValidatorInputMutation.id: NoBeforeValidatorInputMutation,
         NoInputModelMutation.id: NoInputModelMutation,
         NoDatabaseProgrammability.id: NoDatabaseProgrammability,

{sarj_python_lint-1.48.0 → sarj_python_lint-1.49.0}/src/sarj_python_lint/rules/_resource_provenance.py

@@ -8,9 +8,12 @@ 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
+from sarj_python_lint.rules._runtime_bindings import RuntimeBindings
 
 
 if TYPE_CHECKING:
+    from pathlib import Path
+
     from sarj_python_lint._file_context import PythonFileContext
 
 
@@ -76,6 +79,7 @@ class ResourceProvenance:
         self.escape_cache: dict[tuple[ast.AST, bool], bool] = {}
         self.async_contract_cache: dict[ast.AsyncFunctionDef, bool] = {}
         self.import_contract_cache: dict[str, bool] = {}
+        self.runtime_import_cache: dict[ast.alias, bool] = {}
         self.wildcard = False
         self.mutated: set[str] = set()
         self.external_bindings: set[str] = set()
@@ -133,6 +137,113 @@ class ResourceProvenance:
             scope = self.scope(scope)
         return None
 
+    @cached_property
+    def runtime_bindings(self) -> RuntimeBindings:
+        return RuntimeBindings(self.context, self.bindings)
+
+    def runtime_binding(self, name: str, at: ast.AST) -> ast.AST | None:
+        nodes = self.runtime_bindings.lookup(self.scope(at), name)
+        if not nodes:
+            return None
+        return nodes[0] if len(nodes) == 1 or self._same_import_bindings(list(nodes)) else None
+
+    def runtime_import_name(self, node: ast.expr) -> str | None:
+        root = _root_name(node)
+        if self.wildcard or self.dynamic_namespace or root is None or root in self.mutated:
+            return None
+        binding = self.runtime_binding(root, node)
+        if not isinstance(binding, ast.alias):
+            return None
+        qualified = _runtime_import_name(node, binding, self.context.parents.get(binding))
+        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, ())
+            )
+        return qualified if self.runtime_import_cache[binding] else None
+
+    @cached_property
+    def mock_namespace_patching(self) -> bool:
+        return any(
+            self.runtime_import_name(node.func)
+            in {
+                "unittest.mock.patch",
+                "unittest.mock.patch.object",
+                "unittest.mock.patch.multiple",
+                "unittest.mock.patch.dict",
+            }
+            for node in self.context.nodes(ast.Call)
+        )
+
+    @cached_property
+    def imported_namespace_hazards(self) -> frozenset[Path]:
+        hazards: set[Path] = set()
+        for node in self.context.nodes(ast.Name, ast.Attribute):
+            match node:
+                case ast.Attribute(value=value, ctx=ast.Store() | ast.Del()):
+                    hazards.update(self._namespace_paths(value, include_root=True))
+                case ast.Name(ctx=ast.Load()) | ast.Attribute(ctx=ast.Load()) if not self._safe_import_use(node):
+                    hazards.update(self._namespace_paths(node, include_root=False))
+                case _:
+                    pass
+        return frozenset(hazards)
+
+    @cached_property
+    def _namespace_aliases(self) -> dict[str, tuple[ast.alias, ...]]:
+        aliases: dict[str, list[ast.alias]] = defaultdict(list)
+        for binding in self.context.nodes(ast.alias):
+            parent = self.context.parents.get(binding)
+            name = binding.asname or (
+                binding.name.partition(".")[0] if isinstance(parent, ast.Import) else binding.name
+            )
+            aliases[name].append(binding)
+        return {name: tuple(bindings) for name, bindings in aliases.items()}
+
+    def _namespace_paths(self, expression: ast.expr, *, include_root: bool) -> set[Path]:
+        attributes: list[str] = []
+        root = expression
+        while isinstance(root, ast.Attribute):
+            attributes.append(root.attr)
+            root = root.value
+        if not isinstance(root, ast.Name):
+            return set()
+        binding = self.runtime_binding(root.id, expression)
+        aliases: tuple[ast.alias, ...]
+        match binding:
+            case ast.alias():
+                aliases = (binding,)
+            case None:
+                aliases = self._namespace_aliases.get(root.id, ())
+            case _:
+                return set()
+        paths: set[Path] = set()
+        for alias in aliases:
+            path = self._namespace_module_path(alias, tuple(reversed(attributes)))
+            if path is not None:
+                paths.add(path)
+            if include_root and attributes:
+                base = self._namespace_module_path(alias, ())
+                if base is not None:
+                    paths.add(base)
+        return paths
+
+    def _namespace_module_path(self, binding: ast.alias, attributes: tuple[str, ...]) -> Path | None:
+        parent = self.context.parents.get(binding)
+        match parent:
+            case ast.Import():
+                prefix = binding.name if binding.asname else binding.name.partition(".")[0]
+                level = 0
+            case ast.ImportFrom(module=module, level=level):
+                prefix = ".".join(part for part in (module, binding.name) if part)
+            case _:
+                return None
+        module = ".".join((prefix, *attributes))
+        return self.context.session.local_source.resolve_module(
+            self.context.path, module, level, facts=self.context.session.first_party
+        )
+
     def _same_import_bindings(self, nodes: list[ast.AST]) -> bool:
         targets: set[tuple[str, str | None, int, str]] = set()
         for node in nodes:
@@ -417,6 +528,21 @@ def _root_name(node: ast.expr) -> str | None:
     return node.id if isinstance(node, ast.Name) else None
 
 
+def _runtime_import_name(expression: ast.expr, binding: ast.alias, parent: ast.AST | None) -> str | None:
+    attributes: list[str] = []
+    while isinstance(expression, ast.Attribute):
+        attributes.append(expression.attr)
+        expression = expression.value
+    match parent:
+        case ast.Import():
+            prefix = binding.name if binding.asname else binding.name.partition(".")[0]
+        case ast.ImportFrom(module=str(module), level=0):
+            prefix = f"{module}.{binding.name}"
+        case _:
+            return None
+    return ".".join((prefix, *reversed(attributes)))
+
+
 def _bound_names(node: ast.AST) -> tuple[str, ...]:
     match node:
         case ast.Name(id=name, ctx=ast.Store() | ast.Del()) | ast.arg(arg=name):

sarj_python_lint-1.49.0/src/sarj_python_lint/rules/_runtime_bindings.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import ast
+from collections import defaultdict
+import symtable
+from typing import TYPE_CHECKING, final
+
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
+    from sarj_python_lint._file_context import PythonFileContext
+
+
+@final
+class RuntimeBindings:
+    def __init__(
+        self, context: PythonFileContext, bindings: Mapping[ast.AST | None, Mapping[str, Sequence[ast.AST]]]
+    ) -> None:
+        self.bindings = bindings
+        self.tables: dict[int, symtable.SymbolTable] = {}
+        self.parents: dict[int, int | None] = {}
+        self.by_scope: dict[ast.AST, int] = {}
+        self.scopes: dict[int, ast.AST] = {}
+        self.mutable: set[tuple[int, str]] = set()
+        self.module: int | None = None
+        tree = context.tree
+        if tree is None:
+            return
+        try:
+            root = symtable.symtable(context.source, str(context.path), "exec")
+        except SyntaxError, UnicodeError, RecursionError:
+            return
+        self.module = root.get_id()
+        self._collect(root)
+        self._map_scopes(context, tree, root)
+        self._index_writes()
+
+    def lookup(self, scope: ast.AST | None, name: str) -> Sequence[ast.AST] | None:
+        if scope is None or (table_id := self.by_scope.get(scope)) is None:
+            return None
+        symbol = _symbol(self.tables[table_id], name)
+        if symbol is None or (owner := self._owner(table_id, symbol)) is None or (owner, name) in self.mutable:
+            return None
+        owner_scope = self.scopes.get(owner)
+        return self.bindings.get(owner_scope, {}).get(name) if owner_scope is not None else None
+
+    def _collect(self, root: symtable.SymbolTable) -> None:
+        pending: list[tuple[symtable.SymbolTable, int | None]] = [(root, None)]
+        while pending:
+            table, parent = pending.pop()
+            identity = table.get_id()
+            self.tables[identity] = table
+            self.parents[identity] = parent
+            pending.extend((child, identity) for child in table.get_children())
+
+    def _map_scopes(self, context: PythonFileContext, tree: ast.Module, root: symtable.SymbolTable) -> None:
+        candidates: dict[tuple[symtable.SymbolTableType, str, int], list[int]] = defaultdict(list)
+        for identity, table in self.tables.items():
+            candidates[table.get_type(), table.get_name(), table.get_lineno()].append(identity)
+        self.by_scope[tree] = root.get_id()
+        self.scopes[root.get_id()] = tree
+        for node in context.nodes(ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef):
+            kind = (
+                symtable.SymbolTableType.CLASS if isinstance(node, ast.ClassDef) else symtable.SymbolTableType.FUNCTION
+            )
+            matches = candidates.get((kind, node.name, node.lineno), ())
+            if len(matches) == 1:
+                [identity] = matches
+                self.by_scope[node] = identity
+                self.scopes[identity] = node
+
+    def _index_writes(self) -> None:
+        for identity, table in self.tables.items():
+            if identity == self.module:
+                continue
+            for symbol in table.get_symbols():
+                if not (symbol.is_global() or symbol.is_nonlocal()):
+                    continue
+                if not (symbol.is_assigned() or symbol.is_imported() or symbol.is_namespace()):
+                    continue
+                owner = self._owner(identity, symbol)
+                if owner is not None:
+                    self.mutable.add((owner, symbol.get_name()))
+
+    def _owner(self, identity: int, symbol: symtable.Symbol) -> int | None:
+        if symbol.is_global():
+            return self.module
+        if symbol.is_local():
+            return identity
+        if not symbol.is_free():
+            return None
+        parent = self.parents.get(identity)
+        while parent is not None:
+            table = self.tables[parent]
+            if table.get_type() is symtable.SymbolTableType.MODULE:
+                break
+            if table.get_type() is symtable.SymbolTableType.CLASS and symbol.get_name() == "__class__":
+                # The compiler binds this cell to the lexically defined class.
+                return None
+            if table.get_type() is not symtable.SymbolTableType.CLASS:
+                ancestor = _symbol(table, symbol.get_name())
+                if ancestor is not None and ancestor.is_local():
+                    return parent
+            parent = self.parents.get(parent)
+        return None
+
+
+def _symbol(table: symtable.SymbolTable, name: str) -> symtable.Symbol | None:
+    try:
+        return table.lookup(name)
+    except KeyError:
+        return None