griptape-nodes 0.64.10__py3-none-any.whl → 0.65.0__py3-none-any.whl

griptape_nodes/retained_mode/griptape_nodes.py

@@ -188,7 +188,9 @@ class GriptapeNodes(metaclass=SingletonMeta):
 
         try:
             result_event = event_mgr.handle_request(request=request)
-            event_mgr.put_event(GriptapeNodeEvent(wrapped_event=result_event))
+            # Only queue result event if not suppressed
+            if not event_mgr.should_suppress_event(result_event):
+                event_mgr.put_event(GriptapeNodeEvent(wrapped_event=result_event))
         except Exception as e:
             logger.exception(
                 "Unhandled exception while processing request of type %s. "
@@ -214,7 +216,9 @@ class GriptapeNodes(metaclass=SingletonMeta):
 
         try:
             result_event = await event_mgr.ahandle_request(request=request)
-            await event_mgr.aput_event(GriptapeNodeEvent(wrapped_event=result_event))
+            # Only queue result event if not suppressed
+            if not event_mgr.should_suppress_event(result_event):
+                await event_mgr.aput_event(GriptapeNodeEvent(wrapped_event=result_event))
         except Exception as e:
             logger.exception(
                 "Unhandled exception while processing async request of type %s. "

griptape_nodes/retained_mode/managers/config_manager.py

@@ -33,7 +33,7 @@ from griptape_nodes.retained_mode.events.config_events import (
     SetConfigValueResultSuccess,
 )
 from griptape_nodes.retained_mode.managers.event_manager import EventManager
-from griptape_nodes.retained_mode.managers.settings import Settings
+from griptape_nodes.retained_mode.managers.settings import WORKFLOWS_TO_REGISTER_KEY, Settings
 from griptape_nodes.utils.dict_utils import get_dot_value, merge_dicts, set_dot_value
 
 logger = logging.getLogger("griptape_nodes")
@@ -210,7 +210,7 @@ class ConfigManager:
         An exception is made for `workflows_to_register` since resetting it gives the appearance of the user losing their workflows.
         """
         # TODO: https://github.com/griptape-ai/griptape-nodes/issues/1241 need a better way to annotate fields to ignore.
-        workflows_to_register = self.get_config_value("app_events.on_app_initialization_complete.workflows_to_register")
+        workflows_to_register = self.get_config_value(WORKFLOWS_TO_REGISTER_KEY)
         USER_CONFIG_PATH.write_text(
             json.dumps(
                 {
@@ -226,7 +226,7 @@ class ConfigManager:
         self.load_configs()
 
     def save_user_workflow_json(self, workflow_file_name: str) -> None:
-        config_loc = "app_events.on_app_initialization_complete.workflows_to_register"
+        config_loc = WORKFLOWS_TO_REGISTER_KEY
         existing_workflows = self.get_config_value(config_loc)
         if not existing_workflows:
             existing_workflows = []
@@ -234,14 +234,14 @@ class ConfigManager:
         self.set_config_value(config_loc, existing_workflows)
 
     def delete_user_workflow(self, workflow_file_name: str) -> None:
-        default_workflows = self.get_config_value("app_events.on_app_initialization_complete.workflows_to_register")
+        default_workflows = self.get_config_value(WORKFLOWS_TO_REGISTER_KEY)
         if default_workflows:
             default_workflows = [
                 saved_workflow
                 for saved_workflow in default_workflows
                 if (saved_workflow.lower() != workflow_file_name.lower())
             ]
-            self.set_config_value("app_events.on_app_initialization_complete.workflows_to_register", default_workflows)
+            self.set_config_value(WORKFLOWS_TO_REGISTER_KEY, default_workflows)
 
     def get_full_path(self, relative_path: str) -> Path:
         """Get a full path by combining the base path with a relative path.
@@ -288,7 +288,7 @@ class ConfigManager:
 
         if value is None:
             msg = f"Config key '{key}' not found in config file."
-            logger.warning(msg)
+            logger.debug(msg)
             return None
 
         if should_load_env_var_if_detected and isinstance(value, str) and value.startswith("$"):
@@ -528,7 +528,9 @@ class ConfigManager:
             level: The log level to set (e.g., 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL').
         """
         try:
-            logger.setLevel(level.upper())
-        except ValueError:
+            level_upper = level.upper()
+            log_level = getattr(logging, level_upper)
+            logger.setLevel(log_level)
+        except (ValueError, AttributeError):
             logger.error("Invalid log level %s. Defaulting to INFO.", level)
             logger.setLevel(logging.INFO)

griptape_nodes/retained_mode/managers/event_manager.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import inspect
+import logging
 import threading
 from collections import defaultdict
 from dataclasses import fields
@@ -13,14 +14,18 @@ from typing_extensions import TypedDict, TypeVar
 from griptape_nodes.exe_types.node_types import BaseNode
 from griptape_nodes.retained_mode.events.base_events import (
     AppPayload,
+    BaseEvent,
     EventResultFailure,
     EventResultSuccess,
+    ProgressEvent,
     RequestPayload,
+    ResultDetails,
     ResultPayload,
 )
 from griptape_nodes.utils.async_utils import call_function
 
 if TYPE_CHECKING:
+    import types
     from collections.abc import Awaitable, Callable
 
 
@@ -51,6 +56,8 @@ class EventManager:
         self._loop_thread_id: int | None = None
         # Keep a reference to the event loop for thread-safe operations
         self._event_loop: asyncio.AbstractEventLoop | None = None
+        # Per-event reference counting for event suppression
+        self._event_suppression_counts: dict[type, int] = {}
 
     @property
     def event_queue(self) -> asyncio.Queue:
@@ -59,6 +66,15 @@ class EventManager:
             raise ValueError(msg)
         return self._event_queue
 
+    def should_suppress_event(self, event: BaseEvent | ProgressEvent) -> bool:
+        """Check if events should be suppressed from being sent to websockets."""
+        event_type = type(event)
+        return self._event_suppression_counts.get(event_type, 0) > 0
+
+    def clear_event_suppression(self) -> None:
+        """Clear all event suppression counts."""
+        self._event_suppression_counts.clear()
+
     def initialize_queue(self, queue: asyncio.Queue | None = None) -> None:
         """Set the event queue for this manager.
 
@@ -162,6 +178,28 @@ class EventManager:
         if request_type in self._request_type_to_manager:
             del self._request_type_to_manager[request_type]
 
+    def _override_result_log_level(self, result: ResultPayload, level: int) -> None:
+        """Override the log level on all result details.
+
+        Args:
+            result: The result payload to modify
+            level: The new log level to set
+        """
+        if isinstance(result.result_details, ResultDetails):
+            for detail in result.result_details.result_details:
+                detail.level = level
+
+    def _log_result_details(self, result: ResultPayload) -> None:
+        """Log the result details at their specified levels.
+
+        Args:
+            result: The result payload containing details to log
+        """
+        if isinstance(result.result_details, ResultDetails):
+            logger = logging.getLogger("griptape_nodes")
+            for detail in result.result_details.result_details:
+                logger.log(detail.level, detail.message)
+
     def _handle_request_core(
         self,
         request: RP,
@@ -182,6 +220,13 @@ class EventManager:
             if workflow_mgr.should_squelch_workflow_altered():
                 callback_result.altered_workflow_state = False
 
+            # Override failure log level if requested
+            if callback_result.failed() and request.failure_log_level is not None:
+                self._override_result_log_level(callback_result, request.failure_log_level)
+
+            # Log result details (after potential level override)
+            self._log_result_details(callback_result)
+
             retained_mode_str = None
             # If request_id exists, that means it's a direct request from the GUI (not internal), and should be echoed by retained mode.
             if depth_manager.is_top_level() and context.get("request_id") is not None:
@@ -332,3 +377,126 @@ class EventManager:
             # Only flush if there are actually tracked parameters
             if node._tracked_parameters:
                 node.emit_parameter_changes()
+
+
+class EventSuppressionContext:
+    """Context manager to suppress events from being sent to websockets.
+
+    Use this to prevent internal operations (like deserialization/deletion of iteration flows)
+    from sending events to the GUI while still allowing the operations to complete normally.
+
+    Uses per-event reference counting to track nested suppression contexts.
+    Each event type maintains its own reference count, and is only unsuppressed
+    when its count reaches zero.
+    """
+
+    events_to_suppress: set[type]
+
+    def __init__(self, manager: EventManager, events_to_suppress: set[type]):
+        self.manager = manager
+        self.events_to_suppress = events_to_suppress
+
+    def __enter__(self) -> None:
+        for event_type in self.events_to_suppress:
+            current_count = self.manager._event_suppression_counts.get(event_type, 0)
+            self.manager._event_suppression_counts[event_type] = current_count + 1
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        exc_traceback: types.TracebackType | None,
+    ) -> None:
+        for event_type in self.events_to_suppress:
+            current_count = self.manager._event_suppression_counts.get(event_type, 0)
+            if current_count <= 1:
+                self.manager._event_suppression_counts.pop(event_type, None)
+            else:
+                self.manager._event_suppression_counts[event_type] = current_count - 1
+
+
+class EventTranslationContext:
+    """Context manager to translate node names in events from packaged to original names.
+
+    Use this to make loop execution events reference the original nodes that the user placed,
+    rather than the packaged node copies. This allows the UI to highlight the correct nodes
+    during loop execution.
+    """
+
+    def __init__(self, manager: EventManager, node_name_mapping: dict[str, str]):
+        """Initialize the event translation context.
+
+        Args:
+            manager: The EventManager to intercept events from
+            node_name_mapping: Dict mapping packaged node names to original node names
+        """
+        self.manager = manager
+        self.node_name_mapping = node_name_mapping
+        self.original_put_event: Any = None
+
+    def __enter__(self) -> None:
+        """Enter the context and start translating events."""
+        self.original_put_event = self.manager.put_event
+        self.manager.put_event = self._translate_and_put  # type: ignore[method-assign]
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        exc_traceback: types.TracebackType | None,
+    ) -> None:
+        """Exit the context and restore original event sending."""
+        self.manager.put_event = self.original_put_event  # type: ignore[method-assign]
+
+    def _translate_and_put(self, event: Any) -> None:
+        """Translate node names in events and put them in the queue.
+
+        Args:
+            event: The event to potentially translate and send
+        """
+        # Check if event has node_name attribute and needs translation
+        if hasattr(event, "node_name"):
+            node_name = event.node_name
+            if node_name in self.node_name_mapping:
+                # Create a copy of the event with the translated node name
+                translated_event = self._copy_event_with_translated_name(event)
+                self.original_put_event(translated_event)
+                return
+
+        # No translation needed, send as-is
+        self.original_put_event(event)
+
+    def _copy_event_with_translated_name(self, event: Any) -> Any:
+        """Create a copy of an event with the node name translated to the original name.
+
+        Args:
+            event: The event to copy and translate
+
+        Returns:
+            A new event instance with the translated node name
+        """
+        # Get the original node name from the mapping
+        node_name = event.node_name
+        original_node_name = self.node_name_mapping[node_name]
+
+        # Get the event class
+        event_class = type(event)
+
+        # Create a dict of all event attributes
+        if hasattr(event, "model_dump"):
+            event_dict = event.model_dump()
+        elif hasattr(event, "__dict__"):
+            event_dict = event.__dict__.copy()
+        else:
+            # Can't copy this event, return as-is
+            return event
+
+        # Replace the node name with the original name
+        event_dict["node_name"] = original_node_name
+
+        # Create a new event instance with the translated name
+        try:
+            return event_class(**event_dict)
+        except Exception:
+            # If we can't create a new instance, return the original
+            return event

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

@@ -22,6 +22,7 @@ from .modified_parameters_set_removed_problem import ModifiedParametersSetRemove
 from .node_class_not_base_node_problem import NodeClassNotBaseNodeProblem
 from .node_class_not_found_problem import NodeClassNotFoundProblem
 from .node_module_import_problem import NodeModuleImportProblem
+from .old_xdg_location_warning_problem import OldXdgLocationWarningProblem
 from .sandbox_directory_missing_problem import SandboxDirectoryMissingProblem
 from .ui_options_field_modified_incompatible_problem import UiOptionsFieldModifiedIncompatibleProblem
 from .ui_options_field_modified_warning_problem import UiOptionsFieldModifiedWarningProblem
@@ -51,6 +52,7 @@ __all__ = [
     "NodeClassNotBaseNodeProblem",
     "NodeClassNotFoundProblem",
     "NodeModuleImportProblem",
+    "OldXdgLocationWarningProblem",
     "SandboxDirectoryMissingProblem",
     "UiOptionsFieldModifiedIncompatibleProblem",
     "UiOptionsFieldModifiedWarningProblem",

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

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from xdg_base_dirs import xdg_data_home
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class OldXdgLocationWarningProblem(LibraryProblem):
+    """Problem warning that a library is located in the old XDG data directory.
+
+    This is a warning-level problem (FLAWED status) - the library will still
+    load and function normally, but users should migrate to the new location.
+    """
+
+    old_path: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[OldXdgLocationWarningProblem]) -> str:
+        """Display old XDG location warning.
+
+        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(
+                "OldXdgLocationWarningProblem: Expected 1 instance but got %s. Each LibraryInfo should only have one OldXdgLocationWarningProblem.",
+                len(instances),
+            )
+
+        old_libraries_path = xdg_data_home() / "griptape_nodes" / "libraries"
+        return (
+            f"WARNING: Starting with version 0.65.0, libraries are now managed in your workspace directory. "
+            f"This library is located in {old_libraries_path} and will not receive updates because it is not tracked "
+            f"by the library manager. "
+            f"To migrate: run 'gtn init'. "
+            f"The library will continue to function normally until migrated."
+        )