syd 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

syd/{notebook_deploy → notebook_deployment}/widgets.py

@@ -14,14 +14,14 @@ from ..parameters import (
     FloatRangeParameter,
     UnboundedIntegerParameter,
     UnboundedFloatParameter,
-    ButtonParameter,
+    ButtonAction,
 )
 
 T = TypeVar("T", bound=Parameter[Any])
 W = TypeVar("W", bound=widgets.Widget)
 
 
-class BaseParameterWidget(Generic[T, W], ABC):
+class BaseWidget(Generic[T, W], ABC):
     """
     Abstract base class for all parameter widgets.
 
@@ -31,15 +31,32 @@ class BaseParameterWidget(Generic[T, W], ABC):
 
     _widget: W
     _callbacks: List[Dict[str, Union[Callable, Union[str, List[str]]]]]
-
-    def __init__(self, parameter: T, continuous_update: bool = False):
-        self._widget = self._create_widget(parameter, continuous_update)
+    _is_action: bool = False
+
+    def __init__(
+        self,
+        parameter: T,
+        continuous: bool = False,
+        width: str = "auto",
+        margin: str = "3px 0px",
+        description_width: str = "initial",
+    ):
+        self._widget = self._create_widget(
+            parameter, continuous, width, margin, description_width
+        )
         self._updating = False  # Flag to prevent circular updates
         # List of callbacks to remember for quick disabling/enabling
         self._callbacks = []
 
     @abstractmethod
-    def _create_widget(self, parameter: T, continuous_update: bool) -> W:
+    def _create_widget(
+        self,
+        parameter: T,
+        continuous: bool,
+        width: str = "auto",
+        margin: str = "3px 0px",
+        description_width: str = "initial",
+    ) -> W:
         """Create and return the appropriate ipywidget."""
         pass
 
@@ -100,42 +117,62 @@ class BaseParameterWidget(Generic[T, W], ABC):
             self._widget.unobserve(**callback)
 
 
-class TextParameterWidget(BaseParameterWidget[TextParameter, widgets.Text]):
+class TextWidget(BaseWidget[TextParameter, widgets.Text]):
     """Widget for text parameters."""
 
     def _create_widget(
-        self, parameter: TextParameter, continuous_update: bool
+        self,
+        parameter: TextParameter,
+        continuous: bool,
+        width: str = "auto",
+        margin: str = "3px 0px",
+        description_width: str = "initial",
     ) -> widgets.Text:
         return widgets.Text(
             value=parameter.value,
             description=parameter.name,
-            continuous_update=continuous_update,
-            layout=widgets.Layout(width="95%"),
+            continuous=continuous,
+            layout=widgets.Layout(width=width, margin=margin),
+            style={"description_width": description_width},
         )
 
 
-class BooleanParameterWidget(BaseParameterWidget[BooleanParameter, widgets.Checkbox]):
+class BooleanWidget(BaseWidget[BooleanParameter, widgets.ToggleButton]):
     """Widget for boolean parameters."""
 
     def _create_widget(
-        self, parameter: BooleanParameter, continuous_update: bool
-    ) -> widgets.Checkbox:
-        return widgets.Checkbox(value=parameter.value, description=parameter.name)
+        self,
+        parameter: BooleanParameter,
+        continuous: bool,
+        width: str = "auto",
+        margin: str = "3px 0px",
+        description_width: str = "initial",
+    ) -> widgets.ToggleButton:
+        return widgets.ToggleButton(
+            value=parameter.value,
+            description=parameter.name,
+            layout=widgets.Layout(width=width, margin=margin),
+            style={"description_width": description_width},
+        )
 
 
-class SelectionParameterWidget(
-    BaseParameterWidget[SelectionParameter, widgets.Dropdown]
-):
+class SelectionWidget(BaseWidget[SelectionParameter, widgets.Dropdown]):
     """Widget for single selection parameters."""
 
     def _create_widget(
-        self, parameter: SelectionParameter, continuous_update: bool
+        self,
+        parameter: SelectionParameter,
+        continuous: bool,
+        width: str = "auto",
+        margin: str = "3px 0px",
+        description_width: str = "initial",
     ) -> widgets.Dropdown:
         return widgets.Dropdown(
             value=parameter.value,
             options=parameter.options,
             description=parameter.name,
-            layout=widgets.Layout(width="95%"),
+            layout=widgets.Layout(width=width, margin=margin),
+            style={"description_width": description_width},
         )
 
     def matches_parameter(self, parameter: SelectionParameter) -> bool:
@@ -153,20 +190,26 @@ class SelectionParameterWidget(
         self._widget.value = new_value
 
 
-class MultipleSelectionParameterWidget(
-    BaseParameterWidget[MultipleSelectionParameter, widgets.SelectMultiple]
+class MultipleSelectionWidget(
+    BaseWidget[MultipleSelectionParameter, widgets.SelectMultiple]
 ):
     """Widget for multiple selection parameters."""
 
     def _create_widget(
-        self, parameter: MultipleSelectionParameter, continuous_update: bool
+        self,
+        parameter: MultipleSelectionParameter,
+        continuous: bool,
+        width: str = "auto",
+        margin: str = "3px 0px",
+        description_width: str = "initial",
     ) -> widgets.SelectMultiple:
         return widgets.SelectMultiple(
             value=parameter.value,
             options=parameter.options,
             description=parameter.name,
             rows=min(len(parameter.options), 4),
-            layout=widgets.Layout(width="95%"),
+            layout=widgets.Layout(width=width, margin=margin),
+            style={"description_width": description_width},
         )
 
     def matches_parameter(self, parameter: MultipleSelectionParameter) -> bool:
@@ -186,20 +229,25 @@ class MultipleSelectionParameterWidget(
         self._widget.value = new_values
 
 
-class IntegerParameterWidget(BaseParameterWidget[IntegerParameter, widgets.IntSlider]):
+class IntegerWidget(BaseWidget[IntegerParameter, widgets.IntSlider]):
     """Widget for integer parameters."""
 
     def _create_widget(
-        self, parameter: IntegerParameter, continuous_update: bool
+        self,
+        parameter: IntegerParameter,
+        continuous: bool,
+        width: str = "auto",
+        margin: str = "3px 0px",
+        description_width: str = "initial",
     ) -> widgets.IntSlider:
         return widgets.IntSlider(
             value=parameter.value,
             min=parameter.min_value,
             max=parameter.max_value,
             description=parameter.name,
-            continuous_update=continuous_update,
-            layout=widgets.Layout(width="95%"),
-            style={"description_width": "initial"},
+            continuous=continuous,
+            layout=widgets.Layout(width=width, margin=margin),
+            style={"description_width": description_width},
         )
 
     def matches_parameter(self, parameter: IntegerParameter) -> bool:
@@ -218,11 +266,16 @@ class IntegerParameterWidget(BaseParameterWidget[IntegerParameter, widgets.IntSl
         self.value = max(parameter.min_value, min(parameter.max_value, current_value))
 
 
-class FloatParameterWidget(BaseParameterWidget[FloatParameter, widgets.FloatSlider]):
+class FloatWidget(BaseWidget[FloatParameter, widgets.FloatSlider]):
     """Widget for float parameters."""
 
     def _create_widget(
-        self, parameter: FloatParameter, continuous_update: bool
+        self,
+        parameter: FloatParameter,
+        continuous: bool,
+        width: str = "auto",
+        margin: str = "3px 0px",
+        description_width: str = "initial",
     ) -> widgets.FloatSlider:
         return widgets.FloatSlider(
             value=parameter.value,
@@ -230,9 +283,9 @@ class FloatParameterWidget(BaseParameterWidget[FloatParameter, widgets.FloatSlid
             max=parameter.max_value,
             step=parameter.step,
             description=parameter.name,
-            continuous_update=continuous_update,
-            layout=widgets.Layout(width="95%"),
-            style={"description_width": "initial"},
+            continuous=continuous,
+            layout=widgets.Layout(width=width, margin=margin),
+            style={"description_width": description_width},
         )
 
     def matches_parameter(self, parameter: FloatParameter) -> bool:
@@ -252,22 +305,25 @@ class FloatParameterWidget(BaseParameterWidget[FloatParameter, widgets.FloatSlid
         self.value = max(parameter.min_value, min(parameter.max_value, current_value))
 
 
-class IntegerRangeParameterWidget(
-    BaseParameterWidget[IntegerRangeParameter, widgets.IntRangeSlider]
-):
+class IntegerRangeWidget(BaseWidget[IntegerRangeParameter, widgets.IntRangeSlider]):
     """Widget for integer range parameters."""
 
     def _create_widget(
-        self, parameter: IntegerRangeParameter, continuous_update: bool
+        self,
+        parameter: IntegerRangeParameter,
+        continuous: bool,
+        width: str = "auto",
+        margin: str = "3px 0px",
+        description_width: str = "initial",
     ) -> widgets.IntRangeSlider:
         return widgets.IntRangeSlider(
             value=parameter.value,
             min=parameter.min_value,
             max=parameter.max_value,
             description=parameter.name,
-            continuous_update=continuous_update,
-            layout=widgets.Layout(width="95%"),
-            style={"description_width": "initial"},
+            continuous=continuous,
+            layout=widgets.Layout(width=width, margin=margin),
+            style={"description_width": description_width},
         )
 
     def matches_parameter(self, parameter: IntegerRangeParameter) -> bool:
@@ -289,13 +345,16 @@ class IntegerRangeParameterWidget(
         self.value = (low, high)
 
 
-class FloatRangeParameterWidget(
-    BaseParameterWidget[FloatRangeParameter, widgets.FloatRangeSlider]
-):
+class FloatRangeWidget(BaseWidget[FloatRangeParameter, widgets.FloatRangeSlider]):
     """Widget for float range parameters."""
 
     def _create_widget(
-        self, parameter: FloatRangeParameter, continuous_update: bool
+        self,
+        parameter: FloatRangeParameter,
+        continuous: bool,
+        width: str = "auto",
+        margin: str = "3px 0px",
+        description_width: str = "initial",
     ) -> widgets.FloatRangeSlider:
         return widgets.FloatRangeSlider(
             value=parameter.value,
@@ -303,9 +362,9 @@ class FloatRangeParameterWidget(
             max=parameter.max_value,
             step=parameter.step,
             description=parameter.name,
-            continuous_update=continuous_update,
-            layout=widgets.Layout(width="95%"),
-            style={"description_width": "initial"},
+            continuous=continuous,
+            layout=widgets.Layout(width=width, margin=margin),
+            style={"description_width": description_width},
         )
 
     def matches_parameter(self, parameter: FloatRangeParameter) -> bool:
@@ -328,21 +387,22 @@ class FloatRangeParameterWidget(
         self.value = (low, high)
 
 
-class UnboundedIntegerParameterWidget(
-    BaseParameterWidget[UnboundedIntegerParameter, widgets.BoundedIntText]
-):
+class UnboundedIntegerWidget(BaseWidget[UnboundedIntegerParameter, widgets.IntText]):
     """Widget for unbounded integer parameters."""
 
     def _create_widget(
-        self, parameter: UnboundedIntegerParameter, continuous_update: bool
-    ) -> widgets.BoundedIntText:
-        return widgets.BoundedIntText(
+        self,
+        parameter: UnboundedIntegerParameter,
+        continuous: bool,
+        width: str = "auto",
+        margin: str = "3px 0px",
+        description_width: str = "initial",
+    ) -> widgets.IntText:
+        return widgets.IntText(
             value=parameter.value,
-            min=parameter.min_value,
-            max=parameter.max_value,
             description=parameter.name,
-            layout=widgets.Layout(width="95%"),
-            style={"description_width": "initial"},
+            layout=widgets.Layout(width=width, margin=margin),
+            style={"description_width": description_width},
         )
 
     def matches_parameter(self, parameter: UnboundedIntegerParameter) -> bool:
@@ -353,28 +413,26 @@ class UnboundedIntegerParameterWidget(
         self, parameter: UnboundedIntegerParameter
     ) -> None:
         """Extra updates from the parameter."""
-        if parameter.min_value is not None:
-            self._widget.min = parameter.min_value
-        if parameter.max_value is not None:
-            self._widget.max = parameter.max_value
+        pass
 
 
-class UnboundedFloatParameterWidget(
-    BaseParameterWidget[UnboundedFloatParameter, widgets.BoundedFloatText]
-):
+class UnboundedFloatWidget(BaseWidget[UnboundedFloatParameter, widgets.FloatText]):
     """Widget for unbounded float parameters."""
 
     def _create_widget(
-        self, parameter: UnboundedFloatParameter, continuous_update: bool
-    ) -> widgets.BoundedFloatText:
-        return widgets.BoundedFloatText(
+        self,
+        parameter: UnboundedFloatParameter,
+        continuous: bool,
+        width: str = "auto",
+        margin: str = "3px 0px",
+        description_width: str = "initial",
+    ) -> widgets.FloatText:
+        return widgets.FloatText(
             value=parameter.value,
-            min=parameter.min_value,
-            max=parameter.max_value,
             step=parameter.step,
             description=parameter.name,
-            layout=widgets.Layout(width="95%"),
-            style={"description_width": "initial"},
+            layout=widgets.Layout(width=width, margin=margin),
+            style={"description_width": description_width},
         )
 
     def matches_parameter(self, parameter: UnboundedFloatParameter) -> bool:
@@ -383,89 +441,111 @@ class UnboundedFloatParameterWidget(
 
     def extra_updates_from_parameter(self, parameter: UnboundedFloatParameter) -> None:
         """Extra updates from the parameter."""
-        if parameter.min_value is not None:
-            self._widget.min = parameter.min_value
-        if parameter.max_value is not None:
-            self._widget.max = parameter.max_value
         self._widget.step = parameter.step
 
 
-class ButtonParameterWidget(BaseParameterWidget[ButtonParameter, widgets.Button]):
+class ButtonWidget(BaseWidget[ButtonAction, widgets.Button]):
     """Widget for button parameters."""
 
-    _is_button: bool = True
+    _is_action: bool = True
 
     def _create_widget(
-        self, parameter: ButtonParameter, continuous_update: bool
+        self,
+        parameter: ButtonAction,
+        continuous: bool,
+        width: str = "auto",
+        margin: str = "3px 0px",
+        description_width: str = "initial",
     ) -> widgets.Button:
         button = widgets.Button(
             description=parameter.label,
-            layout=widgets.Layout(width="auto"),
-            style={"description_width": "initial"},
+            layout=widgets.Layout(width=width, margin=margin),
+            style={"description_width": description_width},
         )
-        button.on_click(parameter.callback)
         return button
 
-    def matches_parameter(self, parameter: ButtonParameter) -> bool:
+    def matches_parameter(self, parameter: ButtonAction) -> bool:
         """Check if the widget matches the parameter."""
         return self._widget.description == parameter.label
 
-    def extra_updates_from_parameter(self, parameter: ButtonParameter) -> None:
+    def extra_updates_from_parameter(self, parameter: ButtonAction) -> None:
         """Extra updates from the parameter."""
+        # Callbacks are handled in the deployer, so the only relevant update is the label
         self._widget.description = parameter.label
-        # Update click handler
-        self._widget.on_click(parameter.callback, remove=True)  # Remove old handler
-        self._widget.on_click(parameter.callback)  # Add new handler
 
     def observe(self, callback: Callable) -> None:
         """Observe the widget and call the callback when the value changes."""
+        if self._callbacks:
+            raise ValueError("ButtonWidget already has a callback!")
         self._widget.on_click(callback)
-        self._callbacks.append(callback)
+        self._callbacks = callback
 
-    def unobserve(self, callback: Callable[[Any], None]) -> None:
+    def unobserve(self, callback: Callable) -> None:
         """Unobserve the widget and stop calling the callback when the value changes."""
-        self._widget.on_click(None)
-        self._callbacks.remove(callback)
+        self._widget.on_click(callback, remove=True)
+        self._callbacks = []
 
     def reenable_callbacks(self) -> None:
         """Reenable all callbacks from the widget."""
-        for callback in self._callbacks:
-            self._widget.on_click(callback)
+        self._widget.on_click(self._callbacks)
 
     def disable_callbacks(self) -> None:
         """Disable all callbacks from the widget."""
-        for callback in self._callbacks:
-            self._widget.on_click(None)
+        self._widget.on_click(self._callbacks, remove=True)
 
 
-def create_parameter_widget(
-    parameter: Parameter[Any],
-    continuous_update: bool = False,
-) -> BaseParameterWidget[Parameter[Any], widgets.Widget]:
+def create_widget(
+    parameter: Union[Parameter[Any], ButtonAction],
+    continuous: bool = False,
+    width: str = "auto",
+    margin: str = "3px 0px",
+    description_width: str = "initial",
+) -> BaseWidget[Union[Parameter[Any], ButtonAction], widgets.Widget]:
     """Create and return the appropriate widget for the given parameter.
 
     Args:
         parameter: The parameter to create a widget for
-        continuous_update: Whether to update the widget value continuously during user interaction
+        continuous: Whether to update the widget value continuously during user interaction
+        width: Width of the widget
+        margin: Margin of the widget
+        description_width: Width of the description label
     """
     widget_map = {
-        TextParameter: TextParameterWidget,
-        SelectionParameter: SelectionParameterWidget,
-        MultipleSelectionParameter: MultipleSelectionParameterWidget,
-        BooleanParameter: BooleanParameterWidget,
-        IntegerParameter: IntegerParameterWidget,
-        FloatParameter: FloatParameterWidget,
-        IntegerRangeParameter: IntegerRangeParameterWidget,
-        FloatRangeParameter: FloatRangeParameterWidget,
-        UnboundedIntegerParameter: UnboundedIntegerParameterWidget,
-        UnboundedFloatParameter: UnboundedFloatParameterWidget,
-        ButtonParameter: ButtonParameterWidget,
+        TextParameter: TextWidget,
+        SelectionParameter: SelectionWidget,
+        MultipleSelectionParameter: MultipleSelectionWidget,
+        BooleanParameter: BooleanWidget,
+        IntegerParameter: IntegerWidget,
+        FloatParameter: FloatWidget,
+        IntegerRangeParameter: IntegerRangeWidget,
+        FloatRangeParameter: FloatRangeWidget,
+        UnboundedIntegerParameter: UnboundedIntegerWidget,
+        UnboundedFloatParameter: UnboundedFloatWidget,
+        ButtonAction: ButtonWidget,
     }
 
+    # Try direct type lookup first
     widget_class = widget_map.get(type(parameter))
+
+    # If that fails, try matching by class name
+    if widget_class is None:
+        param_type_name = type(parameter).__name__
+        for key_class, value_class in widget_map.items():
+            if key_class.__name__ == param_type_name:
+                widget_class = value_class
+                break
+
     if widget_class is None:
         raise ValueError(
-            f"No widget implementation for parameter type: {type(parameter)}"
+            f"No widget implementation for parameter type: {type(parameter)}\n"
+            f"Parameter type name: {type(parameter).__name__}\n"
+            f"Available types: {[k.__name__ for k in widget_map.keys()]}"
         )
 
-    return widget_class(parameter, continuous_update)
+    return widget_class(
+        parameter,
+        continuous,
+        width=width,
+        margin=margin,
+        description_width=description_width,
+    )