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

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

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

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

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

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

@@ -487,7 +487,7 @@ def expected_packages(environment: Any, lock_text: str) -> dict[str, str]:
         return conda_expected_packages(dependency_file.content, lock_text or "")
     pinned = locked_versions(lock_text) if lock_text else {}
     names: list[str] = []
-    for text in environment.spec.packages.python.dependencies:
+    for text in _declared_dependencies(environment):
         try:
             names.append(canonicalize_name(Requirement(text).name))
         except InvalidRequirement:
@@ -495,6 +495,42 @@ def expected_packages(environment: Any, lock_text: str) -> dict[str, str]:
     return {name: pinned[name] for name in names if name in pinned}
 
 
+def _declared_dependencies(environment: Any) -> list[str]:
+    """The requirements a person declared, wherever the source keeps them.
+
+    A `dependencyFile` source names its packages in the file and leaves
+    `packages.python` empty, which is what the resolver reads too (E3-01).
+    Read from `packages.python` alone, check 5 was handed nothing for a
+    `requirements.txt` and passed for it, found live on 2026-09-18 (E3-08).
+    """
+    from .spec import parse_requirements_txt
+
+    build = environment.spec.build
+    dependency_file = build.dependency_file
+    if build.source == "dependencyFile" and dependency_file is not None:
+        if dependency_file.source_format == "requirements":
+            return parse_requirements_txt(dependency_file.content)
+        if dependency_file.source_format == "pyproject":
+            return _pyproject_dependencies(dependency_file.content)
+    return list(environment.spec.packages.python.dependencies)
+
+
+def _pyproject_dependencies(text: str) -> list[str]:
+    """`[project].dependencies` of a `pyproject.toml`, or none when it cannot be read."""
+    try:
+        import tomllib as toml
+    except ImportError:  # Python 3.10
+        try:
+            import tomli as toml  # type: ignore[no-redef]
+        except ImportError:
+            return []
+    try:
+        project = toml.loads(text).get("project") or {}
+    except toml.TOMLDecodeError:
+        return []
+    return [str(item) for item in project.get("dependencies") or []]
+
+
 def run_core_tier(
     sandbox: Sandbox,
     *,

{code_sandboxes-1.9.30 → code_sandboxes-1.9.31}/code_sandboxes/environments/resolve.py

@@ -39,6 +39,7 @@ Where the solve runs is the :class:`ResolveRunner`'s business:
 from __future__ import annotations
 
 import hashlib
+import os
 import re
 import shlex
 import shutil
@@ -860,9 +861,38 @@ def locked_versions(lock_text: str) -> dict[str, str]:
         ]
         if len(pinned) == 1:
             versions[canonicalize_name(requirement.name)] = pinned[0]
+        elif requirement.url:
+            wheel = _wheel_version(requirement.name, requirement.url)
+            if wheel:
+                versions[canonicalize_name(requirement.name)] = wheel
     return versions
 
 
+def _wheel_version(name: str, url: str) -> str | None:
+    """The version of a direct reference to a wheel, read from its file name.
+
+    How a `pyproject` lock brings Datalayer's `jupyter-server` fork, which no
+    index serves (E3-08): `uv` records a hash only for a wheel it fetched by
+    URL, so the export pins it as `jupyter-server @ https://…whl`, with no
+    `==` for the version. The wheel's name carries one, and nothing else here
+    does. A reference that is not a wheel of the same distribution pins none.
+    """
+    from urllib.parse import unquote, urlsplit
+
+    from packaging.utils import InvalidWheelFilename, canonicalize_name, parse_wheel_filename
+
+    filename = unquote(urlsplit(url).path.rsplit("/", 1)[-1])
+    if not filename.endswith(".whl"):
+        return None
+    try:
+        wheel_name, version, _build, _tags = parse_wheel_filename(filename)
+    except InvalidWheelFilename:
+        return None
+    if wheel_name != canonicalize_name(name):
+        return None
+    return str(version)
+
+
 def apt_pins_in(lock_text: str) -> dict[str, str]:
     """The apt versions a lock records, by package.
 
@@ -1058,10 +1088,12 @@ def _verified_pyproject_lock(
         root = Path(directory)
         (root / "pyproject.toml").write_text(dependency_file.content, encoding="utf-8")
         (root / "uv.lock").write_text(dependency_file.lock_content, encoding="utf-8")
+        environment = _uv_environment(root)
         try:
             checked = invoke(
                 [resolved_uv, "lock", "--dry-run"],
                 cwd=root,
+                env=environment,
                 capture_output=True,
                 text=True,
                 timeout=timeout,
@@ -1109,6 +1141,7 @@ def _verified_pyproject_lock(
         exported = invoke(
             [resolved_uv, "export", "--locked", "--format", "requirements.txt"],
             cwd=root,
+            env=environment,
             capture_output=True,
             text=True,
             timeout=timeout,
@@ -1138,6 +1171,23 @@ def _verified_pyproject_lock(
     }
 
 
+def _uv_environment(root: Path) -> dict[str, str]:
+    """What `uv` checks a lock with: its cache in the scratch directory, and no downloads.
+
+    The durable worker runs as a user with no home, so `uv`'s default cache
+    under `~/.cache` could not be made, and neither could the interpreter it
+    downloads when none satisfies `requires-python` (found on 2026-09-18, E3-08).
+    The interpreter comes from the worker's image instead, where the base
+    channel's own Python is installed: a check that fetched one per resolve would
+    be a check that depends on the network in a way nothing records.
+    """
+    return {
+        **os.environ,
+        "UV_CACHE_DIR": str(root / ".uv-cache"),
+        "UV_PYTHON_DOWNLOADS": "never",
+    }
+
+
 def _refuse_unless_protected_pins_are_locked(packages: Mapping[str, str]) -> None:
     """A `pyproject` source is never merged with Datalayer's pins (E3-01):
     bringing your own lock is the point, so nothing is force-injected the

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

@@ -42,7 +42,7 @@ A document is refused with `DL_ENV_SPEC_INVALID` when a field is wrong, and with
 | `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) and `image` (an existing image from a bootstrap registry allowlist, replacing the approved base) all resolve on the Datalayer variant; `image` from a private registry, and `dockerfile`, are refused until they do. |
+| `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. |
 
 ## The spec digest
 

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

@@ -229,15 +229,33 @@ sandbox.files.read_bytes("/tmp/data.parquet")
 
 ## Environments
 
-An [Environment](/docs/environments) built for Daytona is a **snapshot** —
-built from the approved Datalayer base, `uv pip sync --require-hashes`
-against the resolved lock, your files and `postInstall` commands, and an
-explicit `tini -- sleep infinity` entrypoint (Daytona's own default,
-otherwise, is a bare `sleep infinity`, with no init to reap orphans). The
-base already carries `uv`, the doctor and the sandbox contract's user and
-locale, so none of that is reinstalled — only the lock is genuinely
-per-build. The snapshot's own `id` is the artifact; a build also names it,
-for operability, but a launch never uses the name.
+An [Environment](/environments) built for Daytona is a **snapshot** —
+built from the approved Datalayer base, the resolved lock, your files and
+`postInstall` commands, and an explicit `tini -- sleep infinity` entrypoint
+(Daytona's own default, otherwise, is a bare `sleep infinity`, with no init
+to reap orphans). The base already carries `uv`, the doctor and the sandbox
+contract's user and locale, so none of that is reinstalled — only the lock is
+genuinely per-build. The snapshot's own `id` is the artifact; a build also
+names it, for operability, but a launch never uses the name.
+
+How the lock is installed depends on where the environment came from:
+
+| Source | Installed with |
+|---|---|
+| A package list, a `requirements.txt`, a `pyproject.toml` and its `uv.lock` | `uv pip sync --require-hashes`: the snapshot holds exactly the lock |
+| A conda `environment.yml` | `micromamba install` of the explicit lock into the base's own interpreter, then the pip layer the solve recorded |
+| A Dockerfile | Daytona's `Image.from_dockerfile`, its approved `FROM` pinned to the resolved digest, then `uv pip install --require-hashes` of the lock — `install`, not `sync`, so what the Dockerfile installed stays |
+
+**Deleted by id, and never stranded.** Retention deletes a snapshot nothing
+keeps any more, by its `id` — a name is reused once its snapshot is gone —
+and a snapshot already gone counts as deleted. A build that fails *after*
+Daytona built its snapshot, at the core tier or at the record, deletes that
+snapshot before it reports the failure, so nothing is left in your account
+that no version names.
+
+`make env-build-daytona`, in the `environments` folder of the
+[examples repository](https://github.com/datalayer/examples), builds a
+version for Daytona from the command line.
 
 **Bring your own account:** a build runs with the environment owner's own
 Daytona organization, not this package's ambient credentials — either

{code_sandboxes-1.9.30 → code_sandboxes-1.9.31}/docs/docs/providers/e2b.mdx

@@ -190,7 +190,7 @@ sandbox.files.read_bytes("/tmp/data.parquet")
 
 ## Environments
 
-An [Environment](/docs/environments) built for E2B is a **template**, not
+An [Environment](/environments) built for E2B is a **template**, not
 built from the Datalayer base the other three variants share: E2B's own
 code-interpreter server (the FastAPI service `run_code` and contexts
 actually talk to) is proprietary and ships baked into E2B's own

{code_sandboxes-1.9.30 → code_sandboxes-1.9.31}/docs/docs/providers/modal.mdx

@@ -74,7 +74,7 @@ with Sandbox.create(
 
 ## Environments
 
-An [Environment](/docs/environments) built for Modal is an **image id**,
+An [Environment](/environments) built for Modal is an **image id**,
 `im-…` — pulled `from_aws_ecr` off the approved Datalayer base, with your
 lock installed by `uv pip sync --require-hashes` on top. A published name
 is worth having for operability, but a launch always pins the id: each

{code_sandboxes-1.9.30 → code_sandboxes-1.9.31}/tests/test_environment_resolve.py

@@ -591,6 +591,19 @@ class TestARequirementsFile:
         assert from_packages["content"] == from_file["content"]
         assert from_packages["digest"] == from_file["digest"]
 
+    def test_check_five_is_handed_what_the_file_names(self) -> None:
+        """Read from `packages.python`, which a file source leaves empty, it
+        was handed nothing and check 5 passed for having nothing to check
+        (found live on 2026-09-18, E3-08)."""
+        from code_sandboxes.environments.conformance import expected_packages
+        from code_sandboxes.environments.spec import validate_environment
+
+        environment = validate_environment(
+            a_dependency_file_spec(content="geopandas==1.1.1  # inline\n-r other.txt\nsix>=1\n")
+        )
+        lock = "geopandas==1.1.1\nsix==1.16.0\nshapely==2.1.2\n"
+        assert expected_packages(environment, lock) == {"geopandas": "1.1.1", "six": "1.16.0"}
+
 
 # -- A pyproject.toml and its uv.lock (E3-01) ----------------------------------
 
@@ -606,9 +619,11 @@ class FakeUv:
     def __init__(self, *answers: tuple[int, str, str]) -> None:
         self.answers = list(answers)
         self.calls: list[list[str]] = []
+        self.environments: list[dict[str, str]] = []
 
-    def __call__(self, argv, **_kwargs):
+    def __call__(self, argv, **kwargs):
         self.calls.append(list(argv))
+        self.environments.append(dict(kwargs.get("env") or {}))
         code, out, err = self.answers[min(len(self.calls), len(self.answers)) - 1]
         return subprocess.CompletedProcess(list(argv), code, out, err)
 
@@ -645,6 +660,13 @@ EXPORTED = (
 )
 
 
+#: Where a `pyproject` author locks Datalayer's `jupyter-server` fork from.
+FORK_WHEEL_URL = (
+    "https://github.com/datalayer-externals/jupyter-server/releases/download/"
+    "v2.21.0-datalayer.1/jupyter_server-2.21.0%2Bdatalayer.1-py3-none-any.whl"
+)
+
+
 class TestAPyprojectFile:
     def test_a_current_lock_is_exported_rather_than_resolved(self) -> None:
         uv = FakeUv((0, "", "Resolved 2 packages in 1ms\n"), (0, EXPORTED, ""))
@@ -791,6 +813,70 @@ class TestAPyprojectFile:
             )
         assert raised.value.code.code == "DL_ENV_PROVIDER_ERROR"
 
+    def test_check_five_is_handed_the_projects_own_dependencies(self) -> None:
+        """`[project].dependencies`, not every package the export pins: most of
+        a lock is transitive, and check 5 imports what it is handed."""
+        from code_sandboxes.environments.conformance import expected_packages
+        from code_sandboxes.environments.spec import validate_environment
+
+        environment = validate_environment(a_pyproject_spec())
+        assert expected_packages(environment, EXPORTED) == {"six": "1.16.0"}
+
+    def test_the_fork_brought_by_url_is_a_locked_protected_pin(self) -> None:
+        """No index serves `2.21.0+datalayer.1`, and `uv` hashes a wheel only
+        when it fetched it by URL: so a real author's export names the fork
+        `jupyter-server @ https://…whl`, with no `==` (E3-08). Its version is
+        in the wheel's name, and that is what the pin is checked against."""
+        by_url = EXPORTED.replace(
+            "jupyter-server==2.21.0+datalayer.1 \\\n",
+            f"jupyter-server @ {FORK_WHEEL_URL} \\\n",
+        )
+        uv = FakeUv((0, "", "Resolved 7 packages in 1ms\n"), (0, by_url, ""))
+        answer = resolve_environment(
+            spec=a_pyproject_spec(),
+            variants=["datalayer"],
+            bases=BASES,
+            uv="/usr/bin/uv",
+            pyproject_run=uv,
+        )
+        assert answer["content"] == by_url
+        assert locked_versions(by_url)["jupyter-server"] == "2.21.0+datalayer.1"
+
+    def test_uv_keeps_its_cache_in_the_scratch_directory_and_downloads_no_python(self) -> None:
+        """The durable worker's user has no home: `uv`'s default cache could not
+        be made, nor the interpreter it would download (E3-08)."""
+        uv = FakeUv((0, "", "Resolved 7 packages in 1ms\n"), (0, EXPORTED, ""))
+        resolve_environment(
+            spec=a_pyproject_spec(),
+            variants=["datalayer"],
+            bases=BASES,
+            uv="/usr/bin/uv",
+            pyproject_run=uv,
+        )
+        assert len(uv.environments) == 2
+        for environment in uv.environments:
+            assert environment["UV_PYTHON_DOWNLOADS"] == "never"
+            assert environment["UV_CACHE_DIR"].endswith("/.uv-cache")
+            assert "/dl-pyproject-" in environment["UV_CACHE_DIR"]
+            assert environment["PATH"]
+
+    def test_a_url_that_is_not_that_distributions_wheel_pins_nothing(self) -> None:
+        assert (
+            locked_versions(
+                "jupyter-server @ https://example.org/jupyter_server-2.21.0.tar.gz\n"
+                f"ipykernel @ {FORK_WHEEL_URL}\n"
+                "six @ https://example.org/not-a-wheel-name.whl\n"
+            )
+            == {}
+        )
+
+    def test_a_pyproject_check_five_cannot_read_hands_it_nothing(self) -> None:
+        from code_sandboxes.environments.conformance import expected_packages
+        from code_sandboxes.environments.spec import validate_environment
+
+        environment = validate_environment(a_pyproject_spec(content="[project\n"))
+        assert expected_packages(environment, EXPORTED) == {}
+
 
 # -- An imported image (E3-04) -------------------------------------------------