code-sandboxes 1.9.31__tar.gz → 1.9.33__tar.gz

{code_sandboxes-1.9.31 → code_sandboxes-1.9.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code_sandboxes
-Version: 1.9.31
+Version: 1.9.33
 Project-URL: Home, https://github.com/datalayer/code-sandboxes
 Author-email: Datalayer <info@datalayer.io>
 License: BSD 3-Clause License

{code_sandboxes-1.9.31 → code_sandboxes-1.9.33}/code_sandboxes/__version__.py

@@ -3,4 +3,4 @@
 
 """Code Sandboxes."""
 
-__version__ = "1.9.31"
+__version__ = "1.9.33"

{code_sandboxes-1.9.31 → code_sandboxes-1.9.33}/code_sandboxes/daytona_sandbox.py

@@ -510,6 +510,24 @@ class DaytonaSandbox(Sandbox):
         given = {key: value for key, value in settings.items() if value}
         return daytona.DaytonaConfig(**given) if given else None
 
+    def _snapshot_carries_a_gpu(self) -> bool:
+        """Whether the snapshot this sandbox starts from was built with a GPU (E2-17).
+
+        A GPU is baked into a snapshot with its other resources, so a sandbox
+        of one asks for a GPU without saying so, and Daytona refuses it unless
+        it is ephemeral, the same as one asked for with `gpu=`. The snapshot
+        record says: a GPU environment's artifact, launched by its id, reads
+        `gpu` there. One that cannot be read is taken to have none, and
+        Daytona's own refusal then says why.
+        """
+        if self._snapshot is None or self._daytona is None:
+            return False
+        try:
+            snapshot = self._daytona.snapshot.get(self._snapshot)
+        except Exception:
+            return False
+        return bool(getattr(snapshot, "gpu", 0))
+
     def _create_params(self, daytona: Any) -> Any:  # noqa: C901
         """What to ask Daytona for, from the configuration of this sandbox.
 
@@ -534,7 +552,7 @@ class DaytonaSandbox(Sandbox):
             ]
 
         resources = self._resources(daytona)
-        if _asks_for_a_gpu(resources):
+        if _asks_for_a_gpu(resources) or self._snapshot_carries_a_gpu():
             # Daytona will not create a GPU sandbox that outlives its stop:
             # "GPU sandboxes must be ephemeral; set autoDeleteInterval to 0".
             # It is a property of asking for a GPU at all, not of asking for

{code_sandboxes-1.9.31 → code_sandboxes-1.9.33}/code_sandboxes/environments/adapters/daytona.py

@@ -69,24 +69,20 @@ would make an artifact refuse to build for a reason that says nothing about
 what it does once actually launched. A real answer needs a launched
 sandbox, which is a smoke test's job (E1-14), not this builder's.
 
-**GPU classes are not built here.** `gpu = True` on this builder is a true
-capability (Daytona's own hardware runs one, D-20), and `validate` leaves a
-GPU size class buildable rather than refusing it — the constraint table of
-section 6 has nothing against it, and an existing test
-(`test_a_gpu_spec_is_buildable_on_modal_and_daytona`) already pins that
-answer. What actually stops a GPU build today is upstream: the CUDA base
-channel is E2-17's to publish, and `bases.py` has no digest to resolve
-`python-cuda` to yet, so a `BuildRequest` for one cannot be constructed in
-practice. `build()` itself still guards it explicitly, refusing plainly
-rather than baking an unsourced guess at a GPU type and count into a
-snapshot, in case that ever changes before the real numbers do (section 11.3
-item 7).
+**A GPU is baked into the snapshot** (E2-17, D-20), from the spec's own
+`resources.accelerator`: its `type` is one of Daytona's GPUs, checked at
+`validate` so a GPU Daytona does not offer is refused before any build, and
+its `count` is the number of them. CPU and memory come from the spec's hints,
+or Daytona's own default for that GPU; the disk from the hints, or enough for
+the CUDA base. A sandbox of a GPU snapshot is ephemeral, which Daytona
+requires of every GPU sandbox (`DaytonaSandbox` reads the snapshot's `gpu`).
 
 @module code_sandboxes.environments.adapters.daytona
 """
 
 from __future__ import annotations
 
+import contextlib
 import shlex
 import tempfile
 import uuid
@@ -118,10 +114,10 @@ from ..resolve_conda import (
     micromamba_bootstrap_command,
     micromamba_install_command,
 )
-from ..spec import GPU_SIZE_CLASSES, Environment
+from ..spec import GPU_SIZE_CLASSES, Environment, EnvironmentSpec
 from .managed import ManagedBuilder
 
-__all__ = ["Builder"]
+__all__ = ["DAYTONA_GPUS", "Builder", "daytona_gpu"]
 
 #: Tags Daytona refuses for a snapshot's source image: each moves.
 MOVING_TAGS = ("latest", "lts", "stable")
@@ -148,6 +144,31 @@ _CPU_RESOURCES: dict[str, dict[str, int]] = {
 }
 
 
+#: The GPUs Daytona offers, as its SDK's `GpuType` names them (E2-17). Spelled
+#: out rather than read from the SDK, because `validate` runs where the SDK may
+#: not be installed; a test holds the two together.
+DAYTONA_GPUS: tuple[str, ...] = ("H100", "H200", "RTX-PRO-6000", "RTX-4090", "RTX-5090")
+
+#: A GPU snapshot's disk when the spec gives no hint: the CUDA base alone is
+#: about 15 GB, and Daytona's own default would not hold it with room to work.
+_GPU_DISK_GI = 50
+
+
+def daytona_gpu(accelerator_type: str) -> str | None:
+    """Daytona's name for an accelerator type, or `None` when Daytona has no such GPU.
+
+    `h100`, `H100` and `rtx_4090` name what Daytona calls `H100` and
+    `RTX-4090`; a `T4` or an `A100-80GB` is Modal's vocabulary, not Daytona's.
+    """
+    name = accelerator_type.strip().upper().replace("_", "-")
+    return name if name in DAYTONA_GPUS else None
+
+
+def _snapshot_name(request: BuildRequest) -> str:
+    """The name a build gives its snapshot, unique to the build (its uid is in it)."""
+    return f"dl-{request.environment.metadata.name}-v{request.version}-{request.build_uid}"
+
+
 def _pip_lock_command(*, authored: bool) -> str:
     """Install the pip lock: `sync` to it, or `install` it over an authored Dockerfile.
 
@@ -204,8 +225,8 @@ class Builder(ManagedBuilder):
     #: 2026-09-17.
     forbidden_instructions = ()
     dependency_formats = ("requirements", "pyproject", "conda")
-    #: Daytona runs GPUs, on its own hardware and the owner's account (E2-17).
-    #: This builder does not build one yet: see `_own_findings`.
+    #: Daytona runs GPUs, on its own hardware and the owner's account (E2-17),
+    #: baked into the snapshot with the rest of its resources.
     gpu = True
     #: E0-04's spike found only a registry login for the private base, never
     #: a per-step arbitrary named secret (E3-05): `buildSecrets` is refused.
@@ -230,6 +251,9 @@ class Builder(ManagedBuilder):
         self._daytona_sdk = daytona_sdk or _daytona_sdk
         self._registry_sdk = registry_sdk or _daytona_registry_sdk
         self._client_instance: Any = None
+        #: The builds `cancel` was asked to stop: one whose snapshot is only
+        #: finished after the cancel deletes it itself (E2-18).
+        self._cancelled: set[str] = set()
 
     def _provider_secrets(self) -> dict[str, str]:
         """The owner's Daytona secrets the build credential carries (D-8, E2-01).
@@ -300,15 +324,7 @@ class Builder(ManagedBuilder):
                     field="spec.compatibility.regions",
                 )
             )
-        # A GPU class is left buildable here on purpose (`gpu = True`,
-        # D-20): the CUDA base E2-17 has not published yet, so a GPU
-        # `BuildRequest` cannot reach `build()` in practice — `bases.py`'s
-        # own resolver has no digest to resolve `python-cuda` to, and
-        # refuses first. `build()` itself still guards it explicitly (see
-        # its own docstring), so a spec that somehow got a `resolved_base`
-        # anyway is refused plainly rather than baking an unsourced guess
-        # at a GPU type and count into a snapshot.
-        #
+        findings.extend(self._accelerator_findings(environment.spec))
         # `spec.buildSecrets` needs no check of its own here: `supports_build_secrets
         # = False` above (E3-05, merged since this branch started) makes
         # `ManagedBuilder._own_findings` refuse it before this method is
@@ -330,21 +346,9 @@ class Builder(ManagedBuilder):
         (E0-04).
         """
         spec = request.environment.spec
-        if request.size_class in GPU_SIZE_CLASSES:
-            # `validate` leaves a GPU class buildable (`gpu = True`, D-20):
-            # `bases.py` has no CUDA digest to resolve yet, so this cannot
-            # be reached in practice — refused plainly here rather than
-            # baking an unsourced guess at a GPU type and count into a
-            # snapshot (E2-17 is what will give this real numbers).
-            raise EnvironmentsError(
-                CAPABILITY_UNSUPPORTED,
-                f"Daytona runs `{request.size_class}` on its own GPUs, but the CUDA base "
-                "and the GPU resource shape this needs are E2-17's, not built yet",
-                detail={"variant": self.variant, "missing": "E2-17"},
-            )
         sdk = self._daytona_sdk()
         client = self._client(sdk)
-        name = f"dl-{request.environment.metadata.name}-v{request.version}-{request.build_uid}"
+        name = _snapshot_name(request)
 
         registry_id = self._register_base_pull(client, request.resolved_base)
         try:
@@ -437,7 +441,7 @@ class Builder(ManagedBuilder):
                     logged.append(line)
                     self._log(line)
 
-                resources = self._resources(sdk, request.size_class)
+                resources = self._resources(sdk, request.size_class, spec)
                 # A snapshot is region-scoped, and the region that scopes it is
                 # Daytona's, not this platform's. `validate` already refuses
                 # more than one, so the first is the only one.
@@ -474,6 +478,17 @@ class Builder(ManagedBuilder):
             # not control, whether the build above succeeded or not (D-18).
             self._unregister_base_pull(client, registry_id)
 
+        if request.build_uid in self._cancelled:
+            # Finished after the build was cancelled: nothing will record it,
+            # so it goes now rather than wait in the account for nobody.
+            self._log(f"The build was cancelled: deleting the snapshot {snapshot.id} it made")
+            with contextlib.suppress(EnvironmentsError):
+                self._delete_by_id(sdk, client, snapshot.id)
+            raise EnvironmentsError(
+                BUILD_FAILED,
+                "The build was cancelled, and the snapshot it made was deleted",
+                detail={"variant": self.variant, "name": name},
+            )
         return ArtifactReference(
             variant=self.variant,
             immutable_reference=snapshot.id,
@@ -505,10 +520,40 @@ class Builder(ManagedBuilder):
         )
         return sdk.Image.from_dockerfile(str(dockerfile))
 
-    def _resources(self, sdk: Any, size_class: str) -> Any:
-        """The CPU resources a size class bakes into the snapshot (§11.3 item 4)."""
-        shape = _CPU_RESOURCES.get(size_class, _CPU_RESOURCES["small"])
-        return sdk.Resources(cpu=shape["cpu"], memory=shape["memory"], disk=shape["disk"])
+    @staticmethod
+    def _accelerator_findings(spec: EnvironmentSpec) -> list[CapabilityFinding]:
+        """A GPU Daytona does not offer, refused before any build (E2-17)."""
+        accelerator = spec.resources.accelerator
+        if accelerator == "none" or daytona_gpu(accelerator.type):
+            return []
+        return [
+            CapabilityFinding(
+                code="DL_ENV_CAPABILITY_UNSUPPORTED",
+                message=(
+                    f"Daytona has no GPU called `{accelerator.type}`; it offers "
+                    + ", ".join(DAYTONA_GPUS)
+                ),
+                field="spec.resources.accelerator.type",
+            )
+        ]
+
+    def _resources(self, sdk: Any, size_class: str, spec: EnvironmentSpec) -> Any:
+        """What the snapshot bakes in: a class's CPU, or the spec's GPU (§11.3 item 4, E2-17)."""
+        accelerator = spec.resources.accelerator
+        if size_class not in GPU_SIZE_CLASSES or accelerator == "none":
+            shape = _CPU_RESOURCES.get(size_class, _CPU_RESOURCES["small"])
+            return sdk.Resources(cpu=shape["cpu"], memory=shape["memory"], disk=shape["disk"])
+        # D-4 gives the GPU classes no CPU or memory of their own (E4-11 has
+        # them, for Datalayer's nodes): the GPU is what the class is for, and
+        # Daytona sizes the rest of the machine for it unless the spec hints.
+        hints = spec.resources.hints
+        return sdk.Resources(
+            cpu=round(hints.cpu) if hints.cpu else None,
+            memory=round(hints.memory_gi) if hints.memory_gi else None,
+            disk=round(hints.disk_gi) if hints.disk_gi else _GPU_DISK_GI,
+            gpu=accelerator.count,
+            gpu_type=sdk.GpuType(daytona_gpu(accelerator.type)),
+        )
 
     def _register_base_pull(self, client: Any, resolved_base: str) -> str | None:
         """A private registry entry for this build's base pull (D-17, D-18).
@@ -610,8 +655,11 @@ class Builder(ManagedBuilder):
         a later build's snapshot that inherited it.
         """
         sdk = self._daytona_sdk()
-        client = self._client(sdk)
-        snapshot = artifact.provider_artifact_id or artifact.immutable_reference
+        self._delete_by_id(
+            sdk, self._client(sdk), artifact.provider_artifact_id or artifact.immutable_reference
+        )
+
+    def _delete_by_id(self, sdk: Any, client: Any, snapshot: str) -> None:
         try:
             client.snapshot.delete(snapshot)
         except sdk.DaytonaNotFoundError:
@@ -621,6 +669,26 @@ class Builder(ManagedBuilder):
             raise self._provider_error("delete the snapshot", error) from error
         self._log(f"Deleted the Daytona snapshot {snapshot}")
 
+    def cancel(self, request: BuildRequest) -> None:
+        """Stop a build: delete the snapshot it is making, now or once it is made (E2-18).
+
+        The build step calls this when the build is cancelled, and then lets
+        the build's own thread finish unheard, so a snapshot Daytona goes on
+        building is recorded by nobody. It is found by the name this build
+        gave it, which is unique to the build (the build uid is in it), and
+        deleted by its id. One not made yet is deleted by `build` itself, the
+        moment Daytona hands it back.
+        """
+        self._cancelled.add(request.build_uid)
+        sdk = self._daytona_sdk()
+        client = self._client(sdk)
+        try:
+            snapshot = client.snapshot.get(_snapshot_name(request))
+        except Exception:
+            return
+        self._log(f"The build was cancelled: deleting the snapshot {snapshot.id} it was making")
+        self._delete_by_id(sdk, client, snapshot.id)
+
     def smoke_test(
         self,
         artifact: ArtifactReference,
@@ -657,20 +725,29 @@ class Builder(ManagedBuilder):
                 "lock pinned, and an artifact carries neither",
                 detail={"variant": self.variant},
             )
-        from ..conformance import expected_packages, run_core_tier
+        from ..conformance import expected_packages, run_accelerator_check, run_core_tier
 
         snapshot = artifact.provider_artifact_id or artifact.immutable_reference
         sandbox = self._smoke_test_sandbox(snapshot)
         self._log(f"Launching {snapshot} to smoke-test it")
         try:
             sandbox.start()
-            return run_core_tier(
+            result = run_core_tier(
                 sandbox,
                 python_version=environment.spec.language.version,
                 expected_packages=expected_packages(environment, lock_text or ""),
                 secret_values=tuple(secret_values),
                 restart=lambda: self._restart(sandbox),
             )
+            accelerator = environment.spec.resources.accelerator
+            if accelerator != "none":
+                # A GPU version is only the version its spec describes when
+                # its GPUs are visible and its CUDA is the spec's (check 11,
+                # E2-17): the core tier alone passes on a machine with none.
+                result.checks.append(
+                    run_accelerator_check(sandbox, cuda=accelerator.cuda, count=accelerator.count)
+                )
+            return result
         except EnvironmentsError:
             raise
         except Exception as error:

{code_sandboxes-1.9.31 → code_sandboxes-1.9.33}/code_sandboxes/environments/bases.py

@@ -59,6 +59,9 @@ class ApprovedBase(BaseModel):
     python_versions: tuple[str, ...]
     #: Whether the base carries CUDA, which a GPU size class requires.
     accelerator: bool = False
+    #: The CUDA toolkit the base pins, ``major.minor`` (E2-17): what a spec's
+    #: ``accelerator.cuda`` may ask for, and what check 11 reads back.
+    cuda: str | None = None
     #: Channel, then variant, to the digest resolution pins. A channel with no
     #: variant is approved and not yet published.
     channels: dict[str, dict[str, str]] = Field(default_factory=dict)
@@ -140,12 +143,23 @@ APPROVED_BASES: dict[str, ApprovedBase] = {
             },
             snapshots={"2026.09": "20260916T120000Z"},
         ),
-        # E2-17: jupyter-python-cuda plus the same layer.
+        # E2-17: jupyter-python-cuda:0.3.1 (jupyter-python 0.2.2 and the CUDA
+        # 12.8 toolkit, pinned) plus the same layer, released 2026-09-18 to
+        # environments/base/python-cuda as `2026.09-bceb272088e4`. The doctor
+        # passes all fifteen checks and `nvcc` answers 12.8 without a GPU.
         ApprovedBase(
             ref="datalayer/python-cuda",
             python_versions=("3.13",),
             accelerator=True,
-            channels={"2026.09": {}},
+            cuda="12.8",
+            channels={
+                "2026.09": dict.fromkeys(
+                    ("datalayer", "e2b", "daytona", "modal"),
+                    "sha256:a6374a2d4ff07c8a8fe0a71ee605964f93319894cc4152c4e2a1af6258ac9e6a",
+                )
+            },
+            # After its CUDA layer's own `apt-get update`, which ran that day.
+            snapshots={"2026.09": "20260918T150000Z"},
         ),
     )
 }

{code_sandboxes-1.9.31 → code_sandboxes-1.9.33}/code_sandboxes/environments/conformance.py

@@ -37,6 +37,7 @@ __all__ = [
     "cross_variant_packages",
     "drifted_from",
     "package_versions_of",
+    "run_accelerator_check",
     "run_conformance",
     "run_core_tier",
     "run_extended_tier",
@@ -596,30 +597,62 @@ def _egress(
     )
 
 
-def _gpu(sandbox: Sandbox, requested: bool, cuda: str | None, timeout: float | None) -> CheckResult:
+def _gpu(
+    sandbox: Sandbox,
+    requested: bool,
+    cuda: str | None,
+    timeout: float | None,
+    count: int = 1,
+) -> CheckResult:
+    """Check 11: the GPUs asked for are visible, and CUDA is the spec's.
+
+    Two CUDA versions are read, and they answer different questions. The
+    image's own toolkit (`nvcc`, or the base's `CUDA_VERSION`) is what the
+    spec's `accelerator.cuda` names and the base channel pins. `nvidia-smi`'s
+    "CUDA Version" is the newest CUDA the host's *driver* runs, which the
+    image does not choose: comparing the spec with it failed a correct image
+    on any newer driver (found on 2026-09-18, E2-17). The driver only has to
+    be new enough for the toolkit.
+    """
     if not requested:
         return _result(11, True, gating=False, detail="no accelerator was requested")
     body = (
-        "import re as _dl_re, subprocess as _dl_sp\n"
-        "_dl_out = {'returncode': None, 'gpus': [], 'cuda': None}\n"
+        "import os as _dl_os, re as _dl_re, shutil as _dl_sh, subprocess as _dl_sp\n"
+        "_dl_out = {'returncode': None, 'gpus': [], 'driver': None, 'cuda': None}\n"
         "try:\n"
         "    _dl_run = _dl_sp.run(['nvidia-smi'], capture_output=True, text=True, timeout=30)\n"
         "    _dl_out['returncode'] = _dl_run.returncode\n"
         "    _dl_match = _dl_re.search(r'CUDA Version:\\s*([0-9.]+)', _dl_run.stdout)\n"
-        "    _dl_out['cuda'] = _dl_match.group(1) if _dl_match else None\n"
+        "    _dl_out['driver'] = _dl_match.group(1) if _dl_match else None\n"
         "    _dl_names = _dl_sp.run(['nvidia-smi', '--query-gpu=name', '--format=csv,noheader'], "
         "capture_output=True, text=True, timeout=30)\n"
         "    _dl_out['gpus'] = [_dl_l.strip() for _dl_l in _dl_names.stdout.splitlines() "
         "if _dl_l.strip()]\n"
         "except (OSError, _dl_sp.SubprocessError) as _dl_error:\n"
         "    _dl_out['error'] = str(_dl_error)\n"
+        "try:\n"
+        "    _dl_nvcc = _dl_sh.which('nvcc') or '/usr/local/cuda/bin/nvcc'\n"
+        "    _dl_run = _dl_sp.run([_dl_nvcc, '--version'], capture_output=True, text=True, "
+        "timeout=30)\n"
+        "    _dl_match = _dl_re.search(r'release ([0-9.]+),', _dl_run.stdout)\n"
+        "    _dl_out['cuda'] = _dl_match.group(1) if _dl_match else None\n"
+        "except (OSError, _dl_sp.SubprocessError):\n"
+        "    pass\n"
+        "_dl_out['cuda'] = _dl_out['cuda'] or _dl_os.environ.get('CUDA_VERSION') or None\n"
     )
     answer = probe(sandbox, _code(11, body, "_dl_out"), timeout=timeout)
     problems = []
-    if answer.get("returncode") != 0 or not answer.get("gpus"):
+    gpus = answer.get("gpus") or []
+    if answer.get("returncode") != 0 or not gpus:
         problems.append("no GPU is visible")
-    if cuda and not str(answer.get("cuda") or "").startswith(cuda):
-        problems.append(f"CUDA is {answer.get('cuda')}, not {cuda}")
+    elif len(gpus) < count:
+        problems.append(f"{len(gpus)} GPU(s) visible, not the {count} asked for")
+    toolkit = str(answer.get("cuda") or "")
+    if cuda and not _version_is(toolkit, cuda):
+        problems.append(f"CUDA is {toolkit or None}, not {cuda}")
+    driver = str(answer.get("driver") or "")
+    if toolkit and driver and _version_tuple(driver) < _version_tuple(toolkit):
+        problems.append(f"the driver runs CUDA up to {driver}, older than the image's {toolkit}")
     # A GPU version gates on this (E2-17): a version that asked for an
     # accelerator and cannot see it, or sees the wrong CUDA, is not the
     # version its spec describes. A version that asked for none never
@@ -628,6 +661,31 @@ def _gpu(sandbox: Sandbox, requested: bool, cuda: str | None, timeout: float | N
     return _result(11, not problems, gating=True, detail="; ".join(problems) or None, actual=answer)
 
 
+def _version_tuple(version: str) -> tuple[int, ...]:
+    return tuple(int(part) for part in re.findall(r"\d+", version))
+
+
+def _version_is(version: str, asked: str) -> bool:
+    """Whether `version` is what `asked` names: `12` and `12.8` both name 12.8.3."""
+    wanted = _version_tuple(asked)
+    return bool(wanted) and _version_tuple(version)[: len(wanted)] == wanted
+
+
+def run_accelerator_check(
+    sandbox: Sandbox,
+    *,
+    cuda: str | None = None,
+    count: int = 1,
+    timeout: float | None = 120.0,
+) -> CheckResult:
+    """Appendix B check 11 alone, gating, for a version that asked for an accelerator (E2-17).
+
+    What a builder's smoke test adds to the core tier for a GPU version: the
+    rest of the extended tier records, and this one decides.
+    """
+    return _guard(11, True, lambda: _gpu(sandbox, True, cuda, timeout, count))
+
+
 def _throughput(
     sandbox: Sandbox, contract: SandboxContract, minimum: float, timeout: float | None
 ) -> CheckResult:
@@ -694,6 +752,7 @@ def run_extended_tier(
     contract: SandboxContract = SANDBOX_CONTRACT_V1,
     accelerator_requested: bool = False,
     cuda_version: str | None = None,
+    accelerator_count: int = 1,
     egress_allowed: Sequence[str] = (),
     egress_blocked: Sequence[str] = (),
     cold_start_seconds: float | None = None,
@@ -711,7 +770,7 @@ def run_extended_tier(
         _guard(
             11,
             accelerator_requested,
-            lambda: _gpu(sandbox, accelerator_requested, cuda_version, timeout),
+            lambda: _gpu(sandbox, accelerator_requested, cuda_version, timeout, accelerator_count),
         ),
         _guard(12, False, lambda: _throughput(sandbox, contract, minimum_mib_per_second, timeout)),
         _guard(13, False, lambda: _cold_start(cold_start_seconds, cold_start_budget)),

{code_sandboxes-1.9.31 → code_sandboxes-1.9.33}/code_sandboxes/environments/spec.py

@@ -497,6 +497,12 @@ def _index_findings(field: str, url: str) -> list[SpecFinding]:
     return []
 
 
+def _same_cuda(asked: str, carried: str) -> bool:
+    """Whether a spec's CUDA names the base's: `12` and `12.8` both name 12.8."""
+    asked_parts = asked.strip().split(".")
+    return carried.strip().split(".")[: len(asked_parts)] == asked_parts
+
+
 def parse_requirements_txt(text: str) -> list[str]:
     """The requirement lines of a `requirements.txt`, comments and blanks dropped.
 
@@ -960,6 +966,18 @@ def spec_findings(
                 "spec.base.ref", f"`{base.ref}` has no CUDA; a GPU size class needs a CUDA base"
             )
         )
+    # The CUDA a spec asks for is the base's toolkit, which a channel pins
+    # (E2-17): a version that asks for another would build and then fail
+    # check 11 in every sandbox it starts.
+    cuda = resources.accelerator.cuda if wants_gpu else None
+    if cuda and base is not None and base.cuda and not _same_cuda(cuda, base.cuda):
+        findings.append(
+            SpecFinding(
+                "spec.resources.accelerator.cuda",
+                f"`{base.ref}` carries CUDA {base.cuda}, not {cuda}; ask for {base.cuda} "
+                "or leave `cuda` out",
+            )
+        )
 
     variants = spec.compatibility.variants
     if not variants.required:

{code_sandboxes-1.9.31 → code_sandboxes-1.9.33}/docs/docs/environments/specification.mdx

@@ -37,12 +37,12 @@ A document is refused with `DL_ENV_SPEC_INVALID` when a field is wrong, and with
 | `commands.postInstall` | none | At most 32 non-empty commands, run after the packages are installed. |
 | `buildSecrets` | none | `id` is a Datalayer secret id, `dlsec_...`; `mountAs` is `env` or `file`; `name` is the variable or file name. Ids and names are unique. Secrets are injected into the build step that needs them and never written into the artifact. |
 | `resources.sizeClass` | `small` | `small`, `medium`, `large`, `gpu-small` or `gpu-large`. A GPU class needs an accelerator and a CUDA base; an accelerator needs a GPU class. Datalayer runs no GPU nodes yet, so a GPU class is built for Modal and Daytona, which bring their own GPUs; E2B has none. |
-| `resources.accelerator` | `none` | `none`, or `type`, `count` and `cuda`. |
+| `resources.accelerator` | `none` | `none`, or `type`, `count` and `cuda`. `type` is the provider's own name for the GPU (Daytona: `H100`, `H200`, `RTX-PRO-6000`, `RTX-4090`, `RTX-5090`), and a GPU a variant does not offer is refused for it at `validate`. `cuda` is the base's toolkit: `datalayer/python-cuda:2026.09` carries 12.8, and another version is refused. |
 | `resources.hints` | none | `cpu`, `memoryGi`, `diskGi`: positive numbers, within the size class. |
 | `compatibility.variants.required` | `[datalayer]` | At least one of `datalayer`, `e2b`, `daytona`, `modal`. |
 | `compatibility.variants.optional` | none | The same variants, none of them also required. |
 | `compatibility.regions` | none | Region names. |
-| `build.source` | `packages` | `packages`; `dependencyFile` (a `requirements.txt`; a `pyproject.toml` whose own `uv.lock` is checked against Datalayer's protected pins and exported rather than re-resolved; or a conda `environment.yml`, resolved in its own `micromamba` solve into an explicit lock with the protected pins merged over its `pip:` layer); `dockerfile` (`build.dockerfile.content`, inline: its `FROM` names an approved base with its channel as the tag, which is what resolves, and what its own instructions install is not locked, as the lock's header says); and `image` (an existing image from a bootstrap registry allowlist, replacing the approved base). `packages`, a `requirements.txt`, a conda `environment.yml` and `dockerfile` build on the Datalayer and Daytona variants. A `pyproject.toml` does not build yet: its `uv.lock` has to lock Datalayer's `jupyter-server` fork, which no package index serves. `image` resolves but does not yet start as a sandbox, because the imported image has no Datalayer runtime layer; `image` from a private registry, and a `COPY` from a Dockerfile's build context, are refused. |
+| `build.source` | `packages` | `packages`; `dependencyFile` (a `requirements.txt`; a `pyproject.toml` whose own `uv.lock` is checked against Datalayer's protected pins and exported rather than re-resolved; or a conda `environment.yml`, resolved in its own `micromamba` solve into an explicit lock with the protected pins merged over its `pip:` layer); `dockerfile` (`build.dockerfile.content`, inline: its `FROM` names an approved base with its channel as the tag, which is what resolves, and what its own instructions install is not locked, as the lock's header says); and `image` (an existing image from a bootstrap registry allowlist, replacing the approved base). `packages`, a `requirements.txt`, a `pyproject.toml` with its `uv.lock`, a conda `environment.yml` and `dockerfile` build on the Datalayer and Daytona variants. A `pyproject.toml`'s `uv.lock` has to lock Datalayer's `jupyter-server` fork, which no package index serves: the project takes it by URL from [the fork's release](https://github.com/datalayer-externals/jupyter-server/releases/tag/v2.21.0-datalayer.1), in `[tool.uv.sources]`, which is also what makes `uv` record its hash. `image` resolves but does not yet start as a sandbox, because the imported image has no Datalayer runtime layer; `image` from a private registry, and a `COPY` from a Dockerfile's build context, are refused. |
 
 ## The spec digest
 

{code_sandboxes-1.9.31 → code_sandboxes-1.9.33}/docs/docs/providers/daytona.mdx

@@ -270,6 +270,16 @@ for, and the `target` a build's snapshot lands in is the one a launch
 starts from — a version that changes size class or region rebuilds a
 second, distinct artifact rather than resizing the first.
 
+**A GPU is part of the snapshot too.** A GPU class (`gpu-small`,
+`gpu-large`) on the CUDA base bakes the spec's `accelerator` into it: its
+`type`, one of Daytona's GPUs, and its `count`. CPU and memory come from
+`resources.hints`, or Daytona's own size for that GPU, and the disk holds the
+CUDA base. Every sandbox of a GPU snapshot is ephemeral, as Daytona requires:
+`DaytonaSandbox` reads the snapshot's `gpu` and asks for it. The build's
+smoke test adds check 11 to the core tier: the GPUs asked for are visible,
+CUDA is the base's, and the host's driver is new enough for it. GPU compute
+is billed by Daytona to the owner's organization, which needs GPU credits.
+
 Of the four variants, Daytona is the one whose build-time doctor check and
 live launch agree in full: the doctor is *not* run at build time (a
 build-time `RUN` step's PID 1 is Daytona's own build agent, not the

{code_sandboxes-1.9.31 → code_sandboxes-1.9.33}/tests/test_daytona.py

@@ -700,6 +700,44 @@ def test_a_snapshot_and_an_image_together_are_refused():
         sandbox._create_params(daytona)
 
 
+class _SnapshotsNamed:
+    """`daytona.snapshot`, answering the records it was given by id."""
+
+    def __init__(self, **records) -> None:
+        self.records = records
+
+    def get(self, snapshot_id):
+        if snapshot_id not in self.records:
+            raise KeyError(snapshot_id)
+        return self.records[snapshot_id]
+
+
+def test_a_sandbox_of_a_gpu_snapshot_is_ephemeral():
+    """E2-17: a GPU is baked into an Environment's snapshot, so its sandbox asks
+    for a GPU without `gpu=`, and Daytona refuses it unless it is ephemeral."""
+    import types
+
+    daytona = pytest.importorskip("daytona")
+    sandbox = _started(SandboxConfig(), snapshot="dl-gpu-v1")
+    sandbox._daytona = types.SimpleNamespace(
+        snapshot=_SnapshotsNamed(**{"dl-gpu-v1": types.SimpleNamespace(gpu=2)})
+    )
+    params = sandbox._create_params(daytona)
+    assert isinstance(params, daytona.CreateSandboxFromSnapshotParams)
+    assert params.auto_delete_interval == 0
+
+
+def test_a_sandbox_of_a_cpu_snapshot_is_kept_as_asked():
+    import types
+
+    daytona = pytest.importorskip("daytona")
+    for records in ({"dl-geo-v3": types.SimpleNamespace(gpu=0)}, {}):
+        sandbox = _started(SandboxConfig(), snapshot="dl-geo-v3")
+        sandbox._daytona = types.SimpleNamespace(snapshot=_SnapshotsNamed(**records))
+        params = sandbox._create_params(daytona)
+        assert getattr(params, "auto_delete_interval", None) != 0
+
+
 def test_a_snapshot_alone_still_creates_from_the_snapshot():
     daytona = pytest.importorskip("daytona")