Sandboxes

from daytona import Daytona, CreateSandboxFromSnapshotParams

daytona = Daytona()

# Create a sandbox
sandbox = daytona.create()

# Create a sandbox with python
params = CreateSandboxFromSnapshotParams(language="python")
sandbox = daytona.create(params)

# Create a sandbox with a custom name
params = CreateSandboxFromSnapshotParams(name="my_awesome_sandbox")
sandbox = daytona.create(params)

# Create a sandbox with custom labels
params = CreateSandboxFromSnapshotParams(labels={"LABEL": "label"})
sandbox = daytona.create(params)

import { Daytona } from '@daytona/sdk';

const daytona = new Daytona();

// Create a sandbox
const sandbox = await daytona.create();

// Create a sandbox with typescript
const sandbox = await daytona.create({ language: 'typescript' });

// Create a sandbox with a custom name
const sandbox = await daytona.create({ name: 'my_awesome_sandbox' });

// Create a sandbox with custom labels
const sandbox = await daytona.create({ labels: { LABEL: 'label' } });

require 'daytona'

daytona = Daytona::Daytona.new

# Create a sandbox
sandbox = daytona.create

# Create a sandbox with python
params = Daytona::CreateSandboxFromSnapshotParams.new(language: Daytona::CodeLanguage::PYTHON)
sandbox = daytona.create(params)

# Create a sandbox with custom labels
params = Daytona::CreateSandboxFromSnapshotParams.new(labels: { 'LABEL' => 'label' })
sandbox = daytona.create(params)

// Create a sandbox
params := types.SnapshotParams{
    SandboxBaseParams: types.SandboxBaseParams{
        Language: types.CodeLanguagePython,
    },
}
sandbox, err := client.Create(ctx, params)

from daytona import Daytona, Resources, CreateSandboxFromImageParams, Image

daytona = Daytona()

# Create a sandbox with custom resources
resources = Resources(
    cpu=2,    # 2 CPU cores
    memory=4, # 4GB RAM
    disk=8,   # 8GB disk space
)

params = CreateSandboxFromImageParams(
    image=Image.debian_slim("3.12"),
    resources=resources
)

sandbox = daytona.create(params)

import { Daytona, Image } from "@daytona/sdk";

async function main() {
  const daytona = new Daytona();

  // Create a sandbox with custom resources
  const sandbox = await daytona.create({
    image: Image.debianSlim("3.12"),
    resources: {
      cpu: 2,     // 2 CPU cores
      memory: 4,  // 4GB RAM
      disk: 8,    // 8GB disk space
    },
  });
}

main();

require 'daytona'

daytona = Daytona::Daytona.new

# Create a sandbox with custom resources
sandbox = daytona.create(
  Daytona::CreateSandboxFromImageParams.new(
    image: Daytona::Image.debian_slim('3.12'),
    resources: Daytona::Resources.new(
      cpu: 2,     # 2 CPU cores
      memory: 4,  # 4GB RAM
      disk: 8     # 8GB disk space
    )
  )
)

// Create a sandbox with custom resources
sandbox, err := client.Create(ctx, types.ImageParams{
    Image: "python:3.11",
    Resources: &types.Resources{
        CPU:    2,   // 2 CPU cores
        Memory: 4,   // 4GiB RAM
        Disk:   8,   // 8GiB disk space
    },
})

from daytona import Daytona, CreateSandboxFromSnapshotParams

daytona = Daytona()

# Create an ephemeral sandbox
params = CreateSandboxFromSnapshotParams(
  ephemeral=True,
  auto_stop_interval=5 # The ephemeral sandbox will be deleted after 5 minutes of inactivity
)
sandbox = daytona.create(params)

import { Daytona } from '@daytona/sdk';

const daytona = new Daytona();

// Create an ephemeral sandbox
const sandbox = await daytona.create({
  ephemeral: true,
  autoStopInterval: 5 // The ephemeral sandbox will be deleted after 5 minutes of inactivity
});

require 'daytona'

daytona = Daytona::Daytona.new

# Create an ephemeral Sandbox
params = Daytona::CreateSandboxFromSnapshotParams.new(
  ephemeral: true,
  auto_stop_interval: 5 # The ephemeral sandbox will be deleted after 5 minutes of inactivity
)
sandbox = daytona.create(params)

// Create an ephemeral sandbox
autoStopInterval := 5
params := types.SnapshotParams{
    SandboxBaseParams: types.SandboxBaseParams{
        Language:         types.CodeLanguagePython,
        Ephemeral:        true,
        AutoStopInterval: &autoStopInterval,
    },
}
sandbox, err := client.Create(ctx, params)

sandbox = daytona.create(CreateSandboxFromSnapshotParams(language="python"))
# Start Sandbox
sandbox.start()

const sandbox = await daytona.create({ language: 'typescript' });
// Start Sandbox
await sandbox.start();

sandbox = daytona.create(Daytona::CreateSandboxFromSnapshotParams.new(language: Daytona::CodeLanguage::PYTHON))
# Start Sandbox
sandbox.start

// Start sandbox
err = sandbox.Start(ctx)

# List all sandboxes
result = daytona.list()

# Iterate through results
for sandbox in result.items:
    print(f"Sandbox: {sandbox.id} (state: {sandbox.state})")

# List sandboxes with labels filter
result = daytona.list(labels={"env": "dev"})

// List all sandboxes
const result = await daytona.list();

// Iterate through results
for (const sandbox of result.items) {
    console.log(`Sandbox: ${sandbox.id} (state: ${sandbox.state})`);
}

// List sandboxes with labels filter
const filtered = await daytona.list({ 'env': 'dev' });

# List all sandboxes
result = daytona.list

# Iterate through results
result.items.each do |sandbox|
  puts "Sandbox: #{sandbox.id} (state: #{sandbox.state})"
end

# List sandboxes with labels filter
result = daytona.list({ 'env' => 'dev' })

// List all sandboxes
result, err := client.List(ctx, nil, nil, nil)

// Iterate through results
for _, sandbox := range result.Items {
    fmt.Printf("Sandbox: %s (state: %s)\n", sandbox.Name, sandbox.State)
}

sandbox = daytona.create(CreateSandboxFromSnapshotParams(language="python"))

# Stop sandbox
sandbox.stop()

print(sandbox.id) # 7cd11133-96c1-4cc8-9baa-c757b8f8c916

# The sandbox ID can later be used to get the sandbox and start it
sandbox = daytona.get("7cd11133-96c1-4cc8-9baa-c757b8f8c916")

# Start sandbox
sandbox.start()

const sandbox = await daytona.create({ language: 'typescript' });

// Stop sandbox
await sandbox.stop();

console.log(sandbox.id) // 7cd11133-96c1-4cc8-9baa-c757b8f8c916

// The sandbox ID can later be used to get the sandbox and start it
const found = await daytona.get('7cd11133-96c1-4cc8-9baa-c757b8f8c916');

// Start sandbox
await found.start();

sandbox = daytona.create(Daytona::CreateSandboxFromSnapshotParams.new(language: Daytona::CodeLanguage::PYTHON))

# Stop sandbox
sandbox.stop

puts sandbox.id # 7cd11133-96c1-4cc8-9baa-c757b8f8c916

# The sandbox ID can later be used to find the sandbox and start it
sandbox = daytona.get('7cd11133-96c1-4cc8-9baa-c757b8f8c916')

# Start sandbox
sandbox.start

// Stop sandbox
err = sandbox.Stop(ctx)

fmt.Println(sandbox.ID) // 7cd11133-96c1-4cc8-9baa-c757b8f8c916

// The sandbox ID can later be used to find the sandbox and start it
sandbox, err = client.Get(ctx, sandbox.ID)

// Start sandbox
err = sandbox.Start(ctx)

# Archive Sandbox
sandbox.archive()

// Archive Sandbox
await sandbox.archive();

# Archive Sandbox
sandbox.archive

// Archive sandbox
err = sandbox.Archive(ctx)

# Recover sandbox
sandbox.recover()

// Recover sandbox
await sandbox.recover();

# Recover sandbox
sandbox.recover

# Check if the Sandbox is recoverable
if sandbox.recoverable:
    sandbox.recover()
    print("Sandbox recovered successfully")

// Check if the Sandbox is recoverable
if (sandbox.recoverable) {
    await sandbox.recover();
    console.log('Sandbox recovered successfully');
}

# Check if the Sandbox is in an error state before recovering
if sandbox.state == 'error'
  sandbox.recover
  puts 'Sandbox recovered successfully'
end

from daytona import Daytona, Resources

daytona = Daytona()
sandbox = daytona.create()

# Resize a started sandbox (CPU and memory can be increased)
sandbox.resize(Resources(cpu=2, memory=4))

# Resize a stopped sandbox (CPU and memory can change, disk can only increase)
sandbox.stop()
sandbox.resize(Resources(cpu=4, memory=8, disk=20))
sandbox.start()

import { Daytona } from '@daytona/sdk';

const daytona = new Daytona();
const sandbox = await daytona.create();

// Resize a started sandbox (CPU and memory can be increased)
await sandbox.resize({ cpu: 2, memory: 4 });

// Resize a stopped sandbox (CPU and memory can change, disk can only increase)
await sandbox.stop();
await sandbox.resize({ cpu: 4, memory: 8, disk: 20 });
await sandbox.start();

require 'daytona'

daytona = Daytona::Daytona.new
sandbox = daytona.create

# Resize a started sandbox (CPU and memory can be increased)
sandbox.resize(Daytona::Resources.new(cpu: 2, memory: 4))

# Resize a stopped sandbox (CPU and memory can change, disk can only increase)
sandbox.stop
sandbox.resize(Daytona::Resources.new(cpu: 4, memory: 8, disk: 20))
sandbox.start

// Resize a started sandbox (CPU and memory can be increased)
err := sandbox.Resize(ctx, &types.Resources{CPU: 2, Memory: 4})

// Resize a stopped sandbox (CPU and memory can change, disk can only increase)
err = sandbox.Stop(ctx)
err = sandbox.Resize(ctx, &types.Resources{CPU: 4, Memory: 8, Disk: 20})
err = sandbox.Start(ctx)

# Delete sandbox
sandbox.delete()

// Delete sandbox
await sandbox.delete();

# Delete sandbox
sandbox.delete

// Delete sandbox
err = sandbox.Delete(ctx)

sandbox = daytona.create(CreateSandboxFromSnapshotParams(
    snapshot="my-snapshot-name",
    # Disables the auto-stop feature - default is 15 minutes
    auto_stop_interval=0,
))

const sandbox = await daytona.create({
    snapshot: "my-snapshot-name",
      // Disables the auto-stop feature - default is 15 minutes
    autoStopInterval: 0,
});

sandbox = daytona.create(
  Daytona::CreateSandboxFromSnapshotParams.new(
    snapshot: 'my-snapshot-name',
    # Disables the auto-stop feature - default is 15 minutes
    auto_stop_interval: 0
  )
)

// Create a sandbox with auto-stop disabled
autoStopInterval := 0
params := types.SnapshotParams{
    Snapshot: "my-snapshot-name",
    SandboxBaseParams: types.SandboxBaseParams{
        AutoStopInterval: &autoStopInterval,
    },
}
sandbox, err := client.Create(ctx, params)

sandbox = daytona.create(CreateSandboxFromSnapshotParams(
    snapshot="my-snapshot-name",
    # Auto-archive after a sandbox has been stopped for 1 hour
    auto_archive_interval=60,
))

const sandbox = await daytona.create({
    snapshot: "my-snapshot-name",
    // Auto-archive after a sandbox has been stopped for 1 hour
    autoArchiveInterval: 60,
});

sandbox = daytona.create(
  Daytona::CreateSandboxFromSnapshotParams.new(
    snapshot: 'my-snapshot-name',
    # Auto-archive after a sandbox has been stopped for 1 hour
    auto_archive_interval: 60
  )
)

// Create a sandbox with auto-archive after 1 hour
autoArchiveInterval := 60
params := types.SnapshotParams{
    Snapshot: "my-snapshot-name",
    SandboxBaseParams: types.SandboxBaseParams{
        AutoArchiveInterval: &autoArchiveInterval,
    },
}
sandbox, err := client.Create(ctx, params)

sandbox = daytona.create(CreateSandboxFromSnapshotParams(
    snapshot="my-snapshot-name",
    # Auto-delete after a sandbox has been stopped for 1 hour
    auto_delete_interval=60,
))

# Delete the sandbox immediately after it has been stopped
sandbox.set_auto_delete_interval(0)

# Disable auto-deletion
sandbox.set_auto_delete_interval(-1)

const sandbox = await daytona.create({
    snapshot: "my-snapshot-name",
    // Auto-delete after a sandbox has been stopped for 1 hour
    autoDeleteInterval: 60,
});

// Delete the sandbox immediately after it has been stopped
await sandbox.setAutoDeleteInterval(0)

// Disable auto-deletion
await sandbox.setAutoDeleteInterval(-1)

sandbox = daytona.create(
  Daytona::CreateSandboxFromSnapshotParams.new(
    snapshot: 'my-snapshot-name',
    # Auto-delete after a sandbox has been stopped for 1 hour
    auto_delete_interval: 60
  )
)

# Delete the sandbox immediately after it has been stopped
sandbox.auto_delete_interval = 0

# Disable auto-deletion
sandbox.auto_delete_interval = -1

// Create a sandbox with auto-delete after 1 hour
autoDeleteInterval := 60
params := types.SnapshotParams{
    Snapshot: "my-snapshot-name",
    SandboxBaseParams: types.SandboxBaseParams{
        AutoDeleteInterval: &autoDeleteInterval,
    },
}
sandbox, err := client.Create(ctx, params)

// Delete the sandbox immediately after it has been stopped
zeroInterval := 0
err = sandbox.SetAutoDeleteInterval(ctx, &zeroInterval)

// Disable auto-deletion
disableInterval := -1
err = sandbox.SetAutoDeleteInterval(ctx, &disableInterval)

sandbox = daytona.create(CreateSandboxFromSnapshotParams(
    snapshot="my_awesome_snapshot",
    # Disables the auto-stop feature - default is 15 minutes
    auto_stop_interval=0,
))

const sandbox = await daytona.create({
    snapshot: "my_awesome_snapshot",
    // Disables the auto-stop feature - default is 15 minutes
    autoStopInterval: 0,
});

sandbox = daytona.create(
  Daytona::CreateSandboxFromSnapshotParams.new(
    snapshot: 'my_awesome_snapshot',
    # Disables the auto-stop feature - default is 15 minutes
    auto_stop_interval: 0
  )
)

// Disables the auto-stop feature - default is 15 minutes
autoStopInterval := 0
params := types.SnapshotParams{
    Snapshot: "my_awesome_snapshot",
    SandboxBaseParams: types.SandboxBaseParams{
        AutoStopInterval: &autoStopInterval,
    },
}
sandbox, err := client.Create(ctx, params)