code-sandboxes 1.4.4__tar.gz

code_sandboxes-1.4.4/.github/workflows/build.yml

@@ -0,0 +1,24 @@
+name: Build
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main, develop ]
+  workflow_dispatch:
+
+jobs:
+  python-build:
+    name: Python Build & Test (${{ matrix.python-version }})
+    strategy:
+      matrix:
+        python-version: ['3.11', '3.12']
+    uses: ./.github/workflows/reusable-python.yml
+    with:
+      python-version: ${{ matrix.python-version }}
+      install-extras: test,typing
+      extra-packages: dbus-python keyring secretstorage
+      run-tests: true
+      test-command: pytest tests/ --cov=code_sandboxes --cov-report term-missing
+      run-mypy: true
+      mypy-target: code_sandboxes

code_sandboxes-1.4.4/.github/workflows/py-code-style.yml

@@ -0,0 +1,44 @@
+name: Py Code Style
+
+on:
+  push:
+    branches:
+      - main
+      - develop
+    paths:
+      - 'code_sandboxes/**/*.py'
+      - 'tests/**/*.py'
+      - 'pyproject.toml'
+      - 'setup.py'
+      - '.pre-commit-config.yaml'
+      - 'ruff.toml'
+      - '.ruff.toml'
+      - '.github/workflows/py-code-style.yml'
+      - '.github/workflows/reusable-python.yml'
+  pull_request:
+    branches:
+      - main
+      - develop
+    paths:
+      - 'code_sandboxes/**/*.py'
+      - 'tests/**/*.py'
+      - 'pyproject.toml'
+      - 'setup.py'
+      - '.pre-commit-config.yaml'
+      - 'ruff.toml'
+      - '.ruff.toml'
+      - '.github/workflows/py-code-style.yml'
+      - '.github/workflows/reusable-python.yml'
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  check-code-style:
+    uses: ./.github/workflows/reusable-python.yml
+    with:
+      python-version: '3.11'
+      extra-packages: pre-commit
+      run-pre-commit: true

code_sandboxes-1.4.4/.github/workflows/py-tests.yml

@@ -0,0 +1,43 @@
+name: Py Tests
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'code_sandboxes/**'
+      - 'tests/**'
+      - 'pyproject.toml'
+      - 'setup.py'
+      - 'requirements*.txt'
+      - '**/*.py'
+      - '.github/workflows/py-tests.yml'
+      - '.github/workflows/reusable-python.yml'
+  pull_request:
+    branches:
+      - main
+    paths:
+      - 'code_sandboxes/**'
+      - 'tests/**'
+      - 'pyproject.toml'
+      - 'setup.py'
+      - 'requirements*.txt'
+      - '**/*.py'
+      - '.github/workflows/py-tests.yml'
+      - '.github/workflows/reusable-python.yml'
+
+  workflow_dispatch:
+
+jobs:
+  tests:
+    strategy:
+      max-parallel: 1
+      matrix:
+        python-version: ['3.10', '3.11', '3.12', '3.13']
+    uses: ./.github/workflows/reusable-python.yml
+    with:
+      python-version: ${{ matrix.python-version }}
+      install-extras: test
+      extra-packages: dbus-python keyring secretstorage
+      run-tests: true
+      test-command: pytest tests/ --cov=code_sandboxes --cov-report term-missing

code_sandboxes-1.4.4/.github/workflows/py-typing.yml

@@ -0,0 +1,44 @@
+name: Py Type Checking
+
+on:
+  push:
+    branches:
+      - main
+      - develop
+    paths:
+      - 'code_sandboxes/**/*.py'
+      - 'tests/**/*.py'
+      - 'pyproject.toml'
+      - 'setup.py'
+      - 'mypy.ini'
+      - '.mypy.ini'
+      - '.github/workflows/py-typing.yml'
+      - '.github/workflows/reusable-python.yml'
+  pull_request:
+    branches:
+      - main
+      - develop
+    paths:
+      - 'code_sandboxes/**/*.py'
+      - 'tests/**/*.py'
+      - 'pyproject.toml'
+      - 'setup.py'
+      - 'mypy.ini'
+      - '.mypy.ini'
+      - '.github/workflows/py-typing.yml'
+      - '.github/workflows/reusable-python.yml'
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  type-check:
+    uses: ./.github/workflows/reusable-python.yml
+    with:
+      python-version: '3.12'
+      install-extras: typing
+      extra-packages: types-requests
+      run-mypy: true
+      mypy-target: code_sandboxes

code_sandboxes-1.4.4/.github/workflows/reusable-python.yml

@@ -0,0 +1,100 @@
+name: Reusable Python Workflow
+
+on:
+  workflow_call:
+    inputs:
+      python-version:
+        description: Python version to use
+        required: false
+        type: string
+        default: '3.11'
+      install-system-deps:
+        description: Install Linux system dependencies and unlock keyring
+        required: false
+        type: boolean
+        default: true
+      install-extras:
+        description: Optional extras to install from pyproject (for example test,typing)
+        required: false
+        type: string
+        default: ''
+      extra-packages:
+        description: Optional extra packages to install with uv pip
+        required: false
+        type: string
+        default: ''
+      run-tests:
+        description: Run tests
+        required: false
+        type: boolean
+        default: false
+      test-command:
+        description: Test command to run when run-tests=true
+        required: false
+        type: string
+        default: 'pytest -q'
+      run-mypy:
+        description: Run mypy
+        required: false
+        type: boolean
+        default: false
+      mypy-target:
+        description: Package/module path to type-check
+        required: false
+        type: string
+        default: ''
+      run-pre-commit:
+        description: Run pre-commit
+        required: false
+        type: boolean
+        default: false
+
+jobs:
+  python-checks:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Install system dependencies
+        if: inputs.install-system-deps
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libdbus-1-3 libdbus-1-dev libglib2.0-dev
+
+      - name: Checkout
+        uses: actions/checkout@v6
+
+      - name: Setup UV
+        uses: astral-sh/setup-uv@v7
+        with:
+          version: latest
+          python-version: ${{ inputs.python-version }}
+          activate-environment: true
+
+      - name: Install dependencies
+        run: |
+          uv pip install .
+          if [[ -n "${{ inputs.install-extras }}" ]]; then
+            uv pip install ".[${{ inputs.install-extras }}]"
+          fi
+          if [[ -n "${{ inputs.extra-packages }}" ]]; then
+            uv pip install ${{ inputs.extra-packages }}
+          fi
+
+      - name: Unlock keyring
+        if: inputs.install-system-deps
+        uses: t1m0thyj/unlock-keyring@v1
+
+      - name: Configure git to use https
+        run: git config --global hub.protocol https
+
+      - name: Run tests
+        if: inputs.run-tests
+        run: ${{ inputs.test-command }}
+
+      - name: Run mypy
+        if: inputs.run-mypy
+        run: mypy ${{ inputs.mypy-target }}
+
+      - name: Run pre-commit
+        if: inputs.run-pre-commit
+        run: pre-commit run --all-files

code_sandboxes-1.4.4/.gitignore

@@ -0,0 +1,129 @@
+*.egg-info/
+.ipynb_checkpoints
+
+# Created by https://www.gitignore.io/api/python
+# Edit at https://www.gitignore.io/?templates=python
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+dist/
+downloads/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+.installed.cfg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Environment variables:
+.env
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# Mr Developer
+.mr.developer.cfg
+.project
+.pydevproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# ruff
+.ruff_cache
+
+# Pyre type checker
+.pyre/
+
+# End of https://www.gitignore.io/api/python
+
+# OSX files
+.DS_Store
+
+# Include
+!**/.*ignore
+!**/.*rc
+!**/.*rc.js
+!**/.*rc.json
+!**/.*rc.yml
+!**/.*config
+!*.*rc.json
+!.github
+!.devcontainer
+
+untracked_notebooks/*
+.jupyter_ystore
+.jupyter_ystore.db
+docs/.yarn/*
+
+uv.lock
+
+generated
+skills

code_sandboxes-1.4.4/.licenserc.yaml

@@ -0,0 +1,18 @@
+header:
+  license:
+    content: |
+      Copyright (c) 2025-2026 Datalayer, Inc.
+
+      BSD 3-Clause License
+
+
+  paths-ignore:
+    - '**/*.ipynb'
+    - '**/*.json'
+    - '**/*.yaml'
+    - '**/*.yml'
+    - '**/.*'
+    - 'docs/**/*'
+    - 'LICENSE'
+
+  comment: on-failure

code_sandboxes-1.4.4/.pre-commit-config.yaml

@@ -0,0 +1,38 @@
+ci:
+  autoupdate_schedule: monthly
+
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: end-of-file-fixer
+      - id: check-case-conflict
+      - id: check-executables-have-shebangs
+      - id: requirements-txt-fixer
+      - id: check-added-large-files
+      - id: check-case-conflict
+      - id: check-toml
+      - id: check-yaml
+      - id: debug-statements
+      - id: forbid-new-submodules
+      - id: check-builtin-literals
+      - id: trailing-whitespace
+
+  - repo: https://github.com/python-jsonschema/check-jsonschema
+    rev: 0.29.4
+    hooks:
+      - id: check-github-workflows
+
+  - repo: https://github.com/executablebooks/mdformat
+    rev: 0.7.19
+    hooks:
+      - id: mdformat
+        additional_dependencies:
+          [mdformat-gfm, mdformat-frontmatter, mdformat-footnote]
+
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: v0.8.0
+    hooks:
+      - id: ruff
+        args: ["--fix"]
+      - id: ruff-format

code_sandboxes-1.4.4/.vscode/settings.json

@@ -0,0 +1,9 @@
+{
+    "python-envs.pythonProjects": [
+        {
+            "path": "",
+            "envManager": "ms-python.python:conda",
+            "packageManager": "ms-python.python:conda"
+        }
+    ]
+}

code_sandboxes-1.4.4/CHANGELOG.md

@@ -0,0 +1,223 @@
+<!--
+  ~ Copyright (c) 2025-2026 Datalayer, Inc.
+  ~
+  ~ BSD 3-Clause License
+-->
+
+# Changelog
+
+## Unreleased
+
+- `DatalayerSandbox` can be interrupted. It neither implemented `_do_interrupt`
+  nor read the flag the base class sets, so the default ran instead: it sets a
+  flag, returns `True`, and stops nothing. Everything above believed it —
+  `tasks/cancel` in the MCP gateway marks a task `cancelled` and calls the
+  interrupt `execute_cell` registered, which is this. Measured on prod1 on
+  2026-09-07: a two-minute cell cancelled ten seconds in answered `cancelled`
+  from both `tasks/cancel` and `tasks/get`, and the next `execute_code` on that
+  session took **60.8 seconds** and came back empty, where a free kernel answers
+  in about a second. The cell ran to completion on a runtime that went on being
+  billed. It now delegates to the runtime's own `sandbox_client` — the
+  jupyter-server client `run_code` already executes through, which interrupts
+  the kernel over the REST API — and answers whether the interrupt was
+  delivered, never raising: a cancel that cannot reach the kernel is a cancel
+  that failed, and the caller decides what that means.
+
+  `docker` and `monty` have the same hole and are pinned as known in
+  `tests/test_a_datalayer_sandbox_can_be_interrupted.py`, so the set cannot grow
+  quietly. (`google_colab` and `kaggle` are entitled to the default: they poll
+  `_interrupt_requested` and stop cooperatively.)
+
+- `provider_catalog` takes a `names` argument, so a caller can describe the
+  providers it serves and pay for only those. Added under 1.3.1 without a
+  version bump, which is what broke the operator: its image installs this
+  package unpinned, PyPI's newest was 1.3.0, and the two-argument call landed
+  on a one-argument function — `TypeError: provider_catalog() takes from 0 to 1 positional arguments but 2 were given`, and `datalayer envs ls` answered 500.
+  A new public parameter is a feature; released as 1.4.0 so a dependant can ask
+  for it.
+
+- `CodeExecutionOutcome` now carries `outputs`: the rich results as Jupyter
+  outputs, with their mime bundles intact. It called itself a faithful superset
+  of the raw `ExecutionResult` and was not — every representation but
+  `text/plain` was dropped on the way through, so a matplotlib figure reached
+  its callers as the string `<Figure size 640x480 with 1 Axes>` and anything
+  wanting to draw it had nothing to draw. `results` is unchanged, for callers
+  that only print.
+
+- Exported the lifecycle vocabulary from the package root, so a consumer writes
+  `from code_sandboxes import SandboxLifecycle` rather than reaching into
+  `code_sandboxes.lifecycle` — the import path is the part that cannot be
+  changed afterwards, which is why it moved before anything depended on it.
+
+  The vocabulary gained `update` (the Runtimes API's `PUT`) and split in two.
+  `SandboxLifecycle` is one sandbox — `start`, `stop`, `pause`, `resume`,
+  `snapshot`, `run_code`; `SandboxManagerLifecycle` is whoever hands them out —
+  `create`, `list`, `get`, `update`. They were one protocol that quietly
+  disagreed with `LIFECYCLE_OPERATIONS`, because `Sandbox.create` is a
+  classmethod and a client's `create` is not; `INSTANCE_OPERATIONS` and
+  `MANAGER_OPERATIONS` now say which verb belongs to which shape, and a test
+  holds them to covering every verb exactly once.
+
+  It also gained the URL builders — `runtimes_url`, `runtime_url`,
+  `runtime_pause_url`, `runtime_resume_url`, `sandbox_snapshots_url`,
+  `sandbox_snapshot_url`, `runtime_checkpoints_url` — so every Python caller of
+  the Runtimes API builds a path from one place instead of its own f-string.
+  `snapshot` is recorded against `POST /sandbox-snapshots`, which is the route
+  that exists; it had been documented as a sub-path of the runtime, which was
+  not.
+
+- Numbered the prompt's examples, and made one runnable by its number:
+  `:examples` lists them `1.`, `2.`, … and `:examples:2` prints the second and
+  then executes it, for a reader who wants the answer rather than the paste.
+  They are now declared where the sandbox is made —
+  `Sandbox.create(..., examples=[...])`, carried on `SandboxConfig` — so
+  `run_repl(sandbox)` finds them without being told twice; passing them to
+  `run_repl` still overrides for one prompt. Snippets are printed with Rich's
+  markup off, since `[...]` was being read as a style tag and a snippet
+  holding `list[str]` printed as `list = []`, wrong exactly where someone was
+  about to copy it.
+
+- Added `:examples` to the sandbox prompt. `run_repl(sandbox, examples=[...])`
+  takes title-and-code pairs and prints them on request, for a reader to copy
+  into the prompt; every REPL example under `examples/repl` ships its own, and
+  the ones that can take a GPU offer device discovery and a timed matmul
+  instead of their general set when `--gpu` was asked for. The snippets avoid
+  blocks on purpose: the prompt reads one line at a time, so a pasted `for` or
+  `def` would arrive without its body.
+
+- Fixed a `daytona` GPU sandbox failing to be created at all unless it was
+  also asking for preemptible capacity. Daytona requires every GPU sandbox to
+  be ephemeral — *"GPU sandboxes must be ephemeral; set autoDeleteInterval to
+  0"* — and `auto_delete_interval=0` was being set only on the `spot=True`
+  path, so a plain `gpu="H100"` was refused by the API. It now follows the GPU
+  itself, which is what Daytona ties it to.
+
+- Added three cloud variants: `e2b`, `coreweave` and `cloudflare`.
+
+  `e2b` runs in a Firecracker microVM through E2B's code interpreter SDK, so it
+  holds a Jupyter kernel per context — `x = 1` in one call is still there in
+  the next — and answers with rich display data: a figure comes back as an
+  image, an HTML repr as HTML. It needs `E2B_API_KEY` and
+  `pip install code-sandboxes[e2b]`. `set_timeout()` extends the life of a
+  running sandbox and `get_host(port)` gives the public host of a port inside.
+
+  `coreweave` runs a container on CoreWeave's GPU cloud. What the SDK offers is
+  `exec` — a process at a time — so a namespace is held here instead: one
+  `python -u -c` session is started with the sandbox and fed JSON lines on
+  stdin, the same arrangement the `modal` variant uses, and snippets share a
+  namespace as they do everywhere else. A session that cannot start, or that
+  goes away, drops back to a process per snippet rather than failing. It needs
+  `CWSANDBOX_API_KEY` and `pip install code-sandboxes[coreweave]`.
+
+  `cloudflare` runs a container on Cloudflare's edge. Cloudflare's own SDK is a
+  Workers binding written in TypeScript, which a Python process cannot hold, so
+  this variant drives the SANDBOX BRIDGE — the Worker Cloudflare publishes to
+  expose the SDK over HTTP. Deploy it once with
+  `npm create cloudflare -- sandbox-bridge --template=cloudflare/sandbox-sdk/bridge/worker`,
+  then set `CLOUDFLARE_SANDBOX_API_URL` and `CLOUDFLARE_SANDBOX_API_KEY`. The
+  bridge gives a started process nothing to write to, so each snippet runs in
+  one of its own and state does not carry between calls — put what shares state
+  in one snippet, or keep it in a file, which does persist. Its manager creates,
+  gets and deletes; it cannot list, because the bridge has no endpoint that
+  enumerates sandboxes, and says so rather than answering with an empty list.
+
+- Hardened the three new variants against silently doing something other than
+  what was asked. `cloudflare` now carries `SandboxConfig.env_vars` into every
+  snippet — the bridge takes no environment when it creates a sandbox, so they
+  had been accepted and dropped — refuses a `network_policy` it cannot apply
+  rather than leaving a sandbox believed to be cut off connected, refuses
+  `get_variable` with the reason instead of answering the misleading "no such
+  variable", and serves `files.read`/`files.write` through the bridge's own
+  file endpoints so they need no session at all. `coreweave` refuses the
+  variable APIs when there is no session process — under `stateful=False`, or
+  after one was lost — rather than reporting a successful set that vanishes
+  with the process, and a snippet that runs past its timeout now has its
+  session STOPPED rather than left running and changing the namespace behind a
+  call that already returned.
+
+- A GPU asked of a variant that has none is now REFUSED rather than dropped.
+  `--gpu` reaches `coreweave`, `datalayer`, `daytona`, `kaggle` and `modal`,
+  and `code-sandboxes exec -v e2b --gpu H100` says which variants can give one
+  instead of running on a CPU as though nothing had been asked — a sandbox that
+  looks as though it asked for an H100 and did not is one whose timings mean
+  nothing. `--gpu` was previously accepted and silently ignored for every other
+  variant.
+
+- Corrected the module docstring of the `modal` variant, which still described
+  the process-per-snippet behaviour that the session process replaced: `modal`
+  keeps a namespace between snippets, and falls back to a process per snippet
+  only when the session cannot be held.
+
+- Added GPU support to the `daytona` variant. `gpu=` takes Daytona's own
+  flavors, `gpu_count=` how many, and several names comma-separated are an
+  ordered list of preferences Daytona falls back along — `gpu="H100,H200"`
+  takes an H200 when no H100 is free. `spot=True` runs on preemptible
+  capacity, which is far cheaper and outside the GPU quota; it is GPU-only and
+  built from an image with `auto_delete_interval=0`, both checked before the
+  request rather than left to come back as an API error.
+  `DaytonaSandbox.preempted_at()` answers when a spot sandbox was reclaimed,
+  and `run_code` asks on your behalf so that an eviction is not reported as a
+  dropped connection. `code-sandboxes exec/repl --spot` reaches it from the
+  CLI.
+
+- Renamed the `google_colab` variant to `google-colab`, so every canonical
+  variant name is spelled the one way (`jupyter-server` already was). Any
+  spelling is still accepted everywhere a variant is named — `normalize_variant`
+  now folds to the canonical dashed form rather than to underscores, which is
+  what a dispatcher compares against, so the two can no longer drift apart.
+
+- Added `code-sandboxes exec`, which runs one snippet in a fresh sandbox of any
+  variant and exits with the status the code earned — `0` when it ran cleanly,
+  `1` when it raised — so it composes in a shell. The code comes from an
+  argument, from `--file`, or from standard input; `--quiet` prints only what
+  the code produced. `exec` and `repl` take the same options.
+
+- Moved the machinery for showing a run — `show_code`, `show_result`,
+  `show_and_run`, `run_repl`, `repl_prompt` — into `code_sandboxes.console`,
+  exported from the package. It existed three times over: in the CLI, in the
+  REPL examples and in the exec examples, disagreeing about whether the value
+  of a trailing expression is shown, whether stderr is told apart from stdout,
+  and which words end a session. The examples now import it like any other
+  consumer, and `examples/*/[exec|repl]_common.py` are gone.
+
+- Added the `daytona` sandbox variant (`DaytonaSandbox`), running code in a
+  [Daytona](https://www.daytona.io/docs/) cloud sandbox. It drives the
+  sandbox's code interpreter rather than `process.code_run`, so state persists
+  between calls and `create_context()` gives a namespace Daytona keeps apart.
+  The value of a trailing expression is captured and returned as
+  `ExecutionResult.text`, which the interpreter itself does not report. GPUs,
+  cpu/memory and the network policy map onto Daytona's own settings; binary
+  files go through its filesystem API. Authenticate with `DAYTONA_API_KEY` (or
+  `DAYTONA_JWT_TOKEN` with `DAYTONA_ORGANIZATION_ID`) and install with
+  `pip install code-sandboxes[daytona]`. `get_manager("daytona")` answers the
+  CRUD verbs over an organization's sandboxes.
+
+- Added the `kaggle` sandbox variant (`KaggleSandbox`) to connect to a Kaggle
+  interactive notebook runtime via `jupyter-kernel-client`'s
+  `KaggleKernelClient`. Authenticate with a Kaggle API token (`token` argument or
+  the `KAGGLE_API_TOKEN` environment variable) — omitting `kernel_id` then creates
+  a new kernel. Alternatively, connect to an existing session with a
+  `server_url`/`kernel_id` or a notebook session `channels_url` (the signed JWT in
+  the proxied URL provides the authentication). Install with
+  `pip install code-sandboxes[kaggle]`.
+
+- Enhanced `KaggleSandbox` with a transparent batch primitive: when no runtime
+  connection details are provided, it automatically executes code through
+  `KaggleKernelExecutor` (submit/poll/download) so integrations like
+  `jupyter-mcp-server` can run on Kaggle without requiring interactive runtime
+  wiring.
+
+- Added Kaggle accelerator forwarding in batch mode: `Sandbox.create(variant="kaggle", gpu=...)`
+  now passes the value to `KaggleKernelExecutor.execute(accelerator=...)`,
+  supporting both Kaggle API values (`NvidiaTeslaT4`, ...) and friendly aliases
+  (`T4`, `P100`, ...).
+
+- Updated `ColabSandbox` to be reuse-only for existing Colab runtimes and added
+  `channels_url` parsing support for extracting `server_url` / `kernel_id` /
+  `proxy_token` directly from the Colab WebSocket channels URL.
+
+- Breaking change: sandbox variant names are `eval`, `docker`, `jupyter`, and `datalayer`.
+
+- Removed support for the older `local-*` variant names from the public API and documentation.
+
+- Clarified in the documentation that `Sandbox.create()` defaults to `datalayer`.