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.

refactor: relocate export logic to `_export` and make it more composable (#10342)

Péter Gyarmaticd6541432b08
diff --git a/marimo/_cli/development/commands.py b/marimo/_cli/development/commands.py
index fb577193d5..d8fd239b60 100644
--- a/marimo/_cli/development/commands.py
+++ b/marimo/_cli/development/commands.py
@@ -233,11 +233,11 @@ def _generate_server_api_schema() -> dict[str, Any]:
from marimo._metadata import opengraph
from marimo._runtime import commands
from marimo._runtime.packages.package_manager import PackageDescription
+ from marimo._schemas import export
from marimo._server.ai.tools.types import ToolDefinition
from marimo._server.api.router import build_routes
from marimo._server.models import (
completion,
- export,
files,
home,
lsp,
@@ -245,6 +245,7 @@ def _generate_server_api_schema() -> dict[str, Any]:
packages,
secrets,
)
+ from marimo._session import requests as session_requests
from marimo._snippets import snippets
MODELS = [
@@ -429,7 +430,7 @@ def _generate_server_api_schema() -> dict[str, Any]:
models.FormatResponse,
models.GetCacheInfoRequest,
models.InstallPackagesRequest,
- models.InstantiateNotebookRequest,
+ session_requests.InstantiateNotebookRequest,
models.InvokeAiToolRequest,
models.InvokeAiToolResponse,
models.InvokeFunctionRequest,
@@ -457,7 +458,7 @@ def _generate_server_api_schema() -> dict[str, Any]:
models.UpdateCellConfigRequest,
models.NotebookDocumentTransactionRequest,
models.FocusCellRequest,
- models.UpdateUIElementValuesRequest,
+ session_requests.UpdateUIElementValuesRequest,
models.UpdateUIElementRequest,
models.UpdateUserConfigRequest,
models.ModelRequest,
@@ -752,8 +753,8 @@ def preview(file_path: Path, port: int, host: str, headless: bool) -> None:
from marimo._ast.app_config import _AppConfig
from marimo._config.config import DEFAULT_CONFIG
- from marimo._server.templates.templates import static_notebook_template
from marimo._server.tokens import SkewProtectionToken
+ from marimo._templates import static_notebook_template
from marimo._utils.paths import marimo_package_path
if TYPE_CHECKING:
@@ -762,7 +763,12 @@ def preview(file_path: Path, port: int, host: str, headless: bool) -> None:
try:
# Run the notebook to get actual outputs
click.echo(f"Running notebook {file_path.name}...")
- from marimo._server.export import run_app_until_completion
+ from marimo._cli.export.output import STDERR
+ from marimo._export.file import run_notebook
+ from marimo._export.requests import (
+ NotebookExecutionOptions,
+ RunNotebookRequest,
+ )
from marimo._server.utils import asyncio_run
from marimo._session.notebook import load_notebook
from marimo._session.state.serialize import (
@@ -776,10 +782,15 @@ def preview(file_path: Path, port: int, host: str, headless: bool) -> None:
# Run the notebook to completion and get session view
session_view, did_error = asyncio_run(
- run_app_until_completion(
- file_manager,
- cli_args={},
- argv=None,
+ run_notebook(
+ RunNotebookRequest(
+ file_manager=file_manager,
+ options=NotebookExecutionOptions(
+ cli_args={},
+ argv=None,
+ stderr=STDERR,
+ ),
+ )
)
)
if did_error:
diff --git a/marimo/_cli/export/commands.py b/marimo/_cli/export/commands.py
index 961d37d4ac..d5cfb4914b 100644
--- a/marimo/_cli/export/commands.py
+++ b/marimo/_cli/export/commands.py
@@ -4,28 +4,16 @@ from __future__ import annotations
import asyncio
import os
import sys
-from dataclasses import replace
+from contextlib import contextmanager
from functools import partial
from pathlib import Path
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, cast, get_args
import click
from marimo._cli.errors import MarimoCLIMissingDependencyError
from marimo._cli.export.cloudflare import create_cloudflare_files
-from marimo._cli.export.local_modules import (
- LocalWheelError,
- resolve_notebook_local_modules,
-)
-from marimo._cli.export.local_wheels import (
- WASM_WHEEL_DIR,
- auto_wheel_dependencies,
- build_local_module_wheels,
- copy_local_wheels,
- resolve_metadata_wheel_dependencies,
- wheel_dependency_names,
- with_wheel_dependencies,
-)
+from marimo._cli.export.output import STDERR, STDOUT
from marimo._cli.export.session import session
from marimo._cli.export.thumbnail import thumbnail
from marimo._cli.help_formatter import ColoredCommand, ColoredGroup
@@ -37,39 +25,68 @@ from marimo._cli.print import (
)
from marimo._cli.sandbox import maybe_prompt_run_in_sandbox, run_in_sandbox
from marimo._cli.utils import prompt_to_overwrite
-from marimo._convert.converters import MarimoConvert
-from marimo._convert.markdown.flavor import (
- markdown_output_filename,
- normalize_markdown_flavor,
-)
+from marimo._convert.common.filename import parse_title
+from marimo._convert.markdown.flavor.base import MarkdownFlavorName
+from marimo._convert.script import UnsupportedAsyncCodeError
from marimo._dependencies.dependencies import DependencyManager
from marimo._dependencies.errors import ManyModulesNotFoundError
-from marimo._pyodide.pyodide_constraints import PYODIDE_PYTHON_VERSION
-from marimo._server.api.utils import parse_title
-from marimo._server.export import (
- ExportResult,
- export_as_ipynb,
- export_as_script,
- export_as_wasm,
+from marimo._export._status import PDFExportStatusEvent
+from marimo._export.exporter import Exporter
+from marimo._export.file import (
+ export_html,
+ export_ipynb,
+ export_markdown,
+ export_pdf,
+ export_script,
+ export_wasm,
notebook_uses_slides_layout,
- run_app_then_export_as_html,
- run_app_then_export_as_ipynb,
- run_app_then_export_as_pdf,
- run_app_then_export_as_wasm,
)
-from marimo._server.export._status import PDFExportStatusEvent
-from marimo._server.export.exporter import Exporter
+from marimo._export.local_modules import (
+ LocalWheelError,
+ UVNotFoundError,
+ resolve_notebook_local_modules,
+)
+from marimo._export.local_wheels import (
+ WASM_WHEEL_DIR,
+ auto_wheel_dependencies,
+ build_local_module_wheels,
+ copy_local_wheels,
+ resolve_metadata_wheel_dependencies,
+ wheel_dependency_names,
+ with_wheel_dependencies,
+)
+from marimo._export.requests import (
+ ExportResult,
+ HTMLFileExportRequest,
+ IPYNBFileExportRequest,
+ MarkdownFileExportRequest,
+ NotebookExecutionOptions,
+ PDFFileExportRequest,
+ ScriptFileExportRequest,
+ WASMFileExportRequest,
+)
+from marimo._pyodide.pyodide_constraints import PYODIDE_PYTHON_VERSION
+from marimo._schemas.export_options import (
+ ExportPDFPreset,
+ HTMLExportOptions,
+ IPYNBExportOptions,
+ IPYNBSortMode,
+ MarkdownExportOptions,
+ PDFExportOptions,
+ PDFRasterizationOptions,
+ PDFRasterServer,
+ WASMExportOptions,
+ WASMMode,
+)
from marimo._server.utils import asyncio_run
from marimo._utils.file_watcher import FileWatcher
from marimo._utils.marimo_path import MarimoPath
from marimo._utils.paths import maybe_make_dirs
if TYPE_CHECKING:
- from collections.abc import Callable
+ from collections.abc import Callable, Iterator
from typing import Protocol
- from marimo._convert.markdown.flavor.base import MarkdownFlavorName
-
class _ExportWithCodeTransform(Protocol):
def __call__(
self, *, code_transform: Callable[[str], str]
@@ -109,6 +126,17 @@ class _PDFExportCLIReporter:
echo(f"{green('Exporting PDF', bold=True)}: {message}", err=True)
+@contextmanager
+def _live_notebook_page_url(
+ filepath: str,
+ argv: tuple[str, ...],
+) -> Iterator[str]:
+ from marimo._cli.export.live_notebook_server import LiveNotebookServer
+
+ with LiveNotebookServer(filepath=filepath, argv=list(argv)) as server:
+ yield server.page_url
+
+
def watch_and_export(
marimo_path: MarimoPath,
output: Path | None,
@@ -197,39 +225,6 @@ def watch_and_export(
asyncio_run(start())
-def _export_as_markdown(
- path: MarimoPath,
- *,
- flavor: MarkdownFlavorName | None,
- filename: str | None,
-) -> ExportResult:
- if path.is_python():
- converter = MarimoConvert.from_py(path.read_text(encoding="utf-8"))
- elif path.is_markdown():
- converter = MarimoConvert.from_md(path.read_text(encoding="utf-8"))
- else:
- raise click.ClickException(
- f"Unsupported file type: {path.path.suffix}"
- )
-
- ir = replace(converter.ir, filename=path.short_name)
- source_filename = ir.filename or path.short_name
- export_filename = filename or source_filename
- markdown_flavor = normalize_markdown_flavor(
- flavor, filename=export_filename
- )
- return ExportResult(
- contents=MarimoConvert.from_ir(ir).to_markdown(
- filename=source_filename,
- flavor=markdown_flavor,
- ),
- download_filename=markdown_output_filename(
- export_filename, markdown_flavor
- ),
- did_error=False,
- )
-
-
@click.command(
cls=ColoredCommand,
help="""Run a notebook and export it as an HTML file.
@@ -307,11 +302,19 @@ def html(
def export_callback(file_path: MarimoPath) -> ExportResult:
return asyncio_run(
- run_app_then_export_as_html(
- file_path,
- include_code=include_code,
- cli_args=cli_args,
- argv=list(args),
+ export_html(
+ HTMLFileExportRequest(
+ path=file_path,
+ options=HTMLExportOptions(
+ files=(),
+ include_code=include_code,
+ ),
+ execution=NotebookExecutionOptions(
+ cli_args=cli_args,
+ argv=list(args),
+ stderr=STDERR,
+ ),
+ )
)
)
@@ -380,7 +383,10 @@ def script(
return
def export_callback(file_path: MarimoPath) -> ExportResult:
- return export_as_script(file_path)
+ try:
+ return export_script(ScriptFileExportRequest(path=file_path))
+ except UnsupportedAsyncCodeError as error:
+ raise click.ClickException(str(error)) from None
return watch_and_export(
MarimoPath(name), output, watch, export_callback, force
@@ -428,7 +434,7 @@ Watch for changes and regenerate the script on modification:
)
@click.option(
"--flavor",
- type=click.Choice(["pymdown", "qmd", "mystmd", "mdx"]),
+ type=click.Choice(get_args(MarkdownFlavorName)),
default=None,
help="Markdown flavor to export.",
)
@@ -462,7 +468,15 @@ def md(
filename = str(output) if output is not None else None
def export_callback(file_path: MarimoPath) -> ExportResult:
- return _export_as_markdown(file_path, flavor=flavor, filename=filename)
+ return export_markdown(
+ MarkdownFileExportRequest(
+ path=file_path,
+ options=MarkdownExportOptions(
+ flavor=flavor,
+ filename=filename,
+ ),
+ )
+ )
return watch_and_export(
MarimoPath(name), output, watch, export_callback, force
@@ -491,7 +505,7 @@ Requires nbformat to be installed.
)
@click.option(
"--sort",
- type=click.Choice(["top-down", "topological"]),
+ type=click.Choice(get_args(IPYNBSortMode)),
default="topological",
help="Sort cells top-down or in topological order.",
)
@@ -541,7 +555,7 @@ def ipynb(
name: str,
output: Path,
watch: bool,
- sort: Literal["top-down", "topological"],
+ sort: IPYNBSortMode,
include_outputs: bool,
sandbox: bool | None,
force: bool,
@@ -574,16 +588,24 @@ def ipynb(
cli_args = parse_args(args) if include_outputs else {}
def export_callback(file_path: MarimoPath) -> ExportResult:
- if include_outputs:
- return asyncio_run(
- run_app_then_export_as_ipynb(
- file_path,
- sort_mode=sort,
- cli_args=cli_args,
- argv=list(args),
+ return asyncio_run(
+ export_ipynb(
+ IPYNBFileExportRequest(
+ path=file_path,
+ options=IPYNBExportOptions(sort_mode=sort),
+ execution=(
+ NotebookExecutionOptions(
+ cli_args=cli_args,
+ argv=list(args),
+ stderr=STDERR,
+ )
+ if include_outputs
+ else None
+ ),
+ stderr=STDERR,
)
)
- return export_as_ipynb(file_path, sort_mode=sort)
+ )
return watch_and_export(
MarimoPath(name), output, watch, export_callback, force
@@ -647,7 +669,7 @@ Requires nbformat and nbconvert to be installed.
)
@click.option(
"--raster-server",
- type=click.Choice(["static", "live"], case_sensitive=False),
+ type=click.Choice(get_args(PDFRasterServer), case_sensitive=False),
default="static",
help=(
"Server mode used for raster capture. Use 'static' (default) for "
@@ -658,7 +680,7 @@ Requires nbformat and nbconvert to be installed.
@click.option(
"--as",
"export_as",
- type=click.Choice(["document", "slides"]),
+ type=click.Choice(get_args(ExportPDFPreset)),
default=None,
help=(
"PDF export preset. Use `slides` for reveal.js slide-style output. "
@@ -710,7 +732,7 @@ def pdf(
rasterize_outputs: bool,
raster_scale: float,
raster_server: str,
- export_as: Literal["document", "slides"] | None,
+ export_as: ExportPDFPreset | None,
sandbox: bool | None,
force: bool,
args: tuple[str],
@@ -798,30 +820,49 @@ def pdf(
) from None
raise
- from marimo._server.export._pdf_raster import PDFRasterizationOptions
-
+ raster_server_mode = cast(PDFRasterServer, raster_server)
rasterization_options = PDFRasterizationOptions(
enabled=rasterization_enabled,
scale=raster_scale,
- server_mode=raster_server,
+ server_mode=raster_server_mode,
)
report_status = _PDFExportCLIReporter()
def export_callback(
file_path: MarimoPath,
- ) -> tuple[bytes | None, bool]:
+ ) -> ExportResult:
try:
- return asyncio_run(
- run_app_then_export_as_pdf(
- file_path,
- include_outputs=include_outputs,
- include_inputs=include_inputs,
- webpdf=webpdf,
- export_as=export_as,
- cli_args=cli_args,
- argv=list(args) if include_outputs else None,
- rasterization_options=rasterization_options,
- status_callback=report_status,
+ result = asyncio_run(
+ export_pdf(
+ PDFFileExportRequest(
+ path=file_path,
+ options=PDFExportOptions(
+ webpdf=webpdf,
+ preset=export_as or "document",
+ include_inputs=include_inputs,
+ ),
+ rasterization=rasterization_options,
+ execution=(
+ NotebookExecutionOptions(
+ cli_args=cli_args,
+ argv=list(args),
+ stderr=STDERR,
+ )
+ if include_outputs
+ else None
+ ),
+ live_page_url=(
+ partial(
+ _live_notebook_page_url,
+ file_path.absolute_name,
+ args,
+ )
+ if rasterization_enabled
+ and raster_server == "live"
+ else None
+ ),
+ status_callback=report_status,
+ )
)
)
except ModuleNotFoundError as e:
@@ -834,22 +875,15 @@ def pdf(
raise
except Exception as e:
raise click.ClickException(f"Failed to export PDF: {e}") from None
-
- def export_callback_impl(file_path: MarimoPath) -> ExportResult:
- pdf_bytes, did_error = export_callback(file_path)
- if pdf_bytes is None:
+ if result is None:
raise click.ClickException("Failed to export PDF.")
- return ExportResult(
- contents=pdf_bytes,
- download_filename=str(output),
- did_error=did_error,
- )
+ return result
return watch_and_export(
MarimoPath(name),
output,
watch,
- export_callback_impl,
+ export_callback,
force,
initial_export_in_watch=True,
)
@@ -885,7 +919,7 @@ and cannot be opened directly from the file system (e.g. file://).
)
@click.option(
"--mode",
- type=click.Choice(["edit", "run"]),
+ type=click.Choice(get_args(WASMMode)),
default="run",
help="Whether the notebook code should be editable or readonly.",
required=True,
@@ -943,7 +977,7 @@ and cannot be opened directly from the file system (e.g. file://).
def html_wasm(
name: str,
output: Path,
- mode: Literal["edit", "run"],
+ mode: WASMMode,
watch: bool,
show_code: bool,
include_cloudflare: bool,
@@ -1011,12 +1045,22 @@ def html_wasm(
"""Export with notebook-local wheels injected into PEP 723 metadata."""
metadata_wheels = resolve_metadata_wheel_dependencies(file_path)
metadata_wheel_names = wheel_dependency_names(metadata_wheels)
- modules = tuple(
- resolve_notebook_local_modules(
- file_path.absolute_name,
- exclude_names=metadata_wheel_names,
+ try:
+ modules = tuple(
+ resolve_notebook_local_modules(
+ file_path.absolute_name,
+ exclude_names=metadata_wheel_names,
+ )
)
- )
+ except UVNotFoundError as error:
+ raise MarimoCLIMissingDependencyError(
+ str(error),
+ "uv",
+ additional_tip=(
+ "Install uv from https://github.com/astral-sh/uv"
+ ),
+ ) from error
+
try:
with build_local_module_wheels(modules) as local_wheels:
wheel_dependencies = (
@@ -1040,6 +1084,8 @@ def html_wasm(
except LocalWheelError as error:
raise click.UsageError(str(error)) from error
+ wasm_options = WASMExportOptions(mode=mode, show_code=show_code)
+
if execute:
cli_args = parse_args(args)
@@ -1059,14 +1105,19 @@ def html_wasm(
code_transform: Callable[[str], str],
) -> ExportResult:
return asyncio_run(
- run_app_then_export_as_wasm(
- file_path,
- mode=mode,
- show_code=show_code,
- cli_args=cli_args,
- argv=list(args),
- cache_export_dir=out_dir,
- code_transform=code_transform,
+ export_wasm(
+ WASMFileExportRequest(
+ path=file_path,
+ options=wasm_options,
+ execution=NotebookExecutionOptions(
+ cli_args=cli_args,
+ argv=list(args),
+ stderr=STDERR,
+ ),
+ cache_export_dir=out_dir,
+ code_transform=code_transform,
+ stdout=STDOUT,
+ )
)
)
@@ -1079,15 +1130,26 @@ def html_wasm(
echo("Executing notebook...")
else:
+ def export_unexecuted_wasm(
+ file_path: MarimoPath,
+ *,
+ code_transform: Callable[[str], str],
+ ) -> ExportResult:
+ return asyncio_run(
+ export_wasm(
+ WASMFileExportRequest(
+ path=file_path,
+ options=wasm_options,
+ code_transform=code_transform,
+ stdout=STDOUT,
+ )
+ )
+ )
+
def export_callback(file_path: MarimoPath) -> ExportResult:
return export_with_local_wheels(
file_path,
- partial(
- export_as_wasm,
- file_path,
- mode,
- show_code=show_code,
- ),
+ partial(export_unexecuted_wasm, file_path),
)
# Export assets first
diff --git a/marimo/_server/export/_live_notebook_server.py b/marimo/_cli/export/live_notebook_server.py
similarity index 100%
rename from marimo/_server/export/_live_notebook_server.py
rename to marimo/_cli/export/live_notebook_server.py
diff --git a/marimo/_cli/export/output.py b/marimo/_cli/export/output.py
new file mode 100644
index 0000000000..ae8f7a80ef
--- /dev/null
+++ b/marimo/_cli/export/output.py
@@ -0,0 +1,19 @@
+# Copyright 2026 Marimo. All rights reserved.
+from __future__ import annotations
+
+from io import TextIOBase
+
+from marimo._cli.print import echo
+
+
+class CLIExportWriter(TextIOBase):
+ def __init__(self, *, err: bool) -> None:
+ self._err = err
+
+ def write(self, value: str) -> int:
+ echo(value, err=self._err, nl=False)
+ return len(value)
+
+
+STDOUT = CLIExportWriter(err=False)
+STDERR = CLIExportWriter(err=True)
diff --git a/marimo/_cli/export/session.py b/marimo/_cli/export/session.py
index 65e4f353af..f0080209d4 100644
--- a/marimo/_cli/export/session.py
+++ b/marimo/_cli/export/session.py
@@ -19,13 +19,17 @@ from marimo._cli.export._common import (
from marimo._cli.parse_args import parse_args
from marimo._cli.print import echo, green, red, yellow
from marimo._dependencies.dependencies import DependencyManager
-from marimo._schemas.session import NotebookSessionV1
-from marimo._server.export import run_app_until_completion
-from marimo._server.export._session_cache import (
+from marimo._export._session_cache import (
is_session_snapshot_stale,
serialize_session_snapshot,
write_session_snapshot,
)
+from marimo._export.file import run_notebook
+from marimo._export.requests import (
+ NotebookExecutionOptions,
+ RunNotebookRequest,
+)
+from marimo._schemas.session import NotebookSessionV1
from marimo._server.utils import asyncio_run
from marimo._session.notebook import load_notebook
from marimo._session.state.serialize import get_session_cache_file
@@ -67,12 +71,16 @@ async def _export_session_snapshot(
file_manager = load_notebook(marimo_path.absolute_name)
- session_view, did_error = await run_app_until_completion(
- file_manager,
- cli_args=cli_args,
- argv=list(notebook_args),
- quiet=True,
- persist_session=False,
+ session_view, did_error = await run_notebook(
+ RunNotebookRequest(
+ file_manager=file_manager,
+ options=NotebookExecutionOptions(
+ cli_args=cli_args,
+ argv=list(notebook_args),
+ quiet=True,
+ persist_session=False,
+ ),
+ )
)
session_snapshot = serialize_session_snapshot(
session_view,
@@ -101,8 +109,12 @@ import json
import sys
from marimo._cli.parse_args import parse_args
-from marimo._server.export import run_app_until_completion
-from marimo._server.export._session_cache import serialize_session_snapshot
+from marimo._export._session_cache import serialize_session_snapshot
+from marimo._export.file import run_notebook
+from marimo._export.requests import (
+ NotebookExecutionOptions,
+ RunNotebookRequest,
+)
from marimo._session.notebook import load_notebook
from marimo._utils.marimo_path import MarimoPath
@@ -114,12 +126,16 @@ file_manager = load_notebook(path.absolute_name)
cli_args = parse_args(tuple(args)) if args else {}
session_view, did_error = asyncio.run(
- run_app_until_completion(
- file_manager,
- cli_args=cli_args,
- argv=list(args),
- quiet=True,
- persist_session=False,
+ run_notebook(
+ RunNotebookRequest(
+ file_manager=file_manager,
+ options=NotebookExecutionOptions(
+ cli_args=cli_args,
+ argv=list(args),
+ quiet=True,
+ persist_session=False,
+ ),
+ )
)
)
session_snapshot = serialize_session_snapshot(
diff --git a/marimo/_cli/export/thumbnail.py b/marimo/_cli/export/thumbnail.py
index 5c0f03f32c..c076554fc6 100644
--- a/marimo/_cli/export/thumbnail.py
+++ b/marimo/_cli/export/thumbnail.py
@@ -16,12 +16,18 @@ from marimo._cli.export._common import (
is_multi_target,
run_python_subprocess,
)
+from marimo._cli.export.output import STDERR
from marimo._cli.install_hints import get_playwright_chromium_setup_commands
from marimo._cli.parse_args import parse_args
from marimo._cli.print import echo, green, red, yellow
from marimo._dependencies.dependencies import DependencyManager
-from marimo._server.export import run_app_then_export_as_html
-from marimo._server.export._html_asset_server import HtmlAssetServer
+from marimo._export._html_asset_server import HtmlAssetServer
+from marimo._export.file import export_html
+from marimo._export.requests import (
+ HTMLFileExportRequest,
+ NotebookExecutionOptions,
+)
+from marimo._schemas.export_options import HTMLExportOptions
from marimo._server.utils import asyncio_run
from marimo._utils.marimo_path import MarimoPath
from marimo._utils.paths import marimo_package_path, maybe_make_dirs
@@ -119,21 +125,34 @@ async def _render_html(
venv_python: str | None = None,
) -> str:
if not execute:
- from marimo._server.export import export_as_html_without_execution
-
- result = await export_as_html_without_execution(
- marimo_path, include_code=True, asset_url=asset_url
+ result = await export_html(
+ HTMLFileExportRequest(
+ path=marimo_path,
+ options=HTMLExportOptions(
+ files=(),
+ include_code=True,
+ asset_url=asset_url,
+ ),
+ )
)
return result.text
if venv_python is None:
cli_args = parse_args(args) if args else {}
- result = await run_app_then_export_as_html(
- marimo_path,
- include_code=include_code,
- cli_args=cli_args,
- argv=list(args),
- asset_url=asset_url,
+ result = await export_html(
+ HTMLFileExportRequest(
+ path=marimo_path,
+ options=HTMLExportOptions(
+ files=(),
+ include_code=include_code,
+ asset_url=asset_url,
+ ),
+ execution=NotebookExecutionOptions(
+ cli_args=cli_args,
+ argv=list(args),
+ stderr=STDERR,
+ ),
+ )
)
return result.text
@@ -162,7 +181,12 @@ import json
import sys
from marimo._cli.parse_args import parse_args
-from marimo._server.export import run_app_then_export_as_html
+from marimo._export.file import export_html
+from marimo._export.requests import (
+ HTMLFileExportRequest,
+ NotebookExecutionOptions,
+)
+from marimo._schemas.export_options import HTMLExportOptions
from marimo._utils.marimo_path import MarimoPath
payload = json.loads(sys.argv[1])
@@ -173,12 +197,19 @@ asset_url = payload.get("asset_url")
cli_args = parse_args(tuple(args)) if args else {}
result = asyncio.run(
- run_app_then_export_as_html(
- path,
- include_code=include_code,
- cli_args=cli_args,
- argv=list(args),
- asset_url=asset_url,
+ export_html(
+ HTMLFileExportRequest(
+ path=path,
+ options=HTMLExportOptions(
+ files=(),
+ include_code=include_code,
+ asset_url=asset_url,
+ ),
+ execution=NotebookExecutionOptions(
+ cli_args=cli_args,
+ argv=list(args),
+ ),
+ )
)
)
sys.stdout.write(result.text)
diff --git a/marimo/_code_mode/screenshot.py b/marimo/_code_mode/screenshot.py
index fa77aef3a9..aad4f1fc64 100644
--- a/marimo/_code_mode/screenshot.py
+++ b/marimo/_code_mode/screenshot.py
@@ -13,7 +13,7 @@ import time
from typing import TYPE_CHECKING, Any
from marimo import _loggers
-from marimo._server.export._pdf_raster import (
+from marimo._export._pdf_raster import (
WAIT_FOR_NEXT_PAINT,
WAIT_FOR_PAGE_READY,
)
diff --git a/marimo/_convert/common/filename.py b/marimo/_convert/common/filename.py
index b6355b1cf6..7e44f529b3 100644
--- a/marimo/_convert/common/filename.py
+++ b/marimo/_convert/common/filename.py
@@ -2,9 +2,22 @@
from __future__ import annotations
import os
+from pathlib import Path
from urllib.parse import quote
+def parse_title(filepath: str | None) -> str:
+ """
+ Create a title from a filename.
+ """
+ if filepath is None:
+ return "marimo"
+
+ # filename is used as title, except basename and suffix are
+ # stripped and underscores are replaced with spaces
+ return Path(filepath).stem.replace("_", " ")
+
+
def get_filename(filename: str | None, default: str = "notebook.py") -> str:
if not filename:
filename = default
diff --git a/marimo/_convert/script.py b/marimo/_convert/script.py
index a430aeff54..c41a127169 100644
--- a/marimo/_convert/script.py
+++ b/marimo/_convert/script.py
@@ -8,6 +8,10 @@ from marimo._schemas.serialization import NotebookSerialization
from marimo._version import __version__
+class UnsupportedAsyncCodeError(ValueError):
+ pass
+
+
def _header_for_script(ir: NotebookSerialization) -> str:
"""Extract a Python script-appropriate header from IR.
@@ -48,9 +52,7 @@ def convert_from_ir_to_script(ir: NotebookSerialization) -> str:
if not cell:
continue
if cell._is_coroutine:
- from click import ClickException
-
- raise ClickException(
+ raise UnsupportedAsyncCodeError(
"Cannot export a notebook with async code to a flat script"
)
diff --git a/marimo/_export/__init__.py b/marimo/_export/__init__.py
new file mode 100644
index 0000000000..fe2d2e388e
--- /dev/null
+++ b/marimo/_export/__init__.py
@@ -0,0 +1 @@
+# Copyright 2026 Marimo. All rights reserved.
diff --git a/marimo/_server/export/_html_asset_server.py b/marimo/_export/_html_asset_server.py
similarity index 100%
rename from marimo/_server/export/_html_asset_server.py
rename to marimo/_export/_html_asset_server.py
diff --git a/marimo/_server/export/_nbformat_png_fallbacks.py b/marimo/_export/_nbformat_png_fallbacks.py
similarity index 97%
rename from marimo/_server/export/_nbformat_png_fallbacks.py
rename to marimo/_export/_nbformat_png_fallbacks.py
index 49b849d060..bf62f55b40 100644
--- a/marimo/_server/export/_nbformat_png_fallbacks.py
+++ b/marimo/_export/_nbformat_png_fallbacks.py
@@ -3,7 +3,7 @@ from __future__ import annotations
from typing import TYPE_CHECKING, Any, cast
-from marimo._server.export._raster_mime import MIME_TYPES_REPLACED_BY_PNG
+from marimo._export._raster_mime import MIME_TYPES_REPLACED_BY_PNG
from marimo._types.ids import CellId_t
if TYPE_CHECKING:
diff --git a/marimo/_server/export/_pdf_raster.py b/marimo/_export/_pdf_raster.py
similarity index 85%
rename from marimo/_server/export/_pdf_raster.py
rename to marimo/_export/_pdf_raster.py
index 2b98ea9bd9..727943407e 100644
--- a/marimo/_server/export/_pdf_raster.py
+++ b/marimo/_export/_pdf_raster.py
@@ -11,24 +11,27 @@ from typing import TYPE_CHECKING, Any, Literal, cast
from marimo import _loggers
from marimo._config.config import DisplayConfig
from marimo._config.manager import get_default_config_manager
-from marimo._server.export._html_asset_server import HtmlAssetServer
-from marimo._server.export._live_notebook_server import LiveNotebookServer
-from marimo._server.export._raster_mime import (
+from marimo._export._html_asset_server import HtmlAssetServer
+from marimo._export._raster_mime import (
TEXT_HTML,
TEXT_MARKDOWN,
TEXT_PLAIN,
VEGA_MIME_TYPES,
)
-from marimo._server.export._status import emit_pdf_export_status
-from marimo._server.models.export import ExportAsHTMLRequest
+from marimo._export._status import emit_pdf_export_status
+from marimo._export.requests import (
+ HTMLExportRequest,
+ PDFRasterizationRequest,
+)
+from marimo._export.serialization import serialize_notebook_snapshot
+from marimo._schemas.export_options import HTMLExportOptions
from marimo._types.ids import CellId_t
from marimo._utils.paths import marimo_package_path
if TYPE_CHECKING:
from collections.abc import Sequence
- from marimo._ast.app import InternalApp
- from marimo._server.export._status import PDFExportStatusCallback
+ from marimo._export._status import PDFExportStatusCallback
from marimo._session.state.session_view import SessionView
LOGGER = _loggers.marimo_logger()
@@ -76,13 +79,6 @@ WAIT_FOR_NEXT_PAINT = r"""
"""
-@dataclass(frozen=True)
-class PDFRasterizationOptions:
- enabled: bool = True
- scale: float = 4.0
- server_mode: str = "static"
-
-
CaptureExpectation = Literal["anywidget", "vega"]
@@ -328,22 +324,17 @@ def _to_data_url(image: bytes) -> str:
async def _collect_static_captures(
*,
- app: InternalApp,
- session_view: SessionView,
- filename: str | None,
- filepath: str | None,
- options: PDFRasterizationOptions,
+ request: PDFRasterizationRequest,
static_targets: list[_RasterTarget],
- status_callback: PDFExportStatusCallback | None = None,
) -> dict[CellId_t, str]:
"""Capture PNG fallbacks from exported static HTML for non-live targets."""
- from marimo._server.export.exporter import Exporter
+ from marimo._export.exporter import Exporter
LOGGER.debug(
"Raster capture static phase: %s target(s), scale=%s",
len(static_targets),
- options.scale,
+ request.options.scale,
)
static_dir = marimo_package_path() / "_static"
@@ -352,27 +343,34 @@ async def _collect_static_captures(
route="/__marimo_pdf_raster__.html",
) as server:
capture_view = _promote_component_markup_for_capture(
- session_view,
+ request.session_view,
static_targets,
)
html, _download_filename = Exporter().export_as_html(
- filename=filename,
- app=app,
- session_view=capture_view,
- display_config=_to_display_config(filepath),
- request=ExportAsHTMLRequest(
- download=False,
- files=[],
- include_code=True,
- asset_url=server.base_url,
+ HTMLExportRequest(
+ filename=request.filename,
+ app_code=request.app.to_py(),
+ app_config=request.app.config,
+ snapshot=serialize_notebook_snapshot(
+ request.app,
+ capture_view,
+ drop_virtual_file_outputs=False,
+ include_model_notifications=True,
+ ),
+ display_config=_to_display_config(request.filepath),
+ options=HTMLExportOptions(
+ files=(),
+ include_code=True,
+ asset_url=server.base_url,
+ ),
),
)
server.set_html(html)
captures = await _capture_pngs_from_page(
page_url=server.page_url,
targets=static_targets,
- scale=options.scale,
- status_callback=status_callback,
+ scale=request.options.scale,
+ status_callback=request.status_callback,
)
LOGGER.debug(
"Raster capture static phase complete: %s/%s captured",
@@ -384,32 +382,29 @@ async def _collect_static_captures(
async def _collect_live_captures(
*,
- filepath: str | None,
- argv: list[str] | None,
- options: PDFRasterizationOptions,
+ request: PDFRasterizationRequest,
live_targets: list[_RasterTarget],
- status_callback: PDFExportStatusCallback | None = None,
) -> dict[CellId_t, str]:
"""Capture PNG fallbacks from a live notebook runtime when required."""
- if not filepath:
+ if request.live_page_url is None:
LOGGER.debug(
- "Raster capture live phase skipped: no filepath provided."
+ "Raster capture live phase skipped: no page URL provided."
)
return {}
LOGGER.debug(
"Raster capture live phase: %s target(s), scale=%s",
len(live_targets),
- options.scale,
- )
- captures = await _capture_pngs_from_live_page(
- filepath=filepath,
- targets=live_targets,
- scale=options.scale,
- argv=argv,
- status_callback=status_callback,
+ request.options.scale,
)
+ with request.live_page_url() as page_url:
+ captures = await _capture_pngs_from_page(
+ page_url=page_url,
+ targets=live_targets,
+ scale=request.options.scale,
+ status_callback=request.status_callback,
+ )
LOGGER.debug(
"Raster capture live phase complete: %s/%s captured",
len(captures),
@@ -419,34 +414,27 @@ async def _collect_live_captures(
async def collect_pdf_png_fallbacks(
- *,
- app: InternalApp,
- session_view: SessionView,
- filename: str | None,
- filepath: str | None,
- argv: list[str] | None = None,
- options: PDFRasterizationOptions,
- status_callback: PDFExportStatusCallback | None = None,
+ request: PDFRasterizationRequest,
) -> dict[CellId_t, str]:
"""Collect per-cell PNG fallbacks to inject before nbconvert PDF export."""
- if not options.enabled:
+ if not request.options.enabled:
LOGGER.debug("Raster capture disabled by options.")
return {}
- targets = _collect_raster_targets(session_view)
+ targets = _collect_raster_targets(request.session_view)
if not targets:
LOGGER.debug("Raster capture skipped: no eligible outputs found.")
return {}
targets = _sort_targets_by_notebook_order(
- list(app.cell_manager.cell_ids()), targets
+ list(request.app.cell_manager.cell_ids()), targets
)
- server_mode = options.server_mode.lower()
+ server_mode = request.options.server_mode.lower()
if server_mode not in {"static", "live"}:
LOGGER.warning(
"Unknown raster server mode '%s'; defaulting to static.",
- options.server_mode,
+ request.options.server_mode,
)
server_mode = "static"
@@ -459,10 +447,10 @@ async def collect_pdf_png_fallbacks(
"Rasterizing %s component(s) for PDF [mode=%s, scale=%s].",
len(targets),
server_mode,
- options.scale,
+ request.options.scale,
)
emit_pdf_export_status(
- status_callback,
+ request.status_callback,
phase="raster",
message="rasterizing interactive outputs...",
total=len(targets),
@@ -471,22 +459,14 @@ async def collect_pdf_png_fallbacks(
if server_mode == "live":
LOGGER.debug("Raster capture strategy: live-only.")
captures = await _collect_live_captures(
- filepath=filepath,
- argv=argv,
- options=options,
+ request=request,
live_targets=targets,
- status_callback=status_callback,
)
else:
LOGGER.debug("Raster capture strategy: static-only.")
captures = await _collect_static_captures(
- app=app,
- session_view=session_view,
- filename=filename,
- filepath=filepath,
- options=options,
+ request=request,
static_targets=targets,
- status_callback=status_callback,
)
LOGGER.debug(
@@ -708,22 +688,3 @@ async def _capture_pngs_from_page(
len(targets),
)
return captures
-
-
-async def _capture_pngs_from_live_page(
- *,
- filepath: str,
- 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."""
-
- with LiveNotebookServer(filepath=filepath, argv=argv) as server:
- return await _capture_pngs_from_page(
- page_url=server.page_url,
- targets=targets,
- scale=scale,
- status_callback=status_callback,
- )
diff --git a/marimo/_server/export/_raster_mime.py b/marimo/_export/_raster_mime.py
similarity index 100%
rename from marimo/_server/export/_raster_mime.py
rename to marimo/_export/_raster_mime.py
diff --git a/marimo/_server/export/_session_cache.py b/marimo/_export/_session_cache.py
similarity index 100%
rename from marimo/_server/export/_session_cache.py
rename to marimo/_export/_session_cache.py
diff --git a/marimo/_server/export/_status.py b/marimo/_export/_status.py
similarity index 100%
rename from marimo/_server/export/_status.py
rename to marimo/_export/_status.py
diff --git a/marimo/_server/export/exporter.py b/marimo/_export/exporter.py
similarity index 85%
rename from marimo/_server/export/exporter.py
rename to marimo/_export/exporter.py
index f3ff2bb464..e406f65d3b 100644
--- a/marimo/_server/export/exporter.py
+++ b/marimo/_export/exporter.py
@@ -7,10 +7,9 @@ import mimetypes
import sys
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, cast
+from typing import TYPE_CHECKING, Any, cast
from marimo import _loggers
-from marimo._ast.app import InternalApp
from marimo._ast.names import DEFAULT_CELL_NAME
from marimo._config.config import (
DEFAULT_CONFIG,
@@ -28,29 +27,38 @@ from marimo._convert.common.filename import (
get_download_filename,
get_filename,
)
+from marimo._convert.converters import MarimoConvert
from marimo._convert.ipynb.from_ir import (
NBCONVERT_REMOVE_INPUT_TAG,
convert_from_ir_to_ipynb,
)
+from marimo._convert.markdown.flavor import (
+ markdown_output_filename,
+ normalize_markdown_flavor,
+)
+from marimo._convert.script import convert_from_ir_to_script
from marimo._dependencies.dependencies import DependencyManager
+from marimo._export._status import emit_pdf_export_status
+from marimo._export.requests import (
+ ExportResult,
+ HTMLExportRequest,
+ IPYNBExportRequest,
+ MarkdownExportRequest,
+ PDFExportRequest,
+ ScriptExportRequest,
+ WASMExportRequest,
+)
from marimo._messaging.mimetypes import KnownMimeType
from marimo._messaging.notification import ModelOpen
from marimo._runtime.virtual_file import read_virtual_file
+from marimo._schemas.export_options import IPYNBExportOptions
from marimo._schemas.notebook import NotebookV1
from marimo._schemas.session import NotebookSessionV1
-from marimo._server.export._status import emit_pdf_export_status
-from marimo._server.models.export import ExportAsHTMLRequest
-from marimo._server.templates.templates import (
+from marimo._server.tokens import SkewProtectionToken
+from marimo._templates import (
static_notebook_template,
wasm_notebook_template,
)
-from marimo._server.tokens import SkewProtectionToken
-from marimo._session.state.serialize import (
- serialize_notebook,
- serialize_session_view,
-)
-from marimo._session.state.session_view import SessionView
-from marimo._types.ids import CellId_t
from marimo._utils import async_path
from marimo._utils.code import hash_code
from marimo._utils.data_uri import build_data_url
@@ -59,12 +67,10 @@ from marimo._utils.paths import marimo_package_path, notebook_output_dir
from marimo._version import __version__
if TYPE_CHECKING:
- from collections.abc import Iterator, Mapping
+ from collections.abc import Iterator
from traitlets.config import Config
- from marimo._server.export._status import PDFExportStatusCallback
-
LOGGER = _loggers.marimo_logger()
# Root directory for static assets
@@ -127,6 +133,35 @@ def _render_webpdf(notebook: Any, include_inputs: bool) -> Any:
).result()
+def export_script(request: ScriptExportRequest) -> ExportResult:
+ return ExportResult(
+ contents=convert_from_ir_to_script(request.notebook),
+ download_filename=get_download_filename(
+ request.notebook.filename, "script.py"
+ ),
+ did_error=False,
+ )
+
+
+def export_markdown(request: MarkdownExportRequest) -> ExportResult:
+ source_filename = (
+ request.options.source_filename or request.notebook.filename
+ )
+ export_filename = request.options.filename or source_filename
+ flavor = normalize_markdown_flavor(
+ request.options.flavor,
+ filename=export_filename or "notebook.md",
+ )
+ return ExportResult(
+ contents=MarimoConvert.from_ir(request.notebook).to_markdown(
+ filename=source_filename,
+ flavor=flavor,
+ ),
+ download_filename=markdown_output_filename(export_filename, flavor),
+ did_error=False,
+ )
+
+
class Exporter:
# Virtual file URL format constants
_VIRTUAL_FILE_PATTERN = "./@file/"
@@ -134,27 +169,19 @@ class Exporter:
def export_as_html(
self,
- *,
- filename: str | None,
- app: InternalApp,
- session_view: SessionView,
- display_config: DisplayConfig,
- request: ExportAsHTMLRequest,
- sharing_config: SharingConfig | None = None,
+ request: HTMLExportRequest,
) -> tuple[str, str]:
index_html = get_html_contents()
- filename = get_filename(filename)
+ filename = get_filename(request.filename)
# Configure notebook with display and sharing settings
- config = self._prepare_display_config(display_config, sharing_config)
+ config = self._prepare_display_config(
+ request.display_config, request.sharing_config
+ )
# Serialize notebook state
- session_snapshot = serialize_session_view(
- session_view,
- cell_ids=app.cell_manager.cell_ids(),
- drop_virtual_file_outputs=False,
- )
- notebook_snapshot = serialize_notebook(session_view, app.cell_manager)
+ session_snapshot = deep_copy(request.snapshot.session)
+ notebook_snapshot = deep_copy(request.snapshot.notebook)
# Replace virtual files in HTML outputs with data URIs
session_snapshot, replaced_files = self._inline_virtual_files(
@@ -168,18 +195,21 @@ class Exporter:
public_dir = Path(filename).resolve().parent / "public"
self._inline_public_files(session_snapshot, public_dir)
- app_code = app.to_py()
+ app_code = request.app_code
# Prepare code for export
code = self._prepare_code(
- request.include_code, app_code, notebook_snapshot, session_snapshot
+ request.options.include_code,
+ app_code,
+ notebook_snapshot,
+ session_snapshot,
)
# Build fallback virtual_files dict for files not in HTML outputs.
# Widget ESM referenced only by model notifications (e.g. a
# composed child never displayed on its own) appears in no HTML
# output, so the inline pass above cannot see it.
- model_notifications = session_view.get_model_notifications()
+ model_notifications = list(request.snapshot.model_notifications)
esm_urls = [
self._normalize_virtual_file_url(n.message.esm_spec.url)
for n in model_notifications
@@ -187,7 +217,7 @@ class Exporter:
and n.message.esm_spec is not None
]
virtual_files = self._build_virtual_files_dict(
- [*request.files, *esm_urls],
+ [*request.options.files, *esm_urls],
replaced_files,
max_inline_bytes=MAX_VIRTUAL_FILE_INLINE_BYTES,
)
@@ -199,7 +229,7 @@ class Exporter:
user_config=config,
config_overrides={},
server_token=SkewProtectionToken("static"),
- app_config=app.config,
+ app_config=request.app_config,
filepath=filename,
code=code,
code_hash=code_hash,
@@ -207,7 +237,7 @@ class Exporter:
notebook_snapshot=notebook_snapshot,
files=virtual_files,
model_notifications=model_notifications,
- asset_url=request.asset_url,
+ asset_url=request.options.asset_url,
)
download_filename = get_download_filename(filename, "html")
@@ -437,35 +467,26 @@ class Exporter:
def export_as_ipynb(
self,
- app: InternalApp,
- *,
- sort_mode: Literal["top-down", "topological"],
- session_view: SessionView | None = None,
+ request: IPYNBExportRequest,
) -> str:
"""Export notebook as .ipynb, optionally including outputs if session_view provided."""
return convert_from_ir_to_ipynb(
- app, sort_mode=sort_mode, session_view=session_view
+ request.app,
+ sort_mode=request.options.sort_mode,
+ session_view=request.session_view,
)
def export_as_wasm(
self,
- *,
- app: InternalApp,
- filename: str | None,
- display_config: DisplayConfig,
- code: str,
- mode: Literal["edit", "run"],
- show_code: bool,
- asset_url: str | None = None,
- session_snapshot: NotebookSessionV1 | None = None,
- notebook_snapshot: NotebookV1 | None = None,
- sharing_config: SharingConfig | None = None,
+ request: WASMExportRequest,
) -> tuple[str, str]:
"""Export notebook as a WASM-powered standalone HTML file."""
index_html = get_html_contents()
- filename = get_filename(filename)
+ filename = get_filename(request.filename)
- config = self._prepare_display_config(display_config, sharing_config)
+ config = self._prepare_display_config(
+ request.display_config, request.sharing_config
+ )
# Remove autosave
config["save"]["autosave"] = "off"
@@ -473,15 +494,15 @@ class Exporter:
html=index_html,
version=__version__,
filename=filename,
- mode=mode,
+ mode=request.options.mode,
user_config=config,
config_overrides={},
- app_config=app.config,
- code=code,
- asset_url=asset_url,
- show_code=show_code,
- session_snapshot=session_snapshot,
- notebook_snapshot=notebook_snapshot,
+ app_config=request.app_config,
+ code=request.code,
+ asset_url=request.options.asset_url,
+ show_code=request.options.show_code,
+ session_snapshot=request.session_snapshot,
+ notebook_snapshot=request.notebook_snapshot,
)
download_filename = get_download_filename(filename, "wasm.html")
@@ -490,27 +511,12 @@ class Exporter:
def export_as_pdf(
self,
- *,
- app: InternalApp,
- session_view: SessionView | None,
- png_fallbacks: Mapping[CellId_t, str] | None = None,
- webpdf: bool,
- include_inputs: bool = True,
- status_callback: PDFExportStatusCallback | None = None,
+ request: PDFExportRequest,
) -> bytes | None:
"""Export notebook as a PDF.
Args:
- app: The app to export
- session_view: The session view to export. If None, outputs are not included.
- png_fallbacks: Optional cell-id keyed image/png fallbacks to
- inject 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 webpdf
- directly.
+ request: Notebook data, PDF options, and optional rendered outputs.
Returns:
PDF data
@@ -528,20 +534,24 @@ class Exporter:
)
ipynb_json_str = self.export_as_ipynb(
- app=app, sort_mode="top-down", session_view=session_view
+ IPYNBExportRequest(
+ app=request.app,
+ options=IPYNBExportOptions(sort_mode="top-down"),
+ session_view=request.session_view,
+ )
)
import nbformat
notebook = nbformat.reads(ipynb_json_str, as_version=4) # type: ignore[no-untyped-call]
- if png_fallbacks:
- from marimo._server.export._nbformat_png_fallbacks import (
+ if request.png_fallbacks:
+ from marimo._export._nbformat_png_fallbacks import (
inject_png_fallbacks_into_notebook,
)
inject_png_fallbacks_into_notebook(
notebook,
- png_fallbacks=png_fallbacks,
+ png_fallbacks=request.png_fallbacks,
)
# Try standard PDF export first (requires pandoc + TeX)
@@ -555,28 +565,28 @@ class Exporter:
def _emit_webpdf_fallback_status() -> None:
emit_pdf_export_status(
- status_callback,
+ request.status_callback,
phase="render_fallback",
message=(
"standard PDF export failed; falling back to WebPDF..."
),
)
- if not webpdf:
+ if not request.options.webpdf:
try:
from nbconvert import ( # type: ignore[import-not-found]
PDFExporter,
)
emit_pdf_export_status(
- status_callback,
+ request.status_callback,
phase="render",
message="rendering PDF via standard exporter...",
)
exporter = PDFExporter( # type: ignore[no-untyped-call]
config=_nbconvert_tag_remove_config(),
)
- exporter.exclude_input = not include_inputs
+ exporter.exclude_input = not request.options.include_inputs
pdf_data, _resources = exporter.from_notebook_node(notebook) # type: ignore[no-untyped-call]
if isinstance(pdf_data, bytes):
return pdf_data
@@ -603,11 +613,11 @@ class Exporter:
)
emit_pdf_export_status(
- status_callback,
+ request.status_callback,
phase="render",
message="rendering PDF via WebPDF...",
)
- pdf_data = _render_webpdf(notebook, include_inputs)
+ pdf_data = _render_webpdf(notebook, request.options.include_inputs)
if not isinstance(pdf_data, bytes):
LOGGER.error("PDF data is not bytes: %s", pdf_data)
@@ -616,12 +626,7 @@ class Exporter:
async def export_as_slides_pdf(
self,
- *,
- app: InternalApp,
- session_view: SessionView | None,
- png_fallbacks: Mapping[CellId_t, str] | None = None,
- include_inputs: bool = True,
- status_callback: PDFExportStatusCallback | None = None,
+ request: PDFExportRequest,
) -> bytes | None:
"""Export a slides notebook as PDF using reveal.js + Playwright.
@@ -633,14 +638,7 @@ class Exporter:
is required when running inside an asyncio event loop.
Args:
- app: The app to export
- session_view: The session view to export. If None, outputs
- are not included.
- png_fallbacks: Optional cell-id keyed image/png fallbacks to
- inject 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.
+ request: Notebook data, PDF options, and optional rendered outputs.
Returns:
PDF data
@@ -654,27 +652,33 @@ class Exporter:
)
ipynb_json_str = self.export_as_ipynb(
- app=app, sort_mode="top-down", session_view=session_view
+ IPYNBExportRequest(
+ app=request.app,
+ options=IPYNBExportOptions(sort_mode="top-down"),
+ session_view=request.session_view,
+ )
)
import nbformat
notebook = nbformat.reads(ipynb_json_str, as_version=4) # type: ignore[no-untyped-call]
- if png_fallbacks:
- from marimo._server.export._nbformat_png_fallbacks import (
+ if request.png_fallbacks:
+ from marimo._export._nbformat_png_fallbacks import (
inject_png_fallbacks_into_notebook,
)
inject_png_fallbacks_into_notebook(
notebook,
- png_fallbacks=png_fallbacks,
+ png_fallbacks=request.png_fallbacks,
)
emit_pdf_export_status(
- status_callback,
+ request.status_callback,
phase="render",
message="rendering slides PDF...",
)
- return await self._export_slides_as_pdf(notebook, include_inputs)
+ return await self._export_slides_as_pdf(
+ notebook, request.options.include_inputs
+ )
@staticmethod
def _to_file_uri(path: str) -> str:
@@ -836,6 +840,13 @@ class Exporter:
return False
+async def render_pdf(request: PDFExportRequest) -> bytes | None:
+ exporter = Exporter()
+ if request.options.preset == "slides":
+ return await exporter.export_as_slides_pdf(request)
+ return exporter.export_as_pdf(request)
+
+
class AutoExporter:
def __init__(self) -> None:
# Cache directories we've already created to avoid redundant checks
diff --git a/marimo/_server/export/__init__.py b/marimo/_export/file.py
similarity index 55%
rename from marimo/_server/export/__init__.py
rename to marimo/_export/file.py
index 225b9dfcc1..8cfe9e8293 100644
--- a/marimo/_server/export/__init__.py
+++ b/marimo/_export/file.py
@@ -4,26 +4,47 @@ from __future__ import annotations
import asyncio
import os
import sys
-from dataclasses import dataclass, replace
-from functools import cached_property
+from dataclasses import replace
from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, cast
+from typing import TYPE_CHECKING, Any, cast
from marimo import _loggers
from marimo._ast.app import InternalApp
from marimo._ast.errors import CycleError, MultipleDefinitionError
from marimo._ast.load import load_app
-from marimo._cli.print import echo
from marimo._config.config import RuntimeConfig
from marimo._config.manager import (
get_default_config_manager,
)
from marimo._convert.common.filename import get_download_filename
from marimo._convert.converters import MarimoConvert
-from marimo._convert.markdown.flavor import (
- markdown_output_filename,
- normalize_markdown_flavor,
+from marimo._export._status import emit_pdf_export_status
+from marimo._export.exporter import (
+ Exporter,
+ export_markdown as render_markdown,
+ export_script as render_script,
+ render_pdf,
)
+from marimo._export.requests import (
+ CacheBundleRequest,
+ ExportResult,
+ HTMLExportRequest,
+ HTMLFileExportRequest,
+ IPYNBExportRequest,
+ IPYNBFileExportRequest,
+ MarkdownExportRequest,
+ MarkdownFileExportRequest,
+ PDFExportRequest,
+ PDFFileExportRequest,
+ PDFRasterizationRequest,
+ ReactiveHTMLFileExportRequest,
+ RunNotebookRequest,
+ ScriptExportRequest,
+ ScriptFileExportRequest,
+ WASMExportRequest,
+ WASMFileExportRequest,
+)
+from marimo._export.serialization import serialize_notebook_snapshot
from marimo._messaging.cell_output import CellChannel, CellOutput
from marimo._messaging.errors import Error, is_unexpected_error
from marimo._messaging.notification import (
@@ -33,21 +54,15 @@ from marimo._messaging.notification import (
from marimo._messaging.serde import deserialize_kernel_message
from marimo._messaging.types import KernelMessage
from marimo._output.hypertext import patch_html_for_non_interactive_output
-from marimo._runtime.commands import (
- AppMetadata,
- SerializedCLIArgs,
-)
+from marimo._runtime.commands import AppMetadata
from marimo._runtime.patches import extract_docstring_from_header
-from marimo._schemas.serialization import NotebookSerialization
-from marimo._server.export._status import emit_pdf_export_status
-from marimo._server.export.exporter import Exporter
-from marimo._server.models.export import (
- ExportAsHTMLRequest,
- ExportPDFPreset,
+from marimo._schemas.export_options import (
+ IPYNBExportOptions,
)
-from marimo._server.models.models import InstantiateNotebookRequest
+from marimo._schemas.serialization import NotebookSerialization
from marimo._session.model import ConnectionState, SessionMode
-from marimo._session.notebook import AppFileManager, load_notebook
+from marimo._session.notebook import load_notebook
+from marimo._session.requests import InstantiateNotebookRequest
from marimo._types.ids import ConsumerId
from marimo._utils.inline_script_metadata import (
pin_pep723_dependencies_for_wasm,
@@ -57,36 +72,13 @@ from marimo._utils.marimo_path import MarimoPath
LOGGER = _loggers.marimo_logger()
if TYPE_CHECKING:
- from collections.abc import Callable, Mapping
+ from collections.abc import Mapping
- from marimo._server.export._pdf_raster import PDFRasterizationOptions
- from marimo._server.export._status import PDFExportStatusCallback
from marimo._session.state.session_view import SessionView
from marimo._session.types import Session
from marimo._types.ids import CellId_t
-@dataclass
-class ExportResult:
- contents: bytes | str
- download_filename: str
- did_error: bool
-
- @cached_property
- def bytez(self) -> bytes:
- """Return UTF-8 encoded bytes (cached)."""
- if isinstance(self.contents, bytes):
- return self.contents
- return self.contents.encode("utf-8")
-
- @cached_property
- def text(self) -> str:
- """Return UTF-8 decoded text (cached)."""
- if isinstance(self.contents, str):
- return self.contents
- return self.contents.decode("utf-8")
-
-
def _as_ir(path: MarimoPath) -> NotebookSerialization:
if path.is_python():
py_contents = path.read_text(encoding="utf-8")
@@ -99,108 +91,135 @@ def _as_ir(path: MarimoPath) -> NotebookSerialization:
raise ValueError(f"Unsupported file type: {path.path.suffix}")
-def export_as_script(path: MarimoPath) -> ExportResult:
- from marimo._convert.script import convert_from_ir_to_script
-
- ir = _as_ir(path)
- return ExportResult(
- contents=convert_from_ir_to_script(ir),
- download_filename=get_download_filename(path.short_name, "script.py"),
- did_error=False,
+def export_script(request: ScriptFileExportRequest) -> ExportResult:
+ return render_script(
+ ScriptExportRequest(
+ notebook=_as_ir(request.path),
+ )
)
-def export_as_md(path: MarimoPath) -> ExportResult:
- ir = _as_ir(path)
- filename = ir.filename or path.short_name
- markdown_flavor = normalize_markdown_flavor(None, filename=filename)
- return ExportResult(
- contents=MarimoConvert.from_ir(ir).to_markdown(
- filename=filename, flavor=markdown_flavor
- ),
- download_filename=markdown_output_filename(filename, markdown_flavor),
- did_error=False,
+def export_markdown(request: MarkdownFileExportRequest) -> ExportResult:
+ return render_markdown(
+ MarkdownExportRequest(
+ notebook=_as_ir(request.path),
+ options=request.options,
+ )
)
-def export_as_ipynb(
- path: MarimoPath, sort_mode: Literal["top-down", "topological"]
+async def export_ipynb(
+ request: IPYNBFileExportRequest,
) -> ExportResult:
- app = load_app(path.absolute_name)
- if app is None:
+ if request.execution is None:
+ app = load_app(request.path.absolute_name)
+ if app is None:
+ return ExportResult(
+ contents=b"",
+ download_filename=get_download_filename(
+ request.path.short_name, "ipynb"
+ ),
+ did_error=True,
+ )
+
+ # Try the requested sort mode, fall back to top-down if cycles exist
+ internal_app = InternalApp(app)
+ options = request.options
+ if options.sort_mode == "topological":
+ try:
+ # Check if graph can be accessed (raises CycleError/MultipleDefinitionError)
+ _ = internal_app.graph
+ except (CycleError, MultipleDefinitionError):
+ stderr = request.stderr or sys.stderr
+ stderr.write(
+ "Warning: Notebook has errors, "
+ "using top-down order instead of topological.\n"
+ )
+ options = IPYNBExportOptions(sort_mode="top-down")
+
+ result = Exporter().export_as_ipynb(
+ IPYNBExportRequest(
+ app=internal_app,
+ options=options,
+ )
+ )
return ExportResult(
- contents=b"",
- download_filename=get_download_filename(path.short_name, "ipynb"),
- did_error=True,
+ contents=result,
+ download_filename=get_download_filename(
+ request.path.short_name, "ipynb"
+ ),
+ did_error=False,
)
- # Try the requested sort mode, fall back to top-down if cycles exist
- internal_app = InternalApp(app)
- actual_sort_mode = sort_mode
- if sort_mode == "topological":
- try:
- # Check if graph can be accessed (raises CycleError/MultipleDefinitionError)
- _ = internal_app.graph
- except (CycleError, MultipleDefinitionError):
- echo(
- "Warning: Notebook has errors, "
- "using top-down order instead of topological.",
- err=True,
+ file_manager = load_notebook(request.path.absolute_name)
+ with patch_html_for_non_interactive_output():
+ # Use quiet=True to suppress runtime stdout/stderr since outputs
+ # are captured in the session_view and will be included in the ipynb
+ session_view, did_error = await run_notebook(
+ RunNotebookRequest(
+ file_manager=file_manager,
+ options=replace(request.execution, quiet=True),
)
- actual_sort_mode = "top-down"
+ )
result = Exporter().export_as_ipynb(
- app=internal_app,
- sort_mode=actual_sort_mode,
+ IPYNBExportRequest(
+ app=file_manager.app,
+ options=request.options,
+ session_view=session_view,
+ )
)
return ExportResult(
contents=result,
- download_filename=get_download_filename(path.short_name, "ipynb"),
- did_error=False,
+ download_filename=get_download_filename(
+ request.path.short_name, "ipynb"
+ ),
+ did_error=did_error,
)
-def export_as_wasm(
- path: MarimoPath,
- mode: Literal["edit", "run"],
- show_code: bool,
- asset_url: str | None = None,
- code_transform: Callable[[str], str] | None = None,
+async def export_wasm(
+ request: WASMFileExportRequest,
) -> ExportResult:
- _app = load_app(path.absolute_name)
- if _app is None:
+ if request.execution is None:
+ _app = load_app(request.path.absolute_name)
+ if _app is None:
+ return ExportResult(
+ contents=b"",
+ download_filename=get_download_filename(
+ request.path.short_name, "wasm.html"
+ ),
+ did_error=True,
+ )
+ app = InternalApp(_app)
+ # Inline the layout file, if it exists
+ app.inline_layout_file()
+ config = get_default_config_manager(
+ current_path=request.path.absolute_name
+ )
+ resolved = config.get_config()
+
+ code = app.to_py()
+ if request.code_transform is not None:
+ code = request.code_transform(code)
+
+ result = Exporter().export_as_wasm(
+ WASMExportRequest(
+ filename=request.path.short_name,
+ app_config=app.config,
+ display_config=resolved["display"],
+ code=code,
+ options=request.options,
+ sharing_config=resolved.get("sharing"),
+ )
+ )
return ExportResult(
- contents=b"",
- download_filename=get_download_filename(
- path.short_name, "wasm.html"
- ),
- did_error=True,
+ contents=result[0],
+ download_filename=result[1],
+ did_error=False,
)
- app = InternalApp(_app)
- # Inline the layout file, if it exists
- app.inline_layout_file()
- config = get_default_config_manager(current_path=path.absolute_name)
- resolved = config.get_config()
- code = app.to_py()
- if code_transform is not None:
- code = code_transform(code)
-
- result = Exporter().export_as_wasm(
- filename=path.short_name,
- app=app,
- display_config=resolved["display"],
- mode=mode,
- code=code,
- asset_url=asset_url,
- show_code=show_code,
- sharing_config=resolved.get("sharing"),
- )
- return ExportResult(
- contents=result[0],
- download_filename=result[1],
- did_error=False,
- )
+ return await _export_wasm_with_execution(request)
def notebook_uses_slides_layout(filepath: MarimoPath) -> bool:
@@ -218,159 +237,133 @@ def notebook_uses_slides_layout(filepath: MarimoPath) -> bool:
return False
-async def run_app_then_export_as_ipynb(
- filepath: MarimoPath,
- sort_mode: Literal["top-down", "topological"],
- cli_args: SerializedCLIArgs,
- argv: list[str] | None,
-) -> ExportResult:
- file_manager = load_notebook(filepath.absolute_name)
-
- with patch_html_for_non_interactive_output():
- # Use quiet=True to suppress runtime stdout/stderr since outputs
- # are captured in the session_view and will be included in the ipynb
- (session_view, did_error) = await run_app_until_completion(
- file_manager,
- cli_args,
- argv,
- quiet=True,
- )
-
- result = Exporter().export_as_ipynb(
- app=file_manager.app,
- sort_mode=sort_mode,
- session_view=session_view,
- )
- return ExportResult(
- contents=result,
- download_filename=get_download_filename(filepath.short_name, "ipynb"),
- did_error=did_error,
- )
-
-
-async def run_app_then_export_as_pdf(
- filepath: MarimoPath,
- *,
- include_outputs: bool,
- webpdf: bool,
- cli_args: SerializedCLIArgs,
- argv: list[str] | None,
- export_as: ExportPDFPreset | None,
- include_inputs: bool = True,
- rasterization_options: PDFRasterizationOptions | None = None,
- status_callback: PDFExportStatusCallback | None = None,
-) -> tuple[bytes | None, bool]:
- file_manager = load_notebook(filepath.absolute_name)
+async def export_pdf(
+ request: PDFFileExportRequest,
+) -> ExportResult | None:
+ file_manager = load_notebook(request.path.absolute_name)
session_view: SessionView | None = None
png_fallbacks: Mapping[CellId_t, str] | None = None
did_error = False
- if include_outputs:
+ if request.execution is not None:
emit_pdf_export_status(
- status_callback,
+ request.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
- (session_view, did_error) = await run_app_until_completion(
- file_manager,
- cli_args,
- argv,
- quiet=True,
+ session_view, did_error = await run_notebook(
+ RunNotebookRequest(
+ file_manager=file_manager,
+ options=replace(request.execution, quiet=True),
+ )
)
emit_pdf_export_status(
- status_callback,
+ request.status_callback,
phase="execute_complete",
message="notebook execution finished.",
)
if (
session_view is not None
- and rasterization_options is not None
- and rasterization_options.enabled
+ and request.rasterization is not None
+ and request.rasterization.enabled
):
- from marimo._server.export._pdf_raster import (
+ from marimo._export._pdf_raster import (
collect_pdf_png_fallbacks,
)
png_fallbacks = await collect_pdf_png_fallbacks(
- app=file_manager.app,
- session_view=session_view,
- filename=filepath.short_name,
- filepath=filepath.absolute_name,
- argv=argv,
- options=rasterization_options,
- status_callback=status_callback,
+ PDFRasterizationRequest(
+ app=file_manager.app,
+ session_view=session_view,
+ filename=request.path.short_name,
+ filepath=request.path.absolute_name,
+ options=request.rasterization,
+ live_page_url=request.live_page_url,
+ status_callback=request.status_callback,
+ )
)
emit_pdf_export_status(
- status_callback,
+ request.status_callback,
phase="prepare",
message="serializing notebook for PDF rendering...",
)
- exporter = Exporter()
- if export_as == "slides":
- pdf_data = await exporter.export_as_slides_pdf(
- app=file_manager.app,
- session_view=session_view,
- png_fallbacks=png_fallbacks,
- include_inputs=include_inputs,
- status_callback=status_callback,
- )
- else:
- pdf_data = exporter.export_as_pdf(
- app=file_manager.app,
- session_view=session_view,
- png_fallbacks=png_fallbacks,
- include_inputs=include_inputs,
- webpdf=webpdf,
- status_callback=status_callback,
- )
+ render_request = PDFExportRequest(
+ app=file_manager.app,
+ session_view=session_view,
+ png_fallbacks=png_fallbacks,
+ options=request.options,
+ status_callback=request.status_callback,
+ )
+ pdf_data = await render_pdf(render_request)
if pdf_data is not None:
emit_pdf_export_status(
- status_callback,
+ request.status_callback,
phase="complete",
message="done.",
)
- return pdf_data, did_error
+ else:
+ return None
+ return ExportResult(
+ contents=pdf_data,
+ download_filename=get_download_filename(
+ request.path.short_name, "pdf"
+ ),
+ did_error=did_error,
+ )
-async def run_app_then_export_as_html(
- path: MarimoPath,
- include_code: bool,
- cli_args: SerializedCLIArgs,
- argv: list[str],
- *,
- asset_url: str | None = None,
+
+async def export_html(
+ request: HTMLFileExportRequest,
) -> ExportResult:
- file_manager = load_notebook(path.absolute_name)
+ file_manager = load_notebook(request.path.absolute_name)
# Inline the layout file, if it exists
file_manager.app.inline_layout_file()
+ if request.execution is None:
+ from marimo._session.state.session_view import SessionView
+
+ session_view = SessionView()
+ for cell_data in file_manager.app.cell_manager.cell_data():
+ session_view.last_executed_code[cell_data.cell_id] = cell_data.code
+ did_error = False
+ else:
+ session_view, did_error = await run_notebook(
+ RunNotebookRequest(
+ file_manager=file_manager,
+ options=request.execution,
+ )
+ )
+
config = get_default_config_manager(current_path=file_manager.path)
resolved = config.get_config()
display_config = resolved["display"]
- session_view, did_error = await run_app_until_completion(
- file_manager,
- cli_args,
- argv=argv,
- )
# Export the session as HTML
html, filename = Exporter().export_as_html(
- filename=file_manager.filename,
- app=file_manager.app,
- session_view=session_view,
- display_config=display_config,
- sharing_config=resolved.get("sharing"),
- request=ExportAsHTMLRequest(
- include_code=include_code,
- download=False,
- files=[],
- asset_url=asset_url,
- ),
+ HTMLExportRequest(
+ filename=file_manager.filename,
+ app_code=file_manager.app.to_py(),
+ app_config=file_manager.app.config,
+ snapshot=serialize_notebook_snapshot(
+ file_manager.app,
+ session_view,
+ drop_virtual_file_outputs=False,
+ include_model_notifications=True,
+ ),
+ display_config=display_config,
+ options=request.options,
+ sharing_config=(
+ resolved.get("sharing")
+ if request.execution is not None
+ else None
+ ),
+ )
)
return ExportResult(
contents=html,
@@ -379,7 +372,7 @@ async def run_app_then_export_as_html(
)
-def bundle_cache_export(notebook_path: MarimoPath, out_dir: Path) -> None:
+def bundle_cache_export(request: CacheBundleRequest) -> None:
"""Copy an executed session's cached blobs into `<out_dir>/public/cache/`.
Reads the per-notebook export manifest the kernel wrote next to the blobs,
@@ -391,10 +384,11 @@ def bundle_cache_export(notebook_path: MarimoPath, out_dir: Path) -> None:
import shutil
from pathlib import PurePosixPath
- manifest_file = _cache_export_manifest_path(notebook_path)
+ manifest_file = _cache_export_manifest_path(request.notebook_path)
cache_src = manifest_file.parent
+ stdout = request.stdout or sys.stdout
if not manifest_file.exists():
- echo("No caches to bundle.")
+ stdout.write("No caches to bundle.\n")
return
try:
keys: list[str] = json.loads(manifest_file.read_text())
@@ -402,7 +396,7 @@ def bundle_cache_export(notebook_path: MarimoPath, out_dir: Path) -> None:
LOGGER.warning("Failed to read cache export manifest: %s", e)
return
- cache_dst = out_dir / "public" / "cache"
+ cache_dst = request.output_directory / "public" / "cache"
copied = 0
for key in keys:
if not isinstance(key, str):
@@ -423,7 +417,7 @@ def bundle_cache_export(notebook_path: MarimoPath, out_dir: Path) -> None:
copied += 1
except OSError as e:
LOGGER.warning("Failed to bundle cache file %s: %s", key, e)
- echo(f"Bundled {copied} cache files into {cache_dst}.")
+ stdout.write(f"Bundled {copied} cache files into {cache_dst}.\n")
def _cache_export_manifest_path(notebook_path: MarimoPath) -> Path:
@@ -440,16 +434,8 @@ def _cache_export_manifest_path(notebook_path: MarimoPath) -> Path:
return cache_dir / export_manifest_name(absolute)
-async def run_app_then_export_as_wasm(
- path: MarimoPath,
- mode: Literal["edit", "run"],
- show_code: bool,
- cli_args: SerializedCLIArgs,
- argv: list[str],
- *,
- asset_url: str | None = None,
- cache_export_dir: Path | None = None,
- code_transform: Callable[[str], str] | None = None,
+async def _export_wasm_with_execution(
+ request: WASMFileExportRequest,
) -> ExportResult:
"""Execute notebook and export as WASM HTML with embedded session.
@@ -457,12 +443,10 @@ async def run_app_then_export_as_wasm(
into `<cache_export_dir>/public/cache/` so the exported notebook ships
them and skips recomputation in the browser.
"""
- from marimo._session.state.serialize import (
- serialize_notebook,
- serialize_session_view,
- )
+ if request.execution is None:
+ raise ValueError("Execution options are required.")
- file_manager = load_notebook(path.absolute_name)
+ file_manager = load_notebook(request.path.absolute_name)
file_manager.app.inline_layout_file()
config = get_default_config_manager(current_path=file_manager.path)
@@ -475,50 +459,59 @@ async def run_app_then_export_as_wasm(
# `cache_cells`. Otherwise export runs fully live, so no cell's output
# (console included) is served from a warm cache and skips execution.
cache_dir = (
- cache_export_dir
- if cache_export_dir is not None and cache_cells_enabled(resolved)
+ request.cache_export_dir
+ if request.cache_export_dir is not None
+ and cache_cells_enabled(resolved)
else None
)
if cache_dir is not None:
# NB. drop a prior run's manifest so we never bundle a stale key set.
- _cache_export_manifest_path(path).unlink(missing_ok=True)
-
- session_view, did_error = await run_app_until_completion(
- file_manager,
- cli_args,
- argv=argv,
- cache_export=cache_dir is not None,
+ _cache_export_manifest_path(request.path).unlink(missing_ok=True)
+
+ session_view, did_error = await run_notebook(
+ RunNotebookRequest(
+ file_manager=file_manager,
+ options=replace(
+ request.execution,
+ cache_export=cache_dir is not None,
+ ),
+ )
)
if cache_dir is not None:
# NB. the run joined the kernel, which wrote the manifest on shutdown,
# so it's on disk to read now.
- bundle_cache_export(path, cache_dir)
+ bundle_cache_export(
+ CacheBundleRequest(
+ notebook_path=request.path,
+ output_directory=cache_dir,
+ stdout=request.stdout,
+ )
+ )
- session_snapshot = serialize_session_view(
+ snapshot = serialize_notebook_snapshot(
+ file_manager.app,
session_view,
- cell_ids=file_manager.app.cell_manager.cell_ids(),
drop_virtual_file_outputs=True,
)
- notebook_snapshot = serialize_notebook(
- session_view, file_manager.app.cell_manager
- )
- code = pin_pep723_dependencies_for_wasm(file_manager.app.to_py(), path)
- if code_transform is not None:
- code = code_transform(code)
+ code = pin_pep723_dependencies_for_wasm(
+ file_manager.app.to_py(), request.path
+ )
+ if request.code_transform is not None:
+ code = request.code_transform(code)
html, filename = Exporter().export_as_wasm(
- filename=file_manager.filename,
- app=file_manager.app,
- display_config=display_config,
- code=code,
- mode=mode,
- show_code=show_code,
- asset_url=asset_url,
- session_snapshot=session_snapshot,
- notebook_snapshot=notebook_snapshot,
- sharing_config=resolved.get("sharing"),
+ WASMExportRequest(
+ filename=file_manager.filename,
+ app_config=file_manager.app.config,
+ display_config=display_config,
+ code=code,
+ options=request.options,
+ session_snapshot=snapshot.session,
+ notebook_snapshot=snapshot.notebook,
+ sharing_config=resolved.get("sharing"),
+ )
)
return ExportResult(
contents=html,
@@ -527,58 +520,18 @@ async def run_app_then_export_as_wasm(
)
-async def export_as_html_without_execution(
- path: MarimoPath,
- include_code: bool,
- *,
- asset_url: str | None = None,
-) -> ExportResult:
- """Export a notebook to HTML without executing its cells."""
- from marimo._session.state.session_view import SessionView
-
- file_manager = load_notebook(path.absolute_name)
-
- # Inline the layout file, if it exists.
- file_manager.app.inline_layout_file()
-
- view = SessionView()
- for cell_data in file_manager.app.cell_manager.cell_data():
- view.last_executed_code[cell_data.cell_id] = cell_data.code
-
- config = get_default_config_manager(current_path=file_manager.path)
- display_config = config.get_config()["display"]
-
- html, filename = Exporter().export_as_html(
- filename=file_manager.filename,
- app=file_manager.app,
- session_view=view,
- display_config=display_config,
- request=ExportAsHTMLRequest(
- include_code=include_code,
- download=False,
- files=[],
- asset_url=asset_url,
- ),
- )
- return ExportResult(
- contents=html,
- download_filename=filename,
- did_error=False,
- )
-
-
-async def run_app_then_export_as_reactive_html(
- path: MarimoPath,
- include_code: bool,
+async def export_reactive_html(
+ request: ReactiveHTMLFileExportRequest,
) -> ExportResult:
from marimo._islands._island_generator import MarimoIslandGenerator
generator = MarimoIslandGenerator.from_file(
- path.absolute_name, display_code=include_code
+ request.path.absolute_name,
+ display_code=request.include_code,
)
await generator.build()
html = generator.render_html()
- basename = os.path.basename(path.absolute_name)
+ basename = os.path.basename(request.path.absolute_name)
filename = f"{os.path.splitext(basename)[0]}.html"
return ExportResult(
contents=html,
@@ -587,18 +540,16 @@ async def run_app_then_export_as_reactive_html(
)
-async def run_app_until_completion(
- file_manager: AppFileManager,
- cli_args: SerializedCLIArgs,
- argv: list[str] | None,
- quiet: bool = False,
- persist_session: bool = True,
- cache_export: bool = False,
+async def run_notebook(
+ request: RunNotebookRequest,
) -> tuple[SessionView, bool]:
from marimo._session.consumer import SessionConsumer
from marimo._session.events import SessionEventBus
from marimo._session.session import SessionImpl
+ file_manager = request.file_manager
+ options = request.options
+ stderr = options.stderr or sys.stderr
instantiated_event = asyncio.Event()
class RunUntilCompletionSessionConsumer(SessionConsumer):
@@ -620,14 +571,14 @@ async def run_app_until_completion(
for err in errors:
# Not all errors are fatal
if is_unexpected_error(err):
- if not quiet:
- echo(
- f"{err.__class__.__name__}: {err.describe()}",
- file=sys.stderr,
+ if not options.quiet:
+ stderr.write(
+ f"{err.__class__.__name__}: "
+ f"{err.describe()}\n"
)
self.did_error = True
- if console_output and not quiet:
+ if console_output and not options.quiet:
console_as_list: list[CellOutput] = (
console_output
if isinstance(console_output, list)
@@ -639,7 +590,7 @@ async def run_app_until_completion(
# piped output
mimetype = line.mimetype
if mimetype == "text/plain":
- echo(line.data, file=sys.stderr, nl=False)
+ stderr.write(str(line.data))
except Exception:
LOGGER.warning("Error printing console output")
@@ -664,7 +615,7 @@ async def run_app_until_completion(
"auto_reload": "off",
"watcher_on_save": "lazy",
}
- if cache_export:
+ if options.cache_export:
# Cache every executed cell so the export can bundle the results;
# this same flag gates the kernel's export-manifest dump on teardown.
runtime_overrides["cache_cells"] = True
@@ -686,8 +637,8 @@ async def run_app_until_completion(
app_metadata=AppMetadata(
query_params={},
filename=file_manager.path,
- cli_args=cli_args,
- argv=argv,
+ cli_args=options.cli_args,
+ argv=options.argv,
app_config=file_manager.app.config,
docstring=extract_docstring_from_header(
file_manager.app._app._header
@@ -711,8 +662,8 @@ async def run_app_until_completion(
# console operations.
await asyncio.sleep(0.1)
- if persist_session:
- from marimo._server.export._session_cache import (
+ if options.persist_session:
+ from marimo._export._session_cache import (
persist_session_view_to_cache,
)
@@ -732,7 +683,7 @@ async def run_app_until_completion(
# Stop distributor, terminate kernel process, etc -- all information is
# captured by the session view. When exporting caches, close gracefully so
# the kernel flushes the cache manifest that bundle_cache_export reads next.
- session.close(graceful=cache_export)
+ session.close(graceful=options.cache_export)
return session.session_view, session_consumer.did_error
diff --git a/marimo/_cli/export/local_modules.py b/marimo/_export/local_modules.py
similarity index 97%
rename from marimo/_cli/export/local_modules.py
rename to marimo/_export/local_modules.py
index e3c0901fae..21c7ca8f17 100644
--- a/marimo/_cli/export/local_modules.py
+++ b/marimo/_export/local_modules.py
@@ -28,7 +28,6 @@ from operator import attrgetter
from pathlib import Path
from typing import TYPE_CHECKING, Literal
-from marimo._cli.errors import MarimoCLIMissingDependencyError
from marimo._dependencies.dependencies import DependencyManager
from marimo._utils.uv import find_uv_bin
@@ -44,6 +43,10 @@ class LocalWheelError(Exception):
pass
+class UVNotFoundError(LocalWheelError):
+ pass
+
+
@dataclass(frozen=True)
class LocalModule:
name: str
@@ -243,11 +246,9 @@ def _ruff_graph_command(
def _uv_bin() -> str:
uv_bin = find_uv_bin()
if uv_bin == "uv" and not DependencyManager.which("uv"):
- raise MarimoCLIMissingDependencyError(
+ raise UVNotFoundError(
"uv must be installed to resolve local imports for "
- "html-wasm export.",
- "uv",
- additional_tip="Install uv from https://github.com/astral-sh/uv",
+ "html-wasm export."
)
return uv_bin
diff --git a/marimo/_cli/export/local_wheels.py b/marimo/_export/local_wheels.py
similarity index 99%
rename from marimo/_cli/export/local_wheels.py
rename to marimo/_export/local_wheels.py
index b6999c7260..a6ecb3a432 100644
--- a/marimo/_cli/export/local_wheels.py
+++ b/marimo/_export/local_wheels.py
@@ -32,7 +32,7 @@ from typing import TYPE_CHECKING
from urllib.parse import quote, unquote, urlparse
from urllib.request import url2pathname
-from marimo._cli.export.local_modules import (
+from marimo._export.local_modules import (
LocalModule,
LocalWheelError,
module_python_files,
diff --git a/marimo/_export/requests.py b/marimo/_export/requests.py
new file mode 100644
index 0000000000..986e2c88a8
--- /dev/null
+++ b/marimo/_export/requests.py
@@ -0,0 +1,194 @@
+# Copyright 2026 Marimo. All rights reserved.
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from contextlib import AbstractContextManager
+from dataclasses import dataclass
+from functools import cached_property
+from pathlib import Path # noqa: TC003
+from typing import Protocol
+
+from marimo._ast.app import InternalApp
+from marimo._ast.app_config import _AppConfig
+from marimo._config.config import DisplayConfig, SharingConfig
+from marimo._export._status import PDFExportStatusCallback
+from marimo._runtime.commands import SerializedCLIArgs
+from marimo._schemas.export_options import (
+ HTMLExportOptions,
+ IPYNBExportOptions,
+ MarkdownExportOptions,
+ NotebookExportSnapshot,
+ PDFExportOptions,
+ PDFRasterizationOptions,
+ WASMExportOptions,
+)
+from marimo._schemas.notebook import NotebookV1
+from marimo._schemas.serialization import NotebookSerialization
+from marimo._schemas.session import NotebookSessionV1
+from marimo._session.notebook import AppFileManager
+from marimo._session.state.session_view import SessionView
+from marimo._types.ids import CellId_t
+from marimo._utils.marimo_path import MarimoPath
+
+LivePageURLProvider = Callable[[], AbstractContextManager[str]]
+
+
+class TextWriter(Protocol):
+ def write(self, value: str, /) -> object: ...
+
+
+@dataclass(kw_only=True)
+class ExportResult:
+ contents: bytes | str
+ download_filename: str
+ did_error: bool
+
+ @cached_property
+ def bytez(self) -> bytes:
+ """Return UTF-8 encoded bytes (cached)."""
+ if isinstance(self.contents, bytes):
+ return self.contents
+ return self.contents.encode("utf-8")
+
+ @cached_property
+ def text(self) -> str:
+ """Return UTF-8 decoded text (cached)."""
+ if isinstance(self.contents, str):
+ return self.contents
+ return self.contents.decode("utf-8")
+
+
+@dataclass(frozen=True, kw_only=True)
+class ScriptExportRequest:
+ notebook: NotebookSerialization
+
+
+@dataclass(frozen=True, kw_only=True)
+class MarkdownExportRequest:
+ notebook: NotebookSerialization
+ options: MarkdownExportOptions
+
+
+@dataclass(frozen=True, kw_only=True)
+class HTMLExportRequest:
+ filename: str | None
+ app_code: str
+ app_config: _AppConfig
+ snapshot: NotebookExportSnapshot
+ display_config: DisplayConfig
+ options: HTMLExportOptions
+ sharing_config: SharingConfig | None = None
+
+
+@dataclass(frozen=True, kw_only=True)
+class IPYNBExportRequest:
+ app: InternalApp
+ options: IPYNBExportOptions
+ session_view: SessionView | None = None
+
+
+@dataclass(frozen=True, kw_only=True)
+class WASMExportRequest:
+ filename: str | None
+ app_config: _AppConfig
+ display_config: DisplayConfig
+ code: str
+ options: WASMExportOptions
+ session_snapshot: NotebookSessionV1 | None = None
+ notebook_snapshot: NotebookV1 | None = None
+ sharing_config: SharingConfig | None = None
+
+
+@dataclass(frozen=True, kw_only=True)
+class PDFExportRequest:
+ app: InternalApp
+ session_view: SessionView | None
+ options: PDFExportOptions
+ png_fallbacks: Mapping[CellId_t, str] | None = None
+ status_callback: PDFExportStatusCallback | None = None
+
+
+@dataclass(frozen=True, kw_only=True)
+class NotebookExecutionOptions:
+ cli_args: SerializedCLIArgs
+ argv: list[str] | None
+ quiet: bool = False
+ persist_session: bool = True
+ cache_export: bool = False
+ stderr: TextWriter | None = None
+
+
+@dataclass(frozen=True, kw_only=True)
+class RunNotebookRequest:
+ file_manager: AppFileManager
+ options: NotebookExecutionOptions
+
+
+@dataclass(frozen=True, kw_only=True)
+class ScriptFileExportRequest:
+ path: MarimoPath
+
+
+@dataclass(frozen=True, kw_only=True)
+class MarkdownFileExportRequest:
+ path: MarimoPath
+ options: MarkdownExportOptions
+
+
+@dataclass(frozen=True, kw_only=True)
+class IPYNBFileExportRequest:
+ path: MarimoPath
+ options: IPYNBExportOptions
+ execution: NotebookExecutionOptions | None = None
+ stderr: TextWriter | None = None
+
+
+@dataclass(frozen=True, kw_only=True)
+class HTMLFileExportRequest:
+ path: MarimoPath
+ options: HTMLExportOptions
+ execution: NotebookExecutionOptions | None = None
+
+
+@dataclass(frozen=True, kw_only=True)
+class WASMFileExportRequest:
+ path: MarimoPath
+ options: WASMExportOptions
+ execution: NotebookExecutionOptions | None = None
+ cache_export_dir: Path | None = None
+ code_transform: Callable[[str], str] | None = None
+ stdout: TextWriter | None = None
+
+
+@dataclass(frozen=True, kw_only=True)
+class PDFFileExportRequest:
+ path: MarimoPath
+ options: PDFExportOptions
+ rasterization: PDFRasterizationOptions | None = None
+ execution: NotebookExecutionOptions | None = None
+ live_page_url: LivePageURLProvider | None = None
+ status_callback: PDFExportStatusCallback | None = None
+
+
+@dataclass(frozen=True, kw_only=True)
+class PDFRasterizationRequest:
+ app: InternalApp
+ session_view: SessionView
+ filename: str | None
+ filepath: str | None
+ options: PDFRasterizationOptions
+ live_page_url: LivePageURLProvider | None = None
+ status_callback: PDFExportStatusCallback | None = None
+
+
+@dataclass(frozen=True, kw_only=True)
+class ReactiveHTMLFileExportRequest:
+ path: MarimoPath
+ include_code: bool
+
+
+@dataclass(frozen=True, kw_only=True)
+class CacheBundleRequest:
+ notebook_path: MarimoPath
+ output_directory: Path
+ stdout: TextWriter | None = None
diff --git a/marimo/_export/serialization.py b/marimo/_export/serialization.py
new file mode 100644
index 0000000000..d8e707befa
--- /dev/null
+++ b/marimo/_export/serialization.py
@@ -0,0 +1,32 @@
+# Copyright 2026 Marimo. All rights reserved.
+from __future__ import annotations
+
+from marimo._ast.app import InternalApp
+from marimo._schemas.export_options import NotebookExportSnapshot
+from marimo._session.state.serialize import (
+ serialize_notebook,
+ serialize_session_view,
+)
+from marimo._session.state.session_view import SessionView
+
+
+def serialize_notebook_snapshot(
+ app: InternalApp,
+ session_view: SessionView,
+ *,
+ drop_virtual_file_outputs: bool,
+ include_model_notifications: bool = False,
+) -> NotebookExportSnapshot:
+ return NotebookExportSnapshot(
+ notebook=serialize_notebook(session_view, app.cell_manager),
+ session=serialize_session_view(
+ session_view,
+ cell_ids=app.cell_manager.cell_ids(),
+ drop_virtual_file_outputs=drop_virtual_file_outputs,
+ ),
+ model_notifications=(
+ tuple(session_view.get_model_notifications())
+ if include_model_notifications
+ else ()
+ ),
+ )
diff --git a/marimo/_internal/server/requests.py b/marimo/_internal/server/requests.py
index 49e704dfd2..5c74d41b4f 100644
--- a/marimo/_internal/server/requests.py
+++ b/marimo/_internal/server/requests.py
@@ -1,13 +1,13 @@
# Copyright 2026 Marimo. All rights reserved.
"""Internal API for server request types."""
-from marimo._server.models.export import (
+from marimo._schemas.export import (
ExportAsHTMLRequest,
ExportAsIPYNBRequest,
ExportAsMarkdownRequest,
ExportAsScriptRequest,
)
-from marimo._server.models.models import InstantiateNotebookRequest
+from marimo._session.requests import InstantiateNotebookRequest
__all__ = [
"ExportAsHTMLRequest",
diff --git a/marimo/_islands/_island_generator.py b/marimo/_islands/_island_generator.py
index 0a88ef2287..9556173737 100644
--- a/marimo/_islands/_island_generator.py
+++ b/marimo/_islands/_island_generator.py
@@ -23,8 +23,8 @@ from marimo._schemas.islands import (
MarimoIslandPayload,
)
from marimo._schemas.serialization import NotebookSerialization
-from marimo._server.templates.templates import json_script
from marimo._session.notebook import AppFileManager, load_notebook
+from marimo._templates import json_script
from marimo._types.ids import CellId_t
from marimo._utils.marimo_path import MarimoPath
from marimo._version import __version__
@@ -454,17 +454,26 @@ class MarimoIslandGenerator:
- App: The built app.
"""
- from marimo._server.export import run_app_until_completion
+ from marimo._export.file import run_notebook
+ from marimo._export.requests import (
+ NotebookExecutionOptions,
+ RunNotebookRequest,
+ )
if self.has_run:
raise ValueError("You can only call build() once")
- (session, did_error) = await run_app_until_completion(
- file_manager=AppFileManager.from_app(
- self._app, filename=self._source_filename
- ),
- cli_args={},
- argv=None,
+ session, did_error = await run_notebook(
+ RunNotebookRequest(
+ file_manager=AppFileManager.from_app(
+ self._app,
+ filename=self._source_filename,
+ ),
+ options=NotebookExecutionOptions(
+ cli_args={},
+ argv=None,
+ ),
+ )
)
del did_error
self.has_run = True
diff --git a/marimo/_pyodide/pyodide_session.py b/marimo/_pyodide/pyodide_session.py
index d0617a002c..baaeb01c1e 100644
--- a/marimo/_pyodide/pyodide_session.py
+++ b/marimo/_pyodide/pyodide_session.py
@@ -14,7 +14,9 @@ from marimo._config.config import (
PartialMarimoConfig,
merge_default_config,
)
-from marimo._convert.markdown import convert_from_ir_to_markdown
+from marimo._export.exporter import Exporter, export_markdown
+from marimo._export.requests import HTMLExportRequest, MarkdownExportRequest
+from marimo._export.serialization import serialize_notebook_snapshot
from marimo._messaging.msgspec_encoder import encode_json_str
from marimo._messaging.types import KernelStreams
from marimo._pyodide.restartable_task import RestartableTask
@@ -33,9 +35,14 @@ from marimo._runtime.commands import (
UpdateUserConfigCommand,
)
from marimo._runtime.marimo_pdb import MarimoPdb
-from marimo._server.export.exporter import Exporter
+from marimo._schemas.export import (
+ ExportAsHTMLRequest,
+ to_html_export_options,
+)
+from marimo._schemas.export_options import (
+ MarkdownExportOptions,
+)
from marimo._server.files.os_file_system import OSFileSystem
-from marimo._server.models.export import ExportAsHTMLRequest
from marimo._server.models.files import (
FileCopyRequest,
FileCopyResponse,
@@ -387,19 +394,33 @@ class PyodideBridge:
def export_html(self, request: str) -> str:
parsed = self._parse(request, ExportAsHTMLRequest)
+ app = self.session.app_manager.app
html, _filename = Exporter().export_as_html(
- app=self.session.app_manager.app,
- filename=self.session.app_manager.filename,
- session_view=self.session.session_view,
- display_config=self.session._initial_user_config["display"],
- request=parsed,
+ HTMLExportRequest(
+ filename=self.session.app_manager.filename,
+ app_code=app.to_py(),
+ app_config=app.config,
+ snapshot=serialize_notebook_snapshot(
+ app,
+ self.session.session_view,
+ drop_virtual_file_outputs=False,
+ include_model_notifications=True,
+ ),
+ display_config=self.session._initial_user_config["display"],
+ options=to_html_export_options(parsed),
+ )
)
return json.dumps(html)
def export_markdown(self, request: str) -> str:
del request
- md = convert_from_ir_to_markdown(self.session.app_manager.app.to_ir())
- return json.dumps(md)
+ result = export_markdown(
+ MarkdownExportRequest(
+ notebook=self.session.app_manager.app.to_ir(),
+ options=MarkdownExportOptions(),
+ )
+ )
+ return json.dumps(result.text)
def _parse(self, request: str, cls: type[T]) -> T:
return parse_raw(request, cls)
diff --git a/marimo/_server/models/export.py b/marimo/_schemas/export.py
similarity index 70%
rename from marimo/_server/models/export.py
rename to marimo/_schemas/export.py
index 9760284824..d82af9398c 100644
--- a/marimo/_server/models/export.py
+++ b/marimo/_schemas/export.py
@@ -1,11 +1,14 @@
# Copyright 2026 Marimo. All rights reserved.
from __future__ import annotations
-from typing import Literal
-
import msgspec
from marimo._messaging.mimetypes import MimeBundleTuple
+from marimo._schemas.export_options import (
+ ExportPDFPreset,
+ HTMLExportOptions,
+ PDFRasterServer,
+)
from marimo._types.ids import CellId_t
@@ -16,6 +19,16 @@ class ExportAsHTMLRequest(msgspec.Struct, rename="camel"):
asset_url: str | None = None
+def to_html_export_options(
+ request: ExportAsHTMLRequest,
+) -> HTMLExportOptions:
+ return HTMLExportOptions(
+ files=tuple(request.files),
+ include_code=request.include_code,
+ asset_url=request.asset_url,
+ )
+
+
class ExportAsScriptRequest(msgspec.Struct, rename="camel"):
download: bool
@@ -28,16 +41,13 @@ class ExportAsMarkdownRequest(msgspec.Struct, rename="camel"):
download: bool
-ExportPDFPreset = Literal["document", "slides"]
-
-
class ExportAsPDFRequest(msgspec.Struct, rename="camel"):
webpdf: bool
preset: ExportPDFPreset = "document"
include_inputs: bool = False
rasterize_outputs: bool = True
raster_scale: float = 4.0
- raster_server: Literal["static", "live"] = "static"
+ raster_server: PDFRasterServer = "static"
class UpdateCellOutputsRequest(msgspec.Struct, rename="camel"):
diff --git a/marimo/_schemas/export_options.py b/marimo/_schemas/export_options.py
new file mode 100644
index 0000000000..9a269e8e2a
--- /dev/null
+++ b/marimo/_schemas/export_options.py
@@ -0,0 +1,62 @@
+# Copyright 2026 Marimo. All rights reserved.
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+from marimo._convert.markdown.flavor.base import MarkdownFlavorName
+from marimo._messaging.notification import ModelLifecycleNotification
+from marimo._schemas.notebook import NotebookV1
+from marimo._schemas.session import NotebookSessionV1
+
+ExportPDFPreset = Literal["document", "slides"]
+IPYNBSortMode = Literal["top-down", "topological"]
+PDFRasterServer = Literal["static", "live"]
+WASMMode = Literal["edit", "run"]
+
+
+@dataclass(frozen=True, kw_only=True)
+class NotebookExportSnapshot:
+ notebook: NotebookV1
+ session: NotebookSessionV1
+ model_notifications: tuple[ModelLifecycleNotification, ...] = ()
+
+
+@dataclass(frozen=True, kw_only=True)
+class HTMLExportOptions:
+ files: tuple[str, ...]
+ include_code: bool
+ asset_url: str | None = None
+
+
+@dataclass(frozen=True, kw_only=True)
+class MarkdownExportOptions:
+ flavor: MarkdownFlavorName | None = None
+ filename: str | None = None
+ source_filename: str | None = None
+
+
+@dataclass(frozen=True, kw_only=True)
+class WASMExportOptions:
+ mode: WASMMode
+ show_code: bool
+ asset_url: str | None = None
+
+
+@dataclass(frozen=True, kw_only=True)
+class IPYNBExportOptions:
+ sort_mode: IPYNBSortMode
+
+
+@dataclass(frozen=True, kw_only=True)
+class PDFRasterizationOptions:
+ enabled: bool = True
+ scale: float = 4.0
+ server_mode: PDFRasterServer = "static"
+
+
+@dataclass(frozen=True, kw_only=True)
+class PDFExportOptions:
+ webpdf: bool
+ preset: ExportPDFPreset
+ include_inputs: bool
diff --git a/marimo/_server/api/endpoints/assets.py b/marimo/_server/api/endpoints/assets.py
index 4286cf447f..bf01597c65 100644
--- a/marimo/_server/api/endpoints/assets.py
+++ b/marimo/_server/api/endpoints/assets.py
@@ -32,13 +32,13 @@ from marimo._server.api.auth import TOKEN_QUERY_PARAM
from marimo._server.api.deps import AppState
from marimo._server.files.path_validator import PathValidator
from marimo._server.router import APIRouter
-from marimo._server.templates.templates import (
+from marimo._session.model import SessionMode
+from marimo._templates import (
home_page_template,
inject_script,
json_script,
notebook_page_template,
)
-from marimo._session.model import SessionMode
from marimo._utils.async_path import AsyncPath
from marimo._utils.paths import (
MARIMO_DIR_NAME,
diff --git a/marimo/_server/api/endpoints/execution.py b/marimo/_server/api/endpoints/execution.py
index 2f01c17c75..7a1d24e13f 100644
--- a/marimo/_server/api/endpoints/execution.py
+++ b/marimo/_server/api/endpoints/execution.py
@@ -30,13 +30,11 @@ from marimo._server.models.models import (
DebugCellRequest,
ExecuteCellsRequest,
ExecuteScratchpadRequest,
- InstantiateNotebookRequest,
InvokeFunctionRequest,
KernelStatusResponse,
ModelRequest,
SetBreakpointsRequest,
SuccessResponse,
- UpdateUIElementValuesRequest,
)
from marimo._server.router import APIRouter
from marimo._server.sse import wait_for_http_disconnect
@@ -46,6 +44,10 @@ from marimo._session.consumer_policy import (
TakeoverDecision,
can_take_over_editing,
)
+from marimo._session.requests import (
+ InstantiateNotebookRequest,
+ UpdateUIElementValuesRequest,
+)
from marimo._session.types import KernelState
from marimo._types.ids import ConsumerId
from marimo._utils.asyncio_utils import cancel_and_wait
diff --git a/marimo/_server/api/endpoints/export.py b/marimo/_server/api/endpoints/export.py
index 647eca29a4..79781c40d3 100644
--- a/marimo/_server/api/endpoints/export.py
+++ b/marimo/_server/api/endpoints/export.py
@@ -18,27 +18,41 @@ from marimo._convert.common.filename import (
get_download_filename,
make_download_headers,
)
-from marimo._convert.markdown import convert_from_ir_to_markdown
-from marimo._convert.markdown.flavor import (
- markdown_output_filename,
- normalize_markdown_flavor,
-)
-from marimo._convert.script import convert_from_ir_to_script
from marimo._dependencies.dependencies import DependencyManager
-from marimo._messaging.msgspec_encoder import asdict
-from marimo._server.api.deps import AppState
-from marimo._server.api.utils import (
- notify_server_missing_packages,
- parse_request,
+from marimo._export.exporter import (
+ AutoExporter,
+ Exporter,
+ export_markdown,
+ export_script,
+ render_pdf,
+)
+from marimo._export.requests import (
+ HTMLExportRequest,
+ IPYNBExportRequest,
+ MarkdownExportRequest,
+ PDFExportRequest,
+ ScriptExportRequest,
)
-from marimo._server.export.exporter import AutoExporter, Exporter
-from marimo._server.models.export import (
+from marimo._export.serialization import serialize_notebook_snapshot
+from marimo._messaging.msgspec_encoder import asdict
+from marimo._schemas.export import (
ExportAsHTMLRequest,
ExportAsIPYNBRequest,
ExportAsMarkdownRequest,
ExportAsPDFRequest,
ExportAsScriptRequest,
UpdateCellOutputsRequest,
+ to_html_export_options,
+)
+from marimo._schemas.export_options import (
+ IPYNBExportOptions,
+ MarkdownExportOptions,
+ PDFExportOptions,
+)
+from marimo._server.api.deps import AppState
+from marimo._server.api.utils import (
+ notify_server_missing_packages,
+ parse_request,
)
from marimo._server.models.models import SuccessResponse
from marimo._server.router import APIRouter
@@ -47,8 +61,6 @@ from marimo._utils.http import HTTPStatus
if TYPE_CHECKING:
from starlette.requests import Request
- from marimo._schemas.serialization import NotebookSerializationV1
-
LOGGER = _loggers.marimo_logger()
# Router for export endpoints
@@ -57,22 +69,6 @@ router = APIRouter()
auto_exporter = AutoExporter()
-def _export_markdown(
- notebook: NotebookSerializationV1, filename: str | None
-) -> tuple[str, str]:
- export_filename = filename or notebook.filename
- markdown_flavor = normalize_markdown_flavor(
- None, filename=export_filename or "notebook.md"
- )
- markdown = convert_from_ir_to_markdown(
- notebook, filename=export_filename, flavor=markdown_flavor
- )
- return (
- markdown,
- markdown_output_filename(export_filename, markdown_flavor),
- )
-
-
@router.post("/html")
@requires("read")
async def export_as_html(
@@ -117,13 +113,22 @@ async def export_as_html(
body.include_code = False
resolved_config = session.config_manager.get_config()
+ app = session.app_file_manager.app
html, filename = Exporter().export_as_html(
- app=session.app_file_manager.app,
- filename=session.app_file_manager.filename,
- session_view=session.session_view,
- display_config=resolved_config["display"],
- sharing_config=resolved_config.get("sharing"),
- request=body,
+ HTMLExportRequest(
+ filename=session.app_file_manager.filename,
+ app_code=app.to_py(),
+ app_config=app.config,
+ snapshot=serialize_notebook_snapshot(
+ app,
+ session.session_view,
+ drop_virtual_file_outputs=False,
+ include_model_notifications=True,
+ ),
+ display_config=resolved_config["display"],
+ options=to_html_export_options(body),
+ sharing_config=resolved_config.get("sharing"),
+ )
)
if body.download:
@@ -191,12 +196,21 @@ async def auto_export_as_html(
return PlainTextResponse(status_code=HTTPStatus.NOT_MODIFIED)
async def _background_export() -> None:
+ app = session.app_file_manager.app
html, _filename = Exporter().export_as_html(
- app=session.app_file_manager.app,
- filename=session.app_file_manager.filename,
- session_view=session_view,
- display_config=session.config_manager.get_config()["display"],
- request=body,
+ HTMLExportRequest(
+ filename=session.app_file_manager.filename,
+ app_code=app.to_py(),
+ app_config=app.config,
+ snapshot=serialize_notebook_snapshot(
+ app,
+ session_view,
+ drop_virtual_file_outputs=False,
+ include_model_notifications=True,
+ ),
+ display_config=session.config_manager.get_config()["display"],
+ options=to_html_export_options(body),
+ )
)
# Save the HTML file to disk, at `.marimo/<filename>.html`
@@ -244,7 +258,11 @@ async def export_as_script(
body = await parse_request(request, cls=ExportAsScriptRequest)
session = app_state.require_current_session()
- python = convert_from_ir_to_script(session.app_file_manager.app.to_ir())
+ result = export_script(
+ ScriptExportRequest(
+ notebook=session.app_file_manager.app.to_ir(),
+ )
+ )
filename = get_download_filename(
session.app_file_manager.filename, "script.py"
)
@@ -256,7 +274,7 @@ async def export_as_script(
# Download the Script
return PlainTextResponse(
- content=python,
+ content=result.text,
headers=headers,
)
@@ -301,18 +319,24 @@ async def export_as_markdown(
detail="File must be saved before downloading",
)
- markdown, download_filename = _export_markdown(
- app_file_manager.app.to_ir(), app_file_manager.filename
+ result = export_markdown(
+ MarkdownExportRequest(
+ notebook=app_file_manager.app.to_ir(),
+ options=MarkdownExportOptions(
+ filename=app_file_manager.filename,
+ source_filename=app_file_manager.filename,
+ ),
+ )
)
if body.download:
- headers = make_download_headers(download_filename)
+ headers = make_download_headers(result.download_filename)
else:
headers = {}
# Download the Markdown
return PlainTextResponse(
- content=markdown,
+ content=result.text,
headers=headers,
)
@@ -356,9 +380,11 @@ async def export_as_ipynb(
)
ipynb = Exporter().export_as_ipynb(
- app=session.app_file_manager.app,
- sort_mode="top-down",
- session_view=session.session_view,
+ IPYNBExportRequest(
+ app=session.app_file_manager.app,
+ options=IPYNBExportOptions(sort_mode="top-down"),
+ session_view=session.session_view,
+ )
)
if body.download:
@@ -423,14 +449,17 @@ async def auto_export_as_markdown(
# Reload the file manager to get the latest state
session.app_file_manager.reload()
- markdown = convert_from_ir_to_markdown(
- session.app_file_manager.app.to_ir()
+ result = export_markdown(
+ MarkdownExportRequest(
+ notebook=session.app_file_manager.app.to_ir(),
+ options=MarkdownExportOptions(),
+ )
)
# Save the Markdown file to disk, at `.marimo/<filename>.md`
await auto_exporter.save_md(
filename=session.app_file_manager.filename,
- markdown=markdown,
+ markdown=result.text,
)
session_view.mark_auto_export_md()
@@ -500,9 +529,11 @@ async def auto_export_as_ipynb(
session.app_file_manager.reload()
ipynb = Exporter().export_as_ipynb(
- app=session.app_file_manager.app,
- sort_mode="top-down",
- session_view=session_view,
+ IPYNBExportRequest(
+ app=session.app_file_manager.app,
+ options=IPYNBExportOptions(sort_mode="top-down"),
+ session_view=session_view,
+ )
)
# Save the IPYNB file to disk, at `.marimo/<filename>.ipynb`
@@ -556,20 +587,16 @@ async def export_as_pdf(*, request: Request) -> Response:
detail="File must have a name before exporting",
)
- exporter = Exporter()
- if body.preset == "slides":
- pdf_data = await exporter.export_as_slides_pdf(
- app=session.app_file_manager.app,
- session_view=session.session_view,
- include_inputs=body.include_inputs,
- )
- else:
- pdf_data = exporter.export_as_pdf(
- app=session.app_file_manager.app,
- session_view=session.session_view,
+ export_request = PDFExportRequest(
+ app=session.app_file_manager.app,
+ session_view=session.session_view,
+ options=PDFExportOptions(
webpdf=body.webpdf,
+ preset=body.preset,
include_inputs=body.include_inputs,
- )
+ ),
+ )
+ pdf_data = await render_pdf(export_request)
if pdf_data is None:
raise HTTPException(
status_code=HTTPStatus.SERVER_ERROR, detail="Failed to export PDF"
diff --git a/marimo/_server/api/endpoints/ws/ws_session_connector.py b/marimo/_server/api/endpoints/ws/ws_session_connector.py
index 6a43643edb..b88555b051 100644
--- a/marimo/_server/api/endpoints/ws/ws_session_connector.py
+++ b/marimo/_server/api/endpoints/ws/ws_session_connector.py
@@ -22,8 +22,8 @@ from marimo import _loggers
from marimo._messaging.types import NoopStream
from marimo._runtime.params import QueryParams
from marimo._server.codes import WebSocketCloseReason, WebSocketCodes
-from marimo._server.models.models import InstantiateNotebookRequest
from marimo._session.model import ConnectionState, SessionMode
+from marimo._session.requests import InstantiateNotebookRequest
LOGGER = _loggers.marimo_logger()
diff --git a/marimo/_server/api/utils.py b/marimo/_server/api/utils.py
index 05f50ceafc..a93999a972 100644
--- a/marimo/_server/api/utils.py
+++ b/marimo/_server/api/utils.py
@@ -7,7 +7,6 @@ import sys
import webbrowser
from contextlib import asynccontextmanager
from dataclasses import dataclass
-from pathlib import Path
from shutil import which
from typing import (
TYPE_CHECKING,
@@ -229,18 +228,6 @@ def get_code_mode_credentials(
return server_url, auth_token
-def parse_title(filepath: str | None) -> str:
- """
- Create a title from a filename.
- """
- if filepath is None:
- return "marimo"
-
- # filename is used as title, except basename and suffix are
- # stripped and underscores are replaced with spaces
- return Path(filepath).stem.replace("_", " ")
-
-
def open_url_in_browser(browser: str, url: str) -> None:
"""
Open a browser to the given URL.
diff --git a/marimo/_server/models/models.py b/marimo/_server/models/models.py
index 19d55f536b..5d4d9a1c95 100644
--- a/marimo/_server/models/models.py
+++ b/marimo/_server/models/models.py
@@ -33,7 +33,7 @@ from marimo._runtime.commands import (
UpdateUserConfigCommand,
ValidateSQLCommand,
)
-from marimo._types.ids import CellId_t, UIElementId
+from marimo._types.ids import CellId_t
class ListSecretKeysRequest(ListSecretKeysCommand, tag=False):
@@ -211,26 +211,6 @@ class CodeCompletionRequest(CodeCompletionCommand, tag=False):
)
-class UpdateUIElementValuesRequest(msgspec.Struct, rename="camel"):
- object_ids: list[UIElementId]
- values: list[Any]
-
- # Validate same length
- def __post_init__(self) -> None:
- assert len(self.object_ids) == len(self.values), (
- "Mismatched object_ids and values"
- )
-
-
-class InstantiateNotebookRequest(UpdateUIElementValuesRequest):
- auto_run: bool = True
- # Optional: cell codes to use instead of the codes from the file.
- # This is used when the frontend has local edits that should be
- # used instead of the file codes (e.g., pre-connect editing).
- # Maps cell_id -> code.
- codes: dict[CellId_t, str] | None = None
-
-
class BaseResponse(msgspec.Struct, rename="camel"):
success: bool
diff --git a/marimo/_server/scratchpad.py b/marimo/_server/scratchpad.py
index 1e7bdad727..7f4dd34ea2 100644
--- a/marimo/_server/scratchpad.py
+++ b/marimo/_server/scratchpad.py
@@ -22,9 +22,9 @@ from marimo._messaging.notification import (
from marimo._messaging.serde import deserialize_kernel_message
from marimo._runtime.commands import ExecuteScratchpadCommand, HTTPRequest
from marimo._runtime.scratch import SCRATCH_CELL_ID
-from marimo._server.models.models import InstantiateNotebookRequest
from marimo._server.sse import format_sse_event
from marimo._session.extensions.types import EventAwareExtension
+from marimo._session.requests import InstantiateNotebookRequest
if TYPE_CHECKING:
from collections.abc import AsyncGenerator
diff --git a/marimo/_server/templates/api.py b/marimo/_server/templates/api.py
index 03e5f2319f..0f55176fbe 100644
--- a/marimo/_server/templates/api.py
+++ b/marimo/_server/templates/api.py
@@ -16,13 +16,13 @@ from marimo._config.config import MarimoConfig, PartialMarimoConfig
from marimo._convert.converters import MarimoConvert
from marimo._schemas.notebook import NotebookV1
from marimo._schemas.session import NotebookSessionV1
-from marimo._server.templates.templates import (
+from marimo._server.tokens import SkewProtectionToken
+from marimo._session.model import SessionMode
+from marimo._templates import (
_custom_css_block,
notebook_page_template,
static_notebook_template,
)
-from marimo._server.tokens import SkewProtectionToken
-from marimo._session.model import SessionMode
from marimo._utils.code import hash_code
diff --git a/marimo/_session/requests.py b/marimo/_session/requests.py
new file mode 100644
index 0000000000..261853f4ed
--- /dev/null
+++ b/marimo/_session/requests.py
@@ -0,0 +1,28 @@
+# Copyright 2026 Marimo. All rights reserved.
+from __future__ import annotations
+
+from typing import Any
+
+import msgspec
+
+from marimo._types.ids import CellId_t, UIElementId
+
+
+class UpdateUIElementValuesRequest(msgspec.Struct, rename="camel"):
+ object_ids: list[UIElementId]
+ values: list[Any]
+
+ # Validate same length
+ def __post_init__(self) -> None:
+ assert len(self.object_ids) == len(self.values), (
+ "Mismatched object_ids and values"
+ )
+
+
+class InstantiateNotebookRequest(UpdateUIElementValuesRequest):
+ auto_run: bool = True
+ # Optional: cell codes to use instead of the codes from the file.
+ # This is used when the frontend has local edits that should be
+ # used instead of the file codes (e.g., pre-connect editing).
+ # Maps cell_id -> code.
+ codes: dict[CellId_t, str] | None = None
diff --git a/marimo/_session/session.py b/marimo/_session/session.py
index f7cdb01e96..5176747549 100644
--- a/marimo/_session/session.py
+++ b/marimo/_session/session.py
@@ -67,8 +67,8 @@ if TYPE_CHECKING:
from collections.abc import Iterator
from marimo._runtime.virtual_file import VirtualFileStorageType
- from marimo._server.models.models import InstantiateNotebookRequest
from marimo._session.app_host import AppHostContext
+ from marimo._session.requests import InstantiateNotebookRequest
LOGGER = _loggers.marimo_logger()
diff --git a/marimo/_server/templates/templates.py b/marimo/_templates.py
similarity index 99%
rename from marimo/_server/templates/templates.py
rename to marimo/_templates.py
index 3389a9f4fb..1fbdce6d73 100644
--- a/marimo/_server/templates/templates.py
+++ b/marimo/_templates.py
@@ -12,12 +12,12 @@ from typing import TYPE_CHECKING, Any, Literal, cast
from marimo._ast.app_config import _AppConfig
from marimo._config.config import MarimoConfig, PartialMarimoConfig
+from marimo._convert.common.filename import parse_title
from marimo._convert.converters import MarimoConvert
from marimo._messaging.notification import ModelLifecycleNotification
from marimo._output.utils import uri_encode_component
from marimo._schemas.notebook import NotebookV1
from marimo._schemas.session import NotebookSessionV1
-from marimo._server.api.utils import parse_title
from marimo._server.tokens import SkewProtectionToken
from marimo._session.model import SessionMode
from marimo._session.notebook import read_css_file, read_html_head_file
diff --git a/tests/_cli/test_cli.py b/tests/_cli/test_cli.py
index 0ccd546c7f..58166b3ea6 100644
--- a/tests/_cli/test_cli.py
+++ b/tests/_cli/test_cli.py
@@ -36,11 +36,11 @@ from marimo._cli.cli import (
)
from marimo._config.manager import get_default_config_manager
from marimo._dependencies.dependencies import DependencyManager
-from marimo._server.templates.templates import get_version
from marimo._server.workspace import (
DirectoryWorkspace,
FixedFilesWorkspace,
)
+from marimo._templates import get_version
from marimo._utils.platform import is_windows
from marimo._utils.toml import toml_reader
diff --git a/tests/_cli/test_cli_export.py b/tests/_cli/test_cli_export.py
index b664b14ece..948a3a016f 100644
--- a/tests/_cli/test_cli_export.py
+++ b/tests/_cli/test_cli_export.py
@@ -19,9 +19,9 @@ from click.testing import CliRunner, Result
from marimo._cli.cli import main
from marimo._cli.export.commands import pdf
-from marimo._cli.export.local_modules import _ruff_import_graph
-from marimo._cli.export.local_wheels import _local_wheel_path
from marimo._dependencies.dependencies import DependencyManager
+from marimo._export.local_modules import _ruff_import_graph
+from marimo._export.local_wheels import _local_wheel_path
from marimo._output.utils import uri_decode_component
from marimo._session.state.serialize import get_session_cache_file
from marimo._utils import async_path
@@ -190,11 +190,11 @@ def test_ruff_import_graph_ignores_successful_stderr(tmp_path: Path) -> None:
)
with (
mock.patch(
- "marimo._cli.export.local_modules._ruff_graph_command",
+ "marimo._export.local_modules._ruff_graph_command",
return_value=("ruff",),
),
mock.patch(
- "marimo._cli.export.local_modules.subprocess.run",
+ "marimo._export.local_modules.subprocess.run",
return_value=result,
),
):
@@ -1214,7 +1214,7 @@ class TestExportIpynb:
def test_export_ipynb_cli_args_passed_to_export(
self, temp_marimo_file_with_md: str
) -> None:
- from marimo._server.export import ExportResult
+ from marimo._export.requests import ExportResult
fake_result = ExportResult(
contents="{}", download_filename="test.ipynb", did_error=False
@@ -1225,7 +1225,7 @@ class TestExportIpynb:
return fake_result
with mock.patch(
- "marimo._cli.export.commands.run_app_then_export_as_ipynb",
+ "marimo._cli.export.commands.export_ipynb",
side_effect=fake_export,
) as mock_export:
p = _run_export(
@@ -1241,12 +1241,13 @@ class TestExportIpynb:
_assert_success(p)
mock_export.assert_called_once()
- call_kwargs = mock_export.call_args
- assert call_kwargs.kwargs["cli_args"] == {
+ request = mock_export.call_args.args[0]
+ assert request.execution is not None
+ assert request.execution.cli_args == {
"arg1": "foo",
"arg2": "bar",
}
- assert call_kwargs.kwargs["argv"] == [
+ assert request.execution.argv == [
"--arg1",
"foo",
"--arg2",
@@ -1411,17 +1412,24 @@ class TestExportPDF:
from unittest.mock import AsyncMock, patch
from marimo._cli.export.commands import pdf as pdf_command
+ from marimo._export.requests import ExportResult
output_file = tmp_path / "out.pdf"
runner = CliRunner()
- mock_run_app = AsyncMock(return_value=(b"mock_pdf", False))
+ mock_run_app = AsyncMock(
+ return_value=ExportResult(
+ contents=b"mock_pdf",
+ download_filename="out.pdf",
+ did_error=False,
+ )
+ )
with (
patch(
"marimo._cli.export.commands.DependencyManager.require_many"
),
patch(
- "marimo._cli.export.commands.run_app_then_export_as_pdf",
+ "marimo._cli.export.commands.export_pdf",
mock_run_app,
),
):
@@ -1441,8 +1449,8 @@ class TestExportPDF:
assert result.exit_code == 0
assert output_file.read_bytes() == b"mock_pdf"
assert mock_run_app.await_count == 1
- call_kwargs = mock_run_app.await_args.kwargs
- assert call_kwargs["export_as"] == "slides"
+ request = mock_run_app.await_args.args[0]
+ assert request.options.preset == "slides"
@staticmethod
def test_export_pdf_slides_shows_live_raster_recommendation(
@@ -1452,10 +1460,17 @@ class TestExportPDF:
from unittest.mock import AsyncMock, patch
from marimo._cli.export.commands import pdf as pdf_command
+ from marimo._export.requests import ExportResult
output_file = tmp_path / "slides-tip.pdf"
runner = CliRunner()
- mock_run_app = AsyncMock(return_value=(b"mock_pdf", False))
+ mock_run_app = AsyncMock(
+ return_value=ExportResult(
+ contents=b"mock_pdf",
+ download_filename="slides-tip.pdf",
+ did_error=False,
+ )
+ )
with (
patch(
@@ -1465,7 +1480,7 @@ class TestExportPDF:
"marimo._cli.export.commands.DependencyManager.playwright.require"
),
patch(
- "marimo._cli.export.commands.run_app_then_export_as_pdf",
+ "marimo._cli.export.commands.export_pdf",
mock_run_app,
),
):
@@ -1484,8 +1499,95 @@ class TestExportPDF:
assert result.exit_code == 0
assert "For --as=slides, prefer --raster-server=live" in result.output
assert mock_run_app.await_count == 1
- call_kwargs = mock_run_app.await_args.kwargs
- assert call_kwargs["rasterization_options"].server_mode == "static"
+ request = mock_run_app.await_args.args[0]
+ assert request.rasterization is not None
+ assert request.rasterization.server_mode == "static"
+
+ @staticmethod
+ def test_export_pdf_defers_live_server_startup(
+ 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._export.requests import ExportResult
+
+ output_file = tmp_path / "live.pdf"
+ mock_export = AsyncMock(
+ return_value=ExportResult(
+ contents=b"mock_pdf",
+ download_filename="live.pdf",
+ did_error=False,
+ )
+ )
+
+ with (
+ patch(
+ "marimo._cli.export.commands.DependencyManager.require_many"
+ ),
+ patch(
+ "marimo._cli.export.commands.DependencyManager.playwright.require"
+ ),
+ patch(
+ "marimo._cli.export.commands.export_pdf",
+ mock_export,
+ ),
+ patch(
+ "marimo._cli.export.live_notebook_server.LiveNotebookServer"
+ ) as live_server,
+ ):
+ result = CliRunner().invoke(
+ pdf_command,
+ [
+ "--output",
+ str(output_file),
+ "--raster-server",
+ "live",
+ "--no-sandbox",
+ temp_marimo_file,
+ ],
+ )
+
+ assert result.exit_code == 0
+ request = mock_export.await_args.args[0]
+ assert request.live_page_url is not None
+ live_server.assert_not_called()
+
+ @staticmethod
+ def test_export_pdf_reports_empty_result_once(
+ temp_marimo_file: str,
+ tmp_path: Path,
+ ) -> None:
+ from unittest.mock import AsyncMock, patch
+
+ from marimo._cli.export.commands import pdf as pdf_command
+
+ with (
+ patch(
+ "marimo._cli.export.commands.DependencyManager.require_many"
+ ),
+ patch(
+ "marimo._cli.export.commands.export_pdf",
+ AsyncMock(return_value=None),
+ ),
+ ):
+ result = CliRunner().invoke(
+ pdf_command,
+ [
+ "--output",
+ str(tmp_path / "empty.pdf"),
+ "--no-include-outputs",
+ "--no-sandbox",
+ temp_marimo_file,
+ ],
+ )
+
+ assert result.exit_code != 0
+ assert "Failed to export PDF." in result.output
+ assert (
+ "Failed to export PDF: Failed to export PDF." not in result.output
+ )
@staticmethod
def test_export_pdf_shows_slides_hint_when_preset_missing(
@@ -1495,10 +1597,17 @@ class TestExportPDF:
from unittest.mock import AsyncMock, patch
from marimo._cli.export.commands import pdf as pdf_command
+ from marimo._export.requests import ExportResult
output_file = tmp_path / "hint.pdf"
runner = CliRunner()
- mock_run_app = AsyncMock(return_value=(b"mock_pdf", False))
+ mock_run_app = AsyncMock(
+ return_value=ExportResult(
+ contents=b"mock_pdf",
+ download_filename="hint.pdf",
+ did_error=False,
+ )
+ )
with (
patch(
@@ -1509,7 +1618,7 @@ class TestExportPDF:
return_value=True,
),
patch(
- "marimo._cli.export.commands.run_app_then_export_as_pdf",
+ "marimo._cli.export.commands.export_pdf",
mock_run_app,
),
):
@@ -1527,8 +1636,8 @@ class TestExportPDF:
assert result.exit_code == 0
assert "Use --as=slides for slide-style PDF export." in result.output
assert mock_run_app.await_count == 1
- call_kwargs = mock_run_app.await_args.kwargs
- assert call_kwargs["export_as"] is None
+ request = mock_run_app.await_args.args[0]
+ assert request.options.preset == "document"
@staticmethod
def test_export_pdf_reports_stage_status_updates(
@@ -1538,16 +1647,16 @@ class TestExportPDF:
from unittest.mock import AsyncMock, patch
from marimo._cli.export.commands import pdf as pdf_command
- from marimo._server.export._status import PDFExportStatusEvent
+ from marimo._export._status import PDFExportStatusEvent
+ from marimo._export.requests import ExportResult
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"]
+ async def fake_run_app(*args: Any, **kwargs: Any) -> ExportResult:
+ del kwargs
+ request = args[0]
+ status_callback = request.status_callback
status_callback(
PDFExportStatusEvent(
phase="execute",
@@ -1580,7 +1689,11 @@ class TestExportPDF:
message="done.",
)
)
- return b"mock_pdf", False
+ return ExportResult(
+ contents=b"mock_pdf",
+ download_filename="status.pdf",
+ did_error=False,
+ )
mock_run_app = AsyncMock(side_effect=fake_run_app)
@@ -1592,7 +1705,7 @@ class TestExportPDF:
"marimo._cli.export.commands.DependencyManager.playwright.require"
),
patch(
- "marimo._cli.export.commands.run_app_then_export_as_pdf",
+ "marimo._cli.export.commands.export_pdf",
mock_run_app,
),
):
diff --git a/tests/_cli/test_export_cache_bundle.py b/tests/_cli/test_export_cache_bundle.py
index da13e2be28..13bb8f3bbb 100644
--- a/tests/_cli/test_export_cache_bundle.py
+++ b/tests/_cli/test_export_cache_bundle.py
@@ -13,14 +13,19 @@ from __future__ import annotations
import json
from typing import TYPE_CHECKING
+from marimo._cli.export.output import STDOUT
+from marimo._config.settings import GLOBAL_SETTINGS
+from marimo._export.file import bundle_cache_export
+from marimo._export.requests import CacheBundleRequest
from marimo._save.stores.file import export_manifest_name
-from marimo._server.export import bundle_cache_export
from marimo._utils.marimo_path import MarimoPath
from marimo._utils.paths import notebook_output_dir
if TYPE_CHECKING:
from pathlib import Path
+ import pytest
+
def _notebook(tmp_path: Path) -> MarimoPath:
nb = tmp_path / "nb.py"
@@ -45,10 +50,36 @@ def test_no_manifest_is_a_noop(tmp_path: Path) -> None:
_cache_dir(tmp_path) # cache dir exists, but no manifest was written
out_dir = tmp_path / "dist"
out_dir.mkdir()
- bundle_cache_export(_notebook(tmp_path), out_dir)
+ bundle_cache_export(
+ CacheBundleRequest(
+ notebook_path=_notebook(tmp_path),
+ output_directory=out_dir,
+ )
+ )
assert not (out_dir / "public" / "cache").exists()
+def test_no_manifest_respects_cli_quiet(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ _cache_dir(tmp_path)
+ out_dir = tmp_path / "dist"
+ out_dir.mkdir()
+ monkeypatch.setattr(GLOBAL_SETTINGS, "QUIET", True)
+
+ bundle_cache_export(
+ CacheBundleRequest(
+ notebook_path=_notebook(tmp_path),
+ output_directory=out_dir,
+ stdout=STDOUT,
+ )
+ )
+
+ assert capsys.readouterr().out == ""
+
+
def test_keys_copied(tmp_path: Path) -> None:
cache = _cache_dir(tmp_path)
nb = _notebook(tmp_path)
@@ -59,7 +90,9 @@ def test_keys_copied(tmp_path: Path) -> None:
out_dir = tmp_path / "dist"
out_dir.mkdir()
- bundle_cache_export(nb, out_dir)
+ bundle_cache_export(
+ CacheBundleRequest(notebook_path=nb, output_directory=out_dir)
+ )
dst = out_dir / "public" / "cache"
assert (dst / "lazy" / "E_abc.jsonl").read_bytes() == b"manifest-line\n"
@@ -74,7 +107,9 @@ def test_missing_listed_file_skipped(tmp_path: Path) -> None:
out_dir = tmp_path / "dist"
out_dir.mkdir()
- bundle_cache_export(nb, out_dir)
+ bundle_cache_export(
+ CacheBundleRequest(notebook_path=nb, output_directory=out_dir)
+ )
dst = out_dir / "public" / "cache"
assert (dst / "present.bin").exists()
@@ -91,7 +126,9 @@ def test_keys_outside_session_not_bundled(tmp_path: Path) -> None:
out_dir = tmp_path / "dist"
out_dir.mkdir()
- bundle_cache_export(nb, out_dir)
+ bundle_cache_export(
+ CacheBundleRequest(notebook_path=nb, output_directory=out_dir)
+ )
dst = out_dir / "public" / "cache"
assert (dst / "mine.bin").exists()
@@ -107,7 +144,9 @@ def test_corrupt_manifest_is_a_noop(tmp_path: Path) -> None:
out_dir = tmp_path / "dist"
out_dir.mkdir()
- bundle_cache_export(nb, out_dir)
+ bundle_cache_export(
+ CacheBundleRequest(notebook_path=nb, output_directory=out_dir)
+ )
assert not (out_dir / "public" / "cache").exists()
@@ -123,7 +162,9 @@ def test_non_string_key_skipped(tmp_path: Path) -> None:
out_dir = tmp_path / "dist"
out_dir.mkdir()
- bundle_cache_export(nb, out_dir)
+ bundle_cache_export(
+ CacheBundleRequest(notebook_path=nb, output_directory=out_dir)
+ )
dst = out_dir / "public" / "cache"
assert (dst / "ok.bin").read_bytes() == b"ok"
@@ -141,7 +182,9 @@ def test_path_traversal_key_rejected(tmp_path: Path) -> None:
out_dir = tmp_path / "dist"
out_dir.mkdir()
- bundle_cache_export(nb, out_dir)
+ bundle_cache_export(
+ CacheBundleRequest(notebook_path=nb, output_directory=out_dir)
+ )
dst = out_dir / "public" / "cache"
assert (dst / "ok.bin").exists()
diff --git a/tests/_server/test_server_utils.py b/tests/_convert/common/test_filename.py
similarity index 92%
rename from tests/_server/test_server_utils.py
rename to tests/_convert/common/test_filename.py
index 71072eee50..2ac27acdee 100644
--- a/tests/_server/test_server_utils.py
+++ b/tests/_convert/common/test_filename.py
@@ -1,7 +1,7 @@
# Copyright 2026 Marimo. All rights reserved.
from __future__ import annotations
-from marimo._server.api.utils import parse_title
+from marimo._convert.common.filename import parse_title
def test_parse_title() -> None:
diff --git a/tests/_server/export/fixtures/apps/basic.py b/tests/_export/fixtures/apps/basic.py
similarity index 100%
rename from tests/_server/export/fixtures/apps/basic.py
rename to tests/_export/fixtures/apps/basic.py
diff --git a/tests/_server/export/fixtures/apps/empty_notebook.py b/tests/_export/fixtures/apps/empty_notebook.py
similarity index 100%
rename from tests/_server/export/fixtures/apps/empty_notebook.py
rename to tests/_export/fixtures/apps/empty_notebook.py
diff --git a/tests/_server/export/fixtures/apps/error_ancestor.py b/tests/_export/fixtures/apps/error_ancestor.py
similarity index 100%
rename from tests/_server/export/fixtures/apps/error_ancestor.py
rename to tests/_export/fixtures/apps/error_ancestor.py
diff --git a/tests/_server/export/fixtures/apps/error_complex.py b/tests/_export/fixtures/apps/error_complex.py
similarity index 100%
rename from tests/_server/export/fixtures/apps/error_complex.py
rename to tests/_export/fixtures/apps/error_complex.py
diff --git a/tests/_server/export/fixtures/apps/error_cycle.py b/tests/_export/fixtures/apps/error_cycle.py
similarity index 100%
rename from tests/_server/export/fixtures/apps/error_cycle.py
rename to tests/_export/fixtures/apps/error_cycle.py
diff --git a/tests/_server/export/fixtures/apps/error_redefinition.py b/tests/_export/fixtures/apps/error_redefinition.py
similarity index 100%
rename from tests/_server/export/fixtures/apps/error_redefinition.py
rename to tests/_export/fixtures/apps/error_redefinition.py
diff --git a/tests/_server/export/fixtures/apps/error_undefined.py b/tests/_export/fixtures/apps/error_undefined.py
similarity index 100%
rename from tests/_server/export/fixtures/apps/error_undefined.py
rename to tests/_export/fixtures/apps/error_undefined.py
diff --git a/tests/_server/export/fixtures/apps/error_value_with_stdout.py b/tests/_export/fixtures/apps/error_value_with_stdout.py
similarity index 100%
rename from tests/_server/export/fixtures/apps/error_value_with_stdout.py
rename to tests/_export/fixtures/apps/error_value_with_stdout.py
diff --git a/tests/_server/export/fixtures/apps/with_console_output.py b/tests/_export/fixtures/apps/with_console_output.py
similarity index 100%
rename from tests/_server/export/fixtures/apps/with_console_output.py
rename to tests/_export/fixtures/apps/with_console_output.py
diff --git a/tests/_server/export/fixtures/apps/with_dependencies.py b/tests/_export/fixtures/apps/with_dependencies.py
similarity index 100%
rename from tests/_server/export/fixtures/apps/with_dependencies.py
rename to tests/_export/fixtures/apps/with_dependencies.py
diff --git a/tests/_server/export/fixtures/apps/with_layout.py b/tests/_export/fixtures/apps/with_layout.py
similarity index 100%
rename from tests/_server/export/fixtures/apps/with_layout.py
rename to tests/_export/fixtures/apps/with_layout.py
diff --git a/tests/_server/export/fixtures/apps/with_outputs.py b/tests/_export/fixtures/apps/with_outputs.py
similarity index 100%
rename from tests/_server/export/fixtures/apps/with_outputs.py
rename to tests/_export/fixtures/apps/with_outputs.py
diff --git a/tests/_server/export/fixtures/apps/with_stop.py b/tests/_export/fixtures/apps/with_stop.py
similarity index 100%
rename from tests/_server/export/fixtures/apps/with_stop.py
rename to tests/_export/fixtures/apps/with_stop.py
diff --git a/tests/_server/export/snapshots/ipynb/basic.ipynb.txt b/tests/_export/snapshots/ipynb/basic.ipynb.txt
similarity index 100%
rename from tests/_server/export/snapshots/ipynb/basic.ipynb.txt
rename to tests/_export/snapshots/ipynb/basic.ipynb.txt
diff --git a/tests/_server/export/snapshots/ipynb/empty_notebook.ipynb.txt b/tests/_export/snapshots/ipynb/empty_notebook.ipynb.txt
similarity index 100%
rename from tests/_server/export/snapshots/ipynb/empty_notebook.ipynb.txt
rename to tests/_export/snapshots/ipynb/empty_notebook.ipynb.txt
diff --git a/tests/_server/export/snapshots/ipynb/error_ancestor.ipynb.txt b/tests/_export/snapshots/ipynb/error_ancestor.ipynb.txt
similarity index 100%
rename from tests/_server/export/snapshots/ipynb/error_ancestor.ipynb.txt
rename to tests/_export/snapshots/ipynb/error_ancestor.ipynb.txt
diff --git a/tests/_server/export/snapshots/ipynb/error_complex.ipynb.txt b/tests/_export/snapshots/ipynb/error_complex.ipynb.txt
similarity index 100%
rename from tests/_server/export/snapshots/ipynb/error_complex.ipynb.txt
rename to tests/_export/snapshots/ipynb/error_complex.ipynb.txt
diff --git a/tests/_server/export/snapshots/ipynb/error_cycle.ipynb.txt b/tests/_export/snapshots/ipynb/error_cycle.ipynb.txt
similarity index 100%
rename from tests/_server/export/snapshots/ipynb/error_cycle.ipynb.txt
rename to tests/_export/snapshots/ipynb/error_cycle.ipynb.txt
diff --git a/tests/_server/export/snapshots/ipynb/error_redefinition.ipynb.txt b/tests/_export/snapshots/ipynb/error_redefinition.ipynb.txt
similarity index 100%
rename from tests/_server/export/snapshots/ipynb/error_redefinition.ipynb.txt
rename to tests/_export/snapshots/ipynb/error_redefinition.ipynb.txt
diff --git a/tests/_server/export/snapshots/ipynb/error_undefined.ipynb.txt b/tests/_export/snapshots/ipynb/error_undefined.ipynb.txt
similarity index 100%
rename from tests/_server/export/snapshots/ipynb/error_undefined.ipynb.txt
rename to tests/_export/snapshots/ipynb/error_undefined.ipynb.txt
diff --git a/tests/_server/export/snapshots/ipynb/error_value_with_stdout.ipynb.txt b/tests/_export/snapshots/ipynb/error_value_with_stdout.ipynb.txt
similarity index 100%
rename from tests/_server/export/snapshots/ipynb/error_value_with_stdout.ipynb.txt
rename to tests/_export/snapshots/ipynb/error_value_with_stdout.ipynb.txt
diff --git a/tests/_server/export/snapshots/ipynb/with_console_output.ipynb.txt b/tests/_export/snapshots/ipynb/with_console_output.ipynb.txt
similarity index 100%
rename from tests/_server/export/snapshots/ipynb/with_console_output.ipynb.txt
rename to tests/_export/snapshots/ipynb/with_console_output.ipynb.txt
diff --git a/tests/_server/export/snapshots/ipynb/with_dependencies.ipynb.txt b/tests/_export/snapshots/ipynb/with_dependencies.ipynb.txt
similarity index 100%
rename from tests/_server/export/snapshots/ipynb/with_dependencies.ipynb.txt
rename to tests/_export/snapshots/ipynb/with_dependencies.ipynb.txt
diff --git a/tests/_server/export/snapshots/ipynb/with_layout.ipynb.txt b/tests/_export/snapshots/ipynb/with_layout.ipynb.txt
similarity index 100%
rename from tests/_server/export/snapshots/ipynb/with_layout.ipynb.txt
rename to tests/_export/snapshots/ipynb/with_layout.ipynb.txt
diff --git a/tests/_server/export/snapshots/ipynb/with_outputs.ipynb.txt b/tests/_export/snapshots/ipynb/with_outputs.ipynb.txt
similarity index 100%
rename from tests/_server/export/snapshots/ipynb/with_outputs.ipynb.txt
rename to tests/_export/snapshots/ipynb/with_outputs.ipynb.txt
diff --git a/tests/_server/export/snapshots/ipynb/with_stop.ipynb.txt b/tests/_export/snapshots/ipynb/with_stop.ipynb.txt
similarity index 100%
rename from tests/_server/export/snapshots/ipynb/with_stop.ipynb.txt
rename to tests/_export/snapshots/ipynb/with_stop.ipynb.txt
diff --git a/tests/_server/export/snapshots/run_until_completion_with_console_output.txt b/tests/_export/snapshots/run_notebook_with_console_output.txt
similarity index 100%
rename from tests/_server/export/snapshots/run_until_completion_with_console_output.txt
rename to tests/_export/snapshots/run_notebook_with_console_output.txt
diff --git a/tests/_server/export/snapshots/run_until_completion_with_stack_trace.txt b/tests/_export/snapshots/run_notebook_with_stack_trace.txt
similarity index 100%
rename from tests/_server/export/snapshots/run_until_completion_with_stack_trace.txt
rename to tests/_export/snapshots/run_notebook_with_stack_trace.txt
diff --git a/tests/_server/export/snapshots/run_until_completion_with_stop.txt b/tests/_export/snapshots/run_notebook_with_stop.txt
similarity index 100%
rename from tests/_server/export/snapshots/run_until_completion_with_stop.txt
rename to tests/_export/snapshots/run_notebook_with_stop.txt
diff --git a/tests/_export/test_export_dependencies.py b/tests/_export/test_export_dependencies.py
new file mode 100644
index 0000000000..8dd843d020
--- /dev/null
+++ b/tests/_export/test_export_dependencies.py
@@ -0,0 +1,73 @@
+# Copyright 2026 Marimo. All rights reserved.
+from __future__ import annotations
+
+import subprocess
+import sys
+
+
+def test_export_modules_do_not_require_click_or_starlette() -> None:
+ script = """
+import importlib
+import pkgutil
+import sys
+from dataclasses import replace
+
+
+class BlockedDependency:
+ def find_spec(self, fullname, path=None, target=None):
+ del path, target
+ if (
+ fullname.partition(".")[0] in {"click", "starlette"}
+ or fullname == "marimo._cli.export"
+ or fullname.startswith("marimo._cli.export.")
+ or fullname == "marimo._server.api"
+ or fullname.startswith("marimo._server.api.")
+ ):
+ raise RuntimeError(f"blocked import: {fullname}")
+ return None
+
+
+sys.meta_path.insert(0, BlockedDependency())
+import marimo._export as export_package
+
+for module in pkgutil.walk_packages(
+ export_package.__path__, f"{export_package.__name__}."
+):
+ importlib.import_module(module.name)
+
+from marimo._convert.converters import MarimoConvert
+from marimo._convert.script import UnsupportedAsyncCodeError
+from marimo._export.exporter import export_script
+from marimo._export.requests import ScriptExportRequest
+
+source = '''
+import marimo
+
+__generated_with = "0.0.0"
+app = marimo.App()
+
+async def _():
+ await foo()
+ return
+
+if __name__ == "__main__":
+ app.run()
+'''
+notebook = replace(
+ MarimoConvert.from_py(source).to_ir(),
+ filename="notebook.py",
+)
+try:
+ export_script(ScriptExportRequest(notebook=notebook))
+except UnsupportedAsyncCodeError:
+ pass
+else:
+ raise AssertionError("async script export should fail")
+"""
+ subprocess.run(
+ [sys.executable, "-c", script],
+ check=True,
+ capture_output=True,
+ text=True,
+ )
diff --git a/tests/_server/export/test_export_ipynb.py b/tests/_export/test_export_ipynb.py
similarity index 82%
rename from tests/_server/export/test_export_ipynb.py
rename to tests/_export/test_export_ipynb.py
index 185b7d86f2..8f34ff9e23 100644
--- a/tests/_server/export/test_export_ipynb.py
+++ b/tests/_export/test_export_ipynb.py
@@ -12,7 +12,12 @@ from marimo._ast.app import InternalApp
from marimo._ast.load import load_app
from marimo._convert.ipynb.from_ir import convert_from_ir_to_ipynb
from marimo._dependencies.dependencies import DependencyManager
-from marimo._server.export import run_app_then_export_as_ipynb
+from marimo._export.file import export_ipynb
+from marimo._export.requests import (
+ IPYNBFileExportRequest,
+ NotebookExecutionOptions,
+)
+from marimo._schemas.export_options import IPYNBExportOptions
from marimo._utils.marimo_path import MarimoPath
from tests.mocks import delete_lines_with_files, simplify_images, snapshotter
@@ -66,11 +71,12 @@ async def test_export_ipynb(app_path: Path) -> None:
assert content is not None
# Test with actual run
- result = await run_app_then_export_as_ipynb(
- MarimoPath(app_path),
- sort_mode="top-down",
- cli_args={},
- argv=None,
+ result = await export_ipynb(
+ IPYNBFileExportRequest(
+ path=MarimoPath(app_path),
+ options=IPYNBExportOptions(sort_mode="top-down"),
+ execution=NotebookExecutionOptions(cli_args={}, argv=None),
+ )
)
assert result.download_filename == f"{app_path.stem}.ipynb"
content = delete_lines_with_files(result.text)
diff --git a/tests/_server/export/test_exporter.py b/tests/_export/test_exporter.py
similarity index 82%
rename from tests/_server/export/test_exporter.py
rename to tests/_export/test_exporter.py
index ed74957d66..4887eb682f 100644
--- a/tests/_server/export/test_exporter.py
+++ b/tests/_export/test_exporter.py
@@ -7,8 +7,10 @@ import pathlib
import sys
import textwrap
from concurrent.futures import ThreadPoolExecutor
+from copy import deepcopy
+from dataclasses import replace
from typing import TYPE_CHECKING, Any
-from unittest.mock import ANY, AsyncMock, MagicMock, patch
+from unittest.mock import AsyncMock, MagicMock, patch
import pytest
@@ -17,6 +19,29 @@ from marimo._ast.load import load_app
from marimo._config.config import DEFAULT_CONFIG
from marimo._dependencies.dependencies import Dependency, DependencyManager
from marimo._dependencies.errors import ManyModulesNotFoundError
+from marimo._export._status import PDFExportStatusEvent
+from marimo._export.exporter import Exporter, render_pdf
+from marimo._export.file import (
+ export_html,
+ export_ipynb,
+ export_markdown,
+ export_pdf,
+ export_wasm,
+ run_notebook,
+)
+from marimo._export.requests import (
+ HTMLExportRequest,
+ HTMLFileExportRequest,
+ IPYNBFileExportRequest,
+ MarkdownFileExportRequest,
+ NotebookExecutionOptions,
+ PDFExportRequest,
+ PDFFileExportRequest,
+ RunNotebookRequest,
+ WASMExportRequest,
+ WASMFileExportRequest,
+)
+from marimo._export.serialization import serialize_notebook_snapshot
from marimo._messaging.cell_output import CellChannel, CellOutput
from marimo._messaging.msgspec_encoder import encode_json_str
from marimo._messaging.notification import (
@@ -25,17 +50,18 @@ from marimo._messaging.notification import (
ModelLifecycleNotification,
ModelOpen,
)
-from marimo._server.export import (
- export_as_md,
- export_as_wasm,
- run_app_then_export_as_html,
- run_app_then_export_as_ipynb,
- run_app_then_export_as_pdf,
- run_app_until_completion,
+from marimo._schemas.export import (
+ ExportAsHTMLRequest,
+)
+from marimo._schemas.export_options import (
+ ExportPDFPreset,
+ HTMLExportOptions,
+ IPYNBExportOptions,
+ MarkdownExportOptions,
+ PDFExportOptions,
+ PDFRasterizationOptions,
+ WASMExportOptions,
)
-from marimo._server.export._status import PDFExportStatusEvent
-from marimo._server.export.exporter import Exporter
-from marimo._server.models.export import ExportAsHTMLRequest
from marimo._session.notebook import AppFileManager
from marimo._session.state.serialize import get_session_cache_file
from marimo._session.state.session_view import SessionView
@@ -59,6 +85,87 @@ HAS_DEPS = (
)
+def _html_export_request(
+ *,
+ filename: str | None,
+ app: InternalApp,
+ session_view: SessionView,
+ display_config: Any,
+ request: ExportAsHTMLRequest,
+ sharing_config: Any = None,
+) -> HTMLExportRequest:
+ return HTMLExportRequest(
+ filename=filename,
+ app_code=app.to_py(),
+ app_config=app.config,
+ snapshot=serialize_notebook_snapshot(
+ app,
+ session_view,
+ drop_virtual_file_outputs=False,
+ include_model_notifications=True,
+ ),
+ display_config=display_config,
+ options=HTMLExportOptions(
+ files=tuple(request.files),
+ include_code=request.include_code,
+ asset_url=request.asset_url,
+ ),
+ sharing_config=sharing_config,
+ )
+
+
+def _wasm_export_request(
+ *,
+ filename: str | None,
+ app: InternalApp,
+ display_config: Any,
+ code: str,
+ mode: Any,
+ show_code: bool,
+ asset_url: str | None = None,
+ session_snapshot: Any = None,
+ notebook_snapshot: Any = None,
+ sharing_config: Any = None,
+) -> WASMExportRequest:
+ return WASMExportRequest(
+ filename=filename,
+ app_config=app.config,
+ display_config=display_config,
+ code=code,
+ options=WASMExportOptions(
+ mode=mode,
+ show_code=show_code,
+ asset_url=asset_url,
+ ),
+ session_snapshot=session_snapshot,
+ notebook_snapshot=notebook_snapshot,
+ sharing_config=sharing_config,
+ )
+
+
+def _pdf_export_request(
+ *,
+ app: InternalApp,
+ session_view: SessionView | None,
+ png_fallbacks: Any = None,
+ webpdf: bool = False,
+ include_inputs: bool = True,
+ status_callback: Any = None,
+ preset: ExportPDFPreset = "document",
+) -> PDFExportRequest:
+ return PDFExportRequest(
+ app=app,
+ session_view=session_view,
+ png_fallbacks=png_fallbacks,
+ options=PDFExportOptions(
+ webpdf=webpdf,
+ preset=preset,
+ include_inputs=include_inputs,
+ ),
+ status_callback=status_callback,
+ )
+
+
@pytest.mark.parametrize(
("filename", "source", "expected_fence"),
[
@@ -76,7 +183,12 @@ def test_export_as_md_uses_resolved_markdown_filename(
notebook = tmp_path / filename
notebook.write_text(source, encoding="utf-8")
- result = export_as_md(MarimoPath(notebook))
+ result = export_markdown(
+ MarkdownFileExportRequest(
+ path=MarimoPath(notebook),
+ options=MarkdownExportOptions(),
+ )
+ )
assert result.download_filename == filename
assert expected_fence in result.text
@@ -119,18 +231,19 @@ def _load_fixture_app(name: str) -> InternalApp:
return InternalApp(app)
-# run_until_completion
+# run_notebook
-async def test_run_until_completion_with_stop() -> None:
+async def test_run_notebook_with_stop() -> None:
"""Test run until completion with mo.stop()."""
internal_app = _load_fixture_app("with_stop")
file_manager = AppFileManager.from_app(internal_app)
- session_view, did_error = await run_app_until_completion(
- file_manager,
- cli_args={},
- argv=None,
+ session_view, did_error = await run_notebook(
+ RunNotebookRequest(
+ file_manager=file_manager,
+ options=NotebookExecutionOptions(cli_args={}, argv=None),
+ )
)
assert did_error is False
cell_notifications = [
@@ -139,12 +252,12 @@ async def test_run_until_completion_with_stop() -> None:
if isinstance(op, CellNotification)
]
snapshot(
- "run_until_completion_with_stop.txt",
+ "run_notebook_with_stop.txt",
_print_messages(cell_notifications),
)
-async def test_run_until_completion_persists_session_snapshot(
+async def test_run_notebook_persists_session_snapshot(
tmp_path: Path,
) -> None:
notebook = tmp_path / "notebook.py"
@@ -165,10 +278,11 @@ if __name__ == "__main__":
)
file_manager = AppFileManager(str(notebook))
- _, did_error = await run_app_until_completion(
- file_manager,
- cli_args={},
- argv=None,
+ _, did_error = await run_notebook(
+ RunNotebookRequest(
+ file_manager=file_manager,
+ options=NotebookExecutionOptions(cli_args={}, argv=None),
+ )
)
assert did_error is False
@@ -182,7 +296,7 @@ if __name__ == "__main__":
sys.version_info >= (3, 13), reason="3.13 has different stack trace format"
)
@pytest.mark.xfail(reason="flakey", strict=False)
-async def test_run_until_completion_with_stack_trace() -> None:
+async def test_run_notebook_with_stack_trace() -> None:
"""Test run until completion with stack trace from exception."""
app = App()
@@ -210,8 +324,11 @@ async def test_run_until_completion_with_stack_trace() -> None:
file_manager = AppFileManager.from_app(InternalApp(app))
- session_view, did_error = await run_app_until_completion(
- file_manager, cli_args={}, argv=None
+ session_view, did_error = await run_notebook(
+ RunNotebookRequest(
+ file_manager=file_manager,
+ options=NotebookExecutionOptions(cli_args={}, argv=None),
+ )
)
assert did_error is True
cell_notifications = [
@@ -222,30 +339,31 @@ async def test_run_until_completion_with_stack_trace() -> None:
messages = _print_messages(cell_notifications)
snapshot(
- "run_until_completion_with_stack_trace.txt",
+ "run_notebook_with_stack_trace.txt",
delete_lines_with_files(messages),
)
@pytest.mark.flaky(reruns=3)
-@patch("marimo._server.export.echo")
-async def test_run_until_completion_with_console_output(
- mock_echo: MagicMock,
+async def test_run_notebook_with_console_output(
+ capsys: pytest.CaptureFixture[str],
) -> None:
"""Test run until completion with console output."""
internal_app = _load_fixture_app("with_console_output")
file_manager = AppFileManager.from_app(internal_app)
- session_view, did_error = await run_app_until_completion(
- file_manager,
- cli_args={},
- argv=None,
+ session_view, did_error = await run_notebook(
+ RunNotebookRequest(
+ file_manager=file_manager,
+ options=NotebookExecutionOptions(cli_args={}, argv=None),
+ )
)
assert did_error is False
def _assert_contents() -> None:
- mock_echo.assert_any_call("hello stdout", file=ANY, nl=False)
- mock_echo.assert_any_call("hello stderr", file=ANY, nl=False)
+ captured = capsys.readouterr()
+ assert "hello stdout" in captured.err
+ assert "hello stderr" in captured.err
# Console output notifications arrive asynchronously after CompletedRun.
n_tries = 0
@@ -266,7 +384,7 @@ async def test_run_until_completion_with_console_output(
if isinstance(op, CellNotification)
]
snapshot(
- "run_until_completion_with_console_output.txt",
+ "run_notebook_with_console_output.txt",
_print_messages(cell_notifications),
)
@@ -288,12 +406,14 @@ async def test_export_wasm(mode: str, expected_mode_in_content: str) -> None:
exporter = Exporter()
content, filename = exporter.export_as_wasm(
- filename=file_manager.filename,
- app=file_manager.app,
- display_config=DEFAULT_CONFIG["display"],
- mode=mode,
- code=file_manager.app.to_py(),
- show_code=True,
+ _wasm_export_request(
+ filename=file_manager.filename,
+ app=file_manager.app,
+ display_config=DEFAULT_CONFIG["display"],
+ mode=mode,
+ code=file_manager.app.to_py(),
+ show_code=True,
+ )
)
assert filename == "notebook.wasm.html"
@@ -311,10 +431,11 @@ async def test_export_html_with_layout(tmp_path: Path) -> None:
layout_file.parent.mkdir(parents=True, exist_ok=True)
layout_file.write_text('{"type": "slides", "data": {}}')
- result = export_as_wasm(
- path=MarimoPath(test_file),
- mode="edit",
- show_code=True,
+ result = await export_wasm(
+ WASMFileExportRequest(
+ path=MarimoPath(test_file),
+ options=WASMExportOptions(mode="edit", show_code=True),
+ )
)
assert result.did_error is False
assert "layout.json" not in result.text
@@ -382,11 +503,13 @@ def test_export_as_html_code_inclusion(
)
html, filename = exporter.export_as_html(
- filename=file_manager.filename,
- app=file_manager.app,
- session_view=session_view,
- display_config=DEFAULT_CONFIG["display"],
- request=request,
+ _html_export_request(
+ filename=file_manager.filename,
+ app=file_manager.app,
+ session_view=session_view,
+ display_config=DEFAULT_CONFIG["display"],
+ request=request,
+ )
)
assert filename == "notebook.html"
@@ -464,11 +587,13 @@ def test_export_as_html_with_serialization(session_view: SessionView) -> None:
)
html, filename = exporter.export_as_html(
- filename=file_manager.filename,
- app=file_manager.app,
- session_view=session_view,
- display_config=DEFAULT_CONFIG["display"],
- request=request,
+ _html_export_request(
+ filename=file_manager.filename,
+ app=file_manager.app,
+ session_view=session_view,
+ display_config=DEFAULT_CONFIG["display"],
+ request=request,
+ )
)
assert filename == "notebook.html"
@@ -505,17 +630,17 @@ def test_export_as_html_with_files(session_view: SessionView) -> None:
include_code=True,
)
- with patch(
- "marimo._server.export.exporter.read_virtual_file"
- ) as mock_read:
+ with patch("marimo._export.exporter.read_virtual_file") as mock_read:
mock_read.return_value = b"test file content"
html, filename = exporter.export_as_html(
- filename=file_manager.filename,
- app=file_manager.app,
- session_view=session_view,
- display_config=DEFAULT_CONFIG["display"],
- request=request,
+ _html_export_request(
+ filename=file_manager.filename,
+ app=file_manager.app,
+ session_view=session_view,
+ display_config=DEFAULT_CONFIG["display"],
+ request=request,
+ )
)
assert filename == "notebook.html"
@@ -558,18 +683,20 @@ def test_export_as_html_includes_composed_widget_esm(
)
with patch(
- "marimo._server.export.exporter.read_virtual_file",
+ "marimo._export.exporter.read_virtual_file",
return_value=widget_code,
):
html, _filename = Exporter().export_as_html(
- filename=file_manager.filename,
- app=file_manager.app,
- session_view=session_view,
- display_config=DEFAULT_CONFIG["display"],
- request=ExportAsHTMLRequest(
- download=True,
- files=[],
- include_code=True,
+ _html_export_request(
+ filename=file_manager.filename,
+ app=file_manager.app,
+ session_view=session_view,
+ display_config=DEFAULT_CONFIG["display"],
+ request=ExportAsHTMLRequest(
+ download=True,
+ files=[],
+ include_code=True,
+ ),
),
)
@@ -610,11 +737,13 @@ def test_export_as_html_with_cell_configs(session_view: SessionView) -> None:
)
html, filename = exporter.export_as_html(
- filename=file_manager.filename,
- app=file_manager.app,
- session_view=session_view,
- display_config=DEFAULT_CONFIG["display"],
- request=request,
+ _html_export_request(
+ filename=file_manager.filename,
+ app=file_manager.app,
+ session_view=session_view,
+ display_config=DEFAULT_CONFIG["display"],
+ request=request,
+ )
)
assert filename == "notebook.html"
@@ -666,11 +795,13 @@ def test_export_as_html_preserves_output_order(
)
html, filename = exporter.export_as_html(
- filename=file_manager.filename,
- app=file_manager.app,
- session_view=session_view,
- display_config=DEFAULT_CONFIG["display"],
- request=request,
+ _html_export_request(
+ filename=file_manager.filename,
+ app=file_manager.app,
+ session_view=session_view,
+ display_config=DEFAULT_CONFIG["display"],
+ request=request,
+ )
)
assert filename == "notebook.html"
@@ -717,11 +848,13 @@ def test_export_as_html_with_error_outputs(session_view: SessionView) -> None:
)
html, filename = exporter.export_as_html(
- filename=file_manager.filename,
- app=file_manager.app,
- session_view=session_view,
- display_config=DEFAULT_CONFIG["display"],
- request=request,
+ _html_export_request(
+ filename=file_manager.filename,
+ app=file_manager.app,
+ session_view=session_view,
+ display_config=DEFAULT_CONFIG["display"],
+ request=request,
+ )
)
assert filename == "notebook.html"
@@ -772,7 +905,7 @@ def _write_lazy_notebook(path: Path, lazy_arg: str) -> None:
),
],
)
-async def test_run_app_then_export_as_ipynb_resolves_lazy(
+async def test_export_ipynb_resolves_lazy(
tmp_path: Path,
lazy_arg: str,
expected_marker: str,
@@ -787,11 +920,12 @@ async def test_run_app_then_export_as_ipynb_resolves_lazy(
notebook = tmp_path / "lazy_notebook.py"
_write_lazy_notebook(notebook, lazy_arg)
- result = await run_app_then_export_as_ipynb(
- filepath=MarimoPath(str(notebook)),
- sort_mode="top-down",
- cli_args={},
- argv=[],
+ result = await export_ipynb(
+ IPYNBFileExportRequest(
+ path=MarimoPath(str(notebook)),
+ options=IPYNBExportOptions(sort_mode="top-down"),
+ execution=NotebookExecutionOptions(cli_args={}, argv=[]),
+ )
)
# The rendered HTML is wrapped in <span> by as_html; the raw marker
@@ -806,7 +940,7 @@ async def test_run_app_then_export_as_ipynb_resolves_lazy(
assert rendered not in result.contents
-async def test_run_app_then_export_as_html_keeps_lazy_placeholder(
+async def test_export_html_keeps_lazy_placeholder(
tmp_path: Path,
) -> None:
"""HTML export ships interactive widgets and leaves `mo.lazy` as a placeholder.
@@ -819,11 +953,15 @@ async def test_run_app_then_export_as_html_keeps_lazy_placeholder(
notebook = tmp_path / "lazy_notebook.py"
_write_lazy_notebook(notebook, 'lambda: "SYNC_RESULT"')
- result = await run_app_then_export_as_html(
- path=MarimoPath(str(notebook)),
- include_code=False,
- cli_args={},
- argv=[],
+ result = await export_html(
+ HTMLFileExportRequest(
+ path=MarimoPath(str(notebook)),
+ options=HTMLExportOptions(
+ files=(),
+ include_code=False,
+ ),
+ execution=NotebookExecutionOptions(cli_args={}, argv=[]),
+ )
)
assert "marimo-lazy" in result.contents
@@ -857,34 +995,29 @@ def test_export_as_html_code_hash_consistency(
exporter = Exporter()
# Test with include_code=True
- request_with_code = ExportAsHTMLRequest(
- download=True,
- files=[],
- include_code=True,
- )
-
- html_with_code, _ = exporter.export_as_html(
+ export_request = _html_export_request(
filename=file_manager.filename,
app=file_manager.app,
session_view=session_view,
display_config=DEFAULT_CONFIG["display"],
- request=request_with_code,
+ request=ExportAsHTMLRequest(
+ download=True,
+ files=[],
+ include_code=True,
+ ),
)
+ snapshot_before = deepcopy(export_request.snapshot)
# Test with include_code=False
- request_without_code = ExportAsHTMLRequest(
- download=True,
- files=[],
- include_code=False,
- )
-
html_without_code, _ = exporter.export_as_html(
- filename=file_manager.filename,
- app=file_manager.app,
- session_view=session_view,
- display_config=DEFAULT_CONFIG["display"],
- request=request_without_code,
+ replace(
+ export_request,
+ options=HTMLExportOptions(files=(), include_code=False),
+ )
)
+ html_with_code, _ = exporter.export_as_html(export_request)
+
+ assert export_request.snapshot == snapshot_before
# Extract code hash from both HTML outputs
hash_pattern = r"<marimo-code-hash[^>]*>([a-f0-9]+)</marimo-code-hash>"
@@ -959,11 +1092,13 @@ def test_export_html_replaces_virtual_files_in_outputs(
mock_read.return_value = b"fake_image_data"
html, filename = exporter.export_as_html(
- filename=file_manager.filename,
- app=file_manager.app,
- session_view=session_view,
- display_config=DEFAULT_CONFIG["display"],
- request=request,
+ _html_export_request(
+ filename=file_manager.filename,
+ app=file_manager.app,
+ session_view=session_view,
+ display_config=DEFAULT_CONFIG["display"],
+ request=request,
+ )
)
assert filename == "notebook.html"
@@ -1078,18 +1213,20 @@ def test_export_html_replaces_multiple_virtual_files_complex(
"marimo._convert.common.dom_traversal.read_virtual_file"
) as mock_read_dom,
patch(
- "marimo._server.export.exporter.read_virtual_file"
+ "marimo._export.exporter.read_virtual_file"
) as mock_read_exporter,
):
mock_read_dom.side_effect = mock_read_side_effect
mock_read_exporter.side_effect = mock_read_side_effect
html, filename = exporter.export_as_html(
- filename=file_manager.filename,
- app=file_manager.app,
- session_view=session_view,
- display_config=DEFAULT_CONFIG["display"],
- request=request,
+ _html_export_request(
+ filename=file_manager.filename,
+ app=file_manager.app,
+ session_view=session_view,
+ display_config=DEFAULT_CONFIG["display"],
+ request=request,
+ )
)
assert filename == "notebook.html"
@@ -1153,11 +1290,13 @@ def test_export_html_replaces_audio_virtual_files(
mock_read.return_value = b"fake_audio_data"
html, filename = exporter.export_as_html(
- filename=file_manager.filename,
- app=file_manager.app,
- session_view=session_view,
- display_config=DEFAULT_CONFIG["display"],
- request=request,
+ _html_export_request(
+ filename=file_manager.filename,
+ app=file_manager.app,
+ session_view=session_view,
+ display_config=DEFAULT_CONFIG["display"],
+ request=request,
+ )
)
assert filename == "notebook.html"
@@ -1227,11 +1366,13 @@ def test_export_html_inlines_public_folder_images(
)
html, _filename = exporter.export_as_html(
- filename=str(notebook_path),
- app=file_manager.app,
- session_view=session_view,
- display_config=DEFAULT_CONFIG["display"],
- request=request,
+ _html_export_request(
+ filename=str(notebook_path),
+ app=file_manager.app,
+ session_view=session_view,
+ display_config=DEFAULT_CONFIG["display"],
+ request=request,
+ )
)
# The original path is gone; the image is embedded as a data URI.
@@ -1284,11 +1425,13 @@ def test_export_html_does_not_touch_non_html_outputs(
)
html, _ = exporter.export_as_html(
- filename=str(notebook_path),
- app=file_manager.app,
- session_view=session_view,
- display_config=DEFAULT_CONFIG["display"],
- request=request,
+ _html_export_request(
+ filename=str(notebook_path),
+ app=file_manager.app,
+ session_view=session_view,
+ display_config=DEFAULT_CONFIG["display"],
+ request=request,
+ )
)
# The plain-text content is preserved verbatim (JSON-escaped in the
@@ -1336,11 +1479,13 @@ def test_export_html_public_folder_blocks_path_traversal(
)
html, _ = exporter.export_as_html(
- filename=str(notebook_path),
- app=file_manager.app,
- session_view=session_view,
- display_config=DEFAULT_CONFIG["display"],
- request=request,
+ _html_export_request(
+ filename=str(notebook_path),
+ app=file_manager.app,
+ session_view=session_view,
+ display_config=DEFAULT_CONFIG["display"],
+ request=request,
+ )
)
# The secret file must NOT be inlined.
@@ -1395,18 +1540,20 @@ def test_export_html_skips_oversized_virtual_files(
"marimo._convert.common.dom_traversal.read_virtual_file"
) as mock_read_dom,
patch(
- "marimo._server.export.exporter.read_virtual_file"
+ "marimo._export.exporter.read_virtual_file"
) as mock_read_exporter,
):
mock_read_dom.return_value = b"huge_audio"
mock_read_exporter.return_value = b"huge_audio"
html, _filename = exporter.export_as_html(
- filename=file_manager.filename,
- app=file_manager.app,
- session_view=session_view,
- display_config=DEFAULT_CONFIG["display"],
- request=request,
+ _html_export_request(
+ filename=file_manager.filename,
+ app=file_manager.app,
+ session_view=session_view,
+ display_config=DEFAULT_CONFIG["display"],
+ request=request,
+ )
)
# The large file should NOT be inlined as audio in the HTML output
@@ -1419,6 +1566,46 @@ def test_export_html_skips_oversized_virtual_files(
class TestPDFExport:
+ @pytest.mark.asyncio
+ @pytest.mark.parametrize(
+ ("preset", "expected"),
+ [("document", b"document"), ("slides", b"slides")],
+ )
+ async def test_render_pdf_dispatches_by_preset(
+ self,
+ preset: ExportPDFPreset,
+ expected: bytes,
+ session_view: SessionView,
+ ) -> None:
+ request = _pdf_export_request(
+ app=InternalApp(App()),
+ session_view=session_view,
+ preset=preset,
+ )
+ with (
+ patch.object(
+ Exporter,
+ "export_as_pdf",
+ autospec=True,
+ return_value=b"document",
+ ) as document_export,
+ patch.object(
+ Exporter,
+ "export_as_slides_pdf",
+ autospec=True,
+ return_value=b"slides",
+ ) as slides_export,
+ ):
+ result = await render_pdf(request)
+
+ assert result == expected
+ if preset == "document":
+ assert document_export.call_args.args[1] is request
+ slides_export.assert_not_awaited()
+ else:
+ document_export.assert_not_called()
+ assert slides_export.await_args.args[1] is request
+
def test_export_as_pdf_requires_dependencies(
self,
session_view: SessionView,
@@ -1438,15 +1625,17 @@ class TestPDFExport:
with patch.object(Dependency, "has", return_value=False):
with pytest.raises(ManyModulesNotFoundError) as excinfo:
exporter.export_as_pdf(
- app=file_manager.app,
- session_view=session_view,
- webpdf=False,
+ _pdf_export_request(
+ app=file_manager.app,
+ session_view=session_view,
+ webpdf=False,
+ )
)
assert "for PDF export" in str(excinfo.value)
@pytest.mark.asyncio
- async def test_run_app_then_export_as_pdf_reports_execute_raster_render(
+ async def test_export_pdf_reports_execute_raster_render(
self,
temp_marimo_file: str,
session_view: SessionView,
@@ -1460,10 +1649,9 @@ class TestPDFExport:
return session_view, False
async def fake_collect_pdf_png_fallbacks(
- *args: Any, **kwargs: Any
+ request: Any,
) -> dict[str, str]:
- del args
- status_callback = kwargs["status_callback"]
+ status_callback = request.status_callback
assert status_callback is not None
status_callback(
PDFExportStatusEvent(
@@ -1483,10 +1671,10 @@ class TestPDFExport:
return {"cell-1": "data:image/png;base64,ZmFrZQ=="}
def fake_export_as_pdf(
- self: Exporter, *args: Any, **kwargs: Any
+ self: Exporter, request: PDFExportRequest
) -> bytes:
- del self, args
- status_callback = kwargs["status_callback"]
+ del self
+ status_callback = request.status_callback
assert status_callback is not None
status_callback(
PDFExportStatusEvent(
@@ -1498,11 +1686,11 @@ class TestPDFExport:
with (
patch(
- "marimo._server.export.run_app_until_completion",
+ "marimo._export.file.run_notebook",
side_effect=fake_run_app_until_completion,
),
patch(
- "marimo._server.export._pdf_raster.collect_pdf_png_fallbacks",
+ "marimo._export._pdf_raster.collect_pdf_png_fallbacks",
side_effect=fake_collect_pdf_png_fallbacks,
),
patch.object(
@@ -1512,19 +1700,26 @@ class TestPDFExport:
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,
+ result = await export_pdf(
+ PDFFileExportRequest(
+ path=MarimoPath(temp_marimo_file),
+ options=PDFExportOptions(
+ webpdf=True,
+ preset="document",
+ include_inputs=False,
+ ),
+ rasterization=PDFRasterizationOptions(enabled=True),
+ execution=NotebookExecutionOptions(
+ cli_args={},
+ argv=None,
+ ),
+ status_callback=events.append,
+ )
)
- assert pdf_data == b"mock_pdf"
- assert did_error is False
+ assert result is not None
+ assert result.contents == b"mock_pdf"
+ assert result.did_error is False
assert [event.phase for event in events] == [
"execute",
"execute_complete",
@@ -1545,17 +1740,17 @@ class TestPDFExport:
]
@pytest.mark.asyncio
- async def test_run_app_then_export_as_pdf_reports_render_only_without_outputs(
+ async def test_export_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
+ self: Exporter, request: PDFExportRequest
) -> bytes:
- del self, args
- status_callback = kwargs["status_callback"]
+ del self
+ status_callback = request.status_callback
assert status_callback is not None
status_callback(
PDFExportStatusEvent(
@@ -1567,13 +1762,13 @@ class TestPDFExport:
with (
patch(
- "marimo._server.export.run_app_until_completion",
+ "marimo._export.file.run_notebook",
side_effect=AssertionError(
"execution should not run without outputs"
),
),
patch(
- "marimo._server.export._pdf_raster.collect_pdf_png_fallbacks",
+ "marimo._export._pdf_raster.collect_pdf_png_fallbacks",
side_effect=AssertionError(
"rasterization should not run without outputs"
),
@@ -1585,19 +1780,22 @@ class TestPDFExport:
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,
+ result = await export_pdf(
+ PDFFileExportRequest(
+ path=MarimoPath(temp_marimo_file),
+ options=PDFExportOptions(
+ webpdf=False,
+ preset="document",
+ include_inputs=False,
+ ),
+ rasterization=PDFRasterizationOptions(enabled=False),
+ status_callback=events.append,
+ )
)
- assert pdf_data == b"mock_pdf"
- assert did_error is False
+ assert result is not None
+ assert result.contents == b"mock_pdf"
+ assert result.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..."),
@@ -1618,7 +1816,7 @@ class TestPDFExport:
import nbformat
from marimo._convert.ipynb.from_ir import convert_from_ir_to_ipynb
- from marimo._server.export.exporter import (
+ from marimo._export.exporter import (
_nbconvert_tag_remove_config,
)
@@ -1654,7 +1852,7 @@ class TestPDFExport:
)
@pytest.mark.asyncio
- async def test_run_app_then_export_as_pdf_ignores_status_callback_failures(
+ async def test_export_pdf_ignores_status_callback_failures(
self,
temp_marimo_file: str,
) -> None:
@@ -1669,13 +1867,13 @@ class TestPDFExport:
with (
patch(
- "marimo._server.export.run_app_until_completion",
+ "marimo._export.file.run_notebook",
side_effect=AssertionError(
"execution should not run without outputs"
),
),
patch(
- "marimo._server.export._pdf_raster.collect_pdf_png_fallbacks",
+ "marimo._export._pdf_raster.collect_pdf_png_fallbacks",
side_effect=AssertionError(
"rasterization should not run without outputs"
),
@@ -1687,19 +1885,22 @@ class TestPDFExport:
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,
+ result = await export_pdf(
+ PDFFileExportRequest(
+ path=MarimoPath(temp_marimo_file),
+ options=PDFExportOptions(
+ webpdf=False,
+ preset="document",
+ include_inputs=False,
+ ),
+ rasterization=PDFRasterizationOptions(enabled=False),
+ status_callback=failing_status_callback,
+ )
)
- assert pdf_data == b"mock_pdf"
- assert did_error is False
+ assert result is not None
+ assert result.contents == b"mock_pdf"
+ assert result.did_error is False
@pytest.mark.skipif(
not DependencyManager.nbformat.has()
@@ -1733,9 +1934,11 @@ class TestPDFExport:
mock_pdf_exporter.return_value = mock_exporter_instance
result = exporter.export_as_pdf(
- app=file_manager.app,
- session_view=session_view,
- webpdf=False,
+ _pdf_export_request(
+ app=file_manager.app,
+ session_view=session_view,
+ webpdf=False,
+ )
)
assert result == b"mock_pdf_data"
@@ -1777,9 +1980,11 @@ class TestPDFExport:
mock_webpdf_exporter.return_value = mock_exporter_instance
result = exporter.export_as_pdf(
- app=file_manager.app,
- session_view=session_view,
- webpdf=True,
+ _pdf_export_request(
+ app=file_manager.app,
+ session_view=session_view,
+ webpdf=True,
+ )
)
assert result == b"mock_webpdf_data"
@@ -1796,7 +2001,7 @@ class TestPDFExport:
) -> None:
import nbformat
- from marimo._server.export.exporter import _render_webpdf
+ from marimo._export.exporter import _render_webpdf
(tmp_path / "nbconvert.py").write_text(
textwrap.dedent(
@@ -1830,7 +2035,7 @@ class TestPDFExport:
reason="requires Windows and nbconvert",
)
def test_webpdf_worker_can_spawn_subprocess_on_windows(self) -> None:
- from marimo._server.export.exporter import (
+ from marimo._export.exporter import (
_render_webpdf_with_nbconvert,
)
@@ -1901,10 +2106,12 @@ class TestPDFExport:
mock_webpdf_exporter.return_value = mock_exporter_instance
result = exporter.export_as_pdf(
- app=file_manager.app,
- session_view=session_view,
- include_inputs=False,
- webpdf=True,
+ _pdf_export_request(
+ app=file_manager.app,
+ session_view=session_view,
+ include_inputs=False,
+ webpdf=True,
+ )
)
assert result == b"mock_webpdf_data_no_inputs"
@@ -1946,7 +2153,11 @@ class TestPDFExport:
mock_pdf_exporter.return_value = mock_exporter_instance
result = exporter.export_as_pdf(
- app=file_manager.app, session_view=session_view, webpdf=False
+ _pdf_export_request(
+ app=file_manager.app,
+ session_view=session_view,
+ webpdf=False,
+ )
)
assert result is None
@@ -1994,10 +2205,12 @@ class TestPDFExport:
mock_webpdf_exporter.return_value = mock_webpdf_exporter_instance
result = exporter.export_as_pdf(
- app=file_manager.app,
- session_view=session_view,
- include_inputs=False,
- webpdf=False, # Request standard PDF, but it should fall back
+ _pdf_export_request(
+ app=file_manager.app,
+ session_view=session_view,
+ include_inputs=False,
+ webpdf=False, # Request standard PDF, but it should fall back
+ )
)
# Should fall back to webpdf and succeed
@@ -2059,9 +2272,11 @@ class TestPDFExport:
mock_webpdf_exporter.return_value = mock_webpdf_exporter_instance
result = exporter.export_as_pdf(
- app=file_manager.app,
- session_view=session_view,
- webpdf=False,
+ _pdf_export_request(
+ app=file_manager.app,
+ session_view=session_view,
+ webpdf=False,
+ )
)
assert result == b"fallback_webpdf_data"
@@ -2111,9 +2326,11 @@ class TestPDFExport:
mock_webpdf_exporter.return_value = mock_webpdf_exporter_instance
result = exporter.export_as_pdf(
- app=file_manager.app,
- session_view=session_view,
- webpdf=False,
+ _pdf_export_request(
+ app=file_manager.app,
+ session_view=session_view,
+ webpdf=False,
+ )
)
assert result == b"fallback_webpdf_data"
@@ -2160,10 +2377,12 @@ class TestPDFExport:
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,
+ _pdf_export_request(
+ app=file_manager.app,
+ session_view=session_view,
+ webpdf=False,
+ status_callback=events.append,
+ )
)
assert result == b"fallback_webpdf_data"
@@ -2240,9 +2459,12 @@ class TestPDFExport:
):
events: list[PDFExportStatusEvent] = []
result = await exporter.export_as_slides_pdf(
- app=file_manager.app,
- session_view=session_view,
- status_callback=events.append,
+ _pdf_export_request(
+ app=file_manager.app,
+ session_view=session_view,
+ status_callback=events.append,
+ preset="slides",
+ )
)
assert result == b"mock_slides_pdf_data"
@@ -2348,9 +2570,12 @@ class TestPDFExport:
),
):
result = await exporter.export_as_slides_pdf(
- app=file_manager.app,
- session_view=session_view,
- include_inputs=False,
+ _pdf_export_request(
+ app=file_manager.app,
+ session_view=session_view,
+ include_inputs=False,
+ preset="slides",
+ )
)
assert result == b"mock_slides_pdf_data"
@@ -2403,7 +2628,7 @@ def test_export_assets_preserves_write_permission(
dest = tmp_path / "output"
dest.mkdir()
- with patch("marimo._server.export.exporter.ROOT", src):
+ with patch("marimo._export.exporter.ROOT", src):
Exporter().export_assets(dest)
assert dest.stat().st_mode & stat.S_IWUSR, (
diff --git a/tests/_server/export/test_nbformat_png_fallbacks.py b/tests/_export/test_nbformat_png_fallbacks.py
similarity index 97%
rename from tests/_server/export/test_nbformat_png_fallbacks.py
rename to tests/_export/test_nbformat_png_fallbacks.py
index ff6b5d0ffc..278ce26a06 100644
--- a/tests/_server/export/test_nbformat_png_fallbacks.py
+++ b/tests/_export/test_nbformat_png_fallbacks.py
@@ -2,7 +2,7 @@ from __future__ import annotations
import pytest
-from marimo._server.export._nbformat_png_fallbacks import (
+from marimo._export._nbformat_png_fallbacks import (
inject_png_fallbacks_into_notebook,
)
diff --git a/tests/_server/export/test_pdf_raster.py b/tests/_export/test_pdf_raster.py
similarity index 86%
rename from tests/_server/export/test_pdf_raster.py
rename to tests/_export/test_pdf_raster.py
index b2ed84c6ae..3928298889 100644
--- a/tests/_server/export/test_pdf_raster.py
+++ b/tests/_export/test_pdf_raster.py
@@ -2,15 +2,18 @@ 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._server.export import _pdf_raster
+from marimo._schemas.export_options import PDFRasterizationOptions
from marimo._session.state.session_view import SessionView
@@ -160,22 +163,23 @@ def test_collect_pdf_png_fallbacks_mixed_targets_use_static_by_default() -> (
),
patch.object(
_pdf_raster,
- "_capture_pngs_from_live_page",
+ "_collect_live_captures",
live_capture_mock,
),
patch(
- "marimo._server.export.exporter.Exporter.export_as_html",
+ "marimo._export.exporter.Exporter.export_as_html",
side_effect=_fake_export_as_html,
),
):
return await _pdf_raster.collect_pdf_png_fallbacks(
- app=app,
- session_view=session_view,
- filename="demo.py",
- filepath="demo.py",
- argv=["--arg", "value"],
- options=_pdf_raster.PDFRasterizationOptions(),
- status_callback=events.append,
+ PDFRasterizationRequest(
+ app=app,
+ session_view=session_view,
+ filename="demo.py",
+ filepath="demo.py",
+ options=PDFRasterizationOptions(),
+ status_callback=events.append,
+ )
)
captures = asyncio.run(_run())
@@ -258,20 +262,22 @@ def test_collect_pdf_png_fallbacks_static_only_uses_static_capture() -> None:
),
patch.object(
_pdf_raster,
- "_capture_pngs_from_live_page",
+ "_collect_live_captures",
live_capture_mock,
),
patch(
- "marimo._server.export.exporter.Exporter.export_as_html",
+ "marimo._export.exporter.Exporter.export_as_html",
side_effect=_fake_export_as_html,
),
):
return await _pdf_raster.collect_pdf_png_fallbacks(
- app=app,
- session_view=session_view,
- filename="demo.py",
- filepath="demo.py",
- options=_pdf_raster.PDFRasterizationOptions(),
+ PDFRasterizationRequest(
+ app=app,
+ session_view=session_view,
+ filename="demo.py",
+ filepath="demo.py",
+ options=PDFRasterizationOptions(),
+ )
)
captures = asyncio.run(_run())
@@ -305,15 +311,13 @@ def test_collect_pdf_png_fallbacks_live_mode_uses_live_capture() -> None:
async def _capture_live(
*,
- filepath: str,
+ page_url: str,
targets: list[_pdf_raster._RasterTarget],
scale: float,
- argv: list[str] | None,
status_callback: Any = None,
) -> dict[str, str]:
- del filepath
+ assert page_url == "http://127.0.0.1:1234/demo"
del scale
- del argv
del status_callback
assert [target.cell_id for target in targets] == ["2", "1"]
return {
@@ -321,27 +325,32 @@ def test_collect_pdf_png_fallbacks_live_mode_uses_live_capture() -> None:
"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,
- "_capture_pngs_from_page",
+ "_collect_static_captures",
static_capture_mock,
),
patch.object(
_pdf_raster,
- "_capture_pngs_from_live_page",
+ "_capture_pngs_from_page",
side_effect=_capture_live,
),
):
return await _pdf_raster.collect_pdf_png_fallbacks(
- app=app,
- session_view=session_view,
- filename="demo.py",
- filepath="demo.py",
- options=_pdf_raster.PDFRasterizationOptions(
- server_mode="live"
- ),
+ 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())
@@ -352,6 +361,34 @@ def test_collect_pdf_png_fallbacks_live_mode_uses_live_capture() -> None:
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
diff --git a/tests/_server/export/test_session_cache.py b/tests/_export/test_session_cache.py
similarity index 99%
rename from tests/_server/export/test_session_cache.py
rename to tests/_export/test_session_cache.py
index 739ef16d1b..508ffa185c 100644
--- a/tests/_server/export/test_session_cache.py
+++ b/tests/_export/test_session_cache.py
@@ -4,7 +4,7 @@ import json
from typing import Any, cast
from unittest.mock import patch
-from marimo._server.export import _session_cache
+from marimo._export import _session_cache
from marimo._session.state.session_view import SessionView
from marimo._utils.marimo_path import MarimoPath
from marimo._version import __version__
diff --git a/tests/_server/api/endpoints/test_assets.py b/tests/_server/api/endpoints/test_assets.py
index f5019f20f5..389ef16c23 100644
--- a/tests/_server/api/endpoints/test_assets.py
+++ b/tests/_server/api/endpoints/test_assets.py
@@ -11,12 +11,12 @@ from unittest.mock import Mock, patch
import pytest
+from marimo._convert.common.filename import parse_title
from marimo._server.api.deps import AppState
from marimo._server.api.endpoints.assets import (
DEFAULT_NOTEBOOK_NAME,
_inject_service_worker,
)
-from marimo._server.api.utils import parse_title
from marimo._server.workspace import (
DirectoryWorkspace,
EmptyWorkspace,
diff --git a/tests/_server/api/endpoints/test_auto_instantiate.py b/tests/_server/api/endpoints/test_auto_instantiate.py
index a7b5a94b3f..69d777e4e4 100644
--- a/tests/_server/api/endpoints/test_auto_instantiate.py
+++ b/tests/_server/api/endpoints/test_auto_instantiate.py
@@ -165,7 +165,7 @@ class TestInstantiateNotebookRequest:
def test_instantiate_request_with_codes(self) -> None:
"""InstantiateNotebookRequest should accept optional codes field."""
- from marimo._server.models.models import InstantiateNotebookRequest
+ from marimo._session.requests import InstantiateNotebookRequest
# Without codes
request = InstantiateNotebookRequest(
@@ -192,7 +192,7 @@ class TestInstantiateNotebookRequest:
in the test environment).
"""
del client
- from marimo._server.models.models import InstantiateNotebookRequest
+ from marimo._session.requests import InstantiateNotebookRequest
# Test that the model accepts codes
request_with_codes = InstantiateNotebookRequest(
diff --git a/tests/_server/api/endpoints/test_export.py b/tests/_server/api/endpoints/test_export.py
index 73b132de9d..440a1dfe41 100644
--- a/tests/_server/api/endpoints/test_export.py
+++ b/tests/_server/api/endpoints/test_export.py
@@ -13,6 +13,7 @@ import pytest
from marimo import __version__
from marimo._dependencies.dependencies import DependencyManager
+from marimo._export.requests import PDFExportRequest, PDFRasterizationRequest
from marimo._messaging.cell_output import CellChannel, CellOutput
from marimo._messaging.notification import CellNotification
from marimo._output.utils import uri_encode_component
@@ -40,6 +41,10 @@ HEADERS = {
CODE = uri_encode_component("import marimo as mo")
+class _CollectorNotWired(Exception):
+ pass
+
+
@with_session(SESSION_ID)
def test_export_html(client: TestClient) -> None:
session = get_session_manager(client).get_session(SESSION_ID)
@@ -811,6 +816,7 @@ def test_update_cell_outputs_empty_request(client: TestClient) -> None:
@pytest.mark.xfail(
reason="endpoint does not yet wire up collect_pdf_png_fallbacks",
+ raises=_CollectorNotWired,
strict=True,
)
@pytest.mark.skipif(
@@ -821,24 +827,23 @@ def test_update_cell_outputs_empty_request(client: TestClient) -> None:
@with_session(SESSION_ID)
def test_export_pdf_endpoint(client: TestClient) -> None:
"""Test PDF export endpoint."""
- from unittest.mock import AsyncMock, MagicMock, patch
+ from unittest.mock import AsyncMock, patch
session = get_session_manager(client).get_session(SESSION_ID)
assert session
session.app_file_manager.filename = "test.py"
- # Mock the exporter to avoid needing LaTeX/Chromium
- mock_exporter = MagicMock()
- mock_exporter.export_as_pdf.return_value = b"mock_pdf_content"
+ render_pdf_mock = AsyncMock(return_value=b"mock_pdf_content")
+ collect_mock = AsyncMock(return_value={})
with (
patch(
- "marimo._server.api.endpoints.export.Exporter",
- return_value=mock_exporter,
+ "marimo._server.api.endpoints.export.render_pdf",
+ render_pdf_mock,
),
patch(
- "marimo._server.export._pdf_raster.collect_pdf_png_fallbacks",
- AsyncMock(return_value={}),
+ "marimo._export._pdf_raster.collect_pdf_png_fallbacks",
+ collect_mock,
),
):
response = client.post(
@@ -850,13 +855,18 @@ def test_export_pdf_endpoint(client: TestClient) -> None:
assert response.status_code == 200
assert response.content == b"mock_pdf_content"
assert response.headers["content-type"] == "application/pdf"
- call_kwargs = mock_exporter.export_as_pdf.call_args[1]
- assert call_kwargs["include_inputs"] is False
- assert call_kwargs["png_fallbacks"] == {}
+ render_request = render_pdf_mock.await_args.args[0]
+ assert isinstance(render_request, PDFExportRequest)
+ assert render_request.options.include_inputs is False
+ if collect_mock.await_count == 0:
+ raise _CollectorNotWired
+ collect_mock.assert_awaited_once()
+ assert render_request.png_fallbacks == {}
@pytest.mark.xfail(
reason="endpoint does not yet wire up collect_pdf_png_fallbacks",
+ raises=_CollectorNotWired,
strict=True,
)
@pytest.mark.skipif(
@@ -867,24 +877,23 @@ def test_export_pdf_endpoint(client: TestClient) -> None:
@with_session(SESSION_ID)
def test_export_pdf_endpoint_webpdf_mode(client: TestClient) -> None:
"""Test PDF export endpoint with webpdf mode."""
- from unittest.mock import AsyncMock, MagicMock, patch
+ from unittest.mock import AsyncMock, patch
session = get_session_manager(client).get_session(SESSION_ID)
assert session
session.app_file_manager.filename = "test.py"
- # Mock the exporter to avoid needing Chromium
- mock_exporter = MagicMock()
- mock_exporter.export_as_pdf.return_value = b"mock_webpdf_content"
+ render_pdf_mock = AsyncMock(return_value=b"mock_webpdf_content")
+ collect_mock = AsyncMock(return_value={})
with (
patch(
- "marimo._server.api.endpoints.export.Exporter",
- return_value=mock_exporter,
+ "marimo._server.api.endpoints.export.render_pdf",
+ render_pdf_mock,
),
patch(
- "marimo._server.export._pdf_raster.collect_pdf_png_fallbacks",
- AsyncMock(return_value={}),
+ "marimo._export._pdf_raster.collect_pdf_png_fallbacks",
+ collect_mock,
),
):
response = client.post(
@@ -896,15 +905,20 @@ def test_export_pdf_endpoint_webpdf_mode(client: TestClient) -> None:
assert response.status_code == 200
assert response.content == b"mock_webpdf_content"
# Verify webpdf=True was passed to exporter
- mock_exporter.export_as_pdf.assert_called_once()
- call_kwargs = mock_exporter.export_as_pdf.call_args[1]
- assert call_kwargs["webpdf"] is True
- assert call_kwargs["include_inputs"] is False
- assert call_kwargs["png_fallbacks"] == {}
+ render_pdf_mock.assert_awaited_once()
+ render_request = render_pdf_mock.await_args.args[0]
+ assert isinstance(render_request, PDFExportRequest)
+ assert render_request.options.webpdf is True
+ assert render_request.options.include_inputs is False
+ if collect_mock.await_count == 0:
+ raise _CollectorNotWired
+ collect_mock.assert_awaited_once()
+ assert render_request.png_fallbacks == {}
@pytest.mark.xfail(
reason="endpoint does not yet wire up collect_pdf_png_fallbacks",
+ raises=_CollectorNotWired,
strict=True,
)
@pytest.mark.skipif(
@@ -913,27 +927,28 @@ def test_export_pdf_endpoint_webpdf_mode(client: TestClient) -> None:
reason="nbformat or nbconvert not installed",
)
@with_session(SESSION_ID)
-def test_export_pdf_endpoint_slides_preset(client: TestClient) -> None:
- """Test PDF export endpoint routes slides preset to slides exporter."""
- from unittest.mock import AsyncMock, MagicMock, patch
+def test_export_pdf_endpoint_preserves_slides_preset(
+ client: TestClient,
+) -> None:
+ from unittest.mock import AsyncMock, patch
session = get_session_manager(client).get_session(SESSION_ID)
assert session
session.app_file_manager.filename = "test.py"
- mock_exporter = MagicMock()
- mock_exporter.export_as_slides_pdf = AsyncMock(
- return_value=b"mock_slides_content"
+ render_pdf_mock = AsyncMock(return_value=b"mock_slides_content")
+ collect_mock = AsyncMock(
+ return_value={"1": "data:image/png;base64,ZmFrZQ=="}
)
with (
patch(
- "marimo._server.api.endpoints.export.Exporter",
- return_value=mock_exporter,
+ "marimo._server.api.endpoints.export.render_pdf",
+ render_pdf_mock,
),
patch(
- "marimo._server.export._pdf_raster.collect_pdf_png_fallbacks",
- AsyncMock(return_value={"1": "data:image/png;base64,ZmFrZQ=="}),
+ "marimo._export._pdf_raster.collect_pdf_png_fallbacks",
+ collect_mock,
),
):
response = client.post(
@@ -944,17 +959,22 @@ def test_export_pdf_endpoint_slides_preset(client: TestClient) -> None:
assert response.status_code == 200
assert response.content == b"mock_slides_content"
- mock_exporter.export_as_slides_pdf.assert_awaited_once()
- call_kwargs = mock_exporter.export_as_slides_pdf.await_args.kwargs
- assert call_kwargs["include_inputs"] is False
- assert call_kwargs["png_fallbacks"] == {
+ render_pdf_mock.assert_awaited_once()
+ render_request = render_pdf_mock.await_args.args[0]
+ assert isinstance(render_request, PDFExportRequest)
+ assert render_request.options.preset == "slides"
+ assert render_request.options.include_inputs is False
+ if collect_mock.await_count == 0:
+ raise _CollectorNotWired
+ collect_mock.assert_awaited_once()
+ assert render_request.png_fallbacks == {
"1": "data:image/png;base64,ZmFrZQ=="
}
- mock_exporter.export_as_pdf.assert_not_called()
@pytest.mark.xfail(
reason="endpoint does not yet wire up collect_pdf_png_fallbacks",
+ raises=_CollectorNotWired,
strict=True,
)
@pytest.mark.skipif(
@@ -966,7 +986,7 @@ def test_export_pdf_endpoint_slides_preset(client: TestClient) -> None:
def test_export_pdf_endpoint_live_raster_uses_live_server_mode(
client: TestClient,
) -> None:
- from unittest.mock import AsyncMock, MagicMock, patch
+ from unittest.mock import AsyncMock, patch
from urllib.parse import parse_qs, urlparse
session = get_session_manager(client).get_session(SESSION_ID)
@@ -974,16 +994,15 @@ def test_export_pdf_endpoint_live_raster_uses_live_server_mode(
session.app_file_manager.filename = "/tmp/test.py"
collect_mock = AsyncMock(return_value={})
- mock_exporter = MagicMock()
- mock_exporter.export_as_pdf.return_value = b"mock_pdf_content"
+ render_pdf_mock = AsyncMock(return_value=b"mock_pdf_content")
with (
patch(
- "marimo._server.api.endpoints.export.Exporter",
- return_value=mock_exporter,
+ "marimo._server.api.endpoints.export.render_pdf",
+ render_pdf_mock,
),
patch(
- "marimo._server.export._pdf_raster.collect_pdf_png_fallbacks",
+ "marimo._export._pdf_raster.collect_pdf_png_fallbacks",
collect_mock,
),
):
@@ -994,13 +1013,18 @@ def test_export_pdf_endpoint_live_raster_uses_live_server_mode(
)
assert response.status_code == 200
- call_kwargs = collect_mock.await_args.kwargs
- options = call_kwargs["options"]
- assert options.server_mode == "live"
- live_page_url = call_kwargs["live_page_url"]
- assert isinstance(live_page_url, str)
- parsed = urlparse(live_page_url)
- params = parse_qs(parsed.query)
+ render_request = render_pdf_mock.await_args.args[0]
+ assert isinstance(render_request, PDFExportRequest)
+ if collect_mock.await_count == 0:
+ raise _CollectorNotWired
+ collect_mock.assert_awaited_once()
+ raster_request = collect_mock.await_args.args[0]
+ assert isinstance(raster_request, PDFRasterizationRequest)
+ assert raster_request.options.server_mode == "live"
+ assert raster_request.live_page_url is not None
+ with raster_request.live_page_url() as live_page_url:
+ parsed = urlparse(live_page_url)
+ params = parse_qs(parsed.query)
assert params["session_id"] == [SESSION_ID]
assert params["kiosk"] == ["true"]
assert params["file"] == ["/tmp/test.py"]
@@ -1012,23 +1036,21 @@ def test_export_pdf_endpoint_returns_error_on_failure(
client: TestClient,
) -> None:
"""Test PDF export endpoint returns error when export fails."""
- from unittest.mock import AsyncMock, MagicMock, patch
+ from unittest.mock import AsyncMock, patch
session = get_session_manager(client).get_session(SESSION_ID)
assert session
session.app_file_manager.filename = "test.py"
- # Mock the exporter to return None (failure case)
- mock_exporter = MagicMock()
- mock_exporter.export_as_pdf.return_value = None
+ render_pdf_mock = AsyncMock(return_value=None)
with (
patch(
- "marimo._server.api.endpoints.export.Exporter",
- return_value=mock_exporter,
+ "marimo._server.api.endpoints.export.render_pdf",
+ render_pdf_mock,
),
patch(
- "marimo._server.export._pdf_raster.collect_pdf_png_fallbacks",
+ "marimo._export._pdf_raster.collect_pdf_png_fallbacks",
AsyncMock(return_value={}),
),
):
diff --git a/tests/_server/templates/test_templates.py b/tests/_server/templates/test_templates.py
index 14d65157bd..84c81a49e1 100644
--- a/tests/_server/templates/test_templates.py
+++ b/tests/_server/templates/test_templates.py
@@ -8,6 +8,7 @@ from pathlib import Path
from typing import Literal
from unittest.mock import patch
+import marimo._templates as templates
from marimo._ast.app_config import _AppConfig
from marimo._config.config import (
MarimoConfig,
@@ -28,7 +29,6 @@ from marimo._schemas.session import (
NotebookSessionV1,
StreamOutput,
)
-from marimo._server.templates import templates
from marimo._server.tokens import SkewProtectionToken
from marimo._session.model import SessionMode
from marimo._utils.code import hash_code
diff --git a/tests/_server/test_scratchpad.py b/tests/_server/test_scratchpad.py
index 058bb58081..bf78b481a8 100644
--- a/tests/_server/test_scratchpad.py
+++ b/tests/_server/test_scratchpad.py
@@ -30,7 +30,6 @@ from marimo._runtime.commands import (
HTTPRequest,
)
from marimo._runtime.scratch import SCRATCH_CELL_ID
-from marimo._server.models.models import InstantiateNotebookRequest
from marimo._server.scratchpad import (
ScratchCellListener,
_format_console,
@@ -40,6 +39,7 @@ from marimo._server.scratchpad import (
run_scratchpad_code,
snapshot_for_scratchpad,
)
+from marimo._session.requests import InstantiateNotebookRequest
if TYPE_CHECKING:
from collections.abc import Iterator
diff --git a/tests/_server/test_templates_filename.py b/tests/_server/test_templates_filename.py
index 57f77d4063..10bf51f8ab 100644
--- a/tests/_server/test_templates_filename.py
+++ b/tests/_server/test_templates_filename.py
@@ -7,12 +7,12 @@ import pytest
from marimo._ast.app_config import _AppConfig
from marimo._config.config import MarimoConfig, PartialMarimoConfig
-from marimo._server.templates.templates import (
+from marimo._server.tokens import SkewProtectionToken
+from marimo._templates import (
_get_mount_config,
_html_escape,
json_script,
)
-from marimo._server.tokens import SkewProtectionToken
from tests.mocks import EDGE_CASE_FILENAMES