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

syd/parameters.py

@@ -1,140 +1,18 @@
 from typing import List, Any, Tuple, Generic, TypeVar, Optional, Dict, Callable, Union
 from dataclasses import dataclass, field
-from abc import ABC, ABCMeta, abstractmethod
+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 = []
+from .support import (
+    NoInitialValue,
+    ParameterMeta,
+    ParameterUpdateError,
+    get_parameter_attributes,
+    warn_parameter_update,
+)
 
-    # 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)
-
-    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
+T = TypeVar("T")
 
 
 @dataclass
@@ -216,8 +94,8 @@ class Parameter(Generic[T], ABC, metaclass=ParameterMeta):
 
         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)
 
@@ -292,7 +170,7 @@ class TextParameter(Parameter[str]):
     ----------
     name : str
         The name of the parameter
-    value : str
+    value : Union[str, NoInitialValue]
         The initial text value
 
     Examples
@@ -305,8 +183,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:
@@ -335,7 +215,7 @@ class BooleanParameter(Parameter[bool]):
     ----------
     name : str
         The name of the parameter
-    value : bool, optional
+    value : Union[bool, NoInitialValue]
         The initial state (default is True)
 
     Examples
@@ -348,8 +228,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:
@@ -378,7 +260,7 @@ class SelectionParameter(Parameter[Any]):
     ----------
     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
@@ -401,9 +283,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]:
@@ -458,9 +344,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:
         """
@@ -473,13 +392,50 @@ 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:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"Value {self.value} not in options, setting to first option ({self.options[0]})",
-                )
+
+        # 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_parameter_update(
+                self.name,
+                type(self).__name__,
+                f"Value {self.value} not in options, setting to first option ({self.options[0]})",
             )
             self.value = self.options[0]
 
@@ -497,8 +453,8 @@ class MultipleSelectionParameter(Parameter[List[Any]]):
     ----------
     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
 
@@ -520,9 +476,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]:
@@ -592,22 +555,18 @@ class MultipleSelectionParameter(Parameter[List[Any]]):
     def _validate_update(self) -> None:
         self.options = self._validate_options(self.options)
         if not isinstance(self.value, (list, tuple)):
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"For parameter {self.name}, value {self.value} is not a list or tuple. Setting to empty list.",
-                )
+            warn_parameter_update(
+                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(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"For parameter {self.name}, value {self.value} contains invalid selections: {invalid}. Setting to empty list.",
-                )
+            warn_parameter_update(
+                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
@@ -628,39 +587,41 @@ class IntegerParameter(Parameter[int]):
     ----------
     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:
@@ -683,51 +644,45 @@ 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:
-                warn(
-                    ParameterUpdateWarning(
-                        self.name,
-                        type(self).__name__,
-                        f"Value {new_value} below minimum {self.min_value}, clamping",
-                    )
+            if new_value < self.min:
+                warn_parameter_update(
+                    self.name,
+                    type(self).__name__,
+                    f"Value {new_value} below minimum {self.min}, clamping",
                 )
-                new_value = self.min_value
-            if 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.min
+            if new_value > self.max:
+                warn_parameter_update(
+                    self.name,
+                    type(self).__name__,
+                    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:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"Min value greater than max value, swapping",
-                )
+        if self.min > self.max:
+            warn_parameter_update(
+                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.min, self.max = self.max, self.min
         self.value = self._validate(self.value)
 
 
@@ -744,11 +699,11 @@ class FloatParameter(Parameter[float]):
     ----------
     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.001)
@@ -756,13 +711,13 @@ class FloatParameter(Parameter[float]):
     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
 
@@ -774,22 +729,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,
+        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:
@@ -817,24 +774,20 @@ class FloatParameter(Parameter[float]):
         new_value = round(new_value / self.step) * self.step
 
         if compare_to_range:
-            if new_value < self.min_value:
-                warn(
-                    ParameterUpdateWarning(
-                        self.name,
-                        type(self).__name__,
-                        f"Value {new_value} below minimum {self.min_value}, clamping",
-                    )
+            if new_value < self.min:
+                warn_parameter_update(
+                    self.name,
+                    type(self).__name__,
+                    f"Value {new_value} below minimum {self.min}, clamping",
                 )
-                new_value = self.min_value
-            if 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.min
+            if new_value > self.max:
+                warn_parameter_update(
+                    self.name,
+                    type(self).__name__,
+                    f"Value {new_value} above maximum {self.max}, clamping",
                 )
-                new_value = self.max_value
+                new_value = self.max
 
         return float(new_value)
 
@@ -842,27 +795,25 @@ 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:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"Min value greater than max value, swapping",
-                )
+        if self.min > self.max:
+            warn_parameter_update(
+                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.min, self.max = self.max, self.min
         self.value = self._validate(self.value)
 
 
@@ -879,17 +830,17 @@ class IntegerRangeParameter(Parameter[Tuple[int, int]]):
     ----------
     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
@@ -900,19 +851,21 @@ 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, context="min_value")
-        self.max_value = self._validate_single(max_value, context="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, context: Optional[str] = None) -> int:
@@ -960,33 +913,27 @@ class IntegerRangeParameter(Parameter[Tuple[int, int]]):
         high = self._validate_single(new_value[1])
 
         if low > high:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"Low value {low} greater than high value {high}, swapping",
-                )
+            warn_parameter_update(
+                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(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"Low value {low} below minimum {self.min_value}, clamping",
-                )
+        if low < self.min:
+            warn_parameter_update(
+                self.name,
+                type(self).__name__,
+                f"Low value {low} below minimum {self.min}, clamping",
             )
-            low = self.min_value
-        if high > self.max_value:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"High value {high} above maximum {self.max_value}, clamping",
-                )
+            low = self.min
+        if high > self.max:
+            warn_parameter_update(
+                self.name,
+                type(self).__name__,
+                f"High value {high} above maximum {self.max}, clamping",
             )
-            high = self.max_value
+            high = self.max
 
         return (low, high)
 
@@ -994,27 +941,25 @@ 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:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"Min value greater than max value, swapping",
-                )
+        if self.min > self.max:
+            warn_parameter_update(
+                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.min, self.max = self.max, self.min
         self.value = self._validate(self.value)
 
 
@@ -1031,11 +976,11 @@ class FloatRangeParameter(Parameter[Tuple[float, float]]):
     ----------
     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.001)
@@ -1043,7 +988,7 @@ class FloatRangeParameter(Parameter[Tuple[float, float]]):
     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
@@ -1061,22 +1006,24 @@ 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,
+        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, context="min_value")
-        self.max_value = self._validate_single(max_value, context="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, context: Optional[str] = None) -> float:
@@ -1128,33 +1075,27 @@ class FloatRangeParameter(Parameter[Tuple[float, float]]):
         high = self._validate_single(new_value[1])
 
         if low > high:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"Low value {low} greater than high value {high}, swapping",
-                )
+            warn_parameter_update(
+                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(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"Low value {low} below minimum {self.min_value}, clamping",
-                )
+        if low < self.min:
+            warn_parameter_update(
+                self.name,
+                type(self).__name__,
+                f"Low value {low} below minimum {self.min}, clamping",
             )
-            low = self.min_value
-        if high > self.max_value:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"High value {high} above maximum {self.max_value}, clamping",
-                )
+            low = self.min
+        if high > self.max:
+            warn_parameter_update(
+                self.name,
+                type(self).__name__,
+                f"High value {high} above maximum {self.max}, clamping",
             )
-            high = self.max_value
+            high = self.max
 
         return (low, high)
 
@@ -1162,27 +1103,25 @@ 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:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"Min value greater than max value, swapping",
-                )
+        if self.min > self.max:
+            warn_parameter_update(
+                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.min, self.max = self.max, self.min
         self.value = self._validate(self.value)
 
 
@@ -1199,7 +1138,7 @@ class UnboundedIntegerParameter(Parameter[int]):
     ----------
     name : str
         The name of the parameter
-    value : int
+    value : Union[int, NoInitialValue]
         Initial value
 
     Examples
@@ -1221,9 +1160,11 @@ class UnboundedIntegerParameter(Parameter[int]):
     def __init__(
         self,
         name: str,
-        value: int,
+        value: Union[int, NoInitialValue],
     ):
         self.name = name
+        if isinstance(value, NoInitialValue):
+            value = 0
         self._value = self._validate(value)
 
     def _validate(self, new_value: Any) -> int:
@@ -1269,7 +1210,7 @@ class UnboundedFloatParameter(Parameter[float]):
     ----------
     name : str
         The name of the parameter
-    value : float
+    value : Union[float, NoInitialValue]
         Initial value
     step : float, optional
         Size of each increment (default is None, meaning no rounding)
@@ -1300,11 +1241,13 @@ class UnboundedFloatParameter(Parameter[float]):
     def __init__(
         self,
         name: str,
-        value: float,
+        value: Union[float, NoInitialValue],
         step: Optional[float] = None,
     ):
         self.name = name
         self.step = step
+        if isinstance(value, NoInitialValue):
+            value = 0
         self._value = self._validate(value)
 
     def _validate(self, new_value: Any) -> float:
@@ -1336,7 +1279,7 @@ class UnboundedFloatParameter(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:
@@ -1358,8 +1301,8 @@ class ButtonAction(Parameter[None]):
     ----------
     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
 
@@ -1391,16 +1334,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