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

syd/parameters.py

@@ -1,124 +1,23 @@
-from typing import (
-    List,
-    Any,
-    Tuple,
-    Generic,
-    TypeVar,
-    Optional,
-    Dict,
-    Callable,
-    Union,
-    Sequence,
-)
+from typing import List, Any, Tuple, Generic, TypeVar, Optional, Dict, Callable, Union
 from dataclasses import dataclass, field
 from abc import ABC, abstractmethod
 from enum import Enum
 from copy import deepcopy
 from warnings import warn
-import numpy as np
-
-T = TypeVar("T")
-
-
-# Keep original Parameter class and exceptions unchanged
-class ParameterAddError(Exception):
-    """
-    Exception raised when there is an error creating a new parameter.
-
-    Parameters
-    ----------
-    parameter_name : str
-        Name of the parameter that failed to be created
-    parameter_type : str
-        Type of the parameter that failed to be created
-    message : str, optional
-        Additional error 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"Failed to create {parameter_type} parameter '{parameter_name}'"
-            + (f": {message}" if message else "")
-        )
-
-
-class ParameterUpdateError(Exception):
-    """
-    Exception raised when there is an error updating an existing parameter.
-
-    Parameters
-    ----------
-    parameter_name : str
-        Name of the parameter that failed to update
-    parameter_type : str
-        Type of the parameter that failed to update
-    message : str, optional
-        Additional error 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"Failed to update {parameter_type} parameter '{parameter_name}'"
-            + (f": {message}" if message else "")
-        )
-
-
-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.
-
-    Parameters
-    ----------
-    param_class : class
-        The parameter class to inspect
 
-    Returns
-    -------
-    list of str
-        Names of all valid attributes for the parameter class
-    """
-    attributes = []
-
-    # Walk through class hierarchy in reverse (most specific to most general)
-    for cls in reversed(param_class.__mro__):
-        if hasattr(cls, "__annotations__"):
-            # Only add annotations that haven't been specified by a more specific class
-            for name in cls.__annotations__:
-                if not name.startswith("_"):
-                    attributes.append(name)
+from .support import (
+    NoInitialValue,
+    ParameterMeta,
+    ParameterUpdateError,
+    ParameterUpdateWarning,
+    get_parameter_attributes,
+)
 
-    return attributes
+T = TypeVar("T")
 
 
 @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.
@@ -196,8 +95,8 @@ class Parameter(Generic[T], ABC):
 
         Examples
         --------
-        >>> param = FloatParameter("temperature", 20.0, min_value=0, max_value=100)
-        >>> param.update({"value": 25.0, "max_value": 150})
+        >>> param = FloatParameter("temperature", 20.0, min=0, max=100)
+        >>> param.update({"value": 25.0, "max": 150})
         """
         param_copy = deepcopy(self)
 
@@ -265,14 +164,14 @@ 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
     ----------
     name : str
         The name of the parameter
-    value : str
+    value : Union[str, NoInitialValue]
         The initial text value
 
     Examples
@@ -285,8 +184,10 @@ class TextParameter(Parameter[str]):
     'Bob'
     """
 
-    def __init__(self, name: str, value: str):
+    def __init__(self, name: str, value: Union[str, NoInitialValue]):
         self.name = name
+        if isinstance(value, NoInitialValue):
+            value = ""
         self._value = self._validate(value)
 
     def _validate(self, new_value: Any) -> str:
@@ -308,14 +209,14 @@ 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
     ----------
     name : str
         The name of the parameter
-    value : bool, optional
+    value : Union[bool, NoInitialValue]
         The initial state (default is True)
 
     Examples
@@ -328,8 +229,10 @@ class BooleanParameter(Parameter[bool]):
     False
     """
 
-    def __init__(self, name: str, value: bool = True):
+    def __init__(self, name: str, value: Union[bool, NoInitialValue]):
         self.name = name
+        if isinstance(value, NoInitialValue):
+            value = True
         self._value = self._validate(value)
 
     def _validate(self, new_value: Any) -> bool:
@@ -351,14 +254,14 @@ 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
     ----------
     name : str
         The name of the parameter
-    value : Any
+    value : Union[Any, NoInitialValue]
         The initially selected value (must be one of the options)
     options : sequence
         List, tuple, or 1D numpy array of valid choices that can be selected
@@ -381,9 +284,13 @@ class SelectionParameter(Parameter[Any]):
 
     options: List[Any]
 
-    def __init__(self, name: str, value: Any, options: Union[List, Tuple]):
+    def __init__(
+        self, name: str, value: Union[Any, NoInitialValue], options: Union[List, Tuple]
+    ):
         self.name = name
         self.options = self._validate_options(options)
+        if isinstance(value, NoInitialValue):
+            value = self.options[0]
         self._value = self._validate(value)
 
     def _validate_options(self, options: Any) -> List[Any]:
@@ -412,6 +319,9 @@ class SelectionParameter(Parameter[Any]):
                 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:
@@ -435,9 +345,42 @@ class SelectionParameter(Parameter[Any]):
         Raises:
             ValueError: If value is not in options list
         """
-        if new_value not in self.options:
-            raise ValueError(f"Value {new_value} not in options: {self.options}")
-        return new_value
+        # Direct check for non-float values or when new_value is exactly in options
+        if new_value in self.options:
+            return new_value
+
+        # Special handling for numeric values to account for type mismatches
+        if isinstance(new_value, (int, float)):
+            for option in self.options:
+                # For numeric options, compare as floats
+                if (
+                    isinstance(option, (int, float))
+                    and abs(float(new_value) - float(option)) < 1e-10
+                ):
+                    return option
+                # Also try string conversion for numeric strings
+                elif isinstance(option, str):
+                    try:
+                        if abs(float(new_value) - float(option)) < 1e-10:
+                            return option
+                    except ValueError:
+                        pass
+
+        # Handle string conversion - when new_value is a string but options might be numeric
+        if isinstance(new_value, str):
+            try:
+                # Try to convert to float if possible
+                float_value = float(new_value)
+                for option in self.options:
+                    if (
+                        isinstance(option, (int, float))
+                        and abs(float_value - float(option)) < 1e-10
+                    ):
+                        return option
+            except ValueError:
+                pass
+
+        raise ValueError(f"Value {new_value} not in options: {self.options}")
 
     def _validate_update(self) -> None:
         """
@@ -450,12 +393,51 @@ class SelectionParameter(Parameter[Any]):
             TypeError: If options is not a list or tuple
         """
         self.options = self._validate_options(self.options)
-        if self.value not in self.options:
+
+        # Check if value is directly in options
+        if self.value in self.options:
+            return
+
+        # For numeric values, try flexible comparison
+        value_found = False
+        if isinstance(self.value, (int, float)):
+            for option in self.options:
+                if (
+                    isinstance(option, (int, float))
+                    and abs(float(self.value) - float(option)) < 1e-10
+                ):
+                    # Don't update self.value here as we want to keep the original type if possible
+                    value_found = True
+                    break
+                elif isinstance(option, str):
+                    try:
+                        if abs(float(self.value) - float(option)) < 1e-10:
+                            value_found = True
+                            break
+                    except ValueError:
+                        pass
+
+        # For string values that might be numeric
+        if not value_found and isinstance(self.value, str):
+            try:
+                float_value = float(self.value)
+                for option in self.options:
+                    if (
+                        isinstance(option, (int, float))
+                        and abs(float_value - float(option)) < 1e-10
+                    ):
+                        value_found = True
+                        break
+            except ValueError:
+                pass
+
+        # If value is not found after all checks, reset to first option
+        if not value_found:
             warn(
                 ParameterUpdateWarning(
                     self.name,
                     type(self).__name__,
-                    f"Value {self.value} not in options: {self.options}, setting to first option",
+                    f"Value {self.value} not in options, setting to first option ({self.options[0]})",
                 )
             )
             self.value = self.options[0]
@@ -467,15 +449,15 @@ 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
     ----------
     name : str
         The name of the parameter
-    value : list
-        List of initially selected values (must all be from options)
+    value : Union[List[Any], NoInitialValue]
+        List of initially selected values (must all be from options, can be empty)
     options : sequence
         List, tuple, or 1D numpy array of valid choices that can be selected
 
@@ -497,9 +479,16 @@ class MultipleSelectionParameter(Parameter[List[Any]]):
 
     options: List[Any]
 
-    def __init__(self, name: str, value: List[Any], options: Union[List, Tuple]):
+    def __init__(
+        self,
+        name: str,
+        value: Union[List[Any], NoInitialValue],
+        options: Union[List, Tuple],
+    ):
         self.name = name
         self.options = self._validate_options(options)
+        if isinstance(value, NoInitialValue):
+            value = []
         self._value = self._validate(value)
 
     def _validate_options(self, options: Any) -> List[Any]:
@@ -525,9 +514,12 @@ class MultipleSelectionParameter(Parameter[List[Any]]):
         """
         if not isinstance(options, (list, tuple)):
             raise TypeError(
-                f"Options for parameter {self.name} must be a list or tuple"
+                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:
@@ -580,7 +572,7 @@ class MultipleSelectionParameter(Parameter[List[Any]]):
                 ParameterUpdateWarning(
                     self.name,
                     type(self).__name__,
-                    f"For parameter {self.name}, value {self.value} contains invalid options: {invalid}. Setting to empty list.",
+                    f"For parameter {self.name}, value {self.value} contains invalid selections: {invalid}. Setting to empty list.",
                 )
             )
             self.value = []
@@ -595,46 +587,48 @@ 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
     ----------
     name : str
         The name of the parameter
-    value : int
-        Initial value (will be clamped to fit between min_value and max_value)
-    min_value : int
+    value : Union[int, NoInitialValue]
+        Initial value (will be clamped to fit between min and max)
+    min : int
         Minimum allowed value
-    max_value : int
+    max : int
         Maximum allowed value
 
     Examples
     --------
-    >>> age = IntegerParameter("age", value=25, min_value=0, max_value=120)
+    >>> age = IntegerParameter("age", value=25, min=0, max=120)
     >>> age.value
     25
-    >>> age.update({"value": 150})  # Will be clamped to max_value
+    >>> age.update({"value": 150})  # Will be clamped to max
     >>> age.value
     120
-    >>> age.update({"value": -10})  # Will be clamped to min_value
+    >>> age.update({"value": -10})  # Will be clamped to min
     >>> age.value
     0
     """
 
-    min_value: int
-    max_value: int
+    min: int
+    max: int
 
     def __init__(
         self,
         name: str,
-        value: int,
-        min_value: int,
-        max_value: int,
+        value: Union[int, NoInitialValue],
+        min: int,
+        max: int,
     ):
         self.name = name
-        self.min_value = self._validate(min_value, compare_to_range=False)
-        self.max_value = self._validate(max_value, compare_to_range=False)
+        self.min = self._validate(min, compare_to_range=False)
+        self.max = self._validate(max, compare_to_range=False)
+        if isinstance(value, NoInitialValue):
+            value = self.min
         self._value = self._validate(value)
 
     def _validate(self, new_value: Any, compare_to_range: bool = True) -> int:
@@ -657,43 +651,43 @@ class IntegerParameter(Parameter[int]):
             raise ValueError(f"Value {new_value} cannot be converted to int")
 
         if compare_to_range:
-            if new_value < self.min_value:
+            if new_value < self.min:
                 warn(
                     ParameterUpdateWarning(
                         self.name,
                         type(self).__name__,
-                        f"Value {new_value} below minimum {self.min_value}, clamping",
+                        f"Value {new_value} below minimum {self.min}, clamping",
                     )
                 )
-                new_value = self.min_value
-            if new_value > self.max_value:
+                new_value = self.min
+            if new_value > self.max:
                 warn(
                     ParameterUpdateWarning(
                         self.name,
                         type(self).__name__,
-                        f"Value {new_value} above maximum {self.max_value}, clamping",
+                        f"Value {new_value} above maximum {self.max}, clamping",
                     )
                 )
-                new_value = self.max_value
+                new_value = self.max
         return int(new_value)
 
     def _validate_update(self) -> None:
         """
         Validate complete parameter state after updates.
 
-        Ensures min_value <= max_value, swapping if needed.
+        Ensures min <= max, 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 None or self.max_value is None:
+        if self.min is None or self.max is None:
             raise ParameterUpdateError(
                 self.name,
                 type(self).__name__,
-                "IntegerParameter must have both min_value and max_value bounds",
+                "IntegerParameter must have both min and max bounds",
             )
-        if self.min_value > self.max_value:
+        if self.min > self.max:
             warn(
                 ParameterUpdateWarning(
                     self.name,
@@ -701,7 +695,7 @@ class IntegerParameter(Parameter[int]):
                     f"Min value greater than max value, swapping",
                 )
             )
-            self.min_value, self.max_value = self.max_value, self.min_value
+            self.min, self.max = self.max, self.min
         self.value = self._validate(self.value)
 
 
@@ -711,32 +705,32 @@ 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
     ----------
     name : str
         The name of the parameter
-    value : float
-        Initial value (will be clamped to fit between min_value and max_value)
-    min_value : float
+    value : Union[float, NoInitialValue]
+        Initial value (will be clamped to fit between min and max)
+    min : float
         Minimum allowed value
-    max_value : float
+    max : float
         Maximum allowed value
     step : float, optional
-        Size of each increment (default is 0.1)
+        Size of each increment (default is 0.001)
 
     Examples
     --------
     >>> temp = FloatParameter("temperature", value=98.6,
-    ...     min_value=95.0, max_value=105.0, step=0.1)
+    ...     min=95.0, max=105.0, step=0.1)
     >>> temp.value
     98.6
     >>> temp.update({"value": 98.67})  # Will be rounded to nearest step
     >>> temp.value
     98.7
-    >>> temp.update({"value": 110.0})  # Will be clamped to max_value
+    >>> temp.update({"value": 110.0})  # Will be clamped to max
     >>> temp.value
     105.0
 
@@ -748,22 +742,24 @@ class FloatParameter(Parameter[float]):
     - step=5.0 allows values like 0.0, 5.0, 10.0, etc.
     """
 
-    min_value: float
-    max_value: float
+    min: float
+    max: float
     step: float
 
     def __init__(
         self,
         name: str,
-        value: float,
-        min_value: float,
-        max_value: float,
-        step: float = 0.1,
+        value: Union[float, NoInitialValue],
+        min: float,
+        max: float,
+        step: float = 0.001,
     ):
         self.name = name
         self.step = step
-        self.min_value = self._validate(min_value, compare_to_range=False)
-        self.max_value = self._validate(max_value, compare_to_range=False)
+        self.min = self._validate(min, compare_to_range=False)
+        self.max = self._validate(max, compare_to_range=False)
+        if isinstance(value, NoInitialValue):
+            value = self.min
         self._value = self._validate(value)
 
     def _validate(self, new_value: Any, compare_to_range: bool = True) -> float:
@@ -791,24 +787,24 @@ class FloatParameter(Parameter[float]):
         new_value = round(new_value / self.step) * self.step
 
         if compare_to_range:
-            if new_value < self.min_value:
+            if new_value < self.min:
                 warn(
                     ParameterUpdateWarning(
                         self.name,
                         type(self).__name__,
-                        f"Value {new_value} below minimum {self.min_value}, clamping",
+                        f"Value {new_value} below minimum {self.min}, clamping",
                     )
                 )
-                new_value = self.min_value
-            if new_value > self.max_value:
+                new_value = self.min
+            if new_value > self.max:
                 warn(
                     ParameterUpdateWarning(
                         self.name,
                         type(self).__name__,
-                        f"Value {new_value} above maximum {self.max_value}, clamping",
+                        f"Value {new_value} above maximum {self.max}, clamping",
                     )
                 )
-                new_value = self.max_value
+                new_value = self.max
 
         return float(new_value)
 
@@ -816,19 +812,19 @@ class FloatParameter(Parameter[float]):
         """
         Validate complete parameter state after updates.
 
-        Ensures min_value <= max_value, swapping if needed.
+        Ensures min <= max, 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 None or self.max_value is None:
+        if self.min is None or self.max is None:
             raise ParameterUpdateError(
                 self.name,
                 type(self).__name__,
-                "FloatParameter must have both min_value and max_value bounds",
+                "FloatParameter must have both min and max bounds",
             )
-        if self.min_value > self.max_value:
+        if self.min > self.max:
             warn(
                 ParameterUpdateWarning(
                     self.name,
@@ -836,7 +832,7 @@ class FloatParameter(Parameter[float]):
                     f"Min value greater than max value, swapping",
                 )
             )
-            self.min_value, self.max_value = self.max_value, self.min_value
+            self.min, self.max = self.max, self.min
         self.value = self._validate(self.value)
 
 
@@ -846,24 +842,24 @@ 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
     ----------
     name : str
         The name of the parameter
-    value : tuple[int, int]
+    value : Union[Tuple[int, int], NoInitialValue]
         Initial (low, high) values
-    min_value : int
+    min : int
         Minimum allowed value for both low and high
-    max_value : int
+    max : int
         Maximum allowed value for both low and high
 
     Examples
     --------
     >>> age_range = IntegerRangeParameter("age_range",
-    ...     value=(25, 35), min_value=18, max_value=100)
+    ...     value=(25, 35), min=18, max=100)
     >>> age_range.value
     (25, 35)
     >>> age_range.update({"value": (35, 25)})  # Values will be swapped
@@ -874,22 +870,24 @@ class IntegerRangeParameter(Parameter[Tuple[int, int]]):
     (18, 40)
     """
 
-    min_value: int
-    max_value: int
+    min: int
+    max: int
 
     def __init__(
         self,
         name: str,
-        value: Tuple[int, int],
-        min_value: int,
-        max_value: int,
+        value: Union[Tuple[int, int], NoInitialValue],
+        min: int,
+        max: int,
     ):
         self.name = name
-        self.min_value = self._validate_single(min_value)
-        self.max_value = self._validate_single(max_value)
+        self.min = self._validate_single(min, context="min")
+        self.max = self._validate_single(max, context="max")
+        if isinstance(value, NoInitialValue):
+            value = (self.min, self.max)
         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.
 
@@ -907,8 +905,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]:
         """
@@ -940,24 +941,24 @@ class IntegerRangeParameter(Parameter[Tuple[int, int]]):
             )
             low, high = high, low
 
-        if low < self.min_value:
+        if low < self.min:
             warn(
                 ParameterUpdateWarning(
                     self.name,
                     type(self).__name__,
-                    f"Low value {low} below minimum {self.min_value}, clamping",
+                    f"Low value {low} below minimum {self.min}, clamping",
                 )
             )
-            low = self.min_value
-        if high > self.max_value:
+            low = self.min
+        if high > self.max:
             warn(
                 ParameterUpdateWarning(
                     self.name,
                     type(self).__name__,
-                    f"High value {high} above maximum {self.max_value}, clamping",
+                    f"High value {high} above maximum {self.max}, clamping",
                 )
             )
-            high = self.max_value
+            high = self.max
 
         return (low, high)
 
@@ -965,19 +966,19 @@ class IntegerRangeParameter(Parameter[Tuple[int, int]]):
         """
         Validate complete parameter state after updates.
 
-        Ensures min_value <= max_value, swapping if needed.
+        Ensures min <= max, 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 None or self.max_value is None:
+        if self.min is None or self.max is None:
             raise ParameterUpdateError(
                 self.name,
                 type(self).__name__,
-                "IntegerRangeParameter must have both min_value and max_value bounds",
+                "IntegerRangeParameter must have both min and max bounds",
             )
-        if self.min_value > self.max_value:
+        if self.min > self.max:
             warn(
                 ParameterUpdateWarning(
                     self.name,
@@ -985,7 +986,7 @@ class IntegerRangeParameter(Parameter[Tuple[int, int]]):
                     f"Min value greater than max value, swapping",
                 )
             )
-            self.min_value, self.max_value = self.max_value, self.min_value
+            self.min, self.max = self.max, self.min
         self.value = self._validate(self.value)
 
 
@@ -995,26 +996,26 @@ 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
     ----------
     name : str
         The name of the parameter
-    value : tuple[float, float]
+    value : Union[Tuple[float, float], NoInitialValue]
         Initial (low, high) values
-    min_value : float
+    min : float
         Minimum allowed value for both low and high
-    max_value : float
+    max : 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
     --------
     >>> temp_range = FloatRangeParameter("temperature_range",
-    ...     value=(98.6, 100.4), min_value=95.0, max_value=105.0, step=0.1)
+    ...     value=(98.6, 100.4), min=95.0, max=105.0, step=0.1)
     >>> temp_range.value
     (98.6, 100.4)
     >>> temp_range.update({"value": (98.67, 100.0)})  # Low will be rounded
@@ -1032,25 +1033,27 @@ class FloatRangeParameter(Parameter[Tuple[float, float]]):
     - step=5.0 allows values like 0.0, 5.0, 10.0, etc.
     """
 
-    min_value: float
-    max_value: float
+    min: float
+    max: float
     step: float
 
     def __init__(
         self,
         name: str,
-        value: Tuple[float, float],
-        min_value: float,
-        max_value: float,
-        step: float = 0.1,
+        value: Union[Tuple[float, float], NoInitialValue],
+        min: float,
+        max: float,
+        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 = self._validate_single(min, context="min")
+        self.max = self._validate_single(max, context="max")
+        if isinstance(value, NoInitialValue):
+            value = (self.min, self.max)
         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.
 
@@ -1068,8 +1071,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
@@ -1105,24 +1111,24 @@ class FloatRangeParameter(Parameter[Tuple[float, float]]):
             )
             low, high = high, low
 
-        if low < self.min_value:
+        if low < self.min:
             warn(
                 ParameterUpdateWarning(
                     self.name,
                     type(self).__name__,
-                    f"Low value {low} below minimum {self.min_value}, clamping",
+                    f"Low value {low} below minimum {self.min}, clamping",
                 )
             )
-            low = self.min_value
-        if high > self.max_value:
+            low = self.min
+        if high > self.max:
             warn(
                 ParameterUpdateWarning(
                     self.name,
                     type(self).__name__,
-                    f"High value {high} above maximum {self.max_value}, clamping",
+                    f"High value {high} above maximum {self.max}, clamping",
                 )
             )
-            high = self.max_value
+            high = self.max
 
         return (low, high)
 
@@ -1130,19 +1136,19 @@ class FloatRangeParameter(Parameter[Tuple[float, float]]):
         """
         Validate complete parameter state after updates.
 
-        Ensures min_value <= max_value, swapping if needed.
+        Ensures min <= max, 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 None or self.max_value is None:
+        if self.min is None or self.max is None:
             raise ParameterUpdateError(
                 self.name,
                 type(self).__name__,
-                "FloatRangeParameter must have both min_value and max_value bounds",
+                "FloatRangeParameter must have both min and max bounds",
             )
-        if self.min_value > self.max_value:
+        if self.min > self.max:
             warn(
                 ParameterUpdateWarning(
                     self.name,
@@ -1150,7 +1156,7 @@ class FloatRangeParameter(Parameter[Tuple[float, float]]):
                     f"Min value greater than max value, swapping",
                 )
             )
-            self.min_value, self.max_value = self.max_value, self.min_value
+            self.min, self.max = self.max, self.min
         self.value = self._validate(self.value)
 
 
@@ -1160,28 +1166,21 @@ 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
     ----------
     name : str
         The name of the parameter
-    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)
 
     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
@@ -1189,43 +1188,26 @@ 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,
+        value: Union[int, NoInitialValue],
     ):
         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
-        )
+        if isinstance(value, NoInitialValue):
+            value = 0
         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
@@ -1238,50 +1220,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(
-                    ParameterUpdateWarning(
-                        self.name,
-                        type(self).__name__,
-                        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(
-                    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)
 
     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(
-                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)
 
 
@@ -1291,30 +1238,23 @@ 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
     ----------
     name : str
         The name of the parameter
-    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)
     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
@@ -1323,7 +1263,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:
@@ -1332,42 +1271,27 @@ 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,
+        value: Union[float, NoInitialValue],
         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
-        )
+        if isinstance(value, NoInitialValue):
+            value = 0
         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
@@ -1384,51 +1308,18 @@ 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(
-                    ParameterUpdateWarning(
-                        self.name,
-                        type(self).__name__,
-                        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(
-                    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)
 
     def _validate_update(self) -> None:
         """
         Validate complete parameter state after updates.
 
-        Ensures min_value <= max_value, swapping if needed.
+        Ensures min <= max, 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(
-                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)
 
 
@@ -1438,15 +1329,15 @@ 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.interactive_viewer.InteractiveViewer.add_button` and
-    :meth:`~syd.interactive_viewer.InteractiveViewer.update_button` for usage.
+    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
+    label : Union[str, NoInitialValue]
+        Text to display on the button (default is the button's name)
     callback : callable
         Function to execute when the button is clicked
 
@@ -1478,16 +1369,27 @@ class ButtonAction(Parameter[None]):
     value: None = field(default=None, repr=False)
     _is_action: bool = field(default=True, repr=False)
 
-    def __init__(self, name: str, label: str, callback: Callable):
+    def __init__(
+        self,
+        name: str,
+        label: Union[str, NoInitialValue],
+        callback: Callable,
+    ):
         """
         Initialize a button.
 
-        Args:
-            name: Internal name of the parameter
-            label: Text to display on the button
-            callback: Function to call when button is clicked
+        Parameters
+        ----------
+        name : str
+            The name of the parameter
+        label : Union[str, NoInitialValue]
+            Text to display on the button (default is the button's name)
+        callback : callable
+            Function to execute when the button is clicked
         """
         self.name = name
+        if isinstance(label, NoInitialValue):
+            label = name
         self.label = label
         self.callback = callback
         self._value = None