dags: Resize images that are too large for Bedrock

* Add `piffle` dep for IIIF metadata processing.

* Add variable `TIND_IIIF_MANIFEST_URL_PATTERN` to define where the IIIF
  manifests live for the given TIND API.

* Add helper code to the FetchTind class to fetch the image.  This will
  likely be refactored to the TIND Client package later.

* Add logic for determining the correct size.

Implements: AP-672

Author: awilfox

README.md

@@ -93,6 +93,7 @@ Important environment variables for our build/environment:
 | `OIDC_USER_GROUP` | Similar to admin group. This group is for users in both admin and user roles.| `OIDC_USER_GROUP="cn=edu:berkeley:org:libr:mokelumne:users,ou=campus groups,dc=berkeley,dc=edu"` |
 | `TIND_API_KEY` | API key for TIND access | `TIND_API_KEY="..."` |
 | `TIND_API_URL` | URL for TIND access | `TIND_API_URL="https://digicoll.lib.berkeley.edu/api/v1"` |
+| `TIND_IIIF_MANIFEST_URL_PATTERN` | URL pattern for TIND IIIF manifests | `TIND_IIIF_MANIFEST_URL_PATTERN="https://digicoll.lib.berkeley.edu/record/{tind_id}/export/iiif_manifest"` |
 | `MOKELUMNE_TIND_DOWNLOAD_DIR` | Path for downloaded image cache | `MOKELUMNE_TIND_DOWNLOAD_DIR="/some/path/to/download/to"` |
 |`LANGFUSE_HOST`|Host for Langfuse|`LANGFUSE_HOST="https://us.cloud.langfuse.com"`|
 |`LANGFUSE_SECRET_KEY`|sets langfuse secret key|`LANGFUSE_SECRET_KEY="sk-lf-blah-blah-blah"`|

example.env

@@ -22,6 +22,7 @@ OIDC_WELL_KNOWN="http://keycloak:8180/realms/berkeley-local/.well-known/openid-c
 # TBD
 TIND_API_KEY=
 TIND_API_URL=
+TIND_IIIF_MANIFEST_URL_PATTERN=https://digicoll.lib.berkeley.edu/record/{tind_id}/export/iiif_manifest
 
 LANGFUSE_HOST=https://us.cloud.langfuse.com
 LANGFUSE_SECRET_KEY=sk-lf-blah-blah-blah

mokelumne/dags/fetch_images.py

@@ -4,8 +4,10 @@
 
 import csv
 import logging
+import os
 
 from collections import namedtuple
+from math import ceil, trunc
 from pathlib import Path
 from typing import List
 
@@ -20,6 +22,22 @@
 RunStatus = namedtuple('RunStatus', ('tind_id', 'status', 'path'))
 
 SUPPORTED_IMAGE_TYPES = {"image/jpeg", "image/png", "image/gif", "image/webp"}
+"""The supported image MIME types we will fetch."""
+
+SIZE_LIMIT: int = 3750000
+"""The upper bound for a size of image in bytes that we will fetch."""
+
+
+def base64_size(s: int | float) -> int:
+    """Determine the base64-encoded size of an object given its original size.
+
+    :param s: The original size of the object.
+    :returns: The base64-encoded size of the object.
+    :note: The result of this function has the same unit as its parameter.
+        For example, passing 4.5 MiB will result in 8 (MiB).
+    """
+    return int(4 * (ceil(s * 4 / 3) / 4))
+
 
 @dag(schedule=[to_process_csv], catchup=False, tags=["tind", "fetch", "batch-image"])
 def fetch_images():
@@ -59,17 +77,57 @@ def fetch_image_to_record_directory(orig_run_id: str, tind_id: str) -> RunStatus
         """Fetch an image from TIND to the target record's storage directory."""
         try:
             client = FetchTind(orig_run_id)
-            filemd = client.client.fetch_file_metadata(tind_id)
-            if filemd[0].get("mime") in SUPPORTED_IMAGE_TYPES:
-                path = client.download_image_file(tind_id)
-                status = "fetched"
+            filemd = client.get_first_file_metadata(tind_id)
+            if not filemd.get("mime") in SUPPORTED_IMAGE_TYPES:
+                return RunStatus(tind_id=tind_id, path="",
+                                 status=f"skipped: Unsupported file type {filemd.get('mime')}")
+
+            target_width = width = filemd.get("width", 0)
+            target_height = height = filemd.get("height", 0)
+            size = filemd.get("size", 0)
+            b64_size = base64_size(size)
+            logger.warning("b64_size = %d, size = %d", b64_size, size)
+            if b64_size > SIZE_LIMIT:
+                factor = float(SIZE_LIMIT) / b64_size
+                target_width *= factor
+                target_height *= factor
+
+            if target_width > 8000:
+                factor = 8000.0 / width
+                target_width *= factor
+                target_height *= factor
+
+            if target_height > 8000:
+                factor = 8000.0 / height
+                target_width *= factor
+                target_height *= factor
+
+            target_width = int(trunc(target_width))
+            target_height = int(trunc(target_height))
+
+            if (width != target_width) or (height != target_height):
+                # downsample using IIIF
+                path = client.download_image_from_record_sized(tind_id, target_width, target_height)
+
+                # TIND resampling may cause the image to be larger than original.  recalculate.
+                # in my testing, 290827 resampled to 5998x8000 went from 2.5 MB to 4.9 MB(!)
+                new_size = os.stat(path).st_size
+                b64_size = base64_size(new_size)
+                if b64_size > SIZE_LIMIT:
+                    factor = float(SIZE_LIMIT) / b64_size
+                    target_width *= factor
+                    target_height *= factor
+                    target_width = int(trunc(target_width))
+                    target_height = int(trunc(target_height))
+                    # Only re-download if it actually does exceed the limit.
+                    path = client.download_image_from_record_sized(tind_id, target_width, target_height)
             else:
-                path = ""
-                status = f"skipped: Unsupported file type {filemd[0].get('mime')}"
+                path = client.download_image_file(tind_id)
         except Exception as ex:  # pylint: disable=broad-exception-caught
+            logger.warning("Fetcher encountered exception", exc_info=ex)
             return RunStatus(tind_id=tind_id, status=f'failed: {str(ex)}', path='')
 
-        return RunStatus(tind_id=tind_id, status=status, path=path)
+        return RunStatus(tind_id=tind_id, status="fetched", path=path)
 
     @task(outlets=[fetched_csv])
     def write_status_to_fetched_csv(orig_run_id: str, records: dict[str, list[str]],

mokelumne/util/fetch_tind.py

@@ -1,12 +1,21 @@
 """Provides a helper class, FetchTind, to download information from TIND."""
 
-import csv
+import logging
+from os import environ as ENV
+from typing import Any
 
-from tind_client import TINDClient
+import requests
+from piffle.image import IIIFImageClient
+from piffle.load_iiif import load_iiif_presentation
+from tind_client import TINDClient, TINDError
 
 from mokelumne.util.storage import run_dir, record_dir
 
 
+logger = logging.getLogger(__name__)
+"""The TIND Fetcher logger."""
+
+
 class FetchTind:
     """Helper methods for fetching items from TIND using TINDClient."""
     def __init__(self, _run_id: str):
@@ -17,13 +26,53 @@ def get_ids(self, tind_query: str) -> list[str]:
         """Return the TIND IDs that match a given query."""
         return self.client.fetch_ids_search(tind_query)
 
+    def get_first_file_metadata(self, tind_id: str) -> dict[str, Any]:
+        """Return the file metadata for a given TIND ID."""
+        record = self.client.fetch_file_metadata(tind_id)
+        if not record or not record[0]:
+            return {}
+        return record[0]
+
     def download_image_file(self, tind_id: str) -> str:
         """Download the first file attachment for a given TIND ID."""
-        record = self.client.fetch_file_metadata(tind_id)
-        download_url = record[0]["url"]
+        metadata = self.get_first_file_metadata(tind_id)
+        download_url = metadata["url"]
         record_path = record_dir(self.run_id, tind_id)
         return self.client.fetch_file(download_url, str(record_path))
 
+    def download_image_from_record_sized(self, tind_id: str, width: int, height: int) -> str:
+        """Download the first image for a given TIND ID with the given size.
+
+        :param tind_id: The TIND record ID.
+        :param int width: The desired width of the image in pixels.
+        :param int height: The desired height of the image in pixels.
+        :returns: The path where the file was saved.
+        """
+        url = ENV.get(
+            "TIND_IIIF_MANIFEST_URL_PATTERN",
+            "https://digicoll.lib.berkeley.edu/record/{tind_id}/export/iiif_manifest"
+        ).format(tind_id=tind_id)
+
+        manifest = load_iiif_presentation(url)
+        canvases = len(manifest.items)
+        if canvases != 1:
+            logger.warning("%s: manifest has invalid number of canvases: %d; crash may follow",
+                           tind_id, canvases)
+
+        # Manifest -> Canvas -> AnnotationPage -> Annotation -> Image
+        image_id = manifest.items[0].items[0].items[0].body["id"]
+        image = IIIFImageClient(*image_id.rsplit("/", 1))
+
+        data = requests.get(str(image.size(width=width, height=height, exact=True)))
+        data.raise_for_status()
+
+        output_path = record_dir(self.run_id, tind_id) / image.image_id
+        with output_path.open('wb') as out_f:
+            for chunk in data.iter_content():
+                out_f.write(chunk)
+
+        return str(output_path)
+
     def write_query_results_to_xml(self, tind_query: str, file_name: str = "") -> int:
         """Download the XML results of a search query from TIND."""
         records_written = self.client.write_search_results_to_file(tind_query, file_name)

pyproject.toml

@@ -9,6 +9,7 @@ dependencies = [
     "apache-airflow-task-sdk == 1.2.1",
     "langchain[aws]",
     "langfuse",
+    "piffle",  # IIIF API used in batch image description DAG
     "pymarc",
     "python-tind-client",
 ]

requirements.txt

@@ -4,6 +4,10 @@ a2wsgi==1.10.10 \
     --hash=sha256:a5bcffb52081ba39df0d5e9a884fc6f819d92e3a42389343ba77cbf809fe1f45 \
     --hash=sha256:d2b21379479718539dc15fce53b876251a0efe7615352dfe49f6ad1bc507848d
     # via apache-airflow-core
+addict==2.4.0 \
+    --hash=sha256:249bb56bbfd3cdc2a004ea0ff4c2b6ddc84d53bc2194761636eb314d5cfa5dfc \
+    --hash=sha256:b3b2210e0e067a281f5646c8c5db92e99b7231ea8b0eb5f74dbdf9e259d4e494
+    # via piffle
 aiosmtplib==5.1.0 \
     --hash=sha256:2504a23b2b63c9de6bc4ea719559a38996dba68f73f6af4eb97be20ee4c5e6c4 \
     --hash=sha256:368029440645b486b69db7029208a7a78c6691b90d24a5332ddba35d9109d55b
@@ -119,6 +123,10 @@ botocore==1.42.84 \
     # via
     #   boto3
     #   s3transfer
+cached-property==2.0.1 \
+    --hash=sha256:484d617105e3ee0e4f1f58725e72a8ef9e93deee462222dbd51cd91230897641 \
+    --hash=sha256:f617d70ab1100b7bcf6e42228f9ddcb78c676ffa167278d9f730d1c2fba69ccb
+    # via piffle
 cadwyn==6.2.0 \
     --hash=sha256:896901fd3b8425a550e08afb3dff4081c642ce4a9667bc66670904b1908b21b6 \
     --hash=sha256:ef9aff5279494b82d90e67bc68cb32b1413394346f9dea85db47ad40a2462b1a
@@ -1504,6 +1512,10 @@ pendulum==3.2.0 \
     # via
     #   apache-airflow-core
     #   apache-airflow-task-sdk
+piffle==0.7.0 \
+    --hash=sha256:00f5b9e74668e6e068ee72999158d0cf49f9c75e9b02426a1f842add9253b5c3 \
+    --hash=sha256:64a8e087c5fedccae118a15efbb33938370fd9ac1bec01ff64dfc8f5e732718f
+    # via mokelumne (pyproject.toml)
 playwright==1.58.0 \
     --hash=sha256:185e0132578733d02802dfddfbbc35f42be23a45ff49ccae5081f25952238117 \
     --hash=sha256:1e03be090e75a0fabbdaeab65ce17c308c425d879fa48bb1d7986f96bfad0b99 \
@@ -1885,6 +1897,7 @@ requests==2.33.1 \
     #   apache-airflow-core
     #   langsmith
     #   opentelemetry-exporter-otlp-proto-http
+    #   piffle
     #   pytest-base-url
     #   python-tind-client
     #   requests-toolbelt