sarj-python-lint 1.45.0__tar.gz → 1.45.2__tar.gz

{sarj_python_lint-1.45.0 → sarj_python_lint-1.45.2}/PKG-INFO

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

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

{sarj_python_lint-1.45.0 → sarj_python_lint-1.45.2}/src/sarj_python_lint/__main__.py

@@ -430,12 +430,26 @@ def _baseline_path(path: Path, *, root: Path | None = None) -> str:
 def _read_baseline(path: Path) -> dict[str, dict[str, int]]:
     raw = parse_json(path.read_text(encoding="utf-8"))
     if not is_object_mapping(raw):
-        return {}
+        msg = "baseline must be an object of file paths and diagnostic counts"
+        raise ValueError(msg)
     counts: dict[str, dict[str, int]] = {}
     for file_key, per_code in raw.items():
-        if not isinstance(file_key, str) or not is_object_mapping(per_code):
-            continue
-        counts[file_key] = {code: n for code, n in per_code.items() if isinstance(code, str) and isinstance(n, int)}
+        if not isinstance(file_key, str) or not file_key or not is_object_mapping(per_code):
+            msg = "baseline entries must map non-empty file paths to diagnostic counts"
+            raise ValueError(msg)
+        validated: dict[str, int] = {}
+        for code, count in per_code.items():
+            if (
+                not isinstance(code, str)
+                or not code
+                or not isinstance(count, int)
+                or isinstance(count, bool)
+                or count < 0
+            ):
+                msg = "baseline counts must map non-empty diagnostic codes to non-negative integers"
+                raise ValueError(msg)
+            validated[code] = count
+        counts[file_key] = validated
     return counts
 
 

sarj_python_lint-1.45.2/src/sarj_python_lint/json_boundary.py

@@ -0,0 +1,29 @@
+import json
+from typing import TypeIs
+
+
+def parse_json(text: str) -> object:
+    try:
+        return json.loads(text, object_pairs_hook=_unique_pairs, parse_constant=_invalid_constant)  # pyright: ignore[reportAny] -- untyped stdlib parser boundary.
+    except RecursionError as error:
+        message = "JSON nesting exceeds the supported depth"
+        raise ValueError(message) from error
+
+
+def _unique_pairs(pairs: list[tuple[str, object]]) -> dict[str, object]:
+    result: dict[str, object] = {}
+    for key, value in pairs:
+        if key in result:
+            message = f"duplicate JSON key: {key}"
+            raise ValueError(message)
+        result[key] = value
+    return result
+
+
+def _invalid_constant(value: str) -> None:
+    message = f"non-finite JSON constant: {value}"
+    raise ValueError(message)
+
+
+def is_object_mapping(value: object) -> TypeIs[dict[object, object]]:
+    return isinstance(value, dict)

{sarj_python_lint-1.45.0 → sarj_python_lint-1.45.2}/src/sarj_python_lint/ratchet.py

@@ -221,7 +221,7 @@ def seed(measurement: Measurement, baseline: Baseline) -> Baseline:
 def load_baseline(path: Path) -> Baseline:
     raw = parse_json(path.read_text(encoding="utf-8"))
     schema = _get(raw, "schema_version")
-    if schema is not None and schema != BASELINE_SCHEMA_VERSION:
+    if schema is not None and (type(schema) is not int or schema != BASELINE_SCHEMA_VERSION):
         msg = f"unsupported suppression baseline schema_version: {schema!r}"
         raise ValueError(msg)
     files = _get(raw, "files")

{sarj_python_lint-1.45.0 → sarj_python_lint-1.45.2}/src/sarj_python_lint/rules/no_tautological_expect.py

@@ -56,6 +56,7 @@ class NoTautologicalExpect(Rule):
             "Detection covers truthy scalar constants, definitely non-empty list/set/dict displays, and directly asserted generator expressions or lambdas.",
             "Generator consumption, lambda invocation, comprehensions, and runtime iterator/callable values are not inferred; empty universal-quantification contracts remain valid.",
             "Test-local immutable scalar bindings and their aliases are tracked only through straight-line assignments; calls, control flow, mutable values, and global/nonlocal writes invalidate tracking.",
+            "Pure Boolean conditions, compatible numeric/string/bytes ordering and chained comparisons over known scalar setup are evaluated; proven-true pure assertions retain bindings because their messages do not execute.",
             "Ruff owns asserted strings and tuples, literal comparisons and identity, and unittest-style assertion methods.",
             "Generated files, always-failing assertions, deliberate match-arm success markers, and runtime-value comparisons are excluded.",
         ),
@@ -196,12 +197,13 @@ def _function_bound_tautologies(function: ast.FunctionDef | ast.AsyncFunctionDef
     for statement in function.body:
         if _record_scalar_assignment(statement, bindings):
             continue
-        if isinstance(statement, ast.Assert):
+        if isinstance(statement, ast.Assert) and bindings and _scalar_condition(statement.test, bindings) is True:
             references_setup = any(
                 isinstance(node, ast.Name) and node.id in bindings for node in ast.walk(statement.test)
             )
-            if references_setup and _scalar_condition(statement.test, bindings) is True:
+            if references_setup:
                 found.append(_Tautology(statement, "the condition follows only from unchanged scalar setup"))
+            continue
         bindings.clear()
     return found
 
@@ -239,26 +241,59 @@ def _scalar_value(node: ast.expr, bindings: dict[str, object]) -> object:
 
 
 def _scalar_condition(node: ast.expr, bindings: dict[str, object]) -> bool | None:
-    if isinstance(node, ast.Compare) and len(node.ops) == 1:
-        left = _scalar_value(node.left, bindings)
-        right = _scalar_value(node.comparators[0], bindings)
-        if left is _UNKNOWN or right is _UNKNOWN:
+    if isinstance(node, ast.BoolOp):
+        values = [_scalar_condition(value, bindings) for value in node.values]
+        if None in values:
             return None
-        match node.ops[0]:
-            case ast.Eq():
-                return left == right
-            case ast.NotEq():
-                return left != right
-            case ast.Is() if left is None or isinstance(left, bool):
-                return left is right
-            case ast.IsNot() if left is None or isinstance(left, bool):
-                return left is not right
-            case _:
-                return None
+        return all(values) if isinstance(node.op, ast.And) else any(values)
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.Not):
+        value = _scalar_condition(node.operand, bindings)
+        return None if value is None else not value
+    if isinstance(node, ast.Compare):
+        values = [_scalar_value(value, bindings) for value in (node.left, *node.comparators)]
+        results = list(map(_scalar_relation, values[:-1], values[1:], node.ops, strict=True))
+        return None if None in results else all(results)
     value = _scalar_value(node, bindings)
     return None if value is _UNKNOWN else bool(value)
 
 
+def _scalar_relation(left: object, right: object, op: ast.cmpop) -> bool | None:
+    if left is _UNKNOWN or right is _UNKNOWN:
+        return None
+    match op:
+        case ast.Eq():
+            return left == right
+        case ast.NotEq():
+            return left != right
+        case ast.Is() if left is None or right is None or isinstance(left, bool) or isinstance(right, bool):
+            return left is right
+        case ast.IsNot() if left is None or right is None or isinstance(left, bool) or isinstance(right, bool):
+            return left is not right
+        case _:
+            pass
+    if isinstance(left, (int, float)) and isinstance(right, (int, float)):
+        return _ordered_relation(left, right, op)
+    if isinstance(left, str) and isinstance(right, str):
+        return _ordered_relation(left, right, op)
+    if isinstance(left, bytes) and isinstance(right, bytes):
+        return _ordered_relation(left, right, op)
+    return None
+
+
+def _ordered_relation[T: (int | float, str, bytes)](left: T, right: T, op: ast.cmpop) -> bool | None:
+    match op:
+        case ast.Lt():
+            return left < right
+        case ast.LtE():
+            return left <= right
+        case ast.Gt():
+            return left > right
+        case ast.GtE():
+            return left >= right
+        case _:
+            return None
+
+
 def _exempt_nodes(tree: ast.Module, *, node_index: NodeIndex | None = None) -> set[ast.AST]:
     exempt: set[ast.AST] = set()
     for node in walk_ast(tree, index=node_index):

{sarj_python_lint-1.45.0 → sarj_python_lint-1.45.2}/src/sarj_python_lint/rules/prefer_pytest_fixture_injection.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 import ast
 from collections import Counter
+from functools import cached_property
 from pathlib import PurePosixPath
-from typing import TYPE_CHECKING, ClassVar, NamedTuple, override
+from typing import TYPE_CHECKING, ClassVar, NamedTuple, final, override
 
 from sarj_python_lint.rule_base import (
     AutofixPolicy,
@@ -43,6 +44,34 @@ class _HelperImport(NamedTuple):
     level: int
 
 
+@final
+class _ModuleFacts:
+    def __init__(self, tree: ast.Module) -> None:
+        self.tree = tree
+
+    @cached_property
+    def bindings(self) -> Counter[str]:
+        return _scope_bindings(self.tree)
+
+    @cached_property
+    def writes(self) -> tuple[ast.Attribute | ast.Subscript, ...]:
+        return tuple(
+            node
+            for node in ast.walk(self.tree)
+            if isinstance(node, (ast.Attribute, ast.Subscript)) and isinstance(node.ctx, (ast.Store, ast.Del))
+        )
+
+    @cached_property
+    def mutated_roots(self) -> frozenset[str]:
+        return frozenset(root for node in self.writes if (root := _root_name(node.value)) is not None)
+
+    @cached_property
+    def references(self) -> frozenset[str]:
+        return frozenset(
+            node.id for node in ast.walk(self.tree) if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Load)
+        )
+
+
 class PreferPytestFixtureInjection(Rule):
     id: str = "prefer-pytest-fixture-injection"
     code: str = "SARJ476"
@@ -70,6 +99,7 @@ class PreferPytestFixtureInjection(Rule):
             "Async pools require an explicit literal open=False, no unpacked arguments, and no calls inside constructor arguments; opened or dynamically configured async pools need lifecycle-specific fixture design.",
             "Setup must be the first executable statement and immediately feed a plain call, or appear inline as a direct argument of that first call.",
             "Class tests, decorated helpers, unknown test decorators, dynamic imports, re-exports, and ambiguous or out-of-bound source paths are excluded.",
+            "Tests with statically visible callable references in any scope are excluded; scope-ambiguous references are handled conservatively.",
             "Command-line conftest discovery overrides and external pytest plugin registrations are not inferred.",
         ),
         examples=(
@@ -167,24 +197,23 @@ class PreferPytestFixtureInjection(Rule):
         ):
             return []
         tree = context.tree
-        helpers = _resource_helpers(context)
+        facts = _ModuleFacts(tree)
+        helpers = _resource_helpers(context, facts)
         if not helpers:
             return []
-        module_bindings = _scope_bindings(tree)
-        if "__test__" in module_bindings or any(
-            isinstance(node, ast.Attribute) and node.attr == "__test__" and isinstance(node.ctx, (ast.Store, ast.Del))
-            for node in ast.walk(tree)
+        if "__test__" in facts.bindings or any(
+            isinstance(node, ast.Attribute) and node.attr == "__test__" for node in facts.writes
         ):
             return []
         diagnostics: list[Diagnostic] = []
         for statement in tree.body:
             if (
                 not isinstance(statement, (ast.FunctionDef, ast.AsyncFunctionDef))
-                or module_bindings[statement.name] != 1
-                or _module_reference(tree, statement.name)
+                or facts.bindings[statement.name] != 1
+                or statement.name in facts.references
             ):
                 continue
-            call = _setup_call(context, statement, helpers)
+            call = _setup_call(context, statement, helpers, facts)
             if call is not None:
                 diagnostics.append(
                     Diagnostic(
@@ -205,17 +234,16 @@ class PreferPytestFixtureInjection(Rule):
         return diagnostics
 
 
-def _resource_helpers(context: PythonFileContext) -> frozenset[str]:
+def _resource_helpers(context: PythonFileContext, facts: _ModuleFacts) -> frozenset[str]:
     tree = context.tree
     if tree is None:
         return frozenset()
     references = tuple(_helper_imports(tree))
     if not references:
         return frozenset()
-    bindings = _scope_bindings(tree)
     helpers: set[str] = set()
     for reference in references:
-        if bindings[reference.local] != 1 or _root_mutated(tree, reference.local):
+        if facts.bindings[reference.local] != 1 or reference.local in facts.mutated_roots:
             continue
         target = context.session.local_source.resolve_module(
             context.path, reference.module, reference.level, facts=context.session.first_party
@@ -249,11 +277,12 @@ def _helper_imports(tree: ast.Module) -> Iterator[_HelperImport]:
 
 
 def _is_resource_helper(module: LocalModule, symbol: str) -> bool:
+    facts = _ModuleFacts(module.tree)
     if (
         is_generated(module.path, module.source)
-        or _scope_bindings(module.tree)[symbol] != 1
+        or facts.bindings[symbol] != 1
         or _has_wildcard(module.tree)
-        or _root_mutated(module.tree, symbol)
+        or symbol in facts.mutated_roots
     ):
         return False
     helper = next(
@@ -275,8 +304,8 @@ def _is_resource_helper(module: LocalModule, symbol: str) -> bool:
     qualified = module.runtime_imports.resolved_qualified_name(constructor)
     return (
         root is not None
-        and _scope_bindings(module.tree)[root] == 1
-        and not _root_mutated(module.tree, root)
+        and facts.bindings[root] == 1
+        and root not in facts.mutated_roots
         and qualified in _POOL_CONSTRUCTORS
         and (qualified != "psycopg_pool.AsyncConnectionPool" or _unopened_async_allocation(allocation))
     )
@@ -294,9 +323,11 @@ def _unopened_async_allocation(allocation: ast.Call) -> bool:
     )
 
 
-def _setup_call(context: PythonFileContext, function: Function, helpers: frozenset[str]) -> ast.Call | None:
+def _setup_call(
+    context: PythonFileContext, function: Function, helpers: frozenset[str], facts: _ModuleFacts
+) -> ast.Call | None:
     if not function.name.startswith("test_") or any(
-        not _pytest_mark(context, decorator) for decorator in function.decorator_list
+        not _pytest_mark(context, decorator, facts) for decorator in function.decorator_list
     ):
         return None
     bindings = _scope_bindings(function)
@@ -313,21 +344,21 @@ def _setup_call(context: PythonFileContext, function: Function, helpers: frozens
     if setup is None:
         return None
     if _helper_call(setup, available):
-        return _assigned_dependency_call(context, body, bindings, setup)
-    if not _unshadowed_consumer(context, setup, bindings):
+        return _assigned_dependency_call(body, bindings, setup, facts)
+    if not _unshadowed_consumer(setup, bindings, facts):
         return None
     inline = [arg for arg in _arguments(setup) if isinstance(arg, ast.Call) and _helper_call(arg, available)]
     return inline[0] if len(inline) == 1 else None
 
 
 def _assigned_dependency_call(
-    context: PythonFileContext, body: list[ast.stmt], bindings: Counter[str], setup: ast.Call
+    body: list[ast.stmt], bindings: Counter[str], setup: ast.Call, facts: _ModuleFacts
 ) -> ast.Call | None:
     resource = _assignment_name(body[0])
     if resource is None or bindings[resource] != 1 or len(body) < _SETUP_AND_CONSUMER:
         return None
     consumer = _plain_call(body[1])
-    if consumer is None or not _unshadowed_consumer(context, consumer, bindings):
+    if consumer is None or not _unshadowed_consumer(consumer, bindings, facts):
         return None
     for argument in _arguments(consumer):
         if isinstance(argument, ast.Name) and argument.id == resource:
@@ -335,7 +366,7 @@ def _assigned_dependency_call(
     return None
 
 
-def _pytest_mark(context: PythonFileContext, decorator: ast.expr) -> bool:
+def _pytest_mark(context: PythonFileContext, decorator: ast.expr, facts: _ModuleFacts) -> bool:
     target = decorator.func if isinstance(decorator, ast.Call) else decorator
     qualified = context.module_imports.resolved_qualified_name(target)
     tree = context.tree
@@ -345,12 +376,10 @@ def _pytest_mark(context: PythonFileContext, decorator: ast.expr) -> bool:
         or not qualified.startswith("pytest.mark.")
         or tree is None
         or root is None
-        or _scope_bindings(tree)[root] != 1
+        or facts.bindings[root] != 1
     ):
         return False
-    for node in ast.walk(tree):
-        if not isinstance(node, (ast.Attribute, ast.Subscript)) or not isinstance(node.ctx, (ast.Store, ast.Del)):
-            continue
+    for node in facts.writes:
         if isinstance(node, ast.Subscript) and _root_name(node.value) == root:
             return False
         changed = context.module_imports.resolved_qualified_name(node)
@@ -359,25 +388,9 @@ def _pytest_mark(context: PythonFileContext, decorator: ast.expr) -> bool:
     return True
 
 
-def _unshadowed_consumer(context: PythonFileContext, call: ast.Call, bindings: Counter[str]) -> bool:
+def _unshadowed_consumer(call: ast.Call, bindings: Counter[str], facts: _ModuleFacts) -> bool:
     root = _root_name(call.func)
-    tree = context.tree
-    return (
-        root is not None
-        and root not in bindings
-        and tree is not None
-        and _scope_bindings(tree)[root] <= 1
-        and not _root_mutated(tree, root)
-    )
-
-
-def _module_reference(tree: ast.Module, name: str) -> bool:
-    return any(
-        isinstance(node, ast.Name) and node.id == name and isinstance(node.ctx, ast.Load)
-        for statement in tree.body
-        if not isinstance(statement, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef))
-        for node in ast.walk(statement)
-    )
+    return root is not None and root not in bindings and facts.bindings[root] <= 1 and root not in facts.mutated_roots
 
 
 def _helper_call(call: ast.Call, helpers: frozenset[str] | set[str]) -> bool:
@@ -509,12 +522,3 @@ def _has_wildcard(tree: ast.Module) -> bool:
     return any(
         isinstance(node, ast.ImportFrom) and any(alias.name == "*" for alias in node.names) for node in ast.walk(tree)
     )
-
-
-def _root_mutated(tree: ast.Module, root: str) -> bool:
-    return any(
-        isinstance(node, (ast.Attribute, ast.Subscript))
-        and isinstance(node.ctx, (ast.Store, ast.Del))
-        and _root_name(node.value) == root
-        for node in ast.walk(tree)
-    )

sarj_python_lint-1.45.0/src/sarj_python_lint/json_boundary.py

@@ -1,10 +0,0 @@
-import json
-from typing import TypeIs
-
-
-def parse_json(text: str) -> object:
-    return json.loads(text)  # pyright: ignore[reportAny] -- untyped stdlib parser boundary.
-
-
-def is_object_mapping(value: object) -> TypeIs[dict[object, object]]:
-    return isinstance(value, dict)