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

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

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.workflow_problem import WorkflowProblem
+
+
+@dataclass
+class LibraryVersionBelowRequiredProblem(WorkflowProblem):
+    """Problem indicating a library version is below the required version.
+
+    This is stackable - multiple libraries can have versions below requirements.
+    """
+
+    library_name: str
+    current_version: str
+    required_version: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[LibraryVersionBelowRequiredProblem]) -> str:
+        """Display library version below required problems.
+
+        Sorts by library_name and lists all affected libraries.
+        """
+        if len(instances) == 1:
+            problem = instances[0]
+            return f"'{problem.library_name}' v{problem.current_version} below required v{problem.required_version}. Update library to match workflow requirements."
+
+        # Sort by library_name
+        sorted_instances = sorted(instances, key=lambda p: p.library_name)
+
+        output_lines = []
+        output_lines.append(
+            f"{len(instances)} libraries below required versions. Update libraries to match workflow requirements:"
+        )
+        for i, problem in enumerate(sorted_instances, 1):
+            output_lines.append(
+                f"  {i}. {problem.library_name}: current v{problem.current_version}, required v{problem.required_version}"
+            )
+
+        return "\n".join(output_lines)

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

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.workflow_problem import WorkflowProblem
+
+
+@dataclass
+class LibraryVersionLargeDifferenceProblem(WorkflowProblem):
+    """Problem indicating a library has a large version difference from what workflow expects.
+
+    This is stackable - multiple libraries can have large version differences.
+    """
+
+    library_name: str
+    workflow_version: str
+    current_version: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[LibraryVersionLargeDifferenceProblem]) -> str:
+        """Display library version large difference problems.
+
+        Sorts by library_name and lists all affected libraries.
+        """
+        if len(instances) == 1:
+            problem = instances[0]
+            return f"Saved with '{problem.library_name}' v{problem.workflow_version}. You have v{problem.current_version}. Large version difference may cause compatibility issues. Re-save workflow (may require manual adjustments) to update to latest."
+
+        # Sort by library_name
+        sorted_instances = sorted(instances, key=lambda p: p.library_name)
+
+        output_lines = []
+        output_lines.append(
+            f"Uses {len(instances)} libraries with large version differences (may cause compatibility issues). Re-save workflow (may require manual adjustments) to update to latest:"
+        )
+        for i, problem in enumerate(sorted_instances, 1):
+            output_lines.append(
+                f"  {i}. {problem.library_name}: saved with v{problem.workflow_version}, current v{problem.current_version}"
+            )
+
+        return "\n".join(output_lines)

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

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.workflow_problem import WorkflowProblem
+
+
+@dataclass
+class LibraryVersionMajorMismatchProblem(WorkflowProblem):
+    """Problem indicating a library has a major version mismatch from what workflow expects.
+
+    This is stackable - multiple libraries can have major version mismatches.
+    """
+
+    library_name: str
+    workflow_version: str
+    current_version: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[LibraryVersionMajorMismatchProblem]) -> str:
+        """Display library version major mismatch problems.
+
+        Sorts by library_name and lists all affected libraries.
+        """
+        if len(instances) == 1:
+            problem = instances[0]
+            return f"Saved with '{problem.library_name}' v{problem.workflow_version}. You have v{problem.current_version}. Major version changes may include breaking changes. Re-save workflow (likely requires manual adjustments) to update to latest."
+
+        # Sort by library_name
+        sorted_instances = sorted(instances, key=lambda p: p.library_name)
+
+        output_lines = []
+        output_lines.append(
+            f"Uses {len(instances)} libraries with major version mismatches (may include breaking changes). Re-save workflow (likely requires manual adjustments) to update to latest:"
+        )
+        for i, problem in enumerate(sorted_instances, 1):
+            output_lines.append(
+                f"  {i}. {problem.library_name}: saved with v{problem.workflow_version}, current v{problem.current_version}"
+            )
+
+        return "\n".join(output_lines)

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

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.workflow_problem import WorkflowProblem
+
+
+@dataclass
+class LibraryVersionMinorDifferenceProblem(WorkflowProblem):
+    """Problem indicating a library has a minor version difference from what workflow expects.
+
+    This is stackable - multiple libraries can have minor version differences.
+    """
+
+    library_name: str
+    workflow_version: str
+    current_version: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[LibraryVersionMinorDifferenceProblem]) -> str:
+        """Display library version minor difference problems.
+
+        Sorts by library_name and lists all affected libraries.
+        """
+        if len(instances) == 1:
+            problem = instances[0]
+            return f"Saved with '{problem.library_name}' v{problem.workflow_version}. You have v{problem.current_version}. These are usually compatible. Re-save to update to latest."
+
+        # Sort by library_name
+        sorted_instances = sorted(instances, key=lambda p: p.library_name)
+
+        output_lines = []
+        output_lines.append(
+            f"Uses {len(instances)} libraries with minor version differences (usually compatible). Re-save to update to latest:"
+        )
+        for i, problem in enumerate(sorted_instances, 1):
+            output_lines.append(
+                f"  {i}. {problem.library_name}: saved with v{problem.workflow_version}, current v{problem.current_version}"
+            )
+
+        return "\n".join(output_lines)

griptape_nodes/retained_mode/managers/fitness_problems/workflows/missing_creation_date_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 MissingCreationDateProblem(WorkflowProblem):
+    """Problem indicating workflow metadata is missing a creation date.
+
+    This is one-time only - should only occur once per workflow.
+    """
+
+    default_date: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[MissingCreationDateProblem]) -> str:
+        """Display missing creation date problem."""
+        if len(instances) > 1:
+            logger.error(
+                "MissingCreationDateProblem received %d instances but should only receive 1. This indicates a logic error.",
+                len(instances),
+            )
+
+        problem = instances[0]
+        return f"Missing creation date. Defaulting to {problem.default_date}. Will be replaced on next save."

griptape_nodes/retained_mode/managers/fitness_problems/workflows/missing_last_modified_date_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 MissingLastModifiedDateProblem(WorkflowProblem):
+    """Problem indicating workflow metadata is missing a last modified date.
+
+    This is one-time only - should only occur once per workflow.
+    """
+
+    default_date: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[MissingLastModifiedDateProblem]) -> str:
+        """Display missing last modified date problem."""
+        if len(instances) > 1:
+            logger.error(
+                "MissingLastModifiedDateProblem received %d instances but should only receive 1. This indicates a logic error.",
+                len(instances),
+            )
+
+        problem = instances[0]
+        return f"Workflow metadata was missing a last modified date. Defaulting to {problem.default_date}. This value will be replaced with the current date the first time it is saved."

griptape_nodes/retained_mode/managers/fitness_problems/workflows/missing_toml_section_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 MissingTomlSectionProblem(WorkflowProblem):
+    """Problem indicating required TOML section is missing from workflow metadata.
+
+    This is one-time only - should only occur once per workflow.
+    """
+
+    section_path: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[MissingTomlSectionProblem]) -> str:
+        """Display missing TOML section problem."""
+        if len(instances) > 1:
+            logger.error(
+                "MissingTomlSectionProblem received %d instances but should only receive 1. This indicates a logic error.",
+                len(instances),
+            )
+
+        problem = instances[0]
+        return f"'{problem.section_path}' in TOML metadata not found."

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

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.workflow_problem import WorkflowProblem
+
+
+@dataclass
+class NodeTypeNotFoundProblem(WorkflowProblem):
+    """Problem indicating a workflow uses a node type that doesn't exist in current library version.
+
+    This is stackable - workflows can reference multiple missing node types.
+    """
+
+    node_type: str
+    library_name: str
+    current_library_version: str
+    workflow_library_version: str | None
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[NodeTypeNotFoundProblem]) -> str:
+        """Display node type not found problems.
+
+        Groups by library_name, then sorts by node_type within each library.
+        """
+        if len(instances) == 1:
+            problem = instances[0]
+            return f"Node type '{problem.node_type}' from '{problem.library_name}' not found in current version. May have been removed or renamed."
+
+        # Group by library_name
+        from collections import defaultdict
+
+        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"{len(instances)} node types not found (may have been removed or renamed):")
+
+        for library_name in sorted_libraries:
+            nodes = by_library[library_name]
+            # Sort nodes by node_type within each library
+            nodes.sort(key=lambda p: p.node_type)
+
+            output_lines.append(f"  From '{library_name}':")
+            output_lines.extend(f"    - {node.node_type}" for node in nodes)
+
+        return "\n".join(output_lines)

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

@@ -0,0 +1,27 @@
+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 WorkflowNotFoundProblem(WorkflowProblem):
+    """Problem indicating a workflow file could not be found.
+
+    This is one-time only - should only occur once per workflow.
+    """
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[WorkflowNotFoundProblem]) -> str:
+        """Display workflow not found problem."""
+        if len(instances) > 1:
+            logger.error(
+                "WorkflowNotFoundProblem received %d instances but should only receive 1. This indicates a logic error.",
+                len(instances),
+            )
+
+        return "Workflow file not found. Will be removed from configuration."

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

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Self
+
+
+class WorkflowProblem(ABC):
+    """Base class for all workflow fitness problems."""
+
+    @classmethod
+    @abstractmethod
+    def collate_problems_for_display(cls, instances: list[Self]) -> str:
+        """Collate one or more instances of this problem type for display.
+
+        Args:
+            instances: List of problem instances of this type
+
+        Returns:
+            A formatted string suitable for displaying to the user
+        """

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

@@ -0,0 +1,39 @@
+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 WorkflowSchemaVersionProblem(WorkflowProblem):
+    """Problem indicating a workflow has schema version compatibility issues.
+
+    This is context-specific and likely one-time only per workflow.
+    """
+
+    description: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[WorkflowSchemaVersionProblem]) -> str:
+        """Display workflow schema version problems."""
+        if len(instances) > 1:
+            logger.error(
+                "WorkflowSchemaVersionProblem received %d instances but should typically only receive 1. This may indicate multiple schema issues.",
+                len(instances),
+            )
+
+        if len(instances) == 1:
+            problem = instances[0]
+            return problem.description
+
+        # Multiple schema issues - list them
+        output_lines = []
+        output_lines.append(f"Encountered {len(instances)} workflow schema version issues:")
+        for i, problem in enumerate(instances, 1):
+            output_lines.append(f"  {i}. {problem.description}")
+
+        return "\n".join(output_lines)

griptape_nodes/retained_mode/managers/library_lifecycle/library_provenance/local_file.py

@@ -7,6 +7,7 @@ import logging
 import os
 import subprocess
 import sys
+from collections import defaultdict
 from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -108,7 +109,9 @@ class LibraryProvenanceLocalFile(LibraryProvenance):
         version_issues = GriptapeNodes.VersionCompatibilityManager().check_library_version_compatibility(schema)
         for issue in version_issues:
             lifecycle_severity = LibraryStatus(issue.severity.value)
-            issues.append(LifecycleIssue(message=issue.message, severity=lifecycle_severity))
+            # Collate the problem to get the display message
+            problem_message = type(issue.problem).collate_problems_for_display([issue.problem])
+            issues.append(LifecycleIssue(message=problem_message, severity=lifecycle_severity))
 
         # NOTE: Library name conflicts are checked at the manager level
         # across all evaluated libraries, not here
@@ -225,7 +228,7 @@ class LibraryProvenanceLocalFile(LibraryProvenance):
             issues=problems,
         )
 
-    def load_library(self, context: LibraryLifecycleContext) -> LibraryLoadedResult:
+    def load_library(self, context: LibraryLifecycleContext) -> LibraryLoadedResult:  # noqa: C901
         """Load this local file library into the registry."""
         issues = []
 
@@ -333,7 +336,18 @@ class LibraryProvenanceLocalFile(LibraryProvenance):
 
         # Convert any problems from library_load_results to issues
         if library_load_results.problems:
-            collated_problems = "\n".join(library_load_results.problems)
+            # Group problems by type and collate them for display
+            problems_by_type = defaultdict(list)
+            for problem in library_load_results.problems:
+                problems_by_type[type(problem)].append(problem)
+
+            # Collate each group
+            collated_strings = []
+            for problem_class, instances in problems_by_type.items():
+                collated_display = problem_class.collate_problems_for_display(instances)
+                collated_strings.append(collated_display)
+
+            collated_problems = "\n".join(collated_strings)
             issues.append(
                 LifecycleIssue(
                     message=collated_problems,