API support inventory¶

Generated from the public manifest and indexed input files. A declared status and an input count do not prove all argument combinations. Maturity and release evidence identify the executed scope.

Manifest SHA-256: 467654cfdc578696290dd5879df169acf4c33d30dccb0250bdea5bfd7e58daba.

PIL.Image¶

Public path	Declared support	Input cases	Contract
`PIL.Image.alpha_composite`	supported	84	`alpha_composite(im1: 'Image', im2: 'Image') -> 'Image'`
`PIL.Image.blend`	supported	290	`blend(im1: 'Image', im2: 'Image', alpha: 'float') -> 'Image'`
`PIL.Image.composite`	supported	34	`composite(image1: 'Image', image2: 'Image', mask: 'Image') -> 'Image'`
`PIL.Image.effect_mandelbrot`	supported	57	`effect_mandelbrot(size: 'tuple[int, int]', extent: 'tuple[float, float, float, float]', quality: 'int') -> 'Image'`
`PIL.Image.effect_noise`	supported	49	`effect_noise(size: 'tuple[int, int]', sigma: 'float') -> 'Image'`
`PIL.Image.eval`	supported	15	`eval(image: 'Image', *args: 'Callable[[int], float]') -> 'Image'`
`PIL.Image.fromarray`	supported	125	`fromarray(obj: 'SupportsArrayInterface', mode: 'str \| None' = None) -> 'Image'`
`PIL.Image.frombuffer`	supported	3	`frombuffer(mode: 'str', size: 'tuple[int, int]', data: 'bytes \| SupportsArrayInterface', decoder_name: 'str' = 'raw', *args: 'Any') -> 'Image'`
`PIL.Image.frombytes`	supported	45	`frombytes(mode: 'str', size: 'tuple[int, int]', data: 'bytes \| bytearray \| SupportsArrayInterface', decoder_name: 'str' = 'raw', *args: 'Any') -> 'Image'`
`PIL.Image.linear_gradient`	supported	13	`linear_gradient(mode: 'str') -> 'Image'`
`PIL.Image.merge`	supported	70	`merge(mode: 'str', bands: 'Sequence[Image]') -> 'Image'`
`PIL.Image.new`	supported	80	`new(mode: 'str', size: 'tuple[int, int] \| list[int]', color: 'float \| tuple[float, ...] \| str \| None' = 0) -> 'Image'`
`PIL.Image.open`	supported	37	`open(fp: 'StrOrBytesPath \| IO[bytes]', mode: "Literal['r']" = 'r', formats: 'list[str] \| tuple[str, ...] \| None' = None) -> 'ImageFile.ImageFile'`
`PIL.Image.radial_gradient`	supported	13	`radial_gradient(mode: 'str') -> 'Image'`

PIL.Image.Image¶

Public path	Declared support	Input cases	Contract
`PIL.Image.Image.alpha_composite`	supported	84	`alpha_composite(self, im: 'Image', dest: 'Sequence[int]' = (0, 0), source: 'Sequence[int]' = (0, 0)) -> 'None'`
`PIL.Image.Image.apply_transparency`	supported	18	`apply_transparency(self) -> 'None'`
`PIL.Image.Image.close`	supported	6	`close(self) -> 'None'`
`PIL.Image.Image.convert`	supported	1375	`convert(self, mode: 'str \| None' = None, matrix: 'tuple[float, ...] \| None' = None, dither: 'Dither \| None' = None, palette: 'Palette' = <Palette.WEB: 0>, colors: 'int' = 256) -> 'Image'`
`PIL.Image.Image.copy`	supported	8	`copy(self) -> 'Image'`
`PIL.Image.Image.crop`	supported	202	`crop(self, box: 'tuple[float, float, float, float] \| None' = None) -> 'Image'`
`PIL.Image.Image.draft`	supported	7	`draft(self, mode: 'str \| None', size: 'tuple[int, int] \| None') -> 'tuple[str, tuple[int, int, float, float]] \| None'`
`PIL.Image.Image.effect_spread`	supported	35	`effect_spread(self, distance: 'int') -> 'Image'`
`PIL.Image.Image.entropy`	supported	19	`entropy(self, mask: 'Image \| None' = None, extrema: 'tuple[float, float] \| None' = None) -> 'float'`
`PIL.Image.Image.filter`	supported	173	`filter(self, filter: 'ImageFilter.Filter \| type[ImageFilter.Filter]') -> 'Image'`
`PIL.Image.Image.format`	supported	2	`format(self, /)`
`PIL.Image.Image.frombytes`	supported	21	`frombytes(self, data: 'bytes \| bytearray \| SupportsArrayInterface', decoder_name: 'str' = 'raw', *args: 'Any') -> 'None'`
`PIL.Image.Image.get_child_images`	supported	2	`get_child_images(self) -> 'list[ImageFile.ImageFile]'`
`PIL.Image.Image.get_flattened_data`	supported	3	`get_flattened_data(self, band: 'int \| None' = None) -> 'tuple[tuple[int, ...], ...] \| tuple[float, ...]'`
`PIL.Image.Image.getbands`	supported	19	`getbands(self) -> 'tuple[str, ...]'`
`PIL.Image.Image.getbbox`	supported	110	`getbbox(self, *, alpha_only: 'bool' = True) -> 'tuple[int, int, int, int] \| None'`
`PIL.Image.Image.getchannel`	supported	130	`getchannel(self, channel: 'int \| str') -> 'Image'`
`PIL.Image.Image.getcolors`	supported	28	`getcolors(self, maxcolors: 'int' = 256) -> 'list[tuple[int, tuple[int, ...]]] \| list[tuple[int, float]] \| None'`
`PIL.Image.Image.getdata`	supported	327	`getdata(self, band: 'int \| None' = None) -> 'core.ImagingCore'`
`PIL.Image.Image.getexif`	supported	20	`getexif(self) -> 'Exif'`
`PIL.Image.Image.getextrema`	supported	90	`getextrema(self) -> 'tuple[float, float] \| tuple[tuple[int, int], ...]'`
`PIL.Image.Image.getim`	supported	1	`getim(self) -> 'CapsuleType'`
`PIL.Image.Image.getpalette`	supported	23	`getpalette(self, rawmode: 'str \| None' = 'RGB') -> 'list[int] \| None'`
`PIL.Image.Image.getpixel`	supported	23	`getpixel(self, xy: 'tuple[int, int] \| list[int]') -> 'float \| tuple[int, ...] \| None'`
`PIL.Image.Image.getprojection`	supported	21	`getprojection(self) -> 'tuple[list[int], list[int]]'`
`PIL.Image.Image.getxmp`	supported	2	`getxmp(self) -> 'dict[str, Any]'`
`PIL.Image.Image.has_transparency_data`	supported	4	`has_transparency_data(self, /)`
`PIL.Image.Image.height`	supported	1	`height(self, /)`
`PIL.Image.Image.histogram`	supported	338	`histogram(self, mask: 'Image \| None' = None, extrema: 'tuple[float, float] \| None' = None) -> 'list[int]'`
`PIL.Image.Image.info`	supported	6	`info(self, /)`
`PIL.Image.Image.load`	supported	31	`load(self) -> 'core.PixelAccess \| None'`
`PIL.Image.Image.mode`	supported	1	`mode(self, /)`
`PIL.Image.Image.paste`	supported	326	`paste(self, im: 'Image \| str \| float \| tuple[float, ...]', box: 'Image \| tuple[int, int, int, int] \| tuple[int, int] \| None' = None, mask: 'Image \| None' = None) -> 'None'`
`PIL.Image.Image.point`	supported	331	`point(self, lut: 'Sequence[float] \| NumpyArray \| Callable[[int], float] \| Callable[[ImagePointTransform], ImagePointTransform \| float] \| ImagePointHandler', mode: 'str \| None' = None) -> 'Image'`
`PIL.Image.Image.putalpha`	supported	35	`putalpha(self, alpha: 'Image \| int') -> 'None'`
`PIL.Image.Image.putdata`	supported	168	`putdata(self, data: 'Sequence[float] \| Sequence[Sequence[int]] \| core.ImagingCore \| NumpyArray', scale: 'float' = 1.0, offset: 'float' = 0.0) -> 'None'`
`PIL.Image.Image.putpalette`	supported	12	`putpalette(self, data: 'ImagePalette.ImagePalette \| bytes \| Sequence[int]', rawmode: 'str' = 'RGB') -> 'None'`
`PIL.Image.Image.putpixel`	supported	1325	`putpixel(self, xy: 'tuple[int, int]', value: 'float \| tuple[int, ...] \| list[int]') -> 'None'`
`PIL.Image.Image.quantize`	supported	254	`quantize(self, colors: 'int' = 256, method: 'int \| None' = None, kmeans: 'int' = 0, palette: 'Image \| None' = None, dither: 'Dither' = <Dither.FLOYDSTEINBERG: 3>) -> 'Image'`
`PIL.Image.Image.reduce`	supported	295	`reduce(self, factor: 'int \| tuple[int, int]', box: 'tuple[int, int, int, int] \| None' = None) -> 'Image'`
`PIL.Image.Image.remap_palette`	supported	14	`remap_palette(self, dest_map: 'list[int]', source_palette: 'bytes \| bytearray \| None' = None) -> 'Image'`
`PIL.Image.Image.resize`	supported	876	`resize(self, size: 'tuple[int, int] \| list[int] \| NumpyArray', resample: 'int \| None' = None, box: 'tuple[float, float, float, float] \| None' = None, reducing_gap: 'float \| None' = None) -> 'Image'`
`PIL.Image.Image.rotate`	supported	301	`rotate(self, angle: 'float', resample: 'Resampling' = <Resampling.NEAREST: 0>, expand: 'int \| bool' = False, center: 'tuple[float, float] \| None' = None, translate: 'tuple[int, int] \| None' = None, fillcolor: 'float \| tuple[float, ...] \| str \| None' = None) -> 'Image'`
`PIL.Image.Image.save`	supported	41	`save(self, fp: 'StrOrBytesPath \| IO[bytes]', format: 'str \| None' = None, **params: 'Any') -> 'None'`
`PIL.Image.Image.seek`	supported	8	`seek(self, frame: 'int') -> 'None'`
`PIL.Image.Image.size`	supported	1	`size(self, /)`
`PIL.Image.Image.split`	supported	7	`split(self) -> 'tuple[Image, ...]'`
`PIL.Image.Image.tell`	supported	7	`tell(self) -> 'int'`
`PIL.Image.Image.thumbnail`	supported	174	`thumbnail(self, size: 'tuple[float, float]', resample: 'Resampling' = <Resampling.BICUBIC: 3>, reducing_gap: 'float \| None' = 2.0) -> 'None'`
`PIL.Image.Image.tobitmap`	supported	6	`tobitmap(self, name: 'str' = 'image') -> 'bytes'`
`PIL.Image.Image.tobytes`	supported	31	`tobytes(self, encoder_name: 'str' = 'raw', *args: 'Any') -> 'bytes'`
`PIL.Image.Image.toqimage`	supported	1	`toqimage(self) -> 'ImageQt.ImageQt'`
`PIL.Image.Image.toqpixmap`	supported	1	`toqpixmap(self) -> 'ImageQt.QPixmap'`
`PIL.Image.Image.transform`	supported	980	`transform(self, size: 'tuple[int, int]', method: 'Transform \| ImageTransformHandler \| SupportsGetData', data: 'Sequence[Any] \| None' = None, resample: 'int' = <Resampling.NEAREST: 0>, fill: 'int' = 1, fillcolor: 'float \| tuple[float, ...] \| str \| None' = None) -> 'Image'`
`PIL.Image.Image.transpose`	supported	368	`transpose(self, method: 'Transpose') -> 'Image'`
`PIL.Image.Image.verify`	supported	25	`verify(self) -> 'None'`
`PIL.Image.Image.width`	supported	1	`width(self, /)`

PIL.ImageChops¶

Public path	Declared support	Input cases	Contract
`PIL.ImageChops.add`	supported	67	`add(image1: 'Image.Image', image2: 'Image.Image', scale: 'float' = 1.0, offset: 'float' = 0) -> 'Image.Image'`
`PIL.ImageChops.add_modulo`	supported	172	`add_modulo(image1: 'Image.Image', image2: 'Image.Image') -> 'Image.Image'`
`PIL.ImageChops.blend`	supported	37	`blend(image1: 'Image.Image', image2: 'Image.Image', alpha: 'float') -> 'Image.Image'`
`PIL.ImageChops.composite`	supported	47	`composite(image1: 'Image.Image', image2: 'Image.Image', mask: 'Image.Image') -> 'Image.Image'`
`PIL.ImageChops.constant`	supported	11	`constant(image: 'Image.Image', value: 'int') -> 'Image.Image'`
`PIL.ImageChops.darker`	supported	162	`darker(image1: 'Image.Image', image2: 'Image.Image') -> 'Image.Image'`
`PIL.ImageChops.difference`	supported	173	`difference(image1: 'Image.Image', image2: 'Image.Image') -> 'Image.Image'`
`PIL.ImageChops.duplicate`	supported	11	`duplicate(image: 'Image.Image') -> 'Image.Image'`
`PIL.ImageChops.hard_light`	supported	174	`hard_light(image1: 'Image.Image', image2: 'Image.Image') -> 'Image.Image'`
`PIL.ImageChops.invert`	supported	31	`invert(image: 'Image.Image') -> 'Image.Image'`
`PIL.ImageChops.lighter`	supported	163	`lighter(image1: 'Image.Image', image2: 'Image.Image') -> 'Image.Image'`
`PIL.ImageChops.logical_and`	supported	149	`logical_and(image1: 'Image.Image', image2: 'Image.Image') -> 'Image.Image'`
`PIL.ImageChops.logical_or`	supported	148	`logical_or(image1: 'Image.Image', image2: 'Image.Image') -> 'Image.Image'`
`PIL.ImageChops.logical_xor`	supported	147	`logical_xor(image1: 'Image.Image', image2: 'Image.Image') -> 'Image.Image'`
`PIL.ImageChops.multiply`	supported	178	`multiply(image1: 'Image.Image', image2: 'Image.Image') -> 'Image.Image'`
`PIL.ImageChops.offset`	supported	121	`offset(image: 'Image.Image', xoffset: 'int', yoffset: 'int \| None' = None) -> 'Image.Image'`
`PIL.ImageChops.overlay`	supported	175	`overlay(image1: 'Image.Image', image2: 'Image.Image') -> 'Image.Image'`
`PIL.ImageChops.screen`	supported	301	`screen(image1: 'Image.Image', image2: 'Image.Image') -> 'Image.Image'`
`PIL.ImageChops.soft_light`	supported	175	`soft_light(image1: 'Image.Image', image2: 'Image.Image') -> 'Image.Image'`
`PIL.ImageChops.subtract`	supported	67	`subtract(image1: 'Image.Image', image2: 'Image.Image', scale: 'float' = 1.0, offset: 'float' = 0) -> 'Image.Image'`
`PIL.ImageChops.subtract_modulo`	supported	171	`subtract_modulo(image1: 'Image.Image', image2: 'Image.Image') -> 'Image.Image'`

PIL.ImageColor¶

Public path	Declared support	Input cases	Contract
`PIL.ImageColor.getcolor`	supported	20	`getcolor(color: 'str', mode: 'str') -> 'int \| tuple[int, ...]'`
`PIL.ImageColor.getrgb`	supported	26	`getrgb(color: 'str') -> 'tuple[int, int, int] \| tuple[int, int, int, int]'`

PIL.ImageDraw¶

Public path	Declared support	Input cases	Contract
`PIL.ImageDraw.Draw`	supported	2	`Draw(im: 'Image.Image', mode: 'str \| None' = None) -> 'ImageDraw'`
`PIL.ImageDraw.Outline`	supported	1	`Outline()`

PIL.ImageDraw.ImageDraw¶

Public path	Declared support	Input cases	Contract
`PIL.ImageDraw.ImageDraw.arc`	supported	30	`arc(self, xy: 'Coords', start: 'float', end: 'float', fill: '_Ink \| None' = None, width: 'int' = 1) -> 'None'`
`PIL.ImageDraw.ImageDraw.bitmap`	supported	78	`bitmap(self, xy: 'Sequence[int]', bitmap: 'Image.Image', fill: '_Ink \| None' = None) -> 'None'`
`PIL.ImageDraw.ImageDraw.chord`	supported	27	`chord(self, xy: 'Coords', start: 'float', end: 'float', fill: '_Ink \| None' = None, outline: '_Ink \| None' = None, width: 'int' = 1) -> 'None'`
`PIL.ImageDraw.ImageDraw.circle`	supported	29	`circle(self, xy: 'Sequence[float]', radius: 'float', fill: '_Ink \| None' = None, outline: '_Ink \| None' = None, width: 'int' = 1) -> 'None'`
`PIL.ImageDraw.ImageDraw.ellipse`	supported	28	`ellipse(self, xy: 'Coords', fill: '_Ink \| None' = None, outline: '_Ink \| None' = None, width: 'int' = 1) -> 'None'`
`PIL.ImageDraw.ImageDraw.getfont`	supported	1	`getfont(self) -> 'ImageFont.ImageFont \| ImageFont.FreeTypeFont \| ImageFont.TransposedFont'`
`PIL.ImageDraw.ImageDraw.line`	supported	75	`line(self, xy: 'Coords', fill: '_Ink \| None' = None, width: 'int' = 0, joint: 'str \| None' = None) -> 'None'`
`PIL.ImageDraw.ImageDraw.multiline_text`	supported	25	multiline_text(self, xy: 'tuple[float, float]', text: 'AnyStr', fill: '_Ink \| None' = None, font: 'ImageFont.ImageFont \| ImageFont.FreeTypeFont \| ImageFont.TransposedFont \| None' = None, anchor: 'str \| None' = None, spacing: 'float' = 4, align: 'str' = 'left', direction: 'str \| None' = None, features: 'list[str] \| None' = None, language: 'str \| None' = None, stroke_width: 'float' = 0, stroke_fill: '_Ink \| None' = None, embedded_color: 'bool' = False, *, font_size: 'float \| None' = None) -> 'None'
`PIL.ImageDraw.ImageDraw.multiline_textbbox`	supported	17	`multiline_textbbox(self, xy: 'tuple[float, float]', text: 'AnyStr', font: 'ImageFont.ImageFont \| ImageFont.FreeTypeFont \| ImageFont.TransposedFont \| None' = None, anchor: 'str \| None' = None, spacing: 'float' = 4, align: 'str' = 'left', direction: 'str \| None' = None, features: 'list[str] \| None' = None, language: 'str \| None' = None, stroke_width: 'float' = 0, embedded_color: 'bool' = False, *, font_size: 'float \| None' = None) -> 'tuple[float, float, float, float]'`
`PIL.ImageDraw.ImageDraw.pieslice`	supported	28	`pieslice(self, xy: 'Coords', start: 'float', end: 'float', fill: '_Ink \| None' = None, outline: '_Ink \| None' = None, width: 'int' = 1) -> 'None'`
`PIL.ImageDraw.ImageDraw.point`	supported	44	`point(self, xy: 'Coords', fill: '_Ink \| None' = None) -> 'None'`
`PIL.ImageDraw.ImageDraw.polygon`	supported	64	`polygon(self, xy: 'Coords', fill: '_Ink \| None' = None, outline: '_Ink \| None' = None, width: 'int' = 1) -> 'None'`
`PIL.ImageDraw.ImageDraw.rectangle`	supported	63	`rectangle(self, xy: 'Coords', fill: '_Ink \| None' = None, outline: '_Ink \| None' = None, width: 'int' = 1) -> 'None'`
`PIL.ImageDraw.ImageDraw.regular_polygon`	supported	34	`regular_polygon(self, bounding_circle: 'Sequence[Sequence[float] \| float]', n_sides: 'int', rotation: 'float' = 0, fill: '_Ink \| None' = None, outline: '_Ink \| None' = None, width: 'int' = 1) -> 'None'`
`PIL.ImageDraw.ImageDraw.rounded_rectangle`	supported	34	`rounded_rectangle(self, xy: 'Coords', radius: 'float' = 0, fill: '_Ink \| None' = None, outline: '_Ink \| None' = None, width: 'int' = 1, *, corners: 'tuple[bool, bool, bool, bool] \| None' = None) -> 'None'`
`PIL.ImageDraw.ImageDraw.shape`	supported	20	`shape(self, shape: 'Image.core._Outline', fill: '_Ink \| None' = None, outline: '_Ink \| None' = None) -> 'None'`
`PIL.ImageDraw.ImageDraw.text`	supported	65	text(self, xy: 'tuple[float, float]', text: 'AnyStr \| ImageText.Text[AnyStr]', fill: '_Ink \| None' = None, font: 'ImageFont.ImageFont \| ImageFont.FreeTypeFont \| ImageFont.TransposedFont \| None' = None, anchor: 'str \| None' = None, spacing: 'float' = 4, align: 'str' = 'left', direction: 'str \| None' = None, features: 'list[str] \| None' = None, language: 'str \| None' = None, stroke_width: 'float' = 0, stroke_fill: '_Ink \| None' = None, embedded_color: 'bool' = False, args: 'Any', *kwargs: 'Any') -> 'None'
`PIL.ImageDraw.ImageDraw.textbbox`	supported	15	`textbbox(self, xy: 'tuple[float, float]', text: 'AnyStr', font: 'ImageFont.ImageFont \| ImageFont.FreeTypeFont \| ImageFont.TransposedFont \| None' = None, anchor: 'str \| None' = None, spacing: 'float' = 4, align: 'str' = 'left', direction: 'str \| None' = None, features: 'list[str] \| None' = None, language: 'str \| None' = None, stroke_width: 'float' = 0, embedded_color: 'bool' = False, *, font_size: 'float \| None' = None) -> 'tuple[float, float, float, float]'`
`PIL.ImageDraw.ImageDraw.textlength`	supported	10	`textlength(self, text: 'AnyStr', font: 'ImageFont.ImageFont \| ImageFont.FreeTypeFont \| ImageFont.TransposedFont \| None' = None, direction: 'str \| None' = None, features: 'list[str] \| None' = None, language: 'str \| None' = None, embedded_color: 'bool' = False, *, font_size: 'float \| None' = None) -> 'float'`

PIL.ImageEnhance¶

Public path	Declared support	Input cases	Contract
`PIL.ImageEnhance.Brightness`	supported	11	`Brightness(image: 'Image.Image') -> 'None'`
`PIL.ImageEnhance.Color`	supported	9	`Color(image: 'Image.Image') -> 'None'`
`PIL.ImageEnhance.Contrast`	supported	10	`Contrast(image: 'Image.Image') -> 'None'`
`PIL.ImageEnhance.Sharpness`	supported	9	`Sharpness(image: 'Image.Image') -> 'None'`

PIL.ImageEnhance.Brightness¶

Public path	Declared support	Input cases	Contract
`PIL.ImageEnhance.Brightness.enhance`	supported	248	`enhance(self, factor: 'float') -> 'Image.Image'`

PIL.ImageEnhance.Color¶

Public path	Declared support	Input cases	Contract
`PIL.ImageEnhance.Color.enhance`	supported	292	`enhance(self, factor: 'float') -> 'Image.Image'`

PIL.ImageEnhance.Contrast¶

Public path	Declared support	Input cases	Contract
`PIL.ImageEnhance.Contrast.enhance`	supported	280	`enhance(self, factor: 'float') -> 'Image.Image'`

PIL.ImageEnhance.Sharpness¶

Public path	Declared support	Input cases	Contract
`PIL.ImageEnhance.Sharpness.enhance`	supported	38	`enhance(self, factor: 'float') -> 'Image.Image'`

PIL.ImageFilter¶

Public path	Declared support	Input cases	Contract
`PIL.ImageFilter.BLUR`	supported	6	`BLUR()`
`PIL.ImageFilter.BoxBlur`	supported	63	`BoxBlur(radius: 'float \| Sequence[float]') -> 'None'`
`PIL.ImageFilter.CONTOUR`	supported	4	`CONTOUR()`
`PIL.ImageFilter.Color3DLUT`	supported	20	`Color3DLUT(size: 'int \| tuple[int, int, int]', table: 'Sequence[float] \| Sequence[Sequence[int]] \| NumpyArray', channels: 'int' = 3, target_mode: 'str \| None' = None, **kwargs: 'bool') -> 'None'`
`PIL.ImageFilter.DETAIL`	supported	4	`DETAIL()`
`PIL.ImageFilter.EDGE_ENHANCE`	supported	5	`EDGE_ENHANCE()`
`PIL.ImageFilter.EDGE_ENHANCE_MORE`	supported	4	`EDGE_ENHANCE_MORE()`
`PIL.ImageFilter.EMBOSS`	supported	4	`EMBOSS()`
`PIL.ImageFilter.FIND_EDGES`	supported	4	`FIND_EDGES()`
`PIL.ImageFilter.GaussianBlur`	supported	63	`GaussianBlur(radius: 'float \| Sequence[float]' = 2) -> 'None'`
`PIL.ImageFilter.Kernel`	supported	145	`Kernel(size: 'tuple[int, int]', kernel: 'Sequence[float]', scale: 'float \| None' = None, offset: 'float' = 0) -> 'None'`
`PIL.ImageFilter.MaxFilter`	supported	34	`MaxFilter(size: 'int' = 3) -> 'None'`
`PIL.ImageFilter.MedianFilter`	supported	54	`MedianFilter(size: 'int' = 3) -> 'None'`
`PIL.ImageFilter.MinFilter`	supported	34	`MinFilter(size: 'int' = 3) -> 'None'`
`PIL.ImageFilter.ModeFilter`	supported	21	`ModeFilter(size: 'int' = 3) -> 'None'`
`PIL.ImageFilter.RankFilter`	supported	75	`RankFilter(size: 'int', rank: 'int') -> 'None'`
`PIL.ImageFilter.SHARPEN`	supported	9	`SHARPEN()`
`PIL.ImageFilter.SMOOTH`	supported	4	`SMOOTH()`
`PIL.ImageFilter.SMOOTH_MORE`	supported	4	`SMOOTH_MORE()`
`PIL.ImageFilter.UnsharpMask`	supported	14	`UnsharpMask(radius: 'float' = 2, percent: 'int' = 150, threshold: 'int' = 3) -> 'None'`

PIL.ImageFilter.Color3DLUT¶

Public path Declared support Input cases Contract

PIL.ImageFilter.Color3DLUT.__repr__

supported

1

__repr__(self) -> 'str'

PIL.ImageFilter.Color3DLUT.generate

supported

6

generate(size: 'int | tuple[int, int, int]', callback: 'Callable[[float, float, float], tuple[float, ...]]', channels: 'int' = 3, target_mode: 'str | None' = None) -> 'Color3DLUT'

PIL.ImageFilter.Color3DLUT.transform

supported

7

transform(self, callback: 'Callable[..., tuple[float, ...]]', with_normals: 'bool' = False, channels: 'int | None' = None, target_mode: 'str | None' = None) -> 'Color3DLUT'

PIL.ImageFont¶

Public path	Declared support	Input cases	Contract
`PIL.ImageFont.FreeTypeFont`	supported	5	`FreeTypeFont(font: 'StrOrBytesPath \| BinaryIO', size: 'float' = 10, index: 'int' = 0, encoding: 'str' = '', layout_engine: 'Layout \| None' = None) -> 'None'`
`PIL.ImageFont.ImageFont`	supported	1	`ImageFont()`
`PIL.ImageFont.MAX_STRING_LENGTH`	supported	1	`MAX_STRING_LENGTH()`
`PIL.ImageFont.TransposedFont`	supported	2	`TransposedFont(font: 'ImageFont \| FreeTypeFont', orientation: 'Image.Transpose \| None' = None)`
`PIL.ImageFont.load`	supported	1	`load(filename: 'str') -> 'ImageFont'`
`PIL.ImageFont.load_default`	supported	2	`load_default(size: 'float \| None' = None) -> 'FreeTypeFont \| ImageFont'`
`PIL.ImageFont.load_default_imagefont`	supported	1	`load_default_imagefont() -> 'ImageFont'`
`PIL.ImageFont.load_path`	supported	1	`load_path(filename: 'str \| bytes') -> 'ImageFont'`
`PIL.ImageFont.truetype`	supported	15	`truetype(font: 'StrOrBytesPath \| BinaryIO', size: 'float' = 10, index: 'int' = 0, encoding: 'str' = '', layout_engine: 'Layout \| None' = None) -> 'FreeTypeFont'`

PIL.ImageFont.FreeTypeFont¶

Public path	Declared support	Input cases	Contract
`PIL.ImageFont.FreeTypeFont.font_variant`	supported	8	`font_variant(self, font: 'StrOrBytesPath \| BinaryIO \| None' = None, size: 'float \| None' = None, index: 'int \| None' = None, encoding: 'str \| None' = None, layout_engine: 'Layout \| None' = None) -> 'FreeTypeFont'`
`PIL.ImageFont.FreeTypeFont.get_variation_axes`	supported	5	`get_variation_axes(self) -> 'list[Axis]'`
`PIL.ImageFont.FreeTypeFont.get_variation_names`	supported	6	`get_variation_names(self) -> 'list[bytes]'`
`PIL.ImageFont.FreeTypeFont.getbbox`	supported	16	`getbbox(self, text: 'str \| bytes', mode: 'str' = '', direction: 'str \| None' = None, features: 'list[str] \| None' = None, language: 'str \| None' = None, stroke_width: 'float' = 0, anchor: 'str \| None' = None) -> 'tuple[float, float, float, float]'`
`PIL.ImageFont.FreeTypeFont.getlength`	supported	10	`getlength(self, text: 'str \| bytes', mode: 'str' = '', direction: 'str \| None' = None, features: 'list[str] \| None' = None, language: 'str \| None' = None) -> 'float'`
`PIL.ImageFont.FreeTypeFont.getmask`	supported	26	`getmask(self, text: 'str \| bytes', mode: 'str' = '', direction: 'str \| None' = None, features: 'list[str] \| None' = None, language: 'str \| None' = None, stroke_width: 'float' = 0, anchor: 'str \| None' = None, ink: 'int' = 0, start: 'tuple[float, float] \| None' = None) -> 'Image.core.ImagingCore'`
`PIL.ImageFont.FreeTypeFont.getmask2`	supported	41	`getmask2(self, text: 'str \| bytes', mode: 'str' = '', direction: 'str \| None' = None, features: 'list[str] \| None' = None, language: 'str \| None' = None, stroke_width: 'float' = 0, anchor: 'str \| None' = None, ink: 'int' = 0, start: 'tuple[float, float] \| None' = None, args: 'Any', *kwargs: 'Any') -> 'tuple[Image.core.ImagingCore, tuple[int, int]]'`
`PIL.ImageFont.FreeTypeFont.getmetrics`	supported	2	`getmetrics(self) -> 'tuple[int, int]'`
`PIL.ImageFont.FreeTypeFont.getname`	supported	1	`getname(self) -> 'tuple[str \| None, str \| None]'`
`PIL.ImageFont.FreeTypeFont.set_variation_by_axes`	supported	6	`set_variation_by_axes(self, axes: 'list[float]') -> 'None'`
`PIL.ImageFont.FreeTypeFont.set_variation_by_name`	supported	4	`set_variation_by_name(self, name: 'str \| bytes') -> 'None'`

PIL.ImageFont.ImageFont¶

Public path Declared support Input cases Contract

PIL.ImageFont.ImageFont.getbbox

supported

3

getbbox(self, text: 'str | bytes | bytearray', *args: 'Any', **kwargs: 'Any') -> 'tuple[int, int, int, int]'

PIL.ImageFont.ImageFont.getlength

supported

3

getlength(self, text: 'str | bytes | bytearray', *args: 'Any', **kwargs: 'Any') -> 'int'

PIL.ImageFont.ImageFont.getmask

supported

9

getmask(self, text: 'str | bytes', mode: 'str' = '', *args: 'Any', **kwargs: 'Any') -> 'Image.core.ImagingCore'

PIL.ImageFont.TransposedFont¶

Public path Declared support Input cases Contract

PIL.ImageFont.TransposedFont.getbbox

supported

4

getbbox(self, text: 'str | bytes', *args: 'Any', **kwargs: 'Any') -> 'tuple[int, int, float, float]'

PIL.ImageFont.TransposedFont.getlength

supported

4

getlength(self, text: 'str | bytes', *args: 'Any', **kwargs: 'Any') -> 'float'

PIL.ImageFont.TransposedFont.getmask

supported

5

getmask(self, text: 'str | bytes', mode: 'str' = '', *args: 'Any', **kwargs: 'Any') -> 'Image.core.ImagingCore'

PIL.ImageOps¶

Public path	Declared support	Input cases	Contract
`PIL.ImageOps.autocontrast`	supported	187	`autocontrast(image: 'Image.Image', cutoff: 'float \| tuple[float, float]' = 0, ignore: 'int \| Sequence[int] \| None' = None, mask: 'Image.Image \| None' = None, preserve_tone: 'bool' = False) -> 'Image.Image'`
`PIL.ImageOps.colorize`	supported	43	`colorize(image: 'Image.Image', black: 'str \| tuple[int, ...]', white: 'str \| tuple[int, ...]', mid: 'str \| int \| tuple[int, ...] \| None' = None, blackpoint: 'int' = 0, whitepoint: 'int' = 255, midpoint: 'int' = 127) -> 'Image.Image'`
`PIL.ImageOps.contain`	supported	50	`contain(image: 'Image.Image', size: 'tuple[int, int]', method: 'int' = <Resampling.BICUBIC: 3>) -> 'Image.Image'`
`PIL.ImageOps.cover`	supported	50	`cover(image: 'Image.Image', size: 'tuple[int, int]', method: 'int' = <Resampling.BICUBIC: 3>) -> 'Image.Image'`
`PIL.ImageOps.crop`	supported	16	`crop(image: 'Image.Image', border: 'int' = 0) -> 'Image.Image'`
`PIL.ImageOps.deform`	supported	2	`deform(image: 'Image.Image', deformer: 'SupportsGetMesh', resample: 'int' = <Resampling.BILINEAR: 2>) -> 'Image.Image'`
`PIL.ImageOps.equalize`	supported	185	`equalize(image: 'Image.Image', mask: 'Image.Image \| None' = None) -> 'Image.Image'`
`PIL.ImageOps.exif_transpose`	supported	133	`exif_transpose(image: 'Image.Image', *, in_place: 'bool' = False) -> 'Image.Image \| None'`
`PIL.ImageOps.expand`	supported	66	`expand(image: 'Image.Image', border: 'int \| tuple[int, ...]' = 0, fill: 'str \| int \| tuple[int, ...]' = 0) -> 'Image.Image'`
`PIL.ImageOps.fit`	supported	85	`fit(image: 'Image.Image', size: 'tuple[int, int]', method: 'int' = <Resampling.BICUBIC: 3>, bleed: 'float' = 0.0, centering: 'tuple[float, float]' = (0.5, 0.5)) -> 'Image.Image'`
`PIL.ImageOps.flip`	supported	37	`flip(image: 'Image.Image') -> 'Image.Image'`
`PIL.ImageOps.grayscale`	supported	26	`grayscale(image: 'Image.Image') -> 'Image.Image'`
`PIL.ImageOps.invert`	supported	85	`invert(image: 'Image.Image') -> 'Image.Image'`
`PIL.ImageOps.mirror`	supported	35	`mirror(image: 'Image.Image') -> 'Image.Image'`
`PIL.ImageOps.pad`	supported	276	`pad(image: 'Image.Image', size: 'tuple[int, int]', method: 'int' = <Resampling.BICUBIC: 3>, color: 'str \| int \| tuple[int, ...] \| None' = None, centering: 'tuple[float, float]' = (0.5, 0.5)) -> 'Image.Image'`
`PIL.ImageOps.posterize`	supported	33	`posterize(image: 'Image.Image', bits: 'int') -> 'Image.Image'`
`PIL.ImageOps.scale`	supported	36	`scale(image: 'Image.Image', factor: 'float', resample: 'int' = <Resampling.BICUBIC: 3>) -> 'Image.Image'`
`PIL.ImageOps.solarize`	supported	392	`solarize(image: 'Image.Image', threshold: 'int' = 128) -> 'Image.Image'`

PIL.ImagePalette¶

Public path	Declared support	Input cases	Contract
`PIL.ImagePalette.ImagePalette`	supported	3	`ImagePalette(mode: 'str' = 'RGB', palette: 'Sequence[int] \| bytes \| bytearray \| None' = None) -> 'None'`

PIL.ImagePalette.ImagePalette¶

Public path	Declared support	Input cases	Contract
`PIL.ImagePalette.ImagePalette.copy`	supported	1	`copy(self) -> 'ImagePalette'`
`PIL.ImagePalette.ImagePalette.getcolor`	supported	14	`getcolor(self, color: 'tuple[int, ...]', image: 'Image.Image \| None' = None) -> 'int'`
`PIL.ImagePalette.ImagePalette.getdata`	supported	1	`getdata(self) -> 'tuple[str, Sequence[int] \| bytes \| bytearray]'`
`PIL.ImagePalette.ImagePalette.save`	supported	1	`save(self, fp: 'str \| IO[str]') -> 'None'`
`PIL.ImagePalette.ImagePalette.tobytes`	supported	1	`tobytes(self) -> 'bytes'`

PIL.ImageSequence¶

Public path	Declared support	Input cases	Contract
`PIL.ImageSequence.Iterator`	supported	4	`Iterator(im: 'Image.Image') -> 'None'`

PIL.ImageSequence.Iterator¶

Public path	Declared support	Input cases	Contract
`PIL.ImageSequence.Iterator.__iter__`	supported	1	`__iter__(self) -> 'Iterator'`
`PIL.ImageSequence.Iterator.__next__`	supported	2	`__next__(self) -> 'Image.Image'`

PIL.ImageStat¶

Public path	Declared support	Input cases	Contract
`PIL.ImageStat.Stat`	supported	9	`Stat(image_or_list: 'Image.Image \| list[int]', mask: 'Image.Image \| None' = None) -> 'None'`

PIL.ImageStat.Stat¶

Public path	Declared support	Input cases	Contract
`PIL.ImageStat.Stat.count`	supported	3	`count(self, /)`
`PIL.ImageStat.Stat.extrema`	supported	259	`extrema(self, /)`
`PIL.ImageStat.Stat.mean`	supported	3	`mean(self, /)`
`PIL.ImageStat.Stat.median`	supported	3	`median(self, /)`
`PIL.ImageStat.Stat.rms`	supported	3	`rms(self, /)`
`PIL.ImageStat.Stat.stddev`	supported	3	`stddev(self, /)`
`PIL.ImageStat.Stat.sum`	supported	3	`sum(self, /)`
`PIL.ImageStat.Stat.sum2`	supported	3	`sum2(self, /)`
`PIL.ImageStat.Stat.var`	supported	4	`var(self, /)`