e2b-code-interpreter 0.0.11b47__tar.gz → 1.0.1__tar.gz

e2b_code_interpreter-1.0.1/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.1
+Name: e2b-code-interpreter
+Version: 1.0.1
+Summary: E2B Code Interpreter - Stateful code execution
+Home-page: https://e2b.dev/
+License: Apache-2.0
+Author: e2b
+Author-email: hello@e2b.dev
+Requires-Python: >=3.8,<4.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: attrs (>=21.3.0)
+Requires-Dist: e2b (>=1.0.0,<2.0.0)
+Requires-Dist: httpx (>=0.20.0,<0.28.0)
+Project-URL: Bug Tracker, https://github.com/e2b-dev/code-interpreter/issues
+Project-URL: Repository, https://github.com/e2b-dev/e2b-code-interpreter/tree/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() 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-1.0.1/README.md

@@ -0,0 +1,49 @@
+<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() 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-0.0.11b47/e2b_code_interpreter/graphs.py → e2b_code_interpreter-1.0.1/e2b_code_interpreter/charts.py

@@ -2,9 +2,9 @@ import enum
 from typing import List, Tuple, Any, Optional, Union
 
 
-class GraphType(str, enum.Enum):
+class ChartType(str, enum.Enum):
     """
-    Graph types
+    Chart types
     """
 
     LINE = "line"
@@ -12,7 +12,7 @@ class GraphType(str, enum.Enum):
     BAR = "bar"
     PIE = "pie"
     BOX_AND_WHISKER = "box_and_whisker"
-    SUPERGRAPH = "supergraph"
+    SUPERCHART = "superchart"
     UNKNOWN = "unknown"
 
 
@@ -33,23 +33,23 @@ class ScaleType(str, enum.Enum):
     UNKNOWN = "unknown"
 
 
-class Graph:
+class Chart:
     """
-    Extracted data from a graph. It's useful for building an interactive graphs or custom visualizations.
+    Extracted data from a chart. It's useful for building an interactive charts or custom visualizations.
     """
 
-    type: GraphType
+    type: ChartType
     title: str
 
     elements: List[Any]
 
     def __init__(self, **kwargs):
-        self.type = GraphType(kwargs["type"] or GraphType.UNKNOWN)
+        self.type = ChartType(kwargs["type"] or ChartType.UNKNOWN)
         self.title = kwargs["title"]
         self.elements = kwargs["elements"]
 
 
-class Graph2D(Graph):
+class Chart2D(Chart):
     x_label: Optional[str]
     y_label: Optional[str]
     x_unit: Optional[str]
@@ -72,7 +72,7 @@ class PointData:
         self.points = [(x, y) for x, y in kwargs["points"]]
 
 
-class PointGraph(Graph2D):
+class PointChart(Chart2D):
     x_ticks: List[Union[str, float]]
     x_tick_labels: List[str]
     x_scale: ScaleType
@@ -108,12 +108,12 @@ class PointGraph(Graph2D):
         self.elements = [PointData(**d) for d in kwargs["elements"]]
 
 
-class LineGraph(PointGraph):
-    type = GraphType.LINE
+class LineChart(PointChart):
+    type = ChartType.LINE
 
 
-class ScatterGraph(PointGraph):
-    type = GraphType.SCATTER
+class ScatterChart(PointChart):
+    type = ChartType.SCATTER
 
 
 class BarData:
@@ -127,8 +127,8 @@ class BarData:
         self.group = kwargs["group"]
 
 
-class BarGraph(Graph2D):
-    type = GraphType.BAR
+class BarChart(Chart2D):
+    type = ChartType.BAR
 
     elements: List[BarData]
 
@@ -148,8 +148,8 @@ class PieData:
         self.radius = kwargs["radius"]
 
 
-class PieGraph(Graph):
-    type = GraphType.PIE
+class PieChart(Chart):
+    type = ChartType.PIE
 
     elements: List[PieData]
 
@@ -175,8 +175,8 @@ class BoxAndWhiskerData:
         self.max = kwargs["max"]
 
 
-class BoxAndWhiskerGraph(Graph2D):
-    type = GraphType.BOX_AND_WHISKER
+class BoxAndWhiskerChart(Chart2D):
+    type = ChartType.BOX_AND_WHISKER
 
     elements: List[BoxAndWhiskerData]
 
@@ -185,40 +185,40 @@ class BoxAndWhiskerGraph(Graph2D):
         self.elements = [BoxAndWhiskerData(**d) for d in kwargs["elements"]]
 
 
-class SuperGraph(Graph):
-    type = GraphType.SUPERGRAPH
+class SuperChart(Chart):
+    type = ChartType.SUPERCHART
 
     elements: List[
-        Union[LineGraph, ScatterGraph, BarGraph, PieGraph, BoxAndWhiskerGraph]
+        Union[LineChart, ScatterChart, BarChart, PieChart, BoxAndWhiskerChart]
     ]
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        self.elements = [deserialize_graph(g) for g in kwargs["elements"]]
+        self.elements = [_deserialize_chart(g) for g in kwargs["elements"]]
 
 
-GraphTypes = Union[
-    LineGraph, ScatterGraph, BarGraph, PieGraph, BoxAndWhiskerGraph, SuperGraph
+ChartTypes = Union[
+    LineChart, ScatterChart, BarChart, PieChart, BoxAndWhiskerChart, SuperChart
 ]
 
 
-def deserialize_graph(data: Optional[dict]) -> Optional[GraphTypes]:
+def _deserialize_chart(data: Optional[dict]) -> Optional[ChartTypes]:
     if not data:
         return None
 
-    if data["type"] == GraphType.LINE:
-        graph = LineGraph(**data)
-    elif data["type"] == GraphType.SCATTER:
-        graph = ScatterGraph(**data)
-    elif data["type"] == GraphType.BAR:
-        graph = BarGraph(**data)
-    elif data["type"] == GraphType.PIE:
-        graph = PieGraph(**data)
-    elif data["type"] == GraphType.BOX_AND_WHISKER:
-        graph = BoxAndWhiskerGraph(**data)
-    elif data["type"] == GraphType.SUPERGRAPH:
-        graph = SuperGraph(**data)
+    if data["type"] == ChartType.LINE:
+        chart = LineChart(**data)
+    elif data["type"] == ChartType.SCATTER:
+        chart = ScatterChart(**data)
+    elif data["type"] == ChartType.BAR:
+        chart = BarChart(**data)
+    elif data["type"] == ChartType.PIE:
+        chart = PieChart(**data)
+    elif data["type"] == ChartType.BOX_AND_WHISKER:
+        chart = BoxAndWhiskerChart(**data)
+    elif data["type"] == ChartType.SUPERCHART:
+        chart = SuperChart(**data)
     else:
-        graph = Graph(**data)
+        chart = Chart(**data)
 
-    return graph
+    return chart

{e2b_code_interpreter-0.0.11b47 → e2b_code_interpreter-1.0.1}/e2b_code_interpreter/code_interpreter_async.py

@@ -1,7 +1,7 @@
 import logging
 import httpx
 
-from typing import Optional, Dict, overload
+from typing import Optional, Dict, overload, Union, Literal
 from httpx import AsyncClient
 
 from e2b import (
@@ -17,6 +17,7 @@ from e2b_code_interpreter.constants import (
 )
 from e2b_code_interpreter.models import (
     Execution,
+    ExecutionError,
     Context,
     Result,
     aextract_exception,
@@ -33,6 +34,27 @@ logger = logging.getLogger(__name__)
 
 
 class AsyncSandbox(BaseAsyncSandbox):
+    """
+    E2B cloud sandbox is a secure and isolated cloud environment.
+
+    The sandbox allows you to:
+    - Access Linux OS
+    - Create, list, and delete files and directories
+    - Run commands
+    - Run isolated code
+    - Access the internet
+
+    Check docs [here](https://e2b.dev/docs).
+
+    Use the `AsyncSandbox.create()` to create a new sandbox.
+
+    Example:
+    ```python
+    from e2b_code_interpreter import AsyncSandbox
+    sandbox = await AsyncSandbox.create()
+    ```
+    """
+
     default_template = DEFAULT_TEMPLATE
 
     def __init__(self, sandbox_id: str, connection_config: ConnectionConfig):
@@ -50,55 +72,118 @@ class AsyncSandbox(BaseAsyncSandbox):
     async def run_code(
         self,
         code: str,
-        language: Optional[str] = None,
+        language: Union[Literal["python"], None] = None,
         on_stdout: Optional[OutputHandler[OutputMessage]] = None,
         on_stderr: Optional[OutputHandler[OutputMessage]] = None,
         on_result: Optional[OutputHandler[Result]] = None,
+        on_error: Optional[OutputHandler[ExecutionError]] = None,
         envs: Optional[Dict[str, str]] = None,
         timeout: Optional[float] = None,
         request_timeout: Optional[float] = None,
-    ) -> Execution: ...
+    ) -> Execution:
+        """
+        Runs the code as Python.
+
+        Specify the `language` or `context` option to run the code as a different language or in a different `Context`.
+
+        You can reference previously defined variables, imports, and functions in the code.
+
+        :param code: Code to execute
+        :param language: Language to use for code execution. If not defined, the default Python context is used.
+        :param on_stdout: Callback for stdout messages
+        :param on_stderr: Callback for stderr messages
+        :param on_result: Callback for the `Result` object
+        :param on_error: Callback for the `ExecutionError` object
+        :param envs: Custom environment variables
+        :param timeout: Timeout for the code execution in **seconds**
+        :param request_timeout: Timeout for the request in **seconds**
+
+        :return: `Execution` result object
+        """
+        ...
 
     @overload
     async def run_code(
         self,
         code: str,
-        context: Optional[Context] = None,
+        language: Optional[str] = None,
         on_stdout: Optional[OutputHandler[OutputMessage]] = None,
         on_stderr: Optional[OutputHandler[OutputMessage]] = None,
         on_result: Optional[OutputHandler[Result]] = None,
+        on_error: Optional[OutputHandler[ExecutionError]] = None,
         envs: Optional[Dict[str, str]] = None,
         timeout: Optional[float] = None,
         request_timeout: Optional[float] = None,
-    ) -> Execution: ...
+    ) -> Execution:
+        """
+        Runs the code for the specified language.
+
+        Specify the `language` or `context` option to run the code as a different language or in a different `Context`.
+        If no language is specified, Python is used.
+
+        You can reference previously defined variables, imports, and functions in the code.
+
+        :param code: Code to execute
+        :param language: Language to use for code execution. If not defined, the default Python context is used.
+        :param on_stdout: Callback for stdout messages
+        :param on_stderr: Callback for stderr messages
+        :param on_result: Callback for the `Result` object
+        :param on_error: Callback for the `ExecutionError` object
+        :param envs: Custom environment variables
+        :param timeout: Timeout for the code execution in **seconds**
+        :param request_timeout: Timeout for the request in **seconds**
 
+        :return: `Execution` result object
+        """
+        ...
+
+    @overload
     async def run_code(
         self,
         code: str,
-        language: Optional[str] = None,
         context: Optional[Context] = None,
         on_stdout: Optional[OutputHandler[OutputMessage]] = None,
         on_stderr: Optional[OutputHandler[OutputMessage]] = None,
         on_result: Optional[OutputHandler[Result]] = None,
+        on_error: Optional[OutputHandler[ExecutionError]] = None,
         envs: Optional[Dict[str, str]] = None,
         timeout: Optional[float] = None,
         request_timeout: Optional[float] = None,
     ) -> Execution:
         """
-        Runs the code in the specified language/context, if not specified, the default context is used.
+        Runs the code in the specified context, if not specified, the default context is used.
+
+        Specify the `language` or `context` option to run the code as a different language or in a different `Context`.
+
         You can reference previously defined variables, imports, and functions in the code.
 
-        :param code: The code to execute
-        :param language Based on the value, a default context for the language is used. If not defined and no context is provided, the default Python context is used.
-        :param context Concrete context to run the code in. If not specified, the default context for the language is used. It's mutually exclusive with the language.
+        :param code: Code to execute
+        :param context: Concrete context to run the code in. If not specified, the default context for the language is used. It's mutually exclusive with the language.
         :param on_stdout: Callback for stdout messages
         :param on_stderr: Callback for stderr messages
         :param on_result: Callback for the `Result` object
-        :param envs: Environment variables
-        :param timeout: Max time to wait for the execution to finish
-        :param request_timeout: Max time to wait for the request to finish
-        :return: Execution object
+        :param on_error: Callback for the `ExecutionError` object
+        :param envs: Custom environment variables
+        :param timeout: Timeout for the code execution in **seconds**
+        :param request_timeout: Timeout for the request in **seconds**
+
+        :return: `Execution` result object
         """
+        ...
+
+    async def run_code(
+        self,
+        code: str,
+        language: Optional[str] = None,
+        context: Optional[Context] = None,
+        on_stdout: Optional[OutputHandler[OutputMessage]] = None,
+        on_stderr: Optional[OutputHandler[OutputMessage]] = None,
+        on_result: Optional[OutputHandler[Result]] = None,
+        on_error: Optional[OutputHandler[ExecutionError]] = None,
+        envs: Optional[Dict[str, str]] = None,
+        timeout: Optional[float] = None,
+        request_timeout: Optional[float] = None,
+    ) -> Execution:
         logger.debug(f"Executing code {code}")
 
         if context and language:
@@ -136,6 +221,7 @@ class AsyncSandbox(BaseAsyncSandbox):
                         on_stdout=on_stdout,
                         on_stderr=on_stderr,
                         on_result=on_result,
+                        on_error=on_error,
                     )
 
                 return execution
@@ -148,17 +234,16 @@ class AsyncSandbox(BaseAsyncSandbox):
         self,
         cwd: Optional[str] = None,
         language: Optional[str] = None,
-        envs: Optional[Dict[str, str]] = None,
         request_timeout: Optional[float] = None,
     ) -> Context:
         """
         Creates a new context to run code in.
 
-        :param cwd: Set the current working directory for the context
-        :param language: Language of the context. If not specified, the default Python context is used.
-        :param envs: Environment variables
-        :param request_timeout: Max time to wait for the request to finish
-        :return: Context id
+        :param cwd: Set the current working directory for the context, defaults to `/home/user`
+        :param language: Language of the context. If not specified, defaults to Python
+        :param request_timeout: Timeout for the request in **milliseconds**
+
+        :return: Context object
         """
         logger.debug(f"Creating new {language} context")
 
@@ -167,8 +252,6 @@ class AsyncSandbox(BaseAsyncSandbox):
             data["language"] = language
         if cwd:
             data["cwd"] = cwd
-        if envs:
-            data["env_vars"] = envs
 
         try:
             response = await self._client.post(

{e2b_code_interpreter-0.0.11b47 → e2b_code_interpreter-1.0.1}/e2b_code_interpreter/code_interpreter_sync.py

@@ -1,7 +1,7 @@
 import logging
 import httpx
 
-from typing import Optional, Dict, overload
+from typing import Optional, Dict, overload, Literal, Union
 from httpx import Client
 from e2b import Sandbox as BaseSandbox, InvalidArgumentException
 
@@ -11,6 +11,7 @@ from e2b_code_interpreter.constants import (
     DEFAULT_TIMEOUT,
 )
 from e2b_code_interpreter.models import (
+    ExecutionError,
     Execution,
     Context,
     Result,
@@ -28,6 +29,28 @@ logger = logging.getLogger(__name__)
 
 
 class Sandbox(BaseSandbox):
+    """
+    E2B cloud sandbox is a secure and isolated cloud environment.
+
+    The sandbox allows you to:
+    - Access Linux OS
+    - Create, list, and delete files and directories
+    - Run commands
+    - Run isolated code
+    - Access the internet
+
+    Check docs [here](https://e2b.dev/docs).
+
+    Use the `Sandbox()` to create a new sandbox.
+
+    Example:
+    ```python
+    from e2b_code_interpreter import Sandbox
+
+    sandbox = Sandbox()
+    ```
+    """
+
     default_template = DEFAULT_TEMPLATE
 
     @property
@@ -42,56 +65,118 @@ class Sandbox(BaseSandbox):
     def run_code(
         self,
         code: str,
-        language: Optional[str] = None,
+        language: Union[Literal["python"], None] = None,
         on_stdout: Optional[OutputHandler[OutputMessage]] = None,
         on_stderr: Optional[OutputHandler[OutputMessage]] = None,
         on_result: Optional[OutputHandler[Result]] = None,
+        on_error: Optional[OutputHandler[ExecutionError]] = None,
         envs: Optional[Dict[str, str]] = None,
         timeout: Optional[float] = None,
         request_timeout: Optional[float] = None,
-    ) -> Execution: ...
+    ) -> Execution:
+        """
+        Runs the code as Python.
+
+        Specify the `language` or `context` option to run the code as a different language or in a different `Context`.
+
+        You can reference previously defined variables, imports, and functions in the code.
+
+        :param code: Code to execute
+        :param language: Language to use for code execution. If not defined, the default Python context is used.
+        :param on_stdout: Callback for stdout messages
+        :param on_stderr: Callback for stderr messages
+        :param on_result: Callback for the `Result` object
+        :param on_error: Callback for the `ExecutionError` object
+        :param envs: Custom environment variables
+        :param timeout: Timeout for the code execution in **seconds**
+        :param request_timeout: Timeout for the request in **seconds**
+
+        :return: `Execution` result object
+        """
+        ...
 
     @overload
     def run_code(
         self,
         code: str,
-        context: Optional[Context] = None,
+        language: Optional[str] = None,
         on_stdout: Optional[OutputHandler[OutputMessage]] = None,
         on_stderr: Optional[OutputHandler[OutputMessage]] = None,
         on_result: Optional[OutputHandler[Result]] = None,
+        on_error: Optional[OutputHandler[ExecutionError]] = None,
         envs: Optional[Dict[str, str]] = None,
         timeout: Optional[float] = None,
         request_timeout: Optional[float] = None,
-    ) -> Execution: ...
+    ) -> Execution:
+        """
+        Runs the code for the specified language.
+
+        Specify the `language` or `context` option to run the code as a different language or in a different `Context`.
+        If no language is specified, Python is used.
+
+        You can reference previously defined variables, imports, and functions in the code.
 
+        :param code: Code to execute
+        :param language: Language to use for code execution. If not defined, the default Python context is used.
+        :param on_stdout: Callback for stdout messages
+        :param on_stderr: Callback for stderr messages
+        :param on_result: Callback for the `Result` object
+        :param on_error: Callback for the `ExecutionError` object
+        :param envs: Custom environment variables
+        :param timeout: Timeout for the code execution in **seconds**
+        :param request_timeout: Timeout for the request in **seconds**
+
+        :return: `Execution` result object
+        """
+        ...
+
+    @overload
     def run_code(
         self,
         code: str,
-        language: Optional[str] = None,
         context: Optional[Context] = None,
         on_stdout: Optional[OutputHandler[OutputMessage]] = None,
         on_stderr: Optional[OutputHandler[OutputMessage]] = None,
         on_result: Optional[OutputHandler[Result]] = None,
+        on_error: Optional[OutputHandler[ExecutionError]] = None,
         envs: Optional[Dict[str, str]] = None,
         timeout: Optional[float] = None,
         request_timeout: Optional[float] = None,
     ) -> Execution:
         """
-        Runs the code in the specified language/context, if not specified, the default context is used.
+        Runs the code in the specified context, if not specified, the default context is used.
+
+        Specify the `language` or `context` option to run the code as a different language or in a different `Context`.
+
         You can reference previously defined variables, imports, and functions in the code.
 
-        :param code: The code to execute
-        :param language Based on the value, a default context for the language is used. If not defined and no context is provided, the default Python context is used.
-        :param context Concrete context to run the code in. If not specified, the default context for the language is used. It's mutually exclusive with the language.
+        :param code: Code to execute
+        :param context: Concrete context to run the code in. If not specified, the default context for the language is used. It's mutually exclusive with the language.
         :param on_stdout: Callback for stdout messages
         :param on_stderr: Callback for stderr messages
         :param on_result: Callback for the `Result` object
-        :param envs: Environment variables
-        :param timeout: Max time to wait for the execution to finish
-        :param request_timeout: Max time to wait for the request to finish
-        :return: Execution object
+        :param on_error: Callback for the `ExecutionError` object
+        :param envs: Custom environment variables
+        :param timeout: Timeout for the code execution in **seconds**
+        :param request_timeout: Timeout for the request in **seconds**
+
+        :return: `Execution` result object
         """
+        ...
 
+    def run_code(
+        self,
+        code: str,
+        language: Optional[str] = None,
+        context: Optional[Context] = None,
+        on_stdout: Optional[OutputHandler[OutputMessage]] = None,
+        on_stderr: Optional[OutputHandler[OutputMessage]] = None,
+        on_result: Optional[OutputHandler[Result]] = None,
+        on_error: Optional[OutputHandler[ExecutionError]] = None,
+        envs: Optional[Dict[str, str]] = None,
+        timeout: Optional[float] = None,
+        request_timeout: Optional[float] = None,
+    ) -> Execution:
         logger.debug(f"Executing code {code}")
 
         if language and context:
@@ -128,6 +213,7 @@ class Sandbox(BaseSandbox):
                         on_stdout=on_stdout,
                         on_stderr=on_stderr,
                         on_result=on_result,
+                        on_error=on_error,
                     )
 
                 return execution
@@ -140,17 +226,16 @@ class Sandbox(BaseSandbox):
         self,
         cwd: Optional[str] = None,
         language: Optional[str] = None,
-        envs: Optional[Dict[str, str]] = None,
         request_timeout: Optional[float] = None,
     ) -> Context:
         """
         Creates a new context to run code in.
 
-        :param cwd: Set the current working directory for the context
-        :param language: Language of the context. If not specified, the default Python context is used.
-        :param envs: Environment variables
-        :param request_timeout: Max time to wait for the request to finish
-        :return: Context id
+        :param cwd: Set the current working directory for the context, defaults to `/home/user`
+        :param language: Language of the context. If not specified, defaults to Python
+        :param request_timeout: Timeout for the request in **milliseconds**
+
+        :return: Context object
         """
         logger.debug(f"Creating new {language} context")
 
@@ -159,8 +244,6 @@ class Sandbox(BaseSandbox):
             data["language"] = language
         if cwd:
             data["cwd"] = cwd
-        if envs:
-            data["env_vars"] = envs
 
         try:
             response = self._client.post(

{e2b_code_interpreter-0.0.11b47 → e2b_code_interpreter-1.0.1}/e2b_code_interpreter/constants.py

@@ -1,3 +1,3 @@
-DEFAULT_TEMPLATE = "code-interpreter-beta"
+DEFAULT_TEMPLATE = "code-interpreter-v1"
 JUPYTER_PORT = 49999
 DEFAULT_TIMEOUT = 300

{e2b_code_interpreter-0.0.11b47 → e2b_code_interpreter-1.0.1}/e2b_code_interpreter/models.py

@@ -17,7 +17,7 @@ from typing import (
 
 from httpx import Response
 
-from .graphs import Graph, deserialize_graph
+from .charts import Chart, _deserialize_chart
 
 T = TypeVar("T")
 OutputHandler = Union[
@@ -30,12 +30,22 @@ logger = logging.getLogger(__name__)
 
 @dataclass
 class OutputMessage:
+    """
+    Represents an output message from the sandbox code execution.
+    """
+
     line: str
+    """
+    The output line.
+    """
     timestamp: int
     """
     Unix epoch in nanoseconds
     """
     error: bool = False
+    """
+    Whether the output is an error.
+    """
 
     def __str__(self):
         return self.line
@@ -49,8 +59,17 @@ class ExecutionError:
     """
 
     name: str
+    """
+    Name of the error.
+    """
     value: str
+    """
+    Value of the error.
+    """
     traceback: str
+    """
+    The raw traceback of the error.
+    """
 
     def __init__(self, name: str, value: str, traceback: str, **kwargs):
         self.name = name
@@ -96,7 +115,7 @@ class Result:
     json: Optional[dict] = None
     javascript: Optional[str] = None
     data: Optional[dict] = None
-    graph: Optional[Graph] = None
+    chart: Optional[Chart] = None
     is_main_result: bool = False
     """Whether this data is the result of the cell. Data can be produced by display calls of which can be multiple in a cell."""
     extra: Optional[dict] = None
@@ -115,7 +134,7 @@ class Result:
         json: Optional[dict] = None,
         javascript: Optional[str] = None,
         data: Optional[dict] = None,
-        graph: Optional[dict] = None,
+        chart: Optional[dict] = None,
         is_main_result: bool = False,
         extra: Optional[dict] = None,
         **kwargs,  # Allows for future expansion
@@ -131,12 +150,12 @@ class Result:
         self.json = json
         self.javascript = javascript
         self.data = data
-        if graph:
+        if chart:
             try:
-                self.graph = deserialize_graph(graph)
+                self.chart = _deserialize_chart(chart)
             except Exception as e:
                 logger.error(
-                    f"Error deserializing graph, check if you are using the latest version of the library: {e}"
+                    f"Error deserializing chart, check if you are using the latest version of the library: {e}"
                 )
         self.is_main_result = is_main_result
         self.extra = extra
@@ -170,8 +189,8 @@ class Result:
             formats.append("javascript")
         if self.data:
             formats.append("data")
-        if self.graph:
-            formats.append("graph")
+        if self.chart:
+            formats.append("chart")
 
         if self.extra:
             for key in self.extra:
@@ -394,6 +413,7 @@ def parse_output(
     on_stdout: Optional[OutputHandler[OutputMessage]] = None,
     on_stderr: Optional[OutputHandler[OutputMessage]] = None,
     on_result: Optional[OutputHandler[Result]] = None,
+    on_error: Optional[OutputHandler[ExecutionError]] = None,
 ):
     data = json.loads(output)
     data_type = data.pop("type")
@@ -413,15 +433,30 @@ def parse_output(
             on_stderr(OutputMessage(data["text"], data["timestamp"], True))
     elif data_type == "error":
         execution.error = ExecutionError(data["name"], data["value"], data["traceback"])
+        if on_error:
+            on_error(execution.error)
     elif data_type == "number_of_executions":
         execution.execution_count = data["execution_count"]
 
 
 @dataclass
 class Context:
+    """
+    Represents a context for code execution.
+    """
+
     id: str
+    """
+    The ID of the context.
+    """
     language: str
+    """
+    The language of the context.
+    """
     cwd: str
+    """
+    The working directory of the context.
+    """
 
     def __init__(self, context_id: str, language: str, cwd: str, **kwargs):
         self.id = context_id

{e2b_code_interpreter-0.0.11b47 → e2b_code_interpreter-1.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "e2b-code-interpreter"
-version = "0.0.11b47"
+version = "1.0.1"
 description = "E2B Code Interpreter - Stateful code execution"
 authors = ["e2b <hello@e2b.dev>"]
 license = "Apache-2.0"
@@ -14,7 +14,7 @@ python = "^3.8"
 
 httpx = ">=0.20.0,<0.28.0"
 attrs = ">=21.3.0"
-e2b = "^0.17.2a50"
+e2b = "^1.0.0"
 
 [tool.poetry.group.dev.dependencies]
 black = "^24.3.0"

e2b_code_interpreter-0.0.11b47/PKG-INFO

@@ -1,114 +0,0 @@
-Metadata-Version: 2.1
-Name: e2b-code-interpreter
-Version: 0.0.11b47
-Summary: E2B Code Interpreter - Stateful code execution
-Home-page: https://e2b.dev/
-License: Apache-2.0
-Author: e2b
-Author-email: hello@e2b.dev
-Requires-Python: >=3.8,<4.0
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: attrs (>=21.3.0)
-Requires-Dist: e2b (>=0.17.2a50,<0.18.0)
-Requires-Dist: httpx (>=0.20.0,<0.28.0)
-Project-URL: Bug Tracker, https://github.com/e2b-dev/code-interpreter/issues
-Project-URL: Repository, https://github.com/e2b-dev/e2b-code-interpreter/tree/python
-Description-Content-Type: text/markdown
-
-# Code interpreter extension for Python
-
-The repository contains a template and modules for the code interpreter sandbox. It is based on the Jupyter server and implements the Jupyter Kernel messaging protocol. This allows for sharing context between code executions and improves support for plotting charts and other display-able data.
-
-## Key Features
-
-- **Stateful Execution**: Unlike traditional sandboxes that treat each code execution independently, this package maintains context across executions.
-- **Displaying Graph & Data**: Implements parts of the [Jupyter Kernel messaging protocol](https://jupyter-client.readthedocs.io/en/latest/messaging.html), which support for interactive features like plotting charts, rendering DataFrames, etc.
-
-## Installation
-
-```sh
-pip install e2b-code-interpreter
-```
-
-## Examples
-
-### Minimal example with the sharing context
-
-```python
-from e2b_code_interpreter import Sandbox
-
-with Sandbox() as sandbox:
-    sandbox.run_code("x = 1")
-
-    execution = sandbox.run_code("x+=1; x")
-    print(execution.text)  # outputs 2
-
-```
-
-### Get charts and any display-able data
-
-```python
-import base64
-import io
-
-from matplotlib import image as mpimg, pyplot as plt
-
-from e2b_code_interpreter import Sandbox
-
-code = """
-import matplotlib.pyplot as plt
-import numpy as np
-
-x = np.linspace(0, 20, 100)
-y = np.sin(x)
-
-plt.plot(x, y)
-plt.show()
-"""
-
-with Sandbox() as sandbox:
-    # you can install dependencies in "jupyter notebook style"
-    sandbox.run_code("!pip install matplotlib")
-
-    # plot random graph
-    execution = sandbox.run_code(code)
-
-# there's your image
-image = execution.results[0].png
-
-# example how to show the image / prove it works
-i = base64.b64decode(image)
-i = io.BytesIO(i)
-i = mpimg.imread(i, format='PNG')
-
-plt.imshow(i, interpolation='nearest')
-plt.show()
-```
-
-### Streaming code output
-
-```python
-from e2b_code_interpreter import Sandbox
-
-code = """
-import time
-import pandas as pd
-
-print("hello")
-time.sleep(3)
-data = pd.DataFrame(data=[[1, 2], [3, 4]], columns=["A", "B"])
-display(data.head(10))
-time.sleep(3)
-print("world")
-"""
-
-with Sandbox() as sandbox:
-    sandbox.run_code(code, on_stdout=print, on_stderr=print, on_result=(lambda result: print(result.text)))
-```
-

e2b_code_interpreter-0.0.11b47/README.md

@@ -1,90 +0,0 @@
-# Code interpreter extension for Python
-
-The repository contains a template and modules for the code interpreter sandbox. It is based on the Jupyter server and implements the Jupyter Kernel messaging protocol. This allows for sharing context between code executions and improves support for plotting charts and other display-able data.
-
-## Key Features
-
-- **Stateful Execution**: Unlike traditional sandboxes that treat each code execution independently, this package maintains context across executions.
-- **Displaying Graph & Data**: Implements parts of the [Jupyter Kernel messaging protocol](https://jupyter-client.readthedocs.io/en/latest/messaging.html), which support for interactive features like plotting charts, rendering DataFrames, etc.
-
-## Installation
-
-```sh
-pip install e2b-code-interpreter
-```
-
-## Examples
-
-### Minimal example with the sharing context
-
-```python
-from e2b_code_interpreter import Sandbox
-
-with Sandbox() as sandbox:
-    sandbox.run_code("x = 1")
-
-    execution = sandbox.run_code("x+=1; x")
-    print(execution.text)  # outputs 2
-
-```
-
-### Get charts and any display-able data
-
-```python
-import base64
-import io
-
-from matplotlib import image as mpimg, pyplot as plt
-
-from e2b_code_interpreter import Sandbox
-
-code = """
-import matplotlib.pyplot as plt
-import numpy as np
-
-x = np.linspace(0, 20, 100)
-y = np.sin(x)
-
-plt.plot(x, y)
-plt.show()
-"""
-
-with Sandbox() as sandbox:
-    # you can install dependencies in "jupyter notebook style"
-    sandbox.run_code("!pip install matplotlib")
-
-    # plot random graph
-    execution = sandbox.run_code(code)
-
-# there's your image
-image = execution.results[0].png
-
-# example how to show the image / prove it works
-i = base64.b64decode(image)
-i = io.BytesIO(i)
-i = mpimg.imread(i, format='PNG')
-
-plt.imshow(i, interpolation='nearest')
-plt.show()
-```
-
-### Streaming code output
-
-```python
-from e2b_code_interpreter import Sandbox
-
-code = """
-import time
-import pandas as pd
-
-print("hello")
-time.sleep(3)
-data = pd.DataFrame(data=[[1, 2], [3, 4]], columns=["A", "B"])
-display(data.head(10))
-time.sleep(3)
-print("world")
-"""
-
-with Sandbox() as sandbox:
-    sandbox.run_code(code, on_stdout=print, on_stderr=print, on_result=(lambda result: print(result.text)))
-```