Skip to content

armgit / E2B

Public Imported from GitHub
0

Open-source, secure environment with real-world tools for enterprise-grade agents.

feat(python-sdk): move the REST API client onto pyqwest's httpx transport adapter (#1601)

Mish Ushakova874ced97a94
diff --git a/.changeset/python-pyqwest-rest-transport.md b/.changeset/python-pyqwest-rest-transport.md
new file mode 100644
index 000000000..70f63adfe
--- /dev/null
+++ b/.changeset/python-pyqwest-rest-transport.md
@@ -0,0 +1,56 @@
+---
+"@e2b/python-sdk": minor
+---
+
+Move the REST API client (sandbox lifecycle, listing, templates, volumes
+control plane) onto [`pyqwest`](https://pypi.org/project/pyqwest/) (Rust
+reqwest/hyper) via its httpx-compatible transport adapter, replacing the
+httpx-native `HTTPTransport`/`AsyncHTTPTransport`. The generated httpx client
+API is unchanged — only the transport underneath is swapped — so logging
+event hooks, headers, and redirect handling (`follow_redirects`,
+`response.history`) behave as before.
+
+One timeout semantics change: through the adapter, `request_timeout` is a
+deadline for the whole API call, where the previous transports applied it to
+each phase (connect, read, write) separately — a slow request could exceed it
+in total. For the REST API's small JSON exchanges this tightening is what
+`request_timeout` reads as promising; `0` still disables it.
+
+Because pyqwest transports are thread-safe and loop-independent (I/O runs on
+a Rust runtime), the API connection pool is now shared process-wide per
+proxy, instead of one pool per thread (sync) or per event loop (async), and
+`ApiClient` no longer maintains per-thread/per-loop httpx client caches — a
+single httpx client serves all threads and event loops.
+Connection-establishment failures are retried with backoff
+(`E2B_CONNECTION_RETRIES`, default 3), matching the connect-only retries of
+the previous transports. Timeouts keep raising `httpx.ReadTimeout` (an
+`httpx.TimeoutException`), as before, whether they fire while waiting for the
+response head or while reading the response body, and connection, network, and
+protocol failures keep raising their `httpx` counterparts (`httpx.ConnectError`,
+`httpx.ReadError`, `httpx.RemoteProtocolError`).
+
+`proxy` for API calls takes a URL string (e.g.
+`proxy="http://user:pass@localhost:8030"`, scheme http, https, socks5, or
+socks5h), an `httpx.URL`, or an `httpx.Proxy` — including its credentials
+(sent as `Proxy-Authorization`) and any headers configured for the proxy. The
+one `httpx.Proxy` option pyqwest cannot express, a per-proxy `ssl_context`,
+raises `InvalidArgumentException` rather than being silently dropped.
+
+Low-level HTTP logs stay available: where enabling the `httpcore` logger used
+to show connection-level detail, pyqwest logs one line per request on the
+`pyqwest.access` logger and request lifecycle records on `pyqwest`, both at
+`DEBUG` and off unless enabled:
+
+```python
+import logging
+
+logging.basicConfig()
+logging.getLogger("pyqwest.access").setLevel(logging.DEBUG)
+# DEBUG pyqwest.access - HTTP Request: POST https://api.e2b.app/sandboxes "HTTP/2 201 Created"
+```
+
+The SDK's own `logger` option is unchanged and independent of these.
+
+envd traffic is not affected: RPC (commands, PTY, filesystem watch) already
+runs on pyqwest via `connectrpc`, and the envd HTTP API (file transfers,
+health checks) keeps its httpx transports.
diff --git a/packages/python-sdk/e2b/api/__init__.py b/packages/python-sdk/e2b/api/__init__.py
index 15ef836bf..a6e10900b 100644
--- a/packages/python-sdk/e2b/api/__init__.py
+++ b/packages/python-sdk/e2b/api/__init__.py
@@ -1,23 +1,22 @@
-import asyncio
import json
import logging
import os
import re
-import threading
-import weakref
from dataclasses import dataclass
from types import TracebackType
-from typing import Callable, Optional, Protocol, Union
+from typing import NamedTuple, Optional, Protocol, Tuple, Union
import httpx
from httpx import AsyncBaseTransport, BaseTransport, Limits, Timeout
+from pyqwest import Proxy
from e2b.api.client.client import AuthenticatedClient
from e2b.api.client.types import Response
from e2b.api.metadata import default_headers
-from e2b.connection_config import ConnectionConfig
+from e2b.connection_config import ConnectionConfig, ProxyTypes
from e2b.exceptions import (
AuthenticationException,
+ InvalidArgumentException,
RateLimitException,
SandboxException,
)
@@ -70,6 +69,61 @@ limits = Limits(
connection_retries = int(os.getenv("E2B_CONNECTION_RETRIES") or "3")
+# Mirror the httpx pool tuning above with pyqwest's equivalents for the REST
+# API transports. `pool_max_idle_per_host` is per host rather than httpx's
+# global idle cap, but API traffic goes to a single host, so the values map
+# directly; reqwest has no counterpart to `E2B_MAX_CONNECTIONS` (it does not
+# cap concurrent connections).
+pool_idle_timeout = float(os.getenv("E2B_KEEPALIVE_EXPIRY") or "300")
+pool_max_idle_per_host = int(os.getenv("E2B_MAX_KEEPALIVE_CONNECTIONS") or "20")
+
+
+class ProxyConfig(NamedTuple):
+ """The ``proxy`` connection option in the shape pyqwest transports take.
+
+ A tuple so it can key the transport caches directly: it is hashable and
+ compares by value, where a ``pyqwest.Proxy`` compares by identity and
+ would hand every call its own connection pool."""
+
+ url: str
+ auth: Optional[Tuple[str, str]] = None
+ headers: Tuple[Tuple[str, str], ...] = ()
+
+ def to_pyqwest(self) -> Proxy:
+ """The ``pyqwest.Proxy`` to hand a transport."""
+ return Proxy(self.url, auth=self.auth, headers=self.headers or None)
+
+
+def proxy_to_config(proxy: Optional[ProxyTypes]) -> Optional[ProxyConfig]:
+ """Convert the ``proxy`` connection option — a URL string, an
+ ``httpx.URL``, or an ``httpx.Proxy`` — to the proxy configuration pyqwest
+ transports take: a proxy URL (scheme http, https, socks5, or socks5h,
+ credentials allowed in the userinfo), basic-auth credentials, and headers
+ to send to the proxy. An ``httpx.Proxy`` ``ssl_context`` has no pyqwest
+ counterpart and is rejected rather than silently dropped."""
+ if proxy is None:
+ return None
+ if isinstance(proxy, str):
+ return ProxyConfig(proxy)
+ if isinstance(proxy, httpx.URL):
+ return ProxyConfig(str(proxy))
+ if isinstance(proxy, httpx.Proxy):
+ if proxy.ssl_context is not None:
+ raise InvalidArgumentException(
+ "E2B API calls don't support httpx.Proxy ssl_context"
+ )
+ # httpx.Proxy splits userinfo out of the URL into `.auth`; pyqwest
+ # takes the credentials the same way, so they pass straight through.
+ return ProxyConfig(
+ str(proxy.url),
+ auth=proxy.auth,
+ headers=tuple(proxy.headers.items()),
+ )
+ raise InvalidArgumentException(
+ "E2B API calls support only URL-string, httpx.URL, and httpx.Proxy "
+ 'proxies, e.g. proxy="http://user:pass@localhost:8030"'
+ )
+
@dataclass
class SandboxCreateResponse:
@@ -154,31 +208,20 @@ def validate_api_key(api_key: str) -> None:
class ApiClient(AuthenticatedClient):
"""
The client for interacting with the E2B API.
+
+ A single lazily-created httpx client (see the generated
+ ``AuthenticatedClient``) serves all threads and event loops: the pyqwest
+ transports it delegates to are thread-safe and loop-independent, and
+ ``httpx.Client`` is documented thread-safe.
"""
def __init__(
self,
config: ConnectionConfig,
transport: Optional[Union[BaseTransport, AsyncBaseTransport]] = None,
- transport_factory: Optional[Callable[[], BaseTransport]] = None,
- async_transport_factory: Optional[Callable[[], AsyncBaseTransport]] = None,
*args,
**kwargs,
):
- if transport is not None and (
- transport_factory is not None or async_transport_factory is not None
- ):
- raise ValueError("Use either transport or transport_factory, not both")
-
- self._transport_factory = transport_factory
- self._async_transport_factory = async_transport_factory
- self._thread_local = threading.local()
- # Keyed weakly by the event loop object itself, not id(loop) —
- # CPython reuses object ids, so a new loop could otherwise inherit
- # a client bound to a previous, closed loop.
- self._async_clients: weakref.WeakKeyDictionary[
- asyncio.AbstractEventLoop, httpx.AsyncClient
- ] = weakref.WeakKeyDictionary()
self._proxy = config.proxy
if config.api_key is None:
@@ -223,12 +266,10 @@ class ApiClient(AuthenticatedClient):
"event_hooks": self._logging_event_hooks(),
}
if transport is not None:
+ # The proxy lives in the transport; passing `proxy` here too
+ # would mount a fresh, never-closed proxy transport per client.
httpx_args["transport"] = transport
- if (
- transport is None
- and transport_factory is None
- and async_transport_factory is None
- ):
+ else:
httpx_args["proxy"] = config.proxy
# config.request_timeout is None when the timeout is explicitly
@@ -249,53 +290,6 @@ class ApiClient(AuthenticatedClient):
def _logging_event_hooks(self) -> dict:
return make_logging_event_hooks(self._logger)
- def _headers_with_auth(self) -> dict:
- return {
- **self._headers,
- self.auth_header_name: (
- f"{self.prefix} {self.token}" if self.prefix else self.token
- ),
- }
-
- def get_httpx_client(self) -> httpx.Client:
- if self._client is not None or self._transport_factory is None:
- return super().get_httpx_client()
-
- client = getattr(self._thread_local, "client", None)
- if client is None:
- client = httpx.Client(
- base_url=self._base_url,
- cookies=self._cookies,
- headers=self._headers_with_auth(),
- timeout=self._timeout,
- verify=self._verify_ssl,
- follow_redirects=self._follow_redirects,
- event_hooks=self._httpx_args.get("event_hooks"),
- transport=self._transport_factory(),
- )
- self._thread_local.client = client
- return client
-
- def get_async_httpx_client(self) -> httpx.AsyncClient:
- if self._async_client is not None or self._async_transport_factory is None:
- return super().get_async_httpx_client()
-
- loop = asyncio.get_running_loop()
- client = self._async_clients.get(loop)
- if client is None:
- client = httpx.AsyncClient(
- base_url=self._base_url,
- cookies=self._cookies,
- headers=self._headers_with_auth(),
- timeout=self._timeout,
- verify=self._verify_ssl,
- follow_redirects=self._follow_redirects,
- event_hooks=self._httpx_args.get("event_hooks"),
- transport=self._async_transport_factory(),
- )
- self._async_clients[loop] = client
- return client
-
# We need to override the logging hooks for the async usage
class AsyncApiClient(ApiClient):
diff --git a/packages/python-sdk/e2b/api/client_async/__init__.py b/packages/python-sdk/e2b/api/client_async/__init__.py
index dd001a3a4..f3dac38df 100644
--- a/packages/python-sdk/e2b/api/client_async/__init__.py
+++ b/packages/python-sdk/e2b/api/client_async/__init__.py
@@ -1,32 +1,92 @@
import asyncio
+import threading
import weakref
-from typing import Dict, Optional, Tuple
+from typing import Dict, Optional, Tuple, Union
import httpx
-from httpx._types import ProxyTypes
-
-from e2b.api import AsyncApiClient, connection_retries, limits
-from e2b.connection_config import ConnectionConfig
+from pyqwest import HTTPTransport, Request, Response
+from pyqwest.httpx import AsyncPyqwestTransport
+from pyqwest.middleware.retry import RetryTransport
+
+from e2b.api import (
+ AsyncApiClient,
+ ProxyConfig,
+ connection_retries,
+ limits,
+ pool_idle_timeout,
+ pool_max_idle_per_host,
+ proxy_to_config,
+)
+from e2b.connection_config import ConnectionConfig, ProxyTypes
TransportKey = Tuple[bool, Optional[ProxyTypes]]
def get_api_client(config: ConnectionConfig, **kwargs) -> AsyncApiClient:
- return AsyncApiClient(
- config,
- async_transport_factory=lambda: get_transport(config),
- **kwargs,
- )
-
-
-class AsyncTransportWithLogger(httpx.AsyncHTTPTransport):
+ return AsyncApiClient(config, transport=get_transport(config), **kwargs)
+
+
+class ConnectionRetryTransport(RetryTransport):
+ """Retry only failures establishing the connection, matching the
+ connect-only ``retries`` of the httpx transport this replaced: pyqwest
+ raises the builtin ``ConnectionError`` only before the request was
+ written, so these retries can never replay a request the API may have
+ received. The retry middleware's default policy would otherwise also
+ retry I/O errors and 429/5xx responses for idempotent methods."""
+
+ def should_retry_response(
+ self, request: Request, response: Union[Response, Exception]
+ ) -> bool:
+ return isinstance(response, ConnectionError)
+
+
+_transport_lock = threading.Lock()
+# One transport (= one connection pool) per proxy; None is the direct pool.
+# pyqwest's I/O runs on its own Rust runtime, so unlike the httpx envd
+# transports below, the transport is not bound to an event loop and the
+# cache is process-global rather than per-loop.
+_transports: Dict[Optional[ProxyConfig], AsyncPyqwestTransport] = {}
+
+
+def get_transport(config: ConnectionConfig) -> AsyncPyqwestTransport:
+ """The shared pyqwest-backed httpx transport for REST API calls. For TLS
+ connections ALPN negotiates the HTTP version (HTTP/2 against the E2B
+ API), like the http2-enabled httpx transport this replaced.
+
+ Requests are logged by pyqwest itself on the ``pyqwest.access`` and
+ ``pyqwest`` loggers at ``DEBUG`` (off unless enabled) — the transport-level
+ diagnostics httpcore used to provide. The SDK's own ``logger`` option is
+ separate and sits above this, on the httpx client."""
+ proxy = proxy_to_config(config.proxy)
+ with _transport_lock:
+ transport = _transports.get(proxy)
+ if transport is None:
+ transport = AsyncPyqwestTransport(
+ ConnectionRetryTransport(
+ HTTPTransport(
+ tls_include_system_certs=True,
+ proxy=proxy.to_pyqwest() if proxy is not None else None,
+ pool_idle_timeout=pool_idle_timeout,
+ pool_max_idle_per_host=pool_max_idle_per_host,
+ # Redirects belong to the httpx client above (which the
+ # generated clients leave off), not to reqwest.
+ follow_redirects=False,
+ ),
+ max_retries=connection_retries,
+ )
+ )
+ _transports[proxy] = transport
+ return transport
+
+
+class AsyncEnvdTransportWithLogger(httpx.AsyncHTTPTransport):
# Keyed weakly by the event loop object itself, not id(loop) — CPython
# reuses object ids, so a new loop could otherwise inherit a transport
# bound to a previous, closed loop.
_instances: weakref.WeakKeyDictionary[
asyncio.AbstractEventLoop,
- Dict[TransportKey, "AsyncTransportWithLogger"],
+ Dict[TransportKey, "AsyncEnvdTransportWithLogger"],
] = weakref.WeakKeyDictionary()
@property
@@ -34,17 +94,19 @@ class AsyncTransportWithLogger(httpx.AsyncHTTPTransport):
return self._pool
-def _get_cached_transport(cls, config: ConnectionConfig, http2: bool):
+def get_envd_transport(
+ config: ConnectionConfig, http2: bool = True
+) -> AsyncEnvdTransportWithLogger:
loop = asyncio.get_running_loop()
- loop_instances = cls._instances.get(loop)
+ loop_instances = AsyncEnvdTransportWithLogger._instances.get(loop)
if loop_instances is None:
loop_instances = {}
- cls._instances[loop] = loop_instances
+ AsyncEnvdTransportWithLogger._instances[loop] = loop_instances
key: TransportKey = (http2, config.proxy)
transport = loop_instances.get(key)
if transport is None:
- transport = cls(
+ transport = AsyncEnvdTransportWithLogger(
limits=limits,
proxy=config.proxy,
http2=http2,
@@ -53,22 +115,3 @@ def _get_cached_transport(cls, config: ConnectionConfig, http2: bool):
loop_instances[key] = transport
return transport
-
-
-def get_transport(
- config: ConnectionConfig, http2: bool = True
-) -> AsyncTransportWithLogger:
- return _get_cached_transport(AsyncTransportWithLogger, config, http2)
-
-
-class AsyncEnvdTransportWithLogger(AsyncTransportWithLogger):
- _instances: weakref.WeakKeyDictionary[
- asyncio.AbstractEventLoop,
- Dict[TransportKey, "AsyncEnvdTransportWithLogger"],
- ] = weakref.WeakKeyDictionary()
-
-
-def get_envd_transport(
- config: ConnectionConfig, http2: bool = True
-) -> AsyncEnvdTransportWithLogger:
- return _get_cached_transport(AsyncEnvdTransportWithLogger, config, http2)
diff --git a/packages/python-sdk/e2b/api/client_sync/__init__.py b/packages/python-sdk/e2b/api/client_sync/__init__.py
index 41fb4f023..c2d1a5790 100644
--- a/packages/python-sdk/e2b/api/client_sync/__init__.py
+++ b/packages/python-sdk/e2b/api/client_sync/__init__.py
@@ -1,25 +1,83 @@
-from typing import Dict, Optional, Tuple
+from typing import Dict, Optional, Tuple, Union
import httpx
import threading
-from httpx._types import ProxyTypes
-
-from e2b.api import ApiClient, connection_retries, limits
-from e2b.connection_config import ConnectionConfig
+from pyqwest import SyncHTTPTransport, SyncRequest, SyncResponse
+from pyqwest.httpx import PyqwestTransport
+from pyqwest.middleware.retry import SyncRetryTransport
+
+from e2b.api import (
+ ApiClient,
+ ProxyConfig,
+ connection_retries,
+ limits,
+ pool_idle_timeout,
+ pool_max_idle_per_host,
+ proxy_to_config,
+)
+from e2b.connection_config import ConnectionConfig, ProxyTypes
TransportKey = Tuple[bool, Optional[ProxyTypes]]
def get_api_client(config: ConnectionConfig, **kwargs) -> ApiClient:
- return ApiClient(
- config,
- transport_factory=lambda: get_transport(config),
- **kwargs,
- )
-
-
-class TransportWithLogger(httpx.HTTPTransport):
+ return ApiClient(config, transport=get_transport(config), **kwargs)
+
+
+class ConnectionRetryTransport(SyncRetryTransport):
+ """Retry only failures establishing the connection, matching the
+ connect-only ``retries`` of the httpx transport this replaced: pyqwest
+ raises the builtin ``ConnectionError`` only before the request was
+ written, so these retries can never replay a request the API may have
+ received. The retry middleware's default policy would otherwise also
+ retry I/O errors and 429/5xx responses for idempotent methods."""
+
+ def should_retry_response(
+ self, request: SyncRequest, response: Union[SyncResponse, Exception]
+ ) -> bool:
+ return isinstance(response, ConnectionError)
+
+
+_transport_lock = threading.Lock()
+# One transport (= one connection pool) per proxy; None is the direct pool.
+# pyqwest transports are thread-safe, so unlike the httpx envd transports
+# below, the cache is process-global rather than per-thread.
+_transports: Dict[Optional[ProxyConfig], PyqwestTransport] = {}
+
+
+def get_transport(config: ConnectionConfig) -> PyqwestTransport:
+ """The shared pyqwest-backed httpx transport for REST API calls. For TLS
+ connections ALPN negotiates the HTTP version (HTTP/2 against the E2B
+ API), like the http2-enabled httpx transport this replaced.
+
+ Requests are logged by pyqwest itself on the ``pyqwest.access`` and
+ ``pyqwest`` loggers at ``DEBUG`` (off unless enabled) — the transport-level
+ diagnostics httpcore used to provide. The SDK's own ``logger`` option is
+ separate and sits above this, on the httpx client."""
+ proxy = proxy_to_config(config.proxy)
+ with _transport_lock:
+ transport = _transports.get(proxy)
+ if transport is None:
+ transport = PyqwestTransport(
+ ConnectionRetryTransport(
+ SyncHTTPTransport(
+ tls_include_system_certs=True,
+ proxy=proxy.to_pyqwest() if proxy is not None else None,
+ pool_idle_timeout=pool_idle_timeout,
+ pool_max_idle_per_host=pool_max_idle_per_host,
+ # Redirects belong to the httpx client above (which the
+ # generated clients leave off), not to reqwest.
+ follow_redirects=False,
+ ),
+ max_retries=connection_retries,
+ )
+ )
+ _transports[proxy] = transport
+ return transport
+
+
+class EnvdTransportWithLogger(httpx.HTTPTransport):
_thread_local = threading.local()
@property
@@ -27,30 +85,6 @@ class TransportWithLogger(httpx.HTTPTransport):
return self._pool
-def get_transport(config: ConnectionConfig, http2: bool = True) -> TransportWithLogger:
- instances: Dict[TransportKey, TransportWithLogger] = getattr(
- TransportWithLogger._thread_local, "instances", {}
- )
- key: TransportKey = (http2, config.proxy)
- cached = instances.get(key)
- if cached is not None:
- return cached
-
- transport = TransportWithLogger(
- limits=limits,
- proxy=config.proxy,
- http2=http2,
- retries=connection_retries,
- )
- instances[key] = transport
- TransportWithLogger._thread_local.instances = instances
- return transport
-
-
-class EnvdTransportWithLogger(TransportWithLogger):
- _thread_local = threading.local()
-
-
def get_envd_transport(
config: ConnectionConfig, http2: bool = True
) -> EnvdTransportWithLogger:
diff --git a/packages/python-sdk/e2b/connection_config.py b/packages/python-sdk/e2b/connection_config.py
index 81f4a0946..828c3571f 100644
--- a/packages/python-sdk/e2b/connection_config.py
+++ b/packages/python-sdk/e2b/connection_config.py
@@ -1,14 +1,24 @@
import logging
import os
-from typing import cast, Optional, Dict, TypedDict
+from typing import cast, Optional, Dict, TypedDict, Union
-from httpx._types import ProxyTypes
+import httpx
from typing_extensions import Unpack
from e2b.api.metadata import package_version
from e2b.sandbox_domains import is_supported_sandbox_domain
+ProxyTypes = Union[str, httpx.URL, httpx.Proxy]
+"""The forms the ``proxy`` option accepts: a URL string, an ``httpx.URL``, or
+an ``httpx.Proxy``.
+
+Identical to ``httpx._types.ProxyTypes``, spelled out here so the SDK doesn't
+import httpx's private module at runtime — and so the union can grow a pyqwest
+proxy type as the transports move off httpx. :func:`e2b.api.proxy_to_config`
+narrows it to what the pyqwest REST transports take.
+"""
+
REQUEST_TIMEOUT: float = 60.0 # 60 seconds
KEEPALIVE_PING_INTERVAL_SEC = 50 # 50 seconds
diff --git a/packages/python-sdk/pyproject.toml b/packages/python-sdk/pyproject.toml
index 937f30d13..882bb99e1 100644
--- a/packages/python-sdk/pyproject.toml
+++ b/packages/python-sdk/pyproject.toml
@@ -20,7 +20,7 @@ dependencies = [
"dockerfile-parse>=2.0.1,<3",
"rich>=14.0.0",
"connectrpc>=0.11.1,<0.12",
- "pyqwest>=0.7.0,<0.8",
+ "pyqwest>=0.9.0,<0.10",
]
[project.urls]
diff --git a/packages/python-sdk/tests/test_api_client_transport.py b/packages/python-sdk/tests/test_api_client_transport.py
index e54848e98..f044782a5 100644
--- a/packages/python-sdk/tests/test_api_client_transport.py
+++ b/packages/python-sdk/tests/test_api_client_transport.py
@@ -1,23 +1,46 @@
import asyncio
-import gc
+import base64
+import json
+import logging
+import ssl
+import threading
+import time
from concurrent.futures import ThreadPoolExecutor
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import cast
import httpx
import pytest
-
-from e2b.api.client_async import AsyncEnvdTransportWithLogger, AsyncTransportWithLogger
+from pyqwest import (
+ Proxy,
+ Request,
+ SyncRequest,
+ SyncTransport,
+ Transport,
+)
+from pyqwest.httpx import AsyncPyqwestTransport, PyqwestTransport
+
+import e2b.api.client_async as client_async
+import e2b.api.client_sync as client_sync
+from e2b.api import ProxyConfig, proxy_to_config
+from e2b.api.client_async import AsyncEnvdTransportWithLogger
from e2b.api.client_async import get_api_client as get_async_api_client
from e2b.api.client_async import get_envd_transport as get_async_envd_transport
from e2b.api.client_async import get_transport as get_async_transport
-from e2b.api.client_sync import EnvdTransportWithLogger, TransportWithLogger
+from e2b.api.client_sync import EnvdTransportWithLogger
from e2b.api.client_sync import get_api_client as get_sync_api_client
from e2b.api.client_sync import get_envd_transport as get_sync_envd_transport
from e2b.api.client_sync import get_transport as get_sync_transport
-from e2b.connection_config import ConnectionConfig
+from e2b.connection_config import ConnectionConfig, ProxyTypes
+from e2b.exceptions import InvalidArgumentException
def reset_sync_api_transports():
- TransportWithLogger._thread_local.instances = {}
+ client_sync._transports.clear()
+
+
+def reset_async_api_transports():
+ client_async._transports.clear()
def reset_sync_envd_transports():
@@ -29,6 +52,76 @@ def run_in_worker_thread(fn):
return executor.submit(fn).result()
+def test_proxy_to_config_narrows_urls():
+ assert proxy_to_config(None) is None
+ assert proxy_to_config("http://127.0.0.1:9999") == ProxyConfig(
+ "http://127.0.0.1:9999"
+ )
+ assert proxy_to_config(httpx.URL("http://127.0.0.1:9999")) == ProxyConfig(
+ "http://127.0.0.1:9999"
+ )
+ # Guards callers that ignore the type hint.
+ with pytest.raises(InvalidArgumentException, match="URL-string"):
+ proxy_to_config(cast(ProxyTypes, object()))
+
+
+def test_proxy_to_config_converts_httpx_proxy():
+ # Everything pyqwest's Proxy can express carries over: the URL, the
+ # credentials httpx.Proxy splits off the URL, and headers for the proxy.
+ assert proxy_to_config(httpx.Proxy("http://127.0.0.1:9999")) == ProxyConfig(
+ "http://127.0.0.1:9999"
+ )
+ assert proxy_to_config(
+ httpx.Proxy("http://user:[email protected]:9999")
+ ) == ProxyConfig("http://127.0.0.1:9999", auth=("user", "pass"))
+ assert proxy_to_config(
+ httpx.Proxy("http://127.0.0.1:9999", auth=("user@x", "p@ss"))
+ ) == ProxyConfig("http://127.0.0.1:9999", auth=("user@x", "p@ss"))
+ assert proxy_to_config(
+ httpx.Proxy("http://127.0.0.1:9999", headers={"X-Auth": "t"})
+ ) == ProxyConfig("http://127.0.0.1:9999", headers=(("x-auth", "t"),))
+
+ # A per-proxy TLS context has no pyqwest counterpart; rejected rather than
+ # silently dropped.
+ with pytest.raises(InvalidArgumentException, match="ssl_context"):
+ proxy_to_config(
+ httpx.Proxy(
+ "https://127.0.0.1:9999", ssl_context=ssl.create_default_context()
+ )
+ )
+
+
+def test_proxy_config_builds_a_pyqwest_proxy():
+ config = ProxyConfig(
+ "http://127.0.0.1:9999", auth=("user", "pass"), headers=(("x-auth", "t"),)
+ )
+ assert isinstance(config.to_pyqwest(), Proxy)
+ # Equal configs are one cache key, even though the Proxy objects they
+ # build compare by identity.
+ assert config == ProxyConfig(
+ "http://127.0.0.1:9999", auth=("user", "pass"), headers=(("x-auth", "t"),)
+ )
+ assert config.to_pyqwest() != config.to_pyqwest()
+
+
+def test_connection_retry_policy_retries_only_connection_errors():
+ # The inner transport is never invoked by should_retry_response.
+ sync_policy = client_sync.ConnectionRetryTransport(cast(SyncTransport, object()))
+ async_policy = client_async.ConnectionRetryTransport(cast(Transport, object()))
+ sync_request = SyncRequest("GET", "https://example.com")
+ async_request = Request("GET", "https://example.com")
+
+ assert sync_policy.should_retry_response(sync_request, ConnectionError("refused"))
+ # TimeoutError is an OSError but not a ConnectionError: the request
+ # may have been written, so it must not be replayed.
+ assert not sync_policy.should_retry_response(sync_request, TimeoutError())
+ assert not sync_policy.should_retry_response(sync_request, RuntimeError())
+
+ assert async_policy.should_retry_response(async_request, ConnectionError("refused"))
+ assert not async_policy.should_retry_response(async_request, TimeoutError())
+ assert not async_policy.should_retry_response(async_request, RuntimeError())
+
+
def test_sync_api_client_proxy_uses_explicit_transport(test_api_key):
reset_sync_api_transports()
config = ConnectionConfig(
@@ -42,31 +135,13 @@ def test_sync_api_client_proxy_uses_explicit_transport(test_api_key):
try:
assert "proxy" not in api_client._httpx_args
assert httpx_client._transport is get_sync_transport(config)
+ assert isinstance(httpx_client._transport, PyqwestTransport)
assert httpx_client._mounts == {}
finally:
httpx_client.close()
reset_sync_api_transports()
-def test_sync_get_transport_http2_opt_out_returns_distinct_instance(test_api_key):
- reset_sync_api_transports()
- config = ConnectionConfig(api_key=test_api_key)
-
- try:
- http2_transport = get_sync_transport(config)
- http1_transport = get_sync_transport(config, http2=False)
-
- assert http2_transport is not http1_transport
- assert http2_transport._pool._http2 is True
- assert http1_transport._pool._http2 is False
- # Subsequent calls with the same http2 flag return the cached
- # instance.
- assert get_sync_transport(config) is http2_transport
- assert get_sync_transport(config, http2=False) is http1_transport
- finally:
- reset_sync_api_transports()
-
-
def test_sync_get_transport_keyed_by_proxy(test_api_key):
reset_sync_api_transports()
proxied_config = ConnectionConfig(
@@ -122,7 +197,9 @@ def test_sync_api_client_request_timeout_zero_disables_timeout(test_api_key):
reset_sync_api_transports()
-def test_sync_envd_transport_uses_separate_cache(test_api_key):
+def test_sync_envd_transport_uses_separate_stack(test_api_key):
+ # envd file-transfer traffic stays on the httpx-native transport (its RPC
+ # migration is a separate change); only REST API calls go through pyqwest.
reset_sync_api_transports()
reset_sync_envd_transports()
config = ConnectionConfig(api_key=test_api_key)
@@ -131,67 +208,31 @@ def test_sync_envd_transport_uses_separate_cache(test_api_key):
api_transport = get_sync_transport(config)
envd_transport = get_sync_envd_transport(config)
- assert api_transport is not envd_transport
+ assert isinstance(api_transport, PyqwestTransport)
+ assert isinstance(envd_transport, httpx.HTTPTransport)
assert get_sync_transport(config) is api_transport
assert get_sync_envd_transport(config) is envd_transport
- assert envd_transport._pool._http2 is True
+ envd_pool = envd_transport._pool
+ assert envd_pool._http2 is True # ty: ignore[possibly-missing-attribute]
finally:
reset_sync_api_transports()
reset_sync_envd_transports()
-def test_sync_api_transport_cache_reuses_within_thread_and_isolates_across_threads(
- test_api_key,
-):
- reset_sync_api_transports()
- config = ConnectionConfig(api_key=test_api_key)
-
- try:
- main_transport = get_sync_transport(config)
- same_thread_transport = get_sync_transport(config)
- worker_thread_transport = run_in_worker_thread(
- lambda: get_sync_transport(config)
- )
-
- assert same_thread_transport is main_transport
- assert worker_thread_transport is not main_transport
- finally:
- reset_sync_api_transports()
-
-
-def test_sync_api_client_cache_reuses_within_thread_and_isolates_across_threads(
- test_api_key,
-):
+def test_sync_api_client_is_shared_across_threads(test_api_key):
+ # httpx.Client is thread-safe and the pyqwest transport underneath is
+ # too, so a single client (and its pool) serves all threads — the
+ # per-thread client caching this replaced is gone.
reset_sync_api_transports()
config = ConnectionConfig(api_key=test_api_key)
api_client = get_sync_api_client(config)
- def get_worker_client_ids():
- httpx_client = api_client.get_httpx_client()
- try:
- return (
- id(httpx_client),
- id(api_client.get_httpx_client()),
- id(httpx_client._transport),
- id(get_sync_transport(config)),
- )
- finally:
- httpx_client.close()
-
try:
main_client = api_client.get_httpx_client()
- (
- worker_client_id,
- worker_cached_client_id,
- worker_transport_id,
- worker_cached_transport_id,
- ) = run_in_worker_thread(get_worker_client_ids)
+ worker_client = run_in_worker_thread(api_client.get_httpx_client)
assert api_client.get_httpx_client() is main_client
- assert worker_client_id == worker_cached_client_id
- assert worker_transport_id == worker_cached_transport_id
- assert worker_client_id != id(main_client)
- assert worker_transport_id != id(main_client._transport)
+ assert worker_client is main_client
finally:
main_client.close()
reset_sync_api_transports()
@@ -207,7 +248,8 @@ def test_sync_envd_transport_cache_is_thread_local(test_api_key):
assert main_transport is get_sync_envd_transport(config)
assert thread_transport is not main_transport
- assert main_transport._pool._http2 is True
+ main_pool = main_transport._pool
+ assert main_pool._http2 is True # ty: ignore[possibly-missing-attribute]
assert thread_transport._pool._http2 is True
finally:
reset_sync_envd_transports()
@@ -215,7 +257,7 @@ def test_sync_envd_transport_cache_is_thread_local(test_api_key):
@pytest.mark.asyncio
async def test_async_api_client_proxy_uses_explicit_transport(test_api_key):
- AsyncTransportWithLogger._instances.clear()
+ reset_async_api_transports()
config = ConnectionConfig(
api_key=test_api_key,
proxy="http://127.0.0.1:9999",
@@ -223,44 +265,20 @@ async def test_async_api_client_proxy_uses_explicit_transport(test_api_key):
api_client = get_async_api_client(config)
httpx_client = api_client.get_async_httpx_client()
- transport = AsyncTransportWithLogger._instances[asyncio.get_running_loop()][
- (True, "http://127.0.0.1:9999")
- ]
try:
assert "proxy" not in api_client._httpx_args
- assert httpx_client._transport is transport
+ assert httpx_client._transport is get_async_transport(config)
+ assert isinstance(httpx_client._transport, AsyncPyqwestTransport)
assert httpx_client._mounts == {}
finally:
await httpx_client.aclose()
- AsyncTransportWithLogger._instances.clear()
-
-
-async def test_async_get_transport_http2_opt_out_returns_distinct_instance(
- test_api_key,
-):
- AsyncTransportWithLogger._instances.clear()
- config = ConnectionConfig(api_key=test_api_key)
-
- try:
- http2_transport = get_async_transport(config)
- http1_transport = get_async_transport(config, http2=False)
-
- assert http2_transport is not http1_transport
- assert http2_transport._pool._http2 is True
- assert http1_transport._pool._http2 is False
- # Subsequent calls with the same http2 flag return the cached
- # instance.
- assert get_async_transport(config) is http2_transport
- assert get_async_transport(config, http2=False) is http1_transport
- finally:
- AsyncTransportWithLogger._instances.clear()
+ reset_async_api_transports()
@pytest.mark.asyncio
async def test_async_get_transport_keyed_by_proxy(test_api_key):
- AsyncTransportWithLogger._instances.clear()
+ reset_async_api_transports()
proxied_config = ConnectionConfig(
api_key=test_api_key,
proxy="http://127.0.0.1:9999",
@@ -276,146 +294,349 @@ async def test_async_get_transport_keyed_by_proxy(test_api_key):
assert get_async_transport(proxied_config) is proxied_transport
assert get_async_transport(direct_config) is direct_transport
finally:
- AsyncTransportWithLogger._instances.clear()
+ reset_async_api_transports()
@pytest.mark.asyncio
-async def test_async_api_client_applies_request_timeout(test_api_key):
- AsyncTransportWithLogger._instances.clear()
- config = ConnectionConfig(api_key=test_api_key, request_timeout=1.5)
-
+async def test_async_api_client_is_shared_across_loops(test_api_key):
+ # pyqwest's I/O runs on its own Rust runtime, so neither the transport
+ # nor the httpx client wrapper is bound to an event loop — a single
+ # client serves all loops (the per-loop client caching this replaced is
+ # gone).
+ reset_async_api_transports()
+ config = ConnectionConfig(api_key=test_api_key)
api_client = get_async_api_client(config)
- httpx_client = api_client.get_async_httpx_client()
+
+ async def get_client():
+ return api_client.get_async_httpx_client()
try:
- assert httpx_client.timeout == httpx.Timeout(1.5)
+ main_client = api_client.get_async_httpx_client()
+ other_loop_client = await asyncio.get_running_loop().run_in_executor(
+ None,
+ lambda: asyncio.run(get_client()),
+ )
+
+ assert api_client.get_async_httpx_client() is main_client
+ assert other_loop_client is main_client
finally:
- await httpx_client.aclose()
- AsyncTransportWithLogger._instances.clear()
+ await main_client.aclose()
+ reset_async_api_transports()
@pytest.mark.asyncio
-async def test_async_api_client_cache_reuses_within_loop_and_isolates_across_loops(
- test_api_key,
-):
- AsyncTransportWithLogger._instances.clear()
+async def test_async_envd_transport_uses_separate_stack(test_api_key):
+ reset_async_api_transports()
+ AsyncEnvdTransportWithLogger._instances.clear()
config = ConnectionConfig(api_key=test_api_key)
- api_client = get_async_api_client(config)
- async def get_client_ids():
- httpx_client = api_client.get_async_httpx_client()
- try:
- return (
- id(httpx_client),
- id(api_client.get_async_httpx_client()),
- id(httpx_client._transport),
- id(get_async_transport(config)),
- )
- finally:
- await httpx_client.aclose()
+ try:
+ api_transport = get_async_transport(config)
+ envd_transport = get_async_envd_transport(config)
+
+ assert isinstance(api_transport, AsyncPyqwestTransport)
+ assert isinstance(envd_transport, httpx.AsyncHTTPTransport)
+ assert get_async_transport(config) is api_transport
+ assert get_async_envd_transport(config) is envd_transport
+ envd_pool = envd_transport._pool
+ assert envd_pool._http2 is True # ty: ignore[possibly-missing-attribute]
+ finally:
+ reset_async_api_transports()
+ AsyncEnvdTransportWithLogger._instances.clear()
+
+class _EchoHandler(BaseHTTPRequestHandler):
+ """Answers every GET with a JSON echo of the request headers; a path
+ starting with ``/slow`` sleeps 5 seconds first, one starting with
+ ``/stall`` answers the head and then never sends the body, and one starting
+ with ``/redirect`` answers 302 pointing at ``/sandboxes``."""
+
+ def do_GET(self):
+ if self.path.startswith("/slow"):
+ time.sleep(5)
+ if self.path.startswith("/redirect"):
+ self.send_response(302)
+ self.send_header("Location", "/sandboxes")
+ self.send_header("Content-Length", "0")
+ self.end_headers()
+ return
+ headers = {k.lower(): v for k, v in self.headers.items()}
+ body = json.dumps({"path": self.path, "headers": headers}).encode()
+ self.send_response(200)
+ self.send_header("Content-Type", "application/json")
+ self.send_header("Content-Length", str(len(body)))
+ self.end_headers()
+ if self.path.startswith("/stall"):
+ self.wfile.flush()
+ time.sleep(5)
+ return
+ self.wfile.write(body)
+
+ def log_message(self, *args):
+ pass
+
+
+class _EchoServer(ThreadingHTTPServer):
+ # The concurrency tests open 32 connections at once. Windows resets
+ # connections that overflow the listen backlog (request_queue_size,
+ # default 5) instead of queueing them, which surfaces as a flaky
+ # "connection was forcibly closed" WriteError mid-test.
+ request_queue_size = 64
+
+
+def echo_server():
+ server = _EchoServer(("127.0.0.1", 0), _EchoHandler)
+ thread = threading.Thread(target=server.serve_forever, daemon=True)
+ thread.start()
try:
- main_client = api_client.get_async_httpx_client()
- (
- worker_client_id,
- worker_cached_client_id,
- worker_transport_id,
- worker_cached_transport_id,
- ) = await asyncio.get_running_loop().run_in_executor(
- None,
- lambda: asyncio.run(get_client_ids()),
+ yield f"http://127.0.0.1:{server.server_address[1]}"
+ finally:
+ server.shutdown()
+ thread.join()
+
+
+def test_sync_transport_sends_proxy_credentials_and_headers(test_api_key, echo_server):
+ # Everything an httpx.Proxy can express reaches the proxy: the echo server
+ # stands in for one, so the request arrives in absolute form with the
+ # credentials and the extra headers configured for it.
+ reset_sync_api_transports()
+ config = ConnectionConfig(
+ api_key=test_api_key,
+ proxy=httpx.Proxy(
+ echo_server, auth=("user", "pass"), headers={"X-Proxy-Token": "t"}
+ ),
+ )
+ client = httpx.Client(transport=get_sync_transport(config))
+
+ try:
+ echoed = client.get("http://proxied.invalid/health").json()
+ assert echoed["path"] == "http://proxied.invalid/health"
+ assert echoed["headers"]["proxy-authorization"] == (
+ "Basic " + base64.b64encode(b"user:pass").decode()
)
+ assert echoed["headers"]["x-proxy-token"] == "t"
+ finally:
+ client.close()
+ reset_sync_api_transports()
- assert api_client.get_async_httpx_client() is main_client
- assert worker_client_id == worker_cached_client_id
- assert worker_transport_id == worker_cached_transport_id
- assert worker_client_id != id(main_client)
- assert worker_transport_id != id(main_client._transport)
+
+def test_transport_emits_pyqwest_access_log(test_api_key, echo_server, caplog):
+ # pyqwest logs every request on `pyqwest.access` at DEBUG — the
+ # transport-level diagnostics httpcore used to provide, and separate from
+ # the SDK's own `logger` option.
+ reset_sync_api_transports()
+ config = ConnectionConfig(api_key=test_api_key, api_url=echo_server)
+ api_client = get_sync_api_client(config)
+ httpx_client = api_client.get_httpx_client()
+
+ try:
+ with caplog.at_level(logging.DEBUG, logger="pyqwest.access"):
+ assert httpx_client.request("GET", "/sandboxes").status_code == 200
+
+ messages = [
+ r.getMessage() for r in caplog.records if r.name == "pyqwest.access"
+ ]
+ # The stdlib test server answers HTTP/1.0.
+ assert messages == [
+ f'HTTP Request: GET {echo_server}/sandboxes "HTTP/1.0 200 OK"'
+ ]
finally:
- await main_client.aclose()
- AsyncTransportWithLogger._instances.clear()
+ httpx_client.close()
+ reset_sync_api_transports()
-def test_async_transport_not_reused_across_sequential_loops(test_api_key):
- AsyncTransportWithLogger._instances.clear()
- config = ConnectionConfig(api_key=test_api_key)
+def test_sync_api_client_round_trips_through_pyqwest(test_api_key, echo_server):
+ reset_sync_api_transports()
+ config = ConnectionConfig(api_key=test_api_key, api_url=echo_server)
+ api_client = get_sync_api_client(config)
+ httpx_client = api_client.get_httpx_client()
+
+ try:
+ assert isinstance(httpx_client._transport, PyqwestTransport)
+ response = httpx_client.request("GET", "/sandboxes")
+ assert response.status_code == 200
+ echoed = response.json()
+ assert echoed["path"] == "/sandboxes"
+ assert echoed["headers"]["x-api-key"] == test_api_key
+ assert echoed["headers"]["package_version"]
+ finally:
+ httpx_client.close()
+ reset_sync_api_transports()
+
+
+def test_sync_api_client_serves_concurrent_threads(test_api_key, echo_server):
+ # The scenario the removed per-thread client caching used to guard: one
+ # client, one shared pyqwest pool, many threads at once.
+ reset_sync_api_transports()
+ config = ConnectionConfig(api_key=test_api_key, api_url=echo_server)
+ api_client = get_sync_api_client(config)
+ httpx_client = api_client.get_httpx_client()
- async def get_transport():
- return get_async_transport(config)
+ def request(i: int) -> tuple[int, str]:
+ response = httpx_client.request("GET", f"/sandboxes/{i}")
+ return response.status_code, response.json()["path"]
try:
- loop_a = asyncio.new_event_loop()
- try:
- transport_a = loop_a.run_until_complete(get_transport())
- finally:
- loop_a.close()
- del loop_a
- gc.collect()
-
- # The cache entry dies with the loop, so a later loop can never
- # inherit a transport bound to a closed loop, even when CPython
- # reuses the dead loop's object id.
- assert len(AsyncTransportWithLogger._instances) == 0
-
- loop_b = asyncio.new_event_loop()
- try:
- transport_b = loop_b.run_until_complete(get_transport())
- finally:
- loop_b.close()
-
- assert transport_b is not transport_a
+ with ThreadPoolExecutor(max_workers=16) as executor:
+ results = list(executor.map(request, range(32)))
+
+ assert results == [(200, f"/sandboxes/{i}") for i in range(32)]
finally:
- AsyncTransportWithLogger._instances.clear()
+ httpx_client.close()
+ reset_sync_api_transports()
-def test_async_api_client_not_reused_across_sequential_loops(test_api_key):
- AsyncTransportWithLogger._instances.clear()
- config = ConnectionConfig(api_key=test_api_key)
+async def test_async_api_client_serves_concurrent_requests(test_api_key, echo_server):
+ reset_async_api_transports()
+ config = ConnectionConfig(api_key=test_api_key, api_url=echo_server)
api_client = get_async_api_client(config)
+ httpx_client = api_client.get_async_httpx_client()
- async def get_client():
- client = api_client.get_async_httpx_client()
- assert api_client.get_async_httpx_client() is client
- return client
+ async def request(i: int) -> tuple[int, str]:
+ response = await httpx_client.request("GET", f"/sandboxes/{i}")
+ return response.status_code, response.json()["path"]
try:
- loop_a = asyncio.new_event_loop()
- try:
- client_a = loop_a.run_until_complete(get_client())
- loop_a.run_until_complete(client_a.aclose())
- finally:
- loop_a.close()
- del loop_a
- gc.collect()
-
- assert len(api_client._async_clients) == 0
-
- loop_b = asyncio.new_event_loop()
- try:
- client_b = loop_b.run_until_complete(get_client())
- loop_b.run_until_complete(client_b.aclose())
- finally:
- loop_b.close()
-
- assert client_b is not client_a
+ results = await asyncio.gather(*(request(i) for i in range(32)))
+ assert list(results) == [(200, f"/sandboxes/{i}") for i in range(32)]
finally:
- AsyncTransportWithLogger._instances.clear()
+ await httpx_client.aclose()
+ reset_async_api_transports()
@pytest.mark.asyncio
-async def test_async_envd_transport_uses_separate_cache(test_api_key):
- AsyncTransportWithLogger._instances.clear()
- AsyncEnvdTransportWithLogger._instances.clear()
- config = ConnectionConfig(api_key=test_api_key)
+async def test_async_api_client_round_trips_through_pyqwest(test_api_key, echo_server):
+ reset_async_api_transports()
+ config = ConnectionConfig(api_key=test_api_key, api_url=echo_server)
+ api_client = get_async_api_client(config)
+ httpx_client = api_client.get_async_httpx_client()
try:
- api_transport = get_async_transport(config)
- envd_transport = get_async_envd_transport(config)
+ assert isinstance(httpx_client._transport, AsyncPyqwestTransport)
+ response = await httpx_client.request("GET", "/sandboxes")
+ assert response.status_code == 200
+ echoed = response.json()
+ assert echoed["path"] == "/sandboxes"
+ assert echoed["headers"]["x-api-key"] == test_api_key
+ assert echoed["headers"]["package_version"]
+ finally:
+ await httpx_client.aclose()
+ reset_async_api_transports()
- assert api_transport is not envd_transport
- assert get_async_transport(config) is api_transport
- assert get_async_envd_transport(config) is envd_transport
- assert envd_transport._pool._http2 is True
+
+def test_sync_api_client_leaves_redirects_to_httpx(test_api_key, echo_server):
+ # reqwest would otherwise follow redirects inside the transport, hiding them
+ # from httpx: the generated client asks for no redirect following, so a 302
+ # must surface as-is, and opting in must record the hop in `history`.
+ reset_sync_api_transports()
+ config = ConnectionConfig(api_key=test_api_key, api_url=echo_server)
+ api_client = get_sync_api_client(config)
+ httpx_client = api_client.get_httpx_client()
+
+ try:
+ assert httpx_client.follow_redirects is False
+ response = httpx_client.request("GET", "/redirect")
+ assert response.status_code == 302
+ assert response.headers["location"] == "/sandboxes"
+ assert response.history == []
+
+ followed = httpx_client.request("GET", "/redirect", follow_redirects=True)
+ assert followed.status_code == 200
+ assert followed.json()["path"] == "/sandboxes"
+ assert [r.status_code for r in followed.history] == [302]
finally:
- AsyncTransportWithLogger._instances.clear()
- AsyncEnvdTransportWithLogger._instances.clear()
+ httpx_client.close()
+ reset_sync_api_transports()
+
+
+async def test_async_api_client_leaves_redirects_to_httpx(test_api_key, echo_server):
+ reset_async_api_transports()
+ config = ConnectionConfig(api_key=test_api_key, api_url=echo_server)
+ api_client = get_async_api_client(config)
+ httpx_client = api_client.get_async_httpx_client()
+
+ try:
+ assert httpx_client.follow_redirects is False
+ response = await httpx_client.request("GET", "/redirect")
+ assert response.status_code == 302
+ assert response.headers["location"] == "/sandboxes"
+ assert response.history == []
+
+ followed = await httpx_client.request("GET", "/redirect", follow_redirects=True)
+ assert followed.status_code == 200
+ assert followed.json()["path"] == "/sandboxes"
+ assert [r.status_code for r in followed.history] == [302]
+ finally:
+ await httpx_client.aclose()
+ reset_async_api_transports()
+
+
+def test_sync_api_client_timeout_raises_httpx_read_timeout(test_api_key, echo_server):
+ # pyqwest raises the builtin TimeoutError; the transport re-raises it as
+ # httpx.ReadTimeout to keep the httpx.TimeoutException contract.
+ reset_sync_api_transports()
+ config = ConnectionConfig(api_key=test_api_key, api_url=echo_server)
+ api_client = get_sync_api_client(config)
+ httpx_client = api_client.get_httpx_client()
+
+ try:
+ with pytest.raises(httpx.ReadTimeout):
+ httpx_client.request("GET", "/slow", timeout=0.2)
+ finally:
+ httpx_client.close()
+ reset_sync_api_transports()
+
+
+async def test_async_api_client_timeout_raises_httpx_read_timeout(
+ test_api_key, echo_server
+):
+ reset_async_api_transports()
+ config = ConnectionConfig(api_key=test_api_key, api_url=echo_server)
+ api_client = get_async_api_client(config)
+ httpx_client = api_client.get_async_httpx_client()
+
+ try:
+ with pytest.raises(httpx.ReadTimeout):
+ await httpx_client.request("GET", "/slow", timeout=0.2)
+ finally:
+ await httpx_client.aclose()
+ reset_async_api_transports()
+
+
+def test_sync_api_client_body_timeout_raises_httpx_read_timeout(
+ test_api_key, echo_server
+):
+ # The head arrives in time and the body never does: httpx reads the body
+ # after the transport returned, so that timeout is mapped on the stream.
+ reset_sync_api_transports()
+ config = ConnectionConfig(api_key=test_api_key, api_url=echo_server)
+ api_client = get_sync_api_client(config)
+ httpx_client = api_client.get_httpx_client()
+
+ try:
+ with pytest.raises(httpx.ReadTimeout):
+ httpx_client.request("GET", "/stall", timeout=0.2)
+ finally:
+ httpx_client.close()
+ reset_sync_api_transports()
+
+
+async def test_async_api_client_body_timeout_raises_httpx_read_timeout(
+ test_api_key, echo_server
+):
+ reset_async_api_transports()
+ config = ConnectionConfig(api_key=test_api_key, api_url=echo_server)
+ api_client = get_async_api_client(config)
+ httpx_client = api_client.get_async_httpx_client()
+
+ try:
+ with pytest.raises(httpx.ReadTimeout):
+ await httpx_client.request("GET", "/stall", timeout=0.2)
+ finally:
+ await httpx_client.aclose()
+ reset_async_api_transports()
diff --git a/packages/python-sdk/uv.lock b/packages/python-sdk/uv.lock
index 6ed2353b3..c3c2e406a 100644
--- a/packages/python-sdk/uv.lock
+++ b/packages/python-sdk/uv.lock
@@ -228,7 +228,7 @@ requires-dist = [
{ name = "httpx", specifier = ">=0.27.0,<1.0.0" },
{ name = "packaging", specifier = ">=24.1" },
{ name = "protobuf-py", specifier = ">=0.1.1,<0.2" },
- { name = "pyqwest", specifier = ">=0.7.0,<0.8" },
+ { name = "pyqwest", specifier = ">=0.9.0,<0.10" },
{ name = "python-dateutil", specifier = ">=2.8.2" },
{ name = "rich", specifier = ">=14.0.0" },
{ name = "typing-extensions", specifier = ">=4.10.0" },
@@ -811,55 +811,55 @@ wheels = [
[[package]]
name = "pyqwest"
-version = "0.7.0"
+version = "0.9.0"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "opentelemetry-api" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/01/05/8576f0eeb44d3fe14c70e2bafa77ae6930c5e6f42b93c568719ea4456715/pyqwest-0.7.0.tar.gz", hash = "sha256:ac65f2243f3e814e7f4aad3f2fcfe78f89aad2de2a825eaaabf4c102f1937843", size = 457991, upload-time = "2026-07-19T05:20:06.61Z" }
-wheels = [
- { url = "https://files.pythonhosted.org/packages/86/49/7f26a2c2a3e8bbab4862bcbf4f54b706d9524fa9705cc0127553b81ed161/pyqwest-0.7.0-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:7b2339f3b55ae179e0cb55bbd5792ae1c954d31f80de7b4dde0e95b03576b6be", size = 5159904, upload-time = "2026-07-19T05:18:57.757Z" },
- { url = "https://files.pythonhosted.org/packages/20/f1/4aba1976566936ca873e1a726a0d9bdf8195a0dc4e4f78122f6050328566/pyqwest-0.7.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:2159c7e2eaf2563cdadfda17314e2b1747c30603979bf73db8daef311247db82", size = 5044476, upload-time = "2026-07-19T05:18:59.473Z" },
- { url = "https://files.pythonhosted.org/packages/fe/06/45908e5cda7fa28ba60df5ed2091056893c394c3217a796bc6577c4bd294/pyqwest-0.7.0-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a826f1b492a7497f469c8467bd51faf582733654bb2bc9fcdd4fa502f3e6ca1", size = 5560021, upload-time = "2026-07-19T05:19:01.097Z" },
- { url = "https://files.pythonhosted.org/packages/f2/3d/603f5c9446e8c13a4970b816246d7928e895408a7ed1778d98de3e25ea43/pyqwest-0.7.0-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:da43c7e86bee9e74ff474d4829cd398fb9220ff0d84d633094ea6797fdfe03a1", size = 5506130, upload-time = "2026-07-19T05:19:02.812Z" },
- { url = "https://files.pythonhosted.org/packages/33/6d/2984aa02f4d0296dddb5df159e1af6c6e0ddc0b507d592f13d6ccd0b3162/pyqwest-0.7.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:d1c71327c323a19dc90a0dafb1d68fb13f4f775a2498a26bf95f17165e64da9f", size = 5719961, upload-time = "2026-07-19T05:19:04.213Z" },
- { url = "https://files.pythonhosted.org/packages/19/06/e30c0d31eea17cabf99ef90c7c02e14cc94ca7d59793d397de9359148693/pyqwest-0.7.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:c002e0fc31a96f1c47986299710f49ed4551e4a912a7cdb69aba6fd94db6d544", size = 5908279, upload-time = "2026-07-19T05:19:05.595Z" },
- { url = "https://files.pythonhosted.org/packages/eb/db/a1368faae1cbd094a0d179b76de69b8d1908bd45898d3bcd29ac98622072/pyqwest-0.7.0-cp310-abi3-win_amd64.whl", hash = "sha256:847e4468b5379a219b91a13dd3c92dd3b7b3d9f59af23e4c6776e663594cb241", size = 4755104, upload-time = "2026-07-19T05:19:07.772Z" },
- { url = "https://files.pythonhosted.org/packages/b3/38/c493e85ebd17d3a5c56eb53fbea36a1a6f396b999b38173ffde513576eb1/pyqwest-0.7.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:4988fa1c368072886dce48f52fcbabe9f25784c6e189a9a6f2b42f6e9f383973", size = 5172962, upload-time = "2026-07-19T05:19:09.229Z" },
- { url = "https://files.pythonhosted.org/packages/d6/68/1b340fdc7735b5682d308cabc2d65ea76c03a6cc2c30072a0c14c24f716c/pyqwest-0.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:dfb61138c802c7317d840a274fa24f9d878301f693268e9186a9896452017a71", size = 5032604, upload-time = "2026-07-19T05:19:10.884Z" },
- { url = "https://files.pythonhosted.org/packages/4d/52/eecd858568ef6586cbdc3c419a9a0b1e8f891e2968f0f6b2a9fa9bdaac19/pyqwest-0.7.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f6fdc0601590bdc547007828627082f0dc0e445e92d900dccb227e51898d7243", size = 5558302, upload-time = "2026-07-19T05:19:12.348Z" },
- { url = "https://files.pythonhosted.org/packages/c0/8f/b67d0056b18a9f99a1c9253cb983d5c4361e3e102d729df6623b71d6d939/pyqwest-0.7.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f82c971810695f5fd7962859a2469616c83b7aca6664d8f147287ee5ff430cd", size = 5501483, upload-time = "2026-07-19T05:19:13.892Z" },
- { url = "https://files.pythonhosted.org/packages/c0/a6/69b87c4c80ced01645a143679458895dcb5c0e5ca0b3d4a43d979939cce6/pyqwest-0.7.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9dc2f405803b94525ab030c01cdac7093bcc1a5da6802de3345a868a0f51b3da", size = 5717334, upload-time = "2026-07-19T05:19:15.541Z" },
- { url = "https://files.pythonhosted.org/packages/26/7b/5891b72b9193b692b50ecdc4e26e7e3687f9763f5f263646bc8f997f5b62/pyqwest-0.7.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:537f71f97a533fa355d02c15ed9f0cc05fb8915996cb921caa87fe7310b457ee", size = 5902447, upload-time = "2026-07-19T05:19:17.273Z" },
- { url = "https://files.pythonhosted.org/packages/6a/80/1b280618af3f9d36081449d153efc5620f0eea93ac169574fc69208d2b91/pyqwest-0.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:196aa73fb7eee4b6c052d6f4172a4321904a7208331f4322ccee3ee7d0adbc78", size = 4750469, upload-time = "2026-07-19T05:19:18.916Z" },
- { url = "https://files.pythonhosted.org/packages/c1/9c/64c8df83a152804ac3074fb879c1229c3aca55a12dc33dc73c72e93405e6/pyqwest-0.7.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:72d001892ed570df1dcc489ef8b0a03bc7abd4fbdca10625c358a87e66b226ad", size = 5171308, upload-time = "2026-07-19T05:19:20.332Z" },
- { url = "https://files.pythonhosted.org/packages/14/d1/46e629541a3f7231dd978fa9939e6ddcd075238880395bcfb16544769165/pyqwest-0.7.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:03da0797bac5c2eb1a40f02afccd4b5aad5ad0d375bb993df2f5e0c692fc0c6c", size = 5032449, upload-time = "2026-07-19T05:19:21.967Z" },
- { url = "https://files.pythonhosted.org/packages/44/3c/132194c747696e41ad5745c51587bd20057d800b6a64fb901ce2ac990149/pyqwest-0.7.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:837e18aef4490eed25b4194d49f16732ccf1abf2cdd0845e75d75d2a4428b98c", size = 5556847, upload-time = "2026-07-19T05:19:23.589Z" },
- { url = "https://files.pythonhosted.org/packages/e6/5d/6726a70e89c60bf3cd30d5d918eff68dc1d1ceb9c911331d7fb57977bfc3/pyqwest-0.7.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:418e8c3a67ca6226bfb6147b8668203c74d9c872657117086f4c264a674d7980", size = 5500333, upload-time = "2026-07-19T05:19:25.317Z" },
- { url = "https://files.pythonhosted.org/packages/49/3f/329df64d3e8778bc311a22e432280cd317619c3f9b7e414f375127bb90b0/pyqwest-0.7.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:31176abbbcbe6d03740967b5c0241deaa60b328792644cb2e317a34d6b076433", size = 5717248, upload-time = "2026-07-19T05:19:26.963Z" },
- { url = "https://files.pythonhosted.org/packages/2e/93/6670afb97c6ce7b5ba27981e023d9edc7413e509bbe18afebb729834d9e6/pyqwest-0.7.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e21102f9c13234a0066d42bb5429dc5c311d7fd99401878837d9675a7f6e03b9", size = 5902814, upload-time = "2026-07-19T05:19:28.637Z" },
- { url = "https://files.pythonhosted.org/packages/51/d3/bf9440a03c97f408743313215d8c7e9875b0b2b0d2ef97f5fbb5066cd57d/pyqwest-0.7.0-cp313-cp313-win_amd64.whl", hash = "sha256:ca19e96b5e902a6d35e18cee7f5e90612fca6ab169378d42242cdcb638578cee", size = 4750510, upload-time = "2026-07-19T05:19:30.587Z" },
- { url = "https://files.pythonhosted.org/packages/dc/25/8b0919bf504309982857e564e3035ffd799d7aaa23457eb351485573e5ee/pyqwest-0.7.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:4e4e79187c3e4ebd07d663d8dc7a7cba865c72020332e41807426a7e3526fda0", size = 5177972, upload-time = "2026-07-19T05:19:32.051Z" },
- { url = "https://files.pythonhosted.org/packages/52/12/d652213fe336c52b75fb4df710f5cff08f8a1dcc9e385c9120f18476f5c9/pyqwest-0.7.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1bc2c569481ade1bc0b89b07daf1b49b20a1337a53207ffe0ef325260f509404", size = 5032608, upload-time = "2026-07-19T05:19:33.772Z" },
- { url = "https://files.pythonhosted.org/packages/82/b0/406c91563140b87ade5c5935410997b26449b8eb2f91511bc52741ae38fb/pyqwest-0.7.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ef1bfbdca9ec9c8a7b223268f5ef8d45694da7226929454b0cb40f2e3d1ddd5", size = 5558937, upload-time = "2026-07-19T05:19:35.174Z" },
- { url = "https://files.pythonhosted.org/packages/7f/17/a0a09936b5dd5d9d7517289aee3683bbf6554b0853bce5280ead9da27336/pyqwest-0.7.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4c2f6a6830becfa1c5bb94aa169ad854da5749a95a440aee759932d5965c213", size = 5500603, upload-time = "2026-07-19T05:19:37.023Z" },
- { url = "https://files.pythonhosted.org/packages/00/34/ccec52ca9f14fbe11292fadbe89c771353e0f46d58aa88d8e93d6e018117/pyqwest-0.7.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0d11128ccc382f64fcdf92d3bce6be7191489c1b3a9a3f0dbdf89e55451638de", size = 5719784, upload-time = "2026-07-19T05:19:38.649Z" },
- { url = "https://files.pythonhosted.org/packages/16/cc/58dca466c236e497cbb2e75b97a2489225d21f5063d932ab7d1723294112/pyqwest-0.7.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5832373c7bcccfbc3bb79c44b592e0871631139a2ef5aef771b8fe2b7bd4301d", size = 5901396, upload-time = "2026-07-19T05:19:40.402Z" },
- { url = "https://files.pythonhosted.org/packages/06/a0/983ea3b859828bef8372896e9c407f62bf426b84526d0b0cf9fd9abce411/pyqwest-0.7.0-cp314-cp314-win_amd64.whl", hash = "sha256:7330070c4497e564007985716ac347cb9a7500eba5c9610500653a2ce4cfe86e", size = 4751036, upload-time = "2026-07-19T05:19:42.159Z" },
- { url = "https://files.pythonhosted.org/packages/92/1d/e2fe3dfe6d87989017412f394abc45435a3af2526e998c83cf836937b23c/pyqwest-0.7.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:02fd606a35be7803a770071f642a375e55df4c2025e49b10b859430f424c4492", size = 5165801, upload-time = "2026-07-19T05:19:43.82Z" },
- { url = "https://files.pythonhosted.org/packages/f4/fe/90126ac71fe09c729f36c166cb71b5148dd8a80e47f6f232bf71494604a2/pyqwest-0.7.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a807835c6a0777f0cc57c321c78c7bf162f6354698844d78db6e03ba9edd83dc", size = 5025128, upload-time = "2026-07-19T05:19:45.391Z" },
- { url = "https://files.pythonhosted.org/packages/e5/15/ee84ce834705d613c0b113fb4cf9d274011cfcc6c6ededb52d92a38a2367/pyqwest-0.7.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:86d84871cb0a572700dece3a6c45c294721f655f3d0b85477333209b487ecef1", size = 5551017, upload-time = "2026-07-19T05:19:47.046Z" },
- { url = "https://files.pythonhosted.org/packages/41/ad/18b4540fb276f9b540018efe024aca0801acfe4209417d4faed85bccdb04/pyqwest-0.7.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:005ddd2a777d30ca7ce4de12df1336760e14d46394ab56299a9e81626d78b991", size = 5493032, upload-time = "2026-07-19T05:19:49.038Z" },
- { url = "https://files.pythonhosted.org/packages/6c/91/f25477eb80c375378a876cf2bac80c55ec9ea36b94bd7d4b2b2931860c85/pyqwest-0.7.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ca02089249c292ab9c148fa86c06927701897090226a13e392a6ec53312380ea", size = 5712503, upload-time = "2026-07-19T05:19:50.542Z" },
- { url = "https://files.pythonhosted.org/packages/f4/63/c5be988c55c69c87de950e3dabab322f82a78dc7c2ebdf89af32626bd473/pyqwest-0.7.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:da3bc117c1380e9577994da15b8236f7c3bb400111d6be4b57a9b2e4f30c9a79", size = 5893782, upload-time = "2026-07-19T05:19:52.286Z" },
- { url = "https://files.pythonhosted.org/packages/82/a7/96144e6db9a49eb5e42734562ac5d387c2b78fe1142674d3a284ce188ef7/pyqwest-0.7.0-cp314-cp314t-win_amd64.whl", hash = "sha256:a599ddac7ded32ed62d15ca90bc9c77652ba34b225cf17a404821cec92a189fa", size = 4744187, upload-time = "2026-07-19T05:19:53.921Z" },
- { url = "https://files.pythonhosted.org/packages/ed/42/26cf547b2e43078b4663e717715a289f31fc873d65d45cf354f364faa744/pyqwest-0.7.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:bebc51e3c9c6339d81964c6e60516a5f5c9fe793c82da57ef7c2d87a55741829", size = 5170766, upload-time = "2026-07-19T05:19:55.472Z" },
- { url = "https://files.pythonhosted.org/packages/dc/bc/1aac42f34bd3e5ac4c13a2c267dba6bda4bdea594ff96c7851dff930c8f1/pyqwest-0.7.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:37623b492aea7ccd3b6cfe3179110643d28c2cdc83c765aac3d207b4321995d2", size = 5053361, upload-time = "2026-07-19T05:19:56.973Z" },
- { url = "https://files.pythonhosted.org/packages/0d/59/e3d8cfd2c7be0e12773ee4f767efc03be50ccdd28c6155d0b176bf1d8a9a/pyqwest-0.7.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:02ff96a7746de208a4b8c78abe780c413d66576146a4ec64efd348b0c8a8328c", size = 5573900, upload-time = "2026-07-19T05:19:58.536Z" },
- { url = "https://files.pythonhosted.org/packages/39/a4/7dd4d548be6d54b195d737164dc67c39d9c5df40aa76a873fe1d2d9b4426/pyqwest-0.7.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd2e9bfa81198db7023202962a94920986a9a3dd12fe2f9d310f0cfcdddc092c", size = 5510692, upload-time = "2026-07-19T05:20:00.015Z" },
- { url = "https://files.pythonhosted.org/packages/48/13/c070baf81da8653803328b632baddb5647b66cc7c6353c58f024ca82277c/pyqwest-0.7.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:e1548708dbeb29a60db199c70b9e93733d6b334e7efa1dfa5e3846a4f890db6d", size = 5735516, upload-time = "2026-07-19T05:20:01.487Z" },
- { url = "https://files.pythonhosted.org/packages/84/46/e0f2a02ebf504db6bdf4bf343f0d3362eccf8dd5a325382fab1305fa7022/pyqwest-0.7.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:4bb3cf0975ee829b6c76e1c42f01863122ce71b1a952e507e260a9d29eb9b183", size = 5916743, upload-time = "2026-07-19T05:20:03.132Z" },
- { url = "https://files.pythonhosted.org/packages/07/7c/4a35df79a142e5fcb5f46fce2d1d70dd72325a65db4139bbba4fbed0d9b9/pyqwest-0.7.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:2ea1ce4d630c92cb2cc6b3bf91ada0053b051dfd5c0662d89957ebd829cfdcce", size = 4759967, upload-time = "2026-07-19T05:20:04.837Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/8d/59/97531fd9d0a06d54e84f5493775739b0c1d0d13ec704974d04fa423a3332/pyqwest-0.9.0.tar.gz", hash = "sha256:514dd0b37d7a1bcb978b5d6423d15f89cf7dcf8058ac2a37aa42cd30090de89e", size = 477462, upload-time = "2026-08-10T01:55:36.219Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/47/34/d556fa07d9bff21fc6c9c16738614c6336164b65d9ced1ce9f1c1044aaeb/pyqwest-0.9.0-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:517d2eb295d56ef1530cebe0cf290a66fa199c57955bd1c5f1dc592240fbb7d6", size = 5224594, upload-time = "2026-08-10T01:54:18.646Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/3f/1d7d1a08ebf8838c0c85e99ab5db5c1aae457f76ee03b60c8f4fc4948e01/pyqwest-0.9.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:408dc692835363b6824bee61ee9e4c9a5bba9c08d75b903f82f9a802e41d1b30", size = 5100753, upload-time = "2026-08-10T01:54:20.669Z" },
+ { url = "https://files.pythonhosted.org/packages/66/fe/22c4056b526baa4c2c953f4e99925ce0bb14e7747d66e6ac3448a34f76e5/pyqwest-0.9.0-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1abf1ab3a0c1b545651ab37a643acc7909c4e7644a63a2e4af36e3e230a0db5", size = 5619882, upload-time = "2026-08-10T01:54:22.468Z" },
+ { url = "https://files.pythonhosted.org/packages/de/2c/8f1159a30bbc905b2fcbc386740a260e76ae64372feb263103438ef5201c/pyqwest-0.9.0-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9b02e5c9ce57e079eb3716c464d3818ad2573d7743483c39526ad77ee95af806", size = 5564744, upload-time = "2026-08-10T01:54:24.814Z" },
+ { url = "https://files.pythonhosted.org/packages/ac/fd/ff15034d7874fd208d606bd80c924fb0b1091db8159c892672168b656de1/pyqwest-0.9.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:98bdaa30a3a8d8c71506a33c084e485a243fbf51e77130bb39e0f249dd116142", size = 5779373, upload-time = "2026-08-10T01:54:26.753Z" },
+ { url = "https://files.pythonhosted.org/packages/ed/b5/eeafdeb65ad8fe9c39044aedcfc97610f4e5c7b5620ca9fe2d504f669108/pyqwest-0.9.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:10eba84f9d8512d23bd16dd60b1c77dab956470361559214981dda065df4ad1a", size = 5973306, upload-time = "2026-08-10T01:54:28.729Z" },
+ { url = "https://files.pythonhosted.org/packages/34/db/a8979dab5c591529f858d1505d09b3c8b6dec337921f15bed4858c55716e/pyqwest-0.9.0-cp310-abi3-win_amd64.whl", hash = "sha256:af4e859800b02cd1fcdd898af26a881c4a8ce9520f71f6cb0a5403523d2cbbdf", size = 4834706, upload-time = "2026-08-10T01:54:30.335Z" },
+ { url = "https://files.pythonhosted.org/packages/1d/9e/d070ca1ce3c202952770436172889a4b0556a564a490baf726f7bb895eba/pyqwest-0.9.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:abe322cc1b63947b493bc06028615e0d5de655928159227aab64f60a0eb0e27d", size = 5244745, upload-time = "2026-08-10T01:54:32.257Z" },
+ { url = "https://files.pythonhosted.org/packages/41/97/ebded0bb35a79f51bb2d1519e34922d79c8825f9e71b696bb20f387a08c2/pyqwest-0.9.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c6b2dc6a9c583859d031941e1041b8e711afe0ad4c130628207731cef2b1a486", size = 5101044, upload-time = "2026-08-10T01:54:34.088Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/2c/a7f117e793b4e27642807bf7230b9fa297ff1e1ac489fc260fc3d4350ae4/pyqwest-0.9.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:551e47714da72a72939958029eb37a754cecd974344471c4a2038583a66a5396", size = 5630841, upload-time = "2026-08-10T01:54:35.885Z" },
+ { url = "https://files.pythonhosted.org/packages/b4/b4/be47fc141529941352a848cd77da581803137b733993a51bf464f2c48915/pyqwest-0.9.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3be3d38ccdab3077bf1cfe90c346ce927f9b49c56dcdf20e060f5f2502d01021", size = 5572909, upload-time = "2026-08-10T01:54:37.653Z" },
+ { url = "https://files.pythonhosted.org/packages/cb/fd/703635e12710ce7ef5e961f5e1b22c609aecc8f07eedd79477b48d1edb74/pyqwest-0.9.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:45d9d424da878b22604799d1ce2a0a5df054924487ee5a851ad08025e2076e5c", size = 5794049, upload-time = "2026-08-10T01:54:39.363Z" },
+ { url = "https://files.pythonhosted.org/packages/3c/15/941aad56b108c743df9d41e124be82ecb6be0eba1007e945b6a39f5dd1a0/pyqwest-0.9.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e4420adcd2b756da706b31a04f095a521f6e440dab284b7a1b46c76e048c1f78", size = 5974542, upload-time = "2026-08-10T01:54:41.202Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/86/8445fe05b47322047347464a909ae95dba023bf8409b9967f66bda2905ad/pyqwest-0.9.0-cp312-cp312-win_amd64.whl", hash = "sha256:25734bd9798bbfaa53c83d395649dd9ea9a791a64b9848734955cb78ad52c832", size = 4847034, upload-time = "2026-08-10T01:54:42.899Z" },
+ { url = "https://files.pythonhosted.org/packages/a7/92/013fc3c94f0dc4eeca556431797da477d76ad43d69134837ba149468dcc3/pyqwest-0.9.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:6e4c2afe6c7293d9e42cfdb0489b0b5f64002159c2dc9c45d9322c1b4ffb42cd", size = 5244793, upload-time = "2026-08-10T01:54:44.891Z" },
+ { url = "https://files.pythonhosted.org/packages/48/61/c685e0c595f3f1b7842a776c48aaf2b3f47270a61672967d9d38f7c5e7f6/pyqwest-0.9.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:67f153b94dfbb9aeabc38f20a1bada1acfd9361bec12db86268bd951be35a154", size = 5100715, upload-time = "2026-08-10T01:54:46.777Z" },
+ { url = "https://files.pythonhosted.org/packages/f9/a1/a28b2cd704d7dd37043f1e6b398798576c12293f3efae84f00e7f6a5625c/pyqwest-0.9.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b9942ffa243c8c2243e3ce04e3e3ec9b4c119346c963fd0051cd989f0defecf6", size = 5628787, upload-time = "2026-08-10T01:54:48.488Z" },
+ { url = "https://files.pythonhosted.org/packages/36/31/6255c7f17cd00e39f1c4df3003cea2d2d087e483fb4c49a6535307cd21e0/pyqwest-0.9.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f8f9c880c19826fead1838e12b042865b15df3ec844928cc74188a8b740f761", size = 5571946, upload-time = "2026-08-10T01:54:50.181Z" },
+ { url = "https://files.pythonhosted.org/packages/37/71/344738bdb38bddbc07cb29e5b1287c08db9e53d6b322581492571bdef748/pyqwest-0.9.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:56040761f6ca7abb036c7d288863bf143a9b166d824d98a604908ef20c6906e0", size = 5792872, upload-time = "2026-08-10T01:54:52.045Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/ee/c5c74e3afb6dd0a25bca23bb4757d1a7135fab09a0a054036e837d49dd11/pyqwest-0.9.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:02a51df744521e45eb5379bc325b91de4512ec64a9f4aba3248f9166ec4e5b88", size = 5974192, upload-time = "2026-08-10T01:54:53.818Z" },
+ { url = "https://files.pythonhosted.org/packages/6e/08/302960836e3e43ca3051313ee3b767534d1610bd3b8033c7bbad41b06e1b/pyqwest-0.9.0-cp313-cp313-win_amd64.whl", hash = "sha256:e9a0e3123aee446d5f6e57c43cae87b4dab4b1af3fa970d114d74d5d4b9d075c", size = 4847050, upload-time = "2026-08-10T01:54:56.155Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/3e/a36940844325fbc59adf92116d3bcd1155cc2c72d1a390880886ca492bb4/pyqwest-0.9.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:fdab21bbedff4a21209135423f5f54f287a01dd6143cbd7aeab63d5d8c889654", size = 5246741, upload-time = "2026-08-10T01:54:57.697Z" },
+ { url = "https://files.pythonhosted.org/packages/41/8d/efb9741449a81f2489f6929a7691a2145662c3650e06bcb139c64f543d0a/pyqwest-0.9.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:21a04ddf4497ef3c7fe36cdc473c094999b7710005d38bd8a0dfd4a3feace12f", size = 5102423, upload-time = "2026-08-10T01:54:59.253Z" },
+ { url = "https://files.pythonhosted.org/packages/8f/a8/0b667cf9c07e62861cfe24c09ad30357a9c2a0fc3863cfc5610af5b66e3e/pyqwest-0.9.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c8c51c1a27ea529fffab90c127a045f0dfe1abc54d5b9ad5f4165e954439c9b2", size = 5627663, upload-time = "2026-08-10T01:55:01.036Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/7c/1f88be3d35afe92b79e361aa40faf3904e3a7852e8638a9d3d5c00891ab3/pyqwest-0.9.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10f283ffc40a2774e0dc8fbb47e4a8f9f8a698a99feae3bf4ad75b340c98031b", size = 5572750, upload-time = "2026-08-10T01:55:03.163Z" },
+ { url = "https://files.pythonhosted.org/packages/21/3e/98c1e151772e77dcf00cb8b1c070f2c8edcb15fe12fdee30c1022006ca8e/pyqwest-0.9.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1f73d4a8e75b5860741fbd0623a0ce792a53336dbfec5f34736004acd5446843", size = 5790615, upload-time = "2026-08-10T01:55:04.758Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/f1/12bb4b119cffb7fe5301b2d997ec9ffc1719637f6f4faf2ff2315e13b201/pyqwest-0.9.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e34d55a53492b44b82b690c2b11957fc35e99ebab4db2e9bcb2a1e2621d71b62", size = 5976516, upload-time = "2026-08-10T01:55:06.453Z" },
+ { url = "https://files.pythonhosted.org/packages/53/55/046dbf68ccedd816770fd212c6c2612372a6f0d7ecf2d8273480db460ddf/pyqwest-0.9.0-cp314-cp314-win_amd64.whl", hash = "sha256:48c367150783f6866d0af43c209cc405f8287743d7b2472c7d757fda2478fd57", size = 4841470, upload-time = "2026-08-10T01:55:08.035Z" },
+ { url = "https://files.pythonhosted.org/packages/55/cd/38ff77d145385afd71b2dbd6eb116251ce3ffddbed0edde16c64394fbec2/pyqwest-0.9.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:10fae206270355c993b49c49bf9778995167f5efe591807d50a8e682921d71ea", size = 5222689, upload-time = "2026-08-10T01:55:09.639Z" },
+ { url = "https://files.pythonhosted.org/packages/82/95/d8c6804eeb72b7b89842b58f1f05d5cfda5be410c4a22442d2574d510d39/pyqwest-0.9.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5f475129fb792593222a9ce0fefbbc10bda1544a7411f3946d771c9a61c50e61", size = 5085846, upload-time = "2026-08-10T01:55:11.569Z" },
+ { url = "https://files.pythonhosted.org/packages/f2/e7/04fe8962ec416be0199093ebdd326653a5a7b8f53ddfdb29af81756f7c08/pyqwest-0.9.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78f6f676d349535cb094e8e3bcf33863238a142fb7dcc7afb9e61749e2351047", size = 5613296, upload-time = "2026-08-10T01:55:13.315Z" },
+ { url = "https://files.pythonhosted.org/packages/03/0c/7a11728155a34838d2e7c78fb24c937f2cd844ec791ef416030c52f4bb5e/pyqwest-0.9.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f460f5fcdae8cc46e6a679128836f6cd47fbf4bf73e5c9d6ea868e4a90b2e7ee", size = 5557492, upload-time = "2026-08-10T01:55:15.103Z" },
+ { url = "https://files.pythonhosted.org/packages/4a/d5/8c6e68f0e978b5257b309809fec00d946c1ed20dacef97f25c23de5b91a9/pyqwest-0.9.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:cba6804151e973d27c99b9f02b3f0bcab7270c3f99725b508ada9c147365cabd", size = 5774204, upload-time = "2026-08-10T01:55:16.932Z" },
+ { url = "https://files.pythonhosted.org/packages/17/20/fed89b62d50b4efad2ebe78c3867e0e402f824726652034728a5dd0a342e/pyqwest-0.9.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:bc9dfeca326918d70a5368114de0fc627d9f64fafa36563ab484ae58ffe42c0d", size = 5964506, upload-time = "2026-08-10T01:55:19.031Z" },
+ { url = "https://files.pythonhosted.org/packages/11/de/30575019efebae84502269d097e706e89a30631e3719218b053e4e0dc179/pyqwest-0.9.0-cp314-cp314t-win_amd64.whl", hash = "sha256:384693adc0908f16324e5b508a3c25fb9a92b88f9bdf7ccb6820507db4a95888", size = 4809013, upload-time = "2026-08-10T01:55:21.042Z" },
+ { url = "https://files.pythonhosted.org/packages/d0/4e/46822676c7cfafbf510f2af84b510b6f3dc1f3c4df781a837ff75c7410fc/pyqwest-0.9.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:0c174d8ebde256c457f455dcdedf59446528d84874cb5967041be0d1bda05929", size = 5227559, upload-time = "2026-08-10T01:55:22.625Z" },
+ { url = "https://files.pythonhosted.org/packages/cc/80/9d98ad770043e5dd3ad7b765f2acf911bd11b113e0280565277d2e707864/pyqwest-0.9.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d5e56192b03bca7ec511c9af4ed80fa10fc1c1871d0ccfe49050632785b46099", size = 5109747, upload-time = "2026-08-10T01:55:24.393Z" },
+ { url = "https://files.pythonhosted.org/packages/36/95/d1a88c8115c88f843b907e3d3bd1958eaef851cca023a47bba4257d974d9/pyqwest-0.9.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b3fa3c93638fc645c7c626fe83032f53972673581878bd85702842f41665ad6c", size = 5631597, upload-time = "2026-08-10T01:55:26.19Z" },
+ { url = "https://files.pythonhosted.org/packages/5c/3a/e568f9cf9ff75ca45ce7323ac916d076f9f4df4e957404ff0f0d3286dbe0/pyqwest-0.9.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:869d1c630cbff38510207c5b57139f319acca21ed978f9ce6648fcd868df5fbd", size = 5573130, upload-time = "2026-08-10T01:55:28.351Z" },
+ { url = "https://files.pythonhosted.org/packages/0a/c9/a261dbf9a4fd3cfa790221957c5cbe0d52e75ff7403dd91254aa977164b1/pyqwest-0.9.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:a0bc2ba9b6d3103c6f0cce59cca9e2e294d1707bca435b471a1917db73010801", size = 5794377, upload-time = "2026-08-10T01:55:30.684Z" },
+ { url = "https://files.pythonhosted.org/packages/0b/a4/389a32479767cba432451f2913ff55bcab13981c5cf561028aa54ba97ae1/pyqwest-0.9.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:bfb04e3e91166fe6e4eecdcfccb0b2490da7629984b7988cfd4b11daa1dbb616", size = 5977476, upload-time = "2026-08-10T01:55:32.51Z" },
+ { url = "https://files.pythonhosted.org/packages/14/26/91891131d47e1d9ad652ae6ff010bc9169ab051f20d888cd3471d87f070c/pyqwest-0.9.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:fbff11bbffb572c084ccd76048c40bd57976b255d34f59280e56626f556cfaeb", size = 4833070, upload-time = "2026-08-10T01:55:34.506Z" },
]
[[package]]