e2b-code-interpreter 2.8.0__tar.gz → 2.11.0__tar.gz

e2b_code_interpreter-2.11.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: e2b-code-interpreter
+Version: 2.11.0
+Summary: E2B Code Interpreter - Stateful code execution
+Author: e2b
+Author-email: e2b <hello@e2b.dev>
+License-Expression: MIT
+Requires-Dist: httpx>=0.20.0,<1.0.0
+Requires-Dist: attrs>=21.3.0
+Requires-Dist: e2b>=2.55.1,<3.0.0
+Requires-Python: >=3.11
+Project-URL: Homepage, https://e2b.dev/?utm_source=pypi&utm_medium=referral&utm_campaign=package_homepage&utm_content=e2b-code-interpreter
+Project-URL: Repository, https://github.com/e2b-dev/e2b/tree/main/packages/code-interpreter-python
+Project-URL: Bug Tracker, https://github.com/e2b-dev/e2b/issues
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/e2b-dev/E2B/refs/heads/main/readme-assets/logo-white.png">
+    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/e2b-dev/E2B/refs/heads/main/readme-assets/logo-black.png">
+    <img alt="E2B Logo" src="https://raw.githubusercontent.com/e2b-dev/E2B/refs/heads/main/readme-assets/logo-black.png" width="200">
+  </picture>
+</p>
+
+<h4 align="center">
+  <a href="https://pypi.org/project/e2b/">
+    <img alt="Last 1 month downloads for the Python SDK" loading="lazy" width="200" height="20" decoding="async" data-nimg="1"
+    style="color:transparent;width:auto;height:100%" src="https://img.shields.io/pypi/dm/e2b?label=PyPI%20Downloads">
+  </a>
+</h4>
+
+<!---
+<img width="100%" src="/readme-assets/preview.png" alt="Cover image">
+--->
+## What is E2B?
+[E2B](https://e2b.dev/?utm_source=pypi&utm_medium=referral&utm_campaign=readme&utm_content=code-interpreter) is an open-source infrastructure that allows you run to AI-generated code in secure isolated sandboxes in the cloud. To start and control sandboxes, use our [JavaScript SDK](https://www.npmjs.com/package/@e2b/code-interpreter) or [Python SDK](https://pypi.org/project/e2b_code_interpreter).
+
+Source: [packages/code-interpreter-python](https://github.com/e2b-dev/E2B/tree/main/packages/code-interpreter-python)
+
+## Run your first Sandbox
+
+### 1. Install SDK
+
+```
+pip install e2b-code-interpreter
+```
+
+### 2. Get your E2B API key
+1. Sign up to E2B [here](https://e2b.dev/?utm_source=pypi&utm_medium=referral&utm_campaign=readme&utm_content=code-interpreter).
+2. Get your API key [here](https://e2b.dev/dashboard?tab=keys&utm_source=pypi&utm_medium=referral&utm_campaign=readme&utm_content=code-interpreter).
+3. Set environment variable with your API key.
+```
+E2B_API_KEY=e2b_***
+```
+
+### 3. Execute code with code interpreter inside Sandbox
+
+```py
+from e2b_code_interpreter import Sandbox
+
+with Sandbox.create() as sandbox:
+    sandbox.run_code("x = 1")
+    execution = sandbox.run_code("x+=1; x")
+    print(execution.text)  # outputs 2
+```
+
+### 4. Bind the configuration to a client
+
+The top-level `Sandbox` and `AsyncSandbox` exports read their configuration from the environment variables. To use an explicit configuration — e.g. several API keys or domains in one process — create an `E2B` client and use the resource classes it exposes:
+
+```py
+from e2b_code_interpreter import E2B
+
+client = E2B(api_key="e2b_***", domain="e2b.dev")
+
+with client.Sandbox.create() as sandbox:
+    execution = sandbox.run_code("x = 1; x += 1; x")
+
+# The async variant is exposed as well.
+async_sandbox = await client.AsyncSandbox.create()
+
+# The core resources are bound to the client's configuration as well.
+volume = client.Volume.create("my-volume")
+exists = client.Template.exists("my-template")
+secret = client.Secret.create("openai-api-key", "sk-***")
+
+# The classes can be assigned and used like the top-level ones.
+Sandbox = client.Sandbox
+paginator = Sandbox.list()
+```
+
+Per-call params still take precedence over the client's params, and clients are isolated from each other and from the env-configured top-level exports.
+
+### 5. Check docs
+Visit [E2B documentation](https://docs.e2b.dev/?utm_source=pypi&utm_medium=referral&utm_campaign=readme&utm_content=code-interpreter).
+
+### 6. E2B cookbook
+Visit our [Cookbook](https://github.com/e2b-dev/e2b-cookbook/tree/main) to get inspired by examples with different LLMs and AI frameworks.

e2b_code_interpreter-2.11.0/README.md

@@ -0,0 +1,82 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/e2b-dev/E2B/refs/heads/main/readme-assets/logo-white.png">
+    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/e2b-dev/E2B/refs/heads/main/readme-assets/logo-black.png">
+    <img alt="E2B Logo" src="https://raw.githubusercontent.com/e2b-dev/E2B/refs/heads/main/readme-assets/logo-black.png" width="200">
+  </picture>
+</p>
+
+<h4 align="center">
+  <a href="https://pypi.org/project/e2b/">
+    <img alt="Last 1 month downloads for the Python SDK" loading="lazy" width="200" height="20" decoding="async" data-nimg="1"
+    style="color:transparent;width:auto;height:100%" src="https://img.shields.io/pypi/dm/e2b?label=PyPI%20Downloads">
+  </a>
+</h4>
+
+<!---
+<img width="100%" src="/readme-assets/preview.png" alt="Cover image">
+--->
+## What is E2B?
+[E2B](https://e2b.dev/?utm_source=pypi&utm_medium=referral&utm_campaign=readme&utm_content=code-interpreter) is an open-source infrastructure that allows you run to AI-generated code in secure isolated sandboxes in the cloud. To start and control sandboxes, use our [JavaScript SDK](https://www.npmjs.com/package/@e2b/code-interpreter) or [Python SDK](https://pypi.org/project/e2b_code_interpreter).
+
+Source: [packages/code-interpreter-python](https://github.com/e2b-dev/E2B/tree/main/packages/code-interpreter-python)
+
+## Run your first Sandbox
+
+### 1. Install SDK
+
+```
+pip install e2b-code-interpreter
+```
+
+### 2. Get your E2B API key
+1. Sign up to E2B [here](https://e2b.dev/?utm_source=pypi&utm_medium=referral&utm_campaign=readme&utm_content=code-interpreter).
+2. Get your API key [here](https://e2b.dev/dashboard?tab=keys&utm_source=pypi&utm_medium=referral&utm_campaign=readme&utm_content=code-interpreter).
+3. Set environment variable with your API key.
+```
+E2B_API_KEY=e2b_***
+```
+
+### 3. Execute code with code interpreter inside Sandbox
+
+```py
+from e2b_code_interpreter import Sandbox
+
+with Sandbox.create() as sandbox:
+    sandbox.run_code("x = 1")
+    execution = sandbox.run_code("x+=1; x")
+    print(execution.text)  # outputs 2
+```
+
+### 4. Bind the configuration to a client
+
+The top-level `Sandbox` and `AsyncSandbox` exports read their configuration from the environment variables. To use an explicit configuration — e.g. several API keys or domains in one process — create an `E2B` client and use the resource classes it exposes:
+
+```py
+from e2b_code_interpreter import E2B
+
+client = E2B(api_key="e2b_***", domain="e2b.dev")
+
+with client.Sandbox.create() as sandbox:
+    execution = sandbox.run_code("x = 1; x += 1; x")
+
+# The async variant is exposed as well.
+async_sandbox = await client.AsyncSandbox.create()
+
+# The core resources are bound to the client's configuration as well.
+volume = client.Volume.create("my-volume")
+exists = client.Template.exists("my-template")
+secret = client.Secret.create("openai-api-key", "sk-***")
+
+# The classes can be assigned and used like the top-level ones.
+Sandbox = client.Sandbox
+paginator = Sandbox.list()
+```
+
+Per-call params still take precedence over the client's params, and clients are isolated from each other and from the env-configured top-level exports.
+
+### 5. Check docs
+Visit [E2B documentation](https://docs.e2b.dev/?utm_source=pypi&utm_medium=referral&utm_campaign=readme&utm_content=code-interpreter).
+
+### 6. E2B cookbook
+Visit our [Cookbook](https://github.com/e2b-dev/e2b-cookbook/tree/main) to get inspired by examples with different LLMs and AI frameworks.

{e2b_code_interpreter-2.8.0 → e2b_code_interpreter-2.11.0}/e2b_code_interpreter/__init__.py

@@ -1,4 +1,5 @@
 from e2b import *
+from .client import E2B, E2BClientParams
 from .code_interpreter_sync import Sandbox
 from .code_interpreter_async import AsyncSandbox
 from .models import (

{e2b_code_interpreter-2.8.0 → e2b_code_interpreter-2.11.0}/e2b_code_interpreter/charts.py

@@ -194,17 +194,19 @@ class BoxAndWhiskerChart(Chart2D):
 class SuperChart(Chart):
     type = ChartType.SUPERCHART
 
-    elements: List[
-        Union[LineChart, ScatterChart, BarChart, PieChart, BoxAndWhiskerChart]
-    ]
+    elements: List[Chart]
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        self.elements = [_deserialize_chart(g) for g in kwargs["elements"]]
+        self.elements = []
+        for raw_chart in kwargs["elements"]:
+            chart = _deserialize_chart(raw_chart)
+            if chart is not None:
+                self.elements.append(chart)
 
 
 ChartTypes = Union[
-    LineChart, ScatterChart, BarChart, PieChart, BoxAndWhiskerChart, SuperChart
+    Chart, LineChart, ScatterChart, BarChart, PieChart, BoxAndWhiskerChart, SuperChart
 ]
 
 

e2b_code_interpreter-2.11.0/e2b_code_interpreter/client.py

@@ -0,0 +1,93 @@
+from typing import Dict, Type, TypeVar, cast
+
+from e2b import ApiParams, E2BClientParams
+from e2b import E2B as CoreE2B
+from typing_extensions import Unpack
+
+from e2b_code_interpreter.code_interpreter_async import AsyncSandbox
+from e2b_code_interpreter.code_interpreter_sync import Sandbox
+
+T = TypeVar("T")
+
+__all__ = ["E2B", "E2BClientParams"]
+
+
+def _bind(cls: Type[T], api_params: ApiParams) -> Type[T]:
+    """Generate a subclass of ``cls`` carrying ``api_params`` as its bound params."""
+    return cast(
+        Type[T],
+        type(cls.__name__, (cls,), {"_bound_api_params": api_params}),
+    )
+
+
+class E2B:
+    """
+    E2B client with an explicitly bound connection configuration.
+
+    The resource classes exposed by the client (`Sandbox`, `AsyncSandbox`,
+    `Volume`, `AsyncVolume`, `Template`, `AsyncTemplate`, `Secret`,
+    `AsyncSecret`) behave exactly like the top-level exports of the same name,
+    except the params passed to the client are used as the defaults instead of
+    the environment variables.
+    Per-call params still take precedence over the client's params.
+
+    Multiple clients are fully isolated from each other and from the top-level
+    env-configured exports.
+
+    Example:
+    ```python
+    from e2b_code_interpreter import E2B
+
+    client = E2B(api_key="e2b_...", domain="e2b.dev")
+
+    sandbox = client.Sandbox.create()
+    execution = sandbox.run_code("x = 1; x += 1; x")
+    ```
+    """
+
+    def __init__(self, **opts: Unpack[E2BClientParams]):
+        """
+        Create a new client with the API params bound to it.
+
+        :param opts: API params used as the defaults for every call made
+            through this client's resource classes.
+        """
+        # Params are copied so later mutations of the caller's dicts cannot
+        # change the bound configuration.
+        api_params = cast(ApiParams, dict(cast(Dict[str, object], opts)))
+
+        headers = api_params.get("headers")
+        if headers is not None:
+            api_params["headers"] = dict(headers)
+
+        api_headers = api_params.get("api_headers")
+        if api_headers is not None:
+            api_params["api_headers"] = dict(api_headers)
+
+        self.Sandbox = _bind(Sandbox, api_params)
+        """Code Interpreter `Sandbox` class bound to this client's connection configuration."""
+
+        self.AsyncSandbox = _bind(AsyncSandbox, api_params)
+        """Code Interpreter `AsyncSandbox` class bound to this client's connection configuration."""
+
+        # The resources that are not specific to the Code Interpreter are bound
+        # by the core client.
+        core = CoreE2B(**api_params)
+
+        self.Volume = core.Volume
+        """`Volume` class bound to this client's connection configuration."""
+
+        self.AsyncVolume = core.AsyncVolume
+        """`AsyncVolume` class bound to this client's connection configuration."""
+
+        self.Template = core.Template
+        """`Template` class bound to this client's connection configuration."""
+
+        self.AsyncTemplate = core.AsyncTemplate
+        """`AsyncTemplate` class bound to this client's connection configuration."""
+
+        self.Secret = core.Secret
+        """`Secret` class bound to this client's connection configuration."""
+
+        self.AsyncSecret = core.AsyncSecret
+        """`AsyncSecret` class bound to this client's connection configuration."""

{e2b_code_interpreter-2.8.0 → e2b_code_interpreter-2.11.0}/e2b_code_interpreter/code_interpreter_async.py

@@ -29,6 +29,7 @@ from e2b_code_interpreter.models import (
 from e2b_code_interpreter.exceptions import (
     format_execution_timeout_error,
     format_request_timeout_error,
+    format_sandbox_killed_error,
 )
 
 logger = logging.getLogger(__name__)
@@ -60,14 +61,16 @@ class AsyncSandbox(BaseAsyncSandbox):
 
     @property
     def _jupyter_url(self) -> str:
-        return f"{'http' if self.connection_config.debug else 'https'}://{self.get_host(JUPYTER_PORT)}"
+        return self.connection_config.get_sandbox_url(
+            self.sandbox_id, self.sandbox_domain, port=JUPYTER_PORT
+        )
 
     @property
     def _client(self) -> AsyncClient:
         # TODO: Remove later
         # Use a dedicated HTTP/1.1 transport for Jupyter requests.
         #
-        # The base SDK's shared transport now defaults to http2=True. With
+        # The base SDK's shared transport now defaults to HTTP/2. With
         # HTTP/2, multiple requests are multiplexed over a single TCP
         # connection, so when a client cancels a request (e.g. the caller
         # disconnects from the streaming `/execute` endpoint) the server
@@ -80,9 +83,26 @@ class AsyncSandbox(BaseAsyncSandbox):
         # cancelled reliably. The helper also caches the transport
         # per-event-loop for async.
         return AsyncClient(
-            transport=get_transport(self.connection_config, http2=False),
+            transport=get_transport(self.connection_config, http_version="1.1"),
         )
 
+    async def _handle_connection_error(self, err: Exception) -> None:
+        """
+        Raises a descriptive exception if the connection error was caused by
+        the sandbox being killed mid-request. If the sandbox is still running
+        (or its state can't be determined), returns so the caller can re-raise
+        the original error.
+        """
+        try:
+            running = await self.is_running()
+        except Exception:
+            # The state check itself failed, so we can't tell whether the
+            # sandbox was killed — let the caller re-raise the original error
+            # instead of wrongly claiming the sandbox is gone.
+            return
+        if not running:
+            raise format_sandbox_killed_error() from err
+
     @overload
     async def run_code(
         self,
@@ -178,6 +198,8 @@ class AsyncSandbox(BaseAsyncSandbox):
         try:
             headers = {
                 "Content-Type": "application/json",
+                "E2b-Sandbox-Id": self.sandbox_id,
+                "E2b-Sandbox-Port": str(JUPYTER_PORT),
             }
             if self._envd_access_token:
                 headers["X-Access-Token"] = self._envd_access_token
@@ -194,7 +216,22 @@ class AsyncSandbox(BaseAsyncSandbox):
                     "env_vars": envs,
                 },
                 headers=headers,
-                timeout=(request_timeout, timeout, request_timeout, request_timeout),
+                # `timeout` bounds the execution, `request_timeout` only the
+                # connect. Every non-connect phase must carry `timeout`: the
+                # SDK's pyqwest-backed transport collapses the per-phase
+                # timeouts into a single whole-request deadline and takes the
+                # longest of them, so leaving `request_timeout` on the write
+                # and pool phases would raise the floor to
+                # `max(timeout, request_timeout)` and silently ignore any
+                # `timeout` shorter than it. This matches the JS SDK, which
+                # aborts the execution on a `timeout`-long timer.
+                # `timeout=0` disables the deadline entirely; the transport
+                # still bounds connect on its own.
+                timeout=(
+                    httpx.Timeout(timeout, connect=request_timeout)
+                    if timeout is not None
+                    else httpx.Timeout(None)
+                ),
             ) as response:
                 err = await aextract_exception(response)
                 if err:
@@ -217,6 +254,9 @@ class AsyncSandbox(BaseAsyncSandbox):
             raise format_execution_timeout_error()
         except httpx.TimeoutException:
             raise format_request_timeout_error()
+        except (httpx.ReadError, httpx.RemoteProtocolError) as err:
+            await self._handle_connection_error(err)
+            raise
 
     async def create_code_context(
         self,
@@ -244,6 +284,8 @@ class AsyncSandbox(BaseAsyncSandbox):
         try:
             headers = {
                 "Content-Type": "application/json",
+                "E2b-Sandbox-Id": self.sandbox_id,
+                "E2b-Sandbox-Port": str(JUPYTER_PORT),
             }
             if self.traffic_access_token:
                 headers["E2B-Traffic-Access-Token"] = self.traffic_access_token
@@ -263,6 +305,9 @@ class AsyncSandbox(BaseAsyncSandbox):
             return Context.from_json(data)
         except httpx.TimeoutException:
             raise format_request_timeout_error()
+        except (httpx.ReadError, httpx.RemoteProtocolError) as err:
+            await self._handle_connection_error(err)
+            raise
 
     async def remove_code_context(
         self,
@@ -280,6 +325,8 @@ class AsyncSandbox(BaseAsyncSandbox):
         try:
             headers = {
                 "Content-Type": "application/json",
+                "E2b-Sandbox-Id": self.sandbox_id,
+                "E2b-Sandbox-Port": str(JUPYTER_PORT),
             }
             if self.traffic_access_token:
                 headers["E2B-Traffic-Access-Token"] = self.traffic_access_token
@@ -295,6 +342,9 @@ class AsyncSandbox(BaseAsyncSandbox):
                 raise err
         except httpx.TimeoutException:
             raise format_request_timeout_error()
+        except (httpx.ReadError, httpx.RemoteProtocolError) as err:
+            await self._handle_connection_error(err)
+            raise
 
     async def list_code_contexts(self) -> List[Context]:
         """
@@ -305,6 +355,8 @@ class AsyncSandbox(BaseAsyncSandbox):
         try:
             headers = {
                 "Content-Type": "application/json",
+                "E2b-Sandbox-Id": self.sandbox_id,
+                "E2b-Sandbox-Port": str(JUPYTER_PORT),
             }
             if self.traffic_access_token:
                 headers["E2B-Traffic-Access-Token"] = self.traffic_access_token
@@ -323,6 +375,9 @@ class AsyncSandbox(BaseAsyncSandbox):
             return [Context.from_json(context_data) for context_data in data]
         except httpx.TimeoutException:
             raise format_request_timeout_error()
+        except (httpx.ReadError, httpx.RemoteProtocolError) as err:
+            await self._handle_connection_error(err)
+            raise
 
     async def restart_code_context(
         self,
@@ -339,6 +394,8 @@ class AsyncSandbox(BaseAsyncSandbox):
         try:
             headers = {
                 "Content-Type": "application/json",
+                "E2b-Sandbox-Id": self.sandbox_id,
+                "E2b-Sandbox-Port": str(JUPYTER_PORT),
             }
             if self.traffic_access_token:
                 headers["E2B-Traffic-Access-Token"] = self.traffic_access_token
@@ -354,3 +411,6 @@ class AsyncSandbox(BaseAsyncSandbox):
                 raise err
         except httpx.TimeoutException:
             raise format_request_timeout_error()
+        except (httpx.ReadError, httpx.RemoteProtocolError) as err:
+            await self._handle_connection_error(err)
+            raise

{e2b_code_interpreter-2.8.0 → e2b_code_interpreter-2.11.0}/e2b_code_interpreter/code_interpreter_sync.py

@@ -25,6 +25,7 @@ from e2b_code_interpreter.models import (
 from e2b_code_interpreter.exceptions import (
     format_execution_timeout_error,
     format_request_timeout_error,
+    format_sandbox_killed_error,
 )
 
 logger = logging.getLogger(__name__)
@@ -57,14 +58,16 @@ class Sandbox(BaseSandbox):
 
     @property
     def _jupyter_url(self) -> str:
-        return f"{'http' if self.connection_config.debug else 'https'}://{self.get_host(JUPYTER_PORT)}"
+        return self.connection_config.get_sandbox_url(
+            self.sandbox_id, self.sandbox_domain, port=JUPYTER_PORT
+        )
 
     @property
     def _client(self) -> Client:
         # TODO: Remove later
         # Use a dedicated HTTP/1.1 transport for Jupyter requests.
         #
-        # The base SDK's shared transport now defaults to http2=True. With
+        # The base SDK's shared transport now defaults to HTTP/2. With
         # HTTP/2, multiple requests are multiplexed over a single TCP
         # connection, so when a client cancels a request (e.g. the caller
         # disconnects from the streaming `/execute` endpoint) the server
@@ -75,7 +78,26 @@ class Sandbox(BaseSandbox):
         # connection and request, so client disconnects propagate to the
         # server as a TCP close and long-running executions can be
         # cancelled reliably.
-        return Client(transport=get_transport(self.connection_config, http2=False))
+        return Client(
+            transport=get_transport(self.connection_config, http_version="1.1")
+        )
+
+    def _handle_connection_error(self, err: Exception) -> None:
+        """
+        Raises a descriptive exception if the connection error was caused by
+        the sandbox being killed mid-request. If the sandbox is still running
+        (or its state can't be determined), returns so the caller can re-raise
+        the original error.
+        """
+        try:
+            running = self.is_running()
+        except Exception:
+            # The state check itself failed, so we can't tell whether the
+            # sandbox was killed — let the caller re-raise the original error
+            # instead of wrongly claiming the sandbox is gone.
+            return
+        if not running:
+            raise format_sandbox_killed_error() from err
 
     @overload
     def run_code(
@@ -171,7 +193,11 @@ class Sandbox(BaseSandbox):
         context_id = context.id if context else None
 
         try:
-            headers: Dict[str, str] = {"Content-Type": "application/json"}
+            headers: Dict[str, str] = {
+                "Content-Type": "application/json",
+                "E2b-Sandbox-Id": self.sandbox_id,
+                "E2b-Sandbox-Port": str(JUPYTER_PORT),
+            }
             if self._envd_access_token:
                 headers["X-Access-Token"] = self._envd_access_token
             if self.traffic_access_token:
@@ -187,7 +213,22 @@ class Sandbox(BaseSandbox):
                     "env_vars": envs,
                 },
                 headers=headers,
-                timeout=(request_timeout, timeout, request_timeout, request_timeout),
+                # `timeout` bounds the execution, `request_timeout` only the
+                # connect. Every non-connect phase must carry `timeout`: the
+                # SDK's pyqwest-backed transport collapses the per-phase
+                # timeouts into a single whole-request deadline and takes the
+                # longest of them, so leaving `request_timeout` on the write
+                # and pool phases would raise the floor to
+                # `max(timeout, request_timeout)` and silently ignore any
+                # `timeout` shorter than it. This matches the JS SDK, which
+                # aborts the execution on a `timeout`-long timer.
+                # `timeout=0` disables the deadline entirely; the transport
+                # still bounds connect on its own.
+                timeout=(
+                    httpx.Timeout(timeout, connect=request_timeout)
+                    if timeout is not None
+                    else httpx.Timeout(None)
+                ),
             ) as response:
                 err = extract_exception(response)
                 if err:
@@ -210,6 +251,9 @@ class Sandbox(BaseSandbox):
             raise format_execution_timeout_error()
         except httpx.TimeoutException:
             raise format_request_timeout_error()
+        except (httpx.ReadError, httpx.RemoteProtocolError) as err:
+            self._handle_connection_error(err)
+            raise
 
     def create_code_context(
         self,
@@ -235,9 +279,11 @@ class Sandbox(BaseSandbox):
             data["cwd"] = cwd
 
         try:
-            headers: Dict[str, str] = {"Content-Type": "application/json"}
-            if self._envd_access_token:
-                headers["X-Access-Token"] = self._envd_access_token
+            headers: Dict[str, str] = {
+                "Content-Type": "application/json",
+                "E2b-Sandbox-Id": self.sandbox_id,
+                "E2b-Sandbox-Port": str(JUPYTER_PORT),
+            }
             if self.traffic_access_token:
                 headers["E2B-Traffic-Access-Token"] = self.traffic_access_token
 
@@ -256,6 +302,9 @@ class Sandbox(BaseSandbox):
             return Context.from_json(data)
         except httpx.TimeoutException:
             raise format_request_timeout_error()
+        except (httpx.ReadError, httpx.RemoteProtocolError) as err:
+            self._handle_connection_error(err)
+            raise
 
     def remove_code_context(
         self,
@@ -271,9 +320,11 @@ class Sandbox(BaseSandbox):
         context_id = context.id if isinstance(context, Context) else context
 
         try:
-            headers: Dict[str, str] = {"Content-Type": "application/json"}
-            if self._envd_access_token:
-                headers["X-Access-Token"] = self._envd_access_token
+            headers: Dict[str, str] = {
+                "Content-Type": "application/json",
+                "E2b-Sandbox-Id": self.sandbox_id,
+                "E2b-Sandbox-Port": str(JUPYTER_PORT),
+            }
             if self.traffic_access_token:
                 headers["E2B-Traffic-Access-Token"] = self.traffic_access_token
 
@@ -288,6 +339,9 @@ class Sandbox(BaseSandbox):
                 raise err
         except httpx.TimeoutException:
             raise format_request_timeout_error()
+        except (httpx.ReadError, httpx.RemoteProtocolError) as err:
+            self._handle_connection_error(err)
+            raise
 
     def list_code_contexts(self) -> List[Context]:
         """
@@ -296,9 +350,11 @@ class Sandbox(BaseSandbox):
         :return: List of contexts.
         """
         try:
-            headers: Dict[str, str] = {"Content-Type": "application/json"}
-            if self._envd_access_token:
-                headers["X-Access-Token"] = self._envd_access_token
+            headers: Dict[str, str] = {
+                "Content-Type": "application/json",
+                "E2b-Sandbox-Id": self.sandbox_id,
+                "E2b-Sandbox-Port": str(JUPYTER_PORT),
+            }
             if self.traffic_access_token:
                 headers["E2B-Traffic-Access-Token"] = self.traffic_access_token
 
@@ -316,6 +372,9 @@ class Sandbox(BaseSandbox):
             return [Context.from_json(context_data) for context_data in data]
         except httpx.TimeoutException:
             raise format_request_timeout_error()
+        except (httpx.ReadError, httpx.RemoteProtocolError) as err:
+            self._handle_connection_error(err)
+            raise
 
     def restart_code_context(
         self,
@@ -331,9 +390,11 @@ class Sandbox(BaseSandbox):
         context_id = context.id if isinstance(context, Context) else context
 
         try:
-            headers: Dict[str, str] = {"Content-Type": "application/json"}
-            if self._envd_access_token:
-                headers["X-Access-Token"] = self._envd_access_token
+            headers: Dict[str, str] = {
+                "Content-Type": "application/json",
+                "E2b-Sandbox-Id": self.sandbox_id,
+                "E2b-Sandbox-Port": str(JUPYTER_PORT),
+            }
             if self.traffic_access_token:
                 headers["E2B-Traffic-Access-Token"] = self.traffic_access_token
 
@@ -348,3 +409,6 @@ class Sandbox(BaseSandbox):
                 raise err
         except httpx.TimeoutException:
             raise format_request_timeout_error()
+        except (httpx.ReadError, httpx.RemoteProtocolError) as err:
+            self._handle_connection_error(err)
+            raise

{e2b_code_interpreter-2.8.0 → e2b_code_interpreter-2.11.0}/e2b_code_interpreter/exceptions.py

@@ -11,3 +11,10 @@ def format_execution_timeout_error() -> Exception:
     return TimeoutException(
         "Execution timed out — the 'timeout' option can be used to increase this timeout",
     )
+
+
+def format_sandbox_killed_error() -> Exception:
+    return TimeoutException(
+        "The sandbox was killed while the request was in progress. This can happen when the sandbox times out or is killed manually. "
+        "You can modify the sandbox timeout by passing 'timeout' when starting the sandbox or calling '.set_timeout' on the sandbox with the desired timeout",
+    )

{e2b_code_interpreter-2.8.0 → e2b_code_interpreter-2.11.0}/e2b_code_interpreter/models.py

@@ -207,7 +207,7 @@ class Result:
 
         return formats
 
-    def __str__(self) -> Optional[str]:
+    def __str__(self) -> str:
         """
         Returns the text representation of the data.
 
@@ -305,7 +305,12 @@ class Logs:
     stderr: List[str] = field(default_factory=list)
     """List of strings printed to stderr by prints, subprocesses, etc."""
 
-    def __init__(self, stdout: List[str] = None, stderr: List[str] = None, **kwargs):
+    def __init__(
+        self,
+        stdout: Optional[List[str]] = None,
+        stderr: Optional[List[str]] = None,
+        **kwargs,
+    ):
         self.stdout = stdout or []
         self.stderr = stderr or []
 
@@ -329,7 +334,9 @@ def serialize_results(results: List[Result]) -> List[Dict[str, str]]:
         serialized_dict = {}
         for key in result.formats():
             if key == "chart":
-                serialized_dict[key] = result.chart.to_dict()
+                chart = result.chart
+                if chart is not None:
+                    serialized_dict[key] = chart.to_dict()
             else:
                 serialized_dict[key] = result[key]
 
@@ -356,8 +363,8 @@ class Execution:
 
     def __init__(
         self,
-        results: List[Result] = None,
-        logs: Logs = None,
+        results: Optional[List[Result]] = None,
+        logs: Optional[Logs] = None,
         error: Optional[ExecutionError] = None,
         execution_count: Optional[int] = None,
         **kwargs,
@@ -420,7 +427,10 @@ def format_exception(res: Response):
             f"{res.text}: This error is likely due to sandbox timeout. You can modify the sandbox timeout by passing 'timeout' when starting the sandbox or calling '.set_timeout' on the sandbox with the desired timeout."
         )
     else:
-        return SandboxException(f"{res.status_code}: {res.text}")
+        body = res.text.strip()
+        return SandboxException(
+            f"{res.status_code} {res.reason_phrase}{f': {body}' if body else ''}"
+        )
 
 
 def parse_output(
@@ -510,7 +520,7 @@ class Context:
     @classmethod
     def from_json(cls, data: Dict[str, str]):
         return cls(
-            context_id=data.get("id"),
-            language=data.get("language"),
-            cwd=data.get("cwd"),
+            context_id=data["id"],
+            language=data["language"],
+            cwd=data["cwd"],
         )

e2b_code_interpreter-2.11.0/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "e2b-code-interpreter"
+version = "2.11.0"
+description = "E2B Code Interpreter - Stateful code execution"
+authors = [{ name = "e2b", email = "hello@e2b.dev" }]
+license = "MIT"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "httpx>=0.20.0,<1.0.0",
+    "attrs>=21.3.0",
+    "e2b>=2.55.1,<3.0.0",
+]
+
+[project.urls]
+Homepage = "https://e2b.dev/?utm_source=pypi&utm_medium=referral&utm_campaign=package_homepage&utm_content=e2b-code-interpreter"
+Repository = "https://github.com/e2b-dev/e2b/tree/main/packages/code-interpreter-python"
+"Bug Tracker" = "https://github.com/e2b-dev/e2b/issues"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.3,<10",
+    "python-dotenv>=1.0.0,<2",
+    "pytest-dotenv>=0.5.2,<0.6",
+    "pytest-asyncio>=1.3.0,<2",
+    "pytest-xdist>=3.6.1,<4",
+    "matplotlib>=3.8.0,<4",
+    "ruff>=0.11.12,<0.12",
+    "ty>=0.0.15,<0.0.16",
+]
+
+[build-system]
+requires = ["uv_build>=0.10.0,<0.11.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = ["e2b_code_interpreter"]
+module-root = ""
+
+[tool.uv.sources]
+e2b = { workspace = true }
+
+[tool.uv.workspace]
+members = ["../python-sdk"]
+
+[tool.ruff.lint]
+ignore = ["F401", "F403"]

e2b_code_interpreter-2.8.0/LICENSE

@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) 2025 FOUNDRYLABS, INC.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

e2b_code_interpreter-2.8.0/PKG-INFO

@@ -1,72 +0,0 @@
-Metadata-Version: 2.1
-Name: e2b-code-interpreter
-Version: 2.8.0
-Summary: E2B Code Interpreter - Stateful code execution
-Home-page: https://e2b.dev/
-License: MIT
-Author: e2b
-Author-email: hello@e2b.dev
-Requires-Python: >=3.10,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: attrs (>=21.3.0)
-Requires-Dist: e2b (>=2.26.0,<3.0.0)
-Requires-Dist: httpx (>=0.20.0,<1.0.0)
-Project-URL: Bug Tracker, https://github.com/e2b-dev/code-interpreter/issues
-Project-URL: Repository, https://github.com/e2b-dev/code-interpreter/tree/main/python
-Description-Content-Type: text/markdown
-
-<p align="center">
-  <img width="100" src="https://raw.githubusercontent.com/e2b-dev/E2B/refs/heads/main/readme-assets/logo-circle.png" alt="e2b logo">
-</p>
-
-<h4 align="center">
-  <a href="https://pypi.org/project/e2b/">
-    <img alt="Last 1 month downloads for the Python SDK" loading="lazy" width="200" height="20" decoding="async" data-nimg="1"
-    style="color:transparent;width:auto;height:100%" src="https://img.shields.io/pypi/dm/e2b?label=PyPI%20Downloads">
-  </a>  
-</h4>
-
-<!---
-<img width="100%" src="/readme-assets/preview.png" alt="Cover image">
---->
-## What is E2B?
-[E2B](https://www.e2b.dev/) is an open-source infrastructure that allows you run to AI-generated code in secure isolated sandboxes in the cloud. To start and control sandboxes, use our [JavaScript SDK](https://www.npmjs.com/package/@e2b/code-interpreter) or [Python SDK](https://pypi.org/project/e2b_code_interpreter).
-
-## Run your first Sandbox
-
-### 1. Install SDK
-
-```
-pip install e2b-code-interpreter
-```
-
-### 2. Get your E2B API key
-1. Sign up to E2B [here](https://e2b.dev).
-2. Get your API key [here](https://e2b.dev/dashboard?tab=keys).
-3. Set environment variable with your API key.
-```
-E2B_API_KEY=e2b_***
-```     
-
-### 3. Execute code with code interpreter inside Sandbox
-
-```py
-from e2b_code_interpreter import Sandbox
-
-with Sandbox.create() as sandbox:
-    sandbox.run_code("x = 1")
-    execution = sandbox.run_code("x+=1; x")
-    print(execution.text)  # outputs 2
-```
-
-### 4. Check docs
-Visit [E2B documentation](https://e2b.dev/docs).
-
-### 5. E2B cookbook
-Visit our [Cookbook](https://github.com/e2b-dev/e2b-cookbook/tree/main) to get inspired by examples with different LLMs and AI frameworks.
-

e2b_code_interpreter-2.8.0/README.md

@@ -1,49 +0,0 @@
-<p align="center">
-  <img width="100" src="https://raw.githubusercontent.com/e2b-dev/E2B/refs/heads/main/readme-assets/logo-circle.png" alt="e2b logo">
-</p>
-
-<h4 align="center">
-  <a href="https://pypi.org/project/e2b/">
-    <img alt="Last 1 month downloads for the Python SDK" loading="lazy" width="200" height="20" decoding="async" data-nimg="1"
-    style="color:transparent;width:auto;height:100%" src="https://img.shields.io/pypi/dm/e2b?label=PyPI%20Downloads">
-  </a>  
-</h4>
-
-<!---
-<img width="100%" src="/readme-assets/preview.png" alt="Cover image">
---->
-## What is E2B?
-[E2B](https://www.e2b.dev/) is an open-source infrastructure that allows you run to AI-generated code in secure isolated sandboxes in the cloud. To start and control sandboxes, use our [JavaScript SDK](https://www.npmjs.com/package/@e2b/code-interpreter) or [Python SDK](https://pypi.org/project/e2b_code_interpreter).
-
-## Run your first Sandbox
-
-### 1. Install SDK
-
-```
-pip install e2b-code-interpreter
-```
-
-### 2. Get your E2B API key
-1. Sign up to E2B [here](https://e2b.dev).
-2. Get your API key [here](https://e2b.dev/dashboard?tab=keys).
-3. Set environment variable with your API key.
-```
-E2B_API_KEY=e2b_***
-```     
-
-### 3. Execute code with code interpreter inside Sandbox
-
-```py
-from e2b_code_interpreter import Sandbox
-
-with Sandbox.create() as sandbox:
-    sandbox.run_code("x = 1")
-    execution = sandbox.run_code("x+=1; x")
-    print(execution.text)  # outputs 2
-```
-
-### 4. Check docs
-Visit [E2B documentation](https://e2b.dev/docs).
-
-### 5. E2B cookbook
-Visit our [Cookbook](https://github.com/e2b-dev/e2b-cookbook/tree/main) to get inspired by examples with different LLMs and AI frameworks.

e2b_code_interpreter-2.8.0/pyproject.toml

@@ -1,37 +0,0 @@
-[tool.poetry]
-name = "e2b-code-interpreter"
-version = "2.8.0"
-description = "E2B Code Interpreter - Stateful code execution"
-authors = ["e2b <hello@e2b.dev>"]
-license = "MIT"
-readme = "README.md"
-homepage = "https://e2b.dev/"
-repository = "https://github.com/e2b-dev/code-interpreter/tree/main/python"
-packages = [{ include = "e2b_code_interpreter" }]
-
-[tool.poetry.dependencies]
-python = "^3.10"
-
-httpx = ">=0.20.0, <1.0.0"
-attrs = ">=21.3.0"
-e2b = "^2.26.0"
-
-[tool.poetry.group.dev.dependencies]
-pytest = "^9.0.3"
-python-dotenv = "^1.0.0"
-pytest-dotenv = "^0.5.2"
-pytest-asyncio = "^1.3.0"
-pytest-xdist = "^3.6.1"
-matplotlib = "^3.8.0"
-ruff = "^0.11.12"
-
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
-
-[tool.poetry.urls]
-"Bug Tracker" = "https://github.com/e2b-dev/code-interpreter/issues"
-
-[tool.ruff.lint]
-ignore = ["F401", "F403"]