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: more defensive edge cases when adding packages to inline metadata (#7813)

Myles Scolnicke1af3d3e919b
diff --git a/marimo/_runtime/packages/pypi_package_manager.py b/marimo/_runtime/packages/pypi_package_manager.py
index c166131878..c55a07e2cc 100644
--- a/marimo/_runtime/packages/pypi_package_manager.py
+++ b/marimo/_runtime/packages/pypi_package_manager.py
@@ -23,12 +23,75 @@ from marimo._runtime.packages.utils import split_packages
from marimo._utils.platform import is_pyodide
from marimo._utils.uv import find_uv_bin
from marimo._utils.uv_tree import DependencyTreeNode, parse_uv_tree
+from marimo._utils.versions import (
+ extract_extras,
+ has_version_specifier,
+ without_extras,
+ without_version_specifier,
+)
PY_EXE = sys.executable
LOGGER = _loggers.marimo_logger()
+class VersionMap:
+ """
+ A map of package names to versions, with some extra
+ logic for defensibility when checking if a package is installed.
+ """
+
+ def __init__(self, version_map: dict[str, str]) -> None:
+ self.version_map = version_map
+
+ def get_version(self, package: str) -> str | None:
+ """Get the version of a package."""
+ # Remove extras and version specifier
+ package = without_extras(without_version_specifier(package)).lower()
+ return (
+ self._get(package)
+ # Try replacing _ with - and - with _
+ or self._get(package.replace("_", "-"))
+ or self._get(package.replace("-", "_"))
+ )
+
+ def resolve_with_version(self, package: str) -> str | None:
+ """Resolve a package name to a package name with a version specifier.
+
+ Preserves extras from the original package name in the result.
+ For example: 'requests[security]' -> 'requests[security]==2.28.0'
+ """
+ # Extract and preserve extras
+ extras = extract_extras(without_version_specifier(package))
+
+ # Get the base package name without extras or version specifier
+ base_package = without_extras(
+ without_version_specifier(package)
+ ).lower()
+
+ # Try exact match
+ if base_package in self.version_map:
+ return f"{base_package}{extras}=={self.version_map[base_package]}"
+
+ # Try replacing _ with -
+ normalized_package = base_package.replace("_", "-")
+ if normalized_package in self.version_map:
+ return f"{normalized_package}{extras}=={self.version_map[normalized_package]}"
+
+ # Try replacing - with _
+ normalized_package = base_package.replace("-", "_")
+ if normalized_package in self.version_map:
+ return f"{normalized_package}{extras}=={self.version_map[normalized_package]}"
+
+ return None
+
+ def _get(self, package: str) -> str | None:
+ return self.version_map.get(package)
+
+ def has(self, package: str) -> bool:
+ return self.get_version(package) is not None
+
+
class PypiPackageManager(CanonicalizingPackageManager):
def _construct_module_name_mapping(self) -> dict[str, str]:
return module_name_to_pypi_name()
@@ -347,18 +410,15 @@ class UvPackageManager(PypiPackageManager):
return False
def _is_installed(package: str) -> bool:
- without_brackets = package.split("[")[0]
- return without_brackets.lower() in version_map
+ return version_map.has(package)
def _maybe_add_version(package: str) -> str:
# Skip marimo and marimo[<mod>], but not marimo-<something-else>
if package == "marimo" or package.startswith("marimo["):
return package
- without_brackets = package.split("[")[0]
- version = version_map.get(without_brackets.lower())
- if version:
- return f"{package}=={version}"
- return package
+ if has_version_specifier(package):
+ return package
+ return version_map.resolve_with_version(package) or package
# Filter to packages that are found in "uv pip list" OR are direct references
# Direct references (git URLs, direct URLs, local paths) bypass the installed check
@@ -464,9 +524,9 @@ class UvPackageManager(PypiPackageManager):
)
return success
- def _get_version_map(self) -> dict[str, str]:
+ def _get_version_map(self) -> VersionMap:
packages = self.list_packages()
- return {pkg.name: pkg.version for pkg in packages}
+ return VersionMap({pkg.name: pkg.version for pkg in packages})
# Only needs to run once per session
@cached_property
diff --git a/marimo/_utils/versions.py b/marimo/_utils/versions.py
index 339cd0acfe..1e52b78204 100644
--- a/marimo/_utils/versions.py
+++ b/marimo/_utils/versions.py
@@ -2,6 +2,7 @@
from __future__ import annotations
import json
+import re
from importlib.metadata import Distribution
@@ -22,3 +23,24 @@ def is_editable(pkg_name: str) -> bool:
json.loads(direct_url).get("dir_info", {}).get("editable", False)
)
return bool(pkg_is_editable)
+
+
+def without_version_specifier(package: str) -> str:
+ return re.split(r"[!<>=~]+", package)[0].strip()
+
+
+def without_extras(package: str) -> str:
+ if "[" not in package:
+ return package
+ return package.split("[")[0]
+
+
+def extract_extras(package: str) -> str:
+ """Extract extras from a package name (e.g., '[security]' from 'requests[security]')"""
+ if "[" not in package:
+ return ""
+ return "[" + package.split("[", 1)[1]
+
+
+def has_version_specifier(package: str) -> bool:
+ return re.search(r"[!<>=~]+", package) is not None
diff --git a/tests/_runtime/packages/test_package_managers.py b/tests/_runtime/packages/test_package_managers.py
index 17d89f8fb3..a72f5dcc11 100644
--- a/tests/_runtime/packages/test_package_managers.py
+++ b/tests/_runtime/packages/test_package_managers.py
@@ -15,6 +15,7 @@ from marimo._runtime.packages.pypi_package_manager import (
PipPackageManager,
RyePackageManager,
UvPackageManager,
+ VersionMap,
)
@@ -48,8 +49,8 @@ def test_update_script_metadata() -> None:
runs_calls.append(command)
return True
- def _get_version_map(self) -> dict[str, str]:
- return {"foo": "1.0", "bar": "2.0"}
+ def _get_version_map(self) -> VersionMap:
+ return VersionMap({"foo": "1.0", "bar": "2.0"})
pm = MockUvPackageManager()
pm.update_notebook_script_metadata(
@@ -83,8 +84,8 @@ def test_update_script_metadata_with_version_map() -> None:
runs_calls.append(command)
return True
- def _get_version_map(self) -> dict[str, str]:
- return {"foo": "1.0", "bar": "2.0"}
+ def _get_version_map(self) -> VersionMap:
+ return VersionMap({"foo": "1.0", "bar": "2.0"})
pm = MockUvPackageManager()
# It should ignore when not in the version map
@@ -120,8 +121,10 @@ def test_update_script_metadata_with_mapping() -> None:
runs_calls.append(command)
return True
- def _get_version_map(self) -> dict[str, str]:
- return {"ibis": "2.0", "ibis-framework": "2.0", "pyyaml": "1.0"}
+ def _get_version_map(self) -> VersionMap:
+ return VersionMap(
+ {"ibis": "2.0", "ibis-framework": "2.0", "pyyaml": "1.0"}
+ )
pm = MockUvPackageManager()
# It should not canonicalize when passed explicitly
@@ -139,7 +142,7 @@ def test_update_script_metadata_with_mapping() -> None:
"nb.py", import_namespaces_to_add=["yaml"], upgrade=False
)
assert runs_calls == [
- ["uv", "--quiet", "add", "--script", "nb.py", "PyYAML==1.0"],
+ ["uv", "--quiet", "add", "--script", "nb.py", "pyyaml==1.0"],
]
runs_calls.clear()
@@ -177,12 +180,14 @@ def test_update_script_metadata_marimo_packages() -> None:
runs_calls.append(command)
return True
- def _get_version_map(self) -> dict[str, str]:
- return {
- "marimo": "0.1.0",
- "marimo-ai": "0.2.0",
- "pandas": "2.0.0",
- }
+ def _get_version_map(self) -> VersionMap:
+ return VersionMap(
+ {
+ "marimo": "0.1.0",
+ "marimo-ai": "0.2.0",
+ "pandas": "2.0.0",
+ }
+ )
pm = MockUvPackageManager()
@@ -566,9 +571,9 @@ def test_update_script_metadata_with_git_dependencies() -> None:
runs_calls.append(command)
return True
- def _get_version_map(self) -> dict[str, str]:
+ def _get_version_map(self) -> VersionMap:
# Git dependencies won't be in the version map with their git+ prefix
- return {"python-gcode": "0.1.0"}
+ return VersionMap({"python-gcode": "0.1.0"})
pm = MockUvPackageManager()
diff --git a/tests/_runtime/packages/test_pypi_package_manager.py b/tests/_runtime/packages/test_pypi_package_manager.py
index 2824cc0bd8..09f16c8e0e 100644
--- a/tests/_runtime/packages/test_pypi_package_manager.py
+++ b/tests/_runtime/packages/test_pypi_package_manager.py
@@ -13,6 +13,7 @@ from marimo._runtime.packages.pypi_package_manager import (
PipPackageManager,
PoetryPackageManager,
UvPackageManager,
+ VersionMap,
)
if TYPE_CHECKING:
@@ -815,3 +816,235 @@ async def test_uv_install_in_project_no_fallback(mock_run: MagicMock):
# Should fail without retry
assert result is False
+
+
+# VersionMap Tests
+
+
+class TestVersionMap:
+ """Tests for VersionMap class"""
+
+ 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
diff --git a/tests/_utils/test_versions.py b/tests/_utils/test_versions.py
new file mode 100644
index 0000000000..fc89f2353d
--- /dev/null
+++ b/tests/_utils/test_versions.py
@@ -0,0 +1,160 @@
+# Copyright 2026 Marimo. All rights reserved.
+from __future__ import annotations
+
+import pytest
+
+from marimo._utils.versions import (
+ extract_extras,
+ has_version_specifier,
+ without_extras,
+ without_version_specifier,
+)
+
+
+class TestWithoutVersionSpecifier:
+ """Tests for without_version_specifier function"""
+
+ def test_removes_version_specifiers(self) -> None:
+ # Test various version specifier operators
+ assert without_version_specifier("numpy==1.24.0") == "numpy"
+ assert without_version_specifier("pandas>1.5.0") == "pandas"
+ assert without_version_specifier("scipy>=1.10.0") == "scipy"
+ assert without_version_specifier("requests<3.0.0") == "requests"
+ assert without_version_specifier("urllib3<=2.0.0") == "urllib3"
+ assert without_version_specifier("flask~=2.0.0") == "flask"
+ # Exclusion operator (PEP 440)
+ assert without_version_specifier("package!=1.0.0") == "package"
+
+ def test_handles_whitespace(self) -> None:
+ # Whitespace around version operators should be stripped
+ assert without_version_specifier("package >= 1.0.0") == "package"
+ assert without_version_specifier("package >=1.0.0") == "package"
+
+ def test_preserves_package_without_version(self) -> None:
+ assert without_version_specifier("django") == "django"
+ assert without_version_specifier("") == ""
+
+ def test_handles_extras_and_special_chars(self) -> None:
+ # Should remove version but keep extras
+ assert (
+ without_version_specifier("requests[security]>=2.0.0")
+ == "requests[security]"
+ )
+ # Only splits on first specifier
+ assert without_version_specifier("package>=1.0.0,<2.0.0") == "package"
+ # Handles hyphens and underscores
+ assert (
+ without_version_specifier("scikit-learn>=1.0.0") == "scikit-learn"
+ )
+ assert (
+ without_version_specifier("typing_extensions>=4.0.0")
+ == "typing_extensions"
+ )
+
+
+class TestWithoutExtras:
+ """Tests for without_extras function"""
+
+ def test_removes_extras(self) -> None:
+ # Single extra
+ assert without_extras("requests[security]") == "requests"
+ # Multiple extras
+ assert without_extras("requests[security,socks]") == "requests"
+ # Nested brackets (splits at first bracket)
+ assert without_extras("package[extra[nested]]") == "package"
+
+ def test_preserves_package_without_extras(self) -> None:
+ assert without_extras("numpy") == "numpy"
+ assert without_extras("") == ""
+
+ def test_handles_extras_with_versions_and_special_chars(self) -> None:
+ # Removes extras and anything after them (including version specifiers)
+ assert without_extras("requests[security]>=2.0.0") == "requests"
+ # Handles hyphens and underscores
+ assert without_extras("scikit-learn[all]") == "scikit-learn"
+ assert without_extras("typing_extensions[test]") == "typing_extensions"
+
+
+class TestExtractExtras:
+ """Tests for extract_extras function"""
+
+ def test_extracts_single_extra(self) -> None:
+ assert extract_extras("requests[security]") == "[security]"
+
+ def test_extracts_multiple_extras(self) -> None:
+ assert extract_extras("requests[security,socks]") == "[security,socks]"
+
+ def test_no_extras(self) -> None:
+ assert extract_extras("numpy") == ""
+ assert extract_extras("") == ""
+
+ def test_extras_with_version_specifier(self) -> None:
+ # extract_extras expects version specifier to be removed first
+ package = "requests[security]>=2.0.0"
+ assert (
+ extract_extras(without_version_specifier(package)) == "[security]"
+ )
+
+ def test_extras_with_nested_brackets(self) -> None:
+ # Should include everything after the first opening bracket
+ assert extract_extras("package[extra[nested]]") == "[extra[nested]]"
+
+ def test_extras_with_special_chars(self) -> None:
+ assert extract_extras("package[a-b_c.d]") == "[a-b_c.d]"
+
+
+class TestHasVersionSpecifier:
+ """Tests for has_version_specifier function"""
+
+ def test_detects_version_specifiers(self) -> None:
+ # Various operators
+ assert has_version_specifier("numpy==1.24.0") is True
+ assert has_version_specifier("pandas>1.5.0") is True
+ assert has_version_specifier("scipy>=1.10.0") is True
+ assert has_version_specifier("requests<3.0.0") is True
+ assert has_version_specifier("urllib3<=2.0.0") is True
+ assert has_version_specifier("flask~=2.0.0") is True
+ # Exclusion operator (PEP 440)
+ assert has_version_specifier("package!=1.0.0") is True
+ # Multiple specifiers
+ assert has_version_specifier("package>=1.0.0,<2.0.0") is True
+
+ def test_detects_no_version_specifier(self) -> None:
+ assert has_version_specifier("django") is False
+ assert has_version_specifier("") is False
+ # Extras without version
+ assert has_version_specifier("requests[security]") is False
+ # Hyphens and underscores are not version specifiers
+ assert has_version_specifier("scikit-learn") is False
+ assert has_version_specifier("typing_extensions") is False
+
+ def test_handles_extras_with_version(self) -> None:
+ assert has_version_specifier("requests[security]>=2.0.0") is True
+
+
+class TestCombinedUsage:
+ """Tests for combined usage of utility functions"""
+
+ def test_chaining_functions(self) -> None:
+ package = "requests[security]>=2.0.0"
+ # Chain extras -> version
+ assert without_version_specifier(without_extras(package)) == "requests"
+ # Chain version -> extras
+ assert without_extras(without_version_specifier(package)) == "requests"
+
+ @pytest.mark.parametrize(
+ ("package", "expected_name"),
+ [
+ ("numpy==1.24.0", "numpy"),
+ ("pandas[all]>=1.5.0", "pandas"),
+ ("scikit-learn", "scikit-learn"),
+ ("requests[security,socks]<3.0.0", "requests"),
+ ("typing_extensions>=4.0.0", "typing_extensions"),
+ ],
+ )
+ def test_extract_clean_package_name(
+ self, package: str, expected_name: str
+ ) -> None:
+ """Test extracting clean package name from various formats"""
+ result = without_extras(without_version_specifier(package))
+ assert result == expected_name