sarj-python-lint 0.81.4__tar.gz → 0.81.6__tar.gz

{sarj_python_lint-0.81.4 → sarj_python_lint-0.81.6}/PKG-INFO

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

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

{sarj_python_lint-0.81.4 → sarj_python_lint-0.81.6}/src/sarj_python_lint/rules/complex_postgres_query_requires_architecture_review.py

@@ -200,7 +200,7 @@ def _query_argument(call: ast.Call) -> ast.expr | None:
     tokens = frozenset(part for part in receiver.split("_") if part)
     if (
         receiver not in _QUERY_RECEIVER_TOKENS
-        and not tokens.intersection(_QUERY_RECEIVER_TOKENS)
+        and tokens.isdisjoint(_QUERY_RECEIVER_TOKENS)
         and not any(receiver.endswith(suffix) for suffix in ("conn", "cur", "cursor", "session"))
     ):
         return None

{sarj_python_lint-0.81.4 → sarj_python_lint-0.81.6}/src/sarj_python_lint/rules/no_raw_source_text_test_oracle.py

@@ -761,7 +761,7 @@ def _representation_fixture_path(node: ast.AST) -> bool:
         if not isinstance(child, ast.Constant) or not isinstance(child.value, str):
             continue
         parts = {part.lower() for part in child.value.replace("\\", "/").split("/")}
-        if parts & _REPRESENTATION_DIRS:
+        if not parts.isdisjoint(_REPRESENTATION_DIRS):
             return True
     return False
 

{sarj_python_lint-0.81.4 → sarj_python_lint-0.81.6}/src/sarj_python_lint/rules/no_typed_doc_sections.py

@@ -121,7 +121,7 @@ def _public_contract_docstring_lines(path: Path, source: str) -> frozenset[int]:
         protocol_method = isinstance(owner, ast.ClassDef) and any(
             _terminal_name(base) in _PUBLIC_CONTRACT_BASES for base in owner.bases
         )
-        if decorators & _PUBLIC_CONTRACT_DECORATORS or protocol_method:
+        if not decorators.isdisjoint(_PUBLIC_CONTRACT_DECORATORS) or protocol_method:
             excluded.add(first.lineno)
     return frozenset(excluded)
 

{sarj_python_lint-0.81.4 → sarj_python_lint-0.81.6}/src/sarj_python_lint/rules/no_unnecessary_docstring.py

@@ -647,7 +647,7 @@ def _schema_docstring_consumers(tree: ast.Module, imports: dict[str, str]) -> fr
                 _resolve_imported_name(base.value if isinstance(base, ast.Subscript) else base, imports)
                 for base in class_node.bases
             }
-            if base_names & (_KNOWN_SCHEMA_BASES | consumed):
+            if not base_names.isdisjoint(_KNOWN_SCHEMA_BASES | consumed):
                 consumed.add(name)
                 changed = True
     return frozenset(id(classes[name]) for name in consumed)

{sarj_python_lint-0.81.4 → sarj_python_lint-0.81.6}/src/sarj_python_lint/rules/prefer_class_row.py

@@ -36,6 +36,7 @@ _SCOPE_NODES = (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)
 class _BoundCursor(NamedTuple):
     variable: str
     factory: ast.expr
+    active_nodes: tuple[ast.AST, ...]
 
 
 class _FetchedValue(NamedTuple):
@@ -73,7 +74,7 @@ class PreferClassRow(Rule):
                 files=(
                     ExampleFile.python(
                         "app/task_store.py",
-                        "from psycopg.rows import dict_row\n\nasync def load(conn):\n    async with conn.cursor(row_factory=dict_row) as cursor:\n        row = await cursor.fetchone()\n        return Task.model_validate(row)\n",
+                        'from psycopg.rows import dict_row\n\nasync def load(conn):\n    async with conn.cursor(row_factory=dict_row) as cursor:\n        await cursor.execute("SELECT id, state FROM task")\n        row = await cursor.fetchone()\n        return Task.model_validate(row)\n',
                     ),
                 ),
                 focus_path=PurePosixPath("app/task_store.py"),
@@ -112,7 +113,7 @@ class PreferClassRow(Rule):
             for cursor in _bound_cursors(function):
                 if not imports.is_dict_row(cursor.factory, shadowed):
                     continue
-                models = _models_built_from_cursor(function, cursor.variable)
+                models = _models_built_from_cursor(cursor)
                 if len(models) != 1:
                     continue
                 model = next(iter(models))
@@ -247,37 +248,78 @@ def _functions(tree: ast.Module) -> Iterator[ast.FunctionDef | ast.AsyncFunction
     return (node for node in ast.walk(tree) if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)))
 
 
-def _scope_nodes(function: ast.FunctionDef | ast.AsyncFunctionDef) -> Iterator[ast.AST]:
-    pending: list[ast.AST] = list(reversed(function.body))
-    while pending:
-        node = pending.pop()
-        yield node
-        if isinstance(node, _SCOPE_NODES):
-            continue
-        pending.extend(reversed(list(ast.iter_child_nodes(node))))
-
-
 def _bound_cursors(function: ast.FunctionDef | ast.AsyncFunctionDef) -> list[_BoundCursor]:
+    scoped_nodes = tuple(_nodes_in(function.body))
     cursors: list[_BoundCursor] = []
-    for node in _scope_nodes(function):
+    for node in scoped_nodes:
         if isinstance(node, (ast.With, ast.AsyncWith)):
             for item in node.items:
                 if isinstance(item.optional_vars, ast.Name):
-                    cursor = _cursor(item.context_expr, item.optional_vars.id)
+                    active_nodes = _active_nodes(tuple(_nodes_in(node.body)), item.optional_vars.id, node.lineno)
+                    cursor = _cursor(item.context_expr, item.optional_vars.id, active_nodes)
                     if cursor is not None:
                         cursors.append(cursor)
         elif isinstance(node, ast.Assign) and len(node.targets) == 1 and isinstance(node.targets[0], ast.Name):
-            cursor = _cursor(node.value, node.targets[0].id)
+            variable = node.targets[0].id
+            cursor = _cursor(node.value, variable, _active_nodes(scoped_nodes, variable, node.lineno))
             if cursor is not None:
                 cursors.append(cursor)
         elif isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name) and node.value is not None:
-            cursor = _cursor(node.value, node.target.id)
+            cursor = _cursor(
+                node.value,
+                node.target.id,
+                _active_nodes(scoped_nodes, node.target.id, node.lineno),
+            )
             if cursor is not None:
                 cursors.append(cursor)
     return cursors
 
 
-def _cursor(expression: ast.expr, variable: str) -> _BoundCursor | None:
+def _nodes_in(statements: Iterable[ast.stmt]) -> Iterator[ast.AST]:
+    pending: list[ast.AST] = list(reversed(tuple(statements)))
+    while pending:
+        node = pending.pop()
+        yield node
+        if isinstance(node, _SCOPE_NODES):
+            continue
+        pending.extend(reversed(list(ast.iter_child_nodes(node))))
+
+
+def _active_nodes(nodes: tuple[ast.AST, ...], variable: str, start: int) -> tuple[ast.AST, ...]:
+    rebound_lines = [
+        node.lineno
+        for node in nodes
+        if isinstance(node, ast.stmt) and node.lineno > start and _binds_name(node, variable)
+    ]
+    end = min(rebound_lines, default=None)
+    return tuple(
+        node
+        for node in nodes
+        if getattr(node, "lineno", start) > start and (end is None or getattr(node, "lineno", end) < end)
+    )
+
+
+def _binds_name(node: ast.stmt, name: str) -> bool:
+    if _writes_name(node, name):
+        return True
+    match node:
+        case ast.FunctionDef() | ast.AsyncFunctionDef() | ast.ClassDef():
+            return node.name == name
+        case ast.For() | ast.AsyncFor():
+            return _target_root(node.target) == name
+        case ast.With() | ast.AsyncWith():
+            return any(
+                item.optional_vars is not None and _target_root(item.optional_vars) == name for item in node.items
+            )
+        case ast.Import():
+            return any((alias.asname or alias.name.partition(".")[0]) == name for alias in node.names)
+        case ast.ImportFrom():
+            return any((alias.asname or alias.name) == name for alias in node.names)
+        case _:
+            return False
+
+
+def _cursor(expression: ast.expr, variable: str, active_nodes: tuple[ast.AST, ...]) -> _BoundCursor | None:
     if not (
         isinstance(expression, ast.Call)
         and isinstance(expression.func, ast.Attribute)
@@ -285,18 +327,15 @@ def _cursor(expression: ast.expr, variable: str) -> _BoundCursor | None:
     ):
         return None
     factory = next((keyword.value for keyword in expression.keywords if keyword.arg == _ROW_FACTORY), None)
-    return None if factory is None else _BoundCursor(variable, factory)
+    return None if factory is None else _BoundCursor(variable, factory, active_nodes)
 
 
 def _models_built_from_cursor(
-    function: ast.FunctionDef | ast.AsyncFunctionDef,
-    cursor: str,
+    cursor: _BoundCursor,
 ) -> frozenset[str]:
-    scoped_nodes = list(_scope_nodes(function))
-    fetched_values = _fetched_values(scoped_nodes, cursor)
-    if not fetched_values:
-        return frozenset()
-    models: set[str] = set()
+    scoped_nodes = list(cursor.active_nodes)
+    fetched_values = _fetched_values(scoped_nodes, cursor.variable)
+    models = _models_from_direct_fetch(scoped_nodes, cursor.variable)
     for fetched in fetched_values:
         if fetched.many:
             converted = _models_from_collection(scoped_nodes, fetched)
@@ -308,6 +347,27 @@ def _models_built_from_cursor(
     return frozenset(models)
 
 
+def _models_from_direct_fetch(scoped_nodes: list[ast.AST], cursor: str) -> set[str]:
+    models: set[str] = set()
+    for node in scoped_nodes:
+        if not isinstance(node, ast.Call):
+            continue
+        if isinstance(node.func, ast.Attribute) and node.func.attr == _MODEL_VALIDATE:
+            if len(node.args) != 1 or node.keywords or _fetch_method(node.args[0], cursor) != "fetchone":
+                continue
+            model = _model_name(node.func.value)
+        else:
+            direct_rows = [
+                keyword.value
+                for keyword in node.keywords
+                if keyword.arg is None and _fetch_method(keyword.value, cursor) == "fetchone"
+            ]
+            model = _model_name(node.func) if len(direct_rows) == 1 else None
+        if model is not None:
+            models.add(model)
+    return models
+
+
 def _fetched_values(scoped_nodes: list[ast.AST], cursor: str) -> list[_FetchedValue]:
     fetched: list[_FetchedValue] = []
     for node in scoped_nodes:

{sarj_python_lint-0.81.4 → sarj_python_lint-0.81.6}/src/sarj_python_lint/rules/prefer_constant_time_secret_compare.py

@@ -299,15 +299,15 @@ def _name_role(identifier: str) -> _Role:
 def _is_authenticator_name(identifier: str) -> bool:
     tokens = identifier_tokens(identifier)
     token_set = set(tokens)
-    is_auth_header = "header" in token_set and bool(token_set & {"auth", "authorization"})
+    is_auth_header = "header" in token_set and not token_set.isdisjoint({"auth", "authorization"})
     if not is_secret_name(identifier) and not is_auth_header:
         return False
     if (token_set == {"token"} and not identifier.isupper()) or not tokens:
         return False
-    if tokens[-1] in _DESCRIPTOR_WORDS or token_set & _CATEGORY_WORDS:
+    if tokens[-1] in _DESCRIPTOR_WORDS or not token_set.isdisjoint(_CATEGORY_WORDS):
         return False
-    return bool(
-        token_set & _AUTH_WORDS
+    return (
+        not token_set.isdisjoint(_AUTH_WORDS)
         or is_auth_header
         or any(left == "api" and right == "key" for left, right in pairwise(tokens))
     )

{sarj_python_lint-0.81.4 → sarj_python_lint-0.81.6}/src/sarj_python_lint/rules/prefer_self_documenting_constant.py

@@ -431,7 +431,7 @@ def _missing_unit(statement: ast.Assign | ast.AnnAssign, name: str, comment: str
     # A name carrying a different unit is contradictory, but appending a second
     # suffix would worsen it; leave the conflict to a dedicated future rule.
     mentioned_name_tokens = frozenset(token for unit in mentioned for token in unit.name_tokens)
-    if declaration_tokens & (_CONFLICT_UNIT_NAME_TOKENS - mentioned_name_tokens):
+    if not declaration_tokens.isdisjoint(_CONFLICT_UNIT_NAME_TOKENS - mentioned_name_tokens):
         return None
     # A rationale can mention several quantities; once the name identifies one,
     # guessing that another quantity is the assigned value is unsafe.

{sarj_python_lint-0.81.4 → sarj_python_lint-0.81.6}/src/sarj_python_lint/rules/prefer_set_isdisjoint.py

@@ -23,6 +23,24 @@ if TYPE_CHECKING:
     from pathlib import Path
 
 
+_TRACKED_BUILTINS = frozenset(
+    {
+        "bool",
+        "dict",
+        "enumerate",
+        "filter",
+        "frozenset",
+        "list",
+        "map",
+        "range",
+        "reversed",
+        "set",
+        "tuple",
+        "zip",
+    }
+)
+
+
 @final
 class PreferSetIsdisjoint(Rule):
     id = "prefer-set-isdisjoint"
@@ -35,7 +53,7 @@ class PreferSetIsdisjoint(Rule):
         autofix=AutofixPolicy.SUGGESTION,
         limitations=(
             "Built-in set identity must be proven from a literal, comprehension, constructor, or one dominating local assignment.",
-            "Both intersection operands must be proven built-in sets; annotations, parameters, attributes, subclasses, branch-merged bindings, stored intersections, and generated files are excluded.",
+            "For binary `&`, the left operand must be a proven built-in set and the right operand must be a literal, comprehension, built-in iterable constructor, standard no-argument collection view, or proven set; annotations, parameters, attributes, subclasses, branch-merged bindings, stored intersections, and generated files are excluded.",
             "The suggestion is intentionally not an autofix because short-circuiting may make custom element equality or hashing side effects observable.",
         ),
         examples=(
@@ -185,6 +203,8 @@ class _Scanner:
         if isinstance(expression, ast.UnaryOp) and isinstance(expression.op, ast.Not):
             negated = True
             candidate = expression.operand
+        if isinstance(candidate, ast.Call) and _is_builtin_bool_call(candidate, self.shadowed):
+            candidate = candidate.args[0]
         if _is_intersection(candidate, safe_exact, self.shadowed):
             self._report(candidate, negated=negated)
 
@@ -246,7 +266,7 @@ class _Scanner:
 
 def _is_intersection(node: ast.expr, exact: set[str], shadowed: frozenset[str]) -> bool:
     if isinstance(node, ast.BinOp) and isinstance(node.op, ast.BitAnd):
-        return _is_exact_set(node.left, exact, shadowed) and _is_exact_set(node.right, exact, shadowed)
+        return _is_exact_set(node.left, exact, shadowed) and _is_proven_iterable(node.right, exact, shadowed)
     return (
         isinstance(node, ast.Call)
         and isinstance(node.func, ast.Attribute)
@@ -254,7 +274,17 @@ def _is_intersection(node: ast.expr, exact: set[str], shadowed: frozenset[str])
         and len(node.args) == 1
         and not node.keywords
         and _is_exact_set(node.func.value, exact, shadowed)
-        and _is_exact_set(node.args[0], exact, shadowed)
+    )
+
+
+def _is_builtin_bool_call(node: ast.expr, shadowed: frozenset[str]) -> bool:
+    return (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "bool"
+        and node.func.id not in shadowed
+        and len(node.args) == 1
+        and not node.keywords
     )
 
 
@@ -273,6 +303,30 @@ def _is_exact_set(node: ast.expr, exact: set[str], shadowed: frozenset[str]) ->
     )
 
 
+def _is_proven_iterable(node: ast.expr, exact: set[str], shadowed: frozenset[str]) -> bool:
+    if _is_exact_set(node, exact, shadowed):
+        return True
+    if isinstance(
+        node,
+        ast.List | ast.Tuple | ast.Dict | ast.ListComp | ast.DictComp | ast.GeneratorExp | ast.Constant,
+    ):
+        return not isinstance(node, ast.Constant) or isinstance(node.value, str | bytes)
+    if (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Attribute)
+        and node.func.attr in {"items", "keys", "values"}
+        and not node.args
+        and not node.keywords
+    ):
+        return True
+    return (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id in {"dict", "enumerate", "filter", "list", "map", "range", "reversed", "tuple", "zip"}
+        and node.func.id not in shadowed
+    )
+
+
 def _stored_names(node: ast.AST) -> set[str]:
     return {child.id for child in ast.walk(node) if isinstance(child, ast.Name) and isinstance(child.ctx, ast.Store)}
 
@@ -297,10 +351,10 @@ def _argument_names(arguments: ast.arguments) -> set[str]:
 def _shadowed_builtins(tree: ast.Module) -> frozenset[str]:
     shadowed: set[str] = set()
     for node in ast.walk(tree):
-        if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Store) and node.id in {"set", "frozenset"}:
+        if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Store) and node.id in _TRACKED_BUILTINS:
             shadowed.add(node.id)
-        elif isinstance(node, ast.arg) and node.arg in {"set", "frozenset"}:
+        elif isinstance(node, ast.arg) and node.arg in _TRACKED_BUILTINS:
             shadowed.add(node.arg)
-        elif isinstance(node, ast.alias) and (node.asname or node.name.split(".")[0]) in {"set", "frozenset"}:
+        elif isinstance(node, ast.alias) and (node.asname or node.name.split(".")[0]) in _TRACKED_BUILTINS:
             shadowed.add(node.asname or node.name.split(".")[0])
     return frozenset(shadowed)