@tushar-br/desktop 1.0.283 → 1.0.285

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/PIL/WebPImagePlugin.py

@@ -1,317 +0,0 @@
-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:
-        # Use the newer AnimDecoder API to parse the (possibly) animated file,
-        # and access muxed chunks like ICC/EXIF/XMP.
-        assert self.fp is not None
-        self._decoder = _webp.WebPAnimDecoder(self.fp.read())
-
-        # 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/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/PIL/WmfImagePlugin.py

@@ -1,188 +0,0 @@
-#
-# 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:
-            im._mode = "RGB"
-            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
-
-        loader = self._load()
-        if loader:
-            loader.open(self)
-
-    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/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/PIL/XVThumbImagePlugin.py

@@ -1,83 +0,0 @@
-#
-# 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/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/PIL/XbmImagePlugin.py

@@ -1,98 +0,0 @@
-#
-# 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")