moops 0.7.0__tar.gz → 0.7.2__tar.gz

{moops-0.7.0 → moops-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moops
-Version: 0.7.0
+Version: 0.7.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.7.0 → moops-0.7.2}/pyproject.toml

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

moops-0.7.2/src/moops/_choice_options.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import typing
+
+
+def option_values(
+    options: typing.Sequence[typing.Any] | dict[str, typing.Any],
+) -> dict[str, typing.Any]:
+    if isinstance(options, dict):
+        return dict(options)
+    return {str(opt): opt for opt in options}
+
+
+def option_key(options: dict[str, typing.Any], value: typing.Any) -> str:
+    if isinstance(value, str) and value in options:
+        return value
+    return next(
+        (key for key, option_value in options.items() if value == option_value),
+        str(value),
+    )
+
+
+def option_value(options: dict[str, typing.Any], value: typing.Any) -> typing.Any:
+    return options[value] if isinstance(value, str) and value in options else value

moops-0.7.2/src/moops/_control_mirroring.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import dataclasses
+import typing
+
+import marimo as mo
+
+from . import _options, interface
+
+
+def controls_from(
+    group: typing.Any,
+    iface: interface.Interface,
+    *,
+    prefix: str,
+    exclude: typing.Iterable[str] = (),
+) -> mo.ui.dictionary:
+    """Create a subgroup of controls mirroring another notebook's interface."""
+    child = group.subgroup(prefix)
+    excluded = set(exclude)
+    controls: dict[str, typing.Any] = {
+        name: (
+            controls_from(child, ctrl_or_sub, prefix=name)
+            if isinstance(ctrl_or_sub, interface.Interface)
+            else _create_control(child, iface, ctrl_or_sub)
+        )
+        for name, ctrl_or_sub in iface.iter_controls()
+        if name not in excluded
+    }
+    result = mo.ui.dictionary(controls)
+    # mo.ui.dictionary clones its elements, so result.elements[key] is a
+    # different object than controls[key]. Rebind nested dictionary clones
+    # to interfaces that track their own live cloned elements.
+    for key, original in controls.items():
+        _reattach_interface_to_clone(original, result.elements[key])
+    # Use the live clones (result.elements) rather than the originals so
+    # that cur_values() reads up-to-date widget values.
+    result._moops_interface = child.interface(*result.elements.values())  # type: ignore[attr-defined]
+    return result
+
+
+def _create_control(
+    group: typing.Any,
+    iface: interface.Interface,
+    input_control: _options.InputControl,
+) -> typing.Any:
+    return _create_from_input_control(
+        group, input_control, _unprefixed_option(iface, input_control.option)
+    )
+
+
+def _create_from_input_control(
+    group: typing.Any,
+    input_control: _options.InputControl,
+    display_option: str,
+) -> typing.Any:
+    """Create a marimo element from an existing InputControl."""
+    opt = group._make_opt(label=None, option=display_option)
+    cloned = dataclasses.replace(input_control, option=opt.option)
+    return group._register_control(opt, cloned, cloned.help_text, None)
+
+
+def _unprefixed_option(iface: interface.Interface, option: str) -> str:
+    if iface.option_prefix and option.startswith(f"{iface.option_prefix}-"):
+        return f"--{option[len(iface.option_prefix) :].lstrip('-')}"
+    return option
+
+
+def _reattach_interface_to_clone(original: typing.Any, clone: typing.Any) -> None:
+    moops_iface = getattr(original, "_moops_interface", None)
+    if not isinstance(moops_iface, interface.Interface):
+        return
+    original_elements = getattr(original, "elements", None)
+    clone_elements = getattr(clone, "elements", None)
+    if isinstance(original_elements, dict) and isinstance(clone_elements, dict):
+        typed_original_elements = typing.cast(dict[str, typing.Any], original_elements)
+        typed_clone_elements = typing.cast(dict[str, typing.Any], clone_elements)
+        for key, original_child in typed_original_elements.items():
+            if key in typed_clone_elements:
+                _reattach_interface_to_clone(original_child, typed_clone_elements[key])
+        controls = tuple(typed_clone_elements.values())
+    else:
+        controls = moops_iface.controls
+    moops_iface.controls = controls
+    clone._moops_interface = moops_iface

{moops-0.7.0 → moops-0.7.2}/src/moops/_naming.py

@@ -27,6 +27,10 @@ class OptionLabel:
                 label = option.lstrip("-").replace("-", " ")
         return OptionLabel(label=label, option=option)
 
+    @property
+    def metavar(self) -> str:
+        return self.label.upper().replace(" ", "_")
+
     def label_with_tooltip(self, help_text: str) -> str:
         return (
             f'<span title="{html.escape(help_text, quote=True)} ({self.option})">'

{moops-0.7.0 → moops-0.7.2}/src/moops/_options.py

@@ -10,7 +10,7 @@ import typing
 import marimo as mo
 from hypothesis import strategies as st
 
-from . import _parse, _ui_workarounds
+from . import _choice_options, _parse, _ui_workarounds
 
 Numeric = int | float
 
@@ -33,6 +33,7 @@ class InputControl(abc.ABC):
 
     option: str
     help_text: str
+    default: typing.Any
     extra_kwargs: dict[str, typing.Any] = dataclasses.field(  # type: ignore[assignment]
         default_factory=dict, kw_only=True
     )
@@ -734,7 +735,9 @@ class MultiSelectControl(ValueControl):
         on_change: typing.Callable[[typing.Any], None] | None = None,
         disabled: bool = False,
     ) -> typing.Any:
-        selected_keys = [_option_key(self.select_opts, item) for item in value]
+        selected_keys = [
+            _choice_options.option_key(self.select_opts, item) for item in value
+        ]
         if disabled:
             return _ui_workarounds.LockedMultiselect(
                 [str(item) for item in value], label
@@ -821,7 +824,10 @@ class MultiSelectControl(ValueControl):
         if self.default:
             line += (
                 " (default: "
-                + ", ".join(_option_key(self.select_opts, v) for v in self.default)
+                + ", ".join(
+                    _choice_options.option_key(self.select_opts, v)
+                    for v in self.default
+                )
                 + ")"
             )
         line += f" (repeat {self.option} to select multiple)"
@@ -836,21 +842,20 @@ class MultiSelectControl(ValueControl):
             return []
         if not values and self._no_flag:
             return [self._no_flag]
-        return [
-            f"{self.option} {shlex.quote(_option_key(self.select_opts, v))}"
-            for v in values
-        ]
+        return [f"{self.option} {shlex.quote(self._key_for(v))}" for v in values]
 
     def format_query_value(self, value: typing.Any) -> str | None:
         values = list(value)
-        keys = [_option_key(self.select_opts, v) for v in values]
+        keys = [_choice_options.option_key(self.select_opts, v) for v in values]
         return None if values == self.default else json.dumps(keys)
 
     def prompt_interactive(
         self, effective_default: typing.Any = _UNSET
     ) -> dict[str, str | None]:
         d = self.default if effective_default is _UNSET else effective_default
-        default_keys = {_option_key(self.select_opts, v) for v in (d or [])}
+        default_keys = {
+            _choice_options.option_key(self.select_opts, v) for v in (d or [])
+        }
         for i, v in enumerate(self.select_opts, 1):
             mark = "*" if v in default_keys else " "
             print(f"  {mark}{i}) {v}")
@@ -861,6 +866,9 @@ class MultiSelectControl(ValueControl):
         parts = [p.strip() for p in response.split(",") if p.strip()]
         return {self.option: "\n".join(parts)}
 
+    def _key_for(self, value: typing.Any) -> str:
+        return _choice_options.option_key(self.select_opts, value)
+
 
 @dataclasses.dataclass
 class DropdownControl(InputControl):
@@ -1037,14 +1045,5 @@ def _range_stop(
     return max(steps) if steps else stop
 
 
-def _option_key(options: dict[str, typing.Any], value: typing.Any) -> str:
-    if isinstance(value, str) and value in options:
-        return value
-    for key, option_value in options.items():
-        if value == option_value:
-            return key
-    return str(value)
-
-
 def _format_range(value: typing.Iterable[typing.Any]) -> str:
     return ",".join(str(v) for v in value)

{moops-0.7.0 → moops-0.7.2}/src/moops/group.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import dataclasses
 import inspect
 import pathlib
 import typing
@@ -9,7 +8,8 @@ import warnings
 import marimo as mo
 
 from . import (
-    _control_factory,
+    _choice_options,
+    _control_mirroring,
     _input_map,
     _markdown,
     _naming,
@@ -276,13 +276,7 @@ class Group:
             widget="switch",
             extra_kwargs=kwargs,
         )
-        return self._input_map.register(
-            input_control.create_marimo_element(
-                self._get_value(input_control, value),
-                **self._control_kwargs(opt, input_control, help_text, on_change),
-            ),
-            input_control,
-        )
+        return self._register_control(opt, input_control, help_text, on_change)
 
     def checkbox(
         self,
@@ -304,13 +298,7 @@ class Group:
             widget="checkbox",
             extra_kwargs=kwargs,
         )
-        return self._input_map.register(
-            input_control.create_marimo_element(
-                self._get_value(input_control, value),
-                **self._control_kwargs(opt, input_control, help_text, on_change),
-            ),
-            input_control,
-        )
+        return self._register_control(opt, input_control, help_text, on_change)
 
     def text(
         self,
@@ -335,18 +323,12 @@ class Group:
         opt = self._make_opt(label=label, option=option)
         input_control = _options.TextControl(
             option=opt.option,
-            metavar=placeholder or opt.label.upper().replace(" ", "_"),
+            metavar=placeholder or opt.metavar,
             help_text=help_text,
             default=value,
             extra_kwargs=kwargs,
         )
-        return self._input_map.register(
-            input_control.create_marimo_element(
-                self._get_value(input_control, value),
-                **self._control_kwargs(opt, input_control, help_text, on_change),
-            ),
-            input_control,
-        )
+        return self._register_control(opt, input_control, help_text, on_change)
 
     def text_area(
         self,
@@ -366,18 +348,12 @@ class Group:
         opt = self._make_opt(label=label, option=option)
         input_control = _options.TextAreaControl(
             option=opt.option,
-            metavar=placeholder or opt.label.upper().replace(" ", "_"),
+            metavar=placeholder or opt.metavar,
             help_text=help_text,
             default=value,
             extra_kwargs=kwargs,
         )
-        return self._input_map.register(
-            input_control.create_marimo_element(
-                self._get_value(input_control, value),
-                **self._control_kwargs(opt, input_control, help_text, on_change),
-            ),
-            input_control,
-        )
+        return self._register_control(opt, input_control, help_text, on_change)
 
     def file_browser(
         self,
@@ -423,13 +399,7 @@ class Group:
                 help_text=help_text,
                 extra_kwargs=kwargs,
             )
-        return self._input_map.register(
-            input_control.create_marimo_element(
-                self._get_value(input_control, default),
-                **self._control_kwargs(opt, input_control, help_text, on_change),
-            ),
-            input_control,
-        )
+        return self._register_control(opt, input_control, help_text, on_change)
 
     def number(
         self,
@@ -448,15 +418,10 @@ class Group:
         """Create a number input UI element that maps to a CLI option."""
 
         kwargs = {"step": step, "debounce": debounce, **kwargs}
-        opt, input_control, value = self._numeric_input_control(
+        opt, input_control = self._numeric_input_control(
             start, stop, value, option, help_text, label, "number", kwargs
         )
-        return self._input_map.register(
-            input_control.create_marimo_element(
-                value, **self._control_kwargs(opt, input_control, help_text, on_change)
-            ),
-            input_control,
-        )
+        return self._register_control(opt, input_control, help_text, on_change)
 
     def slider(
         self,
@@ -475,15 +440,10 @@ class Group:
         """Create a slider UI element that maps to a CLI option."""
 
         kwargs = {"step": step, "debounce": debounce, **kwargs}
-        opt, input_control, value = self._numeric_input_control(
+        opt, input_control = self._numeric_input_control(
             start, stop, value, option, help_text, label, "slider", kwargs
         )
-        return self._input_map.register(
-            input_control.create_marimo_element(
-                value, **self._control_kwargs(opt, input_control, help_text, on_change)
-            ),
-            input_control,
-        )
+        return self._register_control(opt, input_control, help_text, on_change)
 
     def range_slider(
         self,
@@ -513,7 +473,7 @@ class Group:
         opt = self._make_opt(label=label, option=option)
         input_control = _options.RangeControl.from_slider(
             option=opt.option,
-            metavar=opt.label.upper().replace(" ", "_"),
+            metavar=opt.metavar,
             help_text=help_text,
             start=start,
             stop=stop,
@@ -522,13 +482,7 @@ class Group:
             step=step,
             extra_kwargs=kwargs,
         )
-        return self._input_map.register(
-            input_control.create_marimo_element(
-                self._get_value(input_control, input_control.default),
-                **self._control_kwargs(opt, input_control, help_text, on_change),
-            ),
-            input_control,
-        )
+        return self._register_control(opt, input_control, help_text, on_change)
 
     def custom(
         self,
@@ -582,13 +536,13 @@ class Group:
         label: str | None,
         widget: typing.Literal["number", "slider"] = "number",
         extra_kwargs: dict[str, typing.Any] | None = None,
-    ) -> tuple[_naming.OptionLabel, _options.NumberControl, float | None]:
+    ) -> tuple[_naming.OptionLabel, _options.NumberControl]:
         if value is None:
             value = start
         opt = self._make_opt(label=label, option=option)
         input_control = _options.NumberControl(
             option=opt.option,
-            metavar=opt.label.upper().replace(" ", "_"),
+            metavar=opt.metavar,
             help_text=help_text,
             default=value,
             start=start,
@@ -596,7 +550,7 @@ class Group:
             widget=widget,
             extra_kwargs=extra_kwargs or {},
         )
-        return opt, input_control, self._get_value(input_control, value)
+        return opt, input_control
 
     def dropdown(
         self,
@@ -618,8 +572,12 @@ class Group:
 
         assert len(options) > 0, "Dropdown options cannot be empty"
         opt = self._make_opt(label=label, option=option)
-        dropdown_opts = _option_values(options)
-        value = _option_key(dropdown_opts, value) if value is not None else None
+        dropdown_opts = _choice_options.option_values(options)
+        value = (
+            _choice_options.option_key(dropdown_opts, value)
+            if value is not None
+            else None
+        )
         if value is None and not allow_select_none:
             value, *_ = [*dropdown_opts]
         input_control = _options.DropdownControl(
@@ -634,13 +592,7 @@ class Group:
                 **kwargs,
             },
         )
-        return self._input_map.register(
-            input_control.create_marimo_element(
-                self._get_value(input_control, value),
-                **self._control_kwargs(opt, input_control, help_text, on_change),
-            ),
-            input_control,
-        )
+        return self._register_control(opt, input_control, help_text, on_change)
 
     def multiselect(
         self,
@@ -657,23 +609,17 @@ class Group:
         if value is None:
             value = []
         opt = self._make_opt(label=label, option=option)
-        select_opts = _option_values(options)
-        default = [_option_value(select_opts, item) for item in value]
+        select_opts = _choice_options.option_values(options)
+        default = [_choice_options.option_value(select_opts, item) for item in value]
         input_control = _options.MultiSelectControl(
             option=opt.option,
-            metavar=opt.label.upper().replace(" ", "_"),
+            metavar=opt.metavar,
             help_text=help_text,
             default=default,
             select_opts=select_opts,
             extra_kwargs=kwargs,
         )
-        return self._input_map.register(
-            input_control.create_marimo_element(
-                self._get_value(input_control, default),
-                **self._control_kwargs(opt, input_control, help_text, on_change),
-            ),
-            input_control,
-        )
+        return self._register_control(opt, input_control, help_text, on_change)
 
     def controls_from(
         self,
@@ -689,27 +635,9 @@ class Group:
         The controls themselves are created in a subgroup, so their CLI options
         are prefixed in the parent notebook.
         """
-        child = self.subgroup(prefix)
-        excluded = set(exclude)
-        controls: dict[str, typing.Any] = {
-            name: (
-                child.controls_from(ctrl_or_sub, prefix=name)
-                if isinstance(ctrl_or_sub, interface.Interface)
-                else _control_factory.create_control(child, iface, ctrl_or_sub)
-            )
-            for name, ctrl_or_sub in iface.iter_controls()
-            if name not in excluded
-        }
-        result = mo.ui.dictionary(controls)
-        # mo.ui.dictionary clones its elements, so result.elements[key] is a
-        # different object than controls[key]. Rebind nested dictionary clones
-        # to interfaces that track their own live cloned elements.
-        for key, original in controls.items():
-            _reattach_interface_to_clone(original, result.elements[key])
-        # Use the live clones (result.elements) rather than the originals so
-        # that cur_values() reads up-to-date widget values.
-        result._moops_interface = child.interface(*result.elements.values())  # type: ignore[attr-defined]
-        return result
+        return _control_mirroring.controls_from(
+            self, iface, prefix=prefix, exclude=exclude
+        )
 
     def _make_value_resolver(self) -> _value_resolution.ValueResolver:
         return _value_resolution.ValueResolver(
@@ -721,49 +649,24 @@ class Group:
             default_preset_state=self._preset_state.default,
         )
 
-    def _control_kwargs(
+    def _register_control(
         self,
         opt: _naming.OptionLabel,
         input_control: _options.InputControl,
         help_text: str,
         on_change: typing.Callable[[typing.Any], None] | None,
-    ) -> dict[str, typing.Any]:
-        return {
-            "label": opt.label_with_tooltip(help_text),
-            "disabled": self._is_overridden(opt.option) or self._disabled,
-            "on_change": self._query_on_change(input_control, on_change),
-        }
-
-    def _get_value(
-        self,
-        control: _options.InputControl,
-        default: typing.Any,
     ) -> typing.Any:
-        return self._value_resolver.get_value(control, default)
-
-    def _is_overridden(self, option: str) -> bool:
-        return self._value_resolver.is_overridden(option)
-
-    def _query_on_change(
-        self,
-        control: _options.InputControl,
-        on_change: typing.Callable[[typing.Any], None] | None,
-    ) -> typing.Callable[[typing.Any], None] | None:
-        return self._value_resolver.query_on_change(control, on_change)
-
-    def _create_from_input_control(
-        self,
-        input_control: _options.InputControl,
-        display_option: str,
-    ) -> typing.Any:
-        """Create a marimo element from an existing InputControl."""
-        opt = self._make_opt(label=None, option=display_option)
-        cloned = dataclasses.replace(input_control, option=opt.option)
-        value = self._get_value(cloned, getattr(cloned, "default", None))
-        ctrl_kwargs = self._control_kwargs(opt, cloned, cloned.help_text, None)
         return self._input_map.register(
-            cloned.create_marimo_element(value, **ctrl_kwargs),
-            cloned,
+            input_control.create_marimo_element(
+                self._value_resolver.get_value(input_control, input_control.default),
+                label=opt.label_with_tooltip(help_text),
+                disabled=self._value_resolver.is_overridden(opt.option)
+                or self._disabled,
+                on_change=self._value_resolver.query_on_change(
+                    input_control, on_change
+                ),
+            ),
+            input_control,
         )
 
     def _make_opt(
@@ -776,43 +679,3 @@ class Group:
                 option=f"{self.option}-{opt.option.lstrip('-')}",
             )
         return opt
-
-
-def _option_values(
-    options: typing.Sequence[typing.Any] | dict[str, typing.Any],
-) -> dict[str, typing.Any]:
-    if isinstance(options, dict):
-        return dict(options)
-    return {str(opt): opt for opt in options}
-
-
-def _reattach_interface_to_clone(original: typing.Any, clone: typing.Any) -> None:
-    moops_iface = getattr(original, "_moops_interface", None)
-    if not isinstance(moops_iface, interface.Interface):
-        return
-    original_elements = getattr(original, "elements", None)
-    clone_elements = getattr(clone, "elements", None)
-    if isinstance(original_elements, dict) and isinstance(clone_elements, dict):
-        typed_original_elements = typing.cast(dict[str, typing.Any], original_elements)
-        typed_clone_elements = typing.cast(dict[str, typing.Any], clone_elements)
-        for key, original_child in typed_original_elements.items():
-            if key in typed_clone_elements:
-                _reattach_interface_to_clone(original_child, typed_clone_elements[key])
-        controls = tuple(typed_clone_elements.values())
-    else:
-        controls = moops_iface.controls
-    moops_iface.controls = controls
-    clone._moops_interface = moops_iface
-
-
-def _option_key(options: dict[str, typing.Any], value: typing.Any) -> str:
-    if isinstance(value, str) and value in options:
-        return value
-    return next(
-        (key for key, option_value in options.items() if value == option_value),
-        str(value),
-    )
-
-
-def _option_value(options: dict[str, typing.Any], value: typing.Any) -> typing.Any:
-    return options[value] if isinstance(value, str) and value in options else value

{moops-0.7.0 → moops-0.7.2}/src/moops/interface.py

@@ -13,6 +13,47 @@ from . import _input_map, _options, _parse, _query_params
 from .presets import Presets
 
 
+def _wrap_usage(prefix: str, parts: list[str], width: int = 88) -> str:
+    indent = " " * len(prefix)
+    lines: list[str] = []
+    current = prefix
+    first_on_line = True
+    for part in parts:
+        attempt = current + part if first_on_line else current + " " + part
+        if first_on_line or len(attempt) <= width:
+            current = attempt
+            first_on_line = False
+        else:
+            lines.append(current)
+            current = indent + part
+    lines.append(current)
+    return "\n".join(lines)
+
+
+def _wrap_help_line(line: str, width: int = 88) -> list[str]:
+    if len(line) <= width:
+        return [line]
+    sep = ": "
+    sep_idx = line.find(sep)
+    if sep_idx == -1:
+        return [line]
+    header = line[: sep_idx + 1]  # e.g. "  --option METAVAR:"
+    indent = "      "
+    result = [header]
+    current = indent
+    first_on_line = True
+    for word in line[sep_idx + len(sep) :].split():
+        attempt = current + word if first_on_line else current + " " + word
+        if first_on_line or len(attempt) <= width:
+            current = attempt
+            first_on_line = False
+        else:
+            result.append(current)
+            current = indent + word
+    result.append(current)
+    return result
+
+
 @dataclasses.dataclass
 class Interface:
     """Controls registered by a subgroup's interface, for passing to the parent."""
@@ -56,7 +97,7 @@ class Interface:
 
     def has_prefixed_options(self, state: _parse.ParseState) -> bool:
         """True if state has CLI options starting with this interface's prefix."""
-        prefix = self.option_prefix + "-" if self.option_prefix else "--"
+        prefix = f"{self.option_prefix}-" if self.option_prefix else "--"
         return any(
             k
             for k in state.args.options
@@ -95,33 +136,38 @@ class Interface:
         usage_parts = list(self._format_usage_parts(_usage_placeholders(self)))
         usage_parts.extend(("[--interactive]", "[-h/--help]"))
         name = self.command.rsplit("/", 1)[-1]
-        segments = [f"Usage: {name} {' '.join(usage_parts)}"]
+        prefix = f"Usage: {name} "
+        segments = [_wrap_usage(prefix, usage_parts)]
         help_lines = list(self._format_help_lines())
         if help_lines:
             segments.append("\n".join(help_lines))
         return "\n\n".join(segments)
 
     def _format_help_lines(self) -> typing.Iterator[str]:
+        prev_was_group_with_content = False
         for ctrl in self.controls:
             if (sub_iface := _attached_interface(ctrl)) is not None:
                 lines = list(sub_iface._format_help_lines())
                 if lines and sub_iface.help_heading:
                     yield ""
-                    yield sub_iface.help_heading + ":"
+                    yield f"{sub_iface.help_heading}:"
                 yield from lines
+                prev_was_group_with_content = bool(lines)
             else:
                 input_control = self.input_map.get(ctrl)
                 if input_control is not None and not self._is_overridden(input_control):
-                    yield from input_control.format_help_lines()
+                    if prev_was_group_with_content:
+                        yield ""
+                    for help_line in input_control.format_help_lines():
+                        yield from _wrap_help_line(help_line)
+                prev_was_group_with_content = False
 
     def _format_usage_parts(
         self, placeholders_by_option: dict[str, str]
     ) -> typing.Iterator[str]:
         for ctrl in self.controls:
-            if (sub_iface := _attached_interface(ctrl)) is not None:
-                if not sub_iface.usage_placeholder:
-                    yield from sub_iface._format_usage_parts(placeholders_by_option)
-            else:
+            sub_iface = _attached_interface(ctrl)
+            if sub_iface is None:
                 input_control = self.input_map.get(ctrl)
                 if input_control is not None and not self._is_overridden(input_control):
                     yield from input_control.format_usage_parts()
@@ -129,14 +175,16 @@ class Interface:
                         if placeholder := placeholders_by_option.pop(option, None):
                             yield placeholder
 
+            elif not sub_iface.usage_placeholder:
+                yield from sub_iface._format_usage_parts(placeholders_by_option)
+
     @property
     def default(self) -> dict[str, typing.Any]:
-        result: dict[str, typing.Any] = {}
-        for name, ctrl_or_sub in self.iter_controls():
-            if isinstance(ctrl_or_sub, Interface):
-                result[name] = ctrl_or_sub.default
-            elif hasattr(ctrl_or_sub, "default"):
-                result[name] = ctrl_or_sub.default  # type: ignore
+        result: dict[str, typing.Any] = {
+            name: ctrl_or_sub.default  # type: ignore
+            for name, ctrl_or_sub in self.iter_controls()
+            if isinstance(ctrl_or_sub, Interface) or hasattr(ctrl_or_sub, "default")
+        }
         return result
 
     def strategy(self) -> st.SearchStrategy[dict[str, typing.Any]]:
@@ -312,9 +360,9 @@ class Interface:
         items: list[typing.Any] = [
             mo.callout(
                 mo.md(
-                    f"This notebook also works as a script:\n```\n{self.help()}\n```\n"
-                    "To run the script with the current values in the notebook use:\n"
-                    f"```\n{current_command}\n```"
+                    "This notebook also works as a script:\n\n"
+                    f"```\n{current_command}\n```\n\n"
+                    f"<details><summary>Usage</summary>\n\n```\n{self.help()}\n```\n</details>\n\n"
                     f"{missing_options_msg}"
                 ),
                 "warn" if missing_options else "info",

moops-0.7.0/src/moops/_control_factory.py

@@ -1,19 +0,0 @@
-import typing
-
-from . import _options, interface
-
-
-def create_control(
-    group: typing.Any,
-    iface: interface.Interface,
-    input_control: _options.InputControl,
-) -> typing.Any:
-    return group._create_from_input_control(
-        input_control, _unprefixed_option(iface, input_control.option)
-    )
-
-
-def _unprefixed_option(iface: interface.Interface, option: str) -> str:
-    if iface.option_prefix and option.startswith(f"{iface.option_prefix}-"):
-        return f"--{option[len(iface.option_prefix) :].lstrip('-')}"
-    return option