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

syd/{interactive_viewer.py → viewer.py}

@@ -23,6 +23,10 @@ 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()
@@ -32,7 +36,7 @@ def validate_parameter_operation(
     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)
@@ -72,7 +76,7 @@ def validate_parameter_operation(
             )
 
         @wraps(func)
-        def wrapper(self: "InteractiveViewer", name: Any, *args, **kwargs):
+        def wrapper(self: "Viewer", name: Any, *args, **kwargs):
             # Validate parameter name is a string
             if not isinstance(name, str):
                 if operation == "add":
@@ -112,9 +116,9 @@ def validate_parameter_operation(
                 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
 
@@ -123,7 +127,7 @@ def validate_parameter_operation(
     return decorator
 
 
-class InteractiveViewer:
+class Viewer:
     """
     Base class for creating interactive matplotlib figures with GUI controls.
 
@@ -138,7 +142,7 @@ class InteractiveViewer:
 
     Examples
     --------
-    >>> class MyViewer(InteractiveViewer):
+    >>> class MyViewer(Viewer):
     ...     def plot(self, state: Dict[str, Any]):
     ...         fig = plt.figure()
     ...         plt.plot([0, state['x']])
@@ -154,7 +158,6 @@ class InteractiveViewer:
 
     parameters: Dict[str, Parameter]
     callbacks: Dict[str, List[Callable]]
-    state: Dict[str, Any]
     _app_deployed: bool
     _in_callbacks: bool
 
@@ -162,15 +165,16 @@ class InteractiveViewer:
         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
@@ -180,10 +184,14 @@ class InteractiveViewer:
         --------
         >>> 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.
@@ -192,14 +200,14 @@ class InteractiveViewer:
 
         1. Call set_plot() with your plotting function
         This will look like this:
-        >>> def plot(viewer, state):
+        >>> def plot(state):
         >>>     ... generate figure, plot stuff ...
         >>>     return fig
         >>> viewer.set_plot(plot))
 
-        2. Subclass InteractiveViewer and override this method
+        2. Subclass Viewer and override this method
         This will look like this:
-        >>> class YourViewer(InteractiveViewer):
+        >>> class YourViewer(Viewer):
         >>>     def plot(self, state):
         >>>         ... generate figure, plot stuff ...
         >>>         return fig
@@ -223,7 +231,7 @@ class InteractiveViewer:
         """
         raise NotImplementedError(
             "Plot method not implemented. Either subclass "
-            "InteractiveViewer and override plot(), or use "
+            "Viewer and override plot(), or use "
             "set_plot() to provide a plotting function."
         )
 
@@ -234,15 +242,35 @@ class InteractiveViewer:
     def deploy(self, env: str = "notebook", **kwargs):
         """Deploy the app in a notebook or standalone environment"""
         if env == "notebook":
-            from .notebook_deployment 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
+
+            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
@@ -265,7 +293,6 @@ class InteractiveViewer:
 
         # Handle partial functions
         if isinstance(func, partial):
-            # Create new partial with self as first arg if not already there
             get_self = (
                 lambda func: hasattr(func.func, "__self__") and func.func.__self__
             )
@@ -274,17 +301,6 @@ class InteractiveViewer:
             get_self = lambda func: hasattr(func, "__self__") and func.__self__
             get_name = lambda func: func.__name__
 
-        # Check if it's a class method
-        class_method = get_self(func) is self.__class__
-        if class_method:
-            raise ValueError(context + "Class methods are not supported.")
-
-        # Check if it's a bound method to another instance other than this one
-        if get_self(func) and get_self(func) is not self:
-            raise ValueError(
-                context + "Bound methods to other instances are not supported."
-            )
-
         # Get function signature
         try:
             params = list(inspect.signature(func).parameters.values())
@@ -294,17 +310,18 @@ class InteractiveViewer:
 
         # 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 + bound_method
+        positional_params = 0
+        required_kwargs = 0
         optional_part = ""
         for param in params:
             # Check if it's a positional parameter. If it is, count it.
-            # As long as we have less than 2 positional parameters, we're good.
-            # When we already have 2 positional parameters, we need to make sure any other positional parameters have defaults.
+            # 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 < 2:
+                if positional_params < 1:
                     positional_params += 1
                 else:
                     if param.default == inspect.Parameter.empty:
@@ -317,10 +334,12 @@ class InteractiveViewer:
                 optional_part += (
                     f", {param.name}={param.default!r}"
                     if param.default != inspect.Parameter.empty
-                    else f", {param.name}"
+                    else f""
                 )
+                if param.default == inspect.Parameter.empty:
+                    required_kwargs += 1
 
-        if positional_params != 2:
+        if positional_params != 1 or required_kwargs != 0:
             func_name = get_name(func)
             if isinstance(func, partial):
                 func_sig = str(inspect.signature(func))
@@ -330,9 +349,8 @@ class InteractiveViewer:
                     context
                     + "\n"
                     + f"Your partial function '{func_name}' has an incorrect signature.\n"
-                    "Partial functions must have exactly two positional parameters.\n"
-                    "The first parameter should be self -- it corresponds to the viewer.\n"
-                    "The second parameter should be state -- a dictionary of the current state of the viewer.\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 ..."
@@ -347,45 +365,44 @@ class InteractiveViewer:
                     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 -- it corresponds to the viewer.\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(InteractiveViewer):\n"
+                    "class YourViewer(Viewer):\n"
                     f"    def {func_name}{func_sig}:\n"
                     "        ... your function code ...\n"
                     "\nIt should look like this:\n"
-                    "class YourViewer(InteractiveViewer):\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"
-                    "External functions must have exactly two positional parameters.\n"
-                    "The first parameter should be viewer -- it corresponds to the viewer.\n"
-                    "The second parameter should be state -- a dictionary of the current state of the viewer.\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}(viewer, state{optional_part}):\n"
+                    f"def {func_name}({'self, ' if add_self else ''}state{optional_part}):\n"
                     "    ... your function code ..."
                 )
                 raise ValueError(msg)
 
-        # If not a bound method, wrap it to inject self when called with just the state
-        if bound_method:
-            return func
-
-        @wraps(func)
-        def func_with_self(*args, **kwargs):
-            return func(self, *args, **kwargs)
-
-        return func_with_self
+        # 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"""
@@ -394,7 +411,7 @@ class InteractiveViewer:
         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:
@@ -484,7 +501,7 @@ class InteractiveViewer:
         Examples
         --------
         >>> viewer.add_text('title', value='My Plot')
-        >>> viewer.get_state()['title']
+        >>> viewer.state['title']
         'My Plot'
         """
         try:
@@ -512,7 +529,7 @@ class InteractiveViewer:
         Examples
         --------
         >>> viewer.add_boolean('show_grid', value=True)
-        >>> viewer.get_state()['show_grid']
+        >>> viewer.state['show_grid']
         True
         """
         try:
@@ -543,7 +560,7 @@ class InteractiveViewer:
         --------
         >>> viewer.add_selection('color', value='red',
         ...                     options=['red', 'green', 'blue'])
-        >>> viewer.get_state()['color']
+        >>> viewer.state['color']
         'red'
         """
         try:
@@ -578,7 +595,7 @@ class InteractiveViewer:
         >>> viewer.add_multiple_selection('toppings',
         ...     value=['cheese'],
         ...     options=['cheese', 'pepperoni', 'mushrooms'])
-        >>> viewer.get_state()['toppings']
+        >>> viewer.state['toppings']
         ['cheese']
         """
         try:
@@ -618,10 +635,10 @@ class InteractiveViewer:
         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:
@@ -632,7 +649,7 @@ class InteractiveViewer:
                 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
 
@@ -644,11 +661,12 @@ class InteractiveViewer:
         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.
@@ -664,16 +682,16 @@ class InteractiveViewer:
         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:
@@ -722,11 +740,11 @@ class InteractiveViewer:
         >>> 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:
@@ -749,7 +767,7 @@ class InteractiveViewer:
         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.
@@ -770,18 +788,18 @@ class InteractiveViewer:
         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:
@@ -803,15 +821,12 @@ class InteractiveViewer:
         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
@@ -820,29 +835,17 @@ class InteractiveViewer:
             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
@@ -855,16 +858,14 @@ class InteractiveViewer:
         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
@@ -873,32 +874,23 @@ class InteractiveViewer:
             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:
@@ -928,16 +920,19 @@ class InteractiveViewer:
         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:",
@@ -957,7 +952,7 @@ class InteractiveViewer:
         """
         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
@@ -971,11 +966,11 @@ class InteractiveViewer:
         --------
         >>> 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)
@@ -987,7 +982,7 @@ class InteractiveViewer:
         """
         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
@@ -1001,11 +996,11 @@ class InteractiveViewer:
         --------
         >>> 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)
@@ -1021,7 +1016,7 @@ class InteractiveViewer:
         """
         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
@@ -1045,9 +1040,9 @@ class InteractiveViewer:
         ...                        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)
@@ -1063,7 +1058,7 @@ class InteractiveViewer:
         """
         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
@@ -1089,9 +1084,9 @@ class InteractiveViewer:
         ...     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)
@@ -1108,7 +1103,7 @@ class InteractiveViewer:
         """
         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
@@ -1131,11 +1126,11 @@ class InteractiveViewer:
         >>> 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)
@@ -1153,7 +1148,7 @@ class InteractiveViewer:
         """
         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
@@ -1180,13 +1175,13 @@ class InteractiveViewer:
         ...                    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)
@@ -1203,7 +1198,7 @@ class InteractiveViewer:
         """
         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
@@ -1228,11 +1223,11 @@ class InteractiveViewer:
         >>> 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)
@@ -1250,7 +1245,7 @@ class InteractiveViewer:
         """
         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
@@ -1278,13 +1273,13 @@ class InteractiveViewer:
         ...                          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)
@@ -1295,13 +1290,11 @@ class InteractiveViewer:
         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
@@ -1309,31 +1302,17 @@ class InteractiveViewer:
         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)
 
@@ -1343,14 +1322,12 @@ class InteractiveViewer:
         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
@@ -1359,36 +1336,23 @@ class InteractiveViewer:
             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)
@@ -1404,7 +1368,7 @@ class InteractiveViewer:
         """
         Update a button parameter's label and/or callback function.
 
-        Updates a parameter created by :meth:`~syd.interactive_viewer.InteractiveViewer.add_button`.
+        Updates a parameter created by :meth:`~syd.viewer.Viewer.add_button`.
         See :class:`~syd.parameters.ButtonAction` for details.
 
         Parameters
@@ -1418,16 +1382,16 @@ class InteractiveViewer:
 
         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:",