python-vibe-guard 0.7.1__py3-none-any.whl

pyvibe/rules/async_requests.py

@@ -0,0 +1,65 @@
+import ast
+from typing import List, Set
+from pyvibe.rules.base import Violation, AsyncBlockingCallVisitor
+
+REQUESTS_METHODS = {"get", "post", "put", "patch", "delete", "head", "options", "request"}
+
+
+class AsyncRequestsRule(AsyncBlockingCallVisitor):
+    """
+    PYVIBE-002 — requests.* inside async def
+
+    `requests` is a synchronous HTTP library. Calling it inside an async
+    function blocks the OS thread running the event loop. Under concurrent
+    load this serialises all I/O and eliminates any benefit of async.
+
+    Fix: use `httpx.AsyncClient` or `aiohttp.ClientSession` with await.
+    """
+
+    RULE_ID = "PYVIBE-002"
+    SEVERITY = "CRITICAL"
+
+    def __init__(self):
+        super().__init__()
+        # Names bound to the `requests` module via `import requests [as X]`
+        self._requests_aliases: Set[str] = set()
+
+    def visit_Import(self, node: ast.Import):
+        for alias in node.names:
+            if alias.name == "requests":
+                self._requests_aliases.add(alias.asname if alias.asname else alias.name)
+        self.generic_visit(node)
+
+    def visit_Call(self, node: ast.Call):
+        if self._current_async_func is None:
+            self.generic_visit(node)
+            return
+
+        method = self._get_requests_method(node)
+        if method:
+            self.violations.append(Violation(
+                rule_id=self.RULE_ID,
+                severity=self.SEVERITY,
+                line=node.lineno,
+                function_name=self._current_async_func,
+                message=f"requests.{method}() is synchronous — blocks the event loop",
+                evidence=f"Use `async with httpx.AsyncClient() as c: await c.{method}(url)`",
+            ))
+
+        self.generic_visit(node)
+
+    def _get_requests_method(self, node: ast.Call):
+        # requests.get(...), requests.post(...), etc. — qualified form only.
+        # Guard against NAME_COLLISION: only flag when the receiver name is
+        # known to be bound to the `requests` module via an import statement.
+        # Without this, `requests = get_pending_requests(); requests.get(key)`
+        # (a dict/object .get() call) would be a false positive.
+        if (
+            isinstance(node.func, ast.Attribute)
+            and node.func.attr in REQUESTS_METHODS
+            and isinstance(node.func.value, ast.Name)
+            and node.func.value.id in self._requests_aliases
+        ):
+            return node.func.attr
+
+        return None

pyvibe/rules/async_sleep.py

@@ -0,0 +1,44 @@
+import ast
+from typing import List
+from pyvibe.rules.base import Violation, AsyncBlockingCallVisitor
+
+
+class AsyncSleepRule(AsyncBlockingCallVisitor):
+    """
+    PYVIBE-001 — time.sleep() inside async def
+
+    Blocks the event loop entirely. All concurrent tasks on the same
+    loop are frozen for the duration of the sleep. Under load, this
+    causes cascading timeouts that look like random failures.
+
+    Fix: use `await asyncio.sleep(n)` instead.
+    """
+
+    RULE_ID = "PYVIBE-001"
+    SEVERITY = "CRITICAL"
+
+    def visit_Call(self, node: ast.Call):
+        if self._current_async_func is None:
+            self.generic_visit(node)
+            return
+
+        if self._is_time_sleep(node):
+            self.violations.append(Violation(
+                rule_id=self.RULE_ID,
+                severity=self.SEVERITY,
+                line=node.lineno,
+                function_name=self._current_async_func,
+                message="time.sleep() blocks the entire event loop",
+                evidence="Use `await asyncio.sleep(n)` instead",
+            ))
+
+        self.generic_visit(node)
+
+    def _is_time_sleep(self, node: ast.Call) -> bool:
+        # time.sleep(n) — qualified form only; bare sleep() excluded (false positives)
+        return (
+            isinstance(node.func, ast.Attribute)
+            and node.func.attr == "sleep"
+            and isinstance(node.func.value, ast.Name)
+            and node.func.value.id == "time"
+        )

pyvibe/rules/asyncio_run.py

@@ -0,0 +1,48 @@
+import ast
+from typing import List
+from pyvibe.rules.base import Violation, AsyncBlockingCallVisitor
+
+
+class AsyncioRunRule(AsyncBlockingCallVisitor):
+    """
+    PYVIBE-003 — asyncio.run() inside async def
+
+    asyncio.run() creates a *new* event loop and blocks until the coroutine
+    completes. Calling it from within a running loop raises:
+        RuntimeError: This event loop is already running.
+
+    AI-generated code frequently does this when mixing sync entrypoints
+    with async handlers — it compiles, passes basic tests, and explodes
+    at runtime in FastAPI / async frameworks.
+
+    Fix: use `await coroutine()` directly.
+    """
+
+    RULE_ID = "PYVIBE-003"
+    SEVERITY = "CRITICAL"
+
+    def visit_Call(self, node: ast.Call):
+        if self._current_async_func is None:
+            self.generic_visit(node)
+            return
+
+        if self._is_asyncio_run(node):
+            self.violations.append(Violation(
+                rule_id=self.RULE_ID,
+                severity=self.SEVERITY,
+                line=node.lineno,
+                function_name=self._current_async_func,
+                message="asyncio.run() inside async def raises RuntimeError at runtime",
+                evidence="Use `await coroutine()` directly — asyncio.run() is for sync entrypoints only",
+            ))
+
+        self.generic_visit(node)
+
+    def _is_asyncio_run(self, node: ast.Call) -> bool:
+        # asyncio.run(...)
+        return (
+            isinstance(node.func, ast.Attribute)
+            and node.func.attr == "run"
+            and isinstance(node.func.value, ast.Name)
+            and node.func.value.id == "asyncio"
+        )

pyvibe/rules/base.py

@@ -0,0 +1,65 @@
+import ast
+from dataclasses import dataclass
+from typing import List, Optional
+
+
+@dataclass
+class Violation:
+    rule_id: str
+    severity: str
+    line: int
+    function_name: str
+    message: str
+    evidence: str
+
+
+class AsyncContextVisitor(ast.NodeVisitor):
+    """Base visitor that tracks the name of the enclosing async function.
+
+    ``_current_async_func`` is set to the function name while visiting its body
+    and restored on exit, supporting nested async defs correctly.
+
+    Use as the base for rules that detect misuse of asyncio primitives
+    (``create_task``, ``ensure_future``, ``gather``) where the bug exists
+    regardless of whether the call appears in a nested sync callable.
+    """
+
+    def __init__(self):
+        self.violations: List[Violation] = []
+        self._current_async_func: Optional[str] = None
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef):
+        previous = self._current_async_func
+        self._current_async_func = node.name
+        self.generic_visit(node)
+        self._current_async_func = previous
+
+
+class AsyncBlockingCallVisitor(AsyncContextVisitor):
+    """AsyncContextVisitor extended with context isolation for nested sync callables.
+
+    A synchronous ``def`` or ``lambda`` nested inside an ``async def`` resets
+    ``_current_async_func`` to ``None``.  The rationale: such callables may be
+    passed to ``run_in_executor`` / ``async_add_executor_job`` / thread pools
+    and therefore do *not* inherently block the event loop.  Without this reset,
+    any blocking call (``requests.get``, ``time.sleep``, ``subprocess.run`` …)
+    inside the nested callable would be falsely flagged.
+
+    Use as the base for rules that detect synchronous blocking calls inside
+    async functions: I/O, HTTP, subprocesses, threading primitives, etc.
+    Do NOT use it for asyncio-primitive-misuse rules (``create_task``,
+    ``ensure_future``, ``gather``) — those rules must inherit from
+    ``AsyncContextVisitor`` directly.
+    """
+
+    def visit_FunctionDef(self, node: ast.FunctionDef):
+        previous = self._current_async_func
+        self._current_async_func = None
+        self.generic_visit(node)
+        self._current_async_func = previous
+
+    def visit_Lambda(self, node: ast.Lambda):
+        previous = self._current_async_func
+        self._current_async_func = None
+        self.generic_visit(node)
+        self._current_async_func = previous

pyvibe/rules/celery_time_limit.py

@@ -0,0 +1,103 @@
+import ast
+from typing import List
+from pyvibe.rules.base import Violation
+
+_LIMIT_KEYS = {"soft_time_limit", "time_limit"}
+
+
+class CeleryTaskTimeLimitRule(ast.NodeVisitor):
+    """
+    PYVIBE-005 — Celery task defined without soft_time_limit or time_limit
+
+    A Celery task with no time limit can hang indefinitely if the external
+    call it wraps never returns — blocking a worker process permanently.
+    Under load, all workers fill with hung tasks and the queue stalls.
+
+    Detected decorators: @app.task, @shared_task (bare or with kwargs).
+    Fix: @app.task(soft_time_limit=30, time_limit=60)
+
+    Known limitation — global configuration blind spot:
+    Celery allows setting task_time_limit and task_soft_time_limit globally
+    via app.conf.task_time_limit, app.conf.update(...), or in celeryconfig.py /
+    settings.py.  When a project uses global limits every task inherits them
+    and per-task decorator arguments are redundant.  This rule does NOT detect
+    global configuration: it only inspects the decorator arguments of the
+    current file.  Projects with a project-wide task_time_limit will see
+    PYVIBE-005 warnings on tasks that are already covered by that global limit.
+    If that applies to your project, either add per-task limits (preferred —
+    self-documenting, immune to config drift) or suppress with # noqa: PYVIBE-005.
+    """
+
+    RULE_ID = "PYVIBE-005"
+    SEVERITY = "CRITICAL"
+
+    def __init__(self):
+        self.violations: List[Violation] = []
+        self._has_celery_import: bool = False
+
+    def visit_Import(self, node: ast.Import) -> None:
+        for alias in node.names:
+            if alias.name == "celery" or alias.name.startswith("celery."):
+                self._has_celery_import = True
+                break
+        self.generic_visit(node)
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        if node.module and (node.module == "celery" or node.module.startswith("celery.")):
+            self._has_celery_import = True
+        self.generic_visit(node)
+
+    def visit_FunctionDef(self, node: ast.FunctionDef):
+        self._check(node)
+        self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef):
+        self._check(node)
+        self.generic_visit(node)
+
+    # ── private ──────────────────────────────────────────────────────────────
+
+    def _check(self, node):
+        for decorator in node.decorator_list:
+            if self._is_task_decorator(decorator) and not self._has_time_limit(decorator):
+                self.violations.append(Violation(
+                    rule_id=self.RULE_ID,
+                    severity=self.SEVERITY,
+                    line=node.lineno,
+                    function_name=node.name,
+                    message="Celery task defined without soft_time_limit or time_limit — can hang forever",
+                    evidence="Use @app.task(soft_time_limit=30, time_limit=60) to bound execution time",
+                ))
+                break  # one violation per function, even if decorated twice
+
+    def _is_task_decorator(self, decorator: ast.expr) -> bool:
+        # Unwrap @app.task(...) or @shared_task(...) to their func node
+        node = decorator.func if isinstance(decorator, ast.Call) else decorator
+        # @shared_task — Celery-specific; taskiq/huey/dramatiq don't use this name
+        if isinstance(node, ast.Name) and node.id == "shared_task":
+            return True
+        if isinstance(node, ast.Attribute) and node.attr == "task":
+            receiver = node.value
+            # @self.huey.task(), @self.app.task — chained attrs seen only in
+            # test infrastructure (Celery own tests, Huey tests). Skip.
+            if not isinstance(receiver, ast.Name):
+                return False
+            name = receiver.id.lower()
+            # @app.task / @importer_app.task — "app" strongly signals a Celery
+            # application object; no other common async task framework uses it
+            if "app" in name:
+                return True
+            # @celery.task / @celery_app.task / @my_celery.task
+            if "celery" in name:
+                return True
+            # @broker.task (taskiq), @huey.task, @dramatiq_broker.task etc. —
+            # only flag when the file explicitly imports from the celery package,
+            # confirming this isn't a different task framework
+            return self._has_celery_import
+        return False
+
+    def _has_time_limit(self, decorator: ast.expr) -> bool:
+        # Bare decorator (@app.task with no call) → no kwargs possible
+        if not isinstance(decorator, ast.Call):
+            return False
+        return any(kw.arg in _LIMIT_KEYS for kw in decorator.keywords)

pyvibe/rules/contextvar_cleanup.py

@@ -0,0 +1,129 @@
+import ast
+from typing import List, Set
+from pyvibe.rules.base import Violation
+
+
+def _shallow_walk(node: ast.AST):
+    """Walk AST without recursing into nested function or class definitions."""
+    yield node
+    for child in ast.iter_child_nodes(node):
+        if not isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            yield from _shallow_walk(child)
+
+
+class ContextVarCleanupRule(ast.NodeVisitor):
+    """
+    PYVIBE-006 — ContextVar.set() inside async def without guaranteed cleanup
+
+    ContextVar.set() returns a Token. Without reset(token) in a finally block,
+    the context value leaks into sibling async tasks that share the same context
+    — a common bug in FastAPI request handlers and async workers.
+
+    Fix: token = var.set(value) then var.reset(token) inside a finally block.
+    """
+
+    RULE_ID = "PYVIBE-006"
+    SEVERITY = "CRITICAL"
+
+    def __init__(self):
+        self.violations: List[Violation] = []
+        self._contextvar_names: Set[str] = set()
+        self._current_async_func: str = None
+
+    def visit_Module(self, node: ast.Module):
+        self._contextvar_names = self._collect_contextvar_names(node)
+        self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef):
+        previous = self._current_async_func
+        self._current_async_func = node.name
+
+        # Async generators (FastAPI yield dependencies) use yield semantics for
+        # cleanup — the code after yield runs on teardown. Skip them to avoid
+        # false positives on the common `token = var.set(v); yield; var.reset(token)` pattern.
+        if not self._is_async_generator(node):
+            set_calls = self._find_set_calls(node)
+            if set_calls and not self._has_finally_reset(node):
+                first = set_calls[0]
+                self.violations.append(Violation(
+                    rule_id=self.RULE_ID,
+                    severity=self.SEVERITY,
+                    line=first.lineno,
+                    function_name=node.name,
+                    message="ContextVar.set() without guaranteed cleanup leaks state between async tasks",
+                    evidence="Capture the token: `token = var.set(v)` then call `var.reset(token)` in a finally block",
+                ))
+
+        self.generic_visit(node)
+        self._current_async_func = previous
+
+    # ── private ──────────────────────────────────────────────────────────────
+
+    def _collect_contextvar_names(self, module: ast.Module) -> Set[str]:
+        """Return variable names assigned from ContextVar(...) anywhere in the module."""
+        names: Set[str] = set()
+        for node in ast.walk(module):
+            if isinstance(node, ast.Assign) and self._is_contextvar_call(node.value):
+                for target in node.targets:
+                    if isinstance(target, ast.Name):
+                        names.add(target.id)
+            elif (
+                isinstance(node, ast.AnnAssign)
+                and node.value
+                and self._is_contextvar_call(node.value)
+                and isinstance(node.target, ast.Name)
+            ):
+                names.add(node.target.id)
+        return names
+
+    def _is_contextvar_call(self, node: ast.AST) -> bool:
+        if not isinstance(node, ast.Call):
+            return False
+        func = node.func
+        # ContextVar('name')
+        if isinstance(func, ast.Name) and func.id == "ContextVar":
+            return True
+        # contextvars.ContextVar('name')
+        if (
+            isinstance(func, ast.Attribute)
+            and func.attr == "ContextVar"
+            and isinstance(func.value, ast.Name)
+            and func.value.id == "contextvars"
+        ):
+            return True
+        return False
+
+    def _find_set_calls(self, func_node: ast.AsyncFunctionDef) -> list:
+        """Find .set() calls on known ContextVar names, not crossing nested function boundaries."""
+        calls = []
+        for node in _shallow_walk(func_node):
+            if (
+                isinstance(node, ast.Call)
+                and isinstance(node.func, ast.Attribute)
+                and node.func.attr == "set"
+                and isinstance(node.func.value, ast.Name)
+                and node.func.value.id in self._contextvar_names
+            ):
+                calls.append(node)
+        return calls
+
+    def _is_async_generator(self, func_node: ast.AsyncFunctionDef) -> bool:
+        """True if the function contains a yield — async generator or FastAPI dependency."""
+        for node in _shallow_walk(func_node):
+            if isinstance(node, (ast.Yield, ast.YieldFrom)):
+                return True
+        return False
+
+    def _has_finally_reset(self, func_node: ast.AsyncFunctionDef) -> bool:
+        """Return True if the function body contains a try/finally with a .reset() call."""
+        for node in _shallow_walk(func_node):
+            if isinstance(node, ast.Try) and node.finalbody:
+                for stmt in node.finalbody:
+                    for child in ast.walk(stmt):
+                        if (
+                            isinstance(child, ast.Call)
+                            and isinstance(child.func, ast.Attribute)
+                            and child.func.attr == "reset"
+                        ):
+                            return True
+        return False

pyvibe/rules/create_task_orphan.py

@@ -0,0 +1,44 @@
+import ast
+from pyvibe.rules.base import Violation, AsyncContextVisitor
+
+
+class CreateTaskOrphanRule(AsyncContextVisitor):
+    """
+    PYVIBE-012 — asyncio.create_task() with discarded return value
+
+    create_task() returns a Task. If the Task object is not retained by any
+    reference, the garbage collector can cancel it mid-execution. Any exception
+    raised inside the task is also silently lost — no traceback, no crash,
+    just missing work. AI-generated "fire-and-forget" code hits this constantly.
+
+    Fix: assign the task and await it, or use asyncio.TaskGroup (Python 3.11+).
+    """
+
+    RULE_ID = "PYVIBE-012"
+    SEVERITY = "CRITICAL"
+
+    def visit_Expr(self, node: ast.Expr):
+        # ast.Expr (capital-E) is the *statement* wrapper for a discarded expression.
+        # If its direct value is create_task(), the Task reference is lost.
+        if self._current_async_func and self._is_create_task(node.value):
+            self.violations.append(Violation(
+                rule_id=self.RULE_ID,
+                severity=self.SEVERITY,
+                line=node.lineno,
+                function_name=self._current_async_func,
+                message="asyncio.create_task() return value discarded — task may be GC'd and silently cancelled",
+                evidence=(
+                    "Assign and await: `task = asyncio.create_task(coro()); await task`, "
+                    "or use `async with asyncio.TaskGroup() as tg: tg.create_task(coro())` (Python 3.11+)"
+                ),
+            ))
+        self.generic_visit(node)
+
+    def _is_create_task(self, node: ast.expr) -> bool:
+        return (
+            isinstance(node, ast.Call)
+            and isinstance(node.func, ast.Attribute)
+            and node.func.attr == "create_task"
+            and isinstance(node.func.value, ast.Name)
+            and node.func.value.id == "asyncio"
+        )

pyvibe/rules/ensure_future_orphan.py

@@ -0,0 +1,44 @@
+import ast
+from pyvibe.rules.base import Violation, AsyncContextVisitor
+
+
+class EnsureFutureOrphanRule(AsyncContextVisitor):
+    """
+    PYVIBE-014 — asyncio.ensure_future() with discarded return value
+
+    ensure_future() (the pre-3.7 predecessor to create_task()) schedules a
+    coroutine and returns a Task/Future. If the return value is not retained,
+    the garbage collector can cancel the task mid-execution and any exception
+    is silently swallowed. Identical hazard to PYVIBE-012 but with a different
+    API that is still widespread in older codebases.
+
+    Fix: assign the result and await it, or migrate to asyncio.create_task()
+    (Python 3.7+) / asyncio.TaskGroup (Python 3.11+).
+    """
+
+    RULE_ID = "PYVIBE-014"
+    SEVERITY = "CRITICAL"
+
+    def visit_Expr(self, node: ast.Expr):
+        if self._current_async_func and self._is_ensure_future(node.value):
+            self.violations.append(Violation(
+                rule_id=self.RULE_ID,
+                severity=self.SEVERITY,
+                line=node.lineno,
+                function_name=self._current_async_func,
+                message="asyncio.ensure_future() return value discarded — task may be GC'd and silently cancelled",
+                evidence=(
+                    "Assign and await: `task = asyncio.ensure_future(coro()); await task`, "
+                    "or migrate to `asyncio.create_task(coro())` (Python 3.7+)"
+                ),
+            ))
+        self.generic_visit(node)
+
+    def _is_ensure_future(self, node: ast.expr) -> bool:
+        return (
+            isinstance(node, ast.Call)
+            and isinstance(node.func, ast.Attribute)
+            and node.func.attr == "ensure_future"
+            and isinstance(node.func.value, ast.Name)
+            and node.func.value.id == "asyncio"
+        )

pyvibe/rules/gather_no_return_exceptions.py

@@ -0,0 +1,57 @@
+import ast
+from pyvibe.rules.base import Violation, AsyncContextVisitor
+
+
+class GatherNoReturnExceptionsRule(AsyncContextVisitor):
+    """
+    PYVIBE-013 — asyncio.gather() without return_exceptions=True
+
+    Without return_exceptions=True, the first exception raised by any task
+    immediately propagates to the gather() caller. The remaining tasks are
+    NOT automatically cancelled — they keep running detached, leaking
+    resources and producing results nobody reads.
+
+    AI-generated code almost never adds return_exceptions=True because the
+    pattern "looks correct" in single-task testing where exceptions don't
+    race. The bug surfaces only under concurrent load.
+
+    Fix: add return_exceptions=True and inspect the result list, or use
+    asyncio.TaskGroup (Python 3.11+) for explicit structured concurrency.
+    """
+
+    RULE_ID = "PYVIBE-013"
+    SEVERITY = "CRITICAL"
+
+    def visit_Call(self, node: ast.Call):
+        if self._current_async_func and self._is_gather(node) and not self._has_return_exceptions_true(node):
+            self.violations.append(Violation(
+                rule_id=self.RULE_ID,
+                severity=self.SEVERITY,
+                line=node.lineno,
+                function_name=self._current_async_func,
+                message="asyncio.gather() without return_exceptions=True — first exception leaks remaining tasks",
+                evidence=(
+                    "Add return_exceptions=True and check results: "
+                    "`results = await asyncio.gather(*coros, return_exceptions=True)`, "
+                    "or use `async with asyncio.TaskGroup() as tg:` (Python 3.11+)"
+                ),
+            ))
+        self.generic_visit(node)
+
+    def _is_gather(self, node: ast.Call) -> bool:
+        return (
+            isinstance(node.func, ast.Attribute)
+            and node.func.attr == "gather"
+            and isinstance(node.func.value, ast.Name)
+            and node.func.value.id == "asyncio"
+        )
+
+    def _has_return_exceptions_true(self, node: ast.Call) -> bool:
+        for kw in node.keywords:
+            if (
+                kw.arg == "return_exceptions"
+                and isinstance(kw.value, ast.Constant)
+                and kw.value.value is True
+            ):
+                return True
+        return False

pyvibe/rules/httpx_client_sync.py

@@ -0,0 +1,43 @@
+import ast
+from typing import List
+from pyvibe.rules.base import Violation, AsyncBlockingCallVisitor
+
+
+class HttpxClientSyncRule(AsyncBlockingCallVisitor):
+    """
+    PYVIBE-016 — httpx.Client() instantiated inside async def
+
+    httpx.Client is the synchronous client. Every request it makes blocks
+    the OS thread for the full HTTP round-trip, starving all other coroutines
+    on the event loop. AI-generated code frequently picks httpx.Client over
+    httpx.AsyncClient because the sync API looks simpler.
+
+    httpx.AsyncClient() has attr='AsyncClient', which is explicitly excluded.
+
+    Fix: use `async with httpx.AsyncClient() as client: response = await client.get(url)`.
+    """
+
+    RULE_ID = "PYVIBE-016"
+    SEVERITY = "CRITICAL"
+
+    def visit_Call(self, node: ast.Call):
+        if self._current_async_func and self._is_httpx_client_sync(node):
+            self.violations.append(Violation(
+                rule_id=self.RULE_ID,
+                severity=self.SEVERITY,
+                line=node.lineno,
+                function_name=self._current_async_func,
+                message="httpx.Client() is synchronous — blocks the event loop for every HTTP request",
+                evidence=(
+                    "Use `async with httpx.AsyncClient() as client: response = await client.get(url)` instead"
+                ),
+            ))
+        self.generic_visit(node)
+
+    def _is_httpx_client_sync(self, node: ast.Call) -> bool:
+        return (
+            isinstance(node.func, ast.Attribute)
+            and node.func.attr == "Client"
+            and isinstance(node.func.value, ast.Name)
+            and node.func.value.id == "httpx"
+        )