sarj-python-lint 1.22.1__tar.gz → 1.24.0__tar.gz

{sarj_python_lint-1.22.1 → sarj_python_lint-1.24.0}/PKG-INFO

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

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

{sarj_python_lint-1.22.1 → sarj_python_lint-1.24.0}/src/sarj_python_lint/rules/no_psycopg_execution_outside_injected_owner.py

@@ -133,18 +133,8 @@ class NoPsycopgExecutionOutsideInjectedOwner(Rule):
             or _is_operational_path(path)
         ):
             return []
-        tree = context.tree
-        if not isinstance(tree, ast.Module):
-            return []
-        types = _type_index(tree)
-        ownership = {
-            node: _class_ownership(node, types) for node in context.nodes(ast.AST) if isinstance(node, ast.ClassDef)
-        }
         source_lines = context.source_lines
-        calls: list[ast.Call] = []
-        for scope in _function_scopes(tree):
-            owned = ownership[scope.owner] if scope.owner is not None else _ClassOwnership(frozenset(), frozenset())
-            calls.extend(_FunctionAnalyzer(types, owned).analyze(scope.function))
+        calls = psycopg_execution_calls(context, include_injected=False, include_probes=False)
         unique = {(call.lineno, call.col_offset): call for call in calls}
         return [
             Diagnostic(
@@ -163,6 +153,25 @@ class NoPsycopgExecutionOutsideInjectedOwner(Rule):
         ]
 
 
+def psycopg_execution_calls(
+    context: PythonFileContext, *, include_injected: bool, include_probes: bool
+) -> list[ast.Call]:
+    tree = context.tree
+    if tree is None:
+        return []
+    types = _type_index(tree)
+    ownership = {node: _class_ownership(node, types) for node in context.nodes(ast.ClassDef)}
+    calls: list[ast.Call] = []
+    for scope in _function_scopes(tree):
+        owned = ownership[scope.owner] if scope.owner is not None else _ClassOwnership(frozenset(), frozenset())
+        calls.extend(
+            _FunctionAnalyzer(types, owned, include_injected=include_injected, include_probes=include_probes).analyze(
+                scope.function
+            )
+        )
+    return calls
+
+
 def _type_index(tree: ast.Module) -> _TypeIndex:
     counts = _module_binding_counts(tree)
     aliases = _module_type_aliases(tree, counts)
@@ -416,9 +425,13 @@ def _function_scopes(tree: ast.Module) -> list[_FunctionScope]:
 
 @final
 class _FunctionAnalyzer:
-    def __init__(self, types: _TypeIndex, ownership: _ClassOwnership) -> None:
+    def __init__(
+        self, types: _TypeIndex, ownership: _ClassOwnership, *, include_injected: bool, include_probes: bool
+    ) -> None:
         self._types = types
         self._ownership = ownership
+        self._allowed_origins = frozenset(_Origin) if include_injected else frozenset({_Origin.EXTERNAL})
+        self._include_probes = include_probes
         self._findings: list[ast.Call] = []
         self._shadowed: set[str] = set()
 
@@ -578,8 +591,8 @@ class _FunctionAnalyzer:
                 if (
                     isinstance(node.func, ast.Attribute)
                     and node.func.attr in _EXECUTE_METHODS
-                    and analyzer._expression_origin(node.func.value, state) is _Origin.EXTERNAL
-                    and not _is_connection_probe(node)
+                    and analyzer._expression_origin(node.func.value, state) in analyzer._allowed_origins
+                    and (analyzer._include_probes or not _is_connection_probe(node))
                 ):
                     analyzer._findings.append(node)
                 self.generic_visit(node)

{sarj_python_lint-1.22.1 → sarj_python_lint-1.24.0}/src/sarj_python_lint/rules/no_raw_connection_in_tests.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import ast
 from pathlib import PurePosixPath
+import re
 from typing import TYPE_CHECKING, ClassVar, final, override
 
 from sarj_python_lint.rule_base import (
@@ -14,9 +15,12 @@ from sarj_python_lint.rule_base import (
     RuleDocumentation,
     RuleExample,
     Severity,
+    is_suppressed,
 )
 from sarj_python_lint.rules._ast_index import walk as walk_ast
 from sarj_python_lint.rules._paths import is_test_path, is_test_support_path
+from sarj_python_lint.rules._sql import sql_string_value, strip_sql_noise
+from sarj_python_lint.rules.no_psycopg_execution_outside_injected_owner import psycopg_execution_calls
 
 
 if TYPE_CHECKING:
@@ -26,6 +30,17 @@ if TYPE_CHECKING:
 
 
 _POOL_TYPES = frozenset({"AsyncConnectionPool", "ConnectionPool"})
+_SQL_METHODS = frozenset(
+    {"execute", "executemany", "executescript", "exec_driver_sql", "fetch", "fetchrow", "fetchval", "query", "command"}
+)
+_QUERY_KEYWORDS = frozenset({"query", "sql", "statement", "command", "operation"})
+_SQL_START = re.compile(
+    r"\A\s*(?:SELECT\b|WITH\s+\S+[\s\S]*?\bAS\s*\(|INSERT\s+INTO\b|"
+    r"UPDATE\s+\S+[\s\S]*?\bSET\b|DELETE\s+FROM\b|TRUNCATE\b|"
+    r"(?:CREATE|ALTER|DROP)\s+(?:TABLE|INDEX|SCHEMA|VIEW|FUNCTION|TRIGGER)\b|"
+    r"LOCK\s+TABLE\b|SET\s+(?:LOCAL|TRANSACTION)\b)",
+    re.IGNORECASE,
+)
 
 
 @final
@@ -34,34 +49,35 @@ class NoRawConnectionInTests(Rule):
     code = "SARJ429"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
         default_level=Severity.ERROR,
-        summary="Do not acquire raw database connections in tests.",
+        summary="Do not execute raw SQL or acquire raw database connections in tests.",
         rationale=(
             "Tests that reach through a pool couple assertions and setup to persistence internals, bypass the "
             "application boundary, and duplicate transaction ownership."
         ),
         remediation=(
-            "Exercise the owning store/service API or expose a narrow test-support fixture. Use an exact SARJ429 "
-            "suppression for a test whose purpose is explicitly connection or transaction behavior."
+            "Exercise the owning store/service API. Do not move SQL into a test-only probe to hide it. Use an exact "
+            "SARJ429 suppression for deliberate database bootstrap, migration or transaction fault testing."
         ),
         category=RuleCategory.TESTING,
         autofix=AutofixPolicy.NONE,
+        aliases=("no-raw-sql-in-tests",),
         limitations=(
-            "Only collected test modules outside conftest.py, conventional shared test-support modules, and migration-test trees are inspected.",
-            "A receiver is reported only when a parameter, annotated local, or constructor call proves it is a psycopg ConnectionPool or AsyncConnectionPool.",
-            "Pytest fixtures may use a connection internally for setup and cleanup, but fixtures that return or yield the connection remain reportable.",
+            "Raw SQL execution is checked in tests, conftest.py, shared test-support helpers and migration tests; generated code is excluded. Standalone SQL examples and store/service calls are not execution.",
+            "Import-proven Psycopg connection/pool flows, including constructor-injected members, aliases and dynamic query arguments, are followed. SQL-shaped literals in execute/query/fetch-like calls are also checked across drivers, including concatenation, f-strings and import-proven SQL/text constructors.",
+            "Opaque non-Psycopg builders and interprocedural receiver flows are not inferred. Raw connection acquisition keeps its existing fixture/support exclusions when no SQL execution is found in that scope.",
         ),
         examples=(
             RuleExample(
-                example_id="test-acquires-pool-connection",
-                title="A test helper reaches directly through its pool",
+                example_id="test-probe-executes-sql",
+                title="An injected test probe still bypasses the owning store",
                 outcome=ExampleOutcome.MATCH,
                 files=(
                     ExampleFile.python(
-                        "tests/test_orders.py",
-                        "async def load_rows(pool: AsyncConnectionPool):\n    async with pool.connection() as conn:\n        return await conn.execute('SELECT 1')\n",
+                        "tests/fixtures/probe.py",
+                        "from psycopg_pool import AsyncConnectionPool\n\nclass Probe:\n    def __init__(self, pool: AsyncConnectionPool):\n        self._pool = pool\n\n    async def seed(self):\n        async with self._pool.connection() as conn:\n            await conn.execute('INSERT INTO jobs (id) VALUES (%s)', (job_id,))\n",
                     ),
                 ),
-                focus_path=PurePosixPath("tests/test_orders.py"),
+                focus_path=PurePosixPath("tests/fixtures/probe.py"),
                 expected_count=1,
                 public=True,
             ),
@@ -86,6 +102,20 @@ class NoRawConnectionInTests(Rule):
     @override
     def check_context(self, context: PythonFileContext) -> list[Diagnostic]:
         path = context.path
+        if context.generated or context.tree is None:
+            return []
+        sql_calls = _test_sql_calls(context)
+        diagnostics = [
+            Diagnostic(
+                path=path,
+                line=node.lineno,
+                col=node.col_offset + 1,
+                code=self.code,
+                message="test code executes raw SQL; use the owning store/service API or an exact SARJ429 exception for deliberate database-level testing",
+            )
+            for node in sql_calls
+            if not is_suppressed(context.source_lines, node.lineno, self.code)
+        ]
         excluded_path = any(
             (
                 not is_test_path(path),
@@ -95,17 +125,19 @@ class NoRawConnectionInTests(Rule):
                 _is_migration_test(path),
             )
         )
-        if excluded_path or context.generated:
-            return []
+        if excluded_path:
+            return sorted(diagnostics, key=lambda item: (item.line, item.col))
         tree = context.tree
         if tree is None:
             return []
-        diagnostics: list[Diagnostic] = []
+        sql_scopes = {_containing_scope(context, node) for node in sql_calls}
         scopes: list[ast.Module | ast.FunctionDef | ast.AsyncFunctionDef] = [
             tree,
             *(node for node in context.nodes(ast.AST) if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))),
         ]
         for scope in scopes:
+            if scope in sql_scopes:
+                continue
             pool_names = _proven_pool_names(scope)
             diagnostics.extend(
                 Diagnostic(
@@ -129,6 +161,63 @@ class NoRawConnectionInTests(Rule):
         return sorted(diagnostics, key=lambda item: (item.line, item.col))
 
 
+def _test_sql_calls(context: PythonFileContext) -> list[ast.Call]:
+    path = context.path
+    if not (is_test_path(path) or is_test_support_path(path) or "test_support" in path.parts):
+        return []
+    candidates = [
+        node
+        for node in context.nodes(ast.Call)
+        if isinstance(node.func, ast.Attribute) and node.func.attr in _SQL_METHODS
+    ]
+    if not candidates:
+        return []
+    calls: list[ast.Call] = []
+    for node in candidates:
+        value = _execution_sql(node, context)
+        if value is not None and _SQL_START.search(strip_sql_noise(value)):
+            calls.append(node)
+    if any(
+        isinstance(node.func, ast.Attribute) and node.func.attr in {"execute", "executemany"} and node not in calls
+        for node in candidates
+    ):
+        calls.extend(psycopg_execution_calls(context, include_injected=True, include_probes=True))
+    unique = {(call.lineno, call.col_offset): call for call in calls}
+    return sorted(unique.values(), key=lambda item: (item.lineno, item.col_offset))
+
+
+def _execution_sql(call: ast.Call, context: PythonFileContext) -> str | None:
+    if call.args:
+        return _literal_sql(call.args[0], context)
+    for keyword in call.keywords:
+        if keyword.arg in _QUERY_KEYWORDS:
+            return _literal_sql(keyword.value, context)
+    return None
+
+
+def _literal_sql(node: ast.expr | None, context: PythonFileContext) -> str | None:
+    if node is None:
+        return None
+    if isinstance(node, ast.Call):
+        if isinstance(node.func, ast.Attribute) and node.func.attr == "format":
+            return _literal_sql(node.func.value, context)
+        if node.args and (
+            context.imports.resolves(node.func, sources=frozenset({"psycopg.sql"}), symbol="SQL")
+            or context.imports.resolves(node.func, sources=frozenset({"sqlalchemy"}), symbol="text")
+        ):
+            return sql_string_value(node.args[0])
+    return sql_string_value(node)
+
+
+def _containing_scope(context: PythonFileContext, node: ast.AST) -> ast.AST:
+    current = node
+    while (parent := context.parents.get(current)) is not None:
+        if isinstance(parent, (ast.Module, ast.FunctionDef, ast.AsyncFunctionDef)):
+            return parent
+        current = parent
+    return current
+
+
 def _is_non_collected_test_support(path: Path) -> bool:
     return "tests" in path.parts and not (path.name.startswith("test_") or path.name.endswith("_test.py"))
 

{sarj_python_lint-1.22.1 → sarj_python_lint-1.24.0}/src/sarj_python_lint/rules/prefer_collection_comprehension.py

@@ -96,7 +96,7 @@ class PreferCollectionComprehension(Rule):
             "Only function-local, adjacent empty initializers and one synchronous single-purpose loop are checked.",
             (
                 "The rule fills gaps left by Ruff PERF401, PERF403, and FURB142: derived dict projections, "
-                "destructured list projections, narrowly filtered computed list candidates, and filtered set "
+                "constructor-valued dict projections, destructured list projections, narrowly filtered computed list candidates, and filtered set "
                 "builders."
             ),
             (
@@ -115,6 +115,41 @@ class PreferCollectionComprehension(Rule):
             ),
         ),
         examples=(
+            RuleExample(
+                example_id="constructor-dict-projection-loop",
+                title="Build constructor-valued dictionaries directly",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/views.py",
+                        "def views(rows, labels):\n"
+                        "    result = {}\n"
+                        "    for row in rows:\n"
+                        "        result[row.id] = EntryView(id=row.id, label=labels.get(row.id))\n"
+                        "    return result\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("app/views.py"),
+                expected_count=1,
+                public=True,
+                scenario="constructor-dict",
+            ),
+            RuleExample(
+                example_id="constructor-dict-comprehension",
+                title="Keep constructor-valued dictionaries declarative",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/views.py",
+                        "def views(rows, labels):\n"
+                        "    return {row.id: EntryView(id=row.id, label=labels.get(row.id)) for row in rows}\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("app/views.py"),
+                expected_count=0,
+                public=True,
+                scenario="constructor-dict",
+            ),
             RuleExample(
                 example_id="derived-dict-projection-loop",
                 title="Build a projected dictionary directly",
@@ -331,6 +366,7 @@ def _loop_replacement(
                         _CollectionKind.DICT,
                         f"{{{ast.unparse(key)}: {ast.unparse(value)} for {ast.unparse(loop.target)} "
                         f"in {ast.unparse(loop.iter)}}}",
+                        allow_multiline=isinstance(value, ast.Call),
                     )
             case _:
                 pass
@@ -520,8 +556,20 @@ def _valid_dict_projection(key: ast.expr, value: ast.expr, name: str, bound_name
         return False
     return (
         _simple_projection(key, bound_names)
-        and _simple_projection(value, bound_names)
-        and (_is_derived(key) or _is_derived(value))
+        and (_simple_projection(value, bound_names) or _constructor_projection(value))
+        and (_is_derived(key) or _is_derived(value) or isinstance(value, ast.Call))
+    )
+
+
+def _constructor_projection(node: ast.expr) -> bool:
+    if not isinstance(node, ast.Call) or _contains_prohibited_expression(node):
+        return False
+    return all(
+        _dotted_name(call.func)
+        and not any(isinstance(argument, ast.Starred) for argument in call.args)
+        and all(keyword.arg is not None for keyword in call.keywords)
+        for call in walk_ast(node)
+        if isinstance(call, ast.Call)
     )
 
 
@@ -553,9 +601,12 @@ def _target_binding_is_observable(owner: _Callable, names: frozenset[str], loop:
     if _declares_external(owner, names) or any(_loads_name(loop.iter, name) for name in names):
         return True
     end_line = loop.end_lineno or loop.lineno
+    comprehension_locals = _comprehension_local_nodes(owner, names)
     for node in walk_ast(owner):
         if isinstance(node, ast.arg) and node.arg in names:
             return True
+        if id(node) in comprehension_locals:
+            continue
         if (
             isinstance(node, ast.Name)
             and node.id in names
@@ -568,6 +619,29 @@ def _target_binding_is_observable(owner: _Callable, names: frozenset[str], loop:
     return False
 
 
+def _comprehension_local_nodes(owner: _Callable, names: frozenset[str]) -> set[int]:
+    local_nodes: set[int] = set()
+    for node in walk_ast(owner):
+        if not isinstance(node, (ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)):
+            continue
+        # Multiple generators can read an outer binding before a later generator shadows it.
+        if len(node.generators) != 1:
+            continue
+        bound = _bound_names(node.generators[0].target) & names
+        if not bound:
+            continue
+        # The first iterable runs in the surrounding scope; targets and remaining expressions are local.
+        scoped: list[ast.AST] = [node.generators[0].target, *node.generators[0].ifs]
+        scoped.extend((node.key, node.value) if isinstance(node, ast.DictComp) else (node.elt,))
+        local_nodes.update(
+            id(child)
+            for expression in scoped
+            for child in walk_ast(expression)
+            if isinstance(child, ast.Name) and child.id in bound
+        )
+    return local_nodes
+
+
 def _declares_external(owner: _Callable, names: frozenset[str]) -> bool:
     return any(
         isinstance(node, (ast.Global, ast.Nonlocal)) and not names.isdisjoint(node.names) for node in walk_ast(owner)
@@ -604,7 +678,24 @@ def _replacement_fits(init: _Init, name: str, expression: str, *, allow_multilin
         prefix = f"{name}: {ast.unparse(init.annotation)} = "
     if init.col_offset + len(prefix) + len(expression) <= _MAX_REPLACEMENT_WIDTH:
         return True
-    if not allow_multiline or not (expression.startswith("[") and expression.endswith("]")):
+    if not allow_multiline:
+        return False
+    if expression.startswith("{"):
+        comprehension = ast.parse(expression, mode="eval").body
+        if not isinstance(comprehension, ast.DictComp) or not isinstance(comprehension.value, ast.Call):
+            return False
+        call = comprehension.value
+        generator = comprehension.generators[0]
+        lines = (
+            f"{ast.unparse(comprehension.key)}: {ast.unparse(call.func)}(",
+            *(f"    {ast.unparse(argument)}," for argument in call.args),
+            *(f"    {keyword.arg}={ast.unparse(keyword.value)}," for keyword in call.keywords),
+            f"for {ast.unparse(generator.target)} in {ast.unparse(generator.iter)}",
+        )
+        return init.col_offset + len(prefix) + 1 <= _MAX_REPLACEMENT_WIDTH and all(
+            init.col_offset + 4 + len(line) <= _MAX_REPLACEMENT_WIDTH for line in lines
+        )
+    if not (expression.startswith("[") and expression.endswith("]")):
         return False
     content = expression[1:-1]
     return (