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

syd/{interactive_viewer.py → viewer.py}

@@ -1,11 +1,12 @@
 from typing import List, Any, Callable, Dict, Tuple, Union, Optional
-from functools import wraps
+from functools import wraps, partial
+import inspect
 from contextlib import contextmanager
-from abc import ABC, abstractmethod
 from matplotlib.figure import Figure
 
 from .parameters import (
     ParameterType,
+    ActionType,
     Parameter,
     ParameterAddError,
     ParameterUpdateError,
@@ -22,16 +23,20 @@ class _NoUpdate:
             cls._instance = super().__new__(cls)
         return cls._instance
 
+    def __eq__(self, other):
+        """This makes sure all comparisons of _NoUpdate objects return True"""
+        return isinstance(other, _NoUpdate)
+
 
 # Create the singleton instance
 _NO_UPDATE = _NoUpdate()
 
 
 def validate_parameter_operation(
-    operation: str, parameter_type: ParameterType
+    operation: str, parameter_type: Union[ParameterType, ActionType]
 ) -> Callable:
     """
-    Decorator that validates parameter operations for the InteractiveViewer class.
+    Decorator that validates parameter operations for the viewer class.
 
     This decorator ensures that:
     1. The operation type matches the method name (add/update)
@@ -64,14 +69,14 @@ def validate_parameter_operation(
                 "Incorrect use of validate_parameter_operation decorator. Must be called with 'add' or 'update' as the first argument."
             )
 
-        @wraps(func)
-        def wrapper(self: "InteractiveViewer", name: Any, *args, **kwargs):
-            # Validate operation matches method name (add/update)
-            if not func.__name__.startswith(operation):
-                raise ValueError(
-                    f"Invalid operation type specified ({operation}) for method {func.__name__}"
-                )
+        # Validate operation matches method name (add/update)
+        if not func.__name__.startswith(operation):
+            raise ValueError(
+                f"Invalid operation type specified ({operation}) for method {func.__name__}"
+            )
 
+        @wraps(func)
+        def wrapper(self: "Viewer", name: Any, *args, **kwargs):
             # Validate parameter name is a string
             if not isinstance(name, str):
                 if operation == "add":
@@ -103,17 +108,17 @@ def validate_parameter_operation(
                         parameter_type.name,
                         "Parameter not found - you can only update registered parameters!",
                     )
-                if type(self.parameters[name]) != parameter_type.value:
-                    msg = f"Parameter called {name} was found but is registered as a different parameter type ({type(self.parameters[name])})"
+                if not isinstance(self.parameters[name], parameter_type.value):
+                    msg = f"Parameter called {name} was found but is registered as a different parameter type ({type(self.parameters[name])}). Expecting {parameter_type.value}."
                     raise ParameterUpdateError(name, parameter_type.name, msg)
 
             try:
                 return func(self, name, *args, **kwargs)
             except Exception as e:
                 if operation == "add":
-                    raise ParameterAddError(name, parameter_type.name, str(e)) from e
+                    raise ParameterAddError(name, parameter_type.name, str(e))
                 elif operation == "update":
-                    raise ParameterUpdateError(name, parameter_type.name, str(e)) from e
+                    raise ParameterUpdateError(name, parameter_type.name, str(e))
                 else:
                     raise e
 
@@ -122,7 +127,7 @@ def validate_parameter_operation(
     return decorator
 
 
-class InteractiveViewer(ABC):
+class Viewer:
     """
     Base class for creating interactive matplotlib figures with GUI controls.
 
@@ -137,7 +142,7 @@ class InteractiveViewer(ABC):
 
     Examples
     --------
-    >>> class MyViewer(InteractiveViewer):
+    >>> class MyViewer(Viewer):
     ...     def plot(self, state: Dict[str, Any]):
     ...         fig = plt.figure()
     ...         plt.plot([0, state['x']])
@@ -153,7 +158,6 @@ class InteractiveViewer(ABC):
 
     parameters: Dict[str, Parameter]
     callbacks: Dict[str, List[Callable]]
-    state: Dict[str, Any]
     _app_deployed: bool
     _in_callbacks: bool
 
@@ -161,15 +165,16 @@ class InteractiveViewer(ABC):
         instance = super().__new__(cls)
         instance.parameters = {}
         instance.callbacks = {}
-        instance.state = {}
         instance._app_deployed = False
         instance._in_callbacks = False
         return instance
 
-    def get_state(self) -> Dict[str, Any]:
+    @property
+    def state(self) -> Dict[str, Any]:
         """
         Get the current values of all parameters.
 
+
         Returns
         -------
         dict
@@ -179,18 +184,38 @@ class InteractiveViewer(ABC):
         --------
         >>> viewer.add_float('x', value=1.0, min_value=0, max_value=10)
         >>> viewer.add_text('label', value='data')
-        >>> viewer.get_state()
+        >>> viewer.state
         {'x': 1.0, 'label': 'data'}
         """
-        return {name: param.value for name, param in self.parameters.items()}
+        return {
+            name: param.value
+            for name, param in self.parameters.items()
+            if not param._is_action
+        }
+
+    def plot(self, state: Dict[str, Any]) -> Figure:
+        """Create and return a matplotlib figure.
+
+        This is a placeholder. You must either:
+
+        1. Call set_plot() with your plotting function
+        This will look like this:
+        >>> def plot(state):
+        >>>     ... generate figure, plot stuff ...
+        >>>     return fig
+        >>> viewer.set_plot(plot))
+
+        2. Subclass Viewer and override this method
+        This will look like this:
+        >>> class YourViewer(Viewer):
+        >>>     def plot(self, state):
+        >>>         ... generate figure, plot stuff ...
+        >>>         return fig
 
-    @abstractmethod
-    def plot(self, **kwargs) -> Figure:
-        """
-        Create and return a matplotlib figure.
-
-        This method must be implemented in your subclass. It should create a new
-        figure using the current parameter values from self.parameters.
+        Parameters
+        ----------
+        state : dict
+            Current parameter values
 
         Returns
         -------
@@ -200,27 +225,56 @@ class InteractiveViewer(ABC):
         Notes
         -----
         - Create a new figure each time, don't reuse old ones
-        - Access parameter values using self.parameters['name'].value
-        - Return the figure object, don't call plt.show()
+        - Access parameter values using state['param_name']
+        - Access your viewer class using self (or viewer for the set_plot() method)
+        - Return the figure object, don't call plt.show()!
         """
-        raise NotImplementedError("Subclasses must implement the plot method")
+        raise NotImplementedError(
+            "Plot method not implemented. Either subclass "
+            "Viewer and override plot(), or use "
+            "set_plot() to provide a plotting function."
+        )
+
+    def set_plot(self, func: Callable) -> None:
+        """Set the plot method for the viewer"""
+        self.plot = self._prepare_function(func, context="Setting plot:")
 
     def deploy(self, env: str = "notebook", **kwargs):
         """Deploy the app in a notebook or standalone environment"""
         if env == "notebook":
-            from .notebook_deploy import NotebookDeployment
+            from .notebook_deployment import NotebookDeployer
 
-            deployer = NotebookDeployment(self, **kwargs)
+            deployer = NotebookDeployer(self, **kwargs)
             deployer.deploy()
+            return self
+
+        elif env == "plotly":
+            from .plotly_deployment import PlotlyDeployer
 
-            return deployer
+            deployer = PlotlyDeployer(self, **kwargs)
+            deployer.deploy(mode="server")
+            return self
+
+        elif env == "plotly-inline":
+            from .plotly_deployment import PlotlyDeployer
+
+            deployer = PlotlyDeployer(self, **kwargs)
+            deployer.deploy(mode="notebook")
+            return self
+
+        elif env == "flask":
+            from .flask_deployment import FlaskDeployer
+
+            deployer = FlaskDeployer(self, **kwargs)
+            deployer.deploy()
+            return self
         else:
             raise ValueError(
-                f"Unsupported environment: {env}, only 'notebook' is supported right now."
+                f"Unsupported environment: {env}, only 'notebook', 'plotly', 'plotly-inline', and 'flask' are supported right now."
             )
 
     @contextmanager
-    def deploy_app(self):
+    def _deploy_app(self):
         """Internal context manager to control app deployment state"""
         self._app_deployed = True
         try:
@@ -228,6 +282,128 @@ class InteractiveViewer(ABC):
         finally:
             self._app_deployed = False
 
+    def _prepare_function(
+        self,
+        func: Callable,
+        context: Optional[str] = "",
+    ) -> Callable:
+        # Check if func is Callable
+        if not callable(func):
+            raise ValueError(f"Function {func} is not callable")
+
+        # Handle partial functions
+        if isinstance(func, partial):
+            get_self = (
+                lambda func: hasattr(func.func, "__self__") and func.func.__self__
+            )
+            get_name = lambda func: func.func.__name__
+        else:
+            get_self = lambda func: hasattr(func, "__self__") and func.__self__
+            get_name = lambda func: func.__name__
+
+        # Get function signature
+        try:
+            params = list(inspect.signature(func).parameters.values())
+        except ValueError:
+            # Handle built-ins or other objects without signatures
+            raise ValueError(context + f"Cannot inspect function signature for {func}")
+
+        # Look through params and check if there are two positional parameters (including self for bound methods)
+        bound_method = get_self(func) is self
+        positional_params = 0
+        required_kwargs = 0
+        optional_part = ""
+        for param in params:
+            # Check if it's a positional parameter. If it is, count it.
+            # We need at least 1 positional parameter. When we already have 1,
+            # we need to make sure any other positional parameters have defaults.
+            if param.kind in (
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                inspect.Parameter.POSITIONAL_ONLY,
+            ):
+                if positional_params < 1:
+                    positional_params += 1
+                else:
+                    if param.default == inspect.Parameter.empty:
+                        positional_params += 1
+                    else:
+                        optional_part += f", {param.name}={param.default!r}"
+            elif param.kind == inspect.Parameter.VAR_KEYWORD:
+                optional_part += f", **{param.name}"
+            elif param.kind == inspect.Parameter.KEYWORD_ONLY:
+                optional_part += (
+                    f", {param.name}={param.default!r}"
+                    if param.default != inspect.Parameter.empty
+                    else f""
+                )
+                if param.default == inspect.Parameter.empty:
+                    required_kwargs += 1
+
+        if positional_params != 1 or required_kwargs != 0:
+            func_name = get_name(func)
+            if isinstance(func, partial):
+                func_sig = str(inspect.signature(func))
+                if bound_method:
+                    func_sig = "(" + "self, " + func_sig[1:]
+                msg = (
+                    context
+                    + "\n"
+                    + f"Your partial function '{func_name}' has an incorrect signature.\n"
+                    "Partial functions must have exactly one positional parameter\n"
+                    "which corresponds to a dictionary of the current state of the viewer.\n"
+                    "\nYour partial function effectivelylooks like this:\n"
+                    f"def {func_name}{func_sig}:\n"
+                    "    ... your function code ..."
+                )
+                raise ValueError(msg)
+
+            if bound_method:
+                original_method = getattr(get_self(func).__class__, get_name(func))
+                func_sig = str(inspect.signature(original_method))
+
+                msg = (
+                    context + "\n"
+                    f"Your bound method '{func_name}{func_sig}' has an incorrect signature.\n"
+                    "Bound methods must have exactly one positional parameter in addition to self.\n"
+                    "The first parameter should be self (required for bound methods).\n"
+                    "The second parameter should be state -- a dictionary of the current state of the viewer.\n"
+                    "\nYour method looks like this:\n"
+                    "class YourViewer(Viewer):\n"
+                    f"    def {func_name}{func_sig}:\n"
+                    "        ... your function code ...\n"
+                    "\nIt should look like this:\n"
+                    "class YourViewer(Viewer):\n"
+                    f"    def {func_name}(self, state{optional_part}):\n"
+                    "        ... your function code ..."
+                )
+                raise ValueError(msg)
+            else:
+                func_sig = str(inspect.signature(func))
+                bound_elsewhere = get_self(func) and get_self(func) is not self
+                if bound_elsewhere:
+                    func_name = f"self.{func_name}"
+                    func_sig = f"(self, {func_sig[1:]})"
+                    add_self = True
+                else:
+                    add_self = False
+                msg = (
+                    context + "\n"
+                    f"Your function '{func_name}{func_sig}' has an incorrect signature.\n"
+                    "Functions must have exactly one positional parameter\n"
+                    "which corresponds to a dictionary of the current state of the viewer.\n"
+                    "\nYour function looks like this:\n"
+                    f"def {func_name}{func_sig}:\n"
+                    "    ... your function code ...\n"
+                    "\nIt should look like this:\n"
+                    f"def {func_name}({'self, ' if add_self else ''}state{optional_part}):\n"
+                    "    ... your function code ..."
+                )
+                raise ValueError(msg)
+
+        # If we've made it here, the function has exactly one required positional parameter
+        # which means it's callable by the viewer.
+        return func
+
     def perform_callbacks(self, name: str) -> bool:
         """Perform callbacks for all parameters that have changed"""
         if self._in_callbacks:
@@ -235,7 +411,7 @@ class InteractiveViewer(ABC):
         try:
             self._in_callbacks = True
             if name in self.callbacks:
-                state = self.get_state()
+                state = self.state
                 for callback in self.callbacks[name]:
                     callback(state)
         finally:
@@ -266,6 +442,11 @@ class InteractiveViewer(ABC):
         if isinstance(parameter_name, str):
             parameter_name = [parameter_name]
 
+        callback = self._prepare_function(
+            callback,
+            context="Setting on_change callback:",
+        )
+
         for param_name in parameter_name:
             if param_name not in self.parameters:
                 raise ValueError(f"Parameter '{param_name}' is not registered!")
@@ -320,7 +501,7 @@ class InteractiveViewer(ABC):
         Examples
         --------
         >>> viewer.add_text('title', value='My Plot')
-        >>> viewer.get_state()['title']
+        >>> viewer.state['title']
         'My Plot'
         """
         try:
@@ -348,7 +529,7 @@ class InteractiveViewer(ABC):
         Examples
         --------
         >>> viewer.add_boolean('show_grid', value=True)
-        >>> viewer.get_state()['show_grid']
+        >>> viewer.state['show_grid']
         True
         """
         try:
@@ -379,7 +560,7 @@ class InteractiveViewer(ABC):
         --------
         >>> viewer.add_selection('color', value='red',
         ...                     options=['red', 'green', 'blue'])
-        >>> viewer.get_state()['color']
+        >>> viewer.state['color']
         'red'
         """
         try:
@@ -414,7 +595,7 @@ class InteractiveViewer(ABC):
         >>> viewer.add_multiple_selection('toppings',
         ...     value=['cheese'],
         ...     options=['cheese', 'pepperoni', 'mushrooms'])
-        >>> viewer.get_state()['toppings']
+        >>> viewer.state['toppings']
         ['cheese']
         """
         try:
@@ -454,10 +635,10 @@ class InteractiveViewer(ABC):
         Examples
         --------
         >>> viewer.add_integer('count', value=5, min_value=0, max_value=10)
-        >>> viewer.get_state()['count']
+        >>> viewer.state['count']
         5
         >>> viewer.update_integer('count', value=15)  # Will be clamped to 10
-        >>> viewer.get_state()['count']
+        >>> viewer.state['count']
         10
         """
         try:
@@ -468,7 +649,7 @@ class InteractiveViewer(ABC):
                 max_value,
             )
         except Exception as e:
-            raise ParameterAddError(name, "number", str(e)) from e
+            raise ParameterAddError(name, "number", str(e))
         else:
             self.parameters[name] = new_param
 
@@ -480,11 +661,12 @@ class InteractiveViewer(ABC):
         value: Union[float, int],
         min_value: Union[float, int],
         max_value: Union[float, int],
-        step: float = 0.1,
+        step: float = 0.01,
     ) -> None:
         """
         Add a decimal number parameter to the viewer.
 
+
         Creates a slider in the GUI that lets users select numbers between
         min_value and max_value. Values will be rounded to the nearest step
         and clamped to stay within bounds.
@@ -500,16 +682,16 @@ class InteractiveViewer(ABC):
         max_value : float
             Maximum allowed value
         step : float, optional
-            Size of each increment (default: 0.1)
+            Size of each increment (default: 0.01)
 
         Examples
         --------
         >>> viewer.add_float('temperature', value=20.0,
         ...                  min_value=0.0, max_value=100.0, step=0.5)
-        >>> viewer.get_state()['temperature']
+        >>> viewer.state['temperature']
         20.0
         >>> viewer.update_float('temperature', value=20.7)  # Will round to 20.5
-        >>> viewer.get_state()['temperature']
+        >>> viewer.state['temperature']
         20.5
         """
         try:
@@ -558,11 +740,11 @@ class InteractiveViewer(ABC):
         >>> viewer.add_integer_range('age_range',
         ...                         value=(25, 35),
         ...                         min_value=18, max_value=100)
-        >>> viewer.get_state()['age_range']
+        >>> viewer.state['age_range']
         (25, 35)
         >>> # Values will be swapped if low > high
         >>> viewer.update_integer_range('age_range', value=(40, 30))
-        >>> viewer.get_state()['age_range']
+        >>> viewer.state['age_range']
         (30, 40)
         """
         try:
@@ -585,7 +767,7 @@ class InteractiveViewer(ABC):
         value: Tuple[Union[float, int], Union[float, int]],
         min_value: Union[float, int],
         max_value: Union[float, int],
-        step: float = 0.1,
+        step: float = 0.01,
     ) -> None:
         """
         Add a range parameter for decimal numbers to the viewer.
@@ -606,18 +788,18 @@ class InteractiveViewer(ABC):
         max_value : float
             Maximum allowed value for both low and high
         step : float, optional
-            Size of each increment (default: 0.1)
+            Size of each increment (default: 0.01)
 
         Examples
         --------
         >>> viewer.add_float_range('price_range',
         ...                       value=(10.0, 20.0),
         ...                       min_value=0.0, max_value=100.0, step=0.5)
-        >>> viewer.get_state()['price_range']
+        >>> viewer.state['price_range']
         (10.0, 20.0)
         >>> # Values will be rounded to nearest step
         >>> viewer.update_float_range('price_range', value=(10.7, 19.2))
-        >>> viewer.get_state()['price_range']
+        >>> viewer.state['price_range']
         (10.5, 19.0)
         """
         try:
@@ -639,15 +821,12 @@ class InteractiveViewer(ABC):
         name: str,
         *,
         value: Union[float, int],
-        min_value: Optional[Union[float, int]] = None,
-        max_value: Optional[Union[float, int]] = None,
     ) -> None:
         """
         Add an unbounded integer parameter to the viewer.
 
         Creates a text input box in the GUI for entering whole numbers. Unlike
-        add_integer(), this allows very large numbers and optionally no minimum
-        or maximum bounds.
+        add_integer(), this allows very large numbers without bounds.
         See :class:`~syd.parameters.UnboundedIntegerParameter` for details.
 
         Parameters
@@ -656,29 +835,17 @@ class InteractiveViewer(ABC):
             Name of the parameter (used as label in GUI)
         value : int
             Initial value
-        min_value : int, optional
-            Minimum allowed value (or None for no minimum)
-        max_value : int, optional
-            Maximum allowed value (or None for no maximum)
 
         Examples
         --------
-        >>> viewer.add_unbounded_integer('population',
-        ...                             value=1000000,
-        ...                             min_value=0)  # No maximum
-        >>> viewer.get_state()['population']
+        >>> viewer.add_unbounded_integer('population', value=1000000)
+        >>> viewer.state['population']
         1000000
-        >>> # Values below minimum will be clamped
-        >>> viewer.update_unbounded_integer('population', value=-5)
-        >>> viewer.get_state()['population']
-        0
         """
         try:
             new_param = ParameterType.unbounded_integer.value(
                 name,
                 value,
-                min_value,
-                max_value,
             )
         except Exception as e:
             raise ParameterAddError(name, "unbounded_integer", str(e)) from e
@@ -691,16 +858,14 @@ class InteractiveViewer(ABC):
         name: str,
         *,
         value: Union[float, int],
-        min_value: Optional[Union[float, int]] = None,
-        max_value: Optional[Union[float, int]] = None,
         step: Optional[float] = None,
     ) -> None:
         """
         Add an unbounded decimal number parameter to the viewer.
 
         Creates a text input box in the GUI for entering numbers. Unlike add_float(),
-        this allows very large or precise numbers and optionally no minimum or
-        maximum bounds. Values can optionally be rounded to a step size.
+        this allows very large or precise numbers without bounds. Values can optionally
+        be rounded to a step size.
         See :class:`~syd.parameters.UnboundedFloatParameter` for details.
 
         Parameters
@@ -709,32 +874,23 @@ class InteractiveViewer(ABC):
             Name of the parameter (used as label in GUI)
         value : float
             Initial value
-        min_value : float, optional
-            Minimum allowed value (or None for no minimum)
-        max_value : float, optional
-            Maximum allowed value (or None for no maximum)
         step : float, optional
             Size of each increment (or None for no rounding)
 
         Examples
         --------
-        >>> viewer.add_unbounded_float('wavelength',
-        ...                           value=550e-9,  # Nanometers
-        ...                           min_value=0.0,
-        ...                           step=1e-9)  # Round to nearest nanometer
-        >>> viewer.get_state()['wavelength']
+        >>> viewer.add_unbounded_float('wavelength', value=550e-9, step=1e-9)
+        >>> viewer.state['wavelength']
         5.5e-07
         >>> # Values will be rounded if step is provided
         >>> viewer.update_unbounded_float('wavelength', value=550.7e-9)
-        >>> viewer.get_state()['wavelength']
+        >>> viewer.state['wavelength']
         5.51e-07
         """
         try:
             new_param = ParameterType.unbounded_float.value(
                 name,
                 value,
-                min_value,
-                max_value,
                 step,
             )
         except Exception as e:
@@ -742,7 +898,7 @@ class InteractiveViewer(ABC):
         else:
             self.parameters[name] = new_param
 
-    @validate_parameter_operation("add", ParameterType.button)
+    @validate_parameter_operation("add", ActionType.button)
     def add_button(
         self,
         name: str,
@@ -764,21 +920,25 @@ class InteractiveViewer(ABC):
         label : str
             Text to display on the button
         callback : callable
-            Function to call when the button is clicked (takes no arguments)
+            Function to call when the button is clicked (takes state as a single argument)
 
         Examples
         --------
-        >>> def reset_plot():
+        >>> def reset_plot(state):
         ...     print("Resetting plot...")
         >>> viewer.add_button('reset', label='Reset Plot', callback=reset_plot)
+
+        >>> def print_plot_info(state):
+        ...     print(f"Current plot info: {state['plot_info']}")
+        >>> viewer.add_button('print_info', label='Print Plot Info', callback=print_plot_info)
         """
         try:
+            callback = self._prepare_function(
+                callback,
+                context="Setting button callback:",
+            )
 
-            # Wrap the callback to include state as an input argument
-            def wrapped_callback(button):
-                callback(self.get_state())
-
-            new_param = ParameterType.button.value(name, label, wrapped_callback)
+            new_param = ActionType.button.value(name, label, callback)
         except Exception as e:
             raise ParameterAddError(name, "button", str(e)) from e
         else:
@@ -792,7 +952,7 @@ class InteractiveViewer(ABC):
         """
         Update a text parameter's value.
 
-        Updates a parameter created by :meth:`~syd.interactive_viewer.InteractiveViewer.add_text`.
+        Updates a parameter created by :meth:`~syd.viewer.Viewer.add_text`.
         See :class:`~syd.parameters.TextParameter` for details about value validation.
 
         Parameters
@@ -806,11 +966,11 @@ class InteractiveViewer(ABC):
         --------
         >>> viewer.add_text('title', value='Original Title')
         >>> viewer.update_text('title', value='New Title')
-        >>> viewer.get_state()['title']
+        >>> viewer.state['title']
         'New Title'
         """
         updates = {}
-        if value is not _NO_UPDATE:
+        if not value == _NO_UPDATE:
             updates["value"] = value
         if updates:
             self.parameters[name].update(updates)
@@ -822,7 +982,7 @@ class InteractiveViewer(ABC):
         """
         Update a boolean parameter's value.
 
-        Updates a parameter created by :meth:`~syd.interactive_viewer.InteractiveViewer.add_boolean`.
+        Updates a parameter created by :meth:`~syd.viewer.Viewer.add_boolean`.
         See :class:`~syd.parameters.BooleanParameter` for details about value validation.
 
         Parameters
@@ -836,11 +996,11 @@ class InteractiveViewer(ABC):
         --------
         >>> viewer.add_boolean('show_grid', value=True)
         >>> viewer.update_boolean('show_grid', value=False)
-        >>> viewer.get_state()['show_grid']
+        >>> viewer.state['show_grid']
         False
         """
         updates = {}
-        if value is not _NO_UPDATE:
+        if not value == _NO_UPDATE:
             updates["value"] = value
         if updates:
             self.parameters[name].update(updates)
@@ -856,7 +1016,7 @@ class InteractiveViewer(ABC):
         """
         Update a selection parameter's value and/or options.
 
-        Updates a parameter created by :meth:`~syd.interactive_viewer.InteractiveViewer.add_selection`.
+        Updates a parameter created by :meth:`~syd.viewer.Viewer.add_selection`.
         See :class:`~syd.parameters.SelectionParameter` for details about value validation.
 
         Parameters
@@ -880,9 +1040,9 @@ class InteractiveViewer(ABC):
         ...                        value='purple')
         """
         updates = {}
-        if value is not _NO_UPDATE:
+        if not value == _NO_UPDATE:
             updates["value"] = value
-        if options is not _NO_UPDATE:
+        if not options == _NO_UPDATE:
             updates["options"] = options
         if updates:
             self.parameters[name].update(updates)
@@ -898,7 +1058,7 @@ class InteractiveViewer(ABC):
         """
         Update a multiple selection parameter's values and/or options.
 
-        Updates a parameter created by :meth:`~syd.interactive_viewer.InteractiveViewer.add_multiple_selection`.
+        Updates a parameter created by :meth:`~syd.viewer.Viewer.add_multiple_selection`.
         See :class:`~syd.parameters.MultipleSelectionParameter` for details about value validation.
 
         Parameters
@@ -924,9 +1084,9 @@ class InteractiveViewer(ABC):
         ...     value=['cheese', 'bacon'])
         """
         updates = {}
-        if value is not _NO_UPDATE:
+        if not value == _NO_UPDATE:
             updates["value"] = value
-        if options is not _NO_UPDATE:
+        if not options == _NO_UPDATE:
             updates["options"] = options
         if updates:
             self.parameters[name].update(updates)
@@ -943,7 +1103,7 @@ class InteractiveViewer(ABC):
         """
         Update an integer parameter's value and/or bounds.
 
-        Updates a parameter created by :meth:`~syd.interactive_viewer.InteractiveViewer.add_integer`.
+        Updates a parameter created by :meth:`~syd.viewer.Viewer.add_integer`.
         See :class:`~syd.parameters.IntegerParameter` for details about value validation.
 
         Parameters
@@ -966,11 +1126,11 @@ class InteractiveViewer(ABC):
         >>> viewer.update_integer('count', min_value=7, max_value=15)
         """
         updates = {}
-        if value is not _NO_UPDATE:
+        if not value == _NO_UPDATE:
             updates["value"] = value
-        if min_value is not _NO_UPDATE:
+        if not min_value == _NO_UPDATE:
             updates["min_value"] = min_value
-        if max_value is not _NO_UPDATE:
+        if not max_value == _NO_UPDATE:
             updates["max_value"] = max_value
         if updates:
             self.parameters[name].update(updates)
@@ -988,7 +1148,7 @@ class InteractiveViewer(ABC):
         """
         Update a float parameter's value, bounds, and/or step size.
 
-        Updates a parameter created by :meth:`~syd.interactive_viewer.InteractiveViewer.add_float`.
+        Updates a parameter created by :meth:`~syd.viewer.Viewer.add_float`.
         See :class:`~syd.parameters.FloatParameter` for details about value validation.
 
         Parameters
@@ -1015,13 +1175,13 @@ class InteractiveViewer(ABC):
         ...                    min_value=15.0, max_value=30.0, step=0.1)
         """
         updates = {}
-        if value is not _NO_UPDATE:
+        if not value == _NO_UPDATE:
             updates["value"] = value
-        if min_value is not _NO_UPDATE:
+        if not min_value == _NO_UPDATE:
             updates["min_value"] = min_value
-        if max_value is not _NO_UPDATE:
+        if not max_value == _NO_UPDATE:
             updates["max_value"] = max_value
-        if step is not _NO_UPDATE:
+        if not step == _NO_UPDATE:
             updates["step"] = step
         if updates:
             self.parameters[name].update(updates)
@@ -1038,7 +1198,7 @@ class InteractiveViewer(ABC):
         """
         Update an integer range parameter's values and/or bounds.
 
-        Updates a parameter created by :meth:`~syd.interactive_viewer.InteractiveViewer.add_integer_range`.
+        Updates a parameter created by :meth:`~syd.viewer.Viewer.add_integer_range`.
         See :class:`~syd.parameters.IntegerRangeParameter` for details about value validation.
 
         Parameters
@@ -1063,11 +1223,11 @@ class InteractiveViewer(ABC):
         >>> viewer.update_integer_range('age_range', min_value=20, max_value=80)
         """
         updates = {}
-        if value is not _NO_UPDATE:
+        if not value == _NO_UPDATE:
             updates["value"] = value
-        if min_value is not _NO_UPDATE:
+        if not min_value == _NO_UPDATE:
             updates["min_value"] = min_value
-        if max_value is not _NO_UPDATE:
+        if not max_value == _NO_UPDATE:
             updates["max_value"] = max_value
         if updates:
             self.parameters[name].update(updates)
@@ -1085,7 +1245,7 @@ class InteractiveViewer(ABC):
         """
         Update a float range parameter's values, bounds, and/or step size.
 
-        Updates a parameter created by :meth:`~syd.interactive_viewer.InteractiveViewer.add_float_range`.
+        Updates a parameter created by :meth:`~syd.viewer.Viewer.add_float_range`.
         See :class:`~syd.parameters.FloatRangeParameter` for details about value validation.
 
         Parameters
@@ -1113,13 +1273,13 @@ class InteractiveViewer(ABC):
         ...                          min_value=5.0, max_value=50.0, step=0.1)
         """
         updates = {}
-        if value is not _NO_UPDATE:
+        if not value == _NO_UPDATE:
             updates["value"] = value
-        if min_value is not _NO_UPDATE:
+        if not min_value == _NO_UPDATE:
             updates["min_value"] = min_value
-        if max_value is not _NO_UPDATE:
+        if not max_value == _NO_UPDATE:
             updates["max_value"] = max_value
-        if step is not _NO_UPDATE:
+        if not step == _NO_UPDATE:
             updates["step"] = step
         if updates:
             self.parameters[name].update(updates)
@@ -1130,13 +1290,11 @@ class InteractiveViewer(ABC):
         name: str,
         *,
         value: Union[int, _NoUpdate] = _NO_UPDATE,
-        min_value: Union[Optional[int], _NoUpdate] = _NO_UPDATE,
-        max_value: Union[Optional[int], _NoUpdate] = _NO_UPDATE,
     ) -> None:
         """
         Update an unbounded integer parameter's value and/or bounds.
 
-        Updates a parameter created by :meth:`~syd.interactive_viewer.InteractiveViewer.add_unbounded_integer`.
+        Updates a parameter created by :meth:`~syd.viewer.Viewer.add_unbounded_integer`.
         See :class:`~syd.parameters.UnboundedIntegerParameter` for details about value validation.
 
         Parameters
@@ -1144,31 +1302,17 @@ class InteractiveViewer(ABC):
         name : str
             Name of the unbounded integer parameter to update
         value : int, optional
-            New value (will be clamped to any bounds) (if not provided, no change)
-        min_value : int or None, optional
-            New minimum value, or None for no minimum (if not provided, no change)
-        max_value : int or None, optional
-            New maximum value, or None for no maximum (if not provided, no change)
+            New value (if not provided, no change)
 
         Examples
         --------
-        >>> viewer.add_unbounded_integer('population',
-        ...                             value=1000000,
-        ...                             min_value=0)  # No maximum
+        >>> viewer.add_unbounded_integer('population', value=1000000)
         >>> # Update just the value
         >>> viewer.update_unbounded_integer('population', value=2000000)
-        >>> # Add a maximum bound (current value will be clamped if needed)
-        >>> viewer.update_unbounded_integer('population', max_value=1500000)
-        >>> # Remove the minimum bound
-        >>> viewer.update_unbounded_integer('population', min_value=None)
         """
         updates = {}
-        if value is not _NO_UPDATE:
+        if not value == _NO_UPDATE:
             updates["value"] = value
-        if min_value is not _NO_UPDATE:
-            updates["min_value"] = min_value
-        if max_value is not _NO_UPDATE:
-            updates["max_value"] = max_value
         if updates:
             self.parameters[name].update(updates)
 
@@ -1178,14 +1322,12 @@ class InteractiveViewer(ABC):
         name: str,
         *,
         value: Union[float, _NoUpdate] = _NO_UPDATE,
-        min_value: Union[Optional[float], _NoUpdate] = _NO_UPDATE,
-        max_value: Union[Optional[float], _NoUpdate] = _NO_UPDATE,
         step: Union[Optional[float], _NoUpdate] = _NO_UPDATE,
     ) -> None:
         """
         Update an unbounded float parameter's value, bounds, and/or step size.
 
-        Updates a parameter created by :meth:`~syd.interactive_viewer.InteractiveViewer.add_unbounded_float`.
+        Updates a parameter created by :meth:`~syd.viewer.Viewer.add_unbounded_float`.
         See :class:`~syd.parameters.UnboundedFloatParameter` for details about value validation.
 
         Parameters
@@ -1194,41 +1336,28 @@ class InteractiveViewer(ABC):
             Name of the unbounded float parameter to update
         value : float, optional
             New value (will be rounded if step is set) (if not provided, no change)
-        min_value : float or None, optional
-            New minimum value, or None for no minimum (if not provided, no change)
-        max_value : float or None, optional
-            New maximum value, or None for no maximum (if not provided, no change)
         step : float or None, optional
             New step size for rounding, or None for no rounding (if not provided, no change)
 
         Examples
         --------
-        >>> viewer.add_unbounded_float('wavelength',
-        ...                           value=550e-9,  # Nanometers
-        ...                           min_value=0.0,
-        ...                           step=1e-9)
+        >>> viewer.add_unbounded_float('wavelength', value=550e-9, step=1e-9)
         >>> # Update value (will be rounded if step is set)
-        >>> viewer.update_unbounded_float('wavelength', value=632.8e-9)  # HeNe laser
-        >>> # Change step size and add maximum
-        >>> viewer.update_unbounded_float('wavelength',
-        ...                              step=0.1e-9,  # Finer control
-        ...                              max_value=1000e-9)  # Infrared limit
+        >>> viewer.update_unbounded_float('wavelength', value=632.8e-9)
+        >>> # Change step size
+        >>> viewer.update_unbounded_float('wavelength', step=0.1e-9)
         >>> # Remove step size (allow any precision)
         >>> viewer.update_unbounded_float('wavelength', step=None)
         """
         updates = {}
-        if value is not _NO_UPDATE:
+        if not value == _NO_UPDATE:
             updates["value"] = value
-        if min_value is not _NO_UPDATE:
-            updates["min_value"] = min_value
-        if max_value is not _NO_UPDATE:
-            updates["max_value"] = max_value
-        if step is not _NO_UPDATE:
+        if not step == _NO_UPDATE:
             updates["step"] = step
         if updates:
             self.parameters[name].update(updates)
 
-    @validate_parameter_operation("update", ParameterType.button)
+    @validate_parameter_operation("update", ActionType.button)
     def update_button(
         self,
         name: str,
@@ -1239,8 +1368,8 @@ class InteractiveViewer(ABC):
         """
         Update a button parameter's label and/or callback function.
 
-        Updates a parameter created by :meth:`~syd.interactive_viewer.InteractiveViewer.add_button`.
-        See :class:`~syd.parameters.ButtonParameter` for details.
+        Updates a parameter created by :meth:`~syd.viewer.Viewer.add_button`.
+        See :class:`~syd.parameters.ButtonAction` for details.
 
         Parameters
         ----------
@@ -1253,16 +1382,20 @@ class InteractiveViewer(ABC):
 
         Examples
         --------
-        >>> def new_callback():
+        >>> def new_callback(state):
         ...     print("New action...")
         >>> viewer.update_button('reset',
-        ...                     label='Clear Plot',
+        ...                     label='New Action!',
         ...                     callback=new_callback)
         """
         updates = {}
-        if label is not _NO_UPDATE:
+        if not label == _NO_UPDATE:
             updates["label"] = label
-        if callback is not _NO_UPDATE:
+        if not callback == _NO_UPDATE:
+            callback = self._prepare_function(
+                callback,
+                context="Updating button callback:",
+            )
             updates["callback"] = callback
         if updates:
             self.parameters[name].update(updates)