sarj-python-lint 0.70.0__tar.gz → 0.71.0__tar.gz

{sarj_python_lint-0.70.0 → sarj_python_lint-0.71.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sarj-python-lint
-Version: 0.70.0
+Version: 0.71.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-0.70.0 → sarj_python_lint-0.71.0}/pyproject.toml

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

{sarj_python_lint-0.70.0 → sarj_python_lint-0.71.0}/src/sarj_python_lint/__main__.py

@@ -9,6 +9,7 @@ import json
 from pathlib import Path
 import sys
 from types import MappingProxyType
+from typing import NamedTuple
 
 from sarj_python_lint import __version__
 from sarj_python_lint._filesystem import atomic_write_text
@@ -120,6 +121,11 @@ _DIAGNOSTIC_PRECEDENCE = MappingProxyType(
 )
 
 
+class _OwnerLocation(NamedTuple):
+    line: int
+    column: int
+
+
 def deduplicate_diagnostics(diags: list[Diagnostic], *, source: str | None = None) -> list[Diagnostic]:
     """Keep the most specific remediation at a source location."""
     codes = frozenset(diagnostic.code for diagnostic in diags)
@@ -130,15 +136,17 @@ def deduplicate_diagnostics(diags: list[Diagnostic], *, source: str | None = Non
         _function_signature_owner_locations(source) if source is not None and needs_signature_owners else {}
     )
 
-    def owner_location(diagnostic: Diagnostic) -> tuple[int, int]:
+    def owner_location(diagnostic: Diagnostic) -> _OwnerLocation:
         if diagnostic.code in {"SARJ034", "SARJ093"}:
-            return signature_owners.get(diagnostic.line, (diagnostic.line, diagnostic.col))
-        return docstring_owners.get(diagnostic.line, (diagnostic.line, diagnostic.col))
+            line, column = signature_owners.get(diagnostic.line, (diagnostic.line, diagnostic.col))
+        else:
+            line, column = docstring_owners.get(diagnostic.line, (diagnostic.line, diagnostic.col))
+        return _OwnerLocation(line, column)
 
     present: dict[tuple[Path, int, int], dict[str, set[Severity]]] = {}
     for diagnostic in diags:
-        line, col = owner_location(diagnostic)
-        by_code = present.setdefault((diagnostic.path, line, col), {})
+        location = owner_location(diagnostic)
+        by_code = present.setdefault((diagnostic.path, location.line, location.column), {})
         by_code.setdefault(diagnostic.code, set()).add(diagnostic.severity)
     suppressed = {
         (location, generic, generic_severity)
@@ -156,7 +164,8 @@ def deduplicate_diagnostics(diags: list[Diagnostic], *, source: str | None = Non
             (
                 (
                     diagnostic.path,
-                    *owner_location(diagnostic),
+                    owner_location(diagnostic).line,
+                    owner_location(diagnostic).column,
                 ),
                 diagnostic.code,
                 diagnostic.severity,

{sarj_python_lint-0.70.0 → sarj_python_lint-0.71.0}/src/sarj_python_lint/rules/_comments.py

@@ -314,15 +314,21 @@ class _CommentScan[T](NamedTuple):
     first_code_line: int
 
 
-_Scan = tuple[list[tuple[int, int, str]], list[tuple[int, int, str]], set[int], int, _Ordered]
+class _Scan(NamedTuple):
+    standalone: list[tuple[int, int, str]]
+    trailing: list[tuple[int, int, str]]
+    nested: set[int]
+    first_code_line: int
+    ordered: _Ordered
+
 
 _last_scan: tuple[str, _Scan] | None = None
 
 
 def all_comments(source: str) -> _CommentScan[_Ordered]:
     """Return every comment as `(line, col0, body, standalone)`, plus the first code line."""
-    _, _, _, first_code_line, ordered = _scan_memo(source)
-    return _CommentScan(ordered, first_code_line)
+    scan = _scan_memo(source)
+    return _CommentScan(scan.ordered, scan.first_code_line)
 
 
 def _scan_memo(source: str) -> _Scan:
@@ -361,23 +367,23 @@ def _scan(source: str) -> _Scan:
             prev_end_row = tok.end[0]
         if tok.type not in _NON_CODE_TOKENS:
             first_code_line = min(first_code_line, tok.start[0])
-    return standalone, trailing, nested, first_code_line, ordered
+    return _Scan(standalone, trailing, nested, first_code_line, ordered)
 
 
 def trailing_comments(source: str) -> list[tuple[int, int, str]]:
     """Return every comment that shares its line with code, as `(line, col, body)`."""
-    return _scan_memo(source)[1]
+    return _scan_memo(source).trailing
 
 
 def nested_comment_lines(source: str) -> set[int]:
     """Return the lines of comments sitting INSIDE a bracketed expression."""
-    return _scan_memo(source)[2]
+    return _scan_memo(source).nested
 
 
 def standalone_comments(source: str) -> _CommentScan[list[tuple[int, int, str]]]:
     """Return every own-line comment as `(line, col, body)`, plus the first code line."""
-    standalone, _, _, first_code_line, _ = _scan_memo(source)
-    return _CommentScan(standalone, first_code_line)
+    scan = _scan_memo(source)
+    return _CommentScan(scan.standalone, scan.first_code_line)
 
 
 def comment_runs(standalone: Sequence[tuple[int, int, str]]) -> list[list[tuple[int, int, str]]]:

{sarj_python_lint-0.70.0 → sarj_python_lint-0.71.0}/src/sarj_python_lint/rules/_fastapi.py

@@ -74,6 +74,16 @@ class ParameterMarker(NamedTuple):
     call: ast.Call
 
 
+class _ReceiverKey(NamedTuple):
+    scope: int
+    name: str
+
+
+class _DecoratorBinding(NamedTuple):
+    receiver: str
+    method: str
+
+
 @dataclass(frozen=True, slots=True)
 class _ImportedReference:
     module: str
@@ -113,12 +123,12 @@ class FastapiIndex:
         self.annotated: set[str] = set()
         self.symbols: dict[str, str] = {}
         self.type_aliases: dict[str, ast.expr] = {}
-        self.receivers: set[tuple[int, str]] = set()
-        self.receiver_origins: dict[tuple[int, str], tuple[int, str]] = {}
-        self.receiver_kinds: dict[tuple[int, str], Literal["FastAPI", "APIRouter"]] = {}
-        self.hidden_receivers: set[tuple[int, str]] = set()
-        self.decorators: dict[tuple[int, str], tuple[str, str]] = {}
-        self.bound_names: set[tuple[int, str]] = set()
+        self.receivers: set[_ReceiverKey] = set()
+        self.receiver_origins: dict[_ReceiverKey, _ReceiverKey] = {}
+        self.receiver_kinds: dict[_ReceiverKey, Literal["FastAPI", "APIRouter"]] = {}
+        self.hidden_receivers: set[_ReceiverKey] = set()
+        self.decorators: dict[_ReceiverKey, _DecoratorBinding] = {}
+        self.bound_names: set[_ReceiverKey] = set()
         self._node_scopes: dict[int, int] = {}
         self._node_classes: dict[int, int | None] = {}
         self._route_scopes: dict[int, int] = {}
@@ -182,31 +192,37 @@ class FastapiIndex:
         assignments: list[tuple[int, str, ast.expr]] = []
         for node in ast.walk(tree):
             if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-                self.bound_names.add((self._node_scopes[id(node)], node.name))
+                self.bound_names.add(_ReceiverKey(self._node_scopes[id(node)], node.name))
                 arguments = [*node.args.posonlyargs, *node.args.args, *node.args.kwonlyargs]
                 if node.args.vararg is not None:
                     arguments.append(node.args.vararg)
                 if node.args.kwarg is not None:
                     arguments.append(node.args.kwarg)
-                self.bound_names.update((node.lineno, argument.arg) for argument in arguments)
+                self.bound_names.update(_ReceiverKey(node.lineno, argument.arg) for argument in arguments)
             elif isinstance(node, ast.ClassDef):
-                self.bound_names.add((self._node_scopes[id(node)], node.name))
+                self.bound_names.add(_ReceiverKey(self._node_scopes[id(node)], node.name))
             elif isinstance(node, (ast.Import, ast.ImportFrom)):
                 self.bound_names.update(
-                    (self._node_scopes[id(node)], alias.asname or alias.name.split(".")[0]) for alias in node.names
+                    _ReceiverKey(self._node_scopes[id(node)], alias.asname or alias.name.split(".")[0])
+                    for alias in node.names
                 )
             elif isinstance(node, (ast.For, ast.AsyncFor)):
-                self.bound_names.update((self._node_scopes[id(node)], name) for name in self._target_names(node.target))
+                self.bound_names.update(
+                    _ReceiverKey(self._node_scopes[id(node)], name) for name in self._target_names(node.target)
+                )
             elif isinstance(node, ast.With):
                 for item in node.items:
                     if item.optional_vars is not None:
                         self.bound_names.update(
-                            (self._node_scopes[id(node)], name) for name in self._target_names(item.optional_vars)
+                            _ReceiverKey(self._node_scopes[id(node)], name)
+                            for name in self._target_names(item.optional_vars)
                         )
             elif isinstance(node, ast.ExceptHandler) and node.name is not None:
-                self.bound_names.add((self._node_scopes[id(node)], node.name))
+                self.bound_names.add(_ReceiverKey(self._node_scopes[id(node)], node.name))
             elif isinstance(node, ast.NamedExpr):
-                self.bound_names.update((self._node_scopes[id(node)], name) for name in self._target_names(node.target))
+                self.bound_names.update(
+                    _ReceiverKey(self._node_scopes[id(node)], name) for name in self._target_names(node.target)
+                )
             if isinstance(node, ast.Assign) and len(node.targets) == 1:
                 name = _binding_name(node.targets[0])
                 if name:
@@ -219,12 +235,12 @@ class FastapiIndex:
                 assignments.append((self._node_scopes[id(node)], node.name.id, node.value))
 
         changed = True
-        counts = Counter((scope, name) for scope, name, _value in assignments)
+        counts = Counter(_ReceiverKey(scope, name) for scope, name, _value in assignments)
         self.bound_names.update(counts)
         while changed:
             changed = False
             for scope, name, value in assignments:
-                key = (scope, name)
+                key = _ReceiverKey(scope, name)
                 if counts[key] != 1:
                     continue
                 if key in self.receivers or key in self.decorators:
@@ -250,7 +266,7 @@ class FastapiIndex:
                 if isinstance(value, ast.Attribute) and value.attr in HTTP_METHODS:
                     receiver = _binding_name(value.value)
                     if self._receiver_key(scope, receiver) is not None:
-                        self.decorators[key] = (receiver, value.attr)
+                        self.decorators[key] = _DecoratorBinding(receiver, value.attr)
                         changed = True
                         continue
                 if self._is_annotated(value) or (isinstance(value, ast.Name) and value.id in self.type_aliases):
@@ -268,12 +284,12 @@ class FastapiIndex:
             return self._node_classes[id(node)] or self._node_scopes[id(node)]
         return self._node_scopes[id(node)]
 
-    def _receiver_key(self, scope: int, name: str) -> tuple[int, str] | None:
+    def _receiver_key(self, scope: int, name: str) -> _ReceiverKey | None:
         if not name:
             return None
         current: int | None = scope
         while current is not None:
-            binding = (current, name)
+            binding = _ReceiverKey(current, name)
             if binding in self.receivers:
                 return binding
             if binding in self.bound_names:
@@ -325,7 +341,8 @@ class FastapiIndex:
                 if receiver_key is not None:
                     method = decorator.func.attr
             elif isinstance(decorator.func, ast.Name) and (resolved := self._decorator(scope, decorator.func.id)):
-                receiver, method = resolved
+                receiver = resolved.receiver
+                method = resolved.method
                 receiver_key = self._receiver_key(scope, receiver)
             if method not in HTTP_METHODS or receiver_key is None:
                 continue
@@ -336,11 +353,11 @@ class FastapiIndex:
             )
             path = path_node.value if isinstance(path_node, ast.Constant) and isinstance(path_node.value, str) else None
             route_methods = self._route_methods(decorator) if method == "api_route" else (method,)
-            origin_scope, origin_name = self.receiver_origins[receiver_key]
+            origin = self.receiver_origins[receiver_key]
             routes.extend(
                 Route(
                     decorator=decorator,
-                    receiver=f"{origin_scope}:{origin_name}",
+                    receiver=f"{origin.scope}:{origin.name}",
                     method=route_method,
                     path=path,
                     receiver_kind=self.receiver_kinds[receiver_key],
@@ -350,10 +367,10 @@ class FastapiIndex:
             )
         return tuple(routes)
 
-    def _decorator(self, scope: int, name: str) -> tuple[str, str] | None:
+    def _decorator(self, scope: int, name: str) -> _DecoratorBinding | None:
         current: int | None = scope
         while current is not None:
-            binding = (current, name)
+            binding = _ReceiverKey(current, name)
             if binding in self.decorators:
                 return self.decorators[binding]
             if binding in self.bound_names:
@@ -473,7 +490,7 @@ class FastapiIndex:
         # it, so begin with that function's parent scope.
         scope: int | None = self._scope_parents.get(node_scope)
         while scope is not None and scope != 0:
-            if (scope, root) in self.bound_names:
+            if _ReceiverKey(scope, root) in self.bound_names:
                 return True
             scope = self._scope_parents.get(scope)
         return False

{sarj_python_lint-0.70.0 → sarj_python_lint-0.71.0}/src/sarj_python_lint/rules/fixture_returns_bare_tuple.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 
 import ast
 from pathlib import PurePosixPath
-from typing import TYPE_CHECKING, ClassVar, override
+from typing import TYPE_CHECKING, ClassVar, NamedTuple, override
 
 from sarj_python_lint.rule_base import (
     Diagnostic,
@@ -34,6 +34,11 @@ _MIN_FIELDS = 2
 _FUNC_NODES = (ast.FunctionDef, ast.AsyncFunctionDef)
 
 
+class _FixtureDecorators(NamedTuple):
+    names: frozenset[str]
+    roots: frozenset[str]
+
+
 class FixtureReturnsBareTuple(Rule):
     id: str = "fixture-returns-bare-tuple"
     code: str = "SARJ044"
@@ -132,7 +137,7 @@ def _bare_tuple_results(tree: ast.Module) -> list[tuple[ast.expr, int]]:
     return hits
 
 
-def _fixture_decorator_names(tree: ast.Module) -> tuple[frozenset[str], frozenset[str]]:
+def _fixture_decorator_names(tree: ast.Module) -> _FixtureDecorators:
     names: set[str] = set()
     roots: set[str] = set()
     for statement in tree.body:
@@ -144,15 +149,14 @@ def _fixture_decorator_names(tree: ast.Module) -> tuple[frozenset[str], frozense
             for alias in statement.names:
                 if alias.name == "fixture":
                     names.add(alias.asname or alias.name)
-    return frozenset(names), frozenset(roots)
+    return _FixtureDecorators(frozenset(names), frozenset(roots))
 
 
 def _is_fixture(
     node: ast.FunctionDef | ast.AsyncFunctionDef,
-    fixture_imports: tuple[frozenset[str], frozenset[str]],
+    fixture_imports: _FixtureDecorators,
 ) -> bool:
-    names, roots = fixture_imports
-    return any(_names_fixture(dec, names, roots) for dec in node.decorator_list)
+    return any(_names_fixture(dec, fixture_imports.names, fixture_imports.roots) for dec in node.decorator_list)
 
 
 def _names_fixture(dec: ast.expr, fixture_names: frozenset[str], fixture_roots: frozenset[str]) -> bool:

{sarj_python_lint-0.70.0 → sarj_python_lint-0.71.0}/src/sarj_python_lint/rules/iac_source_coupled_test.py

@@ -45,7 +45,7 @@ class IacSourceCoupledTest(Rule):
         limitations=(
             "The rule follows local aliases, path collections, context-managed reads, and common normalization; interprocedural flows remain unreported.",
             "Files produced beneath recognized temporary-directory fixtures are generated outputs and remain unreported.",
-            "The warning-stage rule remains suppressible for calibration; promotion may make the locked policy non-suppressible.",
+            "The rule remains suppressible for exceptional compatibility boundaries.",
         ),
         examples=(
             RuleExample(
@@ -98,7 +98,7 @@ class IacSourceCoupledTest(Rule):
                 line=assertion.lineno,
                 col=assertion.col_offset + 1,
                 code=self.code,
-                severity=Severity.WARNING,
+                severity=Severity.ERROR,
                 message=(
                     "raw IaC source text is the test oracle; inspect rendered plan JSON, provider state, or runtime behavior instead."
                 ),

{sarj_python_lint-0.70.0 → sarj_python_lint-0.71.0}/src/sarj_python_lint/rules/invalid_pydantic_field_default.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 import ast
 from dataclasses import dataclass
 from pathlib import PurePosixPath
-from typing import TYPE_CHECKING, final, override
+from typing import TYPE_CHECKING, NamedTuple, final, override
 
 from sarj_python_lint.rule_base import (
     AutofixPolicy,
@@ -84,7 +84,17 @@ _MISSING = object()
 
 @dataclass(frozen=True, slots=True)
 class _LiteralDomain:
-    values: frozenset[tuple[type[object], object]]
+    values: frozenset[_LiteralKey]
+
+
+class _LiteralKey(NamedTuple):
+    value_type: type[object]
+    value: object
+
+
+class _BoundViolation(NamedTuple):
+    bound_name: str
+    bound: object
 
 
 @final
@@ -221,7 +231,7 @@ def _invalid_default_message(
 
     domain = _literal_domain(annotation, imports)
     if domain is not None and not isinstance(literal, float) and _literal_key(literal) not in domain.values:
-        allowed = ", ".join(sorted(repr(value) for _, value in domain.values))
+        allowed = ", ".join(sorted(repr(item.value) for item in domain.values))
         return (
             f"`{field_name}` defaults to {literal!r}, outside its direct `Literal` domain ({allowed}); "
             "use one of the declared literal values."
@@ -229,7 +239,8 @@ def _invalid_default_message(
 
     violation = _bound_violation(literal, call)
     if violation is not None:
-        bound_name, bound = violation
+        bound_name = violation.bound_name
+        bound = violation.bound
         return (
             f"`{field_name}` defaults to {literal!r}, which violates `Field({bound_name}={bound!r})`; "
             "choose a default inside the declared bounds."
@@ -249,8 +260,8 @@ def _literal_value(node: ast.expr) -> object:
             return _MISSING
 
 
-def _literal_key(value: object) -> tuple[type[object], object]:
-    return type(value), value
+def _literal_key(value: object) -> _LiteralKey:
+    return _LiteralKey(type(value), value)
 
 
 def _literal_domain(node: ast.expr, imports: ImportIndex) -> _LiteralDomain | None:
@@ -273,7 +284,7 @@ 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
-    values: set[tuple[type[object], object]] = set()
+    values: set[_LiteralKey] = set()
     for member in _slice_members(node.slice):
         value = _literal_value(member)
         if value is _MISSING or isinstance(value, float):
@@ -285,7 +296,7 @@ def _literal_domain(node: ast.expr, imports: ImportIndex) -> _LiteralDomain | No
 def _merge_domains(domains: tuple[_LiteralDomain | None, ...]) -> _LiteralDomain | None:
     if not domains or any(domain is None for domain in domains):
         return None
-    values: set[tuple[type[object], object]] = set()
+    values: set[_LiteralKey] = set()
     for domain in domains:
         if domain is not None:
             values.update(domain.values)
@@ -318,7 +329,7 @@ def _provably_non_null(node: ast.expr, imports: ImportIndex) -> bool:
     )
 
 
-def _bound_violation(default: object, call: ast.Call) -> tuple[str, object] | None:
+def _bound_violation(default: object, call: ast.Call) -> _BoundViolation | None:
     bounds = {keyword.arg: _literal_value(keyword.value) for keyword in call.keywords if keyword.arg is not None}
     if isinstance(default, (int, float)) and not isinstance(default, bool):
         for name in ("gt", "ge", "lt", "le"):
@@ -326,7 +337,7 @@ def _bound_violation(default: object, call: ast.Call) -> tuple[str, object] | No
             if not isinstance(bound, (int, float)) or isinstance(bound, bool):
                 continue
             if _numeric_bound_is_violated(name, default, bound):
-                return name, bound
+                return _BoundViolation(name, bound)
         return None
     if isinstance(default, (str, bytes)):
         for name in ("min_length", "max_length"):
@@ -334,7 +345,7 @@ def _bound_violation(default: object, call: ast.Call) -> tuple[str, object] | No
             if not isinstance(bound, int) or isinstance(bound, bool) or bound < 0:
                 continue
             if (name == "min_length" and len(default) < bound) or (name == "max_length" and len(default) > bound):
-                return name, bound
+                return _BoundViolation(name, bound)
     return None
 
 

{sarj_python_lint-0.70.0 → sarj_python_lint-0.71.0}/src/sarj_python_lint/rules/no_hidden_constructor_fallback.py

@@ -10,7 +10,7 @@ from dataclasses import dataclass
 from functools import lru_cache
 import os
 from pathlib import Path, PurePosixPath
-from typing import TYPE_CHECKING, ClassVar, final, override
+from typing import TYPE_CHECKING, ClassVar, NamedTuple, final, override
 
 from sarj_python_lint.rule_base import (
     Diagnostic,
@@ -68,6 +68,16 @@ class _HiddenParameter:
     uses_boolean_or: bool
 
 
+class _LoadedModule(NamedTuple):
+    tree: ast.Module
+    path: Path
+
+
+class _CanonicalSymbol(NamedTuple):
+    module: str
+    symbol: str
+
+
 @final
 class NoHiddenConstructorFallback(Rule):
     id = "no-hidden-constructor-fallback"
@@ -379,7 +389,8 @@ class _RuntimeConfigResolver:
         if loaded is None:
             self._settings_cache[key] = False
             return False
-        tree, module_path = loaded
+        tree = loaded.tree
+        module_path = loaded.path
         imports = _imports(tree, module, is_package=module_path.name == "__init__.py")
         classes = _base_settings_classes(tree, imports)
         factory = _assigned_factory(tree, symbol)
@@ -419,7 +430,8 @@ class _RuntimeConfigResolver:
         if loaded is None:
             self._settings_class_cache[key] = False
             return False
-        tree, module_path = loaded
+        tree = loaded.tree
+        module_path = loaded.path
         imports = _imports(tree, module, is_package=module_path.name == "__init__.py")
         if symbol in _base_settings_classes(tree, imports):
             self._settings_class_cache[key] = True
@@ -441,13 +453,13 @@ class _RuntimeConfigResolver:
         self._settings_class_cache[key] = result
         return result
 
-    def _load_module(self, module: str) -> tuple[ast.Module, Path] | None:
+    def _load_module(self, module: str) -> _LoadedModule | None:
         if module == self._module:
-            return self._tree, self._path
+            return _LoadedModule(self._tree, self._path)
         path = _module_path(module, self._root)
         if path is None:
             return None
-        return _read_module(path), path
+        return _LoadedModule(_read_module(path), path)
 
 
 def _imports(tree: ast.Module, current_module: str | None, *, is_package: bool = False) -> dict[str, _Binding]:
@@ -635,13 +647,13 @@ def _distribution_calls_class(root: Path, target_module: str, class_name: str) -
                 if called_symbol != class_name:
                     continue
                 canonical = _canonical_symbol(root, called_module, called_symbol)
-                if canonical == (target_module, class_name):
+                if canonical == _CanonicalSymbol(target_module, class_name):
                     return True
     return False
 
 
 @lru_cache(maxsize=4096)
-def _canonical_symbol(root: Path, module: str, symbol: str) -> tuple[str, str]:
+def _canonical_symbol(root: Path, module: str, symbol: str) -> _CanonicalSymbol:
     return _canonical_symbol_inner(root, module, symbol, frozenset())
 
 
@@ -650,16 +662,16 @@ def _canonical_symbol_inner(
     module: str,
     symbol: str,
     seen: frozenset[tuple[str, str]],
-) -> tuple[str, str]:
+) -> _CanonicalSymbol:
     key = (module, symbol)
     if key in seen:
-        return key
+        return _CanonicalSymbol(module, symbol)
     path = _module_path(module, root)
     if path is None:
-        return key
+        return _CanonicalSymbol(module, symbol)
     binding = _imports(_read_module(path), module, is_package=path.name == "__init__.py").get(symbol)
     if binding is None or binding.symbol is None:
-        return key
+        return _CanonicalSymbol(module, symbol)
     return _canonical_symbol_inner(root, binding.module, binding.symbol, seen | {key})
 
 

{sarj_python_lint-0.70.0 → sarj_python_lint-0.71.0}/src/sarj_python_lint/rules/no_isinstance_union_chain.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 
 import ast
 from pathlib import PurePosixPath
-from typing import TYPE_CHECKING, final, override
+from typing import TYPE_CHECKING, NamedTuple, final, override
 
 from sarj_python_lint.rule_base import (
     AutofixPolicy,
@@ -34,6 +34,12 @@ _MIN_CHAIN_LENGTH = 2
 # `isinstance(x, T)` takes exactly two positional arguments.
 _ISINSTANCE_ARG_COUNT = 2
 
+
+class _IsinstanceTypeTest(NamedTuple):
+    subject: ast.expr
+    type_expression: ast.expr
+
+
 # Exclude builtins and ABCs even when a same-named local class shadows them.
 _EXCLUDED_TYPE_NAMES = frozenset(
     {
@@ -218,7 +224,8 @@ def _qualifying_chain_length(head: ast.If, local_classes: frozenset[str]) -> int
         parsed = _isinstance_single_type(current.test)
         if parsed is None:
             return 0
-        target, type_node = parsed
+        target = parsed.subject
+        type_node = parsed.type_expression
         if not isinstance(target, ast.Name):
             # Match evaluates its subject once, while an isinstance ladder
             # repeats attributes, subscriptions, and calls for every arm.
@@ -299,7 +306,7 @@ def _ast_equal(a: ast.expr, b: ast.expr) -> bool:
     return ast.dump(a) == ast.dump(b)
 
 
-def _isinstance_single_type(test: ast.expr) -> tuple[ast.expr, ast.expr] | None:
+def _isinstance_single_type(test: ast.expr) -> _IsinstanceTypeTest | None:
     """Parse `test` as `isinstance(x, T)` with a single (non-tuple) type argument."""
     if not isinstance(test, ast.Call):
         return None
@@ -308,4 +315,4 @@ def _isinstance_single_type(test: ast.expr) -> tuple[ast.expr, ast.expr] | None:
     if len(test.args) != _ISINSTANCE_ARG_COUNT or test.keywords:
         return None
     target, type_node = test.args
-    return target, type_node
+    return _IsinstanceTypeTest(target, type_node)

{sarj_python_lint-0.70.0 → sarj_python_lint-0.71.0}/src/sarj_python_lint/rules/no_long_comment.py

@@ -89,7 +89,7 @@ class NoLongComment(Rule):
                 group.col,
                 self.code,
                 self.description,
-                Severity.WARNING,
+                Severity.ERROR,
                 column_encoding=group.column_encoding,
             )
             for group in groups(path, source)