syd 0.1.5__py3-none-any.whl → 0.1.6__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,16 @@ class BaseParameterWidget(Generic[T, W], ABC):
 
     _widget: W
     _callbacks: List[Dict[str, Union[Callable, Union[str, List[str]]]]]
+    _is_action: bool = False
 
-    def __init__(self, parameter: T, continuous_update: bool = False):
-        self._widget = self._create_widget(parameter, continuous_update)
+    def __init__(self, parameter: T, continuous: bool = False):
+        self._widget = self._create_widget(parameter, continuous)
         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) -> W:
         """Create and return the appropriate ipywidget."""
         pass
 
@@ -100,36 +101,34 @@ 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
     ) -> widgets.Text:
         return widgets.Text(
             value=parameter.value,
             description=parameter.name,
-            continuous_update=continuous_update,
+            continuous=continuous,
             layout=widgets.Layout(width="95%"),
         )
 
 
-class BooleanParameterWidget(BaseParameterWidget[BooleanParameter, widgets.Checkbox]):
+class BooleanWidget(BaseWidget[BooleanParameter, widgets.Checkbox]):
     """Widget for boolean parameters."""
 
     def _create_widget(
-        self, parameter: BooleanParameter, continuous_update: bool
+        self, parameter: BooleanParameter, continuous: bool
     ) -> widgets.Checkbox:
         return widgets.Checkbox(value=parameter.value, description=parameter.name)
 
 
-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
     ) -> widgets.Dropdown:
         return widgets.Dropdown(
             value=parameter.value,
@@ -153,13 +152,13 @@ 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
     ) -> widgets.SelectMultiple:
         return widgets.SelectMultiple(
             value=parameter.value,
@@ -186,18 +185,18 @@ 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
     ) -> widgets.IntSlider:
         return widgets.IntSlider(
             value=parameter.value,
             min=parameter.min_value,
             max=parameter.max_value,
             description=parameter.name,
-            continuous_update=continuous_update,
+            continuous=continuous,
             layout=widgets.Layout(width="95%"),
             style={"description_width": "initial"},
         )
@@ -218,11 +217,11 @@ 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
     ) -> widgets.FloatSlider:
         return widgets.FloatSlider(
             value=parameter.value,
@@ -230,7 +229,7 @@ class FloatParameterWidget(BaseParameterWidget[FloatParameter, widgets.FloatSlid
             max=parameter.max_value,
             step=parameter.step,
             description=parameter.name,
-            continuous_update=continuous_update,
+            continuous=continuous,
             layout=widgets.Layout(width="95%"),
             style={"description_width": "initial"},
         )
@@ -252,20 +251,18 @@ 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
     ) -> widgets.IntRangeSlider:
         return widgets.IntRangeSlider(
             value=parameter.value,
             min=parameter.min_value,
             max=parameter.max_value,
             description=parameter.name,
-            continuous_update=continuous_update,
+            continuous=continuous,
             layout=widgets.Layout(width="95%"),
             style={"description_width": "initial"},
         )
@@ -289,13 +286,11 @@ 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
     ) -> widgets.FloatRangeSlider:
         return widgets.FloatRangeSlider(
             value=parameter.value,
@@ -303,7 +298,7 @@ class FloatRangeParameterWidget(
             max=parameter.max_value,
             step=parameter.step,
             description=parameter.name,
-            continuous_update=continuous_update,
+            continuous=continuous,
             layout=widgets.Layout(width="95%"),
             style={"description_width": "initial"},
         )
@@ -328,13 +323,13 @@ class FloatRangeParameterWidget(
         self.value = (low, high)
 
 
-class UnboundedIntegerParameterWidget(
-    BaseParameterWidget[UnboundedIntegerParameter, widgets.BoundedIntText]
+class UnboundedIntegerWidget(
+    BaseWidget[UnboundedIntegerParameter, widgets.BoundedIntText]
 ):
     """Widget for unbounded integer parameters."""
 
     def _create_widget(
-        self, parameter: UnboundedIntegerParameter, continuous_update: bool
+        self, parameter: UnboundedIntegerParameter, continuous: bool
     ) -> widgets.BoundedIntText:
         return widgets.BoundedIntText(
             value=parameter.value,
@@ -359,13 +354,13 @@ class UnboundedIntegerParameterWidget(
             self._widget.max = parameter.max_value
 
 
-class UnboundedFloatParameterWidget(
-    BaseParameterWidget[UnboundedFloatParameter, widgets.BoundedFloatText]
+class UnboundedFloatWidget(
+    BaseWidget[UnboundedFloatParameter, widgets.BoundedFloatText]
 ):
     """Widget for unbounded float parameters."""
 
     def _create_widget(
-        self, parameter: UnboundedFloatParameter, continuous_update: bool
+        self, parameter: UnboundedFloatParameter, continuous: bool
     ) -> widgets.BoundedFloatText:
         return widgets.BoundedFloatText(
             value=parameter.value,
@@ -390,13 +385,13 @@ class UnboundedFloatParameterWidget(
         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
     ) -> widgets.Button:
         button = widgets.Button(
             description=parameter.label,
@@ -406,11 +401,11 @@ class ButtonParameterWidget(BaseParameterWidget[ButtonParameter, widgets.Button]
         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."""
         self._widget.description = parameter.label
         # Update click handler
@@ -438,34 +433,46 @@ class ButtonParameterWidget(BaseParameterWidget[ButtonParameter, widgets.Button]
             self._widget.on_click(None)
 
 
-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,
+) -> 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
     """
     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)