sarj-python-lint 1.83.1__tar.gz → 1.84.0__tar.gz

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.83.1
+Version: 1.84.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.83.1 → sarj_python_lint-1.84.0}/pyproject.toml

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

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/__main__.py

@@ -187,12 +187,13 @@ _DIAGNOSTIC_PRECEDENCE = MappingProxyType(
         # A proven external or nested request boundary already requires schema
         # validation at this field read. Retain standalone shape advice when
         # that more specific rule is unselected or locally suppressed.
-        "SARJ411": frozenset({"SARJ521"}),
+        "SARJ411": frozenset({"SARJ521", "SARJ535"}),
         # Any-valued mappings are the stronger correctness failure. SARJ008
         # still owns every fixed dictionary return when selected alone, while
         # an all-rules run emits one actionable diagnostic for this overlap.
         "SARJ447": frozenset({"SARJ008"}),
-        "SARJ450": frozenset({"SARJ521"}),
+        "SARJ450": frozenset({"SARJ521", "SARJ535"}),
+        "SARJ521": frozenset({"SARJ535"}),
         "SARJ457": frozenset({"SARJ045"}),
         "SARJ465": frozenset({"SARJ071"}),
         "SARJ491": frozenset({"SARJ400"}),

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/_autofix.py

@@ -993,10 +993,13 @@ def _jwt_required_sequence(required: ast.expr) -> ast.expr | None:
     ):
         return None
     elements = [*required.elts, ast.Constant(value="exp")]
-    if isinstance(required, ast.List):
-        return ast.List(elts=elements, ctx=ast.Load())
-    if isinstance(required, ast.Tuple):
-        return ast.Tuple(elts=elements, ctx=ast.Load())
+    match required:
+        case ast.List():
+            return ast.List(elts=elements, ctx=ast.Load())
+        case ast.Tuple():
+            return ast.Tuple(elts=elements, ctx=ast.Load())
+        case _:
+            pass
     return ast.Set(elts=elements)
 
 

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_annotation_origins.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import ast
+from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 from sarj_python_lint.rules._imports import ImportIndex
@@ -10,6 +11,15 @@ if TYPE_CHECKING:
     from sarj_python_lint._file_context import PythonFileContext
 
 
+_MAX_ALIAS_DEPTH = 32
+
+
+@dataclass(frozen=True, slots=True)
+class ResolvedAnnotation:
+    expression: ast.expr
+    at: ast.expr
+
+
 class AnnotationOrigins:
     def __init__(self, context: PythonFileContext) -> None:
         self.context = context
@@ -19,6 +29,39 @@ class AnnotationOrigins:
             for node in context.nodes(ast.Import, ast.ImportFrom)
         }
 
+    def alias_value(self, node: ast.Name, at: ast.AST) -> ast.expr | None:
+        value = self.context.annotation_semantics.aliases.get(node.id)
+        if value is None:
+            return None
+        binding = self.provenance.binding(node.id, at)
+        if not isinstance(binding, ast.Name):
+            return None
+        parent = self.context.parents.get(binding)
+        if isinstance(parent, ast.TypeAlias | ast.AnnAssign) and parent.value is value:
+            return value
+        return None
+
+    def resolve_annotation(self, node: ast.expr, *, at: ast.expr | None = None) -> ResolvedAnnotation | None:
+        current = node
+        scope = node if at is None else at
+        seen: set[str] = set()
+        for _ in range(_MAX_ALIAS_DEPTH):
+            parsed = self.context.annotation_semantics.parse(current)
+            if parsed is None:
+                return None
+            if isinstance(parsed, ast.Name):
+                if self.shadowed(parsed.id, scope):
+                    return None
+                value = self.alias_value(parsed, scope)
+                if value is not None:
+                    if parsed.id in seen:
+                        return None
+                    seen.add(parsed.id)
+                    current = scope = value
+                    continue
+            return ResolvedAnnotation(parsed, scope)
+        return None
+
     def shadowed(self, name: str, at: ast.AST) -> bool:
         return type_parameter_shadow(name, at, self.context)
 

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_annotation_semantics.py

@@ -158,10 +158,13 @@ def _bound_names(statement: ast.stmt) -> set[str]:
 
 
 def _target_names(node: ast.expr) -> set[str]:
-    if isinstance(node, ast.Name):
-        return {node.id}
-    if isinstance(node, (ast.List, ast.Tuple)):
-        return {name for item in node.elts for name in _target_names(item)}
+    match node:
+        case ast.Name():
+            return {node.id}
+        case ast.List() | ast.Tuple():
+            return {name for item in node.elts for name in _target_names(item)}
+        case _:
+            pass
     return set()
 
 

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_copy_on_write.py

@@ -659,28 +659,37 @@ class CopyOnWriteAnalysis:
         return _Value(_Shape("dict", element=element), shared_children=shared, fields=tuple(fields.items()))
 
     def _write(self, target: ast.expr, bindings: Mapping[str, _Value]) -> None:
-        if isinstance(target, (ast.Tuple, ast.List)):
-            for item in target.elts:
-                self._write(item, bindings)
-        elif isinstance(target, (ast.Attribute, ast.Subscript)):
-            owner = self._value(target.value, bindings)
-            if (
-                owner is not None
-                and owner.borrowed
-                and (
-                    isinstance(target, ast.Subscript)
-                    or (owner.shape.model is not None and self.models.field(owner.shape.model, target.attr) is not None)
-                )
-            ):
-                self.mutations.append(Mutation(target, self._before))
+        match target:
+            case ast.Tuple() | ast.List():
+                for item in target.elts:
+                    self._write(item, bindings)
+            case ast.Attribute() | ast.Subscript():
+                owner = self._value(target.value, bindings)
+                if (
+                    owner is not None
+                    and owner.borrowed
+                    and (
+                        isinstance(target, ast.Subscript)
+                        or (
+                            owner.shape.model is not None
+                            and self.models.field(owner.shape.model, target.attr) is not None
+                        )
+                    )
+                ):
+                    self.mutations.append(Mutation(target, self._before))
+            case _:
+                pass
 
     def _expression(self, node: ast.AST, bindings: dict[str, _Value]) -> None:
-        if isinstance(node, (ast.Lambda, ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
-            return
-        if isinstance(node, ast.NamedExpr):
-            self._expression(node.value, bindings)
-            self._bind(node.target, self._value(node.value, bindings), bindings)
-            return
+        match node:
+            case ast.Lambda() | ast.FunctionDef() | ast.AsyncFunctionDef() | ast.ClassDef():
+                return
+            case ast.NamedExpr():
+                self._expression(node.value, bindings)
+                self._bind(node.target, self._value(node.value, bindings), bindings)
+                return
+            case _:
+                pass
         if isinstance(node, ast.Call) and self._mutator_call(node, bindings):
             self.mutations.append(Mutation(node, self._before))
         if isinstance(node, (ast.ListComp, ast.SetComp, ast.GeneratorExp, ast.DictComp)):

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_docstrings.py

@@ -305,10 +305,13 @@ def base_names(node: ast.ClassDef) -> set[str]:
     names: set[str] = set()
     for base in node.bases:
         target = base.value if isinstance(base, ast.Subscript) else base
-        if isinstance(target, ast.Attribute):
-            names.add(target.attr)
-        elif isinstance(target, ast.Name):
-            names.add(target.id)
+        match target:
+            case ast.Attribute():
+                names.add(target.attr)
+            case ast.Name():
+                names.add(target.id)
+            case _:
+                pass
     return names
 
 

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_fastapi.py

@@ -241,10 +241,13 @@ class FastapiIndex:
         for node in walk_ast(tree):
             if self._node_scopes[id(node)] != 0:
                 continue
-            if isinstance(node, ast.Import):
-                self._read_import(node)
-            elif isinstance(node, ast.ImportFrom):
-                self._read_import_from(node)
+            match node:
+                case ast.Import():
+                    self._read_import(node)
+                case ast.ImportFrom():
+                    self._read_import_from(node)
+                case _:
+                    pass
 
     def _read_import(self, node: ast.Import) -> None:
         for alias in node.names:

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_imports.py

@@ -141,10 +141,13 @@ def _module_non_import_bindings(tree: ast.Module) -> set[str]:
 
 
 def _target_names(node: ast.expr) -> set[str]:
-    if isinstance(node, ast.Name):
-        return {node.id}
-    if isinstance(node, (ast.Tuple, ast.List)):
-        return {name for element in node.elts for name in _target_names(element)}
+    match node:
+        case ast.Name():
+            return {node.id}
+        case ast.Tuple() | ast.List():
+            return {name for element in node.elts for name in _target_names(element)}
+        case _:
+            pass
     return set()
 
 

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_mapping_shape_callbacks.py

@@ -59,14 +59,17 @@ class RawMappingCallbacks:
     def callback(self, node: ast.expr, *, seen: frozenset[ast.AST] = frozenset()) -> _Function | None:
         if len(seen) >= _MAX_DEPTH:
             return None
-        if isinstance(node, ast.Call):
-            return (
-                self._partial(node, seen)
-                if self.qualified(node.func, node) == "functools.partial"
-                else self._method(node, "__call__", seen)
-            )
-        if isinstance(node, ast.Attribute):
-            return self._method(node.value, node.attr, seen)
+        match node:
+            case ast.Call():
+                return (
+                    self._partial(node, seen)
+                    if self.qualified(node.func, node) == "functools.partial"
+                    else self._method(node, "__call__", seen)
+                )
+            case ast.Attribute():
+                return self._method(node.value, node.attr, seen)
+            case _:
+                pass
         if not isinstance(node, ast.Name) or not self._stable(node.id) or self.shadowed(node.id, node):
             return None
         binding = self.provenance.binding(node.id, node)
@@ -144,10 +147,13 @@ class RawMappingCallbacks:
     def _function(self, node: ast.AST) -> _Function | None:
         current = self.context.parents.get(node)
         while current is not None:
-            if isinstance(current, ast.FunctionDef | ast.AsyncFunctionDef):
-                return current
-            if isinstance(current, ast.ClassDef | ast.Lambda):
-                return None
+            match current:
+                case ast.FunctionDef() | ast.AsyncFunctionDef():
+                    return current
+                case ast.ClassDef() | ast.Lambda():
+                    return None
+                case _:
+                    pass
             current = self.context.parents.get(current)
         return None
 

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_native_object_contracts.py

@@ -406,11 +406,14 @@ class _NamespaceFlow:
     def plain_dict(self, value: ast.expr, *, depth: int = 0) -> bool:
         if depth >= _MAX_DEPTH:
             return False
-        if isinstance(value, ast.Name):
-            assigned = self.assigned(value)
-            return assigned is not None and self.plain_dict(assigned, depth=depth + 1)
-        if isinstance(value, ast.IfExp):
-            return self.plain_dict(value.body, depth=depth + 1) and self.plain_dict(value.orelse, depth=depth + 1)
+        match value:
+            case ast.Name():
+                assigned = self.assigned(value)
+                return assigned is not None and self.plain_dict(assigned, depth=depth + 1)
+            case ast.IfExp():
+                return self.plain_dict(value.body, depth=depth + 1) and self.plain_dict(value.orelse, depth=depth + 1)
+            case _:
+                pass
         return isinstance(value, ast.Dict) or (isinstance(value, ast.Call) and self.native.dict_call(value))
 
     def _collect(self, value: ast.expr, *, execution: ast.Call, depth: int = 0) -> None:
@@ -436,10 +439,13 @@ class _NamespaceFlow:
     def _input(self, value: ast.expr, *, depth: int = 0) -> set[ast.arg]:
         if depth >= _MAX_DEPTH:
             return set()
-        if isinstance(value, ast.Name):
-            return self._name_input(value, depth)
-        if isinstance(value, ast.Dict):
-            return self._dictionary_inputs(value, depth)
+        match value:
+            case ast.Name():
+                return self._name_input(value, depth)
+            case ast.Dict():
+                return self._dictionary_inputs(value, depth)
+            case _:
+                pass
         if isinstance(value, ast.Call) and self.native.dict_call(value):
             return self._constructor_inputs(value, depth)
         found: set[ast.arg] = set()
@@ -652,13 +658,16 @@ class _NamespaceEscapes:
             return None
         binding = self.flow.binding(value)
         found: set[ast.AST] = {binding} if binding is not None else set()
-        if isinstance(value, ast.Name):
-            assigned = self.flow.assigned(value)
-            if isinstance(assigned, ast.Name | ast.Subscript):
-                previous = self._carrier_roots(assigned, depth=depth + 1)
-                return None if previous is None else found | previous
-        elif isinstance(value, ast.Subscript):
-            return self._carrier_roots(value.value, depth=depth + 1)
+        match value:
+            case ast.Name():
+                assigned = self.flow.assigned(value)
+                if isinstance(assigned, ast.Name | ast.Subscript):
+                    previous = self._carrier_roots(assigned, depth=depth + 1)
+                    return None if previous is None else found | previous
+            case ast.Subscript():
+                return self._carrier_roots(value.value, depth=depth + 1)
+            case _:
+                pass
         return found
 
 

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_opaque_contracts.py

@@ -427,10 +427,13 @@ class OpaqueContractFacts:
 
     def _enclosing_assertion(self, node: ast.AST) -> ast.Assert | None:
         while (parent := self.context.parents.get(node)) is not None:
-            if isinstance(parent, ast.Assert):
-                return parent
-            if isinstance(parent, ast.FunctionDef | ast.AsyncFunctionDef | ast.Lambda):
-                return None
+            match parent:
+                case ast.Assert():
+                    return parent
+                case ast.FunctionDef() | ast.AsyncFunctionDef() | ast.Lambda():
+                    return None
+                case _:
+                    pass
             node = parent
         return None
 
@@ -534,11 +537,14 @@ class OpaqueContractFacts:
             return None
         if isinstance(node, ast.Name):
             binding = self.facts.provenance.runtime_binding(node.id, node)
-            if isinstance(binding, ast.arg):
-                return binding
-            if isinstance(binding, ast.Name):
-                value = self.assigned(binding, node)
-                return self.parameter(value, depth=depth + 1) if value is not None else None
+            match binding:
+                case ast.arg():
+                    return binding
+                case ast.Name():
+                    value = self.assigned(binding, node)
+                    return self.parameter(value, depth=depth + 1) if value is not None else None
+                case _:
+                    pass
         receiver = _projection_receiver(node)
         parameter = self.parameter(receiver, depth=depth + 1) if receiver is not None else None
         return parameter if self._raw_annotation(parameter) else None
@@ -993,12 +999,13 @@ def _projection_receiver(node: ast.expr) -> ast.expr | None:
 
 
 def _control_condition(node: ast.AST, parent: ast.AST) -> tuple[ast.expr, bool] | None:
-    if isinstance(parent, ast.IfExp):
-        accepted, rejected = node is parent.body, node is parent.orelse
-    elif isinstance(parent, ast.If):
-        accepted, rejected = node in parent.body, node in parent.orelse
-    else:
-        return None
+    match parent:
+        case ast.IfExp():
+            accepted, rejected = node is parent.body, node is parent.orelse
+        case ast.If():
+            accepted, rejected = node in parent.body, node in parent.orelse
+        case _:
+            return None
     return (parent.test, accepted) if accepted or rejected else None
 
 

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_project_index.py

@@ -1271,10 +1271,13 @@ def _module_constructor_declarations(statement: ast.stmt) -> frozenset[str]:
 
 
 def _direct_functions(owner: ast.stmt) -> tuple[ast.FunctionDef | ast.AsyncFunctionDef, ...]:
-    if isinstance(owner, ast.FunctionDef | ast.AsyncFunctionDef):
-        return (owner,)
-    if isinstance(owner, ast.ClassDef):
-        return tuple(item for item in owner.body if isinstance(item, ast.FunctionDef | ast.AsyncFunctionDef))
+    match owner:
+        case ast.FunctionDef() | ast.AsyncFunctionDef():
+            return (owner,)
+        case ast.ClassDef():
+            return tuple(item for item in owner.body if isinstance(item, ast.FunctionDef | ast.AsyncFunctionDef))
+        case _:
+            pass
     return ()
 
 

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_prose_budget.py

@@ -228,10 +228,13 @@ def _decorator_terminal_names(node: ast.FunctionDef | ast.AsyncFunctionDef | ast
     names: set[str] = set()
     for decorator in node.decorator_list:
         target = decorator.func if isinstance(decorator, ast.Call) else decorator
-        if isinstance(target, ast.Name):
-            names.add(target.id.casefold())
-        elif isinstance(target, ast.Attribute):
-            names.add(target.attr.casefold())
+        match target:
+            case ast.Name():
+                names.add(target.id.casefold())
+            case ast.Attribute():
+                names.add(target.attr.casefold())
+            case _:
+                pass
     return frozenset(names)
 
 

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_registry.py

@@ -250,6 +250,9 @@ from sarj_python_lint.rules.prefer_precise_object_contract import PreferPreciseO
 from sarj_python_lint.rules.prefer_psycopg_executemany import PreferPsycopgExecutemany
 from sarj_python_lint.rules.prefer_pydantic_model_assertion import PreferPydanticModelAssertion
 from sarj_python_lint.rules.prefer_pytest_dependency_fixtures import PreferPytestDependencyFixtures
+from sarj_python_lint.rules.prefer_runtime_validation import PreferRuntimeValidation
+from sarj_python_lint.rules.prefer_typed_cli import PreferTypedCli
+from sarj_python_lint.rules.prefer_typed_mapping_get import PreferTypedMappingGet
 from sarj_python_lint.rules.prefer_typed_settings_field import PreferTypedSettingsField
 from sarj_python_lint.rules.pytest_fixture_returns_closed_resource import PytestFixtureReturnsClosedResource
 from sarj_python_lint.rules.redundant_test_constructor_forwarder import RedundantTestConstructorForwarder
@@ -266,6 +269,9 @@ REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
         AsyncExecutorShutdown.id: AsyncExecutorShutdown,
         NanHiddenByBuiltinMin.id: NanHiddenByBuiltinMin,
         FailedProbeZeroThreshold.id: FailedProbeZeroThreshold,
+        PreferTypedMappingGet.id: PreferTypedMappingGet,
+        PreferRuntimeValidation.id: PreferRuntimeValidation,
+        PreferTypedCli.id: PreferTypedCli,
         PreferGroupedSettings.id: PreferGroupedSettings,
         NoRedundantLocalAlias.id: NoRedundantLocalAlias,
         PytestFixtureReturnsClosedResource.id: PytestFixtureReturnsClosedResource,

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_resource_provenance.py

@@ -225,12 +225,13 @@ class ResourceProvenance:
             if not isinstance(node, ast.alias):
                 return False
             parent = self.parents.get(node)
-            if isinstance(parent, ast.Import):
-                targets.add(("import", None, 0, node.name))
-            elif isinstance(parent, ast.ImportFrom):
-                targets.add(("from", parent.module, parent.level, node.name))
-            else:
-                return False
+            match parent:
+                case ast.Import():
+                    targets.add(("import", None, 0, node.name))
+                case ast.ImportFrom():
+                    targets.add(("from", parent.module, parent.level, node.name))
+                case _:
+                    return False
         return len(targets) == 1
 
     def imported(self, node: ast.expr, qualified: str) -> bool:

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_store_writes.py

@@ -165,11 +165,14 @@ def _free_names(expression: ast.expr) -> Iterator[str]:
         node, shadowed = pending.pop()
         if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Load) and node.id not in shadowed:
             yield node.id
-        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef | ast.Lambda):
-            continue
-        if isinstance(node, ast.ListComp | ast.SetComp | ast.DictComp | ast.GeneratorExp):
-            pending.extend(_comprehension_scopes(node, shadowed))
-            continue
+        match node:
+            case ast.FunctionDef() | ast.AsyncFunctionDef() | ast.ClassDef() | ast.Lambda():
+                continue
+            case ast.ListComp() | ast.SetComp() | ast.DictComp() | ast.GeneratorExp():
+                pending.extend(_comprehension_scopes(node, shadowed))
+                continue
+            case _:
+                pass
         pending.extend((child, shadowed) for child in ast.iter_child_nodes(node))
 
 

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_test_composition.py

@@ -274,20 +274,23 @@ def _value_key(
     scope: WiringScope,
     seen: frozenset[str] = frozenset(),
 ) -> str | None:
-    if isinstance(value, ast.Name):
-        if value.id in seen or value.id in scope.blocked:
-            return None
-        if value.id in scope.aliases:
-            return _value_key(
-                context,
-                project,
-                scope.aliases[value.id],
-                scope,
-                seen=seen | {value.id},
-            )
-        return f"fixture:{value.id}" if value.id in scope.parameters else None
-    if isinstance(value, ast.Constant):
-        return ast.dump(value)
+    match value:
+        case ast.Name():
+            if value.id in seen or value.id in scope.blocked:
+                return None
+            if value.id in scope.aliases:
+                return _value_key(
+                    context,
+                    project,
+                    scope.aliases[value.id],
+                    scope,
+                    seen=seen | {value.id},
+                )
+            return f"fixture:{value.id}" if value.id in scope.parameters else None
+        case ast.Constant():
+            return ast.dump(value)
+        case _:
+            pass
     if not isinstance(value, ast.Call):
         return None
     callee = unalias(value.func, scope.aliases)

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/complex_postgres_query_requires_architecture_review.py

@@ -174,11 +174,14 @@ def _recoverable_query_root(node: ast.expr, constructors: frozenset[str]) -> ast
 
 
 def _qualified_name(node: ast.expr) -> str:
-    if isinstance(node, ast.Name):
-        return node.id
-    if isinstance(node, ast.Attribute):
-        owner = _qualified_name(node.value)
-        return f"{owner}.{node.attr}" if owner else node.attr
+    match node:
+        case ast.Name():
+            return node.id
+        case ast.Attribute():
+            owner = _qualified_name(node.value)
+            return f"{owner}.{node.attr}" if owner else node.attr
+        case _:
+            pass
     return ""
 
 

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/docstring_args_restate_signature.py

@@ -160,10 +160,13 @@ class DocstringArgsRestateSignature(Rule):
         pending: list[tuple[ast.AST, str | None]] = [(child, class_name) for child in reversed(children(node))]
         while pending:
             child, owner = pending.pop()
-            if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
-                self._check_function(child, owner, path, imports, diags)
-            elif isinstance(child, ast.ClassDef):
-                owner = child.name
+            match child:
+                case ast.FunctionDef() | ast.AsyncFunctionDef():
+                    self._check_function(child, owner, path, imports, diags)
+                case ast.ClassDef():
+                    owner = child.name
+                case _:
+                    pass
             pending.extend((nested, owner) for nested in reversed(children(child)))
 
     def _check_function(

{sarj_python_lint-1.83.1 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/docstring_returns_restate_signature.py

@@ -230,10 +230,13 @@ class DocstringReturnsRestateSignature(Rule):
         pending: list[tuple[ast.AST, str | None]] = [(child, class_name) for child in reversed(children(node))]
         while pending:
             child, owner = pending.pop()
-            if isinstance(child, ast.FunctionDef | ast.AsyncFunctionDef):
-                self._check_function(child, owner, path, imports, diags)
-            elif isinstance(child, ast.ClassDef):
-                owner = child.name
+            match child:
+                case ast.FunctionDef() | ast.AsyncFunctionDef():
+                    self._check_function(child, owner, path, imports, diags)
+                case ast.ClassDef():
+                    owner = child.name
+                case _:
+                    pass
             pending.extend((nested, owner) for nested in reversed(children(child)))
 
     def _check_function(
@@ -333,10 +336,13 @@ def _contains_yield(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
     pending: list[ast.AST] = list(node.body)
     while pending:
         current = pending.pop()
-        if isinstance(current, (ast.Yield, ast.YieldFrom)):
-            return True
-        if isinstance(current, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)):
-            continue
+        match current:
+            case ast.Yield() | ast.YieldFrom():
+                return True
+            case ast.FunctionDef() | ast.AsyncFunctionDef() | ast.ClassDef() | ast.Lambda():
+                continue
+            case _:
+                pass
         pending.extend(children(current))
     return False