> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/nemo/gym/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/nemo/gym/_mcp/server.

# nemo_gym.sandbox.providers.daytona

Daytona provider package.

## Submodules

* **[`nemo_gym.sandbox.providers.daytona.provider`](/nemo/gym/nemo-gym/nemo_gym/sandbox/providers/daytona/provider)**

## Package Contents

### Classes

| Name                                                                                                  | Description                                                                     |
| ----------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| [`DaytonaBatchConfig`](#nemo_gym-sandbox-providers-daytona-provider-DaytonaBatchConfig)               | Client-side batch fanout settings.                                              |
| [`DaytonaConnectionConfig`](#nemo_gym-sandbox-providers-daytona-provider-DaytonaConnectionConfig)     | Daytona API client connection settings.                                         |
| [`DaytonaCreateConfig`](#nemo_gym-sandbox-providers-daytona-provider-DaytonaCreateConfig)             | Daytona sandbox creation settings.                                              |
| [`DaytonaCreateError`](#nemo_gym-sandbox-providers-daytona-provider-DaytonaCreateError)               | Raised when Daytona cannot create a sandbox.                                    |
| [`DaytonaCreateTimeoutError`](#nemo_gym-sandbox-providers-daytona-provider-DaytonaCreateTimeoutError) | Raised when Daytona sandbox creation exceeds the client timeout.                |
| [`DaytonaOperationConfig`](#nemo_gym-sandbox-providers-daytona-provider-DaytonaOperationConfig)       | Retry and timeout settings for Daytona operations after create.                 |
| [`DaytonaProbeConfig`](#nemo_gym-sandbox-providers-daytona-provider-DaytonaProbeConfig)               | Post-create probe settings.                                                     |
| [`DaytonaProvider`](#nemo_gym-sandbox-providers-daytona-provider-DaytonaProvider)                     | Provider backed by the Daytona Python SDK.                                      |
| [`DaytonaProviderOptions`](#nemo_gym-sandbox-providers-daytona-provider-DaytonaProviderOptions)       | Recognized per-sandbox create options read from `SandboxSpec.provider_options`. |

### API

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

Dataclass

**Bases:** [DaytonaConfigBase](#nemo_gym-sandbox-providers-daytona-provider-DaytonaConfigBase)

Client-side batch fanout settings.

**`concurrency`** `int = 4`

---

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

```python
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](#nemo_gym-sandbox-providers-daytona-provider-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`

---

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

```python
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](#nemo_gym-sandbox-providers-daytona-provider-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`

---

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

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

**Bases:** [SandboxCreateError](/nemo/gym/nemo-gym/nemo_gym/sandbox/providers/base#nemo_gym-sandbox-providers-base-SandboxCreateError)

Raised when Daytona cannot create a sandbox.

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

**Bases:** [DaytonaCreateError](#nemo_gym-sandbox-providers-daytona-provider-DaytonaCreateError)

Raised when Daytona sandbox creation exceeds the client timeout.

```python
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](#nemo_gym-sandbox-providers-daytona-provider-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`

---

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

```python
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](#nemo_gym-sandbox-providers-daytona-provider-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`

---

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

```python
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)`

---

**`_probe`** `= DaytonaProbeConfig.from_mapping(probe)`

---

**`name`** `= 'daytona'`

---

```python
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

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

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

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

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

async

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

async

```python
nemo_gym.sandbox.providers.daytona.DaytonaProvider._effective_command(
    command: str,
    user: str | int | None
) -> str
```

staticmethod

```python
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

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

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

async

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

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

async

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

async

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

async

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

async

```python
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

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

async

```python
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

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

async

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

async

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

async

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

async

```python
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], ...] = ()`

---

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

classmethod