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

syd/viewer.py

@@ -4,36 +4,17 @@ 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
-
-    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()
+# 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 viewer class.
@@ -112,15 +93,7 @@ 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))
-                elif operation == "update":
-                    raise ParameterUpdateError(name, parameter_type.name, str(e))
-                else:
-                    raise e
+            return func(self, name, *args, **kwargs)
 
         return wrapper
 
@@ -152,7 +125,7 @@ class Viewer:
     ...         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)
     """
 
@@ -182,7 +155,7 @@ class Viewer:
 
         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.state
         {'x': 1.0, 'label': 'data'}
@@ -241,36 +214,31 @@ class Viewer:
 
     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 NotebookDeployer
+            # On demand import because the deployers need to import the viewer
+            from .notebook_deployment.deployer import NotebookDeployer
 
             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 == "browser" or env == "flask":
+            # On demand import because the deployers need to import the viewer
+            from .flask_deployment.deployer import FlaskDeployer
 
-        elif env == "flask":
-            from .flask_deployment import FlaskDeployer
+            if "port" not in kwargs:
+                kwargs["port"] = None
+            if "continuous" in kwargs:
+                kwargs.pop("continuous")
 
             deployer = FlaskDeployer(self, **kwargs)
             deployer.deploy()
             return self
+
         else:
             raise ValueError(
-                f"Unsupported environment: {env}, only 'notebook', 'plotly', 'plotly-inline', and 'flask' are supported right now."
+                f"Unsupported environment: {env}, only 'notebook', 'flask'/'browser' are supported right now."
             )
 
     @contextmanager
@@ -483,8 +451,25 @@ class Viewer:
         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.
 
@@ -495,8 +480,9 @@ class Viewer:
         ----------
         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
         --------
@@ -512,7 +498,12 @@ class Viewer:
             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.
 
@@ -523,8 +514,9 @@ class Viewer:
         ----------
         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
         --------
@@ -540,7 +532,13 @@ class Viewer:
             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.
 
@@ -572,7 +570,11 @@ class Viewer:
 
     @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.
@@ -585,8 +587,9 @@ class Viewer:
         ----------
         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
 
@@ -610,46 +613,38 @@ class Viewer:
         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.state['count']
-        5
-        >>> viewer.update_integer('count', value=15)  # Will be clamped to 10
-        >>> viewer.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))
+            raise ParameterAddError(name, "integer", str(e)) from e
         else:
             self.parameters[name] = new_param
 
@@ -658,52 +653,41 @@ class Viewer:
         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],
         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.01)
+            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.state['temperature']
-        20.0
-        >>> viewer.update_float('temperature', value=20.7)  # Will round to 20.5
-        >>> viewer.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
 
@@ -712,48 +696,38 @@ class Viewer:
         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.state['age_range']
-        (25, 35)
-        >>> # Values will be swapped if low > high
-        >>> viewer.update_integer_range('age_range', value=(40, 30))
-        >>> viewer.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:
@@ -764,52 +738,41 @@ class Viewer:
         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],
         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.01)
+            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.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.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:
@@ -820,7 +783,7 @@ class Viewer:
         self,
         name: str,
         *,
-        value: Union[float, int],
+        value: Union[Union[float, int], NoInitialValue] = NO_INITIAL_VALUE,
     ) -> None:
         """
         Add an unbounded integer parameter to the viewer.
@@ -833,8 +796,9 @@ class Viewer:
         ----------
         name : str
             Name of the parameter (used as label in GUI)
-        value : int
+        value : Union[int, NoInitialValue]
             Initial value
+            If not provided, the parameter will be set to 0.
 
         Examples
         --------
@@ -843,10 +807,7 @@ class Viewer:
         1000000
         """
         try:
-            new_param = ParameterType.unbounded_integer.value(
-                name,
-                value,
-            )
+            new_param = ParameterType.unbounded_integer.value(name, value)
         except Exception as e:
             raise ParameterAddError(name, "unbounded_integer", str(e)) from e
         else:
@@ -857,7 +818,7 @@ class Viewer:
         self,
         name: str,
         *,
-        value: Union[float, int],
+        value: Union[Union[float, int], NoInitialValue] = NO_INITIAL_VALUE,
         step: Optional[float] = None,
     ) -> None:
         """
@@ -872,8 +833,9 @@ class Viewer:
         ----------
         name : str
             Name of the parameter (used as label in GUI)
-        value : float
+        value : Union[float, NoInitialValue]
             Initial value
+            If not provided, the parameter will be set to 0.
         step : float, optional
             Size of each increment (or None for no rounding)
 
@@ -888,11 +850,7 @@ class Viewer:
         5.51e-07
         """
         try:
-            new_param = ParameterType.unbounded_float.value(
-                name,
-                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:
@@ -903,7 +861,7 @@ class Viewer:
         self,
         name: str,
         *,
-        label: str,
+        label: Union[str, NoInitialValue] = NO_INITIAL_VALUE,
         callback: Callable[[], None],
     ) -> None:
         """
@@ -917,8 +875,9 @@ class Viewer:
         ----------
         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 state as a single argument)
 
@@ -947,7 +906,7 @@ class Viewer:
     # -------------------- 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.
@@ -959,7 +918,7 @@ class Viewer:
         ----------
         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
@@ -970,14 +929,14 @@ class Viewer:
         'New Title'
         """
         updates = {}
-        if not value == _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.
@@ -989,7 +948,7 @@ class Viewer:
         ----------
         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
@@ -1000,7 +959,7 @@ class Viewer:
         False
         """
         updates = {}
-        if not value == _NO_UPDATE:
+        if not value == NO_UPDATE:
             updates["value"] = value
         if updates:
             self.parameters[name].update(updates)
@@ -1010,8 +969,8 @@ class Viewer:
         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.
@@ -1023,9 +982,9 @@ class Viewer:
         ----------
         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
@@ -1040,9 +999,9 @@ class Viewer:
         ...                        value='purple')
         """
         updates = {}
-        if not value == _NO_UPDATE:
+        if not value == NO_UPDATE:
             updates["value"] = value
-        if not options == _NO_UPDATE:
+        if not options == NO_UPDATE:
             updates["options"] = options
         if updates:
             self.parameters[name].update(updates)
@@ -1052,8 +1011,8 @@ class Viewer:
         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.
@@ -1065,9 +1024,9 @@ class Viewer:
         ----------
         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
@@ -1084,9 +1043,9 @@ class Viewer:
         ...     value=['cheese', 'bacon'])
         """
         updates = {}
-        if not value == _NO_UPDATE:
+        if not value == NO_UPDATE:
             updates["value"] = value
-        if not options == _NO_UPDATE:
+        if not options == NO_UPDATE:
             updates["options"] = options
         if updates:
             self.parameters[name].update(updates)
@@ -1096,200 +1055,196 @@ class Viewer:
         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.viewer.Viewer.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 not value == _NO_UPDATE:
-            updates["value"] = value
-        if not min_value == _NO_UPDATE:
-            updates["min_value"] = min_value
-        if not max_value == _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.viewer.Viewer.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 not value == _NO_UPDATE:
-            updates["value"] = value
-        if not min_value == _NO_UPDATE:
-            updates["min_value"] = min_value
-        if not max_value == _NO_UPDATE:
-            updates["max_value"] = max_value
-        if not step == _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.viewer.Viewer.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 not value == _NO_UPDATE:
-            updates["value"] = value
-        if not min_value == _NO_UPDATE:
-            updates["min_value"] = min_value
-        if not max_value == _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.viewer.Viewer.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 not value == _NO_UPDATE:
-            updates["value"] = value
-        if not min_value == _NO_UPDATE:
-            updates["min_value"] = min_value
-        if not max_value == _NO_UPDATE:
-            updates["max_value"] = max_value
-        if not step == _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,
+        value: Union[int, NoUpdate] = NO_UPDATE,
     ) -> None:
         """
         Update an unbounded integer parameter's value and/or bounds.
@@ -1301,7 +1256,7 @@ class Viewer:
         ----------
         name : str
             Name of the unbounded integer parameter to update
-        value : int, optional
+        value : Union[int, NoUpdate], optional
             New value (if not provided, no change)
 
         Examples
@@ -1311,7 +1266,7 @@ class Viewer:
         >>> viewer.update_unbounded_integer('population', value=2000000)
         """
         updates = {}
-        if not value == _NO_UPDATE:
+        if not value == NO_UPDATE:
             updates["value"] = value
         if updates:
             self.parameters[name].update(updates)
@@ -1321,8 +1276,8 @@ class Viewer:
         self,
         name: str,
         *,
-        value: Union[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.
@@ -1334,9 +1289,9 @@ class Viewer:
         ----------
         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)
-        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
@@ -1350,9 +1305,9 @@ class Viewer:
         >>> viewer.update_unbounded_float('wavelength', step=None)
         """
         updates = {}
-        if not value == _NO_UPDATE:
+        if not value == NO_UPDATE:
             updates["value"] = value
-        if not step == _NO_UPDATE:
+        if not step == NO_UPDATE:
             updates["step"] = step
         if updates:
             self.parameters[name].update(updates)
@@ -1362,8 +1317,8 @@ class Viewer:
         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.
@@ -1375,9 +1330,9 @@ class Viewer:
         ----------
         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
@@ -1389,13 +1344,21 @@ class Viewer:
         ...                     callback=new_callback)
         """
         updates = {}
-        if not label == _NO_UPDATE:
+        if not label == NO_UPDATE:
             updates["label"] = label
-        if not callback == _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)