sarj-python-lint 0.67.2__tar.gz → 0.67.4__tar.gz

{sarj_python_lint-0.67.2 → sarj_python_lint-0.67.4}/PKG-INFO

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

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

{sarj_python_lint-0.67.2 → sarj_python_lint-0.67.4}/src/sarj_python_lint/rules/_fastapi.py

@@ -570,7 +570,7 @@ def _resolve_module_path(current: Path, reference: _ImportedReference) -> Path |
     current = current.resolve()
     checkout = _checkout_root(current)
     if checkout is None:
-        return None
+        return _resolve_module_path_without_checkout(current, reference)
     module_parts = tuple(part for part in reference.module.split(".") if part)
     candidates: set[Path] = set()
     if 0 < reference.level <= _MAX_PATH_ANCESTORS:
@@ -593,6 +593,41 @@ def _resolve_module_path(current: Path, reference: _ImportedReference) -> Path |
     return next(iter(candidates)) if len(candidates) == 1 else None
 
 
+def _resolve_module_path_without_checkout(current: Path, reference: _ImportedReference) -> Path | None:
+    """Resolve an explicitly local import when a detached source tree has no VCS root.
+
+    Relative imports must stay inside a real package chain. Absolute imports are
+    considered only at an ancestor matching their first component, or as a
+    direct sibling module. These exact, bounded anchors avoid treating an
+    arbitrary filesystem ancestor as an import search path.
+    """
+    module_parts = tuple(part for part in reference.module.split(".") if part)
+    candidates: set[Path] = set()
+    if 0 < reference.level <= _MAX_PATH_ANCESTORS:
+        package = current.parent
+        if not (package / "__init__.py").is_file():
+            return None
+        for _ in range(reference.level - 1):
+            parent = package.parent
+            if not (parent / "__init__.py").is_file():
+                return None
+            package = parent
+        candidates.update(_existing_module_files(package.joinpath(*module_parts), package))
+    elif module_parts:
+        first = module_parts[0]
+        for depth, ancestor in enumerate(current.parent.parents):
+            if depth >= _MAX_PATH_ANCESTORS:
+                break
+            package = ancestor / first
+            if package != current.parent and not current.is_relative_to(package):
+                continue
+            candidates.update(_existing_module_files(ancestor.joinpath(*module_parts), ancestor))
+        # A detached directory of modules is also a valid, deliberately narrow
+        # import root. Do not search any of its parents for an unrelated module.
+        candidates.update(_existing_module_files(current.parent.joinpath(*module_parts), current.parent))
+    return next(iter(candidates)) if len(candidates) == 1 else None
+
+
 def _checkout_root(current: Path) -> Path | None:
     for depth, ancestor in enumerate(current.parents):
         if depth >= _MAX_PATH_ANCESTORS:

{sarj_python_lint-0.67.2 → sarj_python_lint-0.67.4}/src/sarj_python_lint/rules/prefer_immutable_module_constant.py

@@ -202,6 +202,7 @@ class _MutationVisitor(ast.NodeVisitor):
         self.mutated: set[str] = mutated
         self._scopes: list[tuple[set[str], set[str]]] = []
         self._local_container_roots: list[dict[str, set[str]]] = []
+        self._module_container_roots: dict[str, set[str]] = {}
 
     def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
         self._visit_function(node)
@@ -278,11 +279,14 @@ class _MutationVisitor(ast.NodeVisitor):
         self.generic_visit(node)
 
     def _remember_local_container_roots(self, targets: tuple[ast.expr, ...] | list[ast.expr], value: ast.expr) -> None:
-        if not self._local_container_roots:
-            return
         roots = self._module_roots(value)
         if not roots:
             return
+        if not self._local_container_roots:
+            for target in targets:
+                if isinstance(target, ast.Name):
+                    self._module_container_roots.setdefault(target.id, set()).update(roots)
+            return
         locals_ = self._scopes[-1][0]
         aliases = self._local_container_roots[-1]
         for target in targets:
@@ -298,9 +302,11 @@ class _MutationVisitor(ast.NodeVisitor):
                 (scope[name] for scope in reversed(self._local_container_roots) if name in scope),
                 None,
             )
+            if alias is None:
+                alias = self._module_container_roots.get(name)
             if alias is not None:
                 roots.update(alias)
-            elif self._is_module_reference(name):
+            if self._is_module_reference(name):
                 roots.add(name)
         return roots
 

{sarj_python_lint-0.67.2 → sarj_python_lint-0.67.4}/src/sarj_python_lint/rules/prefer_module_level_constant.py

@@ -432,12 +432,20 @@ def _is_safe_read(node: ast.Name, parents: dict[int, ast.AST], safe_methods: fro
             return _is_safe_method_call(parent, parents, safe_methods)
         case ast.Subscript(value=value, ctx=ctx):
             # `x[k]` reads; `x[k] = v` / `del x[k]` mutate.
-            return isinstance(ctx, ast.Load) if value is node else True
+            # A binding used as `frame[x]` is not representation-neutral:
+            # pandas and other selector APIs distinguish a list from a tuple.
+            return value is node and isinstance(ctx, ast.Load)
         case ast.Call(args=args, func=callee):
             return any(arg is node for arg in args) and _is_safe_callee(callee)
         case ast.keyword(arg=str(), value=value) if value is node:
             grandparent = parents.get(id(parent))
-            return isinstance(grandparent, ast.Call) and _is_safe_callee(grandparent.func)
+            # `dict(label=x)` retains `x` as a nested value; unlike
+            # `dict(x)`, it does not copy the candidate collection itself.
+            return (
+                isinstance(grandparent, ast.Call)
+                and _is_safe_callee(grandparent.func)
+                and _dotted_name(grandparent.func) != "dict"
+            )
         case ast.Compare():
             return True
         case ast.For() | ast.AsyncFor() | ast.comprehension():

{sarj_python_lint-0.67.2 → sarj_python_lint-0.67.4}/src/sarj_python_lint/rules/prefer_timedelta_for_durations.py

@@ -143,6 +143,7 @@ class PreferTimedeltaForDurations(Rule):
         exempt_fields = (
             _settings_field_ids(tree) | _pydantic_model_field_ids(tree, imports) | _typed_dict_field_ids(tree, imports)
         )
+        serialized_constants = _exclusively_serialized_duration_constants(tree, imports)
         diags: list[Diagnostic] = []
         for node in nodes(tree, ast.FunctionDef, ast.AsyncFunctionDef, ast.AnnAssign):
             if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
@@ -163,7 +164,7 @@ class PreferTimedeltaForDurations(Rule):
         for statement in tree.body:
             match statement:
                 case ast.Assign(targets=[ast.Name(id=name)], value=value) if _is_numeric_expression(value):
-                    if _is_constant_reference(name):
+                    if _is_constant_reference(name) and name not in serialized_constants:
                         numeric = "float" if _contains_float(value) else "int"
                         self._consider(name, ast.Name(id=numeric), statement, diags, path)
                 case _:
@@ -238,6 +239,148 @@ def _contains_float(node: ast.AST) -> bool:
     return any(isinstance(child, ast.Constant) and isinstance(child.value, float) for child in ast.walk(node))
 
 
+def _exclusively_serialized_duration_constants(tree: ast.Module, imports: ImportIndex) -> frozenset[str]:
+    """Find numeric constants whose reads are proven wire-model construction only."""
+    definitions = {
+        statement.targets[0].id: statement.targets[0]
+        for statement in tree.body
+        if isinstance(statement, ast.Assign)
+        and len(statement.targets) == 1
+        and isinstance(statement.targets[0], ast.Name)
+        and _is_numeric_expression(statement.value)
+        and _is_constant_reference(statement.targets[0].id)
+    }
+    if not definitions:
+        return frozenset()
+    wire_models = _wire_model_class_names(tree, imports)
+    if not wire_models:
+        return frozenset()
+    parent = {id(child): owner for owner in ast.walk(tree) for child in ast.iter_child_nodes(owner)}
+    serialized: set[str] = set()
+    for name, target in definitions.items():
+        if _has_competing_binding(tree, name, target):
+            continue
+        loads = [
+            node
+            for node in ast.walk(tree)
+            if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Load) and node.id == name
+        ]
+        if loads and all(_is_wire_model_value(load, parent, wire_models) for load in loads):
+            serialized.add(name)
+    return frozenset(serialized)
+
+
+def _has_competing_binding(tree: ast.Module, name: str, definition: ast.Name) -> bool:
+    """Reject lexical ambiguity rather than attributing shadowed reads to a constant."""
+    for node in ast.walk(tree):
+        match node:
+            case ast.Name(id=identifier, ctx=ast.Store()) if identifier == name and node is not definition:
+                return True
+            case ast.arg(arg=identifier) if identifier == name:
+                return True
+            case (
+                ast.FunctionDef(name=identifier) | ast.AsyncFunctionDef(name=identifier) | ast.ClassDef(name=identifier)
+            ) if identifier == name:
+                return True
+            case ast.alias(name=imported, asname=alias) if (alias or imported.split(".")[0]) == name:
+                return True
+            case ast.ExceptHandler(name=identifier) if identifier == name:
+                return True
+            case ast.MatchAs(name=identifier) | ast.MatchStar(name=identifier) if identifier == name:
+                return True
+            case ast.MatchMapping(rest=identifier) if identifier == name:
+                return True
+            case _:
+                pass
+    return False
+
+
+def _is_wire_model_value(
+    load: ast.Name,
+    parents: dict[int, ast.AST],
+    wire_models: frozenset[str],
+) -> bool:
+    parent = parents.get(id(load))
+    if isinstance(parent, ast.keyword) and parent.value is load:
+        call = parents.get(id(parent))
+        return isinstance(call, ast.Call) and _trailing_name(call.func) in wire_models
+    if not (isinstance(parent, ast.Dict) and any(value is load for value in parent.values)):
+        return False
+    returned = parents.get(id(parent))
+    if not (isinstance(returned, ast.Return) and returned.value is parent):
+        return False
+    owner = parents.get(id(returned))
+    while owner is not None and not isinstance(owner, (ast.FunctionDef, ast.AsyncFunctionDef)):
+        owner = parents.get(id(owner))
+    return owner is not None and bool(_annotation_names(owner.returns) & wire_models)
+
+
+def _annotation_names(node: ast.expr | None) -> frozenset[str]:
+    if node is None:
+        return frozenset()
+    if isinstance(node, ast.Constant) and isinstance(node.value, str):
+        try:
+            node = ast.parse(node.value.strip(), mode="eval").body
+        except SyntaxError:
+            return frozenset()
+    if isinstance(node, ast.BinOp) and isinstance(node.op, ast.BitOr):
+        return _annotation_names(node.left) | _annotation_names(node.right)
+    if isinstance(node, ast.Subscript) and _trailing_name(node.value) in {"Annotated", "Optional"}:
+        inner = node.slice.elts[0] if isinstance(node.slice, ast.Tuple) and node.slice.elts else node.slice
+        return _annotation_names(inner)
+    name = _trailing_name(node)
+    return frozenset({name}) if name is not None else frozenset()
+
+
+def _wire_model_class_names(tree: ast.Module, imports: ImportIndex) -> frozenset[str]:
+    """Resolve locally declared Pydantic and TypedDict wire models."""
+    classes = nodes(tree, ast.ClassDef)
+    by_name: dict[str, list[ast.ClassDef]] = {}
+    for node in classes:
+        by_name.setdefault(node.name, []).append(node)
+    resolved: dict[int, bool] = {}
+
+    def is_wire_model(node: ast.ClassDef, seen: frozenset[int]) -> bool:
+        cached = resolved.get(id(node))
+        if cached is not None:
+            return cached
+        if id(node) in seen:
+            return False
+        result = any(
+            imports.resolves(
+                base,
+                sources=frozenset(
+                    {
+                        "pydantic",
+                        "pydantic.main",
+                        "pydantic.v1",
+                        "pydantic.v1.main",
+                    }
+                ),
+                symbol="BaseModel",
+            )
+            or imports.resolves(
+                base,
+                sources=frozenset({"typing", "typing_extensions"}),
+                symbol="TypedDict",
+            )
+            or (
+                (base_name := _trailing_name(base)) is not None
+                and len(parents := by_name.get(base_name, ())) == 1
+                and is_wire_model(parents[0], seen | {id(node)})
+            )
+            for base in node.bases
+        )
+        resolved[id(node)] = result
+        return result
+
+    return frozenset(
+        name
+        for name, definitions in by_name.items()
+        if len(definitions) == 1 and is_wire_model(definitions[0], frozenset())
+    )
+
+
 def _has_cli_decorator(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
     """Report whether the function is a `click` / `typer` command entry point."""
     for dec in node.decorator_list: