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.

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.py
index dbcc4c6ca5..848acf08e7 100644
--- a/marimo/_ast/app.py
+++ b/marimo/_ast/app.py
@@ -31,7 +31,7 @@ from typing import (
from marimo import _loggers
from marimo._ast.app_config import _AppConfig
-from marimo._ast.cell import Cell, CellConfig, CellImpl
+from marimo._ast.cell import Cell, CellConfig, CellImpl, ImportWorkspace
from marimo._ast.cell_id import external_prefix
from marimo._ast.cell_manager import CellManager
from 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.cell
if cell is not None:
+ cell_impl = cell._cell
new_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.py
index 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 exists
markdown: Optional[str] = None
- # Mutable fields
+ # ------------------ Mutable fields --------------------------------------
+ #
# explicit configuration of cell
config: CellConfig = dataclasses.field(default_factory=CellConfig)
# workspace for runtimes to use to store metadata about imports
diff --git a/marimo/_runtime/context/kernel_context.py b/marimo/_runtime/context/kernel_context.py
index 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.py
index 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.py
index 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_traceback
from marimo._runtime import dataflow
+from marimo._runtime.context.types import safe_get_context
from marimo._runtime.control_flow import MarimoInterrupt, MarimoStopError
from 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
@staticmethod
diff --git a/marimo/_smoke_tests/appcomp/resetting_sliders/embed_test_a.py b/marimo/_smoke_tests/appcomp/resetting_sliders/embed_test_a.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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 file
diff --git a/tests/_ast/test_app.py b/tests/_ast/test_app.py
index 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 AppKernelRunner
diff --git a/tests/_runtime/runner/test_cell_runner.py b/tests/_runtime/runner/test_cell_runner.py
index 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 stderr
assert 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"] == 100
diff --git a/tests/_runtime/test_context.py b/tests/_runtime/test_context.py
index 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_notebook
assert 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"]