moops 0.3.1__tar.gz → 0.3.2__tar.gz

{moops-0.3.1 → moops-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moops
-Version: 0.3.1
+Version: 0.3.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.3.1 → moops-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "moops"
-version = "0.3.1"
+version = "0.3.2"
 description = "Write Marimo notebooks that also work as CLI scripts, with unified UI controls"
 license = "MIT"
 readme = "README.md"
@@ -40,6 +40,7 @@ dev-dependencies = [
     "pytest>=9.0.3",
     "vulture>=2.16",
     "pymarkdownlnt>=0.9.37",
+    "matplotlib>=3.10.9",
 ]
 
 [tool.pytest.ini_options]

{moops-0.3.1 → moops-0.3.2}/src/moops/__init__.py

@@ -1,10 +1,11 @@
 from importlib.metadata import version
 
 from ._run import run
+from ._run_button import run_button
 from .group import Group
 from .interface import Interface
 from .presets import Presets
 
 __version__ = version("moops")
 
-__all__ = ["Group", "Interface", "Presets", "__version__", "run"]
+__all__ = ["Group", "Interface", "Presets", "__version__", "run", "run_button"]

{moops-0.3.1 → moops-0.3.2}/src/moops/_options.py

@@ -36,7 +36,7 @@ class InputControl(abc.ABC):
 
     def options(self) -> set[str]:
         """Value options for this control."""
-        return set()
+        return {self.option}
 
     def flags(self) -> set[str]:
         """Flags for this control."""
@@ -98,6 +98,9 @@ class InputControl(abc.ABC):
 class FlagControl(InputControl):
     default: bool = False
 
+    def options(self) -> set[str]:
+        return set()
+
     def flags(self) -> set[str]:
         return {self.option}
 
@@ -157,9 +160,6 @@ class ValueControl(InputControl):
 
     metavar: str
 
-    def options(self) -> set[str]:
-        return {self.option}
-
     def format_usage_parts(self) -> list[str]:
         return [f"[{self.option} {self.metavar}]"]
 
@@ -536,13 +536,10 @@ class RangeControl(ValueControl):
 
 @dataclasses.dataclass
 class DropdownControl(InputControl):
-    allowed_values: list[str]
+    dropdown_opts: dict[str, typing.Any]
     supports_none: bool
     default: str | None
 
-    def options(self) -> set[str]:
-        return {self.option}
-
     @property
     def has_no_flag(self) -> bool:
         return self.supports_none and self.default is not None
@@ -564,26 +561,28 @@ class DropdownControl(InputControl):
         raw = args.value_for(self.option)
         if raw is None:
             return None
-        if raw not in self.allowed_values:
+        if raw not in self.dropdown_opts:
             return ParseError(
                 f"Option {self.option} must be one of"
-                f" {self.allowed_values!r}, got: {raw!r}"
+                f" {list(self.dropdown_opts)!r}, got: {raw!r}"
             )
         return ParseResult(raw)
 
     def parse_query_value(self, value: str) -> ParseResult | ParseError:
         if not value and self.supports_none:
             return ParseResult(None)
-        if value not in self.allowed_values:
+        if value not in self.dropdown_opts:
             return ParseError(
                 f"Query parameter for {self.option} must be one of"
-                f" {self.allowed_values!r}, got: {value!r}"
+                f" {list(self.dropdown_opts)!r}, got: {value!r}"
             )
         return ParseResult(value)
 
     def strategy(self) -> st.SearchStrategy:
         return st.sampled_from(
-            [None, *self.allowed_values] if self.supports_none else self.allowed_values
+            [None, *self.dropdown_opts.keys()]
+            if self.supports_none
+            else list(self.dropdown_opts.keys())
         )
 
     def format_usage_parts(self) -> list[str]:
@@ -592,7 +591,7 @@ class DropdownControl(InputControl):
         return [f"[{self.option} {self._values_text()}]"]
 
     def _values_text(self) -> str:
-        return "{" + "|".join(self.allowed_values) + "}"
+        return "{" + "|".join(self.dropdown_opts) + "}"
 
     def format_help_lines(self) -> list[str]:
         line = f"  {self.option} {self._values_text()}: {self.help_text}"
@@ -614,13 +613,16 @@ class DropdownControl(InputControl):
     def format_query_value(self, value: typing.Any) -> str | None:
         if value == self.default:
             return None
-        return "" if value is None else str(value)
+        return next(
+            (k for k, v in self.dropdown_opts.items() if v == value),
+            "" if value is None else str(value),
+        )
 
     def prompt_interactive(
         self, effective_default: typing.Any = _UNSET
     ) -> dict[str, str | None]:
         d = self.default if effective_default is _UNSET else effective_default
-        choices = (["none"] if self.supports_none else []) + self.allowed_values
+        choices = [*(["none"] if self.supports_none else []), *self.dropdown_opts]
         for i, v in enumerate(choices, 1):
             print(f"  {i}) {v}")
         default_display = f" [{d if d is not None else 'none'}]"
@@ -634,12 +636,12 @@ class DropdownControl(InputControl):
                 idx = int(response) - 1
                 select_none = self.supports_none and idx == 0
                 chosen = choices[idx]
-            elif response in self.allowed_values:
+            elif response in self.dropdown_opts:
                 chosen = response
             elif (
                 response.lower() == "none"
                 and self.supports_none
-                and "none" not in self.allowed_values
+                and "none" not in self.dropdown_opts
             ):
                 select_none = True
             else:

{moops-0.3.1 → moops-0.3.2}/src/moops/_query_params.py

@@ -80,9 +80,7 @@ class QueryParams:
     def _is_user_key(self, key: str) -> bool:
         if key == "file":
             return False
-        if not self.prefix:
-            return True
-        return key.startswith(f"{self.prefix}.")
+        return not self.prefix or key.startswith(f"{self.prefix}.")
 
     def _set(self, key: str, value: str | None) -> None:
         params = self.params

moops-0.3.2/src/moops/_run_button.py

@@ -0,0 +1,20 @@
+import typing
+
+import marimo as mo
+
+
+class _RunButtonStub:
+    """Returned by run_button() outside notebooks; always considered clicked."""
+
+    value: bool = True
+
+
+def run_button(**kwargs: typing.Any) -> mo.ui.run_button | _RunButtonStub:
+    """Create a run button that gates notebook execution.
+
+    In CLI context, always returns a stub with .value = True so code that
+    checks `mo.stop(not btn.value)` runs unconditionally.
+    """
+    if mo.running_in_notebook():
+        return mo.ui.run_button(**kwargs)
+    return _RunButtonStub()

{moops-0.3.1 → moops-0.3.2}/src/moops/group.py

@@ -11,6 +11,7 @@ import weakref
 import marimo as mo
 
 from . import _input_map, _markdown, _naming, _options, _parse, _query_params, interface
+from ._run_button import run_button
 from .interface import FileBrowserWithInitialSelection
 from .presets import Presets
 
@@ -76,6 +77,21 @@ class Group:
         """
         if markdown_heading_offset < 0:
             raise ValueError("markdown_heading_offset must be non-negative")
+        _frame = inspect.currentframe()
+        _caller = _frame.f_back if _frame else None
+        if (
+            _caller is not None
+            and mo.running_in_notebook()
+            and bool(_caller.f_code.co_flags & inspect.CO_COROUTINE)
+        ):
+            warnings.warn(
+                f"args.subgroup('{prefix}') called inside an async cell, "
+                "likely the cell making the embed it is used for. "
+                "Each cell re-run creates a new Group object, "
+                "which causes the embedded notebook to reload and lose widget state. "
+                "Move args.subgroup() to a separate sync cell instead.",
+                stacklevel=2,
+            )
         child = type(self)([prefix])
         child._state = self._state
         child._cli_map = _input_map.InputMap()
@@ -509,6 +525,17 @@ class Group:
         )
         return self._cli_map.register(wrapped, cli)
 
+    @staticmethod
+    def run_button(
+        **kwargs: typing.Any,
+    ):
+        """Create a run button that gates notebook execution.
+
+        In CLI context, always returns a stub with .value = True so code that
+        checks `mo.stop(not btn.value)` runs unconditionally.
+        """
+        return run_button(**kwargs)
+
     def _numeric_cli(
         self,
         start: float | None,
@@ -544,20 +571,22 @@ class Group:
 
         assert len(options) > 0, "Dropdown options cannot be empty"
         opt = self._make_opt(label=label, option=option)
-        keys = list(options)
         if value is None and not allow_select_none:
-            value, *_ = keys
+            value, *_ = [*options]
         cli = _options.DropdownControl(
             option=opt.option,
-            allowed_values=keys,
+            dropdown_opts=options
+            if isinstance(options, dict)
+            else {opt: opt for opt in options},
             supports_none=allow_select_none,
             default=value,
             help_text=help_text,
         )
         if self._is_overridden(opt.option):
-            # mo.ui.dropdown doesn't support disabled; filter to one option as a
-            # workaround so the user can't change the value. Remove once marimo adds
-            # disabled support for dropdowns.
+            # mo.ui.dropdown doesn't support disabled;
+            # (see https://github.com/marimo-team/marimo/issues/9579)
+            # So we filter to one option as a workaround
+            # so the user can't change the value.
             override = self._overrides[self._override_key(opt.option)]
             options = (
                 {override: None if override is None else options[override]}