arkindex-base-worker 0.4.0__py3-none-any.whl → 0.4.0a2__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,52 +18,21 @@ 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
 
-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"
+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"
 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
@@ -76,30 +45,6 @@ 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")
     tile_bytes = TILE.read_bytes()
@@ -218,33 +163,74 @@ def test_open_image_rotate_mirror(rotation_angle, mirrored, expected_path):
     assert _root_mean_square(expected, actual) <= 15.0
 
 
-@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],
+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],
                 [25, 224],
                 [0, 0],
                 [0, 300],
@@ -255,161 +241,136 @@ def test_open_image_rotate_mirror(rotation_angle, mirrored, expected_path):
                 [352, 259],
                 [106, 210],
                 [197, 206],
-                [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_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
-    )
-
+                [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
+        )
 
-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
-    )
+    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"])
 
 
 @pytest.mark.parametrize(
@@ -621,189 +582,3 @@ 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