LLM Sandbox

from llm_sandbox import SandboxSession
# Create and use a sandbox sessionwith SandboxSession(lang="python") as session:    result = session.run("""print("Hello from LLM Sandbox!")print("I'm running in a secure container.")    """)    print(result.stdout)

from llm_sandbox import SandboxSession
with SandboxSession(backend="bubblewrap", lang="python") as session:    result = session.run("print('Hello from a local Linux sandbox!')")    print(result.stdout)

from llm_sandbox import SandboxSession
with SandboxSession(backend="windows-mxc", lang="python") as session:    print(session.run("import platform; print(platform.system())").stdout)

from llm_sandbox import SandboxSession
with SandboxSession(    backend="wsl2-bubblewrap",    distribution="Ubuntu",    lang="python",) as session:    print(session.run("import platform; print(platform.system())").stdout)

from llm_sandbox import SandboxSession
with SandboxSession(lang="python") as session:    result = session.run("""import numpy as np
# Create an arrayarr = np.array([1, 2, 3, 4, 5])print(f"Array: {arr}")print(f"Mean: {np.mean(arr)}")    """, libraries=["numpy"])
    print(result.stdout)

with SandboxSession(lang="javascript") as session:    result = session.run("""const greeting = "Hello from Node.js!";console.log(greeting);
const axios = require('axios');console.log("Axios loaded successfully!");    """, libraries=["axios"])

with SandboxSession(lang="java") as session:    result = session.run("""public class HelloWorld {    public static void main(String[] args) {        System.out.println("Hello from Java!");    }}    """)

with SandboxSession(lang="cpp") as session:    result = session.run("""#include <iostream>
int main() {    std::cout << "Hello from C++!" << std::endl;    return 0;}    """)

with SandboxSession(lang="go") as session:    result = session.run("""package mainimport "fmt"
func main() {    fmt.Println("Hello from Go!")}    """)

with SandboxSession(    lang="r",    image="ghcr.io/vndee/sandbox-r-451-bullseye",    verbose=True,) as session:    result = session.run(        """# Basic R operationsprint("=== Basic R Demo ===")
# Create some datanumbers <- c(1, 2, 3, 4, 5, 10, 15, 20)print(paste("Numbers:", paste(numbers, collapse=", ")))
# Basic statisticsprint(paste("Mean:", mean(numbers)))print(paste("Median:", median(numbers)))print(paste("Standard Deviation:", sd(numbers)))
# Work with data framesdf <- data.frame(    name = c("Alice", "Bob", "Charlie", "Diana"),    age = c(25, 30, 35, 28),    score = c(85, 92, 78, 96))
print("=== Data Frame ===")print(df)
# Calculate average scoreavg_score <- mean(df$score)print(paste("Average Score:", avg_score))        """    )

from llm_sandbox import InteractiveSandboxSession
with InteractiveSandboxSession(    lang="python",    kernel_type="ipython",    history_size=200,) as session:    session.run("value = 21 * 2")    result = session.run("print(f'Result: {value}')")    print(result.stdout)  # -> Result: 42
    # Use magic command to install libraries    session.run("%pip install pandas")    result = session.run("import pandas as pd; print(pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]}))")    print(result.stdout)

from llm_sandbox import ArtifactSandboxSessionimport base64from pathlib import Path
with ArtifactSandboxSession(lang="python") as session:    result = session.run("""import matplotlib.pyplot as pltimport numpy as np
x = np.linspace(0, 10, 100)y = np.sin(x)
plt.figure(figsize=(10, 6))plt.plot(x, y)plt.title("Sine Wave")plt.xlabel("x")plt.ylabel("sin(x)")plt.grid(True)plt.savefig("sine_wave.png", dpi=150, bbox_inches="tight")plt.show()    """, libraries=["matplotlib", "numpy"])
    # Extract the generated plots    print(f"Generated {len(result.plots)} plots")
    # Save plots to files    for i, plot in enumerate(result.plots):        plot_path = Path(f"plot_{i + 1}.{plot.format.value}")        with plot_path.open("wb") as f:            f.write(base64.b64decode(plot.content_base64))

from llm_sandbox import ArtifactSandboxSessionimport base64from pathlib import Path
with ArtifactSandboxSession(lang="r") as session:    result = session.run("""library(ggplot2)
# Create sample datadata <- data.frame(    x = rnorm(100),    y = rnorm(100))
# Create ggplot2 visualizationp <- ggplot(data, aes(x = x, y = y)) +    geom_point(alpha = 0.6) +    geom_smooth(method = "lm", se = FALSE) +    labs(title = "Scatter Plot with Trend Line",         x = "X values", y = "Y values") +    theme_minimal()
print(p)
# Base R plothist(data$x, main = "Distribution of X",     xlab = "X values", col = "lightblue", breaks = 20)    """, libraries=["ggplot2"])
    # Extract the generated plots    print(f"Generated {len(result.plots)} R plots")
    # Save plots to files    for i, plot in enumerate(result.plots):        plot_path = Path(f"r_plot_{i + 1}.{plot.format.value}")        with plot_path.open("wb") as f:            f.write(base64.b64decode(plot.content_base64))

from llm_sandbox import SandboxSession
# Create a new sandbox sessionwith SandboxSession(image="python:3.9.19-bullseye", keep_template=True, lang="python") as session:    result = session.run("print('Hello, World!')")    print(result)
# With custom Dockerfilewith SandboxSession(dockerfile="Dockerfile", keep_template=True, lang="python") as session:    result = session.run("print('Hello, World!')")    print(result)
# Or default imagewith SandboxSession(lang="python", keep_template=True) as session:    result = session.run("print('Hello, World!')")    print(result)

from llm_sandbox import SandboxSession
with SandboxSession(lang="python", keep_template=True) as session:    # Copy a file from the host to the sandbox    session.copy_to_runtime("test.py", "/sandbox/test.py")
    # Run the copied Python code in the sandbox    result = session.execute_command("python /sandbox/test.py")    print(result)
    # Copy a file from the sandbox to the host    session.copy_from_runtime("/sandbox/output.txt", "output.txt")

from llm_sandbox import SandboxSession
pod_manifest = {    "apiVersion": "v1",    "kind": "Pod",    "metadata": {        "name": "test",        "namespace": "test",        "labels": {"app": "sandbox"},    },    "spec": {        "containers": [            {                "name": "sandbox-container",                "image": "test",                "tty": True,                "volumeMounts": {                    "name": "tmp",                    "mountPath": "/tmp",                },            }        ],        "volumes": [{"name": "tmp", "emptyDir": {"sizeLimit": "5Gi"}}],    },}with SandboxSession(    backend="kubernetes",    image="python:3.9.19-bullseye",    dockerfile=None,    lang="python",    keep_template=False,    verbose=False,    pod_manifest=pod_manifest,) as session:    result = session.run("print('Hello, World!')")    print(result)

import dockerfrom llm_sandbox import SandboxSession
tls_config = docker.tls.TLSConfig(    client_cert=("path/to/cert.pem", "path/to/key.pem"),    ca_cert="path/to/ca.pem",    verify=True)docker_client = docker.DockerClient(base_url="tcp://<your_host>:<port>", tls=tls_config)
with SandboxSession(    client=docker_client,    image="python:3.9.19-bullseye",    keep_template=True,    lang="python",) as session:    result = session.run("print('Hello, World!')")    print(result)

from kubernetes import client, configfrom llm_sandbox import SandboxSession
# Use local kubeconfigconfig.load_kube_config()k8s_client = client.CoreV1Api()
with SandboxSession(    client=k8s_client,    backend="kubernetes",    image="python:3.9.19-bullseye",    lang="python",    pod_manifest=pod_manifest, # None by default) as session:    result = session.run("print('Hello from Kubernetes!')")    print(result)

from llm_sandbox import SandboxSession
with SandboxSession(    backend="podman",    lang="python",    image="python:3.9.19-bullseye") as session:    result = session.run("print('Hello from Podman!')")    print(result)

from llm_sandbox import SandboxSessionfrom llm_sandbox.pool import PoolConfig, create_pool_manager
# Create a pool manager explicitlypool = create_pool_manager(    backend="docker",    config=PoolConfig(        max_pool_size=10,          # Maximum containers        min_pool_size=3,           # Keep at least 3 warm        idle_timeout=300.0,        # Recycle idle containers after 5 min        enable_prewarming=True,    # Create containers on startup    ),    lang="python",)
# Use the pool in a sessionwith SandboxSession(    lang="python",    pool=pool,) as session:    result = session.run("print('Hello from pool!')")
# Container is automatically returned to pool when the session closes# Clean up the pool when donepool.close()

from llm_sandbox import SandboxSessionfrom llm_sandbox.pool import create_pool_manager, PoolConfig
# Create a shared pool managerpool = create_pool_manager(    backend="docker",    config=PoolConfig(        max_pool_size=10,        min_pool_size=3,    ),    lang="python",    libraries=["numpy", "pandas"],  # Pre-install libraries in all containers)
# Use the pool in multiple sessionswith SandboxSession(lang="python", pool=pool) as session1:    result1 = session1.run("import pandas; print(pandas.__version__)")
with SandboxSession(lang="python", pool=pool) as session2:    result2 = session2.run("import numpy; print(numpy.__version__)")
# Clean up when donepool.close()

from concurrent.futures import ThreadPoolExecutorfrom llm_sandbox import SandboxSessionfrom llm_sandbox.pool import create_pool_manager, PoolConfig
# Create shared poolpool = create_pool_manager(    backend="docker",    config=PoolConfig(max_pool_size=5),    lang="python",)
def run_code(task_id: int):    with SandboxSession(lang="python", pool=pool) as session:        return session.run(f'print("Task {task_id}")')
try:    # Execute 20 tasks concurrently using only 5 containers    with ThreadPoolExecutor(max_workers=10) as executor:        results = list(executor.map(run_code, range(20)))finally:    pool.close()

from llm_sandbox.pool import PoolConfig, ExhaustionStrategy, create_pool_manager
config = PoolConfig(    # Pool size limits    max_pool_size=10,                      # Maximum containers in pool    min_pool_size=2,                       # Minimum warm containers
    # Timeout configuration    idle_timeout=300.0,                    # Recycle idle containers (seconds)    acquisition_timeout=30.0,              # Wait time for available container
    # Health and lifecycle    health_check_interval=60.0,            # Health check frequency    max_container_lifetime=3600.0,         # Max container lifetime    max_container_uses=100,                # Max uses before recycling
    # Pool exhaustion behavior    exhaustion_strategy=ExhaustionStrategy.WAIT,  # WAIT, FAIL_FAST, or TEMPORARY
    # Pre-warming    enable_prewarming=True,                # Pre-warm containers)
pool = create_pool_manager(    backend="docker",    config=config,    lang="python",    libraries=["requests", "numpy"],       # Pre-install libraries)

config = PoolConfig(    max_pool_size=5,    exhaustion_strategy=ExhaustionStrategy.WAIT,    acquisition_timeout=30.0,  # Wait up to 30 seconds)

config = PoolConfig(    max_pool_size=5,    exhaustion_strategy=ExhaustionStrategy.FAIL_FAST,)

config = PoolConfig(    max_pool_size=5,    exhaustion_strategy=ExhaustionStrategy.TEMPORARY,)

from llm_sandbox.pool import create_pool_manager
pool = create_pool_manager(backend="docker", lang="python")
# Get pool statisticsstats = pool.get_stats()print(f"Total containers: {stats['total_size']}")print(f"Idle containers: {stats['state_counts']['idle']}")print(f"Busy containers: {stats['state_counts']['busy']}")
pool.close()

from llm_sandbox import ArtifactSandboxSessionfrom llm_sandbox.pool import create_pool_manager, PoolConfigimport base64from pathlib import Path
# Create pool with pre-installed visualization librariespool = create_pool_manager(    backend="docker",    config=PoolConfig(max_pool_size=5, min_pool_size=2),    lang="python",    libraries=["matplotlib", "numpy"],)
try:    # Option 1: Use pool parameter (recommended for API consistency)    with ArtifactSandboxSession(pool=pool, enable_plotting=True) as session:        result = session.run("""import matplotlib.pyplot as pltimport numpy as np
x = np.linspace(0, 10, 100)y = np.sin(x)plt.plot(x, y)plt.title('Pooled Execution - Sine Wave')plt.show()        """)
        # Save generated plots        for i, plot in enumerate(result.plots):            Path(f"plot_{i}.{plot.format.value}").write_bytes(                base64.b64decode(plot.content_base64)            )
        print(f"Generated {len(result.plots)} plots using pooled container")
    # Option 2: Use ArtifactPooledSandboxSession (explicit class)    # Both approaches work identically    from llm_sandbox.pool import ArtifactPooledSandboxSession
    with ArtifactPooledSandboxSession(pool_manager=pool, enable_plotting=True) as session:        result = session.run("print('Same functionality, different API')")
finally:    pool.close()

from llm_sandbox import SandboxSession
SANDBOX_RUNTIME = {    "network_mode": "none",                        # no egress    "mem_limit": "512m",    "pids_limit": 128,                             # bounds fork bombs    "security_opt": ["no-new-privileges:true"],}
def run_python(code: str) -> str:    with SandboxSession(        lang="python",        keep_template=True,                        # else the image is re-pulled each call        runtime_configs=SANDBOX_RUNTIME,    ) as session:        result = session.run(code, timeout=30)    return result.stdout if result.exit_code == 0 else result.stderr