@tushar-br/desktop 1.0.283 → 1.0.284

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

@@ -1,287 +0,0 @@
-#
-# 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) // len(self.mode)
-        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
-                mode_len = len(self.mode)
-                if index * mode_len < len(self.palette):
-                    self._palette = (
-                        self._palette[: index * mode_len]
-                        + bytes(color)
-                        + self._palette[index * mode_len + mode_len :]
-                    )
-                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

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

@@ -1,20 +0,0 @@
-#
-# 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

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

@@ -1,219 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# a simple Qt image interface.
-#
-# history:
-# 2006-06-03 fl: created
-# 2006-06-04 fl: inherit from QImage instead of wrapping it
-# 2006-06-05 fl: removed toimage helper; move string support to ImageQt
-# 2013-11-13 fl: add support for Qt5 (aurelien.ballier@cyclonit.com)
-#
-# Copyright (c) 2006 by Secret Labs AB
-# Copyright (c) 2006 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-from __future__ import annotations
-
-import sys
-from io import BytesIO
-
-from . import Image
-from ._util import is_path
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from collections.abc import Callable
-    from typing import Any
-
-    from . import ImageFile
-
-    QBuffer: type
-
-qt_version: str | None
-qt_versions = [
-    ["6", "PyQt6"],
-    ["side6", "PySide6"],
-]
-
-# If a version has already been imported, attempt it first
-qt_versions.sort(key=lambda version: version[1] in sys.modules, reverse=True)
-for version, qt_module in qt_versions:
-    try:
-        qRgba: Callable[[int, int, int, int], int]
-        if qt_module == "PyQt6":
-            from PyQt6.QtCore import QBuffer, QByteArray, QIODevice
-            from PyQt6.QtGui import QImage, QPixmap, qRgba
-        elif qt_module == "PySide6":
-            from PySide6.QtCore import (  # type: ignore[assignment]
-                QBuffer,
-                QByteArray,
-                QIODevice,
-            )
-            from PySide6.QtGui import QImage, QPixmap, qRgba  # type: ignore[assignment]
-    except (ImportError, RuntimeError):
-        continue
-    qt_is_installed = True
-    qt_version = version
-    break
-else:
-    qt_is_installed = False
-    qt_version = None
-
-
-def rgb(r: int, g: int, b: int, a: int = 255) -> int:
-    """(Internal) Turns an RGB color into a Qt compatible color integer."""
-    # use qRgb to pack the colors, and then turn the resulting long
-    # into a negative integer with the same bitpattern.
-    return qRgba(r, g, b, a) & 0xFFFFFFFF
-
-
-def fromqimage(im: QImage | QPixmap) -> ImageFile.ImageFile:
-    """
-    :param im: QImage or PIL ImageQt object
-    """
-    buffer = QBuffer()
-    qt_openmode: object
-    if qt_version == "6":
-        try:
-            qt_openmode = getattr(QIODevice, "OpenModeFlag")
-        except AttributeError:
-            qt_openmode = getattr(QIODevice, "OpenMode")
-    else:
-        qt_openmode = QIODevice
-    buffer.open(getattr(qt_openmode, "ReadWrite"))
-    # preserve alpha channel with png
-    # otherwise ppm is more friendly with Image.open
-    if im.hasAlphaChannel():
-        im.save(buffer, "png")
-    else:
-        im.save(buffer, "ppm")
-
-    b = BytesIO()
-    b.write(buffer.data())
-    buffer.close()
-    b.seek(0)
-
-    return Image.open(b)
-
-
-def fromqpixmap(im: QPixmap) -> ImageFile.ImageFile:
-    return fromqimage(im)
-
-
-def align8to32(bytes: bytes, width: int, mode: str) -> bytes:
-    """
-    converts each scanline of data from 8 bit to 32 bit aligned
-    """
-
-    bits_per_pixel = {"1": 1, "L": 8, "P": 8, "I;16": 16}[mode]
-
-    # calculate bytes per line and the extra padding if needed
-    bits_per_line = bits_per_pixel * width
-    full_bytes_per_line, remaining_bits_per_line = divmod(bits_per_line, 8)
-    bytes_per_line = full_bytes_per_line + (1 if remaining_bits_per_line else 0)
-
-    extra_padding = -bytes_per_line % 4
-
-    # already 32 bit aligned by luck
-    if not extra_padding:
-        return bytes
-
-    new_data = [
-        bytes[i * bytes_per_line : (i + 1) * bytes_per_line] + b"\x00" * extra_padding
-        for i in range(len(bytes) // bytes_per_line)
-    ]
-
-    return b"".join(new_data)
-
-
-def _toqclass_helper(im: Image.Image | str | QByteArray) -> dict[str, Any]:
-    data = None
-    colortable = None
-    exclusive_fp = False
-
-    # handle filename, if given instead of image name
-    if hasattr(im, "toUtf8"):
-        # FIXME - is this really the best way to do this?
-        im = str(im.toUtf8(), "utf-8")
-    if is_path(im):
-        im = Image.open(im)
-        exclusive_fp = True
-    assert isinstance(im, Image.Image)
-
-    qt_format = getattr(QImage, "Format") if qt_version == "6" else QImage
-    if im.mode == "1":
-        format = getattr(qt_format, "Format_Mono")
-    elif im.mode == "L":
-        format = getattr(qt_format, "Format_Indexed8")
-        colortable = [rgb(i, i, i) for i in range(256)]
-    elif im.mode == "P":
-        format = getattr(qt_format, "Format_Indexed8")
-        palette = im.getpalette()
-        assert palette is not None
-        colortable = [rgb(*palette[i : i + 3]) for i in range(0, len(palette), 3)]
-    elif im.mode == "RGB":
-        # Populate the 4th channel with 255
-        im = im.convert("RGBA")
-
-        data = im.tobytes("raw", "BGRA")
-        format = getattr(qt_format, "Format_RGB32")
-    elif im.mode == "RGBA":
-        data = im.tobytes("raw", "BGRA")
-        format = getattr(qt_format, "Format_ARGB32")
-    elif im.mode == "I;16":
-        im = im.point(lambda i: i * 256)
-
-        format = getattr(qt_format, "Format_Grayscale16")
-    else:
-        if exclusive_fp:
-            im.close()
-        msg = f"unsupported image mode {repr(im.mode)}"
-        raise ValueError(msg)
-
-    size = im.size
-    __data = data or align8to32(im.tobytes(), size[0], im.mode)
-    if exclusive_fp:
-        im.close()
-    return {"data": __data, "size": size, "format": format, "colortable": colortable}
-
-
-if qt_is_installed:
-
-    class ImageQt(QImage):
-        def __init__(self, im: Image.Image | str | QByteArray) -> None:
-            """
-            An PIL image wrapper for Qt.  This is a subclass of PyQt's QImage
-            class.
-
-            :param im: A PIL Image object, or a file name (given either as
-                Python string or a PyQt string object).
-            """
-            im_data = _toqclass_helper(im)
-            # must keep a reference, or Qt will crash!
-            # All QImage constructors that take data operate on an existing
-            # buffer, so this buffer has to hang on for the life of the image.
-            # Fixes https://github.com/python-pillow/Pillow/issues/1370
-            self.__data = im_data["data"]
-            super().__init__(
-                self.__data,
-                im_data["size"][0],
-                im_data["size"][1],
-                im_data["format"],
-            )
-            if im_data["colortable"]:
-                self.setColorTable(im_data["colortable"])
-
-
-def toqimage(im: Image.Image | str | QByteArray) -> ImageQt:
-    return ImageQt(im)
-
-
-def toqpixmap(im: Image.Image | str | QByteArray) -> QPixmap:
-    qimage = toqimage(im)
-    pixmap = getattr(QPixmap, "fromImage")(qimage)
-    if qt_version == "6":
-        pixmap.detach()
-    return pixmap

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

@@ -1,88 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# sequence support classes
-#
-# history:
-# 1997-02-20 fl     Created
-#
-# Copyright (c) 1997 by Secret Labs AB.
-# Copyright (c) 1997 by Fredrik Lundh.
-#
-# See the README file for information on usage and redistribution.
-#
-
-##
-from __future__ import annotations
-
-from . import Image
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-
-class Iterator:
-    """
-    This class implements an iterator object that can be used to loop
-    over an image sequence.
-
-    You can use the ``[]`` operator to access elements by index. This operator
-    will raise an :py:exc:`IndexError` if you try to access a nonexistent
-    frame.
-
-    :param im: An image object.
-    """
-
-    def __init__(self, im: Image.Image) -> None:
-        if not hasattr(im, "seek"):
-            msg = "im must have seek method"
-            raise AttributeError(msg)
-        self.im = im
-        self.position = getattr(self.im, "_min_frame", 0)
-
-    def __getitem__(self, ix: int) -> Image.Image:
-        try:
-            self.im.seek(ix)
-            return self.im
-        except EOFError as e:
-            msg = "end of sequence"
-            raise IndexError(msg) from e
-
-    def __iter__(self) -> Iterator:
-        return self
-
-    def __next__(self) -> Image.Image:
-        try:
-            self.im.seek(self.position)
-            self.position += 1
-            return self.im
-        except EOFError as e:
-            msg = "end of sequence"
-            raise StopIteration(msg) from e
-
-
-def all_frames(
-    im: Image.Image | list[Image.Image],
-    func: Callable[[Image.Image], Image.Image] | None = None,
-) -> list[Image.Image]:
-    """
-    Applies a given function to all frames in an image or a list of images.
-    The frames are returned as a list of separate images.
-
-    :param im: An image, or a list of images.
-    :param func: The function to apply to all of the image frames.
-    :returns: A list of images.
-    """
-    if not isinstance(im, list):
-        im = [im]
-
-    ims = []
-    for imSequence in im:
-        current = imSequence.tell()
-
-        ims += [im_frame.copy() for im_frame in Iterator(imSequence)]
-
-        imSequence.seek(current)
-    return [func(im) for im in ims] if func else ims