syd 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl

syd/notebook_deployment/widgets.py

@@ -33,14 +33,30 @@ class BaseWidget(Generic[T, W], ABC):
     _callbacks: List[Dict[str, Union[Callable, Union[str, List[str]]]]]
     _is_action: bool = False
 
-    def __init__(self, parameter: T, continuous: bool = False):
-        self._widget = self._create_widget(parameter, continuous)
+    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: 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
 
@@ -105,36 +121,58 @@ class TextWidget(BaseWidget[TextParameter, widgets.Text]):
     """Widget for text parameters."""
 
     def _create_widget(
-        self, parameter: TextParameter, continuous: 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=continuous,
-            layout=widgets.Layout(width="95%"),
+            layout=widgets.Layout(width=width, margin=margin),
+            style={"description_width": description_width},
         )
 
 
-class BooleanWidget(BaseWidget[BooleanParameter, widgets.Checkbox]):
+class BooleanWidget(BaseWidget[BooleanParameter, widgets.ToggleButton]):
     """Widget for boolean parameters."""
 
     def _create_widget(
-        self, parameter: BooleanParameter, continuous: 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 SelectionWidget(BaseWidget[SelectionParameter, widgets.Dropdown]):
     """Widget for single selection parameters."""
 
     def _create_widget(
-        self, parameter: SelectionParameter, continuous: 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:
@@ -158,14 +196,20 @@ class MultipleSelectionWidget(
     """Widget for multiple selection parameters."""
 
     def _create_widget(
-        self, parameter: MultipleSelectionParameter, continuous: 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:
@@ -189,155 +233,194 @@ class IntegerWidget(BaseWidget[IntegerParameter, widgets.IntSlider]):
     """Widget for integer parameters."""
 
     def _create_widget(
-        self, parameter: IntegerParameter, continuous: bool
+        self,
+        parameter: IntegerParameter,
+        continuous: bool,
+        width: str = "auto",
+        margin: str = "3px 0px",
+        description_width: str = "initial",
     ) -> widgets.IntSlider:
+        """Create the integer slider widget."""
         return widgets.IntSlider(
             value=parameter.value,
-            min=parameter.min_value,
-            max=parameter.max_value,
+            min=parameter.min,
+            max=parameter.max,
+            step=1,
             description=parameter.name,
-            continuous=continuous,
-            layout=widgets.Layout(width="95%"),
-            style={"description_width": "initial"},
+            continuous_update=continuous,
+            style={"description_width": description_width},
+            layout=widgets.Layout(width=width, margin=margin),
         )
 
     def matches_parameter(self, parameter: IntegerParameter) -> bool:
-        """Check if the widget matches the parameter."""
+        """Check if the widget values match the parameter."""
         return (
-            self.value == parameter.value
-            and self._widget.min == parameter.min_value
-            and self._widget.max == parameter.max_value
+            self._widget.description == parameter.name
+            and self._widget.value == parameter.value
+            and self._widget.min == parameter.min
+            and self._widget.max == parameter.max
         )
 
     def extra_updates_from_parameter(self, parameter: IntegerParameter) -> None:
-        """Extra updates from the parameter."""
+        """Update the widget attributes from the parameter."""
         current_value = self._widget.value
-        self._widget.min = parameter.min_value
-        self._widget.max = parameter.max_value
-        self.value = max(parameter.min_value, min(parameter.max_value, current_value))
+        self._widget.min = parameter.min
+        self._widget.max = parameter.max
+        self.value = max(parameter.min, min(parameter.max, current_value))
 
 
 class FloatWidget(BaseWidget[FloatParameter, widgets.FloatSlider]):
     """Widget for float parameters."""
 
     def _create_widget(
-        self, parameter: FloatParameter, continuous: bool
+        self,
+        parameter: FloatParameter,
+        continuous: bool,
+        width: str = "auto",
+        margin: str = "3px 0px",
+        description_width: str = "initial",
     ) -> widgets.FloatSlider:
+        """Create the float slider widget."""
         return widgets.FloatSlider(
             value=parameter.value,
-            min=parameter.min_value,
-            max=parameter.max_value,
+            min=parameter.min,
+            max=parameter.max,
             step=parameter.step,
             description=parameter.name,
-            continuous=continuous,
-            layout=widgets.Layout(width="95%"),
-            style={"description_width": "initial"},
+            continuous_update=continuous,
+            style={"description_width": description_width},
+            layout=widgets.Layout(width=width, margin=margin),
         )
 
     def matches_parameter(self, parameter: FloatParameter) -> bool:
-        """Check if the widget matches the parameter."""
+        """Check if the widget values match the parameter."""
         return (
-            self.value == parameter.value
-            and self._widget.min == parameter.min_value
-            and self._widget.max == parameter.max_value
+            self._widget.description == parameter.name
+            and self._widget.value == parameter.value
+            and self._widget.min == parameter.min
+            and self._widget.max == parameter.max
+            and self._widget.step == parameter.step
         )
 
     def extra_updates_from_parameter(self, parameter: FloatParameter) -> None:
-        """Extra updates from the parameter."""
+        """Update the widget attributes from the parameter."""
         current_value = self._widget.value
-        self._widget.min = parameter.min_value
-        self._widget.max = parameter.max_value
+        self._widget.min = parameter.min
+        self._widget.max = parameter.max
         self._widget.step = parameter.step
-        self.value = max(parameter.min_value, min(parameter.max_value, current_value))
+        self.value = max(parameter.min, min(parameter.max, current_value))
 
 
 class IntegerRangeWidget(BaseWidget[IntegerRangeParameter, widgets.IntRangeSlider]):
     """Widget for integer range parameters."""
 
     def _create_widget(
-        self, parameter: IntegerRangeParameter, continuous: bool
+        self,
+        parameter: IntegerRangeParameter,
+        continuous: bool,
+        width: str = "auto",
+        margin: str = "3px 0px",
+        description_width: str = "initial",
     ) -> widgets.IntRangeSlider:
+        """Create the integer range slider widget."""
+        low, high = parameter.value
         return widgets.IntRangeSlider(
-            value=parameter.value,
-            min=parameter.min_value,
-            max=parameter.max_value,
+            value=[low, high],
+            min=parameter.min,
+            max=parameter.max,
+            step=1,
             description=parameter.name,
-            continuous=continuous,
-            layout=widgets.Layout(width="95%"),
-            style={"description_width": "initial"},
+            continuous_update=continuous,
+            style={"description_width": description_width},
+            layout=widgets.Layout(width=width, margin=margin),
         )
 
     def matches_parameter(self, parameter: IntegerRangeParameter) -> bool:
-        """Check if the widget matches the parameter."""
+        """Check if the widget values match the parameter."""
+        low, high = parameter.value
         return (
-            self.value == parameter.value
-            and self._widget.min == parameter.min_value
-            and self._widget.max == parameter.max_value
+            self._widget.description == parameter.name
+            and self._widget.value[0] == low
+            and self._widget.value[1] == high
+            and self._widget.min == parameter.min
+            and self._widget.max == parameter.max
         )
 
     def extra_updates_from_parameter(self, parameter: IntegerRangeParameter) -> None:
-        """Extra updates from the parameter."""
-        current_value = self._widget.value
-        self._widget.min = parameter.min_value
-        self._widget.max = parameter.max_value
-        low, high = current_value
-        low = max(parameter.min_value, min(parameter.max_value, low))
-        high = max(parameter.min_value, min(parameter.max_value, high))
-        self.value = (low, high)
+        """Update the widget attributes from the parameter."""
+        low, high = self._widget.value
+        self._widget.min = parameter.min
+        self._widget.max = parameter.max
+        # Ensure values stay within bounds
+        low = max(parameter.min, min(parameter.max, low))
+        high = max(parameter.min, min(parameter.max, high))
+        self.value = [low, high]
 
 
 class FloatRangeWidget(BaseWidget[FloatRangeParameter, widgets.FloatRangeSlider]):
     """Widget for float range parameters."""
 
     def _create_widget(
-        self, parameter: FloatRangeParameter, continuous: bool
+        self,
+        parameter: FloatRangeParameter,
+        continuous: bool,
+        width: str = "auto",
+        margin: str = "3px 0px",
+        description_width: str = "initial",
     ) -> widgets.FloatRangeSlider:
+        """Create the float range slider widget."""
+        low, high = parameter.value
         return widgets.FloatRangeSlider(
-            value=parameter.value,
-            min=parameter.min_value,
-            max=parameter.max_value,
+            value=[low, high],
+            min=parameter.min,
+            max=parameter.max,
             step=parameter.step,
             description=parameter.name,
-            continuous=continuous,
-            layout=widgets.Layout(width="95%"),
-            style={"description_width": "initial"},
+            continuous_update=continuous,
+            style={"description_width": description_width},
+            layout=widgets.Layout(width=width, margin=margin),
         )
 
     def matches_parameter(self, parameter: FloatRangeParameter) -> bool:
-        """Check if the widget matches the parameter."""
+        """Check if the widget values match the parameter."""
+        low, high = parameter.value
         return (
-            self.value == parameter.value
-            and self._widget.min == parameter.min_value
-            and self._widget.max == parameter.max_value
+            self._widget.description == parameter.name
+            and self._widget.value[0] == low
+            and self._widget.value[1] == high
+            and self._widget.min == parameter.min
+            and self._widget.max == parameter.max
+            and self._widget.step == parameter.step
         )
 
     def extra_updates_from_parameter(self, parameter: FloatRangeParameter) -> None:
-        """Extra updates from the parameter."""
-        current_value = self._widget.value
-        self._widget.min = parameter.min_value
-        self._widget.max = parameter.max_value
+        """Update the widget attributes from the parameter."""
+        low, high = self._widget.value
+        self._widget.min = parameter.min
+        self._widget.max = parameter.max
         self._widget.step = parameter.step
-        low, high = current_value
-        low = max(parameter.min_value, min(parameter.max_value, low))
-        high = max(parameter.min_value, min(parameter.max_value, high))
-        self.value = (low, high)
+        # Ensure values stay within bounds
+        low = max(parameter.min, min(parameter.max, low))
+        high = max(parameter.min, min(parameter.max, high))
+        self.value = [low, high]
 
 
-class UnboundedIntegerWidget(
-    BaseWidget[UnboundedIntegerParameter, widgets.BoundedIntText]
-):
+class UnboundedIntegerWidget(BaseWidget[UnboundedIntegerParameter, widgets.IntText]):
     """Widget for unbounded integer parameters."""
 
     def _create_widget(
-        self, parameter: UnboundedIntegerParameter, continuous: 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:
@@ -348,28 +431,26 @@ class UnboundedIntegerWidget(
         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 UnboundedFloatWidget(
-    BaseWidget[UnboundedFloatParameter, widgets.BoundedFloatText]
-):
+class UnboundedFloatWidget(BaseWidget[UnboundedFloatParameter, widgets.FloatText]):
     """Widget for unbounded float parameters."""
 
     def _create_widget(
-        self, parameter: UnboundedFloatParameter, continuous: 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:
@@ -378,10 +459,6 @@ class UnboundedFloatWidget(
 
     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
 
 
@@ -391,14 +468,18 @@ class ButtonWidget(BaseWidget[ButtonAction, widgets.Button]):
     _is_action: bool = True
 
     def _create_widget(
-        self, parameter: ButtonAction, continuous: 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: ButtonAction) -> bool:
@@ -407,41 +488,45 @@ class ButtonWidget(BaseWidget[ButtonAction, widgets.Button]):
 
     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_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: 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: TextWidget,
@@ -475,4 +560,10 @@ def create_widget(
             f"Available types: {[k.__name__ for k in widget_map.keys()]}"
         )
 
-    return widget_class(parameter, continuous)
+    return widget_class(
+        parameter,
+        continuous,
+        width=width,
+        margin=margin,
+        description_width=description_width,
+    )