griptape-nodes 0.44.0__tar.gz → 0.61.0__tar.gz

{griptape_nodes-0.44.0 → griptape_nodes-0.61.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.3
 Name: griptape-nodes
-Version: 0.44.0
+Version: 0.61.0
 Summary: Add your description here
-Requires-Dist: griptape>=1.8.0
+Requires-Dist: griptape>=1.8.12
 Requires-Dist: pydantic>=2.10.6
 Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: xdg-base-dirs>=6.0.2
@@ -15,10 +15,17 @@ Requires-Dist: uvicorn>=0.34.2
 Requires-Dist: packaging>=25.0
 Requires-Dist: python-multipart>=0.0.20
 Requires-Dist: json-repair>=0.46.1
-Requires-Dist: imageio-ffmpeg>=0.6.0
 Requires-Dist: mcp[ws]>=1.10.1
 Requires-Dist: binaryornot>=0.4.4
 Requires-Dist: pillow>=11.3.0
+Requires-Dist: watchfiles>=1.1.0
+Requires-Dist: typer>=0.15.0
+Requires-Dist: huggingface-hub>=1.0.1
+Requires-Dist: rich>=14.1.0
+Requires-Dist: semver>=3.0.4
+Requires-Dist: aiofiles>=25.1.0
+Requires-Dist: ruamel-yaml>=0.18.15
+Requires-Dist: asyncio-thread-runner>=1.0
 Requires-Dist: austin-dist>=3.7.0 ; extra == 'profiling'
 Requires-Python: >=3.12.0, <3.13
 Provides-Extra: profiling

{griptape_nodes-0.44.0 → griptape_nodes-0.61.0}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "griptape-nodes"
-version = "0.44.0"
+version = "0.61.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12.0, <3.13"
 dependencies = [
-  "griptape>=1.8.0",
+  "griptape>=1.8.12",
   "pydantic>=2.10.6",
   "python-dotenv>=1.0.1",
   "xdg-base-dirs>=6.0.2",
@@ -19,10 +19,17 @@ dependencies = [
   "packaging>=25.0",
   "python-multipart>=0.0.20",
   "json-repair>=0.46.1",
-  "imageio-ffmpeg>=0.6.0",
   "mcp[ws]>=1.10.1",
   "binaryornot>=0.4.4",
   "pillow>=11.3.0",
+  "watchfiles>=1.1.0",
+  "typer>=0.15.0",
+  "huggingface-hub>=1.0.1",
+  "rich>=14.1.0",
+  "semver>=3.0.4",
+  "aiofiles>=25.1.0",
+  "ruamel.yaml>=0.18.15",
+  "asyncio-thread-runner>=1.0",
 ]
 
 [project.optional-dependencies]
@@ -30,6 +37,7 @@ profiling = ["austin-dist>=3.7.0"]
 
 [dependency-groups]
 dev = [
+  "griptape-cloud-client",
   "mdformat>=0.7.22",
   "mdformat-gfm>=0.4.1",
   "mdformat-frontmatter>=2.0.8",
@@ -38,14 +46,21 @@ dev = [
   "pyright>=1.1.396",
   "ruff>=0.11.0",
   "typos>=1.30.2",
-  "watchdog>=6.0.0",
 ]
 docs = [
   "mkdocs-material>=9.6.9",
   "mkdocs>=1.5.2",
   "mkdocstrings[python]>=0.29.1",
+  "mkdocs-mermaid2-plugin>=1.2.2",
+]
+test = [
+  "pytest>=8.3.5",
+  "pytest-asyncio>=1.1.0",
+  "pytest-mock>=3.14.0",
+  "pytest-xdist>=3.6.1",
+  "pytest-cov>=6.0.0",
+  "coverage>=7.0.0",
 ]
-test = ["pytest>=8.3.5", "pytest-mock>=3.14.0", "pytest-xdist>=3.6.1"]
 
 [project.scripts]
 griptape-nodes = "griptape_nodes:main"
@@ -55,11 +70,13 @@ gtn = "griptape_nodes:main"
 requires = ["uv_build"]
 build-backend = "uv_build"
 
+[tool.uv.sources]
+griptape-cloud-client = { git = "https://github.com/griptape-ai/griptape-cloud-python-client", rev = "main" }
+
 [tool.ruff]
 line-length = 120
+extend-exclude = ["libraries/**/templates/*.py"]
 
-[tool.ruff.format]
-exclude = [".venv"]
 
 [tool.ruff.lint]
 select = ["ALL"]
@@ -76,7 +93,6 @@ ignore = [
   "E501",    # TODO: https://github.com/griptape-ai/griptape-nodes/issues/834 
   "D100",    # TODO: https://github.com/griptape-ai/griptape-nodes/issues/835 
   "BLE001",  # TODO: https://github.com/griptape-ai/griptape-nodes/issues/839
-  "B026",    # TODO: https://github.com/griptape-ai/griptape-nodes/issues/836 
   "SLF001",  # TODO :https://github.com/griptape-ai/griptape-nodes/issues/838 
   "SIM108",  # Intentional
   "SIM110",  # Intentional
@@ -90,10 +106,13 @@ 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"
+"libraries.griptape_cloud".msg = "Import from griptape_cloud instead of libraries.griptape_cloud"
 
 [tool.ruff.lint.per-file-ignores]
 "tests/*" = ["S101", "D104"]
-"nodes/tests/*" = ["S101", "D104"]
+"libraries/**/tests/*" = ["S101", "D104"]
 
 [tool.ruff.lint.flake8-annotations]
 mypy-init-return = true
@@ -101,12 +120,20 @@ mypy-init-return = true
 [tool.ruff.lint.pydocstyle]
 convention = "google"
 
+[tool.typos]
+default.extend-ignore-re = [
+  # Ignore any line that ends with this comment:
+  "(?Rm)^.*(#|//)\\s*spellchecker:disable-line$",
+  # Or: ignore the *next* line after this comment:
+  "(?m)(#|//)\\s*spellchecker:ignore-next-line\\n.*",
+]
+
 [tool.pyright]
 venvPath = "."
 venv = ".venv"
 include = ["."]
 exclude = [
-  "libraries/griptape_nodes_library/workflows/templates/**/*",
+  "libraries/**/templates/*",
   ".venv",
   "GriptapeNodes",
   "**/node_modules",
@@ -115,6 +142,3 @@ exclude = [
 ]
 pythonVersion = "3.12"
 reportIncompatibleMethodOverride = false
-
-[tool.uv.sources]
-griptape = { git = "https://github.com/griptape-ai/griptape", rev = "main" }

griptape_nodes-0.61.0/src/griptape_nodes/__init__.py

@@ -0,0 +1,24 @@
+"""Griptape Nodes package."""
+
+import sys
+from pathlib import Path
+
+from rich.console import Console
+
+
+def main() -> None:
+    """Main entry point for the Griptape Nodes CLI."""
+    # Hack to make paths "just work". # noqa: FIX004
+    # Without this, packages like `nodes` don't properly import.
+    # Long term solution could be to make `nodes` a proper src-layout package
+    # but current engine relies on importing files rather than packages.
+    sys.path.append(str(Path.cwd()))
+
+    console = Console()
+    with console.status("[bold green]Loading Griptape Nodes...", spinner="dots"):
+        from griptape_nodes.cli.main import app
+
+    app()
+
+
+__all__ = ["main"]

griptape_nodes-0.61.0/src/griptape_nodes/__main__.py

@@ -0,0 +1,6 @@
+"""Main entry point for the Griptape Nodes CLI when run as a module."""
+
+from griptape_nodes import main
+
+if __name__ == "__main__":
+    main()

griptape_nodes-0.61.0/src/griptape_nodes/api_client/__init__.py

@@ -0,0 +1,9 @@
+"""API client for Nodes API communication."""
+
+from griptape_nodes.api_client.client import Client
+from griptape_nodes.api_client.request_client import RequestClient
+
+__all__ = [
+    "Client",
+    "RequestClient",
+]

griptape_nodes-0.61.0/src/griptape_nodes/api_client/client.py

@@ -0,0 +1,279 @@
+"""Unified WebSocket client for Nodes API communication."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import json
+import logging
+import os
+from typing import TYPE_CHECKING, Any, Self
+from urllib.parse import urljoin
+
+from websockets.asyncio.client import connect
+from websockets.exceptions import ConnectionClosed
+
+from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+    from types import TracebackType
+
+logger = logging.getLogger("griptape_nodes_client")
+
+
+def get_default_websocket_url() -> str:
+    """Get the default WebSocket endpoint URL for connecting to Nodes API.
+
+    Returns:
+        WebSocket URL for Nodes API events endpoint
+    """
+    return urljoin(
+        os.getenv("GRIPTAPE_NODES_API_BASE_URL", "https://api.nodes.griptape.ai").replace("http", "ws"),
+        "/ws/engines/events?version=v2",
+    )
+
+
+class Client:
+    """WebSocket client for Nodes API pub/sub communication.
+
+    Provides connection management, topic-based pub/sub, and message routing.
+    Handles WebSocket reconnection and async event streaming.
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        url: str | None = None,
+    ):
+        """Initialize Nodes API client.
+
+        Args:
+            api_key: API key for authentication (defaults to GT_CLOUD_API_KEY from SecretsManager)
+            url: WebSocket URL to connect to (defaults to Nodes API endpoint)
+        """
+        self.url = url if url is not None else get_default_websocket_url()
+
+        # Get API key from SecretsManager if not provided
+        if api_key is None:
+            api_key = GriptapeNodes.SecretsManager().get_secret("GT_CLOUD_API_KEY")
+
+        self.api_key = api_key
+
+        self.headers = {"Authorization": f"Bearer {api_key}"} if api_key else {}
+
+        # Event streaming management
+        self._message_queue: asyncio.Queue = asyncio.Queue()
+        self._subscribed_topics: set[str] = set()
+        self._receiving_task: asyncio.Task | None = None
+        self._sending_task: asyncio.Task | None = None
+        self._websocket: Any = None
+        self._connection_ready = asyncio.Event()
+        self._reconnect_delay = 2.0
+
+    async def __aenter__(self) -> Self:
+        """Async context manager entry: connect to WebSocket server."""
+        await self._connect()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Async context manager exit: disconnect from WebSocket server."""
+        await self._disconnect()
+
+    def __aiter__(self) -> AsyncIterator[dict[str, Any]]:
+        """Return self as async iterator."""
+        return self
+
+    async def __anext__(self) -> dict[str, Any]:
+        """Get next message from the message queue.
+
+        Returns:
+            Next message dictionary from subscribed topics
+
+        Raises:
+            StopAsyncIteration: When iteration is cancelled
+        """
+        try:
+            return await self._message_queue.get()
+        except asyncio.CancelledError:
+            raise StopAsyncIteration from None
+
+    @property
+    def messages(self) -> AsyncIterator[dict[str, Any]]:
+        """Async iterator for receiving messages from subscribed topics.
+
+        Returns:
+            Async iterator yielding message dictionaries
+
+        Example:
+            async with Client(...) as client:
+                await client.subscribe("topic")
+                async for message in client.messages:
+                    print(message)
+        """
+        return self
+
+    async def subscribe(self, topic: str) -> None:
+        """Subscribe to a topic by sending subscribe command to server.
+
+        Args:
+            topic: Topic name to subscribe to
+
+        Example:
+            await client.subscribe("sessions/123/response")
+        """
+        self._subscribed_topics.add(topic)
+        await self._send_subscribe_command(topic)
+
+    async def unsubscribe(self, topic: str) -> None:
+        """Unsubscribe from a topic.
+
+        Args:
+            topic: Topic name to unsubscribe from
+        """
+        self._subscribed_topics.discard(topic)
+        await self._send_unsubscribe_command(topic)
+
+    async def publish(self, event_type: str, payload: dict[str, Any], topic: str) -> None:
+        """Publish an event to the server.
+
+        Args:
+            event_type: Type of event to publish
+            payload: Event payload data
+            topic: Topic to publish to
+        """
+        message = {"type": event_type, "payload": payload, "topic": topic}
+        await self._send_message(message)
+
+    async def _connect(self) -> None:
+        """Connect to the WebSocket server and start receiving messages.
+
+        This method starts the connection manager task.
+        It returns once the initial connection is established.
+
+        Raises:
+            ConnectionError: If connection fails
+        """
+        # Start connection manager task
+        self._receiving_task = asyncio.create_task(self._manage_connection())
+
+        # Wait for initial connection to be established
+        try:
+            await asyncio.wait_for(self._connection_ready.wait(), timeout=10.0)
+            logger.debug("WebSocket client connected")
+        except TimeoutError as e:
+            logger.error("Failed to connect WebSocket client: timeout")
+            msg = "Connection timeout"
+            raise ConnectionError(msg) from e
+
+    async def _disconnect(self) -> None:
+        """Disconnect from the WebSocket server and clean up tasks."""
+        # Cancel tasks
+        if self._receiving_task:
+            self._receiving_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._receiving_task
+
+        if self._sending_task:
+            self._sending_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._sending_task
+
+        # Close websocket connection
+        if self._websocket:
+            await self._websocket.close()
+        logger.info("WebSocket client disconnected")
+
+    async def _manage_connection(self) -> None:
+        """Manage WebSocket connection lifecycle with automatic reconnection.
+
+        This method establishes and maintains the WebSocket connection,
+        automatically reconnecting on failures.
+        """
+        try:
+            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)
+
+                # Resubscribe to all topics after reconnection
+                if self._subscribed_topics:
+                    logger.debug("Resubscribing to %d topics after reconnection", len(self._subscribed_topics))
+                    for topic in self._subscribed_topics:
+                        await self._send_subscribe_command(topic)
+
+                try:
+                    await self._receive_messages(websocket)
+                except ConnectionClosed:
+                    logger.info("WebSocket connection closed, reconnecting...")
+                    self._connection_ready.clear()
+                    continue
+
+        except asyncio.CancelledError:
+            logger.debug("Connection manager task cancelled")
+
+    async def _receive_messages(self, websocket: Any) -> None:
+        """Receive messages from WebSocket and put them in message queue.
+
+        Args:
+            websocket: WebSocket connection to receive messages from
+
+        Raises:
+            ConnectionClosed: When the WebSocket connection is closed
+        """
+        try:
+            async for message in websocket:
+                try:
+                    data = json.loads(message)
+                    await self._message_queue.put(data)
+                except json.JSONDecodeError:
+                    logger.error("Failed to parse message: %s", message)
+                except Exception as e:
+                    logger.error("Error receiving message: %s", e)
+        except asyncio.CancelledError:
+            logger.debug("Receive messages task cancelled")
+            raise
+
+    async def _send_message(self, message: dict[str, Any]) -> None:
+        """Send a message through the WebSocket connection.
+
+        Args:
+            message: Message dictionary to send
+
+        Raises:
+            ConnectionError: If not connected
+        """
+        if not self._websocket:
+            msg = "Not connected to WebSocket"
+            raise ConnectionError(msg)
+
+        try:
+            await self._websocket.send(json.dumps(message))
+            logger.debug("Sent message type: %s", message.get("type"))
+        except Exception as e:
+            logger.error("Failed to send message: %s", e)
+
+    async def _send_subscribe_command(self, topic: str) -> None:
+        """Send subscribe command to server.
+
+        Args:
+            topic: Topic to subscribe to
+        """
+        message = {"type": "subscribe", "topic": topic, "payload": {}}
+        await self._send_message(message)
+        logger.debug("Sent subscribe command for topic: %s", topic)
+
+    async def _send_unsubscribe_command(self, topic: str) -> None:
+        """Send unsubscribe command to server.
+
+        Args:
+            topic: Topic to unsubscribe from
+        """
+        message = {"type": "unsubscribe", "topic": topic, "payload": {}}
+        await self._send_message(message)
+        logger.debug("Sent unsubscribe command for topic: %s", topic)