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.

16.6 KB
Raw Blame
from __future__ import annotations

import asyncio
import sys
from contextlib import contextmanager
from dataclasses import dataclass
from types import ModuleType
from typing import Any
from unittest.mock import AsyncMock, patch

from marimo._ast.app import App, InternalApp
from marimo._export import _pdf_raster
from marimo._export.requests import PDFRasterizationRequest
from marimo._messaging.cell_output import CellChannel, CellOutput
from marimo._messaging.notification import CellNotification
from marimo._schemas.export_options import PDFRasterizationOptions
from marimo._session.state.session_view import SessionView


def _cell_notification(
    *,
    cell_id: str,
    mimetype: str,
    data: object,
) -> CellNotification:
    return CellNotification(
        cell_id=cell_id,
        status="idle",
        output=CellOutput(
            channel=CellChannel.OUTPUT,
            mimetype=mimetype,
            data=data,
        ),
        timestamp=0,
    )


def test_collect_raster_targets_detects_html_vega_and_anywidget() -> None:
    session_view = SessionView()
    session_view.cell_notifications["1"] = _cell_notification(
        cell_id="1",
        mimetype="text/html",
        data="<div>hello</div>",
    )
    session_view.cell_notifications["2"] = _cell_notification(
        cell_id="2",
        mimetype="application/vnd.marimo+mimebundle",
        data={
            "application/vnd.vegalite.v5+json": {"mark": "point"},
            "text/plain": "vega",
        },
    )
    session_view.cell_notifications["3"] = _cell_notification(
        cell_id="3",
        mimetype="text/markdown",
        data=(
            "&lt;marimo-anywidget "
            'data-initial-value=\'{"model_id":"model-1"}\''
            "&gt;&lt;/marimo-anywidget&gt;"
        ),
    )
    session_view.cell_notifications["4"] = _cell_notification(
        cell_id="4",
        mimetype="text/plain",
        data="plain text",
    )
    session_view.cell_notifications["5"] = _cell_notification(
        cell_id="5",
        mimetype="text/html",
        data=("<marimo-stack>application/vnd.vegalite.v6+json</marimo-stack>"),
    )

    targets = _pdf_raster._collect_raster_targets(session_view)

    by_id = {target.cell_id: target for target in targets}
    assert set(by_id) == {"2", "3", "5"}
    assert by_id["2"].expects == ("vega",)
    assert by_id["3"].expects == ("anywidget",)
    assert by_id["5"].expects == ("vega",)


def test_collect_pdf_png_fallbacks_mixed_targets_use_static_by_default() -> (
    None
):
    session_view = SessionView()
    events: list[Any] = []
    original_anywidget = (
        '&lt;marimo-anywidget data-initial-value=\'{"model_id":"m-live"}\''
        "&gt;&lt;/marimo-anywidget&gt;"
    )
    session_view.cell_notifications["1"] = _cell_notification(
        cell_id="1",
        mimetype="text/plain",
        data=original_anywidget,
    )
    session_view.cell_notifications["2"] = _cell_notification(
        cell_id="2",
        mimetype="text/html",
        data="<marimo-slider></marimo-slider>",
    )
    session_view.cell_notifications["3"] = _cell_notification(
        cell_id="3",
        mimetype="application/vnd.marimo+mimebundle",
        data={
            "application/vnd.vegalite.v6+json": {"mark": "point"},
            "text/plain": "vega",
        },
    )
    app = InternalApp(App())
    app.cell_manager.cell_ids = lambda: ["3", "2", "1"]  # type: ignore[assignment]
    live_capture_mock = AsyncMock(
        side_effect=AssertionError(
            "live capture should not run for default static mode"
        )
    )

    class _FakeServer:
        base_url = "http://127.0.0.1:1234"
        page_url = "http://127.0.0.1:1234/__marimo_pdf_raster__.html"

        def __enter__(self) -> Any:
            return self

        def __exit__(self, *args: object) -> None:
            del args

        def set_html(self, html: str) -> None:
            assert "<html" in html

    async def _capture_static(
        *,
        page_url: str,
        targets: list[_pdf_raster._RasterTarget],
        scale: float,
        status_callback: Any = None,
    ) -> dict[str, str]:
        del status_callback
        assert page_url.endswith("__marimo_pdf_raster__.html")
        assert scale == 4.0
        assert [target.cell_id for target in targets] == ["3", "2", "1"]
        return {
            "3": "data:image/png;base64,c3RhdGljMw==",
            "2": "data:image/png;base64,c3RhdGljMg==",
            "1": "data:image/png;base64,c3RhdGljMQ==",
        }

    def _fake_export_as_html(*args: Any, **kwargs: Any) -> tuple[str, str]:
        del args
        del kwargs
        return "<html></html>", "demo.html"

    async def _run() -> dict[str, str]:
        with (
            patch.object(
                _pdf_raster,
                "HtmlAssetServer",
                return_value=_FakeServer(),
            ),
            patch.object(
                _pdf_raster,
                "_capture_pngs_from_page",
                side_effect=_capture_static,
            ),
            patch.object(
                _pdf_raster,
                "_collect_live_captures",
                live_capture_mock,
            ),
            patch(
                "marimo._export.exporter.Exporter.export_as_html",
                side_effect=_fake_export_as_html,
            ),
        ):
            return await _pdf_raster.collect_pdf_png_fallbacks(
                PDFRasterizationRequest(
                    app=app,
                    session_view=session_view,
                    filename="demo.py",
                    filepath="demo.py",
                    options=PDFRasterizationOptions(),
                    status_callback=events.append,
                )
            )

    captures = asyncio.run(_run())
    assert captures == {
        "1": "data:image/png;base64,c3RhdGljMQ==",
        "2": "data:image/png;base64,c3RhdGljMg==",
        "3": "data:image/png;base64,c3RhdGljMw==",
    }
    live_capture_mock.assert_not_awaited()
    assert [(event.phase, event.message, event.total) for event in events] == [
        ("raster", "rasterizing interactive outputs...", 3)
    ]
    output = session_view.cell_notifications["1"].output
    assert output is not None
    assert output.mimetype == "text/plain"
    assert output.data == original_anywidget


def test_collect_pdf_png_fallbacks_static_only_uses_static_capture() -> None:
    session_view = SessionView()
    session_view.cell_notifications["1"] = _cell_notification(
        cell_id="1",
        mimetype="application/vnd.marimo+mimebundle",
        data={
            "application/vnd.vegalite.v6+json": {"mark": "point"},
            "text/plain": "vega",
        },
    )
    app = InternalApp(App())
    app.cell_manager.cell_ids = lambda: ["1"]  # type: ignore[assignment]

    class _FakeServer:
        base_url = "http://127.0.0.1:1234"
        page_url = "http://127.0.0.1:1234/__marimo_pdf_raster__.html"

        def __enter__(self) -> Any:
            return self

        def __exit__(self, *args: object) -> None:
            del args

        def set_html(self, html: str) -> None:
            assert "<html" in html

    async def _capture_static(
        *,
        page_url: str,
        targets: list[_pdf_raster._RasterTarget],
        scale: float,
        status_callback: Any = None,
    ) -> dict[str, str]:
        del status_callback
        assert page_url.endswith("__marimo_pdf_raster__.html")
        assert scale == 4.0
        assert [target.cell_id for target in targets] == ["1"]
        return {"1": "data:image/png;base64,c3RhdGlj"}

    live_capture_mock = AsyncMock(
        side_effect=AssertionError(
            "live capture should not run for static-only targets"
        )
    )

    def _fake_export_as_html(*args: Any, **kwargs: Any) -> tuple[str, str]:
        del args
        del kwargs
        return "<html></html>", "demo.html"

    async def _run() -> dict[str, str]:
        with (
            patch.object(
                _pdf_raster,
                "HtmlAssetServer",
                return_value=_FakeServer(),
            ),
            patch.object(
                _pdf_raster,
                "_capture_pngs_from_page",
                side_effect=_capture_static,
            ),
            patch.object(
                _pdf_raster,
                "_collect_live_captures",
                live_capture_mock,
            ),
            patch(
                "marimo._export.exporter.Exporter.export_as_html",
                side_effect=_fake_export_as_html,
            ),
        ):
            return await _pdf_raster.collect_pdf_png_fallbacks(
                PDFRasterizationRequest(
                    app=app,
                    session_view=session_view,
                    filename="demo.py",
                    filepath="demo.py",
                    options=PDFRasterizationOptions(),
                )
            )

    captures = asyncio.run(_run())
    assert captures == {"1": "data:image/png;base64,c3RhdGlj"}
    live_capture_mock.assert_not_awaited()


def test_collect_pdf_png_fallbacks_live_mode_uses_live_capture() -> None:
    session_view = SessionView()
    session_view.cell_notifications["1"] = _cell_notification(
        cell_id="1",
        mimetype="application/vnd.marimo+mimebundle",
        data={
            "application/vnd.vegalite.v6+json": {"mark": "point"},
            "text/plain": "vega",
        },
    )
    session_view.cell_notifications["2"] = _cell_notification(
        cell_id="2",
        mimetype="text/html",
        data="<marimo-slider></marimo-slider>",
    )
    app = InternalApp(App())
    app.cell_manager.cell_ids = lambda: ["2", "1"]  # type: ignore[assignment]

    static_capture_mock = AsyncMock(
        side_effect=AssertionError(
            "static capture should not run for explicit live mode"
        )
    )

    async def _capture_live(
        *,
        page_url: str,
        targets: list[_pdf_raster._RasterTarget],
        scale: float,
        status_callback: Any = None,
    ) -> dict[str, str]:
        assert page_url == "http://127.0.0.1:1234/demo"
        del scale
        del status_callback
        assert [target.cell_id for target in targets] == ["2", "1"]
        return {
            "2": "data:image/png;base64,bGl2ZTI=",
            "1": "data:image/png;base64,bGl2ZTE=",
        }

    @contextmanager
    def _live_page_url() -> Any:
        yield "http://127.0.0.1:1234/demo"

    async def _run() -> dict[str, str]:
        with (
            patch.object(
                _pdf_raster,
                "_collect_static_captures",
                static_capture_mock,
            ),
            patch.object(
                _pdf_raster,
                "_capture_pngs_from_page",
                side_effect=_capture_live,
            ),
        ):
            return await _pdf_raster.collect_pdf_png_fallbacks(
                PDFRasterizationRequest(
                    app=app,
                    session_view=session_view,
                    filename="demo.py",
                    filepath="demo.py",
                    options=PDFRasterizationOptions(server_mode="live"),
                    live_page_url=_live_page_url,
                )
            )

    captures = asyncio.run(_run())
    assert captures == {
        "1": "data:image/png;base64,bGl2ZTE=",
        "2": "data:image/png;base64,bGl2ZTI=",
    }
    static_capture_mock.assert_not_awaited()


def test_collect_pdf_png_fallbacks_does_not_open_live_page_without_targets() -> (
    None
):
    opened = False

    @contextmanager
    def _live_page_url() -> Any:
        nonlocal opened
        opened = True
        yield "http://127.0.0.1:1234/demo"

    captures = asyncio.run(
        _pdf_raster.collect_pdf_png_fallbacks(
            PDFRasterizationRequest(
                app=InternalApp(App()),
                session_view=SessionView(),
                filename="demo.py",
                filepath="demo.py",
                options=PDFRasterizationOptions(server_mode="live"),
                live_page_url=_live_page_url,
            )
        )
    )

    assert captures == {}
    assert opened is False


def test_wait_for_target_ready_uses_settle_wait_for_dynamic_targets() -> None:
    class _TimeoutError(Exception):
        pass

    page = AsyncMock()
    locator = AsyncMock()
    target = _pdf_raster._RasterTarget(
        cell_id="dynamic-cell",
        expects=("vega",),
    )

    settle_wait = AsyncMock()
    with patch.object(
        _pdf_raster,
        "_wait_for_navigation_settled",
        settle_wait,
    ):
        ready = asyncio.run(
            _pdf_raster._wait_for_target_ready(
                page=page,
                target=target,
                locator=locator,
                timeout_error=_TimeoutError,
            )
        )

    assert ready is True
    settle_wait.assert_awaited_once()


def test_capture_pngs_from_page_reports_progress_in_notebook_order() -> None:
    class _TimeoutError(Exception):
        pass

    events: list[Any] = []
    visited_locators: list[str] = []

    class _FakeLocator:
        def __init__(self, selector: str) -> None:
            self.selector = selector
            self.first = self

        async def wait_for(self, *args: Any, **kwargs: Any) -> None:
            del args, kwargs

        async def scroll_into_view_if_needed(
            self, *args: Any, **kwargs: Any
        ) -> None:
            del args, kwargs

        async def screenshot(self, *args: Any, **kwargs: Any) -> bytes:
            del args, kwargs
            return self.selector.encode("utf-8")

    class _FakePage:
        async def goto(self, *args: Any, **kwargs: Any) -> None:
            del args, kwargs

        async def wait_for_load_state(self, *args: Any, **kwargs: Any) -> None:
            del args, kwargs

        async def wait_for_function(self, *args: Any, **kwargs: Any) -> None:
            del args, kwargs

        async def evaluate(self, *args: Any, **kwargs: Any) -> None:
            del args, kwargs

        def locator(self, selector: str) -> _FakeLocator:
            visited_locators.append(selector)
            return _FakeLocator(selector)

    class _FakeContext:
        def __init__(self, page: _FakePage) -> None:
            self._page = page

        async def new_page(self) -> _FakePage:
            return self._page

        async def close(self) -> None:
            return None

    class _FakeBrowser:
        def __init__(self, context: _FakeContext) -> None:
            self._context = context

        async def new_context(self, *args: Any, **kwargs: Any) -> _FakeContext:
            del args, kwargs
            return self._context

        async def close(self) -> None:
            return None

    class _FakeChromium:
        def __init__(self, browser: _FakeBrowser) -> None:
            self._browser = browser

        async def launch(self) -> _FakeBrowser:
            return self._browser

    @dataclass
    class _FakePlaywright:
        chromium: _FakeChromium

    class _FakePlaywrightContextManager:
        def __init__(self, playwright: _FakePlaywright) -> None:
            self._playwright = playwright

        async def __aenter__(self) -> _FakePlaywright:
            return self._playwright

        async def __aexit__(self, *args: object) -> bool:
            del args
            return False

    page = _FakePage()
    context = _FakeContext(page)
    browser = _FakeBrowser(context)
    playwright = _FakePlaywright(_FakeChromium(browser))

    fake_async_api = ModuleType("playwright.async_api")
    fake_async_api.TimeoutError = _TimeoutError
    fake_async_api.async_playwright = lambda: _FakePlaywrightContextManager(
        playwright
    )
    fake_playwright = ModuleType("playwright")
    fake_playwright.async_api = fake_async_api  # type: ignore[attr-defined]

    targets = [
        _pdf_raster._RasterTarget(cell_id="2", expects=("vega",)),
        _pdf_raster._RasterTarget(cell_id="1", expects=("anywidget",)),
    ]

    with (
        patch.dict(
            sys.modules,
            {
                "playwright": fake_playwright,
                "playwright.async_api": fake_async_api,
            },
        ),
        patch.object(
            _pdf_raster,
            "_wait_for_target_ready",
            AsyncMock(return_value=True),
        ),
    ):
        captures = asyncio.run(
            _pdf_raster._capture_pngs_from_page(
                page_url="http://127.0.0.1:1234/demo.html",
                targets=targets,
                scale=2.0,
                status_callback=events.append,
            )
        )

    assert list(captures) == ["2", "1"]
    assert [(event.current, event.total) for event in events] == [
        (1, 2),
        (2, 2),
    ]
    assert visited_locators == [
        "#output-2 > .output, #output-2 > .vega-embed",
        "#output-1 > .output, #output-1 > .vega-embed",
    ]