code-sandboxes 1.9.26__tar.gz → 1.9.28__tar.gz

{code_sandboxes-1.9.26 → code_sandboxes-1.9.28}/PKG-INFO

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

{code_sandboxes-1.9.26 → code_sandboxes-1.9.28}/code_sandboxes/__version__.py

@@ -3,4 +3,4 @@
 
 """Code Sandboxes."""
 
-__version__ = "1.9.26"
+__version__ = "1.9.28"

{code_sandboxes-1.9.26 → code_sandboxes-1.9.28}/code_sandboxes/environments/adapters/datalayer.py

@@ -83,6 +83,7 @@ from ..resolve_conda import (
     conda_lock_pip_requirements,
     is_conda_lock,
     micromamba_bootstrap_dockerfile_line,
+    micromamba_install_command,
 )
 from ..spec import BuildSecret, Environment, command_names_secret
 
@@ -364,8 +365,9 @@ class Builder:
                     micromamba_bootstrap_dockerfile_line(),
                     "COPY lock.txt /opt/datalayer/lock.txt",
                     "RUN --mount=type=cache,target=/opt/conda/pkgs "
-                    f"{MICROMAMBA_BINARY} install --yes --name base "
-                    "--file /opt/datalayer/lock.txt",
+                    + micromamba_install_command(
+                        "/opt/datalayer/lock.txt", micromamba=MICROMAMBA_BINARY
+                    ),
                 ]
             )
             if pip_requirements:

{code_sandboxes-1.9.26 → code_sandboxes-1.9.28}/code_sandboxes/environments/adapters/daytona.py

@@ -116,6 +116,7 @@ from ..resolve_conda import (
     conda_lock_pip_requirements,
     is_conda_lock,
     micromamba_bootstrap_command,
+    micromamba_install_command,
 )
 from ..spec import GPU_SIZE_CLASSES, Environment
 from .managed import ManagedBuilder
@@ -373,9 +374,7 @@ class Builder(ManagedBuilder):
                     # present the same as for a pip source. micromamba is
                     # installed first: the approved base bakes uv but not it.
                     image = image.run_commands(micromamba_bootstrap_command())
-                    image = image.run_commands(
-                        f"micromamba install --yes --name base --file {_LOCK_PATH}"
-                    )
+                    image = image.run_commands(micromamba_install_command(_LOCK_PATH))
                     pip_requirements = conda_lock_pip_requirements(request.lock_text)
                     if pip_requirements:
                         requirements = " ".join(shlex.quote(req) for req in pip_requirements)

{code_sandboxes-1.9.26 → code_sandboxes-1.9.28}/code_sandboxes/environments/conformance.py

@@ -477,6 +477,14 @@ def expected_packages(environment: Any, lock_text: str) -> dict[str, str]:
 
     from .resolve import locked_versions
 
+    dependency_file = environment.spec.build.dependency_file
+    if dependency_file is not None and dependency_file.source_format == "conda":
+        # A conda source names its packages in the file, not in
+        # `packages.python`, and its lock is not a pip one (E3-02). Read the
+        # other way, check 5 was handed nothing and passed for it.
+        from .resolve_conda import conda_expected_packages
+
+        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:

{code_sandboxes-1.9.26 → code_sandboxes-1.9.28}/code_sandboxes/environments/resolve_conda.py

@@ -148,6 +148,30 @@ def micromamba_bootstrap_command() -> str:
     )
 
 
+#: Where an approved Datalayer base keeps its interpreter: `python` on the
+#: PATH is `/opt/conda/bin/python` (E1-05), and that is the environment a
+#: sandbox's kernel runs in.
+CONDA_PREFIX = "/opt/conda"
+
+
+def micromamba_install_command(lock_path: str, *, micromamba: str = "micromamba") -> str:
+    """The command that installs an explicit lock into the base's own interpreter.
+
+    **Into `/opt/conda`, by name.** The base sets no `MAMBA_ROOT_PREFIX`, and
+    left to itself `micromamba install --name base` makes a *new* `base` under
+    `~/.local/share/mamba` — for a Datalayer base, inside the very home the
+    runtime mounts a person's content over, and nowhere `python` looks. The
+    first real conda build (2026-09-18) installed all 81 packages there, and
+    then failed its own `postInstall` with `No module named 'osgeo'`. Both the
+    root and the target prefix are named, so nothing depends on which user the
+    step happens to run as.
+    """
+    return (
+        f"{micromamba} install --yes --root-prefix {CONDA_PREFIX} "
+        f"--prefix {CONDA_PREFIX} --file {lock_path}"
+    )
+
+
 def _utcnow() -> datetime:
     return datetime.now(timezone.utc)
 
@@ -416,6 +440,46 @@ def pip_requirements_from_env_yaml(text: str) -> tuple[str, ...]:
     return tuple(requirements)
 
 
+#: What the solved prefix's own interpreter is asked, to list the pip layer
+#: whole. Standard library only, and it runs inside the prefix.
+#:
+#: ``micromamba env export`` names the pip packages the *file* asked for and
+#: nothing they pulled in: the first real solve (2026-09-18) exported 7 pip
+#: pins where pip had installed several dozen distributions, so every build
+#: would have resolved ``tornado``, ``pyzmq``, ``traitlets`` and the rest
+#: afresh — on each variant, on whichever day it ran — under a lock that
+#: claimed to say the whole of what a build installs. A distribution records
+#: who installed it in its own ``INSTALLER`` file, which is what tells the pip
+#: layer from the conda packages that also carry Python metadata.
+PIP_LAYER_SCRIPT = """\
+import importlib.metadata as metadata
+
+layer = {}
+for distribution in metadata.distributions():
+    installer = (distribution.read_text("INSTALLER") or "").strip().lower()
+    name = distribution.metadata["Name"]
+    if installer in ("pip", "uv") and name:
+        layer[name.lower().replace("_", "-")] = distribution.version
+for name in sorted(layer):
+    print(f"{name}=={layer[name]}")
+"""
+
+
+def pip_requirements_from_listing(text: str) -> tuple[str, ...]:
+    """The pip layer :data:`PIP_LAYER_SCRIPT` printed: ``name==version`` lines.
+
+    Anything else on a line — a warning an interpreter wrote to the same
+    stream — is dropped rather than installed.
+    """
+    requirements: list[str] = []
+    for line in text.splitlines():
+        entry = line.strip()
+        name, separator, version = entry.partition("==")
+        if separator and name and version and " " not in entry:
+            requirements.append(entry)
+    return tuple(requirements)
+
+
 class CondaResolveRunner(Protocol):
     """Where a conda solve runs."""
 
@@ -559,9 +623,16 @@ class MicromambaResolveRunner:
                 [self._micromamba, "env", "export", "--prefix", str(prefix)],
                 say,
             )
+            # Every distribution pip installed, the transitive ones included:
+            # the export above names only what the file asked for.
+            listing = self._export(
+                [str(prefix / "bin" / "python"), "-c", PIP_LAYER_SCRIPT],
+                say,
+            )
         return CondaResolveOutcome(
             lock_text=export.stdout,
-            pip_lock=pip_requirements_from_env_yaml(pip_export.stdout),
+            pip_lock=pip_requirements_from_listing(listing.stdout)
+            or pip_requirements_from_env_yaml(pip_export.stdout),
         )
 
     def _export(
@@ -659,9 +730,14 @@ class BuildkitCondaResolveRunner:
                     f"RUN {micromamba} env export --explicit "
                     "--prefix /solve/prefix > /solve/lock.txt",
                     f"RUN {micromamba} env export --prefix /solve/prefix > /solve/pip-env.yml",
+                    # The pip layer whole, from the prefix's own interpreter:
+                    # a file of this package's, never a spec field.
+                    "COPY pip_layer.py ./pip_layer.py",
+                    "RUN /solve/prefix/bin/python pip_layer.py > /solve/pip-lock.txt",
                     "FROM scratch",
                     "COPY --from=solve /solve/lock.txt /lock.txt",
                     "COPY --from=solve /solve/pip-env.yml /pip-env.yml",
+                    "COPY --from=solve /solve/pip-lock.txt /pip-lock.txt",
                 ]
             )
             + "\n"
@@ -686,6 +762,7 @@ class BuildkitCondaResolveRunner:
         with tempfile.TemporaryDirectory(prefix="dl-conda-solve-") as directory:
             root = Path(directory)
             (root / "environment.yml").write_text(request.environment_yml, encoding="utf-8")
+            (root / "pip_layer.py").write_text(PIP_LAYER_SCRIPT, encoding="utf-8")
             (root / "Dockerfile").write_text(self.dockerfile(request), encoding="utf-8")
             out = root / "out"
             command = [
@@ -724,7 +801,12 @@ class BuildkitCondaResolveRunner:
                 raise parse_conda_failure(finished.stderr or finished.stdout or "")
             lock = (out / "lock.txt").read_text(encoding="utf-8")
             pip_env = out / "pip-env.yml"
+            pip_listing = out / "pip-lock.txt"
             pip_lock = (
+                pip_requirements_from_listing(pip_listing.read_text(encoding="utf-8"))
+                if pip_listing.exists()
+                else ()
+            ) or (
                 pip_requirements_from_env_yaml(pip_env.read_text(encoding="utf-8"))
                 if pip_env.exists()
                 else ()
@@ -763,6 +845,69 @@ def explicit_lock_packages(lock_text: str) -> list[str]:
     return packages
 
 
+#: `name-version-build.conda` (or `.tar.bz2`), as the last segment of an
+#: explicit lock's URL. A conda name may itself contain `-`, so the version and
+#: the build are the last two dash-separated fields, never the first two.
+_EXPLICIT_PACKAGE = re.compile(
+    r"/(?P<name>[^/]+)-(?P<version>[^-/]+)-(?P<build>[^-/]+)\.(?:conda|tar\.bz2)(?:#.*)?$"
+)
+
+
+def conda_lock_python_packages(lock_text: str) -> dict[str, str]:
+    """The Python distributions an explicit lock installs, by name, with their versions.
+
+    Only the ones a build string marks as Python packages — `py313h…` for a
+    compiled one, `pyh…`/`pyhd8ed…` for a noarch one. A conda lock is mostly
+    libraries with no Python metadata at all (`libgdal-core`, `proj`, `openssl`),
+    and Appendix B check 5 asks the interpreter for a distribution's version:
+    handing it `proj` would fail a check with nothing wrong to report.
+    """
+    found: dict[str, str] = {}
+    for url in explicit_lock_packages(lock_text):
+        match = _EXPLICIT_PACKAGE.search(url)
+        if match and match["build"].startswith("py"):
+            found[match["name"].lower()] = match["version"]
+    return found
+
+
+def conda_expected_packages(environment_yml: str, lock_text: str) -> dict[str, str]:
+    """What an `environment.yml` names at its top level, pinned to what its lock resolved.
+
+    Check 5's question, for a conda source (E3-02): the file's own `pip:`
+    requirements, and the conda packages it names that are Python
+    distributions. The interpreter is left out — check 3 asks about it, and
+    `python` is not a distribution the interpreter reports about itself.
+    Empty for a file that cannot be read: the spec's own validation refuses
+    one long before a build, and a smoke test is not where to say so again.
+    """
+    from packaging.requirements import InvalidRequirement, Requirement
+    from packaging.utils import canonicalize_name
+
+    try:
+        environment = parse_conda_environment(environment_yml)
+    except EnvironmentsError:
+        return {}
+    expected: dict[str, str] = {}
+    pythons = conda_lock_python_packages(lock_text)
+    for spec in environment.conda_dependencies:
+        name = _conda_package_name(spec)
+        if name != "python" and name in pythons:
+            expected[canonicalize_name(name)] = pythons[name]
+    pinned: dict[str, str] = {}
+    for requirement in conda_lock_pip_requirements(lock_text):
+        name, separator, version = requirement.partition("==")
+        if separator:
+            pinned[canonicalize_name(name.strip())] = version.strip()
+    for text in environment.pip_dependencies:
+        try:
+            name = canonicalize_name(Requirement(text).name)
+        except InvalidRequirement:
+            continue
+        if name in pinned:
+            expected[name] = pinned[name]
+    return expected
+
+
 def is_conda_lock(lock_text: str | None) -> bool:
     """Whether a lock is a conda explicit lock, and not the pip one.
 

{code_sandboxes-1.9.26 → code_sandboxes-1.9.28}/code_sandboxes/jupyter_server_sandbox.py

@@ -650,13 +650,17 @@ class JupyterServerSandbox(Sandbox):
                 "Failed to restart Jupyter kernel: the server answered %s", response.status_code
             )
             return False
-        # The websocket the client holds is to the kernel that has just been
-        # replaced; reconnecting is what makes the next execution land in the
-        # new interpreter rather than on a channel nobody is reading.
-        with contextlib.suppress(Exception):
-            self._client.stop()
-        with contextlib.suppress(Exception):
-            self._client.start()
+        # **The websocket is kept, never reconnected.** jupyter-server binds a
+        # kernel's websocket to the kernel id, not to its process, and moves
+        # it onto the restarted kernel itself — which is how JupyterLab's own
+        # restart works. Reconnecting here broke every restart instead:
+        # `jupyter_kernel_client` caches its shell and IOPub channels bound to
+        # the socket they were built with, so after `stop()` and `start()` the
+        # client held a new socket while its channels still wrote to the
+        # closed one. The next execution answered `ok` with no output — found
+        # on r1, 2026-09-18, as checks 7, 8 and 9 all failing together, and
+        # reproduced against the approved base itself, with the deployed
+        # client. Swallowing both calls' errors is what hid it.
         return True
 
     @marks_execution

{code_sandboxes-1.9.26 → code_sandboxes-1.9.28}/tests/test_environment_datalayer_builder.py

@@ -277,7 +277,14 @@ class TestTheDockerfileItGenerates:
         follows, so the kernel stack (E1-04) is present the same."""
         request = a_request(lock_text=CONDA_LOCK, spec=CONDA_SPEC)
         dockerfile = a_builder().dockerfile(request)
-        assert "micromamba install --yes --name base --file /opt/datalayer/lock.txt" in dockerfile
+        # Into the base's own interpreter, by name: left to itself micromamba
+        # made a new `base` under the content home, where `python` never looks
+        # (found on the first real conda build, 2026-09-18).
+        assert (
+            "micromamba install --yes --root-prefix /opt/conda --prefix /opt/conda "
+            "--file /opt/datalayer/lock.txt"
+        ) in dockerfile
+        assert "--name base" not in dockerfile
         # micromamba is copied in from its pinned image before it is invoked.
         bootstrap = dockerfile.index("COPY --from=mambaorg/micromamba")
         micromamba = dockerfile.index("micromamba install")

{code_sandboxes-1.9.26 → code_sandboxes-1.9.28}/tests/test_environment_daytona_builder.py

@@ -503,6 +503,10 @@ class TestBuildingASnapshot:
         pip = next(i for i, call in enumerate(runs) if "ipykernel==7.3.0" in call.args[0])
         assert bootstrap < micromamba < pip
         assert not any("uv pip sync" in call.args[0] for call in runs)
+        # The interpreter a sandbox runs, not a new `base` under the content
+        # home (2026-09-18): the same command the Datalayer builder emits.
+        assert "--root-prefix /opt/conda --prefix /opt/conda" in runs[micromamba].args[0]
+        assert "--name base" not in runs[micromamba].args[0]
 
     def test_user_root_brackets_the_install_steps(self) -> None:
         """Daytona honours the base's `USER`, unlike E2B (E0-04): no synthetic

{code_sandboxes-1.9.26 → code_sandboxes-1.9.28}/tests/test_environment_resolve_conda.py

@@ -20,16 +20,20 @@ from code_sandboxes.environments.errors import EnvironmentsError
 from code_sandboxes.environments.resolve import protected_pins
 from code_sandboxes.environments.resolve_conda import (
     CONDA_LOCK_FORMAT,
+    PIP_LAYER_SCRIPT,
     BuildkitCondaResolveRunner,
     CondaResolveOutcome,
     CondaResolveRequest,
     MicromambaResolveRunner,
+    conda_expected_packages,
     conda_lock_document,
+    conda_lock_python_packages,
     explicit_lock_packages,
     merge_conda_pip,
     parse_conda_environment,
     parse_conda_failure,
     pip_requirements_from_env_yaml,
+    pip_requirements_from_listing,
     rendered_environment,
     resolve_conda_environment,
 )
@@ -393,6 +397,95 @@ class TestTheRunners:
         assert "COPY --from=mambaorg/micromamba" in dockerfile
         assert "env export --prefix /solve/prefix > /solve/pip-env.yml" in dockerfile
         assert "COPY --from=solve /solve/pip-env.yml /pip-env.yml" in dockerfile
+        # And the pip layer whole, asked of the prefix's own interpreter: the
+        # export names what the file asked for and nothing it pulled in.
+        assert "COPY pip_layer.py ./pip_layer.py" in dockerfile
+        assert "RUN /solve/prefix/bin/python pip_layer.py > /solve/pip-lock.txt" in dockerfile
+        assert "COPY --from=solve /solve/pip-lock.txt /pip-lock.txt" in dockerfile
+
+
+class TestThePipLayerIsWhole:
+    """`micromamba env export` named 7 pip pins where pip had installed 310
+    distributions (the first real solve, 2026-09-18): everything they pulled
+    in would have been resolved afresh by each build, on each variant."""
+
+    def test_the_script_lists_what_pip_installed_and_not_what_conda_did(self, tmp_path) -> None:
+        import subprocess as process
+        import sys
+
+        site = tmp_path / "site"
+        for name, version, installer in (
+            ("Tornado", "6.5.10", "pip"),
+            ("jupyter_server", "2.21.0+datalayer.1", "uv"),
+            ("GDAL", "3.11.5", "conda"),
+            ("unknown", "1.0", ""),
+        ):
+            info = site / f"{name}-{version}.dist-info"
+            info.mkdir(parents=True)
+            (info / "METADATA").write_text(
+                f"Metadata-Version: 2.1\nName: {name}\nVersion: {version}\n"
+            )
+            (info / "INSTALLER").write_text(installer + "\n")
+        listed = process.run(  # noqa: S603 - this interpreter, this package's script
+            [
+                sys.executable,
+                "-S",
+                "-c",
+                f"import sys; sys.path[:] = [{str(site)!r}] + sys.path\n" + PIP_LAYER_SCRIPT,
+            ],
+            capture_output=True,
+            text=True,
+            check=True,
+        ).stdout
+        assert pip_requirements_from_listing(listed) == (
+            "jupyter-server==2.21.0+datalayer.1",
+            "tornado==6.5.10",
+        )
+
+    def test_a_line_that_is_not_a_pin_is_never_installed(self) -> None:
+        listing = "a==1\nWARNING: something was said\n\nb-c==2.0\n== \n"
+        assert pip_requirements_from_listing(listing) == ("a==1", "b-c==2.0")
+
+
+class TestWhatCheckFiveExpectsOfACondaLock:
+    LOCK = (
+        "# datalayer-pip: shapely==2.1.2\n# datalayer-pip: tornado==6.5.10\n@EXPLICIT\n"
+        "https://conda.anaconda.org/conda-forge/linux-64/libgdal-core-3.11.5-h4f65170_7.conda#aa\n"
+        "https://conda.anaconda.org/conda-forge/linux-64/gdal-3.11.5-py313h1ee8c46_7.conda#bb\n"
+        "https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.15.0-pyhcf101f3_0.conda#cc\n"
+        "https://conda.anaconda.org/conda-forge/linux-64/python-3.13.15-h2b335a9_0_cp313.conda#dd\n"
+    )
+    FILE = (
+        "channels: [conda-forge]\n"
+        "dependencies:\n"
+        "  - python=3.13\n"
+        "  - gdal=3.11\n"
+        "  - libgdal-core\n"
+        "  - pip:\n"
+        "      - shapely==2.1.2\n"
+    )
+
+    def test_only_python_distributions_are_read_out_of_the_lock(self) -> None:
+        """`libgdal-core` has no Python metadata: asking the interpreter for
+        its version would fail a check with nothing wrong to report."""
+        assert conda_lock_python_packages(self.LOCK) == {
+            "gdal": "3.11.5",
+            "typing-extensions": "4.15.0",
+        }
+
+    def test_it_is_what_the_file_names_pinned_to_what_the_lock_resolved(self) -> None:
+        assert conda_expected_packages(self.FILE, self.LOCK) == {
+            "gdal": "3.11.5",
+            "shapely": "2.1.2",
+        }
+
+    def test_check_five_is_handed_them_for_a_conda_version(self) -> None:
+        """Read from `packages.python`, as a pip source is, it was handed
+        nothing, and check 5 passed for having nothing to check."""
+        from code_sandboxes.environments.conformance import expected_packages
+
+        environment = validate_environment(a_conda_spec(content=self.FILE))
+        assert expected_packages(environment, self.LOCK) == {"gdal": "3.11.5", "shapely": "2.1.2"}
 
 
 # -- The whole resolve, through the recorded runner --------------------------

{code_sandboxes-1.9.26 → code_sandboxes-1.9.28}/tests/test_jupyter_server.py

@@ -559,6 +559,34 @@ class TestRestartingTheKernelRatherThanTheConnection:
         finally:
             sandbox.stop()
 
+    def test_the_connection_is_kept_across_the_restart(self, monkeypatch):
+        """jupyter-server moves a kernel's websocket onto the restarted kernel.
+
+        Reconnecting broke it: `jupyter_kernel_client`'s channels stay bound
+        to the socket they were built with, so after a `stop()` and `start()`
+        every execution answered `ok` with no output (r1, 2026-09-18).
+        """
+        sandbox = _started_sandbox(monkeypatch, kernel_id="kernel-1")
+        lifecycle: list[str] = []
+        client = sandbox._client
+        monkeypatch.setattr(client, "stop", lambda *a, **k: lifecycle.append("stop"))
+        monkeypatch.setattr(client, "start", lambda *a, **k: lifecycle.append("start"))
+
+        class _Response:
+            ok = True
+            status_code = 200
+
+        monkeypatch.setattr(
+            "code_sandboxes.jupyter_server_sandbox.requests.post",
+            lambda *args, **kwargs: _Response(),
+        )
+        try:
+            assert sandbox.restart_kernel() is True
+            assert lifecycle == []
+            assert sandbox._client is client
+        finally:
+            sandbox.stop()
+
     def test_a_server_that_refuses_the_restart_is_reported_not_raised(self, monkeypatch):
         sandbox = _started_sandbox(monkeypatch, kernel_id="kernel-1")