sarj-python-lint 1.109.0__tar.gz → 1.110.0__tar.gz

{sarj_python_lint-1.109.0 → sarj_python_lint-1.110.0}/PKG-INFO

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

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

{sarj_python_lint-1.109.0 → sarj_python_lint-1.110.0}/src/sarj_python_lint/__main__.py

@@ -289,6 +289,7 @@ _DIAGNOSTIC_PRECEDENCE = MappingProxyType(
         "SARJ457": frozenset({"SARJ045", "SARJ526"}),
         "SARJ465": frozenset({"SARJ071"}),
         "SARJ491": frozenset({"SARJ400"}),
+        "SARJ518": frozenset({"SARJ560"}),
     }
 )
 

{sarj_python_lint-1.109.0 → sarj_python_lint-1.110.0}/src/sarj_python_lint/_rule_descriptors.py

@@ -8,6 +8,33 @@ from sarj_python_lint.rule_metadata import RuleDescriptor
 
 SCHEMA_VERSION = 1
 DESCRIPTORS: tuple[RuleDescriptor, ...] = (
+    RuleDescriptor(
+        rule_id=RuleId("prefer-validated-uuid-comparison"),
+        module="sarj_python_lint.rules.prefer_validated_uuid_comparison",
+        class_name="PreferValidatedUuidComparison",
+        code="SARJ562",
+        description="Validate UUID identifiers at input boundaries before comparing them.",
+        aliases=(),
+        enabled_by_default=True,
+    ),
+    RuleDescriptor(
+        rule_id=RuleId("prefer-single-psycopg-cursor"),
+        module="sarj_python_lint.rules.prefer_single_psycopg_cursor",
+        class_name="PreferSinglePsycopgCursor",
+        code="SARJ561",
+        description="Review repeated Psycopg cursor creation within one function.",
+        aliases=(),
+        enabled_by_default=True,
+    ),
+    RuleDescriptor(
+        rule_id=RuleId("no-psycopg-execution-in-loop"),
+        module="sarj_python_lint.rules.no_psycopg_execution_in_loop",
+        class_name="NoPsycopgExecutionInLoop",
+        code="SARJ560",
+        description="Use bounded bulk queries instead of executing Psycopg operations inside item loops.",
+        aliases=(),
+        enabled_by_default=True,
+    ),
     RuleDescriptor(
         rule_id=RuleId("no-shared-mutable-default"),
         module="sarj_python_lint.rules.no_shared_mutable_default",
@@ -112,7 +139,7 @@ DESCRIPTORS: tuple[RuleDescriptor, ...] = (
         module="sarj_python_lint.rules.no_custom_control_flow_exception",
         class_name="NoCustomControlFlowException",
         code="SARJ542",
-        description="Return typed outcomes for expected domain failures instead of name-only exceptions.",
+        description="Return typed outcomes for expected domain failures instead of marker or fixed-message exceptions.",
         aliases=(),
         enabled_by_default=True,
     ),

{sarj_python_lint-1.109.0 → sarj_python_lint-1.110.0}/src/sarj_python_lint/rules/_registry.py

@@ -248,6 +248,7 @@ from sarj_python_lint.rules.no_impossible_pydantic_field_bounds import NoImpossi
 from sarj_python_lint.rules.no_invalid_pydantic_bypass import NoInvalidPydanticBypass
 from sarj_python_lint.rules.no_invalid_pydantic_validator_return import NoInvalidPydanticValidatorReturn
 from sarj_python_lint.rules.no_partial_type_is import NoPartialTypeIs
+from sarj_python_lint.rules.no_psycopg_execution_in_loop import NoPsycopgExecutionInLoop
 from sarj_python_lint.rules.no_recording_store import NoRecordingStore
 from sarj_python_lint.rules.no_redundant_local_alias import NoRedundantLocalAlias
 from sarj_python_lint.rules.no_redundant_sql_alias import NoRedundantSqlAlias
@@ -268,9 +269,11 @@ from sarj_python_lint.rules.prefer_psycopg_executemany import PreferPsycopgExecu
 from sarj_python_lint.rules.prefer_pydantic_model_assertion import PreferPydanticModelAssertion
 from sarj_python_lint.rules.prefer_pytest_dependency_fixtures import PreferPytestDependencyFixtures
 from sarj_python_lint.rules.prefer_runtime_validation import PreferRuntimeValidation
+from sarj_python_lint.rules.prefer_single_psycopg_cursor import PreferSinglePsycopgCursor
 from sarj_python_lint.rules.prefer_typed_cli import PreferTypedCli
 from sarj_python_lint.rules.prefer_typed_mapping_get import PreferTypedMappingGet
 from sarj_python_lint.rules.prefer_typed_settings_field import PreferTypedSettingsField
+from sarj_python_lint.rules.prefer_validated_uuid_comparison import PreferValidatedUuidComparison
 from sarj_python_lint.rules.pytest_fixture_returns_closed_resource import PytestFixtureReturnsClosedResource
 from sarj_python_lint.rules.redundant_test_constructor_forwarder import RedundantTestConstructorForwarder
 from sarj_python_lint.rules.repeated_unimplemented_test_contract import RepeatedUnimplementedTestContract
@@ -286,6 +289,9 @@ from sarj_python_lint.rules.test_without_explicit_oracle import NoExplicitTestOr
 
 _AUTHORING_REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
     {
+        PreferValidatedUuidComparison.id: PreferValidatedUuidComparison,
+        PreferSinglePsycopgCursor.id: PreferSinglePsycopgCursor,
+        NoPsycopgExecutionInLoop.id: NoPsycopgExecutionInLoop,
         NoSharedMutableDefault.id: NoSharedMutableDefault,
         NoSysPathMutation.id: NoSysPathMutation,
         NoDynamicBuiltins.id: NoDynamicBuiltins,

{sarj_python_lint-1.109.0 → sarj_python_lint-1.110.0}/src/sarj_python_lint/rules/_store_sql.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING
 from sqlglot import exp
 
 from sarj_python_lint.rules._sql import sql_string_value
-from sarj_python_lint.rules._store_writes import Function, methods
+from sarj_python_lint.rules._store_writes import Function, methods, own_nodes
 from sarj_python_lint.rules.no_psycopg_execution_outside_injected_owner import psycopg_execution_calls
 
 
@@ -21,6 +21,7 @@ if TYPE_CHECKING:
 _HOLE = "__sarj_store_sql_hole__"
 _FORMAT_HOLE = re.compile(r"(?<!\{)\{(?:[A-Za-z_]\w*|\d*)\}(?!\})")
 _MAX_RECOVERY_DEPTH = 8
+_MAX_APPEND_VARIANTS = 16
 
 
 @dataclass(frozen=True)
@@ -44,6 +45,25 @@ class _MethodWrites:
     instances: frozenset[tuple[ast.ClassDef, str]]
 
 
+@dataclass(frozen=True)
+class _QueryVariants:
+    origin: ast.expr
+    texts: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class _AppendDefinition:
+    assignment: ast.Assign
+    writes: list[ast.AST | None]
+    function: Function
+
+
+@dataclass(frozen=True)
+class _LiteralAppend:
+    text: str
+    conditional: bool
+
+
 def store_queries(context: PythonFileContext) -> Iterator[StoreQuery]:
     if context.store_queries is None:
         try:
@@ -151,8 +171,17 @@ def query_owner(node: ast.AST, context: PythonFileContext) -> QueryOwner:
 
 def _parsed_query(expression: ast.expr, call: ast.Call, context: PythonFileContext) -> Iterator[StoreQuery]:
     text = _query_text(expression, context, seen=frozenset())
-    if text is None:
-        return
+    origin = _query_origin(expression, context)
+    texts = (text,) if text is not None else ()
+    if not texts and isinstance(expression, ast.Name):
+        appended = _literal_append_variants(expression, context)
+        if appended is not None:
+            origin, texts = appended.origin, appended.texts
+    for query_text in texts:
+        yield from _parse_query_text(query_text, origin, call, context)
+
+
+def _parse_query_text(text: str, origin: ast.expr, call: ast.Call, context: PythonFileContext) -> Iterator[StoreQuery]:
     from sqlglot.errors import SqlglotError  # ruff: ignore[import-outside-top-level] -- malformed input abstains.
 
     from sarj_python_lint.rules._postgres import parse_postgres  # ruff: ignore[import-outside-top-level] -- avoid private-source unsupported SQL logs.
@@ -164,7 +193,81 @@ def _parsed_query(expression: ast.expr, call: ast.Call, context: PythonFileConte
     scope = query_owner(call, context)
     for statement in statements:
         if statement is not None:
-            yield StoreQuery(_query_origin(expression, context), scope.owner, scope.method, text, statement)
+            yield StoreQuery(origin, scope.owner, scope.method, text, statement)
+
+
+def _literal_append_variants(expression: ast.Name, context: PythonFileContext) -> _QueryVariants | None:
+    definition = _append_definition(expression, context)
+    if definition is None:
+        return None
+    value = definition.assignment.value
+    if not isinstance(value, ast.Constant) or not isinstance(value.value, str):
+        return None
+    variants = (value.value,)
+    for write in sorted(definition.writes, key=lambda node: node.lineno if isinstance(node, ast.stmt) else 0):
+        if write is definition.assignment:
+            continue
+        append = _literal_append(write, definition, expression, context)
+        if append is None:
+            return None
+        appended = tuple(text + append.text for text in variants)
+        variants = (*variants, *appended) if append.conditional else appended
+        if len(variants) > _MAX_APPEND_VARIANTS:
+            return None
+    return _QueryVariants(value, tuple(dict.fromkeys(variants)))
+
+
+def _append_definition(expression: ast.Name, context: PythonFileContext) -> _AppendDefinition | None:
+    if context.static_resource_provenance.dynamic_namespace or context.static_resource_provenance.wildcard:
+        return None
+    function = query_owner(expression, context).method
+    if function is None:
+        return None
+    writes = [
+        node
+        for node in own_nodes(function)
+        if isinstance(node, ast.Name) and node.id == expression.id and isinstance(node.ctx, ast.Store | ast.Del)
+    ]
+    assignments = [context.parents.get(node) for node in writes]
+    initial = [
+        node
+        for node in assignments
+        if isinstance(node, ast.Assign)
+        and len(node.targets) == 1
+        and node in function.body
+        and node.lineno < expression.lineno
+    ]
+    if len(initial) != 1:
+        return None
+    if any(expression.id in node.names for node in context.nodes(ast.Global, ast.Nonlocal)):
+        return None
+    return _AppendDefinition(initial[0], assignments, function)
+
+
+def _literal_append(
+    write: ast.AST | None,
+    definition: _AppendDefinition,
+    expression: ast.Name,
+    context: PythonFileContext,
+) -> _LiteralAppend | None:
+    if not (
+        isinstance(write, ast.AugAssign)
+        and isinstance(write.op, ast.Add)
+        and isinstance(write.value, ast.Constant)
+        and isinstance(write.value.value, str)
+        and definition.assignment.lineno < write.lineno < expression.lineno
+    ):
+        return None
+    parent = context.parents.get(write)
+    conditional = (
+        isinstance(parent, ast.If)
+        and parent.body == [write]
+        and not parent.orelse
+        and parent in definition.function.body
+    )
+    if parent is not definition.function and not conditional:
+        return None
+    return _LiteralAppend(write.value.value, conditional)
 
 
 def _query_origin(expression: ast.expr, context: PythonFileContext) -> ast.expr:
@@ -226,6 +329,8 @@ def _query_text(expression: ast.expr, context: PythonFileContext, *, seen: froze
         return literal
     match expression:
         case ast.Name():
+            if context.static_resource_provenance.dynamic_namespace:
+                return None
             value = _bound_value(expression, context)
             return _query_text(value, context, seen=seen) if value is not None else None
         case ast.Call(func=ast.Attribute(attr="format", value=value)):

{sarj_python_lint-1.109.0 → sarj_python_lint-1.110.0}/src/sarj_python_lint/rules/no_custom_control_flow_exception.py

@@ -58,9 +58,9 @@ class NoCustomControlFlowException(Rule):
     code = "SARJ542"
     documentation = RuleDocumentation(
         default_level=Severity.WARNING,
-        summary="Return typed outcomes for expected domain failures instead of name-only exceptions.",
+        summary="Return typed outcomes for expected domain failures instead of marker or fixed-message exceptions.",
         rationale=(
-            "An empty custom exception creates another control-flow type without declaring failure data in "
+            "A marker or fixed-message custom exception creates another control-flow type without declaring failure data in "
             "the function's return contract. Expected domain outcomes can often use tagged result variants "
             "that callers handle explicitly, while exceptional failures and framework rejection still need exceptions."
         ),
@@ -73,7 +73,7 @@ class NoCustomControlFlowException(Rule):
         category=RuleCategory.ARCHITECTURE,
         autofix=AutofixPolicy.NONE,
         limitations=(
-            "This review warning checks stable module-level local Exception/ValueError subclasses whose bodies contain only pass, ellipsis or docstring expressions, including direct from-builtins exception imports and empty local subclasses of those markers. A source-visible direct raise of the class or its constructor is required; imported errors, payload-bearing classes, methods, decorators, generic/ambiguous bases and unused definitions abstain.",
+            "This review warning checks stable module-level Exception/ValueError markers and fixed-message subclasses whose only behavior is a zero-argument initializer calling super().__init__ with one literal string. A source-visible direct raise is required. Fixed-message subclasses of a directly imported base also qualify for review; imported base semantics remain a manual contract check. Payload fields, dynamic messages, extra behavior, decorators, generic/ambiguous bases and unused definitions abstain.",
             "Raising a ValueError-derived marker from an import-proven Pydantic field/model validator or legacy validator preserves that rejection protocol. Direct synchronous module callbacks used only as Annotated validator metadata on plain direct BaseModel fields, and stable nonescaping direct nested helpers, also preserve rejection; lexical helper ownership is bounded to 32 levels. Unknown external bases and visible mutations or escapes of the class or a local base to registrations, callbacks or other value consumers abstain; HTTPException and other framework-required exception types remain valid.",
             "Expectedness is not inferred from a name, message or prefix. Genuine exceptional markers may also match and require review rather than conversion. Cross-module callers and registrations, indirect raises, dynamically mutated namespaces and class aliases are not inferred. Only simple stable module assignment aliases and nongeneric annotation aliases consumed directly by model fields are followed. Explicit string annotations, custom model hooks, async/generator callbacks, escaped helpers and broader call graphs are not followed. Generic lexical resolution can miss a module marker shadowed only in a method's class namespace.",
             "Tests, generated and vendor code are excluded. No automatic rewrite is safe: a result return must preserve failure handling and transaction/resource unwinding. SARJ435 separately reviews joined-string reason identities.",
@@ -144,7 +144,7 @@ class NoCustomControlFlowException(Rule):
                     marker.lineno,
                     marker.col_offset + 1,
                     self.code,
-                    f"Review `{marker.name}`: it adds only an exception identity and is directly raised. "
+                    f"Review `{marker.name}`: it adds only an exception identity or fixed message and is directly raised. "
                     "If this is an expected domain outcome, return a typed tagged result; preserve genuine "
                     "exceptional failures, validation and framework contracts.",
                     severity=Severity.WARNING,
@@ -158,17 +158,15 @@ def _markers(context: PythonFileContext, provenance: ResourceProvenance) -> dict
         return {}
     markers: dict[str, ast.ClassDef] = {}
     for node in context.tree.body:
-        if not isinstance(node, ast.ClassDef) or not _name_only(node):
+        if not isinstance(node, ast.ClassDef) or not _marker_body(node):
             continue
         if provenance.binding(node.name, node) is not node:
             continue
         base = node.bases[0]
-        local = (
-            isinstance(base, ast.Name)
-            and provenance.binding(base.id, base) is markers.get(base.id)
-            and base.id in markers
-        )
-        if not (local or _builtin_base(base, context, provenance)):
+        fixed_message = any(isinstance(member, ast.FunctionDef) for member in node.body)
+        if not _marker_base(base, markers, context, fixed_message=fixed_message):
+            continue
+        if fixed_message and not context.imports.builtin_is_unshadowed("super"):
             continue
         if node.name in provenance.mutated or node.name in provenance.external_bindings:
             continue
@@ -178,7 +176,22 @@ def _markers(context: PythonFileContext, provenance: ResourceProvenance) -> dict
     return markers
 
 
-def _name_only(node: ast.ClassDef) -> bool:
+def _marker_base(
+    base: ast.expr, markers: dict[str, ast.ClassDef], context: PythonFileContext, *, fixed_message: bool
+) -> bool:
+    provenance = context.static_resource_provenance
+    local = isinstance(base, ast.Name) and base.id in markers and provenance.binding(base.id, base) is markers[base.id]
+    if local or _builtin_base(base, context, provenance):
+        return True
+    imported = provenance.runtime_import_name(base)
+    return (
+        fixed_message
+        and imported is not None
+        and not imported.startswith(("builtins.", "asyncio.", "fastapi.", "starlette.", "concurrent.futures."))
+    )
+
+
+def _marker_body(node: ast.ClassDef) -> bool:
     return (
         len(node.bases) == 1
         and not node.decorator_list
@@ -186,6 +199,7 @@ def _name_only(node: ast.ClassDef) -> bool:
         and not node.type_params
         and all(
             isinstance(member, ast.Pass)
+            or (isinstance(member, ast.FunctionDef) and _fixed_message_initializer(member))
             or (
                 isinstance(member, ast.Expr)
                 and isinstance(member.value, ast.Constant)
@@ -196,6 +210,29 @@ def _name_only(node: ast.ClassDef) -> bool:
     )
 
 
+def _fixed_message_initializer(node: ast.FunctionDef) -> bool:
+    arguments = [*node.args.posonlyargs, *node.args.args]
+    if node.name != "__init__" or node.decorator_list or node.type_params or len(arguments) != 1:
+        return False
+    if node.args.vararg or node.args.kwarg or node.args.kwonlyargs or node.args.defaults:
+        return False
+    match node.body:
+        case [
+            ast.Expr(
+                value=ast.Call(
+                    func=ast.Attribute(
+                        value=ast.Call(func=ast.Name(id="super"), args=[], keywords=[]), attr="__init__"
+                    ),
+                    args=[ast.Constant(value=str())],
+                    keywords=[],
+                )
+            )
+        ]:
+            return True
+        case _:
+            return False
+
+
 def _builtin_namespace_safe(context: PythonFileContext) -> bool:
     # Direct exception imports expose immutable class objects.
     for node in context.nodes(ast.Import, ast.ImportFrom, ast.Name):
@@ -250,7 +287,7 @@ def _value_error_marker(marker: ast.ClassDef, context: PythonFileContext, proven
         ) or provenance.imported(base, "builtins.ValueError"):
             return True
         bound = provenance.binding(base.id, base) if isinstance(base, ast.Name) else None
-        if not isinstance(bound, ast.ClassDef) or not _name_only(bound):
+        if not isinstance(bound, ast.ClassDef) or not _marker_body(bound):
             return False
         current = bound
     return False

sarj_python_lint-1.110.0/src/sarj_python_lint/rules/no_psycopg_execution_in_loop.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import ast
+from pathlib import PurePosixPath
+from typing import TYPE_CHECKING, final, override
+
+from sarj_python_lint.rule_base import (
+    AutofixPolicy,
+    Diagnostic,
+    ExampleFile,
+    ExampleOutcome,
+    Rule,
+    RuleCategory,
+    RuleDocumentation,
+    RuleExample,
+    Severity,
+    is_suppressed,
+)
+from sarj_python_lint.rules._store_writes import known_single_iteration
+from sarj_python_lint.rules.no_psycopg_execution_outside_injected_owner import psycopg_execution_calls
+
+
+if TYPE_CHECKING:
+    from sarj_python_lint._file_context import PythonFileContext
+
+
+_BAD = "from psycopg import AsyncConnection\nasync def remove(connection: AsyncConnection, rows):\n    for row in rows:\n        await connection.execute('DELETE FROM item WHERE id = %s', (row.id,))\n"
+_GOOD = "from psycopg import AsyncConnection\nasync def remove(connection: AsyncConnection, rows):\n    identifiers = [row.id for row in rows]\n    await connection.execute('DELETE FROM item WHERE id = ANY(%s)', (identifiers,))\n"
+
+
+@final
+class NoPsycopgExecutionInLoop(Rule):
+    id = "no-psycopg-execution-in-loop"
+    code = "SARJ560"
+    documentation = RuleDocumentation(
+        default_level=Severity.WARNING,
+        summary="Use bounded bulk queries instead of executing Psycopg operations inside item loops.",
+        rationale="Executing a database operation for each input item makes round trips scale with collection size, including loops that prepare each row before executing.",
+        remediation="Collect inputs and use a bounded set-based query, typed bulk store operation or executemany batch. Preserve tenant checks, revision predicates, transaction boundaries, returned rows, ordering and deliberate sequential effects.",
+        category=RuleCategory.PERFORMANCE,
+        autofix=AutofixPolicy.NONE,
+        limitations=(
+            "Checks import-proven Psycopg execute calls in for/async-for bodies and repeated comprehension expressions, including injected pools, connections and cursors. Explicit executemany batch loops remain valid for bounded chunking.",
+            "In-memory preparation, one-shot iteration inputs, known zero/single-item loops, deferred nested functions, unrelated execute methods and generated code are excluded. While retry/stream loops and interprocedural helper execution are not inferred.",
+            "SARJ518 owns its narrower invariant-write cases, so one location receives only that specific executemany diagnostic. Unknown SQL and result-consuming loops still require bulk-query review; no automatic rewrite changes database semantics.",
+        ),
+        examples=(
+            RuleExample(
+                example_id="per-item-write",
+                title="A connection executes once per item",
+                outcome=ExampleOutcome.MATCH,
+                files=(ExampleFile.python("app/store.py", _BAD),),
+                focus_path=PurePosixPath("app/store.py"),
+                expected_count=1,
+                public=True,
+            ),
+            RuleExample(
+                example_id="set-based-write",
+                title="One query consumes the collected identifiers",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(ExampleFile.python("app/store.py", _GOOD),),
+                focus_path=PurePosixPath("app/store.py"),
+                expected_count=0,
+                public=True,
+            ),
+        ),
+    )
+    description = documentation.summary
+
+    @override
+    def check_context(self, context: PythonFileContext) -> list[Diagnostic]:
+        if context.generated or context.tree is None:
+            return []
+        calls = [
+            call
+            for call in psycopg_execution_calls(context, include_injected=True, include_probes=False)
+            if isinstance(call.func, ast.Attribute) and call.func.attr == "execute" and _repeated(call, context)
+        ]
+        if not calls:
+            return []
+        unique = {(call.lineno, call.col_offset): call for call in calls}
+        return [
+            Diagnostic(
+                context.path,
+                call.lineno,
+                call.col_offset + 1,
+                self.code,
+                "This item loop executes a Psycopg operation per iteration; collect inputs and prefer a bounded bulk query or bulk store method, preserving transaction, result and failure semantics.",
+                severity=Severity.WARNING,
+            )
+            for call in unique.values()
+            if not is_suppressed(context.source_lines, call.lineno, self.code)
+        ]
+
+
+def _repeated(call: ast.Call, context: PythonFileContext) -> bool:
+    child: ast.AST = call
+    parent = context.parents.get(child)
+    while parent is not None:
+        if isinstance(parent, ast.FunctionDef | ast.AsyncFunctionDef | ast.Lambda | ast.ClassDef):
+            return False
+        if (
+            isinstance(parent, ast.For | ast.AsyncFor)
+            and child in parent.body
+            and not known_single_iteration(parent.iter)
+        ):
+            return True
+        if isinstance(parent, ast.comprehension):
+            owner = context.parents.get(parent)
+            if child in parent.ifs or (
+                child is parent.iter
+                and isinstance(owner, ast.ListComp | ast.SetComp | ast.DictComp | ast.GeneratorExp)
+                and owner.generators.index(parent) > 0
+            ):
+                return True
+        if isinstance(parent, ast.ListComp | ast.SetComp | ast.GeneratorExp) and child is parent.elt:
+            return True
+        if isinstance(parent, ast.DictComp) and child in {parent.key, parent.value}:
+            return True
+        child, parent = parent, context.parents.get(parent)
+    return False

{sarj_python_lint-1.109.0 → sarj_python_lint-1.110.0}/src/sarj_python_lint/rules/no_psycopg_execution_outside_injected_owner.py

@@ -156,12 +156,26 @@ class NoPsycopgExecutionOutsideInjectedOwner(Rule):
 
 def psycopg_execution_calls(
     context: PythonFileContext, *, include_injected: bool, include_probes: bool
+) -> list[ast.Call]:
+    return _psycopg_operation_calls(
+        context, include_injected=include_injected, include_probes=include_probes, operations=_EXECUTE_METHODS
+    )
+
+
+def psycopg_cursor_calls(context: PythonFileContext) -> list[ast.Call]:
+    return _psycopg_operation_calls(
+        context, include_injected=True, include_probes=True, operations=frozenset({"cursor"})
+    )
+
+
+def _psycopg_operation_calls(
+    context: PythonFileContext, *, include_injected: bool, include_probes: bool, operations: frozenset[str]
 ) -> list[ast.Call]:
     tree = context.tree
     if tree is None:
         return []
     if not any(
-        isinstance(call.func, ast.Attribute) and call.func.attr in _EXECUTE_METHODS for call in context.nodes(ast.Call)
+        isinstance(call.func, ast.Attribute) and call.func.attr in operations for call in context.nodes(ast.Call)
     ):
         return []
     mutated_modules: frozenset[str] | None = frozenset()
@@ -184,6 +198,7 @@ def psycopg_execution_calls(
                 include_probes=include_probes,
                 track_cursor_parameters=include_injected or scope.owner is None,
                 constructor=scope.owner is not None and scope.function.name == "__init__",
+                operations=operations,
             ).analyze(scope.function)
         )
     return calls
@@ -495,6 +510,7 @@ class _FunctionAnalyzer:
         include_probes: bool,
         track_cursor_parameters: bool,
         constructor: bool,
+        operations: frozenset[str],
     ) -> None:
         self._types = types
         self._annotation_types = annotation_types
@@ -503,6 +519,7 @@ class _FunctionAnalyzer:
         self._include_probes = include_probes
         self._track_cursor_parameters = track_cursor_parameters
         self._constructor = constructor
+        self._operations = operations
         self._findings: list[ast.Call] = []
         self._shadowed: set[str] = set()
 
@@ -673,7 +690,7 @@ class _FunctionAnalyzer:
             def visit_Call(self, node: ast.Call) -> None:
                 if (
                     isinstance(node.func, ast.Attribute)
-                    and node.func.attr in _EXECUTE_METHODS
+                    and node.func.attr in analyzer._operations
                     and analyzer._expression_origin(node.func.value, state) in analyzer._allowed_origins
                     and (analyzer._include_probes or not _is_connection_probe(node))
                 ):