Merge branch 'fix/more-magick' into feature/e2e-func-tests

Author: corpo-iwillspeak

.env.example

@@ -6,4 +6,4 @@ OAUTH_AUDIENCE=crisp-athena-live
 
 # Athena server configuration
 # ATHENA_HOST=trust-messages.crispthinking.com
-ATHENA_AFFILIATE=athena-test
+ATHENA_AFFILIATE=athena-test

.github/workflows/ci.yml

@@ -31,7 +31,7 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
 
       - name: Initialize submodules
         env:
@@ -42,7 +42,7 @@ jobs:
           git submodule update --init --recursive
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@v7
         with:
           enable-cache: true
 
@@ -81,13 +81,13 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
 
       - name: Initialize submodules
         run: git submodule update --init --recursive
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@v7
         with:
           enable-cache: true
 
@@ -118,7 +118,7 @@ jobs:
         run: uv build
 
       - name: Upload build artifacts
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v5
         with:
           name: dist
           path: dist/
@@ -134,15 +134,15 @@ jobs:
       id-token: write
 
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@v7
         with:
           enable-cache: true
 
       - name: Download build artifacts
-        uses: actions/download-artifact@v5
+        uses: actions/download-artifact@v6
         with:
           name: dist
           path: dist/

.github/workflows/docs.yml

@@ -42,12 +42,12 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@v7
         with:
           enable-cache: true
 
@@ -82,14 +82,14 @@ jobs:
           path: docs/_build/html
 
       - name: Upload documentation artifacts
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v5
         if: github.event_name != 'release'
         with:
           name: documentation
           path: docs/_build/html
 
       - name: Upload build artifacts for debugging
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v5
         if: failure()
         with:
           name: docs-build-artifacts

.pre-commit-config.yaml

@@ -13,7 +13,7 @@ repos:
     hooks:
       - id: basedpyright
         name: basedpyright
-        entry: basedpyright
+        entry: uv run basedpyright
         language: system
         types_or: [python, pyi]
         pass_filenames: false

athena-protobufs

@@ -239,12 +239,18 @@ async def classify_single(
             else RequestEncoding.REQUEST_ENCODING_UNCOMPRESSED
         )
 
+        # Ensure we never send UNSPECIFIED format over the API
+        # If format is still UNSPECIFIED, default to RAW_UINT8
+        image_format = processed_image.image_format
+        if image_format == ImageFormat.IMAGE_FORMAT_UNSPECIFIED:
+            image_format = ImageFormat.IMAGE_FORMAT_RAW_UINT8_BGR
+
         classification_input = ClassificationInput(
             affiliate=self.options.affiliate,
             correlation_id=correlation_id,
             encoding=request_encoding,
             data=processed_image.data,
-            format=ImageFormat.IMAGE_FORMAT_RAW_UINT8,
+            format=image_format,
             hashes=[
                 ImageHash(
                     value=hash_value,

src/resolver_athena_client/client/athena_client.py

@@ -0,0 +1,73 @@
+"""Utility for detecting image formats from raw bytes."""
+
+from resolver_athena_client.generated.athena.models_pb2 import ImageFormat
+
+PNG_MAGIC_BYTES = b"\x89PNG"
+JPEG_MAGIC_BYTES = b"\xff\xd8\xff"
+GIF87A_MAGIC_BYTES = b"GIF87a"
+GIF89A_MAGIC_BYTES = b"GIF89a"
+BMP_MAGIC_BYTES = b"BM"
+WEBP_RIFF_MAGIC_BYTES = b"RIFF"
+WEBP_WEBP_MAGIC_BYTES = b"WEBP"
+TIFF_LE_MAGIC_BYTES = b"II*\x00"
+TIFF_BE_MAGIC_BYTES = b"MM\x00*"
+
+
+def detect_image_format(data: bytes) -> ImageFormat.ValueType:  # noqa: PLR0911
+    """Detect image format from raw bytes using magic number signatures.
+
+    Args:
+    ----
+        data: Raw image bytes to analyze
+
+    Returns:
+    -------
+        ImageFormat enum value representing the detected format
+
+    """
+    if not data:
+        return ImageFormat.IMAGE_FORMAT_UNSPECIFIED
+
+    # Check magic numbers for common image formats
+    # PNG: starts with PNG_MAGIC_BYTES
+    png_len = len(PNG_MAGIC_BYTES)
+    if len(data) >= png_len and data[:png_len] == PNG_MAGIC_BYTES:
+        return ImageFormat.IMAGE_FORMAT_PNG
+
+    # JPEG: starts with JPEG_MAGIC_BYTES
+    jpeg_len = len(JPEG_MAGIC_BYTES)
+    if len(data) >= jpeg_len and data[:jpeg_len] == JPEG_MAGIC_BYTES:
+        return ImageFormat.IMAGE_FORMAT_JPEG
+
+    # GIF: starts with GIF87A_MAGIC_BYTES or GIF89A_MAGIC_BYTES
+    gif_len = len(GIF87A_MAGIC_BYTES)
+    if len(data) >= gif_len and data[:gif_len] in (
+        GIF87A_MAGIC_BYTES,
+        GIF89A_MAGIC_BYTES,
+    ):
+        return ImageFormat.IMAGE_FORMAT_GIF
+
+    # BMP: starts with BMP_MAGIC_BYTES
+    bmp_len = len(BMP_MAGIC_BYTES)
+    if len(data) >= bmp_len and data[:bmp_len] == BMP_MAGIC_BYTES:
+        return ImageFormat.IMAGE_FORMAT_BMP
+
+    # WebP: RIFF....WEBP (12 bytes minimum for full signature)
+    webp_min_len = len(WEBP_RIFF_MAGIC_BYTES) + len(WEBP_WEBP_MAGIC_BYTES) + 4
+    if (
+        len(data) >= webp_min_len
+        and data[:4] == WEBP_RIFF_MAGIC_BYTES
+        and data[8:12] == WEBP_WEBP_MAGIC_BYTES
+    ):
+        return ImageFormat.IMAGE_FORMAT_WEBP
+
+    # TIFF: little-endian or big-endian magic bytes
+    tiff_len = len(TIFF_LE_MAGIC_BYTES)
+    if len(data) >= tiff_len and (
+        data[:tiff_len] == TIFF_LE_MAGIC_BYTES
+        or data[:tiff_len] == TIFF_BE_MAGIC_BYTES
+    ):
+        return ImageFormat.IMAGE_FORMAT_TIFF
+
+    # Fallback when format cannot be determined
+    return ImageFormat.IMAGE_FORMAT_UNSPECIFIED

src/resolver_athena_client/client/image_format_detector.py

@@ -6,6 +6,14 @@
 """
 
 import hashlib
+from typing import TYPE_CHECKING
+
+from resolver_athena_client.client.image_format_detector import (
+    detect_image_format,
+)
+
+if TYPE_CHECKING:
+    from resolver_athena_client.generated.athena.models_pb2 import ImageFormat
 
 
 class ImageData:
@@ -24,6 +32,8 @@ class ImageData:
     Attributes:
     ----------
         data: The raw bytes of the image (modified in-place by transformers).
+        image_format: The format of the image data (e.g., JPEG, PNG, RAW_UINT8).
+            Updated by transformers when they change the format.
         sha256_hashes: List of SHA256 hashes tracking image transformations.
             Index 0 is the original image, subsequent indices track
             transformations.
@@ -66,6 +76,9 @@ def __init__(self, image_bytes: bytes) -> None:
 
         """
         self.data: bytes = image_bytes
+        self.image_format: ImageFormat.ValueType = detect_image_format(
+            image_bytes
+        )
         self.sha256_hashes: list[str] = [
             hashlib.sha256(image_bytes).hexdigest()
         ]

src/resolver_athena_client/client/models/input_model.py

@@ -48,15 +48,20 @@ def __init__(
     def _create_classification_input(
         self, image_data: ImageData
     ) -> ClassificationInput:
-        # Get image format and data
+        # Ensure we never send UNSPECIFIED format over the API
+        # If format is still UNSPECIFIED, default to RAW_UINT8
+        image_format = image_data.image_format
+        if image_format == ImageFormat.IMAGE_FORMAT_UNSPECIFIED:
+            image_format = ImageFormat.IMAGE_FORMAT_RAW_UINT8_BGR
+
         return ClassificationInput(
             affiliate=self.affiliate,
             correlation_id=self.correlation_provider.get_correlation_id(
                 image_data.data
             ),
             data=image_data.data,
             encoding=self.request_encoding,
-            format=ImageFormat.IMAGE_FORMAT_RAW_UINT8,
+            format=image_format,
         )
 
     @override

src/resolver_athena_client/client/transformers/classification_input.py

@@ -13,14 +13,15 @@
 
 from resolver_athena_client.client.consts import EXPECTED_HEIGHT, EXPECTED_WIDTH
 from resolver_athena_client.client.models import ImageData
+from resolver_athena_client.generated.athena.models_pb2 import ImageFormat
 
 # Global optimization constants
 _target_size = (EXPECTED_WIDTH, EXPECTED_HEIGHT)
 _expected_raw_size = EXPECTED_WIDTH * EXPECTED_HEIGHT * 3
 
 
-def _is_raw_brg_expected_size(data: bytes) -> bool:
-    """Detect if data is already a raw BRG array of expected size."""
+def _is_raw_bgr_expected_size(data: bytes) -> bool:
+    """Detect if data is already a raw BGR array of expected size."""
     return len(data) == _expected_raw_size
 
 
@@ -37,7 +38,7 @@ async def resize_image(image_data: ImageData) -> ImageData:
 
     def process_image() -> tuple[bytes, bool]:
         # Fast path for raw RGB arrays of correct size
-        if _is_raw_brg_expected_size(image_data.data):
+        if _is_raw_bgr_expected_size(image_data.data):
             return image_data.data, False  # No transformation needed
 
         # Try to load the image data directly
@@ -57,22 +58,23 @@ def process_image() -> tuple[bytes, bool]:
 
             rgb_bytes = resized_image.tobytes()
 
-            # Convert RGB to BRG by swapping channels
-            brg_bytes = bytearray(len(rgb_bytes))
+            # Convert RGB to BGR by swapping channels
+            bgr_bytes = bytearray(len(rgb_bytes))
 
             for i in range(0, len(rgb_bytes), 3):
-                brg_bytes[i] = rgb_bytes[i + 2]
-                brg_bytes[i + 1] = rgb_bytes[i]
-                brg_bytes[i + 2] = rgb_bytes[i + 1]
+                bgr_bytes[i] = rgb_bytes[i + 2]
+                bgr_bytes[i + 1] = rgb_bytes[i + 1]
+                bgr_bytes[i + 2] = rgb_bytes[i]
 
-            return bytes(brg_bytes), True  # Data was transformed
+            return bytes(bgr_bytes), True  # Data was transformed
 
     # Use thread pool for CPU-intensive processing
     resized_bytes, was_transformed = await asyncio.to_thread(process_image)
 
     # Only modify data and add hashes if transformation occurred
     if was_transformed:
         image_data.data = resized_bytes
+        image_data.image_format = ImageFormat.IMAGE_FORMAT_RAW_UINT8_BGR
         image_data.add_transformation_hashes()
 
     return image_data