griptape-nodes 0.70.0__tar.gz → 0.70.1__tar.gz

{griptape_nodes-0.70.0 → griptape_nodes-0.70.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: griptape-nodes
-Version: 0.70.0
+Version: 0.70.1
 Summary: Add your description here
 Requires-Dist: griptape>=1.9.0
 Requires-Dist: pydantic>=2.10.6

{griptape_nodes-0.70.0 → griptape_nodes-0.70.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "griptape-nodes"
-version = "0.70.0"
+version = "0.70.1"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12.0, <3.13"

{griptape_nodes-0.70.0 → griptape_nodes-0.70.1}/src/griptape_nodes/exe_types/param_types/parameter_number.py

@@ -235,12 +235,6 @@ class ParameterNumber(Parameter):
             validate_min_max: Whether to validate min/max with error
         """
         # Validation rules
-        if min_val is not None and max_val is None:
-            msg = f"{name}: If min_val is provided, max_val must also be provided"
-            raise ValueError(msg)
-        if max_val is not None and min_val is None:
-            msg = f"{name}: If max_val is provided, min_val must also be provided"
-            raise ValueError(msg)
         if slider and (min_val is None or max_val is None):
             msg = f"{name}: If slider is True, both min_val and max_val must be provided"
             raise ValueError(msg)
@@ -259,7 +253,7 @@ class ParameterNumber(Parameter):
             traits.add(Slider(min_val=min_val, max_val=max_val))
         elif validate_min_max and min_val is not None and max_val is not None:
             traits.add(MinMax(min_val=min_val, max_val=max_val))
-        elif min_val is not None and max_val is not None:
+        elif min_val is not None or max_val is not None:
             traits.add(Clamp(min_val=min_val, max_val=max_val))
 
         # Store traits for later use
@@ -304,9 +298,6 @@ class ParameterNumber(Parameter):
     @min_val.setter
     def min_val(self, value: float | None) -> None:
         """Set minimum value and update constraint traits."""
-        if value is not None and self.max_val is None:
-            msg = f"{self.name}: Cannot set min_val without max_val"
-            raise ValueError(msg)
         self._min_val = value
         self._update_constraint_traits()
 
@@ -321,9 +312,6 @@ class ParameterNumber(Parameter):
     @max_val.setter
     def max_val(self, value: float | None) -> None:
         """Set maximum value and update constraint traits."""
-        if value is not None and self.min_val is None:
-            msg = f"{self.name}: Cannot set max_val without min_val"
-            raise ValueError(msg)
         self._max_val = value
         self._update_constraint_traits()
 
@@ -367,17 +355,35 @@ class ParameterNumber(Parameter):
         min_val = getattr(self, "_min_val", None)
         max_val = getattr(self, "_max_val", None)
 
-        if min_val is None or max_val is None:
+        if min_val is None and max_val is None:
             self._remove_constraint_traits()
             return
 
+        if self.slider and (min_val is None or max_val is None):
+            msg = f"{self.name}: Cannot enable slider without min_val and max_val"
+            raise ValueError(msg)
+
+        if self.validate_min_max and (min_val is None or max_val is None):
+            msg = f"{self.name}: Cannot enable validate_min_max without min_val and max_val"
+            raise ValueError(msg)
+
         # Determine which trait to use based on current state
         if self.slider:
+            # Checked above: both min_val and max_val are available when slider is enabled.
+            # Type narrowing: assign to variables after None check so type checker understands
+            min_val_float: float = min_val  # type: ignore[assignment]
+            max_val_float: float = max_val  # type: ignore[assignment]
+            # Python will naturally coerce int to float if needed (no precision loss for reasonable values)
             self._remove_constraint_traits()
-            self.add_trait(Slider(min_val=min_val, max_val=max_val))
+            self.add_trait(Slider(min_val=min_val_float, max_val=max_val_float))
         elif self.validate_min_max:
+            # Checked above: both min_val and max_val are available when validate_min_max is enabled.
+            # Type narrowing: assign to variables after None check so type checker understands
+            min_val_float: float = min_val  # type: ignore[assignment]
+            max_val_float: float = max_val  # type: ignore[assignment]
+            # Python will naturally coerce int to float if needed (no precision loss for reasonable values)
             self._remove_constraint_traits()
-            self.add_trait(MinMax(min_val=min_val, max_val=max_val))
+            self.add_trait(MinMax(min_val=min_val_float, max_val=max_val_float))
         else:
             self._remove_constraint_traits()
             self.add_trait(Clamp(min_val=min_val, max_val=max_val))

griptape_nodes-0.70.1/src/griptape_nodes/traits/clamp.py

@@ -0,0 +1,79 @@
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+from griptape_nodes.exe_types.core_types import Trait
+
+
+@dataclass(eq=False)
+class Clamp(Trait):
+    min: Any = 0
+    max: Any = 10
+    element_id: str = field(default_factory=lambda: "ClampTrait")
+
+    def __init__(self, min_val: float | None = None, max_val: float | None = None) -> None:
+        super().__init__()
+        self.min = min_val
+        self.max = max_val
+
+    @classmethod
+    def get_trait_keys(cls) -> list[str]:
+        return ["clamp"]
+
+    def _clamp_number(self, value: float) -> float:
+        # Keep this as a tiny helper so the converter stays readable and so we can
+        # consistently apply one-sided bounds (min-only or max-only) everywhere.
+        if self.max is not None and value > self.max:
+            value = self.max
+        if self.min is not None and value < self.min:
+            value = self.min
+        return value
+
+    def _clamp_sequence(self, value: list[Any]) -> list[Any]:
+        # Clamp historically applied to strings/lists by max length; we keep list handling
+        # explicit here so bounds semantics remain obvious.
+        if self.max is None:
+            return value
+        if len(value) <= self.max:
+            return value
+        return value[: self.max]
+
+    def _try_parse_numeric_string(self, value: str) -> float | None:
+        # Trait converters run BEFORE parameter-level converters (e.g. ParameterInt/Float
+        # parsing). That means UI inputs often arrive as strings here; to make min/max
+        # clamping actually work with typical UI inputs, we parse numeric strings when
+        # bounds are configured.
+        if self.min is None and self.max is None:
+            return None
+
+        stripped = value.strip()
+        if not stripped:
+            return None
+
+        try:
+            return float(stripped)
+        except ValueError:
+            return None
+
+    def converters_for_trait(self) -> list[Callable]:
+        def clamp(value: Any) -> Any:
+            if isinstance(value, list):
+                return self._clamp_sequence(value)
+
+            if isinstance(value, str):
+                parsed = self._try_parse_numeric_string(value)
+                if parsed is not None:
+                    return self._clamp_number(parsed)
+
+                # If it's not a numeric string (or no bounds configured), preserve the
+                # historical string behavior: max length clamping only.
+                if self.max is None or len(value) <= self.max:
+                    return value
+                return value[: self.max]
+
+            if isinstance(value, (int, float)):
+                return self._clamp_number(float(value))
+
+            return value
+
+        return [clamp]

griptape_nodes-0.70.0/src/griptape_nodes/traits/clamp.py

@@ -1,36 +0,0 @@
-from collections.abc import Callable
-from dataclasses import dataclass, field
-from typing import Any
-
-from griptape_nodes.exe_types.core_types import Trait
-
-
-@dataclass(eq=False)
-class Clamp(Trait):
-    min: Any = 0
-    max: Any = 10
-    element_id: str = field(default_factory=lambda: "ClampTrait")
-
-    def __init__(self, min_val: float, max_val: float) -> None:
-        super().__init__()
-        self.min = min_val
-        self.max = max_val
-
-    @classmethod
-    def get_trait_keys(cls) -> list[str]:
-        return ["clamp"]
-
-    def converters_for_trait(self) -> list[Callable]:
-        def clamp(value: Any) -> Any:
-            if isinstance(value, (str, list)):
-                if len(value) > self.max:
-                    return value[: self.max]
-                return value
-            if isinstance(value, (int, float)):
-                if value > self.max:
-                    return self.max
-                if value < self.min:
-                    return self.min
-            return value
-
-        return [clamp]