sarj-python-lint 0.87.9__tar.gz → 0.88.0__tar.gz

{sarj_python_lint-0.87.9 → sarj_python_lint-0.88.0}/PKG-INFO

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

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

{sarj_python_lint-0.87.9 → sarj_python_lint-0.88.0}/src/sarj_python_lint/rules/_registry.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from types import MappingProxyType
 from typing import TYPE_CHECKING
 
+from sarj_python_lint.rules.async_mock_call_without_await_assertion import AsyncMockCallWithoutAwaitAssertion
 from sarj_python_lint.rules.complex_postgres_query_requires_architecture_review import (
     ComplexPostgresQueryRequiresArchitectureReview,
 )
@@ -158,7 +159,6 @@ from sarj_python_lint.rules.require_pydantic_for_structured_payload import Requi
 from sarj_python_lint.rules.require_pydantic_ordinal_lower_bound import (
     RequirePydanticOrdinalLowerBound,
 )
-from sarj_python_lint.rules.require_typed_http_test_response import RequireTypedHttpTestResponse
 from sarj_python_lint.rules.restated_test_docstring import RestatedTestDocstring
 from sarj_python_lint.rules.stepdown import Stepdown
 from sarj_python_lint.rules.store_get_delegates_to_bulk_read import StoreGetDelegatesToBulkRead
@@ -180,6 +180,7 @@ if TYPE_CHECKING:
 
 REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
     {
+        AsyncMockCallWithoutAwaitAssertion.id: AsyncMockCallWithoutAwaitAssertion,
         ComplexPostgresQueryRequiresArchitectureReview.id: ComplexPostgresQueryRequiresArchitectureReview,
         ExcessiveCommentary.id: ExcessiveCommentary,
         PreferWalrusAwaitedNoneGuard.id: PreferWalrusAwaitedNoneGuard,
@@ -283,7 +284,6 @@ REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
         NoPsycopgExecutionOutsideInjectedOwner.id: NoPsycopgExecutionOutsideInjectedOwner,
         RequirePydanticOrdinalLowerBound.id: RequirePydanticOrdinalLowerBound,
         RequirePydanticForStructuredPayload.id: RequirePydanticForStructuredPayload,
-        RequireTypedHttpTestResponse.id: RequireTypedHttpTestResponse,
         RequireNoDecodeForSplittingSettingsField.id: RequireNoDecodeForSplittingSettingsField,
         NoVagueSuppressionDescription.id: NoVagueSuppressionDescription,
         NoWholeRequestResponsePayloadInLog.id: NoWholeRequestResponsePayloadInLog,

sarj_python_lint-0.88.0/src/sarj_python_lint/rules/async_mock_call_without_await_assertion.py

@@ -0,0 +1,322 @@
+from __future__ import annotations
+
+import ast
+from pathlib import PurePosixPath
+from types import MappingProxyType
+from typing import TYPE_CHECKING, ClassVar, Final, final, override
+
+from sarj_python_lint.rule_base import (
+    AutofixPolicy,
+    Diagnostic,
+    ExampleFile,
+    ExampleOutcome,
+    Rule,
+    RuleCategory,
+    RuleDocumentation,
+    RuleExample,
+    Severity,
+    is_suppressed,
+    parse_or_none,
+)
+from sarj_python_lint.rules._imports import ImportIndex
+from sarj_python_lint.rules._paths import is_generated
+
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from pathlib import Path
+
+
+_CALL_ASSERTIONS: Final = frozenset(
+    {"assert_called", "assert_called_once", "assert_called_with", "assert_called_once_with"}
+)
+_AWAIT_ASSERTIONS: Final = frozenset(
+    {
+        "assert_awaited",
+        "assert_awaited_once",
+        "assert_awaited_with",
+        "assert_awaited_once_with",
+        "assert_any_await",
+        "assert_has_awaits",
+    }
+)
+_AWAIT_STATE: Final = frozenset({"await_count", "await_args", "await_args_list"})
+_CONSTRUCTOR_KEYWORDS: Final = frozenset({"return_value", "side_effect", "name", "wraps", "unsafe", "spec", "spec_set"})
+_MUTATORS: Final = frozenset({"reset_mock", "configure_mock", "attach_mock", "mock_add_spec"})
+_IMMEDIATE_CHILD_PARTS: Final = 2
+_MOCK_ATTRIBUTES: Final = (
+    _MUTATORS
+    | _AWAIT_STATE
+    | frozenset(
+        {
+            "return_value",
+            "side_effect",
+            "called",
+            "call_count",
+            "call_args",
+            "call_args_list",
+            "mock_calls",
+            "method_calls",
+        }
+    )
+)
+type _TestFunction = ast.FunctionDef | ast.AsyncFunctionDef
+type _Reference = tuple[str, ...]
+
+
+@final
+class AsyncMockCallWithoutAwaitAssertion(Rule):
+    id = "async-mock-call-without-await-assertion"
+    code = "SARJ456"
+    documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
+        default_level=Severity.WARNING,
+        summary="Pair positive AsyncMock call assertions with evidence that the mock was awaited.",
+        rationale=(
+            "Calling an AsyncMock records a call before its coroutine is awaited. A positive call assertion can "
+            "therefore pass when production code silently drops the coroutine. Await assertions cover that gap, "
+            "while call assertions still detect extra calls whose coroutines were never awaited."
+        ),
+        remediation=(
+            "Keep the call assertion and add an appropriate assert_awaited assertion. For a test that deliberately "
+            "checks scheduling before execution, use an exact SARJ456 suppression explaining that contract."
+        ),
+        category=RuleCategory.TESTING,
+        autofix=AutofixPolicy.NONE,
+        limitations=(
+            "Only direct statements in collected test functions and methods are inspected; fixtures, helpers, nested blocks, and generated files are excluded.",
+            "Requires a fresh local unittest.mock.AsyncMock constructor with unshadowed imports; aliases, reassignment, reset, and ambiguous configuration are excluded.",
+            "Only the mock itself and unchanged immediate children of unspecced, unwrapped mocks are inferred; spec children, return values, and deeper chains are excluded.",
+            "Any direct positive await assertion or explicit await-state assertion on the same mock is accepted; argument equality and assertion strength are not compared.",
+            "Custom assertion helpers and intentional scheduling contracts may require a reasoned local suppression.",
+        ),
+        examples=(
+            RuleExample(
+                example_id="call-only-async-mock",
+                title="A call assertion does not prove awaiting",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "tests/test_delivery.py",
+                        "from unittest.mock import AsyncMock\n\nasync def test_delivery():\n    send = AsyncMock()\n    await deliver(send)\n    send.assert_called_once_with('item')\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("tests/test_delivery.py"),
+                expected_count=1,
+                public=True,
+            ),
+            RuleExample(
+                example_id="call-and-await-async-mock",
+                title="Call and await assertions protect different contracts",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "tests/test_delivery.py",
+                        "from unittest.mock import AsyncMock\n\nasync def test_delivery():\n    send = AsyncMock()\n    await deliver(send)\n    send.assert_called_once_with('item')\n    send.assert_awaited_once_with('item')\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("tests/test_delivery.py"),
+                expected_count=0,
+                public=True,
+            ),
+        ),
+    )
+    description = documentation.summary
+
+    @override
+    def check(self, path: Path, source: str) -> list[Diagnostic]:
+        if (
+            path.suffix != ".py"
+            or "AsyncMock" not in source
+            or "assert_called" not in source
+            or not (path.stem.startswith("test_") or path.stem.endswith("_test"))
+            or is_generated(path, source)
+        ):
+            return []
+        tree = parse_or_none(path, source)
+        if tree is None:
+            return []
+        imports = ImportIndex.from_tree(tree, module_scope_only=True)
+        writes = {
+            _reference(node)
+            for node in ast.walk(tree)
+            if isinstance(node, ast.Attribute) and isinstance(node.ctx, (ast.Store, ast.Del))
+        }
+        lines = source.splitlines()
+        return [
+            Diagnostic(
+                path=path,
+                line=call.lineno,
+                col=call.col_offset + 1,
+                code=self.code,
+                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)
+            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)
+        == "pytest.fixture"
+        for decorator in test.decorator_list
+    )
+
+
+def _test_imports(module: ImportIndex, test: _TestFunction) -> ImportIndex:
+    local = ImportIndex.from_tree(ast.Module(body=[test, *test.body], type_ignores=[]))
+    bindings = {name: target for name, target in module.bindings.items() if name not in local.shadowed_names}
+    bindings.update(local.bindings)
+    return ImportIndex(MappingProxyType(bindings), module.shadowed_names | local.shadowed_names)
+
+
+def _uncovered_calls(imports: ImportIndex, test: _TestFunction, writes: set[_Reference]) -> Iterator[ast.Call]:
+    nodes = tuple(ast.walk(test))
+    bindings = _mock_bindings(imports, test.body, writes)
+    covered = _await_oracles(test.body)
+    reported: set[_Reference] = set()
+    for statement in test.body:
+        match statement:
+            case ast.Expr(value=ast.Call(func=ast.Attribute(value=receiver, attr=method)) as call) if (
+                method in _CALL_ASSERTIONS
+            ):
+                reference = _reference(receiver)
+                if not reference or reference in covered or reference in reported:
+                    continue
+                binding = bindings.get(reference[0])
+                if (
+                    binding is None
+                    or not _is_async_reference(reference, binding[1])
+                    or any(_invalidates_reference(node, reference, binding[0]) for node in nodes)
+                ):
+                    continue
+                reported.add(reference)
+                yield call
+            case _:
+                pass
+
+
+def _mock_bindings(
+    imports: ImportIndex, statements: list[ast.stmt], writes: set[_Reference]
+) -> dict[str, tuple[ast.Name, ast.Call]]:
+    bindings: dict[str, tuple[ast.Name, ast.Call]] = {}
+    for statement in statements:
+        match statement:
+            case (
+                ast.Assign(targets=[ast.Name() as target], value=ast.Call() as call)
+                | ast.AnnAssign(target=ast.Name() as target, value=ast.Call() as call)
+            ):
+                if _is_async_constructor(call.func, imports, writes) and all(
+                    keyword.arg in _CONSTRUCTOR_KEYWORDS for keyword in call.keywords
+                ):
+                    bindings[target.id] = (target, call)
+            case _:
+                pass
+    return bindings
+
+
+def _is_async_constructor(node: ast.expr, imports: ImportIndex, writes: set[_Reference]) -> bool:
+    reference = _reference(node)
+    if any(reference[:length] in writes for length in range(1, len(reference) + 1)):
+        return False
+    return imports.resolved_qualified_name(node) == "unittest.mock.AsyncMock" or (
+        isinstance(node, ast.Attribute)
+        and node.attr == "AsyncMock"
+        and imports.resolved_qualified_name(node.value) == "unittest.mock"
+    )
+
+
+def _reference(node: ast.AST) -> _Reference:
+    match node:
+        case ast.Name(id=name):
+            return (name,)
+        case ast.Attribute(value=parent, attr=attribute):
+            prefix = _reference(parent)
+            return (*prefix, attribute) if prefix else ()
+        case _:
+            return ()
+
+
+def _is_async_reference(reference: _Reference, constructor: ast.Call) -> bool:
+    if len(reference) == 1:
+        return True
+    return (
+        len(reference) == _IMMEDIATE_CHILD_PARTS
+        and not constructor.args
+        and not any(keyword.arg in {"spec", "spec_set", "wraps"} for keyword in constructor.keywords)
+        and reference[1] not in _MOCK_ATTRIBUTES
+        and not reference[1].startswith(("_", "assert"))
+    )
+
+
+def _await_oracles(statements: list[ast.stmt]) -> set[_Reference]:
+    covered: set[_Reference] = set()
+    for statement in statements:
+        match statement:
+            case ast.Expr(value=ast.Call(func=ast.Attribute(value=receiver, attr=method))) if (
+                method in _AWAIT_ASSERTIONS
+            ):
+                covered.add(_reference(receiver))
+            case ast.Assert(test=condition):
+                covered.update(
+                    _reference(node.value)
+                    for node in ast.walk(condition)
+                    if isinstance(node, ast.Attribute) and node.attr in _AWAIT_STATE
+                )
+            case _:
+                pass
+    return covered
+
+
+def _invalidates_reference(node: ast.AST, reference: _Reference, binding: ast.Name) -> bool:
+    match node:
+        case ast.Name(id=name, ctx=ast.Store() | ast.Del()):
+            return node is not binding and name == reference[0]
+        case ast.arg(arg=name):
+            return name == reference[0]
+        case ast.Global(names=names) | ast.Nonlocal(names=names):
+            return reference[0] in names
+        case ast.Attribute(ctx=ast.Store() | ast.Del()):
+            changed = _reference(node)
+            return bool(changed) and (
+                reference[: len(changed)] == changed or (changed[:-1] == reference and changed[-1].startswith("assert"))
+            )
+        case ast.Call(func=ast.Attribute(value=receiver, attr=method)) if method in _MUTATORS:
+            changed = _reference(receiver)
+            return bool(changed) and reference[: len(changed)] == changed
+        case ast.Call(func=ast.Name(id="setattr" | "delattr"), args=[receiver, *_]):
+            return _reference(receiver)[:1] == reference[:1]
+        case ast.Assign(value=value) | ast.AnnAssign(value=value) if value is not None:
+            return reference[0] in _alias_roots(value)
+        case _:
+            return False
+
+
+def _alias_roots(node: ast.expr) -> Iterator[str]:
+    match node:
+        case ast.Name() | ast.Attribute():
+            if reference := _reference(node):
+                yield reference[0]
+        case ast.Tuple(elts=elements) | ast.List(elts=elements) | ast.Set(elts=elements):
+            for element in elements:
+                yield from _alias_roots(element)
+        case ast.Dict(keys=keys, values=values):
+            for element in (*keys, *values):
+                if element is not None:
+                    yield from _alias_roots(element)
+        case _:
+            pass

{sarj_python_lint-0.87.9 → sarj_python_lint-0.88.0}/src/sarj_python_lint/rules/no_repeated_test_body.py

@@ -118,6 +118,7 @@ class NoRepeatedTestBody(Rule):
             "At least three consecutive call-and-literal-equality cases with corroborating behavior names are compared even with only two statements.",
             "Meaningful docstring or comment differences keep tests distinct.",
             "Two-test groups with varying literals require corroborating behavior names; long scenario prose and distinct API resources remain separate contracts.",
+            "Differing direct string needles in asserted membership comparisons preserve distinct contracts.",
         ),
         examples=(
             RuleExample(
@@ -486,10 +487,29 @@ def _is_fixture_document(value: object) -> bool:
 
 def _erases_contract_identity(members: list[_Shape]) -> bool:
     columns: list[tuple[object, ...]] = list(zip(*(member.literals for member in members), strict=True))
-    return any(
+    if any(
         len(set(column)) > 1 and all(isinstance(value, str) and value.startswith("/") for value in column)
         for column in columns
+    ):
+        return True
+    needles: list[tuple[str | None, ...]] = list(
+        zip(*(_asserted_membership_needles(member.node) for member in members), strict=True)
     )
+    return any(len(set(column)) > 1 and all(isinstance(value, str) for value in column) for column in needles)
+
+
+def _asserted_membership_needles(node: ast.FunctionDef | ast.AsyncFunctionDef) -> tuple[str | None, ...]:
+    needles: list[str | None] = []
+    for child in _walk(node):
+        if not isinstance(child, ast.Assert) or not isinstance(child.test, ast.Compare):
+            continue
+        comparison = child.test
+        for operand, operator in zip((comparison.left, *comparison.comparators[:-1]), comparison.ops, strict=True):
+            if isinstance(operator, ast.In | ast.NotIn):
+                needles.append(
+                    operand.value if isinstance(operand, ast.Constant) and isinstance(operand.value, str) else None
+                )
+    return tuple(needles)
 
 
 def _has_enough_duplicate_evidence(members: list[_Shape]) -> bool:

sarj_python_lint-0.87.9/src/sarj_python_lint/rules/require_typed_http_test_response.py

@@ -1,214 +0,0 @@
-from __future__ import annotations
-
-import ast
-from pathlib import PurePosixPath
-from typing import TYPE_CHECKING, ClassVar, final, override
-
-from sarj_python_lint.rule_base import (
-    AutofixPolicy,
-    Diagnostic,
-    ExampleFile,
-    ExampleOutcome,
-    Rule,
-    RuleCategory,
-    RuleDocumentation,
-    RuleExample,
-    is_suppressed,
-    parse_or_none,
-)
-from sarj_python_lint.rules._paths import is_generated, is_test_path
-
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-
-@final
-class RequireTypedHttpTestResponse(Rule):
-    id = "require-typed-http-test-response"
-    code = "SARJ449"
-    documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        summary="HTTP tests must validate JSON response bodies into named models before asserting fields.",
-        rationale=(
-            "Raw dictionary assertions duplicate wire spelling and do not prove that the complete response contract validates."
-        ),
-        remediation=(
-            "Parse `response.json()` once with `ResponseModel.model_validate(...)` or a Pydantic `TypeAdapter`, then assert "
-            "typed attributes."
-        ),
-        category=RuleCategory.TESTING,
-        autofix=AutofixPolicy.NONE,
-        limitations=(
-            "Only test files and direct or simple local-aliased HTTP JSON access are checked; branch and nested-scope aliases are excluded.",
-        ),
-        examples=(
-            RuleExample(
-                example_id="raw-http-json-assertion",
-                title="A test indexes an unvalidated response body",
-                outcome=ExampleOutcome.MATCH,
-                files=(
-                    ExampleFile.python(
-                        "tests/test_cards.py",
-                        "def test_interaction(client):\n    response = client.post('/actions')\n    assert response.json()['interactionId']\n",
-                    ),
-                ),
-                focus_path=PurePosixPath("tests/test_cards.py"),
-                expected_count=1,
-                public=True,
-            ),
-            RuleExample(
-                example_id="validated-http-json-assertion",
-                title="A test validates its response model",
-                outcome=ExampleOutcome.NO_MATCH,
-                files=(
-                    ExampleFile.python(
-                        "tests/test_cards.py",
-                        "def test_interaction(client):\n    response = client.post('/actions')\n    body = InteractionResponse.model_validate(response.json())\n    assert body.interaction_id\n",
-                    ),
-                ),
-                focus_path=PurePosixPath("tests/test_cards.py"),
-                expected_count=0,
-                public=True,
-            ),
-        ),
-    )
-    description = documentation.summary
-
-    @override
-    def check(self, path: Path, source: str) -> list[Diagnostic]:
-        if not is_test_path(path) or is_generated(path, source):
-            return []
-        tree = parse_or_none(path, source)
-        if tree is None:
-            return []
-        lines = source.splitlines()
-        findings: list[Diagnostic] = []
-        for node in ast.walk(tree):
-            call = _raw_json_access(node)
-            if call is None or is_suppressed(lines, call.lineno, self.code):
-                continue
-            findings.append(
-                Diagnostic(
-                    path=path,
-                    line=call.lineno,
-                    col=call.col_offset + 1,
-                    code=self.code,
-                    message=(
-                        "validate the HTTP JSON body into its named Pydantic response model before asserting fields"
-                    ),
-                )
-            )
-        for node in ast.walk(tree):
-            if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-                continue
-            findings.extend(_alias_findings(path, lines, node, self.code))
-        return sorted(findings, key=lambda finding: (finding.line, finding.col))
-
-
-def _raw_json_access(node: ast.AST) -> ast.Call | None:
-    value: ast.expr | None = None
-    if isinstance(node, ast.Subscript):
-        value = node.value
-    elif (
-        isinstance(node, ast.Call)
-        and isinstance(node.func, ast.Attribute)
-        and node.func.attr in {"get", "items", "keys"}
-    ):
-        value = node.func.value
-    if not isinstance(value, ast.Call) or value.args or value.keywords:
-        return None
-    if not isinstance(value.func, ast.Attribute) or value.func.attr != "json":
-        return None
-    return value
-
-
-def _alias_findings(
-    path: Path,
-    lines: list[str],
-    function: ast.FunctionDef | ast.AsyncFunctionDef,
-    code: str,
-) -> list[Diagnostic]:
-    aliases: set[str] = set()
-    response_names: set[str] = set()
-    findings: list[Diagnostic] = []
-    for statement in function.body:
-        if not isinstance(statement, (ast.Assign, ast.AnnAssign, ast.Assert, ast.Expr, ast.Return)):
-            # Branches and nested scopes need control-flow analysis before alias state can be trusted.
-            aliases.clear()
-            response_names.clear()
-            continue
-        for node in ast.walk(statement):
-            access = _alias_access(node, aliases)
-            if access is None or is_suppressed(lines, access.lineno, code):
-                continue
-            findings.append(
-                Diagnostic(
-                    path=path,
-                    line=access.lineno,
-                    col=access.col_offset + 1,
-                    code=code,
-                    message="validate the HTTP JSON body into its named Pydantic response model before asserting fields",
-                )
-            )
-        _record_alias_assignment(statement, aliases, response_names)
-    return findings
-
-
-def _record_alias_assignment(statement: ast.stmt, aliases: set[str], response_names: set[str]) -> None:
-    target: ast.expr | None = None
-    value: ast.expr | None = None
-    if isinstance(statement, ast.Assign) and len(statement.targets) == 1:
-        target, value = statement.targets[0], statement.value
-    elif isinstance(statement, ast.AnnAssign):
-        target, value = statement.target, statement.value
-    if not isinstance(target, ast.Name) or value is None:
-        return
-    is_alias = _is_http_json_call(value, response_names) or (isinstance(value, ast.Name) and value.id in aliases)
-    if is_alias:
-        aliases.add(target.id)
-    else:
-        aliases.discard(target.id)
-    if _is_http_response_call(value):
-        response_names.add(target.id)
-    else:
-        response_names.discard(target.id)
-
-
-def _alias_access(node: ast.AST, aliases: set[str]) -> ast.Name | None:
-    value: ast.expr | None = None
-    if isinstance(node, ast.Subscript) and isinstance(node.ctx, ast.Load):
-        value = node.value
-    elif (
-        isinstance(node, ast.Call)
-        and isinstance(node.func, ast.Attribute)
-        and node.func.attr in {"get", "items", "keys"}
-    ):
-        value = node.func.value
-    if isinstance(value, ast.Name) and value.id in aliases:
-        return value
-    return None
-
-
-def _is_http_json_call(value: ast.expr, response_names: set[str]) -> bool:
-    if not isinstance(value, ast.Call) or value.args or value.keywords:
-        return False
-    if not isinstance(value.func, ast.Attribute) or value.func.attr != "json":
-        return False
-    receiver = value.func.value
-    return (isinstance(receiver, ast.Name) and receiver.id in response_names) or _is_http_response_call(receiver)
-
-
-def _is_http_response_call(value: ast.expr) -> bool:
-    if isinstance(value, ast.Await):
-        value = value.value
-    return (
-        isinstance(value, ast.Call)
-        and isinstance(value.func, ast.Attribute)
-        and value.func.attr in {"get", "post", "put", "patch", "delete", "request"}
-        and isinstance(value.func.value, ast.Name)
-        and value.func.value.id.endswith("client")
-        and bool(value.args)
-        and isinstance(value.args[0], ast.Constant)
-        and isinstance(value.args[0].value, str)
-        and value.args[0].value.startswith(("/", "http://", "https://"))
-    )