Added type hints

Tests/oss-fuzz/test_fuzzers.py

@@ -12,8 +12,9 @@ from Tests.helper import skip_unless_feature
 
 if sys.platform.startswith("win32"):
     pytest.skip("Fuzzer is linux only", allow_module_level=True)
-if features.check("libjpeg_turbo"):
+libjpeg_turbo_version = features.version("libjpeg_turbo")
-    version = packaging.version.parse(features.version("libjpeg_turbo"))
+if libjpeg_turbo_version is not None:
+    version = packaging.version.parse(libjpeg_turbo_version)
     if version.major == 2 and version.minor == 0:
         pytestmark = pytest.mark.valgrind_known_error(
             reason="Known failing with libjpeg_turbo 2.0"

Tests/test_features.py

@@ -30,7 +30,7 @@ def test_version() -> None:
     # Check the correctness of the convenience function
     # and the format of version numbers
 
-    def test(name: str, function: Callable[[str], bool]) -> None:
+    def test(name: str, function: Callable[[str], str | None]) -> None:
         version = features.version(name)
         if not features.check(name):
             assert version is None
@@ -67,12 +67,16 @@ def test_webp_anim() -> None:
 
 @skip_unless_feature("libjpeg_turbo")
 def test_libjpeg_turbo_version() -> None:
-    assert re.search(r"\d+\.\d+\.\d+$", features.version("libjpeg_turbo"))
+    version = features.version("libjpeg_turbo")
+    assert version is not None
+    assert re.search(r"\d+\.\d+\.\d+$", version)
 
 
 @skip_unless_feature("libimagequant")
 def test_libimagequant_version() -> None:
-    assert re.search(r"\d+\.\d+\.\d+$", features.version("libimagequant"))
+    version = features.version("libimagequant")
+    assert version is not None
+    assert re.search(r"\d+\.\d+\.\d+$", version)
 
 
 @pytest.mark.parametrize("feature", features.modules)

Tests/test_file_jpeg.py

@@ -70,7 +70,9 @@ class TestFileJpeg:
 
     def test_sanity(self) -> None:
         # internal version number
-        assert re.search(r"\d+\.\d+$", features.version_codec("jpg"))
+        version = features.version_codec("jpg")
+        assert version is not None
+        assert re.search(r"\d+\.\d+$", version)
 
         with Image.open(TEST_FILE) as im:
             im.load()

Tests/test_file_jpeg2k.py

@@ -48,7 +48,9 @@ def roundtrip(im: Image.Image, **options: Any) -> Image.Image:
 
 def test_sanity() -> None:
     # Internal version number
-    assert re.search(r"\d+\.\d+\.\d+$", features.version_codec("jpg_2000"))
+    version = features.version_codec("jpg_2000")
+    assert version is not None
+    assert re.search(r"\d+\.\d+\.\d+$", version)
 
     with Image.open("Tests/images/test-card-lossless.jp2") as im:
         px = im.load()

Tests/test_file_libtiff.py

@@ -52,7 +52,9 @@ class LibTiffTestCase:
 
 class TestFileLibTiff(LibTiffTestCase):
     def test_version(self) -> None:
-        assert re.search(r"\d+\.\d+\.\d+$", features.version_codec("libtiff"))
+        version = features.version_codec("libtiff")
+        assert version is not None
+        assert re.search(r"\d+\.\d+\.\d+$", version)
 
     def test_g4_tiff(self, tmp_path: Path) -> None:
         """Test the ordinary file path load path"""

Tests/test_file_png.py

@@ -85,9 +85,9 @@ class TestFilePng:
 
     def test_sanity(self, tmp_path: Path) -> None:
         # internal version number
-        assert re.search(
+        version = features.version_codec("zlib")
-            r"\d+(\.\d+){1,3}(\.zlib\-ng)?$", features.version_codec("zlib")
+        assert version is not None
-        )
+        assert re.search(r"\d+(\.\d+){1,3}(\.zlib\-ng)?$", version)
 
         test_file = str(tmp_path / "temp.png")
 

Tests/test_file_webp.py

@@ -49,7 +49,9 @@ class TestFileWebp:
     def test_version(self) -> None:
         _webp.WebPDecoderVersion()
         _webp.WebPDecoderBuggyAlpha()
-        assert re.search(r"\d+\.\d+\.\d+$", features.version_module("webp"))
+        version = features.version_module("webp")
+        assert version is not None
+        assert re.search(r"\d+\.\d+\.\d+$", version)
 
     def test_read_rgb(self) -> None:
         """

Tests/test_image_quantize.py

@@ -24,8 +24,9 @@ def test_sanity() -> None:
 def test_libimagequant_quantize() -> None:
     image = hopper()
     if is_ppc64le():
-        libimagequant = parse_version(features.version_feature("libimagequant"))
+        version = features.version_feature("libimagequant")
-        if libimagequant < parse_version("4"):
+        assert version is not None
+        if parse_version(version) < parse_version("4"):
             pytest.skip("Fails with libimagequant earlier than 4.0.0 on ppc64le")
     converted = image.quantize(100, Image.Quantize.LIBIMAGEQUANT)
     assert converted.mode == "P"

Tests/test_image_reduce.py

@@ -102,7 +102,7 @@ def test_unsupported_modes(mode: str) -> None:
 def get_image(mode: str) -> Image.Image:
     mode_info = ImageMode.getmode(mode)
     if mode_info.basetype == "L":
-        bands = [gradients_image]
+        bands: list[Image.Image] = [gradients_image]
         for _ in mode_info.bands[1:]:
             # rotate previous image
             band = bands[-1].transpose(Image.Transpose.ROTATE_90)

Tests/test_imageops_usm.py

@@ -4,11 +4,11 @@ from typing import Generator
 
 import pytest
 
-from PIL import Image, ImageFilter
+from PIL import Image, ImageFile, ImageFilter
 
 
 @pytest.fixture
-def test_images() -> Generator[dict[str, Image.Image], None, None]:
+def test_images() -> Generator[dict[str, ImageFile.ImageFile], None, None]:
     ims = {
         "im": Image.open("Tests/images/hopper.ppm"),
         "snakes": Image.open("Tests/images/color_snakes.png"),
@@ -20,7 +20,7 @@ def test_images() -> Generator[dict[str, Image.Image], None, None]:
             im.close()
 
 
-def test_filter_api(test_images: dict[str, Image.Image]) -> None:
+def test_filter_api(test_images: dict[str, ImageFile.ImageFile]) -> None:
     im = test_images["im"]
 
     test_filter = ImageFilter.GaussianBlur(2.0)
@@ -34,7 +34,7 @@ def test_filter_api(test_images: dict[str, Image.Image]) -> None:
     assert i.size == (128, 128)
 
 
-def test_usm_formats(test_images: dict[str, Image.Image]) -> None:
+def test_usm_formats(test_images: dict[str, ImageFile.ImageFile]) -> None:
     im = test_images["im"]
 
     usm = ImageFilter.UnsharpMask
@@ -52,7 +52,7 @@ def test_usm_formats(test_images: dict[str, Image.Image]) -> None:
         im.convert("YCbCr").filter(usm)
 
 
-def test_blur_formats(test_images: dict[str, Image.Image]) -> None:
+def test_blur_formats(test_images: dict[str, ImageFile.ImageFile]) -> None:
     im = test_images["im"]
 
     blur = ImageFilter.GaussianBlur
@@ -70,7 +70,7 @@ def test_blur_formats(test_images: dict[str, Image.Image]) -> None:
         im.convert("YCbCr").filter(blur)
 
 
-def test_usm_accuracy(test_images: dict[str, Image.Image]) -> None:
+def test_usm_accuracy(test_images: dict[str, ImageFile.ImageFile]) -> None:
     snakes = test_images["snakes"]
 
     src = snakes.convert("RGB")
@@ -79,7 +79,7 @@ def test_usm_accuracy(test_images: dict[str, Image.Image]) -> None:
     assert i.tobytes() == src.tobytes()
 
 
-def test_blur_accuracy(test_images: dict[str, Image.Image]) -> None:
+def test_blur_accuracy(test_images: dict[str, ImageFile.ImageFile]) -> None:
     snakes = test_images["snakes"]
 
     i = snakes.filter(ImageFilter.GaussianBlur(0.4))