griptape-nodes 0.56.0__py3-none-any.whl → 0.56.1__py3-none-any.whl

griptape_nodes/app/app.py

@@ -125,13 +125,10 @@ async def astart_app() -> None:
     # Initialize event queue in main thread
     griptape_nodes.EventManager().initialize_queue()
 
-    # Get main loop reference
-    main_loop = asyncio.get_running_loop()
-
     try:
         # Start WebSocket tasks in daemon thread
         threading.Thread(
-            target=_start_websocket_connection, args=(api_key, main_loop), daemon=True, name="websocket-tasks"
+            target=_start_websocket_connection, args=(api_key,), daemon=True, name="websocket-tasks"
         ).start()
 
         # Run event processing on main thread
@@ -142,7 +139,7 @@ async def astart_app() -> None:
         raise
 
 
-def _start_websocket_connection(api_key: str, main_loop: asyncio.AbstractEventLoop) -> None:
+def _start_websocket_connection(api_key: str) -> None:
     """Run WebSocket tasks in a separate thread with its own async loop."""
     global websocket_event_loop  # noqa: PLW0603
     try:
@@ -155,7 +152,7 @@ def _start_websocket_connection(api_key: str, main_loop: asyncio.AbstractEventLo
         websocket_event_loop_ready.set()
 
         # Run the async WebSocket tasks
-        loop.run_until_complete(_run_websocket_tasks(api_key, main_loop))
+        loop.run_until_complete(_run_websocket_tasks(api_key))
     except Exception as e:
         logger.error("WebSocket thread error: %s", e)
         raise
@@ -164,7 +161,7 @@ def _start_websocket_connection(api_key: str, main_loop: asyncio.AbstractEventLo
         websocket_event_loop_ready.clear()
 
 
-async def _run_websocket_tasks(api_key: str, main_loop: asyncio.AbstractEventLoop) -> None:
+async def _run_websocket_tasks(api_key: str) -> None:
     """Run WebSocket tasks - async version."""
     # Create WebSocket connection for this thread
     connection_stream = _create_websocket_connection(api_key)
@@ -181,12 +178,10 @@ async def _run_websocket_tasks(api_key: str, main_loop: asyncio.AbstractEventLoo
                 initialized = True
 
             # Emit connection established event for every connection
-            griptape_nodes.EventManager().put_event_threadsafe(
-                main_loop, AppEvent(payload=app_events.AppConnectionEstablished())
-            )
+            griptape_nodes.EventManager().put_event(AppEvent(payload=app_events.AppConnectionEstablished()))
 
             async with asyncio.TaskGroup() as tg:
-                tg.create_task(_process_incoming_messages(ws_connection, main_loop))
+                tg.create_task(_process_incoming_messages(ws_connection))
                 tg.create_task(_send_outgoing_messages(ws_connection))
         except (ExceptionGroup, ConnectionClosed, ConnectionClosedError):
             logger.info("WebSocket connection closed, reconnecting...")
@@ -217,14 +212,14 @@ def _ensure_api_key() -> str:
     return api_key
 
 
-async def _process_incoming_messages(ws_connection: Any, main_loop: asyncio.AbstractEventLoop) -> None:
+async def _process_incoming_messages(ws_connection: Any) -> None:
     """Process incoming WebSocket requests from Nodes API."""
     logger.debug("Processing incoming WebSocket requests from WebSocket connection")
 
     async for message in ws_connection:
         try:
             data = json.loads(message)
-            await _process_api_event(data, main_loop)
+            await _process_api_event(data)
         except Exception:
             logger.exception("Error processing event, skipping.")
 
@@ -242,7 +237,7 @@ def _create_websocket_connection(api_key: str) -> Any:
     )
 
 
-async def _process_api_event(event: dict, main_loop: asyncio.AbstractEventLoop) -> None:
+async def _process_api_event(event: dict) -> None:
     """Process API events and add to async queue."""
     payload = event.get("payload", {})
 
@@ -278,7 +273,7 @@ async def _process_api_event(event: dict, main_loop: asyncio.AbstractEventLoop)
         await _process_event_request(request_event)
     else:
         # Add the event to the main thread event queue for processing
-        griptape_nodes.EventManager().put_event_threadsafe(main_loop, request_event)
+        griptape_nodes.EventManager().put_event(request_event)
 
 
 async def _send_outgoing_messages(ws_connection: Any) -> None:

griptape_nodes/app/watch.py

@@ -2,85 +2,53 @@ from __future__ import annotations
 
 import subprocess
 import sys
-import time
-from typing import Any
 
-from watchdog.events import PatternMatchingEventHandler
-from watchdog.observers import Observer
+from watchfiles import DefaultFilter, watch
 
 from griptape_nodes.utils.uv_utils import find_uv_bin
 
 
-class ReloadHandler(PatternMatchingEventHandler):
-    def __init__(
-        self,
-        *,
-        patterns: list[str] | None = None,
-        ignore_patterns: list[str] | None = None,
-        ignore_directories: bool = False,
-        case_sensitive: bool = False,
-    ) -> None:
-        super().__init__(
-            patterns=patterns,
-            ignore_patterns=ignore_patterns,
-            ignore_directories=ignore_directories,
-            case_sensitive=case_sensitive,
-        )
-        self.process = None
-        self.start_process()
+def start_process() -> subprocess.Popen:
+    """Start the gtn process."""
+    uv_path = find_uv_bin()
+    return subprocess.Popen(  # noqa: S603
+        [uv_path, "run", "gtn"],
+        stdout=sys.stdout,
+        stderr=sys.stderr,
+    )
 
-    def start_process(self) -> None:
-        if self.process:
-            self._terminate_process(self.process)
-        uv_path = find_uv_bin()
-        self.process = subprocess.Popen(  # noqa: S603
-            [uv_path, "run", "gtn"],
-            stdout=sys.stdout,
-            stderr=sys.stderr,
-        )
 
-    def _terminate_process(self, process: subprocess.Popen) -> None:
-        """Gracefully terminate a process with timeout."""
-        if process.poll() is not None:
-            return  # Process already terminated
+def terminate_process(process: subprocess.Popen) -> None:
+    """Gracefully terminate a process with timeout."""
+    if process.poll() is not None:
+        return  # Process already terminated
 
-        # First try graceful termination
-        process.terminate()
-        try:
-            # Wait up to 5 seconds for graceful shutdown
-            process.wait(timeout=5)
-        except subprocess.TimeoutExpired:
-            # Force kill if it doesn't shut down gracefully
-            process.kill()
-            process.wait()
-
-    def on_modified(self, event: Any) -> None:
-        """Called on any file event in the watched directory (create, modify, delete, move)."""
-        # Don't reload if the event is on a directory
-        if event.is_directory:
-            return
-
-        if str(event.src_path).endswith(__file__):
-            return
-
-        self.start_process()
+    # First try graceful termination
+    process.terminate()
+    try:
+        # Wait up to 5 seconds for graceful shutdown
+        process.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        # Force kill if it doesn't shut down gracefully
+        process.kill()
+        process.wait()
 
 
 if __name__ == "__main__":
-    event_handler = ReloadHandler(patterns=["*.py"], ignore_patterns=["*.pyc", "*.pyo"], ignore_directories=True)
+    # Configure filter to ignore .venv, __pycache__, and compiled Python files
+    watch_filter = DefaultFilter(
+        ignore_dirs=(".venv",),
+        ignore_entity_patterns=(r"\.pyc$", r"\.pyo$"),
+    )
 
-    observer = Observer()
-    observer.schedule(event_handler, path="src", recursive=True)
-    observer.schedule(event_handler, path="libraries", recursive=True)
-    observer.schedule(event_handler, path="tests", recursive=True)
-    observer.start()
+    process = start_process()
 
     try:
-        while True:
-            time.sleep(1)
+        # Watch for changes in src, libraries, and tests directories
+        for changes in watch("src", "libraries", "tests", watch_filter=watch_filter):
+            # Only restart on .py file changes
+            if any(str(path).endswith(".py") for _, path in changes):
+                terminate_process(process)
+                process = start_process()
     except KeyboardInterrupt:
-        if event_handler.process:
-            event_handler._terminate_process(event_handler.process)
-    finally:
-        observer.stop()
-        observer.join()
+        terminate_process(process)

griptape_nodes/bootstrap/utils/__init__.py

@@ -0,0 +1 @@
+"""Bootstrap utils package."""

griptape_nodes/bootstrap/utils/python_subprocess_executor.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import sys
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class PythonSubprocessExecutorError(Exception):
+    """Exception raised during Python subprocess execution."""
+
+
+class PythonSubprocessExecutor:
+    def __init__(self) -> None:
+        self._process: asyncio.subprocess.Process | None = None
+        self._is_running = False
+
+    async def execute_python_script(
+        self, script_path: Path, args: list[str] | None = None, cwd: Path | None = None
+    ) -> None:
+        """Execute a Python script in a subprocess and wait for completion.
+
+        Args:
+            script_path: Path to the Python script to execute
+            args: Additional command line arguments
+            cwd: Working directory for the subprocess
+        """
+        if self.is_running():
+            logger.warning("Another subprocess is already running. Terminating it first.")
+            await self.terminate()
+
+        args = args or []
+        command = [sys.executable, str(script_path), *args]
+
+        try:
+            logger.info("Starting subprocess: %s", " ".join(command))
+            logger.info("Working directory: %s", cwd)
+
+            self._process = await asyncio.create_subprocess_exec(
+                *command,
+                cwd=cwd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            self._is_running = True
+            logger.info("Subprocess started with PID: %s", self._process.pid)
+
+            stdout_bytes, stderr_bytes = await self._process.communicate()
+            returncode = self._process.returncode
+            stdout = stdout_bytes.decode() if stdout_bytes else ""
+            stderr = stderr_bytes.decode() 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)
+            else:
+                logger.error("Subprocess failed with return code: %d", returncode)
+                msg = f"Subprocess failed with return code: {returncode}"
+                raise RuntimeError(msg)  # noqa: TRY301
+
+        except Exception as e:
+            msg = "Error running subprocess"
+            logger.exception(msg)
+            raise PythonSubprocessExecutorError(msg) from e
+        finally:
+            self._is_running = False
+            self._process = None
+
+    def is_running(self) -> bool:
+        """Check if a subprocess is currently running."""
+        return self._is_running
+
+    async def terminate(self) -> bool:
+        """Terminate the running subprocess.
+
+        Returns:
+            True if successfully terminated, False otherwise
+        """
+        if not self.is_running() or not self._process:
+            return True
+
+        try:
+            logger.info("Terminating subprocess...")
+            self._process.terminate()
+
+            # Wait for graceful termination with timeout using context manager
+            try:
+                async with asyncio.timeout(5.0):
+                    await self._process.wait()
+                logger.info("Subprocess terminated gracefully")
+                return True  # noqa: TRY300
+            except TimeoutError:
+                logger.warning("Subprocess did not terminate gracefully, force killing...")
+                self._process.kill()
+                await self._process.wait()
+                logger.info("Subprocess force killed")
+                return True
+
+        except Exception as e:
+            logger.error("Error terminating subprocess: %s", e)
+            return False
+        finally:
+            self._is_running = False
+            self._process = None
+
+    def get_status(self) -> dict[str, Any]:
+        """Get current status information."""
+        return {
+            "is_running": self.is_running(),
+            "has_process": self._process is not None,
+            "process_pid": self._process.pid if self._process else None,
+        }