griptape-nodes 0.70.0__py3-none-any.whl → 0.71.0__py3-none-any.whl

griptape_nodes/bootstrap/workflow_publishers/subprocess_workflow_publisher.py

@@ -8,9 +8,11 @@ from typing import TYPE_CHECKING, Any, Self
 import anyio
 
 from griptape_nodes.bootstrap.utils.python_subprocess_executor import PythonSubprocessExecutor
+from griptape_nodes.bootstrap.utils.subprocess_websocket_listener import SubprocessWebSocketListenerMixin
 from griptape_nodes.bootstrap.workflow_publishers.local_workflow_publisher import LocalWorkflowPublisher
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
     from types import TracebackType
 
 logger = logging.getLogger(__name__)
@@ -20,11 +22,18 @@ class SubprocessWorkflowPublisherError(Exception):
     """Exception raised during subprocess workflow publishing."""
 
 
-class SubprocessWorkflowPublisher(LocalWorkflowPublisher, PythonSubprocessExecutor):
-    def __init__(self) -> None:
+class SubprocessWorkflowPublisher(LocalWorkflowPublisher, PythonSubprocessExecutor, SubprocessWebSocketListenerMixin):
+    def __init__(
+        self,
+        on_event: Callable[[dict], None] | None = None,
+        session_id: str | None = None,
+    ) -> None:
         PythonSubprocessExecutor.__init__(self)
+        self._init_websocket_listener(session_id=session_id, on_event=on_event)
 
     async def __aenter__(self) -> Self:
+        """Async context manager entry: start WebSocket listener."""
+        await self._start_websocket_listener()
         return self
 
     async def __aexit__(
@@ -33,7 +42,8 @@ class SubprocessWorkflowPublisher(LocalWorkflowPublisher, PythonSubprocessExecut
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
     ) -> None:
-        return
+        """Async context manager exit: stop WebSocket listener."""
+        await self._stop_websocket_listener()
 
     async def arun(
         self,
@@ -76,6 +86,8 @@ class SubprocessWorkflowPublisher(LocalWorkflowPublisher, PythonSubprocessExecut
                 publisher_name,
                 "--published-workflow-file-name",
                 published_workflow_file_name,
+                "--session-id",
+                self._session_id,
             ]
             if kwargs.get("pickle_control_flow_result"):
                 args.append("--pickle-control-flow-result")
@@ -87,3 +99,10 @@ class SubprocessWorkflowPublisher(LocalWorkflowPublisher, PythonSubprocessExecut
                     "GTN_CONFIG_ENABLE_WORKSPACE_FILE_WATCHING": "false",
                 },
             )
+
+    async def _handle_subprocess_event(self, event: dict) -> None:
+        """Handle publisher-specific events from the subprocess.
+
+        Currently, this is a no-op as we just forward all events via the on_event callback.
+        Subclasses can override to add specific event handling logic.
+        """

griptape_nodes/bootstrap/workflow_publishers/utils/subprocess_script.py

@@ -1,7 +1,11 @@
 import asyncio
 import logging
 from argparse import ArgumentParser
+from dataclasses import dataclass
 
+from griptape_nodes.bootstrap.workflow_publishers.local_session_workflow_publisher import (
+    LocalSessionWorkflowPublisher,
+)
 from griptape_nodes.bootstrap.workflow_publishers.local_workflow_publisher import LocalWorkflowPublisher
 
 logging.basicConfig(level=logging.INFO)
@@ -9,25 +13,35 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
-async def _main(
-    workflow_name: str,
-    workflow_path: str,
-    publisher_name: str,
-    published_workflow_file_name: str,
-    *,
-    pickle_control_flow_result: bool,
-) -> None:
-    local_publisher = LocalWorkflowPublisher()
-    async with local_publisher as publisher:
+@dataclass
+class PublishWorkflowArgs:
+    """Arguments for publishing a workflow."""
+
+    workflow_name: str
+    workflow_path: str
+    publisher_name: str
+    published_workflow_file_name: str
+    pickle_control_flow_result: bool
+    session_id: str | None = None
+
+
+async def _main(args: PublishWorkflowArgs) -> None:
+    publisher: LocalWorkflowPublisher
+    if args.session_id is not None:
+        publisher = LocalSessionWorkflowPublisher(session_id=args.session_id)
+    else:
+        publisher = LocalWorkflowPublisher()
+
+    async with publisher:
         await publisher.arun(
-            workflow_name=workflow_name,
-            workflow_path=workflow_path,
-            publisher_name=publisher_name,
-            published_workflow_file_name=published_workflow_file_name,
-            pickle_control_flow_result=pickle_control_flow_result,
+            workflow_name=args.workflow_name,
+            workflow_path=args.workflow_path,
+            publisher_name=args.publisher_name,
+            published_workflow_file_name=args.published_workflow_file_name,
+            pickle_control_flow_result=args.pickle_control_flow_result,
         )
 
-    msg = f"Published workflow to file: {published_workflow_file_name}"
+    msg = f"Published workflow to file: {args.published_workflow_file_name}"
     logger.info(msg)
 
 
@@ -57,13 +71,19 @@ if __name__ == "__main__":
         default=False,
         help="Whether to pickle control flow results",
     )
-    args = parser.parse_args()
-    asyncio.run(
-        _main(
-            workflow_name=args.workflow_name,
-            workflow_path=args.workflow_path,
-            publisher_name=args.publisher_name,
-            published_workflow_file_name=args.published_workflow_file_name,
-            pickle_control_flow_result=args.pickle_control_flow_result,
-        )
+    parser.add_argument(
+        "--session-id",
+        default=None,
+        help="Session ID for WebSocket event emission",
+    )
+    parsed_args = parser.parse_args()
+
+    publish_args = PublishWorkflowArgs(
+        workflow_name=parsed_args.workflow_name,
+        workflow_path=parsed_args.workflow_path,
+        publisher_name=parsed_args.publisher_name,
+        published_workflow_file_name=parsed_args.published_workflow_file_name,
+        pickle_control_flow_result=parsed_args.pickle_control_flow_result,
+        session_id=parsed_args.session_id,
     )
+    asyncio.run(_main(publish_args))

griptape_nodes/common/node_executor.py

@@ -102,6 +102,8 @@ from griptape_nodes.retained_mode.managers.event_manager import (
 )
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from griptape_nodes.retained_mode.events.node_events import SerializedNodeCommands
     from griptape_nodes.retained_mode.managers.library_manager import LibraryManager
 
@@ -220,6 +222,8 @@ class NodeExecutor:
                 # Just execute the node normally! This means we aren't doing any special packaging.
                 await node.aprocess()
                 return
+            # Clear execution state before subprocess execution starts
+            node.subflow_execution_component.clear_execution_state()
             if execution_type == PRIVATE_EXECUTION:
                 # Package the flow and run it in a subprocess.
                 await self._execute_private_workflow(node)
@@ -251,7 +255,9 @@ class NodeExecutor:
             file_name: Name of workflow for logging
             package_result: The packaging result containing parameter mappings
         """
-        my_subprocess_result = await self._execute_subprocess(workflow_path, file_name)
+        # Pass node for event updates if it's a SubflowNodeGroup
+        subflow_node = node if isinstance(node, SubflowNodeGroup) else None
+        my_subprocess_result = await self._execute_subprocess(workflow_path, file_name, node=subflow_node)
         parameter_output_values = self._extract_parameter_output_values(my_subprocess_result)
         self._apply_parameter_values_to_node(node, parameter_output_values, package_result)
 
@@ -343,7 +349,7 @@ class NodeExecutor:
 
         try:
             published_workflow_filename = await self._publish_library_workflow(
-                workflow_result, library_name, result.file_name
+                workflow_result, library_name, result.file_name, node=node
             )
         except Exception as e:
             logger.exception(
@@ -481,19 +487,29 @@ class NodeExecutor:
         )
 
     async def _publish_library_workflow(
-        self, workflow_result: SaveWorkflowFileFromSerializedFlowResultSuccess, library_name: str, file_name: str
+        self,
+        workflow_result: SaveWorkflowFileFromSerializedFlowResultSuccess,
+        library_name: str,
+        file_name: str,
+        node: BaseNode | None = None,
     ) -> Path:
-        subprocess_workflow_publisher = SubprocessWorkflowPublisher()
+        # Define event callback if node is a SubflowNodeGroup for GUI updates
+        on_event: Callable[[dict], None] | None = None
+        if isinstance(node, SubflowNodeGroup):
+            on_event = node.subflow_execution_component.handle_publishing_event
+
+        subprocess_workflow_publisher = SubprocessWorkflowPublisher(on_event=on_event)
         published_filename = f"{Path(workflow_result.file_path).stem}_published"
         published_workflow_filename = GriptapeNodes.ConfigManager().workspace_path / (published_filename + ".py")
 
-        await subprocess_workflow_publisher.arun(
-            workflow_name=file_name,
-            workflow_path=workflow_result.file_path,
-            publisher_name=library_name,
-            published_workflow_file_name=published_filename,
-            pickle_control_flow_result=True,
-        )
+        async with subprocess_workflow_publisher:
+            await subprocess_workflow_publisher.arun(
+                workflow_name=file_name,
+                workflow_path=workflow_result.file_path,
+                publisher_name=library_name,
+                published_workflow_file_name=published_filename,
+                pickle_control_flow_result=True,
+            )
 
         if not published_workflow_filename.exists():
             msg = f"Published workflow file does not exist at path: {published_workflow_filename}"
@@ -507,6 +523,7 @@ class NodeExecutor:
         file_name: str,
         pickle_control_flow_result: bool = True,  # noqa: FBT001, FBT002
         flow_input: dict[str, Any] | None = None,
+        node: SubflowNodeGroup | None = None,
     ) -> dict[str, dict[str | SerializedNodeCommands.UniqueParameterValueUUID, Any] | None]:
         """Execute the published workflow in a subprocess.
 
@@ -515,6 +532,7 @@ class NodeExecutor:
             file_name: Name of the workflow for logging
             pickle_control_flow_result: Whether to pickle control flow results (defaults to True)
             flow_input: Optional dictionary of parameter values to pass to the workflow's StartFlow node
+            node: Optional SubflowNodeGroup to receive real-time event updates
 
         Returns:
             The subprocess execution output dictionary
@@ -523,7 +541,15 @@ class NodeExecutor:
             SubprocessWorkflowExecutor,
         )
 
-        subprocess_executor = SubprocessWorkflowExecutor(workflow_path=str(published_workflow_filename))
+        # Define event callback if node provided for GUI updates
+        on_event: Callable[[dict], None] | None = None
+        if node is not None:
+            on_event = node.subflow_execution_component.handle_execution_event
+
+        subprocess_executor = SubprocessWorkflowExecutor(
+            workflow_path=str(published_workflow_filename),
+            on_event=on_event,
+        )
         try:
             async with subprocess_executor as executor:
                 await executor.arun(
@@ -1454,6 +1480,10 @@ class NodeExecutor:
         # Get execution environment
         execution_type = node.get_parameter_value(node.execution_environment.name)
 
+        # Clear execution state before subprocess execution starts (for non-local execution)
+        if execution_type != LOCAL_EXECUTION:
+            node.subflow_execution_component.clear_execution_state()
+
         # Check if we should run in order (default is sequential/True)
         run_in_order = node.get_parameter_value("run_in_order")
 
@@ -2550,11 +2580,14 @@ class NodeExecutor:
                             end_loop_node.name,
                         )
 
+                        # Pass node for event updates if it's a SubflowNodeGroup (includes BaseIterativeNodeGroup)
+                        subflow_node = end_loop_node if isinstance(end_loop_node, SubflowNodeGroup) else None
                         subprocess_result = await self._execute_subprocess(
                             published_workflow_filename=workflow_path,
                             file_name=f"{file_name_prefix}_iteration_{iteration_index}",
                             pickle_control_flow_result=True,
                             flow_input=flow_input,
+                            node=subflow_node,
                         )
                         iteration_outputs.append((iteration_index, True, subprocess_result))
                     except Exception:
@@ -2562,6 +2595,9 @@ class NodeExecutor:
                         iteration_outputs.append((iteration_index, False, None))
             else:
                 # Execute all iterations concurrently
+                # Get subflow_node reference for event updates (scoped outside the closure)
+                subflow_node = end_loop_node if isinstance(end_loop_node, SubflowNodeGroup) else None
+
                 async def run_single_iteration(iteration_index: int) -> tuple[int, bool, dict[str, Any] | None]:
                     try:
                         flow_input = {start_node_name: parameter_values_per_iteration[iteration_index]}
@@ -2577,6 +2613,7 @@ class NodeExecutor:
                             file_name=f"{file_name_prefix}_iteration_{iteration_index}",
                             pickle_control_flow_result=True,
                             flow_input=flow_input,
+                            node=subflow_node,
                         )
                     except Exception:
                         logger.exception("Iteration %d failed for loop '%s'", iteration_index, end_loop_node.name)
@@ -2794,10 +2831,13 @@ class NodeExecutor:
         sanitized_loop_name = end_loop_node.name.replace(" ", "_")
         file_name_prefix = f"{sanitized_loop_name}_{library_name.replace(' ', '_')}_sequential_loop_flow"
 
+        # Pass node for publishing progress events if it's a SubflowNodeGroup
+        publish_node = end_loop_node if isinstance(end_loop_node, SubflowNodeGroup) else None
         published_workflow_filename, workflow_result = await self._publish_workflow_for_loop_execution(
             package_result=package_result,
             library_name=library_name,
             file_name=file_name_prefix,
+            node=publish_node,
         )
 
         try:
@@ -2837,10 +2877,13 @@ class NodeExecutor:
         sanitized_loop_name = end_loop_node.name.replace(" ", "_")
         file_name_prefix = f"{sanitized_loop_name}_{library_name.replace(' ', '_')}_loop_flow"
 
+        # Pass node for publishing progress events if it's a SubflowNodeGroup
+        publish_node = end_loop_node if isinstance(end_loop_node, SubflowNodeGroup) else None
         published_workflow_filename, workflow_result = await self._publish_workflow_for_loop_execution(
             package_result=package_result,
             library_name=library_name,
             file_name=file_name_prefix,
+            node=publish_node,
         )
 
         try:
@@ -2866,6 +2909,7 @@ class NodeExecutor:
         package_result: PackageNodesAsSerializedFlowResultSuccess,
         library_name: str,
         file_name: str,
+        node: BaseNode | None = None,
     ) -> tuple[Path, Any]:
         """Save and publish workflow for loop execution via publisher.
 
@@ -2873,6 +2917,7 @@ class NodeExecutor:
             package_result: The packaged flow
             library_name: Name of the library to publish to
             file_name: Base file name for the workflow
+            node: Optional node to receive publishing progress events
 
         Returns:
             Tuple of (published_workflow_filename, workflow_result)
@@ -2890,7 +2935,9 @@ class NodeExecutor:
             raise RuntimeError(msg)  # noqa: TRY004 - This is a runtime failure, not a type validation error
 
         # Publish to the library
-        published_workflow_filename = await self._publish_library_workflow(workflow_result, library_name, file_name)
+        published_workflow_filename = await self._publish_library_workflow(
+            workflow_result, library_name, file_name, node=node
+        )
 
         logger.info("Successfully published workflow to '%s'", published_workflow_filename)
 

griptape_nodes/exe_types/base_iterative_nodes.py

@@ -139,7 +139,7 @@ class BaseIterativeStartNode(BaseNode):
                 allowed_modes={ParameterMode.PROPERTY, ParameterMode.OUTPUT},
                 settable=False,
                 default_value=0,
-                ui_options={"hide_property": True},
+                hide_property=True,
             )
         self.add_node_element(group)
 

griptape_nodes/exe_types/node_groups/subflow_node_group.py

@@ -16,6 +16,7 @@ from griptape_nodes.exe_types.node_types import (
     LOCAL_EXECUTION,
     get_library_names_with_publish_handlers,
 )
+from griptape_nodes.exe_types.param_components.subflow_execution_component import SubflowExecutionComponent
 from griptape_nodes.retained_mode.events.connection_events import (
     CreateConnectionRequest,
     DeleteConnectionRequest,
@@ -84,6 +85,9 @@ class SubflowNodeGroup(BaseNodeGroup, ABC):
         # Add parameters from registered StartFlow nodes for each publishing library
         self._add_start_flow_parameters()
 
+        # Add subprocess execution status component for real-time GUI updates
+        self._add_subflow_execution_parameters()
+
     def _create_subflow(self) -> None:
         """Create a dedicated subflow for this NodeGroup's nodes.
 
@@ -144,6 +148,11 @@ class SubflowNodeGroup(BaseNodeGroup, ABC):
         for library_name, handler in event_handlers.items():
             self._process_library_start_flow_parameters(library_name, handler)
 
+    def _add_subflow_execution_parameters(self) -> None:
+        """Add parameters for subflow execution tracking."""
+        self._subflow_execution_component = SubflowExecutionComponent(self)
+        self._subflow_execution_component.add_output_parameters()
+
     def _process_library_start_flow_parameters(self, library_name: str, handler: Any) -> None:
         """Process and add StartFlow parameters from a single library.
 
@@ -649,6 +658,10 @@ class SubflowNodeGroup(BaseNodeGroup, ABC):
         self._cleanup_proxy_parameter(target_parameter, metadata_key)
         return super().after_incoming_connection_removed(source_node, source_parameter, target_parameter)
 
+    def after_value_set(self, parameter: Parameter, value: Any) -> None:
+        super().after_value_set(parameter, value)
+        self.subflow_execution_component.after_value_set(parameter, value)
+
     def add_nodes_to_group(self, nodes: list[BaseNode]) -> None:
         """Add nodes to the group and track their connections.
 
@@ -1004,3 +1017,8 @@ class SubflowNodeGroup(BaseNodeGroup, ABC):
         self.remove_nodes_from_group(nodes_to_remove)
         subflow_name = self.metadata.get("subflow_name")
         return subflow_name
+
+    @property
+    def subflow_execution_component(self) -> SubflowExecutionComponent:
+        """Get the subflow execution component for real-time status updates."""
+        return self._subflow_execution_component

griptape_nodes/exe_types/param_components/log_parameter.py

@@ -69,8 +69,7 @@ class StdoutCapture:
         self._original_stdout.flush()
 
     def isatty(self) -> bool:
-        # Return False to prevent libraries from outputting ANSI color codes
-        return False
+        return self._original_stdout.isatty()
 
     def __enter__(self) -> "StdoutCapture":
         sys.stdout = self