Rename result type

Author: jakubno

README.md

@@ -89,7 +89,7 @@ with CodeInterpreter() as sandbox:
     result = sandbox.notebook.exec_cell(code)
 
 # there's your image
-image = result.data[0].png
+image = result.results[0].png
 
 # example how to show the image / prove it works
 i = base64.b64decode(image)
@@ -150,7 +150,7 @@ with CodeInterpreter() as sandbox:
 #### JavaScript
 
 ```js
-import { CodeInterpreter } from "@e2b/code-interpreter"
+import { CodeInterpreter } from '@e2b/code-interpreter'
 
 code = `
 import time
@@ -162,11 +162,12 @@ print("world")
 
 const sandbox = await CodeInterpreter.create()
 
-await sandbox.notebook.execCell(
-  code,
-  (out) => console.log(out),
-  (outErr) => console.error(outErr),
-)
+await sandbox.notebook.execCell(code, {
+  onStdout: (out) => console.log(out),
+  onStderr: (outErr) => console.error(outErr)
+  onDisplayData: (outData) => console.log(data.text)
+})
+
 ```
 
 ### Pre-installed Python packages inside the sandbox

js/example.js

@@ -1,12 +1,11 @@
 const { CodeInterpreter } = require('./dist')
 const dotenv = require('dotenv')
-dotenv.config();
+dotenv.config()
 
 async function main() {
-    const sandbox = await CodeInterpreter.create()
-    const r =await sandbox.notebook.execCell('x = 1; x')
-    console.log(r)
+  const sandbox = await CodeInterpreter.create()
+  const r = await sandbox.notebook.execCell('x = 1; x')
+  console.log(r)
 }
 
 main().catch(console.error)
-

js/src/code-interpreter.ts

@@ -1,5 +1,5 @@
 import { ProcessMessage, Sandbox, SandboxOpts } from 'e2b'
-import {Data, JupyterKernelWebSocket, Result} from './messaging'
+import { Result, JupyterKernelWebSocket, Execution } from './messaging'
 import { createDeferredPromise } from './utils'
 
 interface Kernels {
@@ -46,10 +46,12 @@ export class JupyterExtension {
     return this.kernelIDPromise.promise
   }
 
-  constructor(private sandbox: CodeInterpreter) { }
+  constructor(private sandbox: CodeInterpreter) {}
 
   async connect(timeout?: number) {
-    return this.startConnectingToDefaultKernel(this.setDefaultKernelID, { timeout })
+    return this.startConnectingToDefaultKernel(this.setDefaultKernelID, {
+      timeout
+    })
   }
 
   /**
@@ -62,6 +64,7 @@ export class JupyterExtension {
    * @param onStdout A callback function to handle standard output messages from the code execution.
    * @param onStderr A callback function to handle standard error messages from the code execution.
    * @param onDisplayData A callback function to handle display data messages from the code execution.
+   * @param timeout The maximum time to wait for the code execution to complete, in milliseconds.
    * @returns A promise that resolves with the result of the code execution.
    */
   async execCell(
@@ -71,23 +74,32 @@ export class JupyterExtension {
       onStdout,
       onStderr,
       onDisplayData,
+      timeout
     }: {
       kernelID?: string
       onStdout?: (msg: ProcessMessage) => Promise<void> | void
       onStderr?: (msg: ProcessMessage) => Promise<void> | void
-      onDisplayData?: (data: Data) => Promise<void> | void
+      onDisplayData?: (data: Result) => Promise<void> | void
+      timeout?: number
     }
+  ): Promise<Execution> {
+    kernelID = kernelID || (await this.defaultKernelID)
+    const ws =
+      this.connectedKernels[kernelID] ||
+      (await this.connectToKernelWS(kernelID))
 
-  ): Promise<Result> {
-    kernelID = kernelID || await this.defaultKernelID
-    const ws = this.connectedKernels[kernelID] || await this.connectToKernelWS(kernelID)
-
-    return await ws.sendExecutionMessage(code, onStdout, onStderr, onDisplayData)
+    return await ws.sendExecutionMessage(
+      code,
+      onStdout,
+      onStderr,
+      onDisplayData,
+      timeout
+    )
   }
 
   private async startConnectingToDefaultKernel(
     resolve: (value: string) => void,
-    opts?: { timeout?: number },
+    opts?: { timeout?: number }
   ) {
     const kernelID = (
       await this.sandbox.filesystem.read('/root/.jupyter/kernel_id', opts)

js/src/index.ts

@@ -1,7 +1,7 @@
 export { CodeInterpreter, JupyterExtension } from './code-interpreter'
 export type { CreateKernelProps } from './code-interpreter'
 
-export type { ExecutionError, Data, Result, MIMEType } from './messaging'
+export type { ExecutionError, Result, Execution, MIMEType } from './messaging'
 
 import { CodeInterpreter } from './code-interpreter'
 export default CodeInterpreter

js/src/messaging.ts

@@ -18,8 +18,8 @@ export class ExecutionError {
     /**
      * The raw traceback of the error.
      **/
-    public tracebackRaw: string[],
-  ) { }
+    public tracebackRaw: string[]
+  ) {}
 
   /**
    * Returns the traceback of the error as a string.
@@ -50,9 +50,9 @@ export type RawData = {
  * as a string, and the result can contain multiple types of data. The text representation is always present, and
  * the other representations are optional.
  */
-export class Data {
+export class Result {
   /**
-   * Text representation of the data. Always present.
+   * Text representation of the result. Always present.
    */
   readonly text: string
   /**
@@ -114,18 +114,20 @@ export class Data {
 
     this.extra = {}
     for (const key of Object.keys(data)) {
-      if (![
-        'text/plain',
-        'text/html',
-        'text/markdown',
-        'image/svg+xml',
-        'image/png',
-        'image/jpeg',
-        'application/pdf',
-        'text/latex',
-        'application/json',
-        'application/javascript'
-      ].includes(key)) {
+      if (
+        ![
+          'text/plain',
+          'text/html',
+          'text/markdown',
+          'image/svg+xml',
+          'image/png',
+          'image/jpeg',
+          'application/pdf',
+          'text/latex',
+          'application/json',
+          'application/javascript'
+        ].includes(key)
+      ) {
         this.extra[key] = data[key]
       }
     }
@@ -149,27 +151,27 @@ export type Logs = {
 /**
  * Represents the result of a cell execution.
  */
-export class Result {
+export class Execution {
   constructor(
     /**
-     * List of result of the cell (interactively interpreted last line), display calls, e.g. matplotlib plots.
+     * List of result of the cell (interactively interpreted last line), display calls (e.g. matplotlib plots).
      */
-    public data: Data[],
+    public results: Result[],
     /**
      * Logs printed to stdout and stderr during execution.
      */
     public logs: Logs,
     /**
      * An Error object if an error occurred, null otherwise.
      */
-    public error?: ExecutionError,
-  ) { }
+    public error?: ExecutionError
+  ) {}
 
   /**
    * Returns the text representation of the main result of the cell.
    */
   get text(): string | undefined {
-    for (const data of this.data) {
+    for (const data of this.results) {
       if (data.isMainResult) {
         return data.text
       }
@@ -182,18 +184,18 @@ export class Result {
  * It's an internal class used by JupyterKernelWebSocket.
  */
 class CellExecution {
-  result: Result
+  result: Execution
   onStdout?: (out: ProcessMessage) => Promise<void> | void
   onStderr?: (out: ProcessMessage) => Promise<void> | void
-  onDisplayData?: (data: Data) => Promise<void> | void
+  onDisplayData?: (data: Result) => Promise<void> | void
   inputAccepted: boolean = false
 
   constructor(
     onStdout?: (out: ProcessMessage) => Promise<void> | void,
     onStderr?: (out: ProcessMessage) => Promise<void> | void,
-    onDisplayData?: (data: Data) => Promise<void> | void
+    onDisplayData?: (data: Result) => Promise<void> | void
   ) {
-    this.result = new Result([], { stdout: [], stderr: [] })
+    this.result = new Execution([], { stdout: [], stderr: [] })
     this.onStdout = onStdout
     this.onStderr = onStderr
     this.onDisplayData = onDisplayData
@@ -230,7 +232,7 @@ export class JupyterKernelWebSocket {
    * Does not start WebSocket connection!
    * You need to call connect() method first.
    */
-  constructor(private readonly url: string) { }
+  constructor(private readonly url: string) {}
 
   // public
   /**
@@ -263,7 +265,7 @@ export class JupyterKernelWebSocket {
         result.error = new ExecutionError(
           message.content.ename,
           message.content.evalue,
-          message.content.traceback,
+          message.content.traceback
         )
       } else if (message.msg_type == 'stream') {
         if (message.content.name == 'stdout') {
@@ -290,12 +292,12 @@ export class JupyterKernelWebSocket {
           }
         }
       } else if (message.msg_type == 'display_data') {
-        result.data.push(new Data(message.content.data, false))
+        result.results.push(new Result(message.content.data, false))
         if (cell.onDisplayData) {
-          cell.onDisplayData(new Data(message.content.data, false))
+          cell.onDisplayData(new Result(message.content.data, false))
         }
       } else if (message.msg_type == 'execute_result') {
-        result.data.push(new Data(message.content.data, true))
+        result.results.push(new Result(message.content.data, true))
       } else if (message.msg_type == 'status') {
         if (message.content.execution_state == 'idle') {
           if (cell.inputAccepted) {
@@ -305,7 +307,7 @@ export class JupyterKernelWebSocket {
           result.error = new ExecutionError(
             message.content.ename,
             message.content.evalue,
-            message.content.traceback,
+            message.content.traceback
           )
           this.idAwaiter[parentMsgId](result)
         }
@@ -314,15 +316,15 @@ export class JupyterKernelWebSocket {
           result.error = new ExecutionError(
             message.content.ename,
             message.content.evalue,
-            message.content.traceback,
+            message.content.traceback
           )
         } else if (message.content.status == 'ok') {
           return
         }
       } else if (message.msg_type == 'execute_input') {
         cell.inputAccepted = true
       } else {
-        console.log('[UNHANDLED MESSAGE TYPE]:', message.msg_type)
+        console.warn('[UNHANDLED MESSAGE TYPE]:', message.msg_type)
       }
     }
   }
@@ -341,10 +343,10 @@ export class JupyterKernelWebSocket {
     code: string,
     onStdout?: (out: ProcessMessage) => Promise<void> | void,
     onStderr?: (out: ProcessMessage) => Promise<void> | void,
-    onDisplayData?: (data: Data) => Promise<void> | void,
+    onDisplayData?: (data: Result) => Promise<void> | void,
     timeout?: number
   ) {
-    return new Promise<Result>((resolve, reject) => {
+    return new Promise<Execution>((resolve, reject) => {
       const msg_id = crypto.randomUUID()
       const data = this.sendExecuteRequest(msg_id, code)
 
@@ -364,7 +366,7 @@ export class JupyterKernelWebSocket {
 
       // expect response
       this.cells[msg_id] = new CellExecution(onStdout, onStderr, onDisplayData)
-      this.idAwaiter[msg_id] = (responseData: Result) => {
+      this.idAwaiter[msg_id] = (responseData: Execution) => {
         // stop timeout
         clearInterval(timeoutSet as number)
         // stop waiting for response
@@ -383,7 +385,6 @@ export class JupyterKernelWebSocket {
    */
   private listen() {
     return new Promise((resolve, reject) => {
-
       this.ws.onopen = (e: unknown) => {
         resolve(e)
       }

js/tests/displayData.test.ts

@@ -17,7 +17,7 @@ test('display data', async () => {
         plt.show()
         `)
 
-  const image = result.data[0]
+  const image = result.results[0]
   expect(image.png).toBeDefined()
   expect(image.text).toBeDefined()
 

python/e2b_code_interpreter/__init__.py

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

python/e2b_code_interpreter/main.py

@@ -10,7 +10,7 @@
 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 @@ def exec_cell(
         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 @@ def exec_cell(
             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}"
         )