sarj-python-lint 1.28.6__tar.gz → 1.29.1__tar.gz

{sarj_python_lint-1.28.6 → sarj_python_lint-1.29.1}/PKG-INFO

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

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

{sarj_python_lint-1.28.6 → sarj_python_lint-1.29.1}/src/sarj_python_lint/__main__.py

@@ -177,6 +177,7 @@ _DIAGNOSTIC_PRECEDENCE = MappingProxyType(
         "SARJ447": frozenset({"SARJ008"}),
         "SARJ457": frozenset({"SARJ045"}),
         "SARJ465": frozenset({"SARJ071"}),
+        "SARJ491": frozenset({"SARJ400"}),
     }
 )
 
@@ -190,6 +191,33 @@ class _OwnerLocation(NamedTuple):
     column: int
 
 
+@dataclass(frozen=True, slots=True)
+class _DiagnosticOwners:
+    docstrings: dict[int, _OwnerLocation]
+    signatures: dict[int, _OwnerLocation]
+    fields: tuple[ast.AnnAssign, ...]
+
+    def location(self, diagnostic: Diagnostic) -> _OwnerLocation:
+        if diagnostic.code in {"SARJ400", "SARJ491"}:
+            return _field_owner_location(diagnostic, self.fields)
+        owners = (
+            self.signatures
+            if diagnostic.code in {"SARJ008", "SARJ034", "SARJ093", "SARJ094", "SARJ447"}
+            else self.docstrings
+        )
+        return _OwnerLocation(*owners.get(diagnostic.line, (diagnostic.line, diagnostic.col)))
+
+    def presence(self, diags: list[Diagnostic]) -> dict[tuple[Path, int, int], dict[str, set[Severity]]]:
+        present: dict[tuple[Path, int, int], dict[str, set[Severity]]] = {}
+        for diagnostic in diags:
+            if diagnostic.code == "SARJ094" and not diagnostic.message.startswith("[return]"):
+                continue
+            location = self.location(diagnostic)
+            by_code = present.setdefault((diagnostic.path, location.line, location.column), {})
+            by_code.setdefault(diagnostic.code, set()).add(diagnostic.severity)
+        return present
+
+
 def deduplicate_diagnostics(
     diags: list[Diagnostic], *, source: str | None = None, context: PythonFileContext | None = None
 ) -> list[Diagnostic]:
@@ -203,30 +231,20 @@ def deduplicate_diagnostics(
         or ("SARJ094" in codes and not codes.isdisjoint(_DIAGNOSTIC_PRECEDENCE["SARJ094"]))
     )
     needs_composition_owners = {"SARJ066", "SARJ457"} <= codes
+    needs_field_owners = {"SARJ400", "SARJ491"} <= codes
     tree = (
         _diagnostic_owner_tree(source, context)
-        if needs_docstring_owners or needs_signature_owners or needs_composition_owners
+        if needs_docstring_owners or needs_signature_owners or needs_composition_owners or needs_field_owners
         else None
     )
     diags = _deduplicate_test_composition(diags, tree)
-    docstring_owners = _docstring_owner_locations(tree) if needs_docstring_owners else {}
-    signature_owners = _function_signature_owner_locations(tree) if needs_signature_owners else {}
-
-    def owner_location(diagnostic: Diagnostic) -> _OwnerLocation:
-        if diagnostic.code in {"SARJ008", "SARJ034", "SARJ093", "SARJ094", "SARJ447"}:
-            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:
-        if diagnostic.code == "SARJ094" and not diagnostic.message.startswith("[return]"):
-            continue
-        location = owner_location(diagnostic)
-        by_code = present.setdefault((diagnostic.path, location.line, location.column), {})
-        by_code.setdefault(diagnostic.code, set()).add(diagnostic.severity)
-    suppressed = _suppressed_diagnostics(present)
+    owners = _DiagnosticOwners(
+        docstrings=_docstring_owner_locations(tree) if needs_docstring_owners else {},
+        signatures=_function_signature_owner_locations(tree) if needs_signature_owners else {},
+        fields=_field_owners(tree) if needs_field_owners else (),
+    )
+
+    suppressed = _suppressed_diagnostics(owners.presence(diags))
     return [
         diagnostic
         for diagnostic in diags
@@ -234,8 +252,8 @@ def deduplicate_diagnostics(
             (
                 (
                     diagnostic.path,
-                    owner_location(diagnostic).line,
-                    owner_location(diagnostic).column,
+                    owners.location(diagnostic).line,
+                    owners.location(diagnostic).column,
                 ),
                 diagnostic.code,
                 diagnostic.severity,
@@ -255,6 +273,22 @@ def _diagnostic_owner_tree(source: str | None, context: PythonFileContext | None
     return None
 
 
+def _field_owners(tree: ast.Module | None) -> tuple[ast.AnnAssign, ...]:
+    if tree is None:
+        return ()
+    return tuple(node for node in ast.walk(tree) if isinstance(node, ast.AnnAssign))
+
+
+def _field_owner_location(diagnostic: Diagnostic, fields: tuple[ast.AnnAssign, ...]) -> _OwnerLocation:
+    location = (diagnostic.line, diagnostic.col - 1)
+    for field in fields:
+        start = (field.lineno, field.col_offset)
+        end = (field.end_lineno or field.lineno, field.end_col_offset or field.col_offset)
+        if start <= location < end:
+            return _OwnerLocation(field.lineno, field.col_offset + 1)
+    return _OwnerLocation(diagnostic.line, diagnostic.col)
+
+
 def _deduplicate_test_composition(diags: list[Diagnostic], tree: ast.Module | None) -> list[Diagnostic]:
     codes = {diagnostic.code for diagnostic in diags}
     if tree is None or not {"SARJ066", "SARJ457"} <= codes:

sarj_python_lint-1.29.1/src/sarj_python_lint/rules/_exports.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import ast
+
+from sarj_python_lint.rules._ast_index import walk
+
+
+def mentions_dunder_all(node: ast.AST) -> bool:
+    for child in walk(node):
+        match child:
+            case ast.Name(id="__all__"):
+                return True
+            case ast.alias() if (child.asname or child.name).split(".")[0] == "__all__":
+                return True
+            case ast.FunctionDef() | ast.AsyncFunctionDef() | ast.ClassDef() if child.name == "__all__":
+                return True
+            case ast.arg(arg="__all__") | ast.ExceptHandler(name="__all__"):
+                return True
+            case ast.MatchAs() | ast.MatchStar() if child.name == "__all__":
+                return True
+            case ast.MatchMapping(rest="__all__"):
+                return True
+            case ast.Global() | ast.Nonlocal() if "__all__" in child.names:
+                return True
+            case _:
+                pass
+    return False

sarj_python_lint-1.29.1/src/sarj_python_lint/rules/_namespace_access.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping
+
+    from sarj_python_lint.rules._imports import ImportIndex
+
+
+_NAMESPACE_APIS = frozenset({"globals", "locals", "vars", "exec", "eval", "__import__"})
+_DYNAMIC_MEMBERS = frozenset(
+    {
+        "__dict__",
+        "__globals__",
+        "__code__",
+        "__setattr__",
+        "__delattr__",
+        "__getattribute__",
+        "f_globals",
+        "f_locals",
+        "f_builtins",
+    }
+)
+_MODULE_APIS = {
+    "sys": frozenset({"modules", "_getframe"}),
+    "importlib": frozenset({"import_module"}),
+    "builtins": _NAMESPACE_APIS,
+}
+
+
+def dynamic_namespace_access(
+    nodes: Iterable[ast.AST], imports: ImportIndex, parents: Mapping[ast.AST, ast.AST]
+) -> bool:
+    indexed = tuple(nodes)
+    aliases = _namespace_api_aliases(indexed)
+    modules = _namespace_module_bindings(indexed)
+    return any(_namespace_reference(node, aliases, modules, imports, parents) for node in indexed)
+
+
+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:
+            continue
+        members = _MODULE_APIS[node.module]
+        aliases.update(alias.asname or alias.name for alias in node.names if alias.name in members)
+    return aliases
+
+
+def _namespace_module_bindings(nodes: Iterable[ast.AST]) -> dict[str, str]:
+    modules: dict[str, str] = {}
+    for node in nodes:
+        if not isinstance(node, ast.Import):
+            continue
+        modules.update({alias.asname or alias.name: alias.name for alias in node.names if alias.name in _MODULE_APIS})
+    return modules
+
+
+def _namespace_reference(
+    node: ast.AST,
+    aliases: set[str],
+    modules: dict[str, str],
+    imports: ImportIndex,
+    parents: Mapping[ast.AST, ast.AST],
+) -> bool:
+    if isinstance(node, ast.Attribute):
+        if node.attr in _DYNAMIC_MEMBERS:
+            return True
+        qualified = imports.resolved_qualified_name(node)
+        return qualified in {"sys.modules", "importlib.import_module"} or (
+            imports.resolved_symbol(node, sources=frozenset({"builtins"})) in _NAMESPACE_APIS
+        )
+    if not isinstance(node, ast.Name) or not isinstance(node.ctx, ast.Load):
+        return False
+    if node.id in aliases:
+        return True
+    module = modules.get(node.id)
+    if module is None:
+        return False
+    parent = parents.get(node)
+    return not isinstance(parent, ast.Attribute) or parent.value is not node or parent.attr in _MODULE_APIS[module]

sarj_python_lint-1.29.1/src/sarj_python_lint/rules/_pydantic_field_contract.py

@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+import ast
+from collections import Counter
+from functools import lru_cache
+import tomllib
+from typing import TYPE_CHECKING, TypeIs
+
+from packaging.requirements import InvalidRequirement, Requirement
+from packaging.version import InvalidVersion, Version
+
+from sarj_python_lint.json_boundary import is_object_mapping
+from sarj_python_lint.rules._first_party import distribution_root
+from sarj_python_lint.rules._namespace_access import dynamic_namespace_access
+
+
+if TYPE_CHECKING:
+    from sarj_python_lint._file_context import PythonFileContext
+
+
+MODEL_SOURCES = frozenset({"pydantic", "pydantic.main"})
+FIELD_SOURCES = frozenset({"pydantic", "pydantic.fields"})
+DECORATOR_SOURCES = frozenset({"pydantic", "pydantic.functional_validators", "pydantic.functional_serializers"})
+TYPING_SOURCES = frozenset({"typing", "typing_extensions"})
+_ALIAS_VERSION = Version("2.11")
+_BUILTIN_BINDINGS = frozenset({"int", "float", "str", "list", "classmethod", "staticmethod"})
+_SENSITIVE_MODULES = frozenset({"pydantic", "typing", "typing_extensions", "builtins"})
+
+
+def direct_models(context: PythonFileContext, *, methods: bool = False) -> tuple[ast.ClassDef, ...]:
+    tree = context.tree
+    if tree is None or context.generated or context.has_wildcard_import:
+        return ()
+    if (
+        _mutated_imports(context)
+        or _ambiguous_imports(context)
+        or _escaped_imports(context)
+        or dynamic_namespace_access(context.nodes(ast.AST), context.imports, context.parents)
+    ):
+        return ()
+    return tuple(
+        node
+        for node in tree.body
+        if isinstance(node, ast.ClassDef)
+        and len(node.bases) == 1
+        and context.imports.resolves(node.bases[0], sources=MODEL_SOURCES, symbol="BaseModel")
+        and not node.decorator_list
+        and not node.keywords
+        and not node.type_params
+        and all(_plain_member(member, context, methods=methods) for member in node.body)
+    )
+
+
+def _plain_member(node: ast.stmt, context: PythonFileContext, *, methods: bool) -> bool:
+    match node:
+        case ast.AnnAssign(target=ast.Name(id=name), annotation=annotation, value=value):
+            return (
+                not name.startswith("__")
+                and _inert_annotation(annotation, context)
+                and (value is None or _inert_expr(value, context))
+            )
+        case ast.Assign(targets=targets, value=value):
+            return all(
+                isinstance(target, ast.Name) and not target.id.startswith("__") for target in targets
+            ) and _inert_expr(value, context)
+        case ast.FunctionDef(name=name) | ast.AsyncFunctionDef(name=name):
+            return (
+                methods and not name.startswith("__") and name != "model_post_init" and _inert_signature(node, context)
+            )
+        case ast.Pass() | ast.Expr(value=ast.Constant(value=str())):
+            return True
+        case _:
+            return False
+
+
+def _inert_annotation(node: ast.expr, context: PythonFileContext) -> bool:
+    if isinstance(node, ast.Constant) and isinstance(node.value, str):
+        try:
+            node = ast.parse(node.value, mode="eval").body
+        except SyntaxError:
+            return False
+    return _inert_expr(node, context)
+
+
+def _inert_signature(node: ast.FunctionDef | ast.AsyncFunctionDef, context: PythonFileContext) -> bool:
+    if node.type_params:
+        return False
+    arguments = (
+        *node.args.posonlyargs,
+        *node.args.args,
+        *node.args.kwonlyargs,
+        *((node.args.vararg,) if node.args.vararg else ()),
+        *((node.args.kwarg,) if node.args.kwarg else ()),
+    )
+    annotations = [argument.annotation for argument in arguments if argument.annotation is not None]
+    if node.returns is not None:
+        annotations.append(node.returns)
+    defaults = (*node.args.defaults, *(value for value in node.args.kw_defaults if value is not None))
+    return all(_inert_annotation(annotation, context) for annotation in annotations) and all(
+        _inert_expr(value, context) for value in defaults
+    )
+
+
+def _inert_expr(node: ast.AST, context: PythonFileContext) -> bool:
+    if isinstance(node, ast.Lambda):
+        return not node.args.defaults and not node.args.kw_defaults
+    if isinstance(node, ast.Call):
+        target = context.imports.resolved_qualified_name(node.func)
+        if target not in {
+            "pydantic.Field",
+            "pydantic.fields.Field",
+            "pydantic.ConfigDict",
+            "pydantic.config.ConfigDict",
+        }:
+            return False
+        if any(keyword.arg is None for keyword in node.keywords) or any(
+            isinstance(argument, ast.Starred) for argument in node.args
+        ):
+            return False
+    if isinstance(
+        node,
+        (ast.NamedExpr, ast.Await, ast.Yield, ast.YieldFrom, ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp),
+    ):
+        return False
+    return all(_inert_expr(child, context) for child in ast.iter_child_nodes(node))
+
+
+def _mutated_imports(context: PythonFileContext) -> bool:
+    for node in context.nodes(ast.Attribute, ast.Subscript, ast.Call):
+        if isinstance(node, (ast.Attribute, ast.Subscript)) and isinstance(node.ctx, (ast.Store, ast.Del)):
+            if _sensitive_import_root(node, context):
+                return True
+        elif (
+            isinstance(node, ast.Call)
+            and node.args
+            and _is_attribute_mutator(node.func, context)
+            and _sensitive_import_root(node.args[0], context)
+        ):
+            return True
+    return False
+
+
+def _sensitive_import_root(node: ast.expr, context: PythonFileContext) -> bool:
+    while isinstance(node, (ast.Attribute, ast.Subscript)):
+        node = node.value
+    binding = context.module_imports.bindings.get(node.id) if isinstance(node, ast.Name) else None
+    return binding is not None and binding.module.partition(".")[0] in _SENSITIVE_MODULES
+
+
+def _is_attribute_mutator(node: ast.expr, context: PythonFileContext) -> bool:
+    names = {"setattr", "delattr"}
+    return (
+        isinstance(node, ast.Name) and node.id in names and context.imports.builtin_is_unshadowed(node.id)
+    ) or context.imports.resolved_symbol(node, sources=frozenset({"builtins"})) in names
+
+
+def _escaped_imports(context: PythonFileContext) -> bool:
+    for node in context.nodes(ast.Name, ast.Attribute):
+        if not isinstance(node.ctx, ast.Load) or not _sensitive_import_root(node, context):
+            continue
+        parent = context.parents.get(node)
+        if isinstance(parent, ast.Attribute) and parent.value is node:
+            continue
+        if (isinstance(node, ast.Name) and node.id == "TYPE_CHECKING") or _type_reference(node, parent):
+            continue
+        return True
+    return False
+
+
+def _type_reference(node: ast.expr, parent: ast.AST | None) -> bool:
+    match parent:
+        case ast.Call(func=func):
+            return func is node
+        case ast.ClassDef(bases=bases):
+            return node in bases
+        case ast.Subscript(value=value):
+            return value is node
+        case ast.arg(annotation=annotation) | ast.AnnAssign(annotation=annotation):
+            return annotation is node
+        case ast.FunctionDef(returns=annotation) | ast.AsyncFunctionDef(returns=annotation):
+            return annotation is node
+        case _:
+            return False
+
+
+def _ambiguous_imports(context: PythonFileContext) -> bool:
+    return any(
+        _nested_namespace_import(node, context) or _ambiguous_import(node, context)
+        for node in context.nodes(ast.Import, ast.ImportFrom)
+    )
+
+
+def _nested_namespace_import(node: ast.Import | ast.ImportFrom, context: PythonFileContext) -> bool:
+    if context.parents.get(node) is context.tree:
+        return False
+    if isinstance(node, ast.ImportFrom):
+        return (node.module or "").partition(".")[0] in _SENSITIVE_MODULES
+    return any(alias.name.partition(".")[0] in _SENSITIVE_MODULES for alias in node.names)
+
+
+def _ambiguous_import(node: ast.Import | ast.ImportFrom, context: PythonFileContext) -> bool:
+    for alias in node.names:
+        name = alias.asname or alias.name.partition(".")[0]
+        if name in _BUILTIN_BINDINGS:
+            return True
+        binding = context.module_imports.bindings.get(name)
+        if binding is None or binding.module.partition(".")[0] not in {"pydantic", "typing", "typing_extensions"}:
+            continue
+        if context.parents.get(node) is not context.tree:
+            return True
+        if isinstance(node, ast.ImportFrom) and (
+            node.level != 0 or node.module != binding.module or alias.name != binding.symbol
+        ):
+            return True
+    return False
+
+
+def unique_members(model: ast.ClassDef) -> frozenset[str]:
+    names: list[str] = []
+    for member in model.body:
+        match member:
+            case ast.FunctionDef(name=name) | ast.AsyncFunctionDef(name=name) | ast.AnnAssign(target=ast.Name(id=name)):
+                names.append(name)
+            case ast.Assign(targets=targets):
+                names.extend(target.id for target in targets if isinstance(target, ast.Name))
+            case _:
+                pass
+    return frozenset(name for name, count in Counter(names).items() if count == 1)
+
+
+def has_alias_validation_options(context: PythonFileContext) -> bool:
+    root = distribution_root(context.path, facts=context.session.first_party)
+    if root is None:
+        return False
+    try:
+        source = (root / "pyproject.toml").read_text(encoding="utf-8")
+    except OSError:
+        return False
+    return _declares_alias_validation_options(source)
+
+
+@lru_cache(maxsize=256)
+def _declares_alias_validation_options(source: str) -> bool:
+    try:
+        document = _parse_toml(source)
+    except tomllib.TOMLDecodeError:
+        return False
+    if not is_object_mapping(document):
+        return False
+    project = document.get("project")
+    if not is_object_mapping(project):
+        return False
+    dependencies = project.get("dependencies")
+    if not _is_object_list(dependencies):
+        return False
+    return any(_alias_dependency(raw) for raw in dependencies)
+
+
+def _alias_dependency(raw: object) -> bool:
+    if not isinstance(raw, str):
+        return False
+    try:
+        requirement = Requirement(raw)
+    except InvalidRequirement:
+        return False
+    if requirement.name.casefold() != "pydantic" or requirement.marker is not None or requirement.url is not None:
+        return False
+    for specifier in requirement.specifier:
+        if specifier.operator not in {">", ">=", "==", "===", "~="}:
+            continue
+        try:
+            version = Version(specifier.version.removesuffix(".*"))
+        except InvalidVersion:
+            continue
+        if version >= _ALIAS_VERSION and version.major == _ALIAS_VERSION.major:
+            return True
+    return False
+
+
+def _parse_toml(source: str) -> object:
+    return tomllib.loads(source)
+
+
+def _is_object_list(value: object) -> TypeIs[list[object]]:
+    return isinstance(value, list)

{sarj_python_lint-1.28.6 → sarj_python_lint-1.29.1}/src/sarj_python_lint/rules/_pytest.py

@@ -1,10 +1,26 @@
 from __future__ import annotations
 
 import ast
+from typing import TYPE_CHECKING
 
 from sarj_python_lint.rules._ast_index import walk
 
 
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+
+def collected_tests(statements: list[ast.stmt]) -> Iterator[ast.FunctionDef | ast.AsyncFunctionDef]:
+    for statement in statements:
+        match statement:
+            case ast.FunctionDef() | ast.AsyncFunctionDef() if statement.name.startswith("test"):
+                yield statement
+            case ast.ClassDef() if statement.name.startswith("Test"):
+                yield from collected_tests(statement.body)
+            case _:
+                pass
+
+
 # The pytest-benchmark fixture: the test measures time, it does not verify.
 _BENCHMARK = "benchmark"
 

{sarj_python_lint-1.28.6 → sarj_python_lint-1.29.1}/src/sarj_python_lint/rules/_registry.py

@@ -209,12 +209,18 @@ if TYPE_CHECKING:
     from sarj_python_lint.rule_base import Rule
 from sarj_python_lint.rules.duplicate_adjacent_exception_handler import DuplicateAdjacentExceptionHandler
 from sarj_python_lint.rules.duplicate_closed_pure_helper import DuplicateClosedPureHelper
+from sarj_python_lint.rules.no_conflicting_pydantic_alias_validation import NoConflictingPydanticAliasValidation
+from sarj_python_lint.rules.no_impossible_pydantic_field_bounds import NoImpossiblePydanticFieldBounds
+from sarj_python_lint.rules.no_unknown_pydantic_validator_field import NoUnknownPydanticValidatorField
 from sarj_python_lint.rules.redundant_test_constructor_forwarder import RedundantTestConstructorForwarder
 from sarj_python_lint.rules.repeated_unimplemented_test_contract import RepeatedUnimplementedTestContract
 
 
 REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
     {
+        NoConflictingPydanticAliasValidation.id: NoConflictingPydanticAliasValidation,
+        NoUnknownPydanticValidatorField.id: NoUnknownPydanticValidatorField,
+        NoImpossiblePydanticFieldBounds.id: NoImpossiblePydanticFieldBounds,
         RequireInjectableRetrySleep.id: RequireInjectableRetrySleep,
         NoFixedSleepInLoop.id: NoFixedSleepInLoop,
         NoInterpreterSourceArguments.id: NoInterpreterSourceArguments,

{sarj_python_lint-1.28.6 → sarj_python_lint-1.29.1}/src/sarj_python_lint/rules/async_mock_call_without_await_assertion.py

@@ -20,6 +20,7 @@ from sarj_python_lint.rule_base import (
 )
 from sarj_python_lint.rules._ast_index import walk as walk_ast
 from sarj_python_lint.rules._imports import ImportIndex
+from sarj_python_lint.rules._pytest import collected_tests
 
 
 if TYPE_CHECKING:
@@ -224,24 +225,13 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
                 severity=Severity.WARNING,
                 message="AsyncMock call assertions do not prove awaiting; keep this assertion and add an await assertion",
             )
-            for test in _collected_tests(tree.body)
+            for test in collected_tests(tree.body)
             if not _is_pytest_fixture(test, imports)
             for call in _uncovered_calls(_test_imports(imports, test), test, writes)
             if not is_suppressed(lines, call.lineno, self.code)
         ]
 
 
-def _collected_tests(statements: list[ast.stmt]) -> Iterator[_TestFunction]:
-    for statement in statements:
-        match statement:
-            case ast.FunctionDef() | ast.AsyncFunctionDef() if statement.name.startswith("test"):
-                yield statement
-            case ast.ClassDef() if statement.name.startswith("Test"):
-                yield from _collected_tests(statement.body)
-            case _:
-                pass
-
-
 def _is_pytest_fixture(test: _TestFunction, imports: ImportIndex) -> bool:
     return any(
         imports.resolved_qualified_name(decorator.func if isinstance(decorator, ast.Call) else decorator)