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

griptape_nodes/retained_mode/managers/resource_types/cpu_resource.py

@@ -0,0 +1,108 @@
+import logging
+from typing import TYPE_CHECKING, Any, Literal
+
+from griptape_nodes.retained_mode.managers.resource_components.capability_field import (
+    CapabilityField,
+    validate_capabilities,
+)
+from griptape_nodes.retained_mode.managers.resource_components.resource_instance import ResourceInstance
+from griptape_nodes.retained_mode.managers.resource_components.resource_type import ResourceType
+
+if TYPE_CHECKING:
+    from griptape_nodes.retained_mode.managers.resource_components.resource_instance import Requirements
+
+logger = logging.getLogger("griptape_nodes")
+
+
+# CPU capability field names
+CPUCapability = Literal[
+    "cores",
+    "threads",
+    "architecture",
+    "clock_speed_ghz",
+]
+
+
+class CPUInstance(ResourceInstance):
+    """Resource instance representing CPU compute resources."""
+
+    def can_be_freed(self) -> bool:
+        """CPU resources can typically be freed when not in use."""
+        return True
+
+    def free(self) -> None:
+        """Free CPU resource instance."""
+        logger.debug("Freeing CPU resource instance %s", self.get_instance_id())
+
+    def get_capability_typed(self, key: CPUCapability) -> Any:
+        """Type-safe capability getter using Literal types."""
+        return self.get_capability_value(key)
+
+
+class CPUResourceType(ResourceType):
+    """Resource type for CPU compute resources."""
+
+    def get_capability_schema(self) -> list[CapabilityField]:
+        """Get the capability schema for CPU resources."""
+        return [
+            CapabilityField(
+                name="cores",
+                type_hint=int,
+                description="Number of CPU cores",
+                required=True,
+            ),
+            CapabilityField(
+                name="threads",
+                type_hint=int,
+                description="Number of threads (with hyperthreading)",
+                required=False,
+            ),
+            CapabilityField(
+                name="architecture",
+                type_hint=str,
+                description="CPU architecture: 'x86_64', 'arm64', 'aarch64'",
+                required=True,
+            ),
+            CapabilityField(
+                name="clock_speed_ghz",
+                type_hint=float,
+                description="Base clock speed in GHz",
+                required=False,
+            ),
+        ]
+
+    def create_instance(self, capabilities: dict[str, Any]) -> ResourceInstance:
+        """Create a new CPU resource instance."""
+        # Validate capabilities against schema
+        validation_errors = validate_capabilities(self.get_capability_schema(), capabilities)
+        if validation_errors:
+            error_msg = f"Invalid CPU capabilities: {', '.join(validation_errors)}"
+            raise ValueError(error_msg)
+
+        return CPUInstance(resource_type=self, instance_id_prefix="cpu", capabilities=capabilities)
+
+    def select_best_compatible_instance(
+        self, compatible_instances: list[ResourceInstance], _requirements: "Requirements | None" = None
+    ) -> ResourceInstance | None:
+        """Select the best CPU instance from compatible ones.
+
+        Prioritizes CPUs with:
+        1. More cores
+        2. Higher clock speed
+        """
+        if not compatible_instances:
+            return None
+
+        def sort_key(instance: ResourceInstance) -> tuple[int, float]:
+            # More cores is better
+            cores = instance.get_capability_value("cores") if instance.has_capability("cores") else 1
+
+            # Higher clock speed is better
+            clock_speed = (
+                instance.get_capability_value("clock_speed_ghz") if instance.has_capability("clock_speed_ghz") else 0
+            )
+
+            return (int(cores), float(clock_speed))
+
+        sorted_instances = sorted(compatible_instances, key=sort_key, reverse=True)
+        return sorted_instances[0]

griptape_nodes/retained_mode/managers/resource_types/os_resource.py

@@ -0,0 +1,87 @@
+import logging
+from typing import TYPE_CHECKING, Any, Literal
+
+from griptape_nodes.retained_mode.managers.resource_components.capability_field import (
+    CapabilityField,
+    validate_capabilities,
+)
+from griptape_nodes.retained_mode.managers.resource_components.resource_instance import ResourceInstance
+from griptape_nodes.retained_mode.managers.resource_components.resource_type import ResourceType
+
+if TYPE_CHECKING:
+    from griptape_nodes.retained_mode.managers.resource_components.resource_instance import Requirements
+
+logger = logging.getLogger("griptape_nodes")
+
+
+# OS capability field names
+OSCapability = Literal[
+    "platform",
+    "arch",
+    "version",
+]
+
+
+class OSInstance(ResourceInstance):
+    """Resource instance representing an operating system environment."""
+
+    def can_be_freed(self) -> bool:
+        """OS resources can be freed when no longer needed."""
+        return True
+
+    def free(self) -> None:
+        """Free OS resource instance."""
+        logger.debug("Freeing OS resource instance %s", self.get_instance_id())
+
+    def get_capability_typed(self, key: OSCapability) -> Any:
+        """Type-safe capability getter using Literal types."""
+        return self.get_capability_value(key)
+
+
+class OSResourceType(ResourceType):
+    """Resource type for operating system environments."""
+
+    def get_capability_schema(self) -> list[CapabilityField]:
+        """Get the capability schema for OS resources."""
+        return [
+            CapabilityField(
+                name="platform",
+                type_hint=str,
+                description="Operating system platform: 'linux', 'darwin', 'windows'",
+                required=True,
+            ),
+            CapabilityField(
+                name="arch",
+                type_hint=str,
+                description="System architecture: 'x86_64', 'arm64', 'aarch64'",
+                required=True,
+            ),
+            CapabilityField(
+                name="version",
+                type_hint=str,
+                description="Operating system version string",
+                required=False,
+            ),
+        ]
+
+    def create_instance(self, capabilities: dict[str, Any]) -> ResourceInstance:
+        """Create a new OS resource instance."""
+        # Validate capabilities against schema
+        validation_errors = validate_capabilities(self.get_capability_schema(), capabilities)
+        if validation_errors:
+            error_msg = f"Invalid OS capabilities: {', '.join(validation_errors)}"
+            raise ValueError(error_msg)
+
+        return OSInstance(resource_type=self, instance_id_prefix="os", capabilities=capabilities)
+
+    def select_best_compatible_instance(
+        self, compatible_instances: list[ResourceInstance], _requirements: "Requirements | None" = None
+    ) -> ResourceInstance | None:
+        """Select the best OS instance from compatible ones.
+
+        Returns the first compatible instance (no special selection criteria for now).
+        """
+        if not compatible_instances:
+            return None
+
+        return compatible_instances[0]

griptape_nodes/retained_mode/managers/settings.py

@@ -210,3 +210,8 @@ class Settings(BaseModel):
         default="synced_workflows",
         description="Path to the synced workflows directory, relative to the workspace directory.",
     )
+    enable_workspace_file_watching: bool = Field(
+        category=FILE_SYSTEM,
+        default=True,
+        description="Enable file watching for synced workflows directory",
+    )

griptape_nodes/retained_mode/managers/sync_manager.py

@@ -164,8 +164,15 @@ class SyncManager:
         try:
             # Check if cloud storage is configured before attempting sync
             self._get_cloud_storage_driver()
-            # Start file watching after successful sync
-            self._start_file_watching()
+
+            # Check if file watching is enabled before starting it
+            enable_file_watching = self._config_manager.get_config_value("enable_workspace_file_watching", default=True)
+            if enable_file_watching:
+                # Start file watching after successful sync
+                self._start_file_watching()
+                logger.debug("File watching enabled - started watching synced workflows directory")
+            else:
+                logger.debug("File watching disabled - skipping file watching startup")
 
             logger.info("App initialization complete - starting automatic cloud workflow sync")
 
@@ -449,7 +456,7 @@ class SyncManager:
 
             # Collect results as they complete
             for future in future_to_filename:
-                filename, success, error = future.result()
+                filename, success, _error = future.result()
                 if success:
                     synced_workflows.append(filename)
                 else: