arkindex-base-worker 0.3.7rc9__py3-none-any.whl → 0.4.0__py3-none-any.whl

tests/test_image.py

@@ -1,5 +1,5 @@
+import logging
 import math
-import unittest
 import uuid
 from io import BytesIO
 from operator import attrgetter
@@ -18,21 +18,52 @@ from arkindex_worker.image import (
     download_tiles,
     open_image,
     polygon_bounding_box,
+    resized_images,
     revert_orientation,
     trim_polygon,
+    update_pillow_image_size_limit,
     upload_image,
 )
 from arkindex_worker.models import Element
+from tests import FIXTURES_DIR
 
-FIXTURES = Path(__file__).absolute().parent / "data"
-TILE = FIXTURES / "test_image.jpg"
-FULL_IMAGE = FIXTURES / "tiled_image.jpg"
-ROTATED_IMAGE = FIXTURES / "rotated_image.jpg"
-MIRRORED_IMAGE = FIXTURES / "mirrored_image.jpg"
-ROTATED_MIRRORED_IMAGE = FIXTURES / "rotated_mirrored_image.jpg"
+TILE = FIXTURES_DIR / "test_image.jpg"
+FULL_IMAGE = FIXTURES_DIR / "tiled_image.jpg"
+ROTATED_IMAGE = FIXTURES_DIR / "rotated_image.jpg"
+MIRRORED_IMAGE = FIXTURES_DIR / "mirrored_image.jpg"
+ROTATED_MIRRORED_IMAGE = FIXTURES_DIR / "rotated_mirrored_image.jpg"
 TEST_IMAGE = {"width": 800, "height": 300}
 
 
+@pytest.fixture
+def mock_page():
+    class Page(Element):
+        def open_image(
+            self,
+            *args,
+            max_width: int | None = None,
+            max_height: int | None = None,
+            use_full_image: bool | None = False,
+            **kwargs,
+        ) -> Image.Image:
+            # Image from Socface (https://socface.site.ined.fr/) project (AD026)
+            image = Image.open(FIXTURES_DIR / "AD026_6M_00505_0001_0373.jpg")
+            image.thumbnail(size=(max_width or image.width, max_height or image.height))
+
+            return image
+
+    return Page(
+        id="page_id",
+        name="1",
+        zone={
+            "polygon": [[0, 0], [1000, 0], [1000, 3000], [0, 3000], [0, 0]],
+            "image": {"width": 1000, "height": 3000},
+        },
+        rotation_angle=0,
+        mirrored=False,
+    )
+
+
 def _root_mean_square(img_a, img_b):
     """
     Get the root-mean-square difference between two images for fuzzy matching
@@ -45,10 +76,33 @@ def _root_mean_square(img_a, img_b):
     )
 
 
+@pytest.mark.parametrize(
+    ("max_image_pixels", "expected_image_pixels"),
+    [
+        # Pillow Image size limit not updated
+        (None, Image.MAX_IMAGE_PIXELS),
+        # Pillow Image size limit set to None
+        ("0", None),
+        (0, None),
+        # Update Pillow Image size limit
+        ("1", 1),
+        (1, 1),
+    ],
+)
+def test_update_pillow_image_size_limit(max_image_pixels, expected_image_pixels):
+    MAX_IMAGE_PIXELS = Image.MAX_IMAGE_PIXELS
+
+    @update_pillow_image_size_limit
+    def function() -> int | None:
+        return Image.MAX_IMAGE_PIXELS
+
+    assert function(max_image_pixels=max_image_pixels) == expected_image_pixels
+    assert Image.MAX_IMAGE_PIXELS == MAX_IMAGE_PIXELS
+
+
 def test_download_tiles(responses):
     expected = Image.open(FULL_IMAGE).convert("RGB")
-    with TILE.open("rb") as tile:
-        tile_bytes = tile.read()
+    tile_bytes = TILE.read_bytes()
 
     responses.add(
         responses.GET,
@@ -76,9 +130,8 @@ def test_download_tiles_crop(responses):
     """
     expected = Image.open(FULL_IMAGE).convert("RGB")
     tile_bytes = BytesIO()
-    with TILE.open("rb") as tile:
-        # Add one extra pixel to each tile to return slightly bigger tiles
-        ImageOps.pad(Image.open(tile), (181, 241)).save(tile_bytes, format="jpeg")
+    # Add one extra pixel to each tile to return slightly bigger tiles
+    ImageOps.pad(Image.open(TILE), (181, 241)).save(tile_bytes, format="jpeg")
 
     tile_bytes = tile_bytes.getvalue()
 
@@ -165,74 +218,33 @@ def test_open_image_rotate_mirror(rotation_angle, mirrored, expected_path):
     assert _root_mean_square(expected, actual) <= 15.0
 
 
-class TestTrimPolygon(unittest.TestCase):
-    def test_trim_polygon_partially_outside_image(self):
-        bad_polygon = [
-            [99, 200],
-            [197, 224],
-            [120, 251],
-            [232, 350],
-            [312, 364],
-            [325, 310],
-            [318, 295],
-            [296, 260],
-            [352, 259],
-            [106, 210],
-            [197, 206],
-            [99, 200],
-        ]
-        expected_polygon = [
-            [99, 200],
-            [197, 224],
-            [120, 251],
-            [232, 300],
-            [312, 300],
-            [325, 300],
-            [318, 295],
-            [296, 260],
-            [352, 259],
-            [106, 210],
-            [197, 206],
-            [99, 200],
-        ]
-        assert (
-            trim_polygon(bad_polygon, TEST_IMAGE["width"], TEST_IMAGE["height"])
-            == expected_polygon
-        )
-
-    def test_trim_polygon_good_polygon(self):
-        good_polygon = (
-            (12, 56),
-            (29, 60),
-            (35, 61),
-            (42, 59),
-            (58, 57),
-            (65, 61),
-            (72, 57),
-            (12, 56),
-        )
-        expected_polygon = [
-            [12, 56],
-            [29, 60],
-            [35, 61],
-            [42, 59],
-            [58, 57],
-            [65, 61],
-            [72, 57],
-            [12, 56],
-        ]
-        assert (
-            trim_polygon(good_polygon, TEST_IMAGE["width"], TEST_IMAGE["height"])
-            == expected_polygon
-        )
-
-    def test_trim_polygon_invalid_polygon(self):
-        """
-        An assertion error is raised the polygon input isn't a list or tuple
-        """
-        bad_polygon = {
-            "polygon": [
-                [99, 200],
+@pytest.mark.parametrize(
+    ("polygon", "error"),
+    [
+        # Polygon input isn't a list or tuple
+        (
+            {
+                "polygon": [
+                    [99, 200],
+                    [25, 224],
+                    [0, 0],
+                    [0, 300],
+                    [102, 300],
+                    [260, 300],
+                    [288, 295],
+                    [296, 260],
+                    [352, 259],
+                    [106, 210],
+                    [197, 206],
+                    [99, 208],
+                ]
+            },
+            "Input polygon must be a valid list or tuple of points.",
+        ),
+        # Point coordinates are not integers
+        (
+            [
+                [9.9, 200],
                 [25, 224],
                 [0, 0],
                 [0, 300],
@@ -243,136 +255,161 @@ class TestTrimPolygon(unittest.TestCase):
                 [352, 259],
                 [106, 210],
                 [197, 206],
-                [99, 208],
-            ]
-        }
-        with pytest.raises(
-            AssertionError,
-            match="Input polygon must be a valid list or tuple of points.",
-        ):
-            trim_polygon(bad_polygon, TEST_IMAGE["width"], TEST_IMAGE["height"])
-
-    def test_trim_polygon_negative_coordinates(self):
-        """
-        Negative coordinates are ignored and replaced by 0 with no error being thrown
-        """
-        bad_polygon = [
-            [99, 200],
-            [25, 224],
-            [-8, -52],
-            [-12, 350],
-            [102, 364],
-            [260, 310],
-            [288, 295],
-            [296, 260],
-            [352, 259],
-            [106, 210],
-            [197, 206],
-            [99, 200],
-        ]
-        expected_polygon = [
-            [99, 200],
-            [25, 224],
-            [0, 0],
-            [0, 300],
-            [102, 300],
-            [260, 300],
-            [288, 295],
-            [296, 260],
-            [352, 259],
-            [106, 210],
-            [197, 206],
-            [99, 200],
-        ]
-        assert (
-            trim_polygon(bad_polygon, TEST_IMAGE["width"], TEST_IMAGE["height"])
-            == expected_polygon
-        )
+                [99, 20.8],
+            ],
+            "Polygon point coordinates must be integers.",
+        ),
+        # Point coordinates are not lists or tuples
+        (
+            [
+                [12, 56],
+                [29, 60],
+                [35, 61],
+                "[42, 59]",
+                [58, 57],
+                [65, 61],
+                [72, 57],
+                [12, 56],
+            ],
+            "Polygon points must be tuples or lists.",
+        ),
+        # Point coordinates are not lists or tuples of length 2
+        (
+            [
+                [12, 56],
+                [29, 60, 3],
+                [35, 61],
+                [42, 59],
+                [58, 57],
+                [65, 61],
+                [72, 57],
+                [12, 56],
+            ],
+            "Polygon points must be tuples or lists of 2 elements.",
+        ),
+        # None of the polygon's points are inside the image
+        (
+            [
+                [999, 200],
+                [1097, 224],
+                [1020, 251],
+                [1232, 350],
+                [1312, 364],
+                [1325, 310],
+                [1318, 295],
+                [1296, 260],
+                [1352, 259],
+                [1006, 210],
+                [997, 206],
+                [999, 200],
+            ],
+            "This polygon is entirely outside the image's bounds.",
+        ),
+    ],
+)
+def test_trim_polygon_errors(polygon, error):
+    with pytest.raises(AssertionError, match=error):
+        trim_polygon(polygon, TEST_IMAGE["width"], TEST_IMAGE["height"])
+
+
+def test_trim_polygon_negative_coordinates():
+    """
+    Negative coordinates are ignored and replaced by 0 with no error being thrown
+    """
+    polygon = [
+        [99, 200],
+        [25, 224],
+        [-8, -52],
+        [-12, 350],
+        [102, 364],
+        [260, 310],
+        [288, 295],
+        [296, 260],
+        [352, 259],
+        [106, 210],
+        [197, 206],
+        [99, 200],
+    ]
+    expected_polygon = [
+        [99, 200],
+        [25, 224],
+        [0, 0],
+        [0, 300],
+        [102, 300],
+        [260, 300],
+        [288, 295],
+        [296, 260],
+        [352, 259],
+        [106, 210],
+        [197, 206],
+        [99, 200],
+    ]
+    assert (
+        trim_polygon(polygon, TEST_IMAGE["width"], TEST_IMAGE["height"])
+        == expected_polygon
+    )
 
-    def test_trim_polygon_outside_image_error(self):
-        """
-        An assertion error is raised when none of the polygon's points are inside the image
-        """
-        bad_polygon = [
-            [999, 200],
-            [1097, 224],
-            [1020, 251],
-            [1232, 350],
-            [1312, 364],
-            [1325, 310],
-            [1318, 295],
-            [1296, 260],
-            [1352, 259],
-            [1006, 210],
-            [997, 206],
-            [999, 200],
-        ]
-        with pytest.raises(
-            AssertionError, match="This polygon is entirely outside the image's bounds."
-        ):
-            trim_polygon(bad_polygon, TEST_IMAGE["width"], TEST_IMAGE["height"])
-
-    def test_trim_polygon_float_coordinates(self):
-        """
-        An assertion error is raised when point coordinates are not integers
-        """
-        bad_polygon = [
-            [9.9, 200],
-            [25, 224],
-            [0, 0],
-            [0, 300],
-            [102, 300],
-            [260, 300],
-            [288, 295],
-            [296, 260],
-            [352, 259],
-            [106, 210],
-            [197, 206],
-            [99, 20.8],
-        ]
-        with pytest.raises(
-            AssertionError, match="Polygon point coordinates must be integers."
-        ):
-            trim_polygon(bad_polygon, TEST_IMAGE["width"], TEST_IMAGE["height"])
-
-    def test_trim_polygon_invalid_points_1(self):
-        """
-        An assertion error is raised when point coordinates are not lists or tuples
-        """
-        bad_polygon = [
-            [12, 56],
-            [29, 60],
-            [35, 61],
-            "[42, 59]",
-            [58, 57],
-            [65, 61],
-            [72, 57],
-            [12, 56],
-        ]
-        with pytest.raises(
-            AssertionError, match="Polygon points must be tuples or lists."
-        ):
-            trim_polygon(bad_polygon, TEST_IMAGE["width"], TEST_IMAGE["height"])
-
-    def test_trim_polygon_invalid_points_2(self):
-        """
-        An assertion error is raised when point coordinates are not lists or tuples of length 2
-        """
-        bad_polygon = [
-            [12, 56],
-            [29, 60, 3],
-            [35, 61],
-            [42, 59],
-            [58, 57],
-            [65, 61],
-            [72, 57],
-            [12, 56],
-        ]
-        with pytest.raises(
-            AssertionError,
-            match="Polygon points must be tuples or lists of 2 elements.",
-        ):
-            trim_polygon(bad_polygon, TEST_IMAGE["width"], TEST_IMAGE["height"])
+
+def test_trim_polygon_partially_outside_image():
+    polygon = [
+        [99, 200],
+        [197, 224],
+        [120, 251],
+        [232, 350],
+        [312, 364],
+        [325, 310],
+        [318, 295],
+        [296, 260],
+        [352, 259],
+        [106, 210],
+        [197, 206],
+        [99, 200],
+    ]
+    expected_polygon = [
+        [99, 200],
+        [197, 224],
+        [120, 251],
+        [232, 300],
+        [312, 300],
+        [325, 300],
+        [318, 295],
+        [296, 260],
+        [352, 259],
+        [106, 210],
+        [197, 206],
+        [99, 200],
+    ]
+    assert (
+        trim_polygon(polygon, TEST_IMAGE["width"], TEST_IMAGE["height"])
+        == expected_polygon
+    )
+
+
+def test_trim_polygon():
+    polygon = (
+        (12, 56),
+        (29, 60),
+        (35, 61),
+        (42, 59),
+        (58, 57),
+        (65, 61),
+        (72, 57),
+        (12, 56),
+    )
+    expected_polygon = [
+        [12, 56],
+        [29, 60],
+        [35, 61],
+        [42, 59],
+        [58, 57],
+        [65, 61],
+        [72, 57],
+        [12, 56],
+    ]
+    assert (
+        trim_polygon(polygon, TEST_IMAGE["width"], TEST_IMAGE["height"])
+        == expected_polygon
+    )
 
 
 @pytest.mark.parametrize(
@@ -584,3 +621,189 @@ def test_upload_image(responses):
 
     assert len(responses.calls) == 1
     assert list(map(attrgetter("request.url"), responses.calls)) == [dest_url]
+
+
+@pytest.mark.parametrize(
+    ("max_pixels", "max_bytes", "expected_sizes", "expected_logs"),
+    [
+        # No limits
+        (
+            None,
+            None,
+            [
+                (1992, 3000),
+                (1793, 2700),
+                (1694, 2550),
+                (1594, 2400),
+                (1494, 2250),
+                (1395, 2100),
+                (1195, 1800),
+                (996, 1500),
+                (797, 1200),
+                (598, 900),
+            ],
+            [
+                (logging.WARNING, "The image was resized to (1992 x 3000)."),
+                (logging.WARNING, "The image was resized to (1793 x 2700)."),
+                (logging.WARNING, "The image was resized to (1694 x 2550)."),
+                (logging.WARNING, "The image was resized to (1594 x 2400)."),
+                (logging.WARNING, "The image was resized to (1494 x 2250)."),
+                (logging.WARNING, "The image was resized to (1395 x 2100)."),
+                (logging.WARNING, "The image was resized to (1195 x 1800)."),
+                (logging.WARNING, "The image was resized to (996 x 1500)."),
+                (logging.WARNING, "The image was resized to (797 x 1200)."),
+                (logging.WARNING, "The image was resized to (598 x 900)."),
+            ],
+        ),
+        # Image already under the limits
+        (
+            10000,
+            4000000,  # 4MB
+            [
+                (1992, 3000),
+                (1793, 2700),
+                (1694, 2550),
+                (1594, 2400),
+                (1494, 2250),
+                (1395, 2100),
+                (1195, 1800),
+                (996, 1500),
+                (797, 1200),
+                (598, 900),
+            ],
+            [
+                (logging.WARNING, "The image was resized to (1992 x 3000)."),
+                (logging.WARNING, "The image was resized to (1793 x 2700)."),
+                (logging.WARNING, "The image was resized to (1694 x 2550)."),
+                (logging.WARNING, "The image was resized to (1594 x 2400)."),
+                (logging.WARNING, "The image was resized to (1494 x 2250)."),
+                (logging.WARNING, "The image was resized to (1395 x 2100)."),
+                (logging.WARNING, "The image was resized to (1195 x 1800)."),
+                (logging.WARNING, "The image was resized to (996 x 1500)."),
+                (logging.WARNING, "The image was resized to (797 x 1200)."),
+                (logging.WARNING, "The image was resized to (598 x 900)."),
+            ],
+        ),
+        # Image above the limits
+        (
+            None,
+            100000,  # 100kB
+            [(598, 900)],
+            [
+                (logging.WARNING, "The image was resized to (1992 x 3000)."),
+                (logging.WARNING, "The image size is 773.4 kB."),
+                (logging.WARNING, "Maximum image input size supported is 100.0 kB."),
+                (logging.WARNING, "The image will be resized."),
+                (logging.WARNING, "The image was resized to (1793 x 2700)."),
+                (logging.WARNING, "The image size is 616.0 kB."),
+                (logging.WARNING, "Maximum image input size supported is 100.0 kB."),
+                (logging.WARNING, "The image will be resized."),
+                (logging.WARNING, "The image was resized to (1694 x 2550)."),
+                (logging.WARNING, "The image size is 546.4 kB."),
+                (logging.WARNING, "Maximum image input size supported is 100.0 kB."),
+                (logging.WARNING, "The image will be resized."),
+                (logging.WARNING, "The image was resized to (1594 x 2400)."),
+                (logging.WARNING, "The image size is 479.4 kB."),
+                (logging.WARNING, "Maximum image input size supported is 100.0 kB."),
+                (logging.WARNING, "The image will be resized."),
+                (logging.WARNING, "The image was resized to (1494 x 2250)."),
+                (logging.WARNING, "The image size is 416.1 kB."),
+                (logging.WARNING, "Maximum image input size supported is 100.0 kB."),
+                (logging.WARNING, "The image will be resized."),
+                (logging.WARNING, "The image was resized to (1395 x 2100)."),
+                (logging.WARNING, "The image size is 360.5 kB."),
+                (logging.WARNING, "Maximum image input size supported is 100.0 kB."),
+                (logging.WARNING, "The image will be resized."),
+                (logging.WARNING, "The image was resized to (1195 x 1800)."),
+                (logging.WARNING, "The image size is 258.6 kB."),
+                (logging.WARNING, "Maximum image input size supported is 100.0 kB."),
+                (logging.WARNING, "The image will be resized."),
+                (logging.WARNING, "The image was resized to (996 x 1500)."),
+                (logging.WARNING, "The image size is 179.0 kB."),
+                (logging.WARNING, "Maximum image input size supported is 100.0 kB."),
+                (logging.WARNING, "The image will be resized."),
+                (logging.WARNING, "The image was resized to (797 x 1200)."),
+                (logging.WARNING, "The image size is 115.7 kB."),
+                (logging.WARNING, "Maximum image input size supported is 100.0 kB."),
+                (logging.WARNING, "The image will be resized."),
+                (logging.WARNING, "The image was resized to (598 x 900)."),
+            ],
+        ),
+        # Image above the limits
+        (
+            2000,
+            None,
+            [(1328, 2000), (1195, 1800), (996, 1500), (797, 1200), (598, 900)],
+            [
+                (
+                    logging.WARNING,
+                    "Maximum image input size supported is (2000 x 2000).",
+                ),
+                (logging.WARNING, "The image will be resized."),
+                (logging.WARNING, "The image was resized to (1328 x 2000)."),
+                (logging.WARNING, "The image was resized to (1195 x 1800)."),
+                (logging.WARNING, "The image was resized to (996 x 1500)."),
+                (logging.WARNING, "The image was resized to (797 x 1200)."),
+                (logging.WARNING, "The image was resized to (598 x 900)."),
+            ],
+        ),
+        # Image above the limits
+        (
+            2000,
+            100000,  # 100kB
+            [(598, 900)],
+            [
+                (
+                    logging.WARNING,
+                    "Maximum image input size supported is (2000 x 2000).",
+                ),
+                (logging.WARNING, "The image will be resized."),
+                (logging.WARNING, "The image was resized to (1328 x 2000)."),
+                (logging.WARNING, "The image size is 325.5 kB."),
+                (logging.WARNING, "Maximum image input size supported is 100.0 kB."),
+                (logging.WARNING, "The image will be resized."),
+                (logging.WARNING, "The image was resized to (1195 x 1800)."),
+                (logging.WARNING, "The image size is 258.6 kB."),
+                (logging.WARNING, "Maximum image input size supported is 100.0 kB."),
+                (logging.WARNING, "The image will be resized."),
+                (logging.WARNING, "The image was resized to (996 x 1500)."),
+                (logging.WARNING, "The image size is 179.0 kB."),
+                (logging.WARNING, "Maximum image input size supported is 100.0 kB."),
+                (logging.WARNING, "The image will be resized."),
+                (logging.WARNING, "The image was resized to (797 x 1200)."),
+                (logging.WARNING, "The image size is 115.7 kB."),
+                (logging.WARNING, "Maximum image input size supported is 100.0 kB."),
+                (logging.WARNING, "The image will be resized."),
+                (logging.WARNING, "The image was resized to (598 x 900)."),
+            ],
+        ),
+        # Image always above the limits
+        (
+            50,
+            50,  # 50B
+            [],
+            [
+                (logging.WARNING, "Maximum image input size supported is (50 x 50)."),
+                (logging.WARNING, "The image will be resized."),
+                (logging.WARNING, "The image was resized to (33 x 50)."),
+                (logging.WARNING, "The image size is 1.0 kB."),
+                (logging.WARNING, "Maximum image input size supported is 50 Bytes."),
+                (logging.WARNING, "The image will be resized."),
+            ],
+        ),
+    ],
+)
+def test_resized_images(
+    max_pixels, max_bytes, expected_sizes, expected_logs, mock_page, caplog
+):
+    caplog.set_level(logging.WARNING)
+
+    assert [
+        Image.open(image).size
+        for image in resized_images(
+            element=mock_page, max_pixels=max_pixels, max_bytes=max_bytes
+        )
+    ] == expected_sizes
+    assert [
+        (record.levelno, record.message) for record in caplog.records
+    ] == expected_logs