code-sandboxes 1.7.0__tar.gz → 1.8.0__tar.gz

{code_sandboxes-1.7.0 → code_sandboxes-1.8.0}/CHANGELOG.md

@@ -8,6 +8,30 @@
 
 ## Unreleased
 
+## 1.8.0
+
+- **The Datalayer builder** (`environments.adapters.datalayer`, PLAN_ENV.md
+  E1-07). The Dockerfile is generated from the lock — `uv pip sync
+  --require-hashes`, apt at the versions the lock recorded, `env` before
+  anything installs, `postInstall` as uid 1000 with no network — and the push
+  is by digest with an SBOM and provenance attestation, under the operability
+  tag `v<n>-<build_uid>` so a retried build cannot collide with the attempt
+  before it. `inspect`, `resolve`, `exists` and `delete` go through the ECR
+  API. Needs the `environments-builder` extra.
+- **The scan and the signature** (`environments.policy`,
+  `environments.attest`, E1-08, E1-09). A critical finding with a fixed
+  version blocks and one nothing fixes is recorded; the decision record keeps
+  the threshold it was decided under, so what stopped a build reads a month
+  later. cosign signs only once the scan passed, and a replay finds the
+  signature rather than pushing a second.
+- **A sandbox launches from an artifact** (E2-02): `Sandbox.create(artifact=…)`
+  hands each variant its own argument — an E2B template build, a Daytona
+  snapshot, a Modal image id through `Image.from_id`.
+- **Fixed, and a live defect:** Daytona's adapter took the image branch
+  whenever resources were requested, so a snapshot asked for with `cpu=` came
+  up from a plain Debian image running none of the snapshot's content, with
+  nothing saying so. The combination is refused (correction 13).
+
 ## 1.7.0
 
 - **A version is resolved into one lock** (`code_sandboxes.environments.resolve`,

{code_sandboxes-1.7.0 → code_sandboxes-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code_sandboxes
-Version: 1.7.0
+Version: 1.8.0
 Project-URL: Home, https://github.com/datalayer/code-sandboxes
 Author-email: Datalayer <info@datalayer.io>
 License: BSD 3-Clause License
@@ -73,6 +73,8 @@ Provides-Extra: docker
 Requires-Dist: docker>=6.0; extra == 'docker'
 Provides-Extra: e2b
 Requires-Dist: e2b-code-interpreter>=2.9.1; extra == 'e2b'
+Provides-Extra: environments-builder
+Requires-Dist: boto3>=1.34; extra == 'environments-builder'
 Provides-Extra: google-colab
 Provides-Extra: kaggle
 Requires-Dist: kaggle>=1.6; extra == 'kaggle'

{code_sandboxes-1.7.0 → code_sandboxes-1.8.0}/code_sandboxes/__version__.py

@@ -3,4 +3,4 @@
 
 """Code Sandboxes."""
 
-__version__ = "1.7.0"
+__version__ = "1.8.0"

{code_sandboxes-1.7.0 → code_sandboxes-1.8.0}/code_sandboxes/base.py

@@ -508,6 +508,7 @@ class Sandbox(ABC):
         allowed_hosts: list[str] | None = None,
         tags: dict[str, str] | None = None,
         examples: list[tuple[str, str]] | None = None,
+        artifact: Any = None,
         **kwargs,
     ) -> Sandbox:
         """Factory method to create a sandbox of the specified variant.
@@ -589,6 +590,17 @@ class Sandbox(ABC):
 
         variant_value = normalize_variant(variant)
 
+        if artifact is not None:
+            # One neutral reference, translated into the argument its variant
+            # takes: a template build for E2B, a snapshot for Daytona, an
+            # image id for Modal (PLAN_ENV.md E2-02). A caller holding an
+            # Environment's artifact should not have to know which. What the
+            # caller passed itself wins, so naming both is not a surprise.
+            from .environments.builders import launch_arguments
+
+            for name_, value in launch_arguments(artifact).items():
+                kwargs.setdefault(name_, value)
+
         if variant_value == "eval":
             sandbox = EvalSandbox(config=config, **kwargs)
         elif variant_value == "docker":

{code_sandboxes-1.7.0 → code_sandboxes-1.8.0}/code_sandboxes/daytona_sandbox.py

@@ -510,8 +510,13 @@ class DaytonaSandbox(Sandbox):
         given = {key: value for key, value in settings.items() if value}
         return daytona.DaytonaConfig(**given) if given else None
 
-    def _create_params(self, daytona: Any) -> Any:
-        """What to ask Daytona for, from the configuration of this sandbox."""
+    def _create_params(self, daytona: Any) -> Any:  # noqa: C901
+        """What to ask Daytona for, from the configuration of this sandbox.
+
+        Read top to bottom: what it refuses — a snapshot with resources, a
+        snapshot with an image — is the rule, and splitting the refusals
+        across helpers would hide them from the one place a reader looks.
+        """
         common: dict[str, Any] = {"labels": self._labels()}
         if self.config.env_vars:
             common["env_vars"] = dict(self.config.env_vars)
@@ -538,6 +543,27 @@ class DaytonaSandbox(Sandbox):
             common["auto_delete_interval"] = 0
         if self._spot:
             common.update(self._spot_params(resources))
+        if self._snapshot is not None:
+            # A snapshot carries the machine it was created for — Daytona bakes
+            # CPU, memory, disk and GPU into it, and it is region-scoped — so
+            # asking for resources beside one asks for two different machines.
+            # This used to take the image branch instead: the sandbox came up
+            # from a Debian image with the resources asked for, running none of
+            # the content the snapshot held, and nothing said so (PLAN_ENV.md
+            # correction 13, E2-02). A resource change is a new snapshot.
+            if resources is not None:
+                raise SandboxConfigurationError(
+                    "A Daytona snapshot carries its own CPU, memory, disk and GPU, so "
+                    "cpu=, memory= and gpu= cannot be passed with snapshot=: the sandbox "
+                    "would have come up from a plain image instead, with none of the "
+                    "snapshot's content. Create a snapshot for the machine you want, or "
+                    "pass image= with the resources."
+                )
+            if self._image is not None:
+                raise SandboxConfigurationError(
+                    "snapshot= and image= are two different things to start from; pass one. "
+                    "A snapshot is what an Environment build records for this variant."
+                )
         if self._image is not None or resources is not None:
             image = self._image
             if image is None:
@@ -547,6 +573,8 @@ class DaytonaSandbox(Sandbox):
                     else daytona.Image.debian_slim()
                 )
             return daytona.CreateSandboxFromImageParams(image=image, resources=resources, **common)
+        # No snapshot named and nothing asked for: Daytona's own default, which
+        # is what `snapshot=None` means to it.
         return daytona.CreateSandboxFromSnapshotParams(snapshot=self._snapshot, **common)
 
     def _spot_params(self, resources: Any | None) -> dict[str, Any]:

{code_sandboxes-1.7.0 → code_sandboxes-1.8.0}/code_sandboxes/environments/__init__.py

@@ -15,6 +15,8 @@ provider-specific:
 
 - :mod:`.spec` — the canonical specification and its rules;
 - :mod:`.resolve` — the lock a version is resolved into, once (D-9);
+- :mod:`.policy` — whether an artifact's scan lets it be used (D-11);
+- :mod:`.attest` — the scan and the signature it needs before anything runs it;
 - :mod:`.contract` — ``sandbox-contract/v1`` and the Dockerfile validator;
 - :mod:`.lifecycle` — the version states and their legal moves;
 - :mod:`.errors` — the error taxonomy every provider error maps into;
@@ -28,6 +30,7 @@ The builders themselves are in :mod:`.adapters`, loaded by variant.
 
 from __future__ import annotations
 
+from .attest import Attestor, attest_artifact, signature_tag
 from .bases import APPROVED_BASES, ApprovedBase
 from .builders import (
     ArtifactReference,
@@ -50,6 +53,7 @@ from .contract import (
 )
 from .errors import ERROR_CODES, EnvironmentsError, ErrorCode, map_provider_error
 from .lifecycle import VersionState, build_outcome, can_transition, transition
+from .policy import DEFAULT_POLICY, PolicyDecision, ScanPolicy, decide, refuse_if_blocked
 from .resolve import (
     LOCK_FORMAT,
     BuildkitResolveRunner,
@@ -76,6 +80,7 @@ __all__ = [
     "API_VERSION",
     "APPROVED_BASES",
     "CONTRACT_V1",
+    "DEFAULT_POLICY",
     "ERROR_CODES",
     "LOCK_FORMAT",
     "SANDBOX_CONTRACT_V1",
@@ -83,8 +88,9 @@ __all__ = [
     "VARIANTS",
     "ApprovedBase",
     "ArtifactReference",
-    "BuildkitResolveRunner",
+    "Attestor",
     "BuildRequest",
+    "BuildkitResolveRunner",
     "CapabilityReport",
     "CapabilitySet",
     "CheckResult",
@@ -94,23 +100,29 @@ __all__ = [
     "EnvironmentsError",
     "ErrorCode",
     "LocalResolveRunner",
+    "PolicyDecision",
     "ResolveRunner",
     "SandboxContract",
+    "ScanPolicy",
     "ValidationResult",
     "VersionState",
+    "attest_artifact",
     "build_outcome",
     "can_transition",
     "canonical_digest",
     "canonical_json",
     "check_dockerfile",
+    "decide",
     "get_builder",
     "locked_versions",
-    "merge_requirements",
     "map_provider_error",
+    "merge_requirements",
     "parse_environment",
     "parse_resolver_failure",
     "protected_pins",
+    "refuse_if_blocked",
     "resolve_environment",
+    "signature_tag",
     "spec_digest",
     "spec_findings",
     "transition",