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

Swap the httpx-native HTTPTransport/AsyncHTTPTransport under the generated
REST API client for pyqwest (Rust reqwest/hyper) via pyqwest.httpx. The
httpx client surface is unchanged; the transports are now thread-safe and
loop-independent, so the pool is cached process-wide per proxy. Strip the
Host header httpx adds — forwarding it on HTTP/2 makes the API edge reset
the stream with PROTOCOL_ERROR. envd traffic and the volume content client
stay on httpx (the streaming download path needs httpx's per-read idle
timeout, which the adapter's whole-request deadline can't express).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: mishushakov

.changeset/python-pyqwest-rest-transport.md

@@ -0,0 +1,25 @@
+---
+"@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, per-request timeouts, and headers behave as before.
+
+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).
+Connection-establishment failures are retried with backoff
+(`E2B_CONNECTION_RETRIES`, default 3), matching the connect-only retries of
+the previous transports.
+
+`proxy` for API calls must now be a URL string (e.g.
+`proxy="http://user:pass@localhost:8030"`, scheme http, https, socks5, or
+socks5h); the richer `httpx.Proxy` objects are rejected with
+`InvalidArgumentException` rather than partially honored.
+
+envd traffic (sandbox commands, filesystem, PTY, file transfers) is not
+affected and stays on its existing stack.

packages/python-sdk/e2b/api/__init__.py

@@ -11,13 +11,15 @@
 
 import httpx
 from httpx import AsyncBaseTransport, BaseTransport, Limits, Timeout
+from httpx._types import ProxyTypes
 
 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.exceptions import (
     AuthenticationException,
+    InvalidArgumentException,
     RateLimitException,
     SandboxException,
 )
@@ -70,6 +72,32 @@ async def on_response(response: Response) -> None:
 
 connection_retries = int(os.getenv("E2B_CONNECTION_RETRIES", "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")
+
+
+def proxy_to_url(proxy: Optional[ProxyTypes]) -> Optional[str]:
+    """Narrow the ``proxy`` connection option to the proxy URL string pyqwest
+    transports take (scheme http, https, socks5, or socks5h, credentials in
+    the URL userinfo). The richer ``httpx.Proxy`` objects the httpx transports
+    accepted (per-proxy auth, headers, TLS context) are rejected rather than
+    partially honored."""
+    if proxy is None:
+        return None
+    if isinstance(proxy, str):
+        return proxy
+    if isinstance(proxy, httpx.URL):
+        return str(proxy)
+    raise InvalidArgumentException(
+        "E2B API calls support only URL-string proxies, "
+        'e.g. proxy="http://user:pass@localhost:8030"'
+    )
+
 
 @dataclass
 class SandboxCreateResponse:

packages/python-sdk/e2b/api/client_async/__init__.py

@@ -1,12 +1,23 @@
 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 pyqwest import HTTPTransport, Request, Response
+from pyqwest.httpx import AsyncPyqwestTransport
+from pyqwest.middleware.retry import RetryTransport
+
+from e2b.api import (
+    AsyncApiClient,
+    connection_retries,
+    limits,
+    pool_idle_timeout,
+    pool_max_idle_per_host,
+    proxy_to_url,
+)
 from e2b.connection_config import ConnectionConfig
 
 TransportKey = Tuple[bool, Optional[ProxyTypes]]
@@ -20,31 +31,92 @@ def get_api_client(config: ConnectionConfig, **kwargs) -> AsyncApiClient:
     )
 
 
-class AsyncTransportWithLogger(httpx.AsyncHTTPTransport):
+class AsyncApiPyqwestTransport(AsyncPyqwestTransport):
+    """Strip the ``Host`` header httpx adds to every request: hyper derives
+    HTTP/1 ``Host`` and HTTP/2 ``:authority`` from the URL itself, and
+    forwarding an explicit ``host`` header on an HTTP/2 connection makes the
+    E2B API edge reset the stream with PROTOCOL_ERROR. (Custom ``Host``
+    overrides are therefore not honored, matching hyper's URL-derived
+    behavior.)"""
+
+    async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
+        if "host" in request.headers:
+            del request.headers["host"]
+        return await super().handle_async_request(request)
+
+
+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[str], "AsyncApiPyqwestTransport"] = {}
+
+
+def get_transport(config: ConnectionConfig) -> "AsyncApiPyqwestTransport":
+    """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."""
+    proxy_url = proxy_to_url(config.proxy)
+    with _transport_lock:
+        transport = _transports.get(proxy_url)
+        if transport is None:
+            transport = AsyncApiPyqwestTransport(
+                ConnectionRetryTransport(
+                    HTTPTransport(
+                        tls_include_system_certs=True,
+                        proxy=proxy_url,
+                        pool_idle_timeout=pool_idle_timeout,
+                        pool_max_idle_per_host=pool_max_idle_per_host,
+                    ),
+                    max_retries=connection_retries,
+                )
+            )
+            _transports[proxy_url] = 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
     def pool(self):
         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 +125,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)

packages/python-sdk/e2b/api/client_sync/__init__.py

@@ -1,11 +1,21 @@
-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 pyqwest import SyncHTTPTransport, SyncRequest, SyncResponse
+from pyqwest.httpx import PyqwestTransport
+from pyqwest.middleware.retry import SyncRetryTransport
+
+from e2b.api import (
+    ApiClient,
+    connection_retries,
+    limits,
+    pool_idle_timeout,
+    pool_max_idle_per_host,
+    proxy_to_url,
+)
 from e2b.connection_config import ConnectionConfig
 
 TransportKey = Tuple[bool, Optional[ProxyTypes]]
@@ -19,38 +29,72 @@ def get_api_client(config: ConnectionConfig, **kwargs) -> ApiClient:
     )
 
 
-class TransportWithLogger(httpx.HTTPTransport):
+class ApiPyqwestTransport(PyqwestTransport):
+    """Strip the ``Host`` header httpx adds to every request: hyper derives
+    HTTP/1 ``Host`` and HTTP/2 ``:authority`` from the URL itself, and
+    forwarding an explicit ``host`` header on an HTTP/2 connection makes the
+    E2B API edge reset the stream with PROTOCOL_ERROR. (Custom ``Host``
+    overrides are therefore not honored, matching hyper's URL-derived
+    behavior.)"""
+
+    def handle_request(self, request: httpx.Request) -> httpx.Response:
+        if "host" in request.headers:
+            del request.headers["host"]
+        return super().handle_request(request)
+
+
+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[str], "ApiPyqwestTransport"] = {}
+
+
+def get_transport(config: ConnectionConfig) -> "ApiPyqwestTransport":
+    """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."""
+    proxy_url = proxy_to_url(config.proxy)
+    with _transport_lock:
+        transport = _transports.get(proxy_url)
+        if transport is None:
+            transport = ApiPyqwestTransport(
+                ConnectionRetryTransport(
+                    SyncHTTPTransport(
+                        tls_include_system_certs=True,
+                        proxy=proxy_url,
+                        pool_idle_timeout=pool_idle_timeout,
+                        pool_max_idle_per_host=pool_max_idle_per_host,
+                    ),
+                    max_retries=connection_retries,
+                )
+            )
+            _transports[proxy_url] = transport
+        return transport
+
+
+class EnvdTransportWithLogger(httpx.HTTPTransport):
     _thread_local = threading.local()
 
     @property
     def pool(self):
         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:

packages/python-sdk/pyproject.toml

@@ -18,6 +18,7 @@ dependencies = [
     "typing-extensions>=4.1.0",
     "dockerfile-parse>=2.0.1,<3",
     "rich>=14.0.0",
+    "pyqwest>=0.7.0,<0.8",
 ]
 
 [project.urls]