sarj-python-lint 1.104.0__tar.gz → 1.108.0__tar.gz

{sarj_python_lint-1.104.0 → sarj_python_lint-1.108.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.104.0
+Version: 1.108.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.6.0
+Requires-Dist: sarj-rule-contracts==0.6.1
 Requires-Dist: sqlglot==30.24.0
 Requires-Dist: typer==0.27.3
 Description-Content-Type: text/markdown

{sarj_python_lint-1.104.0 → sarj_python_lint-1.108.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "1.104.0"
+version = "1.108.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.6.0", "packaging==26.3", "ruff>=0.17.2", "sqlglot==30.24.0", "typer==0.27.3"]
+dependencies = ["sarj-rule-contracts==0.6.1", "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.104.0 → sarj_python_lint-1.108.0}/src/sarj_python_lint/__init__.py

@@ -20,13 +20,24 @@ def __getattr__(name: str) -> object:
         raise AttributeError(msg)
     from sarj_python_lint._analysis_session import AnalysisSession as _AnalysisSession  # ruff: ignore[import-outside-top-level] -- lightweight metadata imports do not need semantic rules.
 
-    globals()["AnalysisSession"] = _AnalysisSession
+    globals(  # sarj-noqa: SARJ557 -- Preserve the lazy public module namespace and historical star-import exports.
+    )["AnalysisSession"] = _AnalysisSession
     if name == "__all__":
         # Star imports previously exposed the complete post-session public namespace.
         # Discover it on demand instead of freezing a narrower list of exports.
-        return tuple(public for public in globals() if not public.startswith("_"))
+        return tuple(
+            public
+            for public in globals(  # sarj-noqa: SARJ557 -- Preserve the lazy public module namespace and historical star-import exports.
+            )
+            if not public.startswith("_")
+        )
     return _AnalysisSession
 
 
 def __dir__() -> list[str]:
-    return sorted(set(globals()).union({"AnalysisSession"}))
+    return sorted(
+        set(
+            globals(  # sarj-noqa: SARJ557 -- Preserve the lazy public module namespace and historical star-import exports.
+            )
+        ).union({"AnalysisSession"})
+    )

{sarj_python_lint-1.104.0 → sarj_python_lint-1.108.0}/src/sarj_python_lint/__main__.py

@@ -103,7 +103,7 @@ def _python_files(p: Path) -> list[Path]:
     for directory, directories, filenames in p.walk():
         directories[:] = [name for name in directories if name not in SKIP_DIR_NAMES]
         for name in filenames:
-            if not fnmatch(name, "*.py"):
+            if not fnmatch(name, "*.py") and not fnmatch(name, "*.pyi"):
                 continue
             child = directory / name
             if child.is_file():

{sarj_python_lint-1.104.0 → sarj_python_lint-1.108.0}/src/sarj_python_lint/_autofix.py

@@ -514,7 +514,9 @@ def _repeated_fix(source: _Source, diagnostic: Diagnostic) -> list[TextEdit]:
 def _statement_pairs(context: PythonFileContext) -> Iterator[tuple[ast.stmt, ast.stmt]]:
     for owner in context.nodes(ast.AST):
         for field in ("body", "orelse", "finalbody"):
-            value: object = getattr(owner, field, None)
+            value: object = getattr(  # sarj-noqa: SARJ557 -- Inspect optional statement-list fields across heterogeneous AST node types.
+                owner, field, None
+            )
             if object_list(value):
                 statements = [item for item in value if isinstance(item, ast.stmt)]
                 yield from pairwise(statements)
@@ -1399,7 +1401,9 @@ def fix_source(path: Path, source: str, *, rule_ids: Sequence[str] | None = None
         # Batch independent candidates; overlapping candidates get fresh offsets on the next pass.
         selected_pass = _coherent_edits(candidates)
         updated = apply_edits(current, selected_pass.edits)
-        compile(updated, str(path), "exec", dont_inherit=True)
+        compile(  # sarj-noqa: SARJ557 -- Compile proposed fixes to reject invalid scopes without executing them.
+            updated, str(path), "exec", dont_inherit=True
+        )
         if updated == current:
             return current
         if passes == _MAX_FIX_PASSES:

{sarj_python_lint-1.104.0 → sarj_python_lint-1.108.0}/src/sarj_python_lint/_fixes.py

@@ -65,5 +65,7 @@ def apply_fixes(source: str, fixes: Sequence[Fix]) -> str:
     result.append(raw[previous:])
     fixed = b"".join(result).decode("utf-8")
     tree = ast.parse(fixed)
-    compile(tree, "<native-fix>", "exec")
+    compile(  # sarj-noqa: SARJ557 -- Reject compiler-invalid fixes without executing the generated code object.
+        tree, "<native-fix>", "exec"
+    )
     return prefix + fixed

{sarj_python_lint-1.104.0 → sarj_python_lint-1.108.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("no-shared-mutable-default"),
+        module="sarj_python_lint.rules.no_shared_mutable_default",
+        class_name="NoSharedMutableDefault",
+        code="SARJ559",
+        description="Do not share mutable function defaults through aliases or read-only annotations.",
+        aliases=(),
+        enabled_by_default=True,
+    ),
+    RuleDescriptor(
+        rule_id=RuleId("no-sys-path-mutation"),
+        module="sarj_python_lint.rules.no_sys_path_mutation",
+        class_name="NoSysPathMutation",
+        code="SARJ558",
+        description="Do not mutate the interpreter import search path.",
+        aliases=(),
+        enabled_by_default=True,
+    ),
+    RuleDescriptor(
+        rule_id=RuleId("no-dynamic-builtins"),
+        module="sarj_python_lint.rules.no_dynamic_builtins",
+        class_name="NoDynamicBuiltins",
+        code="SARJ557",
+        description="Use explicit typed state instead of dynamic Python builtin access.",
+        aliases=(),
+        enabled_by_default=True,
+    ),
     RuleDescriptor(
         rule_id=RuleId("service-singleton-delegates-to-bulk"),
         module="sarj_python_lint.rules.service_singleton_delegates_to_bulk",
@@ -337,7 +364,7 @@ DESCRIPTORS: tuple[RuleDescriptor, ...] = (
         module="sarj_python_lint.rules.no_hasattr",
         class_name="NoHasattr",
         code="SARJ499",
-        description="Production code should not probe attributes with hasattr.",
+        description="Do not probe attributes with the builtin hasattr.",
         aliases=(),
         enabled_by_default=True,
     ),

{sarj_python_lint-1.104.0 → sarj_python_lint-1.108.0}/src/sarj_python_lint/rule_metadata.py

@@ -53,11 +53,19 @@ def is_alias_tuple(value: object) -> TypeIs[tuple[str, ...]]:
 
 def load_descriptors() -> tuple[RuleDescriptor, ...]:
     module = import_module("sarj_python_lint._rule_descriptors")
-    version: object = getattr(module, "SCHEMA_VERSION", None)
+    version: object = (
+        getattr(  # sarj-noqa: SARJ557 -- Validate imported plugin metadata before trusting its declared rule contract.
+            module, "SCHEMA_VERSION", None
+        )
+    )
     if type(version) is not int or version != DESCRIPTOR_SCHEMA_VERSION:
         msg = "unsupported Python rule descriptor schema"
         raise ValueError(msg)
-    value: object = getattr(module, "DESCRIPTORS", None)
+    value: object = (
+        getattr(  # sarj-noqa: SARJ557 -- Validate imported plugin metadata before trusting its declared rule contract.
+            module, "DESCRIPTORS", None
+        )
+    )
     if not _object_tuple(value):
         msg = "Python rule descriptors must be a tuple"
         raise TypeError(msg)
@@ -102,7 +110,12 @@ def _authored_descriptor(rule_id: RuleId, rule: type[Rule]) -> RuleDescriptor:
         msg = f"{rule_id}: instance metadata differs from class metadata"
         raise ValueError(msg)
     module = import_module(rule.__module__)
-    if getattr(module, rule.__name__, None) is not rule:
+    if (
+        getattr(  # sarj-noqa: SARJ557 -- Validate imported plugin metadata before trusting its declared rule contract.
+            module, rule.__name__, None
+        )
+        is not rule
+    ):
         msg = f"{rule_id}: rule class is not importable from its declared module"
         raise ValueError(msg)
     return RuleDescriptor(

{sarj_python_lint-1.104.0 → sarj_python_lint-1.108.0}/src/sarj_python_lint/rules/_ast_index.py

@@ -47,7 +47,11 @@ def object_list(value: object) -> TypeIs[list[object]]:  # sarj-noqa: SARJ528 --
 def children(node: ast.AST) -> list[ast.AST]:
     out: list[ast.AST] = []
     for name in node._fields:
-        value: object = getattr(node, name, None)
+        value: object = (
+            getattr(  # sarj-noqa: SARJ557 -- Preserve the profiled AST child traversal and missing-field behavior.
+                node, name, None
+            )
+        )
         if object_list(value):
             out += [item for item in value if isinstance(item, _AST)]
         elif isinstance(value, _AST):

sarj_python_lint-1.108.0/src/sarj_python_lint/rules/_ast_position.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    import ast
+
+
+@dataclass(frozen=True, order=True, slots=True)
+class AstPosition:
+    line: int
+    column: int
+
+
+def ast_position(node: ast.AST, *, missing: int) -> AstPosition:
+    return AstPosition(
+        line=getattr(  # sarj-noqa: SARJ557 -- Generic AST markers may omit source locations; preserve the caller fallback.
+            node, "lineno", missing
+        ),
+        column=getattr(  # sarj-noqa: SARJ557 -- Generic AST markers may omit source locations; preserve the caller fallback.
+            node, "col_offset", missing
+        ),
+    )

{sarj_python_lint-1.104.0 → sarj_python_lint-1.108.0}/src/sarj_python_lint/rules/_nominal_project.py

@@ -19,6 +19,8 @@ from sarj_python_lint.rules._paths import is_generated
 
 
 if TYPE_CHECKING:
+    from typing import Never
+
     from sarj_python_lint.rules._first_party import FirstPartyFacts
 
 
@@ -239,10 +241,14 @@ def _patterns(value: object) -> tuple[str, ...] | None:
     return tuple(item for item in value if isinstance(item, str))
 
 
+def _raise_walk_error(error: OSError) -> Never:
+    raise error
+
+
 def _files(root: Path, pattern: str) -> list[Path]:
     found: list[Path] = []
     try:
-        for count, (directory, directories, filenames) in enumerate(root.walk()):
+        for count, (directory, directories, filenames) in enumerate(root.walk(on_error=_raise_walk_error)):
             if count >= _MAX_DIRECTORIES or len(found) >= _MAX_FILES:
                 # A partial inventory cannot establish uniqueness.
                 return []

{sarj_python_lint-1.104.0 → sarj_python_lint-1.108.0}/src/sarj_python_lint/rules/_registry.py

@@ -240,6 +240,7 @@ from sarj_python_lint.rules.no_custom_control_flow_exception import NoCustomCont
 from sarj_python_lint.rules.no_defaulted_environment_setting import NoDefaultedEnvironmentSetting
 from sarj_python_lint.rules.no_discarded_tagged_outcome import NoDiscardedTaggedOutcome
 from sarj_python_lint.rules.no_duplicate_field_validator_body import NoDuplicateFieldValidatorBody
+from sarj_python_lint.rules.no_dynamic_builtins import NoDynamicBuiltins
 from sarj_python_lint.rules.no_exception_text_in_500_detail import NoExceptionTextIn500Detail
 from sarj_python_lint.rules.no_folded_bad_request_not_found import NoFoldedBadRequestNotFound
 from sarj_python_lint.rules.no_hasattr import NoHasattr
@@ -251,7 +252,9 @@ 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
 from sarj_python_lint.rules.no_shallow_record_type_guard import NoShallowRecordTypeGuard
+from sarj_python_lint.rules.no_shared_mutable_default import NoSharedMutableDefault
 from sarj_python_lint.rules.no_slash_collection_root_under_prefix import NoSlashCollectionRootUnderPrefix
+from sarj_python_lint.rules.no_sys_path_mutation import NoSysPathMutation
 from sarj_python_lint.rules.no_unknown_pydantic_validator_field import NoUnknownPydanticValidatorField
 from sarj_python_lint.rules.no_work_verb_get_route import NoWorkVerbGetRoute
 from sarj_python_lint.rules.prefer_application_model_joins import PreferApplicationModelJoins
@@ -283,6 +286,9 @@ from sarj_python_lint.rules.test_without_explicit_oracle import NoExplicitTestOr
 
 _AUTHORING_REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
     {
+        NoSharedMutableDefault.id: NoSharedMutableDefault,
+        NoSysPathMutation.id: NoSysPathMutation,
+        NoDynamicBuiltins.id: NoDynamicBuiltins,
         ServiceSingletonDelegatesToBulk.id: ServiceSingletonDelegatesToBulk,
         NoAsyncClientInConstructor.id: NoAsyncClientInConstructor,
         NoDiscardedTaggedOutcome.id: NoDiscardedTaggedOutcome,

{sarj_python_lint-1.104.0 → sarj_python_lint-1.108.0}/src/sarj_python_lint/rules/_resource_provenance.py

@@ -338,7 +338,14 @@ class ResourceProvenance:
             return None
         if not isinstance(self.parents.get(statement), ast.Module | ast.FunctionDef | ast.AsyncFunctionDef):
             return None
-        return statement.value if statement.lineno < getattr(at, "lineno", 0) else None
+        return (
+            statement.value
+            if statement.lineno
+            < getattr(  # sarj-noqa: SARJ557 -- Order heterogeneous AST markers while preserving the missing-location fallback.
+                at, "lineno", 0
+            )
+            else None
+        )
 
     def async_function(self, value: ast.expr, at: ast.AST) -> ast.AsyncFunctionDef | None:
         if self.dynamic_namespace:

sarj_python_lint-1.108.0/src/sarj_python_lint/rules/_runtime_names.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+import keyword
+from typing import TYPE_CHECKING, final
+
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from sarj_python_lint._file_context import PythonFileContext
+
+
+_FUNCTION_SCOPES = (
+    ast.FunctionDef,
+    ast.AsyncFunctionDef,
+    ast.Lambda,
+    ast.ListComp,
+    ast.SetComp,
+    ast.DictComp,
+    ast.GeneratorExp,
+)
+_NATIVE_NAMES = frozenset(
+    {
+        "__import__",
+        "bool",
+        "bytearray",
+        "bytes",
+        "complex",
+        "compile",
+        "delattr",
+        "dict",
+        "float",
+        "frozenset",
+        "getattr",
+        "globals",
+        "hasattr",
+        "int",
+        "list",
+        "locals",
+        "object",
+        "range",
+        "set",
+        "setattr",
+        "str",
+        "tuple",
+    }
+)
+
+_RUFF_BANNED_API = frozenset({"locals", "globals", "compile", "__import__", "getattr", "hasattr", "delattr"})
+
+
+@dataclass(frozen=True, slots=True)
+class BuiltinReference:
+    node: ast.expr | ast.alias
+    name: str
+
+
+@final
+class RuntimeNames:
+    def __init__(self, context: PythonFileContext) -> None:
+        self.context = context
+        self.inventory = context.binding_inventory
+
+    def builtin(self, node: ast.Name) -> bool:
+        return not self.inventory.wildcard and self._binding_scope(node.id, node) is None
+
+    def qualified(self, expression: ast.expr) -> str | None:
+        if self.inventory.wildcard:
+            return None
+        return self._qualified(expression, frozenset(), assignments=True)
+
+    def imported_qualified(self, expression: ast.expr) -> str | None:
+        if self.inventory.wildcard:
+            return None
+        return self._qualified(expression, frozenset(), assignments=False)
+
+    def assigned_value(self, node: ast.Name) -> ast.expr | None:
+        scope = self._binding_scope(node.id, node)
+        declarations = self.inventory.bindings.get(scope, {}).get(node.id, ())
+        stable = tuple(item for item in declarations if not self._inplace_target(item))
+        if len(stable) != 1 or not isinstance(stable[0], ast.Name):
+            return None
+        return self._assignment(stable[0])
+
+    def banned_references(self, names: frozenset[str]) -> list[BuiltinReference]:
+        references = [
+            reference
+            for node in self.context.nodes(ast.Name, ast.Attribute)
+            if (reference := self._banned_reference(node, names)) is not None
+        ]
+        if imported := names.intersection({"exec", "eval"}):
+            references.extend(
+                BuiltinReference(alias, alias.name)
+                for statement in self.context.nodes(ast.ImportFrom)
+                if statement.level == 0 and statement.module == "builtins"
+                for alias in statement.names
+                if alias.name in imported
+            )
+        return sorted(references, key=lambda item: (item.node.lineno, item.node.col_offset))
+
+    def _banned_reference(self, node: ast.Name | ast.Attribute, names: frozenset[str]) -> BuiltinReference | None:
+        if not isinstance(node.ctx, ast.Load):
+            return None
+        if isinstance(node, ast.Name):
+            if node.id not in names or not self.builtin(node):
+                return None
+            name = node.id
+            direct_import = False
+        else:
+            qualified = self.qualified(node)
+            if qualified is None or not qualified.startswith("builtins."):
+                return None
+            name = qualified.removeprefix("builtins.")
+            if name not in names:
+                return None
+            direct_import = self._direct_builtin_module(node.value)
+        if self._native_owner(node, name, direct_import=direct_import):
+            return None
+        return BuiltinReference(node, name)
+
+    def _direct_builtin_module(self, node: ast.expr) -> bool:
+        if not isinstance(node, ast.Name):
+            return False
+        scope = self._binding_scope(node.id, node)
+        declarations = self.inventory.bindings.get(scope, {}).get(node.id, ())
+        return bool(declarations) and all(
+            isinstance(item, ast.alias)
+            and isinstance(self.context.parents.get(item), ast.Import)
+            and item.name == "builtins"
+            for item in declarations
+        )
+
+    def _native_owner(self, node: ast.expr, name: str, *, direct_import: bool) -> bool:
+        if direct_import and name in _RUFF_BANNED_API:
+            return True
+        if name == "eval" and (isinstance(node, ast.Name) or direct_import):
+            return True
+        parent = self.context.parents.get(node)
+        if not isinstance(parent, ast.Call) or parent.func is not node:
+            return False
+        if name in {"exec", "breakpoint"}:
+            return isinstance(node, ast.Name) or direct_import
+        if isinstance(node, ast.Attribute) or parent.keywords:
+            return False
+        match parent.args:
+            case [receiver, ast.Constant(value=str() as value)]:
+                if name == "getattr" and isinstance(receiver, ast.Starred):
+                    return False
+            case _:
+                return False
+        if name == "hasattr":
+            return value == "__call__"
+        if name != "getattr":
+            return False
+        mangled = value.startswith("__") and not value.endswith("__")
+        return value.isidentifier() and not keyword.iskeyword(value) and not mangled
+
+    def _binding_scope(self, name: str, at: ast.AST) -> ast.AST | None:
+        scope = self._scope(at)
+        skip_classes = False
+        while scope is not None:
+            if isinstance(scope, ast.ClassDef) and skip_classes:
+                scope = self._scope(scope)
+                continue
+            declarations = self.inventory.bindings.get(scope, {}).get(name, ())
+            globals_here = any(isinstance(item, ast.Global) for item in declarations)
+            if globals_here and scope is not self.context.tree:
+                if _declares_value(declarations):
+                    return scope
+                scope = self.context.tree
+                continue
+            if _declares_value(declarations) or name in _type_parameters(scope):
+                return scope
+            skip_classes |= isinstance(scope, _FUNCTION_SCOPES)
+            scope = self._scope(scope)
+        return None
+
+    def _scope(self, node: ast.AST) -> ast.AST | None:
+        original = node
+        parent = self.context.parents.get(node)
+        while parent is not None:
+            if isinstance(parent, ast.TypeAlias):
+                return parent
+            if isinstance(parent, ast.comprehension) and parent.iter is node:
+                owner = self.context.parents.get(parent)
+                if (
+                    isinstance(owner, ast.ListComp | ast.SetComp | ast.DictComp | ast.GeneratorExp)
+                    and owner.generators[0] is parent
+                ):
+                    return self._scope(owner)
+            if isinstance(parent, (ast.Module, ast.ClassDef, *_FUNCTION_SCOPES)):
+                break
+            node, parent = parent, self.context.parents.get(parent)
+        return self.inventory.scope(original)
+
+    def _qualified(self, expression: ast.expr, seen: frozenset[ast.AST], *, assignments: bool) -> str | None:
+        if expression in seen:
+            return None
+        seen |= {expression}
+        if isinstance(expression, ast.Attribute):
+            base = self._qualified(expression.value, seen, assignments=assignments)
+            return None if base is None else f"{base}.{expression.attr}"
+        if not isinstance(expression, ast.Name):
+            return None
+        scope = self._binding_scope(expression.id, expression)
+        if scope is None:
+            return f"builtins.{expression.id}" if expression.id in _NATIVE_NAMES else None
+        declarations = self.inventory.bindings.get(scope, {}).get(expression.id, ())
+        declarations = tuple(item for item in declarations if not self._inplace_target(item))
+        if not declarations:
+            return None
+        origins = {self._declaration_origin(item, seen, assignments=assignments) for item in declarations}
+        if len(origins) != 1:
+            return None
+        return next(iter(origins))
+
+    def _declaration_origin(self, node: ast.AST, seen: frozenset[ast.AST], *, assignments: bool) -> str | None:
+        if node in seen:
+            return None
+        parent = self.context.parents.get(node)
+        if isinstance(node, ast.alias):
+            if isinstance(parent, ast.Import):
+                return node.name if node.asname else node.name.partition(".")[0]
+            if isinstance(parent, ast.ImportFrom) and parent.level == 0 and parent.module is not None:
+                return f"{parent.module}.{node.name}"
+        if assignments and isinstance(node, ast.Name) and (value := self._assignment(node)) is not None:
+            return self._qualified(value, seen | {node}, assignments=assignments)
+        return None
+
+    def _assignment(self, node: ast.Name) -> ast.expr | None:
+        parent = self.context.parents.get(node)
+        if isinstance(parent, ast.Assign) and node in parent.targets:
+            return parent.value
+        if isinstance(parent, ast.AnnAssign) and parent.target is node:
+            return parent.value
+        if isinstance(parent, ast.NamedExpr) and parent.target is node:
+            return parent.value
+        return None
+
+    def _inplace_target(self, node: ast.AST) -> bool:
+        parent = self.context.parents.get(node)
+        return isinstance(parent, ast.AugAssign) and parent.target is node
+
+
+def _declares_value(declarations: Iterable[ast.AST]) -> bool:
+    return any(not isinstance(item, ast.Global) for item in declarations)
+
+
+def _type_parameters(scope: ast.AST) -> frozenset[str]:
+    if isinstance(scope, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef | ast.TypeAlias):
+        return frozenset(
+            parameter.name
+            for parameter in scope.type_params
+            if isinstance(parameter, ast.TypeVar | ast.ParamSpec | ast.TypeVarTuple)
+        )
+    return frozenset()

{sarj_python_lint-1.104.0 → sarj_python_lint-1.108.0}/src/sarj_python_lint/rules/_runtime_registry.py

@@ -76,7 +76,9 @@ def _constructor_hooks(rule: type[Rule]) -> _ConstructorHooks | None:
         or not _is_constructor_hook(metaclass_call)
     ):
         return None
-    code: object = getattr(initializer, "__code__", None)
+    code: object = getattr(  # sarj-noqa: SARJ557 -- Validate dynamically imported plugin classes and optional native constructor metadata.
+        initializer, "__code__", None
+    )
     if code is not None and not isinstance(code, CodeType):
         return None
     return _ConstructorHooks(initializer, code, allocator, metaclass_call)
@@ -143,7 +145,9 @@ class _RegistryState:
         if entry.module in sys.modules:
             self.external_modules.add(entry.module)
         module = import_module(entry.module)
-        value: object = getattr(module, entry.class_name, None)
+        value: object = getattr(  # sarj-noqa: SARJ557 -- Validate dynamically imported plugin classes and optional native constructor metadata.
+            module, entry.class_name, None
+        )
         if not isinstance(value, type) or not issubclass(value, Rule):
             msg = f"{entry.rule_id}: descriptor does not resolve to a Rule class"
             raise TypeError(msg)
@@ -201,7 +205,10 @@ class _RegistryState:
                 module is None
                 or rule is None
                 or observed is None
-                or getattr(module, entry.class_name, None) is not rule
+                or getattr(  # sarj-noqa: SARJ557 -- Validate dynamically imported plugin classes and optional native constructor metadata.
+                    module, entry.class_name, None
+                )
+                is not rule
             ):
                 return None
             if (

{sarj_python_lint-1.104.0 → sarj_python_lint-1.108.0}/src/sarj_python_lint/rules/_store_writes.py

@@ -11,6 +11,7 @@ from sqlglot.errors import SqlglotError
 
 from sarj_python_lint.rules._annotation_semantics import AnnotationSemantics, bit_or_members, scope_bound_names
 from sarj_python_lint.rules._ast_index import walk
+from sarj_python_lint.rules._ast_position import ast_position
 from sarj_python_lint.rules._paths import is_generated
 from sarj_python_lint.rules._project_index import ProjectIndexSet
 
@@ -19,6 +20,7 @@ if TYPE_CHECKING:
     from collections.abc import Iterable, Iterator
 
     from sarj_python_lint._file_context import PythonFileContext
+    from sarj_python_lint.rules._ast_position import AstPosition
     from sarj_python_lint.rules._imports import ImportIndex
     from sarj_python_lint.rules._resource_provenance import ResourceProvenance
 
@@ -433,12 +435,6 @@ class _ReceiverOrigin:
     attribute: str | None = None
 
 
-@dataclass(frozen=True, order=True, slots=True)
-class _SourcePosition:
-    line: int
-    column: int
-
-
 class _ReceiverAliases:
     def __init__(self, context: PythonFileContext) -> None:
         self.context = context
@@ -535,8 +531,8 @@ class _ReceiverAliases:
         return frozenset()
 
 
-def _source_position(node: ast.AST) -> _SourcePosition:
-    return _SourcePosition(getattr(node, "lineno", -1), getattr(node, "col_offset", -1))
+def _source_position(node: ast.AST) -> AstPosition:
+    return ast_position(node, missing=-1)
 
 
 class StoreOwners:

{sarj_python_lint-1.104.0 → sarj_python_lint-1.108.0}/src/sarj_python_lint/rules/fastapi_class_router_contract.py

@@ -196,7 +196,7 @@ def _returns_local_router(function: ast.FunctionDef | ast.AsyncFunctionDef, call
         for node in function.body
         if isinstance(node, (ast.Assign, ast.AnnAssign))
         for target in _assignment_targets(node)
-        if isinstance(target, ast.Name) and getattr(node, "value", None) is call
+        if isinstance(target, ast.Name) and node.value is call
     }
     return bool(names) and any(
         isinstance(node, ast.Return) and isinstance(node.value, ast.Name) and node.value.id in names

{sarj_python_lint-1.104.0 → sarj_python_lint-1.108.0}/src/sarj_python_lint/rules/named_record_at_boundaries.py

@@ -251,7 +251,7 @@ def _resolve_annotation(node: ast.expr | None) -> ast.expr | None:
     if isinstance(node, ast.Constant) and isinstance(node.value, str):
         try:
             return ast.parse(node.value.strip(), mode="eval").body
-        except SyntaxError:
+        except SyntaxError, UnicodeError:
             return None
     return node