griptape-nodes 0.62.2__py3-none-any.whl → 0.63.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/fitness_problems/libraries/before_library_callback_problem.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class BeforeLibraryCallbackProblem(LibraryProblem):
+    """Problem indicating an error calling the before_library_nodes_loaded callback."""
+
+    error_message: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[BeforeLibraryCallbackProblem]) -> str:
+        """Display before library callback problem.
+
+        There should only be one instance per library since there's only one
+        before_library_nodes_loaded callback per library.
+        """
+        if len(instances) > 1:
+            logger.error(
+                "BeforeLibraryCallbackProblem: Expected 1 instance but got %s. Each LibraryInfo should only have one BeforeLibraryCallbackProblem.",
+                len(instances),
+            )
+
+        # Use the first instance's error message
+        error_msg = instances[0].error_message
+        return f"Error calling before_library_nodes_loaded callback: {error_msg}"

griptape_nodes/retained_mode/managers/fitness_problems/libraries/create_config_category_problem.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CreateConfigCategoryProblem(LibraryProblem):
+    """Problem indicating a config category failed to be created."""
+
+    category_name: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[CreateConfigCategoryProblem]) -> str:
+        """Display config category creation problem.
+
+        There should only be one instance per library since each LibraryInfo
+        is already associated with a specific library path.
+        """
+        if len(instances) > 1:
+            logger.error(
+                "CreateConfigCategoryProblem: Expected 1 instance but got %s. Each LibraryInfo should only have one CreateConfigCategoryProblem.",
+                len(instances),
+            )
+
+        # Use the first instance's category name
+        category = instances[0].category_name
+        return f"Failed to create new config category '{category}'."

griptape_nodes/retained_mode/managers/fitness_problems/libraries/dependency_installation_failed_problem.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DependencyInstallationFailedProblem(LibraryProblem):
+    """Problem indicating dependency installation failed."""
+
+    error_details: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[DependencyInstallationFailedProblem]) -> str:
+        """Display dependency installation failed problem.
+
+        There should only be one instance per library since each LibraryInfo
+        is already associated with a specific library path.
+        """
+        if len(instances) > 1:
+            logger.error(
+                "DependencyInstallationFailedProblem: Expected 1 instance but got %s. Each LibraryInfo should only have one DependencyInstallationFailedProblem.",
+                len(instances),
+            )
+
+        # Use the first instance's error details
+        details = instances[0].error_details
+        return f"Dependency installation failed: {details}"

griptape_nodes/retained_mode/managers/fitness_problems/libraries/deprecated_node_warning_problem.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import logging
+from collections import defaultdict
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DeprecatedNodeWarningProblem(LibraryProblem):
+    """Problem indicating a library contains deprecated nodes.
+
+    This is stackable - multiple nodes can be deprecated.
+    """
+
+    display_name: str
+    class_name: str
+    removal_version: str | None
+    deprecation_message: str | None
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[DeprecatedNodeWarningProblem]) -> str:
+        """Display deprecated node warnings.
+
+        Groups by removal version, then lists nodes within each group.
+        """
+        if len(instances) == 1:
+            problem = instances[0]
+            removal_info = (
+                f"will be removed in version {problem.removal_version}"
+                if problem.removal_version
+                else "may be removed in future versions"
+            )
+            message = f"Node '{problem.display_name}' is deprecated and {removal_info}."
+            if problem.deprecation_message:
+                message += f" {problem.deprecation_message}"
+            return message
+
+        # Group by removal version
+        by_version = defaultdict(list)
+        for problem in instances:
+            by_version[problem.removal_version].append(problem)
+
+        # Sort versions (None comes last)
+        sorted_versions = sorted(by_version.keys(), key=lambda v: (v is None, v or ""))
+
+        output_lines = []
+        output_lines.append(f"Encountered {len(instances)} deprecated nodes:")
+
+        for version in sorted_versions:
+            nodes = by_version[version]
+
+            if version is None:
+                output_lines.append("  Nodes that may be removed in future versions:")
+            else:
+                output_lines.append(f"  Nodes to be removed in version {version}:")
+
+            # Group nodes within this version by deprecation_message
+            by_message = defaultdict(list)
+            for node in nodes:
+                # Use empty string as key if no message
+                message_key = node.deprecation_message if node.deprecation_message else ""
+                by_message[message_key].append(node)
+
+            # Sort messages alphabetically (empty string first)
+            sorted_messages = sorted(by_message.keys(), key=lambda m: (m != "", m))
+
+            for message in sorted_messages:
+                message_nodes = by_message[message]
+                # Sort nodes by display_name within each message group
+                message_nodes.sort(key=lambda p: p.display_name)
+
+                if message:
+                    output_lines.append(f"    {message}:")
+                    output_lines.extend(f"      - {node.display_name}" for node in message_nodes)
+                else:
+                    # No deprecation message provided
+                    output_lines.extend(f"    - {node.display_name}" for node in message_nodes)
+
+        return "\n".join(output_lines)

griptape_nodes/retained_mode/managers/fitness_problems/libraries/duplicate_library_problem.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DuplicateLibraryProblem(LibraryProblem):
+    """Problem indicating a library with this name was already registered."""
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[DuplicateLibraryProblem]) -> str:
+        """Display duplicate library problem.
+
+        There should only be one instance per library since each LibraryInfo
+        is already associated with a specific library path.
+        """
+        if len(instances) > 1:
+            logger.error(
+                "DuplicateLibraryProblem: Expected 1 instance but got %s. Each LibraryInfo should only have one DuplicateLibraryProblem.",
+                len(instances),
+            )
+
+        return "Failed because a library with this name was already registered. Check the Settings to ensure duplicate libraries are not being loaded."

griptape_nodes/retained_mode/managers/fitness_problems/libraries/duplicate_node_registration_problem.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DuplicateNodeRegistrationProblem(LibraryProblem):
+    """Problem indicating a node class was already registered.
+
+    This is stackable - multiple duplicate registrations can occur.
+    """
+
+    class_name: str
+    library_name: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[DuplicateNodeRegistrationProblem]) -> str:
+        """Display duplicate node registration problems.
+
+        Can handle multiple duplicates - they will be listed out sorted by class_name.
+        """
+        if len(instances) == 1:
+            problem = instances[0]
+            return (
+                f"Attempted to register node class '{problem.class_name}' from library '{problem.library_name}', "
+                f"but a node with that name from that library was already registered. "
+                "Check to ensure you aren't re-adding the same libraries multiple times."
+            )
+
+        # Multiple duplicate registrations - list them sorted by class_name
+        sorted_instances = sorted(instances, key=lambda p: p.class_name)
+        error_lines = []
+        for i, problem in enumerate(sorted_instances, 1):
+            error_lines.append(
+                f"  {i}. Node '{problem.class_name}' from library '{problem.library_name}' already registered"
+            )
+
+        header = f"Encountered {len(instances)} duplicate node registrations:"
+        return header + "\n" + "\n".join(error_lines)

griptape_nodes/retained_mode/managers/fitness_problems/libraries/engine_version_error_problem.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class EngineVersionErrorProblem(LibraryProblem):
+    """Problem indicating the engine version could not be retrieved for sandbox library generation."""
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[EngineVersionErrorProblem]) -> str:
+        """Display engine version error problem.
+
+        There should only be one instance per library since each LibraryInfo
+        is already associated with a specific library path.
+        """
+        if len(instances) > 1:
+            logger.error(
+                "EngineVersionErrorProblem: Expected 1 instance but got %s. Each LibraryInfo should only have one EngineVersionErrorProblem.",
+                len(instances),
+            )
+
+        return "Could not get engine version for sandbox library generation."

griptape_nodes/retained_mode/managers/fitness_problems/libraries/insufficient_disk_space_problem.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class InsufficientDiskSpaceProblem(LibraryProblem):
+    """Problem indicating insufficient disk space for dependencies."""
+
+    min_space_gb: float
+    error_message: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[InsufficientDiskSpaceProblem]) -> str:
+        """Display insufficient disk space problem.
+
+        There should only be one instance per library since each LibraryInfo
+        is already associated with a specific library path.
+        """
+        if len(instances) > 1:
+            logger.error(
+                "InsufficientDiskSpaceProblem: Expected 1 instance but got %s. Each LibraryInfo should only have one InsufficientDiskSpaceProblem.",
+                len(instances),
+            )
+
+        # Use the first instance's details
+        problem = instances[0]
+        return f"Insufficient disk space for dependencies (requires {problem.min_space_gb} GB): {problem.error_message}"

griptape_nodes/retained_mode/managers/fitness_problems/libraries/invalid_version_string_problem.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class InvalidVersionStringProblem(LibraryProblem):
+    """Problem indicating a library's version string is not valid (must be major.minor.patch format)."""
+
+    version_string: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[InvalidVersionStringProblem]) -> str:
+        """Display invalid version string problem.
+
+        There should only be one instance per library since each LibraryInfo
+        is already associated with a specific library path.
+        """
+        if len(instances) > 1:
+            logger.error(
+                "InvalidVersionStringProblem: Expected 1 instance but got %s. Each LibraryInfo should only have one InvalidVersionStringProblem.",
+                len(instances),
+            )
+
+        # Use the first instance's version string
+        version = instances[0].version_string
+        return f"Library's version string '{version}' wasn't valid. Must be in major.minor.patch format."

griptape_nodes/retained_mode/managers/fitness_problems/libraries/library_json_decode_problem.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class LibraryJsonDecodeProblem(LibraryProblem):
+    """Problem indicating a library file is not properly formatted JSON."""
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[LibraryJsonDecodeProblem]) -> str:
+        """Display library JSON decode problem.
+
+        There should only be one instance per library since each LibraryInfo
+        is already associated with a specific library path.
+        """
+        if len(instances) > 1:
+            logger.error(
+                "LibraryJsonDecodeProblem: Expected 1 instance but got %s. Each LibraryInfo should only have one LibraryJsonDecodeProblem.",
+                len(instances),
+            )
+
+        return "Library file not formatted as proper JSON."

griptape_nodes/retained_mode/managers/fitness_problems/libraries/library_load_exception_problem.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class LibraryLoadExceptionProblem(LibraryProblem):
+    """Problem indicating an exception occurred while loading the library file."""
+
+    error_message: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[LibraryLoadExceptionProblem]) -> str:
+        """Display library load exception problem.
+
+        There should only be one instance per library since each LibraryInfo
+        is already associated with a specific library path.
+        """
+        if len(instances) > 1:
+            logger.error(
+                "LibraryLoadExceptionProblem: Expected 1 instance but got %s. Each LibraryInfo should only have one LibraryLoadExceptionProblem.",
+                len(instances),
+            )
+
+        # Use the first instance's error message
+        error_msg = instances[0].error_message
+        return f"Exception occurred when attempting to load the library: {error_msg}."

griptape_nodes/retained_mode/managers/fitness_problems/libraries/library_not_found_problem.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class LibraryNotFoundProblem(LibraryProblem):
+    """Problem indicating a library file could not be found at the specified path."""
+
+    library_path: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[LibraryNotFoundProblem]) -> str:
+        """Display library not found problem.
+
+        There should only be one instance per library since each LibraryInfo
+        is already associated with a specific library path.
+        """
+        if len(instances) > 1:
+            logger.error(
+                "LibraryNotFoundProblem: Expected 1 instance but got %s. Each LibraryInfo should only have one LibraryNotFoundProblem.",
+                len(instances),
+            )
+
+        return "Library could not be found at the file path specified. It will be removed from the configuration."

griptape_nodes/retained_mode/managers/fitness_problems/libraries/library_problem.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+from typing import Self
+
+
+class LibraryProblem(ABC):
+    """Base class for all library fitness problems."""
+
+    @classmethod
+    @abstractmethod
+    def collate_problems_for_display(cls, instances: list[Self]) -> str:
+        """Display one or more instances of this problem type.
+
+        Handles both single and multiple instances with appropriate formatting.
+
+        Args:
+            instances: List of problem instances of this type to display.
+
+        Returns:
+            Formatted string describing the problem(s).
+        """

griptape_nodes/retained_mode/managers/fitness_problems/libraries/library_schema_exception_problem.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class LibrarySchemaExceptionProblem(LibraryProblem):
+    """Problem indicating an unexpected exception during schema validation."""
+
+    error_message: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[LibrarySchemaExceptionProblem]) -> str:
+        """Display library schema exception problem.
+
+        There should only be one instance per library since each LibraryInfo
+        is already associated with a specific library path.
+        """
+        if len(instances) > 1:
+            logger.error(
+                "LibrarySchemaExceptionProblem: Expected 1 instance but got %s. Each LibraryInfo should only have one LibrarySchemaExceptionProblem.",
+                len(instances),
+            )
+
+        # Use the first instance's error message
+        error_msg = instances[0].error_message
+        return f"Library file did not match the library schema specified due to: {error_msg}"

griptape_nodes/retained_mode/managers/fitness_problems/libraries/library_schema_validation_problem.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class LibrarySchemaValidationProblem(LibraryProblem):
+    """Problem indicating a library schema validation error.
+
+    This is stackable - multiple validation errors can occur when validating a library schema.
+    """
+
+    location: str
+    error_type: str
+    message: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[LibrarySchemaValidationProblem]) -> str:
+        """Display library schema validation problems.
+
+        Can handle multiple validation errors - they will be listed out.
+        """
+        if len(instances) == 1:
+            problem = instances[0]
+            return f"Error in section '{problem.location}': {problem.error_type}, {problem.message}"
+
+        # Multiple validation errors - list them
+        error_lines = []
+        for i, problem in enumerate(instances, 1):
+            error_lines.append(f"  {i}. Error in section '{problem.location}': {problem.error_type}, {problem.message}")
+
+        header = f"Encountered {len(instances)} schema validation errors:"
+        return header + "\n" + "\n".join(error_lines)

griptape_nodes/retained_mode/managers/fitness_problems/libraries/modified_parameters_set_deprecation_warning_problem.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ModifiedParametersSetDeprecationWarningProblem(LibraryProblem):
+    """Problem warning that a library will be incompatible in the next version due to modified_parameters_set removal.
+
+    This is stackable - multiple libraries can have this warning.
+    This severity is FLAWED - the library can be loaded but has warnings.
+    """
+
+    library_engine_version: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[ModifiedParametersSetDeprecationWarningProblem]) -> str:
+        """Display modified_parameters_set deprecation warnings.
+
+        Can handle multiple instances - they will be listed out sorted by library_engine_version.
+        """
+        if len(instances) == 1:
+            version = instances[0].library_engine_version
+            return (
+                f"WARNING: The 'modified_parameters_set' parameter will be removed in Griptape Nodes 0.39 from BaseNode methods: 'after_incoming_connection', 'after_outgoing_connection', 'after_incoming_connection_removed', 'after_outgoing_connection_removed', 'before_value_set', and 'after_value_set'. "
+                f"This library (built for engine version {version}) must be updated before the 0.39 release. "
+                "If this library overrides any of these methods, it will fail to load in 0.39. If not, no action is necessary. Please contact the library author to confirm whether this library is impacted."
+            )
+
+        # Multiple libraries with this warning - list them sorted by version
+        sorted_instances = sorted(instances, key=lambda p: p.library_engine_version)
+        error_lines = []
+        for i, problem in enumerate(sorted_instances, 1):
+            error_lines.append(
+                f"  {i}. Library built for engine version {problem.library_engine_version} may be impacted by upcoming modified_parameters_set removal"
+            )
+
+        header = f"Encountered {len(instances)} libraries with modified_parameters_set deprecation warnings:"
+        return header + "\n" + "\n".join(error_lines)

griptape_nodes/retained_mode/managers/fitness_problems/libraries/modified_parameters_set_removed_problem.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ModifiedParametersSetRemovedProblem(LibraryProblem):
+    """Problem indicating a library is incompatible due to modified_parameters_set removal.
+
+    This is stackable - multiple libraries can have this issue.
+    This severity is UNUSABLE - the library cannot be loaded.
+    """
+
+    library_engine_version: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[ModifiedParametersSetRemovedProblem]) -> str:
+        """Display modified_parameters_set removal problems.
+
+        Can handle multiple instances - they will be listed out sorted by library_engine_version.
+        """
+        if len(instances) == 1:
+            version = instances[0].library_engine_version
+            return (
+                f"This library (built for engine version {version}) is incompatible with Griptape Nodes 0.39+. "
+                "The 'modified_parameters_set' parameter has been removed from BaseNode methods: 'after_incoming_connection', 'after_outgoing_connection', 'after_incoming_connection_removed', 'after_outgoing_connection_removed', 'before_value_set', and 'after_value_set'. "
+                "If this library overrides any of these methods, it will not load or function properly. Please update to a newer version of this library or contact the library author immediately."
+            )
+
+        # Multiple libraries with this issue - list them sorted by version
+        sorted_instances = sorted(instances, key=lambda p: p.library_engine_version)
+        error_lines = []
+        for i, problem in enumerate(sorted_instances, 1):
+            error_lines.append(
+                f"  {i}. Library built for engine version {problem.library_engine_version} is incompatible due to modified_parameters_set removal"
+            )
+
+        header = f"Encountered {len(instances)} libraries incompatible due to modified_parameters_set removal:"
+        return header + "\n" + "\n".join(error_lines)

griptape_nodes/retained_mode/managers/fitness_problems/libraries/node_class_not_base_node_problem.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class NodeClassNotBaseNodeProblem(LibraryProblem):
+    """Problem indicating a node class doesn't inherit from BaseNode.
+
+    This is stackable - multiple node classes can have incorrect inheritance.
+    """
+
+    class_name: str
+    file_path: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[NodeClassNotBaseNodeProblem]) -> str:
+        """Display node class inheritance problems.
+
+        Can handle multiple non-BaseNode classes - they will be listed out sorted by class_name.
+        """
+        if len(instances) == 1:
+            problem = instances[0]
+            return f"Class '{problem.class_name}' from {problem.file_path} must inherit from BaseNode"
+
+        # Multiple inheritance issues - list them sorted by class_name
+        sorted_instances = sorted(instances, key=lambda p: p.class_name)
+        error_lines = []
+        for i, problem in enumerate(sorted_instances, 1):
+            error_lines.append(
+                f"  {i}. Class '{problem.class_name}' from {problem.file_path} must inherit from BaseNode"
+            )
+
+        header = f"Encountered {len(instances)} node classes that don't inherit from BaseNode:"
+        return header + "\n" + "\n".join(error_lines)