Pillow/Tests/test_file_webp.py

from __future__ import annotations

import re
import sys
import warnings
from io import BytesIO
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:
        _webp.WebPDecoderVersion()
        _webp.WebPDecoderBuggyAlpha()
        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 = str(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 = BytesIO()
        hopper().save(buffer_no_args, format="WEBP")

        buffer_method = BytesIO()
        hopper().save(buffer_method, format="WEBP", method=6)
        assert buffer_no_args.getbuffer() != buffer_method.getbuffer()

    @skip_unless_feature("webp_anim")
    def test_save_all(self, tmp_path: Path) -> None:
        temp_file = str(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)

    @skip_unless_feature("webp_anim")
    def test_save_all_progress(self) -> None:
        out = BytesIO()
        progress = []

        def callback(state):
            if state["image_filename"]:
                state["image_filename"] = (
                    state["image_filename"]
                    .replace("\\", "/")
                    .split("Tests/images/")[-1]
                )
            progress.append(state)

        Image.new("RGB", (1, 1)).save(out, "WEBP", save_all=True, progress=callback)
        assert progress == [
            {
                "image_index": 0,
                "image_filename": None,
                "completed_frames": 1,
                "total_frames": 1,
            }
        ]

        out = BytesIO()
        progress = []

        with Image.open("Tests/images/iss634.webp") as im:
            im2 = Image.new("RGB", im.size)
            im.save(out, "WEBP", save_all=True, append_images=[im2], progress=callback)

        expected = []
        for i in range(42):
            expected.append(
                {
                    "image_index": 0,
                    "image_filename": "iss634.webp",
                    "completed_frames": i + 1,
                    "total_frames": 43,
                }
            )
        expected.append(
            {
                "image_index": 1,
                "image_filename": None,
                "completed_frames": 43,
                "total_frames": 43,
            }
        )
        assert progress == expected

    def test_icc_profile(self, tmp_path: Path) -> None:
        self._roundtrip(tmp_path, self.rgb_mode, 12.5, {"icc_profile": None})
        if _webp.HAVE_WEBPANIM:
            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:
        temp_file = str(tmp_path / "temp.webp")
        im = Image.new("RGB", (15000, 15000))
        with pytest.raises(ValueError) as e:
            im.save(temp_file, method=0)
        assert str(e.value) == "encoding error 6"

    def test_WebPEncode_with_invalid_args(self) -> None:
        """
        Calling encoder functions with no arguments should result in an error.
        """

        if _webp.HAVE_WEBPANIM:
            with pytest.raises(TypeError):
                _webp.WebPAnimEncoder()
        with pytest.raises(TypeError):
            _webp.WebPEncode()

    def test_WebPDecode_with_invalid_args(self) -> None:
        """
        Calling decoder functions with no arguments should result in an error.
        """

        if _webp.HAVE_WEBPANIM:
            with pytest.raises(TypeError):
                _webp.WebPAnimDecoder()
        with pytest.raises(TypeError):
            _webp.WebPDecode()

    def test_no_resource_warning(self, tmp_path: Path) -> None:
        file_path = "Tests/images/hopper.webp"
        with Image.open(file_path) as image:
            temp_file = str(tmp_path / "temp.webp")
            with warnings.catch_warnings():
                image.save(temp_file)

    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)),
    )
    @skip_unless_feature("webp_anim")
    def test_invalid_background(
        self, background: int | tuple[int, ...], tmp_path: Path
    ) -> None:
        temp_file = str(tmp_path / "temp.webp")
        im = hopper()
        with pytest.raises(OSError):
            im.save(temp_file, save_all=True, append_images=[im], background=background)

    @skip_unless_feature("webp_anim")
    def test_background_from_gif(self, tmp_path: Path) -> None:
        # Save L mode GIF with background
        with Image.open("Tests/images/no_palette_with_background.gif") as im:
            out_webp = str(tmp_path / "temp.webp")
            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
            out_webp = str(tmp_path / "temp.webp")
            im.save(out_webp, save_all=True)

        # Save as GIF
        out_gif = str(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

    @skip_unless_feature("webp_anim")
    def test_duration(self, tmp_path: Path) -> None:
        with Image.open("Tests/images/dispose_bgnd.gif") as im:
            assert im.info["duration"] == 1000

            out_webp = str(tmp_path / "temp.webp")
            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 = str(tmp_path / "temp.webp")
        im = Image.new("RGBA", (1, 1)).convert("P")
        assert im.mode == "P"
        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)