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: sandbox package listing (#8104)

Dylan Madisetti3819f891acd4
diff --git a/marimo/_cli/cli.py b/marimo/_cli/cli.py
index 87c8d27178..0e26741b5f 100644
--- a/marimo/_cli/cli.py
+++ b/marimo/_cli/cli.py
@@ -531,6 +531,10 @@ def edit(
"Or: pip install pyzmq"
)
+ # Enable script metadata management for sandboxed notebooks
+ os.environ["MARIMO_MANAGE_SCRIPT_METADATA"] = "true"
+ GLOBAL_SETTINGS.MANAGE_SCRIPT_METADATA = True
+
# Check shared memory availability early (required for edit mode to
# communicate between the server process and kernel subprocess)
from marimo._utils.platform import check_shared_memory_available
diff --git a/marimo/_runtime/packages/package_manager.py b/marimo/_runtime/packages/package_manager.py
index 8ce7aa4fd7..4e8ba40ab5 100644
--- a/marimo/_runtime/packages/package_manager.py
+++ b/marimo/_runtime/packages/package_manager.py
@@ -19,6 +19,9 @@ if TYPE_CHECKING:
LOGGER = _loggers.marimo_logger()
+# Default Python executable
+PY_EXE = sys.executable
+
# Type alias for log callback function
LogCallback = Callable[[str], None]
@@ -242,10 +245,13 @@ class CanonicalizingPackageManager(PackageManager):
Subclasses needs to implement _construct_module_name_mapping.
"""
- def __init__(self) -> None:
+ def __init__(self, python_exe: str | None = None) -> None:
# Initialized lazily
self._module_name_to_repo_name: dict[str, str] | None = None
self._repo_name_to_module_name: dict[str, str] | None = None
+ # Python executable for targeting a specific venv (used by pip/uv)
+ # Defaults to sys.executable if not provided
+ self._python_exe = python_exe or PY_EXE
super().__init__()
@abc.abstractmethod
diff --git a/marimo/_runtime/packages/package_managers.py b/marimo/_runtime/packages/package_managers.py
index c1712fcacb..b71f7f9a10 100644
--- a/marimo/_runtime/packages/package_managers.py
+++ b/marimo/_runtime/packages/package_managers.py
@@ -22,13 +22,15 @@ PACKAGE_MANAGERS = {
}
-def create_package_manager(name: str) -> PackageManager:
+def create_package_manager(
+ name: str, python_exe: str | None = None
+) -> PackageManager:
if is_pyodide():
# user config has name "pip", but micropip's name is "micropip" ...
return MicropipPackageManager()
if name in PACKAGE_MANAGERS:
- return PACKAGE_MANAGERS[name]() # type:ignore[abstract]
+ return PACKAGE_MANAGERS[name](python_exe=python_exe) # type:ignore[abstract]
raise RuntimeError(
f"Unknown package manager {name}. "
"This is a bug in marimo."
diff --git a/marimo/_runtime/packages/pypi_package_manager.py b/marimo/_runtime/packages/pypi_package_manager.py
index c36c014adf..55d3c9640c 100644
--- a/marimo/_runtime/packages/pypi_package_manager.py
+++ b/marimo/_runtime/packages/pypi_package_manager.py
@@ -128,7 +128,7 @@ class PipPackageManager(PypiPackageManager):
return [
"pip",
"--python",
- PY_EXE,
+ self._python_exe,
"install",
*(["--upgrade"] if upgrade else []),
*split_packages(package),
@@ -142,7 +142,7 @@ class PipPackageManager(PypiPackageManager):
[
"pip",
"--python",
- PY_EXE,
+ self._python_exe,
"uninstall",
"-y",
*split_packages(package),
@@ -151,7 +151,13 @@ class PipPackageManager(PypiPackageManager):
)
def list_packages(self) -> list[PackageDescription]:
- cmd = ["pip", "--python", PY_EXE, "list", "--format=json"]
+ cmd = [
+ "pip",
+ "--python",
+ self._python_exe,
+ "list",
+ "--format=json",
+ ]
return self._list_packages_from_cmd(cmd)
@@ -276,7 +282,7 @@ class UvPackageManager(PypiPackageManager):
# to respect the user's env (e.g. UV_COMPILE_BYTECODE)
*split_packages(package),
"-p",
- PY_EXE,
+ self._python_exe,
]
async def _install(
@@ -584,7 +590,7 @@ class UvPackageManager(PypiPackageManager):
uninstall_cmd = [self._uv_bin, "pip", "uninstall"]
return await self.run(
- uninstall_cmd + [*split_packages(package), "-p", PY_EXE],
+ uninstall_cmd + [*split_packages(package), "-p", self._python_exe],
log_callback=None,
)
@@ -610,7 +616,14 @@ class UvPackageManager(PypiPackageManager):
return sorted(packages, key=lambda pkg: pkg.name)
LOGGER.info("Listing packages with 'uv pip list'")
- cmd = [self._uv_bin, "pip", "list", "--format=json", "-p", PY_EXE]
+ cmd = [
+ self._uv_bin,
+ "pip",
+ "list",
+ "--format=json",
+ "-p",
+ self._python_exe,
+ ]
return self._list_packages_from_cmd(cmd)
def _has_script_metadata(self, filename: str) -> bool:
diff --git a/marimo/_server/api/endpoints/packages.py b/marimo/_server/api/endpoints/packages.py
index 0c2e5df40a..e580ca7782 100644
--- a/marimo/_server/api/endpoints/packages.py
+++ b/marimo/_server/api/endpoints/packages.py
@@ -180,13 +180,27 @@ async def dependency_tree(request: Request) -> DependencyTreeResponse:
def _get_package_manager(request: Request) -> PackageManager:
- if not AppState(request).get_current_session():
+ session = AppState(request).get_current_session()
+ if not session:
return create_package_manager(
AppState(request).config_manager.package_manager
)
config_manager = AppState(request).app_config_manager
- return create_package_manager(config_manager.package_manager)
+
+ # Check if IPC mode - use kernel's venv Python
+ python_exe: str | None = None
+ from marimo._session.managers.ipc import IPCKernelManagerImpl
+ from marimo._session.session import SessionImpl
+
+ if isinstance(session, SessionImpl):
+ kernel_manager = session._kernel_manager
+ if isinstance(kernel_manager, IPCKernelManagerImpl):
+ python_exe = kernel_manager.venv_python
+
+ return create_package_manager(
+ config_manager.package_manager, python_exe=python_exe
+ )
def _get_filename(request: Request) -> Optional[str]:
diff --git a/marimo/_session/managers/ipc.py b/marimo/_session/managers/ipc.py
index e05bb54ff2..eca415a5a7 100644
--- a/marimo/_session/managers/ipc.py
+++ b/marimo/_session/managers/ipc.py
@@ -159,6 +159,7 @@ class IPCKernelManagerImpl(KernelManager):
self._process: subprocess.Popen[bytes] | None = None
self.kernel_task: ProcessLike | None = None
self._sandbox_dir: str | None = None
+ self._venv_python: str | None = None
def start_kernel(self) -> None:
from marimo._cli.print import echo, muted
@@ -260,6 +261,9 @@ class IPCKernelManagerImpl(KernelManager):
err=True,
)
+ # Store the venv python for package manager targeting
+ self._venv_python = venv_python
+
cmd = [venv_python, "-m", "marimo._ipc.launch_kernel"]
if writable:
# Setting this attempts to make auto-installations work even if
@@ -322,6 +326,11 @@ class IPCKernelManagerImpl(KernelManager):
# Profiling not currently supported with IPC kernel
return None
+ @property
+ def venv_python(self) -> str | None:
+ """Python executable path for the kernel's venv."""
+ return self._venv_python
+
def is_alive(self) -> bool:
if self._process is None:
return False
diff --git a/tests/_runtime/packages/test_package_managers.py b/tests/_runtime/packages/test_package_managers.py
index 2320bd5be3..261082c428 100644
--- a/tests/_runtime/packages/test_package_managers.py
+++ b/tests/_runtime/packages/test_package_managers.py
@@ -32,6 +32,30 @@ def test_create_package_managers() -> None:
assert "Unknown package manager" in str(e)
+def test_create_package_manager_with_python_exe() -> None:
+ """Test that create_package_manager passes python_exe to package managers."""
+ custom_python = "/path/to/custom/python"
+
+ pip_mgr = create_package_manager("pip", python_exe=custom_python)
+ assert isinstance(pip_mgr, PipPackageManager)
+ assert pip_mgr._python_exe == custom_python
+
+ uv_mgr = create_package_manager("uv", python_exe=custom_python)
+ assert isinstance(uv_mgr, UvPackageManager)
+ assert uv_mgr._python_exe == custom_python
+
+
+def test_create_package_manager_without_python_exe() -> None:
+ """Test that create_package_manager defaults python_exe to PY_EXE."""
+ pip_mgr = create_package_manager("pip")
+ assert isinstance(pip_mgr, PipPackageManager)
+ assert pip_mgr._python_exe == PY_EXE
+
+ uv_mgr = create_package_manager("uv")
+ assert isinstance(uv_mgr, UvPackageManager)
+ assert uv_mgr._python_exe == PY_EXE
+
+
def test_update_script_metadata() -> None:
runs_calls: list[list[str]] = []
diff --git a/tests/_runtime/packages/test_pypi_package_manager.py b/tests/_runtime/packages/test_pypi_package_manager.py
index 73f800c482..61c9e2ee37 100644
--- a/tests/_runtime/packages/test_pypi_package_manager.py
+++ b/tests/_runtime/packages/test_pypi_package_manager.py
@@ -817,8 +817,6 @@ async def test_uv_install_in_project_no_fallback(mock_run: MagicMock):
class TestVersionMap:
- """Tests for VersionMap class"""
-
def test_get_version_exact_match(self) -> None:
"""Test getting version with exact package name match"""
diff --git a/tests/_server/api/endpoints/test_packages.py b/tests/_server/api/endpoints/test_packages.py
index 9a5516253e..f1c1af8d2b 100644
--- a/tests/_server/api/endpoints/test_packages.py
+++ b/tests/_server/api/endpoints/test_packages.py
@@ -607,3 +607,109 @@ def test_remove_package_with_dev_dependency(
mock_package_manager.uninstall.assert_called_once_with(
"test-package", dev=True
)
+
+
+def test_get_package_manager_uses_ipc_venv_python() -> None:
+ """Test that _get_package_manager uses venv Python from IPC kernel."""
+ from marimo._server.api.endpoints.packages import _get_package_manager
+
+ # Mock the session with an IPC kernel manager having venv_python set
+ mock_kernel_manager = MagicMock()
+ mock_kernel_manager.venv_python = "/custom/venv/python"
+
+ mock_session = MagicMock()
+ mock_session._kernel_manager = mock_kernel_manager
+
+ # Mock app state
+ mock_app_state = MagicMock()
+ mock_app_state.get_current_session.return_value = mock_session
+ mock_app_state.app_config_manager.package_manager = "pip"
+
+ mock_request = MagicMock()
+
+ with (
+ patch(
+ "marimo._server.api.endpoints.packages.AppState",
+ return_value=mock_app_state,
+ ),
+ patch(
+ "marimo._server.api.endpoints.packages.create_package_manager"
+ ) as mock_create_pm,
+ patch(
+ "marimo._server.api.endpoints.packages.isinstance",
+ side_effect=lambda obj, cls: (
+ cls.__name__ == "SessionImpl"
+ if hasattr(cls, "__name__") and cls.__name__ == "SessionImpl"
+ else (
+ cls.__name__ == "IPCKernelManagerImpl"
+ if hasattr(cls, "__name__")
+ and cls.__name__ == "IPCKernelManagerImpl"
+ else isinstance(obj, cls)
+ )
+ ),
+ ),
+ ):
+ _get_package_manager(mock_request)
+
+ # Verify create_package_manager was called with python_exe
+ mock_create_pm.assert_called_once_with(
+ "pip", python_exe="/custom/venv/python"
+ )
+
+
+def test_get_package_manager_without_ipc_session() -> None:
+ """Test that _get_package_manager works without IPC session."""
+ from marimo._server.api.endpoints.packages import _get_package_manager
+
+ # Mock non-IPC kernel manager (no venv_python attribute)
+ mock_kernel_manager = MagicMock(spec=[]) # Empty spec = no venv_python
+
+ mock_session = MagicMock()
+ mock_session._kernel_manager = mock_kernel_manager
+
+ # Mock app state
+ mock_app_state = MagicMock()
+ mock_app_state.get_current_session.return_value = mock_session
+ mock_app_state.app_config_manager.package_manager = "uv"
+
+ mock_request = MagicMock()
+
+ with (
+ patch(
+ "marimo._server.api.endpoints.packages.AppState",
+ return_value=mock_app_state,
+ ),
+ patch(
+ "marimo._server.api.endpoints.packages.create_package_manager"
+ ) as mock_create_pm,
+ ):
+ _get_package_manager(mock_request)
+
+ # Verify create_package_manager was called with python_exe=None
+ mock_create_pm.assert_called_once_with("uv", python_exe=None)
+
+
+def test_get_package_manager_no_session() -> None:
+ """Test that _get_package_manager works without any session."""
+ from marimo._server.api.endpoints.packages import _get_package_manager
+
+ # Mock app state with no session
+ mock_app_state = MagicMock()
+ mock_app_state.get_current_session.return_value = None
+ mock_app_state.config_manager.package_manager = "pip"
+
+ mock_request = MagicMock()
+
+ with (
+ patch(
+ "marimo._server.api.endpoints.packages.AppState",
+ return_value=mock_app_state,
+ ),
+ patch(
+ "marimo._server.api.endpoints.packages.create_package_manager"
+ ) as mock_create_pm,
+ ):
+ _get_package_manager(mock_request)
+
+ # Verify create_package_manager was called without python_exe
+ mock_create_pm.assert_called_once_with("pip")
diff --git a/tests/_session/managers/test_ipc.py b/tests/_session/managers/test_ipc.py
index 946456a9c0..8689429cfd 100644
--- a/tests/_session/managers/test_ipc.py
+++ b/tests/_session/managers/test_ipc.py
@@ -36,6 +36,73 @@ class TestIPCConnection:
kernel_conn.close()
+class TestIPCKernelManagerImpl:
+ def test_venv_python_initial_value(self) -> None:
+ """Test that venv_python is None before kernel starts."""
+ from unittest.mock import MagicMock
+
+ from marimo._session.managers.ipc import (
+ IPCKernelManagerImpl,
+ IPCQueueManagerImpl,
+ )
+ from marimo._session.model import SessionMode
+
+ # Create minimal mocks for construction
+ mock_ipc = MagicMock()
+ queue_manager = IPCQueueManagerImpl(mock_ipc)
+ connection_info = MagicMock()
+ configs: dict = {}
+ app_metadata = MagicMock()
+ config_manager = MagicMock()
+
+ # Create IPCKernelManagerImpl without starting kernel
+ kernel_manager = IPCKernelManagerImpl(
+ queue_manager=queue_manager,
+ connection_info=connection_info,
+ mode=SessionMode.EDIT,
+ configs=configs,
+ app_metadata=app_metadata,
+ config_manager=config_manager,
+ )
+
+ # venv_python should be None before kernel starts
+ assert kernel_manager.venv_python is None
+
+ def test_venv_python_property_returns_stored_value(self) -> None:
+ """Test that venv_python property returns the stored _venv_python value."""
+ from unittest.mock import MagicMock
+
+ from marimo._session.managers.ipc import (
+ IPCKernelManagerImpl,
+ IPCQueueManagerImpl,
+ )
+ from marimo._session.model import SessionMode
+
+ # Create minimal mocks for construction
+ mock_ipc = MagicMock()
+ queue_manager = IPCQueueManagerImpl(mock_ipc)
+ connection_info = MagicMock()
+ configs: dict = {}
+ app_metadata = MagicMock()
+ config_manager = MagicMock()
+
+ kernel_manager = IPCKernelManagerImpl(
+ queue_manager=queue_manager,
+ connection_info=connection_info,
+ mode=SessionMode.EDIT,
+ configs=configs,
+ app_metadata=app_metadata,
+ config_manager=config_manager,
+ )
+
+ # Manually set the internal state (simulating what start_kernel does)
+ kernel_manager._venv_python = "/path/to/sandbox/venv/python"
+
+ # venv_python property should return the stored value
+ assert kernel_manager.venv_python == "/path/to/sandbox/venv/python"
+
+
@pytest.mark.requires("zmq")
class TestIPCQueueManagerImpl:
def test_from_ipc_factory(self) -> None: