sarj-python-lint 1.99.0__tar.gz → 1.101.0__tar.gz

{sarj_python_lint-1.99.0 → sarj_python_lint-1.101.0}/PKG-INFO

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

{sarj_python_lint-1.99.0 → sarj_python_lint-1.101.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "1.99.0"
+version = "1.101.0"
 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.5.0", "packaging==26.3", "ruff>=0.17.2", "sqlglot==30.24.0", "typer==0.27.3"]
+dependencies = ["sarj-rule-contracts==0.6.0", "packaging==26.3", "ruff>=0.17.2", "sqlglot==30.24.0", "typer==0.27.3"]
 
 [project.scripts]
 sarj-python-lint = "sarj_python_lint.__main__:main"

{sarj_python_lint-1.99.0 → sarj_python_lint-1.101.0}/src/sarj_python_lint/_autofix.py

@@ -2,13 +2,14 @@ from __future__ import annotations
 
 import ast
 from bisect import bisect_left, insort
+from dataclasses import dataclass
 from functools import cached_property
 from hashlib import sha256
 from io import StringIO
 from itertools import pairwise
 import re
 import tokenize
-from typing import TYPE_CHECKING, Final, NamedTuple
+from typing import TYPE_CHECKING, Final, Literal, NamedTuple
 from unicodedata import normalize
 
 from sarj_rule_contracts import TextEdit, apply_edits
@@ -80,6 +81,8 @@ _WALRUS_CODES = frozenset({"SARJ081", "SARJ432"})
 _JWT_POSITIONAL_PREFIX_ARGUMENTS = 3
 _STREAM_MIN_BODY_LENGTH = 3
 _CONSTANT_TRUE_DEPTH_LIMIT = 32
+# Bound accepted revisions; each rule still owns its work and replacement size.
+_MAX_FIX_PASSES: Final = 256
 _PURE_STRING_TRANSFORMS: Final[dict[str, str]] = {
     "strip": "stripped_value",
     "lower": "lowered_value",
@@ -1360,6 +1363,18 @@ _BUILDERS: Final[dict[str, Callable[[_Source, Diagnostic], list[TextEdit]]]] = {
 }
 
 
+@dataclass(frozen=True, slots=True)
+class _FixCandidate:
+    code: str
+    edits: tuple[TextEdit, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _FixPass:
+    edits: tuple[TextEdit, ...]
+    codes: tuple[str, ...]
+
+
 def fix_source(path: Path, source: str, *, rule_ids: Sequence[str] | None = None) -> str:
     from sarj_python_lint.__main__ import check_source  # ruff: ignore[import-outside-top-level] -- the CLI imports this entry point lazily.
 
@@ -1371,6 +1386,8 @@ def fix_source(path: Path, source: str, *, rule_ids: Sequence[str] | None = None
         # Only the closed alias builder owns aligned physical-line buffers and token coordinates here.
         rules = [rule for rule in rules if rule.code == "SARJ531"]
     seen: set[bytes] = set()
+    applied_codes: set[str] = set()
+    passes = 0
     current = source
     while (fingerprint := sha256(current.encode("utf-8")).digest()) not in seen:
         seen.add(fingerprint)
@@ -1380,30 +1397,43 @@ def fix_source(path: Path, source: str, *, rule_ids: Sequence[str] | None = None
         if not candidates:
             return current
         # Batch independent candidates; overlapping candidates get fresh offsets on the next pass.
-        updated = apply_edits(current, _coherent_edits(candidates))
+        selected_pass = _coherent_edits(candidates)
+        updated = apply_edits(current, selected_pass.edits)
         compile(updated, str(path), "exec", dont_inherit=True)
         if updated == current:
             return current
+        if passes == _MAX_FIX_PASSES:
+            raise _convergence_error(path, reason="pass budget exhausted", passes=passes, codes=applied_codes)
+        passes += 1
+        applied_codes.update(selected_pass.codes)
         current = updated
-    msg = f"Python autofixes did not converge: {path}"
-    raise ValueError(msg)
+    raise _convergence_error(path, reason="source cycle", passes=passes, codes=applied_codes)
+
+
+def _convergence_error(
+    path: Path, *, reason: Literal["pass budget exhausted", "source cycle"], passes: int, codes: set[str]
+) -> ValueError:
+    participants = ", ".join(sorted(codes)) or "none"
+    msg = f"Python autofixes did not converge: {path} ({reason}; passes={passes}; rules={participants})"
+    return ValueError(msg)
 
 
-def _candidate_edits(context: PythonFileContext, diagnostics: Sequence[Diagnostic]) -> list[list[TextEdit]]:
+def _candidate_edits(context: PythonFileContext, diagnostics: Sequence[Diagnostic]) -> list[_FixCandidate]:
     view = _Source(context, diagnostics)
     return [
-        edits
+        _FixCandidate(diagnostic.code, tuple(edits))
         for diagnostic in diagnostics
         if (builder := _BUILDERS.get(diagnostic.code)) is not None
         if (edits := builder(view, diagnostic))
     ]
 
 
-def _coherent_edits(candidates: list[list[TextEdit]]) -> list[TextEdit]:
+def _coherent_edits(candidates: list[_FixCandidate]) -> _FixPass:
     accepted: list[TextEdit] = []
+    codes: list[str] = []
     known: set[TextEdit] = set()
     for candidate in candidates:
-        additions = sorted(set(candidate) - known)
+        additions = sorted(set(candidate.edits) - known)
         if any(map(_overlap, additions, additions[1:], strict=False)):
             continue
         for edit in additions:
@@ -1416,7 +1446,9 @@ def _coherent_edits(candidates: list[list[TextEdit]]) -> list[TextEdit]:
             for edit in additions:
                 insort(accepted, edit)
             known.update(additions)
-    return accepted
+            if additions:
+                codes.append(candidate.code)
+    return _FixPass(tuple(accepted), tuple(dict.fromkeys(codes)))
 
 
 def _overlap(first: TextEdit, second: TextEdit) -> bool:

{sarj_python_lint-1.99.0 → sarj_python_lint-1.101.0}/src/sarj_python_lint/_parallel.py

@@ -143,19 +143,24 @@ def check_parallel(
             for path, source in loaded.items()
         )
         for result in pool.map(_check_file, items, chunksize=1, buffersize=workers * 4):
-            if result.needs_serial:
-                # Drain the actual worker results so another initializer/file
-                # failure cannot be disguised as a clean serial replay.
-                needs_serial = True
+            # Drain actual results after either replay signal so a later worker
+            # failure cannot be disguised as a clean serial replay.
+            if needs_serial:
                 continue
             resolutions.update(result.resolutions)
             modules.update(result.modules)
             # A worker cannot hit either order-dependent limit when the whole
             # union stays strictly below it. At the boundary, discard all output.
-            if not needs_serial and (
-                len(resolutions) >= LOCAL_SOURCE_CACHE_LIMIT or len(modules) >= LOCAL_SOURCE_CACHE_LIMIT
+            if (
+                result.needs_serial
+                or len(resolutions) >= LOCAL_SOURCE_CACHE_LIMIT
+                or len(modules) >= LOCAL_SOURCE_CACHE_LIMIT
             ):
-                return None
+                needs_serial = True
+                diagnostics.clear()
+                resolutions.clear()
+                modules.clear()
+                continue
             diagnostics.extend(result.diagnostics)
         return None if needs_serial else diagnostics
     finally:

{sarj_python_lint-1.99.0 → sarj_python_lint-1.101.0}/src/sarj_python_lint/rules/_copy_on_write.py

@@ -973,10 +973,8 @@ class CopyOnWriteAnalysis:
                 summaries[key] = _summary_value(_OwnershipSummary(alternatives))
             bindings[name] = summaries[key]
 
-    def _scan(self, statements: list[ast.stmt], bindings: dict[str, _Value]) -> None:
-        for statement in statements:
-            if self._statement(statement, bindings):
-                return
+    def _scan(self, statements: list[ast.stmt], bindings: dict[str, _Value]) -> bool:
+        return any(self._statement(statement, bindings) for statement in statements)
 
     def _statement(self, statement: ast.stmt, bindings: dict[str, _Value]) -> bool:
         match statement:
@@ -991,7 +989,7 @@ class CopyOnWriteAnalysis:
                     self._write(target, bindings)
                     self._bind(target, None, bindings)
             case ast.If():
-                self._branches(statement, bindings)
+                return self._branches(statement, bindings)
             case ast.For() | ast.AsyncFor():
                 self._for(statement, bindings)
             case ast.Expr(value=ast.Call() as call):
@@ -1026,16 +1024,16 @@ class CopyOnWriteAnalysis:
             self._write(target, bindings)
             self._bind(target, value, bindings)
 
-    def _branches(self, statement: ast.If, bindings: dict[str, _Value]) -> None:
+    def _branches(self, statement: ast.If, bindings: dict[str, _Value]) -> bool:
         self._expression(statement.test, bindings)
         branches: list[dict[str, _Value]] = []
         for positive, block in ((True, statement.body), (False, statement.orelse)):
             branch = dict(bindings)
             self._refine(statement.test, branch, positive=positive)
-            self._scan(block, branch)
-            if not block or not isinstance(block[-1], (ast.Return, ast.Raise)):
+            if not self._scan(block, branch):
                 branches.append(branch)
         self._join(branches, bindings)
+        return not branches
 
     def _for(self, statement: ast.For | ast.AsyncFor, bindings: dict[str, _Value]) -> None:
         self._expression(statement.iter, bindings)

{sarj_python_lint-1.99.0 → sarj_python_lint-1.101.0}/src/sarj_python_lint/rules/_namespace_access.py

@@ -48,7 +48,7 @@ def dynamic_namespace_access(
 def _namespace_api_aliases(nodes: Iterable[ast.AST]) -> set[str]:
     aliases = set(_NAMESPACE_APIS) | {"__builtins__"}
     for node in nodes:
-        if not isinstance(node, ast.ImportFrom) or node.module not in _MODULE_APIS:
+        if not isinstance(node, ast.ImportFrom) or node.level != 0 or node.module not in _MODULE_APIS:
             continue
         members = _MODULE_APIS[node.module]
         aliases.update(alias.asname or alias.name for alias in node.names if alias.name in members)

{sarj_python_lint-1.99.0 → sarj_python_lint-1.101.0}/src/sarj_python_lint/rules/_project_index.py

@@ -156,6 +156,11 @@ class SourceUnit:
     captured: CapturedSource | None = None
 
 
+@dataclass(frozen=True, slots=True)
+class _AmbiguousModuleSources:
+    paths: tuple[Path, ...]
+
+
 @dataclass(frozen=True, slots=True)
 class LoadedSource:
     path: Path
@@ -276,8 +281,18 @@ class ProjectIndexSet:
         self._bound_value_prefixes: dict[str, bool] = {}
         self._value_origins_incomplete = False
         self.import_namespace_mutations = ImportNamespaceMutations(WeakMethod(self._namespace_write_inventory))
-        by_module = {unit.module: unit for unit in units.values() if unit.module is not None}
-        self._by_module = MappingProxyType(by_module)
+        by_module: dict[str, dict[Path, SourceUnit]] = {}
+        for unit in units.values():
+            if unit.module is not None:
+                by_module.setdefault(unit.module, {})[unit.path] = unit
+        self._by_module = MappingProxyType(
+            {
+                module: next(iter(candidates.values()))
+                if len(candidates) == 1
+                else _AmbiguousModuleSources(tuple(candidates))
+                for module, candidates in by_module.items()
+            }
+        )
         classes: dict[SymbolRef, ClassSummary] = {}
         nominals: dict[str, set[SymbolRef]] = {}
         _collect_unit_symbols(units, classes, nominals)
@@ -429,7 +444,8 @@ class ProjectIndexSet:
         return False
 
     def source_unit(self, module: str) -> SourceUnit | None:
-        return self._by_module.get(module)
+        source = self._by_module.get(module)
+        return source if isinstance(source, SourceUnit) else None
 
     def _namespace_write_inventory(self) -> Mapping[str, _ImportNamespaceWrites]:
         def resolve(origin: SymbolRef) -> tuple[SymbolRef, ...] | None:

{sarj_python_lint-1.99.0 → sarj_python_lint-1.101.0}/src/sarj_python_lint/rules/_resource_provenance.py

@@ -308,7 +308,8 @@ class ResourceProvenance:
             or (
                 isinstance(parent, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef)
                 and node in parent.decorator_list
-                and self.context.imports.resolved_qualified_name(node) in {"typing.final", "typing_extensions.final"}
+                and self.context.imports.resolved_qualified_name(node)
+                in {"typing.final", "typing_extensions.final", "dataclasses.dataclass"}
             )
         )
 

{sarj_python_lint-1.99.0 → sarj_python_lint-1.101.0}/src/sarj_python_lint/rules/_sql.py

@@ -27,11 +27,18 @@ def is_store_module(path: Path) -> bool:
 
 
 def sql_string_value(node: ast.expr, *, interpolation_placeholder: str = " ") -> str | None:
+    try:
+        return _sql_string_value(node, interpolation_placeholder=interpolation_placeholder)
+    except RecursionError:
+        return None
+
+
+def _sql_string_value(node: ast.expr, *, interpolation_placeholder: str) -> str | None:
     if isinstance(node, ast.Constant) and isinstance(node.value, str):
         return node.value
     if isinstance(node, ast.BinOp) and isinstance(node.op, ast.Add):
-        left = sql_string_value(node.left, interpolation_placeholder=interpolation_placeholder)
-        right = sql_string_value(node.right, interpolation_placeholder=interpolation_placeholder)
+        left = _sql_string_value(node.left, interpolation_placeholder=interpolation_placeholder)
+        right = _sql_string_value(node.right, interpolation_placeholder=interpolation_placeholder)
         if left is not None and right is not None:
             return left + right
     if isinstance(node, ast.JoinedStr):

{sarj_python_lint-1.99.0 → sarj_python_lint-1.101.0}/src/sarj_python_lint/rules/_store_sql.py

@@ -46,7 +46,11 @@ class _MethodWrites:
 
 def store_queries(context: PythonFileContext) -> Iterator[StoreQuery]:
     if context.store_queries is None:
-        context.store_queries = tuple(recover_store_queries(context))
+        try:
+            queries = tuple(recover_store_queries(context))
+        except RecursionError:
+            queries = ()
+        context.store_queries = queries
     return iter(context.store_queries)
 
 

{sarj_python_lint-1.99.0 → sarj_python_lint-1.101.0}/src/sarj_python_lint/rules/complex_postgres_query_requires_architecture_review.py

@@ -85,7 +85,11 @@ def _is_query_context(node: ast.expr, parents: Mapping[ast.AST, ast.AST], roots:
 
 
 def _query_roots(
-    tree: ast.Module, parents: Mapping[ast.AST, ast.AST], *, node_index: NodeIndex | None = None
+    tree: ast.Module,
+    parents: Mapping[ast.AST, ast.AST],
+    *,
+    context: PythonFileContext,
+    node_index: NodeIndex | None = None,
 ) -> frozenset[int]:
     binding_counts: dict[tuple[int, str], int] = {}
     binding_values: dict[tuple[int, str], ast.expr] = {}
@@ -99,11 +103,12 @@ def _query_roots(
 
     constructor_imports = _postgres_sql_constructors(tree, parents, node_index=node_index)
     _query_binding_values(tree, parents, binding_values, node_index=node_index)
+    has_local_classes = bool(nodes(tree, ast.ClassDef, index=node_index))
 
     roots: set[int] = set()
     for call in nodes(tree, ast.Call, index=node_index):
         argument = _query_argument(call)
-        if argument is None:
+        if argument is None or (has_local_classes and _source_local_receiver(call, context)):
             continue
         owner = _scope(call, parents)
         constructors = _visible_constructors(owner, constructor_imports, parents, binding_counts, wildcard_scopes)
@@ -151,6 +156,21 @@ def _query_argument(call: ast.Call) -> ast.expr | None:
     return next((keyword.value for keyword in call.keywords if keyword.arg in _QUERY_KEYWORDS), None)
 
 
+def _source_local_receiver(call: ast.Call, context: PythonFileContext) -> bool:
+    if not isinstance(call.func, ast.Attribute) or not isinstance(call.func.value, (ast.Name, ast.Call)):
+        return False
+    provenance = context.static_resource_provenance
+    receiver: ast.expr | None = call.func.value
+    if isinstance(receiver, ast.Name):
+        binding = provenance.runtime_binding(receiver.id, call)
+        receiver = provenance.assignment_value(binding, call) if isinstance(binding, ast.Name) else None
+    return (
+        isinstance(receiver, ast.Call)
+        and isinstance(receiver.func, ast.Name)
+        and isinstance(provenance.runtime_binding(receiver.func.id, receiver), ast.ClassDef)
+    )
+
+
 def _postgres_sql_constructors(
     tree: ast.Module, parents: Mapping[ast.AST, ast.AST], *, node_index: NodeIndex | None = None
 ) -> frozenset[_ConstructorImport]:
@@ -261,13 +281,16 @@ class ComplexPostgresQueryRequiresArchitectureReview(Rule):
         autofix=AutofixPolicy.NONE,
         limitations=(
             "Only statically recoverable SQL passed to execute, executemany, fetch, fetchrow, fetchval, or prepare in non-test modules with explicit PostgreSQL imports is analyzed, regardless of module filename.",
-            "Execution receivers use a conventional database name or import-proven Psycopg ownership. Native execution additionally follows stable module/local SQL bindings and direct same-class query-forwarding wrappers; unknown receivers abstain.",
+            "Execution receivers use a conventional database name or import-proven Psycopg ownership. Conventional names are a heuristic and can warn on unrelated objects with matching methods. Native execution additionally follows stable module/local SQL bindings and direct same-class query-forwarding wrappers; unknown receivers abstain.",
+            "Modules mixing SQLite and PostgreSQL abstain for conventional receivers; import-proven Psycopg execution remains eligible.",
+            "Stable source-local class construction abstains from conventional receiver inference, including custom delegating instances unless native recovery independently proves execution.",
             "Conventional receivers follow one direct, unambiguous same-scope binding. Native Psycopg recovery may follow bounded stable lexical bindings, including module constants. Unexecuted constants, branch-local assignments, mutable attributes, containers and unknown dynamic composition abstain.",
-            "Review covers derived relations in every SELECT (including LATERAL, CTEs, predicates and writes), four explicit or comma joins, six query stages, three joins plus four stages, or 25 projections plus two joins. A self join over the same explicit table also merits review at 16 projected expressions.",
+            "Review covers derived relations in every SELECT (including LATERAL, CTEs, predicates and writes), four explicit or comma joins (including parenthesized joined tables), six query stages, three joins plus four stages, or 25 projections plus two joins. A self join over the same explicit table also merits review at 16 projected expressions.",
             "Derived-relation review requires grouping, HAVING or windowing combined with joins or nested reads; expression density is not a separate trigger.",
-            "Projection width alone is accepted, and UNION branches are measured independently; execution plans and production cardinality remain authoritative.",
-            "ClickHouse and BigQuery syntax is excluded per query, including in mixed-backend modules.",
+            "Projection width alone is accepted, and UNION branches are measured independently. Set operators do not add read stages beyond their SELECT blocks; execution plans and production cardinality remain authoritative.",
+            "Conventional receivers exclude ClickHouse and BigQuery syntax per query, including in mixed-backend modules. Import-proven Psycopg execution uses PostgreSQL parsing even when identifiers or function names overlap another dialect.",
             "The rule does not infer optimizer behavior, materialization, performance, data-model quality, or datastore placement.",
+            "SQL parsing and static query recovery abstain on recursion limits; deeply nested source can withhold native recovery for the file.",
         ),
         examples=(
             RuleExample(
@@ -351,12 +374,17 @@ class ComplexPostgresQueryRequiresArchitectureReview(Rule):
         tree = context.tree
         if tree is None:
             return []
-        if not _is_postgres_module(tree, node_index=context.node_index):
+        imports = _import_names(tree, node_index=context.node_index)
+        if not _has_import_prefix(imports, _POSTGRES_IMPORT_PREFIXES):
             return []
 
-        diagnostics = _conventional_findings(context, self.code)
+        diagnostics = (
+            []
+            if _has_import_prefix(imports, _AMBIGUOUS_RELATIONAL_IMPORT_PREFIXES)
+            else _conventional_findings(context, self.code)
+        )
         for query in store_queries(context):
-            signal = _query_architecture_signal(query.sql, path)
+            signal = _query_architecture_signal(query.sql, path, native_postgres=True)
             if signal is None:
                 continue
             node = query.node
@@ -372,7 +400,7 @@ def _conventional_findings(context: PythonFileContext, code: str) -> list[Diagno
     tree = context.tree
     if tree is None:
         return []
-    query_roots = _query_roots(tree, parents, node_index=context.node_index)
+    query_roots = _query_roots(tree, parents, context=context, node_index=context.node_index)
     diagnostics: list[Diagnostic] = []
     consumed: set[int] = set()
     for node in context.nodes(ast.Constant, ast.BinOp, ast.JoinedStr):
@@ -477,14 +505,13 @@ def _record_sql_constructors(
         )
 
 
-def _query_architecture_signal(text_value: str, path: Path) -> str | None:
+def _query_architecture_signal(text_value: str, path: Path, *, native_postgres: bool = False) -> str | None:
     sql_without_noise = strip_sql_noise(text_value)
-    if (
-        _QUERY_SHAPE.search(sql_without_noise) is None
-        or _CLICKHOUSE_SQL.search(sql_without_noise)
-        or _BIGQUERY_SQL.search(sql_without_noise)
-        or (is_store_module(path) and analytical_signal(sql_without_noise) is not None)
-    ):
+    if _QUERY_SHAPE.search(sql_without_noise) is None:
+        return None
+    if not native_postgres and (_CLICKHOUSE_SQL.search(sql_without_noise) or _BIGQUERY_SQL.search(sql_without_noise)):
+        return None
+    if is_store_module(path) and analytical_signal(sql_without_noise) is not None:
         return None
     return _parse_signal(text_value)
 
@@ -512,8 +539,8 @@ def _architecture_signal(statement: exp.Expr) -> str | None:
     maximum_joins = _maximum_query_joins(statement)
     if maximum_joins >= _JOIN_LIMIT:
         return f"SELECT block has {maximum_joins} JOINs (4+ explicit JOINs or comma relations)"
-    nested_queries = sum(1 for query in statement.walk() if isinstance(query, (exp.Select, exp.SetOperation)))
-    nested_queries -= isinstance(statement, (exp.Select, exp.SetOperation))
+    nested_queries = sum(1 for query in statement.walk() if isinstance(query, exp.Select))
+    nested_queries -= isinstance(_derived_query(statement), exp.Select)
     if (derived_signal := _derived_architecture_signal(statement)) is not None:
         return derived_signal
     if nested_queries >= _STAGE_LIMIT:
@@ -528,7 +555,7 @@ def _projection_width_signal(statement: exp.Expr) -> str | None:
 
     for select in statement.find_all(exp.Select):
         projections = tuple(_expression_args(select, "expressions"))
-        joins = tuple(join for join in _expression_args(select, "joins") if isinstance(join, exp.Join))
+        joins = _select_joins(select)
         if len(projections) >= _WIDE_PROJECTION_LIMIT and len(joins) >= _WIDE_PROJECTION_JOIN_LIMIT:
             return f"Joined query block has {len(projections)} projected expressions"
         if len(projections) >= _WIDE_SELF_JOIN_PROJECTION_LIMIT and _self_join(select, joins):
@@ -559,7 +586,10 @@ def _self_join(select: exp.Select, joins: tuple[exp.Join, ...]) -> bool:
     relations.extend(_expression_arg(join, "this") for join in joins)
     seen: set[tuple[str, ...]] = set()
     for relation in relations:
-        key = relation_key(relation)
+        base = relation
+        while isinstance(base, (exp.Paren, exp.Subquery)):
+            base = _expression_arg(base, "this")
+        key = relation_key(base)
         if key is None or any(_SQL_HOLE in name for name in key):
             continue
         if key in seen:
@@ -572,9 +602,7 @@ def _derived_architecture_signal(statement: exp.Expr) -> str | None:
     from sqlglot import exp  # ruff: ignore[import-outside-top-level] -- keep parser startup off unrelated lint runs
 
     for select in statement.find_all(exp.Select):
-        for join in _expression_args(select, "joins"):
-            if not isinstance(join, exp.Join):
-                continue
+        for join in _select_joins(select):
             if (derived := _derived_query(_expression_arg(join, "this"))) is not None and _has_complex_body(derived):
                 return "JOIN-derived query combines grouping, HAVING or windowing with joins or nested reads"
         from_clause = _expression_arg(select, "from_")
@@ -597,11 +625,11 @@ def _has_complex_body(query: exp.Query) -> bool:
     if not isinstance(query, exp.Select):
         return False
     if _has_row_transform(query) and (
-        _expression_args(query, "joins") or any(select is not query for select in query.find_all(exp.Select))
+        _select_joins(query) or any(select is not query for select in query.find_all(exp.Select))
     ):
         return True
-    for relation in query.find_all(exp.From, exp.Join):
-        if relation.parent is not query:
+    for relation in (_expression_arg(query, "from_"), *_select_joins(query)):
+        if not isinstance(relation, (exp.From, exp.Join)):
             continue
         child = _derived_query(_expression_arg(relation, "this"))
         if child is not None and (_has_row_transform(child) or _has_complex_body(child)):
@@ -624,14 +652,26 @@ def _maximum_query_joins(statement: exp.Expr) -> int:
     from sqlglot import exp  # ruff: ignore[import-outside-top-level] -- keep parser startup off unrelated lint runs
 
     return max(
-        (
-            sum(isinstance(join, exp.Join) for join in _expression_args(select, "joins"))
-            for select in statement.find_all(exp.Select)
-        ),
+        (len(_select_joins(select)) for select in statement.find_all(exp.Select)),
         default=0,
     )
 
 
+def _select_joins(select: exp.Select) -> tuple[exp.Join, ...]:
+    from sqlglot import exp  # ruff: ignore[import-outside-top-level] -- grouped joined tables retain their SELECT owner.
+
+    relations = (_expression_arg(select, "from_"), *_expression_args(select, "joins"))
+    return tuple(
+        node
+        for relation in relations
+        if relation is not None
+        for node in relation.walk(
+            prune=lambda node: isinstance(node, (exp.Select, exp.SetOperation, exp.Insert, exp.Update, exp.Delete))
+        )
+        if isinstance(node, exp.Join)
+    )
+
+
 def _count_import_bindings(
     tree: ast.Module,
     parents: Mapping[ast.AST, ast.AST],
@@ -671,13 +711,6 @@ def _query_review_guidance(text_value: str) -> str:
     )
 
 
-def _is_postgres_module(tree: ast.Module, *, node_index: NodeIndex | None = None) -> bool:
-    imports = _import_names(tree, node_index=node_index)
-    return _has_import_prefix(imports, _POSTGRES_IMPORT_PREFIXES) and not _has_import_prefix(
-        imports, _AMBIGUOUS_RELATIONAL_IMPORT_PREFIXES
-    )
-
-
 def _has_import_prefix(imports: frozenset[str], prefixes: tuple[str, ...]) -> bool:
     return any(name == prefix or name.startswith(f"{prefix}.") for name in imports for prefix in prefixes)
 

{sarj_python_lint-1.99.0 → sarj_python_lint-1.101.0}/src/sarj_python_lint/rules/no_analytical_aggregation_in_postgres_store.py

@@ -60,15 +60,16 @@ def analytical_signal(sql: str) -> str | None:
 
 
 def _grouped_reporting_signal(sql: str) -> str | None:
-    import sqlglot  # ruff: ignore[import-outside-top-level] -- parse only aggregate-shaped SQL after cheap gates
     from sqlglot import exp  # ruff: ignore[import-outside-top-level] -- paired with lazy parser import
     from sqlglot.errors import SqlglotError  # ruff: ignore[import-outside-top-level] -- paired with lazy parser import
 
+    from sarj_python_lint.rules._postgres import parse_postgres  # ruff: ignore[import-outside-top-level] -- unsupported private SQL must not enter dependency logs.
+
     if _GROUP_BY.search(sql) is None or _COMMON_AGGREGATE.search(sql) is None:
         return None
     try:
-        statements = sqlglot.parse(_PLACEHOLDER.sub("?", sql), read="postgres")
-    except SqlglotError:
+        statements = parse_postgres(_PLACEHOLDER.sub("?", sql))
+    except SqlglotError, RecursionError:
         return None
     for statement in statements:
         if not isinstance(statement, exp.Query):