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

griptape_nodes/retained_mode/managers/fitness_problems/libraries/node_class_not_found_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 NodeClassNotFoundProblem(LibraryProblem):
+    """Problem indicating a node class was not found in its module.
+
+    This is stackable - multiple node classes can be missing.
+    """
+
+    class_name: str
+    file_path: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[NodeClassNotFoundProblem]) -> str:
+        """Display node class not found problems.
+
+        Can handle multiple missing classes - they will be listed out sorted by class_name.
+        """
+        if len(instances) == 1:
+            problem = instances[0]
+            return f"Class '{problem.class_name}' not found in module '{problem.file_path}'"
+
+        # Multiple missing classes - 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}' not found in '{problem.file_path}'")
+
+        header = f"Encountered {len(instances)} node classes not found in their modules:"
+        return header + "\n" + "\n".join(error_lines)

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

@@ -0,0 +1,53 @@
+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 NodeModuleImportProblem(LibraryProblem):
+    """Problem indicating a node module could not be imported.
+
+    This is stackable - multiple node modules can fail to import.
+    """
+
+    class_name: str
+    file_path: str
+    error_message: str
+    root_cause: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[NodeModuleImportProblem]) -> str:
+        """Display node module import problems.
+
+        Groups by root_cause and lists affected nodes under each cause.
+        """
+        if len(instances) == 1:
+            problem = instances[0]
+            return f"Failed to import module for node '{problem.class_name}': {problem.root_cause}"
+
+        # Group by root_cause
+        by_cause = defaultdict(list)
+        for problem in instances:
+            by_cause[problem.root_cause].append(problem)
+
+        # Sort root causes alphabetically
+        sorted_causes = sorted(by_cause.keys())
+
+        output_lines = []
+        output_lines.append(f"Encountered {len(instances)} node module import failures:")
+
+        for cause in sorted_causes:
+            nodes = by_cause[cause]
+            # Sort nodes by class_name within each cause group
+            nodes.sort(key=lambda p: p.class_name)
+
+            output_lines.append(f"  {cause}:")
+            output_lines.extend(f"    - {node.class_name}" for node in nodes)
+
+        return "\n".join(output_lines)

griptape_nodes/retained_mode/managers/fitness_problems/libraries/sandbox_directory_missing_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 SandboxDirectoryMissingProblem(LibraryProblem):
+    """Problem indicating the sandbox directory does not exist."""
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[SandboxDirectoryMissingProblem]) -> str:
+        """Display sandbox directory missing 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(
+                "SandboxDirectoryMissingProblem: Expected 1 instance but got %s. Each LibraryInfo should only have one SandboxDirectoryMissingProblem.",
+                len(instances),
+            )
+
+        return "Sandbox directory does not exist. If you wish to create a Sandbox directory to develop custom nodes: in the Griptape Nodes editor, go to Settings -> Libraries and navigate to the Sandbox Settings."

griptape_nodes/retained_mode/managers/fitness_problems/libraries/ui_options_field_modified_incompatible_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 UiOptionsFieldModifiedIncompatibleProblem(LibraryProblem):
+    """Problem indicating a library is incompatible due to ui_options field modification.
+
+    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[UiOptionsFieldModifiedIncompatibleProblem]) -> str:
+        """Display ui_options field modification incompatibility 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 'ui_options' field has been modified on all Elements. In order to function properly, all nodes must update ui_options by setting its value to a new dictionary. Updating ui_options by accessing the private field _ui_options will no longer create UI updates in the editor."
+                "If this library accesses the private _ui_options field, it will not update the editor 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 ui_options field modification"
+            )
+
+        header = f"Encountered {len(instances)} libraries incompatible due to ui_options field modification:"
+        return header + "\n" + "\n".join(error_lines)

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

@@ -0,0 +1,35 @@
+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 UiOptionsFieldModifiedWarningProblem(LibraryProblem):
+    """Problem warning that a library may not function properly due to ui_options field modification.
+
+    This is stackable - multiple libraries can have this warning.
+    This severity is FLAWED - the library can be loaded but has warnings.
+    """
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[UiOptionsFieldModifiedWarningProblem]) -> str:
+        """Display ui_options field modification warnings.
+
+        Can handle multiple instances.
+        """
+        if len(instances) > 1:
+            logger.error(
+                "UiOptionsFieldModifiedWarningProblem: Expected 1 instance but got %s. This warning should only appear once per library.",
+                len(instances),
+            )
+
+        return (
+            "WARNING: The 'ui_options' field has been modified in Griptape Nodes 0.38 on all BaseNodeElements."
+            "In order to function properly, all nodes must update ui_options by setting its value to a new dictionary. Updating ui_options by accessing the private field _ui_options will no longer create UI updates in the editor."
+            "If this library accesses the private _ui_options field, it will not update the editor properly. Please update to a newer version of this library or contact the library author immediately."
+        )

griptape_nodes/retained_mode/managers/fitness_problems/libraries/update_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 UpdateConfigCategoryProblem(LibraryProblem):
+    """Problem indicating a config category failed to be updated."""
+
+    category_name: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[UpdateConfigCategoryProblem]) -> str:
+        """Display config category update 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(
+                "UpdateConfigCategoryProblem: Expected 1 instance but got %s. Each LibraryInfo should only have one UpdateConfigCategoryProblem.",
+                len(instances),
+            )
+
+        # Use the first instance's category name
+        category = instances[0].category_name
+        return f"Failed to update config category '{category}'."

griptape_nodes/retained_mode/managers/fitness_problems/libraries/venv_creation_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 VenvCreationFailedProblem(LibraryProblem):
+    """Problem indicating virtual environment creation failed."""
+
+    error_message: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[VenvCreationFailedProblem]) -> str:
+        """Display venv creation 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(
+                "VenvCreationFailedProblem: Expected 1 instance but got %s. Each LibraryInfo should only have one VenvCreationFailedProblem.",
+                len(instances),
+            )
+
+        # Use the first instance's error message
+        error_msg = instances[0].error_message
+        return f"Failed to create virtual environment for library dependencies. Error: {error_msg}"

griptape_nodes/retained_mode/managers/fitness_problems/workflows/__init__.py

@@ -0,0 +1,75 @@
+"""Workflow fitness problem classes."""
+
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.deprecated_node_in_workflow_problem import (
+    DeprecatedNodeInWorkflowProblem,
+)
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.invalid_dependency_version_string_problem import (
+    InvalidDependencyVersionStringProblem,
+)
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.invalid_library_version_string_problem import (
+    InvalidLibraryVersionStringProblem,
+)
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.invalid_metadata_schema_problem import (
+    InvalidMetadataSchemaProblem,
+)
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.invalid_metadata_section_count_problem import (
+    InvalidMetadataSectionCountProblem,
+)
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.invalid_toml_format_problem import (
+    InvalidTomlFormatProblem,
+)
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.library_not_registered_problem import (
+    LibraryNotRegisteredProblem,
+)
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.library_version_below_required_problem import (
+    LibraryVersionBelowRequiredProblem,
+)
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.library_version_large_difference_problem import (
+    LibraryVersionLargeDifferenceProblem,
+)
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.library_version_major_mismatch_problem import (
+    LibraryVersionMajorMismatchProblem,
+)
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.library_version_minor_difference_problem import (
+    LibraryVersionMinorDifferenceProblem,
+)
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.missing_creation_date_problem import (
+    MissingCreationDateProblem,
+)
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.missing_last_modified_date_problem import (
+    MissingLastModifiedDateProblem,
+)
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.missing_toml_section_problem import (
+    MissingTomlSectionProblem,
+)
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.node_type_not_found_problem import (
+    NodeTypeNotFoundProblem,
+)
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.workflow_not_found_problem import (
+    WorkflowNotFoundProblem,
+)
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.workflow_problem import WorkflowProblem
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.workflow_schema_version_problem import (
+    WorkflowSchemaVersionProblem,
+)
+
+__all__ = [
+    "DeprecatedNodeInWorkflowProblem",
+    "InvalidDependencyVersionStringProblem",
+    "InvalidLibraryVersionStringProblem",
+    "InvalidMetadataSchemaProblem",
+    "InvalidMetadataSectionCountProblem",
+    "InvalidTomlFormatProblem",
+    "LibraryNotRegisteredProblem",
+    "LibraryVersionBelowRequiredProblem",
+    "LibraryVersionLargeDifferenceProblem",
+    "LibraryVersionMajorMismatchProblem",
+    "LibraryVersionMinorDifferenceProblem",
+    "MissingCreationDateProblem",
+    "MissingLastModifiedDateProblem",
+    "MissingTomlSectionProblem",
+    "NodeTypeNotFoundProblem",
+    "WorkflowNotFoundProblem",
+    "WorkflowProblem",
+    "WorkflowSchemaVersionProblem",
+]

griptape_nodes/retained_mode/managers/fitness_problems/workflows/deprecated_node_in_workflow_problem.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.workflow_problem import WorkflowProblem
+
+
+@dataclass
+class DeprecatedNodeInWorkflowProblem(WorkflowProblem):
+    """Problem indicating a workflow uses a deprecated node.
+
+    This is stackable - workflows can use multiple deprecated nodes.
+    """
+
+    node_display_name: str
+    node_type: str
+    library_name: str
+    current_library_version: str
+    workflow_library_version: str | None
+    removal_version: str | None
+    deprecation_message: str | None
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[DeprecatedNodeInWorkflowProblem]) -> str:
+        """Display deprecated node in workflow problems.
+
+        Groups by library, then by deprecation message within each library.
+        """
+        if len(instances) == 1:
+            problem = instances[0]
+            removal_info = (
+                f"removed in v{problem.removal_version}" if problem.removal_version else "may be removed in future"
+            )
+            message = (
+                f"Uses deprecated node '{problem.node_display_name}' from '{problem.library_name}' ({removal_info})"
+            )
+            if problem.deprecation_message:
+                message += f". {problem.deprecation_message}"
+            else:
+                message += ". No remediation steps provided by library author."
+            return message
+
+        # Group by library
+        by_library = defaultdict(list)
+        for problem in instances:
+            by_library[problem.library_name].append(problem)
+
+        # Sort libraries alphabetically
+        sorted_libraries = sorted(by_library.keys())
+
+        output_lines = []
+        output_lines.append(f"Uses {len(instances)} deprecated nodes:")
+
+        for library_name in sorted_libraries:
+            nodes = by_library[library_name]
+            output_lines.append(f"  From '{library_name}':")
+
+            # Group nodes within this library by deprecation_message
+            by_message = defaultdict(list)
+            for node in nodes:
+                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.node_display_name)
+
+                if message:
+                    output_lines.append(f"    {message}:")
+                    output_lines.extend(f"      - {node.node_display_name}" for node in message_nodes)
+                else:
+                    # No remediation steps provided
+                    output_lines.extend(
+                        f"    - {node.node_display_name} (no remediation steps provided by library author)"
+                        for node in message_nodes
+                    )
+
+        return "\n".join(output_lines)

griptape_nodes/retained_mode/managers/fitness_problems/workflows/invalid_dependency_version_string_problem.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.workflow_problem import WorkflowProblem
+
+
+@dataclass
+class InvalidDependencyVersionStringProblem(WorkflowProblem):
+    """Problem indicating workflow cited an invalid version string for a library dependency.
+
+    This is stackable - multiple libraries can have invalid version strings.
+    """
+
+    library_name: str
+    version_string: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[InvalidDependencyVersionStringProblem]) -> str:
+        """Display invalid dependency version string problems.
+
+        Sorts by library_name and lists all affected libraries.
+        """
+        if len(instances) == 1:
+            problem = instances[0]
+            return f"Workflow has invalid version string '{problem.version_string}' for '{problem.library_name}'. Must be major.minor.patch format."
+
+        # Sort by library_name
+        sorted_instances = sorted(instances, key=lambda p: p.library_name)
+
+        output_lines = []
+        output_lines.append(
+            f"Workflow has {len(instances)} invalid dependency version strings (must be major.minor.patch format):"
+        )
+        for i, problem in enumerate(sorted_instances, 1):
+            output_lines.append(f"  {i}. {problem.library_name}: '{problem.version_string}'")
+
+        return "\n".join(output_lines)

griptape_nodes/retained_mode/managers/fitness_problems/workflows/invalid_library_version_string_problem.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.workflow_problem import WorkflowProblem
+
+
+@dataclass
+class InvalidLibraryVersionStringProblem(WorkflowProblem):
+    """Problem indicating a registered library has an invalid version string.
+
+    This is stackable - multiple libraries can have invalid version strings.
+    """
+
+    library_name: str
+    version_string: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[InvalidLibraryVersionStringProblem]) -> str:
+        """Display invalid library version string problems.
+
+        Sorts by library_name and lists all affected libraries.
+        """
+        if len(instances) == 1:
+            problem = instances[0]
+            return f"'{problem.library_name}' has invalid version string '{problem.version_string}'. Must be major.minor.patch format."
+
+        # Sort by library_name
+        sorted_instances = sorted(instances, key=lambda p: p.library_name)
+
+        output_lines = []
+        output_lines.append(
+            f"{len(instances)} libraries with invalid version strings (must be major.minor.patch format):"
+        )
+        for i, problem in enumerate(sorted_instances, 1):
+            output_lines.append(f"  {i}. {problem.library_name}: '{problem.version_string}'")
+
+        return "\n".join(output_lines)

griptape_nodes/retained_mode/managers/fitness_problems/workflows/invalid_metadata_schema_problem.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.workflow_problem import WorkflowProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class InvalidMetadataSchemaProblem(WorkflowProblem):
+    """Problem indicating workflow metadata doesn't match required schema.
+
+    This is one-time only - should only occur once per workflow.
+    """
+
+    section_path: str
+    error_message: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[InvalidMetadataSchemaProblem]) -> str:
+        """Display invalid metadata schema problem."""
+        if len(instances) > 1:
+            logger.error(
+                "InvalidMetadataSchemaProblem received %d instances but should only receive 1. This indicates a logic error.",
+                len(instances),
+            )
+
+        problem = instances[0]
+        return f"'{problem.section_path}' metadata doesn't match schema: {problem.error_message}"

griptape_nodes/retained_mode/managers/fitness_problems/workflows/invalid_metadata_section_count_problem.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.workflow_problem import WorkflowProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class InvalidMetadataSectionCountProblem(WorkflowProblem):
+    """Problem indicating workflow has wrong number of metadata sections.
+
+    This is one-time only - should only occur once per workflow.
+    """
+
+    section_name: str
+    count: int
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[InvalidMetadataSectionCountProblem]) -> str:
+        """Display invalid metadata section count problem."""
+        if len(instances) > 1:
+            logger.error(
+                "InvalidMetadataSectionCountProblem received %d instances but should only receive 1. This indicates a logic error.",
+                len(instances),
+            )
+
+        problem = instances[0]
+        return f"Has {problem.count} '{problem.section_name}' sections. Expected exactly 1."

griptape_nodes/retained_mode/managers/fitness_problems/workflows/invalid_toml_format_problem.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.workflow_problem import WorkflowProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class InvalidTomlFormatProblem(WorkflowProblem):
+    """Problem indicating workflow metadata is not valid TOML.
+
+    This is one-time only - should only occur once per workflow.
+    """
+
+    error_message: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[InvalidTomlFormatProblem]) -> str:
+        """Display invalid TOML format problem."""
+        if len(instances) > 1:
+            logger.error(
+                "InvalidTomlFormatProblem received %d instances but should only receive 1. This indicates a logic error.",
+                len(instances),
+            )
+
+        problem = instances[0]
+        return f"Metadata not valid TOML: {problem.error_message}"

griptape_nodes/retained_mode/managers/fitness_problems/workflows/library_not_registered_problem.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.workflow_problem import WorkflowProblem
+
+
+@dataclass
+class LibraryNotRegisteredProblem(WorkflowProblem):
+    """Problem indicating a required library was not successfully registered.
+
+    This is stackable - multiple libraries can fail to register.
+    """
+
+    library_name: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[LibraryNotRegisteredProblem]) -> str:
+        """Display library not registered problems.
+
+        Sorts by library_name and lists all affected libraries.
+        """
+        if len(instances) == 1:
+            problem = instances[0]
+            return f"'{problem.library_name}' not registered. May have other problems preventing load."
+
+        # Sort by library_name
+        sorted_instances = sorted(instances, key=lambda p: p.library_name)
+
+        output_lines = []
+        output_lines.append(f"{len(instances)} libraries not registered (may have other problems preventing load):")
+        for i, problem in enumerate(sorted_instances, 1):
+            output_lines.append(f"  {i}. {problem.library_name}")
+
+        return "\n".join(output_lines)