griptape-nodes 0.70.0__tar.gz → 0.71.0__tar.gz

{griptape_nodes-0.70.0 → griptape_nodes-0.71.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: griptape-nodes
-Version: 0.70.0
+Version: 0.71.0
 Summary: Add your description here
 Requires-Dist: griptape>=1.9.0
 Requires-Dist: pydantic>=2.10.6

{griptape_nodes-0.70.0 → griptape_nodes-0.71.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "griptape-nodes"
-version = "0.70.0"
+version = "0.71.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12.0, <3.13"

{griptape_nodes-0.70.0 → griptape_nodes-0.71.0}/src/griptape_nodes/api_client/client.py

@@ -73,7 +73,7 @@ class Client:
 
     async def __aenter__(self) -> Self:
         """Async context manager entry: connect to WebSocket server."""
-        await self._connect()
+        await self.connect()
         return self
 
     async def __aexit__(
@@ -83,7 +83,7 @@ class Client:
         exc_tb: TracebackType | None,
     ) -> None:
         """Async context manager exit: disconnect from WebSocket server."""
-        await self._disconnect()
+        await self.disconnect()
 
     def __aiter__(self) -> AsyncIterator[dict[str, Any]]:
         """Return self as async iterator."""
@@ -150,7 +150,7 @@ class Client:
         message = {"type": event_type, "payload": payload, "topic": topic}
         await self._send_message(message)
 
-    async def _connect(self) -> None:
+    async def connect(self) -> None:
         """Connect to the WebSocket server and start receiving messages.
 
         This method starts the connection manager task.
@@ -175,7 +175,7 @@ class Client:
             )
             raise ConnectionError(msg) from e
 
-    async def _disconnect(self) -> None:
+    async def disconnect(self) -> None:
         """Disconnect from the WebSocket server and clean up tasks."""
         # Cancel tasks
         if self._receiving_task:
@@ -203,7 +203,10 @@ class Client:
             async for websocket in connect(self.url, additional_headers=self.headers):
                 self._websocket = websocket
                 self._connection_ready.set()
-                logger.debug("WebSocket connection established: %s", self.url)
+                if self._subscribed_topics:
+                    logger.info("WebSocket reconnected successfully")
+                else:
+                    logger.debug("WebSocket connection established: %s", self.url)
 
                 # Resubscribe to all topics after reconnection
                 if self._subscribed_topics:

{griptape_nodes-0.70.0 → griptape_nodes-0.71.0}/src/griptape_nodes/bootstrap/utils/python_subprocess_executor.py

@@ -29,6 +29,42 @@ class PythonSubprocessExecutor:
         self._process: asyncio.subprocess.Process | None = None
         self._is_running = False
 
+    async def _stream_output(
+        self,
+        stream: asyncio.StreamReader | None,
+        stream_name: str,
+        collected_lines: list[str],
+    ) -> None:
+        """Read from a stream line-by-line, printing each line in real-time.
+
+        Output is printed directly with ANSI dim formatting to preserve formatting
+        (e.g., rich tables, colors) from the subprocess while making it visually
+        distinct from main process logs.
+
+        Args:
+            stream: The async stream reader to read from
+            stream_name: Name of the stream for logging (e.g., "stdout", "stderr")
+            collected_lines: List to accumulate decoded lines into
+        """
+        if stream is None:
+            return
+
+        # ANSI escape codes for dimmed output
+        ansi_dim = "\033[2m"
+        ansi_reset = "\033[0m"
+
+        # Choose the appropriate output stream
+        output_stream = sys.stderr if stream_name == "stderr" else sys.stdout
+
+        while True:
+            line = await stream.readline()
+            if not line:
+                break
+            decoded_line = line.decode(errors="replace").rstrip()
+            collected_lines.append(decoded_line)
+            # Print with dim formatting to distinguish from main process logs
+            print(f"{ansi_dim}{decoded_line}{ansi_reset}", file=output_stream, flush=True)
+
     async def execute_python_script(
         self,
         script_path: Path,
@@ -51,6 +87,8 @@ class PythonSubprocessExecutor:
         args = args or []
         command = [sys.executable, str(script_path), *args]
         subprocess_env = _create_subprocess_env(env)
+        # Disable Python output buffering so we get real-time output
+        subprocess_env["PYTHONUNBUFFERED"] = "1"
 
         try:
             logger.info("Starting subprocess: %s", " ".join(command))
@@ -66,16 +104,17 @@ class PythonSubprocessExecutor:
             self._is_running = True
             logger.info("Subprocess started with PID: %s", self._process.pid)
 
-            stdout_bytes, stderr_bytes = await self._process.communicate()
+            # Stream stdout and stderr concurrently for real-time output
+            stdout_lines: list[str] = []
+            stderr_lines: list[str] = []
+            await asyncio.gather(
+                self._stream_output(self._process.stdout, "stdout", stdout_lines),
+                self._stream_output(self._process.stderr, "stderr", stderr_lines),
+            )
+
+            # Wait for process to complete and get return code
+            await self._process.wait()
             returncode = self._process.returncode
-            stdout = stdout_bytes.decode(errors="replace") if stdout_bytes else ""
-            stderr = stderr_bytes.decode(errors="replace") if stderr_bytes else ""
-
-            # Log all output regardless of return code
-            if stdout:
-                logger.info("Subprocess stdout: %s", stdout)
-            if stderr:
-                logger.info("Subprocess stderr: %s", stderr)
 
             if returncode == 0:
                 logger.info("Subprocess completed successfully with return code: %d", returncode)

griptape_nodes-0.71.0/src/griptape_nodes/bootstrap/utils/subprocess_websocket_base.py

@@ -0,0 +1,88 @@
+"""Base WebSocket mixin for subprocess communication.
+
+This module provides a reusable base mixin with shared WebSocket client
+and background task lifecycle management used by both listener and sender mixins.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+from typing import TYPE_CHECKING
+
+from griptape_nodes.api_client import Client
+
+if TYPE_CHECKING:
+    from collections.abc import Coroutine
+    from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class SubprocessWebSocketBaseMixin:
+    """Base mixin providing shared WebSocket client and task lifecycle management.
+
+    This mixin handles:
+    - Session ID management
+    - WebSocket client creation and cleanup
+    - Background task lifecycle (creation, cancellation, cleanup)
+
+    Subclasses should use the protected methods to build their specific functionality.
+    """
+
+    _session_id: str
+    _ws_client: Client | None
+    _ws_task: asyncio.Task | None
+
+    def _init_websocket_base(self, session_id: str) -> None:
+        """Initialize shared WebSocket state.
+
+        Args:
+            session_id: Unique session ID for WebSocket topic.
+        """
+        self._session_id = session_id
+        self._ws_client = None
+        self._ws_task = None
+
+    def _get_session_id(self) -> str:
+        """Get the session ID used for WebSocket communication."""
+        return self._session_id
+
+    async def _start_websocket_client(self) -> None:
+        """Start the WebSocket client connection.
+
+        Creates and connects the WebSocket client.
+        Subclasses should call this, then perform additional setup (subscribe, etc.).
+        """
+        logger.info("Starting WebSocket client for session %s", self._session_id)
+        self._ws_client = Client()
+        await self._ws_client.connect()
+        logger.info("WebSocket client connected for session %s", self._session_id)
+
+    def _create_websocket_task(self, coro: Coroutine[Any, Any, None]) -> None:
+        """Create a background task for WebSocket operations.
+
+        Args:
+            coro: The coroutine to run as a background task.
+        """
+        self._ws_task = asyncio.create_task(coro)
+
+    async def _stop_websocket_task(self) -> None:
+        """Cancel and clean up the background task."""
+        if self._ws_task is None:
+            return
+
+        self._ws_task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await self._ws_task
+        self._ws_task = None
+
+    async def _stop_websocket_client(self) -> None:
+        """Close the WebSocket client connection."""
+        if self._ws_client is None:
+            return
+
+        await self._ws_client.disconnect()
+        self._ws_client = None
+        logger.info("WebSocket client disconnected for session %s", self._session_id)

griptape_nodes-0.71.0/src/griptape_nodes/bootstrap/utils/subprocess_websocket_listener.py

@@ -0,0 +1,126 @@
+"""WebSocket listener mixin for subprocess communication.
+
+This module provides a reusable mixin for listening to WebSocket events
+from subprocess executions using native asyncio. Used by both
+SubprocessWorkflowExecutor and SubprocessWorkflowPublisher.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import uuid
+from typing import TYPE_CHECKING
+
+from griptape_nodes.bootstrap.utils.subprocess_websocket_base import SubprocessWebSocketBaseMixin
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+logger = logging.getLogger(__name__)
+
+
+class SubprocessWebSocketListenerMixin(SubprocessWebSocketBaseMixin):
+    """Mixin providing WebSocket listener functionality for subprocess communication.
+
+    This mixin handles:
+    - Starting/stopping a WebSocket listener as a background task
+    - Subscribing to session-specific topics
+    - Processing incoming events and calling callbacks
+
+    Subclasses should implement _handle_subprocess_event() for custom event handling.
+    """
+
+    _on_event: Callable[[dict], None] | None
+
+    def _init_websocket_listener(
+        self,
+        session_id: str | None = None,
+        on_event: Callable[[dict], None] | None = None,
+    ) -> None:
+        """Initialize WebSocket listener state.
+
+        Args:
+            session_id: Unique session ID for WebSocket topic subscription.
+                       If None, a random UUID will be generated.
+            on_event: Optional callback invoked for each received event.
+        """
+        self._init_websocket_base(session_id or uuid.uuid4().hex)
+        self._on_event = on_event
+
+    async def _start_websocket_listener(self) -> None:
+        """Start WebSocket client and listener background task."""
+        logger.info("Starting WebSocket listener for session %s", self._session_id)
+
+        await self._start_websocket_client()
+
+        if self._ws_client is None:
+            msg = "WebSocket client failed to initialize"
+            raise RuntimeError(msg)
+
+        topic = f"sessions/{self._session_id}/response"
+        await self._ws_client.subscribe(topic)
+
+        self._create_websocket_task(self._ws_listen_loop())
+
+        logger.info("WebSocket listener started for session %s", self._session_id)
+
+    async def _ws_listen_loop(self) -> None:
+        """Background task to process incoming messages."""
+        logger.debug("Starting WebSocket listen loop for session %s", self._session_id)
+
+        if self._ws_client is None:
+            logger.error("WebSocket client not available for listening")
+            return
+
+        try:
+            async for message in self._ws_client.messages:
+                try:
+                    logger.debug("Received WebSocket message: %s", message.get("type"))
+                    await self._process_listener_event(message)
+                except Exception:
+                    logger.exception(
+                        "Error processing WebSocket message of type '%s' for session %s",
+                        message.get("type", "unknown"),
+                        self._session_id,
+                    )
+        except asyncio.CancelledError:
+            logger.debug("WebSocket listener cancelled for session %s", self._session_id)
+        except Exception as e:
+            logger.error("Error in WebSocket message listener: %s", e)
+
+        logger.debug("WebSocket listen loop ended for session %s", self._session_id)
+
+    async def _process_listener_event(self, event: dict) -> None:
+        """Process events received from the subprocess via WebSocket.
+
+        This method:
+        1. Calls the on_event callback if provided (for GUI updates)
+        2. Delegates to _handle_subprocess_event for subclass-specific handling
+
+        Args:
+            event: The event dictionary received from the subprocess
+        """
+        if self._on_event:
+            self._on_event(event)
+
+        await self._handle_subprocess_event(event)
+
+    async def _stop_websocket_listener(self) -> None:
+        """Stop the listener task and close client."""
+        logger.info("Stopping WebSocket listener for session %s", self._session_id)
+
+        await self._stop_websocket_task()
+        await self._stop_websocket_client()
+
+        logger.info("WebSocket listener stopped for session %s", self._session_id)
+
+    async def _handle_subprocess_event(self, event: dict) -> None:
+        """Handle subprocess-specific events.
+
+        Override this method in subclasses to implement custom event handling.
+        The default implementation does nothing.
+
+        Args:
+            event: The event dictionary received from the subprocess
+        """

griptape_nodes-0.71.0/src/griptape_nodes/bootstrap/utils/subprocess_websocket_sender.py

@@ -0,0 +1,121 @@
+"""WebSocket sender mixin for subprocess communication.
+
+This module provides a reusable mixin for sending WebSocket events
+from subprocess executions back to the parent process using native asyncio.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+
+from griptape_nodes.app.app import WebSocketMessage
+from griptape_nodes.bootstrap.utils.subprocess_websocket_base import SubprocessWebSocketBaseMixin
+
+logger = logging.getLogger(__name__)
+
+
+class SubprocessWebSocketSenderMixin(SubprocessWebSocketBaseMixin):
+    """Mixin providing WebSocket sender functionality for subprocess communication.
+
+    This mixin handles:
+    - Starting/stopping a WebSocket connection as a background task
+    - Queuing and sending events to the parent process
+    - Non-blocking event emission from the main event loop
+    """
+
+    _ws_send_queue: asyncio.Queue[WebSocketMessage]
+    _ws_shutdown_event: asyncio.Event
+
+    def _init_websocket_sender(self, session_id: str) -> None:
+        """Initialize WebSocket sender state.
+
+        Args:
+            session_id: Unique session ID for WebSocket topic.
+        """
+        self._init_websocket_base(session_id)
+        self._ws_send_queue = asyncio.Queue()
+        self._ws_shutdown_event = asyncio.Event()
+
+    async def _start_websocket_connection(self) -> None:
+        """Start WebSocket client and sender background task."""
+        logger.info("Starting WebSocket sender for session %s", self._session_id)
+
+        self._ws_shutdown_event.clear()
+        await self._start_websocket_client()
+        self._create_websocket_task(self._ws_send_loop())
+
+        logger.info("WebSocket sender started for session %s", self._session_id)
+
+    async def _ws_send_loop(self) -> None:
+        """Background task to send queued messages."""
+        logger.debug("Starting WebSocket send loop for session %s", self._session_id)
+
+        while not self._ws_shutdown_event.is_set():
+            try:
+                message = await asyncio.wait_for(self._ws_send_queue.get(), timeout=1.0)
+            except TimeoutError:
+                continue
+            except asyncio.CancelledError:
+                break
+
+            try:
+                if self._ws_client is None:
+                    logger.warning("WebSocket client not available, message dropped")
+                    continue
+
+                topic = message.topic if message.topic else f"sessions/{self._session_id}/response"
+                payload_dict = json.loads(message.payload)
+                await self._ws_client.publish(message.event_type, payload_dict, topic)
+                logger.debug("DELIVERED: %s event", message.event_type)
+            except Exception as e:
+                logger.error("Error sending WebSocket message: %s", e)
+            finally:
+                self._ws_send_queue.task_done()
+
+        logger.debug("WebSocket send loop ended for session %s", self._session_id)
+
+    def send_event(self, event_type: str, payload: str) -> None:
+        """Queue an event for sending via WebSocket (non-blocking).
+
+        Args:
+            event_type: Type of event (e.g., "execution_event", "success_result")
+            payload: JSON string payload to send
+        """
+        if self._ws_task is None or self._ws_task.done():
+            logger.debug("WebSocket sender not active, event not sent: %s", event_type)
+            return
+
+        topic = f"sessions/{self._session_id}/response"
+        message = WebSocketMessage(event_type, payload, topic)
+
+        try:
+            self._ws_send_queue.put_nowait(message)
+            logger.debug("QUEUED: %s event via websocket", event_type)
+        except asyncio.QueueFull:
+            logger.error("WebSocket queue full, event dropped: %s", event_type)
+
+    async def _stop_websocket_connection(self) -> None:
+        """Stop the sender task and close client."""
+        logger.info("Stopping WebSocket sender for session %s", self._session_id)
+
+        self._ws_shutdown_event.set()
+        await self._stop_websocket_task()
+        await self._stop_websocket_client()
+
+        logger.info("WebSocket sender stopped for session %s", self._session_id)
+
+    async def _wait_for_websocket_queue_flush(self, timeout_seconds: float = 5.0) -> None:
+        """Wait for all queued messages to be sent.
+
+        Args:
+            timeout_seconds: Maximum time to wait for queue to flush.
+        """
+        if self._ws_task is None or self._ws_task.done():
+            return
+
+        try:
+            await asyncio.wait_for(self._ws_send_queue.join(), timeout=timeout_seconds)
+        except TimeoutError:
+            logger.warning("Timeout waiting for websocket queue to flush")