from __future__ import annotations import io import re import sys import warnings from pathlib import Path from typing import Any import pytest from PIL import Image, WebPImagePlugin, features from .helper import ( assert_image_equal, assert_image_similar, assert_image_similar_tofile, hopper, skip_unless_feature, ) try: from PIL import _webp HAVE_WEBP = True except ImportError: HAVE_WEBP = False class TestUnsupportedWebp: def test_unsupported(self) -> None: if HAVE_WEBP: WebPImagePlugin.SUPPORTED = False file_path = "Tests/images/hopper.webp" with pytest.warns(UserWarning): with pytest.raises(OSError): with Image.open(file_path): pass if HAVE_WEBP: WebPImagePlugin.SUPPORTED = True @skip_unless_feature("webp") class TestFileWebp: def setup_method(self) -> None: self.rgb_mode = "RGB" def test_version(self) -> None: version = features.version_module("webp") assert version is not None assert re.search(r"\d+\.\d+\.\d+$", version) def test_read_rgb(self) -> None: """ Can we read a RGB mode WebP file without error? Does it have the bits we expect? """ with Image.open("Tests/images/hopper.webp") as image: assert image.mode == self.rgb_mode assert image.size == (128, 128) assert image.format == "WEBP" image.load() image.getdata() # generated with: # dwebp -ppm ../../Tests/images/hopper.webp -o hopper_webp_bits.ppm assert_image_similar_tofile(image, "Tests/images/hopper_webp_bits.ppm", 1.0) def _roundtrip( self, tmp_path: Path, mode: str, epsilon: float, args: dict[str, Any] = {} ) -> None: temp_file = tmp_path / "temp.webp" hopper(mode).save(temp_file, **args) with Image.open(temp_file) as image: assert image.mode == self.rgb_mode assert image.size == (128, 128) assert image.format == "WEBP" image.load() image.getdata() if mode == self.rgb_mode: # generated with: dwebp -ppm temp.webp -o hopper_webp_write.ppm assert_image_similar_tofile( image, "Tests/images/hopper_webp_write.ppm", 12.0 ) # This test asserts that the images are similar. If the average pixel # difference between the two images is less than the epsilon value, # then we're going to accept that it's a reasonable lossy version of # the image. target = hopper(mode) if mode != self.rgb_mode: target = target.convert(self.rgb_mode) assert_image_similar(image, target, epsilon) def test_write_rgb(self, tmp_path: Path) -> None: """ Can we write a RGB mode file to webp without error? Does it have the bits we expect? """ self._roundtrip(tmp_path, self.rgb_mode, 12.5) def test_write_method(self, tmp_path: Path) -> None: self._roundtrip(tmp_path, self.rgb_mode, 12.0, {"method": 6}) buffer_no_args = io.BytesIO() hopper().save(buffer_no_args, format="WEBP") buffer_method = io.BytesIO() hopper().save(buffer_method, format="WEBP", method=6) assert buffer_no_args.getbuffer() != buffer_method.getbuffer() def test_save_all(self, tmp_path: Path) -> None: temp_file = tmp_path / "temp.webp" im = Image.new("RGB", (1, 1)) im2 = Image.new("RGB", (1, 1), "#f00") im.save(temp_file, save_all=True, append_images=[im2]) with Image.open(temp_file) as reloaded: assert_image_equal(im, reloaded) reloaded.seek(1) assert_image_similar(im2, reloaded, 1) def test_icc_profile(self, tmp_path: Path) -> None: self._roundtrip(tmp_path, self.rgb_mode, 12.5, {"icc_profile": None}) self._roundtrip( tmp_path, self.rgb_mode, 12.5, {"icc_profile": None, "save_all": True} ) def test_write_unsupported_mode_L(self, tmp_path: Path) -> None: """ Saving a black-and-white file to WebP format should work, and be similar to the original file. """ self._roundtrip(tmp_path, "L", 10.0) def test_write_unsupported_mode_P(self, tmp_path: Path) -> None: """ Saving a palette-based file to WebP format should work, and be similar to the original file. """ self._roundtrip(tmp_path, "P", 50.0) @pytest.mark.skipif(sys.maxsize <= 2**32, reason="Requires 64-bit system") def test_write_encoding_error_message(self, tmp_path: Path) -> None: im = Image.new("RGB", (15000, 15000)) with pytest.raises(ValueError) as e: im.save(tmp_path / "temp.webp", method=0) assert str(e.value) == "encoding error 6" @pytest.mark.skipif(sys.maxsize <= 2**32, reason="Requires 64-bit system") def test_write_encoding_error_bad_dimension(self, tmp_path: Path) -> None: im = Image.new("L", (16384, 16384)) with pytest.raises(ValueError) as e: im.save(tmp_path / "temp.webp") assert ( str(e.value) == "encoding error 5: Image size exceeds WebP limit of 16383 pixels" ) def test_WebPEncode_with_invalid_args(self) -> None: """ Calling encoder functions with no arguments should result in an error. """ with pytest.raises(TypeError): _webp.WebPAnimEncoder() with pytest.raises(TypeError): _webp.WebPEncode() def test_WebPAnimDecoder_with_invalid_args(self) -> None: """ Calling decoder functions with no arguments should result in an error. """ with pytest.raises(TypeError): _webp.WebPAnimDecoder() def test_no_resource_warning(self, tmp_path: Path) -> None: file_path = "Tests/images/hopper.webp" with Image.open(file_path) as image: with warnings.catch_warnings(): image.save(tmp_path / "temp.webp") def test_file_pointer_could_be_reused(self) -> None: file_path = "Tests/images/hopper.webp" with open(file_path, "rb") as blob: Image.open(blob).load() Image.open(blob).load() @pytest.mark.parametrize( "background", (0, (0,), (-1, 0, 1, 2), (253, 254, 255, 256)), ) def test_invalid_background( self, background: int | tuple[int, ...], tmp_path: Path ) -> None: temp_file = tmp_path / "temp.webp" im = hopper() with pytest.raises(OSError): im.save(temp_file, save_all=True, append_images=[im], background=background) def test_background_from_gif(self, tmp_path: Path) -> None: out_webp = tmp_path / "temp.webp" # Save L mode GIF with background with Image.open("Tests/images/no_palette_with_background.gif") as im: im.save(out_webp, save_all=True) # Save P mode GIF with background with Image.open("Tests/images/chi.gif") as im: original_value = im.convert("RGB").getpixel((1, 1)) # Save as WEBP im.save(out_webp, save_all=True) # Save as GIF out_gif = tmp_path / "temp.gif" with Image.open(out_webp) as im: im.save(out_gif) with Image.open(out_gif) as reread: reread_value = reread.convert("RGB").getpixel((1, 1)) difference = sum(abs(original_value[i] - reread_value[i]) for i in range(0, 3)) assert difference < 5 def test_duration(self, tmp_path: Path) -> None: out_webp = tmp_path / "temp.webp" with Image.open("Tests/images/dispose_bgnd.gif") as im: assert im.info["duration"] == 1000 im.save(out_webp, save_all=True) with Image.open(out_webp) as reloaded: reloaded.load() assert reloaded.info["duration"] == 1000 def test_roundtrip_rgba_palette(self, tmp_path: Path) -> None: temp_file = tmp_path / "temp.webp" im = Image.new("RGBA", (1, 1)).convert("P") assert im.mode == "P" assert im.palette is not None assert im.palette.mode == "RGBA" im.save(temp_file) with Image.open(temp_file) as im: assert im.getpixel((0, 0)) == (0, 0, 0, 0)