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

syd/{interactive_viewer.py → viewer.py}

@@ -4,35 +4,21 @@ import inspect
 from contextlib import contextmanager
 from matplotlib.figure import Figure
 
-from .parameters import (
-    ParameterType,
-    ActionType,
-    Parameter,
-    ParameterAddError,
-    ParameterUpdateError,
-)
+from .parameters import ParameterType, ActionType, Parameter
+from .support import NoUpdate, NoInitialValue, ParameterAddError, ParameterUpdateError
 
 
-class _NoUpdate:
-    """Singleton class to represent a non-update in parameter operations."""
-
-    _instance = None
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-        return cls._instance
-
-
-# Create the singleton instance
-_NO_UPDATE = _NoUpdate()
+# Create the singleton instances
+NO_UPDATE = NoUpdate()
+NO_INITIAL_VALUE = NoInitialValue()
 
 
 def validate_parameter_operation(
-    operation: str, parameter_type: Union[ParameterType, ActionType]
+    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 +58,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":
@@ -108,22 +94,14 @@ def validate_parameter_operation(
                     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
-                elif operation == "update":
-                    raise ParameterUpdateError(name, parameter_type.name, str(e)) from e
-                else:
-                    raise e
+            return func(self, name, *args, **kwargs)
 
         return wrapper
 
     return decorator
 
 
-class InteractiveViewer:
+class Viewer:
     """
     Base class for creating interactive matplotlib figures with GUI controls.
 
@@ -138,7 +116,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']])
@@ -148,13 +126,12 @@ class InteractiveViewer:
     ...         self.update_float('x', value=state['x'])
     ...
     >>> viewer = MyViewer()
-    >>> viewer.add_float('x', value=1.0, min_value=0, max_value=10)
+    >>> viewer.add_float('x', value=1.0, min=0, max=10)
     >>> viewer.on_change('x', viewer.update_based_on_x)
     """
 
     parameters: Dict[str, Parameter]
     callbacks: Dict[str, List[Callable]]
-    state: Dict[str, Any]
     _app_deployed: bool
     _in_callbacks: bool
 
@@ -162,15 +139,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
@@ -178,12 +156,16 @@ class InteractiveViewer:
 
         Examples
         --------
-        >>> viewer.add_float('x', value=1.0, min_value=0, max_value=10)
+        >>> viewer.add_float('x', value=1.0, min=0, max=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 +174,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 +205,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."
         )
 
@@ -233,16 +215,26 @@ class InteractiveViewer:
 
     def deploy(self, env: str = "notebook", **kwargs):
         """Deploy the app in a notebook or standalone environment"""
+        env = env.lower()
         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 == "browser" or env == "flask":
+            from .flask_deployment import deploy_flask
+
+            # Ensure port is None by default if not specified
+            if "port" not in kwargs:
+                kwargs["port"] = None
 
+            deployer = deploy_flask(self, **kwargs)
             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 +257,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 +265,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 +274,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 +298,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 +313,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 +329,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 +375,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:
@@ -466,8 +447,25 @@ class InteractiveViewer:
         self.perform_callbacks(name)
 
     # -------------------- parameter registration methods --------------------
+    def remove_parameter(self, name: str) -> None:
+        """
+        Remove a parameter from the viewer.
+
+        Parameters
+        ----------
+        name : str
+            Name of the parameter to remove
+        """
+        if name in self.parameters:
+            del self.parameters[name]
+
     @validate_parameter_operation("add", ParameterType.text)
-    def add_text(self, name: str, *, value: str) -> None:
+    def add_text(
+        self,
+        name: str,
+        *,
+        value: Union[str, NoInitialValue] = NO_INITIAL_VALUE,
+    ) -> None:
         """
         Add a text input parameter to the viewer.
 
@@ -478,13 +476,14 @@ class InteractiveViewer:
         ----------
         name : str
             Name of the parameter (used as label in GUI)
-        value : str
+        value : Union[str, NoInitialValue]
             Initial text value
+            If not provided, the parameter will be empty.
 
         Examples
         --------
         >>> viewer.add_text('title', value='My Plot')
-        >>> viewer.get_state()['title']
+        >>> viewer.state['title']
         'My Plot'
         """
         try:
@@ -495,7 +494,12 @@ class InteractiveViewer:
             self.parameters[name] = new_param
 
     @validate_parameter_operation("add", ParameterType.boolean)
-    def add_boolean(self, name: str, *, value: bool) -> None:
+    def add_boolean(
+        self,
+        name: str,
+        *,
+        value: Union[bool, NoInitialValue] = NO_INITIAL_VALUE,
+    ) -> None:
         """
         Add a boolean parameter to the viewer.
 
@@ -506,13 +510,14 @@ class InteractiveViewer:
         ----------
         name : str
             Name of the parameter (used as label in GUI)
-        value : bool
+        value : Union[bool, NoInitialValue]
             Initial state (True=checked, False=unchecked)
+            If not provided, the parameter will be checked.
 
         Examples
         --------
         >>> viewer.add_boolean('show_grid', value=True)
-        >>> viewer.get_state()['show_grid']
+        >>> viewer.state['show_grid']
         True
         """
         try:
@@ -523,7 +528,13 @@ class InteractiveViewer:
             self.parameters[name] = new_param
 
     @validate_parameter_operation("add", ParameterType.selection)
-    def add_selection(self, name: str, *, value: Any, options: List[Any]) -> None:
+    def add_selection(
+        self,
+        name: str,
+        *,
+        value: Union[Any, NoInitialValue] = NO_INITIAL_VALUE,
+        options: List[Any],
+    ) -> None:
         """
         Add a single-selection parameter to the viewer.
 
@@ -543,7 +554,7 @@ class InteractiveViewer:
         --------
         >>> viewer.add_selection('color', value='red',
         ...                     options=['red', 'green', 'blue'])
-        >>> viewer.get_state()['color']
+        >>> viewer.state['color']
         'red'
         """
         try:
@@ -555,7 +566,11 @@ class InteractiveViewer:
 
     @validate_parameter_operation("add", ParameterType.multiple_selection)
     def add_multiple_selection(
-        self, name: str, *, value: List[Any], options: List[Any]
+        self,
+        name: str,
+        *,
+        value: Union[List[Any], NoInitialValue] = NO_INITIAL_VALUE,
+        options: List[Any],
     ) -> None:
         """
         Add a multiple-selection parameter to the viewer.
@@ -568,8 +583,9 @@ class InteractiveViewer:
         ----------
         name : str
             Name of the parameter (used as label in GUI)
-        value : list
+        value : Union[list, NoInitialValue]
             Initially selected values (must all be in options)
+            If not provided, the parameter will be empty.
         options : list
             List of values that can be selected
 
@@ -578,7 +594,7 @@ class InteractiveViewer:
         >>> viewer.add_multiple_selection('toppings',
         ...     value=['cheese'],
         ...     options=['cheese', 'pepperoni', 'mushrooms'])
-        >>> viewer.get_state()['toppings']
+        >>> viewer.state['toppings']
         ['cheese']
         """
         try:
@@ -593,46 +609,38 @@ class InteractiveViewer:
         self,
         name: str,
         *,
-        value: Union[float, int],
-        min_value: Union[float, int],
-        max_value: Union[float, int],
+        value: Union[Union[float, int], NoInitialValue] = NO_INITIAL_VALUE,
+        min: Union[float, int],
+        max: Union[float, int],
     ) -> None:
         """
         Add an integer parameter to the viewer.
 
-        Creates a slider in the GUI that lets users select whole numbers between
-        min_value and max_value. Values will be clamped to stay within bounds.
+        Creates a slider to select whole numbers between a minimum and maximum.
         See :class:`~syd.parameters.IntegerParameter` for details.
 
         Parameters
         ----------
         name : str
-            Name of the parameter (used as label in GUI)
-        value : int
-            Initial value (will be clamped between min_value and max_value)
-        min_value : int
+            Name of the parameter (used as label in GUI and internal identifier)
+        value : Union[int, NoInitialValue]
+            Initial value (default position of the slider)
+            If not provided, the parameter will be set to the minimum value.
+        min : int
             Minimum allowed value
-        max_value : int
+        max : int
             Maximum allowed value
 
         Examples
         --------
-        >>> viewer.add_integer('count', value=5, min_value=0, max_value=10)
-        >>> viewer.get_state()['count']
-        5
-        >>> viewer.update_integer('count', value=15)  # Will be clamped to 10
-        >>> viewer.get_state()['count']
-        10
+        >>> viewer.add_integer('age', value=25, min=0, max=120)
+
+        >>> viewer.add_integer('year', value=2023, min=1900, max=2100)
         """
         try:
-            new_param = ParameterType.integer.value(
-                name,
-                value,
-                min_value,
-                max_value,
-            )
+            new_param = ParameterType.integer.value(name, value, min, max)
         except Exception as e:
-            raise ParameterAddError(name, "number", str(e)) from e
+            raise ParameterAddError(name, "integer", str(e)) from e
         else:
             self.parameters[name] = new_param
 
@@ -641,51 +649,41 @@ class InteractiveViewer:
         self,
         name: str,
         *,
-        value: Union[float, int],
-        min_value: Union[float, int],
-        max_value: Union[float, int],
-        step: float = 0.1,
+        value: Union[Union[float, int], NoInitialValue] = NO_INITIAL_VALUE,
+        min: Union[float, int],
+        max: Union[float, int],
+        step: float = 0.01,
     ) -> None:
         """
-        Add a decimal number parameter to the viewer.
+        Add a float 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.
+        Creates a slider to select decimal numbers between a minimum and maximum.
+        See :class:`~syd.parameters.FloatParameter` for details.
 
         Parameters
         ----------
         name : str
-            Name of the parameter (used as label in GUI)
-        value : float
-            Initial value (will be clamped between min_value and max_value)
-        min_value : float
+            Name of the parameter (internal identifier)
+        value : Union[float, NoInitialValue]
+            Initial value (default position of the slider)
+            If not provided, the parameter will be set to the minimum value.
+        min : float
             Minimum allowed value
-        max_value : float
+        max : float
             Maximum allowed value
         step : float, optional
-            Size of each increment (default: 0.1)
+            Step size for the slider (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']
-        20.0
-        >>> viewer.update_float('temperature', value=20.7)  # Will round to 20.5
-        >>> viewer.get_state()['temperature']
-        20.5
+        >>> viewer.add_float('temperature', value=98.6, min=95.0, max=105.0, step=0.1)
+
+        >>> viewer.add_float('price', value=9.99, min=0.0, max=100.0, step=0.01)
         """
         try:
-            new_param = ParameterType.float.value(
-                name,
-                value,
-                min_value,
-                max_value,
-                step,
-            )
+            new_param = ParameterType.float.value(name, value, min, max, step)
         except Exception as e:
-            raise ParameterAddError(name, "number", str(e)) from e
+            raise ParameterAddError(name, "float", str(e)) from e
         else:
             self.parameters[name] = new_param
 
@@ -694,48 +692,38 @@ class InteractiveViewer:
         self,
         name: str,
         *,
-        value: Tuple[Union[float, int], Union[float, int]],
-        min_value: Union[float, int],
-        max_value: Union[float, int],
+        value: Union[
+            Tuple[Union[float, int], Union[float, int]], NoInitialValue
+        ] = NO_INITIAL_VALUE,
+        min: Union[float, int],
+        max: Union[float, int],
     ) -> None:
         """
-        Add a range parameter for whole numbers to the viewer.
+        Add an integer range parameter to the viewer.
 
-        Creates a range slider in the GUI that lets users select a range of integers
-        between min_value and max_value. The range is specified as (low, high) and
-        both values will be clamped to stay within bounds.
+        Creates a range slider to select a range of whole numbers between bounds.
         See :class:`~syd.parameters.IntegerRangeParameter` for details.
 
         Parameters
         ----------
         name : str
-            Name of the parameter (used as label in GUI)
-        value : tuple[int, int]
-            Initial (low, high) values
-        min_value : int
-            Minimum allowed value for both low and high
-        max_value : int
-            Maximum allowed value for both low and high
+            Name of the parameter (internal identifier)
+        value : Union[tuple[int, int], NoInitialValue]
+            Initial (low, high) values for the range
+            If not provided, the parameter will be set to the full range.
+        min : int
+            Minimum allowed value for the range
+        max : int
+            Maximum allowed value for the range
 
         Examples
         --------
-        >>> viewer.add_integer_range('age_range',
-        ...                         value=(25, 35),
-        ...                         min_value=18, max_value=100)
-        >>> viewer.get_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']
-        (30, 40)
+        >>> viewer.add_integer_range('age_range', value=(25, 45), min=18, max=100)
+
+        >>> viewer.add_integer_range('year_range', value=(2000, 2020), min=1900, max=2100)
         """
         try:
-            new_param = ParameterType.integer_range.value(
-                name,
-                value,
-                min_value,
-                max_value,
-            )
+            new_param = ParameterType.integer_range.value(name, value, min, max)
         except Exception as e:
             raise ParameterAddError(name, "integer_range", str(e)) from e
         else:
@@ -746,52 +734,41 @@ class InteractiveViewer:
         self,
         name: str,
         *,
-        value: Tuple[Union[float, int], Union[float, int]],
-        min_value: Union[float, int],
-        max_value: Union[float, int],
-        step: float = 0.1,
+        value: Union[
+            Tuple[Union[float, int], Union[float, int]], NoInitialValue
+        ] = NO_INITIAL_VALUE,
+        min: Union[float, int],
+        max: Union[float, int],
+        step: float = 0.01,
     ) -> None:
         """
-        Add a range parameter for decimal numbers to the viewer.
+        Add a float range parameter to the viewer.
 
-        Creates a range slider in the GUI that lets users select a range of numbers
-        between min_value and max_value. The range is specified as (low, high) and
-        both values will be rounded to the nearest step and clamped to stay within bounds.
+        Creates a range slider to select a range of decimal numbers between bounds.
         See :class:`~syd.parameters.FloatRangeParameter` for details.
 
         Parameters
         ----------
         name : str
-            Name of the parameter (used as label in GUI)
-        value : tuple[float, float]
-            Initial (low, high) values
-        min_value : float
-            Minimum allowed value for both low and high
-        max_value : float
-            Maximum allowed value for both low and high
+            Name of the parameter (internal identifier)
+        value : Union[tuple[float, float], NoInitialValue]
+            Initial (low, high) values for the range
+            If not provided, the parameter will be set to the full range.
+        min : float
+            Minimum allowed value for the range
+        max : float
+            Maximum allowed value for the range
         step : float, optional
-            Size of each increment (default: 0.1)
+            Step size for the slider (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']
-        (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']
-        (10.5, 19.0)
+        >>> viewer.add_float_range('temp_range', value=(97.0, 99.0), min=95.0, max=105.0, step=0.1)
+
+        >>> viewer.add_float_range('price_range', value=(10.0, 50.0), min=0.0, max=100.0, step=0.01)
         """
         try:
-            new_param = ParameterType.float_range.value(
-                name,
-                value,
-                min_value,
-                max_value,
-                step,
-            )
+            new_param = ParameterType.float_range.value(name, value, min, max, step)
         except Exception as e:
             raise ParameterAddError(name, "float_range", str(e)) from e
         else:
@@ -802,48 +779,31 @@ class InteractiveViewer:
         self,
         name: str,
         *,
-        value: Union[float, int],
-        min_value: Optional[Union[float, int]] = None,
-        max_value: Optional[Union[float, int]] = None,
+        value: Union[Union[float, int], NoInitialValue] = NO_INITIAL_VALUE,
     ) -> 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
         ----------
         name : str
             Name of the parameter (used as label in GUI)
-        value : int
+        value : Union[int, NoInitialValue]
             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)
+            If not provided, the parameter will be set to 0.
 
         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,
-            )
+            new_param = ParameterType.unbounded_integer.value(name, value)
         except Exception as e:
             raise ParameterAddError(name, "unbounded_integer", str(e)) from e
         else:
@@ -854,53 +814,39 @@ class InteractiveViewer:
         self,
         name: str,
         *,
-        value: Union[float, int],
-        min_value: Optional[Union[float, int]] = None,
-        max_value: Optional[Union[float, int]] = None,
+        value: Union[Union[float, int], NoInitialValue] = NO_INITIAL_VALUE,
         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
         ----------
         name : str
             Name of the parameter (used as label in GUI)
-        value : float
+        value : Union[float, NoInitialValue]
             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)
+            If not provided, the parameter will be set to 0.
         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,
-            )
+            new_param = ParameterType.unbounded_float.value(name, value, step)
         except Exception as e:
             raise ParameterAddError(name, "unbounded_float", str(e)) from e
         else:
@@ -911,7 +857,7 @@ class InteractiveViewer:
         self,
         name: str,
         *,
-        label: str,
+        label: Union[str, NoInitialValue] = NO_INITIAL_VALUE,
         callback: Callable[[], None],
     ) -> None:
         """
@@ -925,19 +871,23 @@ class InteractiveViewer:
         ----------
         name : str
             Name of the parameter (internal identifier)
-        label : str
+        label : Union[str, NoInitialValue]
             Text to display on the button
+            If not provided, the parameter's label will be set to the name.
         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:",
@@ -952,60 +902,60 @@ class InteractiveViewer:
     # -------------------- parameter update methods --------------------
     @validate_parameter_operation("update", ParameterType.text)
     def update_text(
-        self, name: str, *, value: Union[str, _NoUpdate] = _NO_UPDATE
+        self, name: str, *, value: Union[str, NoUpdate] = NO_UPDATE
     ) -> None:
         """
         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
         ----------
         name : str
             Name of the text parameter to update
-        value : str, optional
+        value : Union[str, NoUpdate], optional
             New text value (if not provided, no change)
 
         Examples
         --------
         >>> 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)
 
     @validate_parameter_operation("update", ParameterType.boolean)
     def update_boolean(
-        self, name: str, *, value: Union[bool, _NoUpdate] = _NO_UPDATE
+        self, name: str, *, value: Union[bool, NoUpdate] = NO_UPDATE
     ) -> None:
         """
         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
         ----------
         name : str
             Name of the boolean parameter to update
-        value : bool, optional
+        value : Union[bool, NoUpdate], optional
             New state (True/False) (if not provided, no change)
 
         Examples
         --------
         >>> 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)
@@ -1015,22 +965,22 @@ class InteractiveViewer:
         self,
         name: str,
         *,
-        value: Union[Any, _NoUpdate] = _NO_UPDATE,
-        options: Union[List[Any], _NoUpdate] = _NO_UPDATE,
+        value: Union[Any, NoUpdate] = NO_UPDATE,
+        options: Union[List[Any], NoUpdate] = NO_UPDATE,
     ) -> None:
         """
         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
         ----------
         name : str
             Name of the selection parameter to update
-        value : Any, optional
+        value : Union[Any, NoUpdate], optional
             New selected value (must be in options) (if not provided, no change)
-        options : list, optional
+        options : Union[list, NoUpdate], optional
             New list of selectable options (if not provided, no change)
 
         Examples
@@ -1045,9 +995,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)
@@ -1057,22 +1007,22 @@ class InteractiveViewer:
         self,
         name: str,
         *,
-        value: Union[List[Any], _NoUpdate] = _NO_UPDATE,
-        options: Union[List[Any], _NoUpdate] = _NO_UPDATE,
+        value: Union[List[Any], NoUpdate] = NO_UPDATE,
+        options: Union[List[Any], NoUpdate] = NO_UPDATE,
     ) -> None:
         """
         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
         ----------
         name : str
             Name of the multiple selection parameter to update
-        value : list, optional
+        value : Union[list, NoUpdate], optional
             New list of selected values (all must be in options) (if not provided, no change)
-        options : list, optional
+        options : Union[list, NoUpdate], optional
             New list of selectable options (if not provided, no change)
 
         Examples
@@ -1089,9 +1039,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)
@@ -1101,239 +1051,219 @@ class InteractiveViewer:
         self,
         name: str,
         *,
-        value: Union[int, _NoUpdate] = _NO_UPDATE,
-        min_value: Union[int, _NoUpdate] = _NO_UPDATE,
-        max_value: Union[int, _NoUpdate] = _NO_UPDATE,
+        value: Union[int, NoUpdate] = NO_UPDATE,
+        min: Union[int, NoUpdate] = NO_UPDATE,
+        max: Union[int, NoUpdate] = NO_UPDATE,
     ) -> None:
         """
-        Update an integer parameter's value and/or bounds.
+        Update an integer parameter.
 
-        Updates a parameter created by :meth:`~syd.interactive_viewer.InteractiveViewer.add_integer`.
-        See :class:`~syd.parameters.IntegerParameter` for details about value validation.
+        Change the value or bounds of an existing integer parameter.
+        See :class:`~syd.parameters.IntegerParameter` for details.
 
         Parameters
         ----------
         name : str
-            Name of the integer parameter to update
-        value : int, optional
-            New value (will be clamped to bounds) (if not provided, no change)
-        min_value : int, optional
-            New minimum value (if not provided, no change)
-        max_value : int, optional
-            New maximum value (if not provided, no change)
+            Name of the parameter to update
+        value : Union[int, NoUpdate], optional
+            New value
+        min : Union[int, NoUpdate], optional
+            New minimum allowed value
+        max : Union[int, NoUpdate], optional
+            New maximum allowed value
 
         Examples
         --------
-        >>> viewer.add_integer('count', value=5, min_value=0, max_value=10)
-        >>> # Update just the value
-        >>> viewer.update_integer('count', value=8)
-        >>> # Update bounds (current value will be clamped if needed)
-        >>> viewer.update_integer('count', min_value=7, max_value=15)
+        >>> viewer.update_integer('age', value=30)  # Update just the value
+
+        >>> viewer.update_integer('year', min=2000, max=2023)  # Update just the bounds
         """
         updates = {}
-        if value is not _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)
+        if not isinstance(value, NoUpdate):
+            updates["value"] = int(value)
+        if not isinstance(min, NoUpdate):
+            updates["min"] = int(min)
+        if not isinstance(max, NoUpdate):
+            updates["max"] = int(max)
+
+        parameter = self.parameters[name]
+        parameter.update(updates)
 
     @validate_parameter_operation("update", ParameterType.float)
     def update_float(
         self,
         name: str,
         *,
-        value: Union[float, _NoUpdate] = _NO_UPDATE,
-        min_value: Union[float, _NoUpdate] = _NO_UPDATE,
-        max_value: Union[float, _NoUpdate] = _NO_UPDATE,
-        step: Union[float, _NoUpdate] = _NO_UPDATE,
+        value: Union[float, NoUpdate] = NO_UPDATE,
+        min: Union[float, NoUpdate] = NO_UPDATE,
+        max: Union[float, NoUpdate] = NO_UPDATE,
+        step: Union[float, NoUpdate] = NO_UPDATE,
     ) -> None:
         """
-        Update a float parameter's value, bounds, and/or step size.
+        Update a float parameter.
 
-        Updates a parameter created by :meth:`~syd.interactive_viewer.InteractiveViewer.add_float`.
-        See :class:`~syd.parameters.FloatParameter` for details about value validation.
+        Change the value, bounds, or step size of an existing float parameter.
+        See :class:`~syd.parameters.FloatParameter` for details.
 
         Parameters
         ----------
         name : str
-            Name of the float parameter to update
-        value : float, optional
-            New value (will be rounded and clamped) (if not provided, no change)
-        min_value : float, optional
-            New minimum value (if not provided, no change)
-        max_value : float, optional
-            New maximum value (if not provided, no change)
-        step : float, optional
-            New step size (if not provided, no change)
+            Name of the parameter to update
+        value : Union[float, NoUpdate], optional
+            New value
+        min : Union[float, NoUpdate], optional
+            New minimum allowed value
+        max : Union[float, NoUpdate], optional
+            New maximum allowed value
+        step : Union[float, NoUpdate], optional
+            New step size for the slider
 
         Examples
         --------
-        >>> viewer.add_float('temperature', value=20.0,
-        ...                  min_value=0.0, max_value=100.0, step=0.5)
-        >>> # Update just the value (will round to step)
-        >>> viewer.update_float('temperature', value=20.7)  # Becomes 20.5
-        >>> # Update bounds and step size
-        >>> viewer.update_float('temperature',
-        ...                    min_value=15.0, max_value=30.0, step=0.1)
+        >>> viewer.update_float('temperature', value=99.5)  # Update just the value
+
+        >>> viewer.update_float('price', min=5.0, max=200.0, step=0.05)  # Update bounds and step
         """
         updates = {}
-        if value is not _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:
-            updates["step"] = step
-        if updates:
-            self.parameters[name].update(updates)
+        if not isinstance(value, NoUpdate):
+            updates["value"] = float(value)
+        if not isinstance(min, NoUpdate):
+            updates["min"] = float(min)
+        if not isinstance(max, NoUpdate):
+            updates["max"] = float(max)
+        if not isinstance(step, NoUpdate):
+            updates["step"] = float(step)
+
+        parameter = self.parameters[name]
+        parameter.update(updates)
 
     @validate_parameter_operation("update", ParameterType.integer_range)
     def update_integer_range(
         self,
         name: str,
         *,
-        value: Union[Tuple[int, int], _NoUpdate] = _NO_UPDATE,
-        min_value: Union[int, _NoUpdate] = _NO_UPDATE,
-        max_value: Union[int, _NoUpdate] = _NO_UPDATE,
+        value: Union[Tuple[int, int], NoUpdate] = NO_UPDATE,
+        min: Union[int, NoUpdate] = NO_UPDATE,
+        max: Union[int, NoUpdate] = NO_UPDATE,
     ) -> None:
         """
-        Update an integer range parameter's values and/or bounds.
+        Update an integer range parameter.
 
-        Updates a parameter created by :meth:`~syd.interactive_viewer.InteractiveViewer.add_integer_range`.
-        See :class:`~syd.parameters.IntegerRangeParameter` for details about value validation.
+        Change the range values or bounds of an existing integer range parameter.
+        See :class:`~syd.parameters.IntegerRangeParameter` for details.
 
         Parameters
         ----------
         name : str
-            Name of the integer range parameter to update
-        value : tuple[int, int], optional
-            New (low, high) values (will be clamped) (if not provided, no change)
-        min_value : int, optional
-            New minimum value for both low and high (if not provided, no change)
-        max_value : int, optional
-            New maximum value for both low and high (if not provided, no change)
+            Name of the parameter to update
+        value : Union[tuple[int, int], NoUpdate], optional
+            New (low, high) values
+        min : Union[int, NoUpdate], optional
+            New minimum allowed value
+        max : Union[int, NoUpdate], optional
+            New maximum allowed value
 
         Examples
         --------
-        >>> viewer.add_integer_range('age_range',
-        ...                         value=(25, 35),
-        ...                         min_value=18, max_value=100)
-        >>> # Update just the range (values will be swapped if needed)
-        >>> viewer.update_integer_range('age_range', value=(40, 30))  # Becomes (30, 40)
-        >>> # Update bounds (current values will be clamped if needed)
-        >>> viewer.update_integer_range('age_range', min_value=20, max_value=80)
+        >>> viewer.update_integer_range('age_range', value=(30, 50))  # Update just the values
+
+        >>> viewer.update_integer_range('year_range', min=1950, max=2023)  # Update just the bounds
         """
         updates = {}
-        if value is not _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)
+        if not isinstance(value, NoUpdate):
+            val_low, val_high = value
+            updates["value"] = (int(val_low), int(val_high))
+        if not isinstance(min, NoUpdate):
+            updates["min"] = int(min)
+        if not isinstance(max, NoUpdate):
+            updates["max"] = int(max)
+
+        parameter = self.parameters[name]
+        parameter.update(updates)
 
     @validate_parameter_operation("update", ParameterType.float_range)
     def update_float_range(
         self,
         name: str,
         *,
-        value: Union[Tuple[float, float], _NoUpdate] = _NO_UPDATE,
-        min_value: Union[float, _NoUpdate] = _NO_UPDATE,
-        max_value: Union[float, _NoUpdate] = _NO_UPDATE,
-        step: Union[float, _NoUpdate] = _NO_UPDATE,
+        value: Union[Tuple[float, float], NoUpdate] = NO_UPDATE,
+        min: Union[float, NoUpdate] = NO_UPDATE,
+        max: Union[float, NoUpdate] = NO_UPDATE,
+        step: Union[float, NoUpdate] = NO_UPDATE,
     ) -> None:
         """
-        Update a float range parameter's values, bounds, and/or step size.
+        Update a float range parameter.
 
-        Updates a parameter created by :meth:`~syd.interactive_viewer.InteractiveViewer.add_float_range`.
-        See :class:`~syd.parameters.FloatRangeParameter` for details about value validation.
+        Change the range values, bounds, or step size of an existing float range parameter.
+        See :class:`~syd.parameters.FloatRangeParameter` for details.
 
         Parameters
         ----------
         name : str
-            Name of the float range parameter to update
-        value : tuple[float, float], optional
-            New (low, high) values (will be rounded and clamped) (if not provided, no change)
-        min_value : float, optional
-            New minimum value for both low and high (if not provided, no change)
-        max_value : float, optional
-            New maximum value for both low and high (if not provided, no change)
-        step : float, optional
-            New step size for rounding values (if not provided, no change)
+            Name of the parameter to update
+        value : Union[tuple[float, float], NoUpdate], optional
+            New (low, high) values
+        min : Union[float, NoUpdate], optional
+            New minimum allowed value
+        max : Union[float, NoUpdate], optional
+            New maximum allowed value
+        step : Union[float, NoUpdate], optional
+            New step size for the slider
 
         Examples
         --------
-        >>> viewer.add_float_range('price_range',
-        ...                       value=(10.0, 20.0),
-        ...                       min_value=0.0, max_value=100.0, step=0.5)
-        >>> # Update just the range (values will be rounded and swapped if needed)
-        >>> viewer.update_float_range('price_range', value=(15.7, 14.2))  # Becomes (14.0, 15.5)
-        >>> # Update bounds and step size
-        >>> viewer.update_float_range('price_range',
-        ...                          min_value=5.0, max_value=50.0, step=0.1)
+        >>> viewer.update_float_range('temp_range', value=(97.5, 98.5))  # Update just the values
+
+        >>> viewer.update_float_range(
+        ...     'price_range',
+        ...     min=10.0,
+        ...     max=500.0,
+        ...     step=0.5
+        ... )  # Update bounds and step
         """
         updates = {}
-        if value is not _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:
-            updates["step"] = step
-        if updates:
-            self.parameters[name].update(updates)
+        if not isinstance(value, NoUpdate):
+            val_low, val_high = value
+            updates["value"] = (float(val_low), float(val_high))
+        if not isinstance(min, NoUpdate):
+            updates["min"] = float(min)
+        if not isinstance(max, NoUpdate):
+            updates["max"] = float(max)
+        if not isinstance(step, NoUpdate):
+            updates["step"] = float(step)
+
+        parameter = self.parameters[name]
+        parameter.update(updates)
 
     @validate_parameter_operation("update", ParameterType.unbounded_integer)
     def update_unbounded_integer(
         self,
         name: str,
         *,
-        value: Union[int, _NoUpdate] = _NO_UPDATE,
-        min_value: Union[Optional[int], _NoUpdate] = _NO_UPDATE,
-        max_value: Union[Optional[int], _NoUpdate] = _NO_UPDATE,
+        value: Union[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
         ----------
         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)
+        value : Union[int, NoUpdate], optional
+            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)
 
@@ -1342,53 +1272,38 @@ class InteractiveViewer:
         self,
         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,
+        value: Union[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
         ----------
         name : str
             Name of the unbounded float parameter to update
-        value : float, optional
+        value : Union[float, NoUpdate], 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
+        step : Union[Optional[float], NoUpdate], 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)
@@ -1398,40 +1313,48 @@ class InteractiveViewer:
         self,
         name: str,
         *,
-        label: Union[str, _NoUpdate] = _NO_UPDATE,
-        callback: Union[Callable[[], None], _NoUpdate] = _NO_UPDATE,
+        label: Union[str, NoUpdate] = NO_UPDATE,
+        callback: Union[Callable[[], None], NoUpdate] = NO_UPDATE,
     ) -> None:
         """
         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
         ----------
         name : str
             Name of the button parameter to update
-        label : str, optional
+        label : Union[str, NoUpdate], optional
             New text to display on the button (if not provided, no change)
-        callback : callable, optional
+        callback : Union[callable, NoUpdate], optional
             New function to call when clicked (if not provided, no change)
 
         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:
-            callback = self._prepare_function(
-                callback,
-                context="Updating button callback:",
-            )
-            updates["callback"] = callback
+        if not callback == NO_UPDATE:
+            try:
+                callback = self._prepare_function(
+                    callback,
+                    context="Updating button callback:",
+                )
+            except Exception as e:
+                raise ParameterUpdateError(
+                    name,
+                    "button",
+                    str(e),
+                ) from e
+            else:
+                updates["callback"] = callback
         if updates:
             self.parameters[name].update(updates)