e2b-code-interpreter 2.9.1__tar.gz → 2.10.0__tar.gz

e2b_code_interpreter-2.10.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: e2b-code-interpreter
+Version: 2.10.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.44.0,<3.0.0
+Requires-Python: >=3.10
+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.10.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.9.1 → e2b_code_interpreter-2.10.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.9.1 → e2b_code_interpreter-2.10.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.10.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.9.1 → e2b_code_interpreter-2.10.0}/e2b_code_interpreter/code_interpreter_async.py

@@ -1,7 +1,7 @@
 import logging
 import httpx
 
-from typing import Optional, Dict, overload, Union, List
+from typing import cast, Optional, Dict, overload, Union, List
 from httpx import AsyncClient
 
 from e2b import (
@@ -63,11 +63,23 @@ class AsyncSandbox(BaseAsyncSandbox):
     def _jupyter_url(self) -> str:
         # Honors the `sandbox_url` option and the `E2B_SANDBOX_URL` environment
         # variable, same as the base SDK does for envd requests.
-        sandbox_url = self.connection_config._sandbox_url
+        sandbox_url = cast(Optional[str], self.connection_config._sandbox_url)
         if sandbox_url:
             return sandbox_url
         return f"{'http' if self.connection_config.debug else 'https'}://{self.get_host(JUPYTER_PORT)}"
 
+    def _jupyter_request_url(self, path: str) -> str:
+        url = f"{self._jupyter_url}{path}"
+        source = getattr(self.connection_config, "request_source", None)
+        if not source:
+            return url
+        separator = "&" if "?" in url else "?"
+        return f"{url}{separator}source={source}"
+
+    @property
+    def _include_diagnostics(self) -> bool:
+        return getattr(self.connection_config, "request_source", None) == "ci"
+
     @property
     def _client(self) -> AsyncClient:
         # TODO: Remove later
@@ -211,7 +223,7 @@ class AsyncSandbox(BaseAsyncSandbox):
 
             async with self._client.stream(
                 "POST",
-                f"{self._jupyter_url}/execute",
+                self._jupyter_request_url("/execute"),
                 json={
                     "code": code,
                     "context_id": context_id,
@@ -236,7 +248,7 @@ class AsyncSandbox(BaseAsyncSandbox):
                     else httpx.Timeout(None)
                 ),
             ) as response:
-                err = await aextract_exception(response)
+                err = await aextract_exception(response, self._include_diagnostics)
                 if err:
                     raise err
 
@@ -294,13 +306,13 @@ class AsyncSandbox(BaseAsyncSandbox):
                 headers["E2B-Traffic-Access-Token"] = self.traffic_access_token
 
             response = await self._client.post(
-                f"{self._jupyter_url}/contexts",
+                self._jupyter_request_url("/contexts"),
                 headers=headers,
                 json=data,
                 timeout=request_timeout or self.connection_config.request_timeout,
             )
 
-            err = await aextract_exception(response)
+            err = await aextract_exception(response, self._include_diagnostics)
             if err:
                 raise err
 
@@ -335,12 +347,12 @@ class AsyncSandbox(BaseAsyncSandbox):
                 headers["E2B-Traffic-Access-Token"] = self.traffic_access_token
 
             response = await self._client.delete(
-                f"{self._jupyter_url}/contexts/{context_id}",
+                self._jupyter_request_url(f"/contexts/{context_id}"),
                 headers=headers,
                 timeout=self.connection_config.request_timeout,
             )
 
-            err = await aextract_exception(response)
+            err = await aextract_exception(response, self._include_diagnostics)
             if err:
                 raise err
         except httpx.TimeoutException:
@@ -365,12 +377,12 @@ class AsyncSandbox(BaseAsyncSandbox):
                 headers["E2B-Traffic-Access-Token"] = self.traffic_access_token
 
             response = await self._client.get(
-                f"{self._jupyter_url}/contexts",
+                self._jupyter_request_url("/contexts"),
                 headers=headers,
                 timeout=self.connection_config.request_timeout,
             )
 
-            err = await aextract_exception(response)
+            err = await aextract_exception(response, self._include_diagnostics)
             if err:
                 raise err
 
@@ -404,12 +416,12 @@ class AsyncSandbox(BaseAsyncSandbox):
                 headers["E2B-Traffic-Access-Token"] = self.traffic_access_token
 
             response = await self._client.post(
-                f"{self._jupyter_url}/contexts/{context_id}/restart",
+                self._jupyter_request_url(f"/contexts/{context_id}/restart"),
                 headers=headers,
                 timeout=self.connection_config.request_timeout,
             )
 
-            err = await aextract_exception(response)
+            err = await aextract_exception(response, self._include_diagnostics)
             if err:
                 raise err
         except httpx.TimeoutException:

{e2b_code_interpreter-2.9.1 → e2b_code_interpreter-2.10.0}/e2b_code_interpreter/code_interpreter_sync.py

@@ -1,7 +1,7 @@
 import logging
 import httpx
 
-from typing import Optional, Dict, overload, Union, List
+from typing import cast, Optional, Dict, overload, Union, List
 from httpx import Client
 from e2b import Sandbox as BaseSandbox, InvalidArgumentException
 from e2b.api.client_sync import get_transport
@@ -60,11 +60,23 @@ class Sandbox(BaseSandbox):
     def _jupyter_url(self) -> str:
         # Honors the `sandbox_url` option and the `E2B_SANDBOX_URL` environment
         # variable, same as the base SDK does for envd requests.
-        sandbox_url = self.connection_config._sandbox_url
+        sandbox_url = cast(Optional[str], self.connection_config._sandbox_url)
         if sandbox_url:
             return sandbox_url
         return f"{'http' if self.connection_config.debug else 'https'}://{self.get_host(JUPYTER_PORT)}"
 
+    def _jupyter_request_url(self, path: str) -> str:
+        url = f"{self._jupyter_url}{path}"
+        source = getattr(self.connection_config, "request_source", None)
+        if not source:
+            return url
+        separator = "&" if "?" in url else "?"
+        return f"{url}{separator}source={source}"
+
+    @property
+    def _include_diagnostics(self) -> bool:
+        return getattr(self.connection_config, "request_source", None) == "ci"
+
     @property
     def _client(self) -> Client:
         # TODO: Remove later
@@ -206,7 +218,7 @@ class Sandbox(BaseSandbox):
 
             with self._client.stream(
                 "POST",
-                f"{self._jupyter_url}/execute",
+                self._jupyter_request_url("/execute"),
                 json={
                     "code": code,
                     "context_id": context_id,
@@ -231,7 +243,7 @@ class Sandbox(BaseSandbox):
                     else httpx.Timeout(None)
                 ),
             ) as response:
-                err = extract_exception(response)
+                err = extract_exception(response, self._include_diagnostics)
                 if err:
                     raise err
 
@@ -289,13 +301,13 @@ class Sandbox(BaseSandbox):
                 headers["E2B-Traffic-Access-Token"] = self.traffic_access_token
 
             response = self._client.post(
-                f"{self._jupyter_url}/contexts",
+                self._jupyter_request_url("/contexts"),
                 json=data,
                 headers=headers,
                 timeout=request_timeout or self.connection_config.request_timeout,
             )
 
-            err = extract_exception(response)
+            err = extract_exception(response, self._include_diagnostics)
             if err:
                 raise err
 
@@ -330,12 +342,12 @@ class Sandbox(BaseSandbox):
                 headers["E2B-Traffic-Access-Token"] = self.traffic_access_token
 
             response = self._client.delete(
-                f"{self._jupyter_url}/contexts/{context_id}",
+                self._jupyter_request_url(f"/contexts/{context_id}"),
                 headers=headers,
                 timeout=self.connection_config.request_timeout,
             )
 
-            err = extract_exception(response)
+            err = extract_exception(response, self._include_diagnostics)
             if err:
                 raise err
         except httpx.TimeoutException:
@@ -360,12 +372,12 @@ class Sandbox(BaseSandbox):
                 headers["E2B-Traffic-Access-Token"] = self.traffic_access_token
 
             response = self._client.get(
-                f"{self._jupyter_url}/contexts",
+                self._jupyter_request_url("/contexts"),
                 headers=headers,
                 timeout=self.connection_config.request_timeout,
             )
 
-            err = extract_exception(response)
+            err = extract_exception(response, self._include_diagnostics)
             if err:
                 raise err
 
@@ -400,12 +412,12 @@ class Sandbox(BaseSandbox):
                 headers["E2B-Traffic-Access-Token"] = self.traffic_access_token
 
             response = self._client.post(
-                f"{self._jupyter_url}/contexts/{context_id}/restart",
+                self._jupyter_request_url(f"/contexts/{context_id}/restart"),
                 headers=headers,
                 timeout=self.connection_config.request_timeout,
             )
 
-            err = extract_exception(response)
+            err = extract_exception(response, self._include_diagnostics)
             if err:
                 raise err
         except httpx.TimeoutException:

{e2b_code_interpreter-2.9.1 → e2b_code_interpreter-2.10.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,
@@ -393,34 +400,41 @@ class Execution:
         return json.dumps(data)
 
 
-async def aextract_exception(res: Response):
+async def aextract_exception(res: Response, include_diagnostics: bool = False):
     if res.is_success:
         return None
 
     await res.aread()
-    return extract_exception(res)
+    return extract_exception(res, include_diagnostics)
 
 
-def extract_exception(res: Response):
+def extract_exception(res: Response, include_diagnostics: bool = False):
     if res.is_success:
         return None
 
     res.read()
-    return format_exception(res)
+    return format_exception(res, include_diagnostics)
 
 
-def format_exception(res: Response):
+def format_exception(res: Response, include_diagnostics: bool = False):
     if res.is_success:
         return None
 
+    body = res.text
+    trace_id = res.headers.get("X-E2B-Trace-ID") if include_diagnostics else None
+    trace_suffix = f" (trace_id={trace_id})" if trace_id else ""
+
     if res.status_code == 404:
-        return NotFoundException(res.text)
+        return NotFoundException(f"{body}{trace_suffix}")
     elif res.status_code == 502:
         return TimeoutException(
-            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."
+            f"{body}: 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.{trace_suffix}"
         )
     else:
-        return SandboxException(f"{res.status_code}: {res.text}")
+        body_separator = "" if trace_suffix and not body else " "
+        return SandboxException(
+            f"{res.status_code}:{body_separator}{body}{trace_suffix}"
+        )
 
 
 def parse_output(
@@ -510,7 +524,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.10.0/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "e2b-code-interpreter"
+version = "2.10.0"
+description = "E2B Code Interpreter - Stateful code execution"
+authors = [{ name = "e2b", email = "hello@e2b.dev" }]
+license = "MIT"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "httpx>=0.20.0,<1.0.0",
+    "attrs>=21.3.0",
+    "e2b>=2.44.0,<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.9.1/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.9.1/PKG-INFO

@@ -1,72 +0,0 @@
-Metadata-Version: 2.3
-Name: e2b-code-interpreter
-Version: 2.9.1
-Summary: E2B Code Interpreter - Stateful code execution
-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.39.1,<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: Homepage, https://e2b.dev/
-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.9.1/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.9.1/pyproject.toml

@@ -1,37 +0,0 @@
-[tool.poetry]
-name = "e2b-code-interpreter"
-version = "2.9.1"
-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.39.1"
-
-[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"]