e2b-code-interpreter 0.0.1a0__tar.gz → 0.0.1a2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: e2b-code-interpreter
-Version: 0.0.1a0
+Version: 0.0.1a2
 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_display_data=(lambda data: print(data.text)))
 ```
 
 ### Pre-installed Python packages inside the sandbox

{e2b_code_interpreter-0.0.1a0 → e2b_code_interpreter-0.0.1a2}/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_display_data=(lambda data: print(data.text)))
 ```
 
 ### Pre-installed Python packages inside the sandbox

e2b_code_interpreter-0.0.1a2/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.1a0 → e2b_code_interpreter-0.0.1a2}/e2b_code_interpreter/main.py

@@ -10,7 +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
 
 
 logger = logging.getLogger(__name__)
@@ -68,7 +68,7 @@ class JupyterExtension:
         on_stderr: Optional[Callable[[ProcessMessage], Any]] = None,
         on_display_data: Optional[Callable[[Dict[str, Any]], Any]] = None,
         timeout: Optional[float] = TIMEOUT,
-    ) -> Result:
+    ) -> Execution:
         """
         Execute code in a notebook cell.
 
@@ -93,7 +93,9 @@ 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_display_data
+        )
         logger.debug(
             f"Sent execution message to kernel {kernel_id}, session_id: {session_id}"
         )
@@ -282,6 +284,7 @@ class JupyterExtension:
             if kernel_id is None and not self._sandbox.is_open:
                 return
 
+            kernel_id = kernel_id.strip()
             logger.debug(f"Default kernel id: {kernel_id}")
             self._connect_to_kernel_ws(kernel_id, timeout=timeout)
             self._kernel_id_set.set_result(kernel_id)

{e2b_code_interpreter-0.0.1a0 → e2b_code_interpreter-0.0.1a2}/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, MIMEType
 
 logger = logging.getLogger(__name__)
 
@@ -36,8 +36,8 @@ class CellExecution:
         on_stderr: Optional[Callable[[ProcessMessage], None]] = None,
         on_display_data: Optional[Callable[[Dict[MIMEType, str]], None]] = 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
@@ -145,8 +145,10 @@ class JupyterKernelWebSocket(BaseModel):
         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,33 @@ class JupyterKernelWebSocket(BaseModel):
                     )
 
         elif data["msg_type"] in "display_data":
-            result.data.append(Data(is_main_result=False, data=data["content"]["data"]))
+            result = Result(is_main_result=False, data=data["content"]["data"])
+            execution.results.append(result)
             if cell.on_display_data:
-                cell.on_display_data(data["content"]["data"])
+                cell.on_display_data(result)
         elif data["msg_type"] == "execute_result":
-            result.data.append(Data(is_main_result=True, data=data["content"]["data"]))
+            execution.results.append(
+                Result(is_main_result=True, data=data["content"]["data"])
+            )
         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 +240,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.1a0 → e2b_code_interpreter-0.0.1a2}/e2b_code_interpreter/models.py

@@ -32,20 +32,20 @@ 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 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
     the other representations are optional.
 
     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
@@ -180,7 +180,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 +188,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 +202,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.1a0 → e2b_code_interpreter-0.0.1a2}/pyproject.toml

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

e2b_code_interpreter-0.0.1a0/e2b_code_interpreter/__init__.py

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