Skip to content

A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.

fix: add auto env to enable jupyter extension behavior (#11127)

Dylan Madisetti7c19106e6d4e
diff --git a/marimo/_config/settings.py b/marimo/_config/settings.py
index 4e6c1a2374..72fa59a98e 100644
--- a/marimo/_config/settings.py
+++ b/marimo/_config/settings.py
@@ -25,6 +25,11 @@ class GlobalSettings:
SANDBOX_BACKEND: str | None = (
os.environ.get("MARIMO_SANDBOX_BACKEND") or None
)
+ # Let each notebook's manifest pick its environment in a sandboxed
+ # directory server.
+ # [tool.marimo.venv] takes precedence over [tool.pixi] then falls back to the
+ # default SANDBOX_BACKEND (unset is UV). Required for the Jupyter extension.
+ SANDBOX_AUTO: bool = is_env_true("MARIMO_SANDBOX_AUTO")
IN_SECURE_ENVIRONMENT: bool = is_env_true("MARIMO_IN_SECURE_ENVIRONMENT")
# Mark the session cookie as `Secure` so browsers only send it over HTTPS.
# Enable when serving marimo behind TLS / a TLS-terminating proxy. Default
diff --git a/marimo/_environments/backends.py b/marimo/_environments/backends.py
index 31c2689823..f18382e7b3 100644
--- a/marimo/_environments/backends.py
+++ b/marimo/_environments/backends.py
@@ -50,6 +50,24 @@ def current_backend() -> Backend:
return "pixi" if GLOBAL_SETTINGS.SANDBOX_BACKEND == "pixi" else "uv"
+def backend_for(filename: str | None) -> Backend:
+ """The backend that manages `filename`'s environment.
+
+ With `MARIMO_SANDBOX_AUTO` set, a `[tool.pixi]` table in the notebook's
+ manifest selects pixi. Otherwise this is the process backend.
+ """
+ from marimo._config.settings import GLOBAL_SETTINGS
+ from marimo._environments import script_metadata
+
+ if (
+ GLOBAL_SETTINGS.SANDBOX_AUTO
+ and filename is not None
+ and script_metadata.declares_pixi(filename)
+ ):
+ return "pixi"
+ return current_backend()
+
+
def adapter_for(
backend: Backend, reporter: SandboxReporter | None = None
) -> BackendAdapter:
diff --git a/marimo/_environments/script_metadata.py b/marimo/_environments/script_metadata.py
index 007b800a22..6d0f0a80a1 100644
--- a/marimo/_environments/script_metadata.py
+++ b/marimo/_environments/script_metadata.py
@@ -140,6 +140,18 @@ def loads(script: str) -> dict[str, Any] | None:
return None
+def declares_pixi(path: str) -> bool:
+ """True when the notebook's manifest has a `[tool.pixi]` table."""
+ try:
+ project = toml_reader.reads(read_manifest(path))
+ except Exception:
+ # NB. A missing or malformed manifest falls back to the process
+ # backend, which reports the problem when it syncs.
+ return False
+ tool = project.get("tool")
+ return isinstance(tool, dict) and isinstance(tool.get("pixi"), dict)
+
+
def dumps(project: dict[str, Any]) -> str:
"""Serialize a project dict to a `# /// script` block."""
import tomlkit
diff --git a/marimo/_server/api/endpoints/packages.py b/marimo/_server/api/endpoints/packages.py
index 9a6028f10b..374787f10a 100644
--- a/marimo/_server/api/endpoints/packages.py
+++ b/marimo/_server/api/endpoints/packages.py
@@ -8,7 +8,7 @@ from starlette.authentication import requires
from marimo._config.settings import GLOBAL_SETTINGS
from marimo._environments import script_metadata
-from marimo._environments.backends import current_backend
+from marimo._environments.backends import backend_for
from marimo._environments.errors import (
EnvironmentManagerError,
SandboxRestartRequired,
@@ -316,6 +316,14 @@ def _get_filename(request: Request) -> str | None:
return session.app_file_manager.filename
+def _runs_in_configured_venv(state: AppState, path: str) -> bool:
+ """True when auto mode will start `path` in its `[tool.marimo.venv]`."""
+ if not GLOBAL_SETTINGS.SANDBOX_AUTO:
+ return False
+ config = state.config_manager_at_file(path).get_config(hide_secrets=False)
+ return bool(config.get("venv", {}).get("path"))
+
+
def _sandbox_source(
request: Request, file_key: str | None, *, mutation: bool = False
) -> tuple[NotebookSandbox | None, str | None, Backend | None]:
@@ -339,7 +347,11 @@ def _sandbox_source(
if not manager.sandbox:
return None, None, None
path = manager.workspace.resolve(key) if key else None
- return None, path, current_backend()
+ if path is not None and _runs_in_configured_venv(state, path):
+ # NB. Same answer the session path gives once the kernel is up: a
+ # configured-venv kernel has no NotebookSandbox.
+ return None, None, None
+ return None, path, backend_for(path)
@router.post("/sandbox")
diff --git a/marimo/_session/managers/ipc.py b/marimo/_session/managers/ipc.py
index 41149f5aef..96c87ae9f4 100644
--- a/marimo/_session/managers/ipc.py
+++ b/marimo/_session/managers/ipc.py
@@ -330,7 +330,10 @@ class IPCKernelManagerImpl(KernelManager):
"prepare", {}, "kernel", self._notify
) as operation:
venv_config = _get_venv_config(self.config_manager)
- if self._sandbox and venv_config.get("path"):
+ # NB. With MARIMO_SANDBOX_AUTO the manifest picks the environment
+ # per notebook, so a configured venv is honored even here.
+ ignore_venv = self._sandbox and not GLOBAL_SETTINGS.SANDBOX_AUTO
+ if ignore_venv and venv_config.get("path"):
echo(
"Warning: ignoring [tool.marimo.venv] in sandbox mode. "
"Use --no-sandbox to edit with the configured environment.",
@@ -339,7 +342,7 @@ class IPCKernelManagerImpl(KernelManager):
try:
configured_python = (
None
- if self._sandbox
+ if ignore_venv
else get_configured_venv_python(
venv_config, base_path=self.app_metadata.filename
)
@@ -420,10 +423,10 @@ class IPCKernelManagerImpl(KernelManager):
from marimo._environments.errors import EnvironmentManagerError
from marimo._environments.sandbox import NotebookSandbox
- backend = backends.current_backend()
+ filename = self.app_metadata.filename
+ backend = backends.backend_for(filename)
kernel_args_list = ["-m", "marimo._ipc.launch_kernel"]
overlay = runtime_overlay()
- filename = self.app_metadata.filename
sandbox = NotebookSandbox(filename, backend)
try:
plan = await sandbox.launch_async(
diff --git a/tests/_environments/test_script_metadata.py b/tests/_environments/test_script_metadata.py
index 535677904e..fbc31a946a 100644
--- a/tests/_environments/test_script_metadata.py
+++ b/tests/_environments/test_script_metadata.py
@@ -27,6 +27,27 @@ BLOCK_WITH_TOOL_TABLES = """\
"""
+ ("manifest", "expected"),
+ [
+ (
+ "# /// script\n# [tool.pixi.workspace]\n# channels = []\n# ///\n",
+ True,
+ ),
+ (
+ "# /// script\n# [tool.marimo.venv]\n# path = '.venv'\n# ///\n",
+ False,
+ ),
+ ("import marimo\n", False),
+ ("# /// script\n# [tool.pixi\n# ///\n", False),
+ ],
+)
+def test_declares_pixi(tmp_path: Path, manifest: str, expected: bool) -> None:
+ notebook = tmp_path / "notebook.py"
+ notebook.write_text(manifest)
+ assert script_metadata.declares_pixi(str(notebook)) is expected
+
+
def test_loads_returns_none_without_block() -> None:
assert script_metadata.loads("print('hi')\n") is None
diff --git a/tests/_server/api/endpoints/test_packages.py b/tests/_server/api/endpoints/test_packages.py
index d2853a97d0..4f389de840 100644
--- a/tests/_server/api/endpoints/test_packages.py
+++ b/tests/_server/api/endpoints/test_packages.py
@@ -986,8 +986,8 @@ def test_repair_manifest_without_a_kernel(
manager.sandbox = True
manager.workspace = SingleFileWorkspace.from_path(MarimoPath(str(path)))
monkeypatch.setattr(
- "marimo._server.api.endpoints.packages.current_backend",
- lambda: backend,
+ "marimo._server.api.endpoints.packages.backend_for",
+ lambda _path: backend,
)
request = {"fileKey": str(path)}
response = client.post(
@@ -1049,6 +1049,73 @@ def test_manifest_access_uses_workspace_permissions(
assert denied.read_text() == "private = True\n"
+ ("manifest", "expected_backend"),
+ [
+ ("# [tool.pixi.workspace]\n# channels = []\n", "pixi"),
+ ("", "uv"),
+ ],
+)
+def test_sandbox_auto_resolves_backend_without_a_kernel(
+ client: TestClient,
+ tmp_path,
+ monkeypatch: pytest.MonkeyPatch,
+ manifest: str,
+ expected_backend: str,
+) -> None:
+ from marimo._config.settings import GLOBAL_SETTINGS
+ from marimo._server.workspace import SingleFileWorkspace
+ from marimo._utils.marimo_path import MarimoPath
+
+ path = tmp_path / "notebook.py"
+ path.write_text(
+ "# /// script\n# dependencies = []\n" + manifest + "# ///\n"
+ "import marimo\napp = marimo.App()\n"
+ )
+ manager = client.app.state.session_manager
+ manager.sandbox = True
+ manager.workspace = SingleFileWorkspace.from_path(MarimoPath(str(path)))
+ monkeypatch.setattr(GLOBAL_SETTINGS, "SANDBOX_AUTO", True)
+ monkeypatch.setattr(GLOBAL_SETTINGS, "SANDBOX_BACKEND", "uv")
+
+ response = client.post(
+ "/api/packages/sandbox", headers=HEADERS, json={"fileKey": str(path)}
+ )
+
+ assert response.status_code == 200
+ assert response.json()["backend"] == expected_backend
+ assert response.json()["filename"] == str(path)
+
+
+def test_sandbox_auto_reports_no_sandbox_for_configured_venv(
+ client: TestClient, tmp_path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ from marimo._config.settings import GLOBAL_SETTINGS
+ from marimo._server.workspace import SingleFileWorkspace
+ from marimo._utils.marimo_path import MarimoPath
+
+ path = tmp_path / "notebook.py"
+ path.write_text(
+ "# /// script\n# [tool.marimo.venv]\n# path = '.venv'\n"
+ "# [tool.pixi.workspace]\n# channels = []\n# ///\n"
+ "import marimo\napp = marimo.App()\n"
+ )
+ manager = client.app.state.session_manager
+ manager.sandbox = True
+ manager.workspace = SingleFileWorkspace.from_path(MarimoPath(str(path)))
+ monkeypatch.setattr(GLOBAL_SETTINGS, "SANDBOX_AUTO", True)
+
+ response = client.post(
+ "/api/packages/sandbox", headers=HEADERS, json={"fileKey": str(path)}
+ )
+
+ # NB. The venv wins over the pixi table, and a configured-venv kernel
+ # has no sandbox, matching what the session reports after startup.
+ assert response.status_code == 200
+ assert response.json()["backend"] is None
+ assert response.json()["filename"] is None
+
+
@pytest.mark.parametrize(
("endpoint", "operation"),
[("sandbox", "read_manifest"), ("manifest", "write_manifest")],
@@ -1069,7 +1136,8 @@ def test_manifest_file_errors_are_reported(
manager.sandbox = True
manager.workspace = SingleFileWorkspace.from_path(MarimoPath(str(path)))
monkeypatch.setattr(
- "marimo._server.api.endpoints.packages.current_backend", lambda: "uv"
+ "marimo._server.api.endpoints.packages.backend_for",
+ lambda _path: "uv",
)
def denied(*_args: Any, **_kwargs: Any) -> None:
diff --git a/tests/_server/test_sessions.py b/tests/_server/test_sessions.py
index a77a42db7c..a8e6450f61 100644
--- a/tests/_server/test_sessions.py
+++ b/tests/_server/test_sessions.py
@@ -1305,6 +1305,117 @@ async def test_configured_venv_launches_editor_kernel_without_sandbox(
session.close()
+async def test_sandbox_auto_honors_configured_venv(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ from marimo._config.settings import GLOBAL_SETTINGS
+ from marimo._session.managers.ipc import IPCKernelManagerImpl
+
+ monkeypatch.setattr(GLOBAL_SETTINGS, "SANDBOX_AUTO", True)
+ notebook = tmp_path / "notebook.py"
+ notebook.write_text(
+ "# /// script\n# [tool.marimo.venv]\n"
+ f"# path = {str(Path(sys.prefix).as_posix())!r}\n# ///\n"
+ )
+ session = await SessionImpl.create(
+ initialization_id=str(notebook),
+ startup=SessionStartup(),
+ session_consumer=None,
+ mode=SessionMode.EDIT,
+ app_metadata=AppMetadata(
+ query_params={},
+ filename=str(notebook),
+ cli_args={},
+ app_config=_AppConfig(),
+ ),
+ app_file_manager=AppFileManager(filename=str(notebook)),
+ config_manager=get_default_config_manager(current_path=str(tmp_path)),
+ virtual_file_storage=None,
+ redirect_console_to_browser=False,
+ ttl_seconds=None,
+ auto_instantiate=False,
+ sandbox=True,
+ )
+ try:
+ manager = session._kernel_manager
+ assert isinstance(manager, IPCKernelManagerImpl)
+ assert manager.is_alive()
+ assert manager.venv_python is not None
+ assert Path(manager.venv_python).parent.parent == Path(sys.prefix)
+ assert session.notebook_sandbox is None
+ assert "ignoring [tool.marimo.venv]" not in capsys.readouterr().err
+ finally:
+ session.close()
+
+
+ ("manifest", "expected"),
+ [
+ ("# [tool.pixi.workspace]\n# channels = ['conda-forge']\n", "pixi"),
+ ("", "uv"),
+ ],
+)
+async def test_sandbox_auto_picks_backend_from_manifest(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ manifest: str,
+ expected: str,
+) -> None:
+ from marimo._config.settings import GLOBAL_SETTINGS
+ from marimo._environments.environment import Environment, ProcessPlan
+ from marimo._environments.sandbox import BackendAdapter, NotebookSandbox
+
+ monkeypatch.setattr(GLOBAL_SETTINGS, "SANDBOX_AUTO", True)
+ monkeypatch.setattr(GLOBAL_SETTINGS, "SANDBOX_BACKEND", "uv")
+ notebook = tmp_path / "notebook.py"
+ notebook.write_text(
+ "# /// script\n# dependencies = []\n" + manifest + "# ///\n"
+ )
+
+ environment = Environment(sys.executable, sys.prefix, "unchanged")
+ adapter = MagicMock(spec=BackendAdapter)
+ # NB. NotebookSandbox rejects an adapter whose name differs from the
+ # resolved backend, so a wrong resolution fails here, not silently.
+ adapter.name = expected
+ adapter.sync_async.return_value = environment
+ adapter.launch.return_value = ProcessPlan(
+ (sys.executable, "-m", "marimo._ipc.launch_kernel"), os.environ.copy()
+ )
+ monkeypatch.setattr(
+ "marimo._environments.backends.adapter_for", lambda *_: adapter
+ )
+
+ session = await SessionImpl.create(
+ initialization_id=str(notebook),
+ startup=SessionStartup(),
+ session_consumer=None,
+ mode=SessionMode.EDIT,
+ app_metadata=AppMetadata(
+ query_params={},
+ filename=str(notebook),
+ cli_args={},
+ app_config=_AppConfig(),
+ ),
+ app_file_manager=AppFileManager(filename=str(notebook)),
+ config_manager=get_default_config_manager(current_path=str(tmp_path)),
+ virtual_file_storage=None,
+ redirect_console_to_browser=False,
+ ttl_seconds=None,
+ auto_instantiate=False,
+ sandbox=True,
+ )
+ try:
+ sandbox = session.notebook_sandbox
+ assert isinstance(sandbox, NotebookSandbox)
+ assert sandbox.backend == expected
+ finally:
+ session.close()
+
+
async def test_session_script_dotenv_reaches_the_kernel_config(
tmp_path: Path,
) -> None: