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
feat: status indicator for PDF exports via CLI (#9322)
Péter Gyarmati8a1f565da405
diff --git a/marimo/_cli/export/commands.py b/marimo/_cli/export/commands.pyindex d832a464f3..b4d084a251 100644--- a/marimo/_cli/export/commands.py+++ b/marimo/_cli/export/commands.py@@ -33,6 +33,7 @@ from marimo._server.export import (run_app_then_export_as_ipynb,run_app_then_export_as_pdf,)+from marimo._server.export._status import PDFExportStatusEventfrom marimo._server.export.exporter import Exporterfrom marimo._server.utils import asyncio_runfrom marimo._utils.file_watcher import FileWatcher@@ -61,6 +62,20 @@ def export() -> None:pass+class _PDFExportCLIReporter:+ def __call__(self, event: PDFExportStatusEvent) -> None:+ message = event.message+ if event.current is not None and event.total is not None:+ progress = f" [{event.current}/{event.total}]"+ if message.endswith("..."):+ message = f"{message[:-3]}{progress}..."+ elif message.endswith("."):+ message = f"{message[:-1]}{progress}."+ else:+ message = f"{message}{progress}"+ echo(f"{green('Exporting PDF', bold=True)}: {message}", err=True)++def watch_and_export(marimo_path: MarimoPath,output: Path | None,@@ -735,6 +750,7 @@ def pdf(scale=raster_scale,server_mode=raster_server,)+ report_status = _PDFExportCLIReporter()def export_callback(file_path: MarimoPath,@@ -750,6 +766,7 @@ def pdf(cli_args=cli_args,argv=list(args) if include_outputs else None,rasterization_options=rasterization_options,+ status_callback=report_status,))except ModuleNotFoundError as e:diff --git a/marimo/_server/export/__init__.py b/marimo/_server/export/__init__.pyindex 5aa5ee0ed2..0d3a76a337 100644--- a/marimo/_server/export/__init__.py+++ b/marimo/_server/export/__init__.py@@ -31,6 +31,7 @@ from marimo._output.hypertext import patch_html_for_non_interactive_outputfrom marimo._runtime.commands import AppMetadata, SerializedCLIArgsfrom marimo._runtime.patches import extract_docstring_from_headerfrom marimo._schemas.serialization import NotebookSerialization+from marimo._server.export._status import emit_pdf_export_statusfrom marimo._server.export.exporter import Exporterfrom marimo._server.file_router import AppFileRouterfrom marimo._server.models.export import (@@ -49,6 +50,7 @@ if TYPE_CHECKING:from collections.abc import Mappingfrom marimo._server.export._pdf_raster import PDFRasterizationOptions+ from marimo._server.export._status import PDFExportStatusCallbackfrom marimo._session.state.session_view import SessionViewfrom marimo._session.types import Sessionfrom marimo._types.ids import CellId_t@@ -242,6 +244,7 @@ async def run_app_then_export_as_pdf(export_as: ExportPDFPreset | None,include_inputs: bool = True,rasterization_options: PDFRasterizationOptions | None = None,+ status_callback: PDFExportStatusCallback | None = None,) -> tuple[bytes | None, bool]:file_router = AppFileRouter.from_filename(filepath)file_key = file_router.get_unique_file_key()@@ -253,6 +256,11 @@ async def run_app_then_export_as_pdf(did_error = Falseif include_outputs:+ emit_pdf_export_status(+ status_callback,+ phase="execute",+ message="executing notebook...",+ )with patch_html_for_non_interactive_output():# Using quiet=True to suppress runtime stdout/stderr since outputs# are captured in the session_view and will be included in the PDF@@ -262,6 +270,11 @@ async def run_app_then_export_as_pdf(argv,quiet=True,)+ emit_pdf_export_status(+ status_callback,+ phase="execute_complete",+ message="notebook execution finished.",+ )if (session_view is not None@@ -279,7 +292,13 @@ async def run_app_then_export_as_pdf(filepath=filepath.absolute_name,argv=argv,options=rasterization_options,+ status_callback=status_callback,)+ emit_pdf_export_status(+ status_callback,+ phase="prepare",+ message="serializing notebook for PDF rendering...",+ )exporter = Exporter()if export_as == "slides":pdf_data = await exporter.export_as_slides_pdf(@@ -287,6 +306,7 @@ async def run_app_then_export_as_pdf(session_view=session_view,png_fallbacks=png_fallbacks,include_inputs=include_inputs,+ status_callback=status_callback,)else:pdf_data = exporter.export_as_pdf(@@ -295,6 +315,13 @@ async def run_app_then_export_as_pdf(png_fallbacks=png_fallbacks,include_inputs=include_inputs,webpdf=webpdf,+ status_callback=status_callback,+ )+ if pdf_data is not None:+ emit_pdf_export_status(+ status_callback,+ phase="complete",+ message="done.",)return pdf_data, did_errordiff --git a/marimo/_server/export/_pdf_raster.py b/marimo/_server/export/_pdf_raster.pyindex ebba894f0d..2b98ea9bd9 100644--- a/marimo/_server/export/_pdf_raster.py+++ b/marimo/_server/export/_pdf_raster.py@@ -19,6 +19,7 @@ from marimo._server.export._raster_mime import (TEXT_PLAIN,VEGA_MIME_TYPES,)+from marimo._server.export._status import emit_pdf_export_statusfrom marimo._server.models.export import ExportAsHTMLRequestfrom marimo._types.ids import CellId_tfrom marimo._utils.paths import marimo_package_path@@ -27,6 +28,7 @@ if TYPE_CHECKING:from collections.abc import Sequencefrom marimo._ast.app import InternalApp+ from marimo._server.export._status import PDFExportStatusCallbackfrom marimo._session.state.session_view import SessionViewLOGGER = _loggers.marimo_logger()@@ -332,6 +334,7 @@ async def _collect_static_captures(filepath: str | None,options: PDFRasterizationOptions,static_targets: list[_RasterTarget],+ status_callback: PDFExportStatusCallback | None = None,) -> dict[CellId_t, str]:"""Capture PNG fallbacks from exported static HTML for non-live targets."""@@ -369,6 +372,7 @@ async def _collect_static_captures(page_url=server.page_url,targets=static_targets,scale=options.scale,+ status_callback=status_callback,)LOGGER.debug("Raster capture static phase complete: %s/%s captured",@@ -384,6 +388,7 @@ async def _collect_live_captures(argv: list[str] | None,options: PDFRasterizationOptions,live_targets: list[_RasterTarget],+ status_callback: PDFExportStatusCallback | None = None,) -> dict[CellId_t, str]:"""Capture PNG fallbacks from a live notebook runtime when required."""@@ -403,6 +408,7 @@ async def _collect_live_captures(targets=live_targets,scale=options.scale,argv=argv,+ status_callback=status_callback,)LOGGER.debug("Raster capture live phase complete: %s/%s captured",@@ -420,6 +426,7 @@ async def collect_pdf_png_fallbacks(filepath: str | None,argv: list[str] | None = None,options: PDFRasterizationOptions,+ status_callback: PDFExportStatusCallback | None = None,) -> dict[CellId_t, str]:"""Collect per-cell PNG fallbacks to inject before nbconvert PDF export."""@@ -454,6 +461,12 @@ async def collect_pdf_png_fallbacks(server_mode,options.scale,)+ emit_pdf_export_status(+ status_callback,+ phase="raster",+ message="rasterizing interactive outputs...",+ total=len(targets),+ )if server_mode == "live":LOGGER.debug("Raster capture strategy: live-only.")@@ -462,6 +475,7 @@ async def collect_pdf_png_fallbacks(argv=argv,options=options,live_targets=targets,+ status_callback=status_callback,)else:LOGGER.debug("Raster capture strategy: static-only.")@@ -472,6 +486,7 @@ async def collect_pdf_png_fallbacks(filepath=filepath,options=options,static_targets=targets,+ status_callback=status_callback,)LOGGER.debug(@@ -564,6 +579,7 @@ async def _capture_pngs_from_page(page_url: str,targets: list[_RasterTarget],scale: float,+ status_callback: PDFExportStatusCallback | None = None,) -> dict[CellId_t, str]:"""Capture PNG screenshots for target outputs from a single page URL."""@@ -622,6 +638,13 @@ async def _capture_pngs_from_page(LOGGER.debug("Page network idle, starting target captures...")for index, target in enumerate(targets, start=1):+ emit_pdf_export_status(+ status_callback,+ phase="raster",+ message="rasterizing interactive outputs...",+ current=index,+ total=len(targets),+ )LOGGER.info("Rasterizing [%s/%s] cell=%s (%s)",index,@@ -693,6 +716,7 @@ async def _capture_pngs_from_live_page(targets: list[_RasterTarget],scale: float,argv: list[str] | None,+ status_callback: PDFExportStatusCallback | None = None,) -> dict[CellId_t, str]:"""Capture outputs by running notebook in a live marimo server process."""@@ -701,4 +725,5 @@ async def _capture_pngs_from_live_page(page_url=server.page_url,targets=targets,scale=scale,+ status_callback=status_callback,)diff --git a/marimo/_server/export/_status.py b/marimo/_server/export/_status.pynew file mode 100644index 0000000000..a2d84ce82d--- /dev/null+++ b/marimo/_server/export/_status.py@@ -0,0 +1,55 @@+# Copyright 2026 Marimo. All rights reserved.+from __future__ import annotations++from collections.abc import Callable+from dataclasses import dataclass+from typing import Literal++from marimo import _loggers++LOGGER = _loggers.marimo_logger()++PDFExportPhase = Literal[+ "execute",+ "execute_complete",+ "raster",+ "prepare",+ "render",+ "render_fallback",+ "complete",+]+++@dataclass(frozen=True)+class PDFExportStatusEvent:+ phase: PDFExportPhase+ message: str+ current: int | None = None+ total: int | None = None+++PDFExportStatusCallback = Callable[[PDFExportStatusEvent], None]+++def emit_pdf_export_status(+ status_callback: PDFExportStatusCallback | None,+ *,+ phase: PDFExportPhase,+ message: str,+ current: int | None = None,+ total: int | None = None,+) -> None:+ if status_callback is None:+ return++ try:+ status_callback(+ PDFExportStatusEvent(+ phase=phase,+ message=message,+ current=current,+ total=total,+ )+ )+ except Exception as e:+ LOGGER.debug("PDF export status callback failed: %s", e, exc_info=e)diff --git a/marimo/_server/export/exporter.py b/marimo/_server/export/exporter.pyindex c39bbef951..410827710c 100644--- a/marimo/_server/export/exporter.py+++ b/marimo/_server/export/exporter.py@@ -31,6 +31,7 @@ from marimo._messaging.mimetypes import KnownMimeTypefrom marimo._runtime.virtual_file import read_virtual_filefrom marimo._schemas.notebook import NotebookV1from marimo._schemas.session import NotebookSessionV1+from marimo._server.export._status import emit_pdf_export_statusfrom marimo._server.models.export import ExportAsHTMLRequestfrom marimo._server.templates.templates import (static_notebook_template,@@ -53,6 +54,8 @@ from marimo._version import __version__if TYPE_CHECKING:from collections.abc import Mapping+ from marimo._server.export._status import PDFExportStatusCallback+LOGGER = _loggers.marimo_logger()# Root directory for static assets@@ -361,6 +364,7 @@ class Exporter:png_fallbacks: Mapping[CellId_t, str] | None = None,webpdf: bool,include_inputs: bool = True,+ status_callback: PDFExportStatusCallback | None = None,) -> bytes | None:"""Export notebook as a PDF.@@ -370,6 +374,8 @@ class Exporter:png_fallbacks: Optional cell-id keyed image/png fallbacks toinject into notebook outputs before nbconvert.include_inputs: Whether to include code cell inputs in the export.+ status_callback: Optional internal callback for CLI-only PDF+ export stage updates.webpdf: If False, tries standard PDF export (pandoc + TeX) first,falling back to webpdf on failure. If True, uses webpdfdirectly.@@ -415,12 +421,26 @@ class Exporter:PandocMissing,)+ def _emit_webpdf_fallback_status() -> None:+ emit_pdf_export_status(+ status_callback,+ phase="render_fallback",+ message=(+ "standard PDF export failed; falling back to WebPDF..."+ ),+ )+if not webpdf:try:from nbconvert import ( # type: ignore[import-not-found]PDFExporter,)+ emit_pdf_export_status(+ status_callback,+ phase="render",+ message="rendering PDF via standard exporter...",+ )exporter = PDFExporter() # type: ignore[no-untyped-call]exporter.exclude_input = not include_inputspdf_data, _resources = exporter.from_notebook_node(notebook) # type: ignore[no-untyped-call]@@ -430,16 +450,19 @@ class Exporter:return Noneexcept OSError as e:# LatexFailed (IOError) or xelatex not on PATH+ _emit_webpdf_fallback_status()LOGGER.info("Standard PDF export failed, falling back to webpdf: %s",e,)except (PandocMissing, ConversionException) as e:+ _emit_webpdf_fallback_status()LOGGER.info("Standard PDF export failed, falling back to webpdf: %s",e,)except Exception as e:+ _emit_webpdf_fallback_status()LOGGER.error("Standard PDF export failed, falling back to webpdf.",exc_info=e,@@ -447,6 +470,11 @@ class Exporter:from nbconvert import WebPDFExporter+ emit_pdf_export_status(+ status_callback,+ phase="render",+ message="rendering PDF via WebPDF...",+ )web_exporter = WebPDFExporter() # type: ignore[no-untyped-call]web_exporter.exclude_input = not include_inputsweb_exporter.allow_chromium_download = True@@ -464,6 +492,7 @@ class Exporter:session_view: SessionView | None,png_fallbacks: Mapping[CellId_t, str] | None = None,include_inputs: bool = True,+ status_callback: PDFExportStatusCallback | None = None,) -> bytes | None:"""Export a slides notebook as PDF using reveal.js + Playwright.@@ -481,6 +510,8 @@ class Exporter:png_fallbacks: Optional cell-id keyed image/png fallbacks toinject into notebook outputs before conversion.include_inputs: Whether to include code cell inputs.+ status_callback: Optional internal callback for CLI-only PDF+ export stage updates.Returns:PDF data@@ -509,6 +540,11 @@ class Exporter:notebook,png_fallbacks=png_fallbacks,)+ emit_pdf_export_status(+ status_callback,+ phase="render",+ message="rendering slides PDF...",+ )return await self._export_slides_as_pdf(notebook, include_inputs)@staticmethoddiff --git a/tests/_cli/test_cli_export.py b/tests/_cli/test_cli_export.pyindex a5563852bc..632fe372d4 100644--- a/tests/_cli/test_cli_export.py+++ b/tests/_cli/test_cli_export.py@@ -1246,6 +1246,97 @@ class TestExportPDF:call_kwargs = mock_run_app.await_args.kwargsassert call_kwargs["export_as"] is None+ @staticmethod+ def test_export_pdf_reports_stage_status_updates(+ temp_marimo_file: str,+ tmp_path: Path,+ ) -> None:+ from unittest.mock import AsyncMock, patch++ from marimo._cli.export.commands import pdf as pdf_command+ from marimo._server.export._status import PDFExportStatusEvent++ output_file = tmp_path / "status.pdf"+ runner = CliRunner()++ async def fake_run_app(+ *args: Any, **kwargs: Any+ ) -> tuple[bytes, bool]:+ del args+ status_callback = kwargs["status_callback"]+ status_callback(+ PDFExportStatusEvent(+ phase="execute",+ message="executing notebook...",+ )+ )+ status_callback(+ PDFExportStatusEvent(+ phase="raster",+ message="rasterizing interactive outputs...",+ current=2,+ total=7,+ )+ )+ status_callback(+ PDFExportStatusEvent(+ phase="prepare",+ message="serializing notebook for PDF rendering...",+ )+ )+ status_callback(+ PDFExportStatusEvent(+ phase="render",+ message="rendering PDF via WebPDF...",+ )+ )+ status_callback(+ PDFExportStatusEvent(+ phase="complete",+ message="done.",+ )+ )+ return b"mock_pdf", False++ mock_run_app = AsyncMock(side_effect=fake_run_app)++ with (+ patch(+ "marimo._cli.export.commands.DependencyManager.require_many"+ ),+ patch(+ "marimo._cli.export.commands.DependencyManager.playwright.require"+ ),+ patch(+ "marimo._cli.export.commands.run_app_then_export_as_pdf",+ mock_run_app,+ ),+ ):+ result = runner.invoke(+ pdf_command,+ [+ "--output",+ str(output_file),+ "--no-sandbox",+ temp_marimo_file,+ ],+ )++ assert result.exit_code == 0+ assert output_file.read_bytes() == b"mock_pdf"+ assert "Exporting PDF: executing notebook..." in result.output+ assert (+ "Exporting PDF: rasterizing interactive outputs [2/7]..."+ in result.output+ )+ assert (+ "Exporting PDF: serializing notebook for PDF rendering..."+ in result.output+ )+ assert "Exporting PDF: rendering PDF via WebPDF..." in result.output+ assert "Exporting PDF: done." in result.output+ assert mock_run_app.await_count == 1+@pytest.mark.skipif(not DependencyManager.playwright.has(),diff --git a/tests/_server/export/test_exporter.py b/tests/_server/export/test_exporter.pyindex 39758ef8bd..51fc7dc2e4 100644--- a/tests/_server/export/test_exporter.py+++ b/tests/_server/export/test_exporter.py@@ -20,8 +20,10 @@ from marimo._messaging.msgspec_encoder import encode_json_strfrom marimo._messaging.notification import CellNotificationfrom marimo._server.export import (export_as_wasm,+ run_app_then_export_as_pdf,run_app_until_completion,)+from marimo._server.export._status import PDFExportStatusEventfrom marimo._server.export.exporter import Exporterfrom marimo._server.models.export import ExportAsHTMLRequestfrom marimo._session.notebook import AppFileManager@@ -1076,6 +1078,213 @@ class TestPDFExport:assert "for PDF export" in str(excinfo.value)+ @pytest.mark.asyncio+ async def test_run_app_then_export_as_pdf_reports_execute_raster_render(+ self,+ temp_marimo_file: str,+ session_view: SessionView,+ ) -> None:+ events: list[PDFExportStatusEvent] = []++ async def fake_run_app_until_completion(+ *args: Any, **kwargs: Any+ ) -> tuple[SessionView, bool]:+ del args, kwargs+ return session_view, False++ async def fake_collect_pdf_png_fallbacks(+ *args: Any, **kwargs: Any+ ) -> dict[str, str]:+ del args+ status_callback = kwargs["status_callback"]+ assert status_callback is not None+ status_callback(+ PDFExportStatusEvent(+ phase="raster",+ message="rasterizing interactive outputs...",+ total=2,+ )+ )+ status_callback(+ PDFExportStatusEvent(+ phase="raster",+ message="rasterizing interactive outputs...",+ current=1,+ total=2,+ )+ )+ return {"cell-1": "data:image/png;base64,ZmFrZQ=="}++ def fake_export_as_pdf(+ self: Exporter, *args: Any, **kwargs: Any+ ) -> bytes:+ del self, args+ status_callback = kwargs["status_callback"]+ assert status_callback is not None+ status_callback(+ PDFExportStatusEvent(+ phase="render",+ message="rendering PDF via WebPDF...",+ )+ )+ return b"mock_pdf"++ with (+ patch(+ "marimo._server.export.run_app_until_completion",+ side_effect=fake_run_app_until_completion,+ ),+ patch(+ "marimo._server.export._pdf_raster.collect_pdf_png_fallbacks",+ side_effect=fake_collect_pdf_png_fallbacks,+ ),+ patch.object(+ Exporter,+ "export_as_pdf",+ autospec=True,+ side_effect=fake_export_as_pdf,+ ),+ ):+ pdf_data, did_error = await run_app_then_export_as_pdf(+ MarimoPath(temp_marimo_file),+ include_outputs=True,+ webpdf=True,+ cli_args={},+ argv=None,+ export_as=None,+ rasterization_options=MagicMock(enabled=True),+ status_callback=events.append,+ )++ assert pdf_data == b"mock_pdf"+ assert did_error is False+ assert [event.phase for event in events] == [+ "execute",+ "execute_complete",+ "raster",+ "raster",+ "prepare",+ "render",+ "complete",+ ]+ assert [event.message for event in events] == [+ "executing notebook...",+ "notebook execution finished.",+ "rasterizing interactive outputs...",+ "rasterizing interactive outputs...",+ "serializing notebook for PDF rendering...",+ "rendering PDF via WebPDF...",+ "done.",+ ]++ @pytest.mark.asyncio+ async def test_run_app_then_export_as_pdf_reports_render_only_without_outputs(+ self,+ temp_marimo_file: str,+ ) -> None:+ events: list[PDFExportStatusEvent] = []++ def fake_export_as_pdf(+ self: Exporter, *args: Any, **kwargs: Any+ ) -> bytes:+ del self, args+ status_callback = kwargs["status_callback"]+ assert status_callback is not None+ status_callback(+ PDFExportStatusEvent(+ phase="render",+ message="rendering PDF via standard exporter...",+ )+ )+ return b"mock_pdf"++ with (+ patch(+ "marimo._server.export.run_app_until_completion",+ side_effect=AssertionError(+ "execution should not run without outputs"+ ),+ ),+ patch(+ "marimo._server.export._pdf_raster.collect_pdf_png_fallbacks",+ side_effect=AssertionError(+ "rasterization should not run without outputs"+ ),+ ),+ patch.object(+ Exporter,+ "export_as_pdf",+ autospec=True,+ side_effect=fake_export_as_pdf,+ ),+ ):+ pdf_data, did_error = await run_app_then_export_as_pdf(+ MarimoPath(temp_marimo_file),+ include_outputs=False,+ webpdf=False,+ cli_args={},+ argv=None,+ export_as=None,+ rasterization_options=MagicMock(enabled=False),+ status_callback=events.append,+ )++ assert pdf_data == b"mock_pdf"+ assert did_error is False+ assert [(event.phase, event.message) for event in events] == [+ ("prepare", "serializing notebook for PDF rendering..."),+ ("render", "rendering PDF via standard exporter..."),+ ("complete", "done."),+ ]++ @pytest.mark.asyncio+ async def test_run_app_then_export_as_pdf_ignores_status_callback_failures(+ self,+ temp_marimo_file: str,+ ) -> None:+ def failing_status_callback(event: PDFExportStatusEvent) -> None:+ raise RuntimeError(f"boom:{event.phase}")++ def fake_export_as_pdf(+ self: Exporter, *args: Any, **kwargs: Any+ ) -> bytes:+ del self, args, kwargs+ return b"mock_pdf"++ with (+ patch(+ "marimo._server.export.run_app_until_completion",+ side_effect=AssertionError(+ "execution should not run without outputs"+ ),+ ),+ patch(+ "marimo._server.export._pdf_raster.collect_pdf_png_fallbacks",+ side_effect=AssertionError(+ "rasterization should not run without outputs"+ ),+ ),+ patch.object(+ Exporter,+ "export_as_pdf",+ autospec=True,+ side_effect=fake_export_as_pdf,+ ),+ ):+ pdf_data, did_error = await run_app_then_export_as_pdf(+ MarimoPath(temp_marimo_file),+ include_outputs=False,+ webpdf=False,+ cli_args={},+ argv=None,+ export_as=None,+ rasterization_options=MagicMock(enabled=False),+ status_callback=failing_status_callback,+ )++ assert pdf_data == b"mock_pdf"+ assert did_error is False+@pytest.mark.skipif(not DependencyManager.nbformat.has()or not DependencyManager.nbconvert.has()@@ -1410,6 +1619,61 @@ class TestPDFExport:mock_pdf_exporter.assert_called_once()mock_webpdf_exporter.assert_called_once()+ @pytest.mark.skipif(+ not DependencyManager.nbformat.has()+ or not DependencyManager.nbconvert.has(),+ reason="nbformat or nbconvert not installed",+ )+ def test_export_as_pdf_reports_status_during_fallback_to_webpdf(+ self,+ session_view: SessionView,+ ) -> None:+ app = App()++ @app.cell()+ def test_cell():+ return "test"++ file_manager = AppFileManager.from_app(InternalApp(app))+ exporter = Exporter()+ events: list[PDFExportStatusEvent] = []++ mock_pdf_exporter_instance = MagicMock()+ mock_pdf_exporter_instance.from_notebook_node.side_effect = OSError(+ "xelatex not found"+ )++ mock_webpdf_exporter_instance = MagicMock()+ mock_webpdf_exporter_instance.from_notebook_node.return_value = (+ b"fallback_webpdf_data",+ {},+ )++ with (+ patch.object(DependencyManager, "require_many"),+ patch("nbconvert.PDFExporter") as mock_pdf_exporter,+ patch("nbconvert.WebPDFExporter") as mock_webpdf_exporter,+ ):+ mock_pdf_exporter.return_value = mock_pdf_exporter_instance+ mock_webpdf_exporter.return_value = mock_webpdf_exporter_instance++ result = exporter.export_as_pdf(+ app=file_manager.app,+ session_view=session_view,+ webpdf=False,+ status_callback=events.append,+ )++ assert result == b"fallback_webpdf_data"+ assert [(event.phase, event.message) for event in events] == [+ ("render", "rendering PDF via standard exporter..."),+ (+ "render_fallback",+ "standard PDF export failed; falling back to WebPDF...",+ ),+ ("render", "rendering PDF via WebPDF..."),+ ]+@pytest.mark.skipif(not DependencyManager.nbformat.has(),reason="nbformat not installed",@@ -1472,12 +1736,17 @@ class TestPDFExport:DependencyManager.playwright, "has", return_value=True),):+ events: list[PDFExportStatusEvent] = []result = await exporter.export_as_slides_pdf(app=file_manager.app,session_view=session_view,+ status_callback=events.append,)assert result == b"mock_slides_pdf_data"+ assert [(event.phase, event.message) for event in events] == [+ ("render", "rendering slides PDF...")+ ]mock_slides_exporter_cls.assert_called_once()mock_slides_exporter_instance.from_notebook_node.assert_called_once()notebook = (diff --git a/tests/_server/export/test_pdf_raster.py b/tests/_server/export/test_pdf_raster.pyindex ae1b24a93a..b2ed84c6ae 100644--- a/tests/_server/export/test_pdf_raster.py+++ b/tests/_server/export/test_pdf_raster.py@@ -1,6 +1,9 @@from __future__ import annotationsimport asyncio+import sys+from dataclasses import dataclass+from types import ModuleTypefrom typing import Anyfrom unittest.mock import AsyncMock, patch@@ -77,6 +80,7 @@ def test_collect_pdf_png_fallbacks_mixed_targets_use_static_by_default() -> (None):session_view = SessionView()+ events: list[Any] = []original_anywidget = ('<marimo-anywidget data-initial-value=\'{"model_id":"m-live"}\''"></marimo-anywidget>"@@ -125,7 +129,9 @@ def test_collect_pdf_png_fallbacks_mixed_targets_use_static_by_default() -> (page_url: str,targets: list[_pdf_raster._RasterTarget],scale: float,+ status_callback: Any = None,) -> dict[str, str]:+ del status_callbackassert page_url.endswith("__marimo_pdf_raster__.html")assert scale == 4.0assert [target.cell_id for target in targets] == ["3", "2", "1"]@@ -169,6 +175,7 @@ def test_collect_pdf_png_fallbacks_mixed_targets_use_static_by_default() -> (filepath="demo.py",argv=["--arg", "value"],options=_pdf_raster.PDFRasterizationOptions(),+ status_callback=events.append,)captures = asyncio.run(_run())@@ -178,6 +185,9 @@ def test_collect_pdf_png_fallbacks_mixed_targets_use_static_by_default() -> ("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"].outputassert output is not Noneassert output.mimetype == "text/plain"@@ -215,7 +225,9 @@ def test_collect_pdf_png_fallbacks_static_only_uses_static_capture() -> None:page_url: str,targets: list[_pdf_raster._RasterTarget],scale: float,+ status_callback: Any = None,) -> dict[str, str]:+ del status_callbackassert page_url.endswith("__marimo_pdf_raster__.html")assert scale == 4.0assert [target.cell_id for target in targets] == ["1"]@@ -297,10 +309,12 @@ def test_collect_pdf_png_fallbacks_live_mode_uses_live_capture() -> None:targets: list[_pdf_raster._RasterTarget],scale: float,argv: list[str] | None,+ status_callback: Any = None,) -> dict[str, str]:del filepathdel scaledel argv+ del status_callbackassert [target.cell_id for target in targets] == ["2", "1"]return {"2": "data:image/png;base64,bGl2ZTI=",@@ -366,3 +380,139 @@ def test_wait_for_target_ready_uses_settle_wait_for_dynamic_targets() -> None:assert ready is Truesettle_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: Any) -> 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-1 > .output",+ ]