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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: griptape-nodes
-Version: 0.71.0
+Version: 0.72.0
 Summary: Add your description here
 Requires-Dist: griptape>=1.9.0
 Requires-Dist: pydantic>=2.10.6
@@ -29,6 +29,7 @@ Requires-Dist: ruamel-yaml>=0.18.15
 Requires-Dist: asyncio-thread-runner>=1.0
 Requires-Dist: portalocker>=2.10.0
 Requires-Dist: pygit2>=1.19.0
+Requires-Dist: send2trash>=2.1.0
 Requires-Dist: austin-dist>=3.7.0 ; extra == 'profiling'
 Requires-Python: >=3.12.0, <3.13
 Provides-Extra: profiling

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

@@ -1,6 +1,6 @@
 [project]
 name = "griptape-nodes"
-version = "0.71.0"
+version = "0.72.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12.0, <3.13"
@@ -33,6 +33,7 @@ dependencies = [
   "asyncio-thread-runner>=1.0",
   "portalocker>=2.10.0",
   "pygit2>=1.19.0",
+  "send2trash>=2.1.0",
 ]
 
 [project.optional-dependencies]
@@ -124,9 +125,7 @@ mypy-init-return = true
 convention = "google"
 
 [tool.typos]
-files.extend-exclude = [
-  "libraries/**/templates/*",
-]
+files.extend-exclude = ["libraries/**/templates/*"]
 default.extend-ignore-re = [
   # Ignore any line that ends with this comment:
   "(?Rm)^.*(#|//)\\s*spellchecker:disable-line$",

{griptape_nodes-0.71.0 → griptape_nodes-0.72.0}/src/griptape_nodes/app/app.py

@@ -30,6 +30,7 @@ from griptape_nodes.retained_mode.events.base_events import (
 )
 from griptape_nodes.retained_mode.events.logger_events import LogHandlerEvent
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+from griptape_nodes.utils import install_file_url_support
 
 
 # WebSocket thread communication message types
@@ -78,6 +79,9 @@ REQUEST_SEMAPHORE = asyncio.Semaphore(100)
 
 config_manager = GriptapeNodes.ConfigManager()
 
+# Install file:// URL support for httpx/requests
+install_file_url_support()
+
 
 class EventLogHandler(logging.Handler):
     """Custom logging handler that emits log messages as AppEvents.

{griptape_nodes-0.71.0 → griptape_nodes-0.72.0}/src/griptape_nodes/bootstrap/workflow_executors/local_workflow_executor.py

@@ -32,14 +32,23 @@ class LocalWorkflowExecutor(WorkflowExecutor):
     def __init__(
         self,
         storage_backend: StorageBackend = StorageBackend.LOCAL,
+        *,
+        skip_library_loading: bool = False,
+        workflows_to_register: list[str] | None = None,
     ):
         super().__init__()
         self._set_storage_backend(storage_backend=storage_backend)
+        self._skip_library_loading = skip_library_loading
+        self._workflows_to_register = workflows_to_register or []
 
     async def __aenter__(self) -> Self:
         """Async context manager entry: initialize queue and broadcast app initialization."""
         GriptapeNodes.EventManager().initialize_queue()
-        await GriptapeNodes.EventManager().broadcast_app_event(AppInitializationComplete())
+        await GriptapeNodes.EventManager().broadcast_app_event(
+            AppInitializationComplete(
+                skip_library_loading=self._skip_library_loading, workflows_to_register=self._workflows_to_register
+            )
+        )
         return self
 
     async def __aexit__(

{griptape_nodes-0.71.0 → griptape_nodes-0.72.0}/src/griptape_nodes/bootstrap/workflow_executors/utils/subprocess_script.py

@@ -10,6 +10,10 @@ from workflow import execute_workflow  # type: ignore[attr-defined]
 
 from griptape_nodes.bootstrap.workflow_executors.local_session_workflow_executor import LocalSessionWorkflowExecutor
 from griptape_nodes.drivers.storage import StorageBackend
+from griptape_nodes.utils import install_file_url_support
+
+# Install file:// URL support for httpx/requests in subprocess
+install_file_url_support()
 
 
 def _main() -> None:

{griptape_nodes-0.71.0 → griptape_nodes-0.72.0}/src/griptape_nodes/bootstrap/workflow_publishers/utils/subprocess_script.py

@@ -7,6 +7,10 @@ from griptape_nodes.bootstrap.workflow_publishers.local_session_workflow_publish
     LocalSessionWorkflowPublisher,
 )
 from griptape_nodes.bootstrap.workflow_publishers.local_workflow_publisher import LocalWorkflowPublisher
+from griptape_nodes.utils import install_file_url_support
+
+# Install file:// URL support for httpx/requests in subprocess
+install_file_url_support()
 
 logging.basicConfig(level=logging.INFO)
 

{griptape_nodes-0.71.0 → griptape_nodes-0.72.0}/src/griptape_nodes/common/node_executor.py

@@ -3232,7 +3232,7 @@ class NodeExecutor:
                 WorkflowRegistry.generate_new_workflow(str(workflow_path), result.metadata)
 
         delete_request = DeleteWorkflowRequest(name=workflow_name)
-        delete_result = GriptapeNodes.handle_request(delete_request)
+        delete_result = await GriptapeNodes.ahandle_request(delete_request)
         if isinstance(delete_result, DeleteWorkflowResultFailure):
             logger.error(
                 "Failed to delete workflow '%s'. Error: %s",

griptape_nodes-0.72.0/src/griptape_nodes/drivers/image_metadata/__init__.py

@@ -0,0 +1,21 @@
+"""Image metadata injection drivers.
+
+Provides pluggable drivers for injecting workflow metadata into different image formats.
+Drivers are automatically registered on module import.
+"""
+
+from griptape_nodes.drivers.image_metadata.base_image_metadata_driver import BaseImageMetadataDriver
+from griptape_nodes.drivers.image_metadata.exif_metadata_driver import ExifMetadataDriver
+from griptape_nodes.drivers.image_metadata.image_metadata_driver_registry import ImageMetadataDriverRegistry
+from griptape_nodes.drivers.image_metadata.png_metadata_driver import PngMetadataDriver
+
+# Register core drivers on import
+ImageMetadataDriverRegistry.register_driver(PngMetadataDriver())
+ImageMetadataDriverRegistry.register_driver(ExifMetadataDriver())
+
+__all__ = [
+    "BaseImageMetadataDriver",
+    "ExifMetadataDriver",
+    "ImageMetadataDriverRegistry",
+    "PngMetadataDriver",
+]

griptape_nodes-0.72.0/src/griptape_nodes/drivers/image_metadata/base_image_metadata_driver.py

@@ -0,0 +1,63 @@
+"""Base class for image metadata injection and extraction drivers."""
+
+from abc import ABC, abstractmethod
+
+from PIL import Image
+
+
+class BaseImageMetadataDriver(ABC):
+    """Base class for bidirectional image metadata drivers.
+
+    Each driver handles a specific metadata protocol (e.g., PNG text chunks, EXIF).
+    Drivers support both injection (writing) and extraction (reading) of metadata.
+
+    Extraction returns ALL available metadata for the format.
+    Injection writes only custom key-value pairs, preserving existing metadata.
+
+    Drivers are registered with ImageMetadataDriverRegistry and selected based on image format.
+    """
+
+    @abstractmethod
+    def get_supported_formats(self) -> list[str]:
+        """Return list of PIL format strings this driver supports.
+
+        Returns:
+            List of format strings (e.g., ["PNG"], ["JPEG", "TIFF", "MPO"])
+        """
+        ...
+
+    @abstractmethod
+    def inject_metadata(self, pil_image: Image.Image, metadata: dict[str, str]) -> bytes:
+        """Inject metadata into image and return modified image bytes.
+
+        Args:
+            pil_image: PIL Image object to inject metadata into
+            metadata: Dictionary of key-value string pairs to inject
+
+        Returns:
+            Image bytes with metadata injected
+
+        Raises:
+            Exception: On metadata injection failures
+        """
+        ...
+
+    @abstractmethod
+    def extract_metadata(self, pil_image: Image.Image) -> dict[str, str]:
+        """Extract ALL metadata from image.
+
+        Returns all available metadata for the format:
+        - PNG: All text chunks
+        - EXIF: Standard tags, GPS data, and custom UserComment field
+
+        The amount and type of metadata depends on the format and what's
+        present in the image. Custom metadata injected via inject_metadata()
+        is included alongside format-specific metadata.
+
+        Args:
+            pil_image: PIL Image object to extract metadata from
+
+        Returns:
+            Dictionary of metadata key-value pairs, empty dict if none found
+        """
+        ...

griptape_nodes-0.72.0/src/griptape_nodes/drivers/image_metadata/exif_metadata_driver.py

@@ -0,0 +1,218 @@
+"""EXIF metadata injection and extraction driver for JPEG, TIFF, and MPO formats."""
+
+import json
+import logging
+from io import BytesIO
+from typing import Any
+
+from PIL import Image
+from PIL.ExifTags import GPSTAGS, TAGS
+
+from griptape_nodes.drivers.image_metadata.base_image_metadata_driver import BaseImageMetadataDriver
+
+logger = logging.getLogger("griptape_nodes")
+
+# EXIF tag IDs
+EXIF_USERCOMMENT_TAG = 0x9286
+EXIF_GPSINFO_TAG = 0x8825  # 34853
+
+# GPS coordinate tuple length
+GPS_COORD_TUPLE_LENGTH = 3
+
+
+class ExifMetadataDriver(BaseImageMetadataDriver):
+    """Bidirectional driver for EXIF metadata.
+
+    Supports reading ALL EXIF metadata (standard tags, GPS data, custom UserComment)
+    and writing custom metadata to EXIF UserComment field as JSON.
+    Preserves all existing EXIF data when writing.
+    All EXIF-specific logic is encapsulated in this driver.
+    """
+
+    def get_supported_formats(self) -> list[str]:
+        """Return list of PIL format strings this driver supports.
+
+        Returns:
+            List containing "JPEG", "TIFF", "MPO"
+        """
+        return ["JPEG", "TIFF", "MPO", "WEBP"]
+
+    def inject_metadata(self, pil_image: Image.Image, metadata: dict[str, str]) -> bytes:
+        """Inject metadata into EXIF UserComment field as JSON.
+
+        Serializes metadata dictionary to JSON and stores in EXIF UserComment.
+        Preserves all existing EXIF tags.
+
+        Args:
+            pil_image: PIL Image to inject metadata into
+            metadata: Dictionary of key-value pairs to inject
+
+        Returns:
+            Image bytes with metadata injected
+
+        Raises:
+            Exception: On EXIF save errors
+        """
+        # Get existing EXIF data to preserve it
+        exif_data = pil_image.getexif()
+
+        # Serialize metadata to JSON for UserComment field
+        metadata_json = json.dumps(metadata, separators=(",", ":"))
+
+        # Set UserComment field
+        exif_data[EXIF_USERCOMMENT_TAG] = metadata_json
+
+        # Save with updated EXIF
+        output_buffer = BytesIO()
+        pil_image.save(output_buffer, format=pil_image.format, exif=exif_data)
+        return output_buffer.getvalue()
+
+    def extract_metadata(self, pil_image: Image.Image) -> dict[str, str]:
+        """Extract ALL EXIF metadata including standard tags, GPS data, and custom UserComment.
+
+        Returns combined metadata from all sources:
+        - Standard EXIF tags (Make, Model, DateTime, etc.)
+        - GPS metadata (prefixed with 'GPS_')
+        - Custom metadata from UserComment field (JSON parsed)
+
+        Args:
+            pil_image: PIL Image to extract metadata from
+
+        Returns:
+            Dictionary of all metadata key-value pairs, empty dict if no EXIF data
+        """
+        exif_data = pil_image.getexif()
+        if not exif_data:
+            return {}
+
+        metadata = {}
+
+        # Extract standard EXIF tags
+        self._extract_standard_tags(exif_data, metadata)
+
+        # Extract GPS metadata
+        self._extract_gps_metadata(exif_data, metadata)
+
+        # Extract custom UserComment metadata
+        self._extract_user_comment_metadata(exif_data, metadata)
+
+        return metadata
+
+    def _exif_value_to_string(self, value: Any) -> str:
+        """Convert EXIF value to readable string format.
+
+        Args:
+            value: EXIF value (can be bytes, tuple, list, int, etc.)
+
+        Returns:
+            String representation of the value
+        """
+        if isinstance(value, bytes):
+            try:
+                return value.decode("utf-8", errors="ignore").strip("\x00")
+            except Exception:
+                return str(value)
+        elif isinstance(value, (tuple, list)):
+            return ", ".join(str(v) for v in value)
+        return str(value)
+
+    def _format_gps_coordinate(self, coord_tuple: tuple) -> str:
+        """Format GPS coordinate tuple to decimal degrees string.
+
+        Args:
+            coord_tuple: Tuple of (degrees, minutes, seconds) as rational numbers
+
+        Returns:
+            Decimal degrees as string
+        """
+        if not coord_tuple or len(coord_tuple) != GPS_COORD_TUPLE_LENGTH:
+            return str(coord_tuple)
+
+        try:
+            degrees = float(coord_tuple[0])
+            minutes = float(coord_tuple[1])
+            seconds = float(coord_tuple[2])
+
+            decimal_degrees = degrees + (minutes / 60.0) + (seconds / 3600.0)
+        except Exception:
+            return self._exif_value_to_string(coord_tuple)
+        else:
+            return f"{decimal_degrees:.6f}"
+
+    def _extract_standard_tags(self, exif_data: Any, metadata: dict[str, str]) -> None:
+        """Extract standard EXIF tags.
+
+        Args:
+            exif_data: EXIF data object from PIL
+            metadata: Dictionary to populate with standard tags (modified in-place)
+        """
+        for tag_id, value in exif_data.items():
+            # Get tag name
+            tag_name = TAGS.get(tag_id, f"Tag_{tag_id}")
+
+            # Skip UserComment and GPSInfo, we'll handle them separately
+            if tag_id in (EXIF_USERCOMMENT_TAG, EXIF_GPSINFO_TAG):
+                continue
+
+            # Convert value to string
+            metadata[tag_name] = self._exif_value_to_string(value)
+
+    def _extract_gps_metadata(self, exif_data: Any, metadata: dict[str, str]) -> None:
+        """Extract GPS metadata from EXIF data.
+
+        Formats GPS coordinates as decimal degrees and prefixes all GPS tags with 'GPS_'.
+
+        Args:
+            exif_data: EXIF data object from PIL
+            metadata: Dictionary to populate with GPS metadata (modified in-place)
+        """
+        gps_ifd = exif_data.get_ifd(EXIF_GPSINFO_TAG)
+        if not gps_ifd:
+            return
+
+        for gps_tag_id, gps_value in gps_ifd.items():
+            gps_tag_name = GPSTAGS.get(gps_tag_id, f"GPSTag_{gps_tag_id}")
+
+            # Format GPS coordinate values specially
+            if gps_tag_id in (1, 2, 3, 4):  # GPSLatitudeRef, GPSLatitude, GPSLongitudeRef, GPSLongitude
+                if gps_tag_id in (2, 4):  # Latitude or Longitude tuple
+                    metadata[f"GPS_{gps_tag_name}"] = self._format_gps_coordinate(gps_value)
+                else:
+                    metadata[f"GPS_{gps_tag_name}"] = str(gps_value)
+            else:
+                metadata[f"GPS_{gps_tag_name}"] = self._exif_value_to_string(gps_value)
+
+    def _extract_user_comment_metadata(self, exif_data: Any, metadata: dict[str, str]) -> None:
+        """Extract custom metadata from EXIF UserComment field.
+
+        Args:
+            exif_data: EXIF data object from PIL
+            metadata: Dictionary to populate with custom metadata (modified in-place)
+        """
+        user_comment = exif_data.get(EXIF_USERCOMMENT_TAG)
+        if not user_comment:
+            return
+
+        # Parse JSON from UserComment field
+        try:
+            # Pillow handles the character code prefix, but might return bytes or string
+            if isinstance(user_comment, bytes):
+                comment_str = user_comment.decode("utf-8", errors="ignore").strip("\x00")
+            else:
+                comment_str = str(user_comment)
+
+            custom_metadata = json.loads(comment_str)
+            if not isinstance(custom_metadata, dict):
+                logger.debug("UserComment is not a dict, skipping custom metadata")
+                return
+
+            # Merge custom metadata directly into metadata dict
+            for key, value in custom_metadata.items():
+                metadata[key] = str(value)
+
+            if custom_metadata:
+                logger.debug("Merged %d custom metadata entries from EXIF UserComment", len(custom_metadata))
+        except (json.JSONDecodeError, ValueError) as e:
+            logger.debug("Could not parse UserComment as JSON: %s", e)
+        except Exception as e:
+            logger.debug("Unexpected error parsing UserComment: %s", e)

griptape_nodes-0.72.0/src/griptape_nodes/drivers/image_metadata/image_metadata_driver_registry.py

@@ -0,0 +1,55 @@
+"""Registry for image metadata injection drivers."""
+
+from typing import ClassVar
+
+from griptape_nodes.drivers.image_metadata.base_image_metadata_driver import BaseImageMetadataDriver
+from griptape_nodes.utils.metaclasses import SingletonMeta
+
+
+class ImageMetadataDriverRegistry(metaclass=SingletonMeta):
+    """Registry for image metadata injection drivers.
+
+    Provides centralized registration and lookup of metadata injection drivers
+    based on image format. Follows singleton pattern to ensure single registry instance.
+    """
+
+    _drivers: ClassVar[list[BaseImageMetadataDriver]] = []
+
+    @classmethod
+    def register_driver(cls, driver: BaseImageMetadataDriver) -> None:
+        """Register a metadata injection driver.
+
+        Args:
+            driver: Driver instance to register
+        """
+        instance = cls()
+        instance._drivers.append(driver)
+
+    @classmethod
+    def get_driver_for_format(cls, format_str: str) -> BaseImageMetadataDriver | None:
+        """Get the first driver that supports the given format.
+
+        Args:
+            format_str: PIL format string (e.g., "PNG", "JPEG")
+
+        Returns:
+            Driver instance or None if no driver supports format
+        """
+        instance = cls()
+        for driver in instance._drivers:
+            if format_str in driver.get_supported_formats():
+                return driver
+        return None
+
+    @classmethod
+    def get_supported_formats(cls) -> set[str]:
+        """Get all formats supported by registered drivers.
+
+        Returns:
+            Set of format strings supported by any registered driver
+        """
+        instance = cls()
+        formats = set()
+        for driver in instance._drivers:
+            formats.update(driver.get_supported_formats())
+        return formats

griptape_nodes-0.72.0/src/griptape_nodes/drivers/image_metadata/png_metadata_driver.py

@@ -0,0 +1,71 @@
+"""PNG metadata injection and extraction driver using text chunks."""
+
+from io import BytesIO
+
+from PIL import Image, PngImagePlugin
+
+from griptape_nodes.drivers.image_metadata.base_image_metadata_driver import BaseImageMetadataDriver
+
+
+class PngMetadataDriver(BaseImageMetadataDriver):
+    """Bidirectional driver for PNG metadata using text chunks.
+
+    Supports both reading and writing metadata in PNG text chunks.
+    Preserves existing text chunks when writing new metadata.
+    All PNG-specific logic is encapsulated in this driver.
+    """
+
+    def get_supported_formats(self) -> list[str]:
+        """Return list of PIL format strings this driver supports.
+
+        Returns:
+            List containing "PNG"
+        """
+        return ["PNG"]
+
+    def inject_metadata(self, pil_image: Image.Image, metadata: dict[str, str]) -> bytes:
+        """Inject metadata into PNG text chunks.
+
+        Creates PngInfo with existing text chunks and adds new metadata.
+        New metadata overwrites existing keys with same name.
+
+        Args:
+            pil_image: PIL Image to inject metadata into
+            metadata: Dictionary of key-value pairs to inject
+
+        Returns:
+            Image bytes with metadata injected
+
+        Raises:
+            Exception: On PNG save errors
+        """
+        # Create PNG info object
+        png_info = PngImagePlugin.PngInfo()
+
+        # Preserve existing text chunks
+        for key, value in pil_image.info.items():
+            # Only preserve string key-value pairs (text chunks), skip binary data
+            # Don't preserve keys that will be overwritten by new metadata
+            if isinstance(key, str) and isinstance(value, str) and key not in metadata:
+                png_info.add_text(key, value)
+
+        # Add new metadata
+        for key, value in metadata.items():
+            png_info.add_text(key, str(value))
+
+        # Save with metadata
+        output_buffer = BytesIO()
+        pil_image.save(output_buffer, format="PNG", pnginfo=png_info)
+        return output_buffer.getvalue()
+
+    def extract_metadata(self, pil_image: Image.Image) -> dict[str, str]:
+        """Extract all text chunks from PNG image.
+
+        Args:
+            pil_image: PIL Image to extract metadata from
+
+        Returns:
+            Dictionary of all PNG text chunks, empty dict if none found
+        """
+        # PIL unpacks PNG text chunks directly into pil_image.info
+        return {key: value for key, value in pil_image.info.items() if isinstance(key, str) and isinstance(value, str)}

{griptape_nodes-0.71.0 → griptape_nodes-0.72.0}/src/griptape_nodes/drivers/storage/base_storage_driver.py

@@ -75,6 +75,38 @@ class BaseStorageDriver(ABC):
         """
         ...
 
+    @abstractmethod
+    def get_asset_url(self, path: Path) -> str:
+        """Get the permanent unsigned URL for an asset.
+
+        Args:
+            path: The path of the file
+
+        Returns:
+            Permanent URL for accessing the asset
+        """
+        ...
+
+    @abstractmethod
+    def save_file(
+        self, path: Path, file_content: bytes, existing_file_policy: ExistingFilePolicy = ExistingFilePolicy.OVERWRITE
+    ) -> str:
+        """Save a file to storage.
+
+        Args:
+            path: The path of the file to save.
+            file_content: The file content as bytes.
+            existing_file_policy: How to handle existing files. Defaults to OVERWRITE.
+
+        Returns:
+            The absolute file path where the file was saved.
+
+        Raises:
+            FileExistsError: When existing_file_policy is FAIL and file already exists.
+            RuntimeError: If file save fails.
+        """
+        ...
+
     def upload_file(
         self, path: Path, file_content: bytes, existing_file_policy: ExistingFilePolicy = ExistingFilePolicy.OVERWRITE
     ) -> str: