Add files using upload-large-folder tool

.venv/lib/python3.12/site-packages/MarkupSafe-3.0.2.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

.venv/lib/python3.12/site-packages/MarkupSafe-3.0.2.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.2.0)
+Root-Is-Purelib: false
+Tag: cp312-cp312-manylinux_2_17_x86_64
+Tag: cp312-cp312-manylinux2014_x86_64
+

.venv/lib/python3.12/site-packages/PIL/AvifImagePlugin.py

@@ -0,0 +1,291 @@
+from __future__ import annotations
+
+import os
+from io import BytesIO
+from typing import IO
+
+from . import ExifTags, Image, ImageFile
+
+try:
+    from . import _avif
+
+    SUPPORTED = True
+except ImportError:
+    SUPPORTED = False
+
+# Decoder options as module globals, until there is a way to pass parameters
+# to Image.open (see https://github.com/python-pillow/Pillow/issues/569)
+DECODE_CODEC_CHOICE = "auto"
+DEFAULT_MAX_THREADS = 0
+
+
+def get_codec_version(codec_name: str) -> str | None:
+    versions = _avif.codec_versions()
+    for version in versions.split(", "):
+        if version.split(" [")[0] == codec_name:
+            return version.split(":")[-1].split(" ")[0]
+    return None
+
+
+def _accept(prefix: bytes) -> bool | str:
+    if prefix[4:8] != b"ftyp":
+        return False
+    major_brand = prefix[8:12]
+    if major_brand in (
+        # coding brands
+        b"avif",
+        b"avis",
+        # We accept files with AVIF container brands; we can't yet know if
+        # the ftyp box has the correct compatible brands, but if it doesn't
+        # then the plugin will raise a SyntaxError which Pillow will catch
+        # before moving on to the next plugin that accepts the file.
+        #
+        # Also, because this file might not actually be an AVIF file, we
+        # don't raise an error if AVIF support isn't properly compiled.
+        b"mif1",
+        b"msf1",
+    ):
+        if not SUPPORTED:
+            return (
+                "image file could not be identified because AVIF support not installed"
+            )
+        return True
+    return False
+
+
+def _get_default_max_threads() -> int:
+    if DEFAULT_MAX_THREADS:
+        return DEFAULT_MAX_THREADS
+    if hasattr(os, "sched_getaffinity"):
+        return len(os.sched_getaffinity(0))
+    else:
+        return os.cpu_count() or 1
+
+
+class AvifImageFile(ImageFile.ImageFile):
+    format = "AVIF"
+    format_description = "AVIF image"
+    __frame = -1
+
+    def _open(self) -> None:
+        if not SUPPORTED:
+            msg = "image file could not be opened because AVIF support not installed"
+            raise SyntaxError(msg)
+
+        if DECODE_CODEC_CHOICE != "auto" and not _avif.decoder_codec_available(
+            DECODE_CODEC_CHOICE
+        ):
+            msg = "Invalid opening codec"
+            raise ValueError(msg)
+        self._decoder = _avif.AvifDecoder(
+            self.fp.read(),
+            DECODE_CODEC_CHOICE,
+            _get_default_max_threads(),
+        )
+
+        # Get info from decoder
+        self._size, self.n_frames, self._mode, icc, exif, exif_orientation, xmp = (
+            self._decoder.get_info()
+        )
+        self.is_animated = self.n_frames > 1
+
+        if icc:
+            self.info["icc_profile"] = icc
+        if xmp:
+            self.info["xmp"] = xmp
+
+        if exif_orientation != 1 or exif:
+            exif_data = Image.Exif()
+            if exif:
+                exif_data.load(exif)
+                original_orientation = exif_data.get(ExifTags.Base.Orientation, 1)
+            else:
+                original_orientation = 1
+            if exif_orientation != original_orientation:
+                exif_data[ExifTags.Base.Orientation] = exif_orientation
+                exif = exif_data.tobytes()
+        if exif:
+            self.info["exif"] = exif
+        self.seek(0)
+
+    def seek(self, frame: int) -> None:
+        if not self._seek_check(frame):
+            return
+
+        # Set tile
+        self.__frame = frame
+        self.tile = [ImageFile._Tile("raw", (0, 0) + self.size, 0, self.mode)]
+
+    def load(self) -> Image.core.PixelAccess | None:
+        if self.tile:
+            # We need to load the image data for this frame
+            data, timescale, pts_in_timescales, duration_in_timescales = (
+                self._decoder.get_frame(self.__frame)
+            )
+            self.info["timestamp"] = round(1000 * (pts_in_timescales / timescale))
+            self.info["duration"] = round(1000 * (duration_in_timescales / timescale))
+
+            if self.fp and self._exclusive_fp:
+                self.fp.close()
+            self.fp = BytesIO(data)
+
+        return super().load()
+
+    def load_seek(self, pos: int) -> None:
+        pass
+
+    def tell(self) -> int:
+        return self.__frame
+
+
+def _save_all(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    _save(im, fp, filename, save_all=True)
+
+
+def _save(
+    im: Image.Image, fp: IO[bytes], filename: str | bytes, save_all: bool = False
+) -> None:
+    info = im.encoderinfo.copy()
+    if save_all:
+        append_images = list(info.get("append_images", []))
+    else:
+        append_images = []
+
+    total = 0
+    for ims in [im] + append_images:
+        total += getattr(ims, "n_frames", 1)
+
+    quality = info.get("quality", 75)
+    if not isinstance(quality, int) or quality < 0 or quality > 100:
+        msg = "Invalid quality setting"
+        raise ValueError(msg)
+
+    duration = info.get("duration", 0)
+    subsampling = info.get("subsampling", "4:2:0")
+    speed = info.get("speed", 6)
+    max_threads = info.get("max_threads", _get_default_max_threads())
+    codec = info.get("codec", "auto")
+    if codec != "auto" and not _avif.encoder_codec_available(codec):
+        msg = "Invalid saving codec"
+        raise ValueError(msg)
+    range_ = info.get("range", "full")
+    tile_rows_log2 = info.get("tile_rows", 0)
+    tile_cols_log2 = info.get("tile_cols", 0)
+    alpha_premultiplied = bool(info.get("alpha_premultiplied", False))
+    autotiling = bool(info.get("autotiling", tile_rows_log2 == tile_cols_log2 == 0))
+
+    icc_profile = info.get("icc_profile", im.info.get("icc_profile"))
+    exif_orientation = 1
+    if exif := info.get("exif"):
+        if isinstance(exif, Image.Exif):
+            exif_data = exif
+        else:
+            exif_data = Image.Exif()
+            exif_data.load(exif)
+        if ExifTags.Base.Orientation in exif_data:
+            exif_orientation = exif_data.pop(ExifTags.Base.Orientation)
+            exif = exif_data.tobytes() if exif_data else b""
+        elif isinstance(exif, Image.Exif):
+            exif = exif_data.tobytes()
+
+    xmp = info.get("xmp")
+
+    if isinstance(xmp, str):
+        xmp = xmp.encode("utf-8")
+
+    advanced = info.get("advanced")
+    if advanced is not None:
+        if isinstance(advanced, dict):
+            advanced = advanced.items()
+        try:
+            advanced = tuple(advanced)
+        except TypeError:
+            invalid = True
+        else:
+            invalid = any(not isinstance(v, tuple) or len(v) != 2 for v in advanced)
+        if invalid:
+            msg = (
+                "advanced codec options must be a dict of key-value string "
+                "pairs or a series of key-value two-tuples"
+            )
+            raise ValueError(msg)
+
+    # Setup the AVIF encoder
+    enc = _avif.AvifEncoder(
+        im.size,
+        subsampling,
+        quality,
+        speed,
+        max_threads,
+        codec,
+        range_,
+        tile_rows_log2,
+        tile_cols_log2,
+        alpha_premultiplied,
+        autotiling,
+        icc_profile or b"",
+        exif or b"",
+        exif_orientation,
+        xmp or b"",
+        advanced,
+    )
+
+    # Add each frame
+    frame_idx = 0
+    frame_duration = 0
+    cur_idx = im.tell()
+    is_single_frame = total == 1
+    try:
+        for ims in [im] + append_images:
+            # Get number of frames in this image
+            nfr = getattr(ims, "n_frames", 1)
+
+            for idx in range(nfr):
+                ims.seek(idx)
+
+                # Make sure image mode is supported
+                frame = ims
+                rawmode = ims.mode
+                if ims.mode not in {"RGB", "RGBA"}:
+                    rawmode = "RGBA" if ims.has_transparency_data else "RGB"
+                    frame = ims.convert(rawmode)
+
+                # Update frame duration
+                if isinstance(duration, (list, tuple)):
+                    frame_duration = duration[frame_idx]
+                else:
+                    frame_duration = duration
+
+                # Append the frame to the animation encoder
+                enc.add(
+                    frame.tobytes("raw", rawmode),
+                    frame_duration,
+                    frame.size,
+                    rawmode,
+                    is_single_frame,
+                )
+
+                # Update frame index
+                frame_idx += 1
+
+                if not save_all:
+                    break
+
+    finally:
+        im.seek(cur_idx)
+
+    # Get the final output from the encoder
+    data = enc.finish()
+    if data is None:
+        msg = "cannot write file as AVIF (encoder returned None)"
+        raise OSError(msg)
+
+    fp.write(data)
+
+
+Image.register_open(AvifImageFile.format, AvifImageFile, _accept)
+if SUPPORTED:
+    Image.register_save(AvifImageFile.format, _save)
+    Image.register_save_all(AvifImageFile.format, _save_all)
+    Image.register_extensions(AvifImageFile.format, [".avif", ".avifs"])
+    Image.register_mime(AvifImageFile.format, "image/avif")

.venv/lib/python3.12/site-packages/PIL/BdfFontFile.py

@@ -0,0 +1,122 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# bitmap distribution font (bdf) file parser
+#
+# history:
+# 1996-05-16 fl   created (as bdf2pil)
+# 1997-08-25 fl   converted to FontFile driver
+# 2001-05-25 fl   removed bogus __init__ call
+# 2002-11-20 fl   robustification (from Kevin Cazabon, Dmitry Vasiliev)
+# 2003-04-22 fl   more robustification (from Graham Dumpleton)
+#
+# Copyright (c) 1997-2003 by Secret Labs AB.
+# Copyright (c) 1997-2003 by Fredrik Lundh.
+#
+# See the README file for information on usage and redistribution.
+#
+
+"""
+Parse X Bitmap Distribution Format (BDF)
+"""
+from __future__ import annotations
+
+from typing import BinaryIO
+
+from . import FontFile, Image
+
+
+def bdf_char(
+    f: BinaryIO,
+) -> (
+    tuple[
+        str,
+        int,
+        tuple[tuple[int, int], tuple[int, int, int, int], tuple[int, int, int, int]],
+        Image.Image,
+    ]
+    | None
+):
+    # skip to STARTCHAR
+    while True:
+        s = f.readline()
+        if not s:
+            return None
+        if s.startswith(b"STARTCHAR"):
+            break
+    id = s[9:].strip().decode("ascii")
+
+    # load symbol properties
+    props = {}
+    while True:
+        s = f.readline()
+        if not s or s.startswith(b"BITMAP"):
+            break
+        i = s.find(b" ")
+        props[s[:i].decode("ascii")] = s[i + 1 : -1].decode("ascii")
+
+    # load bitmap
+    bitmap = bytearray()
+    while True:
+        s = f.readline()
+        if not s or s.startswith(b"ENDCHAR"):
+            break
+        bitmap += s[:-1]
+
+    # The word BBX
+    # followed by the width in x (BBw), height in y (BBh),
+    # and x and y displacement (BBxoff0, BByoff0)
+    # of the lower left corner from the origin of the character.
+    width, height, x_disp, y_disp = (int(p) for p in props["BBX"].split())
+
+    # The word DWIDTH
+    # followed by the width in x and y of the character in device pixels.
+    dwx, dwy = (int(p) for p in props["DWIDTH"].split())
+
+    bbox = (
+        (dwx, dwy),
+        (x_disp, -y_disp - height, width + x_disp, -y_disp),
+        (0, 0, width, height),
+    )
+
+    try:
+        im = Image.frombytes("1", (width, height), bitmap, "hex", "1")
+    except ValueError:
+        # deal with zero-width characters
+        im = Image.new("1", (width, height))
+
+    return id, int(props["ENCODING"]), bbox, im
+
+
+class BdfFontFile(FontFile.FontFile):
+    """Font file plugin for the X11 BDF format."""
+
+    def __init__(self, fp: BinaryIO) -> None:
+        super().__init__()
+
+        s = fp.readline()
+        if not s.startswith(b"STARTFONT 2.1"):
+            msg = "not a valid BDF file"
+            raise SyntaxError(msg)
+
+        props = {}
+        comments = []
+
+        while True:
+            s = fp.readline()
+            if not s or s.startswith(b"ENDPROPERTIES"):
+                break
+            i = s.find(b" ")
+            props[s[:i].decode("ascii")] = s[i + 1 : -1].decode("ascii")
+            if s[:i] in [b"COMMENT", b"COPYRIGHT"]:
+                if s.find(b"LogicalFontDescription") < 0:
+                    comments.append(s[i + 1 : -1].decode("ascii"))
+
+        while True:
+            c = bdf_char(fp)
+            if not c:
+                break
+            id, ch, (xy, dst, src), im = c
+            if 0 <= ch < len(self.glyph):
+                self.glyph[ch] = xy, dst, src, im

.venv/lib/python3.12/site-packages/PIL/BlpImagePlugin.py

@@ -0,0 +1,497 @@
+"""
+Blizzard Mipmap Format (.blp)
+Jerome Leclanche <jerome@leclan.ch>
+
+The contents of this file are hereby released in the public domain (CC0)
+Full text of the CC0 license:
+  https://creativecommons.org/publicdomain/zero/1.0/
+
+BLP1 files, used mostly in Warcraft III, are not fully supported.
+All types of BLP2 files used in World of Warcraft are supported.
+
+The BLP file structure consists of a header, up to 16 mipmaps of the
+texture
+
+Texture sizes must be powers of two, though the two dimensions do
+not have to be equal; 512x256 is valid, but 512x200 is not.
+The first mipmap (mipmap #0) is the full size image; each subsequent
+mipmap halves both dimensions. The final mipmap should be 1x1.
+
+BLP files come in many different flavours:
+* JPEG-compressed (type == 0) - only supported for BLP1.
+* RAW images (type == 1, encoding == 1). Each mipmap is stored as an
+  array of 8-bit values, one per pixel, left to right, top to bottom.
+  Each value is an index to the palette.
+* DXT-compressed (type == 1, encoding == 2):
+- DXT1 compression is used if alpha_encoding == 0.
+  - An additional alpha bit is used if alpha_depth == 1.
+  - DXT3 compression is used if alpha_encoding == 1.
+  - DXT5 compression is used if alpha_encoding == 7.
+"""
+
+from __future__ import annotations
+
+import abc
+import os
+import struct
+from enum import IntEnum
+from io import BytesIO
+from typing import IO
+
+from . import Image, ImageFile
+
+
+class Format(IntEnum):
+    JPEG = 0
+
+
+class Encoding(IntEnum):
+    UNCOMPRESSED = 1
+    DXT = 2
+    UNCOMPRESSED_RAW_BGRA = 3
+
+
+class AlphaEncoding(IntEnum):
+    DXT1 = 0
+    DXT3 = 1
+    DXT5 = 7
+
+
+def unpack_565(i: int) -> tuple[int, int, int]:
+    return ((i >> 11) & 0x1F) << 3, ((i >> 5) & 0x3F) << 2, (i & 0x1F) << 3
+
+
+def decode_dxt1(
+    data: bytes, alpha: bool = False
+) -> tuple[bytearray, bytearray, bytearray, bytearray]:
+    """
+    input: one "row" of data (i.e. will produce 4*width pixels)
+    """
+
+    blocks = len(data) // 8  # number of blocks in row
+    ret = (bytearray(), bytearray(), bytearray(), bytearray())
+
+    for block_index in range(blocks):
+        # Decode next 8-byte block.
+        idx = block_index * 8
+        color0, color1, bits = struct.unpack_from("<HHI", data, idx)
+
+        r0, g0, b0 = unpack_565(color0)
+        r1, g1, b1 = unpack_565(color1)
+
+        # Decode this block into 4x4 pixels
+        # Accumulate the results onto our 4 row accumulators
+        for j in range(4):
+            for i in range(4):
+                # get next control op and generate a pixel
+
+                control = bits & 3
+                bits = bits >> 2
+
+                a = 0xFF
+                if control == 0:
+                    r, g, b = r0, g0, b0
+                elif control == 1:
+                    r, g, b = r1, g1, b1
+                elif control == 2:
+                    if color0 > color1:
+                        r = (2 * r0 + r1) // 3
+                        g = (2 * g0 + g1) // 3
+                        b = (2 * b0 + b1) // 3
+                    else:
+                        r = (r0 + r1) // 2
+                        g = (g0 + g1) // 2
+                        b = (b0 + b1) // 2
+                elif control == 3:
+                    if color0 > color1:
+                        r = (2 * r1 + r0) // 3
+                        g = (2 * g1 + g0) // 3
+                        b = (2 * b1 + b0) // 3
+                    else:
+                        r, g, b, a = 0, 0, 0, 0
+
+                if alpha:
+                    ret[j].extend([r, g, b, a])
+                else:
+                    ret[j].extend([r, g, b])
+
+    return ret
+
+
+def decode_dxt3(data: bytes) -> tuple[bytearray, bytearray, bytearray, bytearray]:
+    """
+    input: one "row" of data (i.e. will produce 4*width pixels)
+    """
+
+    blocks = len(data) // 16  # number of blocks in row
+    ret = (bytearray(), bytearray(), bytearray(), bytearray())
+
+    for block_index in range(blocks):
+        idx = block_index * 16
+        block = data[idx : idx + 16]
+        # Decode next 16-byte block.
+        bits = struct.unpack_from("<8B", block)
+        color0, color1 = struct.unpack_from("<HH", block, 8)
+
+        (code,) = struct.unpack_from("<I", block, 12)
+
+        r0, g0, b0 = unpack_565(color0)
+        r1, g1, b1 = unpack_565(color1)
+
+        for j in range(4):
+            high = False  # Do we want the higher bits?
+            for i in range(4):
+                alphacode_index = (4 * j + i) // 2
+                a = bits[alphacode_index]
+                if high:
+                    high = False
+                    a >>= 4
+                else:
+                    high = True
+                    a &= 0xF
+                a *= 17  # We get a value between 0 and 15
+
+                color_code = (code >> 2 * (4 * j + i)) & 0x03
+
+                if color_code == 0:
+                    r, g, b = r0, g0, b0
+                elif color_code == 1:
+                    r, g, b = r1, g1, b1
+                elif color_code == 2:
+                    r = (2 * r0 + r1) // 3
+                    g = (2 * g0 + g1) // 3
+                    b = (2 * b0 + b1) // 3
+                elif color_code == 3:
+                    r = (2 * r1 + r0) // 3
+                    g = (2 * g1 + g0) // 3
+                    b = (2 * b1 + b0) // 3
+
+                ret[j].extend([r, g, b, a])
+
+    return ret
+
+
+def decode_dxt5(data: bytes) -> tuple[bytearray, bytearray, bytearray, bytearray]:
+    """
+    input: one "row" of data (i.e. will produce 4 * width pixels)
+    """
+
+    blocks = len(data) // 16  # number of blocks in row
+    ret = (bytearray(), bytearray(), bytearray(), bytearray())
+
+    for block_index in range(blocks):
+        idx = block_index * 16
+        block = data[idx : idx + 16]
+        # Decode next 16-byte block.
+        a0, a1 = struct.unpack_from("<BB", block)
+
+        bits = struct.unpack_from("<6B", block, 2)
+        alphacode1 = bits[2] | (bits[3] << 8) | (bits[4] << 16) | (bits[5] << 24)
+        alphacode2 = bits[0] | (bits[1] << 8)
+
+        color0, color1 = struct.unpack_from("<HH", block, 8)
+
+        (code,) = struct.unpack_from("<I", block, 12)
+
+        r0, g0, b0 = unpack_565(color0)
+        r1, g1, b1 = unpack_565(color1)
+
+        for j in range(4):
+            for i in range(4):
+                # get next control op and generate a pixel
+                alphacode_index = 3 * (4 * j + i)
+
+                if alphacode_index <= 12:
+                    alphacode = (alphacode2 >> alphacode_index) & 0x07
+                elif alphacode_index == 15:
+                    alphacode = (alphacode2 >> 15) | ((alphacode1 << 1) & 0x06)
+                else:  # alphacode_index >= 18 and alphacode_index <= 45
+                    alphacode = (alphacode1 >> (alphacode_index - 16)) & 0x07
+
+                if alphacode == 0:
+                    a = a0
+                elif alphacode == 1:
+                    a = a1
+                elif a0 > a1:
+                    a = ((8 - alphacode) * a0 + (alphacode - 1) * a1) // 7
+                elif alphacode == 6:
+                    a = 0
+                elif alphacode == 7:
+                    a = 255
+                else:
+                    a = ((6 - alphacode) * a0 + (alphacode - 1) * a1) // 5
+
+                color_code = (code >> 2 * (4 * j + i)) & 0x03
+
+                if color_code == 0:
+                    r, g, b = r0, g0, b0
+                elif color_code == 1:
+                    r, g, b = r1, g1, b1
+                elif color_code == 2:
+                    r = (2 * r0 + r1) // 3
+                    g = (2 * g0 + g1) // 3
+                    b = (2 * b0 + b1) // 3
+                elif color_code == 3:
+                    r = (2 * r1 + r0) // 3
+                    g = (2 * g1 + g0) // 3
+                    b = (2 * b1 + b0) // 3
+
+                ret[j].extend([r, g, b, a])
+
+    return ret
+
+
+class BLPFormatError(NotImplementedError):
+    pass
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix.startswith((b"BLP1", b"BLP2"))
+
+
+class BlpImageFile(ImageFile.ImageFile):
+    """
+    Blizzard Mipmap Format
+    """
+
+    format = "BLP"
+    format_description = "Blizzard Mipmap Format"
+
+    def _open(self) -> None:
+        self.magic = self.fp.read(4)
+        if not _accept(self.magic):
+            msg = f"Bad BLP magic {repr(self.magic)}"
+            raise BLPFormatError(msg)
+
+        compression = struct.unpack("<i", self.fp.read(4))[0]
+        if self.magic == b"BLP1":
+            alpha = struct.unpack("<I", self.fp.read(4))[0] != 0
+        else:
+            encoding = struct.unpack("<b", self.fp.read(1))[0]
+            alpha = struct.unpack("<b", self.fp.read(1))[0] != 0
+            alpha_encoding = struct.unpack("<b", self.fp.read(1))[0]
+            self.fp.seek(1, os.SEEK_CUR)  # mips
+
+        self._size = struct.unpack("<II", self.fp.read(8))
+
+        args: tuple[int, int, bool] | tuple[int, int, bool, int]
+        if self.magic == b"BLP1":
+            encoding = struct.unpack("<i", self.fp.read(4))[0]
+            self.fp.seek(4, os.SEEK_CUR)  # subtype
+
+            args = (compression, encoding, alpha)
+            offset = 28
+        else:
+            args = (compression, encoding, alpha, alpha_encoding)
+            offset = 20
+
+        decoder = self.magic.decode()
+
+        self._mode = "RGBA" if alpha else "RGB"
+        self.tile = [ImageFile._Tile(decoder, (0, 0) + self.size, offset, args)]
+
+
+class _BLPBaseDecoder(abc.ABC, ImageFile.PyDecoder):
+    _pulls_fd = True
+
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
+        try:
+            self._read_header()
+            self._load()
+        except struct.error as e:
+            msg = "Truncated BLP file"
+            raise OSError(msg) from e
+        return -1, 0
+
+    @abc.abstractmethod
+    def _load(self) -> None:
+        pass
+
+    def _read_header(self) -> None:
+        self._offsets = struct.unpack("<16I", self._safe_read(16 * 4))
+        self._lengths = struct.unpack("<16I", self._safe_read(16 * 4))
+
+    def _safe_read(self, length: int) -> bytes:
+        assert self.fd is not None
+        return ImageFile._safe_read(self.fd, length)
+
+    def _read_palette(self) -> list[tuple[int, int, int, int]]:
+        ret = []
+        for i in range(256):
+            try:
+                b, g, r, a = struct.unpack("<4B", self._safe_read(4))
+            except struct.error:
+                break
+            ret.append((b, g, r, a))
+        return ret
+
+    def _read_bgra(
+        self, palette: list[tuple[int, int, int, int]], alpha: bool
+    ) -> bytearray:
+        data = bytearray()
+        _data = BytesIO(self._safe_read(self._lengths[0]))
+        while True:
+            try:
+                (offset,) = struct.unpack("<B", _data.read(1))
+            except struct.error:
+                break
+            b, g, r, a = palette[offset]
+            d: tuple[int, ...] = (r, g, b)
+            if alpha:
+                d += (a,)
+            data.extend(d)
+        return data
+
+
+class BLP1Decoder(_BLPBaseDecoder):
+    def _load(self) -> None:
+        self._compression, self._encoding, alpha = self.args
+
+        if self._compression == Format.JPEG:
+            self._decode_jpeg_stream()
+
+        elif self._compression == 1:
+            if self._encoding in (4, 5):
+                palette = self._read_palette()
+                data = self._read_bgra(palette, alpha)
+                self.set_as_raw(data)
+            else:
+                msg = f"Unsupported BLP encoding {repr(self._encoding)}"
+                raise BLPFormatError(msg)
+        else:
+            msg = f"Unsupported BLP compression {repr(self._encoding)}"
+            raise BLPFormatError(msg)
+
+    def _decode_jpeg_stream(self) -> None:
+        from .JpegImagePlugin import JpegImageFile
+
+        (jpeg_header_size,) = struct.unpack("<I", self._safe_read(4))
+        jpeg_header = self._safe_read(jpeg_header_size)
+        assert self.fd is not None
+        self._safe_read(self._offsets[0] - self.fd.tell())  # What IS this?
+        data = self._safe_read(self._lengths[0])
+        data = jpeg_header + data
+        image = JpegImageFile(BytesIO(data))
+        Image._decompression_bomb_check(image.size)
+        if image.mode == "CMYK":
+            args = image.tile[0].args
+            assert isinstance(args, tuple)
+            image.tile = [image.tile[0]._replace(args=(args[0], "CMYK"))]
+        self.set_as_raw(image.convert("RGB").tobytes(), "BGR")
+
+
+class BLP2Decoder(_BLPBaseDecoder):
+    def _load(self) -> None:
+        self._compression, self._encoding, alpha, self._alpha_encoding = self.args
+
+        palette = self._read_palette()
+
+        assert self.fd is not None
+        self.fd.seek(self._offsets[0])
+
+        if self._compression == 1:
+            # Uncompressed or DirectX compression
+
+            if self._encoding == Encoding.UNCOMPRESSED:
+                data = self._read_bgra(palette, alpha)
+
+            elif self._encoding == Encoding.DXT:
+                data = bytearray()
+                if self._alpha_encoding == AlphaEncoding.DXT1:
+                    linesize = (self.state.xsize + 3) // 4 * 8
+                    for yb in range((self.state.ysize + 3) // 4):
+                        for d in decode_dxt1(self._safe_read(linesize), alpha):
+                            data += d
+
+                elif self._alpha_encoding == AlphaEncoding.DXT3:
+                    linesize = (self.state.xsize + 3) // 4 * 16
+                    for yb in range((self.state.ysize + 3) // 4):
+                        for d in decode_dxt3(self._safe_read(linesize)):
+                            data += d
+
+                elif self._alpha_encoding == AlphaEncoding.DXT5:
+                    linesize = (self.state.xsize + 3) // 4 * 16
+                    for yb in range((self.state.ysize + 3) // 4):
+                        for d in decode_dxt5(self._safe_read(linesize)):
+                            data += d
+                else:
+                    msg = f"Unsupported alpha encoding {repr(self._alpha_encoding)}"
+                    raise BLPFormatError(msg)
+            else:
+                msg = f"Unknown BLP encoding {repr(self._encoding)}"
+                raise BLPFormatError(msg)
+
+        else:
+            msg = f"Unknown BLP compression {repr(self._compression)}"
+            raise BLPFormatError(msg)
+
+        self.set_as_raw(data)
+
+
+class BLPEncoder(ImageFile.PyEncoder):
+    _pushes_fd = True
+
+    def _write_palette(self) -> bytes:
+        data = b""
+        assert self.im is not None
+        palette = self.im.getpalette("RGBA", "RGBA")
+        for i in range(len(palette) // 4):
+            r, g, b, a = palette[i * 4 : (i + 1) * 4]
+            data += struct.pack("<4B", b, g, r, a)
+        while len(data) < 256 * 4:
+            data += b"\x00" * 4
+        return data
+
+    def encode(self, bufsize: int) -> tuple[int, int, bytes]:
+        palette_data = self._write_palette()
+
+        offset = 20 + 16 * 4 * 2 + len(palette_data)
+        data = struct.pack("<16I", offset, *((0,) * 15))
+
+        assert self.im is not None
+        w, h = self.im.size
+        data += struct.pack("<16I", w * h, *((0,) * 15))
+
+        data += palette_data
+
+        for y in range(h):
+            for x in range(w):
+                data += struct.pack("<B", self.im.getpixel((x, y)))
+
+        return len(data), 0, data
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    if im.mode != "P":
+        msg = "Unsupported BLP image mode"
+        raise ValueError(msg)
+
+    magic = b"BLP1" if im.encoderinfo.get("blp_version") == "BLP1" else b"BLP2"
+    fp.write(magic)
+
+    assert im.palette is not None
+    fp.write(struct.pack("<i", 1))  # Uncompressed or DirectX compression
+
+    alpha_depth = 1 if im.palette.mode == "RGBA" else 0
+    if magic == b"BLP1":
+        fp.write(struct.pack("<L", alpha_depth))
+    else:
+        fp.write(struct.pack("<b", Encoding.UNCOMPRESSED))
+        fp.write(struct.pack("<b", alpha_depth))
+        fp.write(struct.pack("<b", 0))  # alpha encoding
+        fp.write(struct.pack("<b", 0))  # mips
+    fp.write(struct.pack("<II", *im.size))
+    if magic == b"BLP1":
+        fp.write(struct.pack("<i", 5))
+        fp.write(struct.pack("<i", 0))
+
+    ImageFile._save(im, fp, [ImageFile._Tile("BLP", (0, 0) + im.size, 0, im.mode)])
+
+
+Image.register_open(BlpImageFile.format, BlpImageFile, _accept)
+Image.register_extension(BlpImageFile.format, ".blp")
+Image.register_decoder("BLP1", BLP1Decoder)
+Image.register_decoder("BLP2", BLP2Decoder)
+
+Image.register_save(BlpImageFile.format, _save)
+Image.register_encoder("BLP", BLPEncoder)

.venv/lib/python3.12/site-packages/PIL/BmpImagePlugin.py

@@ -0,0 +1,515 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# BMP file handler
+#
+# Windows (and OS/2) native bitmap storage format.
+#
+# history:
+# 1995-09-01 fl   Created
+# 1996-04-30 fl   Added save
+# 1997-08-27 fl   Fixed save of 1-bit images
+# 1998-03-06 fl   Load P images as L where possible
+# 1998-07-03 fl   Load P images as 1 where possible
+# 1998-12-29 fl   Handle small palettes
+# 2002-12-30 fl   Fixed load of 1-bit palette images
+# 2003-04-21 fl   Fixed load of 1-bit monochrome images
+# 2003-04-23 fl   Added limited support for BI_BITFIELDS compression
+#
+# Copyright (c) 1997-2003 by Secret Labs AB
+# Copyright (c) 1995-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import os
+from typing import IO, Any
+
+from . import Image, ImageFile, ImagePalette
+from ._binary import i16le as i16
+from ._binary import i32le as i32
+from ._binary import o8
+from ._binary import o16le as o16
+from ._binary import o32le as o32
+
+#
+# --------------------------------------------------------------------
+# Read BMP file
+
+BIT2MODE = {
+    # bits => mode, rawmode
+    1: ("P", "P;1"),
+    4: ("P", "P;4"),
+    8: ("P", "P"),
+    16: ("RGB", "BGR;15"),
+    24: ("RGB", "BGR"),
+    32: ("RGB", "BGRX"),
+}
+
+USE_RAW_ALPHA = False
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix.startswith(b"BM")
+
+
+def _dib_accept(prefix: bytes) -> bool:
+    return i32(prefix) in [12, 40, 52, 56, 64, 108, 124]
+
+
+# =============================================================================
+# Image plugin for the Windows BMP format.
+# =============================================================================
+class BmpImageFile(ImageFile.ImageFile):
+    """Image plugin for the Windows Bitmap format (BMP)"""
+
+    # ------------------------------------------------------------- Description
+    format_description = "Windows Bitmap"
+    format = "BMP"
+
+    # -------------------------------------------------- BMP Compression values
+    COMPRESSIONS = {"RAW": 0, "RLE8": 1, "RLE4": 2, "BITFIELDS": 3, "JPEG": 4, "PNG": 5}
+    for k, v in COMPRESSIONS.items():
+        vars()[k] = v
+
+    def _bitmap(self, header: int = 0, offset: int = 0) -> None:
+        """Read relevant info about the BMP"""
+        read, seek = self.fp.read, self.fp.seek
+        if header:
+            seek(header)
+        # read bmp header size @offset 14 (this is part of the header size)
+        file_info: dict[str, bool | int | tuple[int, ...]] = {
+            "header_size": i32(read(4)),
+            "direction": -1,
+        }
+
+        # -------------------- If requested, read header at a specific position
+        # read the rest of the bmp header, without its size
+        assert isinstance(file_info["header_size"], int)
+        header_data = ImageFile._safe_read(self.fp, file_info["header_size"] - 4)
+
+        # ------------------------------- Windows Bitmap v2, IBM OS/2 Bitmap v1
+        # ----- This format has different offsets because of width/height types
+        # 12: BITMAPCOREHEADER/OS21XBITMAPHEADER
+        if file_info["header_size"] == 12:
+            file_info["width"] = i16(header_data, 0)
+            file_info["height"] = i16(header_data, 2)
+            file_info["planes"] = i16(header_data, 4)
+            file_info["bits"] = i16(header_data, 6)
+            file_info["compression"] = self.COMPRESSIONS["RAW"]
+            file_info["palette_padding"] = 3
+
+        # --------------------------------------------- Windows Bitmap v3 to v5
+        #  40: BITMAPINFOHEADER
+        #  52: BITMAPV2HEADER
+        #  56: BITMAPV3HEADER
+        #  64: BITMAPCOREHEADER2/OS22XBITMAPHEADER
+        # 108: BITMAPV4HEADER
+        # 124: BITMAPV5HEADER
+        elif file_info["header_size"] in (40, 52, 56, 64, 108, 124):
+            file_info["y_flip"] = header_data[7] == 0xFF
+            file_info["direction"] = 1 if file_info["y_flip"] else -1
+            file_info["width"] = i32(header_data, 0)
+            file_info["height"] = (
+                i32(header_data, 4)
+                if not file_info["y_flip"]
+                else 2**32 - i32(header_data, 4)
+            )
+            file_info["planes"] = i16(header_data, 8)
+            file_info["bits"] = i16(header_data, 10)
+            file_info["compression"] = i32(header_data, 12)
+            # byte size of pixel data
+            file_info["data_size"] = i32(header_data, 16)
+            file_info["pixels_per_meter"] = (
+                i32(header_data, 20),
+                i32(header_data, 24),
+            )
+            file_info["colors"] = i32(header_data, 28)
+            file_info["palette_padding"] = 4
+            assert isinstance(file_info["pixels_per_meter"], tuple)
+            self.info["dpi"] = tuple(x / 39.3701 for x in file_info["pixels_per_meter"])
+            if file_info["compression"] == self.COMPRESSIONS["BITFIELDS"]:
+                masks = ["r_mask", "g_mask", "b_mask"]
+                if len(header_data) >= 48:
+                    if len(header_data) >= 52:
+                        masks.append("a_mask")
+                    else:
+                        file_info["a_mask"] = 0x0
+                    for idx, mask in enumerate(masks):
+                        file_info[mask] = i32(header_data, 36 + idx * 4)
+                else:
+                    # 40 byte headers only have the three components in the
+                    # bitfields masks, ref:
+                    # https://msdn.microsoft.com/en-us/library/windows/desktop/dd183376(v=vs.85).aspx
+                    # See also
+                    # https://github.com/python-pillow/Pillow/issues/1293
+                    # There is a 4th component in the RGBQuad, in the alpha
+                    # location, but it is listed as a reserved component,
+                    # and it is not generally an alpha channel
+                    file_info["a_mask"] = 0x0
+                    for mask in masks:
+                        file_info[mask] = i32(read(4))
+                assert isinstance(file_info["r_mask"], int)
+                assert isinstance(file_info["g_mask"], int)
+                assert isinstance(file_info["b_mask"], int)
+                assert isinstance(file_info["a_mask"], int)
+                file_info["rgb_mask"] = (
+                    file_info["r_mask"],
+                    file_info["g_mask"],
+                    file_info["b_mask"],
+                )
+                file_info["rgba_mask"] = (
+                    file_info["r_mask"],
+                    file_info["g_mask"],
+                    file_info["b_mask"],
+                    file_info["a_mask"],
+                )
+        else:
+            msg = f"Unsupported BMP header type ({file_info['header_size']})"
+            raise OSError(msg)
+
+        # ------------------ Special case : header is reported 40, which
+        # ---------------------- is shorter than real size for bpp >= 16
+        assert isinstance(file_info["width"], int)
+        assert isinstance(file_info["height"], int)
+        self._size = file_info["width"], file_info["height"]
+
+        # ------- If color count was not found in the header, compute from bits
+        assert isinstance(file_info["bits"], int)
+        file_info["colors"] = (
+            file_info["colors"]
+            if file_info.get("colors", 0)
+            else (1 << file_info["bits"])
+        )
+        assert isinstance(file_info["colors"], int)
+        if offset == 14 + file_info["header_size"] and file_info["bits"] <= 8:
+            offset += 4 * file_info["colors"]
+
+        # ---------------------- Check bit depth for unusual unsupported values
+        self._mode, raw_mode = BIT2MODE.get(file_info["bits"], ("", ""))
+        if not self.mode:
+            msg = f"Unsupported BMP pixel depth ({file_info['bits']})"
+            raise OSError(msg)
+
+        # ---------------- Process BMP with Bitfields compression (not palette)
+        decoder_name = "raw"
+        if file_info["compression"] == self.COMPRESSIONS["BITFIELDS"]:
+            SUPPORTED: dict[int, list[tuple[int, ...]]] = {
+                32: [
+                    (0xFF0000, 0xFF00, 0xFF, 0x0),
+                    (0xFF000000, 0xFF0000, 0xFF00, 0x0),
+                    (0xFF000000, 0xFF00, 0xFF, 0x0),
+                    (0xFF000000, 0xFF0000, 0xFF00, 0xFF),
+                    (0xFF, 0xFF00, 0xFF0000, 0xFF000000),
+                    (0xFF0000, 0xFF00, 0xFF, 0xFF000000),
+                    (0xFF000000, 0xFF00, 0xFF, 0xFF0000),
+                    (0x0, 0x0, 0x0, 0x0),
+                ],
+                24: [(0xFF0000, 0xFF00, 0xFF)],
+                16: [(0xF800, 0x7E0, 0x1F), (0x7C00, 0x3E0, 0x1F)],
+            }
+            MASK_MODES = {
+                (32, (0xFF0000, 0xFF00, 0xFF, 0x0)): "BGRX",
+                (32, (0xFF000000, 0xFF0000, 0xFF00, 0x0)): "XBGR",
+                (32, (0xFF000000, 0xFF00, 0xFF, 0x0)): "BGXR",
+                (32, (0xFF000000, 0xFF0000, 0xFF00, 0xFF)): "ABGR",
+                (32, (0xFF, 0xFF00, 0xFF0000, 0xFF000000)): "RGBA",
+                (32, (0xFF0000, 0xFF00, 0xFF, 0xFF000000)): "BGRA",
+                (32, (0xFF000000, 0xFF00, 0xFF, 0xFF0000)): "BGAR",
+                (32, (0x0, 0x0, 0x0, 0x0)): "BGRA",
+                (24, (0xFF0000, 0xFF00, 0xFF)): "BGR",
+                (16, (0xF800, 0x7E0, 0x1F)): "BGR;16",
+                (16, (0x7C00, 0x3E0, 0x1F)): "BGR;15",
+            }
+            if file_info["bits"] in SUPPORTED:
+                if (
+                    file_info["bits"] == 32
+                    and file_info["rgba_mask"] in SUPPORTED[file_info["bits"]]
+                ):
+                    assert isinstance(file_info["rgba_mask"], tuple)
+                    raw_mode = MASK_MODES[(file_info["bits"], file_info["rgba_mask"])]
+                    self._mode = "RGBA" if "A" in raw_mode else self.mode
+                elif (
+                    file_info["bits"] in (24, 16)
+                    and file_info["rgb_mask"] in SUPPORTED[file_info["bits"]]
+                ):
+                    assert isinstance(file_info["rgb_mask"], tuple)
+                    raw_mode = MASK_MODES[(file_info["bits"], file_info["rgb_mask"])]
+                else:
+                    msg = "Unsupported BMP bitfields layout"
+                    raise OSError(msg)
+            else:
+                msg = "Unsupported BMP bitfields layout"
+                raise OSError(msg)
+        elif file_info["compression"] == self.COMPRESSIONS["RAW"]:
+            if file_info["bits"] == 32 and (
+                header == 22 or USE_RAW_ALPHA  # 32-bit .cur offset
+            ):
+                raw_mode, self._mode = "BGRA", "RGBA"
+        elif file_info["compression"] in (
+            self.COMPRESSIONS["RLE8"],
+            self.COMPRESSIONS["RLE4"],
+        ):
+            decoder_name = "bmp_rle"
+        else:
+            msg = f"Unsupported BMP compression ({file_info['compression']})"
+            raise OSError(msg)
+
+        # --------------- Once the header is processed, process the palette/LUT
+        if self.mode == "P":  # Paletted for 1, 4 and 8 bit images
+            # ---------------------------------------------------- 1-bit images
+            if not (0 < file_info["colors"] <= 65536):
+                msg = f"Unsupported BMP Palette size ({file_info['colors']})"
+                raise OSError(msg)
+            else:
+                assert isinstance(file_info["palette_padding"], int)
+                padding = file_info["palette_padding"]
+                palette = read(padding * file_info["colors"])
+                grayscale = True
+                indices = (
+                    (0, 255)
+                    if file_info["colors"] == 2
+                    else list(range(file_info["colors"]))
+                )
+
+                # ----------------- Check if grayscale and ignore palette if so
+                for ind, val in enumerate(indices):
+                    rgb = palette[ind * padding : ind * padding + 3]
+                    if rgb != o8(val) * 3:
+                        grayscale = False
+
+                # ------- If all colors are gray, white or black, ditch palette
+                if grayscale:
+                    self._mode = "1" if file_info["colors"] == 2 else "L"
+                    raw_mode = self.mode
+                else:
+                    self._mode = "P"
+                    self.palette = ImagePalette.raw(
+                        "BGRX" if padding == 4 else "BGR", palette
+                    )
+
+        # ---------------------------- Finally set the tile data for the plugin
+        self.info["compression"] = file_info["compression"]
+        args: list[Any] = [raw_mode]
+        if decoder_name == "bmp_rle":
+            args.append(file_info["compression"] == self.COMPRESSIONS["RLE4"])
+        else:
+            assert isinstance(file_info["width"], int)
+            args.append(((file_info["width"] * file_info["bits"] + 31) >> 3) & (~3))
+        args.append(file_info["direction"])
+        self.tile = [
+            ImageFile._Tile(
+                decoder_name,
+                (0, 0, file_info["width"], file_info["height"]),
+                offset or self.fp.tell(),
+                tuple(args),
+            )
+        ]
+
+    def _open(self) -> None:
+        """Open file, check magic number and read header"""
+        # read 14 bytes: magic number, filesize, reserved, header final offset
+        head_data = self.fp.read(14)
+        # choke if the file does not have the required magic bytes
+        if not _accept(head_data):
+            msg = "Not a BMP file"
+            raise SyntaxError(msg)
+        # read the start position of the BMP image data (u32)
+        offset = i32(head_data, 10)
+        # load bitmap information (offset=raster info)
+        self._bitmap(offset=offset)
+
+
+class BmpRleDecoder(ImageFile.PyDecoder):
+    _pulls_fd = True
+
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
+        assert self.fd is not None
+        rle4 = self.args[1]
+        data = bytearray()
+        x = 0
+        dest_length = self.state.xsize * self.state.ysize
+        while len(data) < dest_length:
+            pixels = self.fd.read(1)
+            byte = self.fd.read(1)
+            if not pixels or not byte:
+                break
+            num_pixels = pixels[0]
+            if num_pixels:
+                # encoded mode
+                if x + num_pixels > self.state.xsize:
+                    # Too much data for row
+                    num_pixels = max(0, self.state.xsize - x)
+                if rle4:
+                    first_pixel = o8(byte[0] >> 4)
+                    second_pixel = o8(byte[0] & 0x0F)
+                    for index in range(num_pixels):
+                        if index % 2 == 0:
+                            data += first_pixel
+                        else:
+                            data += second_pixel
+                else:
+                    data += byte * num_pixels
+                x += num_pixels
+            else:
+                if byte[0] == 0:
+                    # end of line
+                    while len(data) % self.state.xsize != 0:
+                        data += b"\x00"
+                    x = 0
+                elif byte[0] == 1:
+                    # end of bitmap
+                    break
+                elif byte[0] == 2:
+                    # delta
+                    bytes_read = self.fd.read(2)
+                    if len(bytes_read) < 2:
+                        break
+                    right, up = self.fd.read(2)
+                    data += b"\x00" * (right + up * self.state.xsize)
+                    x = len(data) % self.state.xsize
+                else:
+                    # absolute mode
+                    if rle4:
+                        # 2 pixels per byte
+                        byte_count = byte[0] // 2
+                        bytes_read = self.fd.read(byte_count)
+                        for byte_read in bytes_read:
+                            data += o8(byte_read >> 4)
+                            data += o8(byte_read & 0x0F)
+                    else:
+                        byte_count = byte[0]
+                        bytes_read = self.fd.read(byte_count)
+                        data += bytes_read
+                    if len(bytes_read) < byte_count:
+                        break
+                    x += byte[0]
+
+                    # align to 16-bit word boundary
+                    if self.fd.tell() % 2 != 0:
+                        self.fd.seek(1, os.SEEK_CUR)
+        rawmode = "L" if self.mode == "L" else "P"
+        self.set_as_raw(bytes(data), rawmode, (0, self.args[-1]))
+        return -1, 0
+
+
+# =============================================================================
+# Image plugin for the DIB format (BMP alias)
+# =============================================================================
+class DibImageFile(BmpImageFile):
+    format = "DIB"
+    format_description = "Windows Bitmap"
+
+    def _open(self) -> None:
+        self._bitmap()
+
+
+#
+# --------------------------------------------------------------------
+# Write BMP file
+
+
+SAVE = {
+    "1": ("1", 1, 2),
+    "L": ("L", 8, 256),
+    "P": ("P", 8, 256),
+    "RGB": ("BGR", 24, 0),
+    "RGBA": ("BGRA", 32, 0),
+}
+
+
+def _dib_save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    _save(im, fp, filename, False)
+
+
+def _save(
+    im: Image.Image, fp: IO[bytes], filename: str | bytes, bitmap_header: bool = True
+) -> None:
+    try:
+        rawmode, bits, colors = SAVE[im.mode]
+    except KeyError as e:
+        msg = f"cannot write mode {im.mode} as BMP"
+        raise OSError(msg) from e
+
+    info = im.encoderinfo
+
+    dpi = info.get("dpi", (96, 96))
+
+    # 1 meter == 39.3701 inches
+    ppm = tuple(int(x * 39.3701 + 0.5) for x in dpi)
+
+    stride = ((im.size[0] * bits + 7) // 8 + 3) & (~3)
+    header = 40  # or 64 for OS/2 version 2
+    image = stride * im.size[1]
+
+    if im.mode == "1":
+        palette = b"".join(o8(i) * 3 + b"\x00" for i in (0, 255))
+    elif im.mode == "L":
+        palette = b"".join(o8(i) * 3 + b"\x00" for i in range(256))
+    elif im.mode == "P":
+        palette = im.im.getpalette("RGB", "BGRX")
+        colors = len(palette) // 4
+    else:
+        palette = None
+
+    # bitmap header
+    if bitmap_header:
+        offset = 14 + header + colors * 4
+        file_size = offset + image
+        if file_size > 2**32 - 1:
+            msg = "File size is too large for the BMP format"
+            raise ValueError(msg)
+        fp.write(
+            b"BM"  # file type (magic)
+            + o32(file_size)  # file size
+            + o32(0)  # reserved
+            + o32(offset)  # image data offset
+        )
+
+    # bitmap info header
+    fp.write(
+        o32(header)  # info header size
+        + o32(im.size[0])  # width
+        + o32(im.size[1])  # height
+        + o16(1)  # planes
+        + o16(bits)  # depth
+        + o32(0)  # compression (0=uncompressed)
+        + o32(image)  # size of bitmap
+        + o32(ppm[0])  # resolution
+        + o32(ppm[1])  # resolution
+        + o32(colors)  # colors used
+        + o32(colors)  # colors important
+    )
+
+    fp.write(b"\0" * (header - 40))  # padding (for OS/2 format)
+
+    if palette:
+        fp.write(palette)
+
+    ImageFile._save(
+        im, fp, [ImageFile._Tile("raw", (0, 0) + im.size, 0, (rawmode, stride, -1))]
+    )
+
+
+#
+# --------------------------------------------------------------------
+# Registry
+
+
+Image.register_open(BmpImageFile.format, BmpImageFile, _accept)
+Image.register_save(BmpImageFile.format, _save)
+
+Image.register_extension(BmpImageFile.format, ".bmp")
+
+Image.register_mime(BmpImageFile.format, "image/bmp")
+
+Image.register_decoder("bmp_rle", BmpRleDecoder)
+
+Image.register_open(DibImageFile.format, DibImageFile, _dib_accept)
+Image.register_save(DibImageFile.format, _dib_save)
+
+Image.register_extension(DibImageFile.format, ".dib")
+
+Image.register_mime(DibImageFile.format, "image/bmp")

.venv/lib/python3.12/site-packages/PIL/BufrStubImagePlugin.py

@@ -0,0 +1,75 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# BUFR stub adapter
+#
+# Copyright (c) 1996-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import os
+from typing import IO
+
+from . import Image, ImageFile
+
+_handler = None
+
+
+def register_handler(handler: ImageFile.StubHandler | None) -> None:
+    """
+    Install application-specific BUFR image handler.
+
+    :param handler: Handler object.
+    """
+    global _handler
+    _handler = handler
+
+
+# --------------------------------------------------------------------
+# Image adapter
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix.startswith((b"BUFR", b"ZCZC"))
+
+
+class BufrStubImageFile(ImageFile.StubImageFile):
+    format = "BUFR"
+    format_description = "BUFR"
+
+    def _open(self) -> None:
+        if not _accept(self.fp.read(4)):
+            msg = "Not a BUFR file"
+            raise SyntaxError(msg)
+
+        self.fp.seek(-4, os.SEEK_CUR)
+
+        # make something up
+        self._mode = "F"
+        self._size = 1, 1
+
+        loader = self._load()
+        if loader:
+            loader.open(self)
+
+    def _load(self) -> ImageFile.StubHandler | None:
+        return _handler
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    if _handler is None or not hasattr(_handler, "save"):
+        msg = "BUFR save handler not installed"
+        raise OSError(msg)
+    _handler.save(im, fp, filename)
+
+
+# --------------------------------------------------------------------
+# Registry
+
+Image.register_open(BufrStubImageFile.format, BufrStubImageFile, _accept)
+Image.register_save(BufrStubImageFile.format, _save)
+
+Image.register_extension(BufrStubImageFile.format, ".bufr")

.venv/lib/python3.12/site-packages/PIL/ContainerIO.py

@@ -0,0 +1,173 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# a class to read from a container file
+#
+# History:
+# 1995-06-18 fl     Created
+# 1995-09-07 fl     Added readline(), readlines()
+#
+# Copyright (c) 1997-2001 by Secret Labs AB
+# Copyright (c) 1995 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import io
+from collections.abc import Iterable
+from typing import IO, AnyStr, NoReturn
+
+
+class ContainerIO(IO[AnyStr]):
+    """
+    A file object that provides read access to a part of an existing
+    file (for example a TAR file).
+    """
+
+    def __init__(self, file: IO[AnyStr], offset: int, length: int) -> None:
+        """
+        Create file object.
+
+        :param file: Existing file.
+        :param offset: Start of region, in bytes.
+        :param length: Size of region, in bytes.
+        """
+        self.fh: IO[AnyStr] = file
+        self.pos = 0
+        self.offset = offset
+        self.length = length
+        self.fh.seek(offset)
+
+    ##
+    # Always false.
+
+    def isatty(self) -> bool:
+        return False
+
+    def seekable(self) -> bool:
+        return True
+
+    def seek(self, offset: int, mode: int = io.SEEK_SET) -> int:
+        """
+        Move file pointer.
+
+        :param offset: Offset in bytes.
+        :param mode: Starting position. Use 0 for beginning of region, 1
+           for current offset, and 2 for end of region.  You cannot move
+           the pointer outside the defined region.
+        :returns: Offset from start of region, in bytes.
+        """
+        if mode == 1:
+            self.pos = self.pos + offset
+        elif mode == 2:
+            self.pos = self.length + offset
+        else:
+            self.pos = offset
+        # clamp
+        self.pos = max(0, min(self.pos, self.length))
+        self.fh.seek(self.offset + self.pos)
+        return self.pos
+
+    def tell(self) -> int:
+        """
+        Get current file pointer.
+
+        :returns: Offset from start of region, in bytes.
+        """
+        return self.pos
+
+    def readable(self) -> bool:
+        return True
+
+    def read(self, n: int = -1) -> AnyStr:
+        """
+        Read data.
+
+        :param n: Number of bytes to read. If omitted, zero or negative,
+            read until end of region.
+        :returns: An 8-bit string.
+        """
+        if n > 0:
+            n = min(n, self.length - self.pos)
+        else:
+            n = self.length - self.pos
+        if n <= 0:  # EOF
+            return b"" if "b" in self.fh.mode else ""  # type: ignore[return-value]
+        self.pos = self.pos + n
+        return self.fh.read(n)
+
+    def readline(self, n: int = -1) -> AnyStr:
+        """
+        Read a line of text.
+
+        :param n: Number of bytes to read. If omitted, zero or negative,
+            read until end of line.
+        :returns: An 8-bit string.
+        """
+        s: AnyStr = b"" if "b" in self.fh.mode else ""  # type: ignore[assignment]
+        newline_character = b"\n" if "b" in self.fh.mode else "\n"
+        while True:
+            c = self.read(1)
+            if not c:
+                break
+            s = s + c
+            if c == newline_character or len(s) == n:
+                break
+        return s
+
+    def readlines(self, n: int | None = -1) -> list[AnyStr]:
+        """
+        Read multiple lines of text.
+
+        :param n: Number of lines to read. If omitted, zero, negative or None,
+            read until end of region.
+        :returns: A list of 8-bit strings.
+        """
+        lines = []
+        while True:
+            s = self.readline()
+            if not s:
+                break
+            lines.append(s)
+            if len(lines) == n:
+                break
+        return lines
+
+    def writable(self) -> bool:
+        return False
+
+    def write(self, b: AnyStr) -> NoReturn:
+        raise NotImplementedError()
+
+    def writelines(self, lines: Iterable[AnyStr]) -> NoReturn:
+        raise NotImplementedError()
+
+    def truncate(self, size: int | None = None) -> int:
+        raise NotImplementedError()
+
+    def __enter__(self) -> ContainerIO[AnyStr]:
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()
+
+    def __iter__(self) -> ContainerIO[AnyStr]:
+        return self
+
+    def __next__(self) -> AnyStr:
+        line = self.readline()
+        if not line:
+            msg = "end of region"
+            raise StopIteration(msg)
+        return line
+
+    def fileno(self) -> int:
+        return self.fh.fileno()
+
+    def flush(self) -> None:
+        self.fh.flush()
+
+    def close(self) -> None:
+        self.fh.close()

.venv/lib/python3.12/site-packages/PIL/DcxImagePlugin.py

@@ -0,0 +1,83 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# DCX file handling
+#
+# DCX is a container file format defined by Intel, commonly used
+# for fax applications.  Each DCX file consists of a directory
+# (a list of file offsets) followed by a set of (usually 1-bit)
+# PCX files.
+#
+# History:
+# 1995-09-09 fl   Created
+# 1996-03-20 fl   Properly derived from PcxImageFile.
+# 1998-07-15 fl   Renamed offset attribute to avoid name clash
+# 2002-07-30 fl   Fixed file handling
+#
+# Copyright (c) 1997-98 by Secret Labs AB.
+# Copyright (c) 1995-96 by Fredrik Lundh.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+from . import Image
+from ._binary import i32le as i32
+from ._util import DeferredError
+from .PcxImagePlugin import PcxImageFile
+
+MAGIC = 0x3ADE68B1  # QUIZ: what's this value, then?
+
+
+def _accept(prefix: bytes) -> bool:
+    return len(prefix) >= 4 and i32(prefix) == MAGIC
+
+
+##
+# Image plugin for the Intel DCX format.
+
+
+class DcxImageFile(PcxImageFile):
+    format = "DCX"
+    format_description = "Intel DCX"
+    _close_exclusive_fp_after_loading = False
+
+    def _open(self) -> None:
+        # Header
+        s = self.fp.read(4)
+        if not _accept(s):
+            msg = "not a DCX file"
+            raise SyntaxError(msg)
+
+        # Component directory
+        self._offset = []
+        for i in range(1024):
+            offset = i32(self.fp.read(4))
+            if not offset:
+                break
+            self._offset.append(offset)
+
+        self._fp = self.fp
+        self.frame = -1
+        self.n_frames = len(self._offset)
+        self.is_animated = self.n_frames > 1
+        self.seek(0)
+
+    def seek(self, frame: int) -> None:
+        if not self._seek_check(frame):
+            return
+        if isinstance(self._fp, DeferredError):
+            raise self._fp.ex
+        self.frame = frame
+        self.fp = self._fp
+        self.fp.seek(self._offset[frame])
+        PcxImageFile._open(self)
+
+    def tell(self) -> int:
+        return self.frame
+
+
+Image.register_open(DcxImageFile.format, DcxImageFile, _accept)
+
+Image.register_extension(DcxImageFile.format, ".dcx")

.venv/lib/python3.12/site-packages/PIL/EpsImagePlugin.py

@@ -0,0 +1,479 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# EPS file handling
+#
+# History:
+# 1995-09-01 fl   Created (0.1)
+# 1996-05-18 fl   Don't choke on "atend" fields, Ghostscript interface (0.2)
+# 1996-08-22 fl   Don't choke on floating point BoundingBox values
+# 1996-08-23 fl   Handle files from Macintosh (0.3)
+# 2001-02-17 fl   Use 're' instead of 'regex' (Python 2.1) (0.4)
+# 2003-09-07 fl   Check gs.close status (from Federico Di Gregorio) (0.5)
+# 2014-05-07 e    Handling of EPS with binary preview and fixed resolution
+#                 resizing
+#
+# Copyright (c) 1997-2003 by Secret Labs AB.
+# Copyright (c) 1995-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import io
+import os
+import re
+import subprocess
+import sys
+import tempfile
+from typing import IO
+
+from . import Image, ImageFile
+from ._binary import i32le as i32
+
+# --------------------------------------------------------------------
+
+
+split = re.compile(r"^%%([^:]*):[ \t]*(.*)[ \t]*$")
+field = re.compile(r"^%[%!\w]([^:]*)[ \t]*$")
+
+gs_binary: str | bool | None = None
+gs_windows_binary = None
+
+
+def has_ghostscript() -> bool:
+    global gs_binary, gs_windows_binary
+    if gs_binary is None:
+        if sys.platform.startswith("win"):
+            if gs_windows_binary is None:
+                import shutil
+
+                for binary in ("gswin32c", "gswin64c", "gs"):
+                    if shutil.which(binary) is not None:
+                        gs_windows_binary = binary
+                        break
+                else:
+                    gs_windows_binary = False
+            gs_binary = gs_windows_binary
+        else:
+            try:
+                subprocess.check_call(["gs", "--version"], stdout=subprocess.DEVNULL)
+                gs_binary = "gs"
+            except OSError:
+                gs_binary = False
+    return gs_binary is not False
+
+
+def Ghostscript(
+    tile: list[ImageFile._Tile],
+    size: tuple[int, int],
+    fp: IO[bytes],
+    scale: int = 1,
+    transparency: bool = False,
+) -> Image.core.ImagingCore:
+    """Render an image using Ghostscript"""
+    global gs_binary
+    if not has_ghostscript():
+        msg = "Unable to locate Ghostscript on paths"
+        raise OSError(msg)
+    assert isinstance(gs_binary, str)
+
+    # Unpack decoder tile
+    args = tile[0].args
+    assert isinstance(args, tuple)
+    length, bbox = args
+
+    # Hack to support hi-res rendering
+    scale = int(scale) or 1
+    width = size[0] * scale
+    height = size[1] * scale
+    # resolution is dependent on bbox and size
+    res_x = 72.0 * width / (bbox[2] - bbox[0])
+    res_y = 72.0 * height / (bbox[3] - bbox[1])
+
+    out_fd, outfile = tempfile.mkstemp()
+    os.close(out_fd)
+
+    infile_temp = None
+    if hasattr(fp, "name") and os.path.exists(fp.name):
+        infile = fp.name
+    else:
+        in_fd, infile_temp = tempfile.mkstemp()
+        os.close(in_fd)
+        infile = infile_temp
+
+        # Ignore length and offset!
+        # Ghostscript can read it
+        # Copy whole file to read in Ghostscript
+        with open(infile_temp, "wb") as f:
+            # fetch length of fp
+            fp.seek(0, io.SEEK_END)
+            fsize = fp.tell()
+            # ensure start position
+            # go back
+            fp.seek(0)
+            lengthfile = fsize
+            while lengthfile > 0:
+                s = fp.read(min(lengthfile, 100 * 1024))
+                if not s:
+                    break
+                lengthfile -= len(s)
+                f.write(s)
+
+    if transparency:
+        # "RGBA"
+        device = "pngalpha"
+    else:
+        # "pnmraw" automatically chooses between
+        # PBM ("1"), PGM ("L"), and PPM ("RGB").
+        device = "pnmraw"
+
+    # Build Ghostscript command
+    command = [
+        gs_binary,
+        "-q",  # quiet mode
+        f"-g{width:d}x{height:d}",  # set output geometry (pixels)
+        f"-r{res_x:f}x{res_y:f}",  # set input DPI (dots per inch)
+        "-dBATCH",  # exit after processing
+        "-dNOPAUSE",  # don't pause between pages
+        "-dSAFER",  # safe mode
+        f"-sDEVICE={device}",
+        f"-sOutputFile={outfile}",  # output file
+        # adjust for image origin
+        "-c",
+        f"{-bbox[0]} {-bbox[1]} translate",
+        "-f",
+        infile,  # input file
+        # showpage (see https://bugs.ghostscript.com/show_bug.cgi?id=698272)
+        "-c",
+        "showpage",
+    ]
+
+    # push data through Ghostscript
+    try:
+        startupinfo = None
+        if sys.platform.startswith("win"):
+            startupinfo = subprocess.STARTUPINFO()
+            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        subprocess.check_call(command, startupinfo=startupinfo)
+        with Image.open(outfile) as out_im:
+            out_im.load()
+            return out_im.im.copy()
+    finally:
+        try:
+            os.unlink(outfile)
+            if infile_temp:
+                os.unlink(infile_temp)
+        except OSError:
+            pass
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix.startswith(b"%!PS") or (
+        len(prefix) >= 4 and i32(prefix) == 0xC6D3D0C5
+    )
+
+
+##
+# Image plugin for Encapsulated PostScript. This plugin supports only
+# a few variants of this format.
+
+
+class EpsImageFile(ImageFile.ImageFile):
+    """EPS File Parser for the Python Imaging Library"""
+
+    format = "EPS"
+    format_description = "Encapsulated Postscript"
+
+    mode_map = {1: "L", 2: "LAB", 3: "RGB", 4: "CMYK"}
+
+    def _open(self) -> None:
+        (length, offset) = self._find_offset(self.fp)
+
+        # go to offset - start of "%!PS"
+        self.fp.seek(offset)
+
+        self._mode = "RGB"
+
+        # When reading header comments, the first comment is used.
+        # When reading trailer comments, the last comment is used.
+        bounding_box: list[int] | None = None
+        imagedata_size: tuple[int, int] | None = None
+
+        byte_arr = bytearray(255)
+        bytes_mv = memoryview(byte_arr)
+        bytes_read = 0
+        reading_header_comments = True
+        reading_trailer_comments = False
+        trailer_reached = False
+
+        def check_required_header_comments() -> None:
+            """
+            The EPS specification requires that some headers exist.
+            This should be checked when the header comments formally end,
+            when image data starts, or when the file ends, whichever comes first.
+            """
+            if "PS-Adobe" not in self.info:
+                msg = 'EPS header missing "%!PS-Adobe" comment'
+                raise SyntaxError(msg)
+            if "BoundingBox" not in self.info:
+                msg = 'EPS header missing "%%BoundingBox" comment'
+                raise SyntaxError(msg)
+
+        def read_comment(s: str) -> bool:
+            nonlocal bounding_box, reading_trailer_comments
+            try:
+                m = split.match(s)
+            except re.error as e:
+                msg = "not an EPS file"
+                raise SyntaxError(msg) from e
+
+            if not m:
+                return False
+
+            k, v = m.group(1, 2)
+            self.info[k] = v
+            if k == "BoundingBox":
+                if v == "(atend)":
+                    reading_trailer_comments = True
+                elif not bounding_box or (trailer_reached and reading_trailer_comments):
+                    try:
+                        # Note: The DSC spec says that BoundingBox
+                        # fields should be integers, but some drivers
+                        # put floating point values there anyway.
+                        bounding_box = [int(float(i)) for i in v.split()]
+                    except Exception:
+                        pass
+            return True
+
+        while True:
+            byte = self.fp.read(1)
+            if byte == b"":
+                # if we didn't read a byte we must be at the end of the file
+                if bytes_read == 0:
+                    if reading_header_comments:
+                        check_required_header_comments()
+                    break
+            elif byte in b"\r\n":
+                # if we read a line ending character, ignore it and parse what
+                # we have already read. if we haven't read any other characters,
+                # continue reading
+                if bytes_read == 0:
+                    continue
+            else:
+                # ASCII/hexadecimal lines in an EPS file must not exceed
+                # 255 characters, not including line ending characters
+                if bytes_read >= 255:
+                    # only enforce this for lines starting with a "%",
+                    # otherwise assume it's binary data
+                    if byte_arr[0] == ord("%"):
+                        msg = "not an EPS file"
+                        raise SyntaxError(msg)
+                    else:
+                        if reading_header_comments:
+                            check_required_header_comments()
+                            reading_header_comments = False
+                        # reset bytes_read so we can keep reading
+                        # data until the end of the line
+                        bytes_read = 0
+                byte_arr[bytes_read] = byte[0]
+                bytes_read += 1
+                continue
+
+            if reading_header_comments:
+                # Load EPS header
+
+                # if this line doesn't start with a "%",
+                # or does start with "%%EndComments",
+                # then we've reached the end of the header/comments
+                if byte_arr[0] != ord("%") or bytes_mv[:13] == b"%%EndComments":
+                    check_required_header_comments()
+                    reading_header_comments = False
+                    continue
+
+                s = str(bytes_mv[:bytes_read], "latin-1")
+                if not read_comment(s):
+                    m = field.match(s)
+                    if m:
+                        k = m.group(1)
+                        if k.startswith("PS-Adobe"):
+                            self.info["PS-Adobe"] = k[9:]
+                        else:
+                            self.info[k] = ""
+                    elif s[0] == "%":
+                        # handle non-DSC PostScript comments that some
+                        # tools mistakenly put in the Comments section
+                        pass
+                    else:
+                        msg = "bad EPS header"
+                        raise OSError(msg)
+            elif bytes_mv[:11] == b"%ImageData:":
+                # Check for an "ImageData" descriptor
+                # https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/#50577413_pgfId-1035096
+
+                # If we've already read an "ImageData" descriptor,
+                # don't read another one.
+                if imagedata_size:
+                    bytes_read = 0
+                    continue
+
+                # Values:
+                # columns
+                # rows
+                # bit depth (1 or 8)
+                # mode (1: L, 2: LAB, 3: RGB, 4: CMYK)
+                # number of padding channels
+                # block size (number of bytes per row per channel)
+                # binary/ascii (1: binary, 2: ascii)
+                # data start identifier (the image data follows after a single line
+                #   consisting only of this quoted value)
+                image_data_values = byte_arr[11:bytes_read].split(None, 7)
+                columns, rows, bit_depth, mode_id = (
+                    int(value) for value in image_data_values[:4]
+                )
+
+                if bit_depth == 1:
+                    self._mode = "1"
+                elif bit_depth == 8:
+                    try:
+                        self._mode = self.mode_map[mode_id]
+                    except ValueError:
+                        break
+                else:
+                    break
+
+                # Parse the columns and rows after checking the bit depth and mode
+                # in case the bit depth and/or mode are invalid.
+                imagedata_size = columns, rows
+            elif bytes_mv[:5] == b"%%EOF":
+                break
+            elif trailer_reached and reading_trailer_comments:
+                # Load EPS trailer
+                s = str(bytes_mv[:bytes_read], "latin-1")
+                read_comment(s)
+            elif bytes_mv[:9] == b"%%Trailer":
+                trailer_reached = True
+            elif bytes_mv[:14] == b"%%BeginBinary:":
+                bytecount = int(byte_arr[14:bytes_read])
+                self.fp.seek(bytecount, os.SEEK_CUR)
+            bytes_read = 0
+
+        # A "BoundingBox" is always required,
+        # even if an "ImageData" descriptor size exists.
+        if not bounding_box:
+            msg = "cannot determine EPS bounding box"
+            raise OSError(msg)
+
+        # An "ImageData" size takes precedence over the "BoundingBox".
+        self._size = imagedata_size or (
+            bounding_box[2] - bounding_box[0],
+            bounding_box[3] - bounding_box[1],
+        )
+
+        self.tile = [
+            ImageFile._Tile("eps", (0, 0) + self.size, offset, (length, bounding_box))
+        ]
+
+    def _find_offset(self, fp: IO[bytes]) -> tuple[int, int]:
+        s = fp.read(4)
+
+        if s == b"%!PS":
+            # for HEAD without binary preview
+            fp.seek(0, io.SEEK_END)
+            length = fp.tell()
+            offset = 0
+        elif i32(s) == 0xC6D3D0C5:
+            # FIX for: Some EPS file not handled correctly / issue #302
+            # EPS can contain binary data
+            # or start directly with latin coding
+            # more info see:
+            # https://web.archive.org/web/20160528181353/http://partners.adobe.com/public/developer/en/ps/5002.EPSF_Spec.pdf
+            s = fp.read(8)
+            offset = i32(s)
+            length = i32(s, 4)
+        else:
+            msg = "not an EPS file"
+            raise SyntaxError(msg)
+
+        return length, offset
+
+    def load(
+        self, scale: int = 1, transparency: bool = False
+    ) -> Image.core.PixelAccess | None:
+        # Load EPS via Ghostscript
+        if self.tile:
+            self.im = Ghostscript(self.tile, self.size, self.fp, scale, transparency)
+            self._mode = self.im.mode
+            self._size = self.im.size
+            self.tile = []
+        return Image.Image.load(self)
+
+    def load_seek(self, pos: int) -> None:
+        # we can't incrementally load, so force ImageFile.parser to
+        # use our custom load method by defining this method.
+        pass
+
+
+# --------------------------------------------------------------------
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes, eps: int = 1) -> None:
+    """EPS Writer for the Python Imaging Library."""
+
+    # make sure image data is available
+    im.load()
+
+    # determine PostScript image mode
+    if im.mode == "L":
+        operator = (8, 1, b"image")
+    elif im.mode == "RGB":
+        operator = (8, 3, b"false 3 colorimage")
+    elif im.mode == "CMYK":
+        operator = (8, 4, b"false 4 colorimage")
+    else:
+        msg = "image mode is not supported"
+        raise ValueError(msg)
+
+    if eps:
+        # write EPS header
+        fp.write(b"%!PS-Adobe-3.0 EPSF-3.0\n")
+        fp.write(b"%%Creator: PIL 0.1 EpsEncode\n")
+        # fp.write("%%CreationDate: %s"...)
+        fp.write(b"%%%%BoundingBox: 0 0 %d %d\n" % im.size)
+        fp.write(b"%%Pages: 1\n")
+        fp.write(b"%%EndComments\n")
+        fp.write(b"%%Page: 1 1\n")
+        fp.write(b"%%ImageData: %d %d " % im.size)
+        fp.write(b'%d %d 0 1 1 "%s"\n' % operator)
+
+    # image header
+    fp.write(b"gsave\n")
+    fp.write(b"10 dict begin\n")
+    fp.write(b"/buf %d string def\n" % (im.size[0] * operator[1]))
+    fp.write(b"%d %d scale\n" % im.size)
+    fp.write(b"%d %d 8\n" % im.size)  # <= bits
+    fp.write(b"[%d 0 0 -%d 0 %d]\n" % (im.size[0], im.size[1], im.size[1]))
+    fp.write(b"{ currentfile buf readhexstring pop } bind\n")
+    fp.write(operator[2] + b"\n")
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+    ImageFile._save(im, fp, [ImageFile._Tile("eps", (0, 0) + im.size)])
+
+    fp.write(b"\n%%%%EndBinary\n")
+    fp.write(b"grestore end\n")
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+
+# --------------------------------------------------------------------
+
+
+Image.register_open(EpsImageFile.format, EpsImageFile, _accept)
+
+Image.register_save(EpsImageFile.format, _save)
+
+Image.register_extensions(EpsImageFile.format, [".ps", ".eps"])
+
+Image.register_mime(EpsImageFile.format, "application/postscript")

.venv/lib/python3.12/site-packages/PIL/ExifTags.py

@@ -0,0 +1,382 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# EXIF tags
+#
+# Copyright (c) 2003 by Secret Labs AB
+#
+# See the README file for information on usage and redistribution.
+#
+
+"""
+This module provides constants and clear-text names for various
+well-known EXIF tags.
+"""
+from __future__ import annotations
+
+from enum import IntEnum
+
+
+class Base(IntEnum):
+    # possibly incomplete
+    InteropIndex = 0x0001
+    ProcessingSoftware = 0x000B
+    NewSubfileType = 0x00FE
+    SubfileType = 0x00FF
+    ImageWidth = 0x0100
+    ImageLength = 0x0101
+    BitsPerSample = 0x0102
+    Compression = 0x0103
+    PhotometricInterpretation = 0x0106
+    Thresholding = 0x0107
+    CellWidth = 0x0108
+    CellLength = 0x0109
+    FillOrder = 0x010A
+    DocumentName = 0x010D
+    ImageDescription = 0x010E
+    Make = 0x010F
+    Model = 0x0110
+    StripOffsets = 0x0111
+    Orientation = 0x0112
+    SamplesPerPixel = 0x0115
+    RowsPerStrip = 0x0116
+    StripByteCounts = 0x0117
+    MinSampleValue = 0x0118
+    MaxSampleValue = 0x0119
+    XResolution = 0x011A
+    YResolution = 0x011B
+    PlanarConfiguration = 0x011C
+    PageName = 0x011D
+    FreeOffsets = 0x0120
+    FreeByteCounts = 0x0121
+    GrayResponseUnit = 0x0122
+    GrayResponseCurve = 0x0123
+    T4Options = 0x0124
+    T6Options = 0x0125
+    ResolutionUnit = 0x0128
+    PageNumber = 0x0129
+    TransferFunction = 0x012D
+    Software = 0x0131
+    DateTime = 0x0132
+    Artist = 0x013B
+    HostComputer = 0x013C
+    Predictor = 0x013D
+    WhitePoint = 0x013E
+    PrimaryChromaticities = 0x013F
+    ColorMap = 0x0140
+    HalftoneHints = 0x0141
+    TileWidth = 0x0142
+    TileLength = 0x0143
+    TileOffsets = 0x0144
+    TileByteCounts = 0x0145
+    SubIFDs = 0x014A
+    InkSet = 0x014C
+    InkNames = 0x014D
+    NumberOfInks = 0x014E
+    DotRange = 0x0150
+    TargetPrinter = 0x0151
+    ExtraSamples = 0x0152
+    SampleFormat = 0x0153
+    SMinSampleValue = 0x0154
+    SMaxSampleValue = 0x0155
+    TransferRange = 0x0156
+    ClipPath = 0x0157
+    XClipPathUnits = 0x0158
+    YClipPathUnits = 0x0159
+    Indexed = 0x015A
+    JPEGTables = 0x015B
+    OPIProxy = 0x015F
+    JPEGProc = 0x0200
+    JpegIFOffset = 0x0201
+    JpegIFByteCount = 0x0202
+    JpegRestartInterval = 0x0203
+    JpegLosslessPredictors = 0x0205
+    JpegPointTransforms = 0x0206
+    JpegQTables = 0x0207
+    JpegDCTables = 0x0208
+    JpegACTables = 0x0209
+    YCbCrCoefficients = 0x0211
+    YCbCrSubSampling = 0x0212
+    YCbCrPositioning = 0x0213
+    ReferenceBlackWhite = 0x0214
+    XMLPacket = 0x02BC
+    RelatedImageFileFormat = 0x1000
+    RelatedImageWidth = 0x1001
+    RelatedImageLength = 0x1002
+    Rating = 0x4746
+    RatingPercent = 0x4749
+    ImageID = 0x800D
+    CFARepeatPatternDim = 0x828D
+    BatteryLevel = 0x828F
+    Copyright = 0x8298
+    ExposureTime = 0x829A
+    FNumber = 0x829D
+    IPTCNAA = 0x83BB
+    ImageResources = 0x8649
+    ExifOffset = 0x8769
+    InterColorProfile = 0x8773
+    ExposureProgram = 0x8822
+    SpectralSensitivity = 0x8824
+    GPSInfo = 0x8825
+    ISOSpeedRatings = 0x8827
+    OECF = 0x8828
+    Interlace = 0x8829
+    TimeZoneOffset = 0x882A
+    SelfTimerMode = 0x882B
+    SensitivityType = 0x8830
+    StandardOutputSensitivity = 0x8831
+    RecommendedExposureIndex = 0x8832
+    ISOSpeed = 0x8833
+    ISOSpeedLatitudeyyy = 0x8834
+    ISOSpeedLatitudezzz = 0x8835
+    ExifVersion = 0x9000
+    DateTimeOriginal = 0x9003
+    DateTimeDigitized = 0x9004
+    OffsetTime = 0x9010
+    OffsetTimeOriginal = 0x9011
+    OffsetTimeDigitized = 0x9012
+    ComponentsConfiguration = 0x9101
+    CompressedBitsPerPixel = 0x9102
+    ShutterSpeedValue = 0x9201
+    ApertureValue = 0x9202
+    BrightnessValue = 0x9203
+    ExposureBiasValue = 0x9204
+    MaxApertureValue = 0x9205
+    SubjectDistance = 0x9206
+    MeteringMode = 0x9207
+    LightSource = 0x9208
+    Flash = 0x9209
+    FocalLength = 0x920A
+    Noise = 0x920D
+    ImageNumber = 0x9211
+    SecurityClassification = 0x9212
+    ImageHistory = 0x9213
+    TIFFEPStandardID = 0x9216
+    MakerNote = 0x927C
+    UserComment = 0x9286
+    SubsecTime = 0x9290
+    SubsecTimeOriginal = 0x9291
+    SubsecTimeDigitized = 0x9292
+    AmbientTemperature = 0x9400
+    Humidity = 0x9401
+    Pressure = 0x9402
+    WaterDepth = 0x9403
+    Acceleration = 0x9404
+    CameraElevationAngle = 0x9405
+    XPTitle = 0x9C9B
+    XPComment = 0x9C9C
+    XPAuthor = 0x9C9D
+    XPKeywords = 0x9C9E
+    XPSubject = 0x9C9F
+    FlashPixVersion = 0xA000
+    ColorSpace = 0xA001
+    ExifImageWidth = 0xA002
+    ExifImageHeight = 0xA003
+    RelatedSoundFile = 0xA004
+    ExifInteroperabilityOffset = 0xA005
+    FlashEnergy = 0xA20B
+    SpatialFrequencyResponse = 0xA20C
+    FocalPlaneXResolution = 0xA20E
+    FocalPlaneYResolution = 0xA20F
+    FocalPlaneResolutionUnit = 0xA210
+    SubjectLocation = 0xA214
+    ExposureIndex = 0xA215
+    SensingMethod = 0xA217
+    FileSource = 0xA300
+    SceneType = 0xA301
+    CFAPattern = 0xA302
+    CustomRendered = 0xA401
+    ExposureMode = 0xA402
+    WhiteBalance = 0xA403
+    DigitalZoomRatio = 0xA404
+    FocalLengthIn35mmFilm = 0xA405
+    SceneCaptureType = 0xA406
+    GainControl = 0xA407
+    Contrast = 0xA408
+    Saturation = 0xA409
+    Sharpness = 0xA40A
+    DeviceSettingDescription = 0xA40B
+    SubjectDistanceRange = 0xA40C
+    ImageUniqueID = 0xA420
+    CameraOwnerName = 0xA430
+    BodySerialNumber = 0xA431
+    LensSpecification = 0xA432
+    LensMake = 0xA433
+    LensModel = 0xA434
+    LensSerialNumber = 0xA435
+    CompositeImage = 0xA460
+    CompositeImageCount = 0xA461
+    CompositeImageExposureTimes = 0xA462
+    Gamma = 0xA500
+    PrintImageMatching = 0xC4A5
+    DNGVersion = 0xC612
+    DNGBackwardVersion = 0xC613
+    UniqueCameraModel = 0xC614
+    LocalizedCameraModel = 0xC615
+    CFAPlaneColor = 0xC616
+    CFALayout = 0xC617
+    LinearizationTable = 0xC618
+    BlackLevelRepeatDim = 0xC619
+    BlackLevel = 0xC61A
+    BlackLevelDeltaH = 0xC61B
+    BlackLevelDeltaV = 0xC61C
+    WhiteLevel = 0xC61D
+    DefaultScale = 0xC61E
+    DefaultCropOrigin = 0xC61F
+    DefaultCropSize = 0xC620
+    ColorMatrix1 = 0xC621
+    ColorMatrix2 = 0xC622
+    CameraCalibration1 = 0xC623
+    CameraCalibration2 = 0xC624
+    ReductionMatrix1 = 0xC625
+    ReductionMatrix2 = 0xC626
+    AnalogBalance = 0xC627
+    AsShotNeutral = 0xC628
+    AsShotWhiteXY = 0xC629
+    BaselineExposure = 0xC62A
+    BaselineNoise = 0xC62B
+    BaselineSharpness = 0xC62C
+    BayerGreenSplit = 0xC62D
+    LinearResponseLimit = 0xC62E
+    CameraSerialNumber = 0xC62F
+    LensInfo = 0xC630
+    ChromaBlurRadius = 0xC631
+    AntiAliasStrength = 0xC632
+    ShadowScale = 0xC633
+    DNGPrivateData = 0xC634
+    MakerNoteSafety = 0xC635
+    CalibrationIlluminant1 = 0xC65A
+    CalibrationIlluminant2 = 0xC65B
+    BestQualityScale = 0xC65C
+    RawDataUniqueID = 0xC65D
+    OriginalRawFileName = 0xC68B
+    OriginalRawFileData = 0xC68C
+    ActiveArea = 0xC68D
+    MaskedAreas = 0xC68E
+    AsShotICCProfile = 0xC68F
+    AsShotPreProfileMatrix = 0xC690
+    CurrentICCProfile = 0xC691
+    CurrentPreProfileMatrix = 0xC692
+    ColorimetricReference = 0xC6BF
+    CameraCalibrationSignature = 0xC6F3
+    ProfileCalibrationSignature = 0xC6F4
+    AsShotProfileName = 0xC6F6
+    NoiseReductionApplied = 0xC6F7
+    ProfileName = 0xC6F8
+    ProfileHueSatMapDims = 0xC6F9
+    ProfileHueSatMapData1 = 0xC6FA
+    ProfileHueSatMapData2 = 0xC6FB
+    ProfileToneCurve = 0xC6FC
+    ProfileEmbedPolicy = 0xC6FD
+    ProfileCopyright = 0xC6FE
+    ForwardMatrix1 = 0xC714
+    ForwardMatrix2 = 0xC715
+    PreviewApplicationName = 0xC716
+    PreviewApplicationVersion = 0xC717
+    PreviewSettingsName = 0xC718
+    PreviewSettingsDigest = 0xC719
+    PreviewColorSpace = 0xC71A
+    PreviewDateTime = 0xC71B
+    RawImageDigest = 0xC71C
+    OriginalRawFileDigest = 0xC71D
+    SubTileBlockSize = 0xC71E
+    RowInterleaveFactor = 0xC71F
+    ProfileLookTableDims = 0xC725
+    ProfileLookTableData = 0xC726
+    OpcodeList1 = 0xC740
+    OpcodeList2 = 0xC741
+    OpcodeList3 = 0xC74E
+    NoiseProfile = 0xC761
+
+
+"""Maps EXIF tags to tag names."""
+TAGS = {
+    **{i.value: i.name for i in Base},
+    0x920C: "SpatialFrequencyResponse",
+    0x9214: "SubjectLocation",
+    0x9215: "ExposureIndex",
+    0x828E: "CFAPattern",
+    0x920B: "FlashEnergy",
+    0x9216: "TIFF/EPStandardID",
+}
+
+
+class GPS(IntEnum):
+    GPSVersionID = 0x00
+    GPSLatitudeRef = 0x01
+    GPSLatitude = 0x02
+    GPSLongitudeRef = 0x03
+    GPSLongitude = 0x04
+    GPSAltitudeRef = 0x05
+    GPSAltitude = 0x06
+    GPSTimeStamp = 0x07
+    GPSSatellites = 0x08
+    GPSStatus = 0x09
+    GPSMeasureMode = 0x0A
+    GPSDOP = 0x0B
+    GPSSpeedRef = 0x0C
+    GPSSpeed = 0x0D
+    GPSTrackRef = 0x0E
+    GPSTrack = 0x0F
+    GPSImgDirectionRef = 0x10
+    GPSImgDirection = 0x11
+    GPSMapDatum = 0x12
+    GPSDestLatitudeRef = 0x13
+    GPSDestLatitude = 0x14
+    GPSDestLongitudeRef = 0x15
+    GPSDestLongitude = 0x16
+    GPSDestBearingRef = 0x17
+    GPSDestBearing = 0x18
+    GPSDestDistanceRef = 0x19
+    GPSDestDistance = 0x1A
+    GPSProcessingMethod = 0x1B
+    GPSAreaInformation = 0x1C
+    GPSDateStamp = 0x1D
+    GPSDifferential = 0x1E
+    GPSHPositioningError = 0x1F
+
+
+"""Maps EXIF GPS tags to tag names."""
+GPSTAGS = {i.value: i.name for i in GPS}
+
+
+class Interop(IntEnum):
+    InteropIndex = 0x0001
+    InteropVersion = 0x0002
+    RelatedImageFileFormat = 0x1000
+    RelatedImageWidth = 0x1001
+    RelatedImageHeight = 0x1002
+
+
+class IFD(IntEnum):
+    Exif = 0x8769
+    GPSInfo = 0x8825
+    MakerNote = 0x927C
+    Makernote = 0x927C  # Deprecated
+    Interop = 0xA005
+    IFD1 = -1
+
+
+class LightSource(IntEnum):
+    Unknown = 0x00
+    Daylight = 0x01
+    Fluorescent = 0x02
+    Tungsten = 0x03
+    Flash = 0x04
+    Fine = 0x09
+    Cloudy = 0x0A
+    Shade = 0x0B
+    DaylightFluorescent = 0x0C
+    DayWhiteFluorescent = 0x0D
+    CoolWhiteFluorescent = 0x0E
+    WhiteFluorescent = 0x0F
+    StandardLightA = 0x11
+    StandardLightB = 0x12
+    StandardLightC = 0x13
+    D55 = 0x14
+    D65 = 0x15
+    D75 = 0x16
+    D50 = 0x17
+    ISO = 0x18
+    Other = 0xFF

.venv/lib/python3.12/site-packages/PIL/FitsImagePlugin.py

@@ -0,0 +1,152 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# FITS file handling
+#
+# Copyright (c) 1998-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import gzip
+import math
+
+from . import Image, ImageFile
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix.startswith(b"SIMPLE")
+
+
+class FitsImageFile(ImageFile.ImageFile):
+    format = "FITS"
+    format_description = "FITS"
+
+    def _open(self) -> None:
+        assert self.fp is not None
+
+        headers: dict[bytes, bytes] = {}
+        header_in_progress = False
+        decoder_name = ""
+        while True:
+            header = self.fp.read(80)
+            if not header:
+                msg = "Truncated FITS file"
+                raise OSError(msg)
+            keyword = header[:8].strip()
+            if keyword in (b"SIMPLE", b"XTENSION"):
+                header_in_progress = True
+            elif headers and not header_in_progress:
+                # This is now a data unit
+                break
+            elif keyword == b"END":
+                # Seek to the end of the header unit
+                self.fp.seek(math.ceil(self.fp.tell() / 2880) * 2880)
+                if not decoder_name:
+                    decoder_name, offset, args = self._parse_headers(headers)
+
+                header_in_progress = False
+                continue
+
+            if decoder_name:
+                # Keep going to read past the headers
+                continue
+
+            value = header[8:].split(b"/")[0].strip()
+            if value.startswith(b"="):
+                value = value[1:].strip()
+            if not headers and (not _accept(keyword) or value != b"T"):
+                msg = "Not a FITS file"
+                raise SyntaxError(msg)
+            headers[keyword] = value
+
+        if not decoder_name:
+            msg = "No image data"
+            raise ValueError(msg)
+
+        offset += self.fp.tell() - 80
+        self.tile = [ImageFile._Tile(decoder_name, (0, 0) + self.size, offset, args)]
+
+    def _get_size(
+        self, headers: dict[bytes, bytes], prefix: bytes
+    ) -> tuple[int, int] | None:
+        naxis = int(headers[prefix + b"NAXIS"])
+        if naxis == 0:
+            return None
+
+        if naxis == 1:
+            return 1, int(headers[prefix + b"NAXIS1"])
+        else:
+            return int(headers[prefix + b"NAXIS1"]), int(headers[prefix + b"NAXIS2"])
+
+    def _parse_headers(
+        self, headers: dict[bytes, bytes]
+    ) -> tuple[str, int, tuple[str | int, ...]]:
+        prefix = b""
+        decoder_name = "raw"
+        offset = 0
+        if (
+            headers.get(b"XTENSION") == b"'BINTABLE'"
+            and headers.get(b"ZIMAGE") == b"T"
+            and headers[b"ZCMPTYPE"] == b"'GZIP_1  '"
+        ):
+            no_prefix_size = self._get_size(headers, prefix) or (0, 0)
+            number_of_bits = int(headers[b"BITPIX"])
+            offset = no_prefix_size[0] * no_prefix_size[1] * (number_of_bits // 8)
+
+            prefix = b"Z"
+            decoder_name = "fits_gzip"
+
+        size = self._get_size(headers, prefix)
+        if not size:
+            return "", 0, ()
+
+        self._size = size
+
+        number_of_bits = int(headers[prefix + b"BITPIX"])
+        if number_of_bits == 8:
+            self._mode = "L"
+        elif number_of_bits == 16:
+            self._mode = "I;16"
+        elif number_of_bits == 32:
+            self._mode = "I"
+        elif number_of_bits in (-32, -64):
+            self._mode = "F"
+
+        args: tuple[str | int, ...]
+        if decoder_name == "raw":
+            args = (self.mode, 0, -1)
+        else:
+            args = (number_of_bits,)
+        return decoder_name, offset, args
+
+
+class FitsGzipDecoder(ImageFile.PyDecoder):
+    _pulls_fd = True
+
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
+        assert self.fd is not None
+        value = gzip.decompress(self.fd.read())
+
+        rows = []
+        offset = 0
+        number_of_bits = min(self.args[0] // 8, 4)
+        for y in range(self.state.ysize):
+            row = bytearray()
+            for x in range(self.state.xsize):
+                row += value[offset + (4 - number_of_bits) : offset + 4]
+                offset += 4
+            rows.append(row)
+        self.set_as_raw(bytes([pixel for row in rows[::-1] for pixel in row]))
+        return -1, 0
+
+
+# --------------------------------------------------------------------
+# Registry
+
+Image.register_open(FitsImageFile.format, FitsImageFile, _accept)
+Image.register_decoder("fits_gzip", FitsGzipDecoder)
+
+Image.register_extensions(FitsImageFile.format, [".fit", ".fits"])

.venv/lib/python3.12/site-packages/PIL/FliImagePlugin.py

@@ -0,0 +1,184 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# FLI/FLC file handling.
+#
+# History:
+#       95-09-01 fl     Created
+#       97-01-03 fl     Fixed parser, setup decoder tile
+#       98-07-15 fl     Renamed offset attribute to avoid name clash
+#
+# Copyright (c) Secret Labs AB 1997-98.
+# Copyright (c) Fredrik Lundh 1995-97.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import os
+
+from . import Image, ImageFile, ImagePalette
+from ._binary import i16le as i16
+from ._binary import i32le as i32
+from ._binary import o8
+from ._util import DeferredError
+
+#
+# decoder
+
+
+def _accept(prefix: bytes) -> bool:
+    return (
+        len(prefix) >= 16
+        and i16(prefix, 4) in [0xAF11, 0xAF12]
+        and i16(prefix, 14) in [0, 3]  # flags
+    )
+
+
+##
+# Image plugin for the FLI/FLC animation format.  Use the <b>seek</b>
+# method to load individual frames.
+
+
+class FliImageFile(ImageFile.ImageFile):
+    format = "FLI"
+    format_description = "Autodesk FLI/FLC Animation"
+    _close_exclusive_fp_after_loading = False
+
+    def _open(self) -> None:
+        # HEAD
+        assert self.fp is not None
+        s = self.fp.read(128)
+        if not (
+            _accept(s)
+            and s[20:22] == b"\x00" * 2
+            and s[42:80] == b"\x00" * 38
+            and s[88:] == b"\x00" * 40
+        ):
+            msg = "not an FLI/FLC file"
+            raise SyntaxError(msg)
+
+        # frames
+        self.n_frames = i16(s, 6)
+        self.is_animated = self.n_frames > 1
+
+        # image characteristics
+        self._mode = "P"
+        self._size = i16(s, 8), i16(s, 10)
+
+        # animation speed
+        duration = i32(s, 16)
+        magic = i16(s, 4)
+        if magic == 0xAF11:
+            duration = (duration * 1000) // 70
+        self.info["duration"] = duration
+
+        # look for palette
+        palette = [(a, a, a) for a in range(256)]
+
+        s = self.fp.read(16)
+
+        self.__offset = 128
+
+        if i16(s, 4) == 0xF100:
+            # prefix chunk; ignore it
+            self.fp.seek(self.__offset + i32(s))
+            s = self.fp.read(16)
+
+        if i16(s, 4) == 0xF1FA:
+            # look for palette chunk
+            number_of_subchunks = i16(s, 6)
+            chunk_size: int | None = None
+            for _ in range(number_of_subchunks):
+                if chunk_size is not None:
+                    self.fp.seek(chunk_size - 6, os.SEEK_CUR)
+                s = self.fp.read(6)
+                chunk_type = i16(s, 4)
+                if chunk_type in (4, 11):
+                    self._palette(palette, 2 if chunk_type == 11 else 0)
+                    break
+                chunk_size = i32(s)
+                if not chunk_size:
+                    break
+
+        self.palette = ImagePalette.raw(
+            "RGB", b"".join(o8(r) + o8(g) + o8(b) for (r, g, b) in palette)
+        )
+
+        # set things up to decode first frame
+        self.__frame = -1
+        self._fp = self.fp
+        self.__rewind = self.fp.tell()
+        self.seek(0)
+
+    def _palette(self, palette: list[tuple[int, int, int]], shift: int) -> None:
+        # load palette
+
+        i = 0
+        assert self.fp is not None
+        for e in range(i16(self.fp.read(2))):
+            s = self.fp.read(2)
+            i = i + s[0]
+            n = s[1]
+            if n == 0:
+                n = 256
+            s = self.fp.read(n * 3)
+            for n in range(0, len(s), 3):
+                r = s[n] << shift
+                g = s[n + 1] << shift
+                b = s[n + 2] << shift
+                palette[i] = (r, g, b)
+                i += 1
+
+    def seek(self, frame: int) -> None:
+        if not self._seek_check(frame):
+            return
+        if frame < self.__frame:
+            self._seek(0)
+
+        for f in range(self.__frame + 1, frame + 1):
+            self._seek(f)
+
+    def _seek(self, frame: int) -> None:
+        if isinstance(self._fp, DeferredError):
+            raise self._fp.ex
+        if frame == 0:
+            self.__frame = -1
+            self._fp.seek(self.__rewind)
+            self.__offset = 128
+        else:
+            # ensure that the previous frame was loaded
+            self.load()
+
+        if frame != self.__frame + 1:
+            msg = f"cannot seek to frame {frame}"
+            raise ValueError(msg)
+        self.__frame = frame
+
+        # move to next frame
+        self.fp = self._fp
+        self.fp.seek(self.__offset)
+
+        s = self.fp.read(4)
+        if not s:
+            msg = "missing frame size"
+            raise EOFError(msg)
+
+        framesize = i32(s)
+
+        self.decodermaxblock = framesize
+        self.tile = [ImageFile._Tile("fli", (0, 0) + self.size, self.__offset)]
+
+        self.__offset += framesize
+
+    def tell(self) -> int:
+        return self.__frame
+
+
+#
+# registry
+
+Image.register_open(FliImageFile.format, FliImageFile, _accept)
+
+Image.register_extensions(FliImageFile.format, [".fli", ".flc"])

.venv/lib/python3.12/site-packages/PIL/FontFile.py

@@ -0,0 +1,134 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# base class for raster font file parsers
+#
+# history:
+# 1997-06-05 fl   created
+# 1997-08-19 fl   restrict image width
+#
+# Copyright (c) 1997-1998 by Secret Labs AB
+# Copyright (c) 1997-1998 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import os
+from typing import BinaryIO
+
+from . import Image, _binary
+
+WIDTH = 800
+
+
+def puti16(
+    fp: BinaryIO, values: tuple[int, int, int, int, int, int, int, int, int, int]
+) -> None:
+    """Write network order (big-endian) 16-bit sequence"""
+    for v in values:
+        if v < 0:
+            v += 65536
+        fp.write(_binary.o16be(v))
+
+
+class FontFile:
+    """Base class for raster font file handlers."""
+
+    bitmap: Image.Image | None = None
+
+    def __init__(self) -> None:
+        self.info: dict[bytes, bytes | int] = {}
+        self.glyph: list[
+            tuple[
+                tuple[int, int],
+                tuple[int, int, int, int],
+                tuple[int, int, int, int],
+                Image.Image,
+            ]
+            | None
+        ] = [None] * 256
+
+    def __getitem__(self, ix: int) -> (
+        tuple[
+            tuple[int, int],
+            tuple[int, int, int, int],
+            tuple[int, int, int, int],
+            Image.Image,
+        ]
+        | None
+    ):
+        return self.glyph[ix]
+
+    def compile(self) -> None:
+        """Create metrics and bitmap"""
+
+        if self.bitmap:
+            return
+
+        # create bitmap large enough to hold all data
+        h = w = maxwidth = 0
+        lines = 1
+        for glyph in self.glyph:
+            if glyph:
+                d, dst, src, im = glyph
+                h = max(h, src[3] - src[1])
+                w = w + (src[2] - src[0])
+                if w > WIDTH:
+                    lines += 1
+                    w = src[2] - src[0]
+                maxwidth = max(maxwidth, w)
+
+        xsize = maxwidth
+        ysize = lines * h
+
+        if xsize == 0 and ysize == 0:
+            return
+
+        self.ysize = h
+
+        # paste glyphs into bitmap
+        self.bitmap = Image.new("1", (xsize, ysize))
+        self.metrics: list[
+            tuple[tuple[int, int], tuple[int, int, int, int], tuple[int, int, int, int]]
+            | None
+        ] = [None] * 256
+        x = y = 0
+        for i in range(256):
+            glyph = self[i]
+            if glyph:
+                d, dst, src, im = glyph
+                xx = src[2] - src[0]
+                x0, y0 = x, y
+                x = x + xx
+                if x > WIDTH:
+                    x, y = 0, y + h
+                    x0, y0 = x, y
+                    x = xx
+                s = src[0] + x0, src[1] + y0, src[2] + x0, src[3] + y0
+                self.bitmap.paste(im.crop(src), s)
+                self.metrics[i] = d, dst, s
+
+    def save(self, filename: str) -> None:
+        """Save font"""
+
+        self.compile()
+
+        # font data
+        if not self.bitmap:
+            msg = "No bitmap created"
+            raise ValueError(msg)
+        self.bitmap.save(os.path.splitext(filename)[0] + ".pbm", "PNG")
+
+        # font metrics
+        with open(os.path.splitext(filename)[0] + ".pil", "wb") as fp:
+            fp.write(b"PILfont\n")
+            fp.write(f";;;;;;{self.ysize};\n".encode("ascii"))  # HACK!!!
+            fp.write(b"DATA\n")
+            for id in range(256):
+                m = self.metrics[id]
+                if not m:
+                    puti16(fp, (0,) * 10)
+                else:
+                    puti16(fp, m[0] + m[1] + m[2])

.venv/lib/python3.12/site-packages/PIL/FpxImagePlugin.py

@@ -0,0 +1,257 @@
+#
+# THIS IS WORK IN PROGRESS
+#
+# The Python Imaging Library.
+# $Id$
+#
+# FlashPix support for PIL
+#
+# History:
+# 97-01-25 fl   Created (reads uncompressed RGB images only)
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1997.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import olefile
+
+from . import Image, ImageFile
+from ._binary import i32le as i32
+
+# we map from colour field tuples to (mode, rawmode) descriptors
+MODES = {
+    # opacity
+    (0x00007FFE,): ("A", "L"),
+    # monochrome
+    (0x00010000,): ("L", "L"),
+    (0x00018000, 0x00017FFE): ("RGBA", "LA"),
+    # photo YCC
+    (0x00020000, 0x00020001, 0x00020002): ("RGB", "YCC;P"),
+    (0x00028000, 0x00028001, 0x00028002, 0x00027FFE): ("RGBA", "YCCA;P"),
+    # standard RGB (NIFRGB)
+    (0x00030000, 0x00030001, 0x00030002): ("RGB", "RGB"),
+    (0x00038000, 0x00038001, 0x00038002, 0x00037FFE): ("RGBA", "RGBA"),
+}
+
+
+#
+# --------------------------------------------------------------------
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix.startswith(olefile.MAGIC)
+
+
+##
+# Image plugin for the FlashPix images.
+
+
+class FpxImageFile(ImageFile.ImageFile):
+    format = "FPX"
+    format_description = "FlashPix"
+
+    def _open(self) -> None:
+        #
+        # read the OLE directory and see if this is a likely
+        # to be a FlashPix file
+
+        try:
+            self.ole = olefile.OleFileIO(self.fp)
+        except OSError as e:
+            msg = "not an FPX file; invalid OLE file"
+            raise SyntaxError(msg) from e
+
+        root = self.ole.root
+        if not root or root.clsid != "56616700-C154-11CE-8553-00AA00A1F95B":
+            msg = "not an FPX file; bad root CLSID"
+            raise SyntaxError(msg)
+
+        self._open_index(1)
+
+    def _open_index(self, index: int = 1) -> None:
+        #
+        # get the Image Contents Property Set
+
+        prop = self.ole.getproperties(
+            [f"Data Object Store {index:06d}", "\005Image Contents"]
+        )
+
+        # size (highest resolution)
+
+        assert isinstance(prop[0x1000002], int)
+        assert isinstance(prop[0x1000003], int)
+        self._size = prop[0x1000002], prop[0x1000003]
+
+        size = max(self.size)
+        i = 1
+        while size > 64:
+            size = size // 2
+            i += 1
+        self.maxid = i - 1
+
+        # mode.  instead of using a single field for this, flashpix
+        # requires you to specify the mode for each channel in each
+        # resolution subimage, and leaves it to the decoder to make
+        # sure that they all match.  for now, we'll cheat and assume
+        # that this is always the case.
+
+        id = self.maxid << 16
+
+        s = prop[0x2000002 | id]
+
+        if not isinstance(s, bytes) or (bands := i32(s, 4)) > 4:
+            msg = "Invalid number of bands"
+            raise OSError(msg)
+
+        # note: for now, we ignore the "uncalibrated" flag
+        colors = tuple(i32(s, 8 + i * 4) & 0x7FFFFFFF for i in range(bands))
+
+        self._mode, self.rawmode = MODES[colors]
+
+        # load JPEG tables, if any
+        self.jpeg = {}
+        for i in range(256):
+            id = 0x3000001 | (i << 16)
+            if id in prop:
+                self.jpeg[i] = prop[id]
+
+        self._open_subimage(1, self.maxid)
+
+    def _open_subimage(self, index: int = 1, subimage: int = 0) -> None:
+        #
+        # setup tile descriptors for a given subimage
+
+        stream = [
+            f"Data Object Store {index:06d}",
+            f"Resolution {subimage:04d}",
+            "Subimage 0000 Header",
+        ]
+
+        fp = self.ole.openstream(stream)
+
+        # skip prefix
+        fp.read(28)
+
+        # header stream
+        s = fp.read(36)
+
+        size = i32(s, 4), i32(s, 8)
+        # tilecount = i32(s, 12)
+        tilesize = i32(s, 16), i32(s, 20)
+        # channels = i32(s, 24)
+        offset = i32(s, 28)
+        length = i32(s, 32)
+
+        if size != self.size:
+            msg = "subimage mismatch"
+            raise OSError(msg)
+
+        # get tile descriptors
+        fp.seek(28 + offset)
+        s = fp.read(i32(s, 12) * length)
+
+        x = y = 0
+        xsize, ysize = size
+        xtile, ytile = tilesize
+        self.tile = []
+
+        for i in range(0, len(s), length):
+            x1 = min(xsize, x + xtile)
+            y1 = min(ysize, y + ytile)
+
+            compression = i32(s, i + 8)
+
+            if compression == 0:
+                self.tile.append(
+                    ImageFile._Tile(
+                        "raw",
+                        (x, y, x1, y1),
+                        i32(s, i) + 28,
+                        self.rawmode,
+                    )
+                )
+
+            elif compression == 1:
+                # FIXME: the fill decoder is not implemented
+                self.tile.append(
+                    ImageFile._Tile(
+                        "fill",
+                        (x, y, x1, y1),
+                        i32(s, i) + 28,
+                        (self.rawmode, s[12:16]),
+                    )
+                )
+
+            elif compression == 2:
+                internal_color_conversion = s[14]
+                jpeg_tables = s[15]
+                rawmode = self.rawmode
+
+                if internal_color_conversion:
+                    # The image is stored as usual (usually YCbCr).
+                    if rawmode == "RGBA":
+                        # For "RGBA", data is stored as YCbCrA based on
+                        # negative RGB. The following trick works around
+                        # this problem :
+                        jpegmode, rawmode = "YCbCrK", "CMYK"
+                    else:
+                        jpegmode = None  # let the decoder decide
+
+                else:
+                    # The image is stored as defined by rawmode
+                    jpegmode = rawmode
+
+                self.tile.append(
+                    ImageFile._Tile(
+                        "jpeg",
+                        (x, y, x1, y1),
+                        i32(s, i) + 28,
+                        (rawmode, jpegmode),
+                    )
+                )
+
+                # FIXME: jpeg tables are tile dependent; the prefix
+                # data must be placed in the tile descriptor itself!
+
+                if jpeg_tables:
+                    self.tile_prefix = self.jpeg[jpeg_tables]
+
+            else:
+                msg = "unknown/invalid compression"
+                raise OSError(msg)
+
+            x = x + xtile
+            if x >= xsize:
+                x, y = 0, y + ytile
+                if y >= ysize:
+                    break  # isn't really required
+
+        self.stream = stream
+        self._fp = self.fp
+        self.fp = None
+
+    def load(self) -> Image.core.PixelAccess | None:
+        if not self.fp:
+            self.fp = self.ole.openstream(self.stream[:2] + ["Subimage 0000 Data"])
+
+        return ImageFile.ImageFile.load(self)
+
+    def close(self) -> None:
+        self.ole.close()
+        super().close()
+
+    def __exit__(self, *args: object) -> None:
+        self.ole.close()
+        super().__exit__()
+
+
+#
+# --------------------------------------------------------------------
+
+
+Image.register_open(FpxImageFile.format, FpxImageFile, _accept)
+
+Image.register_extension(FpxImageFile.format, ".fpx")

.venv/lib/python3.12/site-packages/PIL/GbrImagePlugin.py

@@ -0,0 +1,101 @@
+#
+# The Python Imaging Library
+#
+# load a GIMP brush file
+#
+# History:
+#       96-03-14 fl     Created
+#       16-01-08 es     Version 2
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1996.
+# Copyright (c) Eric Soroos 2016.
+#
+# See the README file for information on usage and redistribution.
+#
+#
+# See https://github.com/GNOME/gimp/blob/mainline/devel-docs/gbr.txt for
+# format documentation.
+#
+# This code Interprets version 1 and 2 .gbr files.
+# Version 1 files are obsolete, and should not be used for new
+#   brushes.
+# Version 2 files are saved by GIMP v2.8 (at least)
+# Version 3 files have a format specifier of 18 for 16bit floats in
+#   the color depth field. This is currently unsupported by Pillow.
+from __future__ import annotations
+
+from . import Image, ImageFile
+from ._binary import i32be as i32
+
+
+def _accept(prefix: bytes) -> bool:
+    return len(prefix) >= 8 and i32(prefix, 0) >= 20 and i32(prefix, 4) in (1, 2)
+
+
+##
+# Image plugin for the GIMP brush format.
+
+
+class GbrImageFile(ImageFile.ImageFile):
+    format = "GBR"
+    format_description = "GIMP brush file"
+
+    def _open(self) -> None:
+        header_size = i32(self.fp.read(4))
+        if header_size < 20:
+            msg = "not a GIMP brush"
+            raise SyntaxError(msg)
+        version = i32(self.fp.read(4))
+        if version not in (1, 2):
+            msg = f"Unsupported GIMP brush version: {version}"
+            raise SyntaxError(msg)
+
+        width = i32(self.fp.read(4))
+        height = i32(self.fp.read(4))
+        color_depth = i32(self.fp.read(4))
+        if width == 0 or height == 0:
+            msg = "not a GIMP brush"
+            raise SyntaxError(msg)
+        if color_depth not in (1, 4):
+            msg = f"Unsupported GIMP brush color depth: {color_depth}"
+            raise SyntaxError(msg)
+
+        if version == 1:
+            comment_length = header_size - 20
+        else:
+            comment_length = header_size - 28
+            magic_number = self.fp.read(4)
+            if magic_number != b"GIMP":
+                msg = "not a GIMP brush, bad magic number"
+                raise SyntaxError(msg)
+            self.info["spacing"] = i32(self.fp.read(4))
+
+        self.info["comment"] = self.fp.read(comment_length)[:-1]
+
+        if color_depth == 1:
+            self._mode = "L"
+        else:
+            self._mode = "RGBA"
+
+        self._size = width, height
+
+        # Image might not be small
+        Image._decompression_bomb_check(self.size)
+
+        # Data is an uncompressed block of w * h * bytes/pixel
+        self._data_size = width * height * color_depth
+
+    def load(self) -> Image.core.PixelAccess | None:
+        if self._im is None:
+            self.im = Image.core.new(self.mode, self.size)
+            self.frombytes(self.fp.read(self._data_size))
+        return Image.Image.load(self)
+
+
+#
+# registry
+
+
+Image.register_open(GbrImageFile.format, GbrImageFile, _accept)
+Image.register_extension(GbrImageFile.format, ".gbr")

.venv/lib/python3.12/site-packages/PIL/GifImagePlugin.py

@@ -0,0 +1,1215 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# GIF file handling
+#
+# History:
+# 1995-09-01 fl   Created
+# 1996-12-14 fl   Added interlace support
+# 1996-12-30 fl   Added animation support
+# 1997-01-05 fl   Added write support, fixed local colour map bug
+# 1997-02-23 fl   Make sure to load raster data in getdata()
+# 1997-07-05 fl   Support external decoder (0.4)
+# 1998-07-09 fl   Handle all modes when saving (0.5)
+# 1998-07-15 fl   Renamed offset attribute to avoid name clash
+# 2001-04-16 fl   Added rewind support (seek to frame 0) (0.6)
+# 2001-04-17 fl   Added palette optimization (0.7)
+# 2002-06-06 fl   Added transparency support for save (0.8)
+# 2004-02-24 fl   Disable interlacing for small images
+#
+# Copyright (c) 1997-2004 by Secret Labs AB
+# Copyright (c) 1995-2004 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import itertools
+import math
+import os
+import subprocess
+from enum import IntEnum
+from functools import cached_property
+from typing import Any, NamedTuple, cast
+
+from . import (
+    Image,
+    ImageChops,
+    ImageFile,
+    ImageMath,
+    ImageOps,
+    ImagePalette,
+    ImageSequence,
+)
+from ._binary import i16le as i16
+from ._binary import o8
+from ._binary import o16le as o16
+from ._util import DeferredError
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import IO, Literal
+
+    from . import _imaging
+    from ._typing import Buffer
+
+
+class LoadingStrategy(IntEnum):
+    """.. versionadded:: 9.1.0"""
+
+    RGB_AFTER_FIRST = 0
+    RGB_AFTER_DIFFERENT_PALETTE_ONLY = 1
+    RGB_ALWAYS = 2
+
+
+#: .. versionadded:: 9.1.0
+LOADING_STRATEGY = LoadingStrategy.RGB_AFTER_FIRST
+
+# --------------------------------------------------------------------
+# Identify/read GIF files
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix.startswith((b"GIF87a", b"GIF89a"))
+
+
+##
+# Image plugin for GIF images.  This plugin supports both GIF87 and
+# GIF89 images.
+
+
+class GifImageFile(ImageFile.ImageFile):
+    format = "GIF"
+    format_description = "Compuserve GIF"
+    _close_exclusive_fp_after_loading = False
+
+    global_palette = None
+
+    def data(self) -> bytes | None:
+        s = self.fp.read(1)
+        if s and s[0]:
+            return self.fp.read(s[0])
+        return None
+
+    def _is_palette_needed(self, p: bytes) -> bool:
+        for i in range(0, len(p), 3):
+            if not (i // 3 == p[i] == p[i + 1] == p[i + 2]):
+                return True
+        return False
+
+    def _open(self) -> None:
+        # Screen
+        s = self.fp.read(13)
+        if not _accept(s):
+            msg = "not a GIF file"
+            raise SyntaxError(msg)
+
+        self.info["version"] = s[:6]
+        self._size = i16(s, 6), i16(s, 8)
+        flags = s[10]
+        bits = (flags & 7) + 1
+
+        if flags & 128:
+            # get global palette
+            self.info["background"] = s[11]
+            # check if palette contains colour indices
+            p = self.fp.read(3 << bits)
+            if self._is_palette_needed(p):
+                p = ImagePalette.raw("RGB", p)
+                self.global_palette = self.palette = p
+
+        self._fp = self.fp  # FIXME: hack
+        self.__rewind = self.fp.tell()
+        self._n_frames: int | None = None
+        self._seek(0)  # get ready to read first frame
+
+    @property
+    def n_frames(self) -> int:
+        if self._n_frames is None:
+            current = self.tell()
+            try:
+                while True:
+                    self._seek(self.tell() + 1, False)
+            except EOFError:
+                self._n_frames = self.tell() + 1
+            self.seek(current)
+        return self._n_frames
+
+    @cached_property
+    def is_animated(self) -> bool:
+        if self._n_frames is not None:
+            return self._n_frames != 1
+
+        current = self.tell()
+        if current:
+            return True
+
+        try:
+            self._seek(1, False)
+            is_animated = True
+        except EOFError:
+            is_animated = False
+
+        self.seek(current)
+        return is_animated
+
+    def seek(self, frame: int) -> None:
+        if not self._seek_check(frame):
+            return
+        if frame < self.__frame:
+            self._im = None
+            self._seek(0)
+
+        last_frame = self.__frame
+        for f in range(self.__frame + 1, frame + 1):
+            try:
+                self._seek(f)
+            except EOFError as e:
+                self.seek(last_frame)
+                msg = "no more images in GIF file"
+                raise EOFError(msg) from e
+
+    def _seek(self, frame: int, update_image: bool = True) -> None:
+        if isinstance(self._fp, DeferredError):
+            raise self._fp.ex
+        if frame == 0:
+            # rewind
+            self.__offset = 0
+            self.dispose: _imaging.ImagingCore | None = None
+            self.__frame = -1
+            self._fp.seek(self.__rewind)
+            self.disposal_method = 0
+            if "comment" in self.info:
+                del self.info["comment"]
+        else:
+            # ensure that the previous frame was loaded
+            if self.tile and update_image:
+                self.load()
+
+        if frame != self.__frame + 1:
+            msg = f"cannot seek to frame {frame}"
+            raise ValueError(msg)
+
+        self.fp = self._fp
+        if self.__offset:
+            # backup to last frame
+            self.fp.seek(self.__offset)
+            while self.data():
+                pass
+            self.__offset = 0
+
+        s = self.fp.read(1)
+        if not s or s == b";":
+            msg = "no more images in GIF file"
+            raise EOFError(msg)
+
+        palette: ImagePalette.ImagePalette | Literal[False] | None = None
+
+        info: dict[str, Any] = {}
+        frame_transparency = None
+        interlace = None
+        frame_dispose_extent = None
+        while True:
+            if not s:
+                s = self.fp.read(1)
+            if not s or s == b";":
+                break
+
+            elif s == b"!":
+                #
+                # extensions
+                #
+                s = self.fp.read(1)
+                block = self.data()
+                if s[0] == 249 and block is not None:
+                    #
+                    # graphic control extension
+                    #
+                    flags = block[0]
+                    if flags & 1:
+                        frame_transparency = block[3]
+                    info["duration"] = i16(block, 1) * 10
+
+                    # disposal method - find the value of bits 4 - 6
+                    dispose_bits = 0b00011100 & flags
+                    dispose_bits = dispose_bits >> 2
+                    if dispose_bits:
+                        # only set the dispose if it is not
+                        # unspecified. I'm not sure if this is
+                        # correct, but it seems to prevent the last
+                        # frame from looking odd for some animations
+                        self.disposal_method = dispose_bits
+                elif s[0] == 254:
+                    #
+                    # comment extension
+                    #
+                    comment = b""
+
+                    # Read this comment block
+                    while block:
+                        comment += block
+                        block = self.data()
+
+                    if "comment" in info:
+                        # If multiple comment blocks in frame, separate with \n
+                        info["comment"] += b"\n" + comment
+                    else:
+                        info["comment"] = comment
+                    s = None
+                    continue
+                elif s[0] == 255 and frame == 0 and block is not None:
+                    #
+                    # application extension
+                    #
+                    info["extension"] = block, self.fp.tell()
+                    if block.startswith(b"NETSCAPE2.0"):
+                        block = self.data()
+                        if block and len(block) >= 3 and block[0] == 1:
+                            self.info["loop"] = i16(block, 1)
+                while self.data():
+                    pass
+
+            elif s == b",":
+                #
+                # local image
+                #
+                s = self.fp.read(9)
+
+                # extent
+                x0, y0 = i16(s, 0), i16(s, 2)
+                x1, y1 = x0 + i16(s, 4), y0 + i16(s, 6)
+                if (x1 > self.size[0] or y1 > self.size[1]) and update_image:
+                    self._size = max(x1, self.size[0]), max(y1, self.size[1])
+                    Image._decompression_bomb_check(self._size)
+                frame_dispose_extent = x0, y0, x1, y1
+                flags = s[8]
+
+                interlace = (flags & 64) != 0
+
+                if flags & 128:
+                    bits = (flags & 7) + 1
+                    p = self.fp.read(3 << bits)
+                    if self._is_palette_needed(p):
+                        palette = ImagePalette.raw("RGB", p)
+                    else:
+                        palette = False
+
+                # image data
+                bits = self.fp.read(1)[0]
+                self.__offset = self.fp.tell()
+                break
+            s = None
+
+        if interlace is None:
+            msg = "image not found in GIF frame"
+            raise EOFError(msg)
+
+        self.__frame = frame
+        if not update_image:
+            return
+
+        self.tile = []
+
+        if self.dispose:
+            self.im.paste(self.dispose, self.dispose_extent)
+
+        self._frame_palette = palette if palette is not None else self.global_palette
+        self._frame_transparency = frame_transparency
+        if frame == 0:
+            if self._frame_palette:
+                if LOADING_STRATEGY == LoadingStrategy.RGB_ALWAYS:
+                    self._mode = "RGBA" if frame_transparency is not None else "RGB"
+                else:
+                    self._mode = "P"
+            else:
+                self._mode = "L"
+
+            if palette:
+                self.palette = palette
+            elif self.global_palette:
+                from copy import copy
+
+                self.palette = copy(self.global_palette)
+            else:
+                self.palette = None
+        else:
+            if self.mode == "P":
+                if (
+                    LOADING_STRATEGY != LoadingStrategy.RGB_AFTER_DIFFERENT_PALETTE_ONLY
+                    or palette
+                ):
+                    if "transparency" in self.info:
+                        self.im.putpalettealpha(self.info["transparency"], 0)
+                        self.im = self.im.convert("RGBA", Image.Dither.FLOYDSTEINBERG)
+                        self._mode = "RGBA"
+                        del self.info["transparency"]
+                    else:
+                        self._mode = "RGB"
+                        self.im = self.im.convert("RGB", Image.Dither.FLOYDSTEINBERG)
+
+        def _rgb(color: int) -> tuple[int, int, int]:
+            if self._frame_palette:
+                if color * 3 + 3 > len(self._frame_palette.palette):
+                    color = 0
+                return cast(
+                    tuple[int, int, int],
+                    tuple(self._frame_palette.palette[color * 3 : color * 3 + 3]),
+                )
+            else:
+                return (color, color, color)
+
+        self.dispose = None
+        self.dispose_extent: tuple[int, int, int, int] | None = frame_dispose_extent
+        if self.dispose_extent and self.disposal_method >= 2:
+            try:
+                if self.disposal_method == 2:
+                    # replace with background colour
+
+                    # only dispose the extent in this frame
+                    x0, y0, x1, y1 = self.dispose_extent
+                    dispose_size = (x1 - x0, y1 - y0)
+
+                    Image._decompression_bomb_check(dispose_size)
+
+                    # by convention, attempt to use transparency first
+                    dispose_mode = "P"
+                    color = self.info.get("transparency", frame_transparency)
+                    if color is not None:
+                        if self.mode in ("RGB", "RGBA"):
+                            dispose_mode = "RGBA"
+                            color = _rgb(color) + (0,)
+                    else:
+                        color = self.info.get("background", 0)
+                        if self.mode in ("RGB", "RGBA"):
+                            dispose_mode = "RGB"
+                            color = _rgb(color)
+                    self.dispose = Image.core.fill(dispose_mode, dispose_size, color)
+                else:
+                    # replace with previous contents
+                    if self._im is not None:
+                        # only dispose the extent in this frame
+                        self.dispose = self._crop(self.im, self.dispose_extent)
+                    elif frame_transparency is not None:
+                        x0, y0, x1, y1 = self.dispose_extent
+                        dispose_size = (x1 - x0, y1 - y0)
+
+                        Image._decompression_bomb_check(dispose_size)
+                        dispose_mode = "P"
+                        color = frame_transparency
+                        if self.mode in ("RGB", "RGBA"):
+                            dispose_mode = "RGBA"
+                            color = _rgb(frame_transparency) + (0,)
+                        self.dispose = Image.core.fill(
+                            dispose_mode, dispose_size, color
+                        )
+            except AttributeError:
+                pass
+
+        if interlace is not None:
+            transparency = -1
+            if frame_transparency is not None:
+                if frame == 0:
+                    if LOADING_STRATEGY != LoadingStrategy.RGB_ALWAYS:
+                        self.info["transparency"] = frame_transparency
+                elif self.mode not in ("RGB", "RGBA"):
+                    transparency = frame_transparency
+            self.tile = [
+                ImageFile._Tile(
+                    "gif",
+                    (x0, y0, x1, y1),
+                    self.__offset,
+                    (bits, interlace, transparency),
+                )
+            ]
+
+        if info.get("comment"):
+            self.info["comment"] = info["comment"]
+        for k in ["duration", "extension"]:
+            if k in info:
+                self.info[k] = info[k]
+            elif k in self.info:
+                del self.info[k]
+
+    def load_prepare(self) -> None:
+        temp_mode = "P" if self._frame_palette else "L"
+        self._prev_im = None
+        if self.__frame == 0:
+            if self._frame_transparency is not None:
+                self.im = Image.core.fill(
+                    temp_mode, self.size, self._frame_transparency
+                )
+        elif self.mode in ("RGB", "RGBA"):
+            self._prev_im = self.im
+            if self._frame_palette:
+                self.im = Image.core.fill("P", self.size, self._frame_transparency or 0)
+                self.im.putpalette("RGB", *self._frame_palette.getdata())
+            else:
+                self._im = None
+        if not self._prev_im and self._im is not None and self.size != self.im.size:
+            expanded_im = Image.core.fill(self.im.mode, self.size)
+            if self._frame_palette:
+                expanded_im.putpalette("RGB", *self._frame_palette.getdata())
+            expanded_im.paste(self.im, (0, 0) + self.im.size)
+
+            self.im = expanded_im
+        self._mode = temp_mode
+        self._frame_palette = None
+
+        super().load_prepare()
+
+    def load_end(self) -> None:
+        if self.__frame == 0:
+            if self.mode == "P" and LOADING_STRATEGY == LoadingStrategy.RGB_ALWAYS:
+                if self._frame_transparency is not None:
+                    self.im.putpalettealpha(self._frame_transparency, 0)
+                    self._mode = "RGBA"
+                else:
+                    self._mode = "RGB"
+                self.im = self.im.convert(self.mode, Image.Dither.FLOYDSTEINBERG)
+            return
+        if not self._prev_im:
+            return
+        if self.size != self._prev_im.size:
+            if self._frame_transparency is not None:
+                expanded_im = Image.core.fill("RGBA", self.size)
+            else:
+                expanded_im = Image.core.fill("P", self.size)
+                expanded_im.putpalette("RGB", "RGB", self.im.getpalette())
+                expanded_im = expanded_im.convert("RGB")
+            expanded_im.paste(self._prev_im, (0, 0) + self._prev_im.size)
+
+            self._prev_im = expanded_im
+            assert self._prev_im is not None
+        if self._frame_transparency is not None:
+            if self.mode == "L":
+                frame_im = self.im.convert_transparent("LA", self._frame_transparency)
+            else:
+                self.im.putpalettealpha(self._frame_transparency, 0)
+                frame_im = self.im.convert("RGBA")
+        else:
+            frame_im = self.im.convert("RGB")
+
+        assert self.dispose_extent is not None
+        frame_im = self._crop(frame_im, self.dispose_extent)
+
+        self.im = self._prev_im
+        self._mode = self.im.mode
+        if frame_im.mode in ("LA", "RGBA"):
+            self.im.paste(frame_im, self.dispose_extent, frame_im)
+        else:
+            self.im.paste(frame_im, self.dispose_extent)
+
+    def tell(self) -> int:
+        return self.__frame
+
+
+# --------------------------------------------------------------------
+# Write GIF files
+
+
+RAWMODE = {"1": "L", "L": "L", "P": "P"}
+
+
+def _normalize_mode(im: Image.Image) -> Image.Image:
+    """
+    Takes an image (or frame), returns an image in a mode that is appropriate
+    for saving in a Gif.
+
+    It may return the original image, or it may return an image converted to
+    palette or 'L' mode.
+
+    :param im: Image object
+    :returns: Image object
+    """
+    if im.mode in RAWMODE:
+        im.load()
+        return im
+    if Image.getmodebase(im.mode) == "RGB":
+        im = im.convert("P", palette=Image.Palette.ADAPTIVE)
+        assert im.palette is not None
+        if im.palette.mode == "RGBA":
+            for rgba in im.palette.colors:
+                if rgba[3] == 0:
+                    im.info["transparency"] = im.palette.colors[rgba]
+                    break
+        return im
+    return im.convert("L")
+
+
+_Palette = bytes | bytearray | list[int] | ImagePalette.ImagePalette
+
+
+def _normalize_palette(
+    im: Image.Image, palette: _Palette | None, info: dict[str, Any]
+) -> Image.Image:
+    """
+    Normalizes the palette for image.
+      - Sets the palette to the incoming palette, if provided.
+      - Ensures that there's a palette for L mode images
+      - Optimizes the palette if necessary/desired.
+
+    :param im: Image object
+    :param palette: bytes object containing the source palette, or ....
+    :param info: encoderinfo
+    :returns: Image object
+    """
+    source_palette = None
+    if palette:
+        # a bytes palette
+        if isinstance(palette, (bytes, bytearray, list)):
+            source_palette = bytearray(palette[:768])
+        if isinstance(palette, ImagePalette.ImagePalette):
+            source_palette = bytearray(palette.palette)
+
+    if im.mode == "P":
+        if not source_palette:
+            im_palette = im.getpalette(None)
+            assert im_palette is not None
+            source_palette = bytearray(im_palette)
+    else:  # L-mode
+        if not source_palette:
+            source_palette = bytearray(i // 3 for i in range(768))
+        im.palette = ImagePalette.ImagePalette("RGB", palette=source_palette)
+    assert source_palette is not None
+
+    if palette:
+        used_palette_colors: list[int | None] = []
+        assert im.palette is not None
+        for i in range(0, len(source_palette), 3):
+            source_color = tuple(source_palette[i : i + 3])
+            index = im.palette.colors.get(source_color)
+            if index in used_palette_colors:
+                index = None
+            used_palette_colors.append(index)
+        for i, index in enumerate(used_palette_colors):
+            if index is None:
+                for j in range(len(used_palette_colors)):
+                    if j not in used_palette_colors:
+                        used_palette_colors[i] = j
+                        break
+        dest_map: list[int] = []
+        for index in used_palette_colors:
+            assert index is not None
+            dest_map.append(index)
+        im = im.remap_palette(dest_map)
+    else:
+        optimized_palette_colors = _get_optimize(im, info)
+        if optimized_palette_colors is not None:
+            im = im.remap_palette(optimized_palette_colors, source_palette)
+            if "transparency" in info:
+                try:
+                    info["transparency"] = optimized_palette_colors.index(
+                        info["transparency"]
+                    )
+                except ValueError:
+                    del info["transparency"]
+            return im
+
+    assert im.palette is not None
+    im.palette.palette = source_palette
+    return im
+
+
+def _write_single_frame(
+    im: Image.Image,
+    fp: IO[bytes],
+    palette: _Palette | None,
+) -> None:
+    im_out = _normalize_mode(im)
+    for k, v in im_out.info.items():
+        if isinstance(k, str):
+            im.encoderinfo.setdefault(k, v)
+    im_out = _normalize_palette(im_out, palette, im.encoderinfo)
+
+    for s in _get_global_header(im_out, im.encoderinfo):
+        fp.write(s)
+
+    # local image header
+    flags = 0
+    if get_interlace(im):
+        flags = flags | 64
+    _write_local_header(fp, im, (0, 0), flags)
+
+    im_out.encoderconfig = (8, get_interlace(im))
+    ImageFile._save(
+        im_out, fp, [ImageFile._Tile("gif", (0, 0) + im.size, 0, RAWMODE[im_out.mode])]
+    )
+
+    fp.write(b"\0")  # end of image data
+
+
+def _getbbox(
+    base_im: Image.Image, im_frame: Image.Image
+) -> tuple[Image.Image, tuple[int, int, int, int] | None]:
+    palette_bytes = [
+        bytes(im.palette.palette) if im.palette else b"" for im in (base_im, im_frame)
+    ]
+    if palette_bytes[0] != palette_bytes[1]:
+        im_frame = im_frame.convert("RGBA")
+        base_im = base_im.convert("RGBA")
+    delta = ImageChops.subtract_modulo(im_frame, base_im)
+    return delta, delta.getbbox(alpha_only=False)
+
+
+class _Frame(NamedTuple):
+    im: Image.Image
+    bbox: tuple[int, int, int, int] | None
+    encoderinfo: dict[str, Any]
+
+
+def _write_multiple_frames(
+    im: Image.Image, fp: IO[bytes], palette: _Palette | None
+) -> bool:
+    duration = im.encoderinfo.get("duration")
+    disposal = im.encoderinfo.get("disposal", im.info.get("disposal"))
+
+    im_frames: list[_Frame] = []
+    previous_im: Image.Image | None = None
+    frame_count = 0
+    background_im = None
+    for imSequence in itertools.chain([im], im.encoderinfo.get("append_images", [])):
+        for im_frame in ImageSequence.Iterator(imSequence):
+            # a copy is required here since seek can still mutate the image
+            im_frame = _normalize_mode(im_frame.copy())
+            if frame_count == 0:
+                for k, v in im_frame.info.items():
+                    if k == "transparency":
+                        continue
+                    if isinstance(k, str):
+                        im.encoderinfo.setdefault(k, v)
+
+            encoderinfo = im.encoderinfo.copy()
+            if "transparency" in im_frame.info:
+                encoderinfo.setdefault("transparency", im_frame.info["transparency"])
+            im_frame = _normalize_palette(im_frame, palette, encoderinfo)
+            if isinstance(duration, (list, tuple)):
+                encoderinfo["duration"] = duration[frame_count]
+            elif duration is None and "duration" in im_frame.info:
+                encoderinfo["duration"] = im_frame.info["duration"]
+            if isinstance(disposal, (list, tuple)):
+                encoderinfo["disposal"] = disposal[frame_count]
+            frame_count += 1
+
+            diff_frame = None
+            if im_frames and previous_im:
+                # delta frame
+                delta, bbox = _getbbox(previous_im, im_frame)
+                if not bbox:
+                    # This frame is identical to the previous frame
+                    if encoderinfo.get("duration"):
+                        im_frames[-1].encoderinfo["duration"] += encoderinfo["duration"]
+                    continue
+                if im_frames[-1].encoderinfo.get("disposal") == 2:
+                    # To appear correctly in viewers using a convention,
+                    # only consider transparency, and not background color
+                    color = im.encoderinfo.get(
+                        "transparency", im.info.get("transparency")
+                    )
+                    if color is not None:
+                        if background_im is None:
+                            background = _get_background(im_frame, color)
+                            background_im = Image.new("P", im_frame.size, background)
+                            first_palette = im_frames[0].im.palette
+                            assert first_palette is not None
+                            background_im.putpalette(first_palette, first_palette.mode)
+                        bbox = _getbbox(background_im, im_frame)[1]
+                    else:
+                        bbox = (0, 0) + im_frame.size
+                elif encoderinfo.get("optimize") and im_frame.mode != "1":
+                    if "transparency" not in encoderinfo:
+                        assert im_frame.palette is not None
+                        try:
+                            encoderinfo["transparency"] = (
+                                im_frame.palette._new_color_index(im_frame)
+                            )
+                        except ValueError:
+                            pass
+                    if "transparency" in encoderinfo:
+                        # When the delta is zero, fill the image with transparency
+                        diff_frame = im_frame.copy()
+                        fill = Image.new("P", delta.size, encoderinfo["transparency"])
+                        if delta.mode == "RGBA":
+                            r, g, b, a = delta.split()
+                            mask = ImageMath.lambda_eval(
+                                lambda args: args["convert"](
+                                    args["max"](
+                                        args["max"](
+                                            args["max"](args["r"], args["g"]), args["b"]
+                                        ),
+                                        args["a"],
+                                    )
+                                    * 255,
+                                    "1",
+                                ),
+                                r=r,
+                                g=g,
+                                b=b,
+                                a=a,
+                            )
+                        else:
+                            if delta.mode == "P":
+                                # Convert to L without considering palette
+                                delta_l = Image.new("L", delta.size)
+                                delta_l.putdata(delta.getdata())
+                                delta = delta_l
+                            mask = ImageMath.lambda_eval(
+                                lambda args: args["convert"](args["im"] * 255, "1"),
+                                im=delta,
+                            )
+                        diff_frame.paste(fill, mask=ImageOps.invert(mask))
+            else:
+                bbox = None
+            previous_im = im_frame
+            im_frames.append(_Frame(diff_frame or im_frame, bbox, encoderinfo))
+
+    if len(im_frames) == 1:
+        if "duration" in im.encoderinfo:
+            # Since multiple frames will not be written, use the combined duration
+            im.encoderinfo["duration"] = im_frames[0].encoderinfo["duration"]
+        return False
+
+    for frame_data in im_frames:
+        im_frame = frame_data.im
+        if not frame_data.bbox:
+            # global header
+            for s in _get_global_header(im_frame, frame_data.encoderinfo):
+                fp.write(s)
+            offset = (0, 0)
+        else:
+            # compress difference
+            if not palette:
+                frame_data.encoderinfo["include_color_table"] = True
+
+            if frame_data.bbox != (0, 0) + im_frame.size:
+                im_frame = im_frame.crop(frame_data.bbox)
+            offset = frame_data.bbox[:2]
+        _write_frame_data(fp, im_frame, offset, frame_data.encoderinfo)
+    return True
+
+
+def _save_all(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    _save(im, fp, filename, save_all=True)
+
+
+def _save(
+    im: Image.Image, fp: IO[bytes], filename: str | bytes, save_all: bool = False
+) -> None:
+    # header
+    if "palette" in im.encoderinfo or "palette" in im.info:
+        palette = im.encoderinfo.get("palette", im.info.get("palette"))
+    else:
+        palette = None
+        im.encoderinfo.setdefault("optimize", True)
+
+    if not save_all or not _write_multiple_frames(im, fp, palette):
+        _write_single_frame(im, fp, palette)
+
+    fp.write(b";")  # end of file
+
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+
+def get_interlace(im: Image.Image) -> int:
+    interlace = im.encoderinfo.get("interlace", 1)
+
+    # workaround for @PIL153
+    if min(im.size) < 16:
+        interlace = 0
+
+    return interlace
+
+
+def _write_local_header(
+    fp: IO[bytes], im: Image.Image, offset: tuple[int, int], flags: int
+) -> None:
+    try:
+        transparency = im.encoderinfo["transparency"]
+    except KeyError:
+        transparency = None
+
+    if "duration" in im.encoderinfo:
+        duration = int(im.encoderinfo["duration"] / 10)
+    else:
+        duration = 0
+
+    disposal = int(im.encoderinfo.get("disposal", 0))
+
+    if transparency is not None or duration != 0 or disposal:
+        packed_flag = 1 if transparency is not None else 0
+        packed_flag |= disposal << 2
+
+        fp.write(
+            b"!"
+            + o8(249)  # extension intro
+            + o8(4)  # length
+            + o8(packed_flag)  # packed fields
+            + o16(duration)  # duration
+            + o8(transparency or 0)  # transparency index
+            + o8(0)
+        )
+
+    include_color_table = im.encoderinfo.get("include_color_table")
+    if include_color_table:
+        palette_bytes = _get_palette_bytes(im)
+        color_table_size = _get_color_table_size(palette_bytes)
+        if color_table_size:
+            flags = flags | 128  # local color table flag
+            flags = flags | color_table_size
+
+    fp.write(
+        b","
+        + o16(offset[0])  # offset
+        + o16(offset[1])
+        + o16(im.size[0])  # size
+        + o16(im.size[1])
+        + o8(flags)  # flags
+    )
+    if include_color_table and color_table_size:
+        fp.write(_get_header_palette(palette_bytes))
+    fp.write(o8(8))  # bits
+
+
+def _save_netpbm(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    # Unused by default.
+    # To use, uncomment the register_save call at the end of the file.
+    #
+    # If you need real GIF compression and/or RGB quantization, you
+    # can use the external NETPBM/PBMPLUS utilities.  See comments
+    # below for information on how to enable this.
+    tempfile = im._dump()
+
+    try:
+        with open(filename, "wb") as f:
+            if im.mode != "RGB":
+                subprocess.check_call(
+                    ["ppmtogif", tempfile], stdout=f, stderr=subprocess.DEVNULL
+                )
+            else:
+                # Pipe ppmquant output into ppmtogif
+                # "ppmquant 256 %s | ppmtogif > %s" % (tempfile, filename)
+                quant_cmd = ["ppmquant", "256", tempfile]
+                togif_cmd = ["ppmtogif"]
+                quant_proc = subprocess.Popen(
+                    quant_cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL
+                )
+                togif_proc = subprocess.Popen(
+                    togif_cmd,
+                    stdin=quant_proc.stdout,
+                    stdout=f,
+                    stderr=subprocess.DEVNULL,
+                )
+
+                # Allow ppmquant to receive SIGPIPE if ppmtogif exits
+                assert quant_proc.stdout is not None
+                quant_proc.stdout.close()
+
+                retcode = quant_proc.wait()
+                if retcode:
+                    raise subprocess.CalledProcessError(retcode, quant_cmd)
+
+                retcode = togif_proc.wait()
+                if retcode:
+                    raise subprocess.CalledProcessError(retcode, togif_cmd)
+    finally:
+        try:
+            os.unlink(tempfile)
+        except OSError:
+            pass
+
+
+# Force optimization so that we can test performance against
+# cases where it took lots of memory and time previously.
+_FORCE_OPTIMIZE = False
+
+
+def _get_optimize(im: Image.Image, info: dict[str, Any]) -> list[int] | None:
+    """
+    Palette optimization is a potentially expensive operation.
+
+    This function determines if the palette should be optimized using
+    some heuristics, then returns the list of palette entries in use.
+
+    :param im: Image object
+    :param info: encoderinfo
+    :returns: list of indexes of palette entries in use, or None
+    """
+    if im.mode in ("P", "L") and info and info.get("optimize"):
+        # Potentially expensive operation.
+
+        # The palette saves 3 bytes per color not used, but palette
+        # lengths are restricted to 3*(2**N) bytes. Max saving would
+        # be 768 -> 6 bytes if we went all the way down to 2 colors.
+        # * If we're over 128 colors, we can't save any space.
+        # * If there aren't any holes, it's not worth collapsing.
+        # * If we have a 'large' image, the palette is in the noise.
+
+        # create the new palette if not every color is used
+        optimise = _FORCE_OPTIMIZE or im.mode == "L"
+        if optimise or im.width * im.height < 512 * 512:
+            # check which colors are used
+            used_palette_colors = []
+            for i, count in enumerate(im.histogram()):
+                if count:
+                    used_palette_colors.append(i)
+
+            if optimise or max(used_palette_colors) >= len(used_palette_colors):
+                return used_palette_colors
+
+            assert im.palette is not None
+            num_palette_colors = len(im.palette.palette) // Image.getmodebands(
+                im.palette.mode
+            )
+            current_palette_size = 1 << (num_palette_colors - 1).bit_length()
+            if (
+                # check that the palette would become smaller when saved
+                len(used_palette_colors) <= current_palette_size // 2
+                # check that the palette is not already the smallest possible size
+                and current_palette_size > 2
+            ):
+                return used_palette_colors
+    return None
+
+
+def _get_color_table_size(palette_bytes: bytes) -> int:
+    # calculate the palette size for the header
+    if not palette_bytes:
+        return 0
+    elif len(palette_bytes) < 9:
+        return 1
+    else:
+        return math.ceil(math.log(len(palette_bytes) // 3, 2)) - 1
+
+
+def _get_header_palette(palette_bytes: bytes) -> bytes:
+    """
+    Returns the palette, null padded to the next power of 2 (*3) bytes
+    suitable for direct inclusion in the GIF header
+
+    :param palette_bytes: Unpadded palette bytes, in RGBRGB form
+    :returns: Null padded palette
+    """
+    color_table_size = _get_color_table_size(palette_bytes)
+
+    # add the missing amount of bytes
+    # the palette has to be 2<<n in size
+    actual_target_size_diff = (2 << color_table_size) - len(palette_bytes) // 3
+    if actual_target_size_diff > 0:
+        palette_bytes += o8(0) * 3 * actual_target_size_diff
+    return palette_bytes
+
+
+def _get_palette_bytes(im: Image.Image) -> bytes:
+    """
+    Gets the palette for inclusion in the gif header
+
+    :param im: Image object
+    :returns: Bytes, len<=768 suitable for inclusion in gif header
+    """
+    if not im.palette:
+        return b""
+
+    palette = bytes(im.palette.palette)
+    if im.palette.mode == "RGBA":
+        palette = b"".join(palette[i * 4 : i * 4 + 3] for i in range(len(palette) // 3))
+    return palette
+
+
+def _get_background(
+    im: Image.Image,
+    info_background: int | tuple[int, int, int] | tuple[int, int, int, int] | None,
+) -> int:
+    background = 0
+    if info_background:
+        if isinstance(info_background, tuple):
+            # WebPImagePlugin stores an RGBA value in info["background"]
+            # So it must be converted to the same format as GifImagePlugin's
+            # info["background"] - a global color table index
+            assert im.palette is not None
+            try:
+                background = im.palette.getcolor(info_background, im)
+            except ValueError as e:
+                if str(e) not in (
+                    # If all 256 colors are in use,
+                    # then there is no need for the background color
+                    "cannot allocate more than 256 colors",
+                    # Ignore non-opaque WebP background
+                    "cannot add non-opaque RGBA color to RGB palette",
+                ):
+                    raise
+        else:
+            background = info_background
+    return background
+
+
+def _get_global_header(im: Image.Image, info: dict[str, Any]) -> list[bytes]:
+    """Return a list of strings representing a GIF header"""
+
+    # Header Block
+    # https://www.matthewflickinger.com/lab/whatsinagif/bits_and_bytes.asp
+
+    version = b"87a"
+    if im.info.get("version") == b"89a" or (
+        info
+        and (
+            "transparency" in info
+            or info.get("loop") is not None
+            or info.get("duration")
+            or info.get("comment")
+        )
+    ):
+        version = b"89a"
+
+    background = _get_background(im, info.get("background"))
+
+    palette_bytes = _get_palette_bytes(im)
+    color_table_size = _get_color_table_size(palette_bytes)
+
+    header = [
+        b"GIF"  # signature
+        + version  # version
+        + o16(im.size[0])  # canvas width
+        + o16(im.size[1]),  # canvas height
+        # Logical Screen Descriptor
+        # size of global color table + global color table flag
+        o8(color_table_size + 128),  # packed fields
+        # background + reserved/aspect
+        o8(background) + o8(0),
+        # Global Color Table
+        _get_header_palette(palette_bytes),
+    ]
+    if info.get("loop") is not None:
+        header.append(
+            b"!"
+            + o8(255)  # extension intro
+            + o8(11)
+            + b"NETSCAPE2.0"
+            + o8(3)
+            + o8(1)
+            + o16(info["loop"])  # number of loops
+            + o8(0)
+        )
+    if info.get("comment"):
+        comment_block = b"!" + o8(254)  # extension intro
+
+        comment = info["comment"]
+        if isinstance(comment, str):
+            comment = comment.encode()
+        for i in range(0, len(comment), 255):
+            subblock = comment[i : i + 255]
+            comment_block += o8(len(subblock)) + subblock
+
+        comment_block += o8(0)
+        header.append(comment_block)
+    return header
+
+
+def _write_frame_data(
+    fp: IO[bytes],
+    im_frame: Image.Image,
+    offset: tuple[int, int],
+    params: dict[str, Any],
+) -> None:
+    try:
+        im_frame.encoderinfo = params
+
+        # local image header
+        _write_local_header(fp, im_frame, offset, 0)
+
+        ImageFile._save(
+            im_frame,
+            fp,
+            [ImageFile._Tile("gif", (0, 0) + im_frame.size, 0, RAWMODE[im_frame.mode])],
+        )
+
+        fp.write(b"\0")  # end of image data
+    finally:
+        del im_frame.encoderinfo
+
+
+# --------------------------------------------------------------------
+# Legacy GIF utilities
+
+
+def getheader(
+    im: Image.Image, palette: _Palette | None = None, info: dict[str, Any] | None = None
+) -> tuple[list[bytes], list[int] | None]:
+    """
+    Legacy Method to get Gif data from image.
+
+    Warning:: May modify image data.
+
+    :param im: Image object
+    :param palette: bytes object containing the source palette, or ....
+    :param info: encoderinfo
+    :returns: tuple of(list of header items, optimized palette)
+
+    """
+    if info is None:
+        info = {}
+
+    used_palette_colors = _get_optimize(im, info)
+
+    if "background" not in info and "background" in im.info:
+        info["background"] = im.info["background"]
+
+    im_mod = _normalize_palette(im, palette, info)
+    im.palette = im_mod.palette
+    im.im = im_mod.im
+    header = _get_global_header(im, info)
+
+    return header, used_palette_colors
+
+
+def getdata(
+    im: Image.Image, offset: tuple[int, int] = (0, 0), **params: Any
+) -> list[bytes]:
+    """
+    Legacy Method
+
+    Return a list of strings representing this image.
+    The first string is a local image header, the rest contains
+    encoded image data.
+
+    To specify duration, add the time in milliseconds,
+    e.g. ``getdata(im_frame, duration=1000)``
+
+    :param im: Image object
+    :param offset: Tuple of (x, y) pixels. Defaults to (0, 0)
+    :param \\**params: e.g. duration or other encoder info parameters
+    :returns: List of bytes containing GIF encoded frame data
+
+    """
+    from io import BytesIO
+
+    class Collector(BytesIO):
+        data = []
+
+        def write(self, data: Buffer) -> int:
+            self.data.append(data)
+            return len(data)
+
+    im.load()  # make sure raster data is available
+
+    fp = Collector()
+
+    _write_frame_data(fp, im, offset, params)
+
+    return fp.data
+
+
+# --------------------------------------------------------------------
+# Registry
+
+Image.register_open(GifImageFile.format, GifImageFile, _accept)
+Image.register_save(GifImageFile.format, _save)
+Image.register_save_all(GifImageFile.format, _save_all)
+Image.register_extension(GifImageFile.format, ".gif")
+Image.register_mime(GifImageFile.format, "image/gif")
+
+#
+# Uncomment the following line if you wish to use NETPBM/PBMPLUS
+# instead of the built-in "uncompressed" GIF encoder
+
+# Image.register_save(GifImageFile.format, _save_netpbm)

.venv/lib/python3.12/site-packages/PIL/GimpPaletteFile.py

@@ -0,0 +1,75 @@
+#
+# Python Imaging Library
+# $Id$
+#
+# stuff to read GIMP palette files
+#
+# History:
+# 1997-08-23 fl     Created
+# 2004-09-07 fl     Support GIMP 2.0 palette files.
+#
+# Copyright (c) Secret Labs AB 1997-2004.  All rights reserved.
+# Copyright (c) Fredrik Lundh 1997-2004.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import re
+from io import BytesIO
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import IO
+
+
+class GimpPaletteFile:
+    """File handler for GIMP's palette format."""
+
+    rawmode = "RGB"
+
+    def _read(self, fp: IO[bytes], limit: bool = True) -> None:
+        if not fp.readline().startswith(b"GIMP Palette"):
+            msg = "not a GIMP palette file"
+            raise SyntaxError(msg)
+
+        palette: list[int] = []
+        i = 0
+        while True:
+            if limit and i == 256 + 3:
+                break
+
+            i += 1
+            s = fp.readline()
+            if not s:
+                break
+
+            # skip fields and comment lines
+            if re.match(rb"\w+:|#", s):
+                continue
+            if limit and len(s) > 100:
+                msg = "bad palette file"
+                raise SyntaxError(msg)
+
+            v = s.split(maxsplit=3)
+            if len(v) < 3:
+                msg = "bad palette entry"
+                raise ValueError(msg)
+
+            palette += (int(v[i]) for i in range(3))
+            if limit and len(palette) == 768:
+                break
+
+        self.palette = bytes(palette)
+
+    def __init__(self, fp: IO[bytes]) -> None:
+        self._read(fp)
+
+    @classmethod
+    def frombytes(cls, data: bytes) -> GimpPaletteFile:
+        self = cls.__new__(cls)
+        self._read(BytesIO(data), False)
+        return self
+
+    def getpalette(self) -> tuple[bytes, str]:
+        return self.palette, self.rawmode

.venv/lib/python3.12/site-packages/PIL/GribStubImagePlugin.py

@@ -0,0 +1,75 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# GRIB stub adapter
+#
+# Copyright (c) 1996-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import os
+from typing import IO
+
+from . import Image, ImageFile
+
+_handler = None
+
+
+def register_handler(handler: ImageFile.StubHandler | None) -> None:
+    """
+    Install application-specific GRIB image handler.
+
+    :param handler: Handler object.
+    """
+    global _handler
+    _handler = handler
+
+
+# --------------------------------------------------------------------
+# Image adapter
+
+
+def _accept(prefix: bytes) -> bool:
+    return len(prefix) >= 8 and prefix.startswith(b"GRIB") and prefix[7] == 1
+
+
+class GribStubImageFile(ImageFile.StubImageFile):
+    format = "GRIB"
+    format_description = "GRIB"
+
+    def _open(self) -> None:
+        if not _accept(self.fp.read(8)):
+            msg = "Not a GRIB file"
+            raise SyntaxError(msg)
+
+        self.fp.seek(-8, os.SEEK_CUR)
+
+        # make something up
+        self._mode = "F"
+        self._size = 1, 1
+
+        loader = self._load()
+        if loader:
+            loader.open(self)
+
+    def _load(self) -> ImageFile.StubHandler | None:
+        return _handler
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    if _handler is None or not hasattr(_handler, "save"):
+        msg = "GRIB save handler not installed"
+        raise OSError(msg)
+    _handler.save(im, fp, filename)
+
+
+# --------------------------------------------------------------------
+# Registry
+
+Image.register_open(GribStubImageFile.format, GribStubImageFile, _accept)
+Image.register_save(GribStubImageFile.format, _save)
+
+Image.register_extension(GribStubImageFile.format, ".grib")

.venv/lib/python3.12/site-packages/PIL/IcnsImagePlugin.py

@@ -0,0 +1,401 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# macOS icns file decoder, based on icns.py by Bob Ippolito.
+#
+# history:
+# 2004-10-09 fl   Turned into a PIL plugin; removed 2.3 dependencies.
+# 2020-04-04      Allow saving on all operating systems.
+#
+# Copyright (c) 2004 by Bob Ippolito.
+# Copyright (c) 2004 by Secret Labs.
+# Copyright (c) 2004 by Fredrik Lundh.
+# Copyright (c) 2014 by Alastair Houghton.
+# Copyright (c) 2020 by Pan Jing.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import io
+import os
+import struct
+import sys
+from typing import IO
+
+from . import Image, ImageFile, PngImagePlugin, features
+
+enable_jpeg2k = features.check_codec("jpg_2000")
+if enable_jpeg2k:
+    from . import Jpeg2KImagePlugin
+
+MAGIC = b"icns"
+HEADERSIZE = 8
+
+
+def nextheader(fobj: IO[bytes]) -> tuple[bytes, int]:
+    return struct.unpack(">4sI", fobj.read(HEADERSIZE))
+
+
+def read_32t(
+    fobj: IO[bytes], start_length: tuple[int, int], size: tuple[int, int, int]
+) -> dict[str, Image.Image]:
+    # The 128x128 icon seems to have an extra header for some reason.
+    (start, length) = start_length
+    fobj.seek(start)
+    sig = fobj.read(4)
+    if sig != b"\x00\x00\x00\x00":
+        msg = "Unknown signature, expecting 0x00000000"
+        raise SyntaxError(msg)
+    return read_32(fobj, (start + 4, length - 4), size)
+
+
+def read_32(
+    fobj: IO[bytes], start_length: tuple[int, int], size: tuple[int, int, int]
+) -> dict[str, Image.Image]:
+    """
+    Read a 32bit RGB icon resource.  Seems to be either uncompressed or
+    an RLE packbits-like scheme.
+    """
+    (start, length) = start_length
+    fobj.seek(start)
+    pixel_size = (size[0] * size[2], size[1] * size[2])
+    sizesq = pixel_size[0] * pixel_size[1]
+    if length == sizesq * 3:
+        # uncompressed ("RGBRGBGB")
+        indata = fobj.read(length)
+        im = Image.frombuffer("RGB", pixel_size, indata, "raw", "RGB", 0, 1)
+    else:
+        # decode image
+        im = Image.new("RGB", pixel_size, None)
+        for band_ix in range(3):
+            data = []
+            bytesleft = sizesq
+            while bytesleft > 0:
+                byte = fobj.read(1)
+                if not byte:
+                    break
+                byte_int = byte[0]
+                if byte_int & 0x80:
+                    blocksize = byte_int - 125
+                    byte = fobj.read(1)
+                    for i in range(blocksize):
+                        data.append(byte)
+                else:
+                    blocksize = byte_int + 1
+                    data.append(fobj.read(blocksize))
+                bytesleft -= blocksize
+                if bytesleft <= 0:
+                    break
+            if bytesleft != 0:
+                msg = f"Error reading channel [{repr(bytesleft)} left]"
+                raise SyntaxError(msg)
+            band = Image.frombuffer("L", pixel_size, b"".join(data), "raw", "L", 0, 1)
+            im.im.putband(band.im, band_ix)
+    return {"RGB": im}
+
+
+def read_mk(
+    fobj: IO[bytes], start_length: tuple[int, int], size: tuple[int, int, int]
+) -> dict[str, Image.Image]:
+    # Alpha masks seem to be uncompressed
+    start = start_length[0]
+    fobj.seek(start)
+    pixel_size = (size[0] * size[2], size[1] * size[2])
+    sizesq = pixel_size[0] * pixel_size[1]
+    band = Image.frombuffer("L", pixel_size, fobj.read(sizesq), "raw", "L", 0, 1)
+    return {"A": band}
+
+
+def read_png_or_jpeg2000(
+    fobj: IO[bytes], start_length: tuple[int, int], size: tuple[int, int, int]
+) -> dict[str, Image.Image]:
+    (start, length) = start_length
+    fobj.seek(start)
+    sig = fobj.read(12)
+
+    im: Image.Image
+    if sig.startswith(b"\x89PNG\x0d\x0a\x1a\x0a"):
+        fobj.seek(start)
+        im = PngImagePlugin.PngImageFile(fobj)
+        Image._decompression_bomb_check(im.size)
+        return {"RGBA": im}
+    elif (
+        sig.startswith((b"\xff\x4f\xff\x51", b"\x0d\x0a\x87\x0a"))
+        or sig == b"\x00\x00\x00\x0cjP  \x0d\x0a\x87\x0a"
+    ):
+        if not enable_jpeg2k:
+            msg = (
+                "Unsupported icon subimage format (rebuild PIL "
+                "with JPEG 2000 support to fix this)"
+            )
+            raise ValueError(msg)
+        # j2k, jpc or j2c
+        fobj.seek(start)
+        jp2kstream = fobj.read(length)
+        f = io.BytesIO(jp2kstream)
+        im = Jpeg2KImagePlugin.Jpeg2KImageFile(f)
+        Image._decompression_bomb_check(im.size)
+        if im.mode != "RGBA":
+            im = im.convert("RGBA")
+        return {"RGBA": im}
+    else:
+        msg = "Unsupported icon subimage format"
+        raise ValueError(msg)
+
+
+class IcnsFile:
+    SIZES = {
+        (512, 512, 2): [(b"ic10", read_png_or_jpeg2000)],
+        (512, 512, 1): [(b"ic09", read_png_or_jpeg2000)],
+        (256, 256, 2): [(b"ic14", read_png_or_jpeg2000)],
+        (256, 256, 1): [(b"ic08", read_png_or_jpeg2000)],
+        (128, 128, 2): [(b"ic13", read_png_or_jpeg2000)],
+        (128, 128, 1): [
+            (b"ic07", read_png_or_jpeg2000),
+            (b"it32", read_32t),
+            (b"t8mk", read_mk),
+        ],
+        (64, 64, 1): [(b"icp6", read_png_or_jpeg2000)],
+        (32, 32, 2): [(b"ic12", read_png_or_jpeg2000)],
+        (48, 48, 1): [(b"ih32", read_32), (b"h8mk", read_mk)],
+        (32, 32, 1): [
+            (b"icp5", read_png_or_jpeg2000),
+            (b"il32", read_32),
+            (b"l8mk", read_mk),
+        ],
+        (16, 16, 2): [(b"ic11", read_png_or_jpeg2000)],
+        (16, 16, 1): [
+            (b"icp4", read_png_or_jpeg2000),
+            (b"is32", read_32),
+            (b"s8mk", read_mk),
+        ],
+    }
+
+    def __init__(self, fobj: IO[bytes]) -> None:
+        """
+        fobj is a file-like object as an icns resource
+        """
+        # signature : (start, length)
+        self.dct = {}
+        self.fobj = fobj
+        sig, filesize = nextheader(fobj)
+        if not _accept(sig):
+            msg = "not an icns file"
+            raise SyntaxError(msg)
+        i = HEADERSIZE
+        while i < filesize:
+            sig, blocksize = nextheader(fobj)
+            if blocksize <= 0:
+                msg = "invalid block header"
+                raise SyntaxError(msg)
+            i += HEADERSIZE
+            blocksize -= HEADERSIZE
+            self.dct[sig] = (i, blocksize)
+            fobj.seek(blocksize, io.SEEK_CUR)
+            i += blocksize
+
+    def itersizes(self) -> list[tuple[int, int, int]]:
+        sizes = []
+        for size, fmts in self.SIZES.items():
+            for fmt, reader in fmts:
+                if fmt in self.dct:
+                    sizes.append(size)
+                    break
+        return sizes
+
+    def bestsize(self) -> tuple[int, int, int]:
+        sizes = self.itersizes()
+        if not sizes:
+            msg = "No 32bit icon resources found"
+            raise SyntaxError(msg)
+        return max(sizes)
+
+    def dataforsize(self, size: tuple[int, int, int]) -> dict[str, Image.Image]:
+        """
+        Get an icon resource as {channel: array}.  Note that
+        the arrays are bottom-up like windows bitmaps and will likely
+        need to be flipped or transposed in some way.
+        """
+        dct = {}
+        for code, reader in self.SIZES[size]:
+            desc = self.dct.get(code)
+            if desc is not None:
+                dct.update(reader(self.fobj, desc, size))
+        return dct
+
+    def getimage(
+        self, size: tuple[int, int] | tuple[int, int, int] | None = None
+    ) -> Image.Image:
+        if size is None:
+            size = self.bestsize()
+        elif len(size) == 2:
+            size = (size[0], size[1], 1)
+        channels = self.dataforsize(size)
+
+        im = channels.get("RGBA")
+        if im:
+            return im
+
+        im = channels["RGB"].copy()
+        try:
+            im.putalpha(channels["A"])
+        except KeyError:
+            pass
+        return im
+
+
+##
+# Image plugin for Mac OS icons.
+
+
+class IcnsImageFile(ImageFile.ImageFile):
+    """
+    PIL image support for Mac OS .icns files.
+    Chooses the best resolution, but will possibly load
+    a different size image if you mutate the size attribute
+    before calling 'load'.
+
+    The info dictionary has a key 'sizes' that is a list
+    of sizes that the icns file has.
+    """
+
+    format = "ICNS"
+    format_description = "Mac OS icns resource"
+
+    def _open(self) -> None:
+        self.icns = IcnsFile(self.fp)
+        self._mode = "RGBA"
+        self.info["sizes"] = self.icns.itersizes()
+        self.best_size = self.icns.bestsize()
+        self.size = (
+            self.best_size[0] * self.best_size[2],
+            self.best_size[1] * self.best_size[2],
+        )
+
+    @property
+    def size(self) -> tuple[int, int]:
+        return self._size
+
+    @size.setter
+    def size(self, value: tuple[int, int]) -> None:
+        # Check that a matching size exists,
+        # or that there is a scale that would create a size that matches
+        for size in self.info["sizes"]:
+            simple_size = size[0] * size[2], size[1] * size[2]
+            scale = simple_size[0] // value[0]
+            if simple_size[1] / value[1] == scale:
+                self._size = value
+                return
+        msg = "This is not one of the allowed sizes of this image"
+        raise ValueError(msg)
+
+    def load(self, scale: int | None = None) -> Image.core.PixelAccess | None:
+        if scale is not None:
+            width, height = self.size[:2]
+            self.size = width * scale, height * scale
+            self.best_size = width, height, scale
+
+        px = Image.Image.load(self)
+        if self._im is not None and self.im.size == self.size:
+            # Already loaded
+            return px
+        self.load_prepare()
+        # This is likely NOT the best way to do it, but whatever.
+        im = self.icns.getimage(self.best_size)
+
+        # If this is a PNG or JPEG 2000, it won't be loaded yet
+        px = im.load()
+
+        self.im = im.im
+        self._mode = im.mode
+        self.size = im.size
+
+        return px
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    """
+    Saves the image as a series of PNG files,
+    that are then combined into a .icns file.
+    """
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+    sizes = {
+        b"ic07": 128,
+        b"ic08": 256,
+        b"ic09": 512,
+        b"ic10": 1024,
+        b"ic11": 32,
+        b"ic12": 64,
+        b"ic13": 256,
+        b"ic14": 512,
+    }
+    provided_images = {im.width: im for im in im.encoderinfo.get("append_images", [])}
+    size_streams = {}
+    for size in set(sizes.values()):
+        image = (
+            provided_images[size]
+            if size in provided_images
+            else im.resize((size, size))
+        )
+
+        temp = io.BytesIO()
+        image.save(temp, "png")
+        size_streams[size] = temp.getvalue()
+
+    entries = []
+    for type, size in sizes.items():
+        stream = size_streams[size]
+        entries.append((type, HEADERSIZE + len(stream), stream))
+
+    # Header
+    fp.write(MAGIC)
+    file_length = HEADERSIZE  # Header
+    file_length += HEADERSIZE + 8 * len(entries)  # TOC
+    file_length += sum(entry[1] for entry in entries)
+    fp.write(struct.pack(">i", file_length))
+
+    # TOC
+    fp.write(b"TOC ")
+    fp.write(struct.pack(">i", HEADERSIZE + len(entries) * HEADERSIZE))
+    for entry in entries:
+        fp.write(entry[0])
+        fp.write(struct.pack(">i", entry[1]))
+
+    # Data
+    for entry in entries:
+        fp.write(entry[0])
+        fp.write(struct.pack(">i", entry[1]))
+        fp.write(entry[2])
+
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix.startswith(MAGIC)
+
+
+Image.register_open(IcnsImageFile.format, IcnsImageFile, _accept)
+Image.register_extension(IcnsImageFile.format, ".icns")
+
+Image.register_save(IcnsImageFile.format, _save)
+Image.register_mime(IcnsImageFile.format, "image/icns")
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Syntax: python3 IcnsImagePlugin.py [file]")
+        sys.exit()
+
+    with open(sys.argv[1], "rb") as fp:
+        imf = IcnsImageFile(fp)
+        for size in imf.info["sizes"]:
+            width, height, scale = imf.size = size
+            imf.save(f"out-{width}-{height}-{scale}.png")
+        with Image.open(sys.argv[1]) as im:
+            im.save("out.png")
+        if sys.platform == "windows":
+            os.startfile("out.png")

.venv/lib/python3.12/site-packages/PIL/ImImagePlugin.py

@@ -0,0 +1,389 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# IFUNC IM file handling for PIL
+#
+# history:
+# 1995-09-01 fl   Created.
+# 1997-01-03 fl   Save palette images
+# 1997-01-08 fl   Added sequence support
+# 1997-01-23 fl   Added P and RGB save support
+# 1997-05-31 fl   Read floating point images
+# 1997-06-22 fl   Save floating point images
+# 1997-08-27 fl   Read and save 1-bit images
+# 1998-06-25 fl   Added support for RGB+LUT images
+# 1998-07-02 fl   Added support for YCC images
+# 1998-07-15 fl   Renamed offset attribute to avoid name clash
+# 1998-12-29 fl   Added I;16 support
+# 2001-02-17 fl   Use 're' instead of 'regex' (Python 2.1) (0.7)
+# 2003-09-26 fl   Added LA/PA support
+#
+# Copyright (c) 1997-2003 by Secret Labs AB.
+# Copyright (c) 1995-2001 by Fredrik Lundh.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import os
+import re
+from typing import IO, Any
+
+from . import Image, ImageFile, ImagePalette
+from ._util import DeferredError
+
+# --------------------------------------------------------------------
+# Standard tags
+
+COMMENT = "Comment"
+DATE = "Date"
+EQUIPMENT = "Digitalization equipment"
+FRAMES = "File size (no of images)"
+LUT = "Lut"
+NAME = "Name"
+SCALE = "Scale (x,y)"
+SIZE = "Image size (x*y)"
+MODE = "Image type"
+
+TAGS = {
+    COMMENT: 0,
+    DATE: 0,
+    EQUIPMENT: 0,
+    FRAMES: 0,
+    LUT: 0,
+    NAME: 0,
+    SCALE: 0,
+    SIZE: 0,
+    MODE: 0,
+}
+
+OPEN = {
+    # ifunc93/p3cfunc formats
+    "0 1 image": ("1", "1"),
+    "L 1 image": ("1", "1"),
+    "Greyscale image": ("L", "L"),
+    "Grayscale image": ("L", "L"),
+    "RGB image": ("RGB", "RGB;L"),
+    "RLB image": ("RGB", "RLB"),
+    "RYB image": ("RGB", "RLB"),
+    "B1 image": ("1", "1"),
+    "B2 image": ("P", "P;2"),
+    "B4 image": ("P", "P;4"),
+    "X 24 image": ("RGB", "RGB"),
+    "L 32 S image": ("I", "I;32"),
+    "L 32 F image": ("F", "F;32"),
+    # old p3cfunc formats
+    "RGB3 image": ("RGB", "RGB;T"),
+    "RYB3 image": ("RGB", "RYB;T"),
+    # extensions
+    "LA image": ("LA", "LA;L"),
+    "PA image": ("LA", "PA;L"),
+    "RGBA image": ("RGBA", "RGBA;L"),
+    "RGBX image": ("RGB", "RGBX;L"),
+    "CMYK image": ("CMYK", "CMYK;L"),
+    "YCC image": ("YCbCr", "YCbCr;L"),
+}
+
+# ifunc95 extensions
+for i in ["8", "8S", "16", "16S", "32", "32F"]:
+    OPEN[f"L {i} image"] = ("F", f"F;{i}")
+    OPEN[f"L*{i} image"] = ("F", f"F;{i}")
+for i in ["16", "16L", "16B"]:
+    OPEN[f"L {i} image"] = (f"I;{i}", f"I;{i}")
+    OPEN[f"L*{i} image"] = (f"I;{i}", f"I;{i}")
+for i in ["32S"]:
+    OPEN[f"L {i} image"] = ("I", f"I;{i}")
+    OPEN[f"L*{i} image"] = ("I", f"I;{i}")
+for j in range(2, 33):
+    OPEN[f"L*{j} image"] = ("F", f"F;{j}")
+
+
+# --------------------------------------------------------------------
+# Read IM directory
+
+split = re.compile(rb"^([A-Za-z][^:]*):[ \t]*(.*)[ \t]*$")
+
+
+def number(s: Any) -> float:
+    try:
+        return int(s)
+    except ValueError:
+        return float(s)
+
+
+##
+# Image plugin for the IFUNC IM file format.
+
+
+class ImImageFile(ImageFile.ImageFile):
+    format = "IM"
+    format_description = "IFUNC Image Memory"
+    _close_exclusive_fp_after_loading = False
+
+    def _open(self) -> None:
+        # Quick rejection: if there's not an LF among the first
+        # 100 bytes, this is (probably) not a text header.
+
+        if b"\n" not in self.fp.read(100):
+            msg = "not an IM file"
+            raise SyntaxError(msg)
+        self.fp.seek(0)
+
+        n = 0
+
+        # Default values
+        self.info[MODE] = "L"
+        self.info[SIZE] = (512, 512)
+        self.info[FRAMES] = 1
+
+        self.rawmode = "L"
+
+        while True:
+            s = self.fp.read(1)
+
+            # Some versions of IFUNC uses \n\r instead of \r\n...
+            if s == b"\r":
+                continue
+
+            if not s or s == b"\0" or s == b"\x1a":
+                break
+
+            # FIXME: this may read whole file if not a text file
+            s = s + self.fp.readline()
+
+            if len(s) > 100:
+                msg = "not an IM file"
+                raise SyntaxError(msg)
+
+            if s.endswith(b"\r\n"):
+                s = s[:-2]
+            elif s.endswith(b"\n"):
+                s = s[:-1]
+
+            try:
+                m = split.match(s)
+            except re.error as e:
+                msg = "not an IM file"
+                raise SyntaxError(msg) from e
+
+            if m:
+                k, v = m.group(1, 2)
+
+                # Don't know if this is the correct encoding,
+                # but a decent guess (I guess)
+                k = k.decode("latin-1", "replace")
+                v = v.decode("latin-1", "replace")
+
+                # Convert value as appropriate
+                if k in [FRAMES, SCALE, SIZE]:
+                    v = v.replace("*", ",")
+                    v = tuple(map(number, v.split(",")))
+                    if len(v) == 1:
+                        v = v[0]
+                elif k == MODE and v in OPEN:
+                    v, self.rawmode = OPEN[v]
+
+                # Add to dictionary. Note that COMMENT tags are
+                # combined into a list of strings.
+                if k == COMMENT:
+                    if k in self.info:
+                        self.info[k].append(v)
+                    else:
+                        self.info[k] = [v]
+                else:
+                    self.info[k] = v
+
+                if k in TAGS:
+                    n += 1
+
+            else:
+                msg = f"Syntax error in IM header: {s.decode('ascii', 'replace')}"
+                raise SyntaxError(msg)
+
+        if not n:
+            msg = "Not an IM file"
+            raise SyntaxError(msg)
+
+        # Basic attributes
+        self._size = self.info[SIZE]
+        self._mode = self.info[MODE]
+
+        # Skip forward to start of image data
+        while s and not s.startswith(b"\x1a"):
+            s = self.fp.read(1)
+        if not s:
+            msg = "File truncated"
+            raise SyntaxError(msg)
+
+        if LUT in self.info:
+            # convert lookup table to palette or lut attribute
+            palette = self.fp.read(768)
+            greyscale = 1  # greyscale palette
+            linear = 1  # linear greyscale palette
+            for i in range(256):
+                if palette[i] == palette[i + 256] == palette[i + 512]:
+                    if palette[i] != i:
+                        linear = 0
+                else:
+                    greyscale = 0
+            if self.mode in ["L", "LA", "P", "PA"]:
+                if greyscale:
+                    if not linear:
+                        self.lut = list(palette[:256])
+                else:
+                    if self.mode in ["L", "P"]:
+                        self._mode = self.rawmode = "P"
+                    elif self.mode in ["LA", "PA"]:
+                        self._mode = "PA"
+                        self.rawmode = "PA;L"
+                    self.palette = ImagePalette.raw("RGB;L", palette)
+            elif self.mode == "RGB":
+                if not greyscale or not linear:
+                    self.lut = list(palette)
+
+        self.frame = 0
+
+        self.__offset = offs = self.fp.tell()
+
+        self._fp = self.fp  # FIXME: hack
+
+        if self.rawmode.startswith("F;"):
+            # ifunc95 formats
+            try:
+                # use bit decoder (if necessary)
+                bits = int(self.rawmode[2:])
+                if bits not in [8, 16, 32]:
+                    self.tile = [
+                        ImageFile._Tile(
+                            "bit", (0, 0) + self.size, offs, (bits, 8, 3, 0, -1)
+                        )
+                    ]
+                    return
+            except ValueError:
+                pass
+
+        if self.rawmode in ["RGB;T", "RYB;T"]:
+            # Old LabEye/3PC files.  Would be very surprised if anyone
+            # ever stumbled upon such a file ;-)
+            size = self.size[0] * self.size[1]
+            self.tile = [
+                ImageFile._Tile("raw", (0, 0) + self.size, offs, ("G", 0, -1)),
+                ImageFile._Tile("raw", (0, 0) + self.size, offs + size, ("R", 0, -1)),
+                ImageFile._Tile(
+                    "raw", (0, 0) + self.size, offs + 2 * size, ("B", 0, -1)
+                ),
+            ]
+        else:
+            # LabEye/IFUNC files
+            self.tile = [
+                ImageFile._Tile("raw", (0, 0) + self.size, offs, (self.rawmode, 0, -1))
+            ]
+
+    @property
+    def n_frames(self) -> int:
+        return self.info[FRAMES]
+
+    @property
+    def is_animated(self) -> bool:
+        return self.info[FRAMES] > 1
+
+    def seek(self, frame: int) -> None:
+        if not self._seek_check(frame):
+            return
+        if isinstance(self._fp, DeferredError):
+            raise self._fp.ex
+
+        self.frame = frame
+
+        if self.mode == "1":
+            bits = 1
+        else:
+            bits = 8 * len(self.mode)
+
+        size = ((self.size[0] * bits + 7) // 8) * self.size[1]
+        offs = self.__offset + frame * size
+
+        self.fp = self._fp
+
+        self.tile = [
+            ImageFile._Tile("raw", (0, 0) + self.size, offs, (self.rawmode, 0, -1))
+        ]
+
+    def tell(self) -> int:
+        return self.frame
+
+
+#
+# --------------------------------------------------------------------
+# Save IM files
+
+
+SAVE = {
+    # mode: (im type, raw mode)
+    "1": ("0 1", "1"),
+    "L": ("Greyscale", "L"),
+    "LA": ("LA", "LA;L"),
+    "P": ("Greyscale", "P"),
+    "PA": ("LA", "PA;L"),
+    "I": ("L 32S", "I;32S"),
+    "I;16": ("L 16", "I;16"),
+    "I;16L": ("L 16L", "I;16L"),
+    "I;16B": ("L 16B", "I;16B"),
+    "F": ("L 32F", "F;32F"),
+    "RGB": ("RGB", "RGB;L"),
+    "RGBA": ("RGBA", "RGBA;L"),
+    "RGBX": ("RGBX", "RGBX;L"),
+    "CMYK": ("CMYK", "CMYK;L"),
+    "YCbCr": ("YCC", "YCbCr;L"),
+}
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    try:
+        image_type, rawmode = SAVE[im.mode]
+    except KeyError as e:
+        msg = f"Cannot save {im.mode} images as IM"
+        raise ValueError(msg) from e
+
+    frames = im.encoderinfo.get("frames", 1)
+
+    fp.write(f"Image type: {image_type} image\r\n".encode("ascii"))
+    if filename:
+        # Each line must be 100 characters or less,
+        # or: SyntaxError("not an IM file")
+        # 8 characters are used for "Name: " and "\r\n"
+        # Keep just the filename, ditch the potentially overlong path
+        if isinstance(filename, bytes):
+            filename = filename.decode("ascii")
+        name, ext = os.path.splitext(os.path.basename(filename))
+        name = "".join([name[: 92 - len(ext)], ext])
+
+        fp.write(f"Name: {name}\r\n".encode("ascii"))
+    fp.write(f"Image size (x*y): {im.size[0]}*{im.size[1]}\r\n".encode("ascii"))
+    fp.write(f"File size (no of images): {frames}\r\n".encode("ascii"))
+    if im.mode in ["P", "PA"]:
+        fp.write(b"Lut: 1\r\n")
+    fp.write(b"\000" * (511 - fp.tell()) + b"\032")
+    if im.mode in ["P", "PA"]:
+        im_palette = im.im.getpalette("RGB", "RGB;L")
+        colors = len(im_palette) // 3
+        palette = b""
+        for i in range(3):
+            palette += im_palette[colors * i : colors * (i + 1)]
+            palette += b"\x00" * (256 - colors)
+        fp.write(palette)  # 768 bytes
+    ImageFile._save(
+        im, fp, [ImageFile._Tile("raw", (0, 0) + im.size, 0, (rawmode, 0, -1))]
+    )
+
+
+#
+# --------------------------------------------------------------------
+# Registry
+
+
+Image.register_open(ImImageFile.format, ImImageFile)
+Image.register_save(ImImageFile.format, _save)
+
+Image.register_extension(ImImageFile.format, ".im")

.venv/lib/python3.12/site-packages/PIL/ImageCms.py

@@ -0,0 +1,1076 @@
+# The Python Imaging Library.
+# $Id$
+
+# Optional color management support, based on Kevin Cazabon's PyCMS
+# library.
+
+# Originally released under LGPL.  Graciously donated to PIL in
+# March 2009, for distribution under the standard PIL license
+
+# History:
+
+# 2009-03-08 fl   Added to PIL.
+
+# Copyright (C) 2002-2003 Kevin Cazabon
+# Copyright (c) 2009 by Fredrik Lundh
+# Copyright (c) 2013 by Eric Soroos
+
+# See the README file for information on usage and redistribution.  See
+# below for the original description.
+from __future__ import annotations
+
+import operator
+import sys
+from enum import IntEnum, IntFlag
+from functools import reduce
+from typing import Any, Literal, SupportsFloat, SupportsInt, Union
+
+from . import Image
+from ._deprecate import deprecate
+from ._typing import SupportsRead
+
+try:
+    from . import _imagingcms as core
+
+    _CmsProfileCompatible = Union[
+        str, SupportsRead[bytes], core.CmsProfile, "ImageCmsProfile"
+    ]
+except ImportError as ex:
+    # Allow error import for doc purposes, but error out when accessing
+    # anything in core.
+    from ._util import DeferredError
+
+    core = DeferredError.new(ex)
+
+_DESCRIPTION = """
+pyCMS
+
+    a Python / PIL interface to the littleCMS ICC Color Management System
+    Copyright (C) 2002-2003 Kevin Cazabon
+    kevin@cazabon.com
+    https://www.cazabon.com
+
+    pyCMS home page:  https://www.cazabon.com/pyCMS
+    littleCMS home page:  https://www.littlecms.com
+    (littleCMS is Copyright (C) 1998-2001 Marti Maria)
+
+    Originally released under LGPL.  Graciously donated to PIL in
+    March 2009, for distribution under the standard PIL license
+
+    The pyCMS.py module provides a "clean" interface between Python/PIL and
+    pyCMSdll, taking care of some of the more complex handling of the direct
+    pyCMSdll functions, as well as error-checking and making sure that all
+    relevant data is kept together.
+
+    While it is possible to call pyCMSdll functions directly, it's not highly
+    recommended.
+
+    Version History:
+
+        1.0.0 pil       Oct 2013 Port to LCMS 2.
+
+        0.1.0 pil mod   March 10, 2009
+
+                        Renamed display profile to proof profile. The proof
+                        profile is the profile of the device that is being
+                        simulated, not the profile of the device which is
+                        actually used to display/print the final simulation
+                        (that'd be the output profile) - also see LCMSAPI.txt
+                        input colorspace -> using 'renderingIntent' -> proof
+                        colorspace -> using 'proofRenderingIntent' -> output
+                        colorspace
+
+                        Added LCMS FLAGS support.
+                        Added FLAGS["SOFTPROOFING"] as default flag for
+                        buildProofTransform (otherwise the proof profile/intent
+                        would be ignored).
+
+        0.1.0 pil       March 2009 - added to PIL, as PIL.ImageCms
+
+        0.0.2 alpha     Jan 6, 2002
+
+                        Added try/except statements around type() checks of
+                        potential CObjects... Python won't let you use type()
+                        on them, and raises a TypeError (stupid, if you ask
+                        me!)
+
+                        Added buildProofTransformFromOpenProfiles() function.
+                        Additional fixes in DLL, see DLL code for details.
+
+        0.0.1 alpha     first public release, Dec. 26, 2002
+
+    Known to-do list with current version (of Python interface, not pyCMSdll):
+
+        none
+
+"""
+
+_VERSION = "1.0.0 pil"
+
+
+# --------------------------------------------------------------------.
+
+
+#
+# intent/direction values
+
+
+class Intent(IntEnum):
+    PERCEPTUAL = 0
+    RELATIVE_COLORIMETRIC = 1
+    SATURATION = 2
+    ABSOLUTE_COLORIMETRIC = 3
+
+
+class Direction(IntEnum):
+    INPUT = 0
+    OUTPUT = 1
+    PROOF = 2
+
+
+#
+# flags
+
+
+class Flags(IntFlag):
+    """Flags and documentation are taken from ``lcms2.h``."""
+
+    NONE = 0
+    NOCACHE = 0x0040
+    """Inhibit 1-pixel cache"""
+    NOOPTIMIZE = 0x0100
+    """Inhibit optimizations"""
+    NULLTRANSFORM = 0x0200
+    """Don't transform anyway"""
+    GAMUTCHECK = 0x1000
+    """Out of Gamut alarm"""
+    SOFTPROOFING = 0x4000
+    """Do softproofing"""
+    BLACKPOINTCOMPENSATION = 0x2000
+    NOWHITEONWHITEFIXUP = 0x0004
+    """Don't fix scum dot"""
+    HIGHRESPRECALC = 0x0400
+    """Use more memory to give better accuracy"""
+    LOWRESPRECALC = 0x0800
+    """Use less memory to minimize resources"""
+    # this should be 8BITS_DEVICELINK, but that is not a valid name in Python:
+    USE_8BITS_DEVICELINK = 0x0008
+    """Create 8 bits devicelinks"""
+    GUESSDEVICECLASS = 0x0020
+    """Guess device class (for ``transform2devicelink``)"""
+    KEEP_SEQUENCE = 0x0080
+    """Keep profile sequence for devicelink creation"""
+    FORCE_CLUT = 0x0002
+    """Force CLUT optimization"""
+    CLUT_POST_LINEARIZATION = 0x0001
+    """create postlinearization tables if possible"""
+    CLUT_PRE_LINEARIZATION = 0x0010
+    """create prelinearization tables if possible"""
+    NONEGATIVES = 0x8000
+    """Prevent negative numbers in floating point transforms"""
+    COPY_ALPHA = 0x04000000
+    """Alpha channels are copied on ``cmsDoTransform()``"""
+    NODEFAULTRESOURCEDEF = 0x01000000
+
+    _GRIDPOINTS_1 = 1 << 16
+    _GRIDPOINTS_2 = 2 << 16
+    _GRIDPOINTS_4 = 4 << 16
+    _GRIDPOINTS_8 = 8 << 16
+    _GRIDPOINTS_16 = 16 << 16
+    _GRIDPOINTS_32 = 32 << 16
+    _GRIDPOINTS_64 = 64 << 16
+    _GRIDPOINTS_128 = 128 << 16
+
+    @staticmethod
+    def GRIDPOINTS(n: int) -> Flags:
+        """
+        Fine-tune control over number of gridpoints
+
+        :param n: :py:class:`int` in range ``0 <= n <= 255``
+        """
+        return Flags.NONE | ((n & 0xFF) << 16)
+
+
+_MAX_FLAG = reduce(operator.or_, Flags)
+
+
+_FLAGS = {
+    "MATRIXINPUT": 1,
+    "MATRIXOUTPUT": 2,
+    "MATRIXONLY": (1 | 2),
+    "NOWHITEONWHITEFIXUP": 4,  # Don't hot fix scum dot
+    # Don't create prelinearization tables on precalculated transforms
+    # (internal use):
+    "NOPRELINEARIZATION": 16,
+    "GUESSDEVICECLASS": 32,  # Guess device class (for transform2devicelink)
+    "NOTCACHE": 64,  # Inhibit 1-pixel cache
+    "NOTPRECALC": 256,
+    "NULLTRANSFORM": 512,  # Don't transform anyway
+    "HIGHRESPRECALC": 1024,  # Use more memory to give better accuracy
+    "LOWRESPRECALC": 2048,  # Use less memory to minimize resources
+    "WHITEBLACKCOMPENSATION": 8192,
+    "BLACKPOINTCOMPENSATION": 8192,
+    "GAMUTCHECK": 4096,  # Out of Gamut alarm
+    "SOFTPROOFING": 16384,  # Do softproofing
+    "PRESERVEBLACK": 32768,  # Black preservation
+    "NODEFAULTRESOURCEDEF": 16777216,  # CRD special
+    "GRIDPOINTS": lambda n: (n & 0xFF) << 16,  # Gridpoints
+}
+
+
+# --------------------------------------------------------------------.
+# Experimental PIL-level API
+# --------------------------------------------------------------------.
+
+##
+# Profile.
+
+
+class ImageCmsProfile:
+    def __init__(self, profile: str | SupportsRead[bytes] | core.CmsProfile) -> None:
+        """
+        :param profile: Either a string representing a filename,
+            a file like object containing a profile or a
+            low-level profile object
+
+        """
+        self.filename: str | None = None
+
+        if isinstance(profile, str):
+            if sys.platform == "win32":
+                profile_bytes_path = profile.encode()
+                try:
+                    profile_bytes_path.decode("ascii")
+                except UnicodeDecodeError:
+                    with open(profile, "rb") as f:
+                        self.profile = core.profile_frombytes(f.read())
+                    return
+            self.filename = profile
+            self.profile = core.profile_open(profile)
+        elif hasattr(profile, "read"):
+            self.profile = core.profile_frombytes(profile.read())
+        elif isinstance(profile, core.CmsProfile):
+            self.profile = profile
+        else:
+            msg = "Invalid type for Profile"  # type: ignore[unreachable]
+            raise TypeError(msg)
+
+    def __getattr__(self, name: str) -> Any:
+        if name in ("product_name", "product_info"):
+            deprecate(f"ImageCms.ImageCmsProfile.{name}", 13)
+            return None
+        msg = f"'{self.__class__.__name__}' object has no attribute '{name}'"
+        raise AttributeError(msg)
+
+    def tobytes(self) -> bytes:
+        """
+        Returns the profile in a format suitable for embedding in
+        saved images.
+
+        :returns: a bytes object containing the ICC profile.
+        """
+
+        return core.profile_tobytes(self.profile)
+
+
+class ImageCmsTransform(Image.ImagePointHandler):
+    """
+    Transform.  This can be used with the procedural API, or with the standard
+    :py:func:`~PIL.Image.Image.point` method.
+
+    Will return the output profile in the ``output.info['icc_profile']``.
+    """
+
+    def __init__(
+        self,
+        input: ImageCmsProfile,
+        output: ImageCmsProfile,
+        input_mode: str,
+        output_mode: str,
+        intent: Intent = Intent.PERCEPTUAL,
+        proof: ImageCmsProfile | None = None,
+        proof_intent: Intent = Intent.ABSOLUTE_COLORIMETRIC,
+        flags: Flags = Flags.NONE,
+    ):
+        if proof is None:
+            self.transform = core.buildTransform(
+                input.profile, output.profile, input_mode, output_mode, intent, flags
+            )
+        else:
+            self.transform = core.buildProofTransform(
+                input.profile,
+                output.profile,
+                proof.profile,
+                input_mode,
+                output_mode,
+                intent,
+                proof_intent,
+                flags,
+            )
+        # Note: inputMode and outputMode are for pyCMS compatibility only
+        self.input_mode = self.inputMode = input_mode
+        self.output_mode = self.outputMode = output_mode
+
+        self.output_profile = output
+
+    def point(self, im: Image.Image) -> Image.Image:
+        return self.apply(im)
+
+    def apply(self, im: Image.Image, imOut: Image.Image | None = None) -> Image.Image:
+        if imOut is None:
+            imOut = Image.new(self.output_mode, im.size, None)
+        self.transform.apply(im.getim(), imOut.getim())
+        imOut.info["icc_profile"] = self.output_profile.tobytes()
+        return imOut
+
+    def apply_in_place(self, im: Image.Image) -> Image.Image:
+        if im.mode != self.output_mode:
+            msg = "mode mismatch"
+            raise ValueError(msg)  # wrong output mode
+        self.transform.apply(im.getim(), im.getim())
+        im.info["icc_profile"] = self.output_profile.tobytes()
+        return im
+
+
+def get_display_profile(handle: SupportsInt | None = None) -> ImageCmsProfile | None:
+    """
+    (experimental) Fetches the profile for the current display device.
+
+    :returns: ``None`` if the profile is not known.
+    """
+
+    if sys.platform != "win32":
+        return None
+
+    from . import ImageWin  # type: ignore[unused-ignore, unreachable]
+
+    if isinstance(handle, ImageWin.HDC):
+        profile = core.get_display_profile_win32(int(handle), 1)
+    else:
+        profile = core.get_display_profile_win32(int(handle or 0))
+    if profile is None:
+        return None
+    return ImageCmsProfile(profile)
+
+
+# --------------------------------------------------------------------.
+# pyCMS compatible layer
+# --------------------------------------------------------------------.
+
+
+class PyCMSError(Exception):
+    """(pyCMS) Exception class.
+    This is used for all errors in the pyCMS API."""
+
+    pass
+
+
+def profileToProfile(
+    im: Image.Image,
+    inputProfile: _CmsProfileCompatible,
+    outputProfile: _CmsProfileCompatible,
+    renderingIntent: Intent = Intent.PERCEPTUAL,
+    outputMode: str | None = None,
+    inPlace: bool = False,
+    flags: Flags = Flags.NONE,
+) -> Image.Image | None:
+    """
+    (pyCMS) Applies an ICC transformation to a given image, mapping from
+    ``inputProfile`` to ``outputProfile``.
+
+    If the input or output profiles specified are not valid filenames, a
+    :exc:`PyCMSError` will be raised.  If ``inPlace`` is ``True`` and
+    ``outputMode != im.mode``, a :exc:`PyCMSError` will be raised.
+    If an error occurs during application of the profiles,
+    a :exc:`PyCMSError` will be raised.
+    If ``outputMode`` is not a mode supported by the ``outputProfile`` (or by pyCMS),
+    a :exc:`PyCMSError` will be raised.
+
+    This function applies an ICC transformation to im from ``inputProfile``'s
+    color space to ``outputProfile``'s color space using the specified rendering
+    intent to decide how to handle out-of-gamut colors.
+
+    ``outputMode`` can be used to specify that a color mode conversion is to
+    be done using these profiles, but the specified profiles must be able
+    to handle that mode.  I.e., if converting im from RGB to CMYK using
+    profiles, the input profile must handle RGB data, and the output
+    profile must handle CMYK data.
+
+    :param im: An open :py:class:`~PIL.Image.Image` object (i.e. Image.new(...)
+        or Image.open(...), etc.)
+    :param inputProfile: String, as a valid filename path to the ICC input
+        profile you wish to use for this image, or a profile object
+    :param outputProfile: String, as a valid filename path to the ICC output
+        profile you wish to use for this image, or a profile object
+    :param renderingIntent: Integer (0-3) specifying the rendering intent you
+        wish to use for the transform
+
+            ImageCms.Intent.PERCEPTUAL            = 0 (DEFAULT)
+            ImageCms.Intent.RELATIVE_COLORIMETRIC = 1
+            ImageCms.Intent.SATURATION            = 2
+            ImageCms.Intent.ABSOLUTE_COLORIMETRIC = 3
+
+        see the pyCMS documentation for details on rendering intents and what
+        they do.
+    :param outputMode: A valid PIL mode for the output image (i.e. "RGB",
+        "CMYK", etc.).  Note: if rendering the image "inPlace", outputMode
+        MUST be the same mode as the input, or omitted completely.  If
+        omitted, the outputMode will be the same as the mode of the input
+        image (im.mode)
+    :param inPlace: Boolean.  If ``True``, the original image is modified in-place,
+        and ``None`` is returned.  If ``False`` (default), a new
+        :py:class:`~PIL.Image.Image` object is returned with the transform applied.
+    :param flags: Integer (0-...) specifying additional flags
+    :returns: Either None or a new :py:class:`~PIL.Image.Image` object, depending on
+        the value of ``inPlace``
+    :exception PyCMSError:
+    """
+
+    if outputMode is None:
+        outputMode = im.mode
+
+    if not isinstance(renderingIntent, int) or not (0 <= renderingIntent <= 3):
+        msg = "renderingIntent must be an integer between 0 and 3"
+        raise PyCMSError(msg)
+
+    if not isinstance(flags, int) or not (0 <= flags <= _MAX_FLAG):
+        msg = f"flags must be an integer between 0 and {_MAX_FLAG}"
+        raise PyCMSError(msg)
+
+    try:
+        if not isinstance(inputProfile, ImageCmsProfile):
+            inputProfile = ImageCmsProfile(inputProfile)
+        if not isinstance(outputProfile, ImageCmsProfile):
+            outputProfile = ImageCmsProfile(outputProfile)
+        transform = ImageCmsTransform(
+            inputProfile,
+            outputProfile,
+            im.mode,
+            outputMode,
+            renderingIntent,
+            flags=flags,
+        )
+        if inPlace:
+            transform.apply_in_place(im)
+            imOut = None
+        else:
+            imOut = transform.apply(im)
+    except (OSError, TypeError, ValueError) as v:
+        raise PyCMSError(v) from v
+
+    return imOut
+
+
+def getOpenProfile(
+    profileFilename: str | SupportsRead[bytes] | core.CmsProfile,
+) -> ImageCmsProfile:
+    """
+    (pyCMS) Opens an ICC profile file.
+
+    The PyCMSProfile object can be passed back into pyCMS for use in creating
+    transforms and such (as in ImageCms.buildTransformFromOpenProfiles()).
+
+    If ``profileFilename`` is not a valid filename for an ICC profile,
+    a :exc:`PyCMSError` will be raised.
+
+    :param profileFilename: String, as a valid filename path to the ICC profile
+        you wish to open, or a file-like object.
+    :returns: A CmsProfile class object.
+    :exception PyCMSError:
+    """
+
+    try:
+        return ImageCmsProfile(profileFilename)
+    except (OSError, TypeError, ValueError) as v:
+        raise PyCMSError(v) from v
+
+
+def buildTransform(
+    inputProfile: _CmsProfileCompatible,
+    outputProfile: _CmsProfileCompatible,
+    inMode: str,
+    outMode: str,
+    renderingIntent: Intent = Intent.PERCEPTUAL,
+    flags: Flags = Flags.NONE,
+) -> ImageCmsTransform:
+    """
+    (pyCMS) Builds an ICC transform mapping from the ``inputProfile`` to the
+    ``outputProfile``. Use applyTransform to apply the transform to a given
+    image.
+
+    If the input or output profiles specified are not valid filenames, a
+    :exc:`PyCMSError` will be raised. If an error occurs during creation
+    of the transform, a :exc:`PyCMSError` will be raised.
+
+    If ``inMode`` or ``outMode`` are not a mode supported by the ``outputProfile``
+    (or by pyCMS), a :exc:`PyCMSError` will be raised.
+
+    This function builds and returns an ICC transform from the ``inputProfile``
+    to the ``outputProfile`` using the ``renderingIntent`` to determine what to do
+    with out-of-gamut colors.  It will ONLY work for converting images that
+    are in ``inMode`` to images that are in ``outMode`` color format (PIL mode,
+    i.e. "RGB", "RGBA", "CMYK", etc.).
+
+    Building the transform is a fair part of the overhead in
+    ImageCms.profileToProfile(), so if you're planning on converting multiple
+    images using the same input/output settings, this can save you time.
+    Once you have a transform object, it can be used with
+    ImageCms.applyProfile() to convert images without the need to re-compute
+    the lookup table for the transform.
+
+    The reason pyCMS returns a class object rather than a handle directly
+    to the transform is that it needs to keep track of the PIL input/output
+    modes that the transform is meant for.  These attributes are stored in
+    the ``inMode`` and ``outMode`` attributes of the object (which can be
+    manually overridden if you really want to, but I don't know of any
+    time that would be of use, or would even work).
+
+    :param inputProfile: String, as a valid filename path to the ICC input
+        profile you wish to use for this transform, or a profile object
+    :param outputProfile: String, as a valid filename path to the ICC output
+        profile you wish to use for this transform, or a profile object
+    :param inMode: String, as a valid PIL mode that the appropriate profile
+        also supports (i.e. "RGB", "RGBA", "CMYK", etc.)
+    :param outMode: String, as a valid PIL mode that the appropriate profile
+        also supports (i.e. "RGB", "RGBA", "CMYK", etc.)
+    :param renderingIntent: Integer (0-3) specifying the rendering intent you
+        wish to use for the transform
+
+            ImageCms.Intent.PERCEPTUAL            = 0 (DEFAULT)
+            ImageCms.Intent.RELATIVE_COLORIMETRIC = 1
+            ImageCms.Intent.SATURATION            = 2
+            ImageCms.Intent.ABSOLUTE_COLORIMETRIC = 3
+
+        see the pyCMS documentation for details on rendering intents and what
+        they do.
+    :param flags: Integer (0-...) specifying additional flags
+    :returns: A CmsTransform class object.
+    :exception PyCMSError:
+    """
+
+    if not isinstance(renderingIntent, int) or not (0 <= renderingIntent <= 3):
+        msg = "renderingIntent must be an integer between 0 and 3"
+        raise PyCMSError(msg)
+
+    if not isinstance(flags, int) or not (0 <= flags <= _MAX_FLAG):
+        msg = f"flags must be an integer between 0 and {_MAX_FLAG}"
+        raise PyCMSError(msg)
+
+    try:
+        if not isinstance(inputProfile, ImageCmsProfile):
+            inputProfile = ImageCmsProfile(inputProfile)
+        if not isinstance(outputProfile, ImageCmsProfile):
+            outputProfile = ImageCmsProfile(outputProfile)
+        return ImageCmsTransform(
+            inputProfile, outputProfile, inMode, outMode, renderingIntent, flags=flags
+        )
+    except (OSError, TypeError, ValueError) as v:
+        raise PyCMSError(v) from v
+
+
+def buildProofTransform(
+    inputProfile: _CmsProfileCompatible,
+    outputProfile: _CmsProfileCompatible,
+    proofProfile: _CmsProfileCompatible,
+    inMode: str,
+    outMode: str,
+    renderingIntent: Intent = Intent.PERCEPTUAL,
+    proofRenderingIntent: Intent = Intent.ABSOLUTE_COLORIMETRIC,
+    flags: Flags = Flags.SOFTPROOFING,
+) -> ImageCmsTransform:
+    """
+    (pyCMS) Builds an ICC transform mapping from the ``inputProfile`` to the
+    ``outputProfile``, but tries to simulate the result that would be
+    obtained on the ``proofProfile`` device.
+
+    If the input, output, or proof profiles specified are not valid
+    filenames, a :exc:`PyCMSError` will be raised.
+
+    If an error occurs during creation of the transform,
+    a :exc:`PyCMSError` will be raised.
+
+    If ``inMode`` or ``outMode`` are not a mode supported by the ``outputProfile``
+    (or by pyCMS), a :exc:`PyCMSError` will be raised.
+
+    This function builds and returns an ICC transform from the ``inputProfile``
+    to the ``outputProfile``, but tries to simulate the result that would be
+    obtained on the ``proofProfile`` device using ``renderingIntent`` and
+    ``proofRenderingIntent`` to determine what to do with out-of-gamut
+    colors.  This is known as "soft-proofing".  It will ONLY work for
+    converting images that are in ``inMode`` to images that are in outMode
+    color format (PIL mode, i.e. "RGB", "RGBA", "CMYK", etc.).
+
+    Usage of the resulting transform object is exactly the same as with
+    ImageCms.buildTransform().
+
+    Proof profiling is generally used when using an output device to get a
+    good idea of what the final printed/displayed image would look like on
+    the ``proofProfile`` device when it's quicker and easier to use the
+    output device for judging color.  Generally, this means that the
+    output device is a monitor, or a dye-sub printer (etc.), and the simulated
+    device is something more expensive, complicated, or time consuming
+    (making it difficult to make a real print for color judgement purposes).
+
+    Soft-proofing basically functions by adjusting the colors on the
+    output device to match the colors of the device being simulated. However,
+    when the simulated device has a much wider gamut than the output
+    device, you may obtain marginal results.
+
+    :param inputProfile: String, as a valid filename path to the ICC input
+        profile you wish to use for this transform, or a profile object
+    :param outputProfile: String, as a valid filename path to the ICC output
+        (monitor, usually) profile you wish to use for this transform, or a
+        profile object
+    :param proofProfile: String, as a valid filename path to the ICC proof
+        profile you wish to use for this transform, or a profile object
+    :param inMode: String, as a valid PIL mode that the appropriate profile
+        also supports (i.e. "RGB", "RGBA", "CMYK", etc.)
+    :param outMode: String, as a valid PIL mode that the appropriate profile
+        also supports (i.e. "RGB", "RGBA", "CMYK", etc.)
+    :param renderingIntent: Integer (0-3) specifying the rendering intent you
+        wish to use for the input->proof (simulated) transform
+
+            ImageCms.Intent.PERCEPTUAL            = 0 (DEFAULT)
+            ImageCms.Intent.RELATIVE_COLORIMETRIC = 1
+            ImageCms.Intent.SATURATION            = 2
+            ImageCms.Intent.ABSOLUTE_COLORIMETRIC = 3
+
+        see the pyCMS documentation for details on rendering intents and what
+        they do.
+    :param proofRenderingIntent: Integer (0-3) specifying the rendering intent
+        you wish to use for proof->output transform
+
+            ImageCms.Intent.PERCEPTUAL            = 0 (DEFAULT)
+            ImageCms.Intent.RELATIVE_COLORIMETRIC = 1
+            ImageCms.Intent.SATURATION            = 2
+            ImageCms.Intent.ABSOLUTE_COLORIMETRIC = 3
+
+        see the pyCMS documentation for details on rendering intents and what
+        they do.
+    :param flags: Integer (0-...) specifying additional flags
+    :returns: A CmsTransform class object.
+    :exception PyCMSError:
+    """
+
+    if not isinstance(renderingIntent, int) or not (0 <= renderingIntent <= 3):
+        msg = "renderingIntent must be an integer between 0 and 3"
+        raise PyCMSError(msg)
+
+    if not isinstance(flags, int) or not (0 <= flags <= _MAX_FLAG):
+        msg = f"flags must be an integer between 0 and {_MAX_FLAG}"
+        raise PyCMSError(msg)
+
+    try:
+        if not isinstance(inputProfile, ImageCmsProfile):
+            inputProfile = ImageCmsProfile(inputProfile)
+        if not isinstance(outputProfile, ImageCmsProfile):
+            outputProfile = ImageCmsProfile(outputProfile)
+        if not isinstance(proofProfile, ImageCmsProfile):
+            proofProfile = ImageCmsProfile(proofProfile)
+        return ImageCmsTransform(
+            inputProfile,
+            outputProfile,
+            inMode,
+            outMode,
+            renderingIntent,
+            proofProfile,
+            proofRenderingIntent,
+            flags,
+        )
+    except (OSError, TypeError, ValueError) as v:
+        raise PyCMSError(v) from v
+
+
+buildTransformFromOpenProfiles = buildTransform
+buildProofTransformFromOpenProfiles = buildProofTransform
+
+
+def applyTransform(
+    im: Image.Image, transform: ImageCmsTransform, inPlace: bool = False
+) -> Image.Image | None:
+    """
+    (pyCMS) Applies a transform to a given image.
+
+    If ``im.mode != transform.input_mode``, a :exc:`PyCMSError` is raised.
+
+    If ``inPlace`` is ``True`` and ``transform.input_mode != transform.output_mode``, a
+    :exc:`PyCMSError` is raised.
+
+    If ``im.mode``, ``transform.input_mode`` or ``transform.output_mode`` is not
+    supported by pyCMSdll or the profiles you used for the transform, a
+    :exc:`PyCMSError` is raised.
+
+    If an error occurs while the transform is being applied,
+    a :exc:`PyCMSError` is raised.
+
+    This function applies a pre-calculated transform (from
+    ImageCms.buildTransform() or ImageCms.buildTransformFromOpenProfiles())
+    to an image. The transform can be used for multiple images, saving
+    considerable calculation time if doing the same conversion multiple times.
+
+    If you want to modify im in-place instead of receiving a new image as
+    the return value, set ``inPlace`` to ``True``.  This can only be done if
+    ``transform.input_mode`` and ``transform.output_mode`` are the same, because we
+    can't change the mode in-place (the buffer sizes for some modes are
+    different).  The default behavior is to return a new :py:class:`~PIL.Image.Image`
+    object of the same dimensions in mode ``transform.output_mode``.
+
+    :param im: An :py:class:`~PIL.Image.Image` object, and ``im.mode`` must be the same
+        as the ``input_mode`` supported by the transform.
+    :param transform: A valid CmsTransform class object
+    :param inPlace: Bool.  If ``True``, ``im`` is modified in place and ``None`` is
+        returned, if ``False``, a new :py:class:`~PIL.Image.Image` object with the
+        transform applied is returned (and ``im`` is not changed). The default is
+        ``False``.
+    :returns: Either ``None``, or a new :py:class:`~PIL.Image.Image` object,
+        depending on the value of ``inPlace``. The profile will be returned in
+        the image's ``info['icc_profile']``.
+    :exception PyCMSError:
+    """
+
+    try:
+        if inPlace:
+            transform.apply_in_place(im)
+            imOut = None
+        else:
+            imOut = transform.apply(im)
+    except (TypeError, ValueError) as v:
+        raise PyCMSError(v) from v
+
+    return imOut
+
+
+def createProfile(
+    colorSpace: Literal["LAB", "XYZ", "sRGB"], colorTemp: SupportsFloat = 0
+) -> core.CmsProfile:
+    """
+    (pyCMS) Creates a profile.
+
+    If colorSpace not in ``["LAB", "XYZ", "sRGB"]``,
+    a :exc:`PyCMSError` is raised.
+
+    If using LAB and ``colorTemp`` is not a positive integer,
+    a :exc:`PyCMSError` is raised.
+
+    If an error occurs while creating the profile,
+    a :exc:`PyCMSError` is raised.
+
+    Use this function to create common profiles on-the-fly instead of
+    having to supply a profile on disk and knowing the path to it.  It
+    returns a normal CmsProfile object that can be passed to
+    ImageCms.buildTransformFromOpenProfiles() to create a transform to apply
+    to images.
+
+    :param colorSpace: String, the color space of the profile you wish to
+        create.
+        Currently only "LAB", "XYZ", and "sRGB" are supported.
+    :param colorTemp: Positive number for the white point for the profile, in
+        degrees Kelvin (i.e. 5000, 6500, 9600, etc.).  The default is for D50
+        illuminant if omitted (5000k).  colorTemp is ONLY applied to LAB
+        profiles, and is ignored for XYZ and sRGB.
+    :returns: A CmsProfile class object
+    :exception PyCMSError:
+    """
+
+    if colorSpace not in ["LAB", "XYZ", "sRGB"]:
+        msg = (
+            f"Color space not supported for on-the-fly profile creation ({colorSpace})"
+        )
+        raise PyCMSError(msg)
+
+    if colorSpace == "LAB":
+        try:
+            colorTemp = float(colorTemp)
+        except (TypeError, ValueError) as e:
+            msg = f'Color temperature must be numeric, "{colorTemp}" not valid'
+            raise PyCMSError(msg) from e
+
+    try:
+        return core.createProfile(colorSpace, colorTemp)
+    except (TypeError, ValueError) as v:
+        raise PyCMSError(v) from v
+
+
+def getProfileName(profile: _CmsProfileCompatible) -> str:
+    """
+
+    (pyCMS) Gets the internal product name for the given profile.
+
+    If ``profile`` isn't a valid CmsProfile object or filename to a profile,
+    a :exc:`PyCMSError` is raised If an error occurs while trying
+    to obtain the name tag, a :exc:`PyCMSError` is raised.
+
+    Use this function to obtain the INTERNAL name of the profile (stored
+    in an ICC tag in the profile itself), usually the one used when the
+    profile was originally created.  Sometimes this tag also contains
+    additional information supplied by the creator.
+
+    :param profile: EITHER a valid CmsProfile object, OR a string of the
+        filename of an ICC profile.
+    :returns: A string containing the internal name of the profile as stored
+        in an ICC tag.
+    :exception PyCMSError:
+    """
+
+    try:
+        # add an extra newline to preserve pyCMS compatibility
+        if not isinstance(profile, ImageCmsProfile):
+            profile = ImageCmsProfile(profile)
+        # do it in python, not c.
+        #    // name was "%s - %s" (model, manufacturer) || Description ,
+        #    // but if the Model and Manufacturer were the same or the model
+        #    // was long, Just the model,  in 1.x
+        model = profile.profile.model
+        manufacturer = profile.profile.manufacturer
+
+        if not (model or manufacturer):
+            return (profile.profile.profile_description or "") + "\n"
+        if not manufacturer or (model and len(model) > 30):
+            return f"{model}\n"
+        return f"{model} - {manufacturer}\n"
+
+    except (AttributeError, OSError, TypeError, ValueError) as v:
+        raise PyCMSError(v) from v
+
+
+def getProfileInfo(profile: _CmsProfileCompatible) -> str:
+    """
+    (pyCMS) Gets the internal product information for the given profile.
+
+    If ``profile`` isn't a valid CmsProfile object or filename to a profile,
+    a :exc:`PyCMSError` is raised.
+
+    If an error occurs while trying to obtain the info tag,
+    a :exc:`PyCMSError` is raised.
+
+    Use this function to obtain the information stored in the profile's
+    info tag.  This often contains details about the profile, and how it
+    was created, as supplied by the creator.
+
+    :param profile: EITHER a valid CmsProfile object, OR a string of the
+        filename of an ICC profile.
+    :returns: A string containing the internal profile information stored in
+        an ICC tag.
+    :exception PyCMSError:
+    """
+
+    try:
+        if not isinstance(profile, ImageCmsProfile):
+            profile = ImageCmsProfile(profile)
+        # add an extra newline to preserve pyCMS compatibility
+        # Python, not C. the white point bits weren't working well,
+        # so skipping.
+        # info was description \r\n\r\n copyright \r\n\r\n K007 tag \r\n\r\n whitepoint
+        description = profile.profile.profile_description
+        cpright = profile.profile.copyright
+        elements = [element for element in (description, cpright) if element]
+        return "\r\n\r\n".join(elements) + "\r\n\r\n"
+
+    except (AttributeError, OSError, TypeError, ValueError) as v:
+        raise PyCMSError(v) from v
+
+
+def getProfileCopyright(profile: _CmsProfileCompatible) -> str:
+    """
+    (pyCMS) Gets the copyright for the given profile.
+
+    If ``profile`` isn't a valid CmsProfile object or filename to a profile, a
+    :exc:`PyCMSError` is raised.
+
+    If an error occurs while trying to obtain the copyright tag,
+    a :exc:`PyCMSError` is raised.
+
+    Use this function to obtain the information stored in the profile's
+    copyright tag.
+
+    :param profile: EITHER a valid CmsProfile object, OR a string of the
+        filename of an ICC profile.
+    :returns: A string containing the internal profile information stored in
+        an ICC tag.
+    :exception PyCMSError:
+    """
+    try:
+        # add an extra newline to preserve pyCMS compatibility
+        if not isinstance(profile, ImageCmsProfile):
+            profile = ImageCmsProfile(profile)
+        return (profile.profile.copyright or "") + "\n"
+    except (AttributeError, OSError, TypeError, ValueError) as v:
+        raise PyCMSError(v) from v
+
+
+def getProfileManufacturer(profile: _CmsProfileCompatible) -> str:
+    """
+    (pyCMS) Gets the manufacturer for the given profile.
+
+    If ``profile`` isn't a valid CmsProfile object or filename to a profile, a
+    :exc:`PyCMSError` is raised.
+
+    If an error occurs while trying to obtain the manufacturer tag, a
+    :exc:`PyCMSError` is raised.
+
+    Use this function to obtain the information stored in the profile's
+    manufacturer tag.
+
+    :param profile: EITHER a valid CmsProfile object, OR a string of the
+        filename of an ICC profile.
+    :returns: A string containing the internal profile information stored in
+        an ICC tag.
+    :exception PyCMSError:
+    """
+    try:
+        # add an extra newline to preserve pyCMS compatibility
+        if not isinstance(profile, ImageCmsProfile):
+            profile = ImageCmsProfile(profile)
+        return (profile.profile.manufacturer or "") + "\n"
+    except (AttributeError, OSError, TypeError, ValueError) as v:
+        raise PyCMSError(v) from v
+
+
+def getProfileModel(profile: _CmsProfileCompatible) -> str:
+    """
+    (pyCMS) Gets the model for the given profile.
+
+    If ``profile`` isn't a valid CmsProfile object or filename to a profile, a
+    :exc:`PyCMSError` is raised.
+
+    If an error occurs while trying to obtain the model tag,
+    a :exc:`PyCMSError` is raised.
+
+    Use this function to obtain the information stored in the profile's
+    model tag.
+
+    :param profile: EITHER a valid CmsProfile object, OR a string of the
+        filename of an ICC profile.
+    :returns: A string containing the internal profile information stored in
+        an ICC tag.
+    :exception PyCMSError:
+    """
+
+    try:
+        # add an extra newline to preserve pyCMS compatibility
+        if not isinstance(profile, ImageCmsProfile):
+            profile = ImageCmsProfile(profile)
+        return (profile.profile.model or "") + "\n"
+    except (AttributeError, OSError, TypeError, ValueError) as v:
+        raise PyCMSError(v) from v
+
+
+def getProfileDescription(profile: _CmsProfileCompatible) -> str:
+    """
+    (pyCMS) Gets the description for the given profile.
+
+    If ``profile`` isn't a valid CmsProfile object or filename to a profile, a
+    :exc:`PyCMSError` is raised.
+
+    If an error occurs while trying to obtain the description tag,
+    a :exc:`PyCMSError` is raised.
+
+    Use this function to obtain the information stored in the profile's
+    description tag.
+
+    :param profile: EITHER a valid CmsProfile object, OR a string of the
+        filename of an ICC profile.
+    :returns: A string containing the internal profile information stored in an
+        ICC tag.
+    :exception PyCMSError:
+    """
+
+    try:
+        # add an extra newline to preserve pyCMS compatibility
+        if not isinstance(profile, ImageCmsProfile):
+            profile = ImageCmsProfile(profile)
+        return (profile.profile.profile_description or "") + "\n"
+    except (AttributeError, OSError, TypeError, ValueError) as v:
+        raise PyCMSError(v) from v
+
+
+def getDefaultIntent(profile: _CmsProfileCompatible) -> int:
+    """
+    (pyCMS) Gets the default intent name for the given profile.
+
+    If ``profile`` isn't a valid CmsProfile object or filename to a profile, a
+    :exc:`PyCMSError` is raised.
+
+    If an error occurs while trying to obtain the default intent, a
+    :exc:`PyCMSError` is raised.
+
+    Use this function to determine the default (and usually best optimized)
+    rendering intent for this profile.  Most profiles support multiple
+    rendering intents, but are intended mostly for one type of conversion.
+    If you wish to use a different intent than returned, use
+    ImageCms.isIntentSupported() to verify it will work first.
+
+    :param profile: EITHER a valid CmsProfile object, OR a string of the
+        filename of an ICC profile.
+    :returns: Integer 0-3 specifying the default rendering intent for this
+        profile.
+
+            ImageCms.Intent.PERCEPTUAL            = 0 (DEFAULT)
+            ImageCms.Intent.RELATIVE_COLORIMETRIC = 1
+            ImageCms.Intent.SATURATION            = 2
+            ImageCms.Intent.ABSOLUTE_COLORIMETRIC = 3
+
+        see the pyCMS documentation for details on rendering intents and what
+            they do.
+    :exception PyCMSError:
+    """
+
+    try:
+        if not isinstance(profile, ImageCmsProfile):
+            profile = ImageCmsProfile(profile)
+        return profile.profile.rendering_intent
+    except (AttributeError, OSError, TypeError, ValueError) as v:
+        raise PyCMSError(v) from v
+
+
+def isIntentSupported(
+    profile: _CmsProfileCompatible, intent: Intent, direction: Direction
+) -> Literal[-1, 1]:
+    """
+    (pyCMS) Checks if a given intent is supported.
+
+    Use this function to verify that you can use your desired
+    ``intent`` with ``profile``, and that ``profile`` can be used for the
+    input/output/proof profile as you desire.
+
+    Some profiles are created specifically for one "direction", can cannot
+    be used for others. Some profiles can only be used for certain
+    rendering intents, so it's best to either verify this before trying
+    to create a transform with them (using this function), or catch the
+    potential :exc:`PyCMSError` that will occur if they don't
+    support the modes you select.
+
+    :param profile: EITHER a valid CmsProfile object, OR a string of the
+        filename of an ICC profile.
+    :param intent: Integer (0-3) specifying the rendering intent you wish to
+        use with this profile
+
+            ImageCms.Intent.PERCEPTUAL            = 0 (DEFAULT)
+            ImageCms.Intent.RELATIVE_COLORIMETRIC = 1
+            ImageCms.Intent.SATURATION            = 2
+            ImageCms.Intent.ABSOLUTE_COLORIMETRIC = 3
+
+        see the pyCMS documentation for details on rendering intents and what
+            they do.
+    :param direction: Integer specifying if the profile is to be used for
+        input, output, or proof
+
+            INPUT  = 0 (or use ImageCms.Direction.INPUT)
+            OUTPUT = 1 (or use ImageCms.Direction.OUTPUT)
+            PROOF  = 2 (or use ImageCms.Direction.PROOF)
+
+    :returns: 1 if the intent/direction are supported, -1 if they are not.
+    :exception PyCMSError:
+    """
+
+    try:
+        if not isinstance(profile, ImageCmsProfile):
+            profile = ImageCmsProfile(profile)
+        # FIXME: I get different results for the same data w. different
+        # compilers.  Bug in LittleCMS or in the binding?
+        if profile.profile.is_intent_supported(intent, direction):
+            return 1
+        else:
+            return -1
+    except (AttributeError, OSError, TypeError, ValueError) as v:
+        raise PyCMSError(v) from v

.venv/lib/python3.12/site-packages/PIL/ImageDraw.py

@@ -0,0 +1,1036 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# drawing interface operations
+#
+# History:
+# 1996-04-13 fl   Created (experimental)
+# 1996-08-07 fl   Filled polygons, ellipses.
+# 1996-08-13 fl   Added text support
+# 1998-06-28 fl   Handle I and F images
+# 1998-12-29 fl   Added arc; use arc primitive to draw ellipses
+# 1999-01-10 fl   Added shape stuff (experimental)
+# 1999-02-06 fl   Added bitmap support
+# 1999-02-11 fl   Changed all primitives to take options
+# 1999-02-20 fl   Fixed backwards compatibility
+# 2000-10-12 fl   Copy on write, when necessary
+# 2001-02-18 fl   Use default ink for bitmap/text also in fill mode
+# 2002-10-24 fl   Added support for CSS-style color strings
+# 2002-12-10 fl   Added experimental support for RGBA-on-RGB drawing
+# 2002-12-11 fl   Refactored low-level drawing API (work in progress)
+# 2004-08-26 fl   Made Draw() a factory function, added getdraw() support
+# 2004-09-04 fl   Added width support to line primitive
+# 2004-09-10 fl   Added font mode handling
+# 2006-06-19 fl   Added font bearing support (getmask2)
+#
+# Copyright (c) 1997-2006 by Secret Labs AB
+# Copyright (c) 1996-2006 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import math
+import struct
+from collections.abc import Sequence
+from typing import cast
+
+from . import Image, ImageColor, ImageText
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from types import ModuleType
+    from typing import Any, AnyStr
+
+    from . import ImageDraw2, ImageFont
+    from ._typing import Coords, _Ink
+
+# experimental access to the outline API
+Outline: Callable[[], Image.core._Outline] = Image.core.outline
+
+"""
+A simple 2D drawing interface for PIL images.
+<p>
+Application code should use the <b>Draw</b> factory, instead of
+directly.
+"""
+
+
+class ImageDraw:
+    font: (
+        ImageFont.ImageFont | ImageFont.FreeTypeFont | ImageFont.TransposedFont | None
+    ) = None
+
+    def __init__(self, im: Image.Image, mode: str | None = None) -> None:
+        """
+        Create a drawing instance.
+
+        :param im: The image to draw in.
+        :param mode: Optional mode to use for color values.  For RGB
+           images, this argument can be RGB or RGBA (to blend the
+           drawing into the image).  For all other modes, this argument
+           must be the same as the image mode.  If omitted, the mode
+           defaults to the mode of the image.
+        """
+        im._ensure_mutable()
+        blend = 0
+        if mode is None:
+            mode = im.mode
+        if mode != im.mode:
+            if mode == "RGBA" and im.mode == "RGB":
+                blend = 1
+            else:
+                msg = "mode mismatch"
+                raise ValueError(msg)
+        if mode == "P":
+            self.palette = im.palette
+        else:
+            self.palette = None
+        self._image = im
+        self.im = im.im
+        self.draw = Image.core.draw(self.im, blend)
+        self.mode = mode
+        if mode in ("I", "F"):
+            self.ink = self.draw.draw_ink(1)
+        else:
+            self.ink = self.draw.draw_ink(-1)
+        if mode in ("1", "P", "I", "F"):
+            # FIXME: fix Fill2 to properly support matte for I+F images
+            self.fontmode = "1"
+        else:
+            self.fontmode = "L"  # aliasing is okay for other modes
+        self.fill = False
+
+    def getfont(
+        self,
+    ) -> ImageFont.ImageFont | ImageFont.FreeTypeFont | ImageFont.TransposedFont:
+        """
+        Get the current default font.
+
+        To set the default font for this ImageDraw instance::
+
+            from PIL import ImageDraw, ImageFont
+            draw.font = ImageFont.truetype("Tests/fonts/FreeMono.ttf")
+
+        To set the default font for all future ImageDraw instances::
+
+            from PIL import ImageDraw, ImageFont
+            ImageDraw.ImageDraw.font = ImageFont.truetype("Tests/fonts/FreeMono.ttf")
+
+        If the current default font is ``None``,
+        it is initialized with ``ImageFont.load_default()``.
+
+        :returns: An image font."""
+        if not self.font:
+            # FIXME: should add a font repository
+            from . import ImageFont
+
+            self.font = ImageFont.load_default()
+        return self.font
+
+    def _getfont(
+        self, font_size: float | None
+    ) -> ImageFont.ImageFont | ImageFont.FreeTypeFont | ImageFont.TransposedFont:
+        if font_size is not None:
+            from . import ImageFont
+
+            return ImageFont.load_default(font_size)
+        else:
+            return self.getfont()
+
+    def _getink(
+        self, ink: _Ink | None, fill: _Ink | None = None
+    ) -> tuple[int | None, int | None]:
+        result_ink = None
+        result_fill = None
+        if ink is None and fill is None:
+            if self.fill:
+                result_fill = self.ink
+            else:
+                result_ink = self.ink
+        else:
+            if ink is not None:
+                if isinstance(ink, str):
+                    ink = ImageColor.getcolor(ink, self.mode)
+                if self.palette and isinstance(ink, tuple):
+                    ink = self.palette.getcolor(ink, self._image)
+                result_ink = self.draw.draw_ink(ink)
+            if fill is not None:
+                if isinstance(fill, str):
+                    fill = ImageColor.getcolor(fill, self.mode)
+                if self.palette and isinstance(fill, tuple):
+                    fill = self.palette.getcolor(fill, self._image)
+                result_fill = self.draw.draw_ink(fill)
+        return result_ink, result_fill
+
+    def arc(
+        self,
+        xy: Coords,
+        start: float,
+        end: float,
+        fill: _Ink | None = None,
+        width: int = 1,
+    ) -> None:
+        """Draw an arc."""
+        ink, fill = self._getink(fill)
+        if ink is not None:
+            self.draw.draw_arc(xy, start, end, ink, width)
+
+    def bitmap(
+        self, xy: Sequence[int], bitmap: Image.Image, fill: _Ink | None = None
+    ) -> None:
+        """Draw a bitmap."""
+        bitmap.load()
+        ink, fill = self._getink(fill)
+        if ink is None:
+            ink = fill
+        if ink is not None:
+            self.draw.draw_bitmap(xy, bitmap.im, ink)
+
+    def chord(
+        self,
+        xy: Coords,
+        start: float,
+        end: float,
+        fill: _Ink | None = None,
+        outline: _Ink | None = None,
+        width: int = 1,
+    ) -> None:
+        """Draw a chord."""
+        ink, fill_ink = self._getink(outline, fill)
+        if fill_ink is not None:
+            self.draw.draw_chord(xy, start, end, fill_ink, 1)
+        if ink is not None and ink != fill_ink and width != 0:
+            self.draw.draw_chord(xy, start, end, ink, 0, width)
+
+    def ellipse(
+        self,
+        xy: Coords,
+        fill: _Ink | None = None,
+        outline: _Ink | None = None,
+        width: int = 1,
+    ) -> None:
+        """Draw an ellipse."""
+        ink, fill_ink = self._getink(outline, fill)
+        if fill_ink is not None:
+            self.draw.draw_ellipse(xy, fill_ink, 1)
+        if ink is not None and ink != fill_ink and width != 0:
+            self.draw.draw_ellipse(xy, ink, 0, width)
+
+    def circle(
+        self,
+        xy: Sequence[float],
+        radius: float,
+        fill: _Ink | None = None,
+        outline: _Ink | None = None,
+        width: int = 1,
+    ) -> None:
+        """Draw a circle given center coordinates and a radius."""
+        ellipse_xy = (xy[0] - radius, xy[1] - radius, xy[0] + radius, xy[1] + radius)
+        self.ellipse(ellipse_xy, fill, outline, width)
+
+    def line(
+        self,
+        xy: Coords,
+        fill: _Ink | None = None,
+        width: int = 0,
+        joint: str | None = None,
+    ) -> None:
+        """Draw a line, or a connected sequence of line segments."""
+        ink = self._getink(fill)[0]
+        if ink is not None:
+            self.draw.draw_lines(xy, ink, width)
+            if joint == "curve" and width > 4:
+                points: Sequence[Sequence[float]]
+                if isinstance(xy[0], (list, tuple)):
+                    points = cast(Sequence[Sequence[float]], xy)
+                else:
+                    points = [
+                        cast(Sequence[float], tuple(xy[i : i + 2]))
+                        for i in range(0, len(xy), 2)
+                    ]
+                for i in range(1, len(points) - 1):
+                    point = points[i]
+                    angles = [
+                        math.degrees(math.atan2(end[0] - start[0], start[1] - end[1]))
+                        % 360
+                        for start, end in (
+                            (points[i - 1], point),
+                            (point, points[i + 1]),
+                        )
+                    ]
+                    if angles[0] == angles[1]:
+                        # This is a straight line, so no joint is required
+                        continue
+
+                    def coord_at_angle(
+                        coord: Sequence[float], angle: float
+                    ) -> tuple[float, ...]:
+                        x, y = coord
+                        angle -= 90
+                        distance = width / 2 - 1
+                        return tuple(
+                            p + (math.floor(p_d) if p_d > 0 else math.ceil(p_d))
+                            for p, p_d in (
+                                (x, distance * math.cos(math.radians(angle))),
+                                (y, distance * math.sin(math.radians(angle))),
+                            )
+                        )
+
+                    flipped = (
+                        angles[1] > angles[0] and angles[1] - 180 > angles[0]
+                    ) or (angles[1] < angles[0] and angles[1] + 180 > angles[0])
+                    coords = [
+                        (point[0] - width / 2 + 1, point[1] - width / 2 + 1),
+                        (point[0] + width / 2 - 1, point[1] + width / 2 - 1),
+                    ]
+                    if flipped:
+                        start, end = (angles[1] + 90, angles[0] + 90)
+                    else:
+                        start, end = (angles[0] - 90, angles[1] - 90)
+                    self.pieslice(coords, start - 90, end - 90, fill)
+
+                    if width > 8:
+                        # Cover potential gaps between the line and the joint
+                        if flipped:
+                            gap_coords = [
+                                coord_at_angle(point, angles[0] + 90),
+                                point,
+                                coord_at_angle(point, angles[1] + 90),
+                            ]
+                        else:
+                            gap_coords = [
+                                coord_at_angle(point, angles[0] - 90),
+                                point,
+                                coord_at_angle(point, angles[1] - 90),
+                            ]
+                        self.line(gap_coords, fill, width=3)
+
+    def shape(
+        self,
+        shape: Image.core._Outline,
+        fill: _Ink | None = None,
+        outline: _Ink | None = None,
+    ) -> None:
+        """(Experimental) Draw a shape."""
+        shape.close()
+        ink, fill_ink = self._getink(outline, fill)
+        if fill_ink is not None:
+            self.draw.draw_outline(shape, fill_ink, 1)
+        if ink is not None and ink != fill_ink:
+            self.draw.draw_outline(shape, ink, 0)
+
+    def pieslice(
+        self,
+        xy: Coords,
+        start: float,
+        end: float,
+        fill: _Ink | None = None,
+        outline: _Ink | None = None,
+        width: int = 1,
+    ) -> None:
+        """Draw a pieslice."""
+        ink, fill_ink = self._getink(outline, fill)
+        if fill_ink is not None:
+            self.draw.draw_pieslice(xy, start, end, fill_ink, 1)
+        if ink is not None and ink != fill_ink and width != 0:
+            self.draw.draw_pieslice(xy, start, end, ink, 0, width)
+
+    def point(self, xy: Coords, fill: _Ink | None = None) -> None:
+        """Draw one or more individual pixels."""
+        ink, fill = self._getink(fill)
+        if ink is not None:
+            self.draw.draw_points(xy, ink)
+
+    def polygon(
+        self,
+        xy: Coords,
+        fill: _Ink | None = None,
+        outline: _Ink | None = None,
+        width: int = 1,
+    ) -> None:
+        """Draw a polygon."""
+        ink, fill_ink = self._getink(outline, fill)
+        if fill_ink is not None:
+            self.draw.draw_polygon(xy, fill_ink, 1)
+        if ink is not None and ink != fill_ink and width != 0:
+            if width == 1:
+                self.draw.draw_polygon(xy, ink, 0, width)
+            elif self.im is not None:
+                # To avoid expanding the polygon outwards,
+                # use the fill as a mask
+                mask = Image.new("1", self.im.size)
+                mask_ink = self._getink(1)[0]
+                draw = Draw(mask)
+                draw.draw.draw_polygon(xy, mask_ink, 1)
+
+                self.draw.draw_polygon(xy, ink, 0, width * 2 - 1, mask.im)
+
+    def regular_polygon(
+        self,
+        bounding_circle: Sequence[Sequence[float] | float],
+        n_sides: int,
+        rotation: float = 0,
+        fill: _Ink | None = None,
+        outline: _Ink | None = None,
+        width: int = 1,
+    ) -> None:
+        """Draw a regular polygon."""
+        xy = _compute_regular_polygon_vertices(bounding_circle, n_sides, rotation)
+        self.polygon(xy, fill, outline, width)
+
+    def rectangle(
+        self,
+        xy: Coords,
+        fill: _Ink | None = None,
+        outline: _Ink | None = None,
+        width: int = 1,
+    ) -> None:
+        """Draw a rectangle."""
+        ink, fill_ink = self._getink(outline, fill)
+        if fill_ink is not None:
+            self.draw.draw_rectangle(xy, fill_ink, 1)
+        if ink is not None and ink != fill_ink and width != 0:
+            self.draw.draw_rectangle(xy, ink, 0, width)
+
+    def rounded_rectangle(
+        self,
+        xy: Coords,
+        radius: float = 0,
+        fill: _Ink | None = None,
+        outline: _Ink | None = None,
+        width: int = 1,
+        *,
+        corners: tuple[bool, bool, bool, bool] | None = None,
+    ) -> None:
+        """Draw a rounded rectangle."""
+        if isinstance(xy[0], (list, tuple)):
+            (x0, y0), (x1, y1) = cast(Sequence[Sequence[float]], xy)
+        else:
+            x0, y0, x1, y1 = cast(Sequence[float], xy)
+        if x1 < x0:
+            msg = "x1 must be greater than or equal to x0"
+            raise ValueError(msg)
+        if y1 < y0:
+            msg = "y1 must be greater than or equal to y0"
+            raise ValueError(msg)
+        if corners is None:
+            corners = (True, True, True, True)
+
+        d = radius * 2
+
+        x0 = round(x0)
+        y0 = round(y0)
+        x1 = round(x1)
+        y1 = round(y1)
+        full_x, full_y = False, False
+        if all(corners):
+            full_x = d >= x1 - x0 - 1
+            if full_x:
+                # The two left and two right corners are joined
+                d = x1 - x0
+            full_y = d >= y1 - y0 - 1
+            if full_y:
+                # The two top and two bottom corners are joined
+                d = y1 - y0
+            if full_x and full_y:
+                # If all corners are joined, that is a circle
+                return self.ellipse(xy, fill, outline, width)
+
+        if d == 0 or not any(corners):
+            # If the corners have no curve,
+            # or there are no corners,
+            # that is a rectangle
+            return self.rectangle(xy, fill, outline, width)
+
+        r = int(d // 2)
+        ink, fill_ink = self._getink(outline, fill)
+
+        def draw_corners(pieslice: bool) -> None:
+            parts: tuple[tuple[tuple[float, float, float, float], int, int], ...]
+            if full_x:
+                # Draw top and bottom halves
+                parts = (
+                    ((x0, y0, x0 + d, y0 + d), 180, 360),
+                    ((x0, y1 - d, x0 + d, y1), 0, 180),
+                )
+            elif full_y:
+                # Draw left and right halves
+                parts = (
+                    ((x0, y0, x0 + d, y0 + d), 90, 270),
+                    ((x1 - d, y0, x1, y0 + d), 270, 90),
+                )
+            else:
+                # Draw four separate corners
+                parts = tuple(
+                    part
+                    for i, part in enumerate(
+                        (
+                            ((x0, y0, x0 + d, y0 + d), 180, 270),
+                            ((x1 - d, y0, x1, y0 + d), 270, 360),
+                            ((x1 - d, y1 - d, x1, y1), 0, 90),
+                            ((x0, y1 - d, x0 + d, y1), 90, 180),
+                        )
+                    )
+                    if corners[i]
+                )
+            for part in parts:
+                if pieslice:
+                    self.draw.draw_pieslice(*(part + (fill_ink, 1)))
+                else:
+                    self.draw.draw_arc(*(part + (ink, width)))
+
+        if fill_ink is not None:
+            draw_corners(True)
+
+            if full_x:
+                self.draw.draw_rectangle((x0, y0 + r + 1, x1, y1 - r - 1), fill_ink, 1)
+            elif x1 - r - 1 > x0 + r + 1:
+                self.draw.draw_rectangle((x0 + r + 1, y0, x1 - r - 1, y1), fill_ink, 1)
+            if not full_x and not full_y:
+                left = [x0, y0, x0 + r, y1]
+                if corners[0]:
+                    left[1] += r + 1
+                if corners[3]:
+                    left[3] -= r + 1
+                self.draw.draw_rectangle(left, fill_ink, 1)
+
+                right = [x1 - r, y0, x1, y1]
+                if corners[1]:
+                    right[1] += r + 1
+                if corners[2]:
+                    right[3] -= r + 1
+                self.draw.draw_rectangle(right, fill_ink, 1)
+        if ink is not None and ink != fill_ink and width != 0:
+            draw_corners(False)
+
+            if not full_x:
+                top = [x0, y0, x1, y0 + width - 1]
+                if corners[0]:
+                    top[0] += r + 1
+                if corners[1]:
+                    top[2] -= r + 1
+                self.draw.draw_rectangle(top, ink, 1)
+
+                bottom = [x0, y1 - width + 1, x1, y1]
+                if corners[3]:
+                    bottom[0] += r + 1
+                if corners[2]:
+                    bottom[2] -= r + 1
+                self.draw.draw_rectangle(bottom, ink, 1)
+            if not full_y:
+                left = [x0, y0, x0 + width - 1, y1]
+                if corners[0]:
+                    left[1] += r + 1
+                if corners[3]:
+                    left[3] -= r + 1
+                self.draw.draw_rectangle(left, ink, 1)
+
+                right = [x1 - width + 1, y0, x1, y1]
+                if corners[1]:
+                    right[1] += r + 1
+                if corners[2]:
+                    right[3] -= r + 1
+                self.draw.draw_rectangle(right, ink, 1)
+
+    def text(
+        self,
+        xy: tuple[float, float],
+        text: AnyStr | ImageText.Text,
+        fill: _Ink | None = None,
+        font: (
+            ImageFont.ImageFont
+            | ImageFont.FreeTypeFont
+            | ImageFont.TransposedFont
+            | None
+        ) = None,
+        anchor: str | None = None,
+        spacing: float = 4,
+        align: str = "left",
+        direction: str | None = None,
+        features: list[str] | None = None,
+        language: str | None = None,
+        stroke_width: float = 0,
+        stroke_fill: _Ink | None = None,
+        embedded_color: bool = False,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """Draw text."""
+        if isinstance(text, ImageText.Text):
+            image_text = text
+        else:
+            if font is None:
+                font = self._getfont(kwargs.get("font_size"))
+            image_text = ImageText.Text(
+                text, font, self.mode, spacing, direction, features, language
+            )
+            if embedded_color:
+                image_text.embed_color()
+            if stroke_width:
+                image_text.stroke(stroke_width, stroke_fill)
+
+        def getink(fill: _Ink | None) -> int:
+            ink, fill_ink = self._getink(fill)
+            if ink is None:
+                assert fill_ink is not None
+                return fill_ink
+            return ink
+
+        ink = getink(fill)
+        if ink is None:
+            return
+
+        stroke_ink = None
+        if image_text.stroke_width:
+            stroke_ink = (
+                getink(image_text.stroke_fill)
+                if image_text.stroke_fill is not None
+                else ink
+            )
+
+        for xy, anchor, line in image_text._split(xy, anchor, align):
+
+            def draw_text(ink: int, stroke_width: float = 0) -> None:
+                mode = self.fontmode
+                if stroke_width == 0 and embedded_color:
+                    mode = "RGBA"
+                coord = []
+                for i in range(2):
+                    coord.append(int(xy[i]))
+                start = (math.modf(xy[0])[0], math.modf(xy[1])[0])
+                try:
+                    mask, offset = image_text.font.getmask2(  # type: ignore[union-attr,misc]
+                        line,
+                        mode,
+                        direction=direction,
+                        features=features,
+                        language=language,
+                        stroke_width=stroke_width,
+                        stroke_filled=True,
+                        anchor=anchor,
+                        ink=ink,
+                        start=start,
+                        *args,
+                        **kwargs,
+                    )
+                    coord = [coord[0] + offset[0], coord[1] + offset[1]]
+                except AttributeError:
+                    try:
+                        mask = image_text.font.getmask(  # type: ignore[misc]
+                            line,
+                            mode,
+                            direction,
+                            features,
+                            language,
+                            stroke_width,
+                            anchor,
+                            ink,
+                            start=start,
+                            *args,
+                            **kwargs,
+                        )
+                    except TypeError:
+                        mask = image_text.font.getmask(line)
+                if mode == "RGBA":
+                    # image_text.font.getmask2(mode="RGBA")
+                    # returns color in RGB bands and mask in A
+                    # extract mask and set text alpha
+                    color, mask = mask, mask.getband(3)
+                    ink_alpha = struct.pack("i", ink)[3]
+                    color.fillband(3, ink_alpha)
+                    x, y = coord
+                    if self.im is not None:
+                        self.im.paste(
+                            color, (x, y, x + mask.size[0], y + mask.size[1]), mask
+                        )
+                else:
+                    self.draw.draw_bitmap(coord, mask, ink)
+
+            if stroke_ink is not None:
+                # Draw stroked text
+                draw_text(stroke_ink, image_text.stroke_width)
+
+                # Draw normal text
+                if ink != stroke_ink:
+                    draw_text(ink)
+            else:
+                # Only draw normal text
+                draw_text(ink)
+
+    def multiline_text(
+        self,
+        xy: tuple[float, float],
+        text: AnyStr,
+        fill: _Ink | None = None,
+        font: (
+            ImageFont.ImageFont
+            | ImageFont.FreeTypeFont
+            | ImageFont.TransposedFont
+            | None
+        ) = None,
+        anchor: str | None = None,
+        spacing: float = 4,
+        align: str = "left",
+        direction: str | None = None,
+        features: list[str] | None = None,
+        language: str | None = None,
+        stroke_width: float = 0,
+        stroke_fill: _Ink | None = None,
+        embedded_color: bool = False,
+        *,
+        font_size: float | None = None,
+    ) -> None:
+        return self.text(
+            xy,
+            text,
+            fill,
+            font,
+            anchor,
+            spacing,
+            align,
+            direction,
+            features,
+            language,
+            stroke_width,
+            stroke_fill,
+            embedded_color,
+            font_size=font_size,
+        )
+
+    def textlength(
+        self,
+        text: AnyStr,
+        font: (
+            ImageFont.ImageFont
+            | ImageFont.FreeTypeFont
+            | ImageFont.TransposedFont
+            | None
+        ) = None,
+        direction: str | None = None,
+        features: list[str] | None = None,
+        language: str | None = None,
+        embedded_color: bool = False,
+        *,
+        font_size: float | None = None,
+    ) -> float:
+        """Get the length of a given string, in pixels with 1/64 precision."""
+        if font is None:
+            font = self._getfont(font_size)
+        image_text = ImageText.Text(
+            text,
+            font,
+            self.mode,
+            direction=direction,
+            features=features,
+            language=language,
+        )
+        if embedded_color:
+            image_text.embed_color()
+        return image_text.get_length()
+
+    def textbbox(
+        self,
+        xy: tuple[float, float],
+        text: AnyStr,
+        font: (
+            ImageFont.ImageFont
+            | ImageFont.FreeTypeFont
+            | ImageFont.TransposedFont
+            | None
+        ) = None,
+        anchor: str | None = None,
+        spacing: float = 4,
+        align: str = "left",
+        direction: str | None = None,
+        features: list[str] | None = None,
+        language: str | None = None,
+        stroke_width: float = 0,
+        embedded_color: bool = False,
+        *,
+        font_size: float | None = None,
+    ) -> tuple[float, float, float, float]:
+        """Get the bounding box of a given string, in pixels."""
+        if font is None:
+            font = self._getfont(font_size)
+        image_text = ImageText.Text(
+            text, font, self.mode, spacing, direction, features, language
+        )
+        if embedded_color:
+            image_text.embed_color()
+        if stroke_width:
+            image_text.stroke(stroke_width)
+        return image_text.get_bbox(xy, anchor, align)
+
+    def multiline_textbbox(
+        self,
+        xy: tuple[float, float],
+        text: AnyStr,
+        font: (
+            ImageFont.ImageFont
+            | ImageFont.FreeTypeFont
+            | ImageFont.TransposedFont
+            | None
+        ) = None,
+        anchor: str | None = None,
+        spacing: float = 4,
+        align: str = "left",
+        direction: str | None = None,
+        features: list[str] | None = None,
+        language: str | None = None,
+        stroke_width: float = 0,
+        embedded_color: bool = False,
+        *,
+        font_size: float | None = None,
+    ) -> tuple[float, float, float, float]:
+        return self.textbbox(
+            xy,
+            text,
+            font,
+            anchor,
+            spacing,
+            align,
+            direction,
+            features,
+            language,
+            stroke_width,
+            embedded_color,
+            font_size=font_size,
+        )
+
+
+def Draw(im: Image.Image, mode: str | None = None) -> ImageDraw:
+    """
+    A simple 2D drawing interface for PIL images.
+
+    :param im: The image to draw in.
+    :param mode: Optional mode to use for color values.  For RGB
+       images, this argument can be RGB or RGBA (to blend the
+       drawing into the image).  For all other modes, this argument
+       must be the same as the image mode.  If omitted, the mode
+       defaults to the mode of the image.
+    """
+    try:
+        return getattr(im, "getdraw")(mode)
+    except AttributeError:
+        return ImageDraw(im, mode)
+
+
+def getdraw(im: Image.Image | None = None) -> tuple[ImageDraw2.Draw | None, ModuleType]:
+    """
+    :param im: The image to draw in.
+    :returns: A (drawing context, drawing resource factory) tuple.
+    """
+    from . import ImageDraw2
+
+    draw = ImageDraw2.Draw(im) if im is not None else None
+    return draw, ImageDraw2
+
+
+def floodfill(
+    image: Image.Image,
+    xy: tuple[int, int],
+    value: float | tuple[int, ...],
+    border: float | tuple[int, ...] | None = None,
+    thresh: float = 0,
+) -> None:
+    """
+    .. warning:: This method is experimental.
+
+    Fills a bounded region with a given color.
+
+    :param image: Target image.
+    :param xy: Seed position (a 2-item coordinate tuple). See
+        :ref:`coordinate-system`.
+    :param value: Fill color.
+    :param border: Optional border value.  If given, the region consists of
+        pixels with a color different from the border color.  If not given,
+        the region consists of pixels having the same color as the seed
+        pixel.
+    :param thresh: Optional threshold value which specifies a maximum
+        tolerable difference of a pixel value from the 'background' in
+        order for it to be replaced. Useful for filling regions of
+        non-homogeneous, but similar, colors.
+    """
+    # based on an implementation by Eric S. Raymond
+    # amended by yo1995 @20180806
+    pixel = image.load()
+    assert pixel is not None
+    x, y = xy
+    try:
+        background = pixel[x, y]
+        if _color_diff(value, background) <= thresh:
+            return  # seed point already has fill color
+        pixel[x, y] = value
+    except (ValueError, IndexError):
+        return  # seed point outside image
+    edge = {(x, y)}
+    # use a set to keep record of current and previous edge pixels
+    # to reduce memory consumption
+    full_edge = set()
+    while edge:
+        new_edge = set()
+        for x, y in edge:  # 4 adjacent method
+            for s, t in ((x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)):
+                # If already processed, or if a coordinate is negative, skip
+                if (s, t) in full_edge or s < 0 or t < 0:
+                    continue
+                try:
+                    p = pixel[s, t]
+                except (ValueError, IndexError):
+                    pass
+                else:
+                    full_edge.add((s, t))
+                    if border is None:
+                        fill = _color_diff(p, background) <= thresh
+                    else:
+                        fill = p not in (value, border)
+                    if fill:
+                        pixel[s, t] = value
+                        new_edge.add((s, t))
+        full_edge = edge  # discard pixels processed
+        edge = new_edge
+
+
+def _compute_regular_polygon_vertices(
+    bounding_circle: Sequence[Sequence[float] | float], n_sides: int, rotation: float
+) -> list[tuple[float, float]]:
+    """
+    Generate a list of vertices for a 2D regular polygon.
+
+    :param bounding_circle: The bounding circle is a sequence defined
+        by a point and radius. The polygon is inscribed in this circle.
+        (e.g. ``bounding_circle=(x, y, r)`` or ``((x, y), r)``)
+    :param n_sides: Number of sides
+        (e.g. ``n_sides=3`` for a triangle, ``6`` for a hexagon)
+    :param rotation: Apply an arbitrary rotation to the polygon
+        (e.g. ``rotation=90``, applies a 90 degree rotation)
+    :return: List of regular polygon vertices
+        (e.g. ``[(25, 50), (50, 50), (50, 25), (25, 25)]``)
+
+    How are the vertices computed?
+    1. Compute the following variables
+        - theta: Angle between the apothem & the nearest polygon vertex
+        - side_length: Length of each polygon edge
+        - centroid: Center of bounding circle (1st, 2nd elements of bounding_circle)
+        - polygon_radius: Polygon radius (last element of bounding_circle)
+        - angles: Location of each polygon vertex in polar grid
+            (e.g. A square with 0 degree rotation => [225.0, 315.0, 45.0, 135.0])
+
+    2. For each angle in angles, get the polygon vertex at that angle
+        The vertex is computed using the equation below.
+            X= xcos(φ) + ysin(φ)
+            Y= −xsin(φ) + ycos(φ)
+
+        Note:
+            φ = angle in degrees
+            x = 0
+            y = polygon_radius
+
+        The formula above assumes rotation around the origin.
+        In our case, we are rotating around the centroid.
+        To account for this, we use the formula below
+            X = xcos(φ) + ysin(φ) + centroid_x
+            Y = −xsin(φ) + ycos(φ) + centroid_y
+    """
+    # 1. Error Handling
+    # 1.1 Check `n_sides` has an appropriate value
+    if not isinstance(n_sides, int):
+        msg = "n_sides should be an int"  # type: ignore[unreachable]
+        raise TypeError(msg)
+    if n_sides < 3:
+        msg = "n_sides should be an int > 2"
+        raise ValueError(msg)
+
+    # 1.2 Check `bounding_circle` has an appropriate value
+    if not isinstance(bounding_circle, (list, tuple)):
+        msg = "bounding_circle should be a sequence"
+        raise TypeError(msg)
+
+    if len(bounding_circle) == 3:
+        if not all(isinstance(i, (int, float)) for i in bounding_circle):
+            msg = "bounding_circle should only contain numeric data"
+            raise ValueError(msg)
+
+        *centroid, polygon_radius = cast(list[float], list(bounding_circle))
+    elif len(bounding_circle) == 2 and isinstance(bounding_circle[0], (list, tuple)):
+        if not all(
+            isinstance(i, (int, float)) for i in bounding_circle[0]
+        ) or not isinstance(bounding_circle[1], (int, float)):
+            msg = "bounding_circle should only contain numeric data"
+            raise ValueError(msg)
+
+        if len(bounding_circle[0]) != 2:
+            msg = "bounding_circle centre should contain 2D coordinates (e.g. (x, y))"
+            raise ValueError(msg)
+
+        centroid = cast(list[float], list(bounding_circle[0]))
+        polygon_radius = cast(float, bounding_circle[1])
+    else:
+        msg = (
+            "bounding_circle should contain 2D coordinates "
+            "and a radius (e.g. (x, y, r) or ((x, y), r) )"
+        )
+        raise ValueError(msg)
+
+    if polygon_radius <= 0:
+        msg = "bounding_circle radius should be > 0"
+        raise ValueError(msg)
+
+    # 1.3 Check `rotation` has an appropriate value
+    if not isinstance(rotation, (int, float)):
+        msg = "rotation should be an int or float"  # type: ignore[unreachable]
+        raise ValueError(msg)
+
+    # 2. Define Helper Functions
+    def _apply_rotation(point: list[float], degrees: float) -> tuple[float, float]:
+        return (
+            round(
+                point[0] * math.cos(math.radians(360 - degrees))
+                - point[1] * math.sin(math.radians(360 - degrees))
+                + centroid[0],
+                2,
+            ),
+            round(
+                point[1] * math.cos(math.radians(360 - degrees))
+                + point[0] * math.sin(math.radians(360 - degrees))
+                + centroid[1],
+                2,
+            ),
+        )
+
+    def _compute_polygon_vertex(angle: float) -> tuple[float, float]:
+        start_point = [polygon_radius, 0]
+        return _apply_rotation(start_point, angle)
+
+    def _get_angles(n_sides: int, rotation: float) -> list[float]:
+        angles = []
+        degrees = 360 / n_sides
+        # Start with the bottom left polygon vertex
+        current_angle = (270 - 0.5 * degrees) + rotation
+        for _ in range(n_sides):
+            angles.append(current_angle)
+            current_angle += degrees
+            if current_angle > 360:
+                current_angle -= 360
+        return angles
+
+    # 3. Variable Declarations
+    angles = _get_angles(n_sides, rotation)
+
+    # 4. Compute Vertices
+    return [_compute_polygon_vertex(angle) for angle in angles]
+
+
+def _color_diff(
+    color1: float | tuple[int, ...], color2: float | tuple[int, ...]
+) -> float:
+    """
+    Uses 1-norm distance to calculate difference between two values.
+    """
+    first = color1 if isinstance(color1, tuple) else (color1,)
+    second = color2 if isinstance(color2, tuple) else (color2,)
+
+    return sum(abs(first[i] - second[i]) for i in range(len(second)))

.venv/lib/python3.12/site-packages/PIL/ImageDraw2.py

@@ -0,0 +1,243 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# WCK-style drawing interface operations
+#
+# History:
+# 2003-12-07 fl   created
+# 2005-05-15 fl   updated; added to PIL as ImageDraw2
+# 2005-05-15 fl   added text support
+# 2005-05-20 fl   added arc/chord/pieslice support
+#
+# Copyright (c) 2003-2005 by Secret Labs AB
+# Copyright (c) 2003-2005 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+
+
+"""
+(Experimental) WCK-style drawing interface operations
+
+.. seealso:: :py:mod:`PIL.ImageDraw`
+"""
+from __future__ import annotations
+
+from typing import Any, AnyStr, BinaryIO
+
+from . import Image, ImageColor, ImageDraw, ImageFont, ImagePath
+from ._typing import Coords, StrOrBytesPath
+
+
+class Pen:
+    """Stores an outline color and width."""
+
+    def __init__(self, color: str, width: int = 1, opacity: int = 255) -> None:
+        self.color = ImageColor.getrgb(color)
+        self.width = width
+
+
+class Brush:
+    """Stores a fill color"""
+
+    def __init__(self, color: str, opacity: int = 255) -> None:
+        self.color = ImageColor.getrgb(color)
+
+
+class Font:
+    """Stores a TrueType font and color"""
+
+    def __init__(
+        self, color: str, file: StrOrBytesPath | BinaryIO, size: float = 12
+    ) -> None:
+        # FIXME: add support for bitmap fonts
+        self.color = ImageColor.getrgb(color)
+        self.font = ImageFont.truetype(file, size)
+
+
+class Draw:
+    """
+    (Experimental) WCK-style drawing interface
+    """
+
+    def __init__(
+        self,
+        image: Image.Image | str,
+        size: tuple[int, int] | list[int] | None = None,
+        color: float | tuple[float, ...] | str | None = None,
+    ) -> None:
+        if isinstance(image, str):
+            if size is None:
+                msg = "If image argument is mode string, size must be a list or tuple"
+                raise ValueError(msg)
+            image = Image.new(image, size, color)
+        self.draw = ImageDraw.Draw(image)
+        self.image = image
+        self.transform: tuple[float, float, float, float, float, float] | None = None
+
+    def flush(self) -> Image.Image:
+        return self.image
+
+    def render(
+        self,
+        op: str,
+        xy: Coords,
+        pen: Pen | Brush | None,
+        brush: Brush | Pen | None = None,
+        **kwargs: Any,
+    ) -> None:
+        # handle color arguments
+        outline = fill = None
+        width = 1
+        if isinstance(pen, Pen):
+            outline = pen.color
+            width = pen.width
+        elif isinstance(brush, Pen):
+            outline = brush.color
+            width = brush.width
+        if isinstance(brush, Brush):
+            fill = brush.color
+        elif isinstance(pen, Brush):
+            fill = pen.color
+        # handle transformation
+        if self.transform:
+            path = ImagePath.Path(xy)
+            path.transform(self.transform)
+            xy = path
+        # render the item
+        if op in ("arc", "line"):
+            kwargs.setdefault("fill", outline)
+        else:
+            kwargs.setdefault("fill", fill)
+            kwargs.setdefault("outline", outline)
+        if op == "line":
+            kwargs.setdefault("width", width)
+        getattr(self.draw, op)(xy, **kwargs)
+
+    def settransform(self, offset: tuple[float, float]) -> None:
+        """Sets a transformation offset."""
+        (xoffset, yoffset) = offset
+        self.transform = (1, 0, xoffset, 0, 1, yoffset)
+
+    def arc(
+        self,
+        xy: Coords,
+        pen: Pen | Brush | None,
+        start: float,
+        end: float,
+        *options: Any,
+    ) -> None:
+        """
+        Draws an arc (a portion of a circle outline) between the start and end
+        angles, inside the given bounding box.
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.arc`
+        """
+        self.render("arc", xy, pen, *options, start=start, end=end)
+
+    def chord(
+        self,
+        xy: Coords,
+        pen: Pen | Brush | None,
+        start: float,
+        end: float,
+        *options: Any,
+    ) -> None:
+        """
+        Same as :py:meth:`~PIL.ImageDraw2.Draw.arc`, but connects the end points
+        with a straight line.
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.chord`
+        """
+        self.render("chord", xy, pen, *options, start=start, end=end)
+
+    def ellipse(self, xy: Coords, pen: Pen | Brush | None, *options: Any) -> None:
+        """
+        Draws an ellipse inside the given bounding box.
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.ellipse`
+        """
+        self.render("ellipse", xy, pen, *options)
+
+    def line(self, xy: Coords, pen: Pen | Brush | None, *options: Any) -> None:
+        """
+        Draws a line between the coordinates in the ``xy`` list.
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.line`
+        """
+        self.render("line", xy, pen, *options)
+
+    def pieslice(
+        self,
+        xy: Coords,
+        pen: Pen | Brush | None,
+        start: float,
+        end: float,
+        *options: Any,
+    ) -> None:
+        """
+        Same as arc, but also draws straight lines between the end points and the
+        center of the bounding box.
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.pieslice`
+        """
+        self.render("pieslice", xy, pen, *options, start=start, end=end)
+
+    def polygon(self, xy: Coords, pen: Pen | Brush | None, *options: Any) -> None:
+        """
+        Draws a polygon.
+
+        The polygon outline consists of straight lines between the given
+        coordinates, plus a straight line between the last and the first
+        coordinate.
+
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.polygon`
+        """
+        self.render("polygon", xy, pen, *options)
+
+    def rectangle(self, xy: Coords, pen: Pen | Brush | None, *options: Any) -> None:
+        """
+        Draws a rectangle.
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.rectangle`
+        """
+        self.render("rectangle", xy, pen, *options)
+
+    def text(self, xy: tuple[float, float], text: AnyStr, font: Font) -> None:
+        """
+        Draws the string at the given position.
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.text`
+        """
+        if self.transform:
+            path = ImagePath.Path(xy)
+            path.transform(self.transform)
+            xy = path
+        self.draw.text(xy, text, font=font.font, fill=font.color)
+
+    def textbbox(
+        self, xy: tuple[float, float], text: AnyStr, font: Font
+    ) -> tuple[float, float, float, float]:
+        """
+        Returns bounding box (in pixels) of given text.
+
+        :return: ``(left, top, right, bottom)`` bounding box
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.textbbox`
+        """
+        if self.transform:
+            path = ImagePath.Path(xy)
+            path.transform(self.transform)
+            xy = path
+        return self.draw.textbbox(xy, text, font=font.font)
+
+    def textlength(self, text: AnyStr, font: Font) -> float:
+        """
+        Returns length (in pixels) of given text.
+        This is the amount by which following text should be offset.
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.textlength`
+        """
+        return self.draw.textlength(text, font=font.font)

.venv/lib/python3.12/site-packages/PIL/ImageEnhance.py

@@ -0,0 +1,113 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# image enhancement classes
+#
+# For a background, see "Image Processing By Interpolation and
+# Extrapolation", Paul Haeberli and Douglas Voorhies.  Available
+# at http://www.graficaobscura.com/interp/index.html
+#
+# History:
+# 1996-03-23 fl  Created
+# 2009-06-16 fl  Fixed mean calculation
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1996.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+from . import Image, ImageFilter, ImageStat
+
+
+class _Enhance:
+    image: Image.Image
+    degenerate: Image.Image
+
+    def enhance(self, factor: float) -> Image.Image:
+        """
+        Returns an enhanced image.
+
+        :param factor: A floating point value controlling the enhancement.
+                       Factor 1.0 always returns a copy of the original image,
+                       lower factors mean less color (brightness, contrast,
+                       etc), and higher values more. There are no restrictions
+                       on this value.
+        :rtype: :py:class:`~PIL.Image.Image`
+        """
+        return Image.blend(self.degenerate, self.image, factor)
+
+
+class Color(_Enhance):
+    """Adjust image color balance.
+
+    This class can be used to adjust the colour balance of an image, in
+    a manner similar to the controls on a colour TV set. An enhancement
+    factor of 0.0 gives a black and white image. A factor of 1.0 gives
+    the original image.
+    """
+
+    def __init__(self, image: Image.Image) -> None:
+        self.image = image
+        self.intermediate_mode = "L"
+        if "A" in image.getbands():
+            self.intermediate_mode = "LA"
+
+        if self.intermediate_mode != image.mode:
+            image = image.convert(self.intermediate_mode).convert(image.mode)
+        self.degenerate = image
+
+
+class Contrast(_Enhance):
+    """Adjust image contrast.
+
+    This class can be used to control the contrast of an image, similar
+    to the contrast control on a TV set. An enhancement factor of 0.0
+    gives a solid gray image. A factor of 1.0 gives the original image.
+    """
+
+    def __init__(self, image: Image.Image) -> None:
+        self.image = image
+        if image.mode != "L":
+            image = image.convert("L")
+        mean = int(ImageStat.Stat(image).mean[0] + 0.5)
+        self.degenerate = Image.new("L", image.size, mean)
+        if self.degenerate.mode != self.image.mode:
+            self.degenerate = self.degenerate.convert(self.image.mode)
+
+        if "A" in self.image.getbands():
+            self.degenerate.putalpha(self.image.getchannel("A"))
+
+
+class Brightness(_Enhance):
+    """Adjust image brightness.
+
+    This class can be used to control the brightness of an image.  An
+    enhancement factor of 0.0 gives a black image. A factor of 1.0 gives the
+    original image.
+    """
+
+    def __init__(self, image: Image.Image) -> None:
+        self.image = image
+        self.degenerate = Image.new(image.mode, image.size, 0)
+
+        if "A" in image.getbands():
+            self.degenerate.putalpha(image.getchannel("A"))
+
+
+class Sharpness(_Enhance):
+    """Adjust image sharpness.
+
+    This class can be used to adjust the sharpness of an image. An
+    enhancement factor of 0.0 gives a blurred image, a factor of 1.0 gives the
+    original image, and a factor of 2.0 gives a sharpened image.
+    """
+
+    def __init__(self, image: Image.Image) -> None:
+        self.image = image
+        self.degenerate = image.filter(ImageFilter.SMOOTH)
+
+        if "A" in image.getbands():
+            self.degenerate.putalpha(image.getchannel("A"))

.venv/lib/python3.12/site-packages/PIL/ImageFilter.py

@@ -0,0 +1,607 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# standard filters
+#
+# History:
+# 1995-11-27 fl   Created
+# 2002-06-08 fl   Added rank and mode filters
+# 2003-09-15 fl   Fixed rank calculation in rank filter; added expand call
+#
+# Copyright (c) 1997-2003 by Secret Labs AB.
+# Copyright (c) 1995-2002 by Fredrik Lundh.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import abc
+import functools
+from collections.abc import Sequence
+from typing import cast
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from types import ModuleType
+    from typing import Any
+
+    from . import _imaging
+    from ._typing import NumpyArray
+
+
+class Filter(abc.ABC):
+    @abc.abstractmethod
+    def filter(self, image: _imaging.ImagingCore) -> _imaging.ImagingCore:
+        pass
+
+
+class MultibandFilter(Filter):
+    pass
+
+
+class BuiltinFilter(MultibandFilter):
+    filterargs: tuple[Any, ...]
+
+    def filter(self, image: _imaging.ImagingCore) -> _imaging.ImagingCore:
+        if image.mode == "P":
+            msg = "cannot filter palette images"
+            raise ValueError(msg)
+        return image.filter(*self.filterargs)
+
+
+class Kernel(BuiltinFilter):
+    """
+    Create a convolution kernel. This only supports 3x3 and 5x5 integer and floating
+    point kernels.
+
+    Kernels can only be applied to "L" and "RGB" images.
+
+    :param size: Kernel size, given as (width, height). This must be (3,3) or (5,5).
+    :param kernel: A sequence containing kernel weights. The kernel will be flipped
+                   vertically before being applied to the image.
+    :param scale: Scale factor. If given, the result for each pixel is divided by this
+                  value. The default is the sum of the kernel weights.
+    :param offset: Offset. If given, this value is added to the result, after it has
+                   been divided by the scale factor.
+    """
+
+    name = "Kernel"
+
+    def __init__(
+        self,
+        size: tuple[int, int],
+        kernel: Sequence[float],
+        scale: float | None = None,
+        offset: float = 0,
+    ) -> None:
+        if scale is None:
+            # default scale is sum of kernel
+            scale = functools.reduce(lambda a, b: a + b, kernel)
+        if size[0] * size[1] != len(kernel):
+            msg = "not enough coefficients in kernel"
+            raise ValueError(msg)
+        self.filterargs = size, scale, offset, kernel
+
+
+class RankFilter(Filter):
+    """
+    Create a rank filter.  The rank filter sorts all pixels in
+    a window of the given size, and returns the ``rank``'th value.
+
+    :param size: The kernel size, in pixels.
+    :param rank: What pixel value to pick.  Use 0 for a min filter,
+                 ``size * size / 2`` for a median filter, ``size * size - 1``
+                 for a max filter, etc.
+    """
+
+    name = "Rank"
+
+    def __init__(self, size: int, rank: int) -> None:
+        self.size = size
+        self.rank = rank
+
+    def filter(self, image: _imaging.ImagingCore) -> _imaging.ImagingCore:
+        if image.mode == "P":
+            msg = "cannot filter palette images"
+            raise ValueError(msg)
+        image = image.expand(self.size // 2, self.size // 2)
+        return image.rankfilter(self.size, self.rank)
+
+
+class MedianFilter(RankFilter):
+    """
+    Create a median filter. Picks the median pixel value in a window with the
+    given size.
+
+    :param size: The kernel size, in pixels.
+    """
+
+    name = "Median"
+
+    def __init__(self, size: int = 3) -> None:
+        self.size = size
+        self.rank = size * size // 2
+
+
+class MinFilter(RankFilter):
+    """
+    Create a min filter.  Picks the lowest pixel value in a window with the
+    given size.
+
+    :param size: The kernel size, in pixels.
+    """
+
+    name = "Min"
+
+    def __init__(self, size: int = 3) -> None:
+        self.size = size
+        self.rank = 0
+
+
+class MaxFilter(RankFilter):
+    """
+    Create a max filter.  Picks the largest pixel value in a window with the
+    given size.
+
+    :param size: The kernel size, in pixels.
+    """
+
+    name = "Max"
+
+    def __init__(self, size: int = 3) -> None:
+        self.size = size
+        self.rank = size * size - 1
+
+
+class ModeFilter(Filter):
+    """
+    Create a mode filter. Picks the most frequent pixel value in a box with the
+    given size.  Pixel values that occur only once or twice are ignored; if no
+    pixel value occurs more than twice, the original pixel value is preserved.
+
+    :param size: The kernel size, in pixels.
+    """
+
+    name = "Mode"
+
+    def __init__(self, size: int = 3) -> None:
+        self.size = size
+
+    def filter(self, image: _imaging.ImagingCore) -> _imaging.ImagingCore:
+        return image.modefilter(self.size)
+
+
+class GaussianBlur(MultibandFilter):
+    """Blurs the image with a sequence of extended box filters, which
+    approximates a Gaussian kernel. For details on accuracy see
+    <https://www.mia.uni-saarland.de/Publications/gwosdek-ssvm11.pdf>
+
+    :param radius: Standard deviation of the Gaussian kernel. Either a sequence of two
+                   numbers for x and y, or a single number for both.
+    """
+
+    name = "GaussianBlur"
+
+    def __init__(self, radius: float | Sequence[float] = 2) -> None:
+        self.radius = radius
+
+    def filter(self, image: _imaging.ImagingCore) -> _imaging.ImagingCore:
+        xy = self.radius
+        if isinstance(xy, (int, float)):
+            xy = (xy, xy)
+        if xy == (0, 0):
+            return image.copy()
+        return image.gaussian_blur(xy)
+
+
+class BoxBlur(MultibandFilter):
+    """Blurs the image by setting each pixel to the average value of the pixels
+    in a square box extending radius pixels in each direction.
+    Supports float radius of arbitrary size. Uses an optimized implementation
+    which runs in linear time relative to the size of the image
+    for any radius value.
+
+    :param radius: Size of the box in a direction. Either a sequence of two numbers for
+                   x and y, or a single number for both.
+
+                   Radius 0 does not blur, returns an identical image.
+                   Radius 1 takes 1 pixel in each direction, i.e. 9 pixels in total.
+    """
+
+    name = "BoxBlur"
+
+    def __init__(self, radius: float | Sequence[float]) -> None:
+        xy = radius if isinstance(radius, (tuple, list)) else (radius, radius)
+        if xy[0] < 0 or xy[1] < 0:
+            msg = "radius must be >= 0"
+            raise ValueError(msg)
+        self.radius = radius
+
+    def filter(self, image: _imaging.ImagingCore) -> _imaging.ImagingCore:
+        xy = self.radius
+        if isinstance(xy, (int, float)):
+            xy = (xy, xy)
+        if xy == (0, 0):
+            return image.copy()
+        return image.box_blur(xy)
+
+
+class UnsharpMask(MultibandFilter):
+    """Unsharp mask filter.
+
+    See Wikipedia's entry on `digital unsharp masking`_ for an explanation of
+    the parameters.
+
+    :param radius: Blur Radius
+    :param percent: Unsharp strength, in percent
+    :param threshold: Threshold controls the minimum brightness change that
+      will be sharpened
+
+    .. _digital unsharp masking: https://en.wikipedia.org/wiki/Unsharp_masking#Digital_unsharp_masking
+
+    """
+
+    name = "UnsharpMask"
+
+    def __init__(
+        self, radius: float = 2, percent: int = 150, threshold: int = 3
+    ) -> None:
+        self.radius = radius
+        self.percent = percent
+        self.threshold = threshold
+
+    def filter(self, image: _imaging.ImagingCore) -> _imaging.ImagingCore:
+        return image.unsharp_mask(self.radius, self.percent, self.threshold)
+
+
+class BLUR(BuiltinFilter):
+    name = "Blur"
+    # fmt: off
+    filterargs = (5, 5), 16, 0, (
+        1, 1, 1, 1, 1,
+        1, 0, 0, 0, 1,
+        1, 0, 0, 0, 1,
+        1, 0, 0, 0, 1,
+        1, 1, 1, 1, 1,
+    )
+    # fmt: on
+
+
+class CONTOUR(BuiltinFilter):
+    name = "Contour"
+    # fmt: off
+    filterargs = (3, 3), 1, 255, (
+        -1, -1, -1,
+        -1,  8, -1,
+        -1, -1, -1,
+    )
+    # fmt: on
+
+
+class DETAIL(BuiltinFilter):
+    name = "Detail"
+    # fmt: off
+    filterargs = (3, 3), 6, 0, (
+        0,  -1,  0,
+        -1, 10, -1,
+        0,  -1,  0,
+    )
+    # fmt: on
+
+
+class EDGE_ENHANCE(BuiltinFilter):
+    name = "Edge-enhance"
+    # fmt: off
+    filterargs = (3, 3), 2, 0, (
+        -1, -1, -1,
+        -1, 10, -1,
+        -1, -1, -1,
+    )
+    # fmt: on
+
+
+class EDGE_ENHANCE_MORE(BuiltinFilter):
+    name = "Edge-enhance More"
+    # fmt: off
+    filterargs = (3, 3), 1, 0, (
+        -1, -1, -1,
+        -1,  9, -1,
+        -1, -1, -1,
+    )
+    # fmt: on
+
+
+class EMBOSS(BuiltinFilter):
+    name = "Emboss"
+    # fmt: off
+    filterargs = (3, 3), 1, 128, (
+        -1, 0, 0,
+        0,  1, 0,
+        0,  0, 0,
+    )
+    # fmt: on
+
+
+class FIND_EDGES(BuiltinFilter):
+    name = "Find Edges"
+    # fmt: off
+    filterargs = (3, 3), 1, 0, (
+        -1, -1, -1,
+        -1,  8, -1,
+        -1, -1, -1,
+    )
+    # fmt: on
+
+
+class SHARPEN(BuiltinFilter):
+    name = "Sharpen"
+    # fmt: off
+    filterargs = (3, 3), 16, 0, (
+        -2, -2, -2,
+        -2, 32, -2,
+        -2, -2, -2,
+    )
+    # fmt: on
+
+
+class SMOOTH(BuiltinFilter):
+    name = "Smooth"
+    # fmt: off
+    filterargs = (3, 3), 13, 0, (
+        1, 1, 1,
+        1, 5, 1,
+        1, 1, 1,
+    )
+    # fmt: on
+
+
+class SMOOTH_MORE(BuiltinFilter):
+    name = "Smooth More"
+    # fmt: off
+    filterargs = (5, 5), 100, 0, (
+        1, 1,  1, 1, 1,
+        1, 5,  5, 5, 1,
+        1, 5, 44, 5, 1,
+        1, 5,  5, 5, 1,
+        1, 1,  1, 1, 1,
+    )
+    # fmt: on
+
+
+class Color3DLUT(MultibandFilter):
+    """Three-dimensional color lookup table.
+
+    Transforms 3-channel pixels using the values of the channels as coordinates
+    in the 3D lookup table and interpolating the nearest elements.
+
+    This method allows you to apply almost any color transformation
+    in constant time by using pre-calculated decimated tables.
+
+    .. versionadded:: 5.2.0
+
+    :param size: Size of the table. One int or tuple of (int, int, int).
+                 Minimal size in any dimension is 2, maximum is 65.
+    :param table: Flat lookup table. A list of ``channels * size**3``
+                  float elements or a list of ``size**3`` channels-sized
+                  tuples with floats. Channels are changed first,
+                  then first dimension, then second, then third.
+                  Value 0.0 corresponds lowest value of output, 1.0 highest.
+    :param channels: Number of channels in the table. Could be 3 or 4.
+                     Default is 3.
+    :param target_mode: A mode for the result image. Should have not less
+                        than ``channels`` channels. Default is ``None``,
+                        which means that mode wouldn't be changed.
+    """
+
+    name = "Color 3D LUT"
+
+    def __init__(
+        self,
+        size: int | tuple[int, int, int],
+        table: Sequence[float] | Sequence[Sequence[int]] | NumpyArray,
+        channels: int = 3,
+        target_mode: str | None = None,
+        **kwargs: bool,
+    ) -> None:
+        if channels not in (3, 4):
+            msg = "Only 3 or 4 output channels are supported"
+            raise ValueError(msg)
+        self.size = size = self._check_size(size)
+        self.channels = channels
+        self.mode = target_mode
+
+        # Hidden flag `_copy_table=False` could be used to avoid extra copying
+        # of the table if the table is specially made for the constructor.
+        copy_table = kwargs.get("_copy_table", True)
+        items = size[0] * size[1] * size[2]
+        wrong_size = False
+
+        numpy: ModuleType | None = None
+        if hasattr(table, "shape"):
+            try:
+                import numpy
+            except ImportError:
+                pass
+
+        if numpy and isinstance(table, numpy.ndarray):
+            numpy_table: NumpyArray = table
+            if copy_table:
+                numpy_table = numpy_table.copy()
+
+            if numpy_table.shape in [
+                (items * channels,),
+                (items, channels),
+                (size[2], size[1], size[0], channels),
+            ]:
+                table = numpy_table.reshape(items * channels)
+            else:
+                wrong_size = True
+
+        else:
+            if copy_table:
+                table = list(table)
+
+            # Convert to a flat list
+            if table and isinstance(table[0], (list, tuple)):
+                raw_table = cast(Sequence[Sequence[int]], table)
+                flat_table: list[int] = []
+                for pixel in raw_table:
+                    if len(pixel) != channels:
+                        msg = (
+                            "The elements of the table should "
+                            f"have a length of {channels}."
+                        )
+                        raise ValueError(msg)
+                    flat_table.extend(pixel)
+                table = flat_table
+
+        if wrong_size or len(table) != items * channels:
+            msg = (
+                "The table should have either channels * size**3 float items "
+                "or size**3 items of channels-sized tuples with floats. "
+                f"Table should be: {channels}x{size[0]}x{size[1]}x{size[2]}. "
+                f"Actual length: {len(table)}"
+            )
+            raise ValueError(msg)
+        self.table = table
+
+    @staticmethod
+    def _check_size(size: Any) -> tuple[int, int, int]:
+        try:
+            _, _, _ = size
+        except ValueError as e:
+            msg = "Size should be either an integer or a tuple of three integers."
+            raise ValueError(msg) from e
+        except TypeError:
+            size = (size, size, size)
+        size = tuple(int(x) for x in size)
+        for size_1d in size:
+            if not 2 <= size_1d <= 65:
+                msg = "Size should be in [2, 65] range."
+                raise ValueError(msg)
+        return size
+
+    @classmethod
+    def generate(
+        cls,
+        size: int | tuple[int, int, int],
+        callback: Callable[[float, float, float], tuple[float, ...]],
+        channels: int = 3,
+        target_mode: str | None = None,
+    ) -> Color3DLUT:
+        """Generates new LUT using provided callback.
+
+        :param size: Size of the table. Passed to the constructor.
+        :param callback: Function with three parameters which correspond
+                         three color channels. Will be called ``size**3``
+                         times with values from 0.0 to 1.0 and should return
+                         a tuple with ``channels`` elements.
+        :param channels: The number of channels which should return callback.
+        :param target_mode: Passed to the constructor of the resulting
+                            lookup table.
+        """
+        size_1d, size_2d, size_3d = cls._check_size(size)
+        if channels not in (3, 4):
+            msg = "Only 3 or 4 output channels are supported"
+            raise ValueError(msg)
+
+        table: list[float] = [0] * (size_1d * size_2d * size_3d * channels)
+        idx_out = 0
+        for b in range(size_3d):
+            for g in range(size_2d):
+                for r in range(size_1d):
+                    table[idx_out : idx_out + channels] = callback(
+                        r / (size_1d - 1), g / (size_2d - 1), b / (size_3d - 1)
+                    )
+                    idx_out += channels
+
+        return cls(
+            (size_1d, size_2d, size_3d),
+            table,
+            channels=channels,
+            target_mode=target_mode,
+            _copy_table=False,
+        )
+
+    def transform(
+        self,
+        callback: Callable[..., tuple[float, ...]],
+        with_normals: bool = False,
+        channels: int | None = None,
+        target_mode: str | None = None,
+    ) -> Color3DLUT:
+        """Transforms the table values using provided callback and returns
+        a new LUT with altered values.
+
+        :param callback: A function which takes old lookup table values
+                         and returns a new set of values. The number
+                         of arguments which function should take is
+                         ``self.channels`` or ``3 + self.channels``
+                         if ``with_normals`` flag is set.
+                         Should return a tuple of ``self.channels`` or
+                         ``channels`` elements if it is set.
+        :param with_normals: If true, ``callback`` will be called with
+                             coordinates in the color cube as the first
+                             three arguments. Otherwise, ``callback``
+                             will be called only with actual color values.
+        :param channels: The number of channels in the resulting lookup table.
+        :param target_mode: Passed to the constructor of the resulting
+                            lookup table.
+        """
+        if channels not in (None, 3, 4):
+            msg = "Only 3 or 4 output channels are supported"
+            raise ValueError(msg)
+        ch_in = self.channels
+        ch_out = channels or ch_in
+        size_1d, size_2d, size_3d = self.size
+
+        table: list[float] = [0] * (size_1d * size_2d * size_3d * ch_out)
+        idx_in = 0
+        idx_out = 0
+        for b in range(size_3d):
+            for g in range(size_2d):
+                for r in range(size_1d):
+                    values = self.table[idx_in : idx_in + ch_in]
+                    if with_normals:
+                        values = callback(
+                            r / (size_1d - 1),
+                            g / (size_2d - 1),
+                            b / (size_3d - 1),
+                            *values,
+                        )
+                    else:
+                        values = callback(*values)
+                    table[idx_out : idx_out + ch_out] = values
+                    idx_in += ch_in
+                    idx_out += ch_out
+
+        return type(self)(
+            self.size,
+            table,
+            channels=ch_out,
+            target_mode=target_mode or self.mode,
+            _copy_table=False,
+        )
+
+    def __repr__(self) -> str:
+        r = [
+            f"{self.__class__.__name__} from {self.table.__class__.__name__}",
+            "size={:d}x{:d}x{:d}".format(*self.size),
+            f"channels={self.channels:d}",
+        ]
+        if self.mode:
+            r.append(f"target_mode={self.mode}")
+        return "<{}>".format(" ".join(r))
+
+    def filter(self, image: _imaging.ImagingCore) -> _imaging.ImagingCore:
+        from . import Image
+
+        return image.color_lut_3d(
+            self.mode or image.mode,
+            Image.Resampling.BILINEAR,
+            self.channels,
+            self.size,
+            self.table,
+        )

.venv/lib/python3.12/site-packages/PIL/ImageGrab.py

@@ -0,0 +1,196 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# screen grabber
+#
+# History:
+# 2001-04-26 fl  created
+# 2001-09-17 fl  use builtin driver, if present
+# 2002-11-19 fl  added grabclipboard support
+#
+# Copyright (c) 2001-2002 by Secret Labs AB
+# Copyright (c) 2001-2002 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import io
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+from . import Image
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from . import ImageWin
+
+
+def grab(
+    bbox: tuple[int, int, int, int] | None = None,
+    include_layered_windows: bool = False,
+    all_screens: bool = False,
+    xdisplay: str | None = None,
+    window: int | ImageWin.HWND | None = None,
+) -> Image.Image:
+    im: Image.Image
+    if xdisplay is None:
+        if sys.platform == "darwin":
+            fh, filepath = tempfile.mkstemp(".png")
+            os.close(fh)
+            args = ["screencapture"]
+            if bbox:
+                left, top, right, bottom = bbox
+                args += ["-R", f"{left},{top},{right-left},{bottom-top}"]
+            subprocess.call(args + ["-x", filepath])
+            im = Image.open(filepath)
+            im.load()
+            os.unlink(filepath)
+            if bbox:
+                im_resized = im.resize((right - left, bottom - top))
+                im.close()
+                return im_resized
+            return im
+        elif sys.platform == "win32":
+            if window is not None:
+                all_screens = -1
+            offset, size, data = Image.core.grabscreen_win32(
+                include_layered_windows,
+                all_screens,
+                int(window) if window is not None else 0,
+            )
+            im = Image.frombytes(
+                "RGB",
+                size,
+                data,
+                # RGB, 32-bit line padding, origin lower left corner
+                "raw",
+                "BGR",
+                (size[0] * 3 + 3) & -4,
+                -1,
+            )
+            if bbox:
+                x0, y0 = offset
+                left, top, right, bottom = bbox
+                im = im.crop((left - x0, top - y0, right - x0, bottom - y0))
+            return im
+    # Cast to Optional[str] needed for Windows and macOS.
+    display_name: str | None = xdisplay
+    try:
+        if not Image.core.HAVE_XCB:
+            msg = "Pillow was built without XCB support"
+            raise OSError(msg)
+        size, data = Image.core.grabscreen_x11(display_name)
+    except OSError:
+        if display_name is None and sys.platform not in ("darwin", "win32"):
+            if shutil.which("gnome-screenshot"):
+                args = ["gnome-screenshot", "-f"]
+            elif shutil.which("grim"):
+                args = ["grim"]
+            elif shutil.which("spectacle"):
+                args = ["spectacle", "-n", "-b", "-f", "-o"]
+            else:
+                raise
+            fh, filepath = tempfile.mkstemp(".png")
+            os.close(fh)
+            subprocess.call(args + [filepath])
+            im = Image.open(filepath)
+            im.load()
+            os.unlink(filepath)
+            if bbox:
+                im_cropped = im.crop(bbox)
+                im.close()
+                return im_cropped
+            return im
+        else:
+            raise
+    else:
+        im = Image.frombytes("RGB", size, data, "raw", "BGRX", size[0] * 4, 1)
+        if bbox:
+            im = im.crop(bbox)
+        return im
+
+
+def grabclipboard() -> Image.Image | list[str] | None:
+    if sys.platform == "darwin":
+        p = subprocess.run(
+            ["osascript", "-e", "get the clipboard as «class PNGf»"],
+            capture_output=True,
+        )
+        if p.returncode != 0:
+            return None
+
+        import binascii
+
+        data = io.BytesIO(binascii.unhexlify(p.stdout[11:-3]))
+        return Image.open(data)
+    elif sys.platform == "win32":
+        fmt, data = Image.core.grabclipboard_win32()
+        if fmt == "file":  # CF_HDROP
+            import struct
+
+            o = struct.unpack_from("I", data)[0]
+            if data[16] == 0:
+                files = data[o:].decode("mbcs").split("\0")
+            else:
+                files = data[o:].decode("utf-16le").split("\0")
+            return files[: files.index("")]
+        if isinstance(data, bytes):
+            data = io.BytesIO(data)
+            if fmt == "png":
+                from . import PngImagePlugin
+
+                return PngImagePlugin.PngImageFile(data)
+            elif fmt == "DIB":
+                from . import BmpImagePlugin
+
+                return BmpImagePlugin.DibImageFile(data)
+        return None
+    else:
+        if os.getenv("WAYLAND_DISPLAY"):
+            session_type = "wayland"
+        elif os.getenv("DISPLAY"):
+            session_type = "x11"
+        else:  # Session type check failed
+            session_type = None
+
+        if shutil.which("wl-paste") and session_type in ("wayland", None):
+            args = ["wl-paste", "-t", "image"]
+        elif shutil.which("xclip") and session_type in ("x11", None):
+            args = ["xclip", "-selection", "clipboard", "-t", "image/png", "-o"]
+        else:
+            msg = "wl-paste or xclip is required for ImageGrab.grabclipboard() on Linux"
+            raise NotImplementedError(msg)
+
+        p = subprocess.run(args, capture_output=True)
+        if p.returncode != 0:
+            err = p.stderr
+            for silent_error in [
+                # wl-paste, when the clipboard is empty
+                b"Nothing is copied",
+                # Ubuntu/Debian wl-paste, when the clipboard is empty
+                b"No selection",
+                # Ubuntu/Debian wl-paste, when an image isn't available
+                b"No suitable type of content copied",
+                # wl-paste or Ubuntu/Debian xclip, when an image isn't available
+                b" not available",
+                # xclip, when an image isn't available
+                b"cannot convert ",
+                # xclip, when the clipboard isn't initialized
+                b"xclip: Error: There is no owner for the ",
+            ]:
+                if silent_error in err:
+                    return None
+            msg = f"{args[0]} error"
+            if err:
+                msg += f": {err.strip().decode()}"
+            raise ChildProcessError(msg)
+
+        data = io.BytesIO(p.stdout)
+        im = Image.open(data)
+        im.load()
+        return im

.venv/lib/python3.12/site-packages/PIL/ImageMath.py

@@ -0,0 +1,314 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# a simple math add-on for the Python Imaging Library
+#
+# History:
+# 1999-02-15 fl   Original PIL Plus release
+# 2005-05-05 fl   Simplified and cleaned up for PIL 1.1.6
+# 2005-09-12 fl   Fixed int() and float() for Python 2.4.1
+#
+# Copyright (c) 1999-2005 by Secret Labs AB
+# Copyright (c) 2005 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import builtins
+
+from . import Image, _imagingmath
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from types import CodeType
+    from typing import Any
+
+
+class _Operand:
+    """Wraps an image operand, providing standard operators"""
+
+    def __init__(self, im: Image.Image):
+        self.im = im
+
+    def __fixup(self, im1: _Operand | float) -> Image.Image:
+        # convert image to suitable mode
+        if isinstance(im1, _Operand):
+            # argument was an image.
+            if im1.im.mode in ("1", "L"):
+                return im1.im.convert("I")
+            elif im1.im.mode in ("I", "F"):
+                return im1.im
+            else:
+                msg = f"unsupported mode: {im1.im.mode}"
+                raise ValueError(msg)
+        else:
+            # argument was a constant
+            if isinstance(im1, (int, float)) and self.im.mode in ("1", "L", "I"):
+                return Image.new("I", self.im.size, im1)
+            else:
+                return Image.new("F", self.im.size, im1)
+
+    def apply(
+        self,
+        op: str,
+        im1: _Operand | float,
+        im2: _Operand | float | None = None,
+        mode: str | None = None,
+    ) -> _Operand:
+        im_1 = self.__fixup(im1)
+        if im2 is None:
+            # unary operation
+            out = Image.new(mode or im_1.mode, im_1.size, None)
+            try:
+                op = getattr(_imagingmath, f"{op}_{im_1.mode}")
+            except AttributeError as e:
+                msg = f"bad operand type for '{op}'"
+                raise TypeError(msg) from e
+            _imagingmath.unop(op, out.getim(), im_1.getim())
+        else:
+            # binary operation
+            im_2 = self.__fixup(im2)
+            if im_1.mode != im_2.mode:
+                # convert both arguments to floating point
+                if im_1.mode != "F":
+                    im_1 = im_1.convert("F")
+                if im_2.mode != "F":
+                    im_2 = im_2.convert("F")
+            if im_1.size != im_2.size:
+                # crop both arguments to a common size
+                size = (
+                    min(im_1.size[0], im_2.size[0]),
+                    min(im_1.size[1], im_2.size[1]),
+                )
+                if im_1.size != size:
+                    im_1 = im_1.crop((0, 0) + size)
+                if im_2.size != size:
+                    im_2 = im_2.crop((0, 0) + size)
+            out = Image.new(mode or im_1.mode, im_1.size, None)
+            try:
+                op = getattr(_imagingmath, f"{op}_{im_1.mode}")
+            except AttributeError as e:
+                msg = f"bad operand type for '{op}'"
+                raise TypeError(msg) from e
+            _imagingmath.binop(op, out.getim(), im_1.getim(), im_2.getim())
+        return _Operand(out)
+
+    # unary operators
+    def __bool__(self) -> bool:
+        # an image is "true" if it contains at least one non-zero pixel
+        return self.im.getbbox() is not None
+
+    def __abs__(self) -> _Operand:
+        return self.apply("abs", self)
+
+    def __pos__(self) -> _Operand:
+        return self
+
+    def __neg__(self) -> _Operand:
+        return self.apply("neg", self)
+
+    # binary operators
+    def __add__(self, other: _Operand | float) -> _Operand:
+        return self.apply("add", self, other)
+
+    def __radd__(self, other: _Operand | float) -> _Operand:
+        return self.apply("add", other, self)
+
+    def __sub__(self, other: _Operand | float) -> _Operand:
+        return self.apply("sub", self, other)
+
+    def __rsub__(self, other: _Operand | float) -> _Operand:
+        return self.apply("sub", other, self)
+
+    def __mul__(self, other: _Operand | float) -> _Operand:
+        return self.apply("mul", self, other)
+
+    def __rmul__(self, other: _Operand | float) -> _Operand:
+        return self.apply("mul", other, self)
+
+    def __truediv__(self, other: _Operand | float) -> _Operand:
+        return self.apply("div", self, other)
+
+    def __rtruediv__(self, other: _Operand | float) -> _Operand:
+        return self.apply("div", other, self)
+
+    def __mod__(self, other: _Operand | float) -> _Operand:
+        return self.apply("mod", self, other)
+
+    def __rmod__(self, other: _Operand | float) -> _Operand:
+        return self.apply("mod", other, self)
+
+    def __pow__(self, other: _Operand | float) -> _Operand:
+        return self.apply("pow", self, other)
+
+    def __rpow__(self, other: _Operand | float) -> _Operand:
+        return self.apply("pow", other, self)
+
+    # bitwise
+    def __invert__(self) -> _Operand:
+        return self.apply("invert", self)
+
+    def __and__(self, other: _Operand | float) -> _Operand:
+        return self.apply("and", self, other)
+
+    def __rand__(self, other: _Operand | float) -> _Operand:
+        return self.apply("and", other, self)
+
+    def __or__(self, other: _Operand | float) -> _Operand:
+        return self.apply("or", self, other)
+
+    def __ror__(self, other: _Operand | float) -> _Operand:
+        return self.apply("or", other, self)
+
+    def __xor__(self, other: _Operand | float) -> _Operand:
+        return self.apply("xor", self, other)
+
+    def __rxor__(self, other: _Operand | float) -> _Operand:
+        return self.apply("xor", other, self)
+
+    def __lshift__(self, other: _Operand | float) -> _Operand:
+        return self.apply("lshift", self, other)
+
+    def __rshift__(self, other: _Operand | float) -> _Operand:
+        return self.apply("rshift", self, other)
+
+    # logical
+    def __eq__(self, other: _Operand | float) -> _Operand:  # type: ignore[override]
+        return self.apply("eq", self, other)
+
+    def __ne__(self, other: _Operand | float) -> _Operand:  # type: ignore[override]
+        return self.apply("ne", self, other)
+
+    def __lt__(self, other: _Operand | float) -> _Operand:
+        return self.apply("lt", self, other)
+
+    def __le__(self, other: _Operand | float) -> _Operand:
+        return self.apply("le", self, other)
+
+    def __gt__(self, other: _Operand | float) -> _Operand:
+        return self.apply("gt", self, other)
+
+    def __ge__(self, other: _Operand | float) -> _Operand:
+        return self.apply("ge", self, other)
+
+
+# conversions
+def imagemath_int(self: _Operand) -> _Operand:
+    return _Operand(self.im.convert("I"))
+
+
+def imagemath_float(self: _Operand) -> _Operand:
+    return _Operand(self.im.convert("F"))
+
+
+# logical
+def imagemath_equal(self: _Operand, other: _Operand | float | None) -> _Operand:
+    return self.apply("eq", self, other, mode="I")
+
+
+def imagemath_notequal(self: _Operand, other: _Operand | float | None) -> _Operand:
+    return self.apply("ne", self, other, mode="I")
+
+
+def imagemath_min(self: _Operand, other: _Operand | float | None) -> _Operand:
+    return self.apply("min", self, other)
+
+
+def imagemath_max(self: _Operand, other: _Operand | float | None) -> _Operand:
+    return self.apply("max", self, other)
+
+
+def imagemath_convert(self: _Operand, mode: str) -> _Operand:
+    return _Operand(self.im.convert(mode))
+
+
+ops = {
+    "int": imagemath_int,
+    "float": imagemath_float,
+    "equal": imagemath_equal,
+    "notequal": imagemath_notequal,
+    "min": imagemath_min,
+    "max": imagemath_max,
+    "convert": imagemath_convert,
+}
+
+
+def lambda_eval(expression: Callable[[dict[str, Any]], Any], **kw: Any) -> Any:
+    """
+    Returns the result of an image function.
+
+    :py:mod:`~PIL.ImageMath` only supports single-layer images. To process multi-band
+    images, use the :py:meth:`~PIL.Image.Image.split` method or
+    :py:func:`~PIL.Image.merge` function.
+
+    :param expression: A function that receives a dictionary.
+    :param **kw: Values to add to the function's dictionary.
+    :return: The expression result. This is usually an image object, but can
+             also be an integer, a floating point value, or a pixel tuple,
+             depending on the expression.
+    """
+
+    args: dict[str, Any] = ops.copy()
+    args.update(kw)
+    for k, v in args.items():
+        if isinstance(v, Image.Image):
+            args[k] = _Operand(v)
+
+    out = expression(args)
+    try:
+        return out.im
+    except AttributeError:
+        return out
+
+
+def unsafe_eval(expression: str, **kw: Any) -> Any:
+    """
+    Evaluates an image expression. This uses Python's ``eval()`` function to process
+    the expression string, and carries the security risks of doing so. It is not
+    recommended to process expressions without considering this.
+    :py:meth:`~lambda_eval` is a more secure alternative.
+
+    :py:mod:`~PIL.ImageMath` only supports single-layer images. To process multi-band
+    images, use the :py:meth:`~PIL.Image.Image.split` method or
+    :py:func:`~PIL.Image.merge` function.
+
+    :param expression: A string containing a Python-style expression.
+    :param **kw: Values to add to the evaluation context.
+    :return: The evaluated expression. This is usually an image object, but can
+             also be an integer, a floating point value, or a pixel tuple,
+             depending on the expression.
+    """
+
+    # build execution namespace
+    args: dict[str, Any] = ops.copy()
+    for k in kw:
+        if "__" in k or hasattr(builtins, k):
+            msg = f"'{k}' not allowed"
+            raise ValueError(msg)
+
+    args.update(kw)
+    for k, v in args.items():
+        if isinstance(v, Image.Image):
+            args[k] = _Operand(v)
+
+    compiled_code = compile(expression, "<string>", "eval")
+
+    def scan(code: CodeType) -> None:
+        for const in code.co_consts:
+            if type(const) is type(compiled_code):
+                scan(const)
+
+        for name in code.co_names:
+            if name not in args and name != "abs":
+                msg = f"'{name}' not allowed"
+                raise ValueError(msg)
+
+    scan(compiled_code)
+    out = builtins.eval(expression, {"__builtins": {"abs": abs}}, args)
+    try:
+        return out.im
+    except AttributeError:
+        return out

.venv/lib/python3.12/site-packages/PIL/ImagePalette.py

@@ -0,0 +1,286 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# image palette object
+#
+# History:
+# 1996-03-11 fl   Rewritten.
+# 1997-01-03 fl   Up and running.
+# 1997-08-23 fl   Added load hack
+# 2001-04-16 fl   Fixed randint shadow bug in random()
+#
+# Copyright (c) 1997-2001 by Secret Labs AB
+# Copyright (c) 1996-1997 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import array
+from collections.abc import Sequence
+from typing import IO
+
+from . import GimpGradientFile, GimpPaletteFile, ImageColor, PaletteFile
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from . import Image
+
+
+class ImagePalette:
+    """
+    Color palette for palette mapped images
+
+    :param mode: The mode to use for the palette. See:
+        :ref:`concept-modes`. Defaults to "RGB"
+    :param palette: An optional palette. If given, it must be a bytearray,
+        an array or a list of ints between 0-255. The list must consist of
+        all channels for one color followed by the next color (e.g. RGBRGBRGB).
+        Defaults to an empty palette.
+    """
+
+    def __init__(
+        self,
+        mode: str = "RGB",
+        palette: Sequence[int] | bytes | bytearray | None = None,
+    ) -> None:
+        self.mode = mode
+        self.rawmode: str | None = None  # if set, palette contains raw data
+        self.palette = palette or bytearray()
+        self.dirty: int | None = None
+
+    @property
+    def palette(self) -> Sequence[int] | bytes | bytearray:
+        return self._palette
+
+    @palette.setter
+    def palette(self, palette: Sequence[int] | bytes | bytearray) -> None:
+        self._colors: dict[tuple[int, ...], int] | None = None
+        self._palette = palette
+
+    @property
+    def colors(self) -> dict[tuple[int, ...], int]:
+        if self._colors is None:
+            mode_len = len(self.mode)
+            self._colors = {}
+            for i in range(0, len(self.palette), mode_len):
+                color = tuple(self.palette[i : i + mode_len])
+                if color in self._colors:
+                    continue
+                self._colors[color] = i // mode_len
+        return self._colors
+
+    @colors.setter
+    def colors(self, colors: dict[tuple[int, ...], int]) -> None:
+        self._colors = colors
+
+    def copy(self) -> ImagePalette:
+        new = ImagePalette()
+
+        new.mode = self.mode
+        new.rawmode = self.rawmode
+        if self.palette is not None:
+            new.palette = self.palette[:]
+        new.dirty = self.dirty
+
+        return new
+
+    def getdata(self) -> tuple[str, Sequence[int] | bytes | bytearray]:
+        """
+        Get palette contents in format suitable for the low-level
+        ``im.putpalette`` primitive.
+
+        .. warning:: This method is experimental.
+        """
+        if self.rawmode:
+            return self.rawmode, self.palette
+        return self.mode, self.tobytes()
+
+    def tobytes(self) -> bytes:
+        """Convert palette to bytes.
+
+        .. warning:: This method is experimental.
+        """
+        if self.rawmode:
+            msg = "palette contains raw palette data"
+            raise ValueError(msg)
+        if isinstance(self.palette, bytes):
+            return self.palette
+        arr = array.array("B", self.palette)
+        return arr.tobytes()
+
+    # Declare tostring as an alias for tobytes
+    tostring = tobytes
+
+    def _new_color_index(
+        self, image: Image.Image | None = None, e: Exception | None = None
+    ) -> int:
+        if not isinstance(self.palette, bytearray):
+            self._palette = bytearray(self.palette)
+        index = len(self.palette) // 3
+        special_colors: tuple[int | tuple[int, ...] | None, ...] = ()
+        if image:
+            special_colors = (
+                image.info.get("background"),
+                image.info.get("transparency"),
+            )
+            while index in special_colors:
+                index += 1
+        if index >= 256:
+            if image:
+                # Search for an unused index
+                for i, count in reversed(list(enumerate(image.histogram()))):
+                    if count == 0 and i not in special_colors:
+                        index = i
+                        break
+            if index >= 256:
+                msg = "cannot allocate more than 256 colors"
+                raise ValueError(msg) from e
+        return index
+
+    def getcolor(
+        self,
+        color: tuple[int, ...],
+        image: Image.Image | None = None,
+    ) -> int:
+        """Given an rgb tuple, allocate palette entry.
+
+        .. warning:: This method is experimental.
+        """
+        if self.rawmode:
+            msg = "palette contains raw palette data"
+            raise ValueError(msg)
+        if isinstance(color, tuple):
+            if self.mode == "RGB":
+                if len(color) == 4:
+                    if color[3] != 255:
+                        msg = "cannot add non-opaque RGBA color to RGB palette"
+                        raise ValueError(msg)
+                    color = color[:3]
+            elif self.mode == "RGBA":
+                if len(color) == 3:
+                    color += (255,)
+            try:
+                return self.colors[color]
+            except KeyError as e:
+                # allocate new color slot
+                index = self._new_color_index(image, e)
+                assert isinstance(self._palette, bytearray)
+                self.colors[color] = index
+                if index * 3 < len(self.palette):
+                    self._palette = (
+                        self._palette[: index * 3]
+                        + bytes(color)
+                        + self._palette[index * 3 + 3 :]
+                    )
+                else:
+                    self._palette += bytes(color)
+                self.dirty = 1
+                return index
+        else:
+            msg = f"unknown color specifier: {repr(color)}"  # type: ignore[unreachable]
+            raise ValueError(msg)
+
+    def save(self, fp: str | IO[str]) -> None:
+        """Save palette to text file.
+
+        .. warning:: This method is experimental.
+        """
+        if self.rawmode:
+            msg = "palette contains raw palette data"
+            raise ValueError(msg)
+        if isinstance(fp, str):
+            fp = open(fp, "w")
+        fp.write("# Palette\n")
+        fp.write(f"# Mode: {self.mode}\n")
+        for i in range(256):
+            fp.write(f"{i}")
+            for j in range(i * len(self.mode), (i + 1) * len(self.mode)):
+                try:
+                    fp.write(f" {self.palette[j]}")
+                except IndexError:
+                    fp.write(" 0")
+            fp.write("\n")
+        fp.close()
+
+
+# --------------------------------------------------------------------
+# Internal
+
+
+def raw(rawmode: str, data: Sequence[int] | bytes | bytearray) -> ImagePalette:
+    palette = ImagePalette()
+    palette.rawmode = rawmode
+    palette.palette = data
+    palette.dirty = 1
+    return palette
+
+
+# --------------------------------------------------------------------
+# Factories
+
+
+def make_linear_lut(black: int, white: float) -> list[int]:
+    if black == 0:
+        return [int(white * i // 255) for i in range(256)]
+
+    msg = "unavailable when black is non-zero"
+    raise NotImplementedError(msg)  # FIXME
+
+
+def make_gamma_lut(exp: float) -> list[int]:
+    return [int(((i / 255.0) ** exp) * 255.0 + 0.5) for i in range(256)]
+
+
+def negative(mode: str = "RGB") -> ImagePalette:
+    palette = list(range(256 * len(mode)))
+    palette.reverse()
+    return ImagePalette(mode, [i // len(mode) for i in palette])
+
+
+def random(mode: str = "RGB") -> ImagePalette:
+    from random import randint
+
+    palette = [randint(0, 255) for _ in range(256 * len(mode))]
+    return ImagePalette(mode, palette)
+
+
+def sepia(white: str = "#fff0c0") -> ImagePalette:
+    bands = [make_linear_lut(0, band) for band in ImageColor.getrgb(white)]
+    return ImagePalette("RGB", [bands[i % 3][i // 3] for i in range(256 * 3)])
+
+
+def wedge(mode: str = "RGB") -> ImagePalette:
+    palette = list(range(256 * len(mode)))
+    return ImagePalette(mode, [i // len(mode) for i in palette])
+
+
+def load(filename: str) -> tuple[bytes, str]:
+    # FIXME: supports GIMP gradients only
+
+    with open(filename, "rb") as fp:
+        paletteHandlers: list[
+            type[
+                GimpPaletteFile.GimpPaletteFile
+                | GimpGradientFile.GimpGradientFile
+                | PaletteFile.PaletteFile
+            ]
+        ] = [
+            GimpPaletteFile.GimpPaletteFile,
+            GimpGradientFile.GimpGradientFile,
+            PaletteFile.PaletteFile,
+        ]
+        for paletteHandler in paletteHandlers:
+            try:
+                fp.seek(0)
+                lut = paletteHandler(fp).getpalette()
+                if lut:
+                    break
+            except (SyntaxError, ValueError):
+                pass
+        else:
+            msg = "cannot load palette"
+            raise OSError(msg)
+
+    return lut  # data, rawmode

.venv/lib/python3.12/site-packages/PIL/ImagePath.py

@@ -0,0 +1,20 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# path interface
+#
+# History:
+# 1996-11-04 fl   Created
+# 2002-04-14 fl   Added documentation stub class
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1996.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+from . import Image
+
+Path = Image.core.path

.venv/lib/python3.12/site-packages/PIL/ImageText.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+
+from . import ImageFont
+from ._typing import _Ink
+
+
+class Text:
+    def __init__(
+        self,
+        text: str | bytes,
+        font: (
+            ImageFont.ImageFont
+            | ImageFont.FreeTypeFont
+            | ImageFont.TransposedFont
+            | None
+        ) = None,
+        mode: str = "RGB",
+        spacing: float = 4,
+        direction: str | None = None,
+        features: list[str] | None = None,
+        language: str | None = None,
+    ) -> None:
+        """
+        :param text: String to be drawn.
+        :param font: Either an :py:class:`~PIL.ImageFont.ImageFont` instance,
+                     :py:class:`~PIL.ImageFont.FreeTypeFont` instance,
+                     :py:class:`~PIL.ImageFont.TransposedFont` instance or ``None``. If
+                     ``None``, the default font from :py:meth:`.ImageFont.load_default`
+                     will be used.
+        :param mode: The image mode this will be used with.
+        :param spacing: The number of pixels between lines.
+        :param direction: Direction of the text. It can be ``"rtl"`` (right to left),
+                          ``"ltr"`` (left to right) or ``"ttb"`` (top to bottom).
+                          Requires libraqm.
+        :param features: A list of OpenType font features to be used during text
+                         layout. This is usually used to turn on optional font features
+                         that are not enabled by default, for example ``"dlig"`` or
+                         ``"ss01"``, but can be also used to turn off default font
+                         features, for example ``"-liga"`` to disable ligatures or
+                         ``"-kern"`` to disable kerning.  To get all supported
+                         features, see `OpenType docs`_.
+                         Requires libraqm.
+        :param language: Language of the text. Different languages may use
+                         different glyph shapes or ligatures. This parameter tells
+                         the font which language the text is in, and to apply the
+                         correct substitutions as appropriate, if available.
+                         It should be a `BCP 47 language code`_.
+                         Requires libraqm.
+        """
+        self.text = text
+        self.font = font or ImageFont.load_default()
+
+        self.mode = mode
+        self.spacing = spacing
+        self.direction = direction
+        self.features = features
+        self.language = language
+
+        self.embedded_color = False
+
+        self.stroke_width: float = 0
+        self.stroke_fill: _Ink | None = None
+
+    def embed_color(self) -> None:
+        """
+        Use embedded color glyphs (COLR, CBDT, SBIX).
+        """
+        if self.mode not in ("RGB", "RGBA"):
+            msg = "Embedded color supported only in RGB and RGBA modes"
+            raise ValueError(msg)
+        self.embedded_color = True
+
+    def stroke(self, width: float = 0, fill: _Ink | None = None) -> None:
+        """
+        :param width: The width of the text stroke.
+        :param fill: Color to use for the text stroke when drawing. If not given, will
+                     default to the ``fill`` parameter from
+                     :py:meth:`.ImageDraw.ImageDraw.text`.
+        """
+        self.stroke_width = width
+        self.stroke_fill = fill
+
+    def _get_fontmode(self) -> str:
+        if self.mode in ("1", "P", "I", "F"):
+            return "1"
+        elif self.embedded_color:
+            return "RGBA"
+        else:
+            return "L"
+
+    def get_length(self):
+        """
+        Returns length (in pixels with 1/64 precision) of text.
+
+        This is the amount by which following text should be offset.
+        Text bounding box may extend past the length in some fonts,
+        e.g. when using italics or accents.
+
+        The result is returned as a float; it is a whole number if using basic layout.
+
+        Note that the sum of two lengths may not equal the length of a concatenated
+        string due to kerning. If you need to adjust for kerning, include the following
+        character and subtract its length.
+
+        For example, instead of::
+
+            hello = ImageText.Text("Hello", font).get_length()
+            world = ImageText.Text("World", font).get_length()
+            helloworld = ImageText.Text("HelloWorld", font).get_length()
+            assert hello + world == helloworld
+
+        use::
+
+            hello = (
+                ImageText.Text("HelloW", font).get_length() -
+                ImageText.Text("W", font).get_length()
+            )  # adjusted for kerning
+            world = ImageText.Text("World", font).get_length()
+            helloworld = ImageText.Text("HelloWorld", font).get_length()
+            assert hello + world == helloworld
+
+        or disable kerning with (requires libraqm)::
+
+            hello = ImageText.Text("Hello", font, features=["-kern"]).get_length()
+            world = ImageText.Text("World", font, features=["-kern"]).get_length()
+            helloworld = ImageText.Text(
+                "HelloWorld", font, features=["-kern"]
+            ).get_length()
+            assert hello + world == helloworld
+
+        :return: Either width for horizontal text, or height for vertical text.
+        """
+        split_character = "\n" if isinstance(self.text, str) else b"\n"
+        if split_character in self.text:
+            msg = "can't measure length of multiline text"
+            raise ValueError(msg)
+        return self.font.getlength(
+            self.text,
+            self._get_fontmode(),
+            self.direction,
+            self.features,
+            self.language,
+        )
+
+    def _split(
+        self, xy: tuple[float, float], anchor: str | None, align: str
+    ) -> list[tuple[tuple[float, float], str, str | bytes]]:
+        if anchor is None:
+            anchor = "lt" if self.direction == "ttb" else "la"
+        elif len(anchor) != 2:
+            msg = "anchor must be a 2 character string"
+            raise ValueError(msg)
+
+        lines = (
+            self.text.split("\n")
+            if isinstance(self.text, str)
+            else self.text.split(b"\n")
+        )
+        if len(lines) == 1:
+            return [(xy, anchor, self.text)]
+
+        if anchor[1] in "tb" and self.direction != "ttb":
+            msg = "anchor not supported for multiline text"
+            raise ValueError(msg)
+
+        fontmode = self._get_fontmode()
+        line_spacing = (
+            self.font.getbbox(
+                "A",
+                fontmode,
+                None,
+                self.features,
+                self.language,
+                self.stroke_width,
+            )[3]
+            + self.stroke_width
+            + self.spacing
+        )
+
+        top = xy[1]
+        parts = []
+        if self.direction == "ttb":
+            left = xy[0]
+            for line in lines:
+                parts.append(((left, top), anchor, line))
+                left += line_spacing
+        else:
+            widths = []
+            max_width: float = 0
+            for line in lines:
+                line_width = self.font.getlength(
+                    line, fontmode, self.direction, self.features, self.language
+                )
+                widths.append(line_width)
+                max_width = max(max_width, line_width)
+
+            if anchor[1] == "m":
+                top -= (len(lines) - 1) * line_spacing / 2.0
+            elif anchor[1] == "d":
+                top -= (len(lines) - 1) * line_spacing
+
+            idx = -1
+            for line in lines:
+                left = xy[0]
+                idx += 1
+                width_difference = max_width - widths[idx]
+
+                # align by align parameter
+                if align in ("left", "justify"):
+                    pass
+                elif align == "center":
+                    left += width_difference / 2.0
+                elif align == "right":
+                    left += width_difference
+                else:
+                    msg = 'align must be "left", "center", "right" or "justify"'
+                    raise ValueError(msg)
+
+                if (
+                    align == "justify"
+                    and width_difference != 0
+                    and idx != len(lines) - 1
+                ):
+                    words = (
+                        line.split(" ") if isinstance(line, str) else line.split(b" ")
+                    )
+                    if len(words) > 1:
+                        # align left by anchor
+                        if anchor[0] == "m":
+                            left -= max_width / 2.0
+                        elif anchor[0] == "r":
+                            left -= max_width
+
+                        word_widths = [
+                            self.font.getlength(
+                                word,
+                                fontmode,
+                                self.direction,
+                                self.features,
+                                self.language,
+                            )
+                            for word in words
+                        ]
+                        word_anchor = "l" + anchor[1]
+                        width_difference = max_width - sum(word_widths)
+                        i = 0
+                        for word in words:
+                            parts.append(((left, top), word_anchor, word))
+                            left += word_widths[i] + width_difference / (len(words) - 1)
+                            i += 1
+                        top += line_spacing
+                        continue
+
+                # align left by anchor
+                if anchor[0] == "m":
+                    left -= width_difference / 2.0
+                elif anchor[0] == "r":
+                    left -= width_difference
+                parts.append(((left, top), anchor, line))
+                top += line_spacing
+
+        return parts
+
+    def get_bbox(
+        self,
+        xy: tuple[float, float] = (0, 0),
+        anchor: str | None = None,
+        align: str = "left",
+    ) -> tuple[float, float, float, float]:
+        """
+        Returns bounding box (in pixels) of text.
+
+        Use :py:meth:`get_length` to get the offset of following text with 1/64 pixel
+        precision. The bounding box includes extra margins for some fonts, e.g. italics
+        or accents.
+
+        :param xy: The anchor coordinates of the text.
+        :param anchor: The text anchor alignment. Determines the relative location of
+                       the anchor to the text. The default alignment is top left,
+                       specifically ``la`` for horizontal text and ``lt`` for
+                       vertical text. See :ref:`text-anchors` for details.
+        :param align: For multiline text, ``"left"``, ``"center"``, ``"right"`` or
+                      ``"justify"`` determines the relative alignment of lines. Use the
+                      ``anchor`` parameter to specify the alignment to ``xy``.
+
+        :return: ``(left, top, right, bottom)`` bounding box
+        """
+        bbox: tuple[float, float, float, float] | None = None
+        fontmode = self._get_fontmode()
+        for xy, anchor, line in self._split(xy, anchor, align):
+            bbox_line = self.font.getbbox(
+                line,
+                fontmode,
+                self.direction,
+                self.features,
+                self.language,
+                self.stroke_width,
+                anchor,
+            )
+            bbox_line = (
+                bbox_line[0] + xy[0],
+                bbox_line[1] + xy[1],
+                bbox_line[2] + xy[0],
+                bbox_line[3] + xy[1],
+            )
+            if bbox is None:
+                bbox = bbox_line
+            else:
+                bbox = (
+                    min(bbox[0], bbox_line[0]),
+                    min(bbox[1], bbox_line[1]),
+                    max(bbox[2], bbox_line[2]),
+                    max(bbox[3], bbox_line[3]),
+                )
+
+        if bbox is None:
+            return xy[0], xy[1], xy[0], xy[1]
+        return bbox

.venv/lib/python3.12/site-packages/PIL/ImageTk.py

@@ -0,0 +1,266 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# a Tk display interface
+#
+# History:
+# 96-04-08 fl   Created
+# 96-09-06 fl   Added getimage method
+# 96-11-01 fl   Rewritten, removed image attribute and crop method
+# 97-05-09 fl   Use PyImagingPaste method instead of image type
+# 97-05-12 fl   Minor tweaks to match the IFUNC95 interface
+# 97-05-17 fl   Support the "pilbitmap" booster patch
+# 97-06-05 fl   Added file= and data= argument to image constructors
+# 98-03-09 fl   Added width and height methods to Image classes
+# 98-07-02 fl   Use default mode for "P" images without palette attribute
+# 98-07-02 fl   Explicitly destroy Tkinter image objects
+# 99-07-24 fl   Support multiple Tk interpreters (from Greg Couch)
+# 99-07-26 fl   Automatically hook into Tkinter (if possible)
+# 99-08-15 fl   Hook uses _imagingtk instead of _imaging
+#
+# Copyright (c) 1997-1999 by Secret Labs AB
+# Copyright (c) 1996-1997 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import tkinter
+from io import BytesIO
+from typing import Any
+
+from . import Image, ImageFile
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from ._typing import CapsuleType
+
+# --------------------------------------------------------------------
+# Check for Tkinter interface hooks
+
+
+def _get_image_from_kw(kw: dict[str, Any]) -> ImageFile.ImageFile | None:
+    source = None
+    if "file" in kw:
+        source = kw.pop("file")
+    elif "data" in kw:
+        source = BytesIO(kw.pop("data"))
+    if not source:
+        return None
+    return Image.open(source)
+
+
+def _pyimagingtkcall(
+    command: str, photo: PhotoImage | tkinter.PhotoImage, ptr: CapsuleType
+) -> None:
+    tk = photo.tk
+    try:
+        tk.call(command, photo, repr(ptr))
+    except tkinter.TclError:
+        # activate Tkinter hook
+        # may raise an error if it cannot attach to Tkinter
+        from . import _imagingtk
+
+        _imagingtk.tkinit(tk.interpaddr())
+        tk.call(command, photo, repr(ptr))
+
+
+# --------------------------------------------------------------------
+# PhotoImage
+
+
+class PhotoImage:
+    """
+    A Tkinter-compatible photo image.  This can be used
+    everywhere Tkinter expects an image object.  If the image is an RGBA
+    image, pixels having alpha 0 are treated as transparent.
+
+    The constructor takes either a PIL image, or a mode and a size.
+    Alternatively, you can use the ``file`` or ``data`` options to initialize
+    the photo image object.
+
+    :param image: Either a PIL image, or a mode string.  If a mode string is
+                  used, a size must also be given.
+    :param size: If the first argument is a mode string, this defines the size
+                 of the image.
+    :keyword file: A filename to load the image from (using
+                   ``Image.open(file)``).
+    :keyword data: An 8-bit string containing image data (as loaded from an
+                   image file).
+    """
+
+    def __init__(
+        self,
+        image: Image.Image | str | None = None,
+        size: tuple[int, int] | None = None,
+        **kw: Any,
+    ) -> None:
+        # Tk compatibility: file or data
+        if image is None:
+            image = _get_image_from_kw(kw)
+
+        if image is None:
+            msg = "Image is required"
+            raise ValueError(msg)
+        elif isinstance(image, str):
+            mode = image
+            image = None
+
+            if size is None:
+                msg = "If first argument is mode, size is required"
+                raise ValueError(msg)
+        else:
+            # got an image instead of a mode
+            mode = image.mode
+            if mode == "P":
+                # palette mapped data
+                image.apply_transparency()
+                image.load()
+                mode = image.palette.mode if image.palette else "RGB"
+            size = image.size
+            kw["width"], kw["height"] = size
+
+        if mode not in ["1", "L", "RGB", "RGBA"]:
+            mode = Image.getmodebase(mode)
+
+        self.__mode = mode
+        self.__size = size
+        self.__photo = tkinter.PhotoImage(**kw)
+        self.tk = self.__photo.tk
+        if image:
+            self.paste(image)
+
+    def __del__(self) -> None:
+        try:
+            name = self.__photo.name
+        except AttributeError:
+            return
+        self.__photo.name = None
+        try:
+            self.__photo.tk.call("image", "delete", name)
+        except Exception:
+            pass  # ignore internal errors
+
+    def __str__(self) -> str:
+        """
+        Get the Tkinter photo image identifier.  This method is automatically
+        called by Tkinter whenever a PhotoImage object is passed to a Tkinter
+        method.
+
+        :return: A Tkinter photo image identifier (a string).
+        """
+        return str(self.__photo)
+
+    def width(self) -> int:
+        """
+        Get the width of the image.
+
+        :return: The width, in pixels.
+        """
+        return self.__size[0]
+
+    def height(self) -> int:
+        """
+        Get the height of the image.
+
+        :return: The height, in pixels.
+        """
+        return self.__size[1]
+
+    def paste(self, im: Image.Image) -> None:
+        """
+        Paste a PIL image into the photo image.  Note that this can
+        be very slow if the photo image is displayed.
+
+        :param im: A PIL image. The size must match the target region.  If the
+                   mode does not match, the image is converted to the mode of
+                   the bitmap image.
+        """
+        # convert to blittable
+        ptr = im.getim()
+        image = im.im
+        if not image.isblock() or im.mode != self.__mode:
+            block = Image.core.new_block(self.__mode, im.size)
+            image.convert2(block, image)  # convert directly between buffers
+            ptr = block.ptr
+
+        _pyimagingtkcall("PyImagingPhoto", self.__photo, ptr)
+
+
+# --------------------------------------------------------------------
+# BitmapImage
+
+
+class BitmapImage:
+    """
+    A Tkinter-compatible bitmap image.  This can be used everywhere Tkinter
+    expects an image object.
+
+    The given image must have mode "1".  Pixels having value 0 are treated as
+    transparent.  Options, if any, are passed on to Tkinter.  The most commonly
+    used option is ``foreground``, which is used to specify the color for the
+    non-transparent parts.  See the Tkinter documentation for information on
+    how to specify colours.
+
+    :param image: A PIL image.
+    """
+
+    def __init__(self, image: Image.Image | None = None, **kw: Any) -> None:
+        # Tk compatibility: file or data
+        if image is None:
+            image = _get_image_from_kw(kw)
+
+        if image is None:
+            msg = "Image is required"
+            raise ValueError(msg)
+        self.__mode = image.mode
+        self.__size = image.size
+
+        self.__photo = tkinter.BitmapImage(data=image.tobitmap(), **kw)
+
+    def __del__(self) -> None:
+        try:
+            name = self.__photo.name
+        except AttributeError:
+            return
+        self.__photo.name = None
+        try:
+            self.__photo.tk.call("image", "delete", name)
+        except Exception:
+            pass  # ignore internal errors
+
+    def width(self) -> int:
+        """
+        Get the width of the image.
+
+        :return: The width, in pixels.
+        """
+        return self.__size[0]
+
+    def height(self) -> int:
+        """
+        Get the height of the image.
+
+        :return: The height, in pixels.
+        """
+        return self.__size[1]
+
+    def __str__(self) -> str:
+        """
+        Get the Tkinter bitmap image identifier.  This method is automatically
+        called by Tkinter whenever a BitmapImage object is passed to a Tkinter
+        method.
+
+        :return: A Tkinter bitmap image identifier (a string).
+        """
+        return str(self.__photo)
+
+
+def getimage(photo: PhotoImage) -> Image.Image:
+    """Copies the contents of a PhotoImage to a PIL image memory."""
+    im = Image.new("RGBA", (photo.width(), photo.height()))
+
+    _pyimagingtkcall("PyImagingPhotoGet", photo, im.getim())
+
+    return im

.venv/lib/python3.12/site-packages/PIL/JpegImagePlugin.py

@@ -0,0 +1,888 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# JPEG (JFIF) file handling
+#
+# See "Digital Compression and Coding of Continuous-Tone Still Images,
+# Part 1, Requirements and Guidelines" (CCITT T.81 / ISO 10918-1)
+#
+# History:
+# 1995-09-09 fl   Created
+# 1995-09-13 fl   Added full parser
+# 1996-03-25 fl   Added hack to use the IJG command line utilities
+# 1996-05-05 fl   Workaround Photoshop 2.5 CMYK polarity bug
+# 1996-05-28 fl   Added draft support, JFIF version (0.1)
+# 1996-12-30 fl   Added encoder options, added progression property (0.2)
+# 1997-08-27 fl   Save mode 1 images as BW (0.3)
+# 1998-07-12 fl   Added YCbCr to draft and save methods (0.4)
+# 1998-10-19 fl   Don't hang on files using 16-bit DQT's (0.4.1)
+# 2001-04-16 fl   Extract DPI settings from JFIF files (0.4.2)
+# 2002-07-01 fl   Skip pad bytes before markers; identify Exif files (0.4.3)
+# 2003-04-25 fl   Added experimental EXIF decoder (0.5)
+# 2003-06-06 fl   Added experimental EXIF GPSinfo decoder
+# 2003-09-13 fl   Extract COM markers
+# 2009-09-06 fl   Added icc_profile support (from Florian Hoech)
+# 2009-03-06 fl   Changed CMYK handling; always use Adobe polarity (0.6)
+# 2009-03-08 fl   Added subsampling support (from Justin Huff).
+#
+# Copyright (c) 1997-2003 by Secret Labs AB.
+# Copyright (c) 1995-1996 by Fredrik Lundh.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import array
+import io
+import math
+import os
+import struct
+import subprocess
+import sys
+import tempfile
+import warnings
+
+from . import Image, ImageFile
+from ._binary import i16be as i16
+from ._binary import i32be as i32
+from ._binary import o8
+from ._binary import o16be as o16
+from .JpegPresets import presets
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import IO, Any
+
+    from .MpoImagePlugin import MpoImageFile
+
+#
+# Parser
+
+
+def Skip(self: JpegImageFile, marker: int) -> None:
+    n = i16(self.fp.read(2)) - 2
+    ImageFile._safe_read(self.fp, n)
+
+
+def APP(self: JpegImageFile, marker: int) -> None:
+    #
+    # Application marker.  Store these in the APP dictionary.
+    # Also look for well-known application markers.
+
+    n = i16(self.fp.read(2)) - 2
+    s = ImageFile._safe_read(self.fp, n)
+
+    app = f"APP{marker & 15}"
+
+    self.app[app] = s  # compatibility
+    self.applist.append((app, s))
+
+    if marker == 0xFFE0 and s.startswith(b"JFIF"):
+        # extract JFIF information
+        self.info["jfif"] = version = i16(s, 5)  # version
+        self.info["jfif_version"] = divmod(version, 256)
+        # extract JFIF properties
+        try:
+            jfif_unit = s[7]
+            jfif_density = i16(s, 8), i16(s, 10)
+        except Exception:
+            pass
+        else:
+            if jfif_unit == 1:
+                self.info["dpi"] = jfif_density
+            elif jfif_unit == 2:  # cm
+                # 1 dpcm = 2.54 dpi
+                self.info["dpi"] = tuple(d * 2.54 for d in jfif_density)
+            self.info["jfif_unit"] = jfif_unit
+            self.info["jfif_density"] = jfif_density
+    elif marker == 0xFFE1 and s.startswith(b"Exif\0\0"):
+        # extract EXIF information
+        if "exif" in self.info:
+            self.info["exif"] += s[6:]
+        else:
+            self.info["exif"] = s
+            self._exif_offset = self.fp.tell() - n + 6
+    elif marker == 0xFFE1 and s.startswith(b"http://ns.adobe.com/xap/1.0/\x00"):
+        self.info["xmp"] = s.split(b"\x00", 1)[1]
+    elif marker == 0xFFE2 and s.startswith(b"FPXR\0"):
+        # extract FlashPix information (incomplete)
+        self.info["flashpix"] = s  # FIXME: value will change
+    elif marker == 0xFFE2 and s.startswith(b"ICC_PROFILE\0"):
+        # Since an ICC profile can be larger than the maximum size of
+        # a JPEG marker (64K), we need provisions to split it into
+        # multiple markers. The format defined by the ICC specifies
+        # one or more APP2 markers containing the following data:
+        #   Identifying string      ASCII "ICC_PROFILE\0"  (12 bytes)
+        #   Marker sequence number  1, 2, etc (1 byte)
+        #   Number of markers       Total of APP2's used (1 byte)
+        #   Profile data            (remainder of APP2 data)
+        # Decoders should use the marker sequence numbers to
+        # reassemble the profile, rather than assuming that the APP2
+        # markers appear in the correct sequence.
+        self.icclist.append(s)
+    elif marker == 0xFFED and s.startswith(b"Photoshop 3.0\x00"):
+        # parse the image resource block
+        offset = 14
+        photoshop = self.info.setdefault("photoshop", {})
+        while s[offset : offset + 4] == b"8BIM":
+            try:
+                offset += 4
+                # resource code
+                code = i16(s, offset)
+                offset += 2
+                # resource name (usually empty)
+                name_len = s[offset]
+                # name = s[offset+1:offset+1+name_len]
+                offset += 1 + name_len
+                offset += offset & 1  # align
+                # resource data block
+                size = i32(s, offset)
+                offset += 4
+                data = s[offset : offset + size]
+                if code == 0x03ED:  # ResolutionInfo
+                    photoshop[code] = {
+                        "XResolution": i32(data, 0) / 65536,
+                        "DisplayedUnitsX": i16(data, 4),
+                        "YResolution": i32(data, 8) / 65536,
+                        "DisplayedUnitsY": i16(data, 12),
+                    }
+                else:
+                    photoshop[code] = data
+                offset += size
+                offset += offset & 1  # align
+            except struct.error:
+                break  # insufficient data
+
+    elif marker == 0xFFEE and s.startswith(b"Adobe"):
+        self.info["adobe"] = i16(s, 5)
+        # extract Adobe custom properties
+        try:
+            adobe_transform = s[11]
+        except IndexError:
+            pass
+        else:
+            self.info["adobe_transform"] = adobe_transform
+    elif marker == 0xFFE2 and s.startswith(b"MPF\0"):
+        # extract MPO information
+        self.info["mp"] = s[4:]
+        # offset is current location minus buffer size
+        # plus constant header size
+        self.info["mpoffset"] = self.fp.tell() - n + 4
+
+
+def COM(self: JpegImageFile, marker: int) -> None:
+    #
+    # Comment marker.  Store these in the APP dictionary.
+    n = i16(self.fp.read(2)) - 2
+    s = ImageFile._safe_read(self.fp, n)
+
+    self.info["comment"] = s
+    self.app["COM"] = s  # compatibility
+    self.applist.append(("COM", s))
+
+
+def SOF(self: JpegImageFile, marker: int) -> None:
+    #
+    # Start of frame marker.  Defines the size and mode of the
+    # image.  JPEG is colour blind, so we use some simple
+    # heuristics to map the number of layers to an appropriate
+    # mode.  Note that this could be made a bit brighter, by
+    # looking for JFIF and Adobe APP markers.
+
+    n = i16(self.fp.read(2)) - 2
+    s = ImageFile._safe_read(self.fp, n)
+    self._size = i16(s, 3), i16(s, 1)
+    if self._im is not None and self.size != self.im.size:
+        self._im = None
+
+    self.bits = s[0]
+    if self.bits != 8:
+        msg = f"cannot handle {self.bits}-bit layers"
+        raise SyntaxError(msg)
+
+    self.layers = s[5]
+    if self.layers == 1:
+        self._mode = "L"
+    elif self.layers == 3:
+        self._mode = "RGB"
+    elif self.layers == 4:
+        self._mode = "CMYK"
+    else:
+        msg = f"cannot handle {self.layers}-layer images"
+        raise SyntaxError(msg)
+
+    if marker in [0xFFC2, 0xFFC6, 0xFFCA, 0xFFCE]:
+        self.info["progressive"] = self.info["progression"] = 1
+
+    if self.icclist:
+        # fixup icc profile
+        self.icclist.sort()  # sort by sequence number
+        if self.icclist[0][13] == len(self.icclist):
+            profile = [p[14:] for p in self.icclist]
+            icc_profile = b"".join(profile)
+        else:
+            icc_profile = None  # wrong number of fragments
+        self.info["icc_profile"] = icc_profile
+        self.icclist = []
+
+    for i in range(6, len(s), 3):
+        t = s[i : i + 3]
+        # 4-tuples: id, vsamp, hsamp, qtable
+        self.layer.append((t[0], t[1] // 16, t[1] & 15, t[2]))
+
+
+def DQT(self: JpegImageFile, marker: int) -> None:
+    #
+    # Define quantization table.  Note that there might be more
+    # than one table in each marker.
+
+    # FIXME: The quantization tables can be used to estimate the
+    # compression quality.
+
+    n = i16(self.fp.read(2)) - 2
+    s = ImageFile._safe_read(self.fp, n)
+    while len(s):
+        v = s[0]
+        precision = 1 if (v // 16 == 0) else 2  # in bytes
+        qt_length = 1 + precision * 64
+        if len(s) < qt_length:
+            msg = "bad quantization table marker"
+            raise SyntaxError(msg)
+        data = array.array("B" if precision == 1 else "H", s[1:qt_length])
+        if sys.byteorder == "little" and precision > 1:
+            data.byteswap()  # the values are always big-endian
+        self.quantization[v & 15] = [data[i] for i in zigzag_index]
+        s = s[qt_length:]
+
+
+#
+# JPEG marker table
+
+MARKER = {
+    0xFFC0: ("SOF0", "Baseline DCT", SOF),
+    0xFFC1: ("SOF1", "Extended Sequential DCT", SOF),
+    0xFFC2: ("SOF2", "Progressive DCT", SOF),
+    0xFFC3: ("SOF3", "Spatial lossless", SOF),
+    0xFFC4: ("DHT", "Define Huffman table", Skip),
+    0xFFC5: ("SOF5", "Differential sequential DCT", SOF),
+    0xFFC6: ("SOF6", "Differential progressive DCT", SOF),
+    0xFFC7: ("SOF7", "Differential spatial", SOF),
+    0xFFC8: ("JPG", "Extension", None),
+    0xFFC9: ("SOF9", "Extended sequential DCT (AC)", SOF),
+    0xFFCA: ("SOF10", "Progressive DCT (AC)", SOF),
+    0xFFCB: ("SOF11", "Spatial lossless DCT (AC)", SOF),
+    0xFFCC: ("DAC", "Define arithmetic coding conditioning", Skip),
+    0xFFCD: ("SOF13", "Differential sequential DCT (AC)", SOF),
+    0xFFCE: ("SOF14", "Differential progressive DCT (AC)", SOF),
+    0xFFCF: ("SOF15", "Differential spatial (AC)", SOF),
+    0xFFD0: ("RST0", "Restart 0", None),
+    0xFFD1: ("RST1", "Restart 1", None),
+    0xFFD2: ("RST2", "Restart 2", None),
+    0xFFD3: ("RST3", "Restart 3", None),
+    0xFFD4: ("RST4", "Restart 4", None),
+    0xFFD5: ("RST5", "Restart 5", None),
+    0xFFD6: ("RST6", "Restart 6", None),
+    0xFFD7: ("RST7", "Restart 7", None),
+    0xFFD8: ("SOI", "Start of image", None),
+    0xFFD9: ("EOI", "End of image", None),
+    0xFFDA: ("SOS", "Start of scan", Skip),
+    0xFFDB: ("DQT", "Define quantization table", DQT),
+    0xFFDC: ("DNL", "Define number of lines", Skip),
+    0xFFDD: ("DRI", "Define restart interval", Skip),
+    0xFFDE: ("DHP", "Define hierarchical progression", SOF),
+    0xFFDF: ("EXP", "Expand reference component", Skip),
+    0xFFE0: ("APP0", "Application segment 0", APP),
+    0xFFE1: ("APP1", "Application segment 1", APP),
+    0xFFE2: ("APP2", "Application segment 2", APP),
+    0xFFE3: ("APP3", "Application segment 3", APP),
+    0xFFE4: ("APP4", "Application segment 4", APP),
+    0xFFE5: ("APP5", "Application segment 5", APP),
+    0xFFE6: ("APP6", "Application segment 6", APP),
+    0xFFE7: ("APP7", "Application segment 7", APP),
+    0xFFE8: ("APP8", "Application segment 8", APP),
+    0xFFE9: ("APP9", "Application segment 9", APP),
+    0xFFEA: ("APP10", "Application segment 10", APP),
+    0xFFEB: ("APP11", "Application segment 11", APP),
+    0xFFEC: ("APP12", "Application segment 12", APP),
+    0xFFED: ("APP13", "Application segment 13", APP),
+    0xFFEE: ("APP14", "Application segment 14", APP),
+    0xFFEF: ("APP15", "Application segment 15", APP),
+    0xFFF0: ("JPG0", "Extension 0", None),
+    0xFFF1: ("JPG1", "Extension 1", None),
+    0xFFF2: ("JPG2", "Extension 2", None),
+    0xFFF3: ("JPG3", "Extension 3", None),
+    0xFFF4: ("JPG4", "Extension 4", None),
+    0xFFF5: ("JPG5", "Extension 5", None),
+    0xFFF6: ("JPG6", "Extension 6", None),
+    0xFFF7: ("JPG7", "Extension 7", None),
+    0xFFF8: ("JPG8", "Extension 8", None),
+    0xFFF9: ("JPG9", "Extension 9", None),
+    0xFFFA: ("JPG10", "Extension 10", None),
+    0xFFFB: ("JPG11", "Extension 11", None),
+    0xFFFC: ("JPG12", "Extension 12", None),
+    0xFFFD: ("JPG13", "Extension 13", None),
+    0xFFFE: ("COM", "Comment", COM),
+}
+
+
+def _accept(prefix: bytes) -> bool:
+    # Magic number was taken from https://en.wikipedia.org/wiki/JPEG
+    return prefix.startswith(b"\xff\xd8\xff")
+
+
+##
+# Image plugin for JPEG and JFIF images.
+
+
+class JpegImageFile(ImageFile.ImageFile):
+    format = "JPEG"
+    format_description = "JPEG (ISO 10918)"
+
+    def _open(self) -> None:
+        s = self.fp.read(3)
+
+        if not _accept(s):
+            msg = "not a JPEG file"
+            raise SyntaxError(msg)
+        s = b"\xff"
+
+        # Create attributes
+        self.bits = self.layers = 0
+        self._exif_offset = 0
+
+        # JPEG specifics (internal)
+        self.layer: list[tuple[int, int, int, int]] = []
+        self._huffman_dc: dict[Any, Any] = {}
+        self._huffman_ac: dict[Any, Any] = {}
+        self.quantization: dict[int, list[int]] = {}
+        self.app: dict[str, bytes] = {}  # compatibility
+        self.applist: list[tuple[str, bytes]] = []
+        self.icclist: list[bytes] = []
+
+        while True:
+            i = s[0]
+            if i == 0xFF:
+                s = s + self.fp.read(1)
+                i = i16(s)
+            else:
+                # Skip non-0xFF junk
+                s = self.fp.read(1)
+                continue
+
+            if i in MARKER:
+                name, description, handler = MARKER[i]
+                if handler is not None:
+                    handler(self, i)
+                if i == 0xFFDA:  # start of scan
+                    rawmode = self.mode
+                    if self.mode == "CMYK":
+                        rawmode = "CMYK;I"  # assume adobe conventions
+                    self.tile = [
+                        ImageFile._Tile("jpeg", (0, 0) + self.size, 0, (rawmode, ""))
+                    ]
+                    # self.__offset = self.fp.tell()
+                    break
+                s = self.fp.read(1)
+            elif i in {0, 0xFFFF}:
+                # padded marker or junk; move on
+                s = b"\xff"
+            elif i == 0xFF00:  # Skip extraneous data (escaped 0xFF)
+                s = self.fp.read(1)
+            else:
+                msg = "no marker found"
+                raise SyntaxError(msg)
+
+        self._read_dpi_from_exif()
+
+    def __getstate__(self) -> list[Any]:
+        return super().__getstate__() + [self.layers, self.layer]
+
+    def __setstate__(self, state: list[Any]) -> None:
+        self.layers, self.layer = state[6:]
+        super().__setstate__(state)
+
+    def load_read(self, read_bytes: int) -> bytes:
+        """
+        internal: read more image data
+        For premature EOF and LOAD_TRUNCATED_IMAGES adds EOI marker
+        so libjpeg can finish decoding
+        """
+        s = self.fp.read(read_bytes)
+
+        if not s and ImageFile.LOAD_TRUNCATED_IMAGES and not hasattr(self, "_ended"):
+            # Premature EOF.
+            # Pretend file is finished adding EOI marker
+            self._ended = True
+            return b"\xff\xd9"
+
+        return s
+
+    def draft(
+        self, mode: str | None, size: tuple[int, int] | None
+    ) -> tuple[str, tuple[int, int, float, float]] | None:
+        if len(self.tile) != 1:
+            return None
+
+        # Protect from second call
+        if self.decoderconfig:
+            return None
+
+        d, e, o, a = self.tile[0]
+        scale = 1
+        original_size = self.size
+
+        assert isinstance(a, tuple)
+        if a[0] == "RGB" and mode in ["L", "YCbCr"]:
+            self._mode = mode
+            a = mode, ""
+
+        if size:
+            scale = min(self.size[0] // size[0], self.size[1] // size[1])
+            for s in [8, 4, 2, 1]:
+                if scale >= s:
+                    break
+            assert e is not None
+            e = (
+                e[0],
+                e[1],
+                (e[2] - e[0] + s - 1) // s + e[0],
+                (e[3] - e[1] + s - 1) // s + e[1],
+            )
+            self._size = ((self.size[0] + s - 1) // s, (self.size[1] + s - 1) // s)
+            scale = s
+
+        self.tile = [ImageFile._Tile(d, e, o, a)]
+        self.decoderconfig = (scale, 0)
+
+        box = (0, 0, original_size[0] / scale, original_size[1] / scale)
+        return self.mode, box
+
+    def load_djpeg(self) -> None:
+        # ALTERNATIVE: handle JPEGs via the IJG command line utilities
+
+        f, path = tempfile.mkstemp()
+        os.close(f)
+        if os.path.exists(self.filename):
+            subprocess.check_call(["djpeg", "-outfile", path, self.filename])
+        else:
+            try:
+                os.unlink(path)
+            except OSError:
+                pass
+
+            msg = "Invalid Filename"
+            raise ValueError(msg)
+
+        try:
+            with Image.open(path) as _im:
+                _im.load()
+                self.im = _im.im
+        finally:
+            try:
+                os.unlink(path)
+            except OSError:
+                pass
+
+        self._mode = self.im.mode
+        self._size = self.im.size
+
+        self.tile = []
+
+    def _getexif(self) -> dict[int, Any] | None:
+        return _getexif(self)
+
+    def _read_dpi_from_exif(self) -> None:
+        # If DPI isn't in JPEG header, fetch from EXIF
+        if "dpi" in self.info or "exif" not in self.info:
+            return
+        try:
+            exif = self.getexif()
+            resolution_unit = exif[0x0128]
+            x_resolution = exif[0x011A]
+            try:
+                dpi = float(x_resolution[0]) / x_resolution[1]
+            except TypeError:
+                dpi = x_resolution
+            if math.isnan(dpi):
+                msg = "DPI is not a number"
+                raise ValueError(msg)
+            if resolution_unit == 3:  # cm
+                # 1 dpcm = 2.54 dpi
+                dpi *= 2.54
+            self.info["dpi"] = dpi, dpi
+        except (
+            struct.error,  # truncated EXIF
+            KeyError,  # dpi not included
+            SyntaxError,  # invalid/unreadable EXIF
+            TypeError,  # dpi is an invalid float
+            ValueError,  # dpi is an invalid float
+            ZeroDivisionError,  # invalid dpi rational value
+        ):
+            self.info["dpi"] = 72, 72
+
+    def _getmp(self) -> dict[int, Any] | None:
+        return _getmp(self)
+
+
+def _getexif(self: JpegImageFile) -> dict[int, Any] | None:
+    if "exif" not in self.info:
+        return None
+    return self.getexif()._get_merged_dict()
+
+
+def _getmp(self: JpegImageFile) -> dict[int, Any] | None:
+    # Extract MP information.  This method was inspired by the "highly
+    # experimental" _getexif version that's been in use for years now,
+    # itself based on the ImageFileDirectory class in the TIFF plugin.
+
+    # The MP record essentially consists of a TIFF file embedded in a JPEG
+    # application marker.
+    try:
+        data = self.info["mp"]
+    except KeyError:
+        return None
+    file_contents = io.BytesIO(data)
+    head = file_contents.read(8)
+    endianness = ">" if head.startswith(b"\x4d\x4d\x00\x2a") else "<"
+    # process dictionary
+    from . import TiffImagePlugin
+
+    try:
+        info = TiffImagePlugin.ImageFileDirectory_v2(head)
+        file_contents.seek(info.next)
+        info.load(file_contents)
+        mp = dict(info)
+    except Exception as e:
+        msg = "malformed MP Index (unreadable directory)"
+        raise SyntaxError(msg) from e
+    # it's an error not to have a number of images
+    try:
+        quant = mp[0xB001]
+    except KeyError as e:
+        msg = "malformed MP Index (no number of images)"
+        raise SyntaxError(msg) from e
+    # get MP entries
+    mpentries = []
+    try:
+        rawmpentries = mp[0xB002]
+        for entrynum in range(quant):
+            unpackedentry = struct.unpack_from(
+                f"{endianness}LLLHH", rawmpentries, entrynum * 16
+            )
+            labels = ("Attribute", "Size", "DataOffset", "EntryNo1", "EntryNo2")
+            mpentry = dict(zip(labels, unpackedentry))
+            mpentryattr = {
+                "DependentParentImageFlag": bool(mpentry["Attribute"] & (1 << 31)),
+                "DependentChildImageFlag": bool(mpentry["Attribute"] & (1 << 30)),
+                "RepresentativeImageFlag": bool(mpentry["Attribute"] & (1 << 29)),
+                "Reserved": (mpentry["Attribute"] & (3 << 27)) >> 27,
+                "ImageDataFormat": (mpentry["Attribute"] & (7 << 24)) >> 24,
+                "MPType": mpentry["Attribute"] & 0x00FFFFFF,
+            }
+            if mpentryattr["ImageDataFormat"] == 0:
+                mpentryattr["ImageDataFormat"] = "JPEG"
+            else:
+                msg = "unsupported picture format in MPO"
+                raise SyntaxError(msg)
+            mptypemap = {
+                0x000000: "Undefined",
+                0x010001: "Large Thumbnail (VGA Equivalent)",
+                0x010002: "Large Thumbnail (Full HD Equivalent)",
+                0x020001: "Multi-Frame Image (Panorama)",
+                0x020002: "Multi-Frame Image: (Disparity)",
+                0x020003: "Multi-Frame Image: (Multi-Angle)",
+                0x030000: "Baseline MP Primary Image",
+            }
+            mpentryattr["MPType"] = mptypemap.get(mpentryattr["MPType"], "Unknown")
+            mpentry["Attribute"] = mpentryattr
+            mpentries.append(mpentry)
+        mp[0xB002] = mpentries
+    except KeyError as e:
+        msg = "malformed MP Index (bad MP Entry)"
+        raise SyntaxError(msg) from e
+    # Next we should try and parse the individual image unique ID list;
+    # we don't because I've never seen this actually used in a real MPO
+    # file and so can't test it.
+    return mp
+
+
+# --------------------------------------------------------------------
+# stuff to save JPEG files
+
+RAWMODE = {
+    "1": "L",
+    "L": "L",
+    "RGB": "RGB",
+    "RGBX": "RGB",
+    "CMYK": "CMYK;I",  # assume adobe conventions
+    "YCbCr": "YCbCr",
+}
+
+# fmt: off
+zigzag_index = (
+    0,  1,  5,  6, 14, 15, 27, 28,
+    2,  4,  7, 13, 16, 26, 29, 42,
+    3,  8, 12, 17, 25, 30, 41, 43,
+    9, 11, 18, 24, 31, 40, 44, 53,
+    10, 19, 23, 32, 39, 45, 52, 54,
+    20, 22, 33, 38, 46, 51, 55, 60,
+    21, 34, 37, 47, 50, 56, 59, 61,
+    35, 36, 48, 49, 57, 58, 62, 63,
+)
+
+samplings = {
+    (1, 1, 1, 1, 1, 1): 0,
+    (2, 1, 1, 1, 1, 1): 1,
+    (2, 2, 1, 1, 1, 1): 2,
+}
+# fmt: on
+
+
+def get_sampling(im: Image.Image) -> int:
+    # There's no subsampling when images have only 1 layer
+    # (grayscale images) or when they are CMYK (4 layers),
+    # so set subsampling to the default value.
+    #
+    # NOTE: currently Pillow can't encode JPEG to YCCK format.
+    # If YCCK support is added in the future, subsampling code will have
+    # to be updated (here and in JpegEncode.c) to deal with 4 layers.
+    if not isinstance(im, JpegImageFile) or im.layers in (1, 4):
+        return -1
+    sampling = im.layer[0][1:3] + im.layer[1][1:3] + im.layer[2][1:3]
+    return samplings.get(sampling, -1)
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    if im.width == 0 or im.height == 0:
+        msg = "cannot write empty image as JPEG"
+        raise ValueError(msg)
+
+    try:
+        rawmode = RAWMODE[im.mode]
+    except KeyError as e:
+        msg = f"cannot write mode {im.mode} as JPEG"
+        raise OSError(msg) from e
+
+    info = im.encoderinfo
+
+    dpi = [round(x) for x in info.get("dpi", (0, 0))]
+
+    quality = info.get("quality", -1)
+    subsampling = info.get("subsampling", -1)
+    qtables = info.get("qtables")
+
+    if quality == "keep":
+        quality = -1
+        subsampling = "keep"
+        qtables = "keep"
+    elif quality in presets:
+        preset = presets[quality]
+        quality = -1
+        subsampling = preset.get("subsampling", -1)
+        qtables = preset.get("quantization")
+    elif not isinstance(quality, int):
+        msg = "Invalid quality setting"
+        raise ValueError(msg)
+    else:
+        if subsampling in presets:
+            subsampling = presets[subsampling].get("subsampling", -1)
+        if isinstance(qtables, str) and qtables in presets:
+            qtables = presets[qtables].get("quantization")
+
+    if subsampling == "4:4:4":
+        subsampling = 0
+    elif subsampling == "4:2:2":
+        subsampling = 1
+    elif subsampling == "4:2:0":
+        subsampling = 2
+    elif subsampling == "4:1:1":
+        # For compatibility. Before Pillow 4.3, 4:1:1 actually meant 4:2:0.
+        # Set 4:2:0 if someone is still using that value.
+        subsampling = 2
+    elif subsampling == "keep":
+        if im.format != "JPEG":
+            msg = "Cannot use 'keep' when original image is not a JPEG"
+            raise ValueError(msg)
+        subsampling = get_sampling(im)
+
+    def validate_qtables(
+        qtables: (
+            str | tuple[list[int], ...] | list[list[int]] | dict[int, list[int]] | None
+        ),
+    ) -> list[list[int]] | None:
+        if qtables is None:
+            return qtables
+        if isinstance(qtables, str):
+            try:
+                lines = [
+                    int(num)
+                    for line in qtables.splitlines()
+                    for num in line.split("#", 1)[0].split()
+                ]
+            except ValueError as e:
+                msg = "Invalid quantization table"
+                raise ValueError(msg) from e
+            else:
+                qtables = [lines[s : s + 64] for s in range(0, len(lines), 64)]
+        if isinstance(qtables, (tuple, list, dict)):
+            if isinstance(qtables, dict):
+                qtables = [
+                    qtables[key] for key in range(len(qtables)) if key in qtables
+                ]
+            elif isinstance(qtables, tuple):
+                qtables = list(qtables)
+            if not (0 < len(qtables) < 5):
+                msg = "None or too many quantization tables"
+                raise ValueError(msg)
+            for idx, table in enumerate(qtables):
+                try:
+                    if len(table) != 64:
+                        msg = "Invalid quantization table"
+                        raise TypeError(msg)
+                    table_array = array.array("H", table)
+                except TypeError as e:
+                    msg = "Invalid quantization table"
+                    raise ValueError(msg) from e
+                else:
+                    qtables[idx] = list(table_array)
+            return qtables
+
+    if qtables == "keep":
+        if im.format != "JPEG":
+            msg = "Cannot use 'keep' when original image is not a JPEG"
+            raise ValueError(msg)
+        qtables = getattr(im, "quantization", None)
+    qtables = validate_qtables(qtables)
+
+    extra = info.get("extra", b"")
+
+    MAX_BYTES_IN_MARKER = 65533
+    if xmp := info.get("xmp"):
+        overhead_len = 29  # b"http://ns.adobe.com/xap/1.0/\x00"
+        max_data_bytes_in_marker = MAX_BYTES_IN_MARKER - overhead_len
+        if len(xmp) > max_data_bytes_in_marker:
+            msg = "XMP data is too long"
+            raise ValueError(msg)
+        size = o16(2 + overhead_len + len(xmp))
+        extra += b"\xff\xe1" + size + b"http://ns.adobe.com/xap/1.0/\x00" + xmp
+
+    if icc_profile := info.get("icc_profile"):
+        overhead_len = 14  # b"ICC_PROFILE\0" + o8(i) + o8(len(markers))
+        max_data_bytes_in_marker = MAX_BYTES_IN_MARKER - overhead_len
+        markers = []
+        while icc_profile:
+            markers.append(icc_profile[:max_data_bytes_in_marker])
+            icc_profile = icc_profile[max_data_bytes_in_marker:]
+        i = 1
+        for marker in markers:
+            size = o16(2 + overhead_len + len(marker))
+            extra += (
+                b"\xff\xe2"
+                + size
+                + b"ICC_PROFILE\0"
+                + o8(i)
+                + o8(len(markers))
+                + marker
+            )
+            i += 1
+
+    comment = info.get("comment", im.info.get("comment"))
+
+    # "progressive" is the official name, but older documentation
+    # says "progression"
+    # FIXME: issue a warning if the wrong form is used (post-1.1.7)
+    progressive = info.get("progressive", False) or info.get("progression", False)
+
+    optimize = info.get("optimize", False)
+
+    exif = info.get("exif", b"")
+    if isinstance(exif, Image.Exif):
+        exif = exif.tobytes()
+    if len(exif) > MAX_BYTES_IN_MARKER:
+        msg = "EXIF data is too long"
+        raise ValueError(msg)
+
+    # get keyword arguments
+    im.encoderconfig = (
+        quality,
+        progressive,
+        info.get("smooth", 0),
+        optimize,
+        info.get("keep_rgb", False),
+        info.get("streamtype", 0),
+        dpi,
+        subsampling,
+        info.get("restart_marker_blocks", 0),
+        info.get("restart_marker_rows", 0),
+        qtables,
+        comment,
+        extra,
+        exif,
+    )
+
+    # if we optimize, libjpeg needs a buffer big enough to hold the whole image
+    # in a shot. Guessing on the size, at im.size bytes. (raw pixel size is
+    # channels*size, this is a value that's been used in a django patch.
+    # https://github.com/matthewwithanm/django-imagekit/issues/50
+    if optimize or progressive:
+        # CMYK can be bigger
+        if im.mode == "CMYK":
+            bufsize = 4 * im.size[0] * im.size[1]
+        # keep sets quality to -1, but the actual value may be high.
+        elif quality >= 95 or quality == -1:
+            bufsize = 2 * im.size[0] * im.size[1]
+        else:
+            bufsize = im.size[0] * im.size[1]
+        if exif:
+            bufsize += len(exif) + 5
+        if extra:
+            bufsize += len(extra) + 1
+    else:
+        # The EXIF info needs to be written as one block, + APP1, + one spare byte.
+        # Ensure that our buffer is big enough. Same with the icc_profile block.
+        bufsize = max(len(exif) + 5, len(extra) + 1)
+
+    ImageFile._save(
+        im, fp, [ImageFile._Tile("jpeg", (0, 0) + im.size, 0, rawmode)], bufsize
+    )
+
+
+##
+# Factory for making JPEG and MPO instances
+def jpeg_factory(
+    fp: IO[bytes], filename: str | bytes | None = None
+) -> JpegImageFile | MpoImageFile:
+    im = JpegImageFile(fp, filename)
+    try:
+        mpheader = im._getmp()
+        if mpheader is not None and mpheader[45057] > 1:
+            for segment, content in im.applist:
+                if segment == "APP1" and b' hdrgm:Version="' in content:
+                    # Ultra HDR images are not yet supported
+                    return im
+            # It's actually an MPO
+            from .MpoImagePlugin import MpoImageFile
+
+            # Don't reload everything, just convert it.
+            im = MpoImageFile.adopt(im, mpheader)
+    except (TypeError, IndexError):
+        # It is really a JPEG
+        pass
+    except SyntaxError:
+        warnings.warn(
+            "Image appears to be a malformed MPO file, it will be "
+            "interpreted as a base JPEG file"
+        )
+    return im
+
+
+# ---------------------------------------------------------------------
+# Registry stuff
+
+Image.register_open(JpegImageFile.format, jpeg_factory, _accept)
+Image.register_save(JpegImageFile.format, _save)
+
+Image.register_extensions(JpegImageFile.format, [".jfif", ".jpe", ".jpg", ".jpeg"])
+
+Image.register_mime(JpegImageFile.format, "image/jpeg")

.venv/lib/python3.12/site-packages/PIL/JpegPresets.py

@@ -0,0 +1,242 @@
+"""
+JPEG quality settings equivalent to the Photoshop settings.
+Can be used when saving JPEG files.
+
+The following presets are available by default:
+``web_low``, ``web_medium``, ``web_high``, ``web_very_high``, ``web_maximum``,
+``low``, ``medium``, ``high``, ``maximum``.
+More presets can be added to the :py:data:`presets` dict if needed.
+
+To apply the preset, specify::
+
+  quality="preset_name"
+
+To apply only the quantization table::
+
+  qtables="preset_name"
+
+To apply only the subsampling setting::
+
+  subsampling="preset_name"
+
+Example::
+
+  im.save("image_name.jpg", quality="web_high")
+
+Subsampling
+-----------
+
+Subsampling is the practice of encoding images by implementing less resolution
+for chroma information than for luma information.
+(ref.: https://en.wikipedia.org/wiki/Chroma_subsampling)
+
+Possible subsampling values are 0, 1 and 2 that correspond to 4:4:4, 4:2:2 and
+4:2:0.
+
+You can get the subsampling of a JPEG with the
+:func:`.JpegImagePlugin.get_sampling` function.
+
+In JPEG compressed data a JPEG marker is used instead of an EXIF tag.
+(ref.: https://exiv2.org/tags.html)
+
+
+Quantization tables
+-------------------
+
+They are values use by the DCT (Discrete cosine transform) to remove
+*unnecessary* information from the image (the lossy part of the compression).
+(ref.: https://en.wikipedia.org/wiki/Quantization_matrix#Quantization_matrices,
+https://en.wikipedia.org/wiki/JPEG#Quantization)
+
+You can get the quantization tables of a JPEG with::
+
+  im.quantization
+
+This will return a dict with a number of lists. You can pass this dict
+directly as the qtables argument when saving a JPEG.
+
+The quantization table format in presets is a list with sublists. These formats
+are interchangeable.
+
+Libjpeg ref.:
+https://web.archive.org/web/20120328125543/http://www.jpegcameras.com/libjpeg/libjpeg-3.html
+
+"""
+
+from __future__ import annotations
+
+# fmt: off
+presets = {
+            'web_low':      {'subsampling':  2,  # "4:2:0"
+                             'quantization': [
+                               [20, 16, 25, 39, 50, 46, 62, 68,
+                                16, 18, 23, 38, 38, 53, 65, 68,
+                                25, 23, 31, 38, 53, 65, 68, 68,
+                                39, 38, 38, 53, 65, 68, 68, 68,
+                                50, 38, 53, 65, 68, 68, 68, 68,
+                                46, 53, 65, 68, 68, 68, 68, 68,
+                                62, 65, 68, 68, 68, 68, 68, 68,
+                                68, 68, 68, 68, 68, 68, 68, 68],
+                               [21, 25, 32, 38, 54, 68, 68, 68,
+                                25, 28, 24, 38, 54, 68, 68, 68,
+                                32, 24, 32, 43, 66, 68, 68, 68,
+                                38, 38, 43, 53, 68, 68, 68, 68,
+                                54, 54, 66, 68, 68, 68, 68, 68,
+                                68, 68, 68, 68, 68, 68, 68, 68,
+                                68, 68, 68, 68, 68, 68, 68, 68,
+                                68, 68, 68, 68, 68, 68, 68, 68]
+                              ]},
+            'web_medium':   {'subsampling':  2,  # "4:2:0"
+                             'quantization': [
+                               [16, 11, 11, 16, 23, 27, 31, 30,
+                                11, 12, 12, 15, 20, 23, 23, 30,
+                                11, 12, 13, 16, 23, 26, 35, 47,
+                                16, 15, 16, 23, 26, 37, 47, 64,
+                                23, 20, 23, 26, 39, 51, 64, 64,
+                                27, 23, 26, 37, 51, 64, 64, 64,
+                                31, 23, 35, 47, 64, 64, 64, 64,
+                                30, 30, 47, 64, 64, 64, 64, 64],
+                               [17, 15, 17, 21, 20, 26, 38, 48,
+                                15, 19, 18, 17, 20, 26, 35, 43,
+                                17, 18, 20, 22, 26, 30, 46, 53,
+                                21, 17, 22, 28, 30, 39, 53, 64,
+                                20, 20, 26, 30, 39, 48, 64, 64,
+                                26, 26, 30, 39, 48, 63, 64, 64,
+                                38, 35, 46, 53, 64, 64, 64, 64,
+                                48, 43, 53, 64, 64, 64, 64, 64]
+                             ]},
+            'web_high':     {'subsampling':  0,  # "4:4:4"
+                             'quantization': [
+                               [6,   4,  4,  6,  9, 11, 12, 16,
+                                4,   5,  5,  6,  8, 10, 12, 12,
+                                4,   5,  5,  6, 10, 12, 14, 19,
+                                6,   6,  6, 11, 12, 15, 19, 28,
+                                9,   8, 10, 12, 16, 20, 27, 31,
+                                11, 10, 12, 15, 20, 27, 31, 31,
+                                12, 12, 14, 19, 27, 31, 31, 31,
+                                16, 12, 19, 28, 31, 31, 31, 31],
+                               [7,   7, 13, 24, 26, 31, 31, 31,
+                                7,  12, 16, 21, 31, 31, 31, 31,
+                                13, 16, 17, 31, 31, 31, 31, 31,
+                                24, 21, 31, 31, 31, 31, 31, 31,
+                                26, 31, 31, 31, 31, 31, 31, 31,
+                                31, 31, 31, 31, 31, 31, 31, 31,
+                                31, 31, 31, 31, 31, 31, 31, 31,
+                                31, 31, 31, 31, 31, 31, 31, 31]
+                             ]},
+            'web_very_high': {'subsampling':  0,  # "4:4:4"
+                              'quantization': [
+                               [2,   2,  2,  2,  3,  4,  5,  6,
+                                2,   2,  2,  2,  3,  4,  5,  6,
+                                2,   2,  2,  2,  4,  5,  7,  9,
+                                2,   2,  2,  4,  5,  7,  9, 12,
+                                3,   3,  4,  5,  8, 10, 12, 12,
+                                4,   4,  5,  7, 10, 12, 12, 12,
+                                5,   5,  7,  9, 12, 12, 12, 12,
+                                6,   6,  9, 12, 12, 12, 12, 12],
+                               [3,   3,  5,  9, 13, 15, 15, 15,
+                                3,   4,  6, 11, 14, 12, 12, 12,
+                                5,   6,  9, 14, 12, 12, 12, 12,
+                                9,  11, 14, 12, 12, 12, 12, 12,
+                                13, 14, 12, 12, 12, 12, 12, 12,
+                                15, 12, 12, 12, 12, 12, 12, 12,
+                                15, 12, 12, 12, 12, 12, 12, 12,
+                                15, 12, 12, 12, 12, 12, 12, 12]
+                              ]},
+            'web_maximum':  {'subsampling':  0,  # "4:4:4"
+                             'quantization': [
+                                [1,  1,  1,  1,  1,  1,  1,  1,
+                                 1,  1,  1,  1,  1,  1,  1,  1,
+                                 1,  1,  1,  1,  1,  1,  1,  2,
+                                 1,  1,  1,  1,  1,  1,  2,  2,
+                                 1,  1,  1,  1,  1,  2,  2,  3,
+                                 1,  1,  1,  1,  2,  2,  3,  3,
+                                 1,  1,  1,  2,  2,  3,  3,  3,
+                                 1,  1,  2,  2,  3,  3,  3,  3],
+                                [1,  1,  1,  2,  2,  3,  3,  3,
+                                 1,  1,  1,  2,  3,  3,  3,  3,
+                                 1,  1,  1,  3,  3,  3,  3,  3,
+                                 2,  2,  3,  3,  3,  3,  3,  3,
+                                 2,  3,  3,  3,  3,  3,  3,  3,
+                                 3,  3,  3,  3,  3,  3,  3,  3,
+                                 3,  3,  3,  3,  3,  3,  3,  3,
+                                 3,  3,  3,  3,  3,  3,  3,  3]
+                             ]},
+            'low':          {'subsampling':  2,  # "4:2:0"
+                             'quantization': [
+                               [18, 14, 14, 21, 30, 35, 34, 17,
+                                14, 16, 16, 19, 26, 23, 12, 12,
+                                14, 16, 17, 21, 23, 12, 12, 12,
+                                21, 19, 21, 23, 12, 12, 12, 12,
+                                30, 26, 23, 12, 12, 12, 12, 12,
+                                35, 23, 12, 12, 12, 12, 12, 12,
+                                34, 12, 12, 12, 12, 12, 12, 12,
+                                17, 12, 12, 12, 12, 12, 12, 12],
+                               [20, 19, 22, 27, 20, 20, 17, 17,
+                                19, 25, 23, 14, 14, 12, 12, 12,
+                                22, 23, 14, 14, 12, 12, 12, 12,
+                                27, 14, 14, 12, 12, 12, 12, 12,
+                                20, 14, 12, 12, 12, 12, 12, 12,
+                                20, 12, 12, 12, 12, 12, 12, 12,
+                                17, 12, 12, 12, 12, 12, 12, 12,
+                                17, 12, 12, 12, 12, 12, 12, 12]
+                             ]},
+            'medium':       {'subsampling':  2,  # "4:2:0"
+                             'quantization': [
+                               [12,  8,  8, 12, 17, 21, 24, 17,
+                                8,   9,  9, 11, 15, 19, 12, 12,
+                                8,   9, 10, 12, 19, 12, 12, 12,
+                                12, 11, 12, 21, 12, 12, 12, 12,
+                                17, 15, 19, 12, 12, 12, 12, 12,
+                                21, 19, 12, 12, 12, 12, 12, 12,
+                                24, 12, 12, 12, 12, 12, 12, 12,
+                                17, 12, 12, 12, 12, 12, 12, 12],
+                               [13, 11, 13, 16, 20, 20, 17, 17,
+                                11, 14, 14, 14, 14, 12, 12, 12,
+                                13, 14, 14, 14, 12, 12, 12, 12,
+                                16, 14, 14, 12, 12, 12, 12, 12,
+                                20, 14, 12, 12, 12, 12, 12, 12,
+                                20, 12, 12, 12, 12, 12, 12, 12,
+                                17, 12, 12, 12, 12, 12, 12, 12,
+                                17, 12, 12, 12, 12, 12, 12, 12]
+                             ]},
+            'high':         {'subsampling':  0,  # "4:4:4"
+                             'quantization': [
+                               [6,   4,  4,  6,  9, 11, 12, 16,
+                                4,   5,  5,  6,  8, 10, 12, 12,
+                                4,   5,  5,  6, 10, 12, 12, 12,
+                                6,   6,  6, 11, 12, 12, 12, 12,
+                                9,   8, 10, 12, 12, 12, 12, 12,
+                                11, 10, 12, 12, 12, 12, 12, 12,
+                                12, 12, 12, 12, 12, 12, 12, 12,
+                                16, 12, 12, 12, 12, 12, 12, 12],
+                               [7,   7, 13, 24, 20, 20, 17, 17,
+                                7,  12, 16, 14, 14, 12, 12, 12,
+                                13, 16, 14, 14, 12, 12, 12, 12,
+                                24, 14, 14, 12, 12, 12, 12, 12,
+                                20, 14, 12, 12, 12, 12, 12, 12,
+                                20, 12, 12, 12, 12, 12, 12, 12,
+                                17, 12, 12, 12, 12, 12, 12, 12,
+                                17, 12, 12, 12, 12, 12, 12, 12]
+                             ]},
+            'maximum':      {'subsampling':  0,  # "4:4:4"
+                             'quantization': [
+                               [2,   2,  2,  2,  3,  4,  5,  6,
+                                2,   2,  2,  2,  3,  4,  5,  6,
+                                2,   2,  2,  2,  4,  5,  7,  9,
+                                2,   2,  2,  4,  5,  7,  9, 12,
+                                3,   3,  4,  5,  8, 10, 12, 12,
+                                4,   4,  5,  7, 10, 12, 12, 12,
+                                5,   5,  7,  9, 12, 12, 12, 12,
+                                6,   6,  9, 12, 12, 12, 12, 12],
+                               [3,   3,  5,  9, 13, 15, 15, 15,
+                                3,   4,  6, 10, 14, 12, 12, 12,
+                                5,   6,  9, 14, 12, 12, 12, 12,
+                                9,  10, 14, 12, 12, 12, 12, 12,
+                                13, 14, 12, 12, 12, 12, 12, 12,
+                                15, 12, 12, 12, 12, 12, 12, 12,
+                                15, 12, 12, 12, 12, 12, 12, 12,
+                                15, 12, 12, 12, 12, 12, 12, 12]
+                             ]},
+}
+# fmt: on

.venv/lib/python3.12/site-packages/PIL/PngImagePlugin.py

@@ -0,0 +1,1553 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# PNG support code
+#
+# See "PNG (Portable Network Graphics) Specification, version 1.0;
+# W3C Recommendation", 1996-10-01, Thomas Boutell (ed.).
+#
+# history:
+# 1996-05-06 fl   Created (couldn't resist it)
+# 1996-12-14 fl   Upgraded, added read and verify support (0.2)
+# 1996-12-15 fl   Separate PNG stream parser
+# 1996-12-29 fl   Added write support, added getchunks
+# 1996-12-30 fl   Eliminated circular references in decoder (0.3)
+# 1998-07-12 fl   Read/write 16-bit images as mode I (0.4)
+# 2001-02-08 fl   Added transparency support (from Zircon) (0.5)
+# 2001-04-16 fl   Don't close data source in "open" method (0.6)
+# 2004-02-24 fl   Don't even pretend to support interlaced files (0.7)
+# 2004-08-31 fl   Do basic sanity check on chunk identifiers (0.8)
+# 2004-09-20 fl   Added PngInfo chunk container
+# 2004-12-18 fl   Added DPI read support (based on code by Niki Spahiev)
+# 2008-08-13 fl   Added tRNS support for RGB images
+# 2009-03-06 fl   Support for preserving ICC profiles (by Florian Hoech)
+# 2009-03-08 fl   Added zTXT support (from Lowell Alleman)
+# 2009-03-29 fl   Read interlaced PNG files (from Conrado Porto Lopes Gouvua)
+#
+# Copyright (c) 1997-2009 by Secret Labs AB
+# Copyright (c) 1996 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import itertools
+import logging
+import re
+import struct
+import warnings
+import zlib
+from enum import IntEnum
+from typing import IO, NamedTuple, cast
+
+from . import Image, ImageChops, ImageFile, ImagePalette, ImageSequence
+from ._binary import i16be as i16
+from ._binary import i32be as i32
+from ._binary import o8
+from ._binary import o16be as o16
+from ._binary import o32be as o32
+from ._deprecate import deprecate
+from ._util import DeferredError
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from typing import Any, NoReturn
+
+    from . import _imaging
+
+logger = logging.getLogger(__name__)
+
+is_cid = re.compile(rb"\w\w\w\w").match
+
+
+_MAGIC = b"\211PNG\r\n\032\n"
+
+
+_MODES = {
+    # supported bits/color combinations, and corresponding modes/rawmodes
+    # Grayscale
+    (1, 0): ("1", "1"),
+    (2, 0): ("L", "L;2"),
+    (4, 0): ("L", "L;4"),
+    (8, 0): ("L", "L"),
+    (16, 0): ("I;16", "I;16B"),
+    # Truecolour
+    (8, 2): ("RGB", "RGB"),
+    (16, 2): ("RGB", "RGB;16B"),
+    # Indexed-colour
+    (1, 3): ("P", "P;1"),
+    (2, 3): ("P", "P;2"),
+    (4, 3): ("P", "P;4"),
+    (8, 3): ("P", "P"),
+    # Grayscale with alpha
+    (8, 4): ("LA", "LA"),
+    (16, 4): ("RGBA", "LA;16B"),  # LA;16B->LA not yet available
+    # Truecolour with alpha
+    (8, 6): ("RGBA", "RGBA"),
+    (16, 6): ("RGBA", "RGBA;16B"),
+}
+
+
+_simple_palette = re.compile(b"^\xff*\x00\xff*$")
+
+MAX_TEXT_CHUNK = ImageFile.SAFEBLOCK
+"""
+Maximum decompressed size for a iTXt or zTXt chunk.
+Eliminates decompression bombs where compressed chunks can expand 1000x.
+See :ref:`Text in PNG File Format<png-text>`.
+"""
+MAX_TEXT_MEMORY = 64 * MAX_TEXT_CHUNK
+"""
+Set the maximum total text chunk size.
+See :ref:`Text in PNG File Format<png-text>`.
+"""
+
+
+# APNG frame disposal modes
+class Disposal(IntEnum):
+    OP_NONE = 0
+    """
+    No disposal is done on this frame before rendering the next frame.
+    See :ref:`Saving APNG sequences<apng-saving>`.
+    """
+    OP_BACKGROUND = 1
+    """
+    This frame’s modified region is cleared to fully transparent black before rendering
+    the next frame.
+    See :ref:`Saving APNG sequences<apng-saving>`.
+    """
+    OP_PREVIOUS = 2
+    """
+    This frame’s modified region is reverted to the previous frame’s contents before
+    rendering the next frame.
+    See :ref:`Saving APNG sequences<apng-saving>`.
+    """
+
+
+# APNG frame blend modes
+class Blend(IntEnum):
+    OP_SOURCE = 0
+    """
+    All color components of this frame, including alpha, overwrite the previous output
+    image contents.
+    See :ref:`Saving APNG sequences<apng-saving>`.
+    """
+    OP_OVER = 1
+    """
+    This frame should be alpha composited with the previous output image contents.
+    See :ref:`Saving APNG sequences<apng-saving>`.
+    """
+
+
+def _safe_zlib_decompress(s: bytes) -> bytes:
+    dobj = zlib.decompressobj()
+    plaintext = dobj.decompress(s, MAX_TEXT_CHUNK)
+    if dobj.unconsumed_tail:
+        msg = "Decompressed data too large for PngImagePlugin.MAX_TEXT_CHUNK"
+        raise ValueError(msg)
+    return plaintext
+
+
+def _crc32(data: bytes, seed: int = 0) -> int:
+    return zlib.crc32(data, seed) & 0xFFFFFFFF
+
+
+# --------------------------------------------------------------------
+# Support classes.  Suitable for PNG and related formats like MNG etc.
+
+
+class ChunkStream:
+    def __init__(self, fp: IO[bytes]) -> None:
+        self.fp: IO[bytes] | None = fp
+        self.queue: list[tuple[bytes, int, int]] | None = []
+
+    def read(self) -> tuple[bytes, int, int]:
+        """Fetch a new chunk. Returns header information."""
+        cid = None
+
+        assert self.fp is not None
+        if self.queue:
+            cid, pos, length = self.queue.pop()
+            self.fp.seek(pos)
+        else:
+            s = self.fp.read(8)
+            cid = s[4:]
+            pos = self.fp.tell()
+            length = i32(s)
+
+        if not is_cid(cid):
+            if not ImageFile.LOAD_TRUNCATED_IMAGES:
+                msg = f"broken PNG file (chunk {repr(cid)})"
+                raise SyntaxError(msg)
+
+        return cid, pos, length
+
+    def __enter__(self) -> ChunkStream:
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()
+
+    def close(self) -> None:
+        self.queue = self.fp = None
+
+    def push(self, cid: bytes, pos: int, length: int) -> None:
+        assert self.queue is not None
+        self.queue.append((cid, pos, length))
+
+    def call(self, cid: bytes, pos: int, length: int) -> bytes:
+        """Call the appropriate chunk handler"""
+
+        logger.debug("STREAM %r %s %s", cid, pos, length)
+        return getattr(self, f"chunk_{cid.decode('ascii')}")(pos, length)
+
+    def crc(self, cid: bytes, data: bytes) -> None:
+        """Read and verify checksum"""
+
+        # Skip CRC checks for ancillary chunks if allowed to load truncated
+        # images
+        # 5th byte of first char is 1 [specs, section 5.4]
+        if ImageFile.LOAD_TRUNCATED_IMAGES and (cid[0] >> 5 & 1):
+            self.crc_skip(cid, data)
+            return
+
+        assert self.fp is not None
+        try:
+            crc1 = _crc32(data, _crc32(cid))
+            crc2 = i32(self.fp.read(4))
+            if crc1 != crc2:
+                msg = f"broken PNG file (bad header checksum in {repr(cid)})"
+                raise SyntaxError(msg)
+        except struct.error as e:
+            msg = f"broken PNG file (incomplete checksum in {repr(cid)})"
+            raise SyntaxError(msg) from e
+
+    def crc_skip(self, cid: bytes, data: bytes) -> None:
+        """Read checksum"""
+
+        assert self.fp is not None
+        self.fp.read(4)
+
+    def verify(self, endchunk: bytes = b"IEND") -> list[bytes]:
+        # Simple approach; just calculate checksum for all remaining
+        # blocks.  Must be called directly after open.
+
+        cids = []
+
+        assert self.fp is not None
+        while True:
+            try:
+                cid, pos, length = self.read()
+            except struct.error as e:
+                msg = "truncated PNG file"
+                raise OSError(msg) from e
+
+            if cid == endchunk:
+                break
+            self.crc(cid, ImageFile._safe_read(self.fp, length))
+            cids.append(cid)
+
+        return cids
+
+
+class iTXt(str):
+    """
+    Subclass of string to allow iTXt chunks to look like strings while
+    keeping their extra information
+
+    """
+
+    lang: str | bytes | None
+    tkey: str | bytes | None
+
+    @staticmethod
+    def __new__(
+        cls, text: str, lang: str | None = None, tkey: str | None = None
+    ) -> iTXt:
+        """
+        :param cls: the class to use when creating the instance
+        :param text: value for this key
+        :param lang: language code
+        :param tkey: UTF-8 version of the key name
+        """
+
+        self = str.__new__(cls, text)
+        self.lang = lang
+        self.tkey = tkey
+        return self
+
+
+class PngInfo:
+    """
+    PNG chunk container (for use with save(pnginfo=))
+
+    """
+
+    def __init__(self) -> None:
+        self.chunks: list[tuple[bytes, bytes, bool]] = []
+
+    def add(self, cid: bytes, data: bytes, after_idat: bool = False) -> None:
+        """Appends an arbitrary chunk. Use with caution.
+
+        :param cid: a byte string, 4 bytes long.
+        :param data: a byte string of the encoded data
+        :param after_idat: for use with private chunks. Whether the chunk
+                           should be written after IDAT
+
+        """
+
+        self.chunks.append((cid, data, after_idat))
+
+    def add_itxt(
+        self,
+        key: str | bytes,
+        value: str | bytes,
+        lang: str | bytes = "",
+        tkey: str | bytes = "",
+        zip: bool = False,
+    ) -> None:
+        """Appends an iTXt chunk.
+
+        :param key: latin-1 encodable text key name
+        :param value: value for this key
+        :param lang: language code
+        :param tkey: UTF-8 version of the key name
+        :param zip: compression flag
+
+        """
+
+        if not isinstance(key, bytes):
+            key = key.encode("latin-1", "strict")
+        if not isinstance(value, bytes):
+            value = value.encode("utf-8", "strict")
+        if not isinstance(lang, bytes):
+            lang = lang.encode("utf-8", "strict")
+        if not isinstance(tkey, bytes):
+            tkey = tkey.encode("utf-8", "strict")
+
+        if zip:
+            self.add(
+                b"iTXt",
+                key + b"\0\x01\0" + lang + b"\0" + tkey + b"\0" + zlib.compress(value),
+            )
+        else:
+            self.add(b"iTXt", key + b"\0\0\0" + lang + b"\0" + tkey + b"\0" + value)
+
+    def add_text(
+        self, key: str | bytes, value: str | bytes | iTXt, zip: bool = False
+    ) -> None:
+        """Appends a text chunk.
+
+        :param key: latin-1 encodable text key name
+        :param value: value for this key, text or an
+           :py:class:`PIL.PngImagePlugin.iTXt` instance
+        :param zip: compression flag
+
+        """
+        if isinstance(value, iTXt):
+            return self.add_itxt(
+                key,
+                value,
+                value.lang if value.lang is not None else b"",
+                value.tkey if value.tkey is not None else b"",
+                zip=zip,
+            )
+
+        # The tEXt chunk stores latin-1 text
+        if not isinstance(value, bytes):
+            try:
+                value = value.encode("latin-1", "strict")
+            except UnicodeError:
+                return self.add_itxt(key, value, zip=zip)
+
+        if not isinstance(key, bytes):
+            key = key.encode("latin-1", "strict")
+
+        if zip:
+            self.add(b"zTXt", key + b"\0\0" + zlib.compress(value))
+        else:
+            self.add(b"tEXt", key + b"\0" + value)
+
+
+# --------------------------------------------------------------------
+# PNG image stream (IHDR/IEND)
+
+
+class _RewindState(NamedTuple):
+    info: dict[str | tuple[int, int], Any]
+    tile: list[ImageFile._Tile]
+    seq_num: int | None
+
+
+class PngStream(ChunkStream):
+    def __init__(self, fp: IO[bytes]) -> None:
+        super().__init__(fp)
+
+        # local copies of Image attributes
+        self.im_info: dict[str | tuple[int, int], Any] = {}
+        self.im_text: dict[str, str | iTXt] = {}
+        self.im_size = (0, 0)
+        self.im_mode = ""
+        self.im_tile: list[ImageFile._Tile] = []
+        self.im_palette: tuple[str, bytes] | None = None
+        self.im_custom_mimetype: str | None = None
+        self.im_n_frames: int | None = None
+        self._seq_num: int | None = None
+        self.rewind_state = _RewindState({}, [], None)
+
+        self.text_memory = 0
+
+    def check_text_memory(self, chunklen: int) -> None:
+        self.text_memory += chunklen
+        if self.text_memory > MAX_TEXT_MEMORY:
+            msg = (
+                "Too much memory used in text chunks: "
+                f"{self.text_memory}>MAX_TEXT_MEMORY"
+            )
+            raise ValueError(msg)
+
+    def save_rewind(self) -> None:
+        self.rewind_state = _RewindState(
+            self.im_info.copy(),
+            self.im_tile,
+            self._seq_num,
+        )
+
+    def rewind(self) -> None:
+        self.im_info = self.rewind_state.info.copy()
+        self.im_tile = self.rewind_state.tile
+        self._seq_num = self.rewind_state.seq_num
+
+    def chunk_iCCP(self, pos: int, length: int) -> bytes:
+        # ICC profile
+        assert self.fp is not None
+        s = ImageFile._safe_read(self.fp, length)
+        # according to PNG spec, the iCCP chunk contains:
+        # Profile name  1-79 bytes (character string)
+        # Null separator        1 byte (null character)
+        # Compression method    1 byte (0)
+        # Compressed profile    n bytes (zlib with deflate compression)
+        i = s.find(b"\0")
+        logger.debug("iCCP profile name %r", s[:i])
+        comp_method = s[i + 1]
+        logger.debug("Compression method %s", comp_method)
+        if comp_method != 0:
+            msg = f"Unknown compression method {comp_method} in iCCP chunk"
+            raise SyntaxError(msg)
+        try:
+            icc_profile = _safe_zlib_decompress(s[i + 2 :])
+        except ValueError:
+            if ImageFile.LOAD_TRUNCATED_IMAGES:
+                icc_profile = None
+            else:
+                raise
+        except zlib.error:
+            icc_profile = None  # FIXME
+        self.im_info["icc_profile"] = icc_profile
+        return s
+
+    def chunk_IHDR(self, pos: int, length: int) -> bytes:
+        # image header
+        assert self.fp is not None
+        s = ImageFile._safe_read(self.fp, length)
+        if length < 13:
+            if ImageFile.LOAD_TRUNCATED_IMAGES:
+                return s
+            msg = "Truncated IHDR chunk"
+            raise ValueError(msg)
+        self.im_size = i32(s, 0), i32(s, 4)
+        try:
+            self.im_mode, self.im_rawmode = _MODES[(s[8], s[9])]
+        except Exception:
+            pass
+        if s[12]:
+            self.im_info["interlace"] = 1
+        if s[11]:
+            msg = "unknown filter category"
+            raise SyntaxError(msg)
+        return s
+
+    def chunk_IDAT(self, pos: int, length: int) -> NoReturn:
+        # image data
+        if "bbox" in self.im_info:
+            tile = [ImageFile._Tile("zip", self.im_info["bbox"], pos, self.im_rawmode)]
+        else:
+            if self.im_n_frames is not None:
+                self.im_info["default_image"] = True
+            tile = [ImageFile._Tile("zip", (0, 0) + self.im_size, pos, self.im_rawmode)]
+        self.im_tile = tile
+        self.im_idat = length
+        msg = "image data found"
+        raise EOFError(msg)
+
+    def chunk_IEND(self, pos: int, length: int) -> NoReturn:
+        msg = "end of PNG image"
+        raise EOFError(msg)
+
+    def chunk_PLTE(self, pos: int, length: int) -> bytes:
+        # palette
+        assert self.fp is not None
+        s = ImageFile._safe_read(self.fp, length)
+        if self.im_mode == "P":
+            self.im_palette = "RGB", s
+        return s
+
+    def chunk_tRNS(self, pos: int, length: int) -> bytes:
+        # transparency
+        assert self.fp is not None
+        s = ImageFile._safe_read(self.fp, length)
+        if self.im_mode == "P":
+            if _simple_palette.match(s):
+                # tRNS contains only one full-transparent entry,
+                # other entries are full opaque
+                i = s.find(b"\0")
+                if i >= 0:
+                    self.im_info["transparency"] = i
+            else:
+                # otherwise, we have a byte string with one alpha value
+                # for each palette entry
+                self.im_info["transparency"] = s
+        elif self.im_mode in ("1", "L", "I;16"):
+            self.im_info["transparency"] = i16(s)
+        elif self.im_mode == "RGB":
+            self.im_info["transparency"] = i16(s), i16(s, 2), i16(s, 4)
+        return s
+
+    def chunk_gAMA(self, pos: int, length: int) -> bytes:
+        # gamma setting
+        assert self.fp is not None
+        s = ImageFile._safe_read(self.fp, length)
+        self.im_info["gamma"] = i32(s) / 100000.0
+        return s
+
+    def chunk_cHRM(self, pos: int, length: int) -> bytes:
+        # chromaticity, 8 unsigned ints, actual value is scaled by 100,000
+        # WP x,y, Red x,y, Green x,y Blue x,y
+
+        assert self.fp is not None
+        s = ImageFile._safe_read(self.fp, length)
+        raw_vals = struct.unpack(f">{len(s) // 4}I", s)
+        self.im_info["chromaticity"] = tuple(elt / 100000.0 for elt in raw_vals)
+        return s
+
+    def chunk_sRGB(self, pos: int, length: int) -> bytes:
+        # srgb rendering intent, 1 byte
+        # 0 perceptual
+        # 1 relative colorimetric
+        # 2 saturation
+        # 3 absolute colorimetric
+
+        assert self.fp is not None
+        s = ImageFile._safe_read(self.fp, length)
+        if length < 1:
+            if ImageFile.LOAD_TRUNCATED_IMAGES:
+                return s
+            msg = "Truncated sRGB chunk"
+            raise ValueError(msg)
+        self.im_info["srgb"] = s[0]
+        return s
+
+    def chunk_pHYs(self, pos: int, length: int) -> bytes:
+        # pixels per unit
+        assert self.fp is not None
+        s = ImageFile._safe_read(self.fp, length)
+        if length < 9:
+            if ImageFile.LOAD_TRUNCATED_IMAGES:
+                return s
+            msg = "Truncated pHYs chunk"
+            raise ValueError(msg)
+        px, py = i32(s, 0), i32(s, 4)
+        unit = s[8]
+        if unit == 1:  # meter
+            dpi = px * 0.0254, py * 0.0254
+            self.im_info["dpi"] = dpi
+        elif unit == 0:
+            self.im_info["aspect"] = px, py
+        return s
+
+    def chunk_tEXt(self, pos: int, length: int) -> bytes:
+        # text
+        assert self.fp is not None
+        s = ImageFile._safe_read(self.fp, length)
+        try:
+            k, v = s.split(b"\0", 1)
+        except ValueError:
+            # fallback for broken tEXt tags
+            k = s
+            v = b""
+        if k:
+            k_str = k.decode("latin-1", "strict")
+            v_str = v.decode("latin-1", "replace")
+
+            self.im_info[k_str] = v if k == b"exif" else v_str
+            self.im_text[k_str] = v_str
+            self.check_text_memory(len(v_str))
+
+        return s
+
+    def chunk_zTXt(self, pos: int, length: int) -> bytes:
+        # compressed text
+        assert self.fp is not None
+        s = ImageFile._safe_read(self.fp, length)
+        try:
+            k, v = s.split(b"\0", 1)
+        except ValueError:
+            k = s
+            v = b""
+        if v:
+            comp_method = v[0]
+        else:
+            comp_method = 0
+        if comp_method != 0:
+            msg = f"Unknown compression method {comp_method} in zTXt chunk"
+            raise SyntaxError(msg)
+        try:
+            v = _safe_zlib_decompress(v[1:])
+        except ValueError:
+            if ImageFile.LOAD_TRUNCATED_IMAGES:
+                v = b""
+            else:
+                raise
+        except zlib.error:
+            v = b""
+
+        if k:
+            k_str = k.decode("latin-1", "strict")
+            v_str = v.decode("latin-1", "replace")
+
+            self.im_info[k_str] = self.im_text[k_str] = v_str
+            self.check_text_memory(len(v_str))
+
+        return s
+
+    def chunk_iTXt(self, pos: int, length: int) -> bytes:
+        # international text
+        assert self.fp is not None
+        r = s = ImageFile._safe_read(self.fp, length)
+        try:
+            k, r = r.split(b"\0", 1)
+        except ValueError:
+            return s
+        if len(r) < 2:
+            return s
+        cf, cm, r = r[0], r[1], r[2:]
+        try:
+            lang, tk, v = r.split(b"\0", 2)
+        except ValueError:
+            return s
+        if cf != 0:
+            if cm == 0:
+                try:
+                    v = _safe_zlib_decompress(v)
+                except ValueError:
+                    if ImageFile.LOAD_TRUNCATED_IMAGES:
+                        return s
+                    else:
+                        raise
+                except zlib.error:
+                    return s
+            else:
+                return s
+        if k == b"XML:com.adobe.xmp":
+            self.im_info["xmp"] = v
+        try:
+            k_str = k.decode("latin-1", "strict")
+            lang_str = lang.decode("utf-8", "strict")
+            tk_str = tk.decode("utf-8", "strict")
+            v_str = v.decode("utf-8", "strict")
+        except UnicodeError:
+            return s
+
+        self.im_info[k_str] = self.im_text[k_str] = iTXt(v_str, lang_str, tk_str)
+        self.check_text_memory(len(v_str))
+
+        return s
+
+    def chunk_eXIf(self, pos: int, length: int) -> bytes:
+        assert self.fp is not None
+        s = ImageFile._safe_read(self.fp, length)
+        self.im_info["exif"] = b"Exif\x00\x00" + s
+        return s
+
+    # APNG chunks
+    def chunk_acTL(self, pos: int, length: int) -> bytes:
+        assert self.fp is not None
+        s = ImageFile._safe_read(self.fp, length)
+        if length < 8:
+            if ImageFile.LOAD_TRUNCATED_IMAGES:
+                return s
+            msg = "APNG contains truncated acTL chunk"
+            raise ValueError(msg)
+        if self.im_n_frames is not None:
+            self.im_n_frames = None
+            warnings.warn("Invalid APNG, will use default PNG image if possible")
+            return s
+        n_frames = i32(s)
+        if n_frames == 0 or n_frames > 0x80000000:
+            warnings.warn("Invalid APNG, will use default PNG image if possible")
+            return s
+        self.im_n_frames = n_frames
+        self.im_info["loop"] = i32(s, 4)
+        self.im_custom_mimetype = "image/apng"
+        return s
+
+    def chunk_fcTL(self, pos: int, length: int) -> bytes:
+        assert self.fp is not None
+        s = ImageFile._safe_read(self.fp, length)
+        if length < 26:
+            if ImageFile.LOAD_TRUNCATED_IMAGES:
+                return s
+            msg = "APNG contains truncated fcTL chunk"
+            raise ValueError(msg)
+        seq = i32(s)
+        if (self._seq_num is None and seq != 0) or (
+            self._seq_num is not None and self._seq_num != seq - 1
+        ):
+            msg = "APNG contains frame sequence errors"
+            raise SyntaxError(msg)
+        self._seq_num = seq
+        width, height = i32(s, 4), i32(s, 8)
+        px, py = i32(s, 12), i32(s, 16)
+        im_w, im_h = self.im_size
+        if px + width > im_w or py + height > im_h:
+            msg = "APNG contains invalid frames"
+            raise SyntaxError(msg)
+        self.im_info["bbox"] = (px, py, px + width, py + height)
+        delay_num, delay_den = i16(s, 20), i16(s, 22)
+        if delay_den == 0:
+            delay_den = 100
+        self.im_info["duration"] = float(delay_num) / float(delay_den) * 1000
+        self.im_info["disposal"] = s[24]
+        self.im_info["blend"] = s[25]
+        return s
+
+    def chunk_fdAT(self, pos: int, length: int) -> bytes:
+        assert self.fp is not None
+        if length < 4:
+            if ImageFile.LOAD_TRUNCATED_IMAGES:
+                s = ImageFile._safe_read(self.fp, length)
+                return s
+            msg = "APNG contains truncated fDAT chunk"
+            raise ValueError(msg)
+        s = ImageFile._safe_read(self.fp, 4)
+        seq = i32(s)
+        if self._seq_num != seq - 1:
+            msg = "APNG contains frame sequence errors"
+            raise SyntaxError(msg)
+        self._seq_num = seq
+        return self.chunk_IDAT(pos + 4, length - 4)
+
+
+# --------------------------------------------------------------------
+# PNG reader
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix.startswith(_MAGIC)
+
+
+##
+# Image plugin for PNG images.
+
+
+class PngImageFile(ImageFile.ImageFile):
+    format = "PNG"
+    format_description = "Portable network graphics"
+
+    def _open(self) -> None:
+        if not _accept(self.fp.read(8)):
+            msg = "not a PNG file"
+            raise SyntaxError(msg)
+        self._fp = self.fp
+        self.__frame = 0
+
+        #
+        # Parse headers up to the first IDAT or fDAT chunk
+
+        self.private_chunks: list[tuple[bytes, bytes] | tuple[bytes, bytes, bool]] = []
+        self.png: PngStream | None = PngStream(self.fp)
+
+        while True:
+            #
+            # get next chunk
+
+            cid, pos, length = self.png.read()
+
+            try:
+                s = self.png.call(cid, pos, length)
+            except EOFError:
+                break
+            except AttributeError:
+                logger.debug("%r %s %s (unknown)", cid, pos, length)
+                s = ImageFile._safe_read(self.fp, length)
+                if cid[1:2].islower():
+                    self.private_chunks.append((cid, s))
+
+            self.png.crc(cid, s)
+
+        #
+        # Copy relevant attributes from the PngStream.  An alternative
+        # would be to let the PngStream class modify these attributes
+        # directly, but that introduces circular references which are
+        # difficult to break if things go wrong in the decoder...
+        # (believe me, I've tried ;-)
+
+        self._mode = self.png.im_mode
+        self._size = self.png.im_size
+        self.info = self.png.im_info
+        self._text: dict[str, str | iTXt] | None = None
+        self.tile = self.png.im_tile
+        self.custom_mimetype = self.png.im_custom_mimetype
+        self.n_frames = self.png.im_n_frames or 1
+        self.default_image = self.info.get("default_image", False)
+
+        if self.png.im_palette:
+            rawmode, data = self.png.im_palette
+            self.palette = ImagePalette.raw(rawmode, data)
+
+        if cid == b"fdAT":
+            self.__prepare_idat = length - 4
+        else:
+            self.__prepare_idat = length  # used by load_prepare()
+
+        if self.png.im_n_frames is not None:
+            self._close_exclusive_fp_after_loading = False
+            self.png.save_rewind()
+            self.__rewind_idat = self.__prepare_idat
+            self.__rewind = self._fp.tell()
+            if self.default_image:
+                # IDAT chunk contains default image and not first animation frame
+                self.n_frames += 1
+            self._seek(0)
+        self.is_animated = self.n_frames > 1
+
+    @property
+    def text(self) -> dict[str, str | iTXt]:
+        # experimental
+        if self._text is None:
+            # iTxt, tEXt and zTXt chunks may appear at the end of the file
+            # So load the file to ensure that they are read
+            if self.is_animated:
+                frame = self.__frame
+                # for APNG, seek to the final frame before loading
+                self.seek(self.n_frames - 1)
+            self.load()
+            if self.is_animated:
+                self.seek(frame)
+        assert self._text is not None
+        return self._text
+
+    def verify(self) -> None:
+        """Verify PNG file"""
+
+        if self.fp is None:
+            msg = "verify must be called directly after open"
+            raise RuntimeError(msg)
+
+        # back up to beginning of IDAT block
+        self.fp.seek(self.tile[0][2] - 8)
+
+        assert self.png is not None
+        self.png.verify()
+        self.png.close()
+
+        if self._exclusive_fp:
+            self.fp.close()
+        self.fp = None
+
+    def seek(self, frame: int) -> None:
+        if not self._seek_check(frame):
+            return
+        if frame < self.__frame:
+            self._seek(0, True)
+
+        last_frame = self.__frame
+        for f in range(self.__frame + 1, frame + 1):
+            try:
+                self._seek(f)
+            except EOFError as e:
+                self.seek(last_frame)
+                msg = "no more images in APNG file"
+                raise EOFError(msg) from e
+
+    def _seek(self, frame: int, rewind: bool = False) -> None:
+        assert self.png is not None
+        if isinstance(self._fp, DeferredError):
+            raise self._fp.ex
+
+        self.dispose: _imaging.ImagingCore | None
+        dispose_extent = None
+        if frame == 0:
+            if rewind:
+                self._fp.seek(self.__rewind)
+                self.png.rewind()
+                self.__prepare_idat = self.__rewind_idat
+                self._im = None
+                self.info = self.png.im_info
+                self.tile = self.png.im_tile
+                self.fp = self._fp
+            self._prev_im = None
+            self.dispose = None
+            self.default_image = self.info.get("default_image", False)
+            self.dispose_op = self.info.get("disposal")
+            self.blend_op = self.info.get("blend")
+            dispose_extent = self.info.get("bbox")
+            self.__frame = 0
+        else:
+            if frame != self.__frame + 1:
+                msg = f"cannot seek to frame {frame}"
+                raise ValueError(msg)
+
+            # ensure previous frame was loaded
+            self.load()
+
+            if self.dispose:
+                self.im.paste(self.dispose, self.dispose_extent)
+            self._prev_im = self.im.copy()
+
+            self.fp = self._fp
+
+            # advance to the next frame
+            if self.__prepare_idat:
+                ImageFile._safe_read(self.fp, self.__prepare_idat)
+                self.__prepare_idat = 0
+            frame_start = False
+            while True:
+                self.fp.read(4)  # CRC
+
+                try:
+                    cid, pos, length = self.png.read()
+                except (struct.error, SyntaxError):
+                    break
+
+                if cid == b"IEND":
+                    msg = "No more images in APNG file"
+                    raise EOFError(msg)
+                if cid == b"fcTL":
+                    if frame_start:
+                        # there must be at least one fdAT chunk between fcTL chunks
+                        msg = "APNG missing frame data"
+                        raise SyntaxError(msg)
+                    frame_start = True
+
+                try:
+                    self.png.call(cid, pos, length)
+                except UnicodeDecodeError:
+                    break
+                except EOFError:
+                    if cid == b"fdAT":
+                        length -= 4
+                        if frame_start:
+                            self.__prepare_idat = length
+                            break
+                    ImageFile._safe_read(self.fp, length)
+                except AttributeError:
+                    logger.debug("%r %s %s (unknown)", cid, pos, length)
+                    ImageFile._safe_read(self.fp, length)
+
+            self.__frame = frame
+            self.tile = self.png.im_tile
+            self.dispose_op = self.info.get("disposal")
+            self.blend_op = self.info.get("blend")
+            dispose_extent = self.info.get("bbox")
+
+            if not self.tile:
+                msg = "image not found in APNG frame"
+                raise EOFError(msg)
+        if dispose_extent:
+            self.dispose_extent: tuple[float, float, float, float] = dispose_extent
+
+        # setup frame disposal (actual disposal done when needed in the next _seek())
+        if self._prev_im is None and self.dispose_op == Disposal.OP_PREVIOUS:
+            self.dispose_op = Disposal.OP_BACKGROUND
+
+        self.dispose = None
+        if self.dispose_op == Disposal.OP_PREVIOUS:
+            if self._prev_im:
+                self.dispose = self._prev_im.copy()
+                self.dispose = self._crop(self.dispose, self.dispose_extent)
+        elif self.dispose_op == Disposal.OP_BACKGROUND:
+            self.dispose = Image.core.fill(self.mode, self.size)
+            self.dispose = self._crop(self.dispose, self.dispose_extent)
+
+    def tell(self) -> int:
+        return self.__frame
+
+    def load_prepare(self) -> None:
+        """internal: prepare to read PNG file"""
+
+        if self.info.get("interlace"):
+            self.decoderconfig = self.decoderconfig + (1,)
+
+        self.__idat = self.__prepare_idat  # used by load_read()
+        ImageFile.ImageFile.load_prepare(self)
+
+    def load_read(self, read_bytes: int) -> bytes:
+        """internal: read more image data"""
+
+        assert self.png is not None
+        while self.__idat == 0:
+            # end of chunk, skip forward to next one
+
+            self.fp.read(4)  # CRC
+
+            cid, pos, length = self.png.read()
+
+            if cid not in [b"IDAT", b"DDAT", b"fdAT"]:
+                self.png.push(cid, pos, length)
+                return b""
+
+            if cid == b"fdAT":
+                try:
+                    self.png.call(cid, pos, length)
+                except EOFError:
+                    pass
+                self.__idat = length - 4  # sequence_num has already been read
+            else:
+                self.__idat = length  # empty chunks are allowed
+
+        # read more data from this chunk
+        if read_bytes <= 0:
+            read_bytes = self.__idat
+        else:
+            read_bytes = min(read_bytes, self.__idat)
+
+        self.__idat = self.__idat - read_bytes
+
+        return self.fp.read(read_bytes)
+
+    def load_end(self) -> None:
+        """internal: finished reading image data"""
+        assert self.png is not None
+        if self.__idat != 0:
+            self.fp.read(self.__idat)
+        while True:
+            self.fp.read(4)  # CRC
+
+            try:
+                cid, pos, length = self.png.read()
+            except (struct.error, SyntaxError):
+                break
+
+            if cid == b"IEND":
+                break
+            elif cid == b"fcTL" and self.is_animated:
+                # start of the next frame, stop reading
+                self.__prepare_idat = 0
+                self.png.push(cid, pos, length)
+                break
+
+            try:
+                self.png.call(cid, pos, length)
+            except UnicodeDecodeError:
+                break
+            except EOFError:
+                if cid == b"fdAT":
+                    length -= 4
+                try:
+                    ImageFile._safe_read(self.fp, length)
+                except OSError as e:
+                    if ImageFile.LOAD_TRUNCATED_IMAGES:
+                        break
+                    else:
+                        raise e
+            except AttributeError:
+                logger.debug("%r %s %s (unknown)", cid, pos, length)
+                s = ImageFile._safe_read(self.fp, length)
+                if cid[1:2].islower():
+                    self.private_chunks.append((cid, s, True))
+        self._text = self.png.im_text
+        if not self.is_animated:
+            self.png.close()
+            self.png = None
+        else:
+            if self._prev_im and self.blend_op == Blend.OP_OVER:
+                updated = self._crop(self.im, self.dispose_extent)
+                if self.im.mode == "RGB" and "transparency" in self.info:
+                    mask = updated.convert_transparent(
+                        "RGBA", self.info["transparency"]
+                    )
+                else:
+                    if self.im.mode == "P" and "transparency" in self.info:
+                        t = self.info["transparency"]
+                        if isinstance(t, bytes):
+                            updated.putpalettealphas(t)
+                        elif isinstance(t, int):
+                            updated.putpalettealpha(t)
+                    mask = updated.convert("RGBA")
+                self._prev_im.paste(updated, self.dispose_extent, mask)
+                self.im = self._prev_im
+
+    def _getexif(self) -> dict[int, Any] | None:
+        if "exif" not in self.info:
+            self.load()
+        if "exif" not in self.info and "Raw profile type exif" not in self.info:
+            return None
+        return self.getexif()._get_merged_dict()
+
+    def getexif(self) -> Image.Exif:
+        if "exif" not in self.info:
+            self.load()
+
+        return super().getexif()
+
+
+# --------------------------------------------------------------------
+# PNG writer
+
+_OUTMODES = {
+    # supported PIL modes, and corresponding rawmode, bit depth and color type
+    "1": ("1", b"\x01", b"\x00"),
+    "L;1": ("L;1", b"\x01", b"\x00"),
+    "L;2": ("L;2", b"\x02", b"\x00"),
+    "L;4": ("L;4", b"\x04", b"\x00"),
+    "L": ("L", b"\x08", b"\x00"),
+    "LA": ("LA", b"\x08", b"\x04"),
+    "I": ("I;16B", b"\x10", b"\x00"),
+    "I;16": ("I;16B", b"\x10", b"\x00"),
+    "I;16B": ("I;16B", b"\x10", b"\x00"),
+    "P;1": ("P;1", b"\x01", b"\x03"),
+    "P;2": ("P;2", b"\x02", b"\x03"),
+    "P;4": ("P;4", b"\x04", b"\x03"),
+    "P": ("P", b"\x08", b"\x03"),
+    "RGB": ("RGB", b"\x08", b"\x02"),
+    "RGBA": ("RGBA", b"\x08", b"\x06"),
+}
+
+
+def putchunk(fp: IO[bytes], cid: bytes, *data: bytes) -> None:
+    """Write a PNG chunk (including CRC field)"""
+
+    byte_data = b"".join(data)
+
+    fp.write(o32(len(byte_data)) + cid)
+    fp.write(byte_data)
+    crc = _crc32(byte_data, _crc32(cid))
+    fp.write(o32(crc))
+
+
+class _idat:
+    # wrap output from the encoder in IDAT chunks
+
+    def __init__(self, fp: IO[bytes], chunk: Callable[..., None]) -> None:
+        self.fp = fp
+        self.chunk = chunk
+
+    def write(self, data: bytes) -> None:
+        self.chunk(self.fp, b"IDAT", data)
+
+
+class _fdat:
+    # wrap encoder output in fdAT chunks
+
+    def __init__(self, fp: IO[bytes], chunk: Callable[..., None], seq_num: int) -> None:
+        self.fp = fp
+        self.chunk = chunk
+        self.seq_num = seq_num
+
+    def write(self, data: bytes) -> None:
+        self.chunk(self.fp, b"fdAT", o32(self.seq_num), data)
+        self.seq_num += 1
+
+
+class _Frame(NamedTuple):
+    im: Image.Image
+    bbox: tuple[int, int, int, int] | None
+    encoderinfo: dict[str, Any]
+
+
+def _write_multiple_frames(
+    im: Image.Image,
+    fp: IO[bytes],
+    chunk: Callable[..., None],
+    mode: str,
+    rawmode: str,
+    default_image: Image.Image | None,
+    append_images: list[Image.Image],
+) -> Image.Image | None:
+    duration = im.encoderinfo.get("duration")
+    loop = im.encoderinfo.get("loop", im.info.get("loop", 0))
+    disposal = im.encoderinfo.get("disposal", im.info.get("disposal", Disposal.OP_NONE))
+    blend = im.encoderinfo.get("blend", im.info.get("blend", Blend.OP_SOURCE))
+
+    if default_image:
+        chain = itertools.chain(append_images)
+    else:
+        chain = itertools.chain([im], append_images)
+
+    im_frames: list[_Frame] = []
+    frame_count = 0
+    for im_seq in chain:
+        for im_frame in ImageSequence.Iterator(im_seq):
+            if im_frame.mode == mode:
+                im_frame = im_frame.copy()
+            else:
+                im_frame = im_frame.convert(mode)
+            encoderinfo = im.encoderinfo.copy()
+            if isinstance(duration, (list, tuple)):
+                encoderinfo["duration"] = duration[frame_count]
+            elif duration is None and "duration" in im_frame.info:
+                encoderinfo["duration"] = im_frame.info["duration"]
+            if isinstance(disposal, (list, tuple)):
+                encoderinfo["disposal"] = disposal[frame_count]
+            if isinstance(blend, (list, tuple)):
+                encoderinfo["blend"] = blend[frame_count]
+            frame_count += 1
+
+            if im_frames:
+                previous = im_frames[-1]
+                prev_disposal = previous.encoderinfo.get("disposal")
+                prev_blend = previous.encoderinfo.get("blend")
+                if prev_disposal == Disposal.OP_PREVIOUS and len(im_frames) < 2:
+                    prev_disposal = Disposal.OP_BACKGROUND
+
+                if prev_disposal == Disposal.OP_BACKGROUND:
+                    base_im = previous.im.copy()
+                    dispose = Image.core.fill("RGBA", im.size, (0, 0, 0, 0))
+                    bbox = previous.bbox
+                    if bbox:
+                        dispose = dispose.crop(bbox)
+                    else:
+                        bbox = (0, 0) + im.size
+                    base_im.paste(dispose, bbox)
+                elif prev_disposal == Disposal.OP_PREVIOUS:
+                    base_im = im_frames[-2].im
+                else:
+                    base_im = previous.im
+                delta = ImageChops.subtract_modulo(
+                    im_frame.convert("RGBA"), base_im.convert("RGBA")
+                )
+                bbox = delta.getbbox(alpha_only=False)
+                if (
+                    not bbox
+                    and prev_disposal == encoderinfo.get("disposal")
+                    and prev_blend == encoderinfo.get("blend")
+                    and "duration" in encoderinfo
+                ):
+                    previous.encoderinfo["duration"] += encoderinfo["duration"]
+                    continue
+            else:
+                bbox = None
+            im_frames.append(_Frame(im_frame, bbox, encoderinfo))
+
+    if len(im_frames) == 1 and not default_image:
+        return im_frames[0].im
+
+    # animation control
+    chunk(
+        fp,
+        b"acTL",
+        o32(len(im_frames)),  # 0: num_frames
+        o32(loop),  # 4: num_plays
+    )
+
+    # default image IDAT (if it exists)
+    if default_image:
+        if im.mode != mode:
+            im = im.convert(mode)
+        ImageFile._save(
+            im,
+            cast(IO[bytes], _idat(fp, chunk)),
+            [ImageFile._Tile("zip", (0, 0) + im.size, 0, rawmode)],
+        )
+
+    seq_num = 0
+    for frame, frame_data in enumerate(im_frames):
+        im_frame = frame_data.im
+        if not frame_data.bbox:
+            bbox = (0, 0) + im_frame.size
+        else:
+            bbox = frame_data.bbox
+            im_frame = im_frame.crop(bbox)
+        size = im_frame.size
+        encoderinfo = frame_data.encoderinfo
+        frame_duration = int(round(encoderinfo.get("duration", 0)))
+        frame_disposal = encoderinfo.get("disposal", disposal)
+        frame_blend = encoderinfo.get("blend", blend)
+        # frame control
+        chunk(
+            fp,
+            b"fcTL",
+            o32(seq_num),  # sequence_number
+            o32(size[0]),  # width
+            o32(size[1]),  # height
+            o32(bbox[0]),  # x_offset
+            o32(bbox[1]),  # y_offset
+            o16(frame_duration),  # delay_numerator
+            o16(1000),  # delay_denominator
+            o8(frame_disposal),  # dispose_op
+            o8(frame_blend),  # blend_op
+        )
+        seq_num += 1
+        # frame data
+        if frame == 0 and not default_image:
+            # first frame must be in IDAT chunks for backwards compatibility
+            ImageFile._save(
+                im_frame,
+                cast(IO[bytes], _idat(fp, chunk)),
+                [ImageFile._Tile("zip", (0, 0) + im_frame.size, 0, rawmode)],
+            )
+        else:
+            fdat_chunks = _fdat(fp, chunk, seq_num)
+            ImageFile._save(
+                im_frame,
+                cast(IO[bytes], fdat_chunks),
+                [ImageFile._Tile("zip", (0, 0) + im_frame.size, 0, rawmode)],
+            )
+            seq_num = fdat_chunks.seq_num
+    return None
+
+
+def _save_all(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    _save(im, fp, filename, save_all=True)
+
+
+def _save(
+    im: Image.Image,
+    fp: IO[bytes],
+    filename: str | bytes,
+    chunk: Callable[..., None] = putchunk,
+    save_all: bool = False,
+) -> None:
+    # save an image to disk (called by the save method)
+
+    if save_all:
+        default_image = im.encoderinfo.get(
+            "default_image", im.info.get("default_image")
+        )
+        modes = set()
+        sizes = set()
+        append_images = im.encoderinfo.get("append_images", [])
+        for im_seq in itertools.chain([im], append_images):
+            for im_frame in ImageSequence.Iterator(im_seq):
+                modes.add(im_frame.mode)
+                sizes.add(im_frame.size)
+        for mode in ("RGBA", "RGB", "P"):
+            if mode in modes:
+                break
+        else:
+            mode = modes.pop()
+        size = tuple(max(frame_size[i] for frame_size in sizes) for i in range(2))
+    else:
+        size = im.size
+        mode = im.mode
+
+    outmode = mode
+    if mode == "P":
+        #
+        # attempt to minimize storage requirements for palette images
+        if "bits" in im.encoderinfo:
+            # number of bits specified by user
+            colors = min(1 << im.encoderinfo["bits"], 256)
+        else:
+            # check palette contents
+            if im.palette:
+                colors = max(min(len(im.palette.getdata()[1]) // 3, 256), 1)
+            else:
+                colors = 256
+
+        if colors <= 16:
+            if colors <= 2:
+                bits = 1
+            elif colors <= 4:
+                bits = 2
+            else:
+                bits = 4
+            outmode += f";{bits}"
+
+    # encoder options
+    im.encoderconfig = (
+        im.encoderinfo.get("optimize", False),
+        im.encoderinfo.get("compress_level", -1),
+        im.encoderinfo.get("compress_type", -1),
+        im.encoderinfo.get("dictionary", b""),
+    )
+
+    # get the corresponding PNG mode
+    try:
+        rawmode, bit_depth, color_type = _OUTMODES[outmode]
+    except KeyError as e:
+        msg = f"cannot write mode {mode} as PNG"
+        raise OSError(msg) from e
+    if outmode == "I":
+        deprecate("Saving I mode images as PNG", 13, stacklevel=4)
+
+    #
+    # write minimal PNG file
+
+    fp.write(_MAGIC)
+
+    chunk(
+        fp,
+        b"IHDR",
+        o32(size[0]),  # 0: size
+        o32(size[1]),
+        bit_depth,
+        color_type,
+        b"\0",  # 10: compression
+        b"\0",  # 11: filter category
+        b"\0",  # 12: interlace flag
+    )
+
+    chunks = [b"cHRM", b"cICP", b"gAMA", b"sBIT", b"sRGB", b"tIME"]
+
+    icc = im.encoderinfo.get("icc_profile", im.info.get("icc_profile"))
+    if icc:
+        # ICC profile
+        # according to PNG spec, the iCCP chunk contains:
+        # Profile name  1-79 bytes (character string)
+        # Null separator        1 byte (null character)
+        # Compression method    1 byte (0)
+        # Compressed profile    n bytes (zlib with deflate compression)
+        name = b"ICC Profile"
+        data = name + b"\0\0" + zlib.compress(icc)
+        chunk(fp, b"iCCP", data)
+
+        # You must either have sRGB or iCCP.
+        # Disallow sRGB chunks when an iCCP-chunk has been emitted.
+        chunks.remove(b"sRGB")
+
+    info = im.encoderinfo.get("pnginfo")
+    if info:
+        chunks_multiple_allowed = [b"sPLT", b"iTXt", b"tEXt", b"zTXt"]
+        for info_chunk in info.chunks:
+            cid, data = info_chunk[:2]
+            if cid in chunks:
+                chunks.remove(cid)
+                chunk(fp, cid, data)
+            elif cid in chunks_multiple_allowed:
+                chunk(fp, cid, data)
+            elif cid[1:2].islower():
+                # Private chunk
+                after_idat = len(info_chunk) == 3 and info_chunk[2]
+                if not after_idat:
+                    chunk(fp, cid, data)
+
+    if im.mode == "P":
+        palette_byte_number = colors * 3
+        palette_bytes = im.im.getpalette("RGB")[:palette_byte_number]
+        while len(palette_bytes) < palette_byte_number:
+            palette_bytes += b"\0"
+        chunk(fp, b"PLTE", palette_bytes)
+
+    transparency = im.encoderinfo.get("transparency", im.info.get("transparency", None))
+
+    if transparency or transparency == 0:
+        if im.mode == "P":
+            # limit to actual palette size
+            alpha_bytes = colors
+            if isinstance(transparency, bytes):
+                chunk(fp, b"tRNS", transparency[:alpha_bytes])
+            else:
+                transparency = max(0, min(255, transparency))
+                alpha = b"\xff" * transparency + b"\0"
+                chunk(fp, b"tRNS", alpha[:alpha_bytes])
+        elif im.mode in ("1", "L", "I", "I;16"):
+            transparency = max(0, min(65535, transparency))
+            chunk(fp, b"tRNS", o16(transparency))
+        elif im.mode == "RGB":
+            red, green, blue = transparency
+            chunk(fp, b"tRNS", o16(red) + o16(green) + o16(blue))
+        else:
+            if "transparency" in im.encoderinfo:
+                # don't bother with transparency if it's an RGBA
+                # and it's in the info dict. It's probably just stale.
+                msg = "cannot use transparency for this mode"
+                raise OSError(msg)
+    else:
+        if im.mode == "P" and im.im.getpalettemode() == "RGBA":
+            alpha = im.im.getpalette("RGBA", "A")
+            alpha_bytes = colors
+            chunk(fp, b"tRNS", alpha[:alpha_bytes])
+
+    dpi = im.encoderinfo.get("dpi")
+    if dpi:
+        chunk(
+            fp,
+            b"pHYs",
+            o32(int(dpi[0] / 0.0254 + 0.5)),
+            o32(int(dpi[1] / 0.0254 + 0.5)),
+            b"\x01",
+        )
+
+    if info:
+        chunks = [b"bKGD", b"hIST"]
+        for info_chunk in info.chunks:
+            cid, data = info_chunk[:2]
+            if cid in chunks:
+                chunks.remove(cid)
+                chunk(fp, cid, data)
+
+    exif = im.encoderinfo.get("exif")
+    if exif:
+        if isinstance(exif, Image.Exif):
+            exif = exif.tobytes(8)
+        if exif.startswith(b"Exif\x00\x00"):
+            exif = exif[6:]
+        chunk(fp, b"eXIf", exif)
+
+    single_im: Image.Image | None = im
+    if save_all:
+        single_im = _write_multiple_frames(
+            im, fp, chunk, mode, rawmode, default_image, append_images
+        )
+    if single_im:
+        ImageFile._save(
+            single_im,
+            cast(IO[bytes], _idat(fp, chunk)),
+            [ImageFile._Tile("zip", (0, 0) + single_im.size, 0, rawmode)],
+        )
+
+    if info:
+        for info_chunk in info.chunks:
+            cid, data = info_chunk[:2]
+            if cid[1:2].islower():
+                # Private chunk
+                after_idat = len(info_chunk) == 3 and info_chunk[2]
+                if after_idat:
+                    chunk(fp, cid, data)
+
+    chunk(fp, b"IEND", b"")
+
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+
+# --------------------------------------------------------------------
+# PNG chunk converter
+
+
+def getchunks(im: Image.Image, **params: Any) -> list[tuple[bytes, bytes, bytes]]:
+    """Return a list of PNG chunks representing this image."""
+    from io import BytesIO
+
+    chunks = []
+
+    def append(fp: IO[bytes], cid: bytes, *data: bytes) -> None:
+        byte_data = b"".join(data)
+        crc = o32(_crc32(byte_data, _crc32(cid)))
+        chunks.append((cid, byte_data, crc))
+
+    fp = BytesIO()
+
+    try:
+        im.encoderinfo = params
+        _save(im, fp, "", append)
+    finally:
+        del im.encoderinfo
+
+    return chunks
+
+
+# --------------------------------------------------------------------
+# Registry
+
+Image.register_open(PngImageFile.format, PngImageFile, _accept)
+Image.register_save(PngImageFile.format, _save)
+Image.register_save_all(PngImageFile.format, _save_all)
+
+Image.register_extensions(PngImageFile.format, [".png", ".apng"])
+
+Image.register_mime(PngImageFile.format, "image/png")

.venv/lib/python3.12/site-packages/PIL/PpmImagePlugin.py

@@ -0,0 +1,375 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# PPM support for PIL
+#
+# History:
+#       96-03-24 fl     Created
+#       98-03-06 fl     Write RGBA images (as RGB, that is)
+#
+# Copyright (c) Secret Labs AB 1997-98.
+# Copyright (c) Fredrik Lundh 1996.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import math
+from typing import IO
+
+from . import Image, ImageFile
+from ._binary import i16be as i16
+from ._binary import o8
+from ._binary import o32le as o32
+
+#
+# --------------------------------------------------------------------
+
+b_whitespace = b"\x20\x09\x0a\x0b\x0c\x0d"
+
+MODES = {
+    # standard
+    b"P1": "1",
+    b"P2": "L",
+    b"P3": "RGB",
+    b"P4": "1",
+    b"P5": "L",
+    b"P6": "RGB",
+    # extensions
+    b"P0CMYK": "CMYK",
+    b"Pf": "F",
+    # PIL extensions (for test purposes only)
+    b"PyP": "P",
+    b"PyRGBA": "RGBA",
+    b"PyCMYK": "CMYK",
+}
+
+
+def _accept(prefix: bytes) -> bool:
+    return len(prefix) >= 2 and prefix.startswith(b"P") and prefix[1] in b"0123456fy"
+
+
+##
+# Image plugin for PBM, PGM, and PPM images.
+
+
+class PpmImageFile(ImageFile.ImageFile):
+    format = "PPM"
+    format_description = "Pbmplus image"
+
+    def _read_magic(self) -> bytes:
+        assert self.fp is not None
+
+        magic = b""
+        # read until whitespace or longest available magic number
+        for _ in range(6):
+            c = self.fp.read(1)
+            if not c or c in b_whitespace:
+                break
+            magic += c
+        return magic
+
+    def _read_token(self) -> bytes:
+        assert self.fp is not None
+
+        token = b""
+        while len(token) <= 10:  # read until next whitespace or limit of 10 characters
+            c = self.fp.read(1)
+            if not c:
+                break
+            elif c in b_whitespace:  # token ended
+                if not token:
+                    # skip whitespace at start
+                    continue
+                break
+            elif c == b"#":
+                # ignores rest of the line; stops at CR, LF or EOF
+                while self.fp.read(1) not in b"\r\n":
+                    pass
+                continue
+            token += c
+        if not token:
+            # Token was not even 1 byte
+            msg = "Reached EOF while reading header"
+            raise ValueError(msg)
+        elif len(token) > 10:
+            msg_too_long = b"Token too long in file header: %s" % token
+            raise ValueError(msg_too_long)
+        return token
+
+    def _open(self) -> None:
+        assert self.fp is not None
+
+        magic_number = self._read_magic()
+        try:
+            mode = MODES[magic_number]
+        except KeyError:
+            msg = "not a PPM file"
+            raise SyntaxError(msg)
+        self._mode = mode
+
+        if magic_number in (b"P1", b"P4"):
+            self.custom_mimetype = "image/x-portable-bitmap"
+        elif magic_number in (b"P2", b"P5"):
+            self.custom_mimetype = "image/x-portable-graymap"
+        elif magic_number in (b"P3", b"P6"):
+            self.custom_mimetype = "image/x-portable-pixmap"
+
+        self._size = int(self._read_token()), int(self._read_token())
+
+        decoder_name = "raw"
+        if magic_number in (b"P1", b"P2", b"P3"):
+            decoder_name = "ppm_plain"
+
+        args: str | tuple[str | int, ...]
+        if mode == "1":
+            args = "1;I"
+        elif mode == "F":
+            scale = float(self._read_token())
+            if scale == 0.0 or not math.isfinite(scale):
+                msg = "scale must be finite and non-zero"
+                raise ValueError(msg)
+            self.info["scale"] = abs(scale)
+
+            rawmode = "F;32F" if scale < 0 else "F;32BF"
+            args = (rawmode, 0, -1)
+        else:
+            maxval = int(self._read_token())
+            if not 0 < maxval < 65536:
+                msg = "maxval must be greater than 0 and less than 65536"
+                raise ValueError(msg)
+            if maxval > 255 and mode == "L":
+                self._mode = "I"
+
+            rawmode = mode
+            if decoder_name != "ppm_plain":
+                # If maxval matches a bit depth, use the raw decoder directly
+                if maxval == 65535 and mode == "L":
+                    rawmode = "I;16B"
+                elif maxval != 255:
+                    decoder_name = "ppm"
+
+            args = rawmode if decoder_name == "raw" else (rawmode, maxval)
+        self.tile = [
+            ImageFile._Tile(decoder_name, (0, 0) + self.size, self.fp.tell(), args)
+        ]
+
+
+#
+# --------------------------------------------------------------------
+
+
+class PpmPlainDecoder(ImageFile.PyDecoder):
+    _pulls_fd = True
+    _comment_spans: bool
+
+    def _read_block(self) -> bytes:
+        assert self.fd is not None
+
+        return self.fd.read(ImageFile.SAFEBLOCK)
+
+    def _find_comment_end(self, block: bytes, start: int = 0) -> int:
+        a = block.find(b"\n", start)
+        b = block.find(b"\r", start)
+        return min(a, b) if a * b > 0 else max(a, b)  # lowest nonnegative index (or -1)
+
+    def _ignore_comments(self, block: bytes) -> bytes:
+        if self._comment_spans:
+            # Finish current comment
+            while block:
+                comment_end = self._find_comment_end(block)
+                if comment_end != -1:
+                    # Comment ends in this block
+                    # Delete tail of comment
+                    block = block[comment_end + 1 :]
+                    break
+                else:
+                    # Comment spans whole block
+                    # So read the next block, looking for the end
+                    block = self._read_block()
+
+        # Search for any further comments
+        self._comment_spans = False
+        while True:
+            comment_start = block.find(b"#")
+            if comment_start == -1:
+                # No comment found
+                break
+            comment_end = self._find_comment_end(block, comment_start)
+            if comment_end != -1:
+                # Comment ends in this block
+                # Delete comment
+                block = block[:comment_start] + block[comment_end + 1 :]
+            else:
+                # Comment continues to next block(s)
+                block = block[:comment_start]
+                self._comment_spans = True
+                break
+        return block
+
+    def _decode_bitonal(self) -> bytearray:
+        """
+        This is a separate method because in the plain PBM format, all data tokens are
+        exactly one byte, so the inter-token whitespace is optional.
+        """
+        data = bytearray()
+        total_bytes = self.state.xsize * self.state.ysize
+
+        while len(data) != total_bytes:
+            block = self._read_block()  # read next block
+            if not block:
+                # eof
+                break
+
+            block = self._ignore_comments(block)
+
+            tokens = b"".join(block.split())
+            for token in tokens:
+                if token not in (48, 49):
+                    msg = b"Invalid token for this mode: %s" % bytes([token])
+                    raise ValueError(msg)
+            data = (data + tokens)[:total_bytes]
+        invert = bytes.maketrans(b"01", b"\xff\x00")
+        return data.translate(invert)
+
+    def _decode_blocks(self, maxval: int) -> bytearray:
+        data = bytearray()
+        max_len = 10
+        out_byte_count = 4 if self.mode == "I" else 1
+        out_max = 65535 if self.mode == "I" else 255
+        bands = Image.getmodebands(self.mode)
+        total_bytes = self.state.xsize * self.state.ysize * bands * out_byte_count
+
+        half_token = b""
+        while len(data) != total_bytes:
+            block = self._read_block()  # read next block
+            if not block:
+                if half_token:
+                    block = bytearray(b" ")  # flush half_token
+                else:
+                    # eof
+                    break
+
+            block = self._ignore_comments(block)
+
+            if half_token:
+                block = half_token + block  # stitch half_token to new block
+                half_token = b""
+
+            tokens = block.split()
+
+            if block and not block[-1:].isspace():  # block might split token
+                half_token = tokens.pop()  # save half token for later
+                if len(half_token) > max_len:  # prevent buildup of half_token
+                    msg = (
+                        b"Token too long found in data: %s" % half_token[: max_len + 1]
+                    )
+                    raise ValueError(msg)
+
+            for token in tokens:
+                if len(token) > max_len:
+                    msg = b"Token too long found in data: %s" % token[: max_len + 1]
+                    raise ValueError(msg)
+                value = int(token)
+                if value < 0:
+                    msg_str = f"Channel value is negative: {value}"
+                    raise ValueError(msg_str)
+                if value > maxval:
+                    msg_str = f"Channel value too large for this mode: {value}"
+                    raise ValueError(msg_str)
+                value = round(value / maxval * out_max)
+                data += o32(value) if self.mode == "I" else o8(value)
+                if len(data) == total_bytes:  # finished!
+                    break
+        return data
+
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
+        self._comment_spans = False
+        if self.mode == "1":
+            data = self._decode_bitonal()
+            rawmode = "1;8"
+        else:
+            maxval = self.args[-1]
+            data = self._decode_blocks(maxval)
+            rawmode = "I;32" if self.mode == "I" else self.mode
+        self.set_as_raw(bytes(data), rawmode)
+        return -1, 0
+
+
+class PpmDecoder(ImageFile.PyDecoder):
+    _pulls_fd = True
+
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
+        assert self.fd is not None
+
+        data = bytearray()
+        maxval = self.args[-1]
+        in_byte_count = 1 if maxval < 256 else 2
+        out_byte_count = 4 if self.mode == "I" else 1
+        out_max = 65535 if self.mode == "I" else 255
+        bands = Image.getmodebands(self.mode)
+        dest_length = self.state.xsize * self.state.ysize * bands * out_byte_count
+        while len(data) < dest_length:
+            pixels = self.fd.read(in_byte_count * bands)
+            if len(pixels) < in_byte_count * bands:
+                # eof
+                break
+            for b in range(bands):
+                value = (
+                    pixels[b] if in_byte_count == 1 else i16(pixels, b * in_byte_count)
+                )
+                value = min(out_max, round(value / maxval * out_max))
+                data += o32(value) if self.mode == "I" else o8(value)
+        rawmode = "I;32" if self.mode == "I" else self.mode
+        self.set_as_raw(bytes(data), rawmode)
+        return -1, 0
+
+
+#
+# --------------------------------------------------------------------
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    if im.mode == "1":
+        rawmode, head = "1;I", b"P4"
+    elif im.mode == "L":
+        rawmode, head = "L", b"P5"
+    elif im.mode in ("I", "I;16"):
+        rawmode, head = "I;16B", b"P5"
+    elif im.mode in ("RGB", "RGBA"):
+        rawmode, head = "RGB", b"P6"
+    elif im.mode == "F":
+        rawmode, head = "F;32F", b"Pf"
+    else:
+        msg = f"cannot write mode {im.mode} as PPM"
+        raise OSError(msg)
+    fp.write(head + b"\n%d %d\n" % im.size)
+    if head == b"P6":
+        fp.write(b"255\n")
+    elif head == b"P5":
+        if rawmode == "L":
+            fp.write(b"255\n")
+        else:
+            fp.write(b"65535\n")
+    elif head == b"Pf":
+        fp.write(b"-1.0\n")
+    row_order = -1 if im.mode == "F" else 1
+    ImageFile._save(
+        im, fp, [ImageFile._Tile("raw", (0, 0) + im.size, 0, (rawmode, 0, row_order))]
+    )
+
+
+#
+# --------------------------------------------------------------------
+
+
+Image.register_open(PpmImageFile.format, PpmImageFile, _accept)
+Image.register_save(PpmImageFile.format, _save)
+
+Image.register_decoder("ppm", PpmDecoder)
+Image.register_decoder("ppm_plain", PpmPlainDecoder)
+
+Image.register_extensions(PpmImageFile.format, [".pbm", ".pgm", ".ppm", ".pnm", ".pfm"])
+
+Image.register_mime(PpmImageFile.format, "image/x-portable-anymap")

.venv/lib/python3.12/site-packages/PIL/XVThumbImagePlugin.py

@@ -0,0 +1,83 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# XV Thumbnail file handler by Charles E. "Gene" Cash
+# (gcash@magicnet.net)
+#
+# see xvcolor.c and xvbrowse.c in the sources to John Bradley's XV,
+# available from ftp://ftp.cis.upenn.edu/pub/xv/
+#
+# history:
+# 98-08-15 cec  created (b/w only)
+# 98-12-09 cec  added color palette
+# 98-12-28 fl   added to PIL (with only a few very minor modifications)
+#
+# To do:
+# FIXME: make save work (this requires quantization support)
+#
+from __future__ import annotations
+
+from . import Image, ImageFile, ImagePalette
+from ._binary import o8
+
+_MAGIC = b"P7 332"
+
+# standard color palette for thumbnails (RGB332)
+PALETTE = b""
+for r in range(8):
+    for g in range(8):
+        for b in range(4):
+            PALETTE = PALETTE + (
+                o8((r * 255) // 7) + o8((g * 255) // 7) + o8((b * 255) // 3)
+            )
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix.startswith(_MAGIC)
+
+
+##
+# Image plugin for XV thumbnail images.
+
+
+class XVThumbImageFile(ImageFile.ImageFile):
+    format = "XVThumb"
+    format_description = "XV thumbnail image"
+
+    def _open(self) -> None:
+        # check magic
+        assert self.fp is not None
+
+        if not _accept(self.fp.read(6)):
+            msg = "not an XV thumbnail file"
+            raise SyntaxError(msg)
+
+        # Skip to beginning of next line
+        self.fp.readline()
+
+        # skip info comments
+        while True:
+            s = self.fp.readline()
+            if not s:
+                msg = "Unexpected EOF reading XV thumbnail file"
+                raise SyntaxError(msg)
+            if s[0] != 35:  # ie. when not a comment: '#'
+                break
+
+        # parse header line (already read)
+        s = s.strip().split()
+
+        self._mode = "P"
+        self._size = int(s[0]), int(s[1])
+
+        self.palette = ImagePalette.raw("RGB", PALETTE)
+
+        self.tile = [
+            ImageFile._Tile("raw", (0, 0) + self.size, self.fp.tell(), self.mode)
+        ]
+
+
+# --------------------------------------------------------------------
+
+Image.register_open(XVThumbImageFile.format, XVThumbImageFile, _accept)

.venv/lib/python3.12/site-packages/PIL/XpmImagePlugin.py

@@ -0,0 +1,157 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# XPM File handling
+#
+# History:
+# 1996-12-29 fl   Created
+# 2001-02-17 fl   Use 're' instead of 'regex' (Python 2.1) (0.7)
+#
+# Copyright (c) Secret Labs AB 1997-2001.
+# Copyright (c) Fredrik Lundh 1996-2001.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import re
+
+from . import Image, ImageFile, ImagePalette
+from ._binary import o8
+
+# XPM header
+xpm_head = re.compile(b'"([0-9]*) ([0-9]*) ([0-9]*) ([0-9]*)')
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix.startswith(b"/* XPM */")
+
+
+##
+# Image plugin for X11 pixel maps.
+
+
+class XpmImageFile(ImageFile.ImageFile):
+    format = "XPM"
+    format_description = "X11 Pixel Map"
+
+    def _open(self) -> None:
+        assert self.fp is not None
+        if not _accept(self.fp.read(9)):
+            msg = "not an XPM file"
+            raise SyntaxError(msg)
+
+        # skip forward to next string
+        while True:
+            line = self.fp.readline()
+            if not line:
+                msg = "broken XPM file"
+                raise SyntaxError(msg)
+            m = xpm_head.match(line)
+            if m:
+                break
+
+        self._size = int(m.group(1)), int(m.group(2))
+
+        palette_length = int(m.group(3))
+        bpp = int(m.group(4))
+
+        #
+        # load palette description
+
+        palette = {}
+
+        for _ in range(palette_length):
+            line = self.fp.readline().rstrip()
+
+            c = line[1 : bpp + 1]
+            s = line[bpp + 1 : -2].split()
+
+            for i in range(0, len(s), 2):
+                if s[i] == b"c":
+                    # process colour key
+                    rgb = s[i + 1]
+                    if rgb == b"None":
+                        self.info["transparency"] = c
+                    elif rgb.startswith(b"#"):
+                        rgb_int = int(rgb[1:], 16)
+                        palette[c] = (
+                            o8((rgb_int >> 16) & 255)
+                            + o8((rgb_int >> 8) & 255)
+                            + o8(rgb_int & 255)
+                        )
+                    else:
+                        # unknown colour
+                        msg = "cannot read this XPM file"
+                        raise ValueError(msg)
+                    break
+
+            else:
+                # missing colour key
+                msg = "cannot read this XPM file"
+                raise ValueError(msg)
+
+        args: tuple[int, dict[bytes, bytes] | tuple[bytes, ...]]
+        if palette_length > 256:
+            self._mode = "RGB"
+            args = (bpp, palette)
+        else:
+            self._mode = "P"
+            self.palette = ImagePalette.raw("RGB", b"".join(palette.values()))
+            args = (bpp, tuple(palette.keys()))
+
+        self.tile = [ImageFile._Tile("xpm", (0, 0) + self.size, self.fp.tell(), args)]
+
+    def load_read(self, read_bytes: int) -> bytes:
+        #
+        # load all image data in one chunk
+
+        xsize, ysize = self.size
+
+        assert self.fp is not None
+        s = [self.fp.readline()[1 : xsize + 1].ljust(xsize) for i in range(ysize)]
+
+        return b"".join(s)
+
+
+class XpmDecoder(ImageFile.PyDecoder):
+    _pulls_fd = True
+
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
+        assert self.fd is not None
+
+        data = bytearray()
+        bpp, palette = self.args
+        dest_length = self.state.xsize * self.state.ysize
+        if self.mode == "RGB":
+            dest_length *= 3
+        pixel_header = False
+        while len(data) < dest_length:
+            line = self.fd.readline()
+            if not line:
+                break
+            if line.rstrip() == b"/* pixels */" and not pixel_header:
+                pixel_header = True
+                continue
+            line = b'"'.join(line.split(b'"')[1:-1])
+            for i in range(0, len(line), bpp):
+                key = line[i : i + bpp]
+                if self.mode == "RGB":
+                    data += palette[key]
+                else:
+                    data += o8(palette.index(key))
+        self.set_as_raw(bytes(data))
+        return -1, 0
+
+
+#
+# Registry
+
+
+Image.register_open(XpmImageFile.format, XpmImageFile, _accept)
+Image.register_decoder("xpm", XpmDecoder)
+
+Image.register_extension(XpmImageFile.format, ".xpm")
+
+Image.register_mime(XpmImageFile.format, "image/xpm")

.venv/lib/python3.12/site-packages/PIL/__init__.py

@@ -0,0 +1,87 @@
+"""Pillow (Fork of the Python Imaging Library)
+
+Pillow is the friendly PIL fork by Jeffrey A. Clark and contributors.
+    https://github.com/python-pillow/Pillow/
+
+Pillow is forked from PIL 1.1.7.
+
+PIL is the Python Imaging Library by Fredrik Lundh and contributors.
+Copyright (c) 1999 by Secret Labs AB.
+
+Use PIL.__version__ for this Pillow version.
+
+;-)
+"""
+
+from __future__ import annotations
+
+from . import _version
+
+# VERSION was removed in Pillow 6.0.0.
+# PILLOW_VERSION was removed in Pillow 9.0.0.
+# Use __version__ instead.
+__version__ = _version.__version__
+del _version
+
+
+_plugins = [
+    "AvifImagePlugin",
+    "BlpImagePlugin",
+    "BmpImagePlugin",
+    "BufrStubImagePlugin",
+    "CurImagePlugin",
+    "DcxImagePlugin",
+    "DdsImagePlugin",
+    "EpsImagePlugin",
+    "FitsImagePlugin",
+    "FliImagePlugin",
+    "FpxImagePlugin",
+    "FtexImagePlugin",
+    "GbrImagePlugin",
+    "GifImagePlugin",
+    "GribStubImagePlugin",
+    "Hdf5StubImagePlugin",
+    "IcnsImagePlugin",
+    "IcoImagePlugin",
+    "ImImagePlugin",
+    "ImtImagePlugin",
+    "IptcImagePlugin",
+    "JpegImagePlugin",
+    "Jpeg2KImagePlugin",
+    "McIdasImagePlugin",
+    "MicImagePlugin",
+    "MpegImagePlugin",
+    "MpoImagePlugin",
+    "MspImagePlugin",
+    "PalmImagePlugin",
+    "PcdImagePlugin",
+    "PcxImagePlugin",
+    "PdfImagePlugin",
+    "PixarImagePlugin",
+    "PngImagePlugin",
+    "PpmImagePlugin",
+    "PsdImagePlugin",
+    "QoiImagePlugin",
+    "SgiImagePlugin",
+    "SpiderImagePlugin",
+    "SunImagePlugin",
+    "TgaImagePlugin",
+    "TiffImagePlugin",
+    "WebPImagePlugin",
+    "WmfImagePlugin",
+    "XbmImagePlugin",
+    "XpmImagePlugin",
+    "XVThumbImagePlugin",
+]
+
+
+class UnidentifiedImageError(OSError):
+    """
+    Raised in :py:meth:`PIL.Image.open` if an image cannot be opened and identified.
+
+    If a PNG image raises this error, setting :data:`.ImageFile.LOAD_TRUNCATED_IMAGES`
+    to true may allow the image to be opened after all. The setting will ignore missing
+    data and checksum failures.
+    """
+
+    pass

.venv/lib/python3.12/site-packages/easydict-1.13.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

.venv/lib/python3.12/site-packages/filelock-3.20.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

.venv/lib/python3.12/site-packages/filelock-3.20.0.dist-info/METADATA

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: filelock
+Version: 3.20.0
+Summary: A platform independent file lock.
+Project-URL: Documentation, https://py-filelock.readthedocs.io
+Project-URL: Homepage, https://github.com/tox-dev/py-filelock
+Project-URL: Source, https://github.com/tox-dev/py-filelock
+Project-URL: Tracker, https://github.com/tox-dev/py-filelock/issues
+Maintainer-email: Bernát Gábor <gaborjbernat@gmail.com>
+License-Expression: Unlicense
+License-File: LICENSE
+Keywords: application,cache,directory,log,user
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: The Unlicense (Unlicense)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# filelock
+
+[![PyPI](https://img.shields.io/pypi/v/filelock)](https://pypi.org/project/filelock/)
+[![Supported Python
+versions](https://img.shields.io/pypi/pyversions/filelock.svg)](https://pypi.org/project/filelock/)
+[![Documentation
+status](https://readthedocs.org/projects/py-filelock/badge/?version=latest)](https://py-filelock.readthedocs.io/en/latest/?badge=latest)
+[![Code style:
+black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Downloads](https://static.pepy.tech/badge/filelock/month)](https://pepy.tech/project/filelock)
+[![check](https://github.com/tox-dev/py-filelock/actions/workflows/check.yaml/badge.svg)](https://github.com/tox-dev/py-filelock/actions/workflows/check.yaml)
+
+For more information checkout the [official documentation](https://py-filelock.readthedocs.io/en/latest/index.html).

.venv/lib/python3.12/site-packages/filelock-3.20.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+filelock-3.20.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+filelock-3.20.0.dist-info/METADATA,sha256=gIghqdcbGNywxw52pN02_a9OxFqzhjA8v-9GsDWtNog,2110
+filelock-3.20.0.dist-info/RECORD,,
+filelock-3.20.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+filelock-3.20.0.dist-info/licenses/LICENSE,sha256=iNm062BXnBkew5HKBMFhMFctfu3EqG2qWL8oxuFMm80,1210
+filelock/__init__.py,sha256=_t_-OAGXo_qyPa9lNQ1YnzVYEvSW3I0onPqzpomsVVg,1769
+filelock/__pycache__/__init__.cpython-312.pyc,,
+filelock/__pycache__/_api.cpython-312.pyc,,
+filelock/__pycache__/_error.cpython-312.pyc,,
+filelock/__pycache__/_soft.cpython-312.pyc,,
+filelock/__pycache__/_unix.cpython-312.pyc,,
+filelock/__pycache__/_util.cpython-312.pyc,,
+filelock/__pycache__/_windows.cpython-312.pyc,,
+filelock/__pycache__/asyncio.cpython-312.pyc,,
+filelock/__pycache__/version.cpython-312.pyc,,
+filelock/_api.py,sha256=2aATBeJ3-jtMj5OSm7EE539iNaTBsf13KXtcBMoi8oM,14545
+filelock/_error.py,sha256=-5jMcjTu60YAvAO1UbqDD1GIEjVkwr8xCFwDBtMeYDg,787
+filelock/_soft.py,sha256=haqtc_TB_KJbYv2a8iuEAclKuM4fMG1vTcp28sK919c,1711
+filelock/_unix.py,sha256=eGOs4gDgZ-5fGnJUz-OkJDeZkAMzgvYcD8hVD6XH7e4,2351
+filelock/_util.py,sha256=QHBoNFIYfbAThhotH3Q8E2acFc84wpG49-T-uu017ZE,1715
+filelock/_windows.py,sha256=8k4XIBl_zZVfGC2gz0kEr8DZBvpNa8wdU9qeM1YrBb8,2179
+filelock/asyncio.py,sha256=dSLe6XZSECFOgsVpcQUSh5Y5zAHxHGPu_tfpPX9I45k,12514
+filelock/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+filelock/version.py,sha256=AW5MeEjK4TaQWWJrGb_AlBw8PlmFoIcn7GodG_AVSOM,706

.venv/lib/python3.12/site-packages/filelock-3.20.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

.venv/lib/python3.12/site-packages/filelock/__init__.py

@@ -0,0 +1,70 @@
+"""
+A platform independent file lock that supports the with-statement.
+
+.. autodata:: filelock.__version__
+   :no-value:
+
+"""
+
+from __future__ import annotations
+
+import sys
+import warnings
+from typing import TYPE_CHECKING
+
+from ._api import AcquireReturnProxy, BaseFileLock
+from ._error import Timeout
+from ._soft import SoftFileLock
+from ._unix import UnixFileLock, has_fcntl
+from ._windows import WindowsFileLock
+from .asyncio import (
+    AsyncAcquireReturnProxy,
+    AsyncSoftFileLock,
+    AsyncUnixFileLock,
+    AsyncWindowsFileLock,
+    BaseAsyncFileLock,
+)
+from .version import version
+
+#: version of the project as a string
+__version__: str = version
+
+
+if sys.platform == "win32":  # pragma: win32 cover
+    _FileLock: type[BaseFileLock] = WindowsFileLock
+    _AsyncFileLock: type[BaseAsyncFileLock] = AsyncWindowsFileLock
+else:  # pragma: win32 no cover # noqa: PLR5501
+    if has_fcntl:
+        _FileLock: type[BaseFileLock] = UnixFileLock
+        _AsyncFileLock: type[BaseAsyncFileLock] = AsyncUnixFileLock
+    else:
+        _FileLock = SoftFileLock
+        _AsyncFileLock = AsyncSoftFileLock
+        if warnings is not None:
+            warnings.warn("only soft file lock is available", stacklevel=2)
+
+if TYPE_CHECKING:
+    FileLock = SoftFileLock
+    AsyncFileLock = AsyncSoftFileLock
+else:
+    #: Alias for the lock, which should be used for the current platform.
+    FileLock = _FileLock
+    AsyncFileLock = _AsyncFileLock
+
+
+__all__ = [
+    "AcquireReturnProxy",
+    "AsyncAcquireReturnProxy",
+    "AsyncFileLock",
+    "AsyncSoftFileLock",
+    "AsyncUnixFileLock",
+    "AsyncWindowsFileLock",
+    "BaseAsyncFileLock",
+    "BaseFileLock",
+    "FileLock",
+    "SoftFileLock",
+    "Timeout",
+    "UnixFileLock",
+    "WindowsFileLock",
+    "__version__",
+]

.venv/lib/python3.12/site-packages/filelock/_error.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class Timeout(TimeoutError):  # noqa: N818
+    """Raised when the lock could not be acquired in *timeout* seconds."""
+
+    def __init__(self, lock_file: str) -> None:
+        super().__init__()
+        self._lock_file = lock_file
+
+    def __reduce__(self) -> str | tuple[Any, ...]:
+        return self.__class__, (self._lock_file,)  # Properly pickle the exception
+
+    def __str__(self) -> str:
+        return f"The file lock '{self._lock_file}' could not be acquired."
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.lock_file!r})"
+
+    @property
+    def lock_file(self) -> str:
+        """:return: The path of the file lock."""
+        return self._lock_file
+
+
+__all__ = [
+    "Timeout",
+]