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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "0.81.5"
+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.5 → 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.5 → 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.5 → 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.5 → 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.5 → 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.5 → 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.5 → 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)