e2b-code-interpreter 0.0.1a1__tar.gz → 0.0.2__tar.gz

{e2b_code_interpreter-0.0.1a1 → e2b_code_interpreter-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: e2b-code-interpreter
-Version: 0.0.1a1
+Version: 0.0.2
 Summary: E2B Code Interpreter - Stateful code execution
 Home-page: https://e2b.dev/
 License: Apache-2.0
@@ -13,6 +13,7 @@ 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: e2b (>=0.14.11)
 Requires-Dist: pydantic (>1,<3)
 Requires-Dist: websocket-client (>=1.7.0,<2.0.0)
@@ -43,10 +44,10 @@ pip install e2b-code-interpreter
 from e2b_code_interpreter import CodeInterpreter
 
 with CodeInterpreter() as sandbox:
-    sandbox.exec_cell("x = 1")
+    sandbox.notebook.exec_cell("x = 1")
 
-    result = sandbox.exec_cell("x += 1; x")
-    print(result.text)  # outputs 2
+    execution = sandbox.notebook.exec_cell("x+=1; x")
+    print(execution.text)  # outputs 2
 
 ```
 
@@ -73,21 +74,21 @@ plt.show()
 
 with CodeInterpreter() as sandbox:
     # you can install dependencies in "jupyter notebook style"
-    sandbox.exec_cell("!pip install matplotlib")
+    sandbox.notebook.exec_cell("!pip install matplotlib")
 
     # plot random graph
-    result = sandbox.exec_cell(code)
+    execution = sandbox.notebook.exec_cell(code)
 
-    # there's your image
-    image = result.display_data[0]["image/png"]
+# 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')
+# 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()
+plt.imshow(i, interpolation='nearest')
+plt.show()
 ```
 
 ### Streaming code output
@@ -97,14 +98,18 @@ from e2b_code_interpreter import CodeInterpreter
 
 code = """
 import time
+import pandas as pd
 
 print("hello")
-time.sleep(5)
+time.sleep(3)
+data = pd.DataFrame(data=[[1, 2], [3, 4]], columns=["A", "B"])
+display(data.head(10))
+time.sleep(3)
 print("world")
 """
 
 with CodeInterpreter() as sandbox:
-    sandbox.exec_cell(code, on_stdout=print, on_stderr=print)
+    sandbox.notebook.exec_cell(code, on_stdout=print, on_stderr=print, on_result=(lambda result: print(result.text)))
 ```
 
 ### Pre-installed Python packages inside the sandbox

{e2b_code_interpreter-0.0.1a1 → e2b_code_interpreter-0.0.2}/README.md

@@ -21,10 +21,10 @@ pip install e2b-code-interpreter
 from e2b_code_interpreter import CodeInterpreter
 
 with CodeInterpreter() as sandbox:
-    sandbox.exec_cell("x = 1")
+    sandbox.notebook.exec_cell("x = 1")
 
-    result = sandbox.exec_cell("x += 1; x")
-    print(result.text)  # outputs 2
+    execution = sandbox.notebook.exec_cell("x+=1; x")
+    print(execution.text)  # outputs 2
 
 ```
 
@@ -51,21 +51,21 @@ plt.show()
 
 with CodeInterpreter() as sandbox:
     # you can install dependencies in "jupyter notebook style"
-    sandbox.exec_cell("!pip install matplotlib")
+    sandbox.notebook.exec_cell("!pip install matplotlib")
 
     # plot random graph
-    result = sandbox.exec_cell(code)
+    execution = sandbox.notebook.exec_cell(code)
 
-    # there's your image
-    image = result.display_data[0]["image/png"]
+# 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')
+# 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()
+plt.imshow(i, interpolation='nearest')
+plt.show()
 ```
 
 ### Streaming code output
@@ -75,14 +75,18 @@ from e2b_code_interpreter import CodeInterpreter
 
 code = """
 import time
+import pandas as pd
 
 print("hello")
-time.sleep(5)
+time.sleep(3)
+data = pd.DataFrame(data=[[1, 2], [3, 4]], columns=["A", "B"])
+display(data.head(10))
+time.sleep(3)
 print("world")
 """
 
 with CodeInterpreter() as sandbox:
-    sandbox.exec_cell(code, on_stdout=print, on_stderr=print)
+    sandbox.notebook.exec_cell(code, on_stdout=print, on_stderr=print, on_result=(lambda result: print(result.text)))
 ```
 
 ### Pre-installed Python packages inside the sandbox

e2b_code_interpreter-0.0.2/e2b_code_interpreter/__init__.py

@@ -0,0 +1,2 @@
+from .main import CodeInterpreter, JupyterExtension
+from .models import Execution, Error, Result, KernelException

{e2b_code_interpreter-0.0.1a1 → e2b_code_interpreter-0.0.2}/e2b_code_interpreter/main.py

@@ -10,8 +10,7 @@ from e2b import EnvVars, ProcessMessage, Sandbox
 from e2b.constants import TIMEOUT
 
 from e2b_code_interpreter.messaging import JupyterKernelWebSocket
-from e2b_code_interpreter.models import KernelException, Result
-
+from e2b_code_interpreter.models import KernelException, Execution, Result
 
 logger = logging.getLogger(__name__)
 
@@ -66,9 +65,9 @@ class JupyterExtension:
         kernel_id: Optional[str] = None,
         on_stdout: Optional[Callable[[ProcessMessage], Any]] = None,
         on_stderr: Optional[Callable[[ProcessMessage], Any]] = None,
-        on_display_data: Optional[Callable[[Dict[str, Any]], Any]] = None,
+        on_result: Optional[Callable[[Result], Any]] = None,
         timeout: Optional[float] = TIMEOUT,
-    ) -> Result:
+    ) -> Execution:
         """
         Execute code in a notebook cell.
 
@@ -76,7 +75,7 @@ class JupyterExtension:
         :param kernel_id: The ID of the kernel to execute the code on. If not provided, the default kernel is used.
         :param on_stdout: A callback function to handle standard output messages from the code execution.
         :param on_stderr: A callback function to handle standard error messages from the code execution.
-        :param on_display_data: A callback function to handle display data messages from the code execution.
+        :param on_result: A callback function to handle the result and display calls of the code execution.
         :param timeout: Timeout for the call
 
         :return: Result of the execution
@@ -93,7 +92,7 @@ class JupyterExtension:
             logger.debug(f"Creating new websocket connection to kernel {kernel_id}")
             ws = self._connect_to_kernel_ws(kernel_id, timeout=timeout)
 
-        session_id = ws.send_execution_message(code, on_stdout, on_stderr, on_display_data)
+        session_id = ws.send_execution_message(code, on_stdout, on_stderr, on_result)
         logger.debug(
             f"Sent execution message to kernel {kernel_id}, session_id: {session_id}"
         )

{e2b_code_interpreter-0.0.1a1 → e2b_code_interpreter-0.0.2}/e2b_code_interpreter/messaging.py

@@ -14,7 +14,7 @@ from e2b.sandbox.websocket_client import WebSocket
 from e2b.utils.future import DeferredFuture
 from pydantic import ConfigDict, PrivateAttr, BaseModel
 
-from e2b_code_interpreter.models import Result, Data, Error, MIMEType
+from e2b_code_interpreter.models import Execution, Result, Error
 
 logger = logging.getLogger(__name__)
 
@@ -26,21 +26,21 @@ class CellExecution:
     """
 
     input_accepted: bool = False
-    on_stdout: Optional[Callable[[ProcessMessage], None]] = None
-    on_stderr: Optional[Callable[[ProcessMessage], None]] = None
-    on_display_data: Optional[Callable[[Dict[MIMEType, str]], None]] = None
+    on_stdout: Optional[Callable[[ProcessMessage], Any]] = None
+    on_stderr: Optional[Callable[[ProcessMessage], Any]] = None
+    on_result: Optional[Callable[[Result], Any]] = None
 
     def __init__(
         self,
-        on_stdout: Optional[Callable[[ProcessMessage], None]] = None,
-        on_stderr: Optional[Callable[[ProcessMessage], None]] = None,
-        on_display_data: Optional[Callable[[Dict[MIMEType, str]], None]] = None,
+        on_stdout: Optional[Callable[[ProcessMessage], Any]] = None,
+        on_stderr: Optional[Callable[[ProcessMessage], Any]] = None,
+        on_result: Optional[Callable[[Result], Any]] = None,
     ):
-        self.partial_result = Result()
-        self.result = Future()
+        self.partial_result = Execution()
+        self.execution = Future()
         self.on_stdout = on_stdout
         self.on_stderr = on_stderr
-        self.on_display_data = on_display_data
+        self.on_result = on_result
 
 
 class JupyterKernelWebSocket(BaseModel):
@@ -129,9 +129,9 @@ class JupyterKernelWebSocket(BaseModel):
     def send_execution_message(
         self,
         code: str,
-        on_stdout: Optional[Callable[[ProcessMessage], None]] = None,
-        on_stderr: Optional[Callable[[ProcessMessage], None]] = None,
-        on_display_data: Optional[Callable[[Dict[MIMEType, str]], None]] = None,
+        on_stdout: Optional[Callable[[ProcessMessage], Any]] = None,
+        on_stderr: Optional[Callable[[ProcessMessage], Any]] = None,
+        on_result: Optional[Callable[[Result], Any]] = None,
     ) -> str:
         message_id = str(uuid.uuid4())
         logger.debug(f"Sending execution message: {message_id}")
@@ -139,14 +139,16 @@ class JupyterKernelWebSocket(BaseModel):
         self._cells[message_id] = CellExecution(
             on_stdout=on_stdout,
             on_stderr=on_stderr,
-            on_display_data=on_display_data,
+            on_result=on_result,
         )
         request = self._get_execute_request(message_id, code)
         self._queue_in.put(request)
         return message_id
 
-    def get_result(self, message_id: str, timeout: Optional[float] = TIMEOUT) -> Result:
-        result = self._cells[message_id].result.result(timeout=timeout)
+    def get_result(
+        self, message_id: str, timeout: Optional[float] = TIMEOUT
+    ) -> Execution:
+        result = self._cells[message_id].execution.result(timeout=timeout)
         logger.debug(f"Got result for message: {message_id}")
         del self._cells[message_id]
         return result
@@ -167,11 +169,11 @@ class JupyterKernelWebSocket(BaseModel):
         if not cell:
             return
 
-        result = cell.partial_result
+        execution = cell.partial_result
 
         if data["msg_type"] == "error":
             logger.debug(f"Cell {parent_msg_ig} finished execution with error")
-            result.error = Error(
+            execution.error = Error(
                 name=data["content"]["ename"],
                 value=data["content"]["evalue"],
                 traceback_raw=data["content"]["traceback"],
@@ -179,7 +181,7 @@ class JupyterKernelWebSocket(BaseModel):
 
         elif data["msg_type"] == "stream":
             if data["content"]["name"] == "stdout":
-                result.logs.stdout.append(data["content"]["text"])
+                execution.logs.stdout.append(data["content"]["text"])
                 if cell.on_stdout:
                     cell.on_stdout(
                         ProcessMessage(
@@ -189,7 +191,7 @@ class JupyterKernelWebSocket(BaseModel):
                     )
 
             elif data["content"]["name"] == "stderr":
-                result.logs.stderr.append(data["content"]["text"])
+                execution.logs.stderr.append(data["content"]["text"])
                 if cell.on_stderr:
                     cell.on_stderr(
                         ProcessMessage(
@@ -200,30 +202,34 @@ class JupyterKernelWebSocket(BaseModel):
                     )
 
         elif data["msg_type"] in "display_data":
-            result.data.append(Data(is_main_result=False, data=data["content"]["data"]))
-            if cell.on_display_data:
-                cell.on_display_data(data["content"]["data"])
+            result = Result(is_main_result=False, data=data["content"]["data"])
+            execution.results.append(result)
+            if cell.on_result:
+                cell.on_result(result)
         elif data["msg_type"] == "execute_result":
-            result.data.append(Data(is_main_result=True, data=data["content"]["data"]))
+            result = Result(is_main_result=True, data=data["content"]["data"])
+            execution.results.append(result)
+            if cell.on_result:
+                cell.on_result(result)
         elif data["msg_type"] == "status":
             if data["content"]["execution_state"] == "idle":
                 if cell.input_accepted:
                     logger.debug(f"Cell {parent_msg_ig} finished execution")
-                    cell.result.set_result(result)
+                    cell.execution.set_result(execution)
 
             elif data["content"]["execution_state"] == "error":
                 logger.debug(f"Cell {parent_msg_ig} finished execution with error")
-                result.error = Error(
+                execution.error = Error(
                     name=data["content"]["ename"],
                     value=data["content"]["evalue"],
                     traceback_raw=data["content"]["traceback"],
                 )
-                cell.result.set_result(result)
+                cell.execution.set_result(execution)
 
         elif data["msg_type"] == "execute_reply":
             if data["content"]["status"] == "error":
                 logger.debug(f"Cell {parent_msg_ig} finished execution with error")
-                result.error = Error(
+                execution.error = Error(
                     name=data["content"]["ename"],
                     value=data["content"]["evalue"],
                     traceback_raw=data["content"]["traceback"],
@@ -235,8 +241,7 @@ class JupyterKernelWebSocket(BaseModel):
             logger.debug(f"Input accepted for {parent_msg_ig}")
             cell.input_accepted = True
         else:
-            logger.error(f"[UNHANDLED MESSAGE TYPE]: {data['msg_type']}")
-            print("[UNHANDLED MESSAGE TYPE]:", data["msg_type"])
+            logger.warning(f"[UNHANDLED MESSAGE TYPE]: {data['msg_type']}")
 
     def close(self):
         logger.debug("Closing WebSocket")

{e2b_code_interpreter-0.0.1a1 → e2b_code_interpreter-0.0.2}/e2b_code_interpreter/models.py

@@ -32,11 +32,10 @@ class MIMEType(str):
     """
 
 
-class Data:
+class Result:
     """
     Represents the data to be displayed as a result of executing a cell in a Jupyter notebook.
-    This is result returned by ipython kernel: https://ipython.readthedocs.io/en/stable/development/execution.html#execution-semantics
-
+    The result is similar to the structure returned by ipython kernel: https://ipython.readthedocs.io/en/stable/development/execution.html#execution-semantics
 
     The result can contain multiple types of data, such as text, images, plots, etc. Each type of data is represented
     as a string, and the result can contain multiple types of data. The text representation is always present, and
@@ -44,8 +43,9 @@ class Data:
 
     The class also provides methods to display the data in a Jupyter notebook.
     """
+
     text: str
-    "Text representation of the data. Always present."
+    "Text representation of the result. Always present."
     html: Optional[str] = None
     markdown: Optional[str] = None
     svg: Optional[str] = None
@@ -80,13 +80,36 @@ class Data:
         self.javascript = data.pop("application/javascript", None)
         self.extra = data
 
-    def keys(self) -> Iterable[str]:
-        """
-        Returns the MIME types of the data.
-
-        :return: The MIME types of the data.
-        """
-        return self.raw.keys()
+    def formats(self) -> Iterable[str]:
+        """
+        Returns all available formats of the result.
+
+        :return: All available formats of the result in MIME types.
+        """
+        formats = []
+        if self.html:
+            formats.append("html")
+        if self.markdown:
+            formats.append("markdown")
+        if self.svg:
+            formats.append("svg")
+        if self.png:
+            formats.append("png")
+        if self.jpeg:
+            formats.append("jpeg")
+        if self.pdf:
+            formats.append("pdf")
+        if self.latex:
+            formats.append("latex")
+        if self.json:
+            formats.append("json")
+        if self.javascript:
+            formats.append("javascript")
+
+        for key in self.extra:
+            formats.append(key)
+
+        return formats
 
     def __str__(self) -> str:
         """
@@ -180,7 +203,7 @@ class Logs(BaseModel):
     "List of strings printed to stderr by prints, subprocesses, etc."
 
 
-class Result(BaseModel):
+class Execution(BaseModel):
     """
     Represents the result of a cell execution.
     """
@@ -188,8 +211,8 @@ class Result(BaseModel):
     class Config:
         arbitrary_types_allowed = True
 
-    data: List[Data] = []
-    "List of result of the cell (interactively interpreted last line), display calls, e.g. matplotlib plots."
+    results: List[Result] = []
+    "List of the result of the cell (interactively interpreted last line), display calls (e.g. matplotlib plots)."
     logs: Logs = Logs()
     "Logs printed to stdout and stderr during execution."
     error: Optional[Error] = None
@@ -202,7 +225,7 @@ class Result(BaseModel):
 
         :return: The text representation of the result.
         """
-        for d in self.data:
+        for d in self.results:
             if d.is_main_result:
                 return d.text
 

{e2b_code_interpreter-0.0.1a1 → e2b_code_interpreter-0.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "e2b-code-interpreter"
-version = "0.0.1a1"
+version = "0.0.2"
 description = "E2B Code Interpreter - Stateful code execution"
 authors = ["e2b <hello@e2b.dev>"]
 license = "Apache-2.0"

e2b_code_interpreter-0.0.1a1/e2b_code_interpreter/__init__.py

@@ -1,2 +0,0 @@
-from .main import CodeInterpreter, JupyterExtension
-from .models import Result, Error, Data, KernelException