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
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.pyindex 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_packagesfrom marimo._utils.platform import is_pyodidefrom marimo._utils.uv import find_uv_binfrom 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.executableLOGGER = _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 Falsedef _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_propertydiff --git a/marimo/_utils/versions.py b/marimo/_utils/versions.pyindex 339cd0acfe..1e52b78204 100644--- a/marimo/_utils/versions.py+++ b/marimo/_utils/versions.py@@ -2,6 +2,7 @@from __future__ import annotationsimport json+import refrom 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 Nonediff --git a/tests/_runtime/packages/test_package_managers.py b/tests/_runtime/packages/test_package_managers.pyindex 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.pyindex 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 retryassert 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 Truediff --git a/tests/_utils/test_versions.py b/tests/_utils/test_versions.pynew file mode 100644index 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