griptape-nodes 0.52.1__py3-none-any.whl → 0.54.0__py3-none-any.whl

griptape_nodes/retained_mode/retained_mode.py

@@ -10,6 +10,7 @@ from griptape_nodes.retained_mode.events.base_events import (
 )
 from griptape_nodes.retained_mode.events.config_events import (
     GetConfigCategoryRequest,
+    GetConfigSchemaRequest,
     GetConfigValueRequest,
     SetConfigCategoryRequest,
     SetConfigValueRequest,
@@ -1396,6 +1397,24 @@ class RetainedMode:
         result = GriptapeNodes().handle_request(request)
         return result
 
+    @classmethod
+    def get_config_schema(cls) -> ResultPayload:
+        """Gets the JSON schema for the configuration model.
+
+        Returns:
+            ResultPayload: Contains the configuration schema with field types, enums, and validation rules.
+
+        Example:
+            # Get the configuration schema
+            schema_result = cmd.get_config_schema()
+            if isinstance(schema_result, GetConfigSchemaResultSuccess):
+                schema = schema_result.schema
+                # Use schema to render appropriate UI components
+        """
+        request = GetConfigSchemaRequest()
+        result = GriptapeNodes().handle_request(request)
+        return result
+
     @classmethod
     def rename(cls, object_name: str, requested_name: str) -> ResultPayload:
         """Renames a node or flow.

griptape_nodes/servers/__init__.py

@@ -0,0 +1 @@
+"""Package for web servers the engine may need to start."""

griptape_nodes/{mcp_server/server.py → servers/mcp.py}

@@ -16,7 +16,6 @@ from pydantic import TypeAdapter
 from rich.logging import RichHandler
 from starlette.types import Receive, Scope, Send
 
-from griptape_nodes.mcp_server.ws_request_manager import AsyncRequestManager, WebSocketConnectionManager
 from griptape_nodes.retained_mode.events.base_events import RequestPayload
 from griptape_nodes.retained_mode.events.connection_events import (
     CreateConnectionRequest,
@@ -38,6 +37,7 @@ from griptape_nodes.retained_mode.events.parameter_events import (
 )
 from griptape_nodes.retained_mode.managers.config_manager import ConfigManager
 from griptape_nodes.retained_mode.managers.secrets_manager import SecretsManager
+from griptape_nodes.servers.ws_request_manager import AsyncRequestManager, WebSocketConnectionManager
 
 SUPPORTED_REQUEST_EVENTS: dict[str, type[RequestPayload]] = {
     # Nodes

griptape_nodes/{app/api.py → servers/static.py}

@@ -4,15 +4,16 @@ import binascii
 import logging
 import os
 from pathlib import Path
-from typing import Annotated
 from urllib.parse import urljoin
 
 import uvicorn
-from fastapi import Depends, FastAPI, HTTPException, Request
+from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from rich.logging import RichHandler
 
+from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
 # Whether to enable the static server
 STATIC_SERVER_ENABLED = os.getenv("STATIC_SERVER_ENABLED", "true").lower() == "true"
 # Host of the static server
@@ -20,7 +21,7 @@ STATIC_SERVER_HOST = os.getenv("STATIC_SERVER_HOST", "localhost")
 # Port of the static server
 STATIC_SERVER_PORT = int(os.getenv("STATIC_SERVER_PORT", "8124"))
 # URL path for the static server
-STATIC_SERVER_URL = os.getenv("STATIC_SERVER_URL", "/static")
+STATIC_SERVER_URL = os.getenv("STATIC_SERVER_URL", "/workspace")
 # Log level for the static server
 STATIC_SERVER_LOG_LEVEL = os.getenv("STATIC_SERVER_LOG_LEVEL", "ERROR").lower()
 
@@ -28,18 +29,6 @@ logger = logging.getLogger("griptape_nodes_api")
 logging.getLogger("uvicorn").addHandler(RichHandler(show_time=True, show_path=False, markup=True, rich_tracebacks=True))
 
 
-# Global static directory - initialized as None and set when starting the API
-static_dir: Path | None = None
-
-
-def get_static_dir() -> Path:
-    """FastAPI dependency to get the static directory."""
-    if static_dir is None:
-        msg = "Static directory is not initialized"
-        raise HTTPException(status_code=500, detail=msg)
-    return static_dir
-
-
 """Create and configure the FastAPI application."""
 app = FastAPI()
 
@@ -52,35 +41,34 @@ async def _create_static_file_upload_url(request: Request) -> dict:
     """
     base_url = request.base_url
     body = await request.json()
-    file_name = body["file_name"]
-    url = urljoin(str(base_url), f"/static-uploads/{file_name}")
+    file_path = body["file_path"].lstrip("/")
+    url = urljoin(str(base_url), f"/static-uploads/{file_path}")
 
     return {"url": url}
 
 
 @app.put("/static-uploads/{file_path:path}")
-async def _create_static_file(
-    request: Request, file_path: str, static_directory: Annotated[Path, Depends(get_static_dir)]
-) -> dict:
+async def _create_static_file(request: Request, file_path: str) -> dict:
     """Upload a static file to the static server."""
     if not STATIC_SERVER_ENABLED:
         msg = "Static server is not enabled. Please set STATIC_SERVER_ENABLED to True."
         raise ValueError(msg)
 
-    file_full_path = Path(static_directory / file_path)
+    workspace_directory = Path(GriptapeNodes.ConfigManager().get_config_value("workspace_directory"))
+    full_file_path = workspace_directory / file_path
 
     # Create parent directories if they don't exist
-    file_full_path.parent.mkdir(parents=True, exist_ok=True)
+    full_file_path.parent.mkdir(parents=True, exist_ok=True)
 
     data = await request.body()
     try:
-        file_full_path.write_bytes(data)
+        full_file_path.write_bytes(data)
     except binascii.Error as e:
         msg = f"Invalid base64 encoding for file {file_path}."
         logger.error(msg)
         raise HTTPException(status_code=400, detail=msg) from e
     except (OSError, PermissionError) as e:
-        msg = f"Failed to write file {file_path} to {static_dir}: {e}"
+        msg = f"Failed to write file {full_file_path}: {e}"
         logger.error(msg)
         raise HTTPException(status_code=500, detail=msg) from e
 
@@ -88,19 +76,28 @@ async def _create_static_file(
     return {"url": static_url}
 
 
+@app.get("/static-uploads/{file_path_prefix:path}")
 @app.get("/static-uploads/")
-async def _list_static_files(static_directory: Annotated[Path, Depends(get_static_dir)]) -> dict:
-    """List all static files in the static server."""
+async def _list_static_files(file_path_prefix: str = "") -> dict:
+    """List static files in the static server under the specified path prefix."""
     if not STATIC_SERVER_ENABLED:
         msg = "Static server is not enabled. Please set STATIC_SERVER_ENABLED to True."
         raise HTTPException(status_code=500, detail=msg)
 
+    workspace_directory = Path(GriptapeNodes.ConfigManager().get_config_value("workspace_directory"))
+
+    # Handle the prefix path
+    if file_path_prefix:
+        target_directory = workspace_directory / file_path_prefix
+    else:
+        target_directory = workspace_directory
+
     try:
         file_names = []
-        if static_directory.exists():
-            for file_path in static_directory.rglob("*"):
+        if target_directory.exists() and target_directory.is_dir():
+            for file_path in target_directory.rglob("*"):
                 if file_path.is_file():
-                    relative_path = file_path.relative_to(static_directory)
+                    relative_path = file_path.relative_to(workspace_directory)
                     file_names.append(str(relative_path))
     except (OSError, PermissionError) as e:
         msg = f"Failed to list files in static directory: {e}"
@@ -111,13 +108,14 @@ async def _list_static_files(static_directory: Annotated[Path, Depends(get_stati
 
 
 @app.delete("/static-files/{file_path:path}")
-async def _delete_static_file(file_path: str, static_directory: Annotated[Path, Depends(get_static_dir)]) -> dict:
+async def _delete_static_file(file_path: str) -> dict:
     """Delete a static file from the static server."""
     if not STATIC_SERVER_ENABLED:
         msg = "Static server is not enabled. Please set STATIC_SERVER_ENABLED to True."
         raise HTTPException(status_code=500, detail=msg)
 
-    file_full_path = Path(static_directory / file_path)
+    workspace_directory = Path(GriptapeNodes.ConfigManager().get_config_value("workspace_directory"))
+    file_full_path = workspace_directory / file_path
 
     # Check if file exists
     if not file_full_path.exists():
@@ -141,13 +139,10 @@ async def _delete_static_file(file_path: str, static_directory: Annotated[Path,
         return {"message": f"File {file_path} deleted successfully"}
 
 
-def _setup_app(static_directory: Path) -> None:
+def _setup_app() -> None:
     """Setup FastAPI app with middleware and static files."""
-    global static_dir  # noqa: PLW0603
-    static_dir = static_directory
-
-    if not static_dir.exists():
-        static_dir.mkdir(parents=True, exist_ok=True)
+    workspace_directory = Path(GriptapeNodes.ConfigManager().get_config_value("workspace_directory"))
+    static_files_directory = Path(GriptapeNodes.ConfigManager().get_config_value("static_files_directory"))
 
     app.add_middleware(
         CORSMiddleware,
@@ -163,15 +158,23 @@ def _setup_app(static_directory: Path) -> None:
 
     app.mount(
         STATIC_SERVER_URL,
-        StaticFiles(directory=static_directory),
+        StaticFiles(directory=workspace_directory),
+        name="workspace",
+    )
+    static_files_path = workspace_directory / static_files_directory
+    static_files_path.mkdir(parents=True, exist_ok=True)
+    # For legacy urls
+    app.mount(
+        "/static",
+        StaticFiles(directory=workspace_directory / static_files_directory),
         name="static",
     )
 
 
-def start_static_server(static_directory: Path) -> None:
+def start_static_server() -> None:
     """Run uvicorn server synchronously using uvicorn.run."""
     # Setup the FastAPI app
-    _setup_app(static_directory)
+    _setup_app()
 
     try:
         # Run server using uvicorn.run

griptape_nodes/traits/add_param_button.py

@@ -11,7 +11,7 @@ class AddParameterButton(Trait):
 
     def __init__(self) -> None:
         super().__init__(element_id="AddParameterButton")
-        self.add_child(Button(button_type="AddParameter"))
+        self.add_child(Button(label="AddParameter"))
 
     @classmethod
     def get_trait_keys(cls) -> list[str]:

griptape_nodes/traits/button.py

@@ -1,21 +1,349 @@
+import logging
 from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Literal, get_args
 
-from griptape_nodes.exe_types.core_types import Trait
+from griptape_nodes.exe_types.core_types import NodeMessagePayload, NodeMessageResult, Trait
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+# Don't export callback types - let users import explicitly
+
+logger = logging.getLogger("griptape_nodes")
+
+
+# Type aliases using Literals
+ButtonVariant = Literal[
+    "default",
+    "secondary",
+    "destructive",
+    "outline",
+    "ghost",
+    "link",
+]
+
+ButtonSize = Literal[
+    "default",
+    "sm",
+    "icon",
+]
+
+ButtonState = Literal[
+    "normal",
+    "disabled",
+    "loading",
+    "hidden",
+]
+
+IconPosition = Literal[
+    "left",
+    "right",
+]
+
+
+class ButtonDetailsMessagePayload(NodeMessagePayload):
+    """Payload containing complete button details and status information."""
+
+    label: str
+    variant: str
+    size: str
+    state: str
+    icon: str | None = None
+    icon_class: str | None = None
+    icon_position: str | None = None
+    full_width: bool = False
+    loading_label: str | None = None
+    loading_icon: str | None = None
+    loading_icon_class: str | None = None
+
+
+class OnClickMessageResultPayload(NodeMessagePayload):
+    """Payload for button click result messages."""
+
+    button_details: ButtonDetailsMessagePayload
+
+
+class SetButtonStatusMessagePayload(NodeMessagePayload):
+    """Payload for setting button status with explicit field updates."""
+
+    updates: dict[str, str | bool | None]
 
 
 @dataclass(eq=False)
 class Button(Trait):
-    type: str = field(default_factory=lambda: "Generic")
+    # Specific callback types for better type safety and clarity
+    type OnClickCallback = Callable[[Button, ButtonDetailsMessagePayload], NodeMessageResult | None]
+    type GetButtonStateCallback = Callable[[Button, ButtonDetailsMessagePayload], NodeMessageResult | None]
+
+    # Static message type constants
+    ON_CLICK_MESSAGE_TYPE = "on_click"
+    GET_BUTTON_STATUS_MESSAGE_TYPE = "get_button_status"
+    SET_BUTTON_STATUS_MESSAGE_TYPE = "set_button_status"
+
+    # Button styling and behavior properties
+    label: str = "Button"
+    variant: ButtonVariant = "default"
+    size: ButtonSize = "default"
+    state: ButtonState = "normal"
+    icon: str | None = None
+    icon_class: str | None = None
+    icon_position: IconPosition | None = None
+    full_width: bool = False
+    loading_label: str | None = None
+    loading_icon: str | None = None
+    loading_icon_class: str | None = None
+
     element_id: str = field(default_factory=lambda: "Button")
+    on_click_callback: OnClickCallback | None = field(default=None, init=False)
+    get_button_state_callback: GetButtonStateCallback | None = field(default=None, init=False)
 
-    def __init__(self, button_type: str | None = None) -> None:
+    def __init__(  # noqa: PLR0913
+        self,
+        *,
+        label: str = "",  # Allows a button with no text.
+        variant: ButtonVariant = "secondary",
+        size: ButtonSize = "default",
+        state: ButtonState = "normal",
+        icon: str | None = None,
+        icon_class: str | None = None,
+        icon_position: IconPosition | None = None,
+        full_width: bool = False,
+        loading_label: str | None = None,
+        loading_icon: str | None = None,
+        loading_icon_class: str | None = None,
+        on_click: OnClickCallback | None = None,
+        get_button_state: GetButtonStateCallback | None = None,
+    ) -> None:
         super().__init__(element_id="Button")
-        if button_type:
-            self.type = button_type
+        self.label = label
+        self.variant = variant
+        self.size = size
+        self.state = state
+        self.icon = icon
+        self.icon_class = icon_class
+        self.icon_position = icon_position
+        self.full_width = full_width
+        self.loading_label = loading_label
+        self.loading_icon = loading_icon
+        self.loading_icon_class = loading_icon_class
+        self.on_click_callback = on_click
+        self.get_button_state_callback = get_button_state
 
     @classmethod
     def get_trait_keys(cls) -> list[str]:
         return ["button", "addbutton"]
 
+    def get_button_details(self, state: ButtonState | None = None) -> ButtonDetailsMessagePayload:
+        """Create a ButtonDetailsMessagePayload with current or specified button state."""
+        return ButtonDetailsMessagePayload(
+            label=self.label,
+            variant=self.variant,
+            size=self.size,
+            state=state or self.state,
+            icon=self.icon,
+            icon_class=self.icon_class,
+            icon_position=self.icon_position,
+            full_width=self.full_width,
+            loading_label=self.loading_label,
+            loading_icon=self.loading_icon,
+            loading_icon_class=self.loading_icon_class,
+        )
+
     def ui_options_for_trait(self) -> dict:
-        return {"button": self.type}
+        """Generate UI options for the button trait with all styling properties."""
+        options = {
+            "button_label": self.label,
+            "variant": self.variant,
+            "size": self.size,
+            "state": self.state,
+            "full_width": self.full_width,
+        }
+
+        # Only include icon properties if icon is specified
+        if self.icon:
+            options["button_icon"] = self.icon
+            options["iconPosition"] = self.icon_position or "left"
+            if self.icon_class:
+                options["icon_class"] = self.icon_class
+
+        # Include loading properties if specified
+        if self.loading_label:
+            options["loading_label"] = self.loading_label
+        if self.loading_icon:
+            options["loading_icon"] = self.loading_icon
+        if self.loading_icon_class:
+            options["loading_icon_class"] = self.loading_icon_class
+
+        return options
+
+    def on_message_received(self, message_type: str, message: NodeMessagePayload | None) -> NodeMessageResult | None:  # noqa: PLR0911
+        """Handle messages sent to this button trait.
+
+        Args:
+            message_type: String indicating the message type for parsing
+            message: Message payload as NodeMessagePayload or None
+
+        Returns:
+            NodeMessageResult | None: Result if handled, None if no handler available
+        """
+        match message_type.lower():
+            case self.ON_CLICK_MESSAGE_TYPE:
+                if self.on_click_callback is not None:
+                    try:
+                        # Pre-fill button details with current state and pass to callback
+                        button_details = self.get_button_details()
+                        result = self.on_click_callback(self, button_details)
+
+                        # If callback returns None, provide optimistic success result
+                        if result is None:
+                            result = NodeMessageResult(
+                                success=True,
+                                details=f"Button '{self.label}' clicked successfully",
+                                response=button_details,
+                            )
+                        return result  # noqa: TRY300
+                    except Exception as e:
+                        return NodeMessageResult(
+                            success=False,
+                            details=f"Button '{self.label}' callback failed: {e!s}",
+                            response=None,
+                        )
+
+                # Log debug message and fall through if no callback specified
+                logger.debug("Button '%s' was clicked, but no on_click_callback was specified.", self.label)
+
+            case self.GET_BUTTON_STATUS_MESSAGE_TYPE:
+                # Use custom callback if provided, otherwise use default implementation
+                if self.get_button_state_callback is not None:
+                    try:
+                        # Pre-fill button details with current state and pass to callback
+                        button_details = self.get_button_details()
+                        result = self.get_button_state_callback(self, button_details)
+
+                        # If callback returns None, provide optimistic success result
+                        if result is None:
+                            result = NodeMessageResult(
+                                success=True,
+                                details=f"Button '{self.label}' state retrieved successfully",
+                                response=button_details,
+                                altered_workflow_state=False,
+                            )
+                        return result  # noqa: TRY300
+                    except Exception as e:
+                        return NodeMessageResult(
+                            success=False,
+                            details=f"Button '{self.label}' get_button_state callback failed: {e!s}",
+                            response=None,
+                        )
+                else:
+                    return self._default_get_button_status(message_type, message)
+
+            case self.SET_BUTTON_STATUS_MESSAGE_TYPE:
+                return self._handle_set_button_status(message)
+
+        # Delegate to parent implementation for unhandled messages or no callback
+        return super().on_message_received(message_type, message)
+
+    def _default_get_button_status(
+        self,
+        message_type: str,  # noqa: ARG002
+        message: NodeMessagePayload | None,  # noqa: ARG002
+    ) -> NodeMessageResult:
+        """Default implementation for get_button_status that returns current button details."""
+        button_details = self.get_button_details()
+
+        return NodeMessageResult(
+            success=True,
+            details=f"Button '{self.label}' details retrieved",
+            response=button_details,
+            altered_workflow_state=False,
+        )
+
+    def _handle_set_button_status(self, message: NodeMessagePayload | None) -> NodeMessageResult:  # noqa: C901
+        """Handle set button status messages by updating fields specified in the updates dict."""
+        if not message:
+            return NodeMessageResult(
+                success=False,
+                details="No message payload provided for set_button_status",
+                response=None,
+                altered_workflow_state=False,
+            )
+
+        if not isinstance(message, SetButtonStatusMessagePayload):
+            return NodeMessageResult(
+                success=False,
+                details="Invalid message payload type for set_button_status",
+                response=None,
+                altered_workflow_state=False,
+            )
+
+        # Track which fields were updated
+        updated_fields = []
+        validation_errors = []
+
+        # Valid field names and their expected types
+        valid_fields = {
+            "label": str,
+            "variant": str,  # Will validate against ButtonVariant literals
+            "size": str,  # Will validate against ButtonSize literals
+            "state": str,  # Will validate against ButtonState literals
+            "icon": str,
+            "icon_class": str,
+            "icon_position": str,  # Will validate against IconPosition literals
+            "full_width": bool,
+            "loading_label": str,
+            "loading_icon": str,
+            "loading_icon_class": str,
+        }
+
+        # Process each update
+        for field_name, value in message.updates.items():
+            # Check if field is valid
+            if field_name not in valid_fields:
+                validation_errors.append(f"Invalid field: {field_name}")
+                continue
+
+            # Type check if value is not None
+            if value is not None and not isinstance(value, valid_fields[field_name]):
+                validation_errors.append(
+                    f"Invalid type for {field_name}: expected {valid_fields[field_name].__name__}, got {type(value).__name__}"
+                )
+                continue
+
+            # Additional validation for Literal types
+            if field_name == "variant" and value is not None and value not in get_args(ButtonVariant):
+                validation_errors.append(f"Invalid variant: {value}")
+                continue
+            if field_name == "size" and value is not None and value not in get_args(ButtonSize):
+                validation_errors.append(f"Invalid size: {value}")
+                continue
+            if field_name == "state" and value is not None and value not in get_args(ButtonState):
+                validation_errors.append(f"Invalid state: {value}")
+                continue
+            if field_name == "icon_position" and value is not None and value not in get_args(IconPosition):
+                validation_errors.append(f"Invalid icon_position: {value}")
+                continue
+
+            # Update the field
+            setattr(self, field_name, value)
+            updated_fields.append(field_name)
+
+        # Return validation errors if any
+        if validation_errors:
+            return NodeMessageResult(
+                success=False,
+                details=f"Validation errors: {'; '.join(validation_errors)}",
+                response=None,
+                altered_workflow_state=False,
+            )
+
+        # Return success with updated button details
+        button_details = self.get_button_details()
+        fields_str = ", ".join(updated_fields) if updated_fields else "no fields"
+
+        return NodeMessageResult(
+            success=True,
+            details=f"Button '{self.label}' updated ({fields_str})",
+            response=button_details,
+            altered_workflow_state=True,
+        )

griptape_nodes/traits/color_picker.py

@@ -0,0 +1,66 @@
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+from griptape_nodes.exe_types.core_types import Parameter, ParameterMode, Trait
+
+
+@dataclass(eq=False)
+class ColorPicker(Trait):
+    format: Literal["hex", "hexa", "rgb", "rgba", "hsl", "hsla", "hsv", "hsva"] = "hex"
+    element_id: str = field(default_factory=lambda: "ColorPicker")
+
+    _allowed_modes: set = field(default_factory=lambda: {ParameterMode.PROPERTY})
+
+    def __init__(self, format: Literal["hex", "hexa", "rgb", "rgba", "hsl", "hsla", "hsv", "hsva"] = "hex") -> None:  # noqa: A002
+        super().__init__()
+        self.format = format
+
+    @classmethod
+    def get_trait_keys(cls) -> list[str]:
+        return ["color_picker"]
+
+    def ui_options_for_trait(self) -> dict:
+        return {"color_picker": {"format": self.format}}
+
+    def _validate_hex_format(self, value: str) -> None:
+        """Validate hex and hexa color formats."""
+        if not value.startswith("#"):
+            # Allow hex without # prefix
+            if len(value) in [6, 8] and all(c in "0123456789ABCDEFabcdef" for c in value):
+                return  # Valid hex without # prefix
+            msg = f"Invalid {self.format} format: {value}. Expected format like #FF0000 or #FF000088"
+            raise ValueError(msg)
+        if self.format == "hex" and len(value) not in [4, 7]:  # #fff or #ffffff
+            msg = f"Invalid hex format: {value}. Expected format like #FF0000 or #FFF"
+            raise ValueError(msg)
+        if self.format == "hexa" and len(value) not in [5, 9]:  # #ffff or #ffffffff
+            msg = f"Invalid hexa format: {value}. Expected format like #FF000088 or #FFFF"
+            raise ValueError(msg)
+
+    def _validate_function_format(self, value: str, prefixes: tuple[str, ...], example: str) -> None:
+        """Validate function-based color formats (rgb, hsl, hsv)."""
+        if not value.startswith(prefixes):
+            msg = f"Invalid {self.format} format: {value}. Expected format like {example}"
+            raise ValueError(msg)
+
+    def validators_for_trait(self) -> list[Callable[..., Any]]:
+        def validate(param: Parameter, value: Any) -> None:  # noqa: ARG001
+            if value is None:
+                return
+
+            if not isinstance(value, str):
+                msg = f"Color value must be a string for format {self.format}"
+                raise TypeError(msg)
+
+            # Validate based on format
+            if self.format in ["hex", "hexa"]:
+                self._validate_hex_format(value)
+            elif self.format in ["rgb", "rgba"]:
+                self._validate_function_format(value, ("rgb(", "rgba("), "rgb(255, 255, 255)")
+            elif self.format in ["hsl", "hsla"]:
+                self._validate_function_format(value, ("hsl(", "hsla("), "hsl(0, 0%, 100%)")
+            elif self.format in ["hsv", "hsva"]:
+                self._validate_function_format(value, ("hsv(", "hsva("), "hsv(0, 0%, 100%)")
+
+        return [validate]