sarj-python-lint 1.107.0__tar.gz → 1.108.1__tar.gz

{sarj_python_lint-1.107.0 → sarj_python_lint-1.108.1}/PKG-INFO

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

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

{sarj_python_lint-1.107.0 → sarj_python_lint-1.108.1}/src/sarj_python_lint/__main__.py

@@ -103,7 +103,7 @@ def _python_files(p: Path) -> list[Path]:
     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"):
+            if not fnmatch(name, "*.py") and not fnmatch(name, "*.pyi"):
                 continue
             child = directory / name
             if child.is_file():

{sarj_python_lint-1.107.0 → sarj_python_lint-1.108.1}/src/sarj_python_lint/rules/_nominal_project.py

@@ -19,6 +19,8 @@ from sarj_python_lint.rules._paths import is_generated
 
 
 if TYPE_CHECKING:
+    from typing import Never
+
     from sarj_python_lint.rules._first_party import FirstPartyFacts
 
 
@@ -239,10 +241,14 @@ def _patterns(value: object) -> tuple[str, ...] | None:
     return tuple(item for item in value if isinstance(item, str))
 
 
+def _raise_walk_error(error: OSError) -> Never:
+    raise error
+
+
 def _files(root: Path, pattern: str) -> list[Path]:
     found: list[Path] = []
     try:
-        for count, (directory, directories, filenames) in enumerate(root.walk()):
+        for count, (directory, directories, filenames) in enumerate(root.walk(on_error=_raise_walk_error)):
             if count >= _MAX_DIRECTORIES or len(found) >= _MAX_FILES:
                 # A partial inventory cannot establish uniqueness.
                 return []

{sarj_python_lint-1.107.0 → sarj_python_lint-1.108.1}/src/sarj_python_lint/rules/fastapi_explicit_openapi_contract.py

@@ -256,11 +256,14 @@ class FastapiExplicitOpenapiContract(Rule):
         tree = context.tree
         if tree is None:
             return []
+        functions = context.nodes(ast.FunctionDef, ast.AsyncFunctionDef)
+        if not any(function.decorator_list for function in functions):
+            return []
         index = context.fastapi
         scopes = _function_scopes(tree)
         findings: list[_Finding] = []
         declared: list[tuple[int, Route]] = []
-        for function in context.nodes(ast.FunctionDef, ast.AsyncFunctionDef):
+        for function in functions:
             all_routes = index.routes(function)
             declared.extend((scopes[id(function)], route) for route in all_routes)
             routes = tuple(route for route in all_routes if not route.is_hidden)

{sarj_python_lint-1.107.0 → sarj_python_lint-1.108.1}/src/sarj_python_lint/rules/named_record_at_boundaries.py

@@ -251,7 +251,7 @@ def _resolve_annotation(node: ast.expr | None) -> ast.expr | None:
     if isinstance(node, ast.Constant) and isinstance(node.value, str):
         try:
             return ast.parse(node.value.strip(), mode="eval").body
-        except SyntaxError:
+        except SyntaxError, UnicodeError:
             return None
     return node
 

{sarj_python_lint-1.107.0 → sarj_python_lint-1.108.1}/src/sarj_python_lint/rules/prefer_str_enum.py

@@ -419,7 +419,7 @@ class PreferStrEnum(Rule):
         if tree is None:
             return []
         signals = context.symbol_source
-        class_choice_signal = "str" in signals and any(name in signals.lower() for name in CHOICES_ATTR_NAMES)
+        class_choice_signal = _has_class_choice_signal(signals)
         wrapper_signal = any(symbol in signals for symbol in ("Annotated", "Optional", "Union"))
         imports = context.imports if class_choice_signal or "assert_never" in signals or wrapper_signal else None
         rejection_imports = _assert_never_imports(context, imports)
@@ -694,9 +694,16 @@ class PreferStrEnum(Rule):
         return diags
 
 
+def _has_class_choice_signal(source: str) -> bool:
+    # Decoded string annotations can spell str through escapes or adjacent literals.
+    return ("str" in source or '"' in source or "'" in source) and any(
+        name in source.lower() for name in CHOICES_ATTR_NAMES
+    )
+
+
 def _has_str_enum_signal(source: str) -> bool:
     has_string_literal = '"' in source or "'" in source
-    if "str" in source and any(name in source.lower() for name in CHOICES_ATTR_NAMES):
+    if _has_class_choice_signal(source):
         return True
     has_rejection = "raise" in source or "assert_never" in source
     return (

{sarj_python_lint-1.107.0 → sarj_python_lint-1.108.1}/src/sarj_python_lint/rules/prefer_typed_mapping_get.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import ast
 from dataclasses import dataclass
-from pathlib import PurePosixPath
+from pathlib import Path, PurePosixPath
 from typing import TYPE_CHECKING, final, override
 
 from sarj_python_lint.rule_base import (
@@ -22,8 +22,6 @@ from sarj_python_lint.rules.require_pydantic_for_mapping_shape import MappingSha
 
 
 if TYPE_CHECKING:
-    from pathlib import Path
-
     from sarj_python_lint._file_context import PythonFileContext
 
 _UNTYPED = frozenset(
@@ -39,6 +37,7 @@ _UNTYPED = frozenset(
 )
 _JSON_PARSERS = frozenset({"json.load", "json.loads"})
 _MAX_DEPTH = 32
+_MAX_RETURN_PROOFS = 512
 _BAD = "def service_name(state: dict[str, object]):\n    return state.get('name')\n"
 _GOOD = "from typing import TypedDict\nclass State(TypedDict):\n    name: str\ndef service_name(state: State) -> str | None:\n    return state.get('name')\n"
 
@@ -195,11 +194,49 @@ class _ImportLocation:
     name: str
 
 
+@dataclass(frozen=True, slots=True, kw_only=True)
+class _ReturnProofKey:
+    owner_path: Path
+    definition: ast.FunctionDef | ast.AsyncFunctionDef
+    seen: frozenset[ast.AST]
+
+
 class _ReturnContracts:
     def __init__(self, facts: MappingShapeFacts) -> None:
         self.owners = {facts.context.path: facts}
         # Return lookups must leave other rules enough budget to resolve their validators.
         self.local_source = LocalSourceFacts(source_inputs=facts.context.session.source_inputs)
+        self._return_proofs: dict[_ReturnProofKey, bool] = {}
+        self._return_nodes: dict[Path, dict[ast.FunctionDef | ast.AsyncFunctionDef, tuple[ast.Return, ...]]] = {}
+
+    def returned_mapping(
+        self, owner: MappingShapeFacts, function: ast.FunctionDef | ast.AsyncFunctionDef, seen: frozenset[ast.AST]
+    ) -> bool:
+        key = _ReturnProofKey(owner_path=owner.context.path, definition=function, seen=seen)
+        cached = self._return_proofs.get(key)
+        if cached is not None:
+            return cached
+        returned = self.return_nodes(owner, function)
+        result = bool(returned) and all(
+            node.value is not None and _untyped_receiver(node.value, owner, self, seen=seen | {function})
+            for node in returned
+        )
+        if len(self._return_proofs) < _MAX_RETURN_PROOFS:
+            self._return_proofs[key] = result
+        return result
+
+    def return_nodes(
+        self, owner: MappingShapeFacts, function: ast.FunctionDef | ast.AsyncFunctionDef
+    ) -> tuple[ast.Return, ...]:
+        path = owner.context.path
+        if path not in self._return_nodes:
+            grouped: dict[ast.FunctionDef | ast.AsyncFunctionDef, list[ast.Return]] = {}
+            for node in owner.context.nodes(ast.Return):
+                scope = owner.provenance.scope(node)
+                if isinstance(scope, ast.FunctionDef | ast.AsyncFunctionDef):
+                    grouped.setdefault(scope, []).append(node)
+            self._return_nodes[path] = {scope: tuple(nodes) for scope, nodes in grouped.items()}
+        return self._return_nodes[path].get(function, ())
 
     def function(
         self, expression: ast.expr, facts: MappingShapeFacts, seen: frozenset[ast.AST]
@@ -343,11 +380,7 @@ def _returned_mapping(
         return owner.annotation(function.returns, function.returns, mapping=True) or _erased_annotation(
             function.returns, owner
         )
-    returned = [node for node in owner.context.nodes(ast.Return) if owner.provenance.scope(node) is function]
-    return bool(returned) and all(
-        node.value is not None and _untyped_receiver(node.value, owner, contracts, seen=seen | {function})
-        for node in returned
-    )
+    return contracts.returned_mapping(owner, function, seen)
 
 
 def _name_receiver(