griptape-nodes 0.64.0__tar.gz → 0.64.2__tar.gz

{griptape_nodes-0.64.0 → griptape_nodes-0.64.2}/PKG-INFO

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

{griptape_nodes-0.64.0 → griptape_nodes-0.64.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "griptape-nodes"
-version = "0.64.0"
+version = "0.64.2"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12.0, <3.13"

{griptape_nodes-0.64.0 → griptape_nodes-0.64.2}/src/griptape_nodes/retained_mode/managers/node_manager.py

@@ -1912,6 +1912,14 @@ class NodeManager:
             details = f"Attempted to set parameter '{param_name}' value on node '{node_name}'. Failed because the Node was locked."
             return SetParameterValueResultFailure(result_details=details)
 
+        # Let versioning system potentially squelch removed parameters.
+        # This check must run BEFORE we validate parameter existence, since removed parameters won't exist.
+        version_compat_result = GriptapeNodes.VersionCompatibilityManager().check_set_parameter_version_compatibility(
+            node, param_name, request.value
+        )
+        if version_compat_result is not None:
+            return version_compat_result
+
         # Handle ErrorProxyNode parameter value requests
         if isinstance(node, ErrorProxyNode):
             if request.initial_setup:
@@ -1929,6 +1937,7 @@ class NodeManager:
 
         # Does the Parameter actually exist on the Node?
         parameter = node.get_parameter_by_name(param_name)
+
         if parameter is None:
             details = f"Attempted to set parameter value for '{node_name}.{param_name}'. Failed because no parameter with that name could be found."
 

{griptape_nodes-0.64.0 → griptape_nodes-0.64.2}/src/griptape_nodes/retained_mode/managers/version_compatibility_manager.py

@@ -4,7 +4,7 @@ import importlib
 import logging
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import TYPE_CHECKING, NamedTuple
+from typing import TYPE_CHECKING, Any, NamedTuple
 
 import semver
 
@@ -35,8 +35,13 @@ from griptape_nodes.retained_mode.managers.fitness_problems.workflows.node_type_
 from griptape_nodes.retained_mode.managers.library_lifecycle.library_status import LibraryStatus
 
 if TYPE_CHECKING:
+    from griptape_nodes.exe_types.node_types import BaseNode
     from griptape_nodes.node_library.library_registry import LibrarySchema
     from griptape_nodes.node_library.workflow_registry import WorkflowMetadata
+    from griptape_nodes.retained_mode.events.parameter_events import (
+        SetParameterValueResultFailure,
+        SetParameterValueResultSuccess,
+    )
     from griptape_nodes.retained_mode.managers.event_manager import EventManager
     from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
     from griptape_nodes.retained_mode.managers.fitness_problems.workflows.workflow_problem import WorkflowProblem
@@ -83,6 +88,38 @@ class WorkflowVersionCompatibilityCheck(ABC):
         """Perform the workflow compatibility check."""
 
 
+class SetParameterVersionCompatibilityCheck(ABC):
+    """Abstract base class for runtime parameter set version compatibility checks."""
+
+    @abstractmethod
+    def applies_to_set_parameter(self, node: BaseNode, parameter_name: str, value: Any) -> bool:
+        """Return True if this check applies to the given parameter set operation.
+
+        Args:
+            node: The node instance
+            parameter_name: Name of the parameter being set
+            value: The value being set
+
+        Returns:
+            True if this check should be performed for this parameter
+        """
+
+    @abstractmethod
+    def set_parameter_value(
+        self, node: BaseNode, parameter_name: str, value: Any
+    ) -> SetParameterValueResultSuccess | SetParameterValueResultFailure:
+        """Handle setting the parameter value with version compatibility logic.
+
+        Args:
+            node: The node instance
+            parameter_name: Name of the parameter being set
+            value: The value being set
+
+        Returns:
+            SetParameterValueResultSuccess or SetParameterValueResultFailure
+        """
+
+
 class VersionCompatibilityManager:
     """Manages version compatibility checks for libraries and other components."""
 
@@ -90,89 +127,74 @@ class VersionCompatibilityManager:
         self._event_manager = event_manager
         self._compatibility_checks: list[LibraryVersionCompatibilityCheck] = []
         self._workflow_compatibility_checks: list[WorkflowVersionCompatibilityCheck] = []
+        self._set_parameter_compatibility_checks: list[SetParameterVersionCompatibilityCheck] = []
         self._discover_version_checks()
 
     def _discover_version_checks(self) -> None:
-        """Automatically discover and register library and workflow version compatibility checks."""
-        self._discover_library_version_checks()
-        self._discover_workflow_version_checks()
+        """Automatically discover and register all version compatibility checks from the versions/ directory."""
+        try:
+            import griptape_nodes.version_compatibility.versions as versions_module
 
-    def _discover_library_version_checks(self) -> None:
-        """Discover and register library version compatibility checks."""
-        # Get the path to the version_compatibility/versions directory
-        import griptape_nodes.version_compatibility.versions as versions_module
+            if versions_module.__file__ is None:
+                logger.debug("No version compatibility checks directory found, skipping discovery")
+                return
 
-        versions_path = Path(versions_module.__file__).parent
+            versions_path = Path(versions_module.__file__).parent
 
-        # Iterate through version directories
-        for version_dir in versions_path.iterdir():
-            if version_dir.is_dir() and not version_dir.name.startswith("__"):
-                self._discover_checks_in_version_dir(version_dir)
+            # Iterate through version directories (e.g., v0_39_0, v0_63_8)
+            for version_dir in versions_path.iterdir():
+                if not version_dir.is_dir() or version_dir.name.startswith("__"):
+                    continue
 
-    def _discover_workflow_version_checks(self) -> None:
-        """Discover and register workflow version compatibility checks."""
-        try:
-            import griptape_nodes.version_compatibility.workflow_versions as workflow_versions_module
+                # Iterate through Python files in the version directory
+                for check_file in version_dir.glob("*.py"):
+                    if check_file.name.startswith("__"):
+                        continue
+
+                    # Import the module once
+                    file_module_path = (
+                        f"griptape_nodes.version_compatibility.versions.{version_dir.name}.{check_file.stem}"
+                    )
+                    try:
+                        check_module = importlib.import_module(file_module_path)
+                    except ImportError as e:
+                        logger.debug("Failed to import check module %s: %s", file_module_path, e)
+                        continue
 
-            workflow_versions_path = Path(workflow_versions_module.__file__).parent
+                    # Scan and register all check types in this module
+                    self._register_checks_from_module(check_module)
 
-            # Iterate through version directories
-            for version_dir in workflow_versions_path.iterdir():
-                if version_dir.is_dir() and not version_dir.name.startswith("__"):
-                    self._discover_workflow_checks_in_version_dir(version_dir)
         except ImportError:
-            # workflow_versions directory doesn't exist yet, skip discovery
-            logger.debug("No workflow version compatibility checks directory found, skipping workflow check discovery")
-
-    def _discover_checks_in_version_dir(self, version_dir: Path) -> None:
-        """Discover compatibility checks in a specific version directory."""
-        # Iterate through Python files in the version directory
-        for check_file in version_dir.glob("*.py"):
-            if check_file.name.startswith("__"):
-                continue
+            logger.debug("No version compatibility checks directory found, skipping discovery")
+
+    def _register_checks_from_module(self, check_module: Any) -> None:
+        """Register all version compatibility checks found in a module.
 
-            # Import the module
-            module_path = f"griptape_nodes.version_compatibility.versions.{version_dir.name}.{check_file.stem}"
-            module = importlib.import_module(module_path)
-
-            # Look for classes that inherit from LibraryVersionCompatibilityCheck
-            for attr_name in dir(module):
-                attr = getattr(module, attr_name)
-                if (
-                    isinstance(attr, type)
-                    and issubclass(attr, LibraryVersionCompatibilityCheck)
-                    and attr is not LibraryVersionCompatibilityCheck
-                ):
-                    check_instance = attr()
-                    self._compatibility_checks.append(check_instance)
-                    logger.debug("Registered library version compatibility check: %s", attr_name)
-
-    def _discover_workflow_checks_in_version_dir(self, version_dir: Path) -> None:
-        """Discover workflow compatibility checks in a specific version directory."""
-        # Iterate through Python files in the version directory
-        for check_file in version_dir.glob("*.py"):
-            if check_file.name.startswith("__"):
+        Args:
+            check_module: The imported module to scan for check classes
+        """
+        for attr_name in dir(check_module):
+            attr = getattr(check_module, attr_name)
+            if not isinstance(attr, type):
                 continue
 
-            # Import the module
-            module_path = f"griptape_nodes.version_compatibility.workflow_versions.{version_dir.name}.{check_file.stem}"
-            try:
-                module = importlib.import_module(module_path)
-            except ImportError as e:
-                logger.debug("Failed to import workflow compatibility check module %s: %s", module_path, e)
+            # Skip abstract base classes
+            if ABC in getattr(attr, "__bases__", ()):
                 continue
 
-            # Look for classes that inherit from WorkflowVersionCompatibilityCheck
-            for attr_name in dir(module):
-                attr = getattr(module, attr_name)
-                if (
-                    isinstance(attr, type)
-                    and issubclass(attr, WorkflowVersionCompatibilityCheck)
-                    and attr is not WorkflowVersionCompatibilityCheck
-                ):
-                    check_instance = attr()
-                    self._workflow_compatibility_checks.append(check_instance)
-                    logger.debug("Registered workflow version compatibility check: %s", attr_name)
+            # Register based on which base class it inherits from
+            if issubclass(attr, LibraryVersionCompatibilityCheck):
+                check_instance = attr()
+                self._compatibility_checks.append(check_instance)
+                logger.debug("Registered library version compatibility check: %s", attr_name)
+            elif issubclass(attr, WorkflowVersionCompatibilityCheck):
+                check_instance = attr()
+                self._workflow_compatibility_checks.append(check_instance)
+                logger.debug("Registered workflow version compatibility check: %s", attr_name)
+            elif issubclass(attr, SetParameterVersionCompatibilityCheck):
+                check_instance = attr()
+                self._set_parameter_compatibility_checks.append(check_instance)
+                logger.debug("Registered set parameter version compatibility check: %s", attr_name)
 
     def _check_library_for_deprecated_nodes(
         self, library_data: LibrarySchema
@@ -333,6 +355,28 @@ class VersionCompatibilityManager:
 
         return issues
 
+    def check_set_parameter_version_compatibility(
+        self, node: BaseNode, parameter_name: str, value: Any
+    ) -> SetParameterValueResultSuccess | SetParameterValueResultFailure | None:
+        """Check if a parameter set operation requires version compatibility handling.
+
+        Args:
+            node: The node instance
+            parameter_name: Name of the parameter being set
+            value: The value being set
+
+        Returns:
+            SetParameterValueResultSuccess, SetParameterValueResultFailure, or None if no check applies
+        """
+        # Iterate through registered checks and find the first one that applies
+        for check_instance in self._set_parameter_compatibility_checks:
+            if check_instance.applies_to_set_parameter(node, parameter_name, value):
+                # First matching check handles the parameter
+                return check_instance.set_parameter_value(node, parameter_name, value)
+
+        # No checks applied
+        return None
+
     def _get_current_engine_version(self) -> semver.VersionInfo:
         """Get the current engine version."""
         result = GriptapeNodes.handle_request(GetEngineVersionRequest())

{griptape_nodes-0.64.0 → griptape_nodes-0.64.2}/src/griptape_nodes/updater/__init__.py

@@ -7,6 +7,7 @@ Usage:
 from __future__ import annotations
 
 import subprocess
+import sys
 
 from rich.console import Console
 
@@ -60,7 +61,7 @@ def _sync_libraries() -> None:
     console.print("[bold green]Syncing libraries...[/bold green]")
     try:
         subprocess.run(
-            ["griptape-nodes", "--no-update", "libraries", "sync"],  # noqa: S607
+            [sys.executable, "--no-update", "libraries", "sync"],
             text=True,
             capture_output=True,
             check=True,

griptape_nodes-0.64.2/src/griptape_nodes/version_compatibility/versions/v0_63_8/__init__.py

@@ -0,0 +1 @@
+"""Version 0.63.8 parameter compatibility checks."""

griptape_nodes-0.64.2/src/griptape_nodes/version_compatibility/versions/v0_63_8/deprecated_nodegroup_parameters.py

@@ -0,0 +1,105 @@
+"""Check for deprecated job_group and execution_environment parameters."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, ClassVar
+
+import semver
+
+from griptape_nodes.exe_types.node_types import NodeGroupNode
+from griptape_nodes.retained_mode.events.app_events import (
+    GetEngineVersionRequest,
+    GetEngineVersionResultSuccess,
+)
+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 DeprecatedNodeGroupParametersCheck(SetParameterVersionCompatibilityCheck):
+    """Check for deprecated job_group and execution_environment parameters.
+
+    These parameters were removed in engine version 0.63.8 for all nodes except NodeGroup.
+    This check intercepts attempts to set these parameters and logs a warning prompting
+    users to resave their workflows.
+    """
+
+    DEPRECATED_PARAMETERS: ClassVar[set[str]] = {"job_group", "execution_environment"}
+    REMOVAL_VERSION: ClassVar[semver.VersionInfo] = semver.VersionInfo(0, 63, 8)
+
+    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 deprecated parameter on a non-NodeGroup 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
+        """
+        # Check parameter name first (fastest check)
+        if parameter_name not in self.DEPRECATED_PARAMETERS:
+            return False
+
+        # Check if node is NOT a NodeGroup (we only block for non-NodeGroup nodes)
+        if isinstance(node, NodeGroupNode):
+            return False
+
+        # Check if current engine version is >= 0.63.8
+        engine_version_result = GriptapeNodes.handle_request(GetEngineVersionRequest())
+        if not isinstance(engine_version_result, GetEngineVersionResultSuccess):
+            return False
+
+        current_version = semver.VersionInfo(
+            engine_version_result.major, engine_version_result.minor, engine_version_result.patch
+        )
+        return current_version >= self.REMOVAL_VERSION
+
+    def set_parameter_value(self, _node: BaseNode, parameter_name: str, _value: Any) -> SetParameterValueResultSuccess:
+        """Handle the deprecated parameter by logging a warning and returning success with empty value.
+
+        Args:
+            _node: The node instance (unused)
+            parameter_name: Name of the parameter being set
+            _value: The value being set (unused)
+
+        Returns:
+            SetParameterValueResultSuccess with empty list value
+        """
+        # Get the current workflow name to track warnings per workflow
+        workflow_name = GriptapeNodes.ContextManager().get_current_workflow_name()
+
+        # Check if we've already warned for this workflow
+        if workflow_name not in self._warned_workflows:
+            # Mark this workflow as warned
+            self._warned_workflows.add(workflow_name)
+
+            # Log warning with all deprecated parameters
+            deprecated_params_list = ", ".join(f"'{param}'" for param in self.DEPRECATED_PARAMETERS)
+            logger.warning(
+                "This workflow uses deprecated parameters (%s) that were removed in engine version %s. "
+                "Please resave your workflow and this warning will go away.",
+                deprecated_params_list,
+                self.REMOVAL_VERSION,
+            )
+
+        # Return success with None as the value (parameter doesn't exist, so no meaningful value to return)
+        return SetParameterValueResultSuccess(
+            finalized_value=None,
+            data_type="any",
+            result_details=f"Parameter '{parameter_name}' was removed in v{self.REMOVAL_VERSION}. Please resave this workflow.",
+        )

griptape_nodes-0.64.0/src/griptape_nodes/version_compatibility/workflow_versions/__init__.py

@@ -1 +0,0 @@
-"""Workflow version compatibility checks module."""