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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: e2b-code-interpreter
-Version: 0.0.1a2
+Version: 0.0.2
 Summary: E2B Code Interpreter - Stateful code execution
 Home-page: https://e2b.dev/
 License: Apache-2.0
@@ -109,7 +109,7 @@ print("world")
 """
 
 with CodeInterpreter() as sandbox:
-    sandbox.notebook.exec_cell(code, on_stdout=print, on_stderr=print, on_display_data=(lambda data: print(data.text)))
+    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.1a2 → e2b_code_interpreter-0.0.2}/README.md

@@ -86,7 +86,7 @@ print("world")
 """
 
 with CodeInterpreter() as sandbox:
-    sandbox.notebook.exec_cell(code, on_stdout=print, on_stderr=print, on_display_data=(lambda data: print(data.text)))
+    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.1a2 → 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, Execution
-
+from e2b_code_interpreter.models import KernelException, Execution, Result
 
 logger = logging.getLogger(__name__)
 
@@ -66,7 +65,7 @@ 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,
     ) -> Execution:
         """
@@ -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,9 +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.1a2 → 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 Execution, Result, 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 = 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,7 +139,7 @@ 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)
@@ -204,12 +204,13 @@ class JupyterKernelWebSocket(BaseModel):
         elif data["msg_type"] in "display_data":
             result = Result(is_main_result=False, data=data["content"]["data"])
             execution.results.append(result)
-            if cell.on_display_data:
-                cell.on_display_data(result)
+            if cell.on_result:
+                cell.on_result(result)
         elif data["msg_type"] == "execute_result":
-            execution.results.append(
-                Result(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:

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

@@ -35,7 +35,7 @@ class MIMEType(str):
 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
@@ -80,13 +80,36 @@ class Result:
         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:
         """

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

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