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.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
from __future__ import annotations
import asyncio
import json
import os
import subprocess
import sys
import threading
from functools import partial
from pathlib import Path
from typing import Any
from unittest.mock import MagicMock, patch
import pytest
from marimo._ast import compiler
from marimo._runtime.packages.package_manager import PackageDescription
from marimo._runtime.packages.pypi_package_manager import (
PipPackageManager,
PoetryPackageManager,
UvPackageManager,
VersionMap,
)
parse_cell = partial(compiler.compile_cell, cell_id="0")
PY_EXE = sys.executable
def _normalize_cmd(cmd: list[Any]) -> list[Any]:
"""Normalize path-like args (containing / or \\) to their stem."""
return [
Path(arg).stem
if isinstance(arg, str) and ("/" in arg or "\\" in arg)
else arg
for arg in cmd
]
def _assert_cmd_called_once_with(
mock: MagicMock, expected_cmd: list[Any], **expected_kwargs: Any
) -> None:
"""Assert mock was called once, normalizing path args for cross-platform comparison."""
mock.assert_called_once()
call_args, call_kwargs = mock.call_args
assert _normalize_cmd(call_args[0]) == _normalize_cmd(expected_cmd)
# Package-manager commands always run in their own session so that
# cell interrupts don't abort them
assert call_kwargs.pop("start_new_session", None) is True
assert call_kwargs == expected_kwargs
def test_module_to_package() -> None:
mgr = PipPackageManager()
assert mgr.module_to_package("marimo") == "marimo"
assert mgr.module_to_package("123_456_789") == "123-456-789"
assert mgr.module_to_package("sklearn") == "scikit-learn"
def test_package_to_module() -> None:
mgr = PipPackageManager()
assert mgr.package_to_module("marimo") == "marimo"
assert mgr.package_to_module("123-456-789") == "123_456_789"
assert mgr.package_to_module("scikit-learn") == "sklearn"
def test_package_to_module_is_normalized() -> None:
# PyPI package names are case-insensitive and treat runs of `-`, `_`, `.`
# as equivalent (PEP 503). uv normalizes names when it writes them into a
# notebook's script metadata (e.g. `Pillow` -> `pillow`), so the reverse
# mapping must still resolve them back to the correct module.
# Regression test for https://github.com/marimo-team/marimo/issues/9801
mgr = PipPackageManager()
assert mgr.package_to_module("Pillow") == "PIL"
assert mgr.package_to_module("pillow") == "PIL"
assert mgr.package_to_module("scikit-learn") == "sklearn"
assert mgr.package_to_module("Scikit-Learn") == "sklearn"
assert mgr.package_to_module("scikit_learn") == "sklearn"
async def test_failed_install_returns_false() -> None:
mgr = PipPackageManager()
# almost surely does not exist
assert not await mgr.install("asdfasdfasdfasdfqwerty", version=None)
@patch("subprocess.run")
def test_pip_is_manager_installed_primary_check_success(mock_run: MagicMock):
"""Primary python -m pip check succeeds → returns True."""
mock_run.return_value = MagicMock(returncode=0)
mgr = PipPackageManager()
assert mgr.is_manager_installed() is True
mock_run.assert_called_once()
call_args = mock_run.call_args[0][0]
assert call_args == [PY_EXE, "-m", "pip", "--version"]
@patch("subprocess.run")
@patch("marimo._dependencies.dependencies.DependencyManager.which")
def test_pip_is_manager_installed_fallback_check(
mock_which: MagicMock, mock_run: MagicMock
):
"""Primary python -m pip fails but pip is on PATH → returns True (fallback)."""
mock_run.return_value = MagicMock(returncode=1)
mock_which.return_value = True
mgr = PipPackageManager()
assert mgr.is_manager_installed() is True
# Primary check was called and failed
mock_run.assert_called_once()
# Fallback which() was also called
mock_which.assert_called_once_with("pip")
@patch("subprocess.run")
@patch("marimo._dependencies.dependencies.DependencyManager.which")
def test_pip_is_manager_installed_permission_error(
mock_which: MagicMock, mock_run: MagicMock
):
"""python -m pip raises OSError (e.g. PermissionError) → returns False."""
mock_run.side_effect = PermissionError("python not executable")
mock_which.return_value = False
mgr = PipPackageManager()
assert mgr.is_manager_installed() is False
@patch("subprocess.run")
@patch("marimo._dependencies.dependencies.DependencyManager.which")
def test_pip_is_manager_installed_both_fail(
mock_which: MagicMock, mock_run: MagicMock
):
"""Both python -m pip and which("pip") fail → returns False."""
mock_run.return_value = MagicMock(returncode=1)
mock_which.return_value = False
mgr = PipPackageManager()
assert mgr.is_manager_installed() is False
manager = PipPackageManager()
@patch("subprocess.run")
async def test_install(mock_run: MagicMock):
mock_run.return_value = MagicMock(returncode=0)
with patch.object(manager, "is_manager_installed", return_value=True):
result = await manager._install(
"package1 package2", upgrade=False, group=None
)
mock_run.assert_called_once_with(
[PY_EXE, "-m", "pip", "install", "package1", "package2"],
start_new_session=True,
)
assert result is True
@patch("subprocess.run")
async def test_install_failure(mock_run: MagicMock):
mock_run.return_value = MagicMock(returncode=1)
result = await manager._install(
"nonexistent-package", upgrade=False, group=None
)
assert result is False
@patch("subprocess.run")
async def test_uninstall(mock_run: MagicMock):
mock_run.return_value = MagicMock(returncode=0)
with patch.object(manager, "is_manager_installed", return_value=True):
result = await manager.uninstall("package1 package2", group=None)
mock_run.assert_called_once_with(
[
PY_EXE,
"-m",
"pip",
"uninstall",
"-y",
"package1",
"package2",
],
start_new_session=True,
)
assert result is True
@patch("subprocess.run")
def test_list_packages(mock_run: MagicMock):
mock_output = json.dumps(
[
{"name": "package1", "version": "1.0.0"},
{"name": "package2", "version": "2.1.0"},
]
)
mock_run.return_value = MagicMock(returncode=0, stdout=mock_output)
with patch.object(manager, "is_manager_installed", return_value=True):
packages = manager.list_packages()
mock_run.assert_called_once_with(
[PY_EXE, "-m", "pip", "list", "--format=json"],
capture_output=True,
text=True,
encoding="utf-8",
start_new_session=True,
)
assert len(packages) == 2
assert packages[0] == PackageDescription(name="package1", version="1.0.0")
assert packages[1] == PackageDescription(name="package2", version="2.1.0")
@patch("subprocess.run")
def test_list_packages_failure(mock_run: MagicMock):
mock_run.return_value = MagicMock(returncode=1)
packages = manager.list_packages()
assert len(packages) == 0
# Poetry Package Manager Tests
def test_poetry_generate_cmd_version_one():
mgr = PoetryPackageManager()
assert mgr._generate_list_packages_cmd(1) == [
"poetry",
"show",
"--no-dev",
]
@patch("subprocess.run")
def test_poetry_generate_cmd_version_two_prefers_without_dev(
mock_run: MagicMock,
):
mock_run.return_value = MagicMock(returncode=0, stderr="")
mgr = PoetryPackageManager()
cmd = mgr._generate_list_packages_cmd(2)
assert cmd == ["poetry", "show", "--without", "dev"]
mock_run.assert_called_once_with(
["poetry", "show", "--without", "dev"],
capture_output=True,
text=True,
start_new_session=True,
)
@patch("subprocess.run")
def test_poetry_generate_cmd_version_two_falls_back_when_missing_group(
mock_run: MagicMock,
):
mock_run.return_value = MagicMock(
returncode=1, stderr="Group(s) not found"
)
mgr = PoetryPackageManager()
cmd = mgr._generate_list_packages_cmd(2)
assert cmd == ["poetry", "show"]
@patch("subprocess.run")
def test_poetry_generate_cmd_default_for_other_versions(
mock_run: MagicMock,
):
mock_run.return_value = MagicMock(returncode=1, stderr="")
mgr = PoetryPackageManager()
cmd = mgr._generate_list_packages_cmd(3)
assert cmd == ["poetry", "show"]
@patch("subprocess.run")
def test_poetry_list_packages_parses_output(mock_run: MagicMock):
mock_run.side_effect = [
MagicMock(returncode=0, stdout="Poetry (1.8.2)"),
MagicMock(
returncode=0,
stdout="package-1 1.0.0\npackage-two 2.0.0\n",
),
]
mgr = PoetryPackageManager()
with patch.object(
PoetryPackageManager, "is_manager_installed", return_value=True
):
packages = mgr.list_packages()
assert packages == [
PackageDescription(name="package-1", version="1.0.0"),
PackageDescription(name="package-two", version="2.0.0"),
]
# Last subprocess call should be the list invocation with UTF-8 encoding
cmd_args, cmd_kwargs = mock_run.call_args_list[-1]
assert cmd_args[0] == ["poetry", "show", "--no-dev"]
assert cmd_kwargs.get("encoding") == "utf-8"
assert cmd_kwargs.get("text") is True
# UV Package Manager Tests
@patch.dict("os.environ", {}, clear=True)
def test_uv_is_in_uv_project_no_venv():
"""Test is_in_uv_project returns False when no VIRTUAL_ENV is set"""
mgr = UvPackageManager()
assert mgr.is_in_uv_project is False
@patch.dict("os.environ", {"VIRTUAL_ENV": "/path/to/venv"}, clear=True)
def test_uv_is_in_uv_project_no_uv_env():
"""Test is_in_uv_project returns False when UV env var is not set"""
mgr = UvPackageManager()
assert mgr.is_in_uv_project is False
@patch.dict(
"os.environ",
{"VIRTUAL_ENV": "/path/to/venv", "UV": "/other/path"},
clear=True,
)
def test_uv_is_in_uv_project_uv_env_mismatch():
"""Test is_in_uv_project returns False when UV env var doesn't match VIRTUAL_ENV"""
mgr = UvPackageManager()
assert mgr.is_in_uv_project is False
@patch.dict(
"os.environ",
{"VIRTUAL_ENV": "/path/to/venv", "UV": "/path/to/venv"},
clear=True,
)
@patch("pathlib.Path.exists")
def test_uv_is_in_uv_project_missing_files(mock_exists: MagicMock):
"""Test is_in_uv_project returns False when uv.lock or pyproject.toml don't exist"""
mock_exists.return_value = False
mgr = UvPackageManager()
assert mgr.is_in_uv_project is False
@patch.dict(
"os.environ",
{"VIRTUAL_ENV": "/path/to/venv", "UV": "/path/to/venv"},
clear=True,
)
@patch("pathlib.Path.exists")
def test_uv_is_in_uv_project_true(mock_exists: MagicMock):
"""Test is_in_uv_project returns True when all conditions are met"""
mock_exists.return_value = True
mgr = UvPackageManager()
assert mgr.is_in_uv_project is True
@patch.object(UvPackageManager, "_uv_bin", "uv")
def test_uv_can_target_python_without_mutating_project() -> None:
mgr = UvPackageManager.for_pip_install("/server/python")
assert mgr.install_command("nbformat", upgrade=False) == [
"uv",
"pip",
"install",
"nbformat",
"-p",
"/server/python",
]
@patch.object(UvPackageManager, "_uv_bin", "uv")
def test_uv_install_command_preserves_spaced_extras() -> None:
mgr = UvPackageManager.for_pip_install("/server/python")
assert mgr.install_command(
"matplotlib pydantic-ai[duckduckgo, web-fetch]", upgrade=True
) == [
"uv",
"pip",
"install",
"--upgrade",
"matplotlib",
"pydantic-ai[duckduckgo, web-fetch]",
"-p",
"/server/python",
]
@patch.dict(
"os.environ",
{"VIRTUAL_ENV": "/path/to/venv", "UV": "/path/to/venv"},
clear=True,
)
@patch("pathlib.Path.exists")
def test_uv_is_in_uv_project_cached(mock_exists: MagicMock):
"""Test is_in_uv_project is cached and only evaluates once"""
mock_exists.return_value = True
mgr = UvPackageManager()
# Access the property multiple times
result1 = mgr.is_in_uv_project
result2 = mgr.is_in_uv_project
result3 = mgr.is_in_uv_project
# Should all return the same value
assert result1 is True
assert result2 is True
assert result3 is True
# Path.exists should only be called twice (once for uv.lock, once for pyproject.toml)
# since the property is cached after the first access
assert mock_exists.call_count == 2
@patch("marimo._utils.subprocess.subprocess.Popen")
@patch.object(UvPackageManager, "is_in_uv_project", False)
async def test_uv_install_not_in_project(mock_popen: MagicMock):
"""Test UV install uses pip subcommand when not in UV project"""
mock_process = MagicMock()
mock_process.wait.return_value = 0
mock_process.stdout.readline.return_value = b""
mock_popen.return_value = mock_process
mgr = UvPackageManager()
result = await mgr._install("package1 package2", upgrade=False, group=None)
mock_popen.assert_called_once()
call_kwargs = mock_popen.call_args[1]
assert call_kwargs["stdout"] == subprocess.PIPE
assert call_kwargs["stderr"] == subprocess.STDOUT
assert call_kwargs["universal_newlines"] is False
assert call_kwargs["bufsize"] == 0
assert result is True
@patch.object(UvPackageManager, "is_in_uv_project", False)
async def test_uv_install_does_not_block_event_loop() -> None:
process_started = asyncio.Event()
release_process = threading.Event()
loop = asyncio.get_running_loop()
def install(*args: Any, **kwargs: Any) -> bool:
del args, kwargs
loop.call_soon_threadsafe(process_started.set)
release_process.wait(timeout=1)
return True
mgr = UvPackageManager()
with patch.object(
mgr, "_install_with_cache_fallback", side_effect=install
):
task = asyncio.create_task(
mgr._install("package1", upgrade=False, group=None)
)
await process_started.wait()
assert not task.done()
release_process.set()
assert await task is True
@patch("marimo._utils.subprocess.subprocess.Popen")
@patch.object(UvPackageManager, "is_in_uv_project", False)
async def test_uv_install_not_in_project_with_target(mock_popen: MagicMock):
"""Test UV install uses pip with target"""
mock_process = MagicMock()
mock_process.wait.return_value = 0
mock_process.stdout.readline.return_value = b""
mock_popen.return_value = mock_process
mgr = UvPackageManager()
# Explicitly set environ, since patch doesn't work in an asynchronous
# context.
os.environ["MARIMO_UV_TARGET"] = "target_path"
result = await mgr._install("package1 package2", upgrade=False, group=None)
del os.environ["MARIMO_UV_TARGET"]
mock_popen.assert_called_once()
call_kwargs = mock_popen.call_args[1]
assert call_kwargs["stdout"] == subprocess.PIPE
assert call_kwargs["stderr"] == subprocess.STDOUT
assert call_kwargs["universal_newlines"] is False
assert call_kwargs["bufsize"] == 0
assert result is True
@patch("subprocess.run")
@patch.object(UvPackageManager, "is_in_uv_project", True)
async def test_uv_install_in_project(mock_run: MagicMock):
"""Test UV install uses add subcommand when in UV project"""
mock_run.return_value = MagicMock(returncode=0)
mgr = UvPackageManager()
result = await mgr._install("package1 package2", upgrade=False, group=None)
_assert_cmd_called_once_with(
mock_run,
["uv", "add", "package1", "package2", "-p", PY_EXE],
)
assert result is True
@patch("subprocess.run")
@patch.object(UvPackageManager, "is_in_uv_project", True)
async def test_uv_install_dev_dependency_in_project(mock_run: MagicMock):
"""Test UV install uses add subcommand when in UV project"""
mock_run.return_value = MagicMock(returncode=0)
mgr = UvPackageManager()
result = await mgr._install(
"package1 package2", upgrade=False, group="dev"
)
_assert_cmd_called_once_with(
mock_run,
[
"uv",
"add",
"--group",
"dev",
"package1",
"package2",
"-p",
PY_EXE,
],
)
assert result is True
@patch("subprocess.run")
@patch.object(UvPackageManager, "is_in_uv_project", True)
async def test_uv_install_custom_group_in_project(mock_run: MagicMock):
"""Test UV install uses --group flag with custom dependency group"""
mock_run.return_value = MagicMock(returncode=0)
mgr = UvPackageManager()
result = await mgr._install("sphinx", upgrade=False, group="docs")
_assert_cmd_called_once_with(
mock_run,
[
"uv",
"add",
"--group",
"docs",
"sphinx",
"-p",
PY_EXE,
],
)
assert result is True
@patch("subprocess.run")
@patch.object(UvPackageManager, "is_in_uv_project", True)
async def test_uv_install_no_group_in_project(mock_run: MagicMock):
"""Test UV install without group doesn't pass --group flag"""
mock_run.return_value = MagicMock(returncode=0)
mgr = UvPackageManager()
result = await mgr._install("requests", upgrade=False, group=None)
_assert_cmd_called_once_with(
mock_run,
[
"uv",
"add",
"requests",
"-p",
PY_EXE,
],
)
assert result is True
@patch("subprocess.run")
@patch.object(UvPackageManager, "is_in_uv_project", True)
async def test_uv_uninstall_with_group_in_project(mock_run: MagicMock):
"""Test UV uninstall uses --group flag with dependency group"""
mock_run.return_value = MagicMock(returncode=0)
mgr = UvPackageManager()
result = await mgr.uninstall("sphinx", group="docs")
_assert_cmd_called_once_with(
mock_run,
["uv", "remove", "--group", "docs", "sphinx", "-p", PY_EXE],
)
assert result is True
@patch("subprocess.run")
@patch.object(UvPackageManager, "is_in_uv_project", False)
async def test_uv_uninstall_not_in_project(mock_run: MagicMock):
"""Test UV uninstall uses pip subcommand when not in UV project"""
mock_run.return_value = MagicMock(returncode=0)
mgr = UvPackageManager()
result = await mgr.uninstall("package1 package2")
_assert_cmd_called_once_with(
mock_run,
["uv", "pip", "uninstall", "package1", "package2", "-p", PY_EXE],
)
assert result is True
@patch("subprocess.run")
@patch.object(UvPackageManager, "is_in_uv_project", True)
async def test_uv_uninstall_in_project(mock_run: MagicMock):
"""Test UV uninstall uses remove subcommand when in UV project"""
mock_run.return_value = MagicMock(returncode=0)
mgr = UvPackageManager()
result = await mgr.uninstall("package1 package2")
_assert_cmd_called_once_with(
mock_run,
["uv", "remove", "package1", "package2", "-p", PY_EXE],
)
assert result is True
@patch("subprocess.run")
@patch.object(UvPackageManager, "dependency_tree")
def test_uv_list_packages(
mock_dependency_tree: MagicMock, mock_run: MagicMock
):
"""Test UV list packages uses pip list subcommand"""
mock_output = json.dumps(
[
{"name": "package1", "version": "1.0.0"},
{"name": "package2", "version": "2.1.0"},
]
)
mock_run.return_value = MagicMock(returncode=0, stdout=mock_output)
mock_dependency_tree.return_value = None
mgr = UvPackageManager()
packages = mgr.list_packages()
_assert_cmd_called_once_with(
mock_run,
["uv", "pip", "list", "--format=json", "-p", PY_EXE],
capture_output=True,
text=True,
encoding="utf-8",
)
assert len(packages) == 2
assert packages[0] == PackageDescription(name="package1", version="1.0.0")
assert packages[1] == PackageDescription(name="package2", version="2.1.0")
@patch.object(UvPackageManager, "dependency_tree")
def test_uv_list_packages_with_tree_success(mock_dependency_tree: MagicMock):
"""Test UV list packages uses uv tree when available"""
from marimo._server.models.packages import DependencyTreeNode
# Mock dependency_tree to return a valid tree
mock_tree = DependencyTreeNode(
name="root",
version="1.0.0",
tags=[],
dependencies=[
DependencyTreeNode(
name="z-package1",
version="1.0.0",
tags=[],
dependencies=[
DependencyTreeNode(
name="package3",
version="3.0.0",
tags=[],
dependencies=[],
)
],
),
DependencyTreeNode(
name="package2",
version=None, # Test None version handling
tags=[],
dependencies=[
# Duplicate package
DependencyTreeNode(
name="package3",
version="3.0.0",
tags=[],
dependencies=[],
)
],
),
],
)
mock_dependency_tree.return_value = mock_tree
mgr = UvPackageManager()
packages = mgr.list_packages()
# Should call dependency_tree first
mock_dependency_tree.assert_called_once()
# Should return packages from tree
assert len(packages) == 3
assert packages[0] == PackageDescription(name="package2", version="")
assert packages[1] == PackageDescription(name="package3", version="3.0.0")
assert packages[2] == PackageDescription(
name="z-package1", version="1.0.0"
)
@patch("subprocess.run")
@patch.object(UvPackageManager, "dependency_tree")
def test_uv_list_packages_tree_fallback_to_pip_list(
mock_dependency_tree: MagicMock, mock_run: MagicMock
):
"""Test UV list packages falls back to pip list when tree is None"""
# Mock dependency_tree to return None (fallback case)
mock_dependency_tree.return_value = None
# Mock subprocess for pip list
mock_output = json.dumps(
[
{"name": "fallback1", "version": "1.5.0"},
{"name": "fallback2", "version": "2.3.0"},
]
)
mock_run.return_value = MagicMock(returncode=0, stdout=mock_output)
mgr = UvPackageManager()
packages = mgr.list_packages()
# Should try dependency_tree first
mock_dependency_tree.assert_called_once()
# Should fall back to subprocess call
_assert_cmd_called_once_with(
mock_run,
["uv", "pip", "list", "--format=json", "-p", PY_EXE],
capture_output=True,
text=True,
encoding="utf-8",
)
# Should return packages from fallback method
assert len(packages) == 2
assert packages[0] == PackageDescription(name="fallback1", version="1.5.0")
assert packages[1] == PackageDescription(name="fallback2", version="2.3.0")
@patch.object(UvPackageManager, "dependency_tree")
def test_uv_list_packages_with_empty_tree(mock_dependency_tree: MagicMock):
"""Test UV list packages handles empty dependency tree"""
from marimo._server.models.packages import DependencyTreeNode
# Mock dependency_tree to return tree with no dependencies
mock_tree = DependencyTreeNode(
name="root", version="1.0.0", tags=[], dependencies=[]
)
mock_dependency_tree.return_value = mock_tree
mgr = UvPackageManager()
packages = mgr.list_packages()
# Should call dependency_tree
mock_dependency_tree.assert_called_once()
# Should return empty list
assert len(packages) == 0
assert packages == []
@patch.dict(
"os.environ",
{
"VIRTUAL_ENV": "/path/to/venv",
"UV_PROJECT_ENVIRONMENT": "/path/to/venv",
},
clear=True,
)
def test_uv_is_in_uv_project_uv_project_environment_match():
"""Test is_in_uv_project returns True when UV_PROJECT_ENVIRONMENT equals VIRTUAL_ENV"""
mgr = UvPackageManager()
assert mgr.is_in_uv_project is True
@patch.dict(
"os.environ",
{
"VIRTUAL_ENV": "/path/to/venv",
"UV_PROJECT_ENVIRONMENT": "/different/path",
},
clear=True,
)
def test_uv_is_in_uv_project_uv_project_environment_mismatch():
"""Test is_in_uv_project returns False when UV_PROJECT_ENVIRONMENT doesn't match VIRTUAL_ENV"""
mgr = UvPackageManager()
assert mgr.is_in_uv_project is False
# Encoding tests for Windows compatibility
@patch("subprocess.run")
def test_pip_list_packages_uses_utf8_encoding(mock_run: MagicMock):
"""Test that pip list uses UTF-8 encoding to handle non-ASCII characters"""
mock_output = json.dumps(
[
{"name": "package-中文", "version": "1.0.0"},
{"name": "пакет", "version": "2.0.0"},
]
)
mock_run.return_value = MagicMock(returncode=0, stdout=mock_output)
mgr = PipPackageManager()
with patch.object(mgr, "is_manager_installed", return_value=True):
packages = mgr.list_packages()
# Verify encoding='utf-8' is passed
mock_run.assert_called_once()
call_kwargs = mock_run.call_args[1]
assert call_kwargs.get("encoding") == "utf-8"
assert call_kwargs.get("text") is True
@patch("subprocess.run")
def test_uv_dependency_tree_uses_utf8_encoding(mock_run: MagicMock):
"""Test that uv tree uses UTF-8 encoding"""
mock_output = "test-package v1.0.0\n"
mock_run.return_value = MagicMock(
returncode=0, stdout=mock_output, stderr=""
)
mgr = UvPackageManager()
mgr.dependency_tree(filename="test.py")
# Verify encoding='utf-8' is passed
mock_run.assert_called_once()
call_kwargs = mock_run.call_args[1]
assert call_kwargs.get("encoding") == "utf-8"
assert call_kwargs.get("text") is True
@patch("subprocess.run")
def test_uv_dependency_tree_materializes_markdown(
mock_run: MagicMock, tmp_path: Path
) -> None:
notebook = tmp_path / "notebook.md"
notebook.write_text(
"---\n"
"pyproject: |\n"
' dependencies = ["test-package"]\n'
"---\n\n"
"# Notebook\n",
encoding="utf-8",
)
def run(command: list[str], **kwargs: Any) -> MagicMock:
carrier = Path(command[-1])
assert carrier.name == ".marimo-v1-notebook.md.py"
assert 'dependencies = ["test-package"]' in carrier.read_text()
assert kwargs["cwd"] == str(tmp_path)
return MagicMock(
args=command,
returncode=0,
stdout="test-package v1.0.0\n",
stderr="",
)
mock_run.side_effect = run
tree = UvPackageManager().dependency_tree(filename=str(notebook))
assert tree is not None
assert not (tmp_path / ".marimo-v1-notebook.md.py").exists()
@patch("subprocess.run")
def test_uv_pip_list_uses_utf8_encoding(mock_run: MagicMock):
"""Test that uv pip list uses UTF-8 encoding"""
mock_output = json.dumps([{"name": "test-pkg", "version": "1.0.0"}])
mock_run.return_value = MagicMock(returncode=0, stdout=mock_output)
mgr = UvPackageManager()
# Mock dependency_tree to return None so it falls back to pip list
with patch.object(mgr, "dependency_tree", return_value=None):
mgr.list_packages()
# Verify encoding='utf-8' is passed
mock_run.assert_called_once()
call_kwargs = mock_run.call_args[1]
assert call_kwargs.get("encoding") == "utf-8"
assert call_kwargs.get("text") is True
def test_has_script_metadata_with_metadata(tmp_path: Path):
"""Test that _has_script_metadata returns True when script has metadata"""
script_file = tmp_path / "script_with_metadata.py"
script_file.write_text(
"""# /// script
# requires-python = ">=3.11"
# dependencies = [
# "requests",
# "pandas",
# ]
# ///
import marimo as mo
"""
)
mgr = UvPackageManager()
assert mgr._has_script_metadata(str(script_file)) is True
def test_has_script_metadata_without_metadata(tmp_path: Path):
"""Test that _has_script_metadata returns False when script has no metadata"""
script_file = tmp_path / "script_without_metadata.py"
script_file.write_text(
"""import marimo as mo
import pandas as pd
# This is a regular comment
# Not a script metadata block
"""
)
mgr = UvPackageManager()
assert mgr._has_script_metadata(str(script_file)) is False
def test_has_script_metadata_nonexistent_file():
"""Test that _has_script_metadata returns False for nonexistent files"""
mgr = UvPackageManager()
assert mgr._has_script_metadata("/nonexistent/path/to/file.py") is False
def test_has_script_metadata_binary_file(tmp_path: Path):
"""Test that _has_script_metadata returns False for binary files"""
binary_file = tmp_path / "binary.bin"
binary_file.write_bytes(b"\x00\x01\x02\x03\xff\xfe\xfd")
mgr = UvPackageManager()
assert mgr._has_script_metadata(str(binary_file)) is False
@patch("marimo._utils.subprocess.subprocess.Popen")
@patch("subprocess.run")
@patch.object(UvPackageManager, "is_in_uv_project", False)
async def test_uv_install_cache_error_fallback(
mock_run: MagicMock, mock_popen: MagicMock
):
"""Test UV install retries with --no-cache on cache write errors"""
# Mock the first install attempt (via Popen) to fail with cache error
mock_process = MagicMock()
mock_process.wait.return_value = 1 # Failure
mock_process.stdout.readline.side_effect = [
b" \xc3\x97 Failed to download and build `pyqtree==1.0.0`\n",
b" \xe2\x94\x9c\xe2\x94\x80\xe2\x96\xb6 Failed to write to the distribution cache\n",
b" \xe2\x95\xb0\xe2\x94\x80\xe2\x96\xb6 Operation not permitted (os error 1)\n",
b"", # End of output
]
mock_popen.return_value = mock_process
# Mock the retry (via run) to succeed
mock_run.return_value = MagicMock(returncode=0)
mgr = UvPackageManager()
with patch.object(mgr, "is_manager_installed", return_value=True):
result = await mgr._install("datamapplot", upgrade=False, group=None)
# First attempt should use Popen (via safe_popen)
mock_popen.assert_called_once()
call_kwargs = mock_popen.call_args
assert call_kwargs[1]["stdout"] == subprocess.PIPE
assert call_kwargs[1]["stderr"] == subprocess.STDOUT
assert call_kwargs[1]["universal_newlines"] is False
assert call_kwargs[1]["bufsize"] == 0
# Retry should add --no-cache flag
_assert_cmd_called_once_with(
mock_run,
[
"uv",
"pip",
"install",
"datamapplot",
"-p",
PY_EXE,
"--no-cache",
],
)
# Should ultimately succeed
assert result is True
@patch("marimo._utils.subprocess.subprocess.Popen")
@patch.object(UvPackageManager, "is_in_uv_project", False)
async def test_uv_install_no_fallback_on_different_error(
mock_popen: MagicMock,
):
"""Test UV install does not retry when error is not cache-related"""
# Mock the install attempt to fail with a different error
mock_process = MagicMock()
mock_process.wait.return_value = 1 # Failure
mock_process.stdout.readline.side_effect = [
b" \xc3\x97 Failed to download package\n",
b" \xe2\x94\x9c\xe2\x94\x80\xe2\x96\xb6 Network error\n",
b"", # End of output
]
mock_popen.return_value = mock_process
mgr = UvPackageManager()
with patch.object(mgr, "is_manager_installed", return_value=True):
result = await mgr._install(
"nonexistent-package", upgrade=False, group=None
)
# Should only call Popen once (no retry)
mock_popen.assert_called_once()
# Should fail
assert result is False
@patch("subprocess.run")
@patch.object(UvPackageManager, "is_in_uv_project", True)
async def test_uv_install_in_project_no_fallback(mock_run: MagicMock):
"""Test UV install in a project does not use fallback mechanism"""
mock_run.return_value = MagicMock(returncode=1) # Failure
mgr = UvPackageManager()
result = await mgr._install("package1", upgrade=False, group=None)
# Should only call run once (no fallback for project mode)
_assert_cmd_called_once_with(
mock_run,
["uv", "add", "package1", "-p", PY_EXE],
)
# Should fail without retry
assert result is False
# VersionMap Tests
class TestVersionMap:
def test_get_version_exact_match(self) -> None:
"""Test getting version with exact package name match"""
version_map = VersionMap({"numpy": "1.24.0", "pandas": "2.0.0"})
assert version_map.get_version("numpy") == "1.24.0"
assert version_map.get_version("pandas") == "2.0.0"
def test_get_version_with_underscore_to_dash(self) -> None:
"""Test getting version when package name uses underscore but map has dash"""
version_map = VersionMap({"some-package": "1.0.0"})
assert version_map.get_version("some_package") == "1.0.0"
def test_get_version_with_dash_to_underscore(self) -> None:
"""Test getting version when package name uses dash but map has underscore"""
version_map = VersionMap({"some_package": "1.0.0"})
assert version_map.get_version("some-package") == "1.0.0"
def test_get_version_case_insensitive(self) -> None:
"""Test getting version is case insensitive"""
version_map = VersionMap({"numpy": "1.24.0"})
assert version_map.get_version("NumPy") == "1.24.0"
assert version_map.get_version("NUMPY") == "1.24.0"
def test_get_version_with_extras(self) -> None:
"""Test getting version removes extras from package name"""
version_map = VersionMap({"requests": "2.28.0"})
assert version_map.get_version("requests[security]") == "2.28.0"
assert version_map.get_version("requests[security,socks]") == "2.28.0"
def test_get_version_with_version_specifier(self) -> None:
"""Test getting version removes version specifier from package name"""
version_map = VersionMap({"numpy": "1.24.0"})
assert version_map.get_version("numpy>=1.20.0") == "1.24.0"
assert version_map.get_version("numpy==1.24.0") == "1.24.0"
assert version_map.get_version("numpy<2.0.0") == "1.24.0"
def test_get_version_with_extras_and_version(self) -> None:
"""Test getting version with both extras and version specifier"""
version_map = VersionMap({"requests": "2.28.0"})
assert version_map.get_version("requests[security]>=2.0.0") == "2.28.0"
def test_get_version_not_found(self) -> None:
"""Test getting version for non-existent package returns None"""
version_map = VersionMap({"numpy": "1.24.0"})
assert version_map.get_version("pandas") is None
assert version_map.get_version("nonexistent") is None
def test_has_package_exists(self) -> None:
"""Test has() returns True for existing packages"""
version_map = VersionMap({"numpy": "1.24.0", "pandas": "2.0.0"})
assert version_map.has("numpy") is True
assert version_map.has("pandas") is True
def test_has_package_not_exists(self) -> None:
"""Test has() returns False for non-existent packages"""
version_map = VersionMap({"numpy": "1.24.0"})
assert version_map.has("pandas") is False
assert version_map.has("nonexistent") is False
def test_has_with_underscore_dash_normalization(self) -> None:
"""Test has() works with underscore/dash normalization"""
version_map = VersionMap({"some-package": "1.0.0"})
assert version_map.has("some_package") is True
assert version_map.has("some-package") is True
def test_has_with_extras(self) -> None:
"""Test has() works with extras"""
version_map = VersionMap({"requests": "2.28.0"})
assert version_map.has("requests[security]") is True
def test_has_with_version_specifier(self) -> None:
"""Test has() works with version specifiers"""
version_map = VersionMap({"numpy": "1.24.0"})
assert version_map.has("numpy>=1.20.0") is True
def test_resolve_with_version_exact_match(self) -> None:
"""Test resolve_with_version with exact match"""
version_map = VersionMap({"numpy": "1.24.0"})
assert version_map.resolve_with_version("numpy") == "numpy==1.24.0"
def test_resolve_with_version_with_underscore_to_dash(self) -> None:
"""Test resolve_with_version handles underscore to dash conversion"""
version_map = VersionMap({"some-package": "1.0.0"})
assert (
version_map.resolve_with_version("some_package")
== "some-package==1.0.0"
)
def test_resolve_with_version_with_dash_to_underscore(self) -> None:
"""Test resolve_with_version handles dash to underscore conversion"""
version_map = VersionMap({"some_package": "1.0.0"})
assert (
version_map.resolve_with_version("some-package")
== "some_package==1.0.0"
)
def test_resolve_with_version_not_found(self) -> None:
"""Test resolve_with_version returns None for non-existent package"""
version_map = VersionMap({"numpy": "1.24.0"})
assert version_map.resolve_with_version("pandas") is None
def test_resolve_with_version_case_insensitive(self) -> None:
"""Test resolve_with_version is case insensitive"""
version_map = VersionMap({"numpy": "1.24.0"})
assert version_map.resolve_with_version("NumPy") == "numpy==1.24.0"
def test_resolve_with_version_with_extras(self) -> None:
"""Test resolve_with_version preserves extras"""
version_map = VersionMap({"requests": "2.28.0"})
assert (
version_map.resolve_with_version("requests[security]")
== "requests[security]==2.28.0"
)
def test_resolve_with_version_with_multiple_extras(self) -> None:
"""Test resolve_with_version preserves multiple extras"""
version_map = VersionMap({"requests": "2.28.0"})
assert (
version_map.resolve_with_version("requests[security,socks]")
== "requests[security,socks]==2.28.0"
)
def test_resolve_with_version_with_extras_and_version(self) -> None:
"""Test resolve_with_version preserves extras when version is stripped"""
version_map = VersionMap({"requests": "2.28.0"})
assert (
version_map.resolve_with_version("requests[security]>=2.0.0")
== "requests[security]==2.28.0"
)
def test_resolve_with_version_with_extras_underscore_dash(self) -> None:
"""Test resolve_with_version preserves extras with underscore/dash normalization"""
version_map = VersionMap({"some-package": "1.0.0"})
assert (
version_map.resolve_with_version("some_package[extra]")
== "some-package[extra]==1.0.0"
)
version_map = VersionMap({"some_package": "2.0.0"})
assert (
version_map.resolve_with_version("some-package[extra]")
== "some_package[extra]==2.0.0"
)
def test_resolve_with_version_with_complex_extras(self) -> None:
"""Test resolve_with_version handles complex extras correctly"""
version_map = VersionMap({"apache-airflow": "2.7.0"})
assert (
version_map.resolve_with_version(
"apache-airflow[postgres,redis]>=2.0"
)
== "apache-airflow[postgres,redis]==2.7.0"
)
def test_resolve_with_version_with_version_specifier(self) -> None:
"""Test resolve_with_version removes existing version specifier"""
version_map = VersionMap({"numpy": "1.24.0"})
assert (
version_map.resolve_with_version("numpy>=1.20.0")
== "numpy==1.24.0"
)
def test_version_map_empty(self) -> None:
"""Test VersionMap with empty dict"""
version_map = VersionMap({})
assert version_map.get_version("numpy") is None
assert version_map.has("numpy") is False
assert version_map.resolve_with_version("numpy") is None
def test_version_map_real_world_packages(self) -> None:
"""Test VersionMap with real-world package names"""
version_map = VersionMap(
{
"scikit-learn": "1.3.0",
"typing_extensions": "4.8.0",
"pillow": "10.0.0",
"beautifulsoup4": "4.12.0",
}
)
# Test scikit-learn
assert version_map.get_version("scikit_learn") == "1.3.0"
assert version_map.has("scikit-learn") is True
assert (
version_map.resolve_with_version("scikit_learn")
== "scikit-learn==1.3.0"
)
# Test typing_extensions
assert version_map.get_version("typing-extensions") == "4.8.0"
assert version_map.has("typing_extensions") is True
# Test pillow (no dash/underscore conversion)
assert version_map.get_version("pillow") == "10.0.0"
assert version_map.has("Pillow") is True
# Test beautifulsoup4 (number in name)
assert version_map.get_version("beautifulsoup4") == "4.12.0"
assert version_map.has("beautifulsoup4") is True
@pytest.mark.asyncio
@pytest.mark.parametrize(
"requirement",
["my_pkg[extra]", "my-pkg>=1", "my-pkg @ https://example.org/pkg.whl"],
)
async def test_script_uninstall_matches_distribution_name(
tmp_path: Path, requirement: str
) -> None:
notebook = tmp_path / "notebook.py"
notebook.write_text(
'# /// script\n# dependencies = ["my-pkg[extra]>=1"]\n# ///\n'
)
from marimo._environments.sandbox import NotebookSandbox
from marimo._runtime.packages.sandbox_package_manager import (
SandboxPackageManager,
)
sandbox = NotebookSandbox(str(notebook), "uv")
manager = SandboxPackageManager(sandbox)
with patch.object(sandbox, "_sync"):
assert await manager.uninstall(requirement)
assert "my-pkg" not in notebook.read_text()
@pytest.mark.asyncio
async def test_script_uninstall_preserves_transitive_dependency(
tmp_path: Path,
) -> None:
notebook = tmp_path / "notebook.py"
notebook.write_text('# /// script\n# dependencies = ["parent"]\n# ///\n')
from marimo._environments.sandbox import NotebookSandbox
from marimo._runtime.packages.sandbox_package_manager import (
SandboxPackageManager,
)
sandbox = NotebookSandbox(str(notebook), "uv")
manager = SandboxPackageManager(sandbox)
with patch.object(sandbox, "_sync") as change:
assert not await manager.uninstall("transitive")
change.assert_not_called()