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 sys
from unittest.mock import patch
import pytest
from marimo._dependencies.dependencies import (
Dependency,
DependencyManager,
DependencyRequirement,
_version_check,
)
from marimo._dependencies.errors import ManyModulesNotFoundError
def test_dependencies() -> None:
# Only testing 2 random dependencies
if DependencyManager.altair.has():
import altair
assert altair is not None
DependencyManager.altair.require("for testing")
assert DependencyManager.altair.imported()
assert DependencyManager.imported("altair")
if DependencyManager.pandas.has():
import pandas
assert pandas is not None
DependencyManager.pandas.require("for testing")
assert DependencyManager.pandas.imported()
assert DependencyManager.imported("pandas")
def test_without_dependencies() -> None:
missing = Dependency("missing")
assert missing is not None
assert not missing.has()
with pytest.raises(ModuleNotFoundError) as excinfo:
missing.require("for testing")
assert excinfo.value.name == "missing"
assert "for testing" in str(excinfo.value)
def test_package_name_defaults_to_pkg() -> None:
"""Test that package_name defaults to pkg when not specified."""
dep = Dependency("some_module")
assert dep.pkg_name_to_install == "some_module"
def test_package_name_used_in_require() -> None:
"""Test that package_name is used in ModuleNotFoundError."""
# When package_name differs from pkg, the error should use package_name
missing = Dependency(
"missing_module", pkg_name_to_install="missing-package"
)
assert not missing.has()
with pytest.raises(ModuleNotFoundError) as excinfo:
missing.require("for testing")
# The error name should be the package_name, not the pkg
assert excinfo.value.name == "missing-package"
def test_subpackage_cache_invalidation() -> None:
"""Test that subpackage dependencies properly invalidate importlib cache."""
# Create a dependency for a missing subpackage
missing_subpackage = Dependency("google.missing_package")
with patch("importlib.invalidate_caches") as mock_invalidate:
with pytest.raises(ModuleNotFoundError) as excinfo:
missing_subpackage.require("for testing subpackage handling")
# Verify the behavior
assert excinfo.value.name == "google.missing_package"
assert "for testing subpackage handling" in str(excinfo.value)
# Verify that invalidate_caches was called for subpackage
mock_invalidate.assert_called_once()
# Verify that the module was removed from sys.modules
assert "google.missing_package" not in sys.modules
def test_regular_package_no_cache_invalidation() -> None:
"""Test that regular packages (no dot) don't trigger cache invalidation."""
# Create a dependency for a missing regular package
missing_package = Dependency("missing_regular_package")
with patch("importlib.invalidate_caches") as mock_invalidate:
with pytest.raises(ModuleNotFoundError) as excinfo:
missing_package.require("for testing regular package")
# Verify the behavior
assert excinfo.value.name == "missing_regular_package"
assert "for testing regular package" in str(excinfo.value)
# Verify that invalidate_caches was NOT called for regular package
mock_invalidate.assert_not_called()
@pytest.mark.skipif(
not DependencyManager.altair.has(),
reason="altair is not installed",
)
def test_versions():
assert (
DependencyManager.altair.require_version(
min_version="0.0.0", max_version="10.0.0"
)
is None
)
with pytest.raises(RuntimeError) as excinfo:
DependencyManager.altair.require_version(min_version="10.0.0")
version = DependencyManager.altair.get_version()
assert (
str(excinfo.value)
== f"Mismatched version of altair: expected >=10.0.0, got {version}"
)
# Override version
assert (
DependencyManager.altair.has_at_version(
min_version="0.0.0", max_version="10.0.0"
)
is True
)
assert (
DependencyManager.altair.has_at_version(min_version="10.0.0") is False
)
with pytest.raises(RuntimeError) as excinfo:
DependencyManager.altair.require_at_version(
why="for testing", min_version="10.0.0"
)
assert (
str(excinfo.value)
== f"Mismatched version of altair: expected >=10.0.0, got {version}"
)
assert (
DependencyManager.altair.require_at_version(
why="for testing", min_version="2.0.0"
)
is None
)
def test_has_as_version_when_not_installed():
missing = Dependency("missing")
assert missing is not None
assert missing.has() is False
assert missing.has_at_version(min_version="2.0.0") is False
def test_version_check():
# within range
assert (
_version_check(pkg="test", v="1.0.0", min_v="0.0.0", max_v="2.0.0")
is True
)
assert (
_version_check(pkg="test", v="1.0.0", min_v="1.0.0", max_v="2.0.0")
is True
)
# outside range
assert (
_version_check(pkg="test", v="0.4.0", min_v="1.0.0", max_v="2.0.0")
is False
)
assert (
_version_check(pkg="test", v="2.0.0", min_v="1.0.0", max_v="2.0.0")
is False
)
# does not raise
assert (
_version_check(
pkg="test",
v="1.0.0",
min_v="1.0.0",
max_v="2.0.0",
raise_error=True,
)
is True
)
assert (
_version_check(
pkg="test",
v="1.5.0",
min_v="1.0.0",
max_v="2.0.0",
raise_error=True,
)
is True
)
# too low
with pytest.raises(RuntimeError) as excinfo:
_version_check(
pkg="test",
v="1.0.0",
min_v="2.0.0",
max_v="3.0.0",
raise_error=True,
)
assert (
str(excinfo.value)
== "Mismatched version of test: expected >=2.0.0, got 1.0.0"
)
with pytest.raises(RuntimeError) as excinfo:
_version_check(
pkg="test",
v="3.0.0",
min_v="2.0.0",
max_v="3.0.0",
raise_error=True,
)
# too high
assert (
str(excinfo.value)
== "Mismatched version of test: expected <3.0.0, got 3.0.0"
)
def test_require_many() -> None:
"""Test that require_many correctly raises ManyModulesNotFoundError."""
missing1 = Dependency("missing1")
missing2 = Dependency("missing2")
# Test with all missing dependencies
with pytest.raises(ManyModulesNotFoundError) as excinfo:
DependencyManager.require_many(
"for testing multiple dependencies",
missing1,
missing2,
source="kernel",
)
assert excinfo.value.package_names == ["missing1", "missing2"]
assert "for testing multiple dependencies" in str(excinfo.value)
def test_missing_packages_returns_unique_install_names() -> None:
missing1 = Dependency(
"missing_module1", pkg_name_to_install="missing-package"
)
missing2 = Dependency(
"missing_module2", pkg_name_to_install="missing-package"
)
available = Dependency("available")
with (
patch.object(missing1, "has", return_value=False),
patch.object(missing2, "has", return_value=False),
patch.object(available, "has", return_value=True),
):
assert DependencyManager.missing_packages(
missing1,
available,
missing2,
) == ["missing-package"]
def test_missing_packages_supports_grouped_requirement() -> None:
available = Dependency("available")
missing = Dependency("missing")
requirement = DependencyRequirement(
package="feature[extra]",
dependencies=(available, missing),
)
with (
patch.object(available, "has", return_value=True),
patch.object(missing, "has", return_value=False),
):
assert DependencyManager.missing_packages(requirement) == [
"feature[extra]"
]
def test_require_many_uses_package_name() -> None:
"""Test that require_many uses package_name when specified."""
missing1 = Dependency(
"missing_module1", pkg_name_to_install="missing-package-1"
)
missing2 = Dependency(
"missing_module2", pkg_name_to_install="missing-package-2"
)
with pytest.raises(ManyModulesNotFoundError) as excinfo:
DependencyManager.require_many(
"for testing package names",
missing1,
missing2,
source="kernel",
)
# Should use package_name, not pkg
assert excinfo.value.package_names == [
"missing-package-1",
"missing-package-2",
]
# Test with some dependencies available (if pandas is installed)
if DependencyManager.pandas.has():
with pytest.raises(ManyModulesNotFoundError) as excinfo:
DependencyManager.require_many(
"for testing mixed dependencies",
DependencyManager.pandas,
missing1,
source="kernel",
)
assert excinfo.value.package_names == ["missing-package-1"]
assert "for testing mixed dependencies" in str(excinfo.value)
# Test with all dependencies available
result = DependencyManager.require_many(
"for testing available dependencies",
DependencyManager.pandas,
source="kernel",
)
assert result is None