@ai-ecoverse/py-pillow 12.3.0-2

package/lib/python3.14/site-packages/PIL/WebPImagePlugin.py

@@ -0,0 +1,322 @@
+from __future__ import annotations
+
+from io import BytesIO
+
+from . import Image, ImageFile
+
+try:
+    from . import _webp
+
+    SUPPORTED = True
+except ImportError:
+    SUPPORTED = False
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import IO, Any
+
+_VP8_MODES_BY_IDENTIFIER = {
+    b"VP8 ": "RGB",
+    b"VP8X": "RGBA",
+    b"VP8L": "RGBA",  # lossless
+}
+
+
+def _accept(prefix: bytes) -> bool | str:
+    is_riff_file_format = prefix.startswith(b"RIFF")
+    is_webp_file = prefix[8:12] == b"WEBP"
+    is_valid_vp8_mode = prefix[12:16] in _VP8_MODES_BY_IDENTIFIER
+
+    if is_riff_file_format and is_webp_file and is_valid_vp8_mode:
+        if not SUPPORTED:
+            return (
+                "image file could not be identified because WEBP support not installed"
+            )
+        return True
+    return False
+
+
+class WebPImageFile(ImageFile.ImageFile):
+    format = "WEBP"
+    format_description = "WebP image"
+    __loaded = 0
+    __logical_frame = 0
+
+    def _open(self) -> None:
+        assert self.fp is not None
+        s = self.fp.read()
+        if not _accept(s):
+            msg = "not a WEBP file"
+            raise SyntaxError(msg)
+
+        # Use the newer AnimDecoder API to parse the (possibly) animated file,
+        # and access muxed chunks like ICC/EXIF/XMP.
+        self._decoder = _webp.WebPAnimDecoder(s)
+
+        # Get info from decoder
+        self._size, self.info["loop"], bgcolor, self.n_frames, self.rawmode = (
+            self._decoder.get_info()
+        )
+        self.info["background"] = (
+            (bgcolor >> 16) & 0xFF,  # R
+            (bgcolor >> 8) & 0xFF,  # G
+            bgcolor & 0xFF,  # B
+            (bgcolor >> 24) & 0xFF,  # A
+        )
+        self.is_animated = self.n_frames > 1
+        self._mode = "RGB" if self.rawmode == "RGBX" else self.rawmode
+
+        # Attempt to read ICC / EXIF / XMP chunks from file
+        for key, chunk_name in {
+            "icc_profile": "ICCP",
+            "exif": "EXIF",
+            "xmp": "XMP ",
+        }.items():
+            if value := self._decoder.get_chunk(chunk_name):
+                self.info[key] = value
+
+        # Initialize seek state
+        self._reset(reset=False)
+
+    def _getexif(self) -> dict[int, Any] | None:
+        if "exif" not in self.info:
+            return None
+        return self.getexif()._get_merged_dict()
+
+    def seek(self, frame: int) -> None:
+        if not self._seek_check(frame):
+            return
+
+        # Set logical frame to requested position
+        self.__logical_frame = frame
+
+    def _reset(self, reset: bool = True) -> None:
+        if reset:
+            self._decoder.reset()
+        self.__physical_frame = 0
+        self.__loaded = -1
+        self.__timestamp = 0
+
+    def _get_next(self) -> tuple[bytes, int, int]:
+        # Get next frame
+        ret = self._decoder.get_next()
+        self.__physical_frame += 1
+
+        # Check if an error occurred
+        if ret is None:
+            self._reset()  # Reset just to be safe
+            self.seek(0)
+            msg = "failed to decode next frame in WebP file"
+            raise EOFError(msg)
+
+        # Compute duration
+        data, timestamp = ret
+        duration = timestamp - self.__timestamp
+        self.__timestamp = timestamp
+
+        # libwebp gives frame end, adjust to start of frame
+        timestamp -= duration
+        return data, timestamp, duration
+
+    def _seek(self, frame: int) -> None:
+        if self.__physical_frame == frame:
+            return  # Nothing to do
+        if frame < self.__physical_frame:
+            self._reset()  # Rewind to beginning
+        while self.__physical_frame < frame:
+            self._get_next()  # Advance to the requested frame
+
+    def load(self) -> Image.core.PixelAccess | None:
+        if self.__loaded != self.__logical_frame:
+            self._seek(self.__logical_frame)
+
+            # We need to load the image data for this frame
+            data, self.info["timestamp"], self.info["duration"] = self._get_next()
+            self.__loaded = self.__logical_frame
+
+            # Set tile
+            if self.fp and self._exclusive_fp:
+                self.fp.close()
+            self.fp = BytesIO(data)
+            self.tile = [ImageFile._Tile("raw", (0, 0) + self.size, 0, self.rawmode)]
+
+        return super().load()
+
+    def load_seek(self, pos: int) -> None:
+        pass
+
+    def tell(self) -> int:
+        return self.__logical_frame
+
+
+def _convert_frame(im: Image.Image) -> Image.Image:
+    # Make sure image mode is supported
+    if im.mode not in ("RGBX", "RGBA", "RGB"):
+        im = im.convert("RGBA" if im.has_transparency_data else "RGB")
+    return im
+
+
+def _save_all(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    encoderinfo = im.encoderinfo.copy()
+    append_images = list(encoderinfo.get("append_images", []))
+
+    # If total frame count is 1, then save using the legacy API, which
+    # will preserve non-alpha modes
+    total = 0
+    for ims in [im] + append_images:
+        total += getattr(ims, "n_frames", 1)
+    if total == 1:
+        _save(im, fp, filename)
+        return
+
+    background: int | tuple[int, ...] = (0, 0, 0, 0)
+    if "background" in encoderinfo:
+        background = encoderinfo["background"]
+    elif "background" in im.info:
+        background = im.info["background"]
+        if isinstance(background, int):
+            # GifImagePlugin stores a global color table index in
+            # info["background"]. So it must be converted to an RGBA value
+            palette = im.getpalette()
+            if palette:
+                r, g, b = palette[background * 3 : (background + 1) * 3]
+                background = (r, g, b, 255)
+            else:
+                background = (background, background, background, 255)
+
+    duration = im.encoderinfo.get("duration", im.info.get("duration", 0))
+    loop = im.encoderinfo.get("loop", 0)
+    minimize_size = im.encoderinfo.get("minimize_size", False)
+    kmin = im.encoderinfo.get("kmin", None)
+    kmax = im.encoderinfo.get("kmax", None)
+    allow_mixed = im.encoderinfo.get("allow_mixed", False)
+    verbose = False
+    lossless = im.encoderinfo.get("lossless", False)
+    quality = im.encoderinfo.get("quality", 80)
+    alpha_quality = im.encoderinfo.get("alpha_quality", 100)
+    method = im.encoderinfo.get("method", 0)
+    icc_profile = im.encoderinfo.get("icc_profile") or ""
+    exif = im.encoderinfo.get("exif", "")
+    if isinstance(exif, Image.Exif):
+        exif = exif.tobytes()
+    xmp = im.encoderinfo.get("xmp", "")
+    if allow_mixed:
+        lossless = False
+
+    # Sensible keyframe defaults are from gif2webp.c script
+    if kmin is None:
+        kmin = 9 if lossless else 3
+    if kmax is None:
+        kmax = 17 if lossless else 5
+
+    # Validate background color
+    if (
+        not isinstance(background, (list, tuple))
+        or len(background) != 4
+        or not all(0 <= v < 256 for v in background)
+    ):
+        msg = f"Background color is not an RGBA tuple clamped to (0-255): {background}"
+        raise OSError(msg)
+
+    # Convert to packed uint
+    bg_r, bg_g, bg_b, bg_a = background
+    background = (bg_a << 24) | (bg_r << 16) | (bg_g << 8) | (bg_b << 0)
+
+    # Setup the WebP animation encoder
+    enc = _webp.WebPAnimEncoder(
+        im.size,
+        background,
+        loop,
+        minimize_size,
+        kmin,
+        kmax,
+        allow_mixed,
+        verbose,
+    )
+
+    # Add each frame
+    frame_idx = 0
+    timestamp = 0
+    cur_idx = im.tell()
+    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)
+
+                frame = _convert_frame(ims)
+
+                # Append the frame to the animation encoder
+                enc.add(
+                    frame.getim(),
+                    round(timestamp),
+                    lossless,
+                    quality,
+                    alpha_quality,
+                    method,
+                )
+
+                # Update timestamp and frame index
+                if isinstance(duration, (list, tuple)):
+                    timestamp += duration[frame_idx]
+                else:
+                    timestamp += duration
+                frame_idx += 1
+
+    finally:
+        im.seek(cur_idx)
+
+    # Force encoder to flush frames
+    enc.add(None, round(timestamp), lossless, quality, alpha_quality, 0)
+
+    # Get the final output from the encoder
+    data = enc.assemble(icc_profile, exif, xmp)
+    if data is None:
+        msg = "cannot write file as WebP (encoder returned None)"
+        raise OSError(msg)
+
+    fp.write(data)
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    lossless = im.encoderinfo.get("lossless", False)
+    quality = im.encoderinfo.get("quality", 80)
+    alpha_quality = im.encoderinfo.get("alpha_quality", 100)
+    icc_profile = im.encoderinfo.get("icc_profile") or ""
+    exif = im.encoderinfo.get("exif", b"")
+    if isinstance(exif, Image.Exif):
+        exif = exif.tobytes()
+    if exif.startswith(b"Exif\x00\x00"):
+        exif = exif[6:]
+    xmp = im.encoderinfo.get("xmp", "")
+    method = im.encoderinfo.get("method", 4)
+    exact = 1 if im.encoderinfo.get("exact") else 0
+
+    im = _convert_frame(im)
+
+    data = _webp.WebPEncode(
+        im.getim(),
+        lossless,
+        float(quality),
+        float(alpha_quality),
+        icc_profile,
+        method,
+        exact,
+        exif,
+        xmp,
+    )
+    if data is None:
+        msg = "cannot write file as WebP (encoder returned None)"
+        raise OSError(msg)
+
+    fp.write(data)
+
+
+Image.register_open(WebPImageFile.format, WebPImageFile, _accept)
+if SUPPORTED:
+    Image.register_save(WebPImageFile.format, _save)
+    Image.register_save_all(WebPImageFile.format, _save_all)
+    Image.register_extension(WebPImageFile.format, ".webp")
+    Image.register_mime(WebPImageFile.format, "image/webp")

package/lib/python3.14/site-packages/PIL/WmfImagePlugin.py

@@ -0,0 +1,183 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# WMF stub codec
+#
+# history:
+# 1996-12-14 fl   Created
+# 2004-02-22 fl   Turned into a stub driver
+# 2004-02-23 fl   Added EMF support
+#
+# Copyright (c) Secret Labs AB 1997-2004.  All rights reserved.
+# Copyright (c) Fredrik Lundh 1996.
+#
+# See the README file for information on usage and redistribution.
+#
+# WMF/EMF reference documentation:
+# https://winprotocoldoc.blob.core.windows.net/productionwindowsarchives/MS-WMF/[MS-WMF].pdf
+# http://wvware.sourceforge.net/caolan/index.html
+# http://wvware.sourceforge.net/caolan/ora-wmf.html
+from __future__ import annotations
+
+from typing import IO
+
+from . import Image, ImageFile
+from ._binary import i16le as word
+from ._binary import si16le as short
+from ._binary import si32le as _long
+
+_handler = None
+
+
+def register_handler(handler: ImageFile.StubHandler | None) -> None:
+    """
+    Install application-specific WMF image handler.
+
+    :param handler: Handler object.
+    """
+    global _handler
+    _handler = handler
+
+
+if hasattr(Image.core, "drawwmf"):
+    # install default handler (windows only)
+
+    class WmfHandler(ImageFile.StubHandler):
+        def open(self, im: ImageFile.StubImageFile) -> None:
+            self.bbox = im.info["wmf_bbox"]
+
+        def load(self, im: ImageFile.StubImageFile) -> Image.Image:
+            assert im.fp is not None
+            im.fp.seek(0)  # rewind
+            return Image.frombytes(
+                "RGB",
+                im.size,
+                Image.core.drawwmf(im.fp.read(), im.size, self.bbox),
+                "raw",
+                "BGR",
+                (im.size[0] * 3 + 3) & -4,
+                -1,
+            )
+
+    register_handler(WmfHandler())
+
+#
+# --------------------------------------------------------------------
+# Read WMF file
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix.startswith((b"\xd7\xcd\xc6\x9a\x00\x00", b"\x01\x00\x00\x00"))
+
+
+##
+# Image plugin for Windows metafiles.
+
+
+class WmfStubImageFile(ImageFile.StubImageFile):
+    format = "WMF"
+    format_description = "Windows Metafile"
+
+    def _open(self) -> None:
+        # check placeable header
+        assert self.fp is not None
+        s = self.fp.read(44)
+
+        if s.startswith(b"\xd7\xcd\xc6\x9a\x00\x00"):
+            # placeable windows metafile
+
+            # get units per inch
+            inch = word(s, 14)
+            if inch == 0:
+                msg = "Invalid inch"
+                raise ValueError(msg)
+            self._inch: tuple[float, float] = inch, inch
+
+            # get bounding box
+            x0 = short(s, 6)
+            y0 = short(s, 8)
+            x1 = short(s, 10)
+            y1 = short(s, 12)
+
+            # normalize size to 72 dots per inch
+            self.info["dpi"] = 72
+            size = (
+                (x1 - x0) * self.info["dpi"] // inch,
+                (y1 - y0) * self.info["dpi"] // inch,
+            )
+
+            self.info["wmf_bbox"] = x0, y0, x1, y1
+
+            # sanity check (standard metafile header)
+            if s[22:26] != b"\x01\x00\t\x00":
+                msg = "Unsupported WMF file format"
+                raise SyntaxError(msg)
+
+        elif s.startswith(b"\x01\x00\x00\x00") and s[40:44] == b" EMF":
+            # enhanced metafile
+
+            # get bounding box
+            x0 = _long(s, 8)
+            y0 = _long(s, 12)
+            x1 = _long(s, 16)
+            y1 = _long(s, 20)
+
+            # get frame (in 0.01 millimeter units)
+            frame = _long(s, 24), _long(s, 28), _long(s, 32), _long(s, 36)
+
+            size = x1 - x0, y1 - y0
+
+            # calculate dots per inch from bbox and frame
+            xdpi = 2540.0 * (x1 - x0) / (frame[2] - frame[0])
+            ydpi = 2540.0 * (y1 - y0) / (frame[3] - frame[1])
+
+            self.info["wmf_bbox"] = x0, y0, x1, y1
+
+            if xdpi == ydpi:
+                self.info["dpi"] = xdpi
+            else:
+                self.info["dpi"] = xdpi, ydpi
+            self._inch = xdpi, ydpi
+
+        else:
+            msg = "Unsupported file format"
+            raise SyntaxError(msg)
+
+        self._mode = "RGB"
+        self._size = size
+
+    def _load(self) -> ImageFile.StubHandler | None:
+        return _handler
+
+    def load(
+        self, dpi: float | tuple[float, float] | None = None
+    ) -> Image.core.PixelAccess | None:
+        if dpi is not None:
+            self.info["dpi"] = dpi
+            x0, y0, x1, y1 = self.info["wmf_bbox"]
+            if not isinstance(dpi, tuple):
+                dpi = dpi, dpi
+            self._size = (
+                int((x1 - x0) * dpi[0] / self._inch[0]),
+                int((y1 - y0) * dpi[1] / self._inch[1]),
+            )
+        return super().load()
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    if _handler is None or not hasattr(_handler, "save"):
+        msg = "WMF save handler not installed"
+        raise OSError(msg)
+    _handler.save(im, fp, filename)
+
+
+#
+# --------------------------------------------------------------------
+# Registry stuff
+
+
+Image.register_open(WmfStubImageFile.format, WmfStubImageFile, _accept)
+Image.register_save(WmfStubImageFile.format, _save)
+
+Image.register_extensions(WmfStubImageFile.format, [".wmf", ".emf"])

package/lib/python3.14/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)
+        w, h = s.strip().split(maxsplit=2)[:2]
+
+        self._mode = "P"
+        self._size = int(w), int(h)
+
+        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)

package/lib/python3.14/site-packages/PIL/XbmImagePlugin.py

@@ -0,0 +1,98 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# XBM File handling
+#
+# History:
+# 1995-09-08 fl   Created
+# 1996-11-01 fl   Added save support
+# 1997-07-07 fl   Made header parser more tolerant
+# 1997-07-22 fl   Fixed yet another parser bug
+# 2001-02-17 fl   Use 're' instead of 'regex' (Python 2.1) (0.4)
+# 2001-05-13 fl   Added hotspot handling (based on code from Bernhard Herzog)
+# 2004-02-24 fl   Allow some whitespace before first #define
+#
+# Copyright (c) 1997-2004 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 re
+from typing import IO
+
+from . import Image, ImageFile
+
+# XBM header
+xbm_head = re.compile(
+    rb"\s*#define[ \t]+.*_width[ \t]+(?P<width>[0-9]+)[\r\n]+"
+    b"#define[ \t]+.*_height[ \t]+(?P<height>[0-9]+)[\r\n]+"
+    b"(?P<hotspot>"
+    b"#define[ \t]+[^_]*_x_hot[ \t]+(?P<xhot>[0-9]+)[\r\n]+"
+    b"#define[ \t]+[^_]*_y_hot[ \t]+(?P<yhot>[0-9]+)[\r\n]+"
+    b")?"
+    rb"[\000-\377]*_bits\[]"
+)
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix.lstrip().startswith(b"#define")
+
+
+##
+# Image plugin for X11 bitmaps.
+
+
+class XbmImageFile(ImageFile.ImageFile):
+    format = "XBM"
+    format_description = "X11 Bitmap"
+
+    def _open(self) -> None:
+        assert self.fp is not None
+
+        m = xbm_head.match(self.fp.read(512))
+
+        if not m:
+            msg = "not a XBM file"
+            raise SyntaxError(msg)
+
+        xsize = int(m.group("width"))
+        ysize = int(m.group("height"))
+
+        if m.group("hotspot"):
+            self.info["hotspot"] = (int(m.group("xhot")), int(m.group("yhot")))
+
+        self._mode = "1"
+        self._size = xsize, ysize
+
+        self.tile = [ImageFile._Tile("xbm", (0, 0) + self.size, m.end())]
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    if im.mode != "1":
+        msg = f"cannot write mode {im.mode} as XBM"
+        raise OSError(msg)
+
+    fp.write(f"#define im_width {im.size[0]}\n".encode("ascii"))
+    fp.write(f"#define im_height {im.size[1]}\n".encode("ascii"))
+
+    hotspot = im.encoderinfo.get("hotspot")
+    if hotspot:
+        fp.write(f"#define im_x_hot {hotspot[0]}\n".encode("ascii"))
+        fp.write(f"#define im_y_hot {hotspot[1]}\n".encode("ascii"))
+
+    fp.write(b"static char im_bits[] = {\n")
+
+    ImageFile._save(im, fp, [ImageFile._Tile("xbm", (0, 0) + im.size)])
+
+    fp.write(b"};\n")
+
+
+Image.register_open(XbmImageFile.format, XbmImageFile, _accept)
+Image.register_save(XbmImageFile.format, _save)
+
+Image.register_extension(XbmImageFile.format, ".xbm")
+
+Image.register_mime(XbmImageFile.format, "image/xbm")