griptape-nodes 0.55.1__py3-none-any.whl → 0.56.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/library_manager.py

@@ -2041,32 +2041,26 @@ class LibraryManager:
         config_mgr = GriptapeNodes.ConfigManager()
         user_libraries_section = "app_events.on_app_initialization_complete.libraries_to_register"
 
-        libraries_to_process = []
-
-        # Add from config
-        config_libraries = config_mgr.get_config_value(user_libraries_section, default=[])
-        libraries_to_process.extend(config_libraries)
-
-        # Add from workspace - recursive discovery of library JSON files
-        workspace_path = config_mgr.workspace_path
-        libraries_to_process.append(str(workspace_path))
-
-        library_files = []
+        discovered_libraries = set()
 
         def process_path(path: Path) -> None:
             """Process a path, handling both files and directories."""
             if path.is_dir():
                 # Process all library JSON files recursively in the directory
-                library_files.extend(path.rglob(LibraryManager.LIBRARY_CONFIG_FILENAME))
+                discovered_libraries.update(path.rglob(LibraryManager.LIBRARY_CONFIG_FILENAME))
             elif path.suffix == ".json":
-                library_files.append(path)
+                discovered_libraries.add(path)
 
-        # Process library paths
-        for library_to_process in libraries_to_process:
-            library_path = Path(library_to_process)
-
-            # Handle library config files and directories only (skip requirement specifiers)
+        # Add from config
+        config_libraries = config_mgr.get_config_value(user_libraries_section, default=[])
+        for library_path_str in config_libraries:
+            library_path = Path(library_path_str)
             if library_path.exists():
                 process_path(library_path)
 
-        return library_files
+        # Add from workspace - recursive discovery of library JSON files
+        workspace_path = config_mgr.workspace_path
+        if workspace_path.exists():
+            process_path(workspace_path)
+
+        return list(discovered_libraries)

griptape_nodes/retained_mode/managers/model_manager.py

@@ -65,6 +65,17 @@ class SearchResultsData:
     query_info: QueryInfo
 
 
+@dataclass
+class DownloadParams:
+    """Data class for model download parameters."""
+
+    model_id: str
+    local_dir: str | None = None
+    revision: str | None = None
+    allow_patterns: list[str] | None = None
+    ignore_patterns: list[str] | None = None
+
+
 class ModelDownloadTracker(tqdm):
     """Custom tqdm progress bar that tracks aggregate model download progress."""
 
@@ -129,7 +140,7 @@ class ModelDownloadTracker(tqdm):
                 status_file = self._get_status_file_path()
                 current_time = datetime.now(UTC).isoformat()
 
-                logger.info(
+                logger.debug(
                     "ModelDownloadTracker initializing status file: %s (total_files=%s)", status_file, self.total
                 )
 
@@ -146,7 +157,7 @@ class ModelDownloadTracker(tqdm):
                 with status_file.open("w") as f:
                     json.dump(data, f, indent=2)
 
-                logger.info("ModelDownloadTracker status file initialized successfully")
+                logger.debug("ModelDownloadTracker status file initialized successfully")
 
         except Exception:
             logger.exception("ModelDownloadTracker._init_status_file failed")
@@ -295,7 +306,7 @@ class ModelManager:
     async def on_handle_download_model_request(self, request: DownloadModelRequest) -> ResultPayload:
         """Handle model download requests asynchronously.
 
-        This method starts a background task to download models from Hugging Face Hub using the provided parameters.
+        This method downloads models from Hugging Face Hub using the provided parameters.
         It supports both model IDs and full URLs, and can download entire repositories
         or specific files based on the patterns provided.
 
@@ -303,89 +314,127 @@ class ModelManager:
             request: The download request containing model ID and options
 
         Returns:
-            ResultPayload: Success result indicating download started or failure with error details
+            ResultPayload: Success result with download completion or failure with error details
         """
         parsed_model_id = self._parse_model_id(request.model_id)
         if parsed_model_id != request.model_id:
             logger.debug("Parsed model ID '%s' from URL '%s'", parsed_model_id, request.model_id)
 
         try:
-            download_params = {
-                "model_id": parsed_model_id,
-                "local_dir": request.local_dir,
-                "revision": request.revision,
-                "allow_patterns": request.allow_patterns,
-                "ignore_patterns": request.ignore_patterns,
-            }
+            download_params = DownloadParams(
+                model_id=parsed_model_id,
+                local_dir=request.local_dir,
+                revision=request.revision,
+                allow_patterns=request.allow_patterns,
+                ignore_patterns=request.ignore_patterns,
+            )
 
             task = asyncio.create_task(self._download_model_task(download_params))
             self._download_tasks[parsed_model_id] = task
 
-            result_details = f"Started background download for model '{parsed_model_id}'"
+            await task
+            self._update_download_status_success(parsed_model_id)
+        except asyncio.CancelledError:
+            # Handle task cancellation gracefully
+            logger.info("Download request cancelled for model '%s'", parsed_model_id)
 
             return DownloadModelResultSuccess(
                 model_id=parsed_model_id,
-                result_details=result_details,
+                result_details=f"Successfully downloaded model '{parsed_model_id}'",
             )
 
         except Exception as e:
-            error_msg = f"Failed to start download for model '{request.model_id}': {e}"
+            error_msg = f"Failed to download model '{request.model_id}': {e}"
+            # Update status file to mark download as failed due to cancellation
+            self._update_download_status_failure(parsed_model_id, error_msg)
+
             return DownloadModelResultFailure(
                 result_details=error_msg,
                 exception=e,
             )
+        else:
+            return DownloadModelResultSuccess(
+                model_id=parsed_model_id,
+                result_details=f"Successfully downloaded model '{parsed_model_id}'",
+            )
+        finally:
+            # Clean up the task reference
+            if parsed_model_id in self._download_tasks:
+                del self._download_tasks[parsed_model_id]
 
-    async def _download_model_task(self, download_params: dict[str, str | list[str] | None]) -> None:
-        """Background task for downloading a model using CLI command.
+    def _get_download_local_path(self, params: DownloadParams) -> str:
+        """Get the local path where the model was downloaded.
 
         Args:
-            download_params: Dictionary containing download parameters
-        """
-        model_id = download_params["model_id"]
-        logger.info("Starting background download for model: %s", model_id)
+            params: Download parameters
 
-        # Build CLI command arguments
-        cmd = [sys.executable, "-m", "griptape_nodes", "models", "download", str(model_id)]
+        Returns:
+            Local path where the model is stored
+        """
+        if params.local_dir:
+            return params.local_dir
 
-        # Add optional parameters
-        if download_params.get("local_dir"):
-            cmd.extend(["--local-dir", str(download_params["local_dir"])])
-        if download_params.get("revision") and download_params["revision"] != "main":
-            cmd.extend(["--revision", str(download_params["revision"])])
+        # Otherwise, use the HuggingFace cache directory
+        from huggingface_hub import snapshot_download
 
         try:
-            # Start subprocess
-            process = await asyncio.create_subprocess_exec(
-                *cmd,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
+            # Get the path without actually downloading (since it's already downloaded)
+            return snapshot_download(
+                repo_id=params.model_id,
+                repo_type="model",
+                revision=params.revision,
+                local_files_only=True,  # Only check local cache
             )
+        except Exception:
+            # Fallback: construct the expected cache path
+            from huggingface_hub.constants import HF_HUB_CACHE
 
+            cache_path = Path(HF_HUB_CACHE)
+            return str(cache_path / f"models--{params.model_id.replace('/', '--')}")
+
+    async def _download_model_task(self, download_params: DownloadParams) -> None:
+        """Background task for downloading a model using CLI command.
+
+        Args:
+            download_params: Download parameters
+
+        Returns:
+            str: Local path where the model was downloaded
+
+        Raises:
+            Exception: If download fails
+        """
+        model_id = download_params.model_id
+        logger.info("Starting download for model: %s", model_id)
+
+        # Build CLI command
+        cmd = [sys.executable, "-m", "griptape_nodes", "models", "download", download_params.model_id]
+
+        if download_params.local_dir:
+            cmd.extend(["--local-dir", download_params.local_dir])
+        if download_params.revision and download_params.revision != "main":
+            cmd.extend(["--revision", download_params.revision])
+
+        # Start subprocess
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+
+        try:
             # Store process for cancellation
-            if isinstance(model_id, str):
-                self._download_processes[model_id] = process
+            self._download_processes[model_id] = process
 
-            # Wait for completion (this can be cancelled)
-            stdout, stderr = await process.communicate()
+            stdout, _ = await process.communicate()
 
             if process.returncode == 0:
                 logger.info("Successfully downloaded model '%s'", model_id)
             else:
-                logger.error("Download failed for model '%s': %s", model_id, stderr.decode())
-
-        except asyncio.CancelledError:
-            logger.info("Download cancelled for model '%s'", model_id)
-            raise
-
-        except Exception:
-            logger.exception("Error downloading model '%s'", model_id)
-
+                raise ValueError(stdout.decode().strip())
         finally:
-            if isinstance(model_id, str):
-                if model_id in self._download_tasks:
-                    del self._download_tasks[model_id]
-                if model_id in self._download_processes:
-                    del self._download_processes[model_id]
+            if model_id in self._download_processes:
+                del self._download_processes[model_id]
 
     async def on_handle_list_models_request(self, request: ListModelsRequest) -> ResultPayload:  # noqa: ARG002
         """Handle model listing requests asynchronously.
@@ -612,48 +661,28 @@ class ModelManager:
         # Create download tasks for concurrent execution
         download_tasks = []
         for model_id in all_models:
-            task = asyncio.create_task(self._download_model_with_logging(model_id))
+            task = asyncio.create_task(
+                self.on_handle_download_model_request(
+                    DownloadModelRequest(
+                        model_id=model_id,
+                        local_dir=None,
+                        revision="main",
+                        allow_patterns=None,
+                        ignore_patterns=None,
+                    )
+                )
+            )
             download_tasks.append(task)
 
         # Wait for all downloads to complete
         results = await asyncio.gather(*download_tasks, return_exceptions=True)
 
         # Log summary of results
-        successful = sum(1 for result in results if not isinstance(result, Exception))
+        successful = sum(1 for result in results if not isinstance(result, DownloadModelResultFailure))
         failed = len(results) - successful
 
         logger.info("Completed automatic model downloads: %d successful, %d failed", successful, failed)
 
-    async def _download_model_with_logging(self, model_id: str) -> None:
-        """Download a single model with proper logging.
-
-        Args:
-            model_id: The model ID to download
-        """
-        logger.info("Auto-downloading model: %s", model_id)
-
-        # Create download request with default parameters
-        request = DownloadModelRequest(
-            model_id=model_id,
-            local_dir=None,  # Use default cache directory
-            revision="main",
-            allow_patterns=None,
-            ignore_patterns=None,
-        )
-
-        try:
-            # Run the download asynchronously
-            result = await self.on_handle_download_model_request(request)
-
-            if isinstance(result, DownloadModelResultFailure):
-                logger.warning("Failed to auto-download model '%s': %s", model_id, result.result_details)
-            elif not isinstance(result, DownloadModelResultSuccess):
-                logger.warning("Unknown result type for model '%s' download: %s", model_id, type(result))
-
-        except Exception as e:
-            logger.error("Unexpected error auto-downloading model '%s': %s", model_id, e)
-            raise
-
     def _get_status_file_path(self, model_id: str) -> Path:
         """Get the path to the status file for a model.
 
@@ -1050,7 +1079,7 @@ class ModelManager:
                 task = self._download_tasks[model_id]
                 if not task.done():
                     task.cancel()
-                    logger.info("Cancelled active download task for model '%s'", model_id)
+                    logger.debug("Cancelled active download task for model '%s'", model_id)
                 del self._download_tasks[model_id]
 
             # Delete status file
@@ -1105,3 +1134,75 @@ class ModelManager:
 
         status_file.unlink()
         return str(status_file)
+
+    def _update_download_status_failure(self, model_id: str, error_message: str) -> None:
+        """Update the status file to mark download as failed.
+
+        Args:
+            model_id: The model ID that failed to download
+            error_message: The error message describing the failure
+        """
+        try:
+            status_file = self._get_status_file_path(model_id)
+
+            if not status_file.exists():
+                logger.warning("Status file does not exist for failed model '%s'", model_id)
+                return
+
+            with status_file.open() as f:
+                data = json.load(f)
+
+            current_time = datetime.now(UTC).isoformat()
+
+            data.update(
+                {
+                    "status": "failed",
+                    "updated_at": current_time,
+                    "failed_at": current_time,
+                    "error_message": error_message,
+                }
+            )
+
+            with status_file.open("w") as f:
+                json.dump(data, f, indent=2)
+
+            logger.debug("Updated status file to 'failed' for model '%s'", model_id)
+
+        except Exception:
+            logger.exception("Failed to update status file for failed model '%s'", model_id)
+
+    def _update_download_status_success(self, model_id: str) -> None:
+        """Update the status file to mark download as completed.
+
+        Args:
+            model_id: The model ID that was successfully downloaded
+            local_path: The local path where the model was downloaded
+        """
+        try:
+            status_file = self._get_status_file_path(model_id)
+
+            if not status_file.exists():
+                logger.warning("Status file does not exist for completed model '%s'", model_id)
+                return
+
+            with status_file.open() as f:
+                data = json.load(f)
+
+            current_time = datetime.now(UTC).isoformat()
+
+            data.update(
+                {
+                    "status": "completed",
+                    "updated_at": current_time,
+                    "completed_at": current_time,
+                    "progress_percent": 100.0,
+                }
+            )
+
+            with status_file.open("w") as f:
+                json.dump(data, f, indent=2)
+
+            logger.debug("Updated status file to 'completed' for model '%s'", model_id)
+
+        except Exception:
+            logger.exception("Failed to update status file for completed model '%s'", model_id)

griptape_nodes/retained_mode/managers/node_manager.py

@@ -446,7 +446,7 @@ class NodeManager:
             # get the current node executing / resolving
             # if it's in connected nodes, cancel flow.
             # otherwise, leave it.
-            control_node_names, resolving_node_names, _ = GriptapeNodes.FlowManager().flow_state(parent_flow)
+            control_node_names, resolving_node_names = GriptapeNodes.FlowManager().flow_state(parent_flow)
             connected_nodes = parent_flow.get_all_connected_nodes(node)
             cancelled = False
             if control_node_names is not None:
@@ -2061,7 +2061,7 @@ class NodeManager:
             # Normal node - use current parameter values
             for parameter in node.parameters:
                 # SetParameterValueRequest event
-                set_param_value_requests = NodeManager._handle_parameter_value_saving(
+                set_param_value_requests = NodeManager.handle_parameter_value_saving(
                     parameter=parameter,
                     node=node,
                     unique_parameter_uuid_to_values=request.unique_parameter_uuid_to_values,
@@ -2482,7 +2482,7 @@ class NodeManager:
         return indirect_set_value_command
 
     @staticmethod
-    def _handle_parameter_value_saving(
+    def handle_parameter_value_saving(
         parameter: Parameter,
         node: BaseNode,
         unique_parameter_uuid_to_values: dict[SerializedNodeCommands.UniqueParameterValueUUID, Any],

griptape_nodes/retained_mode/managers/os_manager.py

@@ -12,6 +12,7 @@ from typing import Any
 from binaryornot.check import is_binary
 from rich.console import Console
 
+from griptape_nodes.retained_mode.events.app_events import AppInitializationComplete
 from griptape_nodes.retained_mode.events.base_events import ResultDetails, ResultPayload
 from griptape_nodes.retained_mode.events.os_events import (
     CreateFileRequest,
@@ -31,8 +32,16 @@ from griptape_nodes.retained_mode.events.os_events import (
     RenameFileResultFailure,
     RenameFileResultSuccess,
 )
+from griptape_nodes.retained_mode.events.resource_events import (
+    CreateResourceInstanceRequest,
+    CreateResourceInstanceResultSuccess,
+    RegisterResourceTypeRequest,
+    RegisterResourceTypeResultSuccess,
+)
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes, logger
 from griptape_nodes.retained_mode.managers.event_manager import EventManager
+from griptape_nodes.retained_mode.managers.resource_types.cpu_resource import CPUResourceType
+from griptape_nodes.retained_mode.managers.resource_types.os_resource import OSResourceType
 
 console = Console()
 
@@ -74,6 +83,9 @@ class OSManager:
                 request_type=RenameFileRequest, callback=self.on_rename_file_request
             )
 
+            # Register for app initialization event to setup system resources
+            event_manager.add_listener_to_app_event(AppInitializationComplete, self.on_app_initialization_complete)
+
     def _get_workspace_path(self) -> Path:
         """Get the workspace path from config."""
         return GriptapeNodes.ConfigManager().workspace_path
@@ -374,7 +386,7 @@ class OSManager:
                     try:
                         stat = entry.stat()
                         # Get path relative to workspace if within workspace
-                        is_entry_in_workspace, entry_path = self._validate_workspace_path(entry)
+                        _is_entry_in_workspace, entry_path = self._validate_workspace_path(entry)
                         mime_type = self._detect_mime_type(entry)
                         entries.append(
                             FileSystemEntry(
@@ -843,3 +855,108 @@ class OSManager:
             msg = f"Failed to rename {request.old_path} to {request.new_path}: {e}"
             logger.error(msg)
             return RenameFileResultFailure(result_details=msg)
+
+    def on_app_initialization_complete(self, _payload: AppInitializationComplete) -> None:
+        """Handle app initialization complete event by registering system resources."""
+        self._register_system_resources()
+
+    # NEW Resource Management Methods
+    def _register_system_resources(self) -> None:
+        """Register OS and CPU resource types with ResourceManager and create system instances."""
+        self._attempt_generate_os_resources()
+        self._attempt_generate_cpu_resources()
+
+    def _attempt_generate_os_resources(self) -> None:
+        """Register OS resource type and create system OS instance if successful."""
+        # Register OS resource type
+        os_resource_type = OSResourceType()
+        register_request = RegisterResourceTypeRequest(resource_type=os_resource_type)
+        result = GriptapeNodes.handle_request(register_request)
+
+        if not isinstance(result, RegisterResourceTypeResultSuccess):
+            logger.error("Attempted to register OS resource type. Failed due to resource type registration failure")
+            return
+
+        logger.debug("Successfully registered OS resource type")
+        # Registration successful, now create instance
+        self._create_system_os_instance()
+
+    def _attempt_generate_cpu_resources(self) -> None:
+        """Register CPU resource type and create system CPU instance if successful."""
+        # Register CPU resource type
+        cpu_resource_type = CPUResourceType()
+        register_request = RegisterResourceTypeRequest(resource_type=cpu_resource_type)
+        result = GriptapeNodes.handle_request(register_request)
+
+        if not isinstance(result, RegisterResourceTypeResultSuccess):
+            logger.error("Attempted to register CPU resource type. Failed due to resource type registration failure")
+            return
+
+        logger.debug("Successfully registered CPU resource type")
+        # Registration successful, now create instance
+        self._create_system_cpu_instance()
+
+    def _create_system_os_instance(self) -> None:
+        """Create system OS instance."""
+        os_capabilities = {
+            "platform": self._get_platform_name(),
+            "arch": self._get_architecture(),
+            "version": self._get_platform_version(),
+        }
+        create_request = CreateResourceInstanceRequest(
+            resource_type_name="OSResourceType", capabilities=os_capabilities
+        )
+        result = GriptapeNodes.handle_request(create_request)
+
+        if not isinstance(result, CreateResourceInstanceResultSuccess):
+            logger.error(
+                "Attempted to create system OS resource instance. Failed due to resource instance creation failure"
+            )
+            return
+
+        logger.debug("Successfully created system OS instance: %s", result.instance_id)
+
+    def _create_system_cpu_instance(self) -> None:
+        """Create system CPU instance."""
+        cpu_capabilities = {
+            "cores": os.cpu_count() or 1,
+            "architecture": self._get_architecture(),
+        }
+        create_request = CreateResourceInstanceRequest(
+            resource_type_name="CPUResourceType", capabilities=cpu_capabilities
+        )
+        result = GriptapeNodes.handle_request(create_request)
+
+        if not isinstance(result, CreateResourceInstanceResultSuccess):
+            logger.error(
+                "Attempted to create system CPU resource instance. Failed due to resource instance creation failure"
+            )
+            return
+
+        logger.debug("Successfully created system CPU instance: %s", result.instance_id)
+
+    def _get_platform_name(self) -> str:
+        """Get platform name using existing sys.platform detection."""
+        if self.is_windows():
+            return "windows"
+        if self.is_mac():
+            return "darwin"
+        if self.is_linux():
+            return "linux"
+        return sys.platform
+
+    def _get_architecture(self) -> str:
+        """Get system architecture."""
+        try:
+            return os.uname().machine.lower()
+        except AttributeError:
+            # Windows doesn't have os.uname(), fallback to environment variable
+            return os.environ.get("PROCESSOR_ARCHITECTURE", "unknown").lower()
+
+    def _get_platform_version(self) -> str:
+        """Get platform version."""
+        try:
+            return os.uname().release
+        except AttributeError:
+            # Windows doesn't have os.uname(), return basic platform info
+            return sys.platform

griptape_nodes/retained_mode/managers/resource_components/__init__.py

@@ -0,0 +1 @@
+"""Resource components package."""

griptape_nodes/retained_mode/managers/resource_components/capability_field.py

@@ -0,0 +1,41 @@
+"""Capability field definition for resource schemas."""
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class CapabilityField:
+    """Definition of a single capability field."""
+
+    name: str
+    type_hint: type
+    description: str
+    required: bool = True
+    default: Any = None
+
+
+def validate_capabilities(schema: list[CapabilityField], capabilities: dict[str, Any]) -> list[str]:
+    """Validate capabilities against schema and return list of validation errors."""
+    errors = []
+
+    # Check required fields
+    for field in schema:
+        if field.required and field.name not in capabilities:
+            errors.append(f"Required field '{field.name}' is missing")  # noqa: PERF401
+
+    # Check field types (basic validation)
+    for field_name, value in capabilities.items():
+        schema_field = next((f for f in schema if f.name == field_name), None)
+        if schema_field:
+            # Handle numeric types (int/float are interchangeable)
+            if schema_field.type_hint in (int, float):
+                if not isinstance(value, (int, float)):
+                    errors.append(f"Field '{field_name}' should be numeric, got {type(value).__name__}")
+            # Standard type checking for all other types
+            elif not isinstance(value, schema_field.type_hint):
+                errors.append(
+                    f"Field '{field_name}' should be a {schema_field.type_hint.__name__}, got {type(value).__name__}"
+                )
+
+    return errors

griptape_nodes/retained_mode/managers/resource_components/comparator.py

@@ -0,0 +1,18 @@
+from enum import StrEnum
+
+
+class Comparator(StrEnum):
+    """String-based comparators for resource requirement matching."""
+
+    EQUALS = "=="
+    NOT_EQUALS = "!="
+    GREATER_THAN = ">"
+    GREATER_THAN_OR_EQUAL = ">="
+    LESS_THAN = "<"
+    LESS_THAN_OR_EQUAL = "<="
+    STARTS_WITH = "startswith"
+    INCLUDES = "includes"  # substring match
+    NOT_PRESENT = "~"  # key should not exist
+    HAS_ANY = "has_any"  # container has any of the required items
+    HAS_ALL = "has_all"  # container has all of the required items
+    CUSTOM = "custom"  # allows ResourceType to implement custom comparison logic