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
# Copyright 2026 Marimo. All rights reserved.
from __future__ import annotations
from unittest.mock import ANY, Mock
import pytest
from marimo._dependencies.dependencies import DependencyManager
from marimo._plugins.ui._impl.from_panel import (
_extract_holoviews_settings,
panel,
render_extension,
)
from marimo._runtime.runtime import Kernel
from tests.conftest import ExecReqProvider
HAS_DEPS = DependencyManager.panel.has()
HAS_HOLOVIEWS = DependencyManager.holoviews.has()
if HAS_DEPS:
import panel as pn
else:
pn = Mock()
@pytest.mark.skipif(not HAS_DEPS, reason="optional dependencies not installed")
class TestPanel:
@staticmethod
async def test_instances(k: Kernel, exec_req: ExecReqProvider) -> None:
await k.run(
[
exec_req.get(
"""
import panel as pn
import marimo as mo
slider = pn.widgets.IntSlider(start=0, end=10, value=5)
slider = mo.ui.panel(slider)
"""
)
]
)
@staticmethod
@pytest.mark.parametrize(
("panel_version", "modern_loader"),
[
("1.9.0", False),
("1.9.4", False),
("1.10.0", True),
("1.11.0rc1", True),
("1.11.0", True),
],
)
def test_extension_loader_compatibility(
monkeypatch: pytest.MonkeyPatch,
panel_version: str,
modern_loader: bool,
) -> None:
from panel.io import notebook
configs: list[dict[str, object]] = []
requirements = ["example"]
exports = {"example": "Example"}
skip_imports = {"Example": ["example.js"]}
require_skip = ["bundled-example.js"]
get_version = Mock(return_value=panel_version)
monkeypatch.setattr(
DependencyManager.panel, "get_version", get_version
)
def legacy_components() -> tuple[object, ...]:
return configs, requirements, exports, skip_imports
def modern_components(resources: object) -> tuple[object, ...]:
assert resources is not None
return (*legacy_components(), require_skip)
monkeypatch.setattr(
notebook,
"require_components",
modern_components if modern_loader else legacy_components,
)
autoload = Mock(return_value="extension JavaScript")
monkeypatch.setattr(notebook, "_autoload_js", autoload)
assert render_extension(load_timeout=123) == "extension JavaScript"
get_version.assert_called_once_with()
expected: dict[str, object] = {
"bundle": ANY,
"configs": configs,
"requirements": requirements,
"exports": exports,
"skip_imports": skip_imports,
"ipywidget": ANY,
"reloading": False,
"load_timeout": 123,
}
if modern_loader:
expected.update(require_skip=require_skip, error_id=None)
autoload.assert_called_once_with(**expected)
@staticmethod
def test_proxy_attributes() -> None:
slider = pn.widgets.IntSlider(start=0, end=10, value=5)
wrapped = panel(slider)
# Test attribute access
assert (
wrapped.value == {}
) # slider gets wrapped in a row, so it's value is empty
assert wrapped.start == 0
assert wrapped.end == 10
# Test attribute modification
wrapped.value = 7
assert (
wrapped.value == {}
) # slider gets wrapped in a row, so it's value is empty
assert slider.value == 7
@staticmethod
def test_layout_components() -> None:
row = panel(pn.Row("Test"))
col = panel(pn.Column("Test"))
tabs = panel(pn.Tabs(("Tab1", "Content")))
assert isinstance(row, panel)
assert isinstance(col, panel)
assert isinstance(tabs, panel)
@staticmethod
def test_any_object() -> None:
assert panel({}) is not None
assert panel([]) is not None
assert panel(()) is not None
assert panel(1) is not None
assert panel("test") is not None
assert panel(True) is not None
assert panel(False) is not None
assert panel(None) is not None
@staticmethod
def test_extension_served_as_virtual_file(
executing_kernel: Kernel,
) -> None:
# The extension JS must be served via a `./@file/...` virtual file
# path rather than inlined as a `data-extension` attribute. This is
# what lets the frontend refuse to execute attacker-controlled
# scripts embedded in markdown via raw <marimo-panel> elements.
del executing_kernel # fixture installs the runtime context
slider = pn.widgets.IntSlider(start=0, end=10, value=5)
element = panel(slider)
text = element.text
assert "data-extension-url=" in text
assert "data-extension=" not in text
# The extension URL must be a virtual file path; absolute or data:
# URLs would let raw-HTML attackers load arbitrary JavaScript.
assert "@file/" in text
@pytest.mark.skipif(not HAS_HOLOVIEWS, reason="holoviews not installed")
class TestHoloViewsSettings:
@staticmethod
def test_extract_holoviews_settings_with_widget_location() -> None:
"""Test that widget_location is extracted from holoviews renderer."""
import holoviews as hv
# Set up holoviews with bokeh backend
hv.extension("bokeh")
hv.output(widget_location="top")
# Create a simple holoviews object
curve = hv.Curve([1, 2, 3])
# Extract settings
settings = _extract_holoviews_settings(curve)
# Verify widget_location is extracted
assert "widget_location" in settings
assert settings["widget_location"] == "top"
@staticmethod
def test_extract_holoviews_settings_with_center() -> None:
"""Test that center is extracted from holoviews renderer."""
import holoviews as hv
# Set up holoviews with bokeh backend
hv.extension("bokeh")
hv.output(center=True)
# Create a simple holoviews object
curve = hv.Curve([1, 2, 3])
# Extract settings
settings = _extract_holoviews_settings(curve)
# Verify center is extracted
assert "center" in settings
assert settings["center"] is True
@staticmethod
def test_extract_holoviews_settings_non_holoviews_object() -> None:
"""Test that non-holoviews objects return empty dict."""
# Test with regular objects
assert _extract_holoviews_settings({}) == {}
assert _extract_holoviews_settings([1, 2, 3]) == {}
assert _extract_holoviews_settings("test") == {}
@staticmethod
def test_extract_holoviews_settings_no_widget_location() -> None:
"""Test extraction when widget_location is not set (None)."""
import holoviews as hv
# Set up holoviews with bokeh backend but no widget_location
hv.extension("bokeh")
# Get the renderer and ensure widget_location is None
renderer = hv.renderer("bokeh")
renderer.widget_location = None
# Create a simple holoviews object
curve = hv.Curve([1, 2, 3])
# Extract settings
settings = _extract_holoviews_settings(curve)
# Verify that None values are not included
assert "widget_location" not in settings
@pytest.mark.skipif(
not (HAS_DEPS and HAS_HOLOVIEWS),
reason="panel and holoviews not installed",
)
class TestPanelWithHoloViews:
@staticmethod
def test_panel_respects_holoviews_output_settings() -> None:
"""Test that panel() passes holoviews settings to Panel pane."""
import holoviews as hv
# Set up holoviews with specific settings
hv.extension("bokeh")
hv.output(widget_location="bottom")
# Create a holoviews object
curve = hv.Curve([1, 2, 3])
# Wrap in panel
wrapped = panel(curve)
# The wrapped object should be a Panel pane
# We can't directly check if widget_location was passed,
# but we can verify the object was created successfully
assert wrapped is not None
assert isinstance(wrapped, panel)