diff --git a/stubs/Pillow/METADATA.toml b/stubs/Pillow/METADATA.toml new file mode 100644 index 000000000..0d4c0a4bd --- /dev/null +++ b/stubs/Pillow/METADATA.toml @@ -0,0 +1 @@ +version = "8.2" diff --git a/stubs/Pillow/PIL/Image.pyi b/stubs/Pillow/PIL/Image.pyi new file mode 100644 index 000000000..bb9e72816 --- /dev/null +++ b/stubs/Pillow/PIL/Image.pyi @@ -0,0 +1,239 @@ +from _typeshed import SupportsRead, SupportsWrite +from collections.abc import Iterable, Iterator, MutableMapping +from pathlib import Path +from typing import Any, Dict, Protocol, Tuple, Union +from typing_extensions import Literal + +from ._imaging import ( + DEFAULT_STRATEGY as DEFAULT_STRATEGY, + FILTERED as FILTERED, + FIXED as FIXED, + HUFFMAN_ONLY as HUFFMAN_ONLY, + RLE as RLE, +) + +_Mode = Literal["1", "CMYK", "F", "HSV", "I", "L", "LAB", "P", "RGB", "RGBA", "RGBX", "YCbCr"] +_Resample = Literal[0, 1, 2, 3, 4, 5] + +_ConversionMatrix = Union[ + Tuple[float, float, float, float], Tuple[float, float, float, float, float, float, float, float, float, float, float, float], +] +_Color = Union[float, Tuple[float, ...]] + +class _Writeable(SupportsWrite[bytes], Protocol): + def seek(self, __offset: int) -> Any: ... + +# obsolete +NORMAL: Literal[0] +SEQUENCE: Literal[1] +CONTAINER: Literal[2] + +class DecompressionBombWarning(RuntimeWarning): ... +class DecompressionBombError(Exception): ... + +MAX_IMAGE_PIXELS: int + +NONE: Literal[0] + +FLIP_LEFT_RIGHT: Literal[0] +FLIP_TOP_BOTTOM: Literal[1] +ROTATE_90: Literal[2] +ROTATE_180: Literal[3] +ROTATE_270: Literal[4] +TRANSPOSE: Literal[5] +TRANSVERSE: Literal[6] + +AFFINE: Literal[0] +EXTENT: Literal[1] +PERSPECTIVE: Literal[2] +QUAD: Literal[3] +MESH: Literal[4] + +NEAREST: Literal[0] +BOX: Literal[4] +BILINEAR: Literal[2] +LINEAR: Literal[2] +HAMMING: Literal[5] +BICUBIC: Literal[3] +CUBIC: Literal[3] +LANCZOS: Literal[1] +ANTIALIAS: Literal[1] + +ORDERED: Literal[1] +RASTERIZE: Literal[2] +FLOYDSTEINBERG: Literal[3] + +WEB: Literal[0] +ADAPTIVE: Literal[1] + +MEDIANCUT: Literal[0] +MAXCOVERAGE: Literal[1] +FASTOCTREE: Literal[2] +LIBIMAGEQUANT: Literal[3] + +ID: list[str] +OPEN: dict[str, Any] +MIME: dict[str, str] +SAVE: dict[str, Any] +SAVE_ALL: dict[str, Any] +EXTENSION: dict[str, str] +DECODERS: dict[str, Any] +ENCODERS: dict[str, Any] + +MODES: list[_Mode] + +def getmodebase(mode: _Mode) -> Literal["L", "RGB"]: ... +def getmodetype(mode: _Mode) -> Literal["L", "I", "F"]: ... +def getmodebandnames(mode: _Mode) -> Tuple[str, ...]: ... +def getmodebands(mode: _Mode) -> int: ... +def preinit() -> None: ... +def init() -> None: ... +def coerce_e(value) -> _E: ... + +class _E: + def __init__(self, data) -> None: ... + def __add__(self, other) -> _E: ... + def __mul__(self, other) -> _E: ... + +_ImageState = Tuple[Dict[str, Any], str, Tuple[int, int], Any, bytes] + +class Image: + format: Any + format_description: Any + im: Any + mode: str + palette: Any + info: dict[Any, Any] + readonly: int + pyaccess: Any + @property + def category(self) -> int: ... # obsolete + @property + def width(self) -> int: ... + @property + def height(self) -> int: ... + @property + def size(self) -> tuple[int, int]: ... + def __enter__(self) -> Image: ... + def __exit__(self, *args: Any) -> None: ... + def close(self) -> None: ... + def __eq__(self, other: object) -> bool: ... + @property + def __array_interface__(self) -> dict[str, Any]: ... + def __getstate__(self) -> _ImageState: ... + def __setstate__(self, state: _ImageState) -> None: ... + def tobytes(self, encoder_name: str = ..., *args) -> bytes: ... + def tobitmap(self, name: str = ...) -> bytes: ... + def frombytes(self, data: bytes, decoder_name: str = ..., *args) -> None: ... + def load(self): ... + def verify(self) -> None: ... + def convert( + self, + mode: str | None = ..., + matrix: _ConversionMatrix | None = ..., + dither: int | None = ..., + palette: Literal[0, 1] = ..., + colors: int = ..., + ) -> Image: ... + def quantize( + self, + colors: int = ..., + method: Literal[0, 1, 2, 3] | None = ..., + kmeans: int = ..., + palette: Image | None = ..., + dither: int = ..., + ) -> Image: ... + def copy(self) -> Image: ... + __copy__ = copy + def crop(self, box=...) -> Image: ... + def draft(self, mode, size) -> None: ... + def filter(self, filter): ... + def getbands(self) -> Tuple[str, ...]: ... + def getbbox(self) -> tuple[int, int, int, int] | None: ... + def getcolors(self, maxcolors: int = ...): ... + def getdata(self, band=...): ... + def getextrema(self): ... + def getexif(self) -> Exif: ... + def getim(self): ... + def getpalette(self): ... + def getpixel(self, xy): ... + def getprojection(self): ... + def histogram(self, mask=..., extrema=...): ... + def entropy(self, mask=..., extrema=...): ... + def paste( + self, im: Image, box: tuple[float, float] | tuple[float, float, float, float] | None = ..., mask: Image | None = ... + ) -> None: ... + def alpha_composite(self, im: Image, dest: tuple[int, int] = ..., source: tuple[int, int] = ...) -> None: ... + def point(self, lut, mode=...): ... + def putalpha(self, alpha): ... + def putdata(self, data, scale: float = ..., offset: float = ...): ... + def putpalette(self, data, rawmode=...): ... + def putpixel(self, xy, value): ... + def remap_palette(self, dest_map, source_palette=...): ... + def resize( + self, size: tuple[int, int], resample: _Resample = ..., box: tuple[float, float, float, float] | None = ... + ) -> Image: ... + def reduce(self, factor, box=...): ... + def rotate( + self, + angle: float, + resample: _Resample = ..., + expand: bool = ..., + center: tuple[float, float] | None = ..., + translate: tuple[float, float] | None = ..., + fillcolor: _Color | None = ..., + ) -> Image: ... + def save(self, fp: str | bytes | Path | _Writeable, format: str | None = ..., **params: Any) -> None: ... + def seek(self, frame): ... + def show(self, title=..., command=...): ... + def split(self): ... + def getchannel(self, channel): ... + def tell(self) -> int: ... + def thumbnail(self, size: tuple[int, int], resample: _Resample = ..., reducing_gap: float = ...) -> None: ... + def transform( + self, size, method: Literal[0, 1, 2, 3, 4], data=..., resample: _Resample = ..., fill: int = ..., fillcolor=... + ) -> None: ... + def transpose(self, method: Literal[0, 1, 2, 3, 4, 5, 6]): ... + def effect_spread(self, distance): ... + def toqimage(self): ... + def toqpixmap(self): ... + +class ImagePointHandler: ... +class ImageTransformHandler: ... + +def new(mode: _Mode, size: tuple[int, int], color: float | Tuple[float, ...] = ...) -> Image: ... +def frombytes(mode: _Mode, size: tuple[int, int], data, decoder_name: str = ..., *args) -> Image: ... +def frombuffer(mode: _Mode, size: tuple[int, int], data, decoder_name: str = ..., *args) -> Image: ... +def fromarray(obj, mode: _Mode = ...) -> Image: ... +def fromqimage(im) -> Image: ... +def fromqpixmap(im) -> Image: ... +def open(fp: str | bytes | Path | SupportsRead[bytes], mode: _Mode = ..., formats=...) -> Image: ... +def alpha_composite(im1: Image, im2: Image) -> Image: ... +def blend(im1: Image, im2: Image, alpha) -> Image: ... +def composite(image1: Image, image2: Image, mask) -> Image: ... +def eval(image: Image, *args): ... +def merge(mode, bands): ... +def register_open(id: str, factory, accept=...) -> None: ... +def register_mime(id: str, mimetype: str) -> None: ... +def register_save(id: str, driver) -> None: ... +def register_save_all(id: str, driver) -> None: ... +def register_extension(id: str, extension: str) -> None: ... +def register_extensions(id: str, extensions: Iterable[str]) -> None: ... +def registered_extensions() -> dict[str, str]: ... +def register_decoder(name: str, decoder) -> None: ... +def register_encoder(name: str, encoder) -> None: ... +def effect_mandelbrot(size: tuple[int, int], extent, quality) -> Image: ... +def effect_noise(size: tuple[int, int], sigma) -> Image: ... +def linear_gradient(mode) -> Image: ... +def radial_gradient(mode) -> Image: ... + +class Exif(MutableMapping[int, Any]): + def load(self, data: bytes) -> None: ... + def tobytes(self, offset: int = ...) -> bytes: ... + def get_ifd(self, tag: int): ... + def __len__(self) -> int: ... + def __getitem__(self, tag: int): ... + def __contains__(self, tag: object) -> bool: ... + def __setitem__(self, tag: int, value) -> None: ... + def __delitem__(self, tag: int) -> None: ... + def __iter__(self) -> Iterator[int]: ... diff --git a/stubs/Pillow/PIL/ImageDraw.pyi b/stubs/Pillow/PIL/ImageDraw.pyi new file mode 100644 index 000000000..374c509c6 --- /dev/null +++ b/stubs/Pillow/PIL/ImageDraw.pyi @@ -0,0 +1,148 @@ +from collections.abc import Container +from typing import Any, Tuple, Union, overload +from typing_extensions import Literal + +from .Image import Image +from .ImageFont import _Font + +_Ink = Union[str, Tuple[int, int, int]] + +class ImageDraw: + def __init__(self, im: Image, mode: str | None = ...) -> None: ... + def getfont(self): ... + def arc(self, xy, start, end, fill: _Ink | None = ..., width: float = ...) -> None: ... + def bitmap(self, xy, bitmap, fill: _Ink | None = ...) -> None: ... + def chord(self, xy, start, end, fill: _Ink | None = ..., outline: _Ink | None = ..., width: float = ...) -> None: ... + def ellipse(self, xy, fill: _Ink | None = ..., outline: _Ink | None = ..., width: float = ...) -> None: ... + def line(self, xy, fill: _Ink | None = ..., width: float = ..., joint=...) -> None: ... + def shape(self, shape, fill: _Ink | None = ..., outline: _Ink | None = ...) -> None: ... + def pieslice( + self, + xy: tuple[tuple[float, float], tuple[float, float]], + start: float, + end: float, + fill: _Ink | None = ..., + outline: _Ink | None = ..., + width: float = ..., + ) -> None: ... + def point(self, xy, fill: _Ink | None = ...) -> None: ... + def polygon(self, xy, fill: _Ink | None = ..., outline: _Ink | None = ...) -> None: ... + def regular_polygon( + self, bounding_circle, n_sides: int, rotation: float = ..., fill: _Ink | None = ..., outline: _Ink | None = ... + ): ... + def rectangle( + self, + xy: tuple[float, float, float, float] | tuple[tuple[float, float], tuple[float, float]], + fill: _Ink | None = ..., + outline: _Ink | None = ..., + width: float = ..., + ) -> None: ... + def rounded_rectangle( + self, + xy: tuple[float, float, float, float] | tuple[tuple[float, float], tuple[float, float]], + radius: float = ..., + fill: _Ink | None = ..., + outline: _Ink | None = ..., + width: float = ..., + ) -> None: ... + def text( + self, + xy: tuple[float, float], + text: str | bytes, + fill: _Ink | None = ..., + font: _Font | None = ..., + anchor=..., + spacing: float = ..., + align: Literal["left", "center", "right"] = ..., + direction: Literal["rtl", "ltr", "ttb"] | None = ..., + features=..., + language: str | None = ..., + stroke_width: float = ..., + stroke_fill: _Ink | None = ..., + embedded_color: bool = ..., + *args, + **kwargs, + ) -> None: ... + def multiline_text( + self, + xy: tuple[float, float], + text: str | bytes, + fill: _Ink | None = ..., + font: _Font | None = ..., + anchor=..., + spacing: float = ..., + align: Literal["left", "center", "right"] = ..., + direction: Literal["rtl", "ltr", "ttb"] = ..., + features=..., + language: str = ..., + stroke_width: float = ..., + stroke_fill: _Ink | None = ..., + embedded_color: bool = ..., + ) -> None: ... + def textsize( + self, + text: str | bytes, + font: _Font | None = ..., + spacing: float = ..., + direction: Literal["rtl", "ltr", "ttb"] | None = ..., + features=..., + language: str | None = ..., + stroke_width: float = ..., + ) -> tuple[int, int]: ... + def multiline_textsize( + self, + text: str | bytes, + font: _Font | None = ..., + spacing: float = ..., + direction: Literal["rtl", "ltr", "ttb"] | None = ..., + features=..., + language: str | None = ..., + stroke_width: float = ..., + ) -> tuple[int, int]: ... + def textlength( + self, + text: str | bytes, + font: _Font | None = ..., + direction: Literal["rtl", "ltr", "ttb"] | None = ..., + features=..., + language: str | None = ..., + embedded_color: bool = ..., + ) -> int: ... + def textbbox( + self, + xy, + text: str | bytes, + font: _Font | None = ..., + anchor=..., + spacing: float = ..., + align: Literal["left", "center", "right"] = ..., + direction: Literal["rtl", "ltr", "ttb"] = ..., + features=..., + language: str | None = ..., + stroke_width: float = ..., + embedded_color: bool = ..., + ) -> tuple[int, int, int, int]: ... + def multiline_textbbox( + self, + xy, + text: str | bytes, + font: _Font | None = ..., + anchor=..., + spacing: float = ..., + align: Literal["left", "center", "right"] = ..., + direction: Literal["rtl", "ltr", "ttb"] = ..., + features=..., + language: str | None = ..., + stroke_width: float = ..., + embedded_color: bool = ..., + ) -> tuple[int, int, int, int]: ... + +def Draw(im: Image, mode: str | None = ...) -> ImageDraw: ... + +Outline: Any + +@overload +def getdraw(im: None = ..., hints: Container[Literal["nicest"]] | None = ...) -> tuple[None, Any]: ... +@overload +def getdraw(im: Image, hints: Container[Literal["nicest"]] | None = ...) -> tuple[Image, Any]: ... +def floodfill(image: Image, xy: tuple[float, float], value, border=..., thresh: float = ...) -> None: ... diff --git a/stubs/Pillow/PIL/ImageFile.pyi b/stubs/Pillow/PIL/ImageFile.pyi new file mode 100644 index 000000000..373e3902c --- /dev/null +++ b/stubs/Pillow/PIL/ImageFile.pyi @@ -0,0 +1,8 @@ +from typing import Any + +from .Image import Image + +class ImageFile(Image): + def __getattr__(self, __item: str) -> Any: ... # incomplete + +def __getattr__(__name: str) -> Any: ... # incomplete diff --git a/stubs/Pillow/PIL/ImageFont.pyi b/stubs/Pillow/PIL/ImageFont.pyi new file mode 100644 index 000000000..820f813f3 --- /dev/null +++ b/stubs/Pillow/PIL/ImageFont.pyi @@ -0,0 +1,100 @@ +from _typeshed import SupportsRead +from typing import Any, Protocol +from typing_extensions import Literal + +LAYOUT_BASIC: Literal[0] +LAYOUT_RAQM: Literal[1] + +class _Font(Protocol): + def getmask(self, text: str, mode: str = ..., direction=..., features=...): ... + +class ImageFont: + def getsize(self, text: str, *args, **kwargs) -> tuple[int, int]: ... + def getmask(self, text: str, mode: str = ..., direction=..., features=...): ... + +class FreeTypeFont: + path: str | bytes | SupportsRead[bytes] | None + size: int + index: int + encoding: str + layout_engine: Any + def __init__( + self, + font: str | bytes | SupportsRead[bytes] | None = ..., + size: int = ..., + index: int = ..., + encoding: str = ..., + layout_engine: int | None = ..., + ) -> None: ... + def getname(self) -> tuple[str, str]: ... + def getmetrics(self): ... + def getlength( + self, text, mode=..., direction: Literal["ltr", "rtl", "ttb"] = ..., features=..., language: str | None = ... + ) -> int: ... + def getbbox( + self, text, mode: str = ..., direction=..., features=..., language: str | None = ..., stroke_width: int = ..., anchor=... + ): ... + def getsize( + self, + text, + direction: Literal["ltr", "rtl", "ttb"] = ..., + features=..., + language: str | None = ..., + stroke_width: int = ..., + ) -> tuple[int, int]: ... + def getsize_multiline( + self, + text, + direction: Literal["ltr", "rtl", "ttb"] = ..., + spacing: float = ..., + features=..., + language: str | None = ..., + stroke_width: float = ..., + ): ... + def getoffset(self, text) -> tuple[int, int]: ... + def getmask( + self, + text: str, + mode: str = ..., + direction: Literal["ltr", "rtl", "ttb"] = ..., + features=..., + language: str | None = ..., + stroke_width: float = ..., + anchor=..., + ink=..., + ): ... + def getmask2( + self, + text, + mode: str = ..., + fill=..., + direction: Literal["ltr", "rtl", "ttb"] = ..., + features=..., + language: str | None = ..., + stroke_width: float = ..., + anchor=..., + ink=..., + *args, + **kwargs, + ): ... + def font_variant(self, font=..., size=..., index=..., encoding=..., layout_engine=...): ... + def get_variation_names(self): ... + def set_variation_by_name(self, name): ... + def get_variation_axes(self): ... + def set_variation_by_axes(self, axes): ... + +class TransposedFont: + def __init__(self, font, orientation=...): ... + def getsize(self, text, *args, **kwargs): ... + def getmask(self, text, mode: str = ..., *args, **kwargs): ... + +def load(filename) -> ImageFont: ... +def truetype( + font: str | bytes | SupportsRead[bytes] | None = ..., + size: int = ..., + index: int = ..., + encoding: str = ..., + layout_engine: int | None = ..., +) -> FreeTypeFont: ... +def load_path(filename: str | bytes) -> ImageFont: ... +def load_default() -> ImageFont: ... diff --git a/stubs/Pillow/PIL/__init__.pyi b/stubs/Pillow/PIL/__init__.pyi new file mode 100644 index 000000000..9ecad7bfe --- /dev/null +++ b/stubs/Pillow/PIL/__init__.pyi @@ -0,0 +1,8 @@ +from typing import Any + +__version__: str + +class UnidentifiedImageError(OSError): ... + +# Submodules are missing, __init__.pyi itself is complete. +def __getattr__(__name: str) -> Any: ... # incomplete diff --git a/stubs/Pillow/PIL/_imaging.pyi b/stubs/Pillow/PIL/_imaging.pyi new file mode 100644 index 000000000..8731e58f1 --- /dev/null +++ b/stubs/Pillow/PIL/_imaging.pyi @@ -0,0 +1,10 @@ +from typing import Any +from typing_extensions import Literal + +DEFAULT_STRATEGY: Literal[0] +FILTERED: Literal[1] +HUFFMAN_ONLY: Literal[2] +RLE: Literal[3] +FIXED: Literal[4] + +def __getattr__(__name: str) -> Any: ... # incomplete diff --git a/stubs/Pillow/PIL/_version.pyi b/stubs/Pillow/PIL/_version.pyi new file mode 100644 index 000000000..bda5b5a7f --- /dev/null +++ b/stubs/Pillow/PIL/_version.pyi @@ -0,0 +1 @@ +__version__: str