e2b-code-interpreter 0.0.8a0__tar.gz → 0.0.9__tar.gz

{e2b_code_interpreter-0.0.8a0 → e2b_code_interpreter-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: e2b-code-interpreter
-Version: 0.0.8a0
+Version: 0.0.9
 Summary: E2B Code Interpreter - Stateful code execution
 Home-page: https://e2b.dev/
 License: Apache-2.0

{e2b_code_interpreter-0.0.8a0 → e2b_code_interpreter-0.0.9}/e2b_code_interpreter/main.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import json
 import logging
 import threading
 import uuid
@@ -63,9 +62,6 @@ class JupyterExtension:
         self._connected_kernels: Dict[str, Future[JupyterKernelWebSocket]] = {}
         self._default_kernel_id: Optional[str] = None
 
-    def get_default_url(self) -> str:
-        return f"https://{self._sandbox.get_hostname(8888)}/doc/tree/RTC:default.ipynb"
-
     def exec_cell(
         self,
         code: str,
@@ -109,47 +105,6 @@ class JupyterExtension:
             f"Received result from kernel {kernel_id}, message_id: {message_id}, result: {result}"
         )
 
-        nb = self._sandbox.filesystem.read(f"/home/user/default.ipynb", timeout=timeout)
-        nb_parsed = json.loads(nb)
-        cell = {
-            "cell_type": "code",
-            "metadata": {},
-            "source": code,
-        }
-
-        outputs = []
-        if result.logs.stdout:
-            outputs.append(
-                {"output_type": "stream", "name": "stdout", "text": result.logs.stdout}
-            )
-        if result.logs.stderr:
-            outputs.append(
-                {"output_type": "stream", "name": "stderr", "text": result.logs.stderr}
-            )
-
-        if result.results:
-            outputs = [
-                {
-                    "output_type": (
-                        "execute_result" if r.is_main_result else "display_data"
-                    ),
-                    "data": r.raw,
-                    "metadata": {},
-                }
-                for r in result.results
-            ]
-
-        cell["execution_count"] = result.execution_count
-        cell["outputs"] = outputs
-
-        if nb_parsed["cells"] and not nb_parsed["cells"][-1]["source"]:
-            nb_parsed["cells"][-1] = cell
-        else:
-            nb_parsed["cells"].append(cell)
-
-        self._sandbox.filesystem.write(
-            f"/home/user/default.ipynb", json.dumps(nb_parsed), timeout=timeout
-        )
         return result
 
     @property
@@ -164,77 +119,59 @@ class JupyterExtension:
             self._default_kernel_id = self._kernel_id_set.result()
 
         return self._default_kernel_id
-    #
-    # def create_kernel(
-    #     self,
-    #     name: str,
-    #     path: str = "/home/user",
-    #     kernel_name: str = "python3",
-    #     timeout: Optional[float] = TIMEOUT,
-    # ) -> str:
-    #     """
-    #     Creates a new kernel, this can be useful if you want to have multiple independent code execution environments.
-    #
-    #     The kernel can be optionally configured to start in a specific working directory and/or
-    #     with a specific kernel name. If no kernel name is provided, the default kernel will be used.
-    #     Once the kernel is created, this method establishes a WebSocket connection to the new kernel for
-    #     real-time communication.
-    #
-    #     :param name: Name of the kernel
-    #     :param path: Sets the current working directory for the kernel. Defaults to "/home/user".
-    #     :param kernel_name: Specifies which kernel should be used, useful if you have multiple kernel types.
-    #     :param timeout: Timeout for the kernel creation request.
-    #     :return: Kernel id of the created kernel
-    #     """
-    #
-    #     x = {
-    #         "metadata": {
-    #             "signature": "hex-digest",
-    #             "kernel_info": {"name": kernel_name},
-    #             "language_info": {
-    #                 "name": kernel_name,
-    #                 "version": "3.10.14",
-    #             },  # TODO: get version
-    #         },
-    #         "nbformat": 4,
-    #         "nbformat_minor": 0,
-    #         "cells": [],
-    #     }
-    #
-    #     self._sandbox.filesystem.write(
-    #         f"/home/user/default.ipynb", json.dumps(x), timeout=timeout
-    #     )
-    #     self._sandbox.process.start("chmod 777 /home/user/default.ipynb")
-    #
-    #     data = {
-    #         "name": name,
-    #         "kernel": {"name": kernel_name},
-    #         "notebook": {"name": "default.ipynb"},
-    #         "path": path,
-    #         "type": "notebook",
-    #     }
-    #
-    #     logger.debug(f"Creating kernel with data: {data}")
-    #
-    #     response = requests.post(
-    #         f"{self._sandbox.get_protocol()}://{self._sandbox.get_hostname(8888)}/api/sessions",
-    #         json=data,
-    #         timeout=timeout,
-    #     )
-    #     if not response.ok:
-    #         raise KernelException(f"Failed to create kernel: {response.text}")
-    #
-    #     response_data = response.json()
-    #     kernel_id = response_data["kernel"]["id"]
-    #     session_id = response_data["id"]
-    #
-    #     logger.debug(f"Created kernel {kernel_id}, session {session_id}")
-    #
-    #     threading.Thread(
-    #         target=self._connect_to_kernel_ws, args=(kernel_id, session_id, timeout)
-    #     ).start()
-    #
-    #     return kernel_id
+
+    def create_kernel(
+        self,
+        cwd: str = "/home/user",
+        kernel_name: Optional[str] = None,
+        timeout: Optional[float] = TIMEOUT,
+    ) -> str:
+        """
+        Creates a new kernel, this can be useful if you want to have multiple independent code execution environments.
+
+        The kernel can be optionally configured to start in a specific working directory and/or
+        with a specific kernel name. If no kernel name is provided, the default kernel will be used.
+        Once the kernel is created, this method establishes a WebSocket connection to the new kernel for
+        real-time communication.
+
+        :param cwd: Sets the current working directory for the kernel. Defaults to "/home/user".
+        :param kernel_name:
+            Specifies which kernel should be used, useful if you have multiple kernel types.
+            If not provided, the default kernel will be used.
+        :param timeout: Timeout for the kernel creation request.
+        :return: Kernel id of the created kernel
+        """
+        kernel_name = kernel_name or "python3"
+
+        data = {"path": str(uuid.uuid4()), "kernel": {"name": kernel_name}, "type": "notebook", "name": str(uuid.uuid4())}
+        logger.debug(f"Creating kernel with data: {data}")
+
+        response = requests.post(
+            f"{self._sandbox.get_protocol()}://{self._sandbox.get_hostname(8888)}/api/sessions",
+            json=data,
+            timeout=timeout,
+        )
+        if not response.ok:
+            raise KernelException(f"Failed to create kernel: {response.text}")
+
+        session_data = response.json()
+        session_id = session_data["id"]
+        kernel_id = session_data["kernel"]["id"]
+
+        response = requests.patch(
+            f"{self._sandbox.get_protocol()}://{self._sandbox.get_hostname(8888)}/api/sessions/{session_id}",
+            json={"path": cwd},
+            timeout=timeout,
+        )
+        if not response.ok:
+            raise KernelException(f"Failed to create kernel: {response.text}")
+
+        logger.debug(f"Created kernel {kernel_id}")
+
+        threading.Thread(
+            target=self._connect_to_kernel_ws, args=(kernel_id, session_id, timeout)
+        ).start()
+        return kernel_id
 
     def restart_kernel(
         self, kernel_id: Optional[str] = None, timeout: Optional[float] = TIMEOUT
@@ -264,51 +201,51 @@ class JupyterExtension:
         threading.Thread(
             target=self._connect_to_kernel_ws, args=(kernel_id, None, timeout)
         ).start()
-    #
-    # def shutdown_kernel(
-    #     self, kernel_id: Optional[str] = None, timeout: Optional[float] = TIMEOUT
-    # ) -> None:
-    #     """
-    #     Shuts down an existing Jupyter kernel. This method is used to gracefully terminate a kernel's process.
-    #
-    #     :param kernel_id: The unique identifier of the kernel to shutdown. If not provided, the default kernel is shutdown.
-    #     :param timeout: The timeout for the kernel shutdown request.
-    #     """
-    #     kernel_id = kernel_id or self.default_kernel_id
-    #     logger.debug(f"Shutting down kernel {kernel_id}")
-    #
-    #     self._connected_kernels[kernel_id].result().close()
-    #     del self._connected_kernels[kernel_id]
-    #     logger.debug(f"Closed websocket connection to kernel {kernel_id}")
-    #
-    #     response = requests.delete(
-    #         f"{self._sandbox.get_protocol()}://{self._sandbox.get_hostname(8888)}/api/kernels/{kernel_id}",
-    #         timeout=timeout,
-    #     )
-    #     if not response.ok:
-    #         raise KernelException(f"Failed to shutdown kernel {kernel_id}")
-    #
-    #     logger.debug(f"Shutdown kernel {kernel_id}")
-    #
-    # def list_kernels(self, timeout: Optional[float] = TIMEOUT) -> List[str]:
-    #     """
-    #     Lists all available Jupyter kernels.
-    #
-    #     This method fetches a list of all currently available Jupyter kernels from the server. It can be used
-    #     to retrieve the IDs of all kernels that are currently running or available for connection.
-    #
-    #     :param timeout: The timeout for the kernel list request.
-    #     :return: List of kernel ids
-    #     """
-    #     response = requests.get(
-    #         f"{self._sandbox.get_protocol()}://{self._sandbox.get_hostname(8888)}/api/kernels",
-    #         timeout=timeout,
-    #     )
-    #
-    #     if not response.ok:
-    #         raise KernelException(f"Failed to list kernels: {response.text}")
-    #
-    #     return [kernel["id"] for kernel in response.json()]
+
+    def shutdown_kernel(
+        self, kernel_id: Optional[str] = None, timeout: Optional[float] = TIMEOUT
+    ) -> None:
+        """
+        Shuts down an existing Jupyter kernel. This method is used to gracefully terminate a kernel's process.
+
+        :param kernel_id: The unique identifier of the kernel to shutdown. If not provided, the default kernel is shutdown.
+        :param timeout: The timeout for the kernel shutdown request.
+        """
+        kernel_id = kernel_id or self.default_kernel_id
+        logger.debug(f"Shutting down kernel {kernel_id}")
+
+        self._connected_kernels[kernel_id].result().close()
+        del self._connected_kernels[kernel_id]
+        logger.debug(f"Closed websocket connection to kernel {kernel_id}")
+
+        response = requests.delete(
+            f"{self._sandbox.get_protocol()}://{self._sandbox.get_hostname(8888)}/api/kernels/{kernel_id}",
+            timeout=timeout,
+        )
+        if not response.ok:
+            raise KernelException(f"Failed to shutdown kernel {kernel_id}")
+
+        logger.debug(f"Shutdown kernel {kernel_id}")
+
+    def list_kernels(self, timeout: Optional[float] = TIMEOUT) -> List[str]:
+        """
+        Lists all available Jupyter kernels.
+
+        This method fetches a list of all currently available Jupyter kernels from the server. It can be used
+        to retrieve the IDs of all kernels that are currently running or available for connection.
+
+        :param timeout: The timeout for the kernel list request.
+        :return: List of kernel ids
+        """
+        response = requests.get(
+            f"{self._sandbox.get_protocol()}://{self._sandbox.get_hostname(8888)}/api/kernels",
+            timeout=timeout,
+        )
+
+        if not response.ok:
+            raise KernelException(f"Failed to list kernels: {response.text}")
+
+        return [kernel["id"] for kernel in response.json()]
 
     def close(self):
         """
@@ -319,23 +256,16 @@ class JupyterExtension:
             ws.result().close()
 
     def _connect_to_kernel_ws(
-        self,
-        kernel_id: str,
-        session_id: Optional[str],
-        timeout: Optional[float] = TIMEOUT,
+        self, kernel_id: str, session_id: Optional[str], timeout: Optional[float] = TIMEOUT
     ) -> JupyterKernelWebSocket:
         """
         Establishes a WebSocket connection to a specified Jupyter kernel.
 
         :param kernel_id: Kernel id
-        :param session_id: Session id
         :param timeout: The timeout for the kernel connection request.
 
         :return: Websocket connection
         """
-        if not session_id:
-            session_id = uuid.uuid4()
-
         logger.debug(f"Connecting to kernel's ({kernel_id}) websocket")
         future = Future()
         self._connected_kernels[kernel_id] = future
@@ -343,7 +273,7 @@ class JupyterExtension:
         session_id = session_id or str(uuid.uuid4())
         ws = JupyterKernelWebSocket(
             url=f"{self._sandbox.get_protocol('ws')}://{self._sandbox.get_hostname(8888)}/api/kernels/{kernel_id}/channels",
-            session_id=session_id,
+            session_id=session_id
         )
 
         ws.connect(timeout=timeout)
@@ -362,18 +292,17 @@ class JupyterExtension:
         logger.debug("Starting to connect to the default kernel")
 
         def setup_default_kernel():
-            session_info = self._sandbox.filesystem.read(
-                "/root/.jupyter/.session_info", timeout=timeout
+            kernel_id = self._sandbox.filesystem.read(
+                "/root/.jupyter/kernel_id", timeout=timeout
             )
 
-            if session_info is None and not self._sandbox.is_open:
+            if kernel_id is None and not self._sandbox.is_open:
                 return
 
-            data = json.loads(session_info)
-            kernel_id = data["kernel"]["id"]
-            session_id = data["id"]
+            kernel_id = kernel_id.strip()
+
             logger.debug(f"Default kernel id: {kernel_id}")
-            self._connect_to_kernel_ws(kernel_id, session_id, timeout=timeout)
+            self._connect_to_kernel_ws(kernel_id, None, timeout=timeout)
             self._kernel_id_set.set_result(kernel_id)
 
         threading.Thread(target=setup_default_kernel).start()

{e2b_code_interpreter-0.0.8a0 → e2b_code_interpreter-0.0.9}/e2b_code_interpreter/messaging.py

@@ -161,7 +161,11 @@ class JupyterKernelWebSocket:
 
         :param data: The message data
         """
-        parent_msg_ig = data["parent_header"]["msg_id"]
+        parent_msg_ig = data["parent_header"].get("msg_id", None)
+        if parent_msg_ig is None:
+            logger.warning("Parent message ID not found. %s", data)
+            return
+
         logger.debug(f"Received message {data['msg_type']} for {parent_msg_ig}")
 
         cell = self._cells.get(parent_msg_ig)

{e2b_code_interpreter-0.0.8a0 → e2b_code_interpreter-0.0.9}/e2b_code_interpreter/models.py

@@ -124,6 +124,9 @@ class Result:
         """
         return self.text
 
+    def __repr__(self) -> str:
+        return f"Result({self.text})"
+
     def _repr_html_(self) -> Optional[str]:
         """
         Returns the HTML representation of the data.

{e2b_code_interpreter-0.0.8a0 → e2b_code_interpreter-0.0.9}/pyproject.toml

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