sarj-python-lint 1.42.0__tar.gz → 1.42.2__tar.gz

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.42.0
+Version: 1.42.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/
@@ -19,7 +19,7 @@ Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.14
 Requires-Dist: packaging==26.3
 Requires-Dist: ruff>=0.17.0
-Requires-Dist: sarj-rule-contracts==0.2.4
+Requires-Dist: sarj-rule-contracts==0.2.5
 Requires-Dist: sqlglot==30.22.0
 Requires-Dist: typer==0.27.3
 Description-Content-Type: text/markdown

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "1.42.0"
+version = "1.42.2"
 description = "Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults"
 readme = "README.md"
 authors = [{ name = "sarj-ai" }]
@@ -15,7 +15,7 @@ classifiers = [
   "Programming Language :: Python :: 3.14",
   "Topic :: Software Development :: Quality Assurance",
 ]
-dependencies = ["sarj-rule-contracts==0.2.4", "packaging==26.3", "ruff>=0.17.0", "sqlglot==30.22.0", "typer==0.27.3"]
+dependencies = ["sarj-rule-contracts==0.2.5", "packaging==26.3", "ruff>=0.17.0", "sqlglot==30.22.0", "typer==0.27.3"]
 
 [project.scripts]
 sarj-python-lint = "sarj_python_lint.__main__:main"

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/_annotation_semantics.py

@@ -131,6 +131,15 @@ def _target_names(node: ast.expr) -> set[str]:
 class _ScopeBindings(ast.NodeVisitor):
     def __init__(self) -> None:
         self.names: set[str] = set()
+        self._pending: list[ast.AST] = []
+
+    def visit(self, node: ast.AST) -> None:
+        self._pending.append(node)
+        while self._pending:
+            super().visit(self._pending.pop())
+
+    def generic_visit(self, node: ast.AST) -> None:
+        self._pending.extend(reversed(tuple(ast.iter_child_nodes(node))))
 
     def visit_Name(self, node: ast.Name) -> None:
         if isinstance(node.ctx, (ast.Store, ast.Del)):

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/_fastapi.py

@@ -138,7 +138,9 @@ class FastapiIndex:
         self._read_aliases(tree)
 
     def _index_scopes(self, tree: ast.Module) -> None:
-        def visit(node: ast.AST, scope: int, class_owner: int | None) -> None:
+        pending: list[tuple[ast.AST, int, int | None]] = [(tree, 0, None)]
+        while pending:
+            node, scope, class_owner = pending.pop()
             self._node_scopes[id(node)] = scope
             if isinstance(node, ast.ClassDef):
                 class_owner = node.lineno
@@ -149,10 +151,7 @@ class FastapiIndex:
                 self._route_scopes[id(node)] = scope
                 self._scope_parents[node.lineno] = scope
                 scope = node.lineno
-            for child in ast.iter_child_nodes(node):
-                visit(child, scope, class_owner)
-
-        visit(tree, 0, None)
+            pending.extend((child, scope, class_owner) for child in reversed(tuple(ast.iter_child_nodes(node))))
 
     def _read_imports(self, tree: ast.Module) -> None:
         for node in walk_ast(tree):

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/_pydantic_field_contract.py

@@ -108,39 +108,48 @@ 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):
-        target = context.imports.resolved_qualified_name(node.func)
-        if target not in {
-            "pydantic.Field",
-            "pydantic.fields.Field",
-            "pydantic.ConfigDict",
-            "pydantic.config.ConfigDict",
-        }:
+    pending = [node]
+    while pending:
+        current = pending.pop()
+        if isinstance(current, ast.Subscript) and not _inert_subscription(current, context):
+            return False
+        if isinstance(current, ast.Lambda):
+            if current.args.defaults or current.args.kw_defaults:
+                return False
+            continue
+        if isinstance(current, ast.Call) and not _inert_pydantic_call(current, context):
             return False
-        if any(keyword.arg is None for keyword in node.keywords) or any(
-            isinstance(argument, ast.Starred) for argument in node.args
+        if isinstance(
+            current,
+            (
+                ast.NamedExpr,
+                ast.Starred,
+                ast.Await,
+                ast.Yield,
+                ast.YieldFrom,
+                ast.ListComp,
+                ast.SetComp,
+                ast.DictComp,
+                ast.GeneratorExp,
+            ),
         ):
             return False
-    if isinstance(
-        node,
-        (
-            ast.NamedExpr,
-            ast.Starred,
-            ast.Await,
-            ast.Yield,
-            ast.YieldFrom,
-            ast.ListComp,
-            ast.SetComp,
-            ast.DictComp,
-            ast.GeneratorExp,
-        ),
-    ):
+        pending.extend(reversed(tuple(ast.iter_child_nodes(current))))
+    return True
+
+
+def _inert_pydantic_call(node: ast.Call, context: PythonFileContext) -> bool:
+    target = context.imports.resolved_qualified_name(node.func)
+    if target not in {
+        "pydantic.Field",
+        "pydantic.fields.Field",
+        "pydantic.ConfigDict",
+        "pydantic.config.ConfigDict",
+    }:
         return False
-    return all(_inert_expr(child, context) for child in ast.iter_child_nodes(node))
+    return not any(keyword.arg is None for keyword in node.keywords) and not any(
+        isinstance(argument, ast.Starred) for argument in node.args
+    )
 
 
 def _inert_subscription(node: ast.Subscript, context: PythonFileContext) -> bool:

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/docstring_args_restate_signature.py

@@ -128,14 +128,14 @@ class DocstringArgsRestateSignature(Rule):
         imports: ImportIndex,
         diags: list[Diagnostic],
     ) -> None:
-        for child in children(node):
+        pending: list[tuple[ast.AST, str | None]] = [(child, class_name) for child in reversed(children(node))]
+        while pending:
+            child, owner = pending.pop()
             if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
-                self._check_function(child, class_name, path, imports, diags)
-                self._walk(child, class_name, path, imports, diags)
+                self._check_function(child, owner, path, imports, diags)
             elif isinstance(child, ast.ClassDef):
-                self._walk(child, child.name, path, imports, diags)
-            else:
-                self._walk(child, class_name, path, imports, diags)
+                owner = child.name
+            pending.extend((nested, owner) for nested in reversed(children(child)))
 
     def _check_function(
         self,

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/docstring_returns_restate_signature.py

@@ -196,14 +196,14 @@ class DocstringReturnsRestateSignature(Rule):
         imports: ImportIndex,
         diags: list[Diagnostic],
     ) -> None:
-        for child in children(node):
+        pending: list[tuple[ast.AST, str | None]] = [(child, class_name) for child in reversed(children(node))]
+        while pending:
+            child, owner = pending.pop()
             if isinstance(child, ast.FunctionDef | ast.AsyncFunctionDef):
-                self._check_function(child, class_name, path, imports, diags)
-                self._walk(child, class_name, path, imports, diags)
+                self._check_function(child, owner, path, imports, diags)
             elif isinstance(child, ast.ClassDef):
-                self._walk(child, child.name, path, imports, diags)
-            else:
-                self._walk(child, class_name, path, imports, diags)
+                owner = child.name
+            pending.extend((nested, owner) for nested in reversed(children(child)))
 
     def _check_function(
         self,

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/iac_source_coupled_test.py

@@ -62,7 +62,7 @@ class IacSourceCoupledTest(Rule):
                 files=(
                     ExampleFile.python(
                         "tests/test_policy.py",
-                        "def test_policy(rendered_plan_json: str):\n"
+                        "import json\n\ndef test_policy(rendered_plan_json: str):\n"
                         "    plan = json.loads(rendered_plan_json)\n"
                         "    changes = plan['resource_changes']\n"
                         "    assert changes[0]['change']['actions'] == ['create']\n",

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/invalid_pydantic_field_default.py

@@ -314,12 +314,24 @@ def _literal_key(value: object) -> _LiteralKey:
     return _LiteralKey(type(value), value)
 
 
+def _bit_union_members(node: ast.expr) -> list[ast.expr]:
+    members: list[ast.expr] = []
+    pending = [node]
+    while pending:
+        member = pending.pop()
+        if isinstance(member, ast.BinOp) and isinstance(member.op, ast.BitOr):
+            pending.extend((member.right, member.left))
+        else:
+            members.append(member)
+    return members
+
+
 def _literal_domain(node: ast.expr, imports: ImportIndex) -> _LiteralDomain | None:
     node = _parse_forward_annotation(node)
     if isinstance(node, ast.Constant) and node.value is None:
         return _LiteralDomain(frozenset({_literal_key(None)}))
     if isinstance(node, ast.BinOp) and isinstance(node.op, ast.BitOr):
-        return _merge_domains((_literal_domain(node.left, imports), _literal_domain(node.right, imports)))
+        return _merge_domains(tuple(_literal_domain(member, imports) for member in _bit_union_members(node)))
     if not isinstance(node, ast.Subscript):
         return None
     if imports.resolves(node.value, sources=_TYPING_SOURCES, symbol="Annotated"):
@@ -334,8 +346,12 @@ def _literal_domain(node: ast.expr, imports: ImportIndex) -> _LiteralDomain | No
         return _merge_domains(tuple(_literal_domain(member, imports) for member in _slice_members(node.slice)))
     if not imports.resolves(node.value, sources=_TYPING_SOURCES, symbol="Literal"):
         return None
+    return _literal_members_domain(_slice_members(node.slice))
+
+
+def _literal_members_domain(members: tuple[ast.expr, ...]) -> _LiteralDomain | None:
     values: set[_LiteralKey] = set()
-    for member in _slice_members(node.slice):
+    for member in members:
         value = _literal_value(member)
         if value is _MISSING or isinstance(value, float):
             return None
@@ -514,7 +530,7 @@ def _numeric_bound_is_violated(name: str, default: float, bound: float) -> bool:
 def _provably_non_null(node: ast.expr, imports: ImportIndex) -> bool:
     node = _parse_forward_annotation(node)
     if isinstance(node, ast.BinOp) and isinstance(node.op, ast.BitOr):
-        return _provably_non_null(node.left, imports) and _provably_non_null(node.right, imports)
+        return all(_provably_non_null(member, imports) for member in _bit_union_members(node))
     if isinstance(node, ast.Name):
         return node.id in _KNOWN_NON_NULL_BUILTINS and imports.builtin_is_unshadowed(node.id)
     if not isinstance(node, ast.Subscript):

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/named_record_at_boundaries.py

@@ -237,16 +237,14 @@ def _is_framework_hook(node: ast.FunctionDef | ast.AsyncFunctionDef, imports: Im
 
 def _private_class_function_ids(tree: ast.Module) -> set[int]:
     private: set[int] = set()
-
-    def visit(node: ast.AST, *, inside_private_class: bool) -> None:
+    pending: list[tuple[ast.AST, bool]] = [(tree, False)]
+    while pending:
+        node, inside_private_class = pending.pop()
         if isinstance(node, ast.ClassDef):
             inside_private_class = inside_private_class or node.name.startswith("_")
         if inside_private_class and isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
             private.add(id(node))
-        for child in children(node):
-            visit(child, inside_private_class=inside_private_class)
-
-    visit(tree, inside_private_class=False)
+        pending.extend((child, inside_private_class) for child in reversed(children(node)))
     return private
 
 

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/no_broad_keyword_capture.py

@@ -2,7 +2,9 @@ from __future__ import annotations
 
 import ast
 from dataclasses import replace
+from io import StringIO
 from pathlib import PurePosixPath
+import tokenize
 from types import MappingProxyType
 from typing import TYPE_CHECKING, ClassVar, final
 
@@ -187,8 +189,10 @@ class NoBroadKeywordCapture(Rule):
                 overloads = _overload_implementations(context, semantics, mutated_members)
             if function in overloads:
                 continue
-            if is_suppressed(context.source_lines, argument.lineno, self.code) or is_suppressed(
-                context.source_lines, function.lineno, self.code
+            if (
+                is_suppressed(context.source_lines, argument.lineno, self.code)
+                or is_suppressed(context.source_lines, function.lineno, self.code)
+                or _signature_end_suppressed(function, context, self.code)
             ):
                 continue
             findings.append(
@@ -207,6 +211,39 @@ class NoBroadKeywordCapture(Rule):
         return sorted(findings, key=lambda finding: (finding.line, finding.col))
 
 
+def _signature_end_suppressed(
+    function: ast.FunctionDef | ast.AsyncFunctionDef, context: PythonFileContext, code: str
+) -> bool:
+    first_statement = function.body[0]
+    header = context.source_lines[function.lineno - 1 : first_statement.lineno]
+    if not any("sarj-noqa" in line.lower() for line in header):
+        return False
+    # AST columns count UTF-8 bytes, and a continued inline body can share the header's logical line.
+    header[-1] = header[-1].encode("utf-8")[: first_statement.col_offset].decode("utf-8")
+    try:
+        line = _signature_end_line(header, function.lineno)
+    except tokenize.TokenError, SyntaxError:
+        return False
+    return line is not None and is_suppressed(context.source_lines, line, code)
+
+
+def _signature_end_line(header: list[str], start_line: int) -> int | None:
+    depth = 0
+    line = None
+    for token in tokenize.generate_tokens(StringIO("\n".join(header)).readline):
+        if token.type == tokenize.NEWLINE:
+            return line
+        if token.type != tokenize.OP:
+            continue
+        if token.string in {"(", "[", "{"}:
+            depth += 1
+        elif token.string in {")", "]", "}"}:
+            depth -= 1
+        elif token.string == ":" and depth == 0:
+            line = start_line + token.start[0] - 1
+    return line
+
+
 def _interface_severity(
     function: ast.FunctionDef | ast.AsyncFunctionDef,
     context: PythonFileContext,

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/no_database_programmability.py

@@ -29,8 +29,8 @@ _DATABASE_BEHAVIOR = re.compile(
     r"CREATE\s+CONSTRAINT\s+TRIGGER|ALTER\s+TABLE\s+[^;]+?\s+ENABLE\s+(?:(?:ALWAYS|REPLICA)\s+)?TRIGGER)\b",
     re.IGNORECASE,
 )
-_BAD = 'await conn.execute("CREATE TRIGGER fail_counter BEFORE UPDATE ON batch EXECUTE FUNCTION fail_counter()")\n'
-_GOOD = 'await conn.execute("ALTER TABLE batch ADD CONSTRAINT fail_counter CHECK (false) NOT VALID")\n'
+_BAD = 'async def install_fault(conn):\n    await conn.execute("CREATE TRIGGER fail_counter BEFORE UPDATE ON batch EXECUTE FUNCTION fail_counter()")\n'
+_GOOD = 'async def install_fault(conn):\n    await conn.execute("ALTER TABLE batch ADD CONSTRAINT fail_counter CHECK (false) NOT VALID")\n'
 
 
 @final

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/no_loguru_exc_info.py

@@ -83,7 +83,7 @@ class NoLoguruExcInfo(Rule):
 
     @override
     def check_context(self, context: PythonFileContext) -> list[Diagnostic]:
-        if "exc_info" not in context.source or context.generated or context.tree is None:
+        if "exc_info" not in context.symbol_source or context.generated or context.tree is None:
             return []
         shadowed = _ambiguous_import_names(context)
         if "*" in shadowed:

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/no_loguru_printf_format.py

@@ -89,7 +89,7 @@ class NoLoguruPrintfFormat(Rule):
 
     @override
     def check_context(self, context: PythonFileContext) -> list[Diagnostic]:
-        if "loguru" not in context.source or context.generated or context.tree is None:
+        if "loguru" not in context.symbol_source or context.generated or context.tree is None:
             return []
         provenance: ResourceProvenance | None = None
         diagnostics: list[Diagnostic] = []

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/no_psycopg_execution_outside_injected_owner.py

@@ -386,40 +386,22 @@ def _has_dynamic_reflective_self_write(function: ast.FunctionDef | ast.AsyncFunc
 
 def _function_scopes(tree: ast.Module) -> list[_FunctionScope]:
     scopes: list[_FunctionScope] = []
-
-    class Collector(ast.NodeVisitor):
-        def __init__(self) -> None:
-            self.owner: ast.ClassDef | None = None
-
-        @override
-        def visit_ClassDef(self, node: ast.ClassDef) -> None:
-            previous = self.owner
-            self.owner = node
-            for statement in node.body:
-                self.visit(statement)
-            self.owner = previous
-
-        @override
-        def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
-            self._function(node)
-
-        @override
-        def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
-            self._function(node)
-
-        def _function(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> None:
-            scopes.append(_FunctionScope(node, self.owner))
-            previous = self.owner
-            self.owner = None
-            for statement in node.body:
-                self.visit(statement)
-            self.owner = previous
-
-        @override
-        def visit_Lambda(self, node: ast.Lambda) -> None:
-            return
-
-    Collector().visit(tree)
+    pending: list[tuple[ast.AST, ast.ClassDef | None]] = [(tree, None)]
+    while pending:
+        node, owner = pending.pop()
+        match node:
+            case ast.Lambda():
+                continue
+            case ast.ClassDef():
+                owner = node
+                children = tuple(node.body)
+            case ast.FunctionDef() | ast.AsyncFunctionDef():
+                scopes.append(_FunctionScope(node, owner))
+                owner = None
+                children = tuple(node.body)
+            case _:
+                children = tuple(ast.iter_child_nodes(node))
+        pending.extend((child, owner) for child in reversed(children))
     return scopes
 
 

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/no_redundant_literal_description.py

@@ -275,9 +275,7 @@ def _closed_domain(
     if isinstance(node, ast.Name):
         return local_domains.get(node.id)
     if isinstance(node, ast.BinOp) and isinstance(node.op, ast.BitOr):
-        left = _closed_domain(node.left, imports, local_domains)
-        right = _closed_domain(node.right, imports, local_domains)
-        return left | right if left is not None and right is not None else None
+        return _closed_union_domain(node, imports, local_domains)
     if not isinstance(node, ast.Subscript):
         return None
     if imports.resolves(node.value, sources=_TYPING_SOURCES, symbol="Literal"):
@@ -288,6 +286,23 @@ def _closed_domain(
     return None
 
 
+def _closed_union_domain(
+    node: ast.expr, imports: ImportIndex, local_domains: dict[str, frozenset[str]]
+) -> frozenset[str] | None:
+    values: set[str] = set()
+    pending = [node]
+    while pending:
+        member = pending.pop()
+        if isinstance(member, ast.BinOp) and isinstance(member.op, ast.BitOr):
+            pending.extend((member.right, member.left))
+            continue
+        domain = _closed_domain(member, imports, local_domains)
+        if domain is None:
+            return None
+        values.update(domain)
+    return frozenset(values)
+
+
 def _repeats_domain(description: str, domain: frozenset[str]) -> bool:
     match = _DOMAIN_CLAUSE.search(description)
     if match is None:

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/no_repeated_string_literal.py

@@ -154,17 +154,19 @@ class NoRepeatedStringLiteral(Rule):
                 scope_of[id(node)] = scope
 
         def visit(node: ast.AST, scope: int) -> None:
-            for annotation in _annotation_exprs(node):
-                excluded.update(id(child) for child in walk(annotation) if isinstance(child, ast.Constant))
-            if isinstance(node, (ast.Module, ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)):
-                scope = declaration_scope(node, scope)
-            elif isinstance(node, ast.Lambda):
-                scope = id(node)
-                scope_line_of[scope] = node.lineno
-            else:
-                collect_literal(node, scope)
-            for child in children(node):
-                visit(child, scope)
+            pending = [(node, scope)]
+            while pending:
+                node, scope = pending.pop()
+                for annotation in _annotation_exprs(node):
+                    excluded.update(id(child) for child in walk(annotation) if isinstance(child, ast.Constant))
+                if isinstance(node, (ast.Module, ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)):
+                    scope = declaration_scope(node, scope)
+                elif isinstance(node, ast.Lambda):
+                    scope = id(node)
+                    scope_line_of[scope] = node.lineno
+                else:
+                    collect_literal(node, scope)
+                pending.extend((child, scope) for child in reversed(children(node)))
 
         visit(tree, _MODULE_SCOPE)
 

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/no_secret_in_log.py

@@ -103,7 +103,7 @@ class NoSecretInLog(Rule):
             ),
             RuleExample(
                 example_id="redacted-logging-keyword",
-                title="Token prefix logged under a redacted name",
+                title="Only non-sensitive authentication metadata is logged",
                 outcome=ExampleOutcome.NO_MATCH,
                 files=(
                     ExampleFile.python(

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/no_tautological_expect.py

@@ -40,24 +40,56 @@ class NoTautologicalExpect(Rule):
     id: str = "no-statically-truthy-assertion"
     code: str = "SARJ057"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        summary="An assertion condition is statically truthy, including test-local scalar setup.",
+        summary="An assertion condition is statically truthy, including deferred expressions and test-local scalar setup.",
         rationale=(
             "A condition that stays truthy whenever evaluation succeeds cannot reject an incorrect result and often "
-            "means the intended condition was wrapped in a container or placed in the message slot."
+            "means the intended condition was wrapped in a container, deferred without execution, or placed in the message slot."
         ),
         remediation=(
             "Assert an explicit runtime-derived condition. If the test only requires an operation not to raise, "
-            "evaluate it directly and retain any meaningful follow-up assertion."
+            "evaluate it directly and retain any meaningful follow-up assertion. Consume generator values or call "
+            "the lambda when their result is the contract; choose empty-input behavior explicitly."
         ),
         category=RuleCategory.TESTING,
         aliases=("no-tautological-expect",),
         limitations=(
-            "Detection covers truthy scalar constants and definitely non-empty list, set, and dict displays.",
+            "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.",
             "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.",
         ),
         examples=(
+            RuleExample(
+                example_id="unconsumed-generator",
+                scenario="deferred-condition",
+                title="A generator object does not check the yielded conditions",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "tests/test_service.py",
+                        "def test_values(rows):\n    assert (row.is_valid for row in rows)\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("tests/test_service.py"),
+                expected_count=1,
+                public=True,
+            ),
+            RuleExample(
+                example_id="consumed-generator",
+                scenario="deferred-condition",
+                title="Consume the conditions when the contract requires every row to be valid",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "tests/test_service.py",
+                        "def test_values(rows):\n    assert all(row.is_valid for row in rows)\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("tests/test_service.py"),
+                expected_count=0,
+                public=True,
+            ),
             RuleExample(
                 example_id="setup-only-oracle",
                 scenario="setup-only",
@@ -273,6 +305,10 @@ def _fixed_truth_reason(test: ast.expr) -> str | None:
     kind = _nonempty_container_kind(test)
     if kind is not None:
         return f"a non-empty {kind} display is truthy whatever it contains"
+    if isinstance(test, ast.GeneratorExp):
+        return "a generator expression creates a truthy iterator without checking its yielded values"
+    if isinstance(test, ast.Lambda):
+        return "a lambda expression creates a truthy function without calling its body"
     return None
 
 

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/no_unnecessary_docstring.py

@@ -218,15 +218,13 @@ def _is_syntax_required(owner: ast.Module | ast.ClassDef | ast.FunctionDef | ast
 
 def _owner_keys(tree: ast.Module) -> dict[int, str]:
     keys = {id(tree): "__doc__"}
-
-    def visit(node: ast.AST, prefix: tuple[str, ...]) -> None:
+    pending: list[tuple[ast.AST, tuple[str, ...]]] = [(tree, ())]
+    while pending:
+        node, prefix = pending.pop()
         if isinstance(node, (ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)):
             prefix = (*prefix, node.name)
             keys[id(node)] = ".".join(prefix)
-        for child in ast.iter_child_nodes(node):
-            visit(child, prefix)
-
-    visit(tree, ())
+        pending.extend((child, prefix) for child in reversed(tuple(ast.iter_child_nodes(node))))
     return keys
 
 

{sarj_python_lint-1.42.0 → sarj_python_lint-1.42.2}/src/sarj_python_lint/rules/prefer_class_row.py

@@ -90,7 +90,7 @@ class PreferClassRow(Rule):
                 files=(
                     ExampleFile.python(
                         "app/task_store.py",
-                        "from psycopg.rows import class_row\n\nasync def load(conn):\n    async with conn.cursor(row_factory=class_row(Task)) as cursor:\n        return await cursor.fetchone()\n",
+                        'from psycopg.rows import class_row\n\nasync def load(conn):\n    async with conn.cursor(row_factory=class_row(Task)) as cursor:\n        await cursor.execute("SELECT id, state FROM task")\n        return await cursor.fetchone()\n',
                     ),
                 ),
                 focus_path=PurePosixPath("app/task_store.py"),