sarj-python-lint 1.35.0__tar.gz → 1.36.0__tar.gz

{sarj_python_lint-1.35.0 → sarj_python_lint-1.36.0}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "1.35.0"
+version = "1.36.0"
 description = "Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults"
 readme = "README.md"
 authors = [{ name = "sarj-ai" }]
@@ -30,6 +30,7 @@ Issues = "https://github.com/sarj-ai/code-standards/issues"
 
 [dependency-groups]
 dev = [
+  "pydantic==2.14.1",
   "pytest>=9.1.1",
   "ruff>=0.17.0",
   "basedpyright>=1.40.2",

{sarj_python_lint-1.35.0 → sarj_python_lint-1.36.0}/src/sarj_python_lint/rules/_ast_index.py

@@ -29,6 +29,10 @@ def children(node: ast.AST) -> list[ast.AST]:
     return out
 
 
+def comprehension_results(node: ast.ListComp | ast.SetComp | ast.DictComp | ast.GeneratorExp) -> list[ast.expr]:
+    return [child for child in children(node) if isinstance(child, ast.expr)]
+
+
 def walk(node: ast.AST, *, index: NodeIndex | None = None) -> Iterator[ast.AST]:
     if index is not None and index.tree is node:
         yield from index.query((ast.AST,))

{sarj_python_lint-1.35.0 → sarj_python_lint-1.36.0}/src/sarj_python_lint/rules/_copy_on_write.py

@@ -9,6 +9,7 @@ from typing import TYPE_CHECKING, final
 from sarj_python_lint._analysis_session import AnalysisSession
 from sarj_python_lint._file_context import PythonFileContext
 from sarj_python_lint.rules._annotation_semantics import AnnotationSemantics, scope_bound_names
+from sarj_python_lint.rules._ast_index import comprehension_results
 from sarj_python_lint.rules._closed_helpers import plain_class_members
 from sarj_python_lint.rules._imports import ImportIndex
 from sarj_python_lint.rules._project_index import ProjectIndexSet, SourceUnit, SymbolRef, imports_outside
@@ -695,11 +696,8 @@ class CopyOnWriteAnalysis:
             self._bind(generator.target, self._iter_element(generator.iter, local), local)
             for condition in generator.ifs:
                 self._expression(condition, local)
-        if isinstance(node, ast.DictComp):
-            self._expression(node.key, local)
-            self._expression(node.value, local)
-        else:
-            self._expression(node.elt, local)
+        for child in comprehension_results(node):
+            self._expression(child, local)
 
     def _iter_element(self, expression: ast.expr, bindings: Mapping[str, _Value]) -> _Value | None:
         owner = self._value(expression, bindings)

{sarj_python_lint-1.35.0 → sarj_python_lint-1.36.0}/src/sarj_python_lint/rules/_imports.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass
 from types import MappingProxyType
 from typing import Self
 
-from sarj_python_lint.rules._ast_index import walk as walk_ast
+from sarj_python_lint.rules._ast_index import comprehension_results, walk as walk_ast
 
 
 ABC_SOURCES = frozenset({"abc"})
@@ -138,13 +138,9 @@ def _collect_module_bindings(node: ast.AST, names: set[str]) -> None:
         case ast.FunctionDef() | ast.AsyncFunctionDef() | ast.ClassDef():
             names.add(node.name)
             return
-        case ast.ListComp() | ast.SetComp() | ast.GeneratorExp():
-            _collect_module_bindings(node.elt, names)
-            _collect_comprehension_bindings(node.generators, names)
-            return
-        case ast.DictComp():
-            _collect_module_bindings(node.key, names)
-            _collect_module_bindings(node.value, names)
+        case ast.ListComp() | ast.SetComp() | ast.GeneratorExp() | ast.DictComp():
+            for result in comprehension_results(node):
+                _collect_module_bindings(result, names)
             _collect_comprehension_bindings(node.generators, names)
             return
         case ast.Lambda():

{sarj_python_lint-1.35.0 → sarj_python_lint-1.36.0}/src/sarj_python_lint/rules/_pydantic_field_contract.py

@@ -25,6 +25,8 @@ DECORATOR_SOURCES = frozenset({"pydantic", "pydantic.functional_validators", "py
 TYPING_SOURCES = frozenset({"typing", "typing_extensions"})
 _ALIAS_VERSION = Version("2.11")
 _BUILTIN_BINDINGS = frozenset({"int", "float", "str", "list", "classmethod", "staticmethod"})
+_GENERIC_BUILTINS = frozenset({"dict", "frozenset", "list", "set", "tuple", "type"})
+_BUILTIN_SOURCES = frozenset({"builtins"})
 _SENSITIVE_MODULES = frozenset({"pydantic", "typing", "typing_extensions", "builtins"})
 
 
@@ -76,6 +78,8 @@ def _plain_member(node: ast.stmt, context: PythonFileContext, provenance: Resour
 
 
 def inert_annotation(node: ast.expr, context: PythonFileContext) -> bool:
+    if isinstance(node, (ast.Tuple, ast.List)):
+        return all(inert_annotation(element, context) for element in node.elts)
     if isinstance(node, ast.Constant) and isinstance(node.value, str):
         try:
             node = ast.parse(node.value, mode="eval").body
@@ -104,6 +108,8 @@ def inert_signature(node: ast.FunctionDef | ast.AsyncFunctionDef, context: Pytho
 
 
 def _inert_expr(node: ast.AST, context: PythonFileContext) -> bool:
+    if isinstance(node, ast.Subscript) and not _inert_subscription(node, context):
+        return False
     if isinstance(node, ast.Lambda):
         return not node.args.defaults and not node.args.kw_defaults
     if isinstance(node, ast.Call):
@@ -121,12 +127,41 @@ def _inert_expr(node: ast.AST, context: PythonFileContext) -> bool:
             return False
     if isinstance(
         node,
-        (ast.NamedExpr, ast.Await, ast.Yield, ast.YieldFrom, ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp),
+        (
+            ast.NamedExpr,
+            ast.Starred,
+            ast.Await,
+            ast.Yield,
+            ast.YieldFrom,
+            ast.ListComp,
+            ast.SetComp,
+            ast.DictComp,
+            ast.GeneratorExp,
+        ),
     ):
         return False
     return all(_inert_expr(child, context) for child in ast.iter_child_nodes(node))
 
 
+def _inert_subscription(node: ast.Subscript, context: PythonFileContext) -> bool:
+    symbol = context.imports.resolved_symbol(node.value, sources=TYPING_SOURCES)
+    if symbol is None and not (
+        (
+            isinstance(node.value, ast.Name)
+            and node.value.id in _GENERIC_BUILTINS
+            and context.imports.builtin_is_unshadowed(node.value.id)
+        )
+        or context.imports.resolved_symbol(node.value, sources=_BUILTIN_SOURCES) in _GENERIC_BUILTINS
+    ):
+        return False
+    arguments = node.slice.elts if isinstance(node.slice, ast.Tuple) else [node.slice]
+    if symbol == "Literal":
+        return True
+    if symbol == "Annotated":
+        return bool(arguments) and inert_annotation(arguments[0], context)
+    return all(inert_annotation(argument, context) for argument in arguments)
+
+
 def literal_value(value: ast.expr) -> bool:
     if any(isinstance(node, ast.Call) for node in ast.walk(value)):
         return False

{sarj_python_lint-1.35.0 → sarj_python_lint-1.36.0}/src/sarj_python_lint/rules/no_any_mapping_types.py

@@ -4,6 +4,7 @@ import ast
 from collections.abc import Mapping
 from dataclasses import dataclass
 from pathlib import PurePosixPath
+import re
 from typing import TYPE_CHECKING, ClassVar, final, override
 
 from sarj_python_lint.rule_base import (
@@ -38,6 +39,7 @@ _MAPPING_NAMES = frozenset({"dict", "Dict", "Mapping", "MutableMapping"})
 _MAPPING_ARGUMENT_COUNT = 2
 _BUILTIN_TYPE_CONTAINERS = frozenset({"dict", "list", "set", "frozenset", "tuple", "type"})
 _TYPE_MODULES = frozenset({"typing", "typing_extensions", "pydantic", "collections", "builtins"})
+_TYPE_COMMENT_MARKER = re.compile(r"#\s*type:")
 
 
 @dataclass(frozen=True, slots=True)
@@ -125,9 +127,14 @@ class NoAnyMappingTypes(Rule):
         source = context.source
         if context.generated or _is_vendor_path(path):
             return []
-        try:
-            tree = ast.parse(source, filename=str(path), type_comments=True)
-        except SyntaxError:
+        if _TYPE_COMMENT_MARKER.search(source) is None:
+            tree = context.tree
+        else:
+            try:
+                tree = ast.parse(source, filename=str(path), type_comments=True)
+            except SyntaxError:
+                return []
+        if tree is None:
             return []
         semantics = AnnotationSemantics.from_tree(tree)
         imports = semantics.imports

{sarj_python_lint-1.35.0 → sarj_python_lint-1.36.0}/src/sarj_python_lint/rules/no_dunder_all.py

@@ -14,6 +14,7 @@ from sarj_python_lint.rule_base import (
     RuleDocumentation,
     RuleExample,
 )
+from sarj_python_lint.rules._ast_index import comprehension_results
 
 
 if TYPE_CHECKING:
@@ -344,11 +345,8 @@ class _DunderAllVisitor(_ScopePruningVisitor):
         self.generic_visit(node)
 
     def _visit_comprehension(self, node: ast.ListComp | ast.SetComp | ast.DictComp | ast.GeneratorExp) -> None:
-        if isinstance(node, ast.DictComp):
-            self.visit(node.key)
-            self.visit(node.value)
-        else:
-            self.visit(node.elt)
+        for result in comprehension_results(node):
+            self.visit(result)
         for generator in node.generators:
             self.visit(generator.iter)
             for condition in generator.ifs:

{sarj_python_lint-1.35.0 → sarj_python_lint-1.36.0}/src/sarj_python_lint/rules/no_excessive_cognitive_complexity.py

@@ -15,7 +15,7 @@ from sarj_python_lint.rule_base import (
     RuleExample,
     Severity,
 )
-from sarj_python_lint.rules._ast_index import children
+from sarj_python_lint.rules._ast_index import children, comprehension_results
 
 
 if TYPE_CHECKING:
@@ -154,8 +154,7 @@ class _Complexity:
                 self.add(condition, nesting, "comprehension filter")
                 self.visit(condition, nesting)
                 nesting += 1
-        values = (node.key, node.value) if isinstance(node, ast.DictComp) else (node.elt,)
-        self.visit_all(values, nesting)
+        self.visit_all(comprehension_results(node), nesting)
 
 
 @final

{sarj_python_lint-1.35.0 → sarj_python_lint-1.36.0}/src/sarj_python_lint/rules/no_hidden_constructor_fallback.py

@@ -18,6 +18,7 @@ from sarj_python_lint.rule_base import (
     RuleExample,
     Severity,
 )
+from sarj_python_lint.rules._ast_index import comprehension_results
 from sarj_python_lint.rules._first_party import FirstPartyFacts, distribution_root
 from sarj_python_lint.rules._paths import is_generated, is_test_path
 
@@ -870,8 +871,8 @@ def _calls_with_shadowing(
         case ast.ListComp() | ast.SetComp() | ast.GeneratorExp():
             yield from _comprehension_calls(node.generators, (node.elt,), shadowed, nested_scope_base)
             return
-        case ast.DictComp(generators=generators, key=key, value=value):
-            yield from _comprehension_calls(generators, (key, value), shadowed, nested_scope_base)
+        case ast.DictComp(generators=generators):
+            yield from _comprehension_calls(generators, tuple(comprehension_results(node)), shadowed, nested_scope_base)
             return
         case ast.Lambda(args=args, body=body):
             outer_nodes = [*args.defaults, *(default for default in args.kw_defaults if default is not None)]
@@ -1008,8 +1009,8 @@ class LocalBindingCollector(ast.NodeVisitor):
 
     @override
     def visit_DictComp(self, node: ast.DictComp) -> None:
-        self.visit(node.key)
-        self.visit(node.value)
+        for result in comprehension_results(node):
+            self.visit(result)
         self._visit_generators(node.generators)
 
     @override

{sarj_python_lint-1.35.0 → sarj_python_lint-1.36.0}/src/sarj_python_lint/rules/no_impossible_pydantic_field_bounds.py

@@ -28,6 +28,8 @@ if TYPE_CHECKING:
 _NUMERIC_BOUNDS = frozenset({"gt", "ge", "lt", "le"})
 _LENGTH_BOUNDS = frozenset({"min_length", "max_length"})
 _KINDS = frozenset({"int", "float", "str", "list"})
+_PASSIVE_CONFIG_BOOLEANS = frozenset({"strict", "frozen", "validate_default"})
+_EXTRA_POLICIES = frozenset({"allow", "forbid", "ignore"})
 _PASSIVE_OPTIONS = frozenset(
     {
         "default",
@@ -59,13 +61,15 @@ class NoImpossiblePydanticFieldBounds(Rule):
     documentation = RuleDocumentation(
         default_level=Severity.ERROR,
         summary="Pydantic field bounds must admit at least one value.",
-        rationale="Contradictory literal constraints reject every field value, including integer intervals with no integer member.",
+        rationale="Contradictory literal constraints reject every field value, including integer multiples and float intervals with no representable member.",
         remediation="Correct the conflicting bounds so the declared field domain admits the intended values.",
         category=RuleCategory.CORRECTNESS,
         autofix=AutofixPolicy.NONE,
         limitations=(
             "Only plain direct module-level BaseModel subclasses and built-in int, float, str and list fields are inspected.",
             "Bounds must be finite literals; int and length bounds must be integers, and float bounds must convert exactly.",
+            "Positive integer multiple_of constraints use exact integer arithmetic; floating-point steps remain outside the rule.",
+            "Literal strict, frozen, validate_default and extra model settings preserve coverage; other or dynamic configuration is excluded.",
             "Unknown metadata, nullable types, repeated bound names, methods, dynamic namespaces and generated files are excluded.",
             "Visible namespace APIs, dynamic module access, ambiguous imports and escaped or mutated imported objects exclude the file.",
             "No autofix chooses a domain or changes validation behavior.",
@@ -130,7 +134,7 @@ class NoImpossiblePydanticFieldBounds(Rule):
 def _candidate_fields(context: PythonFileContext) -> list[ast.AnnAssign]:
     fields: list[ast.AnnAssign] = []
     for model in direct_models(context):
-        if any(isinstance(member, (ast.Assign, ast.AnnAssign)) and _names_config(member) for member in model.body):
+        if not _passive_model_configuration(model, context):
             continue
         unique = unique_members(model)
         fields.extend(
@@ -144,11 +148,50 @@ def _candidate_fields(context: PythonFileContext) -> list[ast.AnnAssign]:
     return fields
 
 
+def _passive_model_configuration(model: ast.ClassDef, context: PythonFileContext) -> bool:
+    configurations = [
+        member for member in model.body if isinstance(member, (ast.Assign, ast.AnnAssign)) and _names_config(member)
+    ]
+    if not configurations:
+        return True
+    if len(configurations) != 1:
+        return False
+    options = _configuration_options(configurations[0].value, context)
+    return options is not None and all(
+        isinstance(item, ast.Constant)
+        and (
+            (name in _PASSIVE_CONFIG_BOOLEANS and type(item.value) is bool)
+            or (name == "extra" and isinstance(item.value, str) and item.value in _EXTRA_POLICIES)
+        )
+        for name, item in options
+    )
+
+
 def _names_config(node: ast.Assign | ast.AnnAssign) -> bool:
     targets = node.targets if isinstance(node, ast.Assign) else [node.target]
     return any(isinstance(target, ast.Name) and target.id == "model_config" for target in targets)
 
 
+def _configuration_options(value: ast.expr | None, context: PythonFileContext) -> list[tuple[str, ast.expr]] | None:
+    if isinstance(value, ast.Dict):
+        options: list[tuple[str, ast.expr]] = []
+        for key, item in zip(value.keys, value.values, strict=True):
+            if not isinstance(key, ast.Constant) or not isinstance(key.value, str):
+                return None
+            options.append((key.value, item))
+        return options
+    if (
+        not isinstance(value, ast.Call)
+        or value.args
+        or not context.module_imports.resolves(
+            value.func, sources=frozenset({"pydantic", "pydantic.config"}), symbol="ConfigDict"
+        )
+        or any(keyword.arg is None for keyword in value.keywords)
+    ):
+        return None
+    return [(keyword.arg, keyword.value) for keyword in value.keywords if keyword.arg is not None]
+
+
 def _field_contract(field: ast.AnnAssign, context: PythonFileContext) -> tuple[str, dict[str, int | float]] | None:
     annotation = field.annotation
     calls: list[ast.Call] = []
@@ -186,7 +229,9 @@ def _literal_bounds(calls: list[ast.Call], kind: str) -> dict[str, int | float]
     if any(call.args for call in calls):
         return None
     bounds: dict[str, int | float] = {}
-    allowed = _NUMERIC_BOUNDS if kind in {"int", "float"} else _LENGTH_BOUNDS
+    allowed = (
+        _NUMERIC_BOUNDS | {"multiple_of"} if kind == "int" else _NUMERIC_BOUNDS if kind == "float" else _LENGTH_BOUNDS
+    )
     for keyword in (keyword for call in calls for keyword in call.keywords):
         name = keyword.arg
         if name in _PASSIVE_OPTIONS:
@@ -194,7 +239,7 @@ def _literal_bounds(calls: list[ast.Call], kind: str) -> dict[str, int | float]
         if name is None or name not in allowed or name in bounds:
             return None
         value = _bound_value(keyword.value, kind)
-        if value is None:
+        if value is None or (name == "multiple_of" and value <= 0):
             return None
         bounds[name] = value
     return bounds
@@ -240,5 +285,19 @@ def _empty_interval(kind: str, bounds: dict[str, int | float]) -> bool:
     lower = max(lowers, key=lambda bound: (bound.value, bound.exclusive))
     upper = min(uppers, key=lambda bound: (bound.value, not bound.exclusive))
     if kind != "float":
-        return lower.value + int(lower.exclusive) > upper.value - int(upper.exclusive)
-    return lower.value > upper.value or (lower.value == upper.value and (lower.exclusive or upper.exclusive))
+        minimum = lower.value + int(lower.exclusive)
+        maximum = upper.value - int(upper.exclusive)
+        if minimum > maximum:
+            return True
+        multiple = bounds.get("multiple_of")
+        return (
+            kind == "int"
+            and isinstance(minimum, int)
+            and isinstance(maximum, int)
+            and isinstance(multiple, int)
+            and multiple > 0
+            and -(-minimum // multiple) * multiple > maximum
+        )
+    minimum_float = math.nextafter(lower.value, math.inf) if lower.exclusive else float(lower.value)
+    maximum_float = math.nextafter(upper.value, -math.inf) if upper.exclusive else float(upper.value)
+    return minimum_float > maximum_float

{sarj_python_lint-1.35.0 → sarj_python_lint-1.36.0}/src/sarj_python_lint/rules/no_psycopg_execution_outside_injected_owner.py

@@ -18,7 +18,7 @@ from sarj_python_lint.rule_base import (
     Severity,
     is_suppressed,
 )
-from sarj_python_lint.rules._ast_index import walk as walk_ast
+from sarj_python_lint.rules._ast_index import comprehension_results, walk as walk_ast
 from sarj_python_lint.rules._imports import ImportIndex
 
 
@@ -611,7 +611,7 @@ class _FunctionAnalyzer:
 
             @override
             def visit_DictComp(self, node: ast.DictComp) -> None:
-                self._comprehension(node.generators, [node.key, node.value])
+                self._comprehension(node.generators, comprehension_results(node))
 
             def _comprehension(self, generators: list[ast.comprehension], results: list[ast.expr]) -> None:
                 saved_shadowed = set(analyzer._shadowed)

{sarj_python_lint-1.35.0 → sarj_python_lint-1.36.0}/src/sarj_python_lint/rules/no_raw_source_text_test_oracle.py

@@ -19,7 +19,7 @@ from sarj_python_lint.rule_base import (
     Severity,
     is_suppressed,
 )
-from sarj_python_lint.rules._ast_index import walk as walk_ast
+from sarj_python_lint.rules._ast_index import comprehension_results, walk as walk_ast
 from sarj_python_lint.rules._imports import ImportIndex
 from sarj_python_lint.rules._paths import is_test_path
 
@@ -1060,7 +1060,7 @@ def _comprehension_oracle(
         flow = _bind_comprehension_target(generator, flow)
         if any(_raw_text_oracle(condition, flow) for condition in generator.ifs):
             return True
-    values = [node.key, node.value] if isinstance(node, ast.DictComp) else [node.elt]
+    values = comprehension_results(node)
     return any(
         _raw_text_oracle(value, flow) or (consumes_values and _raw_text_expression(value, flow)) for value in values
     )

{sarj_python_lint-1.35.0 → sarj_python_lint-1.36.0}/src/sarj_python_lint/rules/no_whole_request_response_payload_in_log.py

@@ -69,6 +69,9 @@ def _reference_tokens(value: ast.expr) -> tuple[str, ...]:
             return tuple(identifier_tokens(name))
         case ast.Attribute(value=receiver, attr=attribute):
             return (*_reference_tokens(receiver), *identifier_tokens(attribute))
+        case ast.Subscript(value=receiver, slice=ast.Constant(value=str() as key)):
+            metadata = tuple(word for word in identifier_tokens(key) if word in _SAFE_METADATA or word == "not")
+            return (*_reference_tokens(receiver), *metadata)
         case ast.Subscript(value=receiver):
             return _reference_tokens(receiver)
         case ast.Await(value=awaited):

{sarj_python_lint-1.35.0 → sarj_python_lint-1.36.0}/src/sarj_python_lint/rules/stepdown.py

@@ -16,7 +16,7 @@ from sarj_python_lint.rule_base import (
     RuleDocumentation,
     RuleExample,
 )
-from sarj_python_lint.rules._ast_index import children
+from sarj_python_lint.rules._ast_index import children, comprehension_results
 from sarj_python_lint.rules._paths import is_test_path
 
 
@@ -571,11 +571,7 @@ def _comprehension_expressions(
     for generator in node.generators:
         yield generator.iter
         yield from generator.ifs
-    if isinstance(node, ast.DictComp):
-        yield node.key
-        yield node.value
-    else:
-        yield node.elt
+    yield from comprehension_results(node)
 
 
 def _module_pinned_names(tree: ast.Module, definition_names: frozenset[str]) -> set[str]:
@@ -712,8 +708,7 @@ def _resolved_comprehension_loads(
         yield from _resolved_loads((generator.iter,), candidates, comp_blocked)
         comp_blocked.update(_target_names(generator.target) & candidates)
         yield from _resolved_loads(generator.ifs, candidates, comp_blocked)
-    values = (node.key, node.value) if isinstance(node, ast.DictComp) else (node.elt,)
-    yield from _resolved_loads(values, candidates, comp_blocked)
+    yield from _resolved_loads(comprehension_results(node), candidates, comp_blocked)
 
 
 def _direct_scope_bindings(node: ast.FunctionDef | ast.AsyncFunctionDef) -> set[str]:

{sarj_python_lint-1.35.0 → sarj_python_lint-1.36.0}/src/sarj_python_lint/rules/uncontrolled_randomness_in_test.py

@@ -16,6 +16,7 @@ from sarj_python_lint.rule_base import (
     RuleExample,
     Severity,
 )
+from sarj_python_lint.rules._ast_index import comprehension_results
 from sarj_python_lint.rules._paths import is_test_path
 
 
@@ -444,10 +445,7 @@ def _repeated_comprehension_regions(
             regions.extend(generator.ifs)
         prior_generator_repeats = prior_generator_repeats or this_generator_repeats
     if prior_generator_repeats:
-        if isinstance(node, ast.DictComp):
-            regions.extend((node.key, node.value))
-        else:
-            regions.append(node.elt)
+        regions.extend(comprehension_results(node))
     return tuple(regions)