A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
# Copyright 2026 Marimo. All rights reserved.
from __future__ import annotations
import asyncio
import json
import unittest.mock
from pathlib import Path
from textwrap import dedent
from types import SimpleNamespace
from typing import TYPE_CHECKING, Any
from unittest.mock import MagicMock, Mock, patch
import msgspec
import pytest
from marimo._ast.app_config import _AppConfig
from marimo._config.config import DEFAULT_CONFIG, merge_config
from marimo._dependencies.dependencies import DependencyManager
from marimo._messaging.types import KernelMessage
from marimo._pyodide.pyodide_session import (
AsyncQueueManager,
PyodideBridge,
PyodideSession,
_launch_pyodide_kernel,
parse_command,
)
from marimo._runtime.commands import (
AppMetadata,
ClearCacheCommand,
CreateNotebookCommand,
DebugCellCommand,
DeleteCellCommand,
ExecuteCellsCommand,
ExecuteScratchpadCommand,
ExecuteStaleCellsCommand,
GetCacheInfoCommand,
InstallPackagesCommand,
InvokeFunctionCommand,
ListDataSourceConnectionCommand,
ListSecretKeysCommand,
ListSQLTablesCommand,
ModelCommand,
PreviewDatasetColumnCommand,
PreviewSQLTableCommand,
RefreshSecretsCommand,
RenameNotebookCommand,
StopKernelCommand,
SyncGraphCommand,
UpdateCellConfigCommand,
UpdateUIElementCommand,
UpdateUserConfigCommand,
ValidateSQLCommand,
)
from marimo._runtime.context.types import teardown_context
from marimo._session.model import SessionMode
from marimo._session.notebook import AppFileManager
from marimo._types.ids import CellId_t, UIElementId
from tests._server.templates.utils import parse_mount_config
if TYPE_CHECKING:
from collections.abc import AsyncGenerator, Generator
@pytest.fixture
def pyodide_app_file(tmp_path: Path) -> Path:
filename = tmp_path / "test.py"
filename.write_text(
"""
import marimo
app = marimo.App()
@app.cell
def _():
"Hello, world!"
return
"""
)
return filename
@pytest.fixture
def mock_pyodide_http() -> Generator[MagicMock, None, None]:
import sys
mock = MagicMock()
sys.modules["pyodide_http"] = mock
mock.patch_all.return_value = None
yield mock
del sys.modules["pyodide_http"]
@pytest.fixture
def mock_pyodide() -> Generator[MagicMock, None, None]:
import sys
from types import ModuleType
# Create a proper module structure for pyodide
mock = MagicMock(spec=ModuleType)
mock.code = MagicMock(spec=ModuleType)
mock.code.find_imports = MagicMock(
return_value=["numpy", "pandas", "sklearn", "matplotlib.pyplot"]
)
# Save original module if it exists
original_module = sys.modules.get("pyodide", None)
# Install our mock
sys.modules["pyodide"] = mock
sys.modules["pyodide.code"] = mock
yield mock
# Restore original state
if original_module is not None:
sys.modules["pyodide"] = original_module
else:
del sys.modules["pyodide"]
@pytest.fixture
async def pyodide_session(
pyodide_app_file: Path,
) -> AsyncGenerator[PyodideSession, None]:
session = PyodideSession(
app=AppFileManager(filename=str(pyodide_app_file)),
mode=SessionMode.EDIT,
app_metadata=AppMetadata(
query_params={},
cli_args={},
app_config=_AppConfig(),
filename=str(pyodide_app_file),
),
user_config=DEFAULT_CONFIG,
)
yield session
teardown_context()
async def test_async_queue_manager() -> None:
async_queue_manager = AsyncQueueManager()
# Test putting and getting from queues
stop_request = StopKernelCommand()
set_ui_element_request = UpdateUIElementCommand(
object_ids=[UIElementId("test")], values=["test"]
)
async_queue_manager.control_queue.put_nowait(stop_request)
async_queue_manager.set_ui_element_queue.put_nowait(set_ui_element_request)
assert await async_queue_manager.control_queue.get() == stop_request
assert (
await async_queue_manager.set_ui_element_queue.get()
== set_ui_element_request
)
async def test_pyodide_session_start(
pyodide_session: PyodideSession,
mock_pyodide_http: MagicMock,
) -> None:
# Test starting the session
start_task = asyncio.create_task(pyodide_session.start())
await asyncio.sleep(0) # Let the task start
assert pyodide_session.kernel_task is not None
mock_pyodide_http.patch_all.assert_called_once()
pyodide_session.kernel_task.stop()
start_task.cancel()
try:
await start_task
except asyncio.CancelledError:
pass
async def test_pyodide_kernel_teardown_runs_on_stop(
pyodide_app_file: Path,
) -> None:
"""Stopping the kernel task must trigger teardown_kernel via the listen()
finally block (previously absent for the pyodide path)."""
fake_kernel = MagicMock()
cleanup_order: list[str] = []
class FakeLifecycleItem:
def dispose(self, context: Any, deletion: bool) -> bool:
assert context is fake_ctx
assert deletion is True
cleanup_order.append("dispose")
return True
lifecycle_item = FakeLifecycleItem()
fake_ctx = SimpleNamespace(
cell_lifecycle_registry=SimpleNamespace(
registry={"cell": {lifecycle_item}}
)
)
teardown_calls: list[tuple[Any, Any]] = []
async def block_until_cancelled(*_args: Any, **_kwargs: Any) -> None:
await asyncio.Event().wait()
async def wait_for_wasm_runtime_work(*_args: Any, **_kwargs: Any) -> bool:
cleanup_order.append("wait")
return True
async def shutdown_wasm_runtime_work(*_args: Any, **_kwargs: Any) -> None:
cleanup_order.append("shutdown")
with (
patch(
"marimo._runtime.kernel_lifecycle.create_kernel",
return_value=(fake_kernel, fake_ctx),
),
patch(
"marimo._runtime.kernel_lifecycle.listen_messages",
side_effect=block_until_cancelled,
),
patch(
"marimo._runtime.kernel_lifecycle.teardown_kernel",
side_effect=lambda k, c: (
cleanup_order.append("teardown"),
teardown_calls.append((k, c)),
),
),
patch(
"marimo._runtime._wasm.wait_for_wasm_runtime_work_async",
side_effect=wait_for_wasm_runtime_work,
),
patch(
"marimo._runtime._wasm.shutdown_wasm_runtime_work_async",
side_effect=shutdown_wasm_runtime_work,
),
patch("marimo._pyodide.pyodide_session.signal"),
patch("marimo._output.formatters.formatters.register_formatters"),
patch(
"marimo._pyodide.pyodide_session.patches.patch_pyodide_networking"
),
patch("marimo._pyodide.pyodide_session.patches.patch_recursion_limit"),
):
kernel_task = _launch_pyodide_kernel(
control_queue=asyncio.Queue(),
set_ui_element_queue=asyncio.Queue(),
completion_queue=asyncio.Queue(),
input_queue=asyncio.Queue(),
on_message=lambda _msg: None,
session_mode=SessionMode.EDIT,
configs={},
app_metadata=AppMetadata(
query_params={},
cli_args={},
app_config=_AppConfig(),
filename=str(pyodide_app_file),
),
user_config=DEFAULT_CONFIG,
)
start_task = asyncio.create_task(kernel_task.start())
# Yield enough times for: outer task → RestartableTask.start → inner
# task creation → listen() → asyncio.gather → child tasks suspended.
for _ in range(5):
await asyncio.sleep(0)
kernel_task.stop()
try:
await start_task
except asyncio.CancelledError:
pass
assert teardown_calls == [(fake_kernel, fake_ctx)]
assert cleanup_order == ["dispose", "wait", "shutdown", "teardown"]
assert fake_ctx.cell_lifecycle_registry.registry == {}
async def test_pyodide_kernel_teardown_logs_wasm_shutdown_timeout(
pyodide_app_file: Path,
) -> None:
fake_kernel = MagicMock()
fake_ctx = SimpleNamespace(
cell_lifecycle_registry=SimpleNamespace(registry={})
)
teardown_calls: list[tuple[Any, Any]] = []
async def block_until_cancelled(*_args: Any, **_kwargs: Any) -> None:
await asyncio.Event().wait()
async def wait_for_wasm_runtime_work(*_args: Any, **_kwargs: Any) -> bool:
return False
async def shutdown_wasm_runtime_work(*_args: Any, **_kwargs: Any) -> None:
raise RuntimeError("WASM runtime work did not shut down in time")
with (
patch(
"marimo._runtime.kernel_lifecycle.create_kernel",
return_value=(fake_kernel, fake_ctx),
),
patch(
"marimo._runtime.kernel_lifecycle.listen_messages",
side_effect=block_until_cancelled,
),
patch(
"marimo._runtime.kernel_lifecycle.teardown_kernel",
side_effect=lambda k, c: teardown_calls.append((k, c)),
),
patch(
"marimo._runtime._wasm.wait_for_wasm_runtime_work_async",
side_effect=wait_for_wasm_runtime_work,
),
patch(
"marimo._runtime._wasm.shutdown_wasm_runtime_work_async",
side_effect=shutdown_wasm_runtime_work,
),
patch("marimo._pyodide.pyodide_session.LOGGER") as logger,
patch("marimo._pyodide.pyodide_session.signal"),
patch("marimo._output.formatters.formatters.register_formatters"),
patch(
"marimo._pyodide.pyodide_session.patches.patch_pyodide_networking"
),
patch("marimo._pyodide.pyodide_session.patches.patch_recursion_limit"),
):
kernel_task = _launch_pyodide_kernel(
control_queue=asyncio.Queue(),
set_ui_element_queue=asyncio.Queue(),
completion_queue=asyncio.Queue(),
input_queue=asyncio.Queue(),
on_message=lambda _msg: None,
session_mode=SessionMode.EDIT,
configs={},
app_metadata=AppMetadata(
query_params={},
cli_args={},
app_config=_AppConfig(),
filename=str(pyodide_app_file),
),
user_config=DEFAULT_CONFIG,
)
start_task = asyncio.create_task(kernel_task.start())
for _ in range(5):
await asyncio.sleep(0)
kernel_task.stop()
try:
await start_task
except asyncio.CancelledError:
pass
logger.exception.assert_called_with(
"Failed to shut down Pyodide WASM runtime work"
)
assert teardown_calls == [(fake_kernel, fake_ctx)]
async def test_pyodide_session_put_control_request(
pyodide_session: PyodideSession,
) -> None:
# Test putting control requests
execution_request = ExecuteCellsCommand(
cell_ids=[CellId_t("test")],
codes=["test"],
)
set_ui_element_request = UpdateUIElementCommand(
object_ids=[UIElementId("test")], values=["test"]
)
pyodide_session.put_control_request(execution_request)
pyodide_session.put_control_request(set_ui_element_request)
assert not pyodide_session._queue_manager.control_queue.empty()
assert not pyodide_session._queue_manager.set_ui_element_queue.empty()
async def test_pyodide_session_find_packages(
pyodide_session: PyodideSession,
mock_pyodide: MagicMock,
) -> None:
# We don't use `pyodide.code.find_imports`
# because this returns imports not in the lockfile (and potentially not trusted).
code = dedent(
"""
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
"""
)
packages = pyodide_session.find_packages(code)
assert sorted(packages) == sorted([])
mock_pyodide.code.find_imports.assert_not_called()
async def test_pyodide_session_find_packages_with_script_metadata(
pyodide_session: PyodideSession,
mock_pyodide: MagicMock,
) -> None:
# Test finding packages in code
code = dedent(
"""
# /// script
# dependencies = [
# "foo",
# "bar==1.0.0",
# "baz>=2.0.0",
# ]
# ///
import numpy as np
import pandas as pd
"""
)
packages = pyodide_session.find_packages(code)
# Specifiers are preserved: these go to micropip, which resolves them.
assert sorted(packages) == sorted(["foo", "bar==1.0.0", "baz>=2.0.0"])
mock_pyodide.code.find_imports.assert_not_called()
async def test_find_packages_keeps_a_pinned_prerelease(
pyodide_session: PyodideSession,
) -> None:
"""A pin is the only thing that selects a pre-release.
Dropping it does not just lose precision -- an unpinned name resolves to
the newest *stable* release, so the notebook silently gets a different
version than it asked for, and one that may not run in Pyodide at all.
"""
code = dedent(
"""
# /// script
# dependencies = ["somepkg==1.0.0.dev2"]
# ///
import somepkg
"""
)
assert pyodide_session.find_packages(code) == ["somepkg==1.0.0.dev2"]
@pytest.mark.parametrize(
("python_version", "expected_package"),
[
("3.12", "older-python; python_version < '3.13'"),
("3.13", "newer-python; python_version >= '3.13'"),
],
)
async def test_find_packages_from_island_notebook(
pyodide_session: PyodideSession,
mock_pyodide: MagicMock,
python_version: str,
expected_package: str,
) -> None:
from packaging.markers import default_environment
# Generated by the frontend from a Python-rendered island payload.
code = (
Path(__file__).parent.parent
/ "_islands/snapshots/notebook-dependencies.txt"
).read_text(encoding="utf-8")
environment = {
**default_environment(),
"python_version": python_version,
"python_full_version": f"{python_version}.0",
}
with patch(
"packaging.markers.default_environment", return_value=environment
):
assert pyodide_session.find_packages(code) == [
'cowsay==6.1; sys_platform == "emscripten"',
"rich[jupyter]>=13",
expected_package,
]
mock_pyodide.code.find_imports.assert_not_called()
async def test_complex_find_packages(pyodide_session: PyodideSession) -> None:
code = dedent(
"""
# /// script
# requires-python = ">=3.12"
# dependencies = [
# "plotly[express]==6.5.0",
# "polars==1.36.1",
# ]
# ///
import marimo
app = marimo.App()
@app.cell
def _():
import marimo as mo
return (mo,)
"""
)
packages = pyodide_session.find_packages(code)
assert sorted(packages) == sorted(
["plotly[express]==6.5.0", "polars==1.36.1"]
)
async def test_strip_version_resilience(
pyodide_session: PyodideSession,
) -> None:
"""find_packages keeps each requirement as written.
Specifiers reach micropip, which resolves them. Environment markers are
still applied (a non-emscripten requirement drops out), and URL forms are
unchanged. `strip_requirement_name` keeps its own tests in
tests/_runtime/packages/test_package_utils.py.
"""
code_templates = [
# Basic version specifiers
('dependencies = ["package==1.0.0"]', ["package==1.0.0"]),
('dependencies = ["package>=1.0.0"]', ["package>=1.0.0"]),
('dependencies = ["package<=2.0.0"]', ["package<=2.0.0"]),
('dependencies = ["package~=1.4"]', ["package~=1.4"]),
('dependencies = ["package!=1.5.0"]', ["package!=1.5.0"]),
('dependencies = ["package>1.0"]', ["package>1.0"]),
('dependencies = ["package<2.0"]', ["package<2.0"]),
('dependencies = ["package===1.0.0"]', ["package===1.0.0"]),
# With extras
(
'dependencies = ["package[extra]==1.0.0"]',
["package[extra]==1.0.0"],
),
(
'dependencies = ["package[extra1,extra2]>=1.0.0"]',
["package[extra1,extra2]>=1.0.0"],
),
# With whitespace
('dependencies = ["package >= 1.0.0"]', ["package >= 1.0.0"]),
('dependencies = [" package==1.0.0 "]', ["package==1.0.0"]),
# With environment markers
(
'dependencies = ["package>=1.0.0; python_version>=\\"3.8\\""]',
['package>=1.0.0; python_version>="3.8"'],
),
(
'dependencies = ["package[extra]>=1.0; sys_platform==\\"linux\\""]',
[],
),
(
'dependencies = ["native>=1.0; sys_platform!=\\"emscripten\\"", "pure-python>=1.0"]',
["pure-python>=1.0"],
),
(
'dependencies = ["wasm-only; sys_platform==\\"emscripten\\"", "linux-only; sys_platform==\\"linux\\""]',
['wasm-only; sys_platform=="emscripten"'],
),
# URL dependencies - left as-is
(
'dependencies = ["package @ https://github.com/user/repo.git"]',
["package @ https://github.com/user/repo.git"],
),
(
'dependencies = ["package @ git+https://github.com/user/repo.git"]',
["package @ git+https://github.com/user/repo.git"],
),
(
'dependencies = ["package @ git+ssh://[email protected]/user/repo.git"]',
["package @ git+ssh://[email protected]/user/repo.git"],
),
(
'dependencies = ["package @ file:///path/to/local/package"]',
["package @ file:///path/to/local/package"],
),
# Multiple packages with various specifiers
(
'dependencies = ["foo==1.0", "bar>=2.0", "baz~=3.0", "qux[extra]>=4.0"]',
["foo==1.0", "bar>=2.0", "baz~=3.0", "qux[extra]>=4.0"],
),
# No version specifier
('dependencies = ["package"]', ["package"]),
]
for deps_str, expected in code_templates:
code = dedent(
f"""
# /// script
# {deps_str}
# ///
import marimo
"""
)
packages = pyodide_session.find_packages(code)
assert sorted(packages) == sorted(expected), (
f"Failed for {deps_str}: expected {expected}, got {packages}"
)
async def test_pyodide_session_put_input(
pyodide_session: PyodideSession,
) -> None:
# Test putting input
input_text = "test input"
pyodide_session.put_input(input_text)
assert not pyodide_session._queue_manager.input_queue.empty()
assert await pyodide_session._queue_manager.input_queue.get() == input_text
@pytest.mark.parametrize(
("json_payload", "expected_type"),
[
# Notebook operations
(
(
'{"type": "create-notebook", "executionRequests": [{"cellId": "cell-1", "code": "print(1)", "type": "execute-cell"}], '
'"cellIds": ["cell-1"], "setUiElementValueRequest": {"objectIds": [], "values": [], "type": "update-ui-element"}, '
'"autoRun": true}'
),
CreateNotebookCommand,
),
(
'{"type": "rename-notebook", "filename": "test.py"}',
RenameNotebookCommand,
),
# Cell execution and management
(
'{"type": "execute-cells", "cellIds": ["cell-1"], "codes": ["print(1)"]}',
ExecuteCellsCommand,
),
(
'{"type": "execute-cells", "cellIds": ["cell-1", "cell-2"], "codes": ["x=1", "y=2"]}',
ExecuteCellsCommand,
),
(
'{"type": "execute-scratchpad", "code": "print(1)"}',
ExecuteScratchpadCommand,
),
('{"type": "execute-stale-cells"}', ExecuteStaleCellsCommand),
('{"type": "debug-cell", "cellId": "cell-1"}', DebugCellCommand),
('{"type": "delete-cell", "cellId": "cell-1"}', DeleteCellCommand),
(
'{"type": "sync-graph", "cells": {"cell-1": "x=1"}, "runIds": ["cell-1"], "deleteIds": []}',
SyncGraphCommand,
),
(
'{"type": "update-cell-config", "configs": {"cell-1": {"hide_code": true}}}',
UpdateCellConfigCommand,
),
# Package management
(
'{"type": "install-packages", "manager": "pip", "versions": {}}',
InstallPackagesCommand,
),
(
'{"type": "install-packages", "manager": "pip", "versions": {"numpy": "1.24.0"}}',
InstallPackagesCommand,
),
# UI element and widget model operations
(
'{"type": "update-ui-element", "objectIds": ["test-1"], "values": [42], "token": "test-token"}',
UpdateUIElementCommand,
),
(
'{"type": "update-ui-element", "objectIds": ["test-1"], "values": [42]}',
UpdateUIElementCommand,
),
(
'{"type": "update-ui-element", "objectIds": [], "values": []}',
UpdateUIElementCommand,
),
(
'{"type": "model", "modelId": "model-1", "message": {"method": "update", "state": {}, "bufferPaths": []}, "buffers": []}',
ModelCommand,
),
(
'{"type": "invoke-function", "functionCallId": "fc-1", "namespace": "test", "functionName": "foo", "args": {}}',
InvokeFunctionCommand,
),
# Data/SQL operations
(
'{"type": "preview-dataset-column", "sourceType": "duckdb", "source": "test.db", "tableName": "users", "columnName": "id"}',
PreviewDatasetColumnCommand,
),
(
(
'{"type": "preview-sql-table", "requestId": "req-1", "engine": "duckdb", "database": "test.db", '
'"schema": "main", "tableName": "users"}'
),
PreviewSQLTableCommand,
),
(
'{"type": "list-sql-tables", "requestId": "req-2", "engine": "duckdb", "database": "test.db", "schema": "main"}',
ListSQLTablesCommand,
),
(
'{"type": "validate-sql", "requestId": "req-3", "query": "SELECT * FROM users", "onlyParse": false}',
ValidateSQLCommand,
),
(
'{"type": "validate-sql", "requestId": "req-4", "query": "SELECT * FROM users", "onlyParse": true, "dialect": "postgres"}',
ValidateSQLCommand,
),
(
'{"type": "list-data-source-connection", "engine": "duckdb"}',
ListDataSourceConnectionCommand,
),
# Secrets management
(
'{"type": "list-secret-keys", "requestId": "req-1"}',
ListSecretKeysCommand,
),
('{"type": "refresh-secrets"}', RefreshSecretsCommand),
# Cache management
('{"type": "clear-cache"}', ClearCacheCommand),
('{"type": "get-cache-info"}', GetCacheInfoCommand),
# Kernel operations
('{"type": "stop-kernel"}', StopKernelCommand),
],
)
def test_command_parsing_with_discriminator(
json_payload: str, expected_type: type
) -> None:
"""Test that Command types are parsed correctly using the type discriminator."""
parsed = parse_command(json_payload)
assert type(parsed) is expected_type, (
f"Expected {expected_type.__name__} but got {type(parsed).__name__} "
f"for payload: {json_payload}"
)
def test_control_request_parsing_invalid() -> None:
"""Test that invalid JSON raises DecodeError."""
with pytest.raises(msgspec.DecodeError):
parse_command("invalid json")
async def test_async_queue_manager_close() -> None:
"""Test closing queues puts a StopRequest."""
manager = AsyncQueueManager()
manager.close_queues()
request = await manager.control_queue.get()
assert isinstance(request, StopKernelCommand)
async def test_pyodide_session_on_message(
pyodide_session: PyodideSession,
) -> None:
"""Test that _on_message calls all consumers."""
mock_consumer1 = Mock()
mock_consumer2 = Mock()
pyodide_session.consumers = [mock_consumer1, mock_consumer2]
test_msg: KernelMessage = {
"op": "completed-run",
"cell_id": CellId_t("test"),
}
pyodide_session._on_message(test_msg)
mock_consumer1.assert_called_once_with(test_msg)
mock_consumer2.assert_called_once_with(test_msg)
async def test_pyodide_session_on_message_isolates_consumers(
pyodide_session: PyodideSession,
) -> None:
"""A failing or departing consumer does not keep the message from others."""
received: list[str] = []
def failing(_msg: KernelMessage) -> None:
raise RuntimeError("receiver is gone")
def departing(_msg: KernelMessage) -> None:
received.append("departing")
pyodide_session.consumers.remove(departing)
pyodide_session.consumers = [
failing,
departing,
lambda _msg: received.append("last"),
]
pyodide_session._on_message(b"{}")
assert received == ["departing", "last"]
async def test_pyodide_session_put_completion_request(
pyodide_session: PyodideSession,
) -> None:
"""Test putting completion requests."""
from marimo._runtime.commands import CodeCompletionCommand
completion_request = CodeCompletionCommand(
id="test",
document="test code",
cell_id=CellId_t("test"),
)
pyodide_session.put_completion_request(completion_request)
assert not pyodide_session._queue_manager.completion_queue.empty()
result = await pyodide_session._queue_manager.completion_queue.get()
assert result == completion_request
# ===== PyodideBridge Tests =====
@pytest.fixture
def pyodide_bridge(
pyodide_session: PyodideSession,
) -> PyodideBridge:
"""Create a PyodideBridge instance for testing."""
return PyodideBridge(session=pyodide_session)
def test_pyodide_bridge_init(pyodide_bridge: PyodideBridge) -> None:
"""Test PyodideBridge initialization."""
assert pyodide_bridge.session is not None
assert pyodide_bridge.file_system is not None
def test_pyodide_bridge_put_control_request(
pyodide_bridge: PyodideBridge,
) -> None:
"""Test putting control requests through the bridge."""
request_json = '{"type": "execute-cells", "cellIds": ["cell-1"], "codes": ["print(1)"]}'
pyodide_bridge.put_control_request(request_json)
assert not pyodide_bridge.session._queue_manager.control_queue.empty()
def test_pyodide_bridge_put_input(pyodide_bridge: PyodideBridge) -> None:
"""Test putting input through the bridge."""
test_input = "test input"
pyodide_bridge.put_input(test_input)
assert not pyodide_bridge.session._queue_manager.input_queue.empty()
def test_pyodide_bridge_code_complete(pyodide_bridge: PyodideBridge) -> None:
"""Test code completion through the bridge."""
request_json = '{"id": "test", "document": "test code", "cellId": "test"}'
pyodide_bridge.code_complete(request_json)
assert not pyodide_bridge.session._queue_manager.completion_queue.empty()
def test_pyodide_bridge_read_code(
pyodide_bridge: PyodideBridge,
pyodide_app_file: Path,
) -> None:
"""Test reading code through the bridge."""
del pyodide_app_file
result = pyodide_bridge.read_code()
response = json.loads(result)
assert "contents" in response
assert "marimo.App()" in response["contents"]
@pytest.mark.skipif(
not (DependencyManager.ruff.has() or DependencyManager.black.has()),
reason="ruff or black not installed",
)
async def test_pyodide_bridge_format(pyodide_bridge: PyodideBridge) -> None:
"""Test formatting code through the bridge."""
request_json = json.dumps(
{
"codes": {"cell-1": "x=1+2"},
"lineLength": 79,
}
)
result = await pyodide_bridge.format(request_json)
response = json.loads(result)
assert "codes" in response
assert "cell-1" in response["codes"]
async def test_pyodide_bridge_document_export(
pyodide_bridge: PyodideBridge,
) -> None:
result = json.loads(
await pyodide_bridge.notebook.call(
json.dumps(
{
"operation": "notebook.edit",
"params": {"notebook_id": pyodide_bridge.notebook.id},
"headers": {"idempotency-key": "edit-1"},
"body": {
"changes": [
{
"kind": "put_cell",
"base_etag": None,
"cell": {
"id": "test",
"code": 'message = "NEW"',
},
}
]
},
}
)
)
)
assert result["status"] == 200, result
request = json.dumps({"download": False})
script = json.loads(pyodide_bridge.export_script(request))
markdown = json.loads(pyodide_bridge.export_markdown(request))
assert 'message = "NEW"' in script["contents"]
assert 'message = "NEW"' in markdown["contents"]
def test_pyodide_bridge_save_user_config(
pyodide_bridge: PyodideBridge,
) -> None:
pyodide_bridge.session._initial_user_config = merge_config(
DEFAULT_CONFIG,
{
"ai": {
"open_ai": {"api_key": "configured-key"},
"mode": "manual",
}
},
)
request_json = json.dumps(
{
"config": {
"ai": {"models": {"chat_model": "openai/gpt-4o"}},
}
}
)
pyodide_bridge.save_user_config(request_json)
command = pyodide_bridge.session._queue_manager.control_queue.get_nowait()
assert isinstance(command, UpdateUserConfigCommand)
assert command.config["ai"]["open_ai"]["api_key"] == "configured-key"
assert command.config["ai"]["mode"] == "manual"
assert command.config["ai"]["models"]["chat_model"] == "openai/gpt-4o"
pyodide_bridge.save_user_config(
json.dumps({"config": {"ai": {"mode": "agent"}}})
)
command = pyodide_bridge.session._queue_manager.control_queue.get_nowait()
assert isinstance(command, UpdateUserConfigCommand)
assert command.config["ai"]["open_ai"]["api_key"] == "configured-key"
assert command.config["ai"]["mode"] == "agent"
assert command.config["ai"]["models"]["chat_model"] == "openai/gpt-4o"
def test_pyodide_bridge_rename_file(
pyodide_bridge: PyodideBridge,
tmp_path: Path,
) -> None:
"""Test renaming file through the bridge."""
new_filename = str(tmp_path / "renamed.py")
pyodide_bridge.rename_file(new_filename)
assert pyodide_bridge.session.app_manager.filename == new_filename
def test_pyodide_bridge_list_files(
pyodide_bridge: PyodideBridge,
tmp_path: Path,
) -> None:
"""Test listing files through the bridge."""
# Create some test files
(tmp_path / "test1.py").write_text("# test1")
(tmp_path / "test2.py").write_text("# test2")
request_json = json.dumps({"path": str(tmp_path)})
result = pyodide_bridge.list_files(request_json)
response = json.loads(result)
assert "files" in response
assert "root" in response
assert response["root"] == str(tmp_path)
def test_pyodide_bridge_file_roots(
pyodide_bridge: PyodideBridge,
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
"""Test listing configured file-browser roots through the bridge."""
primary = tmp_path / "project"
shared = tmp_path / "shared"
primary.mkdir()
shared.mkdir()
monkeypatch.setattr(
pyodide_bridge.file_system, "get_root", lambda: str(primary)
)
monkeypatch.setitem(
pyodide_bridge.session._initial_user_config,
"file_browser",
{"folders": [{"path": str(shared), "name": "Shared"}]},
)
response = json.loads(pyodide_bridge.file_roots())
assert response == {
"roots": [
{
"path": str(primary.resolve()),
"name": "project",
"isPrimary": True,
},
{
"path": str(shared.resolve()),
"name": "Shared",
"isPrimary": False,
},
]
}
def test_pyodide_bridge_file_details(
pyodide_bridge: PyodideBridge,
tmp_path: Path,
) -> None:
"""Test getting file details through the bridge."""
test_file = tmp_path / "test.py"
test_file.write_text("# test")
request_json = json.dumps({"path": str(test_file)})
result = pyodide_bridge.file_details(request_json)
response = json.loads(result)
assert "file" in response
assert "contents" in response
assert response["file"]["path"] == str(test_file)
def test_pyodide_bridge_toml_file_details(
pyodide_bridge: PyodideBridge,
tmp_path: Path,
) -> None:
test_file = tmp_path / "pyproject.toml"
test_file.write_text('[project]\nname = "demo"')
request_json = json.dumps({"path": str(test_file)})
response = json.loads(pyodide_bridge.file_details(request_json))
assert response["mimeType"] == "application/toml"
def test_pyodide_bridge_file_details_honors_limit(
pyodide_bridge: PyodideBridge,
tmp_path: Path,
) -> None:
test_file = tmp_path / "large.txt"
test_file.write_bytes(b"12345")
request_json = json.dumps({"path": str(test_file), "maxBytes": 4})
response = json.loads(pyodide_bridge.file_details(request_json))
assert response["contents"] is None
assert response["isTooLarge"] is True
def test_pyodide_bridge_file_details_without_limit_is_unrestricted(
pyodide_bridge: PyodideBridge,
tmp_path: Path,
) -> None:
test_file = tmp_path / "download.bin"
test_file.write_bytes(b"12345")
request_json = json.dumps({"path": str(test_file)})
response = json.loads(pyodide_bridge.file_details(request_json))
assert response["contents"] == "12345"
assert response["isTooLarge"] is False
def test_pyodide_bridge_create_file(
pyodide_bridge: PyodideBridge,
tmp_path: Path,
) -> None:
"""Test creating file through the bridge."""
import base64
test_content = b"# new file"
encoded_content = base64.b64encode(test_content).decode()
request_json = json.dumps(
{
"path": str(tmp_path),
"type": "file",
"name": "new_file.py",
"contents": encoded_content,
}
)
result = pyodide_bridge.create_file_or_directory(request_json)
response = json.loads(result)
assert response["success"] is True
assert (tmp_path / "new_file.py").exists()
def test_pyodide_bridge_delete_file(
pyodide_bridge: PyodideBridge,
tmp_path: Path,
) -> None:
"""Test deleting file through the bridge."""
test_file = tmp_path / "to_delete.py"
test_file.write_text("# delete me")
request_json = json.dumps({"path": str(test_file)})
result = pyodide_bridge.delete_file_or_directory(request_json)
response = json.loads(result)
assert response["success"] is True
assert not test_file.exists()
def test_pyodide_bridge_move_file(
pyodide_bridge: PyodideBridge,
tmp_path: Path,
) -> None:
"""Test moving file through the bridge."""
test_file = tmp_path / "old.py"
test_file.write_text("# move me")
new_path = tmp_path / "new.py"
request_json = json.dumps(
{
"path": str(test_file),
"newPath": str(new_path),
}
)
result = pyodide_bridge.move_file_or_directory(request_json)
response = json.loads(result)
assert response["success"] is True
assert not test_file.exists()
assert new_path.exists()
def test_pyodide_bridge_copy_file(
pyodide_bridge: PyodideBridge,
tmp_path: Path,
) -> None:
"""Test copying file through the bridge."""
test_file = tmp_path / "original.py"
test_file.write_text("# copy me")
new_path = tmp_path / "copied.py"
request_json = json.dumps(
{
"path": str(test_file),
"newPath": str(new_path),
}
)
result = pyodide_bridge.copy_file_or_directory(request_json)
response = json.loads(result)
assert response["success"] is True
assert test_file.exists()
assert new_path.exists()
assert new_path.read_text() == "# copy me"
def test_pyodide_bridge_update_file(
pyodide_bridge: PyodideBridge,
tmp_path: Path,
) -> None:
"""Test updating file through the bridge."""
test_file = tmp_path / "update.py"
test_file.write_text("# old content")
new_content = "# new content"
request_json = json.dumps(
{
"path": str(test_file),
"contents": new_content,
}
)
result = pyodide_bridge.update_file(request_json)
response = json.loads(result)
assert response["success"] is True
assert test_file.read_text() == new_content
def test_pyodide_bridge_export_html(
pyodide_bridge: PyodideBridge,
) -> None:
"""Test exporting HTML through the bridge."""
request_json = json.dumps(
{
"download": False,
"files": [],
"includeCode": True,
"layout": {
"type": "slides",
"data": {"deck": {"transition": "fade"}},
},
}
)
result = pyodide_bridge.export_html(request_json)
exported_file = json.loads(result)
assert exported_file["filename"] == "test.html"
assert exported_file["mediaType"] == "text/html; charset=utf-8"
assert parse_mount_config(exported_file["contents"])["layout"] == {
"type": "slides",
"data": {"deck": {"transition": "fade"}},
}
@pytest.mark.parametrize(
("flavor", "expected_filename", "expected_fence"),
[
(None, "test.md", "```python {.marimo}"),
("qmd", "test.qmd", "```{marimo .python"),
],
)
def test_pyodide_bridge_export_markdown(
pyodide_bridge: PyodideBridge,
flavor: str | None,
expected_filename: str,
expected_fence: str,
) -> None:
"""Test exporting markdown through the bridge."""
request = {"download": False}
if flavor is not None:
request["flavor"] = flavor
result = pyodide_bridge.export_markdown(json.dumps(request))
exported_file = json.loads(result)
assert exported_file["filename"] == expected_filename
assert exported_file["mediaType"] == "text/plain; charset=utf-8"
assert expected_fence in exported_file["contents"]
@pytest.mark.parametrize(
("filename", "expected_filename"),
[
("renamed.py", "renamed.script.py"),
(None, "notebook.script.py"),
],
)
def test_pyodide_bridge_export_script(
pyodide_bridge: PyodideBridge,
filename: str | None,
expected_filename: str,
) -> None:
pyodide_bridge.session.app_manager.filename = filename
result = pyodide_bridge.export_script(
json.dumps(
{
"download": False,
}
)
)
exported_file = json.loads(result)
assert exported_file["filename"] == expected_filename
assert exported_file["mediaType"] == "text/plain; charset=utf-8"
assert '# %%\n"Hello, world!"' in exported_file["contents"]
async def test_pyodide_bridge_read_snippets(
pyodide_bridge: PyodideBridge,
default_snippets: Any,
) -> None:
"""Test reading snippets through the bridge."""
with unittest.mock.patch(
"marimo._pyodide.pyodide_session.read_snippets",
return_value=default_snippets,
):
result = await pyodide_bridge.read_snippets()
data = json.loads(result)
assert isinstance(data, dict)
assert "snippets" in data
assert isinstance(data["snippets"], list)