moops 0.13.0__tar.gz → 0.13.2__tar.gz

{moops-0.13.0 → moops-0.13.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moops
-Version: 0.13.0
+Version: 0.13.2
 Summary: Write Marimo notebooks that also work as CLI scripts, with unified UI controls
 Keywords: marimo,notebooks,cli,testing
 Author: Yair Chuchem

{moops-0.13.0 → moops-0.13.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "moops"
-version = "0.13.0"
+version = "0.13.2"
 description = "Write Marimo notebooks that also work as CLI scripts, with unified UI controls"
 license = "MIT"
 readme = "README.md"

{moops-0.13.0 → moops-0.13.2}/src/moops/_control_mirroring.py

@@ -188,7 +188,7 @@ def _create_control(
 ) -> typing.Any:
     """Create a marimo element from an existing InputControl."""
     display_option = _interface_utils.unprefixed_option(iface, input_control.option)
-    opt = group._make_opt(label=None, option=display_option)
+    opt = group._make_opt(label=input_control.label, option=display_option)
     cloned = input_control.with_option(opt.option)
     return group._register_control(opt, cloned, cloned.help_text, None)
 

{moops-0.13.0 → moops-0.13.2}/src/moops/_options.py

@@ -52,6 +52,10 @@ class InputControl(abc.ABC):
     option: str
     help_text: str
     default: typing.Any
+    # Resolved display label, stashed at registration so controls_from can
+    # mirror it. None until registered; the mirror falls back to the option
+    # name. Travels through with_option's dataclasses.replace.
+    label: str | None = dataclasses.field(default=None, kw_only=True)
     extra_kwargs: dict[str, typing.Any] = dataclasses.field(
         default_factory=dict[str, typing.Any], kw_only=True
     )

{moops-0.13.0 → moops-0.13.2}/src/moops/_variant.py

@@ -26,6 +26,12 @@ class VariantContext:
 def selected_key(selector: typing.Any) -> typing.Any:
     if hasattr(selector, "_selected_key"):
         return selector._selected_key
+    # A switch/checkbox used as a variant selector has no `_selected_key`. In
+    # the controls_from mirroring path the selector is a freshly-cloned widget,
+    # so reading `.value` trips marimo's "value accessed in its creating cell"
+    # guard; the raw cached `_value` holds the same value without the guard.
+    if hasattr(selector, "_value"):
+        return selector._value
     return selector.value
 
 

{moops-0.13.0 → moops-0.13.2}/src/moops/group.py

@@ -972,6 +972,7 @@ class Group:
         help_text: str,
         on_change: typing.Callable[[typing.Any], None] | None,
     ) -> typing.Any:
+        input_control.label = opt.label
         reset_state = self._value_resolver.query_on_change(input_control, on_change)
         control = input_control.make_element(
             self._value_resolver.get_value(input_control, input_control.default),

{moops-0.13.0 → moops-0.13.2}/src/moops/interface.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import dataclasses
 import html
+import os
 import pathlib
 import shlex
 import sys
@@ -179,6 +180,8 @@ class Interface:
             tokens = shlex.split(text)
         except ValueError as exc:
             return (f"Could not parse arguments: {exc}",)
+        if tokens[:2] == ["uv", "run"]:
+            tokens = tokens[2:]
         commands = {self.command, pathlib.PurePath(self.command).name}
         if tokens and tokens[0] in commands:
             tokens = tokens[1:]
@@ -443,9 +446,7 @@ class Interface:
             # Non-empty: the parent injected defs beyond args, so no CLI
             # command can reproduce this setup.
             return link
-        command = _text_wrap.wrap_command(
-            self.notebook_file, self._standalone_arg_groups()
-        )
+        command = _wrap_command(self.notebook_file, self._standalone_arg_groups())
         return mo.vstack(
             [link, mo.md(f"To run as a standalone script:\n```\n{command}\n```")]
         )
@@ -455,48 +456,57 @@ class Interface:
         query = urllib.parse.urlencode({"file": self.notebook_file, **values})
         return f"/?{query}"
 
-    def _standalone_query_values(self) -> dict[str, str]:
-        values: dict[str, str] = {}
-        for ctrl in self.controls:
-            if isinstance(ctrl, Interface):
-                values.update(ctrl._standalone_query_values())
-            elif (sub_iface := attached_interface(ctrl)) is not None:
-                values.update(self._controls_from_query_values(sub_iface))
-            else:
-                self._add_query_value(values, ctrl, self.input_map)
-        return values
-
-    def _controls_from_query_values(self, sub_iface: Interface) -> dict[str, str]:
-        """Collect standalone query values for a controls_from mirror.
+    def _standalone_query_values(self, prefix: str = "") -> dict[str, str]:
+        """Query params reproducing this notebook's state when run standalone.
 
-        Uses this interface's key scheme (our option_prefix) so the resulting
-        URL params match the parent notebook's parameter namespace.
+        ``prefix`` is the dotted query-param path of this interface relative to
+        the standalone root (empty at the root). A real subgroup keeps its
+        segment so its controls round-trip under the same dotted key the
+        subgroup reads back (e.g. ``sub.mode``); the embedded-summary link calls
+        this on the subgroup itself, so there ``prefix`` is empty and its
+        controls go flat, matching the embedded notebook running as root.
         """
         values: dict[str, str] = {}
-        for ctrl in sub_iface.controls:
-            if (nested := attached_interface(ctrl)) is not None:
-                values.update(self._controls_from_query_values(nested))
+        for ctrl in self.controls:
+            if (sub_iface := attached_interface(ctrl)) is not None:
+                segment = sub_iface._query_segment_below(self.query_params.prefix)
+                child = (
+                    f"{prefix}.{segment}" if prefix and segment else segment or prefix
+                )
+                values.update(sub_iface._standalone_query_values(child))
             else:
-                self._add_query_value(values, ctrl, sub_iface.input_map)
+                self._add_query_value(values, ctrl, self.input_map, prefix)
         return values
 
+    def _query_segment_below(self, parent_prefix: str) -> str:
+        """This interface's dotted query path relative to ``parent_prefix``."""
+        prefix = self.query_params.prefix
+        if parent_prefix and prefix.startswith(f"{parent_prefix}."):
+            return prefix[len(parent_prefix) + 1 :]
+        if parent_prefix and prefix == parent_prefix:
+            return ""
+        return prefix
+
     def _add_query_value(
         self,
         values: dict[str, str],
         ctrl: typing.Any,
         input_map: _input_map.InputMap,
+        prefix: str = "",
     ) -> None:
         input_control = input_map.get(ctrl)
         if input_control is None:
             return
         value = input_control.format_query_value(_marimo_controls.ctrl_value(ctrl))
         if value is not None:
-            values[_query_params.escape_url_key(self._key(input_control))] = value
+            leaf = self._key(input_control)
+            full = f"{prefix}.{leaf}" if prefix else leaf
+            values[_query_params.escape_url_key(full)] = value
 
     def _root_panel(self) -> mo.Html:
         args = self._current_args()
         body_items: list[typing.Any] = [mo.md("This notebook also works as a script:")]
-        command = _text_wrap.wrap_command(self.command, self._arg_groups())
+        command = _wrap_command(self.command, self._arg_groups())
         missing_options = self.missing_options()
         kind = "warn" if missing_options else "info"
         if self._presets_ui is not None:
@@ -621,6 +631,21 @@ def attached_interface(ctrl: typing.Any) -> Interface | None:
     return iface
 
 
+def _wrap_command(command: str, groups: list[str]) -> str:
+    if _should_use_uv_run(command):
+        return _text_wrap.wrap_command("uv", [f"run {shlex.quote(command)}", *groups])
+    return _text_wrap.wrap_command(command, groups)
+
+
+def _should_use_uv_run(command: str) -> bool:
+    path = pathlib.Path(command)
+    return (
+        "UV_RUN_RECURSION_DEPTH" in os.environ
+        and path.is_file()
+        and not os.access(path, os.X_OK)
+    )
+
+
 def _reset_value(
     input_control: _options.InputControl,
     args: _parse.ParsedArgs,