addressing PR feedback

Author: Tim Huff

pyproject.toml

@@ -9,7 +9,7 @@ packages = [
     {include = "**/*.py", from = "src"},
 ]
 readme = "README.md"
-version = "0.28.0"
+version = "0.29.0"
 
 [tool.poetry.dependencies]
 # For certifi, use ">=" instead of "^" since it upgrades its "major version" every year, not really following semver

src/groundlight/client.py

@@ -43,7 +43,7 @@
 from groundlight.binary_labels import Label, convert_internal_label_to_display
 from groundlight.config import API_TOKEN_MISSING_HELP_MESSAGE, API_TOKEN_VARIABLE_NAME, DISABLE_TLS_VARIABLE_NAME
 from groundlight.encodings import url_encode_dict
-from groundlight.images import ByteStreamWrapper, parse_supported_image_types, recompress_shrink_image
+from groundlight.images import ByteStreamWrapper, parse_supported_image_types, shrink_image_if_needed
 from groundlight.internalapi import (
     GroundlightApiClient,
     NotFoundError,
@@ -799,10 +799,10 @@ def submit_image_query(  # noqa: PLR0913 # pylint: disable=too-many-arguments, t
         detector_id = detector.id if isinstance(detector, Detector) else detector
 
         image_bytesio: ByteStreamWrapper = parse_supported_image_types(image)
-        # Match the cloud's ingest pipeline locally. Saves bandwidth and ensures Edge
-        # Endpoints, which do not run this step, see the same input distribution
-        # cloud-trained models were trained on.
-        image_bytesio = ByteStreamWrapper(data=recompress_shrink_image(image_bytesio.read()))
+        # Match the Groundlight cloud service's ingest pipeline locally. Saves bandwidth
+        # and ensures Edge Endpoints, which do not run this step, see the same input
+        # distribution cloud-trained models were trained on.
+        image_bytesio = ByteStreamWrapper(data=shrink_image_if_needed(image_bytesio.read()))
 
         params = {
             "detector_id": detector_id,

src/groundlight/images.py

@@ -7,18 +7,14 @@
 
 DEFAULT_JPEG_QUALITY = 95
 
-# The Groundlight cloud applies a recompress/shrink step on ingest. Doing the same
-# work client-side saves bandwidth and ensures Edge Endpoints, which do not run
-# this step, see the same input distribution that cloud-trained models expect.
-#
-# The constants and algorithm below mirror zuuul's implementation. Source of truth:
-#   - zuuul/janzu/apparati/imgtools.py::recompress_shrink_image
-#   - zuuul/janzu/reef_api/utils.py::_save_image (gate)
-#   - zuuul/janzu/authz/user-settings-defaults.yaml (default values)
-# If the cloud's behavior changes, update these together.
+# The Groundlight cloud service applies the same shrink-and-re-encode step on
+# ingest. Doing the same work client-side saves bandwidth and ensures Edge
+# Endpoints, which do not run this step, see the same input distribution that
+# cloud-trained models expect. Keep these constants in sync with the cloud
+# service if it ever changes its defaults.
 MAX_BYTES_IMAGE_SIZE = 256_000
 MAX_IMAGE_RESOLUTION_LONGSIDE = 1024
-RECOMPRESS_SHRINK_IMAGE_JPEG_QUALITY = 85
+SHRINK_JPEG_QUALITY = 85
 
 
 class ByteStreamWrapper(IOBase):
@@ -91,8 +87,8 @@ def bytestream_from_pil(pil_image: Image.Image, jpeg_quality: int = DEFAULT_JPEG
     return ByteStreamWrapper(data=bytesio)
 
 
-def recompress_shrink_image(jpeg: bytes) -> bytes:
-    """Shrink and re-encode an oversized JPEG to match the cloud's ingest pipeline.
+def shrink_image_if_needed(jpeg: bytes) -> bytes:
+    """Shrink an oversized JPEG to match the Groundlight cloud service's ingest pipeline.
 
     If the input is already at or below MAX_BYTES_IMAGE_SIZE, returns it unchanged.
     Otherwise, decodes the image, scales it (BICUBIC, aspect-ratio preserved) so the
@@ -109,7 +105,7 @@ def recompress_shrink_image(jpeg: bytes) -> bytes:
         new_size = (int(img.width * ratio), int(img.height * ratio))
         img = img.resize(new_size, resample=Image.Resampling.BICUBIC)
     buf = BytesIO()
-    img.save(buf, "jpeg", quality=RECOMPRESS_SHRINK_IMAGE_JPEG_QUALITY)
+    img.save(buf, "jpeg", quality=SHRINK_JPEG_QUALITY)
     return buf.getvalue()
 
 

test/integration/test_groundlight.py

@@ -374,10 +374,11 @@ def test_submit_image_query_png(gl: Groundlight, detector: Detector):
 def test_submit_image_query_shrinks_oversized_image(gl: Groundlight, detector: Detector):
     """Verifies the SDK shrinks oversized images client-side and the cloud stores the shrunken version.
 
-    Detects drift between the SDK and zuuul: if either side changes its algorithm such that
-    the cloud-stored dimensions differ from what the SDK produces locally, this test fails.
-    Does not catch zuuul becoming more permissive (the SDK would still shrink to a smaller
-    image that zuuul accepts as-is); that direction is benign and intentionally not covered.
+    Detects drift between the SDK and the cloud service: if either side changes its
+    algorithm such that the cloud-stored dimensions differ from what the SDK produces
+    locally, this test fails. Does not catch the cloud service becoming more permissive
+    (the SDK would still shrink to a smaller image that the cloud accepts as-is); that
+    direction is benign and intentionally not covered.
     """
     np.random.seed(0)
     # Random noise compresses poorly, so 3000x4000 is well above the 256 KB threshold.

test/unit/test_imagefuncs.py

@@ -91,35 +91,35 @@ def test_pil_support_ref():
 
 
 @pytest.mark.skipif(MISSING_NUMPY or MISSING_PIL, reason="Needs numpy and pillow")  # type: ignore
-def test_recompress_shrink_image_small_returns_unchanged():
+def test_shrink_image_if_needed_small_returns_unchanged():
     """Images at or below the byte threshold are passed through untouched."""
     np.random.seed(0)
     small = jpeg_from_numpy(np.random.uniform(0, 255, (200, 200, 3)))
     assert len(small) <= MAX_BYTES_IMAGE_SIZE
-    assert recompress_shrink_image(small) is small
+    assert shrink_image_if_needed(small) is small
 
 
 @pytest.mark.skipif(MISSING_NUMPY or MISSING_PIL, reason="Needs numpy and pillow")  # type: ignore
-def test_recompress_shrink_image_oversized_dimensions_get_resized():
+def test_shrink_image_if_needed_oversized_dimensions_get_resized():
     """Images above the byte threshold with longest side > 1024 are downscaled."""
     np.random.seed(0)
     # Random noise compresses poorly, so 3000x4000 easily exceeds the 256 KB threshold.
     big = jpeg_from_numpy(np.random.uniform(0, 255, (3000, 4000, 3)))
     assert len(big) > MAX_BYTES_IMAGE_SIZE
-    out = recompress_shrink_image(big)
+    out = shrink_image_if_needed(big)
     out_img = Image.open(BytesIO(out))
     # 3000x4000 scaled so longest side == 1024 preserves the 3:4 aspect ratio.
     assert out_img.size == (1024, 768)
 
 
 @pytest.mark.skipif(MISSING_NUMPY or MISSING_PIL, reason="Needs numpy and pillow")  # type: ignore
-def test_recompress_shrink_image_oversized_bytes_only_gets_reencoded():
+def test_shrink_image_if_needed_oversized_bytes_only_gets_reencoded():
     """Images above the byte threshold but with longest side <= 1024 are re-encoded only."""
     np.random.seed(0)
     arr = np.random.uniform(0, 255, (768, 1024, 3))
     high_q = jpeg_from_numpy(arr, jpeg_quality=99)
     assert len(high_q) > MAX_BYTES_IMAGE_SIZE
-    out = recompress_shrink_image(high_q)
+    out = shrink_image_if_needed(high_q)
     out_img = Image.open(BytesIO(out))
     assert out_img.size == (1024, 768)
     # Bytes changed (proves re-encode happened) and got smaller (Q85 vs Q99).