nemo_gym.sandbox.providers.daytona.provider

Daytona provider implementation.

Module Contents

Classes

Name	Description
`DaytonaBatchConfig`	Client-side batch fanout settings.
`DaytonaConfigBase`	Shared dataclass construction for Daytona provider config blocks.
`DaytonaConnectionConfig`	Daytona API client connection settings.
`DaytonaCreateConfig`	Daytona sandbox creation settings.
`DaytonaCreateError`	Raised when Daytona cannot create a sandbox.
`DaytonaCreateTimeoutError`	Raised when Daytona sandbox creation exceeds the client timeout.
`DaytonaCreateVerificationError`	Raised when a newly-created Daytona sandbox cannot execute a probe command.
`DaytonaOperationConfig`	Retry and timeout settings for Daytona operations after create.
`DaytonaProbeConfig`	Post-create probe settings.
`DaytonaProvider`	Provider backed by the Daytona Python SDK.
`DaytonaProviderOptions`	Recognized per-sandbox create options read from `SandboxSpec.provider_options`.

Functions

Name	Description
`_coerce_bool`	-
`_coerce_int`	-
`_configured_or_extension`	-
`_daytona_error_types`	-
`_daytona_exec_error_message`	-
`_daytona_exec_error_result`	-
`_exception_status_code`	-
`_extension_value`	-
`_has_retryable_error_marker`	-
`_is_daytona_command_exec_error`	-
`_is_empty_daytona_command_exec_error`	-
`_is_missing_sandbox_delete_error`	-
`_is_retryable_create_error`	-
`_is_retryable_operation_error`	-
`_is_root_user`	-
`_log_create_retry`	-
`_log_operation_retry`	-
`_mib_to_gib`	-
`_normalize_spec`	-
`_provider_options`	-
`_quantity_to_int`	-
`_requested_user`	A spec’s default exec user as an os_user name, or `None` for root (Daytona’s own default).
`_require_daytona_sdk`	-
`_require_tenacity`	-
`_resources_requested`	-
`_spec_extensions`	-
`_spec_snapshot_id`	-
`_spec_volumes`	-
`_string_map`	-
`_supplied_config_keys`	-
`_to_resources`	-
`_to_sandbox_status`	-
`_to_volume_mounts`	-

Data

DAYTONA_COMMAND_ERROR_PREFIX

DAYTONA_EXTENSION_PREFIX

LOGGER

PROVIDER_OPTION_EXTENSIONS

PROVIDER_OPTION_SNAPSHOT_ID

PROVIDER_OPTION_VOLUMES

RETRYABLE_ERROR_MARKERS

RETRYABLE_HTTP_STATUS_CODES

SANDBOX_ID_LABEL

STATUS_CODE_RE

API

class nemo_gym.sandbox.providers.daytona.DaytonaBatchConfig(
    concurrency: int = 4
)

Dataclass

Bases: DaytonaConfigBase

Client-side batch fanout settings.

concurrency

int = 4

nemo_gym.sandbox.providers.daytona.DaytonaBatchConfig.__post_init__() -> None

class nemo_gym.sandbox.providers.daytona.provider.DaytonaConfigBase()

Shared dataclass construction for Daytona provider config blocks.

nemo_gym.sandbox.providers.daytona.provider.DaytonaConfigBase.from_mapping(
    value: typing.Any
) -> typing.Any

classmethod

class nemo_gym.sandbox.providers.daytona.DaytonaConnectionConfig(
    api_key: str | None = None,
    jwt_token: str | None = None,
    organization_id: str | None = None,
    api_url: str | None = None,
    server_url: str | None = None,
    target: str | None = None,
    connection_pool_maxsize: int | None = None,
    otel_enabled: bool | None = None
)

Dataclass

Bases: DaytonaConfigBase

Daytona API client connection settings.

api_key

str | None = None

api_url

str | None = None

connection_pool_maxsize

int | None = None

jwt_token

str | None = None

organization_id

str | None = None

otel_enabled

bool | None = None

server_url

str | None = None

target

str | None = None

nemo_gym.sandbox.providers.daytona.DaytonaConnectionConfig.__post_init__() -> None

class nemo_gym.sandbox.providers.daytona.DaytonaCreateConfig(
    timeout_s: float = 60.0,
    retries: int = 2,
    retry_delay_s: float = 1.0,
    retry_max_delay_s: float = 30.0,
    language: str | None = None,
    os_user: str | None = None,
    public: bool | None = None,
    auto_stop_interval: int | None = None,
    auto_archive_interval: int | None = None,
    auto_delete_interval: int | None = None,
    ephemeral: bool | None = None,
    network_block_all: bool | None = None,
    network_allow_list: str | None = None
)

Dataclass

Bases: DaytonaConfigBase

Daytona sandbox creation settings.

auto_archive_interval

int | None = None

auto_delete_interval

int | None = None

auto_stop_interval

int | None = None

ephemeral

bool | None = None

language

str | None = None

network_allow_list

str | None = None

network_block_all

bool | None = None

os_user

str | None = None

public

bool | None = None

retries

int = 2

retry_delay_s

float = 1.0

retry_max_delay_s

float = 30.0

timeout_s

float = 60.0

nemo_gym.sandbox.providers.daytona.DaytonaCreateConfig.__post_init__() -> None

class nemo_gym.sandbox.providers.daytona.DaytonaCreateError()

Bases: SandboxCreateError

Raised when Daytona cannot create a sandbox.

class nemo_gym.sandbox.providers.daytona.DaytonaCreateTimeoutError()

Bases: DaytonaCreateError

Raised when Daytona sandbox creation exceeds the client timeout.

class nemo_gym.sandbox.providers.daytona.provider.DaytonaCreateVerificationError()

Bases: SandboxCreateVerificationError

Raised when a newly-created Daytona sandbox cannot execute a probe command.

class nemo_gym.sandbox.providers.daytona.DaytonaOperationConfig(
    retries: int = 3,
    retry_delay_s: float = 1.0,
    retry_max_delay_s: float = 15.0,
    command_retries: int = 0,
    command_timeout_margin_s: float = 60.0,
    file_timeout_s: int | None = 30 * 60,
    close_timeout_s: float | None = 60.0
)

Dataclass

Bases: DaytonaConfigBase

Retry and timeout settings for Daytona operations after create.

close_timeout_s

float | None = 60.0

command_retries

int = 0

command_timeout_margin_s

float = 60.0

file_timeout_s

int | None = 30 * 60

retries

int = 3

retry_delay_s

float = 1.0

retry_max_delay_s

float = 15.0

nemo_gym.sandbox.providers.daytona.DaytonaOperationConfig.__post_init__() -> None

class nemo_gym.sandbox.providers.daytona.DaytonaProbeConfig(
    command: str | None = 'printf nemo-rl-sandbox-ready',
    expected_stdout: str | None = 'nemo-rl-sandbox-ready',
    timeout_s: int = 30,
    deadline_s: float | None = None
)

Dataclass

Bases: DaytonaConfigBase

Post-create probe settings.

command

str | None = 'printf nemo-rl-sandbox-ready'

deadline_s

float | None = None

expected_stdout

str | None = 'nemo-rl-sandbox-ready'

timeout_s

int = 30

nemo_gym.sandbox.providers.daytona.DaytonaProbeConfig.__post_init__() -> None

class nemo_gym.sandbox.providers.daytona.DaytonaProvider(
    connection: nemo_gym.sandbox.providers.daytona.provider.DaytonaConnectionConfig | collections.abc.Mapping[str, typing.Any] | None = None,
    create: nemo_gym.sandbox.providers.daytona.provider.DaytonaCreateConfig | collections.abc.Mapping[str, typing.Any] | None = None,
    probe: nemo_gym.sandbox.providers.daytona.provider.DaytonaProbeConfig | collections.abc.Mapping[str, typing.Any] | None = None,
    operations: nemo_gym.sandbox.providers.daytona.provider.DaytonaOperationConfig | collections.abc.Mapping[str, typing.Any] | None = None,
    batch: nemo_gym.sandbox.providers.daytona.provider.DaytonaBatchConfig | collections.abc.Mapping[str, typing.Any] | None = None
)

Provider backed by the Daytona Python SDK.

_batch

= DaytonaBatchConfig.from_mapping(batch)

_connection

= DaytonaConnectionConfig.from_mapping(connection)

_connection_supplied_keys

_create

= DaytonaCreateConfig.from_mapping(create)

_daytona

Any | None = None

_operations

= DaytonaOperationConfig.from_mapping(operations)

_os_users

dict[str, str] = {}

_probe

= DaytonaProbeConfig.from_mapping(probe)

name

= 'daytona'

nemo_gym.sandbox.providers.daytona.DaytonaProvider._await_operation(
    operation_factory: typing.Callable[[], typing.Awaitable[typing.Any]],
    operation: str,
    sandbox_id: str,
    timeout_s: float | None,
    retries: int | None = None
) -> typing.Any

async

nemo_gym.sandbox.providers.daytona.DaytonaProvider._base_create_kwargs(
    spec: nemo_gym.sandbox.providers.base.SandboxSpec
) -> dict[str, typing.Any]

nemo_gym.sandbox.providers.daytona.DaytonaProvider._client() -> typing.Any

nemo_gym.sandbox.providers.daytona.DaytonaProvider._command_retry_count() -> int

nemo_gym.sandbox.providers.daytona.DaytonaProvider._create_once(
    spec: nemo_gym.sandbox.providers.base.SandboxSpec
) -> nemo_gym.sandbox.providers.base.SandboxHandle

async

nemo_gym.sandbox.providers.daytona.DaytonaProvider._create_with_retries(
    spec: nemo_gym.sandbox.providers.base.SandboxSpec
) -> nemo_gym.sandbox.providers.base.SandboxHandle

async

nemo_gym.sandbox.providers.daytona.DaytonaProvider._effective_command(
    command: str,
    user: str | int | None,
    handle: nemo_gym.sandbox.providers.base.SandboxHandle
) -> str

command as Daytona runs it: unchanged for root and for the user the sandbox already runs as (its os_user), which needs no switch; any other user is refused, as Daytona has no per-command form.

nemo_gym.sandbox.providers.daytona.DaytonaProvider._exec(
    handle: nemo_gym.sandbox.providers.base.SandboxHandle,
    command: str,
    cwd: str | None = None,
    env: dict[str, str] | None = None,
    timeout_s: int | None = None,
    user: str | int | None = None,
    retries: int | None = None
) -> nemo_gym.sandbox.providers.base.SandboxExecResult

async

nemo_gym.sandbox.providers.daytona.DaytonaProvider._os_user(
    spec: nemo_gym.sandbox.providers.base.SandboxSpec
) -> str | None

The os_user a sandbox for spec is created with: the configured or extension value, else the spec’s own default exec user. Daytona selects the user at creation only, so a requested default becomes the sandbox’s os_user, and one that conflicts with the configured os_user is refused here, before any task command runs.

nemo_gym.sandbox.providers.daytona.DaytonaProvider._sandbox_os_user(
    handle: nemo_gym.sandbox.providers.base.SandboxHandle
) -> str | None

The os_user handle’s sandbox runs as: recorded at create, else the sandbox’s own user (a connected sandbox), else the configured create.os_user.

nemo_gym.sandbox.providers.daytona.DaytonaProvider._to_create_params(
    spec: nemo_gym.sandbox.providers.base.SandboxSpec
) -> typing.Any | None

nemo_gym.sandbox.providers.daytona.DaytonaProvider._verify_created_handle(
    handle: nemo_gym.sandbox.providers.base.SandboxHandle
) -> None

async

nemo_gym.sandbox.providers.daytona.DaytonaProvider._with_generated_sandbox_id(
    spec: nemo_gym.sandbox.providers.base.SandboxSpec
) -> nemo_gym.sandbox.providers.base.SandboxSpec

nemo_gym.sandbox.providers.daytona.DaytonaProvider.aclose() -> None

async

nemo_gym.sandbox.providers.daytona.DaytonaProvider.close(
    handle: nemo_gym.sandbox.providers.base.SandboxHandle,
    delete: bool = True
) -> None

async

nemo_gym.sandbox.providers.daytona.DaytonaProvider.connect(
    sandbox_id: str
) -> nemo_gym.sandbox.providers.base.SandboxHandle

async

nemo_gym.sandbox.providers.daytona.DaytonaProvider.create(
    spec: nemo_gym.sandbox.providers.base.SandboxSpec
) -> nemo_gym.sandbox.providers.base.SandboxHandle

async

nemo_gym.sandbox.providers.daytona.DaytonaProvider.create_batch(
    spec: nemo_gym.sandbox.providers.base.SandboxSpec,
    count: int,
    allow_partial: bool = False
) -> list[nemo_gym.sandbox.providers.base.SandboxHandle]

async

nemo_gym.sandbox.providers.daytona.DaytonaProvider.download_file(
    handle: nemo_gym.sandbox.providers.base.SandboxHandle,
    source_path: str,
    target_path: pathlib.Path
) -> None

async

nemo_gym.sandbox.providers.daytona.DaytonaProvider.exec(
    handle: nemo_gym.sandbox.providers.base.SandboxHandle,
    command: str,
    cwd: str | None = None,
    env: dict[str, str] | None = None,
    timeout_s: int | None = None,
    user: str | int | None = None
) -> nemo_gym.sandbox.providers.base.SandboxExecResult

async

nemo_gym.sandbox.providers.daytona.DaytonaProvider.read_file(
    handle: nemo_gym.sandbox.providers.base.SandboxHandle,
    source_path: str
) -> bytes

async

nemo_gym.sandbox.providers.daytona.DaytonaProvider.status(
    handle: nemo_gym.sandbox.providers.base.SandboxHandle
) -> nemo_gym.sandbox.providers.base.SandboxStatus

async

nemo_gym.sandbox.providers.daytona.DaytonaProvider.upload_file(
    handle: nemo_gym.sandbox.providers.base.SandboxHandle,
    source_path: pathlib.Path,
    target_path: str
) -> None

async

nemo_gym.sandbox.providers.daytona.DaytonaProvider.write_file(
    handle: nemo_gym.sandbox.providers.base.SandboxHandle,
    target_path: str,
    data: str | bytes
) -> None

async

class nemo_gym.sandbox.providers.daytona.DaytonaProviderOptions(
    extensions: collections.abc.Mapping[str, str] = dict(),
    snapshot_id: str | None = None,
    volumes: tuple[collections.abc.Mapping[str, typing.Any], ...] = ()
)

Dataclass

Recognized per-sandbox create options read from SandboxSpec.provider_options.

extensions

Mapping[str, str] = field(default_factory=dict)

snapshot_id

str | None = None

volumes

tuple[Mapping[str, Any], ...] = ()

nemo_gym.sandbox.providers.daytona.DaytonaProviderOptions.from_mapping(
    options: collections.abc.Mapping[str, typing.Any] | None
) -> nemo_gym.sandbox.providers.daytona.provider.DaytonaProviderOptions

classmethod

nemo_gym.sandbox.providers.daytona.provider._coerce_bool(
    name: str,
    value: typing.Any
) -> bool

nemo_gym.sandbox.providers.daytona.provider._coerce_int(
    name: str,
    value: typing.Any
) -> int

nemo_gym.sandbox.providers.daytona.provider._configured_or_extension(
    spec: nemo_gym.sandbox.providers.base.SandboxSpec,
    key: str,
    configured: typing.Any
) -> typing.Any

nemo_gym.sandbox.providers.daytona.provider._daytona_error_types() -> dict[str, type[BaseException]]

nemo_gym.sandbox.providers.daytona.provider._daytona_exec_error_message(
    exception: BaseException
) -> str

nemo_gym.sandbox.providers.daytona.provider._daytona_exec_error_result(
    exception: BaseException
) -> nemo_gym.sandbox.providers.base.SandboxExecResult

nemo_gym.sandbox.providers.daytona.provider._exception_status_code(
    exception: BaseException
) -> int | None

nemo_gym.sandbox.providers.daytona.provider._extension_value(
    spec: nemo_gym.sandbox.providers.base.SandboxSpec,
    key: str
) -> str | None

nemo_gym.sandbox.providers.daytona.provider._has_retryable_error_marker(
    exception: BaseException
) -> bool

nemo_gym.sandbox.providers.daytona.provider._is_daytona_command_exec_error(
    exception: BaseException
) -> bool

nemo_gym.sandbox.providers.daytona.provider._is_empty_daytona_command_exec_error(
    exception: BaseException
) -> bool

nemo_gym.sandbox.providers.daytona.provider._is_missing_sandbox_delete_error(
    exception: BaseException
) -> bool

nemo_gym.sandbox.providers.daytona.provider._is_retryable_create_error(
    exception: BaseException
) -> bool

nemo_gym.sandbox.providers.daytona.provider._is_retryable_operation_error(
    exception: BaseException
) -> bool

nemo_gym.sandbox.providers.daytona.provider._is_root_user(
    user: str | int | None
) -> bool

nemo_gym.sandbox.providers.daytona.provider._log_create_retry(
    retry_state: typing.Any
) -> None

nemo_gym.sandbox.providers.daytona.provider._log_operation_retry(
    retry_state: typing.Any
) -> None

nemo_gym.sandbox.providers.daytona.provider._mib_to_gib(
    name: str,
    value: typing.Any
) -> int

nemo_gym.sandbox.providers.daytona.provider._normalize_spec(
    spec: nemo_gym.sandbox.providers.base.SandboxSpec
) -> nemo_gym.sandbox.providers.base.SandboxSpec

nemo_gym.sandbox.providers.daytona.provider._provider_options(
    spec: nemo_gym.sandbox.providers.base.SandboxSpec
) -> nemo_gym.sandbox.providers.daytona.provider.DaytonaProviderOptions

nemo_gym.sandbox.providers.daytona.provider._quantity_to_int(
    name: str,
    value: typing.Any
) -> int

nemo_gym.sandbox.providers.daytona.provider._requested_user(
    user: str | int | None
) -> str | None

A spec’s default exec user as an os_user name, or None for root (Daytona’s own default).

nemo_gym.sandbox.providers.daytona.provider._require_daytona_sdk() -> tuple[typing.Any, typing.Any, typing.Any, typing.Any, typing.Any, typing.Any]

nemo_gym.sandbox.providers.daytona.provider._require_tenacity() -> tuple[typing.Any, typing.Any, typing.Any, typing.Any]

nemo_gym.sandbox.providers.daytona.provider._resources_requested(
    resources: nemo_gym.sandbox.providers.base.SandboxResources | collections.abc.Mapping[str, typing.Any]
) -> bool

nemo_gym.sandbox.providers.daytona.provider._spec_extensions(
    spec: nemo_gym.sandbox.providers.base.SandboxSpec
) -> dict[str, str]

nemo_gym.sandbox.providers.daytona.provider._spec_snapshot_id(
    spec: nemo_gym.sandbox.providers.base.SandboxSpec
) -> str | None

nemo_gym.sandbox.providers.daytona.provider._spec_volumes(
    spec: nemo_gym.sandbox.providers.base.SandboxSpec
) -> list[dict[str, typing.Any]] | None

nemo_gym.sandbox.providers.daytona.provider._string_map(
    values: dict[str, typing.Any]
) -> dict[str, str]

nemo_gym.sandbox.providers.daytona.provider._supplied_config_keys(
    value: typing.Any,
    config_cls: type[typing.Any]
) -> set[str]

nemo_gym.sandbox.providers.daytona.provider._to_resources(
    resources: nemo_gym.sandbox.providers.base.SandboxResources | collections.abc.Mapping[str, typing.Any]
) -> typing.Any | None

nemo_gym.sandbox.providers.daytona.provider._to_sandbox_status(
    value: typing.Any
) -> nemo_gym.sandbox.providers.base.SandboxStatus

nemo_gym.sandbox.providers.daytona.provider._to_volume_mounts(
    volumes: list[dict[str, typing.Any]]
) -> list[typing.Any]

nemo_gym.sandbox.providers.daytona.provider.DAYTONA_COMMAND_ERROR_PREFIX = 'Failed to execute command:'

nemo_gym.sandbox.providers.daytona.provider.DAYTONA_EXTENSION_PREFIX = 'daytona.'

nemo_gym.sandbox.providers.daytona.provider.LOGGER = logging.getLogger(__name__)

nemo_gym.sandbox.providers.daytona.provider.PROVIDER_OPTION_EXTENSIONS = 'extensions'

nemo_gym.sandbox.providers.daytona.provider.PROVIDER_OPTION_SNAPSHOT_ID = 'snapshot_id'

nemo_gym.sandbox.providers.daytona.provider.PROVIDER_OPTION_VOLUMES = 'volumes'

nemo_gym.sandbox.providers.daytona.provider.RETRYABLE_ERROR_MARKERS = ('connection refused', 'connection reset', 'gateway timeout', 'http 408', 'http ...

nemo_gym.sandbox.providers.daytona.provider.RETRYABLE_HTTP_STATUS_CODES = {408, 409, 425, 429, 500, 502, 503, 504}

nemo_gym.sandbox.providers.daytona.provider.SANDBOX_ID_LABEL = 'sandbox_id'

nemo_gym.sandbox.providers.daytona.provider.STATUS_CODE_RE = re.compile('(?:status code|http)\\D+(\\d{3})', re.IGNORECASE)