code-sandboxes 1.9.32__tar.gz → 1.9.34__tar.gz

{code_sandboxes-1.9.32 → code_sandboxes-1.9.34}/PKG-INFO

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

{code_sandboxes-1.9.32 → code_sandboxes-1.9.34}/code_sandboxes/__version__.py

@@ -3,4 +3,4 @@
 
 """Code Sandboxes."""
 
-__version__ = "1.9.32"
+__version__ = "1.9.34"

{code_sandboxes-1.9.32 → code_sandboxes-1.9.34}/code_sandboxes/environments/adapters/daytona.py

@@ -82,6 +82,7 @@ requires of every GPU sandbox (`DaytonaSandbox` reads the snapshot's `gpu`).
 
 from __future__ import annotations
 
+import contextlib
 import shlex
 import tempfile
 import uuid
@@ -163,6 +164,11 @@ def daytona_gpu(accelerator_type: str) -> str | None:
     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.
 
@@ -245,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).
@@ -339,7 +348,7 @@ class Builder(ManagedBuilder):
         spec = request.environment.spec
         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:
@@ -459,6 +468,10 @@ class Builder(ManagedBuilder):
                         timeout=self.max_build_seconds,
                     )
                 except Exception as error:
+                    # Daytona keeps a snapshot that failed, in `error`, under
+                    # the build's own name: one over its size limit was left
+                    # there (E2-17, 2026-09-18). Nothing records it, so it goes.
+                    self._discard_named(sdk, client, name)
                     raise EnvironmentsError(
                         BUILD_FAILED,
                         f"The Daytona build failed: {error}",
@@ -469,6 +482,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,
@@ -635,8 +659,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:
@@ -646,6 +673,38 @@ 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)
+        self._discard_named(sdk, client, _snapshot_name(request))
+
+    def _discard_named(self, sdk: Any, client: Any, name: str) -> None:
+        """Delete, by its id, the snapshot this build named, when Daytona has one.
+
+        A build's name is its own (the build uid is in it), so looking it up
+        by name cannot find another build's. Never a second reason to fail:
+        what could not be deleted is said in the log.
+        """
+        try:
+            snapshot = client.snapshot.get(name)
+        except Exception:
+            return
+        self._log(f"Deleting the snapshot {snapshot.id} this build made, which nothing records")
+        try:
+            self._delete_by_id(sdk, client, snapshot.id)
+        except EnvironmentsError as error:
+            self._log(f"The snapshot {snapshot.id} could not be deleted: {error.message}")
+
     def smoke_test(
         self,
         artifact: ArtifactReference,

{code_sandboxes-1.9.32 → code_sandboxes-1.9.34}/code_sandboxes/environments/bases.py

@@ -143,10 +143,13 @@ APPROVED_BASES: dict[str, ApprovedBase] = {
             },
             snapshots={"2026.09": "20260916T120000Z"},
         ),
-        # 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.
+        # E2-17: jupyter-python-cuda:0.3.2 (jupyter-python 0.2.2 and CUDA 12.8's
+        # compiler and runtime headers, pinned) plus the same layer, released
+        # 2026-09-18 to environments/base/python-cuda as `2026.09-a3baa7b80931`.
+        # 6.9 GB: the first release carried the whole toolkit (15.7 GB), and a
+        # PyTorch environment on it made a snapshot Daytona refused, over its
+        # 20 GB limit. The doctor passes all fifteen checks and `nvcc` answers
+        # 12.8 without a GPU.
         ApprovedBase(
             ref="datalayer/python-cuda",
             python_versions=("3.13",),
@@ -155,7 +158,7 @@ APPROVED_BASES: dict[str, ApprovedBase] = {
             channels={
                 "2026.09": dict.fromkeys(
                     ("datalayer", "e2b", "daytona", "modal"),
-                    "sha256:a6374a2d4ff07c8a8fe0a71ee605964f93319894cc4152c4e2a1af6258ac9e6a",
+                    "sha256:dc8f0015b4f7dbca92a88d2d6a4a96714b76f9a1af9dddd86835812493e40f08",
                 )
             },
             # After its CUDA layer's own `apt-get update`, which ran that day.

{code_sandboxes-1.9.32 → code_sandboxes-1.9.34}/tests/test_environment_bases.py

@@ -32,7 +32,7 @@ def test_the_2026_09_channel_of_python_cuda_resolves_the_digest_its_release_push
     carrying the CUDA 12.8 toolkit a spec's `accelerator.cuda` may ask for."""
     base = APPROVED_BASES["datalayer/python-cuda"]
     assert resolve_base(base.ref, "2026.09", variant) == (
-        "sha256:a6374a2d4ff07c8a8fe0a71ee605964f93319894cc4152c4e2a1af6258ac9e6a"
+        "sha256:dc8f0015b4f7dbca92a88d2d6a4a96714b76f9a1af9dddd86835812493e40f08"
     )
     assert (base.accelerator, base.cuda) == (True, "12.8")
 

{code_sandboxes-1.9.32 → code_sandboxes-1.9.34}/tests/test_environment_daytona_builder.py

@@ -912,6 +912,69 @@ class TestReadingTheRegistry:
         assert len(daytona.daytona_calls) == 1
 
 
+class TestCancellingABuild:
+    """E2-18: the build step lets a cancelled build's thread finish unheard, so
+    a snapshot Daytona goes on building would be recorded by nobody. Found by
+    E2-14's drill on 2026-09-18: `dl-backfill-drill-v2-…` kept building after
+    its build was cancelled."""
+
+    NAME = "dl-geospatial-analysis-v3-bld-1"
+
+    def test_a_snapshot_being_made_is_deleted_by_id(self) -> None:
+        service = FakeSnapshotService(
+            get_results={
+                self.NAME: FakeSnapshot(id="snp-9", name=self.NAME),
+                "snp-9": FakeSnapshot(id="snp-9", name=self.NAME),
+            }
+        )
+        builder = a_builder(
+            daytona=FakeDaytonaModule(client=FakeDaytonaClient(snapshot_service=service))
+        )
+        builder.cancel(a_request())
+        assert [call.args for call in service.get_calls] == [(self.NAME,)]
+        assert [call.args for call in service.delete_calls] == [("snp-9",)]
+
+    def test_one_made_after_the_cancel_is_deleted_by_the_build(self) -> None:
+        """Not made yet when the cancel came: the build deletes it the moment
+        Daytona hands it back, and does not answer with it."""
+        made = FakeSnapshot(id="snp-late", name=self.NAME)
+        service = FakeSnapshotService(create_result=made, get_results={"snp-late": made})
+        builder = a_builder(
+            daytona=FakeDaytonaModule(client=FakeDaytonaClient(snapshot_service=service))
+        )
+        builder.cancel(a_request())
+        assert service.delete_calls == []
+        with pytest.raises(EnvironmentsError) as raised:
+            builder.build(a_request())
+        assert raised.value.code.code == BUILD_FAILED.code
+        assert "cancelled" in raised.value.message
+        assert [call.args for call in service.delete_calls] == [("snp-late",)]
+
+    def test_a_snapshot_daytona_refused_is_deleted_by_the_build(self) -> None:
+        """Daytona keeps a failed snapshot, in `error`, under the build's name:
+        one over its 20 GB limit was left there (E2-17, 2026-09-18)."""
+        failed = FakeSnapshot(id="snp-err", name=self.NAME, state="error")
+        service = FakeSnapshotService(
+            create_error=RuntimeError(
+                "Snapshot size (28.66GB) exceeds maximum allowed size of 20GB"
+            ),
+            get_results={self.NAME: failed, "snp-err": failed},
+        )
+        builder = a_builder(
+            daytona=FakeDaytonaModule(client=FakeDaytonaClient(snapshot_service=service))
+        )
+        with pytest.raises(EnvironmentsError) as raised:
+            builder.build(a_request())
+        assert raised.value.code.code == BUILD_FAILED.code
+        assert "20GB" in raised.value.message
+        assert [call.args for call in service.delete_calls] == [("snp-err",)]
+
+    def test_another_build_of_the_same_builder_is_not_touched(self) -> None:
+        builder = a_builder()
+        builder.cancel(a_request(build_uid="bld-other"))
+        assert builder.build(a_request()).provider_artifact_id
+
+
 class TestDeletingASnapshot:
     """E2-18: retention and a failed build both need a snapshot to go."""