griptape-nodes 0.56.0__tar.gz → 0.57.0__tar.gz

{griptape_nodes-0.56.0 → griptape_nodes-0.57.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.3
 Name: griptape-nodes
-Version: 0.56.0
+Version: 0.57.0
 Summary: Add your description here
-Requires-Dist: griptape>=1.8.2
+Requires-Dist: griptape>=1.8.3
 Requires-Dist: pydantic>=2.10.6
 Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: xdg-base-dirs>=6.0.2

{griptape_nodes-0.56.0 → griptape_nodes-0.57.0}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "griptape-nodes"
-version = "0.56.0"
+version = "0.57.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12.0, <3.13"
 dependencies = [
-  "griptape>=1.8.2",
+  "griptape>=1.8.3",
   "pydantic>=2.10.6",
   "python-dotenv>=1.0.1",
   "xdg-base-dirs>=6.0.2",
@@ -41,7 +41,6 @@ dev = [
   "pyright>=1.1.396",
   "ruff>=0.11.0",
   "typos>=1.30.2",
-  "watchdog>=6.0.0",
 ]
 docs = [
   "mkdocs-material>=9.6.9",
@@ -99,6 +98,8 @@ ignore = [
 
 [tool.ruff.lint.flake8-tidy-imports.banned-api]
 "nodes.griptape_nodes_library".msg = "Import from griptape_nodes_library instead of nodes.griptape_nodes_library"
+"libraries.griptape_nodes_library".msg = "Import from griptape_nodes_library instead of libraries.griptape_nodes_library"
+"libraries.griptape_nodes_advanced_media_library".msg = "Import from griptape_nodes_advanced_media_library instead of libraries.griptape_nodes_advanced_media_library"
 
 [tool.ruff.lint.per-file-ignores]
 "tests/*" = ["S101", "D104"]

{griptape_nodes-0.56.0 → griptape_nodes-0.57.0}/src/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-0.57.0/src/griptape_nodes/app/watch.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+
+from watchfiles import DefaultFilter, watch
+
+from griptape_nodes.utils.uv_utils import find_uv_bin
+
+
+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 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()
+
+
+if __name__ == "__main__":
+    # Configure filter to ignore .venv, __pycache__, and compiled Python files
+    watch_filter = DefaultFilter(
+        ignore_dirs=(".venv",),
+        ignore_entity_patterns=(r"\.pyc$", r"\.pyo$"),
+    )
+
+    process = start_process()
+
+    try:
+        # 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:
+        terminate_process(process)

griptape_nodes-0.57.0/src/griptape_nodes/bootstrap/utils/__init__.py

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

griptape_nodes-0.57.0/src/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,
+        }