griptape-nodes 0.70.1__py3-none-any.whl → 0.71.0__py3-none-any.whl

griptape_nodes/exe_types/param_components/subflow_execution_component.py

@@ -0,0 +1,329 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from griptape_nodes.exe_types.core_types import NodeMessageResult, Parameter, ParameterMode
+from griptape_nodes.exe_types.node_types import LOCAL_EXECUTION, PRIVATE_EXECUTION
+from griptape_nodes.retained_mode.events.base_events import (
+    EventResultSuccess,
+    ExecutionEvent,
+)
+from griptape_nodes.retained_mode.events.execution_events import (
+    ControlFlowCancelledEvent,
+    ControlFlowResolvedEvent,
+    GriptapeEvent,
+    NodeFinishProcessEvent,
+    NodeResolvedEvent,
+    NodeStartProcessEvent,
+)
+from griptape_nodes.retained_mode.events.payload_registry import PayloadRegistry
+from griptape_nodes.retained_mode.events.workflow_events import (
+    PublishWorkflowProgressEvent,
+    PublishWorkflowRequest,
+    PublishWorkflowResultFailure,
+    PublishWorkflowResultSuccess,
+)
+from griptape_nodes.traits.button import Button, ButtonDetailsMessagePayload, OnClickMessageResultPayload
+
+if TYPE_CHECKING:
+    from griptape_nodes.exe_types.node_types import BaseNode
+
+logger = logging.getLogger(__name__)
+
+
+class SubflowExecutionComponent:
+    """A reusable component for managing subprocess execution event parameters.
+
+    This component creates and manages parameters that display
+    real-time events from subprocess execution in the GUI.
+    """
+
+    def __init__(self, node: BaseNode) -> None:
+        """Initialize the SubflowExecutionComponent.
+
+        Args:
+            node: The node instance that will own the parameter
+        """
+        self._node = node
+
+    def add_output_parameters(self) -> None:
+        """Add the parameters to the node."""
+        self._node.add_parameter(
+            Parameter(
+                name="publishing_progress",
+                output_type="float",
+                allowed_modes={ParameterMode.PROPERTY},
+                tooltip="Progress bar showing workflow publishing completion (0.0 to 1.0)",
+                ui_options={"progress_bar": True},
+                settable=False,
+                hide=True,
+            )
+        )
+        self._node.add_parameter(
+            Parameter(
+                name="publishing_target_link",
+                output_type="str",
+                tooltip="Click the button to open the published workflow location",
+                hide=True,
+                allowed_modes={ParameterMode.PROPERTY},
+                traits={
+                    Button(
+                        icon="link",
+                        on_click=self._handle_get_publishing_target_link,
+                        tooltip="Open publishing target link",
+                        state="normal",
+                    ),
+                },
+                ui_options={"placeholder_text": "Link will appear after publishing"},
+            )
+        )
+        self._node.add_parameter(
+            Parameter(
+                name="execution_events",
+                output_type="str",
+                allowed_modes={ParameterMode.PROPERTY},
+                tooltip="Real-time events from subprocess execution",
+                ui_options={"multiline": True},
+            )
+        )
+        if "execution_panel" not in self._node.metadata:
+            self._node.metadata["execution_panel"] = {"params": []}
+        self._node.metadata["execution_panel"]["params"].append("execution_events")
+        self._node.metadata["execution_panel"]["params"].append("publishing_progress")
+        self._node.metadata["execution_panel"]["params"].append("publishing_target_link")
+
+    def _handle_get_publishing_target_link(
+        self,
+        button: Button,  # noqa: ARG002
+        button_details: ButtonDetailsMessagePayload,
+    ) -> NodeMessageResult | None:
+        publishing_target_link = self._node.get_parameter_value("publishing_target_link")
+        if publishing_target_link:
+            return NodeMessageResult(
+                success=True,
+                details="Publishing target link retrieved successfully.",
+                response=OnClickMessageResultPayload(
+                    button_details=button_details,
+                    href=publishing_target_link,
+                ),
+                altered_workflow_state=False,
+            )
+        return None
+
+    def clear_execution_state(self) -> None:
+        """Clear the component state."""
+        self.reset_publishing_progress()
+        self.clear_events()
+        self.clear_publishing_target_link()
+
+    def clear_events(self) -> None:
+        """Clear events at start of execution."""
+        self._node.publish_update_to_parameter("execution_events", "")
+
+    def clear_publishing_target_link(self) -> None:
+        """Clear the publishing target link parameter."""
+        self._node.set_parameter_value("publishing_target_link", None)
+
+    def append_event(self, event_str: str) -> None:
+        """Append a stringified event to the parameter.
+
+        Args:
+            event_str: The event string to append
+        """
+        self._node.append_value_to_parameter("execution_events", event_str + "\n")
+
+    def after_value_set(self, parameter: Parameter, value: Any) -> None:
+        """Handle actions after a parameter value is set.
+
+        Args:
+            parameter: The parameter that was set
+            value: The new value of the parameter
+        """
+        if parameter.name == "execution_environment":
+            if value in {LOCAL_EXECUTION, PRIVATE_EXECUTION}:
+                self._node.hide_parameter_by_name("publishing_progress")
+                self._node.hide_parameter_by_name("publishing_target_link")
+            else:
+                self._node.show_parameter_by_name("publishing_progress")
+
+        if parameter.name == "publishing_target_link":
+            if value and self._node.get_parameter_value("execution_environment") not in {
+                LOCAL_EXECUTION,
+                PRIVATE_EXECUTION,
+            }:
+                self._node.show_parameter_by_name("publishing_target_link")
+            else:
+                self._node.hide_parameter_by_name("publishing_target_link")
+
+    def reset_publishing_progress(self) -> None:
+        """Reset the publishing progress bar to 0."""
+        self._node.publish_update_to_parameter("publishing_progress", 0.0)
+
+    def _parse_execution_event(self, event: dict) -> ExecutionEvent | None:
+        """Parse an execution event dictionary into an ExecutionEvent object.
+
+        Args:
+            event: The event dictionary containing the execution event data.
+                   Expected to have type="execution_event" and a payload with payload_type.
+
+        Returns:
+            The parsed ExecutionEvent if successful, None if the event cannot be parsed
+            (wrong type, unknown payload type, etc.)
+        """
+        event_type = event.get("type", "unknown")
+        if event_type != "execution_event":
+            return None
+
+        payload = event.get("payload", {})
+        payload_type_name = payload.get("payload_type", "")
+        payload_type = PayloadRegistry.get_type(payload_type_name)
+
+        if payload_type is None:
+            logger.debug("Unknown payload type: %s", payload_type_name)
+            return None
+
+        return ExecutionEvent.from_dict(data=payload, payload_type=payload_type)
+
+    def handle_publishing_event(self, event: dict) -> None:
+        """Handle events from SubprocessWorkflowPublisher.
+
+        Processes publishing events and updates the GUI with relevant information.
+        Handles PublishWorkflowProgressEvent for progress bar updates, and
+        PublishWorkflowResultSuccess/Failure for completion status.
+
+        Args:
+            event: The event dictionary from the subprocess publisher
+        """
+        event_type = event.get("type", "unknown")
+
+        # Handle result events (success/failure)
+        if event_type in ("success_result", "failure_result"):
+            self._handle_publishing_result_event(event)
+            return
+
+        # Handle execution events (progress updates)
+        ex_event = self._parse_execution_event(event)
+        if ex_event is None:
+            return
+
+        if isinstance(ex_event.payload, PublishWorkflowProgressEvent):
+            # Update progress bar (convert from 0-100 to 0.0-1.0)
+            progress_value = min(1.0, max(0.0, ex_event.payload.progress / 100.0))
+            self._node.publish_update_to_parameter("publishing_progress", progress_value)
+
+            # Also append a user-friendly message if provided
+            if ex_event.payload.message:
+                self.append_event(f"Publishing: {ex_event.payload.message} ({ex_event.payload.progress:.0f}%)")
+
+    def _handle_publishing_result_event(self, event: dict) -> None:
+        """Handle publishing result events (success/failure).
+
+        Args:
+            event: The event dictionary containing the result
+        """
+        payload = event.get("payload", {})
+        result_type_name = payload.get("result_type", "")
+        result_payload_type = PayloadRegistry.get_type(result_type_name)
+
+        if result_payload_type is None:
+            logger.debug("Unknown result type: %s", result_type_name)
+            return
+
+        result_data = payload.get("result", {})
+
+        if result_payload_type == PublishWorkflowResultSuccess:
+            event_result = EventResultSuccess.from_dict(
+                data=payload, req_payload_type=PublishWorkflowRequest, res_payload_type=PublishWorkflowResultSuccess
+            )
+            if isinstance(event_result.result, PublishWorkflowResultSuccess):
+                publish_workflow_result_success = event_result.result
+                target_link = (
+                    publish_workflow_result_success.metadata.get("publish_target_link")
+                    if publish_workflow_result_success.metadata
+                    else None
+                )
+                if target_link:
+                    self._node.set_parameter_value("publishing_target_link", target_link)
+
+        elif result_payload_type == PublishWorkflowResultFailure:
+            result_details = result_data.get("result_details", "Unknown error")
+            self.append_event(f"Publishing failed: {result_details}")
+
+    def handle_execution_event(self, event: dict) -> None:
+        """Handle events from SubprocessWorkflowExecutor.
+
+        Processes execution events and updates the GUI with relevant information.
+        Filters to only display relevant events with formatted messages.
+
+        Args:
+            event: The event dictionary from the subprocess executor
+        """
+        ex_event = self._parse_execution_event(event)
+
+        if ex_event is None:
+            return
+
+        formatted_message = self._format_execution_event(ex_event)
+        if formatted_message is not None:
+            self.append_event(formatted_message)
+
+    def _format_execution_event(self, ex_event: ExecutionEvent) -> str | None:
+        """Format an execution event into a user-friendly message.
+
+        Args:
+            ex_event: The parsed ExecutionEvent
+
+        Returns:
+            A formatted string message, or None if the event should be filtered out
+        """
+        payload = ex_event.payload
+        payload_type = type(payload)
+
+        # Map payload types to their formatting functions
+        formatters = {
+            NodeStartProcessEvent: self._format_node_start_process,
+            NodeFinishProcessEvent: self._format_node_finish_process,
+            NodeResolvedEvent: self._format_node_resolved,
+            ControlFlowResolvedEvent: self._format_control_flow_resolved,
+            ControlFlowCancelledEvent: self._format_control_flow_cancelled,
+            GriptapeEvent: self._format_griptape_event,
+        }
+
+        formatter = formatters.get(payload_type)
+        if formatter is None:
+            # Filter out other event types
+            return None
+
+        return formatter(payload)
+
+    def _format_node_start_process(self, payload: NodeStartProcessEvent) -> str:
+        """Format a NodeStartProcessEvent."""
+        return f"Starting: {payload.node_name}"
+
+    def _format_node_finish_process(self, payload: NodeFinishProcessEvent) -> str:
+        """Format a NodeFinishProcessEvent."""
+        return f"Finished: {payload.node_name}"
+
+    def _format_node_resolved(self, payload: NodeResolvedEvent) -> str:
+        """Format a NodeResolvedEvent."""
+        return f"Resolved: {payload.node_name}"
+
+    def _format_control_flow_resolved(self, payload: ControlFlowResolvedEvent) -> str:
+        """Format a ControlFlowResolvedEvent."""
+        return f"Flow completed: {payload.end_node_name}"
+
+    def _format_control_flow_cancelled(self, payload: ControlFlowCancelledEvent) -> str:
+        """Format a ControlFlowCancelledEvent."""
+        details = payload.result_details or "Unknown error"
+        return f"Flow cancelled: {details}"
+
+    def _format_griptape_event(self, payload: GriptapeEvent) -> str | None:
+        """Format a GriptapeEvent (progress event).
+
+        Only formats events for the 'result_details' parameter, filtering out others.
+        """
+        if payload.parameter_name != "result_details":
+            return None
+
+        return f"{payload.node_name}: {payload.value}"

griptape_nodes/exe_types/param_types/parameter_audio.py

@@ -4,6 +4,7 @@ from collections.abc import Callable
 from typing import Any
 
 from griptape_nodes.exe_types.core_types import Parameter, ParameterMode, Trait
+from griptape_nodes.utils.artifact_normalization import normalize_artifact_input
 
 
 class ParameterAudio(Parameter):
@@ -24,7 +25,7 @@ class ParameterAudio(Parameter):
         param.pulse_on_run = True  # Change UI options at runtime
     """
 
-    def __init__(  # noqa: PLR0913
+    def __init__(  # noqa: C901, PLR0913
         self,
         name: str,
         tooltip: str | None = None,
@@ -122,6 +123,20 @@ class ParameterAudio(Parameter):
         else:
             final_input_types = ["AudioUrlArtifact"]
 
+        # Add automatic converter to normalize string inputs to AudioUrlArtifact
+        # This allows ParameterAudio to automatically handle file paths and localhost URLs
+        audio_converters = list(converters) if converters else []
+        if accept_any:
+            # Create a converter function that uses normalize_artifact_input with AudioUrlArtifact
+            def _normalize_audio(value: Any) -> Any:
+                try:
+                    from griptape.artifacts import AudioUrlArtifact
+                except ImportError:
+                    return value
+                return normalize_artifact_input(value, AudioUrlArtifact)
+
+            audio_converters.insert(0, _normalize_audio)
+
         # Call parent with explicit parameters, following ControlParameter pattern
         super().__init__(
             name=name,
@@ -135,7 +150,7 @@ class ParameterAudio(Parameter):
             tooltip_as_output=tooltip_as_output,
             allowed_modes=allowed_modes,
             traits=traits,
-            converters=converters,
+            converters=audio_converters,
             validators=validators,
             ui_options=ui_options,
             hide=hide,

griptape_nodes/exe_types/param_types/parameter_image.py

@@ -3,7 +3,10 @@
 from collections.abc import Callable
 from typing import Any
 
+from griptape.artifacts import ImageArtifact, ImageUrlArtifact
+
 from griptape_nodes.exe_types.core_types import Parameter, ParameterMode, Trait
+from griptape_nodes.utils.artifact_normalization import normalize_artifact_input
 
 
 class ParameterImage(Parameter):
@@ -122,6 +125,16 @@ class ParameterImage(Parameter):
         else:
             final_input_types = ["ImageUrlArtifact"]
 
+        # Add automatic converter to normalize string inputs to ImageUrlArtifact
+        # This allows ParameterImage to automatically handle file paths and localhost URLs
+        image_converters = list(converters) if converters else []
+        if accept_any:
+            # Create a converter function that uses normalize_artifact_input with ImageUrlArtifact
+            def _normalize_image(value: Any) -> Any:
+                return normalize_artifact_input(value, ImageUrlArtifact, accepted_types=(ImageArtifact,))
+
+            image_converters.insert(0, _normalize_image)
+
         # Call parent with explicit parameters, following ControlParameter pattern
         super().__init__(
             name=name,
@@ -135,7 +148,7 @@ class ParameterImage(Parameter):
             tooltip_as_output=tooltip_as_output,
             allowed_modes=allowed_modes,
             traits=traits,
-            converters=converters,
+            converters=image_converters,
             validators=validators,
             ui_options=ui_options,
             hide=hide,

griptape_nodes/exe_types/param_types/parameter_number.py

@@ -235,6 +235,12 @@ 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)
@@ -253,7 +259,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 or max_val is not None:
+        elif min_val is not None and max_val is not None:
             traits.add(Clamp(min_val=min_val, max_val=max_val))
 
         # Store traits for later use
@@ -298,6 +304,9 @@ 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()
 
@@ -312,6 +321,9 @@ 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()
 
@@ -355,35 +367,17 @@ class ParameterNumber(Parameter):
         min_val = getattr(self, "_min_val", None)
         max_val = getattr(self, "_max_val", None)
 
-        if min_val is None and max_val is None:
+        if min_val is None or 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_float, max_val=max_val_float))
+            self.add_trait(Slider(min_val=min_val, max_val=max_val))
         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_float, max_val=max_val_float))
+            self.add_trait(MinMax(min_val=min_val, max_val=max_val))
         else:
             self._remove_constraint_traits()
             self.add_trait(Clamp(min_val=min_val, max_val=max_val))

griptape_nodes/exe_types/param_types/parameter_three_d.py

@@ -3,7 +3,10 @@
 from collections.abc import Callable
 from typing import Any
 
+from griptape_nodes_library.three_d.three_d_artifact import ThreeDUrlArtifact  # pyright: ignore[reportMissingImports]
+
 from griptape_nodes.exe_types.core_types import Parameter, ParameterMode, Trait
+from griptape_nodes.utils.artifact_normalization import normalize_artifact_input
 
 
 class Parameter3D(Parameter):
@@ -117,6 +120,16 @@ class Parameter3D(Parameter):
         else:
             final_input_types = ["ThreeDUrlArtifact"]
 
+        # Add automatic converter to normalize string inputs to ThreeDUrlArtifact
+        # This allows Parameter3D to automatically handle file paths and localhost URLs
+        three_d_converters = list(converters) if converters else []
+        if accept_any:
+            # Create a converter function that uses normalize_artifact_input with ThreeDUrlArtifact
+            def _normalize_three_d(value: Any) -> Any:
+                return normalize_artifact_input(value, ThreeDUrlArtifact)
+
+            three_d_converters.insert(0, _normalize_three_d)
+
         # Call parent with explicit parameters, following ControlParameter pattern
         super().__init__(
             name=name,
@@ -130,7 +143,7 @@ class Parameter3D(Parameter):
             tooltip_as_output=tooltip_as_output,
             allowed_modes=allowed_modes,
             traits=traits,
-            converters=converters,
+            converters=three_d_converters,
             validators=validators,
             ui_options=ui_options,
             hide=hide,

griptape_nodes/exe_types/param_types/parameter_video.py

@@ -4,6 +4,7 @@ from collections.abc import Callable
 from typing import Any
 
 from griptape_nodes.exe_types.core_types import Parameter, ParameterMode, Trait
+from griptape_nodes.utils.artifact_normalization import normalize_artifact_input
 
 
 class ParameterVideo(Parameter):
@@ -24,7 +25,7 @@ class ParameterVideo(Parameter):
         param.pulse_on_run = True  # Change UI options at runtime
     """
 
-    def __init__(  # noqa: PLR0913
+    def __init__(  # noqa: C901, PLR0913
         self,
         name: str,
         tooltip: str | None = None,
@@ -122,6 +123,20 @@ class ParameterVideo(Parameter):
         else:
             final_input_types = ["VideoUrlArtifact"]
 
+        # Add automatic converter to normalize string inputs to VideoUrlArtifact
+        # This allows ParameterVideo to automatically handle file paths and localhost URLs
+        video_converters = list(converters) if converters else []
+        if accept_any:
+            # Create a converter function that uses normalize_artifact_input with VideoUrlArtifact
+            def _normalize_video(value: Any) -> Any:
+                try:
+                    from griptape.artifacts import VideoUrlArtifact
+                except ImportError:
+                    return value
+                return normalize_artifact_input(value, VideoUrlArtifact)
+
+            video_converters.insert(0, _normalize_video)
+
         # Call parent with explicit parameters, following ControlParameter pattern
         super().__init__(
             name=name,
@@ -135,7 +150,7 @@ class ParameterVideo(Parameter):
             tooltip_as_output=tooltip_as_output,
             allowed_modes=allowed_modes,
             traits=traits,
-            converters=converters,
+            converters=video_converters,
             validators=validators,
             ui_options=ui_options,
             hide=hide,

griptape_nodes/retained_mode/managers/os_manager.py

@@ -2033,7 +2033,7 @@ class OSManager:
                 mode=file_mode,  # type: ignore[arg-type]
                 encoding=encoding if isinstance(content, str) else None,
                 timeout=0,  # Non-blocking
-                flags=portalocker.LockFlags.EXCLUSIVE,
+                flags=portalocker.LockFlags.EXCLUSIVE | portalocker.LockFlags.NON_BLOCKING,
             ) as fh:
                 fh.write(content)
 

griptape_nodes/traits/clamp.py

@@ -11,7 +11,7 @@ class Clamp(Trait):
     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:
+    def __init__(self, min_val: float, max_val: float) -> None:
         super().__init__()
         self.min = min_val
         self.max = max_val
@@ -20,60 +20,17 @@ class Clamp(Trait):
     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, (str, list)):
+                if len(value) > self.max:
+                    return value[: self.max]
+                return value
             if isinstance(value, (int, float)):
-                return self._clamp_number(float(value))
-
+                if value > self.max:
+                    return self.max
+                if value < self.min:
+                    return self.min
             return value
 
         return [clamp]