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

syd/parameters.py

@@ -1,9 +1,10 @@
-from typing import List, Any, Tuple, Generic, TypeVar, Optional, Dict, Callable
-from dataclasses import dataclass
-from abc import ABC, abstractmethod
+from typing import List, Any, Tuple, Generic, TypeVar, Optional, Dict, Callable, Union
+from dataclasses import dataclass, field
+from abc import ABC, ABCMeta, abstractmethod
 from enum import Enum
 from copy import deepcopy
 from warnings import warn
+import numpy as np
 
 T = TypeVar("T")
 
@@ -55,6 +56,29 @@ class ParameterUpdateError(Exception):
         )
 
 
+class ParameterUpdateWarning(Warning):
+    """
+    Warning raised when there is a non-critical issue updating a parameter.
+
+    Parameters
+    ----------
+    parameter_name : str
+        Name of the parameter that had the warning
+    parameter_type : str
+        Type of the parameter
+    message : str, optional
+        Additional warning details
+    """
+
+    def __init__(self, parameter_name: str, parameter_type: str, message: str = None):
+        self.parameter_name = parameter_name
+        self.parameter_type = parameter_type
+        super().__init__(
+            f"Warning updating {parameter_type} parameter '{parameter_name}'"
+            + (f": {message}" if message else "")
+        )
+
+
 def get_parameter_attributes(param_class) -> List[str]:
     """
     Get all valid attributes for a parameter class.
@@ -82,8 +106,39 @@ def get_parameter_attributes(param_class) -> List[str]:
     return attributes
 
 
+class ParameterMeta(ABCMeta):
+    _parameter_types = {}
+    _parameter_ids = {}  # Store unique identifiers for our parameter types
+
+    def __new__(cls, name, bases, namespace):
+        parameter_class = super().__new__(cls, name, bases, namespace)
+        if name != "Parameter":
+            # Generate a unique ID for this parameter type
+            type_id = f"syd.parameters.{name}"  # Using fully qualified name
+            cls._parameter_ids[name] = type_id
+
+            # Add ID to the class
+            if not hasattr(parameter_class, "_parameter_type_id"):
+                setattr(parameter_class, "_parameter_type_id", type_id)
+            else:
+                if getattr(parameter_class, "_parameter_type_id") != type_id:
+                    raise ValueError(
+                        f"Parameter type {name} has multiple IDs: {type_id} and {getattr(parameter_class, '_parameter_type_id')}"
+                    )
+            cls._parameter_types[name] = parameter_class
+        return parameter_class
+
+    def __instancecheck__(cls, instance):
+        type_id = cls._parameter_ids.get(cls.__name__)
+        if not type_id:
+            return False
+
+        # Check if instance has our type ID
+        return getattr(instance.__class__, "_parameter_type_id", None) == type_id
+
+
 @dataclass
-class Parameter(Generic[T], ABC):
+class Parameter(Generic[T], ABC, metaclass=ParameterMeta):
     """
     Base class for all parameter types. Parameters are the building blocks
     for creating interactive GUI elements.
@@ -106,6 +161,7 @@ class Parameter(Generic[T], ABC):
 
     name: str
     value: T
+    _is_action: bool = False
 
     @abstractmethod
     def __init__(self, name: str, value: T):
@@ -229,8 +285,8 @@ class TextParameter(Parameter[str]):
     Parameter for text input.
 
     Creates a text box in the GUI that accepts any string input.
-    See :meth:`~syd.interactive_viewer.InteractiveViewer.add_text` and
-    :meth:`~syd.interactive_viewer.InteractiveViewer.update_text` for usage.
+    See :meth:`~syd.viewer.Viewer.add_text` and
+    :meth:`~syd.viewer.Viewer.update_text` for usage.
 
     Parameters
     ----------
@@ -272,8 +328,8 @@ class BooleanParameter(Parameter[bool]):
     Parameter for boolean values.
 
     Creates a checkbox in the GUI that can be toggled on/off.
-    See :meth:`~syd.interactive_viewer.InteractiveViewer.add_boolean` and
-    :meth:`~syd.interactive_viewer.InteractiveViewer.update_boolean` for usage.
+    See :meth:`~syd.viewer.Viewer.add_boolean` and
+    :meth:`~syd.viewer.Viewer.update_boolean` for usage.
 
     Parameters
     ----------
@@ -315,8 +371,8 @@ class SelectionParameter(Parameter[Any]):
     Parameter for single selection from a list of options.
 
     Creates a dropdown menu in the GUI where users can select one option.
-    See :meth:`~syd.interactive_viewer.InteractiveViewer.add_selection` and
-    :meth:`~syd.interactive_viewer.InteractiveViewer.update_selection` for usage.
+    See :meth:`~syd.viewer.Viewer.add_selection` and
+    :meth:`~syd.viewer.Viewer.update_selection` for usage.
 
     Parameters
     ----------
@@ -324,8 +380,8 @@ class SelectionParameter(Parameter[Any]):
         The name of the parameter
     value : Any
         The initially selected value (must be one of the options)
-    options : list
-        List of valid choices that can be selected
+    options : sequence
+        List, tuple, or 1D numpy array of valid choices that can be selected
 
     Examples
     --------
@@ -336,15 +392,59 @@ class SelectionParameter(Parameter[Any]):
     >>> color.value
     'blue'
     >>> color.update({"value": "yellow"})  # This will raise an error
+    >>> # With numpy array
+    >>> import numpy as np
+    >>> numbers = SelectionParameter("number", 1, options=np.array([1, 2, 3]))
+    >>> numbers.value
+    1
     """
 
     options: List[Any]
 
-    def __init__(self, name: str, value: Any, options: List[Any]):
+    def __init__(self, name: str, value: Any, options: Union[List, Tuple]):
         self.name = name
-        self.options = options
+        self.options = self._validate_options(options)
         self._value = self._validate(value)
 
+    def _validate_options(self, options: Any) -> List[Any]:
+        """
+        Validate options and convert to list if necessary.
+
+        Parameters
+        ----------
+        options : list or tuple
+            The options to validate
+
+        Returns
+        -------
+        list
+            Validated list of options
+
+        Raises
+        ------
+        TypeError
+            If options is not a list or tuple
+        ValueError
+            If any option is not hashable
+        """
+        if not isinstance(options, (list, tuple)):
+            raise TypeError(
+                f"Options for parameter {self.name} must be a list or tuple"
+            )
+
+        if not options:
+            raise ValueError(f"Options for parameter {self.name} must not be empty")
+
+        # Verify all options are hashable (needed for comparison)
+        try:
+            for opt in options:
+                hash(opt)
+        except TypeError as e:
+            raise ValueError(
+                f"All options for parameter {self.name} must be hashable: {str(e)}"
+            )
+        return list(options)
+
     def _validate(self, new_value: Any) -> Any:
         """
         Validate that value is one of the allowed options.
@@ -372,13 +472,14 @@ class SelectionParameter(Parameter[Any]):
         Raises:
             TypeError: If options is not a list or tuple
         """
-        if not isinstance(self.options, (list, tuple)):
-            raise TypeError(
-                f"Options for parameter {self.name} are not a list or tuple: {self.options}"
-            )
+        self.options = self._validate_options(self.options)
         if self.value not in self.options:
             warn(
-                f"Value {self.value} not in options: {self.options}, setting to first option"
+                ParameterUpdateWarning(
+                    self.name,
+                    type(self).__name__,
+                    f"Value {self.value} not in options, setting to first option ({self.options[0]})",
+                )
             )
             self.value = self.options[0]
 
@@ -389,8 +490,8 @@ class MultipleSelectionParameter(Parameter[List[Any]]):
     Parameter for multiple selections from a list of options.
 
     Creates a set of checkboxes or multi-select dropdown in the GUI.
-    See :meth:`~syd.interactive_viewer.InteractiveViewer.add_multiple_selection` and
-    :meth:`~syd.interactive_viewer.InteractiveViewer.update_multiple_selection` for usage.
+    See :meth:`~syd.viewer.Viewer.add_multiple_selection` and
+    :meth:`~syd.viewer.Viewer.update_multiple_selection` for usage.
 
     Parameters
     ----------
@@ -398,8 +499,8 @@ class MultipleSelectionParameter(Parameter[List[Any]]):
         The name of the parameter
     value : list
         List of initially selected values (must all be from options)
-    options : list
-        List of valid choices that can be selected
+    options : sequence
+        List, tuple, or 1D numpy array of valid choices that can be selected
 
     Examples
     --------
@@ -408,18 +509,61 @@ class MultipleSelectionParameter(Parameter[List[Any]]):
     ...     options=["cheese", "mushrooms", "pepperoni", "olives"])
     >>> toppings.value
     ['cheese', 'mushrooms']
-    >>> toppings.update({"value": ["cheese", "pepperoni"]})
-    >>> toppings.value
-    ['cheese', 'pepperoni']
+    >>> # With numpy array
+    >>> import numpy as np
+    >>> numbers = MultipleSelectionParameter("numbers",
+    ...     value=[1, 3],
+    ...     options=np.array([1, 2, 3, 4]))
+    >>> numbers.value
+    [1, 3]
     """
 
     options: List[Any]
 
-    def __init__(self, name: str, value: List[Any], options: List[Any]):
+    def __init__(self, name: str, value: List[Any], options: Union[List, Tuple]):
         self.name = name
-        self.options = options
+        self.options = self._validate_options(options)
         self._value = self._validate(value)
 
+    def _validate_options(self, options: Any) -> List[Any]:
+        """
+        Validate options and convert to list if necessary.
+
+        Parameters
+        ----------
+        options : list or tuple
+            The options to validate
+
+        Returns
+        -------
+        list
+            Validated list of options
+
+        Raises
+        ------
+        TypeError
+            If options is not a list or tuple
+        ValueError
+            If any option is not hashable
+        """
+        if not isinstance(options, (list, tuple)):
+            raise TypeError(
+                f"Options for parameter {self.name} must be a list or tuple, received {type(options)}"
+            )
+
+        if not options:
+            raise ValueError(f"Options for parameter {self.name} must not be empty")
+
+        # Verify all options are hashable (needed for comparison)
+        try:
+            for opt in options:
+                hash(opt)
+        except TypeError as e:
+            raise ValueError(
+                f"All options for parameter {self.name} must be hashable: {str(e)}"
+            )
+        return list(options)
+
     def _validate(self, new_value: Any) -> List[Any]:
         """
         Validate list of selected values against options.
@@ -446,19 +590,24 @@ class MultipleSelectionParameter(Parameter[List[Any]]):
         return [x for x in self.options if x in new_value]
 
     def _validate_update(self) -> None:
-        if not isinstance(self.options, (list, tuple)):
-            raise TypeError(
-                f"Options for parameter {self.name} are not a list or tuple: {self.options}"
-            )
+        self.options = self._validate_options(self.options)
         if not isinstance(self.value, (list, tuple)):
             warn(
-                f"For parameter {self.name}, value {self.value} is not a list or tuple. Setting to empty list."
+                ParameterUpdateWarning(
+                    self.name,
+                    type(self).__name__,
+                    f"For parameter {self.name}, value {self.value} is not a list or tuple. Setting to empty list.",
+                )
             )
             self.value = []
         if not all(val in self.options for val in self.value):
             invalid = [val for val in self.value if val not in self.options]
             warn(
-                f"For parameter {self.name}, value {self.value} contains invalid options: {invalid}. Setting to empty list."
+                ParameterUpdateWarning(
+                    self.name,
+                    type(self).__name__,
+                    f"For parameter {self.name}, value {self.value} contains invalid selections: {invalid}. Setting to empty list.",
+                )
             )
             self.value = []
         # Keep only unique values while preserving order based on self.options
@@ -472,8 +621,8 @@ class IntegerParameter(Parameter[int]):
     Parameter for bounded integer values.
 
     Creates a slider in the GUI for selecting whole numbers between bounds.
-    See :meth:`~syd.interactive_viewer.InteractiveViewer.add_integer` and
-    :meth:`~syd.interactive_viewer.InteractiveViewer.update_integer` for usage.
+    See :meth:`~syd.viewer.Viewer.add_integer` and
+    :meth:`~syd.viewer.Viewer.update_integer` for usage.
 
     Parameters
     ----------
@@ -535,10 +684,22 @@ class IntegerParameter(Parameter[int]):
 
         if compare_to_range:
             if new_value < self.min_value:
-                warn(f"Value {new_value} below minimum {self.min_value}, clamping")
+                warn(
+                    ParameterUpdateWarning(
+                        self.name,
+                        type(self).__name__,
+                        f"Value {new_value} below minimum {self.min_value}, clamping",
+                    )
+                )
                 new_value = self.min_value
             if new_value > self.max_value:
-                warn(f"Value {new_value} above maximum {self.max_value}, clamping")
+                warn(
+                    ParameterUpdateWarning(
+                        self.name,
+                        type(self).__name__,
+                        f"Value {new_value} above maximum {self.max_value}, clamping",
+                    )
+                )
                 new_value = self.max_value
         return int(new_value)
 
@@ -559,7 +720,13 @@ class IntegerParameter(Parameter[int]):
                 "IntegerParameter must have both min_value and max_value bounds",
             )
         if self.min_value > self.max_value:
-            warn(f"Min value greater than max value, swapping")
+            warn(
+                ParameterUpdateWarning(
+                    self.name,
+                    type(self).__name__,
+                    f"Min value greater than max value, swapping",
+                )
+            )
             self.min_value, self.max_value = self.max_value, self.min_value
         self.value = self._validate(self.value)
 
@@ -570,8 +737,8 @@ class FloatParameter(Parameter[float]):
     Parameter for bounded decimal numbers.
 
     Creates a slider in the GUI for selecting numbers between bounds.
-    See :meth:`~syd.interactive_viewer.InteractiveViewer.add_float` and
-    :meth:`~syd.interactive_viewer.InteractiveViewer.update_float` for usage.
+    See :meth:`~syd.viewer.Viewer.add_float` and
+    :meth:`~syd.viewer.Viewer.update_float` for usage.
 
     Parameters
     ----------
@@ -584,7 +751,7 @@ class FloatParameter(Parameter[float]):
     max_value : float
         Maximum allowed value
     step : float, optional
-        Size of each increment (default is 0.1)
+        Size of each increment (default is 0.001)
 
     Examples
     --------
@@ -617,7 +784,7 @@ class FloatParameter(Parameter[float]):
         value: float,
         min_value: float,
         max_value: float,
-        step: float = 0.1,
+        step: float = 0.001,
     ):
         self.name = name
         self.step = step
@@ -651,10 +818,22 @@ class FloatParameter(Parameter[float]):
 
         if compare_to_range:
             if new_value < self.min_value:
-                warn(f"Value {new_value} below minimum {self.min_value}, clamping")
+                warn(
+                    ParameterUpdateWarning(
+                        self.name,
+                        type(self).__name__,
+                        f"Value {new_value} below minimum {self.min_value}, clamping",
+                    )
+                )
                 new_value = self.min_value
             if new_value > self.max_value:
-                warn(f"Value {new_value} above maximum {self.max_value}, clamping")
+                warn(
+                    ParameterUpdateWarning(
+                        self.name,
+                        type(self).__name__,
+                        f"Value {new_value} above maximum {self.max_value}, clamping",
+                    )
+                )
                 new_value = self.max_value
 
         return float(new_value)
@@ -676,7 +855,13 @@ class FloatParameter(Parameter[float]):
                 "FloatParameter must have both min_value and max_value bounds",
             )
         if self.min_value > self.max_value:
-            warn(f"Min value greater than max value, swapping")
+            warn(
+                ParameterUpdateWarning(
+                    self.name,
+                    type(self).__name__,
+                    f"Min value greater than max value, swapping",
+                )
+            )
             self.min_value, self.max_value = self.max_value, self.min_value
         self.value = self._validate(self.value)
 
@@ -687,8 +872,8 @@ class IntegerRangeParameter(Parameter[Tuple[int, int]]):
     Parameter for a range of bounded integer values.
 
     Creates a range slider in the GUI for selecting a range of whole numbers.
-    See :meth:`~syd.interactive_viewer.InteractiveViewer.add_integer_range` and
-    :meth:`~syd.interactive_viewer.InteractiveViewer.update_integer_range` for usage.
+    See :meth:`~syd.viewer.Viewer.add_integer_range` and
+    :meth:`~syd.viewer.Viewer.update_integer_range` for usage.
 
     Parameters
     ----------
@@ -726,11 +911,11 @@ class IntegerRangeParameter(Parameter[Tuple[int, int]]):
         max_value: int,
     ):
         self.name = name
-        self.min_value = self._validate_single(min_value)
-        self.max_value = self._validate_single(max_value)
+        self.min_value = self._validate_single(min_value, context="min_value")
+        self.max_value = self._validate_single(max_value, context="max_value")
         self._value = self._validate(value)
 
-    def _validate_single(self, new_value: Any) -> int:
+    def _validate_single(self, new_value: Any, context: Optional[str] = None) -> int:
         """
         Validate and convert a single numeric value.
 
@@ -748,8 +933,11 @@ class IntegerRangeParameter(Parameter[Tuple[int, int]]):
         """
         try:
             return int(new_value)
-        except ValueError:
-            raise ValueError(f"Value {new_value} cannot be converted to int")
+        except Exception:
+            msg = f"Value {new_value} cannot be converted to int"
+            if context:
+                msg += f" for {context}"
+            raise ValueError(msg)
 
     def _validate(self, new_value: Any) -> Tuple[int, int]:
         """
@@ -772,14 +960,32 @@ class IntegerRangeParameter(Parameter[Tuple[int, int]]):
         high = self._validate_single(new_value[1])
 
         if low > high:
-            warn(f"Low value {low} greater than high value {high}, swapping")
+            warn(
+                ParameterUpdateWarning(
+                    self.name,
+                    type(self).__name__,
+                    f"Low value {low} greater than high value {high}, swapping",
+                )
+            )
             low, high = high, low
 
         if low < self.min_value:
-            warn(f"Low value {low} below minimum {self.min_value}, clamping")
+            warn(
+                ParameterUpdateWarning(
+                    self.name,
+                    type(self).__name__,
+                    f"Low value {low} below minimum {self.min_value}, clamping",
+                )
+            )
             low = self.min_value
         if high > self.max_value:
-            warn(f"High value {high} above maximum {self.max_value}, clamping")
+            warn(
+                ParameterUpdateWarning(
+                    self.name,
+                    type(self).__name__,
+                    f"High value {high} above maximum {self.max_value}, clamping",
+                )
+            )
             high = self.max_value
 
         return (low, high)
@@ -801,7 +1007,13 @@ class IntegerRangeParameter(Parameter[Tuple[int, int]]):
                 "IntegerRangeParameter must have both min_value and max_value bounds",
             )
         if self.min_value > self.max_value:
-            warn(f"Min value greater than max value, swapping")
+            warn(
+                ParameterUpdateWarning(
+                    self.name,
+                    type(self).__name__,
+                    f"Min value greater than max value, swapping",
+                )
+            )
             self.min_value, self.max_value = self.max_value, self.min_value
         self.value = self._validate(self.value)
 
@@ -812,8 +1024,8 @@ class FloatRangeParameter(Parameter[Tuple[float, float]]):
     Parameter for a range of bounded decimal numbers.
 
     Creates a range slider in the GUI for selecting a range of numbers.
-    See :meth:`~syd.interactive_viewer.InteractiveViewer.add_float_range` and
-    :meth:`~syd.interactive_viewer.InteractiveViewer.update_float_range` for usage.
+    See :meth:`~syd.viewer.Viewer.add_float_range` and
+    :meth:`~syd.viewer.Viewer.update_float_range` for usage.
 
     Parameters
     ----------
@@ -826,7 +1038,7 @@ class FloatRangeParameter(Parameter[Tuple[float, float]]):
     max_value : float
         Maximum allowed value for both low and high
     step : float, optional
-        Size of each increment (default is 0.1)
+        Size of each increment (default is 0.001)
 
     Examples
     --------
@@ -859,15 +1071,15 @@ class FloatRangeParameter(Parameter[Tuple[float, float]]):
         value: Tuple[float, float],
         min_value: float,
         max_value: float,
-        step: float = 0.1,
+        step: float = 0.001,
     ):
         self.name = name
         self.step = step
-        self.min_value = self._validate_single(min_value)
-        self.max_value = self._validate_single(max_value)
+        self.min_value = self._validate_single(min_value, context="min_value")
+        self.max_value = self._validate_single(max_value, context="max_value")
         self._value = self._validate(value)
 
-    def _validate_single(self, new_value: Any) -> float:
+    def _validate_single(self, new_value: Any, context: Optional[str] = None) -> float:
         """
         Validate and convert a single numeric value.
 
@@ -885,8 +1097,11 @@ class FloatRangeParameter(Parameter[Tuple[float, float]]):
         """
         try:
             new_value = float(new_value)
-        except ValueError:
-            raise ValueError(f"Value {new_value} cannot be converted to float")
+        except Exception:
+            msg = f"Value {new_value} cannot be converted to float"
+            if context:
+                msg += f" for {context}"
+            raise ValueError(msg)
 
         # Round to the nearest step
         new_value = round(new_value / self.step) * self.step
@@ -913,14 +1128,32 @@ class FloatRangeParameter(Parameter[Tuple[float, float]]):
         high = self._validate_single(new_value[1])
 
         if low > high:
-            warn(f"Low value {low} greater than high value {high}, swapping")
+            warn(
+                ParameterUpdateWarning(
+                    self.name,
+                    type(self).__name__,
+                    f"Low value {low} greater than high value {high}, swapping",
+                )
+            )
             low, high = high, low
 
         if low < self.min_value:
-            warn(f"Low value {low} below minimum {self.min_value}, clamping")
+            warn(
+                ParameterUpdateWarning(
+                    self.name,
+                    type(self).__name__,
+                    f"Low value {low} below minimum {self.min_value}, clamping",
+                )
+            )
             low = self.min_value
         if high > self.max_value:
-            warn(f"High value {high} above maximum {self.max_value}, clamping")
+            warn(
+                ParameterUpdateWarning(
+                    self.name,
+                    type(self).__name__,
+                    f"High value {high} above maximum {self.max_value}, clamping",
+                )
+            )
             high = self.max_value
 
         return (low, high)
@@ -942,7 +1175,13 @@ class FloatRangeParameter(Parameter[Tuple[float, float]]):
                 "FloatRangeParameter must have both min_value and max_value bounds",
             )
         if self.min_value > self.max_value:
-            warn(f"Min value greater than max value, swapping")
+            warn(
+                ParameterUpdateWarning(
+                    self.name,
+                    type(self).__name__,
+                    f"Min value greater than max value, swapping",
+                )
+            )
             self.min_value, self.max_value = self.max_value, self.min_value
         self.value = self._validate(self.value)
 
@@ -953,8 +1192,8 @@ class UnboundedIntegerParameter(Parameter[int]):
     Parameter for optionally bounded integer values.
 
     Creates a text input box in the GUI for entering whole numbers.
-    See :meth:`~syd.interactive_viewer.InteractiveViewer.add_unbounded_integer` and
-    :meth:`~syd.interactive_viewer.InteractiveViewer.update_unbounded_integer` for usage.
+    See :meth:`~syd.viewer.Viewer.add_unbounded_integer` and
+    :meth:`~syd.viewer.Viewer.update_unbounded_integer` for usage.
 
     Parameters
     ----------
@@ -962,19 +1201,12 @@ class UnboundedIntegerParameter(Parameter[int]):
         The name of the parameter
     value : int
         Initial value
-    min_value : int, optional
-        Minimum allowed value (or None for no minimum)
-    max_value : int, optional
-        Maximum allowed value (or None for no maximum)
 
     Examples
     --------
-    >>> count = UnboundedIntegerParameter("count", value=10, min_value=0)
+    >>> count = UnboundedIntegerParameter("count", value=10)
     >>> count.value
     10
-    >>> count.update({"value": -5})  # Will be clamped to min_value
-    >>> count.value
-    0
     >>> count.update({"value": 1000000})  # No maximum, so this is allowed
     >>> count.value
     1000000
@@ -982,43 +1214,24 @@ class UnboundedIntegerParameter(Parameter[int]):
     Notes
     -----
     Use this instead of IntegerParameter when you:
-    - Don't know a reasonable maximum value
-    - Only want to enforce a minimum or maximum, but not both
+    - Don't have any reason to bound the value
     - Need to allow very large numbers that would be impractical with a slider
     """
 
-    min_value: Optional[int]
-    max_value: Optional[int]
-
     def __init__(
         self,
         name: str,
         value: int,
-        min_value: Optional[int] = None,
-        max_value: Optional[int] = None,
     ):
         self.name = name
-        self.min_value = (
-            self._validate(min_value, compare_to_range=False)
-            if min_value is not None
-            else None
-        )
-        self.max_value = (
-            self._validate(max_value, compare_to_range=False)
-            if max_value is not None
-            else None
-        )
         self._value = self._validate(value)
 
-    def _validate(self, new_value: Any, compare_to_range: bool = True) -> int:
+    def _validate(self, new_value: Any) -> int:
         """
-        Validate and convert value to integer, optionally checking bounds.
-
-        Handles None min/max values by skipping those bound checks.
+        Validate and convert value to integer.
 
         Args:
             new_value: Value to validate
-            compare_to_range: If True, clamps value to any defined min/max bounds
 
         Returns:
             Validated integer value
@@ -1031,32 +1244,15 @@ class UnboundedIntegerParameter(Parameter[int]):
         except ValueError:
             raise ValueError(f"Value {new_value} cannot be converted to int")
 
-        if compare_to_range:
-            if self.min_value is not None and new_value < self.min_value:
-                warn(f"Value {new_value} below minimum {self.min_value}, clamping")
-                new_value = self.min_value
-            if self.max_value is not None and new_value > self.max_value:
-                warn(f"Value {new_value} above maximum {self.max_value}, clamping")
-                new_value = self.max_value
         return int(new_value)
 
     def _validate_update(self) -> None:
         """
         Validate complete parameter state after updates.
 
-        Ensures min_value <= max_value, swapping if needed.
-        Re-validates current value against potentially updated bounds.
-
         Raises:
             ParameterUpdateError: If bounds are invalid (e.g. None when required)
         """
-        if (
-            self.min_value is not None
-            and self.max_value is not None
-            and self.min_value > self.max_value
-        ):
-            warn(f"Min value greater than max value, swapping")
-            self.min_value, self.max_value = self.max_value, self.min_value
         self.value = self._validate(self.value)
 
 
@@ -1066,8 +1262,8 @@ class UnboundedFloatParameter(Parameter[float]):
     Parameter for optionally bounded decimal numbers.
 
     Creates a text input box in the GUI for entering numbers.
-    See :meth:`~syd.interactive_viewer.InteractiveViewer.add_unbounded_float` and
-    :meth:`~syd.interactive_viewer.InteractiveViewer.update_unbounded_float` for usage.
+    See :meth:`~syd.viewer.Viewer.add_unbounded_float` and
+    :meth:`~syd.viewer.Viewer.update_unbounded_float` for usage.
 
     Parameters
     ----------
@@ -1075,21 +1271,14 @@ class UnboundedFloatParameter(Parameter[float]):
         The name of the parameter
     value : float
         Initial value
-    min_value : float, optional
-        Minimum allowed value (or None for no minimum)
-    max_value : float, optional
-        Maximum allowed value (or None for no maximum)
     step : float, optional
         Size of each increment (default is None, meaning no rounding)
 
     Examples
     --------
-    >>> price = UnboundedFloatParameter("price", value=19.99, min_value=0.0, step=0.01)
+    >>> price = UnboundedFloatParameter("price", value=19.99)
     >>> price.value
     19.99
-    >>> price.update({"value": -5.0})  # Will be clamped to min_value
-    >>> price.value
-    0.0
     >>> price.update({"value": 19.987})  # Will be rounded to step
     >>> price.value
     19.99
@@ -1098,7 +1287,6 @@ class UnboundedFloatParameter(Parameter[float]):
     -----
     Use this instead of FloatParameter when you:
     - Don't know a reasonable maximum value
-    - Only want to enforce a minimum or maximum, but not both
     - Need to allow very large or precise numbers that would be impractical with a slider
 
     If step is provided, values will be rounded:
@@ -1107,42 +1295,25 @@ class UnboundedFloatParameter(Parameter[float]):
     - step=5.0 rounds to 0.0, 5.0, 10.0, etc.
     """
 
-    min_value: Optional[float]
-    max_value: Optional[float]
-    step: float
+    step: Optional[float]
 
     def __init__(
         self,
         name: str,
         value: float,
-        min_value: Optional[float] = None,
-        max_value: Optional[float] = None,
         step: Optional[float] = None,
     ):
         self.name = name
         self.step = step
-        self.min_value = (
-            self._validate(min_value, compare_to_range=False)
-            if min_value is not None
-            else None
-        )
-        self.max_value = (
-            self._validate(max_value, compare_to_range=False)
-            if max_value is not None
-            else None
-        )
         self._value = self._validate(value)
 
-    def _validate(self, new_value: Any, compare_to_range: bool = True) -> float:
+    def _validate(self, new_value: Any) -> float:
         """
-        Validate and convert value to float, optionally checking bounds.
-
-        Handles None min/max values by skipping those bound checks.
+        Validate and convert value to float.
         Only rounds to step if step is not None.
 
         Args:
             new_value: Value to validate
-            compare_to_range: If True, clamps value to any defined min/max bounds
 
         Returns:
             Validated and potentially rounded float value
@@ -1159,14 +1330,6 @@ class UnboundedFloatParameter(Parameter[float]):
         if self.step is not None:
             new_value = round(new_value / self.step) * self.step
 
-        if compare_to_range:
-            if self.min_value is not None and new_value < self.min_value:
-                warn(f"Value {new_value} below minimum {self.min_value}, clamping")
-                new_value = self.min_value
-            if self.max_value is not None and new_value > self.max_value:
-                warn(f"Value {new_value} above maximum {self.max_value}, clamping")
-                new_value = self.max_value
-
         return float(new_value)
 
     def _validate_update(self) -> None:
@@ -1179,24 +1342,58 @@ class UnboundedFloatParameter(Parameter[float]):
         Raises:
             ParameterUpdateError: If bounds are invalid (e.g. None when required)
         """
-        if (
-            self.min_value is not None
-            and self.max_value is not None
-            and self.min_value > self.max_value
-        ):
-            warn(f"Min value greater than max value, swapping")
-            self.min_value, self.max_value = self.max_value, self.min_value
         self.value = self._validate(self.value)
 
 
-class ButtonParameter(Parameter):
-    """A parameter that represents a clickable button."""
+@dataclass(init=False)
+class ButtonAction(Parameter[None]):
+    """
+    Parameter for creating clickable buttons with callbacks.
+
+    Creates a button in the GUI that executes a callback function when clicked.
+    See :meth:`~syd.viewer.Viewer.add_button` and
+    :meth:`~syd.viewer.Viewer.update_button` for usage.
+
+    Parameters
+    ----------
+    name : str
+        The name of the parameter
+    label : str
+        Text to display on the button
+    callback : callable
+        Function to execute when the button is clicked
+
+    Examples
+    --------
+    >>> def print_hello():
+    ...     print("Hello!")
+    >>> button = ButtonAction("greeting", label="Say Hello", callback=print_hello)
+    >>> button.callback()  # Simulates clicking the button
+    Hello!
+    >>> # Update the button's label and callback
+    >>> def print_goodbye():
+    ...     print("Goodbye!")
+    >>> button.update({"label": "Say Goodbye", "callback": print_goodbye})
+    >>> button.callback()
+    Goodbye!
+
+    Notes
+    -----
+    Unlike other Parameter types, ButtonAction:
+    - Has no value (always None)
+    - Is marked as an action (_is_action = True)
+    - Executes code directly rather than storing state
+    - Cannot be updated through the value property
+    """
 
-    _is_button: bool = True
+    label: str
+    callback: Callable
+    value: None = field(default=None, repr=False)
+    _is_action: bool = field(default=True, repr=False)
 
-    def __init__(self, name: str, label: str, callback: Callable[[], None]):
+    def __init__(self, name: str, label: str, callback: Callable):
         """
-        Initialize a button parameter.
+        Initialize a button.
 
         Args:
             name: Internal name of the parameter
@@ -1206,32 +1403,28 @@ class ButtonParameter(Parameter):
         self.name = name
         self.label = label
         self.callback = callback
-        self._value = None  # Buttons don't have a value in the traditional sense
-
-    def update(self, updates: Dict[str, Any]) -> None:
-        """Update the button's label and/or callback."""
-        if "label" in updates:
-            self.label = updates["label"]
-        if "callback" in updates:
-            self.callback = updates["callback"]
+        self._value = None
 
-    @property
-    def value(self) -> None:
-        """Buttons don't have a value, always returns None."""
-        return self._value
-
-    @value.setter
-    def value(self, _: Any) -> None:
-        """Buttons don't store values."""
-        pass
+    def _validate(self, new_value: Any) -> None:
+        """Validate the button's value."""
+        return None
 
     def _validate_update(self) -> None:
-        """Buttons don't need validation."""
-        pass
-
-    def _validate(self, new_value: Any) -> None:
-        """Buttons don't need validation."""
-        pass
+        """Validate the button's value after updates."""
+        if not callable(self.callback):
+            raise ParameterUpdateError(
+                self.name,
+                type(self).__name__,
+                f"Callback {self.callback} is not callable",
+            )
+        try:
+            str(self.label)
+        except Exception:
+            raise ParameterUpdateError(
+                self.name,
+                type(self).__name__,
+                f"Label {self.label} doesn't have a string representation",
+            )
 
 
 class ParameterType(Enum):
@@ -1247,4 +1440,7 @@ class ParameterType(Enum):
     float_range = FloatRangeParameter
     unbounded_integer = UnboundedIntegerParameter
     unbounded_float = UnboundedFloatParameter
-    button = ButtonParameter
+
+
+class ActionType(Enum):
+    button = ButtonAction