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
fix: UI element interaction should respect overridden defs in embedded apps (#7889)
Akshay Agrawal998e90024c37
diff --git a/marimo/_ast/app.py b/marimo/_ast/app.pyindex dbcc4c6ca5..848acf08e7 100644--- a/marimo/_ast/app.py+++ b/marimo/_ast/app.py@@ -31,7 +31,7 @@ from typing import (from marimo import _loggersfrom marimo._ast.app_config import _AppConfig-from marimo._ast.cell import Cell, CellConfig, CellImpl+from marimo._ast.cell import Cell, CellConfig, CellImpl, ImportWorkspacefrom marimo._ast.cell_id import external_prefixfrom marimo._ast.cell_manager import CellManagerfrom marimo._ast.errors import (@@ -292,16 +292,37 @@ class App:self._cell_manager.configs(),):cell = None- # If the cell exists, the cell data should be set.cell_data = self._cell_manager._cell_data.get(cell_id)new_cell_id = app._cell_manager.create_cell_id()+ # If the cell exists, the cell data should be set (ie not None).if cell_data is not None:cell = cell_data.cellif cell is not None:+ cell_impl = cell._cellnew_cell = Cell(_name=cell.name,+ # CellImpl has mutable fields and cannot safely be shallow copied._cell=CellImpl(- **{**cell._cell.__dict__, "cell_id": new_cell_id}+ cell_id=new_cell_id,+ key=cell_impl.key,+ code=cell_impl.code,+ mod=cell_impl.mod,+ defs=cell_impl.defs,+ refs=cell_impl.refs,+ sql_refs=cell_impl.sql_refs,+ temporaries=cell_impl.temporaries,+ variable_data=cell_impl.variable_data,+ deleted_refs=cell_impl.deleted_refs,+ body=cell_impl.body,+ last_expr=cell_impl.last_expr,+ language=cell_impl.language,+ markdown=cell_impl.markdown,+ config=CellConfig.from_dict(+ cell_impl.config.asdict()+ ),+ import_workspace=ImportWorkspace(+ is_import_block=cell_impl.import_workspace.is_import_block+ ),),_app=InternalApp(app),)@@ -1015,6 +1036,10 @@ class InternalApp:) -> tuple[HumanReadableStatus, JSONType, bool]:return await self._app._function_call(request)+ def overrides(self) -> dict[str, Any] | None:+ """Overridden definitions; only matters for embedded apps."""+ return self._app._get_kernel_runner()._previously_seen_defs+def to_ir(self) -> NotebookSerializationV1:return NotebookSerializationV1(header=Header(value=self._app._header)diff --git a/marimo/_ast/cell.py b/marimo/_ast/cell.pyindex 488e3fa3d9..08c3e95fcf 100644--- a/marimo/_ast/cell.py+++ b/marimo/_ast/cell.py@@ -177,7 +177,8 @@ class CellImpl:# Markdown content of the cell if it existsmarkdown: Optional[str] = None- # Mutable fields+ # ------------------ Mutable fields --------------------------------------+ ## explicit configuration of cellconfig: CellConfig = dataclasses.field(default_factory=CellConfig)# workspace for runtimes to use to store metadata about importsdiff --git a/marimo/_runtime/context/kernel_context.py b/marimo/_runtime/context/kernel_context.pyindex 63368cf919..3048c8a28f 100644--- a/marimo/_runtime/context/kernel_context.py+++ b/marimo/_runtime/context/kernel_context.py@@ -174,7 +174,11 @@ def create_kernel_context(function_registry=FunctionRegistry(),cache_store=get_store(kernel.app_metadata.filename),cell_lifecycle_registry=CellLifecycleRegistry(),- app_kernel_runner_registry=AppKernelRunnerRegistry(),+ app_kernel_runner_registry=(+ parent.app_kernel_runner_registry+ if parent is not None+ else AppKernelRunnerRegistry()+ ),virtual_file_registry=VirtualFileRegistry(storage=storage),virtual_files_supported=virtual_files_supported,stream=stream,diff --git a/marimo/_runtime/context/types.py b/marimo/_runtime/context/types.pyindex f8f6dedcb5..51b879f8b9 100644--- a/marimo/_runtime/context/types.py+++ b/marimo/_runtime/context/types.py@@ -175,6 +175,9 @@ class RuntimeContext(abc.ABC):def with_cell_id(self, cell_id: CellId_t) -> Iterator[None]:pass+ def is_embedded(self) -> bool:+ return self.parent is not None+def add_child(self, runtime_context: RuntimeContext) -> None:if runtime_context not in self.children:self.children.append(runtime_context)diff --git a/marimo/_runtime/runner/cell_runner.py b/marimo/_runtime/runner/cell_runner.pyindex f9c1cb7c7c..a5d67fdccc 100644--- a/marimo/_runtime/runner/cell_runner.py+++ b/marimo/_runtime/runner/cell_runner.py@@ -28,6 +28,7 @@ from marimo._messaging.errors import ()from marimo._messaging.tracebacks import write_tracebackfrom marimo._runtime import dataflow+from marimo._runtime.context.types import safe_get_contextfrom marimo._runtime.control_flow import MarimoInterrupt, MarimoStopErrorfrom marimo._runtime.exceptions import (MarimoMissingRefError,@@ -204,11 +205,23 @@ class Runner:relatives=dataflow.get_import_block_relatives(graph),)- return dataflow.topological_sort(+ sorted_cells = dataflow.topological_sort(graph,cells_to_run - excluded_cells,)+ # Overridden cells may be on the path of a UI element update.+ if (+ (ctx := safe_get_context()) is not None+ and ctx.is_embedded()+ and ((overrides := ctx.app.overrides()) is not None)+ ):+ sorted_cells = dataflow.prune_cells_for_overrides(+ graph, sorted_cells, overrides+ )++ return sorted_cells+# Adapted from# https://github.com/ipython/ipykernel/blob/eddd3e666a82ebec287168b0da7cfa03639a3772/ipykernel/ipkernel.py#L312 # noqa: E501@staticmethoddiff --git a/marimo/_smoke_tests/appcomp/resetting_sliders/embed_test_a.py b/marimo/_smoke_tests/appcomp/resetting_sliders/embed_test_a.pynew file mode 100644index 0000000000..cdbc2f0da3--- /dev/null+++ b/marimo/_smoke_tests/appcomp/resetting_sliders/embed_test_a.py@@ -0,0 +1,54 @@+import marimo++__generated_with = "0.19.2"+app = marimo.App()+++def _():+ import marimo as mo+ return+++def _():+ import embed_test_b+ return (embed_test_b,)+++def _(embed_test_b):+ clone_a = embed_test_b.app.clone()+ return (clone_a,)+++async def _(clone_a):+ embed_a = await clone_a.embed()+ embed_a.output+ return (embed_a,)+++def _(embed_test_b):+ clone_b = embed_test_b.app.clone()+ return (clone_b,)+++async def _(clone_b, embed_a):+ (+ await clone_b.embed(+ defs={+ "slider": None,+ "value": embed_a.defs["value"],+ "label": "their",+ "kind": "warn",+ }+ )+ ).output+ return+++if __name__ == "__main__":+ app.run()diff --git a/marimo/_smoke_tests/appcomp/resetting_sliders/embed_test_b.py b/marimo/_smoke_tests/appcomp/resetting_sliders/embed_test_b.pynew file mode 100644index 0000000000..61454a68d1--- /dev/null+++ b/marimo/_smoke_tests/appcomp/resetting_sliders/embed_test_b.py@@ -0,0 +1,62 @@+import marimo++__generated_with = "0.19.2"+app = marimo.App(width="full")+++def _():+ import marimo as mo+ import time+ return (mo,)+++def _():+ state = None+ return (state,)+++def _(mo):+ print("Creating slider")+ slider = mo.ui.slider(0, 10, 1, 3, label="A slider")+ return (slider,)+++def _(slider):+ slider+ return+++def _(slider, state):+ value = slider.value if state is None else state()+ label = "our"+ return label, value+++def _():+ kind = "info"+ return (kind,)+++def _(kind, label, mo, value):+ mo.callout(+ mo.md(f"""+ The value of *{label}* slider is **{value}**!+ """), kind+ )+ return+++def _():+ return+++if __name__ == "__main__":+ app.run()diff --git a/marimo/_smoke_tests/appcomp/ui_elements_with_overrides/embed_test_a.py b/marimo/_smoke_tests/appcomp/ui_elements_with_overrides/embed_test_a.pynew file mode 100644index 0000000000..b5b327b9a4--- /dev/null+++ b/marimo/_smoke_tests/appcomp/ui_elements_with_overrides/embed_test_a.py@@ -0,0 +1,55 @@+import marimo++__generated_with = "0.19.2"+app = marimo.App(width="full")+++def _():+ # https://github.com/marimo-team/marimo/issues/7685+ import marimo as mo+ return+++def _():+ import embed_test_b+ return (embed_test_b,)+++def _(embed_test_b):+ clone_a = embed_test_b.app.clone()+ return (clone_a,)+++async def _(clone_a):+ embed_a = await clone_a.embed()+ embed_a.output+ return (embed_a,)+++def _(embed_test_b):+ clone_b = embed_test_b.app.clone()+ return (clone_b,)+++async def _(clone_b, embed_a):+ (+ await clone_b.embed(+ defs={"value": embed_a.defs["value"], "label": "their", "kind": "warn"}+ )+ ).output+ return+++def _():+ return+++if __name__ == "__main__":+ app.run()diff --git a/marimo/_smoke_tests/appcomp/ui_elements_with_overrides/embed_test_b.py b/marimo/_smoke_tests/appcomp/ui_elements_with_overrides/embed_test_b.pynew file mode 100644index 0000000000..5eb1739ce2--- /dev/null+++ b/marimo/_smoke_tests/appcomp/ui_elements_with_overrides/embed_test_b.py@@ -0,0 +1,49 @@+import marimo++__generated_with = "0.18.4"+app = marimo.App(width="full")+++def _():+ import marimo as mo+ return (mo,)+++def _(mo):+ slider = mo.ui.slider(0, 10, 1, 3, label="A slider")+ slider+ return (slider,)+++def _(slider):+ value = slider.value+ label = "our"+ return label, value+++def _():+ kind = "info"+ return (kind,)+++def _(kind, label, mo, value):+ mo.callout(+ mo.md(f"""+ The value of *{label}* slider is **{value}**!+ """), kind+ )+ return+++def _():+ return+++if __name__ == "__main__":+ app.run()\ No newline at end of filediff --git a/tests/_ast/test_app.py b/tests/_ast/test_app.pyindex 7d50efc3dd..6687c54440 100644--- a/tests/_ast/test_app.py+++ b/tests/_ast/test_app.py@@ -886,6 +886,60 @@ class TestApp:InternalApp(app).cell_manager.cell_ids())+ def test_app_clone_deep_copies_cell_impl_mutable_fields(self) -> None:+ """Test that clone() deep-copies CellImpl's mutable fields.++ CellImpl has mutable fields (config, import_workspace, and private+ runtime state) that should not be shared between the original and+ cloned app.+ """+ app = App()++ @app.cell+ def __():+ x = 1+ return (x,)++ clone = app.clone()++ original_internal = InternalApp(app)+ cloned_internal = InternalApp(clone)++ # Get the cell data from both apps+ original_cell_ids = list(original_internal.cell_manager.cell_ids())+ cloned_cell_ids = list(cloned_internal.cell_manager.cell_ids())++ original_cell = original_internal.cell_manager._cell_data[+ original_cell_ids[0]+ ].cell+ cloned_cell = cloned_internal.cell_manager._cell_data[+ cloned_cell_ids[0]+ ].cell++ assert original_cell is not None+ assert cloned_cell is not None++ original_impl = original_cell._cell+ cloned_impl = cloned_cell._cell++ # CellImpl objects should be different+ assert original_impl is not cloned_impl++ # Public mutable fields should be deep-copied, not shared+ assert original_impl.config is not cloned_impl.config+ assert original_impl.import_workspace is not cloned_impl.import_workspace++ # Private mutable runtime state fields should also be independent+ assert original_impl._status is not cloned_impl._status+ assert original_impl._run_result_status is not cloned_impl._run_result_status+ assert original_impl._stale is not cloned_impl._stale+ assert original_impl._output is not cloned_impl._output++ # Verify mutation of config doesn't affect the original+ cloned_impl.config.configure({"disabled": True})+ assert cloned_impl.config.disabled is True+ assert original_impl.config.disabled is False+def test_to_py(self) -> None:"""Test that InternalApp.to_py() returns the Python code representation."""app = App()@@ -1592,6 +1646,128 @@ class TestAppComposition:assert is_external_cell_id(setup_cell_ids[0])+class TestInternalAppOverrides:+ """Tests for InternalApp.overrides() method."""++ async def test_overrides_none_when_no_defs_passed(+ self, k: Kernel, exec_req: ExecReqProvider+ ) -> None:+ """Test that overrides() returns None when no defs are passed."""+ await k.run(+ [+ exec_req.get(+ """+ from marimo import App+ from marimo._ast.app import InternalApp++ app = App()++ @app.cell+ def __() -> tuple[int]:+ x = 10+ return (x,)++ @app.cell+ def __(x: int) -> tuple[int]:+ y = x + 1+ return (y,)+ """+ ),+ exec_req.get(+ """+ # embed without any overrides+ result = await app.embed()+ internal_app = InternalApp(app)+ overrides = internal_app.overrides()+ """+ ),+ ]+ )+ assert not k.errors+ assert k.globals["overrides"] is None++ async def test_overrides_returns_overridden_defs_dict(+ self, k: Kernel, exec_req: ExecReqProvider+ ) -> None:+ """Test that overrides() returns a dict of overridden definitions."""+ await k.run(+ [+ exec_req.get(+ """+ from marimo import App+ from marimo._ast.app import InternalApp++ app = App()++ @app.cell+ def __() -> tuple[int]:+ x = 10+ return (x,)++ @app.cell+ def __(x: int) -> tuple[int]:+ y = x + 1+ return (y,)+ """+ ),+ exec_req.get(+ """+ # embed with x overridden+ result = await app.embed(defs={"x": 100})+ internal_app = InternalApp(app)+ overrides = internal_app.overrides()+ """+ ),+ ]+ )+ assert not k.errors+ assert k.globals["overrides"] == {"x": 100}++ async def test_overrides_returns_multiple_defs(+ self, k: Kernel, exec_req: ExecReqProvider+ ) -> None:+ """Test that overrides() returns all overridden definitions."""+ await k.run(+ [+ exec_req.get(+ """+ from marimo import App+ from marimo._ast.app import InternalApp++ app = App()++ @app.cell+ def __() -> tuple[int]:+ a = 1+ return (a,)++ @app.cell+ def __() -> tuple[int]:+ b = 2+ return (b,)++ @app.cell+ def __(a: int, b: int) -> tuple[int]:+ c = a + b+ return (c,)+ """+ ),+ exec_req.get(+ """+ # embed with both a and b overridden+ result = await app.embed(defs={"a": 10, "b": 20})+ internal_app = InternalApp(app)+ overrides = internal_app.overrides()+ """+ ),+ ]+ )+ assert not k.errors+ assert k.globals["overrides"] == {"a": 10, "b": 20}++++class TestAppKernelRunnerRegistry:def test_get_runner(self, k: Kernel) -> None:# `k` fixture installs a context, needed for AppKernelRunnerdiff --git a/tests/_runtime/runner/test_cell_runner.py b/tests/_runtime/runner/test_cell_runner.pyindex e9db5a57b9..2aa8b7c25c 100644--- a/tests/_runtime/runner/test_cell_runner.py+++ b/tests/_runtime/runner/test_cell_runner.py@@ -137,3 +137,68 @@ raise ParseError("malformed SQL")stderr = buffer.getvalue()assert "Traceback (most recent call last):" not in stderrassert isinstance(runner.exceptions[er.cell_id], MarimoSQLError)+++async def test_ui_element_update_skips_overridden_cells(+ execution_kernel: Kernel, exec_req: ExecReqProvider+) -> None:+ """Test that UI element updates skip cells whose defs are overridden."""+ from marimo._runtime.commands import UpdateUIElementCommand++ k = execution_kernel+ await k.run(+ [+ exec_req.get(+ """+ from marimo import App+ import marimo as mo++ app = App()++ @app.cell+ def _():+ import marimo as mo+ # Use a counter to track how many times this cell runs+ slider = mo.ui.slider(0, 10, value=5)+ return (slider,)++ @app.cell+ def _(slider):+ # This cell defines x based on the slider+ x = slider.value+ return (x,)++ @app.cell+ def _(x):+ # This cell uses x+ result = x * 2+ return (result,)+ """+ ),+ exec_req.get(+ """+ # Embed with x overridden - the cell defining x should be skipped+ # on UI element updates+ embed_result = await app.embed(defs={"x": 100})+ slider_element = embed_result.defs["slider"]+ initial_result = embed_result.defs["result"]+ """+ ),+ ]+ )+ assert not k.errors+ # With x=100 overridden, result should be 200+ assert k.globals["initial_result"] == 200++ # Now update the slider - the cell defining x should NOT run+ # because x is overridden+ slider_element = k.globals["slider_element"]+ assert await k.set_ui_element_value(+ UpdateUIElementCommand.from_ids_and_values([(slider_element._id, 8)])+ )++ # After UI update, result should still be 200 because x is still overridden+ embed_result = k.globals["embed_result"]+ assert embed_result.defs["result"] == 200+ # x should still be the overridden value, not slider.value+ assert embed_result.defs["x"] == 100diff --git a/tests/_runtime/test_context.py b/tests/_runtime/test_context.pyindex 7944b938f4..1ae009f589 100644--- a/tests/_runtime/test_context.py+++ b/tests/_runtime/test_context.py@@ -30,3 +30,60 @@ def test_not_running_in_notebook() -> None:from marimo._runtime.context.utils import running_in_notebookassert not running_in_notebook()+++async def test_is_embedded(+ execution_kernel: Kernel, exec_req: ExecReqProvider+) -> None:+ """Test that is_embedded() returns True when parent context exists."""+ k = execution_kernel+ await k.run(+ [+ exec_req.get(+ """+ import marimo as mo+ from marimo._runtime.context.types import get_context++ # In the main kernel, there's no parent, so is_embedded is False+ ctx = get_context()+ is_embedded_main = ctx.is_embedded()+ """+ )+ ]+ )+ assert not k.errors+ assert not k.globals["is_embedded_main"]+++async def test_is_embedded_in_app_embed(+ execution_kernel: Kernel, exec_req: ExecReqProvider+) -> None:+ """Test that is_embedded() returns True inside an embedded app."""+ k = execution_kernel+ await k.run(+ [+ exec_req.get(+ """+ from marimo import App++ app = App()++ @app.cell+ def _():+ from marimo._runtime.context.types import get_context+ ctx = get_context()+ is_embedded_inner = ctx.is_embedded()+ return (is_embedded_inner,)+ """+ ),+ exec_req.get(+ """+ result = await app.embed()+ is_embedded_in_app = result.defs["is_embedded_inner"]+ """+ ),+ ]+ )+ assert not k.errors+ # Inside the embedded app, is_embedded should return True+ assert k.globals["is_embedded_in_app"]