Skip to content

armgit / E2B

Public Imported from GitHub
0

Open-source, secure environment with real-world tools for enterprise-grade agents.

[skip ci] Release new versions

github-actions[bot]5ca2b9cc426d
diff --git a/.changeset/clean-chicken-sort.md b/.changeset/clean-chicken-sort.md
deleted file mode 100644
index b1873658e..000000000
--- a/.changeset/clean-chicken-sort.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'@e2b/python-sdk': patch
----
-
-Allow python SDKs to write any instance of IOBase files
diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.3.2/exceptions/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.3.2/exceptions/page.mdx
new file mode 100644
index 000000000..17864645d
--- /dev/null
+++ b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.3.2/exceptions/page.mdx
@@ -0,0 +1,84 @@
+
+
+
+## SandboxException
+
+```python
+class SandboxException(Exception)
+```
+
+Base class for all sandbox errors.
+
+Raised when a general sandbox exception occurs.
+
+
+## TimeoutException
+
+```python
+class TimeoutException(SandboxException)
+```
+
+Raised when a timeout occurs.
+
+The `unavailable` exception type is caused by sandbox timeout.
+
+The `canceled` exception type is caused by exceeding request timeout.
+
+The `deadline_exceeded` exception type is caused by exceeding the timeout for process, watch, etc.
+
+The `unknown` exception type is sometimes caused by the sandbox timeout when the request is not processed correctly.
+
+
+## InvalidArgumentException
+
+```python
+class InvalidArgumentException(SandboxException)
+```
+
+Raised when an invalid argument is provided.
+
+
+## NotEnoughSpaceException
+
+```python
+class NotEnoughSpaceException(SandboxException)
+```
+
+Raised when there is not enough disk space.
+
+
+## NotFoundException
+
+```python
+class NotFoundException(SandboxException)
+```
+
+Raised when a resource is not found.
+
+
+## AuthenticationException
+
+```python
+class AuthenticationException(SandboxException)
+```
+
+Raised when authentication fails.
+
+
+## TemplateException
+
+```python
+class TemplateException(SandboxException)
+```
+
+Exception raised when the template uses old envd version. It isn't compatible with the new SDK.
+
+
+## RateLimitException
+
+```python
+class RateLimitException(SandboxException)
+```
+
+Raised when the API rate limit is exceeded.
+
diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.3.2/sandbox_async/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.3.2/sandbox_async/page.mdx
new file mode 100644
index 000000000..53388750b
--- /dev/null
+++ b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.3.2/sandbox_async/page.mdx
@@ -0,0 +1,1014 @@
+
+
+
+
+
+## AsyncCommandHandle
+
+```python
+class AsyncCommandHandle()
+```
+
+Command execution handle.
+
+It provides methods for waiting for the command to finish, retrieving stdout/stderr, and killing the command.
+
+
+### pid
+
+```python
+@property
+def pid()
+```
+
+Command process ID.
+
+
+### stdout
+
+```python
+@property
+def stdout()
+```
+
+Command stdout output.
+
+
+### stderr
+
+```python
+@property
+def stderr()
+```
+
+Command stderr output.
+
+
+### error
+
+```python
+@property
+def error()
+```
+
+Command execution error message.
+
+
+### exit\_code
+
+```python
+@property
+def exit_code()
+```
+
+Command execution exit code.
+
+`0` if the command finished successfully.
+
+It is `None` if the command is still running.
+
+
+### disconnect
+
+```python
+async def disconnect() -> None
+```
+
+Disconnects from the command.
+
+The command is not killed, but SDK stops receiving events from the command.
+You can reconnect to the command using `sandbox.commands.connect` method.
+
+
+### wait
+
+```python
+async def wait() -> CommandResult
+```
+
+Wait for the command to finish and return the result.
+
+If the command exits with a non-zero exit code, it throws a `CommandExitException`.
+
+**Returns**:
+
+`CommandResult` result of command execution
+
+
+### kill
+
+```python
+async def kill() -> bool
+```
+
+Kills the command.
+
+It uses `SIGKILL` signal to kill the command
+
+**Returns**:
+
+`True` if the command was killed successfully, `False` if the command was not found
+
+
+
+
+## Pty
+
+```python
+class Pty()
+```
+
+Module for interacting with PTYs (pseudo-terminals) in the sandbox.
+
+
+### kill
+
+```python
+async def kill(pid: int, request_timeout: Optional[float] = None) -> bool
+```
+
+Kill PTY.
+
+**Arguments**:
+
+- `pid`: Process ID of the PTY
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`true` if the PTY was killed, `false` if the PTY was not found
+
+
+### send\_stdin
+
+```python
+async def send_stdin(pid: int,
+ data: bytes,
+ request_timeout: Optional[float] = None) -> None
+```
+
+Send input to a PTY.
+
+**Arguments**:
+
+- `pid`: Process ID of the PTY
+- `data`: Input data to send
+- `request_timeout`: Timeout for the request in **seconds**
+
+
+### create
+
+```python
+async def create(
+ size: PtySize,
+ on_data: OutputHandler[PtyOutput],
+ user: Username = "user",
+ cwd: Optional[str] = None,
+ envs: Optional[Dict[str, str]] = None,
+ timeout: Optional[float] = 60,
+ request_timeout: Optional[float] = None) -> AsyncCommandHandle
+```
+
+Start a new PTY (pseudo-terminal).
+
+**Arguments**:
+
+- `size`: Size of the PTY
+- `on_data`: Callback to handle PTY data
+- `user`: User to use for the PTY
+- `cwd`: Working directory for the PTY
+- `envs`: Environment variables for the PTY
+- `timeout`: Timeout for the PTY in **seconds**
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+Handle to interact with the PTY
+
+
+### resize
+
+```python
+async def resize(pid: int,
+ size: PtySize,
+ request_timeout: Optional[float] = None)
+```
+
+Resize PTY.
+
+Call this when the terminal window is resized and the number of columns and rows has changed.
+
+**Arguments**:
+
+- `pid`: Process ID of the PTY
+- `size`: New size of the PTY
+- `request_timeout`: Timeout for the request in **seconds**
+
+
+
+
+## Commands
+
+```python
+class Commands()
+```
+
+Module for executing commands in the sandbox.
+
+
+### list
+
+```python
+async def list(request_timeout: Optional[float] = None) -> List[ProcessInfo]
+```
+
+Lists all running commands and PTY sessions.
+
+**Arguments**:
+
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+List of running commands and PTY sessions
+
+
+### kill
+
+```python
+async def kill(pid: int, request_timeout: Optional[float] = None) -> bool
+```
+
+Kill a running command specified by its process ID.
+
+It uses `SIGKILL` signal to kill the command.
+
+**Arguments**:
+
+- `pid`: Process ID of the command. You can get the list of processes using `sandbox.commands.list()`
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`True` if the command was killed, `False` if the command was not found
+
+
+### send\_stdin
+
+```python
+async def send_stdin(pid: int,
+ data: str,
+ request_timeout: Optional[float] = None) -> None
+```
+
+Send data to command stdin.
+
+:param pid Process ID of the command. You can get the list of processes using `sandbox.commands.list()`.
+:param data: Data to send to the command
+:param request_timeout: Timeout for the request in **seconds**
+
+
+
+### run
+
+```python
+@overload
+async def run(cmd: str,
+ background: Union[Literal[False], None] = None,
+ envs: Optional[Dict[str, str]] = None,
+ user: Username = "user",
+ cwd: Optional[str] = None,
+ on_stdout: Optional[OutputHandler[Stdout]] = None,
+ on_stderr: Optional[OutputHandler[Stderr]] = None,
+ timeout: Optional[float] = 60,
+ request_timeout: Optional[float] = None) -> CommandResult
+```
+
+Start a new command and wait until it finishes executing.
+
+**Arguments**:
+
+- `cmd`: Command to execute
+- `background`: **`False` if the command should be executed in the foreground**, `True` if the command should be executed in the background
+- `envs`: Environment variables used for the command
+- `user`: User to run the command as
+- `cwd`: Working directory to run the command
+- `on_stdout`: Callback for command stdout output
+- `on_stderr`: Callback for command stderr output
+- `timeout`: Timeout for the command connection in **seconds**. Using `0` will not limit the command connection time
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`CommandResult` result of the command execution
+
+
+### run
+
+```python
+@overload
+async def run(cmd: str,
+ background: Literal[True],
+ envs: Optional[Dict[str, str]] = None,
+ user: Username = "user",
+ cwd: Optional[str] = None,
+ on_stdout: Optional[OutputHandler[Stdout]] = None,
+ on_stderr: Optional[OutputHandler[Stderr]] = None,
+ timeout: Optional[float] = 60,
+ request_timeout: Optional[float] = None) -> AsyncCommandHandle
+```
+
+Start a new command and return a handle to interact with it.
+
+**Arguments**:
+
+- `cmd`: Command to execute
+- `background`: `False` if the command should be executed in the foreground, **`True` if the command should be executed in the background**
+- `envs`: Environment variables used for the command
+- `user`: User to run the command as
+- `cwd`: Working directory to run the command
+- `on_stdout`: Callback for command stdout output
+- `on_stderr`: Callback for command stderr output
+- `timeout`: Timeout for the command connection in **seconds**. Using `0` will not limit the command connection time
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`AsyncCommandHandle` handle to interact with the running command
+
+
+### connect
+
+```python
+async def connect(
+ pid: int,
+ timeout: Optional[float] = 60,
+ request_timeout: Optional[float] = None,
+ on_stdout: Optional[OutputHandler[Stdout]] = None,
+ on_stderr: Optional[OutputHandler[Stderr]] = None
+) -> AsyncCommandHandle
+```
+
+Connects to a running command.
+
+You can use `AsyncCommandHandle.wait()` to wait for the command to finish and get execution results.
+
+**Arguments**:
+
+- `pid`: Process ID of the command to connect to. You can get the list of processes using `sandbox.commands.list()`
+- `request_timeout`: Request timeout in **seconds**
+- `timeout`: Timeout for the command connection in **seconds**. Using `0` will not limit the command connection time
+- `on_stdout`: Callback for command stdout output
+- `on_stderr`: Callback for command stderr output
+
+**Returns**:
+
+`AsyncCommandHandle` handle to interact with the running command
+
+
+
+
+## SandboxApi
+
+```python
+class SandboxApi(SandboxApiBase)
+```
+
+
+### list
+
+```python
+@classmethod
+async def list(cls,
+ api_key: Optional[str] = None,
+ query: Optional[SandboxQuery] = None,
+ domain: Optional[str] = None,
+ debug: Optional[bool] = None,
+ request_timeout: Optional[float] = None) -> List[SandboxInfo]
+```
+
+List all running sandboxes.
+
+**Arguments**:
+
+- `api_key`: API key to use for authentication, defaults to `E2B_API_KEY` environment variable
+- `query`: Filter the list of sandboxes, e.g. by metadata `SandboxQuery(metadata={"key": "value"})`, if there are multiple filters they are combined with AND.
+- `domain`: Domain to use for the request, only relevant for self-hosted environments
+- `debug`: Enable debug mode, all requested are then sent to localhost
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+List of running sandboxes
+
+
+### get\_info
+
+```python
+@classmethod
+async def get_info(cls,
+ sandbox_id: str,
+ api_key: Optional[str] = None,
+ domain: Optional[str] = None,
+ debug: Optional[bool] = None,
+ request_timeout: Optional[float] = None) -> SandboxInfo
+```
+
+Get the sandbox info.
+
+**Arguments**:
+
+- `sandbox_id`: Sandbox ID
+- `api_key`: API key to use for authentication, defaults to `E2B_API_KEY` environment variable
+- `domain`: Domain to use for the request, defaults to `E2B_DOMAIN` environment variable
+- `debug`: Debug mode, defaults to `E2B_DEBUG` environment variable
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+Sandbox info
+
+
+
+
+## AsyncSandbox
+
+```python
+class AsyncSandbox(SandboxSetup, SandboxApi)
+```
+
+E2B cloud sandbox is a secure and isolated cloud environment.
+
+The sandbox allows you to:
+- Access Linux OS
+- Create, list, and delete files and directories
+- Run commands
+- Run isolated code
+- Access the internet
+
+Check docs [here](https://e2b.dev/docs).
+
+Use the `AsyncSandbox.create()` to create a new sandbox.
+
+**Example**:
+
+```python
+from e2b import AsyncSandbox
+
+sandbox = await AsyncSandbox.create()
+```
+
+
+### files
+
+```python
+@property
+def files() -> Filesystem
+```
+
+Module for interacting with the sandbox filesystem.
+
+
+### commands
+
+```python
+@property
+def commands() -> Commands
+```
+
+Module for running commands in the sandbox.
+
+
+### pty
+
+```python
+@property
+def pty() -> Pty
+```
+
+Module for interacting with the sandbox pseudo-terminal.
+
+
+### sandbox\_id
+
+```python
+@property
+def sandbox_id() -> str
+```
+
+Unique identifier of the sandbox.
+
+
+### \_\_init\_\_
+
+```python
+def __init__(**opts: Unpack[AsyncSandboxOpts])
+```
+
+Use `AsyncSandbox.create()` to create a new sandbox instead.
+
+
+### is\_running
+
+```python
+async def is_running(request_timeout: Optional[float] = None) -> bool
+```
+
+Check if the sandbox is running.
+
+**Arguments**:
+
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`True` if the sandbox is running, `False` otherwise
+Example
+```python
+sandbox = await AsyncSandbox.create()
+await sandbox.is_running() # Returns True
+
+await sandbox.kill()
+await sandbox.is_running() # Returns False
+```
+
+
+### create
+
+```python
+@classmethod
+async def create(cls,
+ template: Optional[str] = None,
+ timeout: Optional[int] = None,
+ metadata: Optional[Dict[str, str]] = None,
+ envs: Optional[Dict[str, str]] = None,
+ api_key: Optional[str] = None,
+ domain: Optional[str] = None,
+ debug: Optional[bool] = None,
+ request_timeout: Optional[float] = None)
+```
+
+Create a new sandbox.
+
+By default, the sandbox is created from the default `base` sandbox template.
+
+**Arguments**:
+
+- `template`: Sandbox template name or ID
+- `timeout`: Timeout for the sandbox in **seconds**, default to 300 seconds. Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.
+- `metadata`: Custom metadata for the sandbox
+- `envs`: Custom environment variables for the sandbox
+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+sandbox instance for the new sandbox
+Use this method instead of using the constructor to create a new sandbox.
+
+
+### connect
+
+```python
+@classmethod
+async def connect(cls,
+ sandbox_id: str,
+ api_key: Optional[str] = None,
+ domain: Optional[str] = None,
+ debug: Optional[bool] = None)
+```
+
+Connect to an existing sandbox.
+
+With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).
+
+**Arguments**:
+
+- `sandbox_id`: Sandbox ID
+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable
+
+**Returns**:
+
+sandbox instance for the existing sandbox
+@example
+```python
+sandbox = await AsyncSandbox.create()
+sandbox_id = sandbox.sandbox_id
+
+same_sandbox = await AsyncSandbox.connect(sandbox_id)
+
+
+### kill
+
+```python
+@overload
+async def kill(request_timeout: Optional[float] = None) -> bool
+```
+
+Kill the sandbox.
+
+**Arguments**:
+
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`True` if the sandbox was killed, `False` if the sandbox was not found
+
+
+### kill
+
+```python
+@overload
+@staticmethod
+async def kill(sandbox_id: str,
+ api_key: Optional[str] = None,
+ domain: Optional[str] = None,
+ debug: Optional[bool] = None,
+ request_timeout: Optional[float] = None) -> bool
+```
+
+Kill the sandbox specified by sandbox ID.
+
+**Arguments**:
+
+- `sandbox_id`: Sandbox ID
+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`True` if the sandbox was killed, `False` if the sandbox was not found
+
+
+### set\_timeout
+
+```python
+@overload
+async def set_timeout(timeout: int,
+ request_timeout: Optional[float] = None) -> None
+```
+
+Set the timeout of the sandbox.
+
+After the timeout expires the sandbox will be automatically killed.
+This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.
+
+Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.
+
+**Arguments**:
+
+- `timeout`: Timeout for the sandbox in **seconds**
+- `request_timeout`: Timeout for the request in **seconds**
+
+
+### set\_timeout
+
+```python
+@overload
+@staticmethod
+async def set_timeout(sandbox_id: str,
+ timeout: int,
+ api_key: Optional[str] = None,
+ domain: Optional[str] = None,
+ debug: Optional[bool] = None,
+ request_timeout: Optional[float] = None) -> None
+```
+
+Set the timeout of the specified sandbox.
+
+After the timeout expires the sandbox will be automatically killed.
+This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.
+
+Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.
+
+**Arguments**:
+
+- `sandbox_id`: Sandbox ID
+- `timeout`: Timeout for the sandbox in **seconds**
+- `request_timeout`: Timeout for the request in **seconds**
+
+
+### get\_info
+
+```python
+async def get_info(request_timeout: Optional[float] = None) -> SandboxInfo
+```
+
+Get sandbox information like sandbox id, template, metadata, started at/end at date.
+
+**Arguments**:
+
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+Sandbox info
+
+
+
+
+## AsyncWatchHandle
+
+```python
+class AsyncWatchHandle()
+```
+
+Handle for watching a directory in the sandbox filesystem.
+
+Use `.stop()` to stop watching the directory.
+
+
+### stop
+
+```python
+async def stop()
+```
+
+Stop watching the directory.
+
+
+
+
+## Filesystem
+
+```python
+class Filesystem()
+```
+
+Module for interacting with the filesystem in the sandbox.
+
+
+### read
+
+```python
+@overload
+async def read(path: str,
+ format: Literal["text"] = "text",
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> str
+```
+
+Read file content as a `str`.
+
+**Arguments**:
+
+- `path`: Path to the file
+- `user`: Run the operation as this user
+- `format`: Format of the file content—`text` by default
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+File content as a `str`
+
+
+### read
+
+```python
+@overload
+async def read(path: str,
+ format: Literal["bytes"],
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> bytearray
+```
+
+Read file content as a `bytearray`.
+
+**Arguments**:
+
+- `path`: Path to the file
+- `user`: Run the operation as this user
+- `format`: Format of the file content—`bytes`
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+File content as a `bytearray`
+
+
+### read
+
+```python
+@overload
+async def read(
+ path: str,
+ format: Literal["stream"],
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> AsyncIterator[bytes]
+```
+
+Read file content as a `AsyncIterator[bytes]`.
+
+**Arguments**:
+
+- `path`: Path to the file
+- `user`: Run the operation as this user
+- `format`: Format of the file content—`stream`
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+File content as an `AsyncIterator[bytes]`
+
+
+### write
+
+```python
+@overload
+async def write(path: str,
+ data: Union[str, bytes, IO],
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> EntryInfo
+```
+
+Write content to a file on the path.
+
+Writing to a file that doesn't exist creates the file.
+
+Writing to a file that already exists overwrites the file.
+
+Writing to a file at path that doesn't exist creates the necessary directories.
+
+**Arguments**:
+
+- `path`: Path to the file
+- `data`: Data to write to the file, can be a `str`, `bytes`, or `IO`.
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+Information about the written file
+
+
+### write
+
+```python
+@overload
+async def write(files: List[WriteEntry],
+ user: Optional[Username] = "user",
+ request_timeout: Optional[float] = None) -> List[EntryInfo]
+```
+
+Writes multiple files.
+
+**Arguments**:
+
+- `files`: list of files to write
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request
+
+**Returns**:
+
+Information about the written files
+
+
+### write
+
+```python
+async def write(
+ path_or_files: Union[str, List[WriteEntry]],
+ data_or_user: Union[str, bytes, IO, Username] = "user",
+ user_or_request_timeout: Optional[Union[float, Username]] = None,
+ request_timeout_or_none: Optional[float] = None
+) -> Union[EntryInfo, List[EntryInfo]]
+```
+
+Writes content to a file on the path.
+When writing to a file that doesn't exist, the file will get created.
+When writing to a file that already exists, the file will get overwritten.
+When writing to a file that's in a directory that doesn't exist, you'll get an error.
+
+
+### list
+
+```python
+async def list(path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> List[EntryInfo]
+```
+
+List entries in a directory.
+
+**Arguments**:
+
+- `path`: Path to the directory
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+List of entries in the directory
+
+
+### exists
+
+```python
+async def exists(path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> bool
+```
+
+Check if a file or a directory exists.
+
+**Arguments**:
+
+- `path`: Path to a file or a directory
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`True` if the file or directory exists, `False` otherwise
+
+
+### remove
+
+```python
+async def remove(path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> None
+```
+
+Remove a file or a directory.
+
+**Arguments**:
+
+- `path`: Path to a file or a directory
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request in **seconds**
+
+
+### rename
+
+```python
+async def rename(old_path: str,
+ new_path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> EntryInfo
+```
+
+Rename a file or directory.
+
+**Arguments**:
+
+- `old_path`: Path to the file or directory to rename
+- `new_path`: New path to the file or directory
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+Information about the renamed file or directory
+
+
+### make\_dir
+
+```python
+async def make_dir(path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> bool
+```
+
+Create a new directory and all directories along the way if needed on the specified path.
+
+**Arguments**:
+
+- `path`: Path to a new directory. For example '/dirA/dirB' when creating 'dirB'.
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`True` if the directory was created, `False` if the directory already exists
+
+
+### watch\_dir
+
+```python
+async def watch_dir(path: str,
+ on_event: OutputHandler[FilesystemEvent],
+ on_exit: Optional[OutputHandler[Exception]] = None,
+ user: Username = "user",
+ request_timeout: Optional[float] = None,
+ timeout: Optional[float] = 60,
+ recursive: bool = False) -> AsyncWatchHandle
+```
+
+Watch directory for filesystem events.
+
+**Arguments**:
+
+- `path`: Path to a directory to watch
+- `on_event`: Callback to call on each event in the directory
+- `on_exit`: Callback to call when the watching ends
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request in **seconds**
+- `timeout`: Timeout for the watch operation in **seconds**. Using `0` will not limit the watch time
+- `recursive`: Watch directory recursively
+
+**Returns**:
+
+`AsyncWatchHandle` object for stopping watching directory
+
diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.3.2/sandbox_sync/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.3.2/sandbox_sync/page.mdx
new file mode 100644
index 000000000..74859cad1
--- /dev/null
+++ b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.3.2/sandbox_sync/page.mdx
@@ -0,0 +1,979 @@
+
+
+
+## CommandHandle
+
+```python
+class CommandHandle()
+```
+
+Command execution handle.
+
+It provides methods for waiting for the command to finish, retrieving stdout/stderr, and killing the command.
+
+
+### pid
+
+```python
+@property
+def pid()
+```
+
+Command process ID.
+
+
+### \_\_iter\_\_
+
+```python
+def __iter__()
+```
+
+Iterate over the command output.
+
+**Returns**:
+
+Generator of command outputs
+
+
+### disconnect
+
+```python
+def disconnect() -> None
+```
+
+Disconnect from the command.
+
+The command is not killed, but SDK stops receiving events from the command.
+You can reconnect to the command using `sandbox.commands.connect` method.
+
+
+### wait
+
+```python
+def wait(on_pty: Optional[Callable[[PtyOutput], None]] = None,
+ on_stdout: Optional[Callable[[str], None]] = None,
+ on_stderr: Optional[Callable[[str], None]] = None) -> CommandResult
+```
+
+Wait for the command to finish and returns the result.
+
+If the command exits with a non-zero exit code, it throws a `CommandExitException`.
+
+**Arguments**:
+
+- `on_pty`: Callback for pty output
+- `on_stdout`: Callback for stdout output
+- `on_stderr`: Callback for stderr output
+
+**Returns**:
+
+`CommandResult` result of command execution
+
+
+### kill
+
+```python
+def kill() -> bool
+```
+
+Kills the command.
+
+It uses `SIGKILL` signal to kill the command.
+
+**Returns**:
+
+Whether the command was killed successfully
+
+
+
+
+## Pty
+
+```python
+class Pty()
+```
+
+Module for interacting with PTYs (pseudo-terminals) in the sandbox.
+
+
+### kill
+
+```python
+def kill(pid: int, request_timeout: Optional[float] = None) -> bool
+```
+
+Kill PTY.
+
+**Arguments**:
+
+- `pid`: Process ID of the PTY
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`true` if the PTY was killed, `false` if the PTY was not found
+
+
+### send\_stdin
+
+```python
+def send_stdin(pid: int,
+ data: bytes,
+ request_timeout: Optional[float] = None) -> None
+```
+
+Send input to a PTY.
+
+**Arguments**:
+
+- `pid`: Process ID of the PTY
+- `data`: Input data to send
+- `request_timeout`: Timeout for the request in **seconds**
+
+
+### create
+
+```python
+def create(size: PtySize,
+ user: Username = "user",
+ cwd: Optional[str] = None,
+ envs: Optional[Dict[str, str]] = None,
+ timeout: Optional[float] = 60,
+ request_timeout: Optional[float] = None) -> CommandHandle
+```
+
+Start a new PTY (pseudo-terminal).
+
+**Arguments**:
+
+- `size`: Size of the PTY
+- `user`: User to use for the PTY
+- `cwd`: Working directory for the PTY
+- `envs`: Environment variables for the PTY
+- `timeout`: Timeout for the PTY in **seconds**
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+Handle to interact with the PTY
+
+
+### resize
+
+```python
+def resize(pid: int,
+ size: PtySize,
+ request_timeout: Optional[float] = None) -> None
+```
+
+Resize PTY.
+
+Call this when the terminal window is resized and the number of columns and rows has changed.
+
+**Arguments**:
+
+- `pid`: Process ID of the PTY
+- `size`: New size of the PTY
+- `request_timeout`: Timeout for the request in **seconds**s
+
+
+
+
+## Commands
+
+```python
+class Commands()
+```
+
+Module for executing commands in the sandbox.
+
+
+### list
+
+```python
+def list(request_timeout: Optional[float] = None) -> List[ProcessInfo]
+```
+
+Lists all running commands and PTY sessions.
+
+**Arguments**:
+
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+List of running commands and PTY sessions
+
+
+### kill
+
+```python
+def kill(pid: int, request_timeout: Optional[float] = None) -> bool
+```
+
+Kills a running command specified by its process ID.
+
+It uses `SIGKILL` signal to kill the command.
+
+**Arguments**:
+
+- `pid`: Process ID of the command. You can get the list of processes using `sandbox.commands.list()`
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`True` if the command was killed, `False` if the command was not found
+
+
+### send\_stdin
+
+```python
+def send_stdin(pid: int, data: str, request_timeout: Optional[float] = None)
+```
+
+Send data to command stdin.
+
+:param pid Process ID of the command. You can get the list of processes using `sandbox.commands.list()`.
+:param data: Data to send to the command
+:param request_timeout: Timeout for the request in **seconds**
+
+
+
+### run
+
+```python
+@overload
+def run(cmd: str,
+ background: Union[Literal[False], None] = None,
+ envs: Optional[Dict[str, str]] = None,
+ user: Username = "user",
+ cwd: Optional[str] = None,
+ on_stdout: Optional[Callable[[str], None]] = None,
+ on_stderr: Optional[Callable[[str], None]] = None,
+ timeout: Optional[float] = 60,
+ request_timeout: Optional[float] = None) -> CommandResult
+```
+
+Start a new command and wait until it finishes executing.
+
+**Arguments**:
+
+- `cmd`: Command to execute
+- `background`: **`False` if the command should be executed in the foreground**, `True` if the command should be executed in the background
+- `envs`: Environment variables used for the command
+- `user`: User to run the command as
+- `cwd`: Working directory to run the command
+- `on_stdout`: Callback for command stdout output
+- `on_stderr`: Callback for command stderr output
+- `timeout`: Timeout for the command connection in **seconds**. Using `0` will not limit the command connection time
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`CommandResult` result of the command execution
+
+
+### run
+
+```python
+@overload
+def run(cmd: str,
+ background: Literal[True],
+ envs: Optional[Dict[str, str]] = None,
+ user: Username = "user",
+ cwd: Optional[str] = None,
+ on_stdout: None = None,
+ on_stderr: None = None,
+ timeout: Optional[float] = 60,
+ request_timeout: Optional[float] = None) -> CommandHandle
+```
+
+Start a new command and return a handle to interact with it.
+
+**Arguments**:
+
+- `cmd`: Command to execute
+- `background`: `False` if the command should be executed in the foreground, **`True` if the command should be executed in the background**
+- `envs`: Environment variables used for the command
+- `user`: User to run the command as
+- `cwd`: Working directory to run the command
+- `timeout`: Timeout for the command connection in **seconds**. Using `0` will not limit the command connection time
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`CommandHandle` handle to interact with the running command
+
+
+### connect
+
+```python
+def connect(pid: int,
+ timeout: Optional[float] = 60,
+ request_timeout: Optional[float] = None)
+```
+
+Connects to a running command.
+
+You can use `CommandHandle.wait()` to wait for the command to finish and get execution results.
+
+**Arguments**:
+
+- `pid`: Process ID of the command to connect to. You can get the list of processes using `sandbox.commands.list()`
+- `timeout`: Timeout for the connection in **seconds**. Using `0` will not limit the connection time
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`CommandHandle` handle to interact with the running command
+
+
+
+
+## SandboxApi
+
+```python
+class SandboxApi(SandboxApiBase)
+```
+
+
+### list
+
+```python
+@classmethod
+def list(cls,
+ api_key: Optional[str] = None,
+ query: Optional[SandboxQuery] = None,
+ domain: Optional[str] = None,
+ debug: Optional[bool] = None,
+ request_timeout: Optional[float] = None) -> List[SandboxInfo]
+```
+
+List all running sandboxes.
+
+**Arguments**:
+
+- `api_key`: API key to use for authentication, defaults to `E2B_API_KEY` environment variable
+- `query`: Filter the list of sandboxes, e.g. by metadata `SandboxQuery(metadata={"key": "value"})`, if there are multiple filters they are combined with AND.
+- `domain`: Domain to use for the request, only relevant for self-hosted environments
+- `debug`: Enable debug mode, all requested are then sent to localhost
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+List of running sandboxes
+
+
+### get\_info
+
+```python
+@classmethod
+def get_info(cls,
+ sandbox_id: str,
+ api_key: Optional[str] = None,
+ domain: Optional[str] = None,
+ debug: Optional[bool] = None,
+ request_timeout: Optional[float] = None) -> SandboxInfo
+```
+
+Get the sandbox info.
+
+**Arguments**:
+
+- `sandbox_id`: Sandbox ID
+- `api_key`: API key to use for authentication, defaults to `E2B_API_KEY` environment variable
+- `domain`: Domain to use for the request, defaults to `E2B_DOMAIN` environment variable
+- `debug`: Debug mode, defaults to `E2B_DEBUG` environment variable
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+Sandbox info
+
+
+
+
+## Sandbox
+
+```python
+class Sandbox(SandboxSetup, SandboxApi)
+```
+
+E2B cloud sandbox is a secure and isolated cloud environment.
+
+The sandbox allows you to:
+- Access Linux OS
+- Create, list, and delete files and directories
+- Run commands
+- Run isolated code
+- Access the internet
+
+Check docs [here](https://e2b.dev/docs).
+
+Use the `Sandbox()` to create a new sandbox.
+
+**Example**:
+
+```python
+from e2b import Sandbox
+
+sandbox = Sandbox()
+```
+
+
+### files
+
+```python
+@property
+def files() -> Filesystem
+```
+
+Module for interacting with the sandbox filesystem.
+
+
+### commands
+
+```python
+@property
+def commands() -> Commands
+```
+
+Module for running commands in the sandbox.
+
+
+### pty
+
+```python
+@property
+def pty() -> Pty
+```
+
+Module for interacting with the sandbox pseudo-terminal.
+
+
+### sandbox\_id
+
+```python
+@property
+def sandbox_id() -> str
+```
+
+Unique identifier of the sandbox
+
+
+### \_\_init\_\_
+
+```python
+def __init__(template: Optional[str] = None,
+ timeout: Optional[int] = None,
+ metadata: Optional[Dict[str, str]] = None,
+ envs: Optional[Dict[str, str]] = None,
+ api_key: Optional[str] = None,
+ domain: Optional[str] = None,
+ debug: Optional[bool] = None,
+ sandbox_id: Optional[str] = None,
+ request_timeout: Optional[float] = None)
+```
+
+Create a new sandbox.
+
+By default, the sandbox is created from the default `base` sandbox template.
+
+**Arguments**:
+
+- `template`: Sandbox template name or ID
+- `timeout`: Timeout for the sandbox in **seconds**, default to 300 seconds. Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users
+- `metadata`: Custom metadata for the sandbox
+- `envs`: Custom environment variables for the sandbox
+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+sandbox instance for the new sandbox
+
+
+### is\_running
+
+```python
+def is_running(request_timeout: Optional[float] = None) -> bool
+```
+
+Check if the sandbox is running.
+
+**Arguments**:
+
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`True` if the sandbox is running, `False` otherwise
+Example
+```python
+sandbox = Sandbox()
+sandbox.is_running() # Returns True
+
+sandbox.kill()
+sandbox.is_running() # Returns False
+```
+
+
+### connect
+
+```python
+@classmethod
+def connect(cls,
+ sandbox_id: str,
+ api_key: Optional[str] = None,
+ domain: Optional[str] = None,
+ debug: Optional[bool] = None)
+```
+
+Connects to an existing Sandbox.
+
+With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).
+
+**Arguments**:
+
+- `sandbox_id`: Sandbox ID
+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable
+
+**Returns**:
+
+sandbox instance for the existing sandbox
+@example
+```python
+sandbox = Sandbox()
+sandbox_id = sandbox.sandbox_id
+
+same_sandbox = Sandbox.connect(sandbox_id)
+```
+
+
+### kill
+
+```python
+@overload
+def kill(request_timeout: Optional[float] = None) -> bool
+```
+
+Kill the sandbox.
+
+**Arguments**:
+
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`True` if the sandbox was killed, `False` if the sandbox was not found
+
+
+### kill
+
+```python
+@overload
+@staticmethod
+def kill(sandbox_id: str,
+ api_key: Optional[str] = None,
+ domain: Optional[str] = None,
+ debug: Optional[bool] = None,
+ request_timeout: Optional[float] = None) -> bool
+```
+
+Kill the sandbox specified by sandbox ID.
+
+**Arguments**:
+
+- `sandbox_id`: Sandbox ID
+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`True` if the sandbox was killed, `False` if the sandbox was not found
+
+
+### kill
+
+```python
+@class_method_variant("_cls_kill")
+def kill(request_timeout: Optional[float] = None) -> bool
+```
+
+Kill the sandbox.
+
+**Arguments**:
+
+- `request_timeout`: Timeout for the request
+
+**Returns**:
+
+`True` if the sandbox was killed, `False` if the sandbox was not found
+
+
+### set\_timeout
+
+```python
+@overload
+def set_timeout(timeout: int, request_timeout: Optional[float] = None) -> None
+```
+
+Set the timeout of the sandbox.
+
+After the timeout expires the sandbox will be automatically killed.
+This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.
+
+Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.
+
+**Arguments**:
+
+- `timeout`: Timeout for the sandbox in **seconds**
+- `request_timeout`: Timeout for the request in **seconds**
+
+
+### set\_timeout
+
+```python
+@overload
+@staticmethod
+def set_timeout(sandbox_id: str,
+ timeout: int,
+ api_key: Optional[str] = None,
+ domain: Optional[str] = None,
+ debug: Optional[bool] = None,
+ request_timeout: Optional[float] = None) -> None
+```
+
+Set the timeout of the sandbox specified by sandbox ID.
+
+After the timeout expires the sandbox will be automatically killed.
+This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.
+
+Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.
+
+**Arguments**:
+
+- `sandbox_id`: Sandbox ID
+- `timeout`: Timeout for the sandbox in **seconds**
+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable
+- `request_timeout`: Timeout for the request in **seconds**
+
+
+### get\_info
+
+```python
+def get_info(request_timeout: Optional[float] = None) -> SandboxInfo
+```
+
+Get sandbox information like sandbox id, template, metadata, started at/end at date.
+
+**Arguments**:
+
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+Sandbox info
+
+
+
+
+## WatchHandle
+
+```python
+class WatchHandle()
+```
+
+Handle for watching filesystem events.
+It is used to get the latest events that have occurred in the watched directory.
+
+Use `.stop()` to stop watching the directory.
+
+
+### stop
+
+```python
+def stop()
+```
+
+Stop watching the directory.
+After you stop the watcher you won't be able to get the events anymore.
+
+
+### get\_new\_events
+
+```python
+def get_new_events() -> List[FilesystemEvent]
+```
+
+Get the latest events that have occurred in the watched directory since the last call, or from the beginning of the watching, up until now.
+
+**Returns**:
+
+List of filesystem events
+
+
+
+
+## Filesystem
+
+```python
+class Filesystem()
+```
+
+Module for interacting with the filesystem in the sandbox.
+
+
+### read
+
+```python
+@overload
+def read(path: str,
+ format: Literal["text"] = "text",
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> str
+```
+
+Read file content as a `str`.
+
+**Arguments**:
+
+- `path`: Path to the file
+- `user`: Run the operation as this user
+- `format`: Format of the file content—`text` by default
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+File content as a `str`
+
+
+### read
+
+```python
+@overload
+def read(path: str,
+ format: Literal["bytes"],
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> bytearray
+```
+
+Read file content as a `bytearray`.
+
+**Arguments**:
+
+- `path`: Path to the file
+- `user`: Run the operation as this user
+- `format`: Format of the file content—`bytes`
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+File content as a `bytearray`
+
+
+### read
+
+```python
+@overload
+def read(path: str,
+ format: Literal["stream"],
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> Iterator[bytes]
+```
+
+Read file content as a `Iterator[bytes]`.
+
+**Arguments**:
+
+- `path`: Path to the file
+- `user`: Run the operation as this user
+- `format`: Format of the file content—`stream`
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+File content as an `Iterator[bytes]`
+
+
+### write
+
+```python
+@overload
+def write(path: str,
+ data: Union[str, bytes, IO],
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> EntryInfo
+```
+
+Write content to a file on the path.
+
+Writing to a file that doesn't exist creates the file.
+
+Writing to a file that already exists overwrites the file.
+
+Writing to a file at path that doesn't exist creates the necessary directories.
+
+**Arguments**:
+
+- `path`: Path to the file
+- `data`: Data to write to the file, can be a `str`, `bytes`, or `IO`.
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+Information about the written file
+
+
+### write
+
+```python
+@overload
+def write(files: List[WriteEntry],
+ user: Optional[Username] = "user",
+ request_timeout: Optional[float] = None) -> List[EntryInfo]
+```
+
+Writes a list of files to the filesystem.
+
+When writing to a file that doesn't exist, the file will get created.
+When writing to a file that already exists, the file will get overwritten.
+When writing to a file that's in a directory that doesn't exist, you'll get an error.
+
+**Arguments**:
+
+- `files`: list of files to write
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request
+
+**Returns**:
+
+Information about the written files
+
+
+### list
+
+```python
+def list(path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> List[EntryInfo]
+```
+
+List entries in a directory.
+
+**Arguments**:
+
+- `path`: Path to the directory
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+List of entries in the directory
+
+
+### exists
+
+```python
+def exists(path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> bool
+```
+
+Check if a file or a directory exists.
+
+**Arguments**:
+
+- `path`: Path to a file or a directory
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`True` if the file or directory exists, `False` otherwise
+
+
+### remove
+
+```python
+def remove(path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> None
+```
+
+Remove a file or a directory.
+
+**Arguments**:
+
+- `path`: Path to a file or a directory
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request in **seconds**
+
+
+### rename
+
+```python
+def rename(old_path: str,
+ new_path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> EntryInfo
+```
+
+Rename a file or directory.
+
+**Arguments**:
+
+- `old_path`: Path to the file or directory to rename
+- `new_path`: New path to the file or directory
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+Information about the renamed file or directory
+
+
+### make\_dir
+
+```python
+def make_dir(path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> bool
+```
+
+Create a new directory and all directories along the way if needed on the specified path.
+
+**Arguments**:
+
+- `path`: Path to a new directory. For example '/dirA/dirB' when creating 'dirB'.
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request in **seconds**
+
+**Returns**:
+
+`True` if the directory was created, `False` if the directory already exists
+
+
+### watch\_dir
+
+```python
+def watch_dir(path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None,
+ recursive: bool = False) -> WatchHandle
+```
+
+Watch directory for filesystem events.
+
+**Arguments**:
+
+- `path`: Path to a directory to watch
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request in **seconds**
+- `recursive`: Watch directory recursively
+
+**Returns**:
+
+`WatchHandle` object for stopping watching directory
+
diff --git a/packages/python-sdk/package.json b/packages/python-sdk/package.json
index ef5f377c2..69f7b667b 100644
--- a/packages/python-sdk/package.json
+++ b/packages/python-sdk/package.json
@@ -1,7 +1,7 @@
{
"name": "@e2b/python-sdk",
"private": true,
- "version": "1.3.1",
+ "version": "1.3.2",
"scripts": {
"example": "poetry run python example.py",
"test": "poetry run pytest -n 4 --verbose -x",
diff --git a/packages/python-sdk/pyproject.toml b/packages/python-sdk/pyproject.toml
index 9949b1f3f..eca7545f6 100644
--- a/packages/python-sdk/pyproject.toml
+++ b/packages/python-sdk/pyproject.toml
@@ -1,6 +1,6 @@
[tool.poetry]
name = "e2b"
-version = "1.3.1"
+version = "1.3.2"
description = "E2B SDK that give agents cloud environments"
authors = ["e2b <[email protected]>"]
license = "MIT"