griptape-nodes 0.65.6__py3-none-any.whl → 0.66.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/resource_types/compute_resource.py

@@ -0,0 +1,82 @@
+import logging
+from enum import StrEnum
+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")
+
+
+class ComputeBackend(StrEnum):
+    """Supported compute backends."""
+
+    CPU = "cpu"
+    CUDA = "cuda"  # NVIDIA GPU
+    MPS = "mps"  # Apple Metal Performance Shaders
+
+
+# Compute capability field names
+ComputeCapability = Literal[
+    "compute",  # List of available compute backends: ["cpu", "cuda", "mps"]
+]
+
+
+class ComputeInstance(ResourceInstance):
+    """Resource instance representing available compute backends."""
+
+    def can_be_freed(self) -> bool:
+        """Compute resources can be freed when no longer needed."""
+        return True
+
+    def free(self) -> None:
+        """Free compute resource instance."""
+        logger.debug("Freeing compute resource instance %s", self.get_instance_id())
+
+    def get_capability_typed(self, key: ComputeCapability) -> Any:
+        """Type-safe capability getter using Literal types."""
+        return self.get_capability_value(key)
+
+
+class ComputeResourceType(ResourceType):
+    """Resource type for compute backend availability."""
+
+    def get_capability_schema(self) -> list[CapabilityField]:
+        """Get the capability schema for compute resources."""
+        return [
+            CapabilityField(
+                name="compute",
+                type_hint=list,
+                description="List of available compute backends: 'cpu', 'cuda', 'mps'",
+                required=True,
+            ),
+        ]
+
+    def create_instance(self, capabilities: dict[str, Any]) -> ResourceInstance:
+        """Create a new compute resource instance."""
+        # Validate capabilities against schema
+        validation_errors = validate_capabilities(self.get_capability_schema(), capabilities)
+        if validation_errors:
+            error_msg = f"Invalid compute capabilities: {', '.join(validation_errors)}"
+            raise ValueError(error_msg)
+
+        return ComputeInstance(resource_type=self, instance_id_prefix="compute", capabilities=capabilities)
+
+    def select_best_compatible_instance(
+        self, compatible_instances: list[ResourceInstance], _requirements: "Requirements | None" = None
+    ) -> ResourceInstance | None:
+        """Select the best compute instance from compatible ones.
+
+        Returns the first compatible instance (no special selection criteria).
+        """
+        if not compatible_instances:
+            return None
+
+        return compatible_instances[0]

griptape_nodes/retained_mode/managers/resource_types/os_resource.py

@@ -1,4 +1,5 @@
 import logging
+from enum import StrEnum
 from typing import TYPE_CHECKING, Any, Literal
 
 from griptape_nodes.retained_mode.managers.resource_components.capability_field import (
@@ -14,6 +15,22 @@ if TYPE_CHECKING:
 logger = logging.getLogger("griptape_nodes")
 
 
+class Platform(StrEnum):
+    """Supported operating system platforms."""
+
+    WINDOWS = "windows"
+    DARWIN = "darwin"  # macOS
+    LINUX = "linux"
+
+
+class Architecture(StrEnum):
+    """Supported system architectures."""
+
+    X86_64 = "x86_64"  # Also known as amd64
+    ARM64 = "arm64"
+    AARCH64 = "aarch64"  # ARM64 on Linux
+
+
 # OS capability field names
 OSCapability = Literal[
     "platform",

griptape_nodes/retained_mode/managers/static_files_manager.py

@@ -11,6 +11,7 @@ from griptape_nodes.drivers.storage import StorageBackend
 from griptape_nodes.drivers.storage.griptape_cloud_storage_driver import GriptapeCloudStorageDriver
 from griptape_nodes.drivers.storage.local_storage_driver import LocalStorageDriver
 from griptape_nodes.retained_mode.events.app_events import AppInitializationComplete
+from griptape_nodes.retained_mode.events.os_events import ExistingFilePolicy
 from griptape_nodes.retained_mode.events.static_file_events import (
     CreateStaticFileDownloadUrlRequest,
     CreateStaticFileDownloadUrlResultFailure,
@@ -182,7 +183,9 @@ class StaticFilesManager:
         if isinstance(self.storage_driver, LocalStorageDriver):
             threading.Thread(target=start_static_server, daemon=True, name="static-server").start()
 
-    def save_static_file(self, data: bytes, file_name: str) -> str:
+    def save_static_file(
+        self, data: bytes, file_name: str, existing_file_policy: ExistingFilePolicy = ExistingFilePolicy.OVERWRITE
+    ) -> str:
         """Saves a static file to the workspace directory.
 
         This is used to save files that are generated by the node, such as images or other artifacts.
@@ -190,27 +193,37 @@ class StaticFilesManager:
         Args:
             data: The file data to save.
             file_name: The name of the file to save.
+            existing_file_policy: How to handle existing files. Defaults to OVERWRITE for backward compatibility.
+                - OVERWRITE: Replace existing file content (default)
+                - CREATE_NEW: Auto-generate unique filename (e.g., file_1.txt, file_2.txt)
+                - FAIL: Raise FileExistsError if file exists
 
         Returns:
-            The URL of the saved file.
+            The URL of the saved file. Note: the actual filename may differ from the requested
+            file_name when using CREATE_NEW policy.
+
+        Raises:
+            FileExistsError: When existing_file_policy is FAIL and file already exists.
         """
         resolved_directory = self._get_static_files_directory()
         file_path = Path(resolved_directory) / file_name
 
-        response = self.storage_driver.create_signed_upload_url(file_path)
+        # Pass the existing_file_policy to the storage driver
+        response = self.storage_driver.create_signed_upload_url(file_path, existing_file_policy)
+
+        resolved_file_path = Path(response["file_path"])
 
         try:
-            response = httpx.request(
+            upload_response = httpx.request(
                 response["method"], response["url"], content=data, headers=response["headers"], timeout=60
             )
-            response.raise_for_status()
+            upload_response.raise_for_status()
         except httpx.HTTPStatusError as e:
-            msg = str(e.response.json())
+            msg = str(e.response.json()) if hasattr(e, "response") else str(e)
             logger.error(msg)
             raise ValueError(msg) from e
 
-        url = self.storage_driver.create_signed_download_url(file_path)
-
+        url = self.storage_driver.create_signed_download_url(resolved_file_path)
         return url
 
     def _get_static_files_directory(self) -> str:

griptape_nodes/retained_mode/managers/version_compatibility_manager.py

@@ -32,7 +32,7 @@ from griptape_nodes.retained_mode.managers.fitness_problems.workflows.deprecated
 from griptape_nodes.retained_mode.managers.fitness_problems.workflows.node_type_not_found_problem import (
     NodeTypeNotFoundProblem,
 )
-from griptape_nodes.retained_mode.managers.library_lifecycle.library_status import LibraryStatus
+from griptape_nodes.retained_mode.managers.library_manager import LibraryManager
 
 if TYPE_CHECKING:
     from griptape_nodes.exe_types.node_types import BaseNode
@@ -54,7 +54,7 @@ class LibraryVersionCompatibilityIssue(NamedTuple):
     """Represents a library version compatibility issue found in a library."""
 
     problem: LibraryProblem
-    severity: LibraryStatus
+    severity: LibraryManager.LibraryFitness
 
 
 class LibraryVersionCompatibilityCheck(ABC):
@@ -208,7 +208,7 @@ class VersionCompatibilityManager:
                     removal_version=node.metadata.deprecation.removal_version,
                     deprecation_message=node.metadata.deprecation.deprecation_message,
                 ),
-                severity=LibraryStatus.FLAWED,
+                severity=LibraryManager.LibraryFitness.FLAWED,
             )
             for node in library_data.nodes
             if node.metadata.deprecation is not None

griptape_nodes/utils/git_utils.py

@@ -1171,34 +1171,19 @@ def _shallow_clone_with_pygit2(remote_url: str, ref: str) -> tuple[str, str, dic
                 callbacks = _get_ssh_callbacks()
 
             # Shallow clone with depth=1
-            # Note: We don't use checkout_branch here because it only works with branches,
-            # not tags or commit SHAs. Instead, we'll fetch and checkout the ref manually.
+            checkout_branch = ref if ref != "HEAD" else None
             repo = pygit2.clone_repository(
                 remote_url,
                 str(temp_path),
                 callbacks=callbacks,
                 depth=1,
+                checkout_branch=checkout_branch,
             )
 
             if repo is None:
                 msg = f"Failed to clone repository from {remote_url}"
                 raise GitCloneError(msg)
 
-            # If a specific ref was requested (not HEAD), fetch and checkout that ref
-            if ref != "HEAD":
-                try:
-                    # Fetch the specific ref (works for branches, tags, and commits)
-                    remote = repo.remotes["origin"]
-                    remote.fetch([ref], callbacks=callbacks, depth=1)
-
-                    # Now resolve and checkout the ref
-                    resolved_ref = repo.revparse_single(ref)
-                    repo.checkout_tree(resolved_ref)
-                    repo.set_head(resolved_ref.id)
-                except (KeyError, pygit2.GitError) as e:
-                    msg = f"Failed to fetch and checkout ref '{ref}' in clone from {remote_url}: {e}"
-                    raise GitCloneError(msg) from e
-
             # Find the library JSON file
             library_json_path = find_file_in_directory(temp_path, "griptape[-_]nodes[-_]library.json")
             if library_json_path is None:

griptape_nodes/version_compatibility/versions/v0_39_0/modified_parameters_set_removal.py

@@ -21,7 +21,7 @@ from griptape_nodes.retained_mode.managers.fitness_problems.libraries.ui_options
 from griptape_nodes.retained_mode.managers.fitness_problems.libraries.ui_options_field_modified_warning_problem import (
     UiOptionsFieldModifiedWarningProblem,
 )
-from griptape_nodes.retained_mode.managers.library_lifecycle.library_status import LibraryStatus
+from griptape_nodes.retained_mode.managers.library_manager import LibraryManager
 from griptape_nodes.retained_mode.managers.version_compatibility_manager import (
     LibraryVersionCompatibilityCheck,
     LibraryVersionCompatibilityIssue,
@@ -62,11 +62,11 @@ class ModifiedParametersSetRemovalCheck(LibraryVersionCompatibilityCheck):
             return [
                 LibraryVersionCompatibilityIssue(
                     problem=ModifiedParametersSetRemovedProblem(library_engine_version=library_version_str),
-                    severity=LibraryStatus.UNUSABLE,
+                    severity=LibraryManager.LibraryFitness.UNUSABLE,
                 ),
                 LibraryVersionCompatibilityIssue(
                     problem=UiOptionsFieldModifiedIncompatibleProblem(library_engine_version=library_version_str),
-                    severity=LibraryStatus.UNUSABLE,
+                    severity=LibraryManager.LibraryFitness.UNUSABLE,
                 ),
             ]
         if current_engine_version >= semver.VersionInfo(0, 38, 0):
@@ -74,11 +74,11 @@ class ModifiedParametersSetRemovalCheck(LibraryVersionCompatibilityCheck):
             return [
                 LibraryVersionCompatibilityIssue(
                     problem=ModifiedParametersSetDeprecationWarningProblem(library_engine_version=library_version_str),
-                    severity=LibraryStatus.FLAWED,
+                    severity=LibraryManager.LibraryFitness.FLAWED,
                 ),
                 LibraryVersionCompatibilityIssue(
                     problem=UiOptionsFieldModifiedWarningProblem(),
-                    severity=LibraryStatus.FLAWED,
+                    severity=LibraryManager.LibraryFitness.FLAWED,
                 ),
             ]
 

griptape_nodes/version_compatibility/versions/v0_65_4/__init__.py

@@ -0,0 +1,5 @@
+"""Version 0.65.4 backward compatibility checks.
+
+This version includes backward compatibility for the parameter name change from
+'run_in_parallel' to 'run_in_order' in ForLoopStartNode and ForEachStartNode.
+"""

griptape_nodes/version_compatibility/versions/v0_65_4/run_in_parallel_to_run_in_order.py

@@ -0,0 +1,79 @@
+"""Backward compatibility for run_in_parallel to run_in_order parameter change.
+
+This module handles the parameter name change from 'run_in_parallel' to 'run_in_order'
+in ForLoopStartNode and ForEachStartNode. The logic is inverted: run_in_parallel=True
+becomes run_in_order=False (run in parallel means NOT run in order).
+
+TODO: Remove this compatibility check once all workflows have been migrated and we no
+longer need to support loading old workflows with the run_in_parallel parameter.
+Link: https://github.com/griptape-ai/griptape-nodes/issues/XXXX
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from griptape_nodes.retained_mode.events.parameter_events import SetParameterValueResultSuccess
+from griptape_nodes.retained_mode.managers.version_compatibility_manager import (
+    SetParameterVersionCompatibilityCheck,
+)
+
+if TYPE_CHECKING:
+    from griptape_nodes.exe_types.node_types import BaseNode
+
+
+class RunInParallelToRunInOrderCheck(SetParameterVersionCompatibilityCheck):
+    """Handle migration from run_in_parallel to run_in_order parameter.
+
+    This check intercepts attempts to set the old 'run_in_parallel' parameter
+    and converts it to the new 'run_in_order' parameter with inverted boolean logic.
+
+    Applies to:
+    - ForLoopStartNode
+    - ForEachStartNode
+
+    Migration logic:
+    - run_in_parallel=True → run_in_order=False (run in parallel)
+    - run_in_parallel=False → run_in_order=True (run sequentially)
+    """
+
+    def applies_to_set_parameter(self, node: BaseNode, parameter_name: str, _value: Any) -> bool:
+        """Return True if this is the old run_in_parallel parameter on an affected node.
+
+        Args:
+            node: The node instance
+            parameter_name: Name of the parameter being set
+            _value: The value being set (unused)
+
+        Returns:
+            True if this check should handle this parameter
+        """
+        if parameter_name != "run_in_parallel":
+            return False
+
+        node_type_name = type(node).__name__
+        return node_type_name in ("ForLoopStartNode", "ForEachStartNode")
+
+    def set_parameter_value(self, node: BaseNode, parameter_name: str, value: Any) -> SetParameterValueResultSuccess:
+        """Migrate run_in_parallel to run_in_order with inverted boolean value.
+
+        Args:
+            node: The node instance
+            parameter_name: Name of the parameter being set (should be "run_in_parallel")
+            value: The value being set (boolean)
+
+        Returns:
+            SetParameterValueResultSuccess indicating the migration was successful
+        """
+        if value is None:
+            inverted_value = True
+        else:
+            inverted_value = not bool(value)
+
+        node.set_parameter_value("run_in_order", inverted_value)
+
+        return SetParameterValueResultSuccess(
+            finalized_value=inverted_value,
+            data_type="bool",
+            result_details=f"Migrated deprecated '{parameter_name}' parameter to 'run_in_order' with inverted value",
+        )

griptape_nodes/version_compatibility/versions/v0_65_5/__init__.py

@@ -0,0 +1,5 @@
+"""Version 0.65.5 backward compatibility checks.
+
+This version includes backward compatibility for removed parameters in
+Flux2ImageGeneration: 'prompt_upsampling' and 'aspect_ratio'.
+"""

griptape_nodes/version_compatibility/versions/v0_65_5/flux_2_removed_parameters.py

@@ -0,0 +1,85 @@
+"""Backward compatibility for removed Flux2ImageGeneration parameters.
+
+This module handles removed parameters from Flux2ImageGeneration when adding
+FLUX.2[max] support:
+- prompt_upsampling: removed entirely
+- aspect_ratio: replaced with explicit width/height parameters
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from griptape_nodes.retained_mode.events.parameter_events import SetParameterValueResultSuccess
+from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+from griptape_nodes.retained_mode.managers.version_compatibility_manager import (
+    SetParameterVersionCompatibilityCheck,
+)
+
+if TYPE_CHECKING:
+    from griptape_nodes.exe_types.node_types import BaseNode
+
+logger = logging.getLogger("griptape_nodes")
+
+
+class Flux2RemovedParametersCheck(SetParameterVersionCompatibilityCheck):
+    """Handle removed prompt_upsampling and aspect_ratio parameters.
+
+    These parameters were removed in engine version 0.65.5 when adding FLUX.2[max] support.
+    This check intercepts attempts to set these parameters and logs a warning prompting
+    users to resave their workflows.
+    """
+
+    REMOVED_PARAMETERS: ClassVar[set[str]] = {"prompt_upsampling", "aspect_ratio"}
+
+    def __init__(self) -> None:
+        """Initialize the check with an empty set of warned workflows."""
+        super().__init__()
+        self._warned_workflows: set[str] = set()
+
+    def applies_to_set_parameter(self, node: BaseNode, parameter_name: str, _value: Any) -> bool:
+        """Return True if this is a removed parameter on a Flux2ImageGeneration node.
+
+        Args:
+            node: The node instance
+            parameter_name: Name of the parameter being set
+            _value: The value being set (unused)
+
+        Returns:
+            True if this check should handle this parameter
+        """
+        if parameter_name not in self.REMOVED_PARAMETERS:
+            return False
+
+        return type(node).__name__ == "Flux2ImageGeneration"
+
+    def set_parameter_value(self, _node: BaseNode, parameter_name: str, _value: Any) -> SetParameterValueResultSuccess:
+        """Handle the removed parameter by logging a warning and returning success.
+
+        Args:
+            _node: The node instance (unused)
+            parameter_name: Name of the parameter being set
+            _value: The value being set (unused)
+
+        Returns:
+            SetParameterValueResultSuccess with None value
+        """
+        workflow_name = GriptapeNodes.ContextManager().get_current_workflow_name()
+
+        if workflow_name not in self._warned_workflows:
+            self._warned_workflows.add(workflow_name)
+
+            removed_params_list = ", ".join(f"'{param}'" for param in self.REMOVED_PARAMETERS)
+            logger.warning(
+                "This workflow uses removed Flux2ImageGeneration parameters (%s) that were "
+                "replaced in engine version 0.65.5. Please resave your workflow and this "
+                "warning will go away.",
+                removed_params_list,
+            )
+
+        return SetParameterValueResultSuccess(
+            finalized_value=None,
+            data_type="any",
+            result_details=f"Parameter '{parameter_name}' was removed in v0.65.5. Please resave this workflow.",
+        )

{griptape_nodes-0.65.6.dist-info → griptape_nodes-0.66.0.dist-info}/METADATA

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