Sandbox

class Sandbox(SandboxDto)

Represents a Daytona Sandbox.

Attributes:

fs FileSystem - File system operations interface.
git Git - Git operations interface.
process Process - Process execution interface.
computer_use ComputerUse - Computer use operations interface for desktop automation.
id str - Unique identifier for the Sandbox.
name str - Name of the Sandbox.
organization_id str - Organization ID of the Sandbox.
snapshot str - Daytona snapshot used to create the Sandbox.
user str - OS user running in the Sandbox.
env Dict[str, str] - Environment variables set in the Sandbox.
labels Dict[str, str] - Custom labels attached to the Sandbox.
public bool - Whether the Sandbox is publicly accessible.
target str - Target location of the runner where the Sandbox runs.
cpu int - Number of CPUs allocated to the Sandbox.
gpu int - Number of GPUs allocated to the Sandbox.
memory int - Amount of memory allocated to the Sandbox in GiB.
disk int - Amount of disk space allocated to the Sandbox in GiB.
state SandboxState - Current state of the Sandbox (e.g., “started”, “stopped”).
error_reason str - Error message if Sandbox is in error state.
backup_state SandboxBackupStateEnum - Current state of Sandbox backup.
backup_created_at str - When the backup was created.
auto_stop_interval int - Auto-stop interval in minutes.
auto_archive_interval int - Auto-archive interval in minutes.
auto_delete_interval int - Auto-delete interval in minutes.
volumes List[str] - Volumes attached to the Sandbox.
build_info str - Build information for the Sandbox if it was created from dynamic build.
created_at str - When the Sandbox was created.
updated_at str - When the Sandbox was last updated.
network_block_all bool - Whether to block all network access for the Sandbox.
network_allow_list str - Comma-separated list of allowed CIDR network addresses for the Sandbox.

Sandbox.init

def __init__(sandbox_dto: SandboxDto, toolbox_api: ApiClient,
             sandbox_api: SandboxApi, code_toolbox: SandboxCodeToolbox,
             get_toolbox_base_url: Callable[[], str])

Initialize a new Sandbox instance.

Arguments:

sandbox_dto SandboxDto - The sandbox data from the API.
toolbox_api ApiClient - API client for toolbox operations.
sandbox_api SandboxApi - API client for Sandbox operations.
code_toolbox SandboxCodeToolbox - Language-specific toolbox implementation.
get_toolbox_base_url Callable[[], str] - Function to get the toolbox base URL.

Sandbox.refresh_data

@intercept_errors(message_prefix="Failed to refresh sandbox data: ")
def refresh_data() -> None

Refreshes the Sandbox data from the API.

Example:

sandbox.refresh_data()
print(f"Sandbox {sandbox.id}:")
print(f"State: {sandbox.state}")
print(f"Resources: {sandbox.cpu} CPU, {sandbox.memory} GiB RAM")

Sandbox.get_user_home_dir

@intercept_errors(message_prefix="Failed to get user home directory: ")
def get_user_home_dir() -> str

Gets the user’s home directory path inside the Sandbox.

Returns:

str - The absolute path to the user’s home directory inside the Sandbox.

Example:

user_home_dir = sandbox.get_user_home_dir()
print(f"Sandbox user home: {user_home_dir}")

Sandbox.get_work_dir

@intercept_errors(message_prefix="Failed to get working directory path: ")
def get_work_dir() -> str

Gets the working directory path inside the Sandbox.

Returns:

str - The absolute path to the Sandbox working directory. Uses the WORKDIR specified in the Dockerfile if present, or falling back to the user’s home directory if not.

Example:

work_dir = sandbox.get_work_dir()
print(f"Sandbox working directory: {work_dir}")

Sandbox.create_lsp_server

def create_lsp_server(language_id: LspLanguageId,
                      path_to_project: str) -> LspServer

Creates a new Language Server Protocol (LSP) server instance.

The LSP server provides language-specific features like code completion, diagnostics, and more.

Arguments:

language_id LspLanguageId - The language server type (e.g., LspLanguageId.PYTHON).
path_to_project str - Path to the project root directory. Relative paths are resolved based on the sandbox working directory.

Returns:

LspServer - A new LSP server instance configured for the specified language.

Example:

lsp = sandbox.create_lsp_server("python", "workspace/project")

Sandbox.set_labels

@intercept_errors(message_prefix="Failed to set labels: ")
def set_labels(labels: Dict[str, str]) -> Dict[str, str]

Sets labels for the Sandbox.

Labels are key-value pairs that can be used to organize and identify Sandboxes.

Arguments:

labels Dict[str, str] - Dictionary of key-value pairs representing Sandbox labels.

Returns:

Dict[str, str]: Dictionary containing the updated Sandbox labels.

Example:

new_labels = sandbox.set_labels({
    "project": "my-project",
    "environment": "development",
    "team": "backend"
})
print(f"Updated labels: {new_labels}")

Sandbox.start

@intercept_errors(message_prefix="Failed to start sandbox: ")
@with_timeout(error_message=lambda self, timeout: (
    f"Sandbox {self.id} failed to start within the {timeout} seconds timeout period"
))
def start(timeout: Optional[float] = 60)

Starts the Sandbox and waits for it to be ready.

Arguments:

timeout Optional[float] - Maximum time to wait in seconds. 0 means no timeout. Default is 60 seconds.

Raises:

DaytonaError - If timeout is negative. If sandbox fails to start or times out.

Example:

sandbox = daytona.get_current_sandbox("my-sandbox")
sandbox.start(timeout=40)  # Wait up to 40 seconds
print("Sandbox started successfully")

Sandbox.stop

@intercept_errors(message_prefix="Failed to stop sandbox: ")
@with_timeout(error_message=lambda self, timeout: (
    f"Sandbox {self.id} failed to stop within the {timeout} seconds timeout period"
))
def stop(timeout: Optional[float] = 60)

Stops the Sandbox and waits for it to be fully stopped.

Arguments:

timeout Optional[float] - Maximum time to wait in seconds. 0 means no timeout. Default is 60 seconds.

Raises:

DaytonaError - If timeout is negative; If sandbox fails to stop or times out

Example:

sandbox = daytona.get_current_sandbox("my-sandbox")
sandbox.stop()
print("Sandbox stopped successfully")

Sandbox.delete

@intercept_errors(message_prefix="Failed to remove sandbox: ")
def delete(timeout: Optional[float] = 60) -> None

Deletes the Sandbox.

Arguments:

timeout Optional[float] - Timeout (in seconds) for sandbox deletion. 0 means no timeout. Default is 60 seconds.

Sandbox.wait_for_sandbox_start

@intercept_errors(
    message_prefix="Failure during waiting for sandbox to start: ")
@with_timeout(error_message=lambda self, timeout: (
    f"Sandbox {self.id} failed to become ready within the {timeout} seconds timeout period"
))
def wait_for_sandbox_start(timeout: Optional[float] = 60) -> None

Waits for the Sandbox to reach the ‘started’ state. Polls the Sandbox status until it reaches the ‘started’ state, encounters an error or times out.

Arguments:

timeout Optional[float] - Maximum time to wait in seconds. 0 means no timeout. Default is 60 seconds.

Raises:

DaytonaError - If timeout is negative; If Sandbox fails to start or times out

Sandbox.wait_for_sandbox_stop

@intercept_errors(
    message_prefix="Failure during waiting for sandbox to stop: ")
@with_timeout(error_message=lambda self, timeout: (
    f"Sandbox {self.id} failed to become stopped within the {timeout} seconds timeout period"
))
def wait_for_sandbox_stop(timeout: Optional[float] = 60) -> None

Waits for the Sandbox to reach the ‘stopped’ state. Polls the Sandbox status until it reaches the ‘stopped’ state, encounters an error or times out. It will wait up to 60 seconds for the Sandbox to stop. Treats destroyed as stopped to cover ephemeral sandboxes that are automatically deleted after stopping.

Arguments:

timeout Optional[float] - Maximum time to wait in seconds. 0 means no timeout. Default is 60 seconds.

Raises:

DaytonaError - If timeout is negative. If Sandbox fails to stop or times out.

Sandbox.set_autostop_interval

@intercept_errors(message_prefix="Failed to set auto-stop interval: ")
def set_autostop_interval(interval: int) -> None

Sets the auto-stop interval for the Sandbox.

The Sandbox will automatically stop after being idle (no new events) for the specified interval. Events include any state changes or interactions with the Sandbox through the SDK. Interactions using Sandbox Previews are not included.

Arguments:

interval int - Number of minutes of inactivity before auto-stopping. Set to 0 to disable auto-stop. Defaults to 15.

Raises:

DaytonaError - If interval is negative

Example:

# Auto-stop after 1 hour
sandbox.set_autostop_interval(60)
# Or disable auto-stop
sandbox.set_autostop_interval(0)

Sandbox.set_auto_archive_interval

@intercept_errors(message_prefix="Failed to set auto-archive interval: ")
def set_auto_archive_interval(interval: int) -> None

Sets the auto-archive interval for the Sandbox.

The Sandbox will automatically archive after being continuously stopped for the specified interval.

Arguments:

interval int - Number of minutes after which a continuously stopped Sandbox will be auto-archived. Set to 0 for the maximum interval. Default is 7 days.

Raises:

DaytonaError - If interval is negative

Example:

# Auto-archive after 1 hour
sandbox.set_auto_archive_interval(60)
# Or use the maximum interval
sandbox.set_auto_archive_interval(0)

Sandbox.set_auto_delete_interval

@intercept_errors(message_prefix="Failed to set auto-delete interval: ")
def set_auto_delete_interval(interval: int) -> None

Sets the auto-delete interval for the Sandbox.

The Sandbox will automatically delete after being continuously stopped for the specified interval.

Arguments:

interval int - Number of minutes after which a continuously stopped Sandbox will be auto-deleted. Set to negative value to disable auto-delete. Set to 0 to delete immediately upon stopping. By default, auto-delete is disabled.

Example:

# Auto-delete after 1 hour
sandbox.set_auto_delete_interval(60)
# Or delete immediately upon stopping
sandbox.set_auto_delete_interval(0)
# Or disable auto-delete
sandbox.set_auto_delete_interval(-1)

Sandbox.get_preview_link

@intercept_errors(message_prefix="Failed to get preview link: ")
def get_preview_link(port: int) -> PortPreviewUrl

Retrieves the preview link for the sandbox at the specified port. If the port is closed, it will be opened automatically. For private sandboxes, a token is included to grant access to the URL.

Arguments:

port int - The port to open the preview link on.

Returns:

PortPreviewUrl - The response object for the preview link, which includes the url and the token (to access private sandboxes).

Example:

preview_link = sandbox.get_preview_link(3000)
print(f"Preview URL: {preview_link.url}")
print(f"Token: {preview_link.token}")

Sandbox.archive

@intercept_errors(message_prefix="Failed to archive sandbox: ")
def archive() -> None

Archives the sandbox, making it inactive and preserving its state. When sandboxes are archived, the entire filesystem state is moved to cost-effective object storage, making it possible to keep sandboxes available for an extended period. The tradeoff between archived and stopped states is that starting an archived sandbox takes more time, depending on its size. Sandbox must be stopped before archiving.

Sandbox.create_ssh_access

@intercept_errors(message_prefix="Failed to create SSH access: ")
def create_ssh_access(
        expires_in_minutes: Optional[int] = None) -> SshAccessDto

Creates an SSH access token for the sandbox.

Arguments:

expires_in_minutes Optional[int] - The number of minutes the SSH access token will be valid for.

Sandbox.revoke_ssh_access

@intercept_errors(message_prefix="Failed to revoke SSH access: ")
def revoke_ssh_access(token: str) -> None

Revokes an SSH access token for the sandbox.

Arguments:

token str - The token to revoke.

Sandbox.validate_ssh_access

@intercept_errors(message_prefix="Failed to validate SSH access: ")
def validate_ssh_access(token: str) -> SshAccessValidationDto

Validates an SSH access token for the sandbox.

Arguments:

token str - The token to validate.

PaginatedSandboxes

class PaginatedSandboxes(PaginatedSandboxesDto)

Represents a paginated list of Daytona Sandboxes.

Attributes:

items List[Sandbox] - List of Sandbox instances in the current page.
total int - Total number of Sandboxes across all pages.
page int - Current page number.
total_pages int - Total number of pages available.

Resources

@dataclass
class Resources()

Resources configuration for Sandbox.

Attributes:

cpu Optional[int] - Number of CPU cores to allocate.
memory Optional[int] - Amount of memory in GiB to allocate.
disk Optional[int] - Amount of disk space in GiB to allocate.
gpu Optional[int] - Number of GPUs to allocate.

Example:

resources = Resources(
    cpu=2,
    memory=4,  # 4GiB RAM
    disk=20,   # 20GiB disk
    gpu=1
)
params = CreateSandboxFromImageParams(
    image=Image.debian_slim("3.12"),
    language="python",
    resources=resources
)

Sandbox

Sandbox.__init__

Sandbox.refresh_data

Sandbox.get_user_home_dir

Sandbox.get_work_dir

Sandbox.create_lsp_server

Sandbox.set_labels

Sandbox.start

Sandbox.stop

Sandbox.delete

Sandbox.wait_for_sandbox_start

Sandbox.wait_for_sandbox_stop

Sandbox.set_autostop_interval

Sandbox.set_auto_archive_interval

Sandbox.set_auto_delete_interval

Sandbox.get_preview_link

Sandbox.archive

Sandbox.create_ssh_access

Sandbox.revoke_ssh_access

Sandbox.validate_ssh_access

PaginatedSandboxes

Resources

Sandbox.init