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

syd/parameters.py

@@ -1,17 +1,6 @@
-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 abc import ABC, ABCMeta, abstractmethod
 from enum import Enum
 from copy import deepcopy
 from warnings import warn
@@ -117,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.
@@ -265,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
     ----------
@@ -308,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
     ----------
@@ -351,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
     ----------
@@ -412,6 +432,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:
@@ -455,7 +478,7 @@ class SelectionParameter(Parameter[Any]):
                 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,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
     ----------
@@ -525,9 +548,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 +606,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,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
     ----------
@@ -711,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
     ----------
@@ -725,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
     --------
@@ -758,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
@@ -846,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
     ----------
@@ -885,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.
 
@@ -907,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]:
         """
@@ -995,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
     ----------
@@ -1009,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
     --------
@@ -1042,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.
 
@@ -1068,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
@@ -1160,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
     ----------
@@ -1169,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
@@ -1189,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
@@ -1238,50 +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(
-                    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,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
     ----------
@@ -1300,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
@@ -1323,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:
@@ -1332,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
@@ -1384,26 +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(
-                    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:
@@ -1416,19 +1342,6 @@ 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(
-                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,8 +1351,8 @@ 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
     ----------

syd/plotly_deployment/__init__.py

@@ -0,0 +1 @@
+from .deployer import PlotlyDeployer