dory-processor-sdk 0.0.1__py3-none-any.whl

dory/output/formatter.py

@@ -0,0 +1,113 @@
+"""
+Output formatting for processor results.
+
+Provides pluggable formatters for serializing data before publishing.
+"""
+
+import dataclasses
+import json
+import logging
+from abc import ABC, abstractmethod
+from datetime import datetime, date
+from enum import Enum
+from typing import Any
+from uuid import UUID
+
+logger = logging.getLogger(__name__)
+
+
+class OutputFormatter(ABC):
+    """Abstract base class for output formatters."""
+
+    @abstractmethod
+    def format(self, data: Any) -> bytes:
+        """Serialize data to bytes.
+
+        Args:
+            data: Data to serialize.
+
+        Returns:
+            Serialized bytes.
+        """
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def content_type(self) -> str:
+        """MIME type for the formatted output."""
+        raise NotImplementedError
+
+
+class JSONFormatter(OutputFormatter):
+    """JSON output formatter with support for common Python types.
+
+    Handles serialization of datetime, UUID, Enum, and dataclass objects
+    via a custom default handler.
+
+    Args:
+        indent: JSON indentation level (None for compact).
+        sort_keys: Whether to sort dictionary keys.
+        max_size_bytes: Maximum allowed output size in bytes (0 = unlimited).
+    """
+
+    def __init__(
+        self,
+        indent: int | None = None,
+        sort_keys: bool = False,
+        max_size_bytes: int = 0,
+    ):
+        self._indent = indent
+        self._sort_keys = sort_keys
+        self._max_size_bytes = max_size_bytes
+
+    @property
+    def content_type(self) -> str:
+        return "application/json"
+
+    def format(self, data: Any) -> bytes:
+        """Serialize data to UTF-8 encoded JSON bytes.
+
+        Args:
+            data: Data to serialize. Must be JSON-serializable
+                  (with support for datetime, UUID, Enum, dataclass).
+
+        Returns:
+            UTF-8 encoded JSON bytes.
+
+        Raises:
+            TypeError: If data contains non-serializable types.
+            ValueError: If serialized output exceeds max_size_bytes.
+        """
+        encoded = json.dumps(
+            data,
+            default=self._default_handler,
+            indent=self._indent,
+            sort_keys=self._sort_keys,
+            ensure_ascii=False,
+        ).encode("utf-8")
+
+        if self._max_size_bytes > 0 and len(encoded) > self._max_size_bytes:
+            raise ValueError(
+                f"Serialized output size {len(encoded)} bytes exceeds "
+                f"max_size_bytes limit of {self._max_size_bytes}"
+            )
+
+        return encoded
+
+    @staticmethod
+    def _default_handler(obj: Any) -> Any:
+        """Handle non-standard JSON types.
+
+        Supports: datetime, date, UUID, Enum, dataclass.
+        """
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        if isinstance(obj, date):
+            return obj.isoformat()
+        if isinstance(obj, UUID):
+            return str(obj)
+        if isinstance(obj, Enum):
+            return obj.value
+        if dataclasses.is_dataclass(obj) and not isinstance(obj, type):
+            return dataclasses.asdict(obj)
+        raise TypeError(f"Object of type {type(obj).__name__} is not JSON serializable")