e2b 2.28.0__tar.gz → 2.28.2__tar.gz

{e2b-2.28.0 → e2b-2.28.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: e2b
-Version: 2.28.0
+Version: 2.28.2
 Summary: E2B SDK that give agents cloud environments
 License: MIT
 Author: e2b

{e2b-2.28.0 → e2b-2.28.2}/e2b/api/__init__.py

@@ -1,12 +1,15 @@
+import asyncio
 import json
 import logging
 import os
 import re
+import threading
 from dataclasses import dataclass
 from types import TracebackType
-from typing import Optional, Protocol, Union
+from typing import Callable, Dict, Optional, Protocol, Union
 
-from httpx import AsyncBaseTransport, BaseTransport, Limits
+import httpx
+from httpx import AsyncBaseTransport, BaseTransport, Limits, Timeout
 
 from e2b.api.client.client import AuthenticatedClient
 from e2b.api.client.types import Response
@@ -102,9 +105,22 @@ class ApiClient(AuthenticatedClient):
         require_api_key: bool = True,
         require_access_token: bool = False,
         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()
+        self._async_clients: Dict[int, httpx.AsyncClient] = {}
+        self._proxy = config.proxy
+
         if require_api_key and require_access_token:
             raise AuthenticationException(
                 "Only one of api_key or access_token can be required, not both",
@@ -157,11 +173,20 @@ class ApiClient(AuthenticatedClient):
                 "request": [self._log_request],
                 "response": [self._log_response],
             },
-            "transport": transport,
         }
-        if transport is None:
+        if transport is not None:
+            httpx_args["transport"] = transport
+        if (
+            transport is None
+            and transport_factory is None
+            and async_transport_factory is None
+        ):
             httpx_args["proxy"] = config.proxy
 
+        # config.request_timeout is None when the timeout is explicitly
+        # disabled (request_timeout=0), which httpx.Timeout(None) preserves.
+        kwargs.setdefault("timeout", Timeout(config.request_timeout))
+
         super().__init__(
             base_url=config.api_url,
             httpx_args=httpx_args,
@@ -173,6 +198,53 @@ class ApiClient(AuthenticatedClient):
             **kwargs,
         )
 
+    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_id = id(asyncio.get_running_loop())
+        client = self._async_clients.get(loop_id)
+        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_id] = client
+        return client
+
     def _log_request(self, request):
         logger.info(f"Request {request.method} {request.url}")
 

{e2b-2.28.0 → e2b-2.28.2}/e2b/api/client_async/__init__.py

@@ -1,25 +1,29 @@
 import asyncio
 import logging
-from typing import Dict, Tuple
+from typing import Dict, Optional, Tuple
 
 import httpx
 
+from httpx._types import ProxyTypes
+
 from e2b.api import AsyncApiClient, limits
 from e2b.connection_config import ConnectionConfig
 
 logger = logging.getLogger(__name__)
 
+TransportKey = Tuple[int, bool, Optional[ProxyTypes]]
+
 
 def get_api_client(config: ConnectionConfig, **kwargs) -> AsyncApiClient:
     return AsyncApiClient(
         config,
-        transport=get_transport(config),
+        async_transport_factory=lambda: get_transport(config),
         **kwargs,
     )
 
 
 class AsyncTransportWithLogger(httpx.AsyncHTTPTransport):
-    _instances: Dict[Tuple[int, bool], "AsyncTransportWithLogger"] = {}
+    _instances: Dict[TransportKey, "AsyncTransportWithLogger"] = {}
 
     async def handle_async_request(self, request):
         url = f"{request.url.scheme}://{request.url.host}{request.url.path}"
@@ -39,10 +43,10 @@ class AsyncTransportWithLogger(httpx.AsyncHTTPTransport):
 def get_transport(
     config: ConnectionConfig, http2: bool = True
 ) -> AsyncTransportWithLogger:
-    loop_id = (id(asyncio.get_running_loop()), http2)
+    key: TransportKey = (id(asyncio.get_running_loop()), http2, config.proxy)
 
-    if loop_id in AsyncTransportWithLogger._instances:
-        return AsyncTransportWithLogger._instances[loop_id]
+    if key in AsyncTransportWithLogger._instances:
+        return AsyncTransportWithLogger._instances[key]
 
     transport = AsyncTransportWithLogger(
         limits=limits,
@@ -50,21 +54,21 @@ def get_transport(
         http2=http2,
     )
 
-    AsyncTransportWithLogger._instances[loop_id] = transport
+    AsyncTransportWithLogger._instances[key] = transport
     return transport
 
 
 class AsyncEnvdTransportWithLogger(AsyncTransportWithLogger):
-    _instances: Dict[Tuple[int, bool], "AsyncEnvdTransportWithLogger"] = {}
+    _instances: Dict[TransportKey, "AsyncEnvdTransportWithLogger"] = {}
 
 
 def get_envd_transport(
     config: ConnectionConfig, http2: bool = True
 ) -> AsyncEnvdTransportWithLogger:
-    loop_id = (id(asyncio.get_running_loop()), http2)
+    key: TransportKey = (id(asyncio.get_running_loop()), http2, config.proxy)
 
-    if loop_id in AsyncEnvdTransportWithLogger._instances:
-        return AsyncEnvdTransportWithLogger._instances[loop_id]
+    if key in AsyncEnvdTransportWithLogger._instances:
+        return AsyncEnvdTransportWithLogger._instances[key]
 
     transport = AsyncEnvdTransportWithLogger(
         limits=limits,
@@ -72,5 +76,5 @@ def get_envd_transport(
         http2=http2,
     )
 
-    AsyncEnvdTransportWithLogger._instances[loop_id] = transport
+    AsyncEnvdTransportWithLogger._instances[key] = transport
     return transport

{e2b-2.28.0 → e2b-2.28.2}/e2b/api/client_sync/__init__.py

@@ -1,19 +1,23 @@
-from typing import Dict
+from typing import Dict, Optional, Tuple
 
 import httpx
 import logging
 import threading
 
+from httpx._types import ProxyTypes
+
 from e2b.api import ApiClient, limits
 from e2b.connection_config import ConnectionConfig
 
 logger = logging.getLogger(__name__)
 
+TransportKey = Tuple[bool, Optional[ProxyTypes]]
+
 
 def get_api_client(config: ConnectionConfig, **kwargs) -> ApiClient:
     return ApiClient(
         config,
-        transport=get_transport(config),
+        transport_factory=lambda: get_transport(config),
         **kwargs,
     )
 
@@ -37,10 +41,11 @@ class TransportWithLogger(httpx.HTTPTransport):
 
 
 def get_transport(config: ConnectionConfig, http2: bool = True) -> TransportWithLogger:
-    instances: Dict[bool, TransportWithLogger] = getattr(
+    instances: Dict[TransportKey, TransportWithLogger] = getattr(
         TransportWithLogger._thread_local, "instances", {}
     )
-    cached = instances.get(http2)
+    key: TransportKey = (http2, config.proxy)
+    cached = instances.get(key)
     if cached is not None:
         return cached
 
@@ -49,7 +54,7 @@ def get_transport(config: ConnectionConfig, http2: bool = True) -> TransportWith
         proxy=config.proxy,
         http2=http2,
     )
-    instances[http2] = transport
+    instances[key] = transport
     TransportWithLogger._thread_local.instances = instances
     return transport
 
@@ -61,10 +66,11 @@ class EnvdTransportWithLogger(TransportWithLogger):
 def get_envd_transport(
     config: ConnectionConfig, http2: bool = True
 ) -> EnvdTransportWithLogger:
-    instances: Dict[bool, EnvdTransportWithLogger] = getattr(
+    instances: Dict[TransportKey, EnvdTransportWithLogger] = getattr(
         EnvdTransportWithLogger._thread_local, "instances", {}
     )
-    cached = instances.get(http2)
+    key: TransportKey = (http2, config.proxy)
+    cached = instances.get(key)
     if cached is not None:
         return cached
 
@@ -73,6 +79,6 @@ def get_envd_transport(
         proxy=config.proxy,
         http2=http2,
     )
-    instances[http2] = transport
+    instances[key] = transport
     EnvdTransportWithLogger._thread_local.instances = instances
     return transport

{e2b-2.28.0 → e2b-2.28.2}/e2b/connection_config.py

@@ -95,7 +95,7 @@ class ConnectionConfig:
         proxy: Optional[ProxyTypes] = None,
     ):
         self.domain = domain or ConnectionConfig._domain()
-        self.debug = debug or ConnectionConfig._debug()
+        self.debug = debug if debug is not None else ConnectionConfig._debug()
         self.api_key = api_key or ConnectionConfig._api_key()
         self.access_token = access_token or ConnectionConfig._access_token()
         self.headers = {**(headers or {}), **(api_headers or {})}

{e2b-2.28.0 → e2b-2.28.2}/e2b/sandbox_sync/commands/command.py

@@ -1,8 +1,9 @@
+import threading
 from typing import Callable, Dict, List, Literal, Optional, Union, overload
 
 import e2b_connect
-import httpcore
 from packaging.version import Version
+from e2b.api.client_sync import get_envd_transport
 from e2b.connection_config import (
     ConnectionConfig,
     Username,
@@ -27,20 +28,32 @@ class Commands:
         self,
         envd_api_url: str,
         connection_config: ConnectionConfig,
-        pool: httpcore.ConnectionPool,
         envd_version: Version,
     ) -> None:
+        self._envd_api_url = envd_api_url
         self._connection_config = connection_config
         self._envd_version = envd_version
-        self._rpc = process_connect.ProcessClient(
-            envd_api_url,
+        self._thread_local = threading.local()
+
+    def _create_rpc(self) -> process_connect.ProcessClient:
+        transport = get_envd_transport(self._connection_config)
+        return process_connect.ProcessClient(
+            self._envd_api_url,
             # TODO: Fix and enable compression again — the headers compression is not solved for streaming.
             # compressor=e2b_connect.GzipCompressor,
-            pool=pool,
+            pool=transport.pool,
             json=True,
-            headers=connection_config.sandbox_headers,
+            headers=self._connection_config.sandbox_headers,
         )
 
+    @property
+    def _rpc(self) -> process_connect.ProcessClient:
+        rpc = getattr(self._thread_local, "rpc", None)
+        if rpc is None:
+            rpc = self._create_rpc()
+            self._thread_local.rpc = rpc
+        return rpc
+
     def list(
         self,
         request_timeout: Optional[float] = None,

{e2b-2.28.0 → e2b-2.28.2}/e2b/sandbox_sync/commands/pty.py

@@ -1,9 +1,10 @@
 import e2b_connect
-import httpcore
+import threading
 
 from typing import Dict, Optional
 
 from packaging.version import Version
+from e2b.api.client_sync import get_envd_transport
 from e2b.envd.process import process_connect, process_pb2
 from e2b.connection_config import (
     Username,
@@ -26,20 +27,32 @@ class Pty:
         self,
         envd_api_url: str,
         connection_config: ConnectionConfig,
-        pool: httpcore.ConnectionPool,
         envd_version: Version,
     ) -> None:
+        self._envd_api_url = envd_api_url
         self._connection_config = connection_config
         self._envd_version = envd_version
-        self._rpc = process_connect.ProcessClient(
-            envd_api_url,
+        self._thread_local = threading.local()
+
+    def _create_rpc(self) -> process_connect.ProcessClient:
+        transport = get_envd_transport(self._connection_config)
+        return process_connect.ProcessClient(
+            self._envd_api_url,
             # TODO: Fix and enable compression again — the headers compression is not solved for streaming.
             # compressor=e2b_connect.GzipCompressor,
-            pool=pool,
+            pool=transport.pool,
             json=True,
-            headers=connection_config.sandbox_headers,
+            headers=self._connection_config.sandbox_headers,
         )
 
+    @property
+    def _rpc(self) -> process_connect.ProcessClient:
+        rpc = getattr(self._thread_local, "rpc", None)
+        if rpc is None:
+            rpc = self._create_rpc()
+            self._thread_local.rpc = rpc
+        return rpc
+
     def kill(
         self,
         pid: int,

{e2b-2.28.0 → e2b-2.28.2}/e2b/sandbox_sync/filesystem/filesystem.py

@@ -1,10 +1,11 @@
+import threading
 from typing import IO, Dict, Iterator, List, Literal, Optional, Union, overload
 
-import httpcore
 import httpx
 from packaging.version import Version
 
 import e2b_connect
+from e2b.api.client_sync import get_envd_transport
 from e2b.connection_config import (
     KEEPALIVE_PING_HEADER,
     KEEPALIVE_PING_INTERVAL_SEC,
@@ -71,24 +72,47 @@ class Filesystem:
         envd_api_url: str,
         envd_version: Version,
         connection_config: ConnectionConfig,
-        pool: httpcore.ConnectionPool,
-        envd_api: httpx.Client,
     ) -> None:
         self._envd_api_url = envd_api_url
         self._envd_version = envd_version
         self._connection_config = connection_config
-        self._pool = pool
-        self._envd_api = envd_api
+        self._thread_local = threading.local()
+
+    def _create_envd_api(self) -> httpx.Client:
+        transport = get_envd_transport(self._connection_config)
+        return httpx.Client(
+            base_url=self._envd_api_url,
+            transport=transport,
+            headers=self._connection_config.sandbox_headers,
+        )
 
-        self._rpc = filesystem_connect.FilesystemClient(
-            envd_api_url,
+    def _create_rpc(self) -> filesystem_connect.FilesystemClient:
+        transport = get_envd_transport(self._connection_config)
+        return filesystem_connect.FilesystemClient(
+            self._envd_api_url,
             # TODO: Fix and enable compression again — the headers compression is not solved for streaming.
             # compressor=e2b_connect.GzipCompressor,
-            pool=pool,
+            pool=transport.pool,
             json=True,
-            headers=connection_config.sandbox_headers,
+            headers=self._connection_config.sandbox_headers,
         )
 
+    @property
+    def _envd_api(self) -> httpx.Client:
+        envd_api = getattr(self._thread_local, "envd_api", None)
+        if envd_api is None:
+            envd_api = self._create_envd_api()
+            self._thread_local.envd_api = envd_api
+        return envd_api
+
+    @property
+    def _rpc(self) -> filesystem_connect.FilesystemClient:
+        rpc = getattr(self._thread_local, "rpc", None)
+        if rpc is None:
+            rpc = self._create_rpc()
+            self._thread_local.rpc = rpc
+        return rpc
+
     @overload
     def read(
         self,
@@ -579,4 +603,4 @@ class Filesystem:
         except Exception as e:
             raise _handle_filesystem_rpc_exception(e)
 
-        return WatchHandle(self._rpc, r.watcher_id)
+        return WatchHandle(lambda: self._rpc, r.watcher_id)

{e2b-2.28.0 → e2b-2.28.2}/e2b/sandbox_sync/filesystem/watch_handle.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import Callable, List
 
 from e2b import SandboxException
 from e2b.envd.filesystem import filesystem_connect
@@ -21,10 +21,10 @@ class WatchHandle:
 
     def __init__(
         self,
-        rpc: filesystem_connect.FilesystemClient,
+        get_rpc: Callable[[], filesystem_connect.FilesystemClient],
         watcher_id: str,
     ):
-        self._rpc = rpc
+        self._get_rpc = get_rpc
         self._watcher_id = watcher_id
         self._closed = False
 
@@ -34,7 +34,9 @@ class WatchHandle:
         After you stop the watcher you won't be able to get the events anymore.
         """
         try:
-            self._rpc.remove_watcher(RemoveWatcherRequest(watcher_id=self._watcher_id))
+            self._get_rpc().remove_watcher(
+                RemoveWatcherRequest(watcher_id=self._watcher_id)
+            )
         except Exception as e:
             raise handle_rpc_exception(e)
 
@@ -50,7 +52,7 @@ class WatchHandle:
             raise SandboxException("The watcher is already stopped")
 
         try:
-            r = self._rpc.get_watcher_events(
+            r = self._get_rpc().get_watcher_events(
                 GetWatcherEventsRequest(watcher_id=self._watcher_id)
             )
         except Exception as e:

{e2b-2.28.0 → e2b-2.28.2}/e2b/sandbox_sync/main.py

@@ -10,7 +10,6 @@ from packaging.version import Version
 from typing_extensions import Self, Unpack
 
 from e2b.api.client.types import Unset
-from e2b.api.client_sync import get_envd_transport as get_transport
 from e2b.connection_config import ApiParams, ConnectionConfig
 from e2b.envd.api import ENVD_API_HEALTH_ROUTE, handle_envd_api_exception
 from e2b.envd.versions import ENVD_DEBUG_FALLBACK
@@ -101,34 +100,27 @@ class Sandbox(SandboxApi):
         """
         super().__init__(**opts)
 
-        self._transport = get_transport(self.connection_config)
-
-        self._envd_api = httpx.Client(
-            base_url=self.envd_api_url,
-            transport=self._transport,
-            headers=self.connection_config.sandbox_headers,
-        )
         self._filesystem = Filesystem(
             self.envd_api_url,
             self._envd_version,
             self.connection_config,
-            self._transport.pool,
-            self._envd_api,
         )
         self._commands = Commands(
             self.envd_api_url,
             self.connection_config,
-            self._transport.pool,
             self._envd_version,
         )
         self._pty = Pty(
             self.envd_api_url,
             self.connection_config,
-            self._transport.pool,
             self._envd_version,
         )
         self._git = Git(self._commands)
 
+    @property
+    def _envd_api(self) -> httpx.Client:
+        return self._filesystem._envd_api
+
     def is_running(self, request_timeout: Optional[float] = None) -> bool:
         """
         Check if the sandbox is running.

{e2b-2.28.0 → e2b-2.28.2}/e2b/template_async/build_api.py

@@ -111,8 +111,14 @@ async def upload_file(
             file_name, context_path, ignore_patterns, resolve_symlinks
         )
 
-        client = api_client.get_async_httpx_client()
-        response = await client.put(url, content=tar_buffer.getvalue())
+        async with httpx.AsyncClient(
+            timeout=api_client._timeout,
+            verify=api_client._verify_ssl,
+            follow_redirects=api_client._follow_redirects,
+            proxy=getattr(api_client, "_proxy", None),
+            http2=False,
+        ) as client:
+            response = await client.put(url, content=tar_buffer.getvalue())
         response.raise_for_status()
     except httpx.HTTPStatusError as e:
         raise FileUploadException(f"Failed to upload file: {e}").with_traceback(

{e2b-2.28.0 → e2b-2.28.2}/e2b/template_sync/build_api.py

@@ -110,8 +110,14 @@ def upload_file(
         tar_buffer = tar_file_stream(
             file_name, context_path, ignore_patterns, resolve_symlinks
         )
-        client = api_client.get_httpx_client()
-        response = client.put(url, content=tar_buffer.getvalue())
+        with httpx.Client(
+            timeout=api_client._timeout,
+            verify=api_client._verify_ssl,
+            follow_redirects=api_client._follow_redirects,
+            proxy=getattr(api_client, "_proxy", None),
+            http2=False,
+        ) as client:
+            response = client.put(url, content=tar_buffer.getvalue())
         response.raise_for_status()
     except httpx.HTTPStatusError as e:
         raise FileUploadException(f"Failed to upload file: {e}").with_traceback(

{e2b-2.28.0 → e2b-2.28.2}/e2b_connect/client.py

@@ -361,7 +361,6 @@ class Client:
             },
         }
 
-    @_retry(RemoteProtocolError, 3)
     async def acall_server_stream(
         self,
         req,
@@ -395,7 +394,6 @@ class Client:
                 for parsed in parser.parse(chunk):
                     yield parsed
 
-    @_retry(RemoteProtocolError, 3)
     def call_server_stream(
         self,
         req,
@@ -479,7 +477,10 @@ class ServerStreamParser:
     def parse(self, chunk: bytes) -> Generator[Any, None, None]:
         self.buffer += chunk
 
-        while len(self.buffer) >= envelope_header_length:
+        # Once the header is consumed, the remaining payload can be shorter
+        # than the header length, so only require a full header when we still
+        # need to read one.
+        while self._header is not None or len(self.buffer) >= envelope_header_length:
             flags, data_len = self.header
 
             if data_len > len(self.buffer):

{e2b-2.28.0 → e2b-2.28.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "e2b"
-version = "2.28.0"
+version = "2.28.2"
 description = "E2B SDK that give agents cloud environments"
 authors = ["e2b <hello@e2b.dev>"]
 license = "MIT"