@ai-ecoverse/py-pillow 12.3.0-2

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

@@ -0,0 +1,234 @@
+#
+# 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,
+    *,
+    scale_down: bool = False,
+) -> Image.Image:
+    im: Image.Image
+    if xdisplay is None:
+        if sys.platform == "darwin":
+            fh, filepath = tempfile.mkstemp(".png")
+            os.close(fh)
+            args = ["screencapture"]
+            if window is not None:
+                args += ["-l", str(window)]
+            elif bbox:
+                left, top, right, bottom = bbox
+                args += ["-R", f"{left},{top},{right-left},{bottom-top}"]
+            args += ["-x", filepath]
+            retcode = subprocess.call(args)
+            if retcode:
+                raise subprocess.CalledProcessError(retcode, args)
+            im = Image.open(filepath)
+            im.load()
+            os.unlink(filepath)
+            if bbox:
+                if window is not None:
+                    # Determine if the window was in Retina mode or not
+                    # by capturing it without the shadow,
+                    # and checking how different the width is
+                    fh, filepath = tempfile.mkstemp(".png")
+                    os.close(fh)
+                    args = ["screencapture", "-l", str(window), "-o", "-x", filepath]
+                    retcode = subprocess.call(args)
+                    if retcode:
+                        raise subprocess.CalledProcessError(retcode, args)
+                    with Image.open(filepath) as im_no_shadow:
+                        retina = im.width - im_no_shadow.width > 100
+                    os.unlink(filepath)
+
+                    # Since screencapture's -R does not work with -l,
+                    # crop the image manually
+                    if retina:
+                        left, top, right, bottom = bbox
+                        scale = 1 if scale_down else 2
+                        im_cropped = im.resize(
+                            ((right - left) * scale, (bottom - top) * scale),
+                            box=tuple(coord * 2 for coord in bbox),
+                        )
+                    else:
+                        im_cropped = im.crop(bbox)
+                    im.close()
+                    return im_cropped
+                elif scale_down:
+                    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)
+            args.append(filepath)
+            retcode = subprocess.call(args)
+            if retcode:
+                raise subprocess.CalledProcessError(retcode, args)
+            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

package/lib/python3.14/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, None, args)
+    try:
+        return out.im
+    except AttributeError:
+        return out

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

@@ -0,0 +1,85 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# standard mode descriptors
+#
+# History:
+# 2006-03-20 fl   Added
+#
+# 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 functools import lru_cache
+from typing import NamedTuple
+
+
+class ModeDescriptor(NamedTuple):
+    """Wrapper for mode strings."""
+
+    mode: str
+    bands: tuple[str, ...]
+    basemode: str
+    basetype: str
+    typestr: str
+
+    def __str__(self) -> str:
+        return self.mode
+
+
+@lru_cache
+def getmode(mode: str) -> ModeDescriptor:
+    """Gets a mode descriptor for the given mode."""
+    endian = "<" if sys.byteorder == "little" else ">"
+
+    modes = {
+        # core modes
+        # Bits need to be extended to bytes
+        "1": ("L", "L", ("1",), "|b1"),
+        "L": ("L", "L", ("L",), "|u1"),
+        "I": ("L", "I", ("I",), f"{endian}i4"),
+        "F": ("L", "F", ("F",), f"{endian}f4"),
+        "P": ("P", "L", ("P",), "|u1"),
+        "RGB": ("RGB", "L", ("R", "G", "B"), "|u1"),
+        "RGBX": ("RGB", "L", ("R", "G", "B", "X"), "|u1"),
+        "RGBA": ("RGB", "L", ("R", "G", "B", "A"), "|u1"),
+        "CMYK": ("RGB", "L", ("C", "M", "Y", "K"), "|u1"),
+        "YCbCr": ("RGB", "L", ("Y", "Cb", "Cr"), "|u1"),
+        # UNDONE - unsigned |u1i1i1
+        "LAB": ("RGB", "L", ("L", "A", "B"), "|u1"),
+        "HSV": ("RGB", "L", ("H", "S", "V"), "|u1"),
+        # extra experimental modes
+        "RGBa": ("RGB", "L", ("R", "G", "B", "a"), "|u1"),
+        "LA": ("L", "L", ("L", "A"), "|u1"),
+        "La": ("L", "L", ("L", "a"), "|u1"),
+        "PA": ("RGB", "L", ("P", "A"), "|u1"),
+    }
+    if mode in modes:
+        base_mode, base_type, bands, type_str = modes[mode]
+        return ModeDescriptor(mode, bands, base_mode, base_type, type_str)
+
+    mapping_modes = {
+        # I;16 == I;16L, and I;32 == I;32L
+        "I;16": "<u2",
+        "I;16S": "<i2",
+        "I;16L": "<u2",
+        "I;16LS": "<i2",
+        "I;16B": ">u2",
+        "I;16BS": ">i2",
+        "I;16N": f"{endian}u2",
+        "I;16NS": f"{endian}i2",
+        "I;32": "<u4",
+        "I;32B": ">u4",
+        "I;32L": "<u4",
+        "I;32S": "<i4",
+        "I;32BS": ">i4",
+        "I;32LS": "<i4",
+    }
+
+    type_str = mapping_modes[mode]
+    return ModeDescriptor(mode, ("I",), "L", "L", type_str)