mirror of
https://github.com/python-pillow/Pillow.git
synced 2024-11-10 19:56:47 +03:00
Merge branch 'main' into improve-error-messages
This commit is contained in:
Yngve Mardal Moe
GitHub
commit
9ba4e10a16
|
|
@ -21,7 +21,7 @@ set -e
|
|||
|
||||
if [[ $(uname) != CYGWIN* ]]; then
|
||||
sudo apt-get -qq install libfreetype6-dev liblcms2-dev python3-tk\
|
||||
ghostscript libffi-dev libjpeg-turbo-progs libopenjp2-7-dev\
|
||||
ghostscript libjpeg-turbo-progs libopenjp2-7-dev\
|
||||
cmake meson imagemagick libharfbuzz-dev libfribidi-dev\
|
||||
sway wl-clipboard libopenblas-dev
|
||||
fi
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@ numpy
|
|||
packaging
|
||||
pytest
|
||||
sphinx
|
||||
types-atheris
|
||||
types-defusedxml
|
||||
types-olefile
|
||||
types-setuptools
|
||||
|
|
|
|||
2
.github/workflows/test.yml
vendored
2
.github/workflows/test.yml
vendored
|
|
@ -76,7 +76,7 @@ jobs:
|
|||
"pyproject.toml"
|
||||
|
||||
- name: Set up Python ${{ matrix.python-version }} (free-threaded)
|
||||
uses: deadsnakes/action@v3.1.0
|
||||
uses: deadsnakes/action@v3.2.0
|
||||
if: "${{ matrix.disable-gil }}"
|
||||
with:
|
||||
python-version: ${{ matrix.python-version }}
|
||||
|
|
|
|||
45
.github/workflows/wheels-dependencies.sh
vendored
45
.github/workflows/wheels-dependencies.sh
vendored
|
|
@ -16,7 +16,11 @@ ARCHIVE_SDIR=pillow-depends-main
|
|||
|
||||
# Package versions for fresh source builds
|
||||
FREETYPE_VERSION=2.13.2
|
||||
if [[ "$MB_ML_VER" != 2014 ]]; then
|
||||
HARFBUZZ_VERSION=9.0.0
|
||||
else
|
||||
HARFBUZZ_VERSION=8.5.0
|
||||
fi
|
||||
LIBPNG_VERSION=1.6.43
|
||||
JPEGTURBO_VERSION=3.0.3
|
||||
OPENJPEG_VERSION=2.5.2
|
||||
|
|
@ -40,7 +44,7 @@ BROTLI_VERSION=1.1.0
|
|||
|
||||
if [[ -n "$IS_MACOS" ]] && [[ "$CIBW_ARCHS" == "x86_64" ]]; then
|
||||
function build_openjpeg {
|
||||
local out_dir=$(fetch_unpack https://github.com/uclouvain/openjpeg/archive/v${OPENJPEG_VERSION}.tar.gz openjpeg-${OPENJPEG_VERSION}.tar.gz)
|
||||
local out_dir=$(fetch_unpack https://github.com/uclouvain/openjpeg/archive/v$OPENJPEG_VERSION.tar.gz openjpeg-$OPENJPEG_VERSION.tar.gz)
|
||||
(cd $out_dir \
|
||||
&& cmake -DCMAKE_INSTALL_PREFIX=$BUILD_PREFIX -DCMAKE_INSTALL_NAME_DIR=$BUILD_PREFIX/lib . \
|
||||
&& make install)
|
||||
|
|
@ -50,7 +54,7 @@ fi
|
|||
|
||||
function build_brotli {
|
||||
local cmake=$(get_modern_cmake)
|
||||
local out_dir=$(fetch_unpack https://github.com/google/brotli/archive/v$BROTLI_VERSION.tar.gz brotli-1.1.0.tar.gz)
|
||||
local out_dir=$(fetch_unpack https://github.com/google/brotli/archive/v$BROTLI_VERSION.tar.gz brotli-$BROTLI_VERSION.tar.gz)
|
||||
(cd $out_dir \
|
||||
&& $cmake -DCMAKE_INSTALL_PREFIX=$BUILD_PREFIX -DCMAKE_INSTALL_NAME_DIR=$BUILD_PREFIX/lib . \
|
||||
&& make install)
|
||||
|
|
@ -60,6 +64,25 @@ function build_brotli {
|
|||
fi
|
||||
}
|
||||
|
||||
function build_harfbuzz {
|
||||
if [[ "$HARFBUZZ_VERSION" == 8.5.0 ]]; then
|
||||
export FREETYPE_LIBS=-lfreetype
|
||||
export FREETYPE_CFLAGS=-I/usr/local/include/freetype2/
|
||||
build_simple harfbuzz $HARFBUZZ_VERSION https://github.com/harfbuzz/harfbuzz/releases/download/$HARFBUZZ_VERSION tar.xz --with-freetype=yes --with-glib=no
|
||||
export FREETYPE_LIBS=""
|
||||
export FREETYPE_CFLAGS=""
|
||||
else
|
||||
local out_dir=$(fetch_unpack https://github.com/harfbuzz/harfbuzz/releases/download/$HARFBUZZ_VERSION/$HARFBUZZ_VERSION.tar.xz harfbuzz-$HARFBUZZ_VERSION.tar.xz)
|
||||
(cd $out_dir \
|
||||
&& meson setup build --buildtype=release -Dfreetype=enabled -Dglib=disabled)
|
||||
(cd $out_dir/build \
|
||||
&& meson install)
|
||||
if [[ "$MB_ML_LIBC" == "manylinux" ]]; then
|
||||
cp /usr/local/lib64/libharfbuzz* /usr/local/lib
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
function build {
|
||||
if [[ -n "$IS_MACOS" ]] && [[ "$CIBW_ARCHS" == "arm64" ]]; then
|
||||
sudo chown -R runner /usr/local
|
||||
|
|
@ -109,15 +132,7 @@ function build {
|
|||
build_freetype
|
||||
fi
|
||||
|
||||
if [ -z "$IS_MACOS" ]; then
|
||||
export FREETYPE_LIBS=-lfreetype
|
||||
export FREETYPE_CFLAGS=-I/usr/local/include/freetype2/
|
||||
fi
|
||||
build_simple harfbuzz $HARFBUZZ_VERSION https://github.com/harfbuzz/harfbuzz/releases/download/$HARFBUZZ_VERSION tar.xz --with-freetype=yes --with-glib=no
|
||||
if [ -z "$IS_MACOS" ]; then
|
||||
export FREETYPE_LIBS=""
|
||||
export FREETYPE_CFLAGS=""
|
||||
fi
|
||||
build_harfbuzz
|
||||
}
|
||||
|
||||
# Any stuff that you need to do before you start building the wheels
|
||||
|
|
@ -140,7 +155,13 @@ if [[ -n "$IS_MACOS" ]]; then
|
|||
brew remove --ignore-dependencies webp
|
||||
fi
|
||||
|
||||
brew install pkg-config
|
||||
brew install meson pkg-config
|
||||
elif [[ "$MB_ML_LIBC" == "manylinux" ]]; then
|
||||
if [[ "$HARFBUZZ_VERSION" != 8.5.0 ]]; then
|
||||
yum install -y meson
|
||||
fi
|
||||
else
|
||||
apk add meson
|
||||
fi
|
||||
|
||||
wrap_wheel_builder build
|
||||
|
|
|
|||
48
CHANGES.rst
48
CHANGES.rst
|
|
@ -5,6 +5,54 @@ Changelog (Pillow)
|
|||
11.0.0 (unreleased)
|
||||
-------------------
|
||||
|
||||
- Deprecate ICNS (width, height, scale) sizes in favour of load(scale) #8352
|
||||
[radarhere]
|
||||
|
||||
- Improved handling of RGBA palettes when saving GIF images #8366
|
||||
[radarhere]
|
||||
|
||||
- Deprecate isImageType #8364
|
||||
[radarhere]
|
||||
|
||||
- Support converting more modes to LAB by converting to RGBA first #8358
|
||||
[radarhere]
|
||||
|
||||
- Deprecate support for FreeType 2.9.0 #8356
|
||||
[hugovk, radarhere]
|
||||
|
||||
- Removed unused TiffImagePlugin IFD_LEGACY_API #8355
|
||||
[radarhere]
|
||||
|
||||
- Handle duplicate EXIF header #8350
|
||||
[zakajd, radarhere]
|
||||
|
||||
- Return early from BoxBlur if either width or height is zero #8347
|
||||
[radarhere]
|
||||
|
||||
- Check text is either string or bytes #8308
|
||||
[radarhere]
|
||||
|
||||
- Added writing XMP bytes to JPEG #8286
|
||||
[radarhere]
|
||||
|
||||
- Support JPEG2000 RGBA palettes #8256
|
||||
[radarhere]
|
||||
|
||||
- Expand C image to match GIF frame image size #8237
|
||||
[radarhere]
|
||||
|
||||
- Allow saving I;16 images as PPM #8231
|
||||
[radarhere]
|
||||
|
||||
- When IFD is missing, connect get_ifd() dictionary to Exif #8230
|
||||
[radarhere]
|
||||
|
||||
- Skip truncated ICO mask if LOAD_TRUNCATED_IMAGES is enabled #8180
|
||||
[radarhere]
|
||||
|
||||
- Treat unknown JPEG2000 colorspace as unspecified #8343
|
||||
[radarhere]
|
||||
|
||||
- Updated error message when saving WebP with invalid width or height #8322
|
||||
[radarhere, hugovk]
|
||||
|
||||
|
|
|
|||
BIN
Tests/images/test_extents_transparency.gif
Normal file
BIN
Tests/images/test_extents_transparency.gif
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 415 B |
|
|
@ -16,8 +16,9 @@
|
|||
|
||||
|
||||
import atheris
|
||||
from atheris.import_hook import instrument_imports
|
||||
|
||||
with atheris.instrument_imports():
|
||||
with instrument_imports():
|
||||
import sys
|
||||
|
||||
import fuzzers
|
||||
|
|
|
|||
|
|
@ -14,8 +14,9 @@
|
|||
|
||||
|
||||
import atheris
|
||||
from atheris.import_hook import instrument_imports
|
||||
|
||||
with atheris.instrument_imports():
|
||||
with instrument_imports():
|
||||
import sys
|
||||
|
||||
import fuzzers
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
{
|
||||
<py3_8_encode_current_locale>
|
||||
<py3_10_encode_current_locale>
|
||||
Memcheck:Cond
|
||||
...
|
||||
fun:encode_current_locale
|
||||
|
|
|
|||
|
|
@ -71,6 +71,11 @@ def test_color_modes() -> None:
|
|||
box_blur(sample.convert("YCbCr"))
|
||||
|
||||
|
||||
@pytest.mark.parametrize("size", ((0, 1), (1, 0)))
|
||||
def test_zero_dimension(size: tuple[int, int]) -> None:
|
||||
assert box_blur(Image.new("L", size)).size == size
|
||||
|
||||
|
||||
def test_radius_0() -> None:
|
||||
assert_blur(
|
||||
sample,
|
||||
|
|
|
|||
|
|
@ -1378,8 +1378,26 @@ def test_lzw_bits() -> None:
|
|||
im.load()
|
||||
|
||||
|
||||
def test_extents() -> None:
|
||||
with Image.open("Tests/images/test_extents.gif") as im:
|
||||
@pytest.mark.parametrize(
|
||||
"test_file, loading_strategy",
|
||||
(
|
||||
("test_extents.gif", GifImagePlugin.LoadingStrategy.RGB_AFTER_FIRST),
|
||||
(
|
||||
"test_extents.gif",
|
||||
GifImagePlugin.LoadingStrategy.RGB_AFTER_DIFFERENT_PALETTE_ONLY,
|
||||
),
|
||||
(
|
||||
"test_extents_transparency.gif",
|
||||
GifImagePlugin.LoadingStrategy.RGB_AFTER_FIRST,
|
||||
),
|
||||
),
|
||||
)
|
||||
def test_extents(
|
||||
test_file: str, loading_strategy: GifImagePlugin.LoadingStrategy
|
||||
) -> None:
|
||||
GifImagePlugin.LOADING_STRATEGY = loading_strategy
|
||||
try:
|
||||
with Image.open("Tests/images/" + test_file) as im:
|
||||
assert im.size == (100, 100)
|
||||
|
||||
# Check that n_frames does not change the size
|
||||
|
|
@ -1389,6 +1407,11 @@ def test_extents() -> None:
|
|||
im.seek(1)
|
||||
assert im.size == (150, 150)
|
||||
|
||||
im.load()
|
||||
assert im.im.size == (150, 150)
|
||||
finally:
|
||||
GifImagePlugin.LOADING_STRATEGY = GifImagePlugin.LoadingStrategy.RGB_AFTER_FIRST
|
||||
|
||||
|
||||
def test_missing_background() -> None:
|
||||
# The Global Color Table Flag isn't set, so there is no background color index,
|
||||
|
|
@ -1406,3 +1429,21 @@ def test_saving_rgba(tmp_path: Path) -> None:
|
|||
with Image.open(out) as reloaded:
|
||||
reloaded_rgba = reloaded.convert("RGBA")
|
||||
assert reloaded_rgba.load()[0, 0][3] == 0
|
||||
|
||||
|
||||
def test_optimizing_p_rgba(tmp_path: Path) -> None:
|
||||
out = str(tmp_path / "temp.gif")
|
||||
|
||||
im1 = Image.new("P", (100, 100))
|
||||
d = ImageDraw.Draw(im1)
|
||||
d.ellipse([(40, 40), (60, 60)], fill=1)
|
||||
data = [0, 0, 0, 0, 0, 0, 0, 255] + [0, 0, 0, 0] * 254
|
||||
im1.putpalette(data, "RGBA")
|
||||
|
||||
im2 = Image.new("P", (100, 100))
|
||||
im2.putpalette(data, "RGBA")
|
||||
|
||||
im1.save(out, save_all=True, append_images=[im2])
|
||||
|
||||
with Image.open(out) as reloaded:
|
||||
assert reloaded.n_frames == 2
|
||||
|
|
|
|||
|
|
@ -63,8 +63,8 @@ def test_save_append_images(tmp_path: Path) -> None:
|
|||
assert_image_similar_tofile(im, temp_file, 1)
|
||||
|
||||
with Image.open(temp_file) as reread:
|
||||
reread.size = (16, 16, 2)
|
||||
reread.load()
|
||||
reread.size = (16, 16)
|
||||
reread.load(2)
|
||||
assert_image_equal(reread, provided_im)
|
||||
|
||||
|
||||
|
|
@ -87,14 +87,21 @@ def test_sizes() -> None:
|
|||
for w, h, r in im.info["sizes"]:
|
||||
wr = w * r
|
||||
hr = h * r
|
||||
with pytest.warns(DeprecationWarning):
|
||||
im.size = (w, h, r)
|
||||
im.load()
|
||||
assert im.mode == "RGBA"
|
||||
assert im.size == (wr, hr)
|
||||
|
||||
# Test using load() with scale
|
||||
im.size = (w, h)
|
||||
im.load(scale=r)
|
||||
assert im.mode == "RGBA"
|
||||
assert im.size == (wr, hr)
|
||||
|
||||
# Check that we cannot load an incorrect size
|
||||
with pytest.raises(ValueError):
|
||||
im.size = (1, 1)
|
||||
im.size = (1, 2)
|
||||
|
||||
|
||||
def test_older_icon() -> None:
|
||||
|
|
@ -105,8 +112,8 @@ def test_older_icon() -> None:
|
|||
wr = w * r
|
||||
hr = h * r
|
||||
with Image.open("Tests/images/pillow2.icns") as im2:
|
||||
im2.size = (w, h, r)
|
||||
im2.load()
|
||||
im2.size = (w, h)
|
||||
im2.load(r)
|
||||
assert im2.mode == "RGBA"
|
||||
assert im2.size == (wr, hr)
|
||||
|
||||
|
|
@ -122,8 +129,8 @@ def test_jp2_icon() -> None:
|
|||
wr = w * r
|
||||
hr = h * r
|
||||
with Image.open("Tests/images/pillow3.icns") as im2:
|
||||
im2.size = (w, h, r)
|
||||
im2.load()
|
||||
im2.size = (w, h)
|
||||
im2.load(r)
|
||||
assert im2.mode == "RGBA"
|
||||
assert im2.size == (wr, hr)
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ from pathlib import Path
|
|||
|
||||
import pytest
|
||||
|
||||
from PIL import IcoImagePlugin, Image, ImageDraw
|
||||
from PIL import IcoImagePlugin, Image, ImageDraw, ImageFile
|
||||
|
||||
from .helper import assert_image_equal, assert_image_equal_tofile, hopper
|
||||
|
||||
|
|
@ -241,3 +241,29 @@ def test_draw_reloaded(tmp_path: Path) -> None:
|
|||
|
||||
with Image.open(outfile) as im:
|
||||
assert_image_equal_tofile(im, "Tests/images/hopper_draw.ico")
|
||||
|
||||
|
||||
def test_truncated_mask() -> None:
|
||||
# 1 bpp
|
||||
with open("Tests/images/hopper_mask.ico", "rb") as fp:
|
||||
data = fp.read()
|
||||
|
||||
ImageFile.LOAD_TRUNCATED_IMAGES = True
|
||||
data = data[:-3]
|
||||
|
||||
try:
|
||||
with Image.open(io.BytesIO(data)) as im:
|
||||
with Image.open("Tests/images/hopper_mask.png") as expected:
|
||||
assert im.mode == "1"
|
||||
|
||||
# 32 bpp
|
||||
output = io.BytesIO()
|
||||
expected = hopper("RGBA")
|
||||
expected.save(output, "ico", bitmap_format="bmp")
|
||||
|
||||
data = output.getvalue()[:-1]
|
||||
|
||||
with Image.open(io.BytesIO(data)) as im:
|
||||
assert im.mode == "RGB"
|
||||
finally:
|
||||
ImageFile.LOAD_TRUNCATED_IMAGES = False
|
||||
|
|
|
|||
|
|
@ -991,12 +991,29 @@ class TestFileJpeg:
|
|||
else:
|
||||
assert im.getxmp() == {"xmpmeta": None}
|
||||
|
||||
def test_save_xmp(self, tmp_path: Path) -> None:
|
||||
f = str(tmp_path / "temp.jpg")
|
||||
im = hopper()
|
||||
im.save(f, xmp=b"XMP test")
|
||||
with Image.open(f) as reloaded:
|
||||
assert reloaded.info["xmp"] == b"XMP test"
|
||||
|
||||
im.info["xmp"] = b"1" * 65504
|
||||
im.save(f)
|
||||
with Image.open(f) as reloaded:
|
||||
assert reloaded.info["xmp"] == b"1" * 65504
|
||||
|
||||
with pytest.raises(ValueError):
|
||||
im.save(f, xmp=b"1" * 65505)
|
||||
|
||||
@pytest.mark.timeout(timeout=1)
|
||||
def test_eof(self) -> None:
|
||||
# Even though this decoder never says that it is finished
|
||||
# the image should still end when there is no new data
|
||||
class InfiniteMockPyDecoder(ImageFile.PyDecoder):
|
||||
def decode(self, buffer: bytes) -> tuple[int, int]:
|
||||
def decode(
|
||||
self, buffer: bytes | Image.SupportsArrayInterface
|
||||
) -> tuple[int, int]:
|
||||
return 0, 0
|
||||
|
||||
Image.register_decoder("INFINITE", InfiniteMockPyDecoder)
|
||||
|
|
|
|||
|
|
@ -182,6 +182,15 @@ def test_restricted_icc_profile() -> None:
|
|||
ImageFile.LOAD_TRUNCATED_IMAGES = False
|
||||
|
||||
|
||||
@pytest.mark.skipif(
|
||||
not os.path.exists(EXTRA_DIR), reason="Extra image files not installed"
|
||||
)
|
||||
def test_unknown_colorspace() -> None:
|
||||
with Image.open(f"{EXTRA_DIR}/file8.jp2") as im:
|
||||
im.load()
|
||||
assert im.mode == "L"
|
||||
|
||||
|
||||
def test_header_errors() -> None:
|
||||
for path in (
|
||||
"Tests/images/invalid_header_length.jp2",
|
||||
|
|
@ -391,6 +400,13 @@ def test_pclr() -> None:
|
|||
assert len(im.palette.colors) == 256
|
||||
assert im.palette.colors[(255, 255, 255)] == 0
|
||||
|
||||
with Image.open(
|
||||
f"{EXTRA_DIR}/147af3f1083de4393666b7d99b01b58b_signal_sigsegv_130c531_6155_5136.jp2"
|
||||
) as im:
|
||||
assert im.mode == "P"
|
||||
assert len(im.palette.colors) == 139
|
||||
assert im.palette.colors[(0, 0, 0, 0)] == 0
|
||||
|
||||
|
||||
def test_comment() -> None:
|
||||
with Image.open("Tests/images/comment.jp2") as im:
|
||||
|
|
|
|||
|
|
@ -95,7 +95,9 @@ def test_16bit_pgm_write(tmp_path: Path) -> None:
|
|||
with Image.open("Tests/images/16_bit_binary.pgm") as im:
|
||||
filename = str(tmp_path / "temp.pgm")
|
||||
im.save(filename, "PPM")
|
||||
assert_image_equal_tofile(im, filename)
|
||||
|
||||
im.convert("I;16").save(filename, "PPM")
|
||||
assert_image_equal_tofile(im, filename)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -775,6 +775,22 @@ class TestImage:
|
|||
exif.load(b"Exif\x00\x00")
|
||||
assert not dict(exif)
|
||||
|
||||
def test_duplicate_exif_header(self) -> None:
|
||||
with Image.open("Tests/images/exif.png") as im:
|
||||
im.load()
|
||||
im.info["exif"] = b"Exif\x00\x00" + im.info["exif"]
|
||||
|
||||
exif = im.getexif()
|
||||
assert exif[274] == 1
|
||||
|
||||
def test_empty_get_ifd(self) -> None:
|
||||
exif = Image.Exif()
|
||||
ifd = exif.get_ifd(0x8769)
|
||||
assert ifd == {}
|
||||
|
||||
ifd[36864] = b"0220"
|
||||
assert exif.get_ifd(0x8769) == {36864: b"0220"}
|
||||
|
||||
@mark_if_feature_version(
|
||||
pytest.mark.valgrind_known_error, "libjpeg_turbo", "2.0", reason="Known Failing"
|
||||
)
|
||||
|
|
@ -1101,6 +1117,10 @@ class TestImage:
|
|||
assert len(caplog.records) == 0
|
||||
assert im.fp is None
|
||||
|
||||
def test_deprecation(self) -> None:
|
||||
with pytest.warns(DeprecationWarning):
|
||||
assert not Image.isImageType(None)
|
||||
|
||||
|
||||
class TestImageBytes:
|
||||
@pytest.mark.parametrize("mode", Image.MODES + ["BGR;15", "BGR;16", "BGR;24"])
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ def test_toarray() -> None:
|
|||
|
||||
def test_with_dtype(dtype: npt.DTypeLike) -> None:
|
||||
ai = numpy.array(im, dtype=dtype)
|
||||
assert ai.dtype == dtype
|
||||
assert ai.dtype.type is dtype
|
||||
|
||||
# assert test("1") == ((100, 128), '|b1', 1600))
|
||||
assert test("L") == ((100, 128), "|u1", 12800)
|
||||
|
|
|
|||
|
|
@ -696,6 +696,12 @@ def test_rgb_lab(mode: str) -> None:
|
|||
assert value[:3] == (0, 255, 255)
|
||||
|
||||
|
||||
def test_cmyk_lab() -> None:
|
||||
im = Image.new("CMYK", (1, 1))
|
||||
converted_im = im.convert("LAB")
|
||||
assert converted_im.getpixel((0, 0)) == (255, 128, 128)
|
||||
|
||||
|
||||
def test_deprecation() -> None:
|
||||
with pytest.warns(DeprecationWarning):
|
||||
assert ImageCms.DESCRIPTION.strip().startswith("pyCMS")
|
||||
|
|
|
|||
|
|
@ -210,7 +210,7 @@ class MockPyDecoder(ImageFile.PyDecoder):
|
|||
|
||||
super().__init__(mode, *args)
|
||||
|
||||
def decode(self, buffer: bytes) -> tuple[int, int]:
|
||||
def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
|
||||
# eof
|
||||
return -1, 0
|
||||
|
||||
|
|
@ -238,7 +238,9 @@ class MockImageFile(ImageFile.ImageFile):
|
|||
self.rawmode = "RGBA"
|
||||
self._mode = "RGBA"
|
||||
self._size = (200, 200)
|
||||
self.tile = [("MOCK", (xoff, yoff, xoff + xsize, yoff + ysize), 32, None)]
|
||||
self.tile = [
|
||||
ImageFile._Tile("MOCK", (xoff, yoff, xoff + xsize, yoff + ysize), 32, None)
|
||||
]
|
||||
|
||||
|
||||
class CodecsTest:
|
||||
|
|
@ -268,7 +270,7 @@ class TestPyDecoder(CodecsTest):
|
|||
buf = BytesIO(b"\x00" * 255)
|
||||
|
||||
im = MockImageFile(buf)
|
||||
im.tile = [("MOCK", None, 32, None)]
|
||||
im.tile = [ImageFile._Tile("MOCK", None, 32, None)]
|
||||
|
||||
im.load()
|
||||
|
||||
|
|
@ -281,12 +283,12 @@ class TestPyDecoder(CodecsTest):
|
|||
buf = BytesIO(b"\x00" * 255)
|
||||
|
||||
im = MockImageFile(buf)
|
||||
im.tile = [("MOCK", (xoff, yoff, -10, yoff + ysize), 32, None)]
|
||||
im.tile = [ImageFile._Tile("MOCK", (xoff, yoff, -10, yoff + ysize), 32, None)]
|
||||
|
||||
with pytest.raises(ValueError):
|
||||
im.load()
|
||||
|
||||
im.tile = [("MOCK", (xoff, yoff, xoff + xsize, -10), 32, None)]
|
||||
im.tile = [ImageFile._Tile("MOCK", (xoff, yoff, xoff + xsize, -10), 32, None)]
|
||||
with pytest.raises(ValueError):
|
||||
im.load()
|
||||
|
||||
|
|
@ -294,12 +296,20 @@ class TestPyDecoder(CodecsTest):
|
|||
buf = BytesIO(b"\x00" * 255)
|
||||
|
||||
im = MockImageFile(buf)
|
||||
im.tile = [("MOCK", (xoff, yoff, xoff + xsize + 100, yoff + ysize), 32, None)]
|
||||
im.tile = [
|
||||
ImageFile._Tile(
|
||||
"MOCK", (xoff, yoff, xoff + xsize + 100, yoff + ysize), 32, None
|
||||
)
|
||||
]
|
||||
|
||||
with pytest.raises(ValueError):
|
||||
im.load()
|
||||
|
||||
im.tile = [("MOCK", (xoff, yoff, xoff + xsize, yoff + ysize + 100), 32, None)]
|
||||
im.tile = [
|
||||
ImageFile._Tile(
|
||||
"MOCK", (xoff, yoff, xoff + xsize, yoff + ysize + 100), 32, None
|
||||
)
|
||||
]
|
||||
with pytest.raises(ValueError):
|
||||
im.load()
|
||||
|
||||
|
|
@ -336,7 +346,7 @@ class TestPyEncoder(CodecsTest):
|
|||
buf = BytesIO(b"\x00" * 255)
|
||||
|
||||
im = MockImageFile(buf)
|
||||
im.tile = [("MOCK", None, 32, None)]
|
||||
im.tile = [ImageFile._Tile("MOCK", None, 32, None)]
|
||||
|
||||
fp = BytesIO()
|
||||
ImageFile._save(im, fp, [ImageFile._Tile("MOCK", None, 0, "RGB")])
|
||||
|
|
|
|||
|
|
@ -1140,6 +1140,9 @@ def test_bytes(font: ImageFont.FreeTypeFont) -> None:
|
|||
)
|
||||
assert font.getmask2(b"test")[1] == font.getmask2("test")[1]
|
||||
|
||||
with pytest.raises(TypeError):
|
||||
font.getlength((0, 0)) # type: ignore[arg-type]
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"test_file",
|
||||
|
|
@ -1174,3 +1177,15 @@ def test_invalid_truetype_sizes_raise_valueerror(
|
|||
) -> None:
|
||||
with pytest.raises(ValueError):
|
||||
ImageFont.truetype(FONT_PATH, size, layout_engine=layout_engine)
|
||||
|
||||
|
||||
def test_freetype_deprecation(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
# Arrange: mock features.version_module to return fake FreeType version
|
||||
def fake_version_module(module: str) -> str:
|
||||
return "2.9.0"
|
||||
|
||||
monkeypatch.setattr(features, "version_module", fake_version_module)
|
||||
|
||||
# Act / Assert
|
||||
with pytest.warns(DeprecationWarning):
|
||||
ImageFont.truetype(FONT_PATH, FONT_SIZE)
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
# install libimagequant
|
||||
|
||||
archive_name=libimagequant
|
||||
archive_version=4.3.1
|
||||
archive_version=4.3.3
|
||||
|
||||
archive=$archive_name-$archive_version
|
||||
|
||||
|
|
|
|||
|
|
@ -121,7 +121,7 @@ nitpicky = True
|
|||
# generating warnings in “nitpicky mode”. Note that type should include the domain name
|
||||
# if present. Example entries would be ('py:func', 'int') or
|
||||
# ('envvar', 'LD_LIBRARY_PATH').
|
||||
# nitpick_ignore = []
|
||||
nitpick_ignore = [("py:class", "_io.BytesIO")]
|
||||
|
||||
|
||||
# -- Options for HTML output ----------------------------------------------
|
||||
|
|
|
|||
|
|
@ -109,6 +109,35 @@ ImageDraw.getdraw hints parameter
|
|||
|
||||
The ``hints`` parameter in :py:meth:`~PIL.ImageDraw.getdraw()` has been deprecated.
|
||||
|
||||
FreeType 2.9.0
|
||||
^^^^^^^^^^^^^^
|
||||
|
||||
.. deprecated:: 11.0.0
|
||||
|
||||
Support for FreeType 2.9.0 is deprecated and will be removed in Pillow 12.0.0
|
||||
(2025-10-15), when FreeType 2.9.1 will be the minimum supported.
|
||||
|
||||
We recommend upgrading to at least FreeType `2.10.4`_, which fixed a severe
|
||||
vulnerability introduced in FreeType 2.6 (:cve:`2020-15999`).
|
||||
|
||||
.. _2.10.4: https://sourceforge.net/projects/freetype/files/freetype2/2.10.4/
|
||||
|
||||
ICNS (width, height, scale) sizes
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. deprecated:: 11.0.0
|
||||
|
||||
Setting an ICNS image size to ``(width, height, scale)`` before loading has been
|
||||
deprecated. Instead, ``load(scale)`` can be used.
|
||||
|
||||
Image isImageType()
|
||||
^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. deprecated:: 11.0.0
|
||||
|
||||
``Image.isImageType(im)`` has been deprecated. Use ``isinstance(im, Image.Image)``
|
||||
instead.
|
||||
|
||||
ImageMath.lambda_eval and ImageMath.unsafe_eval options parameter
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
|
|
@ -142,6 +171,13 @@ Removed features
|
|||
Deprecated features are only removed in major releases after an appropriate
|
||||
period of deprecation has passed.
|
||||
|
||||
TiffImagePlugin IFD_LEGACY_API
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
.. versionremoved:: 11.0.0
|
||||
|
||||
``TiffImagePlugin.IFD_LEGACY_API`` was removed, as it was an unused setting.
|
||||
|
||||
PSFile
|
||||
~~~~~~
|
||||
|
||||
|
|
|
|||
|
|
@ -246,7 +246,9 @@ class DdsImageFile(ImageFile.ImageFile):
|
|||
msg = f"Unimplemented pixel format {repr(fourcc)}"
|
||||
raise NotImplementedError(msg)
|
||||
|
||||
self.tile = [(self.decoder, (0, 0) + self.size, 0, (self.mode, 0, 1))]
|
||||
self.tile = [
|
||||
ImageFile._Tile(self.decoder, (0, 0) + self.size, 0, (self.mode, 0, 1))
|
||||
]
|
||||
|
||||
def load_seek(self, pos: int) -> None:
|
||||
pass
|
||||
|
|
@ -255,7 +257,7 @@ class DdsImageFile(ImageFile.ImageFile):
|
|||
class DXT1Decoder(ImageFile.PyDecoder):
|
||||
_pulls_fd = True
|
||||
|
||||
def decode(self, buffer: bytes) -> tuple[int, int]:
|
||||
def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
|
||||
assert self.fd is not None
|
||||
try:
|
||||
self.set_as_raw(_dxt1(self.fd, self.state.xsize, self.state.ysize))
|
||||
|
|
@ -268,7 +270,7 @@ class DXT1Decoder(ImageFile.PyDecoder):
|
|||
class DXT5Decoder(ImageFile.PyDecoder):
|
||||
_pulls_fd = True
|
||||
|
||||
def decode(self, buffer: bytes) -> tuple[int, int]:
|
||||
def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
|
||||
assert self.fd is not None
|
||||
try:
|
||||
self.set_as_raw(_dxt5(self.fd, self.state.xsize, self.state.ysize))
|
||||
|
|
|
|||
|
|
@ -324,12 +324,19 @@ sets the following :py:attr:`~PIL.Image.Image.info` property:
|
|||
**sizes**
|
||||
A list of supported sizes found in this icon file; these are a
|
||||
3-tuple, ``(width, height, scale)``, where ``scale`` is 2 for a retina
|
||||
icon and 1 for a standard icon. You *are* permitted to use this 3-tuple
|
||||
format for the :py:attr:`~PIL.Image.Image.size` property if you set it
|
||||
before calling :py:meth:`~PIL.Image.Image.load`; after loading, the size
|
||||
will be reset to a 2-tuple containing pixel dimensions (so, e.g. if you
|
||||
ask for ``(512, 512, 2)``, the final value of
|
||||
:py:attr:`~PIL.Image.Image.size` will be ``(1024, 1024)``).
|
||||
icon and 1 for a standard icon.
|
||||
|
||||
.. _icns-loading:
|
||||
|
||||
Loading
|
||||
~~~~~~~
|
||||
|
||||
You can call the :py:meth:`~PIL.Image.Image.load` method with the following parameter.
|
||||
|
||||
**scale**
|
||||
Affects the scale of the resultant image. If the size is set to ``(512, 512)``,
|
||||
after loading at scale 2, the final value of :py:attr:`~PIL.Image.Image.size` will
|
||||
be ``(1024, 1024)``.
|
||||
|
||||
.. _icns-saving:
|
||||
|
||||
|
|
|
|||
|
|
@ -64,7 +64,7 @@ Many of Pillow's features require external libraries:
|
|||
|
||||
* **libimagequant** provides improved color quantization
|
||||
|
||||
* Pillow has been tested with libimagequant **2.6-4.3.1**
|
||||
* Pillow has been tested with libimagequant **2.6-4.3.3**
|
||||
* Libimagequant is licensed GPLv3, which is more restrictive than
|
||||
the Pillow license, therefore we will not be distributing binaries
|
||||
with libimagequant support enabled.
|
||||
|
|
|
|||
|
|
@ -33,6 +33,14 @@ Internal Modules
|
|||
Provides a convenient way to import type hints that are not available
|
||||
on some Python versions.
|
||||
|
||||
.. py:class:: Buffer
|
||||
|
||||
Typing alias.
|
||||
|
||||
.. py:class:: IntegralLike
|
||||
|
||||
Typing alias.
|
||||
|
||||
.. py:class:: NumpyArray
|
||||
|
||||
Typing alias.
|
||||
|
|
|
|||
|
|
@ -40,12 +40,53 @@ removed. Pillow's C API will now be used on PyPy instead.
|
|||
``Image.USE_CFFI_ACCESS``, for switching from the C API to PyAccess, was
|
||||
similarly removed.
|
||||
|
||||
TiffImagePlugin IFD_LEGACY_API
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
An unused setting, ``TiffImagePlugin.IFD_LEGACY_API``, has been removed.
|
||||
|
||||
WebP 0.4
|
||||
^^^^^^^^
|
||||
|
||||
Support for WebP 0.4 and earlier has been removed; WebP 0.5 is the minimum supported.
|
||||
|
||||
Deprecations
|
||||
============
|
||||
|
||||
FreeType 2.9.0
|
||||
^^^^^^^^^^^^^^
|
||||
|
||||
.. deprecated:: 11.0.0
|
||||
|
||||
Support for FreeType 2.9.0 is deprecated and will be removed in Pillow 12.0.0
|
||||
(2025-10-15), when FreeType 2.9.1 will be the minimum supported.
|
||||
|
||||
We recommend upgrading to at least FreeType `2.10.4`_, which fixed a severe
|
||||
vulnerability introduced in FreeType 2.6 (:cve:`2020-15999`).
|
||||
|
||||
.. _2.10.4: https://sourceforge.net/projects/freetype/files/freetype2/2.10.4/
|
||||
|
||||
ICNS (width, height, scale) sizes
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. deprecated:: 11.0.0
|
||||
|
||||
Setting an ICNS image size to ``(width, height, scale)`` before loading has been
|
||||
deprecated. Instead, ``load(scale)`` can be used.
|
||||
|
||||
Image isImageType()
|
||||
^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. deprecated:: 11.0.0
|
||||
|
||||
``Image.isImageType(im)`` has been deprecated. Use ``isinstance(im, Image.Image)``
|
||||
instead.
|
||||
|
||||
ImageMath.lambda_eval and ImageMath.unsafe_eval options parameter
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. deprecated:: 11.0.0
|
||||
|
||||
The ``options`` parameter in :py:meth:`~PIL.ImageMath.lambda_eval()` and
|
||||
:py:meth:`~PIL.ImageMath.unsafe_eval()` has been deprecated. One or more
|
||||
keyword arguments can be used instead.
|
||||
|
|
@ -61,6 +102,8 @@ have been deprecated, and will be removed in Pillow 12 (2025-10-15).
|
|||
Specific WebP Feature Checks
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. deprecated:: 11.0.0
|
||||
|
||||
``features.check("transp_webp")``, ``features.check("webp_mux")`` and
|
||||
``features.check("webp_anim")`` are now deprecated. They will always return
|
||||
``True`` if the WebP module is installed, until they are removed in Pillow
|
||||
|
|
@ -77,10 +120,18 @@ TODO
|
|||
API Additions
|
||||
=============
|
||||
|
||||
TODO
|
||||
^^^^
|
||||
Writing XMP bytes to JPEG and MPO
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
TODO
|
||||
XMP data can now be saved to JPEG files using an ``xmp`` argument::
|
||||
|
||||
im.save("out.jpg", xmp=b"test")
|
||||
|
||||
The data can also be set through :py:attr:`~PIL.Image.Image.info`, for use when saving
|
||||
either JPEG or MPO images::
|
||||
|
||||
im.info["xmp"] = b"test"
|
||||
im.save("out.jpg")
|
||||
|
||||
Other Changes
|
||||
=============
|
||||
|
|
@ -94,6 +145,8 @@ of 3.13.0 final (2024-10-01, :pep:`719`).
|
|||
|
||||
Pillow 11.0.0 now officially supports Python 3.13.
|
||||
|
||||
Support has also been added for the experimental free-threaded mode of :pep:`703`.
|
||||
|
||||
C-level Flags
|
||||
^^^^^^^^^^^^^
|
||||
|
||||
|
|
|
|||
|
|
@ -163,7 +163,3 @@ follow_imports = "silent"
|
|||
warn_redundant_casts = true
|
||||
warn_unreachable = true
|
||||
warn_unused_ignores = true
|
||||
exclude = [
|
||||
'^Tests/oss-fuzz/fuzz_font.py$',
|
||||
'^Tests/oss-fuzz/fuzz_pillow.py$',
|
||||
]
|
||||
|
|
|
|||
249
setup.py
249
setup.py
|
|
@ -15,18 +15,20 @@ import struct
|
|||
import subprocess
|
||||
import sys
|
||||
import warnings
|
||||
from collections.abc import Iterator
|
||||
from typing import Any
|
||||
|
||||
from setuptools import Extension, setup
|
||||
from setuptools.command.build_ext import build_ext
|
||||
|
||||
|
||||
def get_version():
|
||||
def get_version() -> str:
|
||||
version_file = "src/PIL/_version.py"
|
||||
with open(version_file, encoding="utf-8") as f:
|
||||
return f.read().split('"')[1]
|
||||
|
||||
|
||||
configuration = {}
|
||||
configuration: dict[str, list[str]] = {}
|
||||
|
||||
|
||||
PILLOW_VERSION = get_version()
|
||||
|
|
@ -143,7 +145,7 @@ class RequiredDependencyException(Exception):
|
|||
PLATFORM_MINGW = os.name == "nt" and "GCC" in sys.version
|
||||
|
||||
|
||||
def _dbg(s, tp=None):
|
||||
def _dbg(s: str, tp: Any = None) -> None:
|
||||
if DEBUG:
|
||||
if tp:
|
||||
print(s % tp)
|
||||
|
|
@ -151,10 +153,13 @@ def _dbg(s, tp=None):
|
|||
print(s)
|
||||
|
||||
|
||||
def _find_library_dirs_ldconfig():
|
||||
def _find_library_dirs_ldconfig() -> list[str]:
|
||||
# Based on ctypes.util from Python 2
|
||||
|
||||
ldconfig = "ldconfig" if shutil.which("ldconfig") else "/sbin/ldconfig"
|
||||
args: list[str]
|
||||
env: dict[str, str]
|
||||
expr: str
|
||||
if sys.platform.startswith("linux") or sys.platform.startswith("gnu"):
|
||||
if struct.calcsize("l") == 4:
|
||||
machine = os.uname()[4] + "-32"
|
||||
|
|
@ -184,13 +189,11 @@ def _find_library_dirs_ldconfig():
|
|||
|
||||
try:
|
||||
p = subprocess.Popen(
|
||||
args, stderr=subprocess.DEVNULL, stdout=subprocess.PIPE, env=env
|
||||
args, stderr=subprocess.DEVNULL, stdout=subprocess.PIPE, env=env, text=True
|
||||
)
|
||||
except OSError: # E.g. command not found
|
||||
return []
|
||||
[data, _] = p.communicate()
|
||||
if isinstance(data, bytes):
|
||||
data = data.decode("latin1")
|
||||
data = p.communicate()[0]
|
||||
|
||||
dirs = []
|
||||
for dll in re.findall(expr, data):
|
||||
|
|
@ -200,7 +203,9 @@ def _find_library_dirs_ldconfig():
|
|||
return dirs
|
||||
|
||||
|
||||
def _add_directory(path, subdir, where=None):
|
||||
def _add_directory(
|
||||
path: list[str], subdir: str | None, where: int | None = None
|
||||
) -> None:
|
||||
if subdir is None:
|
||||
return
|
||||
subdir = os.path.realpath(subdir)
|
||||
|
|
@ -216,7 +221,7 @@ def _add_directory(path, subdir, where=None):
|
|||
path.insert(where, subdir)
|
||||
|
||||
|
||||
def _find_include_file(self, include):
|
||||
def _find_include_file(self: pil_build_ext, include: str) -> int:
|
||||
for directory in self.compiler.include_dirs:
|
||||
_dbg("Checking for include file %s in %s", (include, directory))
|
||||
if os.path.isfile(os.path.join(directory, include)):
|
||||
|
|
@ -225,7 +230,7 @@ def _find_include_file(self, include):
|
|||
return 0
|
||||
|
||||
|
||||
def _find_library_file(self, library):
|
||||
def _find_library_file(self: pil_build_ext, library: str) -> str | None:
|
||||
ret = self.compiler.find_library_file(self.compiler.library_dirs, library)
|
||||
if ret:
|
||||
_dbg("Found library %s at %s", (library, ret))
|
||||
|
|
@ -234,7 +239,7 @@ def _find_library_file(self, library):
|
|||
return ret
|
||||
|
||||
|
||||
def _find_include_dir(self, dirname, include):
|
||||
def _find_include_dir(self: pil_build_ext, dirname: str, include: str) -> bool | str:
|
||||
for directory in self.compiler.include_dirs:
|
||||
_dbg("Checking for include file %s in %s", (include, directory))
|
||||
if os.path.isfile(os.path.join(directory, include)):
|
||||
|
|
@ -245,6 +250,7 @@ def _find_include_dir(self, dirname, include):
|
|||
if os.path.isfile(os.path.join(subdir, include)):
|
||||
_dbg("Found %s in %s", (include, subdir))
|
||||
return subdir
|
||||
return False
|
||||
|
||||
|
||||
def _cmd_exists(cmd: str) -> bool:
|
||||
|
|
@ -256,7 +262,7 @@ def _cmd_exists(cmd: str) -> bool:
|
|||
)
|
||||
|
||||
|
||||
def _pkg_config(name):
|
||||
def _pkg_config(name: str) -> tuple[list[str], list[str]] | None:
|
||||
command = os.environ.get("PKG_CONFIG", "pkg-config")
|
||||
for keep_system in (True, False):
|
||||
try:
|
||||
|
|
@ -283,10 +289,11 @@ def _pkg_config(name):
|
|||
return libs, cflags
|
||||
except Exception:
|
||||
pass
|
||||
return None
|
||||
|
||||
|
||||
class pil_build_ext(build_ext):
|
||||
class feature:
|
||||
class ext_feature:
|
||||
features = [
|
||||
"zlib",
|
||||
"jpeg",
|
||||
|
|
@ -301,25 +308,32 @@ class pil_build_ext(build_ext):
|
|||
]
|
||||
|
||||
required = {"jpeg", "zlib"}
|
||||
vendor = set()
|
||||
vendor: set[str] = set()
|
||||
|
||||
def __init__(self):
|
||||
def __init__(self) -> None:
|
||||
self._settings: dict[str, str | bool | None] = {}
|
||||
for f in self.features:
|
||||
setattr(self, f, None)
|
||||
self.set(f, None)
|
||||
|
||||
def require(self, feat):
|
||||
def require(self, feat: str) -> bool:
|
||||
return feat in self.required
|
||||
|
||||
def want(self, feat):
|
||||
return getattr(self, feat) is None
|
||||
def get(self, feat: str) -> str | bool | None:
|
||||
return self._settings[feat]
|
||||
|
||||
def want_vendor(self, feat):
|
||||
def set(self, feat: str, value: str | bool | None) -> None:
|
||||
self._settings[feat] = value
|
||||
|
||||
def want(self, feat: str) -> bool:
|
||||
return self._settings[feat] is None
|
||||
|
||||
def want_vendor(self, feat: str) -> bool:
|
||||
return feat in self.vendor
|
||||
|
||||
def __iter__(self):
|
||||
def __iter__(self) -> Iterator[str]:
|
||||
yield from self.features
|
||||
|
||||
feature = feature()
|
||||
feature = ext_feature()
|
||||
|
||||
user_options = (
|
||||
build_ext.user_options
|
||||
|
|
@ -337,10 +351,10 @@ class pil_build_ext(build_ext):
|
|||
)
|
||||
|
||||
@staticmethod
|
||||
def check_configuration(option, value):
|
||||
def check_configuration(option: str, value: str) -> bool | None:
|
||||
return True if value in configuration.get(option, []) else None
|
||||
|
||||
def initialize_options(self):
|
||||
def initialize_options(self) -> None:
|
||||
self.disable_platform_guessing = self.check_configuration(
|
||||
"platform-guessing", "disable"
|
||||
)
|
||||
|
|
@ -355,7 +369,7 @@ class pil_build_ext(build_ext):
|
|||
self.debug = True
|
||||
self.parallel = configuration.get("parallel", [None])[-1]
|
||||
|
||||
def finalize_options(self):
|
||||
def finalize_options(self) -> None:
|
||||
build_ext.finalize_options(self)
|
||||
if self.debug:
|
||||
global DEBUG
|
||||
|
|
@ -363,12 +377,16 @@ class pil_build_ext(build_ext):
|
|||
if not self.parallel:
|
||||
# If --parallel (or -j) wasn't specified, we want to reproduce the same
|
||||
# behavior as before, that is, auto-detect the number of jobs.
|
||||
self.parallel = None
|
||||
|
||||
cpu_count = os.cpu_count()
|
||||
if cpu_count is not None:
|
||||
try:
|
||||
self.parallel = int(
|
||||
os.environ.get("MAX_CONCURRENCY", min(4, os.cpu_count()))
|
||||
os.environ.get("MAX_CONCURRENCY", min(4, cpu_count))
|
||||
)
|
||||
except TypeError:
|
||||
self.parallel = None
|
||||
pass
|
||||
for x in self.feature:
|
||||
if getattr(self, f"disable_{x}"):
|
||||
setattr(self.feature, x, False)
|
||||
|
|
@ -402,7 +420,13 @@ class pil_build_ext(build_ext):
|
|||
_dbg("Using vendored version of %s", x)
|
||||
self.feature.vendor.add(x)
|
||||
|
||||
def _update_extension(self, name, libraries, define_macros=None, sources=None):
|
||||
def _update_extension(
|
||||
self,
|
||||
name: str,
|
||||
libraries: list[str] | list[str | bool | None],
|
||||
define_macros: list[tuple[str, str | None]] | None = None,
|
||||
sources: list[str] | None = None,
|
||||
) -> None:
|
||||
for extension in self.extensions:
|
||||
if extension.name == name:
|
||||
extension.libraries += libraries
|
||||
|
|
@ -415,13 +439,13 @@ class pil_build_ext(build_ext):
|
|||
extension.extra_link_args = ["--stdlib=libc++"]
|
||||
break
|
||||
|
||||
def _remove_extension(self, name):
|
||||
def _remove_extension(self, name: str) -> None:
|
||||
for extension in self.extensions:
|
||||
if extension.name == name:
|
||||
self.extensions.remove(extension)
|
||||
break
|
||||
|
||||
def get_macos_sdk_path(self):
|
||||
def get_macos_sdk_path(self) -> str | None:
|
||||
try:
|
||||
sdk_path = (
|
||||
subprocess.check_output(["xcrun", "--show-sdk-path"])
|
||||
|
|
@ -442,9 +466,9 @@ class pil_build_ext(build_ext):
|
|||
sdk_path = commandlinetools_sdk_path
|
||||
return sdk_path
|
||||
|
||||
def build_extensions(self):
|
||||
library_dirs = []
|
||||
include_dirs = []
|
||||
def build_extensions(self) -> None:
|
||||
library_dirs: list[str] = []
|
||||
include_dirs: list[str] = []
|
||||
|
||||
pkg_config = None
|
||||
if _cmd_exists(os.environ.get("PKG_CONFIG", "pkg-config")):
|
||||
|
|
@ -468,19 +492,22 @@ class pil_build_ext(build_ext):
|
|||
root = globals()[root_name]
|
||||
|
||||
if root is None and root_name in os.environ:
|
||||
prefix = os.environ[root_name]
|
||||
root = (os.path.join(prefix, "lib"), os.path.join(prefix, "include"))
|
||||
root_prefix = os.environ[root_name]
|
||||
root = (
|
||||
os.path.join(root_prefix, "lib"),
|
||||
os.path.join(root_prefix, "include"),
|
||||
)
|
||||
|
||||
if root is None and pkg_config:
|
||||
if isinstance(lib_name, tuple):
|
||||
if isinstance(lib_name, str):
|
||||
_dbg(f"Looking for `{lib_name}` using pkg-config.")
|
||||
root = pkg_config(lib_name)
|
||||
else:
|
||||
for lib_name2 in lib_name:
|
||||
_dbg(f"Looking for `{lib_name2}` using pkg-config.")
|
||||
root = pkg_config(lib_name2)
|
||||
if root:
|
||||
break
|
||||
else:
|
||||
_dbg(f"Looking for `{lib_name}` using pkg-config.")
|
||||
root = pkg_config(lib_name)
|
||||
|
||||
if isinstance(root, tuple):
|
||||
lib_root, include_root = root
|
||||
|
|
@ -660,22 +687,22 @@ class pil_build_ext(build_ext):
|
|||
_dbg("Looking for zlib")
|
||||
if _find_include_file(self, "zlib.h"):
|
||||
if _find_library_file(self, "z"):
|
||||
feature.zlib = "z"
|
||||
feature.set("zlib", "z")
|
||||
elif sys.platform == "win32" and _find_library_file(self, "zlib"):
|
||||
feature.zlib = "zlib" # alternative name
|
||||
feature.set("zlib", "zlib") # alternative name
|
||||
|
||||
if feature.want("jpeg"):
|
||||
_dbg("Looking for jpeg")
|
||||
if _find_include_file(self, "jpeglib.h"):
|
||||
if _find_library_file(self, "jpeg"):
|
||||
feature.jpeg = "jpeg"
|
||||
feature.set("jpeg", "jpeg")
|
||||
elif sys.platform == "win32" and _find_library_file(self, "libjpeg"):
|
||||
feature.jpeg = "libjpeg" # alternative name
|
||||
feature.set("jpeg", "libjpeg") # alternative name
|
||||
|
||||
feature.openjpeg_version = None
|
||||
feature.set("openjpeg_version", None)
|
||||
if feature.want("jpeg2000"):
|
||||
_dbg("Looking for jpeg2000")
|
||||
best_version = None
|
||||
best_version: tuple[int, ...] | None = None
|
||||
best_path = None
|
||||
|
||||
# Find the best version
|
||||
|
|
@ -705,26 +732,26 @@ class pil_build_ext(build_ext):
|
|||
# <openjpeg.h> rather than having to cope with the versioned
|
||||
# include path
|
||||
_add_directory(self.compiler.include_dirs, best_path, 0)
|
||||
feature.jpeg2000 = "openjp2"
|
||||
feature.openjpeg_version = ".".join(str(x) for x in best_version)
|
||||
feature.set("jpeg2000", "openjp2")
|
||||
feature.set("openjpeg_version", ".".join(str(x) for x in best_version))
|
||||
|
||||
if feature.want("imagequant"):
|
||||
_dbg("Looking for imagequant")
|
||||
if _find_include_file(self, "libimagequant.h"):
|
||||
if _find_library_file(self, "imagequant"):
|
||||
feature.imagequant = "imagequant"
|
||||
feature.set("imagequant", "imagequant")
|
||||
elif _find_library_file(self, "libimagequant"):
|
||||
feature.imagequant = "libimagequant"
|
||||
feature.set("imagequant", "libimagequant")
|
||||
|
||||
if feature.want("tiff"):
|
||||
_dbg("Looking for tiff")
|
||||
if _find_include_file(self, "tiff.h"):
|
||||
if _find_library_file(self, "tiff"):
|
||||
feature.tiff = "tiff"
|
||||
feature.set("tiff", "tiff")
|
||||
if sys.platform in ["win32", "darwin"] and _find_library_file(
|
||||
self, "libtiff"
|
||||
):
|
||||
feature.tiff = "libtiff"
|
||||
feature.set("tiff", "libtiff")
|
||||
|
||||
if feature.want("freetype"):
|
||||
_dbg("Looking for freetype")
|
||||
|
|
@ -745,31 +772,31 @@ class pil_build_ext(build_ext):
|
|||
freetype_version = 21
|
||||
break
|
||||
if freetype_version:
|
||||
feature.freetype = "freetype"
|
||||
feature.set("freetype", "freetype")
|
||||
if subdir:
|
||||
_add_directory(self.compiler.include_dirs, subdir, 0)
|
||||
|
||||
if feature.freetype and feature.want("raqm"):
|
||||
if feature.get("freetype") and feature.want("raqm"):
|
||||
if not feature.want_vendor("raqm"): # want system Raqm
|
||||
_dbg("Looking for Raqm")
|
||||
if _find_include_file(self, "raqm.h"):
|
||||
if _find_library_file(self, "raqm"):
|
||||
feature.raqm = "raqm"
|
||||
feature.set("raqm", "raqm")
|
||||
elif _find_library_file(self, "libraqm"):
|
||||
feature.raqm = "libraqm"
|
||||
feature.set("raqm", "libraqm")
|
||||
else: # want to build Raqm from src/thirdparty
|
||||
_dbg("Looking for HarfBuzz")
|
||||
feature.harfbuzz = None
|
||||
feature.set("harfbuzz", None)
|
||||
hb_dir = _find_include_dir(self, "harfbuzz", "hb.h")
|
||||
if hb_dir:
|
||||
if isinstance(hb_dir, str):
|
||||
_add_directory(self.compiler.include_dirs, hb_dir, 0)
|
||||
if _find_library_file(self, "harfbuzz"):
|
||||
feature.harfbuzz = "harfbuzz"
|
||||
if feature.harfbuzz:
|
||||
feature.set("harfbuzz", "harfbuzz")
|
||||
if feature.get("harfbuzz"):
|
||||
if not feature.want_vendor("fribidi"): # want system FriBiDi
|
||||
_dbg("Looking for FriBiDi")
|
||||
feature.fribidi = None
|
||||
feature.set("fribidi", None)
|
||||
fribidi_dir = _find_include_dir(self, "fribidi", "fribidi.h")
|
||||
if fribidi_dir:
|
||||
if isinstance(fribidi_dir, str):
|
||||
|
|
@ -777,19 +804,19 @@ class pil_build_ext(build_ext):
|
|||
self.compiler.include_dirs, fribidi_dir, 0
|
||||
)
|
||||
if _find_library_file(self, "fribidi"):
|
||||
feature.fribidi = "fribidi"
|
||||
feature.raqm = True
|
||||
feature.set("fribidi", "fribidi")
|
||||
feature.set("raqm", True)
|
||||
else: # want to build FriBiDi shim from src/thirdparty
|
||||
feature.raqm = True
|
||||
feature.set("raqm", True)
|
||||
|
||||
if feature.want("lcms"):
|
||||
_dbg("Looking for lcms")
|
||||
if _find_include_file(self, "lcms2.h"):
|
||||
if _find_library_file(self, "lcms2"):
|
||||
feature.lcms = "lcms2"
|
||||
feature.set("lcms", "lcms2")
|
||||
elif _find_library_file(self, "lcms2_static"):
|
||||
# alternate Windows name.
|
||||
feature.lcms = "lcms2_static"
|
||||
feature.set("lcms", "lcms2_static")
|
||||
|
||||
if feature.want("webp"):
|
||||
_dbg("Looking for webp")
|
||||
|
|
@ -803,17 +830,17 @@ class pil_build_ext(build_ext):
|
|||
_find_library_file(self, prefix + library)
|
||||
for library in ("webp", "webpmux", "webpdemux")
|
||||
):
|
||||
feature.webp = prefix + "webp"
|
||||
feature.set("webp", prefix + "webp")
|
||||
break
|
||||
|
||||
if feature.want("xcb"):
|
||||
_dbg("Looking for xcb")
|
||||
if _find_include_file(self, "xcb/xcb.h"):
|
||||
if _find_library_file(self, "xcb"):
|
||||
feature.xcb = "xcb"
|
||||
feature.set("xcb", "xcb")
|
||||
|
||||
for f in feature:
|
||||
if not getattr(feature, f) and feature.require(f):
|
||||
if not feature.get(f) and feature.require(f):
|
||||
if f in ("jpeg", "zlib"):
|
||||
raise RequiredDependencyException(f)
|
||||
raise DependencyException(f)
|
||||
|
|
@ -821,10 +848,11 @@ class pil_build_ext(build_ext):
|
|||
#
|
||||
# core library
|
||||
|
||||
libs = self.add_imaging_libs.split()
|
||||
defs = []
|
||||
if feature.tiff:
|
||||
libs.append(feature.tiff)
|
||||
libs: list[str | bool | None] = []
|
||||
libs.extend(self.add_imaging_libs.split())
|
||||
defs: list[tuple[str, str | None]] = []
|
||||
if feature.get("tiff"):
|
||||
libs.append(feature.get("tiff"))
|
||||
defs.append(("HAVE_LIBTIFF", None))
|
||||
if sys.platform == "win32":
|
||||
# This define needs to be defined if-and-only-if it was defined
|
||||
|
|
@ -832,22 +860,22 @@ class pil_build_ext(build_ext):
|
|||
# so we have to guess; by default it is defined in all Windows builds.
|
||||
# See #4237, #5243, #5359 for more information.
|
||||
defs.append(("USE_WIN32_FILEIO", None))
|
||||
if feature.jpeg:
|
||||
libs.append(feature.jpeg)
|
||||
if feature.get("jpeg"):
|
||||
libs.append(feature.get("jpeg"))
|
||||
defs.append(("HAVE_LIBJPEG", None))
|
||||
if feature.jpeg2000:
|
||||
libs.append(feature.jpeg2000)
|
||||
if feature.get("jpeg2000"):
|
||||
libs.append(feature.get("jpeg2000"))
|
||||
defs.append(("HAVE_OPENJPEG", None))
|
||||
if sys.platform == "win32" and not PLATFORM_MINGW:
|
||||
defs.append(("OPJ_STATIC", None))
|
||||
if feature.zlib:
|
||||
libs.append(feature.zlib)
|
||||
if feature.get("zlib"):
|
||||
libs.append(feature.get("zlib"))
|
||||
defs.append(("HAVE_LIBZ", None))
|
||||
if feature.imagequant:
|
||||
libs.append(feature.imagequant)
|
||||
if feature.get("imagequant"):
|
||||
libs.append(feature.get("imagequant"))
|
||||
defs.append(("HAVE_LIBIMAGEQUANT", None))
|
||||
if feature.xcb:
|
||||
libs.append(feature.xcb)
|
||||
if feature.get("xcb"):
|
||||
libs.append(feature.get("xcb"))
|
||||
defs.append(("HAVE_XCB", None))
|
||||
if sys.platform == "win32":
|
||||
libs.extend(["kernel32", "user32", "gdi32"])
|
||||
|
|
@ -861,22 +889,22 @@ class pil_build_ext(build_ext):
|
|||
#
|
||||
# additional libraries
|
||||
|
||||
if feature.freetype:
|
||||
if feature.get("freetype"):
|
||||
srcs = []
|
||||
libs = ["freetype"]
|
||||
defs = []
|
||||
if feature.raqm:
|
||||
if feature.get("raqm"):
|
||||
if not feature.want_vendor("raqm"): # using system Raqm
|
||||
defs.append(("HAVE_RAQM", None))
|
||||
defs.append(("HAVE_RAQM_SYSTEM", None))
|
||||
libs.append(feature.raqm)
|
||||
libs.append(feature.get("raqm"))
|
||||
else: # building Raqm from src/thirdparty
|
||||
defs.append(("HAVE_RAQM", None))
|
||||
srcs.append("src/thirdparty/raqm/raqm.c")
|
||||
libs.append(feature.harfbuzz)
|
||||
libs.append(feature.get("harfbuzz"))
|
||||
if not feature.want_vendor("fribidi"): # using system FriBiDi
|
||||
defs.append(("HAVE_FRIBIDI_SYSTEM", None))
|
||||
libs.append(feature.fribidi)
|
||||
libs.append(feature.get("fribidi"))
|
||||
else: # building FriBiDi shim from src/thirdparty
|
||||
srcs.append("src/thirdparty/fribidi-shim/fribidi.c")
|
||||
self._update_extension("PIL._imagingft", libs, defs, srcs)
|
||||
|
|
@ -884,16 +912,17 @@ class pil_build_ext(build_ext):
|
|||
else:
|
||||
self._remove_extension("PIL._imagingft")
|
||||
|
||||
if feature.lcms:
|
||||
extra = []
|
||||
if feature.get("lcms"):
|
||||
libs = [feature.get("lcms")]
|
||||
if sys.platform == "win32":
|
||||
extra.extend(["user32", "gdi32"])
|
||||
self._update_extension("PIL._imagingcms", [feature.lcms] + extra)
|
||||
libs.extend(["user32", "gdi32"])
|
||||
self._update_extension("PIL._imagingcms", libs)
|
||||
else:
|
||||
self._remove_extension("PIL._imagingcms")
|
||||
|
||||
if feature.webp:
|
||||
libs = [feature.webp, feature.webp + "mux", feature.webp + "demux"]
|
||||
webp = feature.get("webp")
|
||||
if isinstance(webp, str):
|
||||
libs = [webp, webp + "mux", webp + "demux"]
|
||||
self._update_extension("PIL._webp", libs)
|
||||
else:
|
||||
self._remove_extension("PIL._webp")
|
||||
|
|
@ -908,14 +937,14 @@ class pil_build_ext(build_ext):
|
|||
|
||||
self.summary_report(feature)
|
||||
|
||||
def summary_report(self, feature):
|
||||
def summary_report(self, feature: ext_feature) -> None:
|
||||
print("-" * 68)
|
||||
print("PIL SETUP SUMMARY")
|
||||
print("-" * 68)
|
||||
print(f"version Pillow {PILLOW_VERSION}")
|
||||
v = sys.version.split("[")
|
||||
print(f"platform {sys.platform} {v[0].strip()}")
|
||||
for v in v[1:]:
|
||||
version = sys.version.split("[")
|
||||
print(f"platform {sys.platform} {version[0].strip()}")
|
||||
for v in version[1:]:
|
||||
print(f" [{v.strip()}")
|
||||
print("-" * 68)
|
||||
|
||||
|
|
@ -926,16 +955,20 @@ class pil_build_ext(build_ext):
|
|||
raqm_extra_info += ", FriBiDi shim"
|
||||
|
||||
options = [
|
||||
(feature.jpeg, "JPEG"),
|
||||
(feature.jpeg2000, "OPENJPEG (JPEG2000)", feature.openjpeg_version),
|
||||
(feature.zlib, "ZLIB (PNG/ZIP)"),
|
||||
(feature.imagequant, "LIBIMAGEQUANT"),
|
||||
(feature.tiff, "LIBTIFF"),
|
||||
(feature.freetype, "FREETYPE2"),
|
||||
(feature.raqm, "RAQM (Text shaping)", raqm_extra_info),
|
||||
(feature.lcms, "LITTLECMS2"),
|
||||
(feature.webp, "WEBP"),
|
||||
(feature.xcb, "XCB (X protocol)"),
|
||||
(feature.get("jpeg"), "JPEG"),
|
||||
(
|
||||
feature.get("jpeg2000"),
|
||||
"OPENJPEG (JPEG2000)",
|
||||
feature.get("openjpeg_version"),
|
||||
),
|
||||
(feature.get("zlib"), "ZLIB (PNG/ZIP)"),
|
||||
(feature.get("imagequant"), "LIBIMAGEQUANT"),
|
||||
(feature.get("tiff"), "LIBTIFF"),
|
||||
(feature.get("freetype"), "FREETYPE2"),
|
||||
(feature.get("raqm"), "RAQM (Text shaping)", raqm_extra_info),
|
||||
(feature.get("lcms"), "LITTLECMS2"),
|
||||
(feature.get("webp"), "WEBP"),
|
||||
(feature.get("xcb"), "XCB (X protocol)"),
|
||||
]
|
||||
|
||||
all = 1
|
||||
|
|
@ -964,7 +997,7 @@ class pil_build_ext(build_ext):
|
|||
print("")
|
||||
|
||||
|
||||
def debug_build():
|
||||
def debug_build() -> bool:
|
||||
return hasattr(sys, "gettotalrefcount") or FUZZING_BUILD
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -273,13 +273,13 @@ class BlpImageFile(ImageFile.ImageFile):
|
|||
raise BLPFormatError(msg)
|
||||
|
||||
self._mode = "RGBA" if self._blp_alpha_depth else "RGB"
|
||||
self.tile = [(decoder, (0, 0) + self.size, 0, (self.mode, 0, 1))]
|
||||
self.tile = [ImageFile._Tile(decoder, (0, 0) + self.size, 0, (self.mode, 0, 1))]
|
||||
|
||||
|
||||
class _BLPBaseDecoder(ImageFile.PyDecoder):
|
||||
_pulls_fd = True
|
||||
|
||||
def decode(self, buffer: bytes) -> tuple[int, int]:
|
||||
def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
|
||||
try:
|
||||
self._read_blp_header()
|
||||
self._load()
|
||||
|
|
@ -372,7 +372,10 @@ class BLP1Decoder(_BLPBaseDecoder):
|
|||
Image._decompression_bomb_check(image.size)
|
||||
if image.mode == "CMYK":
|
||||
decoder_name, extents, offset, args = image.tile[0]
|
||||
image.tile = [(decoder_name, extents, offset, (args[0], "CMYK"))]
|
||||
assert isinstance(args, tuple)
|
||||
image.tile = [
|
||||
ImageFile._Tile(decoder_name, extents, offset, (args[0], "CMYK"))
|
||||
]
|
||||
r, g, b = image.convert("RGB").split()
|
||||
reversed_image = Image.merge("RGB", (b, g, r))
|
||||
self.set_as_raw(reversed_image.tobytes())
|
||||
|
|
|
|||
|
|
@ -296,7 +296,7 @@ class BmpImageFile(ImageFile.ImageFile):
|
|||
args.append(((file_info["width"] * file_info["bits"] + 31) >> 3) & (~3))
|
||||
args.append(file_info["direction"])
|
||||
self.tile = [
|
||||
(
|
||||
ImageFile._Tile(
|
||||
decoder_name,
|
||||
(0, 0, file_info["width"], file_info["height"]),
|
||||
offset or self.fp.tell(),
|
||||
|
|
@ -321,7 +321,7 @@ class BmpImageFile(ImageFile.ImageFile):
|
|||
class BmpRleDecoder(ImageFile.PyDecoder):
|
||||
_pulls_fd = True
|
||||
|
||||
def decode(self, buffer: bytes) -> tuple[int, int]:
|
||||
def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
|
||||
assert self.fd is not None
|
||||
rle4 = self.args[1]
|
||||
data = bytearray()
|
||||
|
|
@ -387,7 +387,7 @@ class BmpRleDecoder(ImageFile.PyDecoder):
|
|||
if self.fd.tell() % 2 != 0:
|
||||
self.fd.seek(1, os.SEEK_CUR)
|
||||
rawmode = "L" if self.mode == "L" else "P"
|
||||
self.set_as_raw(bytes(data), (rawmode, 0, self.args[-1]))
|
||||
self.set_as_raw(bytes(data), rawmode, (0, self.args[-1]))
|
||||
return -1, 0
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
#
|
||||
from __future__ import annotations
|
||||
|
||||
from . import BmpImagePlugin, Image
|
||||
from . import BmpImagePlugin, Image, ImageFile
|
||||
from ._binary import i16le as i16
|
||||
from ._binary import i32le as i32
|
||||
|
||||
|
|
@ -64,7 +64,7 @@ class CurImageFile(BmpImagePlugin.BmpImageFile):
|
|||
# patch up the bitmap height
|
||||
self._size = self.size[0], self.size[1] // 2
|
||||
d, e, o, a = self.tile[0]
|
||||
self.tile[0] = d, (0, 0) + self.size, o, a
|
||||
self.tile[0] = ImageFile._Tile(d, (0, 0) + self.size, o, a)
|
||||
|
||||
|
||||
#
|
||||
|
|
|
|||
|
|
@ -367,7 +367,7 @@ class DdsImageFile(ImageFile.ImageFile):
|
|||
mask_count = 3
|
||||
|
||||
masks = struct.unpack(f"<{mask_count}I", header.read(mask_count * 4))
|
||||
self.tile = [("dds_rgb", extents, 0, (bitcount, masks))]
|
||||
self.tile = [ImageFile._Tile("dds_rgb", extents, 0, (bitcount, masks))]
|
||||
return
|
||||
elif pfflags & DDPF.LUMINANCE:
|
||||
if bitcount == 8:
|
||||
|
|
@ -481,7 +481,7 @@ class DdsImageFile(ImageFile.ImageFile):
|
|||
class DdsRgbDecoder(ImageFile.PyDecoder):
|
||||
_pulls_fd = True
|
||||
|
||||
def decode(self, buffer: bytes) -> tuple[int, int]:
|
||||
def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
|
||||
assert self.fd is not None
|
||||
bitcount, masks = self.args
|
||||
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ class FitsImageFile(ImageFile.ImageFile):
|
|||
raise ValueError(msg)
|
||||
|
||||
offset += self.fp.tell() - 80
|
||||
self.tile = [(decoder_name, (0, 0) + self.size, offset, args)]
|
||||
self.tile = [ImageFile._Tile(decoder_name, (0, 0) + self.size, offset, args)]
|
||||
|
||||
def _get_size(
|
||||
self, headers: dict[bytes, bytes], prefix: bytes
|
||||
|
|
@ -126,7 +126,7 @@ class FitsImageFile(ImageFile.ImageFile):
|
|||
class FitsGzipDecoder(ImageFile.PyDecoder):
|
||||
_pulls_fd = True
|
||||
|
||||
def decode(self, buffer: bytes) -> tuple[int, int]:
|
||||
def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
|
||||
assert self.fd is not None
|
||||
value = gzip.decompress(self.fd.read())
|
||||
|
||||
|
|
|
|||
|
|
@ -159,7 +159,7 @@ class FliImageFile(ImageFile.ImageFile):
|
|||
framesize = i32(s)
|
||||
|
||||
self.decodermaxblock = framesize
|
||||
self.tile = [("fli", (0, 0) + self.size, self.__offset, None)]
|
||||
self.tile = [ImageFile._Tile("fli", (0, 0) + self.size, self.__offset, None)]
|
||||
|
||||
self.__offset += framesize
|
||||
|
||||
|
|
|
|||
|
|
@ -166,7 +166,7 @@ class FpxImageFile(ImageFile.ImageFile):
|
|||
|
||||
if compression == 0:
|
||||
self.tile.append(
|
||||
(
|
||||
ImageFile._Tile(
|
||||
"raw",
|
||||
(x, y, x1, y1),
|
||||
i32(s, i) + 28,
|
||||
|
|
@ -177,7 +177,7 @@ class FpxImageFile(ImageFile.ImageFile):
|
|||
elif compression == 1:
|
||||
# FIXME: the fill decoder is not implemented
|
||||
self.tile.append(
|
||||
(
|
||||
ImageFile._Tile(
|
||||
"fill",
|
||||
(x, y, x1, y1),
|
||||
i32(s, i) + 28,
|
||||
|
|
@ -205,7 +205,7 @@ class FpxImageFile(ImageFile.ImageFile):
|
|||
jpegmode = rawmode
|
||||
|
||||
self.tile.append(
|
||||
(
|
||||
ImageFile._Tile(
|
||||
"jpeg",
|
||||
(x, y, x1, y1),
|
||||
i32(s, i) + 28,
|
||||
|
|
|
|||
|
|
@ -93,9 +93,9 @@ class FtexImageFile(ImageFile.ImageFile):
|
|||
|
||||
if format == Format.DXT1:
|
||||
self._mode = "RGBA"
|
||||
self.tile = [("bcn", (0, 0) + self.size, 0, 1)]
|
||||
self.tile = [ImageFile._Tile("bcn", (0, 0) + self.size, 0, (1,))]
|
||||
elif format == Format.UNCOMPRESSED:
|
||||
self.tile = [("raw", (0, 0) + self.size, 0, ("RGB", 0, 1))]
|
||||
self.tile = [ImageFile._Tile("raw", (0, 0) + self.size, 0, ("RGB", 0, 1))]
|
||||
else:
|
||||
msg = f"Invalid texture compression format: {repr(format)}"
|
||||
raise ValueError(msg)
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ class GdImageFile(ImageFile.ImageFile):
|
|||
)
|
||||
|
||||
self.tile = [
|
||||
(
|
||||
ImageFile._Tile(
|
||||
"raw",
|
||||
(0, 0) + self.size,
|
||||
7 + true_color_offset + 4 + 256 * 4,
|
||||
|
|
|
|||
|
|
@ -29,7 +29,6 @@ import itertools
|
|||
import math
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
from enum import IntEnum
|
||||
from functools import cached_property
|
||||
from typing import IO, TYPE_CHECKING, Any, Literal, NamedTuple, Union
|
||||
|
|
@ -49,6 +48,7 @@ from ._binary import o16le as o16
|
|||
|
||||
if TYPE_CHECKING:
|
||||
from . import _imaging
|
||||
from ._typing import Buffer
|
||||
|
||||
|
||||
class LoadingStrategy(IntEnum):
|
||||
|
|
@ -407,7 +407,7 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
elif self.mode not in ("RGB", "RGBA"):
|
||||
transparency = frame_transparency
|
||||
self.tile = [
|
||||
(
|
||||
ImageFile._Tile(
|
||||
"gif",
|
||||
(x0, y0, x1, y1),
|
||||
self.__offset,
|
||||
|
|
@ -438,6 +438,13 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
self.im.putpalette("RGB", *self._frame_palette.getdata())
|
||||
else:
|
||||
self._im = None
|
||||
if not self._prev_im and self._im is not None and self.size != self.im.size:
|
||||
expanded_im = Image.core.fill(self.im.mode, self.size)
|
||||
if self._frame_palette:
|
||||
expanded_im.putpalette("RGB", *self._frame_palette.getdata())
|
||||
expanded_im.paste(self.im, (0, 0) + self.im.size)
|
||||
|
||||
self.im = expanded_im
|
||||
self._mode = temp_mode
|
||||
self._frame_palette = None
|
||||
|
||||
|
|
@ -455,6 +462,17 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
return
|
||||
if not self._prev_im:
|
||||
return
|
||||
if self.size != self._prev_im.size:
|
||||
if self._frame_transparency is not None:
|
||||
expanded_im = Image.core.fill("RGBA", self.size)
|
||||
else:
|
||||
expanded_im = Image.core.fill("P", self.size)
|
||||
expanded_im.putpalette("RGB", "RGB", self.im.getpalette())
|
||||
expanded_im = expanded_im.convert("RGB")
|
||||
expanded_im.paste(self._prev_im, (0, 0) + self._prev_im.size)
|
||||
|
||||
self._prev_im = expanded_im
|
||||
assert self._prev_im is not None
|
||||
if self._frame_transparency is not None:
|
||||
self.im.putpalettealpha(self._frame_transparency, 0)
|
||||
frame_im = self.im.convert("RGBA")
|
||||
|
|
@ -535,7 +553,9 @@ def _normalize_palette(
|
|||
|
||||
if im.mode == "P":
|
||||
if not source_palette:
|
||||
source_palette = im.im.getpalette("RGB")[:768]
|
||||
im_palette = im.getpalette(None)
|
||||
assert im_palette is not None
|
||||
source_palette = bytearray(im_palette)
|
||||
else: # L-mode
|
||||
if not source_palette:
|
||||
source_palette = bytearray(i // 3 for i in range(768))
|
||||
|
|
@ -611,7 +631,10 @@ def _write_single_frame(
|
|||
def _getbbox(
|
||||
base_im: Image.Image, im_frame: Image.Image
|
||||
) -> tuple[Image.Image, tuple[int, int, int, int] | None]:
|
||||
if _get_palette_bytes(im_frame) != _get_palette_bytes(base_im):
|
||||
palette_bytes = [
|
||||
bytes(im.palette.palette) if im.palette else b"" for im in (base_im, im_frame)
|
||||
]
|
||||
if palette_bytes[0] != palette_bytes[1]:
|
||||
im_frame = im_frame.convert("RGBA")
|
||||
base_im = base_im.convert("RGBA")
|
||||
delta = ImageChops.subtract_modulo(im_frame, base_im)
|
||||
|
|
@ -966,7 +989,13 @@ def _get_palette_bytes(im: Image.Image) -> bytes:
|
|||
:param im: Image object
|
||||
:returns: Bytes, len<=768 suitable for inclusion in gif header
|
||||
"""
|
||||
return bytes(im.palette.palette) if im.palette else b""
|
||||
if not im.palette:
|
||||
return b""
|
||||
|
||||
palette = bytes(im.palette.palette)
|
||||
if im.palette.mode == "RGBA":
|
||||
palette = b"".join(palette[i * 4 : i * 4 + 3] for i in range(len(palette) // 3))
|
||||
return palette
|
||||
|
||||
|
||||
def _get_background(
|
||||
|
|
@ -1139,19 +1168,10 @@ def getdata(
|
|||
class Collector(BytesIO):
|
||||
data = []
|
||||
|
||||
if sys.version_info >= (3, 12):
|
||||
from collections.abc import Buffer
|
||||
|
||||
def write(self, data: Buffer) -> int:
|
||||
self.data.append(data)
|
||||
return len(data)
|
||||
|
||||
else:
|
||||
|
||||
def write(self, data: Any) -> int:
|
||||
self.data.append(data)
|
||||
return len(data)
|
||||
|
||||
im.load() # make sure raster data is available
|
||||
|
||||
fp = Collector()
|
||||
|
|
|
|||
|
|
@ -25,6 +25,7 @@ import sys
|
|||
from typing import IO
|
||||
|
||||
from . import Image, ImageFile, PngImagePlugin, features
|
||||
from ._deprecate import deprecate
|
||||
|
||||
enable_jpeg2k = features.check_codec("jpg_2000")
|
||||
if enable_jpeg2k:
|
||||
|
|
@ -275,37 +276,37 @@ class IcnsImageFile(ImageFile.ImageFile):
|
|||
self.best_size[1] * self.best_size[2],
|
||||
)
|
||||
|
||||
@property
|
||||
def size(self):
|
||||
@property # type: ignore[override]
|
||||
def size(self) -> tuple[int, int] | tuple[int, int, int]:
|
||||
return self._size
|
||||
|
||||
@size.setter
|
||||
def size(self, value) -> None:
|
||||
info_size = value
|
||||
if info_size not in self.info["sizes"] and len(info_size) == 2:
|
||||
info_size = (info_size[0], info_size[1], 1)
|
||||
if (
|
||||
info_size not in self.info["sizes"]
|
||||
and len(info_size) == 3
|
||||
and info_size[2] == 1
|
||||
):
|
||||
simple_sizes = [
|
||||
(size[0] * size[2], size[1] * size[2]) for size in self.info["sizes"]
|
||||
]
|
||||
if value in simple_sizes:
|
||||
info_size = self.info["sizes"][simple_sizes.index(value)]
|
||||
if info_size not in self.info["sizes"]:
|
||||
def size(self, value: tuple[int, int] | tuple[int, int, int]) -> None:
|
||||
if len(value) == 3:
|
||||
deprecate("Setting size to (width, height, scale)", 12, "load(scale)")
|
||||
if value in self.info["sizes"]:
|
||||
self._size = value # type: ignore[assignment]
|
||||
return
|
||||
else:
|
||||
# Check that a matching size exists,
|
||||
# or that there is a scale that would create a size that matches
|
||||
for size in self.info["sizes"]:
|
||||
simple_size = size[0] * size[2], size[1] * size[2]
|
||||
scale = simple_size[0] // value[0]
|
||||
if simple_size[1] / value[1] == scale:
|
||||
self._size = value
|
||||
return
|
||||
msg = "This is not one of the allowed sizes of this image"
|
||||
raise ValueError(msg)
|
||||
self._size = value
|
||||
|
||||
def load(self) -> Image.core.PixelAccess | None:
|
||||
if len(self.size) == 3:
|
||||
self.best_size = self.size
|
||||
self.size = (
|
||||
self.best_size[0] * self.best_size[2],
|
||||
self.best_size[1] * self.best_size[2],
|
||||
)
|
||||
def load(self, scale: int | None = None) -> Image.core.PixelAccess | None:
|
||||
if scale is not None or len(self.size) == 3:
|
||||
if scale is None and len(self.size) == 3:
|
||||
scale = self.size[2]
|
||||
assert scale is not None
|
||||
width, height = self.size[:2]
|
||||
self.size = width * scale, height * scale
|
||||
self.best_size = width, height, scale
|
||||
|
||||
px = Image.Image.load(self)
|
||||
if self._im is not None and self.im.size == self.size:
|
||||
|
|
|
|||
|
|
@ -228,7 +228,7 @@ class IcoFile:
|
|||
# change tile dimension to only encompass XOR image
|
||||
im._size = (im.size[0], int(im.size[1] / 2))
|
||||
d, e, o, a = im.tile[0]
|
||||
im.tile[0] = d, (0, 0) + im.size, o, a
|
||||
im.tile[0] = ImageFile._Tile(d, (0, 0) + im.size, o, a)
|
||||
|
||||
# figure out where AND mask image starts
|
||||
if header.bpp == 32:
|
||||
|
|
@ -243,6 +243,7 @@ class IcoFile:
|
|||
alpha_bytes = self.buf.read(im.size[0] * im.size[1] * 4)[3::4]
|
||||
|
||||
# convert to an 8bpp grayscale image
|
||||
try:
|
||||
mask = Image.frombuffer(
|
||||
"L", # 8bpp
|
||||
im.size, # (w, h)
|
||||
|
|
@ -250,6 +251,11 @@ class IcoFile:
|
|||
"raw", # raw decoder
|
||||
("L", 0, -1), # 8bpp inverted, unpadded, reversed
|
||||
)
|
||||
except ValueError:
|
||||
if ImageFile.LOAD_TRUNCATED_IMAGES:
|
||||
mask = None
|
||||
else:
|
||||
raise
|
||||
else:
|
||||
# get AND image from end of bitmap
|
||||
w = im.size[0]
|
||||
|
|
@ -267,6 +273,7 @@ class IcoFile:
|
|||
mask_data = self.buf.read(total_bytes)
|
||||
|
||||
# convert raw data to image
|
||||
try:
|
||||
mask = Image.frombuffer(
|
||||
"1", # 1 bpp
|
||||
im.size, # (w, h)
|
||||
|
|
@ -274,10 +281,16 @@ class IcoFile:
|
|||
"raw", # raw decoder
|
||||
("1;I", int(w / 8), -1), # 1bpp inverted, padded, reversed
|
||||
)
|
||||
except ValueError:
|
||||
if ImageFile.LOAD_TRUNCATED_IMAGES:
|
||||
mask = None
|
||||
else:
|
||||
raise
|
||||
|
||||
# now we have two images, im is XOR image and mask is AND image
|
||||
|
||||
# apply mask image as alpha channel
|
||||
if mask:
|
||||
im = im.convert("RGBA")
|
||||
im.putalpha(mask)
|
||||
|
||||
|
|
|
|||
|
|
@ -253,7 +253,11 @@ class ImImageFile(ImageFile.ImageFile):
|
|||
# use bit decoder (if necessary)
|
||||
bits = int(self.rawmode[2:])
|
||||
if bits not in [8, 16, 32]:
|
||||
self.tile = [("bit", (0, 0) + self.size, offs, (bits, 8, 3, 0, -1))]
|
||||
self.tile = [
|
||||
ImageFile._Tile(
|
||||
"bit", (0, 0) + self.size, offs, (bits, 8, 3, 0, -1)
|
||||
)
|
||||
]
|
||||
return
|
||||
except ValueError:
|
||||
pass
|
||||
|
|
@ -263,13 +267,17 @@ class ImImageFile(ImageFile.ImageFile):
|
|||
# ever stumbled upon such a file ;-)
|
||||
size = self.size[0] * self.size[1]
|
||||
self.tile = [
|
||||
("raw", (0, 0) + self.size, offs, ("G", 0, -1)),
|
||||
("raw", (0, 0) + self.size, offs + size, ("R", 0, -1)),
|
||||
("raw", (0, 0) + self.size, offs + 2 * size, ("B", 0, -1)),
|
||||
ImageFile._Tile("raw", (0, 0) + self.size, offs, ("G", 0, -1)),
|
||||
ImageFile._Tile("raw", (0, 0) + self.size, offs + size, ("R", 0, -1)),
|
||||
ImageFile._Tile(
|
||||
"raw", (0, 0) + self.size, offs + 2 * size, ("B", 0, -1)
|
||||
),
|
||||
]
|
||||
else:
|
||||
# LabEye/IFUNC files
|
||||
self.tile = [("raw", (0, 0) + self.size, offs, (self.rawmode, 0, -1))]
|
||||
self.tile = [
|
||||
ImageFile._Tile("raw", (0, 0) + self.size, offs, (self.rawmode, 0, -1))
|
||||
]
|
||||
|
||||
@property
|
||||
def n_frames(self) -> int:
|
||||
|
|
@ -295,7 +303,9 @@ class ImImageFile(ImageFile.ImageFile):
|
|||
|
||||
self.fp = self._fp
|
||||
|
||||
self.tile = [("raw", (0, 0) + self.size, offs, (self.rawmode, 0, -1))]
|
||||
self.tile = [
|
||||
ImageFile._Tile("raw", (0, 0) + self.size, offs, (self.rawmode, 0, -1))
|
||||
]
|
||||
|
||||
def tell(self) -> int:
|
||||
return self.frame
|
||||
|
|
|
|||
|
|
@ -133,6 +133,7 @@ def isImageType(t: Any) -> TypeGuard[Image]:
|
|||
:param t: object to check if it's an image
|
||||
:returns: True if the object is an image
|
||||
"""
|
||||
deprecate("Image.isImageType(im)", 12, "isinstance(im, Image.Image)")
|
||||
return hasattr(t, "im")
|
||||
|
||||
|
||||
|
|
@ -225,6 +226,11 @@ if TYPE_CHECKING:
|
|||
|
||||
from . import ImageFile, ImageFilter, ImagePalette, ImageQt, TiffImagePlugin
|
||||
from ._typing import NumpyArray, StrOrBytesPath, TypeGuard
|
||||
|
||||
if sys.version_info >= (3, 13):
|
||||
from types import CapsuleType
|
||||
else:
|
||||
CapsuleType = object
|
||||
ID: list[str] = []
|
||||
OPEN: dict[
|
||||
str,
|
||||
|
|
@ -851,7 +857,10 @@ class Image:
|
|||
)
|
||||
|
||||
def frombytes(
|
||||
self, data: bytes | bytearray, decoder_name: str = "raw", *args: Any
|
||||
self,
|
||||
data: bytes | bytearray | SupportsArrayInterface,
|
||||
decoder_name: str = "raw",
|
||||
*args: Any,
|
||||
) -> None:
|
||||
"""
|
||||
Loads this image with pixel data from a bytes object.
|
||||
|
|
@ -1058,7 +1067,7 @@ class Image:
|
|||
trns_im = new(self.mode, (1, 1))
|
||||
if self.mode == "P":
|
||||
assert self.palette is not None
|
||||
trns_im.putpalette(self.palette)
|
||||
trns_im.putpalette(self.palette, self.palette.mode)
|
||||
if isinstance(t, tuple):
|
||||
err = "Couldn't allocate a palette color for transparency"
|
||||
assert trns_im.palette is not None
|
||||
|
|
@ -1122,17 +1131,23 @@ class Image:
|
|||
return new_im
|
||||
|
||||
if "LAB" in (self.mode, mode):
|
||||
other_mode = mode if self.mode == "LAB" else self.mode
|
||||
im = self
|
||||
if mode == "LAB":
|
||||
if im.mode not in ("RGB", "RGBA", "RGBX"):
|
||||
im = im.convert("RGBA")
|
||||
other_mode = im.mode
|
||||
else:
|
||||
other_mode = mode
|
||||
if other_mode in ("RGB", "RGBA", "RGBX"):
|
||||
from . import ImageCms
|
||||
|
||||
srgb = ImageCms.createProfile("sRGB")
|
||||
lab = ImageCms.createProfile("LAB")
|
||||
profiles = [lab, srgb] if self.mode == "LAB" else [srgb, lab]
|
||||
profiles = [lab, srgb] if im.mode == "LAB" else [srgb, lab]
|
||||
transform = ImageCms.buildTransform(
|
||||
profiles[0], profiles[1], self.mode, mode
|
||||
profiles[0], profiles[1], im.mode, mode
|
||||
)
|
||||
return transform.apply(self)
|
||||
return transform.apply(im)
|
||||
|
||||
# colorspace conversion
|
||||
if dither is None:
|
||||
|
|
@ -1598,7 +1613,7 @@ class Image:
|
|||
self.fp.seek(offset)
|
||||
return child_images
|
||||
|
||||
def getim(self):
|
||||
def getim(self) -> CapsuleType:
|
||||
"""
|
||||
Returns a capsule that points to the internal image memory.
|
||||
|
||||
|
|
@ -1809,23 +1824,22 @@ class Image:
|
|||
:param mask: An optional mask image.
|
||||
"""
|
||||
|
||||
if isImageType(box):
|
||||
if isinstance(box, Image):
|
||||
if mask is not None:
|
||||
msg = "If using second argument as mask, third argument must be None"
|
||||
raise ValueError(msg)
|
||||
# abbreviated paste(im, mask) syntax
|
||||
mask = box
|
||||
box = None
|
||||
assert not isinstance(box, Image)
|
||||
|
||||
if box is None:
|
||||
box = (0, 0)
|
||||
|
||||
if len(box) == 2:
|
||||
# upper left corner given; get size from image or mask
|
||||
if isImageType(im):
|
||||
if isinstance(im, Image):
|
||||
size = im.size
|
||||
elif isImageType(mask):
|
||||
elif isinstance(mask, Image):
|
||||
size = mask.size
|
||||
else:
|
||||
# FIXME: use self.size here?
|
||||
|
|
@ -1838,17 +1852,15 @@ class Image:
|
|||
from . import ImageColor
|
||||
|
||||
source = ImageColor.getcolor(im, self.mode)
|
||||
elif isImageType(im):
|
||||
elif isinstance(im, Image):
|
||||
im.load()
|
||||
if self.mode != im.mode:
|
||||
if self.mode != "RGB" or im.mode not in ("LA", "RGBA", "RGBa"):
|
||||
# should use an adapter for this!
|
||||
im = im.convert(self.mode)
|
||||
source = im.im
|
||||
elif isinstance(im, tuple):
|
||||
source = im
|
||||
else:
|
||||
source = cast(float, im)
|
||||
source = im
|
||||
|
||||
self._ensure_mutable()
|
||||
|
||||
|
|
@ -2009,7 +2021,7 @@ class Image:
|
|||
else:
|
||||
band = 3
|
||||
|
||||
if isImageType(alpha):
|
||||
if isinstance(alpha, Image):
|
||||
# alpha layer
|
||||
if alpha.mode not in ("1", "L"):
|
||||
msg = "illegal image mode"
|
||||
|
|
@ -2019,7 +2031,6 @@ class Image:
|
|||
alpha = alpha.convert("L")
|
||||
else:
|
||||
# constant alpha
|
||||
alpha = cast(int, alpha) # see python/typing#1013
|
||||
try:
|
||||
self.im.fillband(band, alpha)
|
||||
except (AttributeError, ValueError):
|
||||
|
|
@ -2168,6 +2179,9 @@ class Image:
|
|||
source_palette = self.im.getpalette(palette_mode, palette_mode)
|
||||
else: # L-mode
|
||||
source_palette = bytearray(i // 3 for i in range(768))
|
||||
elif len(source_palette) > 768:
|
||||
bands = 4
|
||||
palette_mode = "RGBA"
|
||||
|
||||
palette_bytes = b""
|
||||
new_positions = [0] * 256
|
||||
|
|
@ -3140,7 +3154,7 @@ def new(
|
|||
def frombytes(
|
||||
mode: str,
|
||||
size: tuple[int, int],
|
||||
data: bytes | bytearray,
|
||||
data: bytes | bytearray | SupportsArrayInterface,
|
||||
decoder_name: str = "raw",
|
||||
*args: Any,
|
||||
) -> Image:
|
||||
|
|
@ -3184,7 +3198,11 @@ def frombytes(
|
|||
|
||||
|
||||
def frombuffer(
|
||||
mode: str, size: tuple[int, int], data, decoder_name: str = "raw", *args: Any
|
||||
mode: str,
|
||||
size: tuple[int, int],
|
||||
data: bytes | SupportsArrayInterface,
|
||||
decoder_name: str = "raw",
|
||||
*args: Any,
|
||||
) -> Image:
|
||||
"""
|
||||
Creates an image memory referencing pixel data in a byte buffer.
|
||||
|
|
@ -3641,7 +3659,10 @@ def merge(mode: str, bands: Sequence[Image]) -> Image:
|
|||
|
||||
def register_open(
|
||||
id: str,
|
||||
factory: Callable[[IO[bytes], str | bytes], ImageFile.ImageFile],
|
||||
factory: (
|
||||
Callable[[IO[bytes], str | bytes], ImageFile.ImageFile]
|
||||
| type[ImageFile.ImageFile]
|
||||
),
|
||||
accept: Callable[[bytes], bool | str] | None = None,
|
||||
) -> None:
|
||||
"""
|
||||
|
|
@ -3960,7 +3981,7 @@ class Exif(_ExifBase):
|
|||
self._data.clear()
|
||||
self._hidden_data.clear()
|
||||
self._ifds.clear()
|
||||
if data and data.startswith(b"Exif\x00\x00"):
|
||||
while data and data.startswith(b"Exif\x00\x00"):
|
||||
data = data[6:]
|
||||
if not data:
|
||||
self._info = None
|
||||
|
|
@ -4136,7 +4157,7 @@ class Exif(_ExifBase):
|
|||
ifd = self._get_ifd_dict(tag_data, tag)
|
||||
if ifd is not None:
|
||||
self._ifds[tag] = ifd
|
||||
ifd = self._ifds.get(tag, {})
|
||||
ifd = self._ifds.setdefault(tag, {})
|
||||
if tag == ExifTags.IFD.Exif and self._hidden_data:
|
||||
ifd = {
|
||||
k: v
|
||||
|
|
|
|||
|
|
@ -34,12 +34,15 @@ import itertools
|
|||
import os
|
||||
import struct
|
||||
import sys
|
||||
from typing import IO, Any, NamedTuple
|
||||
from typing import IO, TYPE_CHECKING, Any, NamedTuple, cast
|
||||
|
||||
from . import Image
|
||||
from ._deprecate import deprecate
|
||||
from ._util import is_path
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from ._typing import StrOrBytesPath
|
||||
|
||||
MAXBLOCK = 65536
|
||||
|
||||
SAFEBLOCK = 1024 * 1024
|
||||
|
|
@ -107,32 +110,34 @@ class _Tile(NamedTuple):
|
|||
class ImageFile(Image.Image):
|
||||
"""Base class for image file format handlers."""
|
||||
|
||||
def __init__(self, fp=None, filename=None):
|
||||
def __init__(
|
||||
self, fp: StrOrBytesPath | IO[bytes], filename: str | bytes | None = None
|
||||
) -> None:
|
||||
super().__init__()
|
||||
|
||||
self._min_frame = 0
|
||||
|
||||
self.custom_mimetype = None
|
||||
self.custom_mimetype: str | None = None
|
||||
|
||||
self.tile = None
|
||||
self.tile: list[_Tile] = []
|
||||
""" A list of tile descriptors, or ``None`` """
|
||||
|
||||
self.readonly = 1 # until we know better
|
||||
|
||||
self.decoderconfig = ()
|
||||
self.decoderconfig: tuple[Any, ...] = ()
|
||||
self.decodermaxblock = MAXBLOCK
|
||||
|
||||
if is_path(fp):
|
||||
# filename
|
||||
self.fp = open(fp, "rb")
|
||||
self.filename = fp
|
||||
self.filename = os.path.realpath(os.fspath(fp))
|
||||
self._exclusive_fp = True
|
||||
else:
|
||||
# stream
|
||||
self.fp = fp
|
||||
self.filename = filename
|
||||
self.fp = cast(IO[bytes], fp)
|
||||
self.filename = filename if filename is not None else ""
|
||||
# can be overridden
|
||||
self._exclusive_fp = None
|
||||
self._exclusive_fp = False
|
||||
|
||||
try:
|
||||
try:
|
||||
|
|
@ -155,6 +160,9 @@ class ImageFile(Image.Image):
|
|||
self.fp.close()
|
||||
raise
|
||||
|
||||
def _open(self) -> None:
|
||||
pass
|
||||
|
||||
def get_format_mimetype(self) -> str | None:
|
||||
if self.custom_mimetype:
|
||||
return self.custom_mimetype
|
||||
|
|
@ -178,7 +186,7 @@ class ImageFile(Image.Image):
|
|||
def load(self) -> Image.core.PixelAccess | None:
|
||||
"""Load image data based on tile list"""
|
||||
|
||||
if self.tile is None:
|
||||
if not self.tile and self._im is None:
|
||||
msg = "cannot load this image"
|
||||
raise OSError(msg)
|
||||
|
||||
|
|
@ -214,6 +222,7 @@ class ImageFile(Image.Image):
|
|||
args = (args, 0, 1)
|
||||
if (
|
||||
decoder_name == "raw"
|
||||
and isinstance(args, tuple)
|
||||
and len(args) >= 3
|
||||
and args[0] == self.mode
|
||||
and args[0] in Image._MAPMODES
|
||||
|
|
@ -724,7 +733,7 @@ class PyDecoder(PyCodec):
|
|||
def pulls_fd(self) -> bool:
|
||||
return self._pulls_fd
|
||||
|
||||
def decode(self, buffer: bytes) -> tuple[int, int]:
|
||||
def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
|
||||
"""
|
||||
Override to perform the decoding process.
|
||||
|
||||
|
|
@ -736,19 +745,22 @@ class PyDecoder(PyCodec):
|
|||
msg = "unavailable in base decoder"
|
||||
raise NotImplementedError(msg)
|
||||
|
||||
def set_as_raw(self, data: bytes, rawmode=None) -> None:
|
||||
def set_as_raw(
|
||||
self, data: bytes, rawmode: str | None = None, extra: tuple[Any, ...] = ()
|
||||
) -> None:
|
||||
"""
|
||||
Convenience method to set the internal image from a stream of raw data
|
||||
|
||||
:param data: Bytes to be set
|
||||
:param rawmode: The rawmode to be used for the decoder.
|
||||
If not specified, it will default to the mode of the image
|
||||
:param extra: Extra arguments for the decoder.
|
||||
:returns: None
|
||||
"""
|
||||
|
||||
if not rawmode:
|
||||
rawmode = self.mode
|
||||
d = Image._getdecoder(self.mode, "raw", rawmode)
|
||||
d = Image._getdecoder(self.mode, "raw", rawmode, extra)
|
||||
assert self.im is not None
|
||||
d.setimage(self.im, self.state.extents())
|
||||
s = d.decode(data)
|
||||
|
|
|
|||
|
|
@ -34,9 +34,9 @@ import warnings
|
|||
from enum import IntEnum
|
||||
from io import BytesIO
|
||||
from types import ModuleType
|
||||
from typing import IO, TYPE_CHECKING, Any, BinaryIO, TypedDict
|
||||
from typing import IO, TYPE_CHECKING, Any, BinaryIO, TypedDict, cast
|
||||
|
||||
from . import Image
|
||||
from . import Image, features
|
||||
from ._typing import StrOrBytesPath
|
||||
from ._util import DeferredError, is_path
|
||||
|
||||
|
|
@ -215,7 +215,7 @@ class FreeTypeFont:
|
|||
|
||||
def __init__(
|
||||
self,
|
||||
font: StrOrBytesPath | BinaryIO | None = None,
|
||||
font: StrOrBytesPath | BinaryIO,
|
||||
size: float = 10,
|
||||
index: int = 0,
|
||||
encoding: str = "",
|
||||
|
|
@ -235,6 +235,21 @@ class FreeTypeFont:
|
|||
self.index = index
|
||||
self.encoding = encoding
|
||||
|
||||
try:
|
||||
from packaging.version import parse as parse_version
|
||||
except ImportError:
|
||||
pass
|
||||
else:
|
||||
if freetype_version := features.version_module("freetype2"):
|
||||
if parse_version(freetype_version) < parse_version("2.9.1"):
|
||||
warnings.warn(
|
||||
"Support for FreeType 2.9.0 is deprecated and will be removed "
|
||||
"in Pillow 12 (2025-10-15). Please upgrade to FreeType 2.9.1 "
|
||||
"or newer, preferably FreeType 2.10.4 which fixes "
|
||||
"CVE-2020-15999.",
|
||||
DeprecationWarning,
|
||||
)
|
||||
|
||||
if layout_engine not in (Layout.BASIC, Layout.RAQM):
|
||||
layout_engine = Layout.BASIC
|
||||
if core.HAVE_RAQM:
|
||||
|
|
@ -248,7 +263,7 @@ class FreeTypeFont:
|
|||
|
||||
self.layout_engine = layout_engine
|
||||
|
||||
def load_from_bytes(f) -> None:
|
||||
def load_from_bytes(f: IO[bytes]) -> None:
|
||||
self.font_bytes = f.read()
|
||||
self.font = core.getfont(
|
||||
"", size, index, encoding, self.font_bytes, layout_engine
|
||||
|
|
@ -270,7 +285,7 @@ class FreeTypeFont:
|
|||
font, size, index, encoding, layout_engine=layout_engine
|
||||
)
|
||||
else:
|
||||
load_from_bytes(font)
|
||||
load_from_bytes(cast(IO[bytes], font))
|
||||
|
||||
def __getstate__(self) -> list[Any]:
|
||||
return [self.path, self.size, self.index, self.encoding, self.layout_engine]
|
||||
|
|
@ -785,7 +800,7 @@ def load(filename: str) -> ImageFont:
|
|||
|
||||
|
||||
def truetype(
|
||||
font: StrOrBytesPath | BinaryIO | None = None,
|
||||
font: StrOrBytesPath | BinaryIO,
|
||||
size: float = 10,
|
||||
index: int = 0,
|
||||
encoding: str = "",
|
||||
|
|
@ -857,7 +872,7 @@ def truetype(
|
|||
:exception ValueError: If the font size is not greater than zero.
|
||||
"""
|
||||
|
||||
def freetype(font: StrOrBytesPath | BinaryIO | None) -> FreeTypeFont:
|
||||
def freetype(font: StrOrBytesPath | BinaryIO) -> FreeTypeFont:
|
||||
return FreeTypeFont(font, size, index, encoding, layout_engine)
|
||||
|
||||
try:
|
||||
|
|
|
|||
|
|
@ -268,7 +268,7 @@ def lambda_eval(
|
|||
args.update(options)
|
||||
args.update(kw)
|
||||
for k, v in args.items():
|
||||
if hasattr(v, "im"):
|
||||
if isinstance(v, Image.Image):
|
||||
args[k] = _Operand(v)
|
||||
|
||||
out = expression(args)
|
||||
|
|
@ -319,7 +319,7 @@ def unsafe_eval(
|
|||
args.update(options)
|
||||
args.update(kw)
|
||||
for k, v in args.items():
|
||||
if hasattr(v, "im"):
|
||||
if isinstance(v, Image.Image):
|
||||
args[k] = _Operand(v)
|
||||
|
||||
compiled_code = compile(expression, "<string>", "eval")
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ class ImtImageFile(ImageFile.ImageFile):
|
|||
if s == b"\x0C":
|
||||
# image data begins
|
||||
self.tile = [
|
||||
(
|
||||
ImageFile._Tile(
|
||||
"raw",
|
||||
(0, 0) + self.size,
|
||||
self.fp.tell() - len(buffer),
|
||||
|
|
|
|||
|
|
@ -147,7 +147,9 @@ class IptcImageFile(ImageFile.ImageFile):
|
|||
|
||||
# tile
|
||||
if tag == (8, 10):
|
||||
self.tile = [("iptc", (0, 0) + self.size, offset, compression)]
|
||||
self.tile = [
|
||||
ImageFile._Tile("iptc", (0, 0) + self.size, offset, compression)
|
||||
]
|
||||
|
||||
def load(self) -> Image.core.PixelAccess | None:
|
||||
if len(self.tile) != 1 or self.tile[0][0] != "iptc":
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@ from __future__ import annotations
|
|||
import io
|
||||
import os
|
||||
import struct
|
||||
from collections.abc import Callable
|
||||
from typing import IO, cast
|
||||
|
||||
from . import Image, ImageFile, ImagePalette, _binary
|
||||
|
|
@ -205,7 +206,7 @@ def _parse_jp2_header(
|
|||
if bitdepth > max_bitdepth:
|
||||
max_bitdepth = bitdepth
|
||||
if max_bitdepth <= 8:
|
||||
palette = ImagePalette.ImagePalette()
|
||||
palette = ImagePalette.ImagePalette("RGBA" if npc == 4 else "RGB")
|
||||
for i in range(ne):
|
||||
color: list[int] = []
|
||||
for value in header.read_fields(">" + ("B" * npc)):
|
||||
|
|
@ -286,7 +287,7 @@ class Jpeg2KImageFile(ImageFile.ImageFile):
|
|||
length = -1
|
||||
|
||||
self.tile = [
|
||||
(
|
||||
ImageFile._Tile(
|
||||
"jpeg2k",
|
||||
(0, 0) + self.size,
|
||||
0,
|
||||
|
|
@ -316,8 +317,13 @@ class Jpeg2KImageFile(ImageFile.ImageFile):
|
|||
else:
|
||||
self.fp.seek(length - 2, os.SEEK_CUR)
|
||||
|
||||
@property
|
||||
def reduce(self):
|
||||
@property # type: ignore[override]
|
||||
def reduce(
|
||||
self,
|
||||
) -> (
|
||||
Callable[[int | tuple[int, int], tuple[int, int, int, int] | None], Image.Image]
|
||||
| int
|
||||
):
|
||||
# https://github.com/python-pillow/Pillow/issues/4343 found that the
|
||||
# new Image 'reduce' method was shadowed by this plugin's 'reduce'
|
||||
# property. This attempts to allow for both scenarios
|
||||
|
|
@ -338,8 +344,9 @@ class Jpeg2KImageFile(ImageFile.ImageFile):
|
|||
|
||||
# Update the reduce and layers settings
|
||||
t = self.tile[0]
|
||||
assert isinstance(t[3], tuple)
|
||||
t3 = (t[3][0], self._reduce, self.layers, t[3][3], t[3][4])
|
||||
self.tile = [(t[0], (0, 0) + self.size, t[2], t3)]
|
||||
self.tile = [ImageFile._Tile(t[0], (0, 0) + self.size, t[2], t3)]
|
||||
|
||||
return ImageFile.ImageFile.load(self)
|
||||
|
||||
|
|
|
|||
|
|
@ -372,7 +372,9 @@ class JpegImageFile(ImageFile.ImageFile):
|
|||
rawmode = self.mode
|
||||
if self.mode == "CMYK":
|
||||
rawmode = "CMYK;I" # assume adobe conventions
|
||||
self.tile = [("jpeg", (0, 0) + self.size, 0, (rawmode, ""))]
|
||||
self.tile = [
|
||||
ImageFile._Tile("jpeg", (0, 0) + self.size, 0, (rawmode, ""))
|
||||
]
|
||||
# self.__offset = self.fp.tell()
|
||||
break
|
||||
s = self.fp.read(1)
|
||||
|
|
@ -423,6 +425,7 @@ class JpegImageFile(ImageFile.ImageFile):
|
|||
scale = 1
|
||||
original_size = self.size
|
||||
|
||||
assert isinstance(a, tuple)
|
||||
if a[0] == "RGB" and mode in ["L", "YCbCr"]:
|
||||
self._mode = mode
|
||||
a = mode, ""
|
||||
|
|
@ -432,6 +435,7 @@ class JpegImageFile(ImageFile.ImageFile):
|
|||
for s in [8, 4, 2, 1]:
|
||||
if scale >= s:
|
||||
break
|
||||
assert e is not None
|
||||
e = (
|
||||
e[0],
|
||||
e[1],
|
||||
|
|
@ -441,7 +445,7 @@ class JpegImageFile(ImageFile.ImageFile):
|
|||
self._size = ((self.size[0] + s - 1) // s, (self.size[1] + s - 1) // s)
|
||||
scale = s
|
||||
|
||||
self.tile = [(d, e, o, a)]
|
||||
self.tile = [ImageFile._Tile(d, e, o, a)]
|
||||
self.decoderconfig = (scale, 0)
|
||||
|
||||
box = (0, 0, original_size[0] / scale, original_size[1] / scale)
|
||||
|
|
@ -747,17 +751,27 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
|
|||
extra = info.get("extra", b"")
|
||||
|
||||
MAX_BYTES_IN_MARKER = 65533
|
||||
xmp = info.get("xmp", im.info.get("xmp"))
|
||||
if xmp:
|
||||
overhead_len = 29 # b"http://ns.adobe.com/xap/1.0/\x00"
|
||||
max_data_bytes_in_marker = MAX_BYTES_IN_MARKER - overhead_len
|
||||
if len(xmp) > max_data_bytes_in_marker:
|
||||
msg = "XMP data is too long"
|
||||
raise ValueError(msg)
|
||||
size = o16(2 + overhead_len + len(xmp))
|
||||
extra += b"\xFF\xE1" + size + b"http://ns.adobe.com/xap/1.0/\x00" + xmp
|
||||
|
||||
icc_profile = info.get("icc_profile")
|
||||
if icc_profile:
|
||||
ICC_OVERHEAD_LEN = 14
|
||||
MAX_DATA_BYTES_IN_MARKER = MAX_BYTES_IN_MARKER - ICC_OVERHEAD_LEN
|
||||
overhead_len = 14 # b"ICC_PROFILE\0" + o8(i) + o8(len(markers))
|
||||
max_data_bytes_in_marker = MAX_BYTES_IN_MARKER - overhead_len
|
||||
markers = []
|
||||
while icc_profile:
|
||||
markers.append(icc_profile[:MAX_DATA_BYTES_IN_MARKER])
|
||||
icc_profile = icc_profile[MAX_DATA_BYTES_IN_MARKER:]
|
||||
markers.append(icc_profile[:max_data_bytes_in_marker])
|
||||
icc_profile = icc_profile[max_data_bytes_in_marker:]
|
||||
i = 1
|
||||
for marker in markers:
|
||||
size = o16(2 + ICC_OVERHEAD_LEN + len(marker))
|
||||
size = o16(2 + overhead_len + len(marker))
|
||||
extra += (
|
||||
b"\xFF\xE2"
|
||||
+ size
|
||||
|
|
@ -844,7 +858,7 @@ def _save_cjpeg(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
|
|||
##
|
||||
# Factory for making JPEG and MPO instances
|
||||
def jpeg_factory(
|
||||
fp: IO[bytes] | None = None, filename: str | bytes | None = None
|
||||
fp: IO[bytes], filename: str | bytes | None = None
|
||||
) -> JpegImageFile | MpoImageFile:
|
||||
im = JpegImageFile(fp, filename)
|
||||
try:
|
||||
|
|
|
|||
|
|
@ -67,7 +67,9 @@ class McIdasImageFile(ImageFile.ImageFile):
|
|||
offset = w[34] + w[15]
|
||||
stride = w[15] + w[10] * w[11] * w[14]
|
||||
|
||||
self.tile = [("raw", (0, 0) + self.size, offset, (rawmode, stride, 1))]
|
||||
self.tile = [
|
||||
ImageFile._Tile("raw", (0, 0) + self.size, offset, (rawmode, stride, 1))
|
||||
]
|
||||
|
||||
|
||||
# --------------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -26,6 +26,7 @@ from typing import IO, Any, cast
|
|||
|
||||
from . import (
|
||||
Image,
|
||||
ImageFile,
|
||||
ImageSequence,
|
||||
JpegImagePlugin,
|
||||
TiffImagePlugin,
|
||||
|
|
@ -145,7 +146,9 @@ class MpoImageFile(JpegImagePlugin.JpegImageFile):
|
|||
if self.info.get("exif") != original_exif:
|
||||
self._reload_exif()
|
||||
|
||||
self.tile = [("jpeg", (0, 0) + self.size, self.offset, self.tile[0][-1])]
|
||||
self.tile = [
|
||||
ImageFile._Tile("jpeg", (0, 0) + self.size, self.offset, self.tile[0][-1])
|
||||
]
|
||||
self.__frame = frame
|
||||
|
||||
def tell(self) -> int:
|
||||
|
|
|
|||
|
|
@ -70,9 +70,9 @@ class MspImageFile(ImageFile.ImageFile):
|
|||
self._size = i16(s, 4), i16(s, 6)
|
||||
|
||||
if s[:4] == b"DanM":
|
||||
self.tile = [("raw", (0, 0) + self.size, 32, ("1", 0, 1))]
|
||||
self.tile = [ImageFile._Tile("raw", (0, 0) + self.size, 32, ("1", 0, 1))]
|
||||
else:
|
||||
self.tile = [("MSP", (0, 0) + self.size, 32, None)]
|
||||
self.tile = [ImageFile._Tile("MSP", (0, 0) + self.size, 32, None)]
|
||||
|
||||
|
||||
class MspDecoder(ImageFile.PyDecoder):
|
||||
|
|
@ -112,7 +112,7 @@ class MspDecoder(ImageFile.PyDecoder):
|
|||
|
||||
_pulls_fd = True
|
||||
|
||||
def decode(self, buffer: bytes) -> tuple[int, int]:
|
||||
def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
|
||||
assert self.fd is not None
|
||||
|
||||
img = io.BytesIO()
|
||||
|
|
@ -152,7 +152,7 @@ class MspDecoder(ImageFile.PyDecoder):
|
|||
msg = f"Corrupted MSP file in row {x}"
|
||||
raise OSError(msg) from e
|
||||
|
||||
self.set_as_raw(img.getvalue(), ("1", 0, 1))
|
||||
self.set_as_raw(img.getvalue(), "1")
|
||||
|
||||
return -1, 0
|
||||
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ class PcdImageFile(ImageFile.ImageFile):
|
|||
|
||||
self._mode = "RGB"
|
||||
self._size = 768, 512 # FIXME: not correct for rotated images!
|
||||
self.tile = [("pcd", (0, 0) + self.size, 96 * 2048, None)]
|
||||
self.tile = [ImageFile._Tile("pcd", (0, 0) + self.size, 96 * 2048, None)]
|
||||
|
||||
def load_end(self) -> None:
|
||||
if self.tile_post_rotate:
|
||||
|
|
|
|||
|
|
@ -128,7 +128,9 @@ class PcxImageFile(ImageFile.ImageFile):
|
|||
bbox = (0, 0) + self.size
|
||||
logger.debug("size: %sx%s", *self.size)
|
||||
|
||||
self.tile = [("pcx", bbox, self.fp.tell(), (rawmode, planes * stride))]
|
||||
self.tile = [
|
||||
ImageFile._Tile("pcx", bbox, self.fp.tell(), (rawmode, planes * stride))
|
||||
]
|
||||
|
||||
|
||||
# --------------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -61,7 +61,9 @@ class PixarImageFile(ImageFile.ImageFile):
|
|||
# FIXME: to be continued...
|
||||
|
||||
# create tile descriptor (assuming "dumped")
|
||||
self.tile = [("raw", (0, 0) + self.size, 1024, (self.mode, 0, 1))]
|
||||
self.tile = [
|
||||
ImageFile._Tile("raw", (0, 0) + self.size, 1024, (self.mode, 0, 1))
|
||||
]
|
||||
|
||||
|
||||
#
|
||||
|
|
|
|||
|
|
@ -258,7 +258,9 @@ class iTXt(str):
|
|||
tkey: str | bytes | None
|
||||
|
||||
@staticmethod
|
||||
def __new__(cls, text, lang=None, tkey=None):
|
||||
def __new__(
|
||||
cls, text: str, lang: str | None = None, tkey: str | None = None
|
||||
) -> iTXt:
|
||||
"""
|
||||
:param cls: the class to use when creating the instance
|
||||
:param text: value for this key
|
||||
|
|
@ -368,21 +370,27 @@ class PngInfo:
|
|||
# PNG image stream (IHDR/IEND)
|
||||
|
||||
|
||||
class _RewindState(NamedTuple):
|
||||
info: dict[str | tuple[int, int], Any]
|
||||
tile: list[ImageFile._Tile]
|
||||
seq_num: int | None
|
||||
|
||||
|
||||
class PngStream(ChunkStream):
|
||||
def __init__(self, fp):
|
||||
def __init__(self, fp: IO[bytes]) -> None:
|
||||
super().__init__(fp)
|
||||
|
||||
# local copies of Image attributes
|
||||
self.im_info = {}
|
||||
self.im_text = {}
|
||||
self.im_info: dict[str | tuple[int, int], Any] = {}
|
||||
self.im_text: dict[str, str | iTXt] = {}
|
||||
self.im_size = (0, 0)
|
||||
self.im_mode = None
|
||||
self.im_tile = None
|
||||
self.im_palette = None
|
||||
self.im_custom_mimetype = None
|
||||
self.im_n_frames = None
|
||||
self._seq_num = None
|
||||
self.rewind_state = None
|
||||
self.im_mode = ""
|
||||
self.im_tile: list[ImageFile._Tile] = []
|
||||
self.im_palette: tuple[str, bytes] | None = None
|
||||
self.im_custom_mimetype: str | None = None
|
||||
self.im_n_frames: int | None = None
|
||||
self._seq_num: int | None = None
|
||||
self.rewind_state = _RewindState({}, [], None)
|
||||
|
||||
self.text_memory = 0
|
||||
|
||||
|
|
@ -396,16 +404,16 @@ class PngStream(ChunkStream):
|
|||
raise ValueError(msg)
|
||||
|
||||
def save_rewind(self) -> None:
|
||||
self.rewind_state = {
|
||||
"info": self.im_info.copy(),
|
||||
"tile": self.im_tile,
|
||||
"seq_num": self._seq_num,
|
||||
}
|
||||
self.rewind_state = _RewindState(
|
||||
self.im_info.copy(),
|
||||
self.im_tile,
|
||||
self._seq_num,
|
||||
)
|
||||
|
||||
def rewind(self) -> None:
|
||||
self.im_info = self.rewind_state["info"].copy()
|
||||
self.im_tile = self.rewind_state["tile"]
|
||||
self._seq_num = self.rewind_state["seq_num"]
|
||||
self.im_info = self.rewind_state.info.copy()
|
||||
self.im_tile = self.rewind_state.tile
|
||||
self._seq_num = self.rewind_state.seq_num
|
||||
|
||||
def chunk_iCCP(self, pos: int, length: int) -> bytes:
|
||||
# ICC profile
|
||||
|
|
@ -459,11 +467,11 @@ class PngStream(ChunkStream):
|
|||
def chunk_IDAT(self, pos: int, length: int) -> NoReturn:
|
||||
# image data
|
||||
if "bbox" in self.im_info:
|
||||
tile = [("zip", self.im_info["bbox"], pos, self.im_rawmode)]
|
||||
tile = [ImageFile._Tile("zip", self.im_info["bbox"], pos, self.im_rawmode)]
|
||||
else:
|
||||
if self.im_n_frames is not None:
|
||||
self.im_info["default_image"] = True
|
||||
tile = [("zip", (0, 0) + self.im_size, pos, self.im_rawmode)]
|
||||
tile = [ImageFile._Tile("zip", (0, 0) + self.im_size, pos, self.im_rawmode)]
|
||||
self.im_tile = tile
|
||||
self.im_idat = length
|
||||
msg = "image data found"
|
||||
|
|
|
|||
|
|
@ -151,7 +151,9 @@ class PpmImageFile(ImageFile.ImageFile):
|
|||
decoder_name = "ppm"
|
||||
|
||||
args = rawmode if decoder_name == "raw" else (rawmode, maxval)
|
||||
self.tile = [(decoder_name, (0, 0) + self.size, self.fp.tell(), args)]
|
||||
self.tile = [
|
||||
ImageFile._Tile(decoder_name, (0, 0) + self.size, self.fp.tell(), args)
|
||||
]
|
||||
|
||||
|
||||
#
|
||||
|
|
@ -282,7 +284,7 @@ class PpmPlainDecoder(ImageFile.PyDecoder):
|
|||
break
|
||||
return data
|
||||
|
||||
def decode(self, buffer: bytes) -> tuple[int, int]:
|
||||
def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
|
||||
self._comment_spans = False
|
||||
if self.mode == "1":
|
||||
data = self._decode_bitonal()
|
||||
|
|
@ -298,7 +300,7 @@ class PpmPlainDecoder(ImageFile.PyDecoder):
|
|||
class PpmDecoder(ImageFile.PyDecoder):
|
||||
_pulls_fd = True
|
||||
|
||||
def decode(self, buffer: bytes) -> tuple[int, int]:
|
||||
def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
|
||||
assert self.fd is not None
|
||||
|
||||
data = bytearray()
|
||||
|
|
@ -333,7 +335,7 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
|
|||
rawmode, head = "1;I", b"P4"
|
||||
elif im.mode == "L":
|
||||
rawmode, head = "L", b"P5"
|
||||
elif im.mode == "I":
|
||||
elif im.mode in ("I", "I;16"):
|
||||
rawmode, head = "I;16B", b"P5"
|
||||
elif im.mode in ("RGB", "RGBA"):
|
||||
rawmode, head = "RGB", b"P6"
|
||||
|
|
|
|||
|
|
@ -277,8 +277,8 @@ def _layerinfo(
|
|||
|
||||
def _maketile(
|
||||
file: IO[bytes], mode: str, bbox: tuple[int, int, int, int], channels: int
|
||||
) -> list[ImageFile._Tile] | None:
|
||||
tiles = None
|
||||
) -> list[ImageFile._Tile]:
|
||||
tiles = []
|
||||
read = file.read
|
||||
|
||||
compression = i16(read(2))
|
||||
|
|
@ -291,7 +291,6 @@ def _maketile(
|
|||
if compression == 0:
|
||||
#
|
||||
# raw compression
|
||||
tiles = []
|
||||
for channel in range(channels):
|
||||
layer = mode[channel]
|
||||
if mode == "CMYK":
|
||||
|
|
@ -303,7 +302,6 @@ def _maketile(
|
|||
#
|
||||
# packbits compression
|
||||
i = 0
|
||||
tiles = []
|
||||
bytecount = read(channels * ysize * 2)
|
||||
offset = file.tell()
|
||||
for channel in range(channels):
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ class QoiImageFile(ImageFile.ImageFile):
|
|||
self._mode = "RGB" if channels == 3 else "RGBA"
|
||||
|
||||
self.fp.seek(1, os.SEEK_CUR) # colorspace
|
||||
self.tile = [("qoi", (0, 0) + self._size, self.fp.tell(), None)]
|
||||
self.tile = [ImageFile._Tile("qoi", (0, 0) + self._size, self.fp.tell(), None)]
|
||||
|
||||
|
||||
class QoiDecoder(ImageFile.PyDecoder):
|
||||
|
|
@ -47,7 +47,7 @@ class QoiDecoder(ImageFile.PyDecoder):
|
|||
hash_value = (r * 3 + g * 5 + b * 7 + a * 11) % 64
|
||||
self._previously_seen_pixels[hash_value] = value
|
||||
|
||||
def decode(self, buffer: bytes) -> tuple[int, int]:
|
||||
def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
|
||||
assert self.fd is not None
|
||||
|
||||
self._previously_seen_pixels = {}
|
||||
|
|
|
|||
|
|
@ -109,19 +109,28 @@ class SgiImageFile(ImageFile.ImageFile):
|
|||
pagesize = xsize * ysize * bpc
|
||||
if bpc == 2:
|
||||
self.tile = [
|
||||
("SGI16", (0, 0) + self.size, headlen, (self.mode, 0, orientation))
|
||||
ImageFile._Tile(
|
||||
"SGI16",
|
||||
(0, 0) + self.size,
|
||||
headlen,
|
||||
(self.mode, 0, orientation),
|
||||
)
|
||||
]
|
||||
else:
|
||||
self.tile = []
|
||||
offset = headlen
|
||||
for layer in self.mode:
|
||||
self.tile.append(
|
||||
("raw", (0, 0) + self.size, offset, (layer, 0, orientation))
|
||||
ImageFile._Tile(
|
||||
"raw", (0, 0) + self.size, offset, (layer, 0, orientation)
|
||||
)
|
||||
)
|
||||
offset += pagesize
|
||||
elif compression == 1:
|
||||
self.tile = [
|
||||
("sgi_rle", (0, 0) + self.size, headlen, (rawmode, orientation, bpc))
|
||||
ImageFile._Tile(
|
||||
"sgi_rle", (0, 0) + self.size, headlen, (rawmode, orientation, bpc)
|
||||
)
|
||||
]
|
||||
|
||||
|
||||
|
|
@ -205,7 +214,7 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
|
|||
class SGI16Decoder(ImageFile.PyDecoder):
|
||||
_pulls_fd = True
|
||||
|
||||
def decode(self, buffer: bytes) -> tuple[int, int]:
|
||||
def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
|
||||
assert self.fd is not None
|
||||
assert self.im is not None
|
||||
|
||||
|
|
|
|||
|
|
@ -154,7 +154,9 @@ class SpiderImageFile(ImageFile.ImageFile):
|
|||
self.rawmode = "F;32F"
|
||||
self._mode = "F"
|
||||
|
||||
self.tile = [("raw", (0, 0) + self.size, offset, (self.rawmode, 0, 1))]
|
||||
self.tile = [
|
||||
ImageFile._Tile("raw", (0, 0) + self.size, offset, (self.rawmode, 0, 1))
|
||||
]
|
||||
self._fp = self.fp # FIXME: hack
|
||||
|
||||
@property
|
||||
|
|
|
|||
|
|
@ -124,9 +124,13 @@ class SunImageFile(ImageFile.ImageFile):
|
|||
# (https://www.fileformat.info/format/sunraster/egff.htm)
|
||||
|
||||
if file_type in (0, 1, 3, 4, 5):
|
||||
self.tile = [("raw", (0, 0) + self.size, offset, (rawmode, stride))]
|
||||
self.tile = [
|
||||
ImageFile._Tile("raw", (0, 0) + self.size, offset, (rawmode, stride))
|
||||
]
|
||||
elif file_type == 2:
|
||||
self.tile = [("sun_rle", (0, 0) + self.size, offset, rawmode)]
|
||||
self.tile = [
|
||||
ImageFile._Tile("sun_rle", (0, 0) + self.size, offset, rawmode)
|
||||
]
|
||||
else:
|
||||
msg = "Unsupported Sun Raster file type"
|
||||
raise SyntaxError(msg)
|
||||
|
|
|
|||
|
|
@ -137,7 +137,7 @@ class TgaImageFile(ImageFile.ImageFile):
|
|||
if imagetype & 8:
|
||||
# compressed
|
||||
self.tile = [
|
||||
(
|
||||
ImageFile._Tile(
|
||||
"tga_rle",
|
||||
(0, 0) + self.size,
|
||||
self.fp.tell(),
|
||||
|
|
@ -146,7 +146,7 @@ class TgaImageFile(ImageFile.ImageFile):
|
|||
]
|
||||
else:
|
||||
self.tile = [
|
||||
(
|
||||
ImageFile._Tile(
|
||||
"raw",
|
||||
(0, 0) + self.size,
|
||||
self.fp.tell(),
|
||||
|
|
|
|||
|
|
@ -61,12 +61,14 @@ from ._typing import StrOrBytesPath
|
|||
from ._util import is_path
|
||||
from .TiffTags import TYPES
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from ._typing import Buffer, IntegralLike
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# Set these to true to force use of libtiff for reading or writing.
|
||||
READ_LIBTIFF = False
|
||||
WRITE_LIBTIFF = False
|
||||
IFD_LEGACY_API = True
|
||||
STRIP_SIZE = 65536
|
||||
|
||||
II = b"II" # little-endian (Intel style)
|
||||
|
|
@ -291,22 +293,24 @@ def _accept(prefix: bytes) -> bool:
|
|||
|
||||
def _limit_rational(
|
||||
val: float | Fraction | IFDRational, max_val: int
|
||||
) -> tuple[float, float]:
|
||||
) -> tuple[IntegralLike, IntegralLike]:
|
||||
inv = abs(float(val)) > 1
|
||||
n_d = IFDRational(1 / val if inv else val).limit_rational(max_val)
|
||||
return n_d[::-1] if inv else n_d
|
||||
|
||||
|
||||
def _limit_signed_rational(val, max_val, min_val):
|
||||
def _limit_signed_rational(
|
||||
val: IFDRational, max_val: int, min_val: int
|
||||
) -> tuple[IntegralLike, IntegralLike]:
|
||||
frac = Fraction(val)
|
||||
n_d = frac.numerator, frac.denominator
|
||||
n_d: tuple[IntegralLike, IntegralLike] = frac.numerator, frac.denominator
|
||||
|
||||
if min(n_d) < min_val:
|
||||
if min(float(i) for i in n_d) < min_val:
|
||||
n_d = _limit_rational(val, abs(min_val))
|
||||
|
||||
if max(n_d) > max_val:
|
||||
val = Fraction(*n_d)
|
||||
n_d = _limit_rational(val, max_val)
|
||||
n_d_float = tuple(float(i) for i in n_d)
|
||||
if max(n_d_float) > max_val:
|
||||
n_d = _limit_rational(n_d_float[0] / n_d_float[1], max_val)
|
||||
|
||||
return n_d
|
||||
|
||||
|
|
@ -318,8 +322,10 @@ _load_dispatch = {}
|
|||
_write_dispatch = {}
|
||||
|
||||
|
||||
def _delegate(op: str):
|
||||
def delegate(self, *args):
|
||||
def _delegate(op: str) -> Any:
|
||||
def delegate(
|
||||
self: IFDRational, *args: tuple[float, ...]
|
||||
) -> bool | float | Fraction:
|
||||
return getattr(self._val, op)(*args)
|
||||
|
||||
return delegate
|
||||
|
|
@ -357,6 +363,9 @@ class IFDRational(Rational):
|
|||
if isinstance(value, Fraction):
|
||||
self._numerator = value.numerator
|
||||
self._denominator = value.denominator
|
||||
else:
|
||||
if TYPE_CHECKING:
|
||||
self._numerator = cast(IntegralLike, value)
|
||||
else:
|
||||
self._numerator = value
|
||||
self._denominator = denominator
|
||||
|
|
@ -371,14 +380,14 @@ class IFDRational(Rational):
|
|||
self._val = Fraction(value / denominator)
|
||||
|
||||
@property
|
||||
def numerator(self):
|
||||
def numerator(self) -> IntegralLike:
|
||||
return self._numerator
|
||||
|
||||
@property
|
||||
def denominator(self) -> int:
|
||||
return self._denominator
|
||||
|
||||
def limit_rational(self, max_denominator: int) -> tuple[float, int]:
|
||||
def limit_rational(self, max_denominator: int) -> tuple[IntegralLike, int]:
|
||||
"""
|
||||
|
||||
:param max_denominator: Integer, the maximum denominator value
|
||||
|
|
@ -406,13 +415,17 @@ class IFDRational(Rational):
|
|||
val = float(val)
|
||||
return val == other
|
||||
|
||||
def __getstate__(self) -> list[float | Fraction]:
|
||||
def __getstate__(self) -> list[float | Fraction | IntegralLike]:
|
||||
return [self._val, self._numerator, self._denominator]
|
||||
|
||||
def __setstate__(self, state: list[float | Fraction]) -> None:
|
||||
def __setstate__(self, state: list[float | Fraction | IntegralLike]) -> None:
|
||||
IFDRational.__init__(self, 0)
|
||||
_val, _numerator, _denominator = state
|
||||
assert isinstance(_val, (float, Fraction))
|
||||
self._val = _val
|
||||
if TYPE_CHECKING:
|
||||
self._numerator = cast(IntegralLike, _numerator)
|
||||
else:
|
||||
self._numerator = _numerator
|
||||
assert isinstance(_denominator, int)
|
||||
self._denominator = _denominator
|
||||
|
|
@ -471,8 +484,8 @@ def _register_loader(idx: int, size: int) -> Callable[[_LoaderFunc], _LoaderFunc
|
|||
return decorator
|
||||
|
||||
|
||||
def _register_writer(idx: int):
|
||||
def decorator(func):
|
||||
def _register_writer(idx: int) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
|
||||
def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
|
||||
_write_dispatch[idx] = func # noqa: F821
|
||||
return func
|
||||
|
||||
|
|
@ -1111,7 +1124,7 @@ class ImageFileDirectory_v1(ImageFileDirectory_v2):
|
|||
return val
|
||||
|
||||
|
||||
# undone -- switch this pointer when IFD_LEGACY_API == False
|
||||
# undone -- switch this pointer
|
||||
ImageFileDirectory = ImageFileDirectory_v1
|
||||
|
||||
|
||||
|
|
@ -1126,7 +1139,7 @@ class TiffImageFile(ImageFile.ImageFile):
|
|||
|
||||
def __init__(
|
||||
self,
|
||||
fp: StrOrBytesPath | IO[bytes] | None = None,
|
||||
fp: StrOrBytesPath | IO[bytes],
|
||||
filename: str | bytes | None = None,
|
||||
) -> None:
|
||||
self.tag_v2: ImageFileDirectory_v2
|
||||
|
|
@ -1298,7 +1311,7 @@ class TiffImageFile(ImageFile.ImageFile):
|
|||
# (self._compression, (extents tuple),
|
||||
# 0, (rawmode, self._compression, fp))
|
||||
extents = self.tile[0][1]
|
||||
args = list(self.tile[0][3])
|
||||
args = self.tile[0][3]
|
||||
|
||||
# To be nice on memory footprint, if there's a
|
||||
# file descriptor, use that instead of reading
|
||||
|
|
@ -1316,11 +1329,12 @@ class TiffImageFile(ImageFile.ImageFile):
|
|||
fp = False
|
||||
|
||||
if fp:
|
||||
args[2] = fp
|
||||
assert isinstance(args, tuple)
|
||||
args_list = list(args)
|
||||
args_list[2] = fp
|
||||
args = tuple(args_list)
|
||||
|
||||
decoder = Image._getdecoder(
|
||||
self.mode, "libtiff", tuple(args), self.decoderconfig
|
||||
)
|
||||
decoder = Image._getdecoder(self.mode, "libtiff", args, self.decoderconfig)
|
||||
try:
|
||||
decoder.setimage(self.im, extents)
|
||||
except ValueError as e:
|
||||
|
|
@ -1538,7 +1552,7 @@ class TiffImageFile(ImageFile.ImageFile):
|
|||
# Offset in the tile tuple is 0, we go from 0,0 to
|
||||
# w,h, and we only do this once -- eds
|
||||
a = (rawmode, self._compression, False, self.tag_v2.offset)
|
||||
self.tile.append(("libtiff", (0, 0, xsize, ysize), 0, a))
|
||||
self.tile.append(ImageFile._Tile("libtiff", (0, 0, xsize, ysize), 0, a))
|
||||
|
||||
elif STRIPOFFSETS in self.tag_v2 or TILEOFFSETS in self.tag_v2:
|
||||
# striped image
|
||||
|
|
@ -1571,7 +1585,7 @@ class TiffImageFile(ImageFile.ImageFile):
|
|||
|
||||
args = (tile_rawmode, int(stride), 1)
|
||||
self.tile.append(
|
||||
(
|
||||
ImageFile._Tile(
|
||||
self._compression,
|
||||
(x, y, min(x + w, xsize), min(y + h, ysize)),
|
||||
offset,
|
||||
|
|
@ -1632,7 +1646,7 @@ SAVE_INFO = {
|
|||
}
|
||||
|
||||
|
||||
def _save(im: Image.Image, fp, filename: str | bytes) -> None:
|
||||
def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
|
||||
try:
|
||||
rawmode, prefix, photo, format, bits, extra = SAVE_INFO[im.mode]
|
||||
except KeyError as e:
|
||||
|
|
@ -1943,7 +1957,7 @@ def _save(im: Image.Image, fp, filename: str | bytes) -> None:
|
|||
setattr(im, "_debug_multipage", ifd)
|
||||
|
||||
|
||||
class AppendingTiffWriter:
|
||||
class AppendingTiffWriter(io.BytesIO):
|
||||
fieldSizes = [
|
||||
0, # None
|
||||
1, # byte
|
||||
|
|
@ -2053,6 +2067,12 @@ class AppendingTiffWriter:
|
|||
return self.f.tell() - self.offsetOfNewPage
|
||||
|
||||
def seek(self, offset: int, whence: int = io.SEEK_SET) -> int:
|
||||
"""
|
||||
:param offset: Distance to seek.
|
||||
:param whence: Whether the distance is relative to the start,
|
||||
end or current position.
|
||||
:returns: The resulting position, relative to the start.
|
||||
"""
|
||||
if whence == os.SEEK_SET:
|
||||
offset += self.offsetOfNewPage
|
||||
|
||||
|
|
@ -2086,7 +2106,7 @@ class AppendingTiffWriter:
|
|||
num_tags = self.readShort()
|
||||
self.f.seek(num_tags * 12, os.SEEK_CUR)
|
||||
|
||||
def write(self, data: bytes) -> int | None:
|
||||
def write(self, data: Buffer, /) -> int:
|
||||
return self.f.write(data)
|
||||
|
||||
def readShort(self) -> int:
|
||||
|
|
@ -2128,6 +2148,7 @@ class AppendingTiffWriter:
|
|||
|
||||
def close(self) -> None:
|
||||
self.finalize()
|
||||
if self.close_fp:
|
||||
self.f.close()
|
||||
|
||||
def fixIFD(self) -> None:
|
||||
|
|
|
|||
|
|
@ -142,7 +142,7 @@ class WebPImageFile(ImageFile.ImageFile):
|
|||
if self.fp and self._exclusive_fp:
|
||||
self.fp.close()
|
||||
self.fp = BytesIO(data)
|
||||
self.tile = [("raw", (0, 0) + self.size, 0, self.rawmode)]
|
||||
self.tile = [ImageFile._Tile("raw", (0, 0) + self.size, 0, self.rawmode)]
|
||||
|
||||
return super().load()
|
||||
|
||||
|
|
|
|||
|
|
@ -73,7 +73,11 @@ class XVThumbImageFile(ImageFile.ImageFile):
|
|||
|
||||
self.palette = ImagePalette.raw("RGB", PALETTE)
|
||||
|
||||
self.tile = [("raw", (0, 0) + self.size, self.fp.tell(), (self.mode, 0, 1))]
|
||||
self.tile = [
|
||||
ImageFile._Tile(
|
||||
"raw", (0, 0) + self.size, self.fp.tell(), (self.mode, 0, 1)
|
||||
)
|
||||
]
|
||||
|
||||
|
||||
# --------------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ class XbmImageFile(ImageFile.ImageFile):
|
|||
self._mode = "1"
|
||||
self._size = xsize, ysize
|
||||
|
||||
self.tile = [("xbm", (0, 0) + self.size, m.end(), None)]
|
||||
self.tile = [ImageFile._Tile("xbm", (0, 0) + self.size, m.end(), None)]
|
||||
|
||||
|
||||
def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
|
||||
|
|
|
|||
|
|
@ -101,7 +101,9 @@ class XpmImageFile(ImageFile.ImageFile):
|
|||
self._mode = "P"
|
||||
self.palette = ImagePalette.raw("RGB", b"".join(palette))
|
||||
|
||||
self.tile = [("raw", (0, 0) + self.size, self.fp.tell(), ("P", 0, 1))]
|
||||
self.tile = [
|
||||
ImageFile._Tile("raw", (0, 0) + self.size, self.fp.tell(), ("P", 0, 1))
|
||||
]
|
||||
|
||||
def load_read(self, read_bytes: int) -> bytes:
|
||||
#
|
||||
|
|
|
|||
|
|
@ -6,6 +6,8 @@ from collections.abc import Sequence
|
|||
from typing import TYPE_CHECKING, Any, Protocol, TypeVar, Union
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from numbers import _IntegralLike as IntegralLike
|
||||
|
||||
try:
|
||||
import numpy.typing as npt
|
||||
|
||||
|
|
@ -13,6 +15,11 @@ if TYPE_CHECKING:
|
|||
except (ImportError, AttributeError):
|
||||
pass
|
||||
|
||||
if sys.version_info >= (3, 12):
|
||||
from collections.abc import Buffer
|
||||
else:
|
||||
Buffer = Any
|
||||
|
||||
if sys.version_info >= (3, 10):
|
||||
from typing import TypeGuard
|
||||
else:
|
||||
|
|
@ -38,4 +45,4 @@ class SupportsRead(Protocol[_T_co]):
|
|||
StrOrBytesPath = Union[str, bytes, "os.PathLike[str]", "os.PathLike[bytes]"]
|
||||
|
||||
|
||||
__all__ = ["TypeGuard", "StrOrBytesPath", "SupportsRead"]
|
||||
__all__ = ["Buffer", "IntegralLike", "StrOrBytesPath", "SupportsRead", "TypeGuard"]
|
||||
|
|
|
|||
|
|
@ -272,7 +272,7 @@ text_layout_raqm(
|
|||
}
|
||||
set_text = raqm_set_text(rq, text, size);
|
||||
PyMem_Free(text);
|
||||
} else {
|
||||
} else if (PyBytes_Check(string)) {
|
||||
char *buffer;
|
||||
PyBytes_AsStringAndSize(string, &buffer, &size);
|
||||
if (!buffer || !size) {
|
||||
|
|
@ -281,6 +281,9 @@ text_layout_raqm(
|
|||
goto failed;
|
||||
}
|
||||
set_text = raqm_set_text_utf8(rq, buffer, size);
|
||||
} else {
|
||||
PyErr_SetString(PyExc_TypeError, "expected string or bytes");
|
||||
goto failed;
|
||||
}
|
||||
if (!set_text) {
|
||||
PyErr_SetString(PyExc_ValueError, "raqm_set_text() failed");
|
||||
|
|
@ -425,8 +428,11 @@ text_layout_fallback(
|
|||
|
||||
if (PyUnicode_Check(string)) {
|
||||
count = PyUnicode_GET_LENGTH(string);
|
||||
} else {
|
||||
} else if (PyBytes_Check(string)) {
|
||||
PyBytes_AsStringAndSize(string, &buffer, &count);
|
||||
} else {
|
||||
PyErr_SetString(PyExc_TypeError, "expected string or bytes");
|
||||
return 0;
|
||||
}
|
||||
if (count == 0) {
|
||||
return 0;
|
||||
|
|
|
|||
|
|
@ -185,7 +185,7 @@ put_pixel_32(Imaging im, int x, int y, const void *color) {
|
|||
}
|
||||
|
||||
void
|
||||
ImagingAccessInit() {
|
||||
ImagingAccessInit(void) {
|
||||
#define ADD(mode_, get_pixel_, put_pixel_) \
|
||||
{ \
|
||||
ImagingAccess access = add_item(mode_); \
|
||||
|
|
|
|||
|
|
@ -238,6 +238,9 @@ ImagingBoxBlur(Imaging imOut, Imaging imIn, float xradius, float yradius, int n)
|
|||
int i;
|
||||
Imaging imTransposed;
|
||||
|
||||
if (imOut->xsize == 0 || imOut->ysize == 0) {
|
||||
return imOut;
|
||||
}
|
||||
if (n < 1) {
|
||||
return ImagingError_ValueError("number of passes must be greater than zero");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -31,7 +31,27 @@ ImagingGetBBox(Imaging im, int bbox[4], int alpha_only) {
|
|||
bbox[2] = bbox[3] = 0;
|
||||
|
||||
#define GETBBOX(image, mask) \
|
||||
/* first stage: looking for any pixels from top */ \
|
||||
for (y = 0; y < im->ysize; y++) { \
|
||||
has_data = 0; \
|
||||
for (x = 0; x < im->xsize; x++) { \
|
||||
if (im->image[y][x] & mask) { \
|
||||
has_data = 1; \
|
||||
bbox[0] = x; \
|
||||
bbox[1] = y; \
|
||||
break; \
|
||||
} \
|
||||
} \
|
||||
if (has_data) { \
|
||||
break; \
|
||||
} \
|
||||
} \
|
||||
/* Check that we have a box */ \
|
||||
if (bbox[1] < 0) { \
|
||||
return 0; /* no data */ \
|
||||
} \
|
||||
/* second stage: looking for any pixels from bottom */ \
|
||||
for (y = im->ysize - 1; y >= bbox[1]; y--) { \
|
||||
has_data = 0; \
|
||||
for (x = 0; x < im->xsize; x++) { \
|
||||
if (im->image[y][x] & mask) { \
|
||||
|
|
@ -39,16 +59,27 @@ ImagingGetBBox(Imaging im, int bbox[4], int alpha_only) {
|
|||
if (x < bbox[0]) { \
|
||||
bbox[0] = x; \
|
||||
} \
|
||||
if (x >= bbox[2]) { \
|
||||
bbox[2] = x + 1; \
|
||||
} \
|
||||
bbox[3] = y + 1; \
|
||||
break; \
|
||||
} \
|
||||
} \
|
||||
if (has_data) { \
|
||||
if (bbox[1] < 0) { \
|
||||
bbox[1] = y; \
|
||||
break; \
|
||||
} \
|
||||
} \
|
||||
/* third stage: looking for left and right boundaries */ \
|
||||
for (y = bbox[1]; y < bbox[3]; y++) { \
|
||||
for (x = 0; x < bbox[0]; x++) { \
|
||||
if (im->image[y][x] & mask) { \
|
||||
bbox[0] = x; \
|
||||
break; \
|
||||
} \
|
||||
} \
|
||||
for (x = im->xsize - 1; x >= bbox[2]; x--) { \
|
||||
if (im->image[y][x] & mask) { \
|
||||
bbox[2] = x + 1; \
|
||||
break; \
|
||||
} \
|
||||
bbox[3] = y + 1; \
|
||||
} \
|
||||
}
|
||||
|
||||
|
|
@ -71,11 +102,6 @@ ImagingGetBBox(Imaging im, int bbox[4], int alpha_only) {
|
|||
GETBBOX(image32, mask);
|
||||
}
|
||||
|
||||
/* Check that we got a box */
|
||||
if (bbox[1] < 0) {
|
||||
return 0; /* no data */
|
||||
}
|
||||
|
||||
return 1; /* ok */
|
||||
}
|
||||
|
||||
|
|
@ -144,6 +170,9 @@ ImagingGetExtrema(Imaging im, void *extrema) {
|
|||
imax = in[x];
|
||||
}
|
||||
}
|
||||
if (imin == 0 && imax == 255) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
((UINT8 *)extrema)[0] = (UINT8)imin;
|
||||
((UINT8 *)extrema)[1] = (UINT8)imax;
|
||||
|
|
|
|||
|
|
@ -698,8 +698,7 @@ j2k_decode_entry(Imaging im, ImagingCodecState state) {
|
|||
}
|
||||
|
||||
/* Check that this image is something we can handle */
|
||||
if (image->numcomps < 1 || image->numcomps > 4 ||
|
||||
image->color_space == OPJ_CLRSPC_UNKNOWN) {
|
||||
if (image->numcomps < 1 || image->numcomps > 4) {
|
||||
state->errcode = IMAGING_CODEC_BROKEN;
|
||||
state->state = J2K_STATE_FAILED;
|
||||
goto quick_exit;
|
||||
|
|
@ -744,7 +743,7 @@ j2k_decode_entry(Imaging im, ImagingCodecState state) {
|
|||
/* Find the correct unpacker */
|
||||
color_space = image->color_space;
|
||||
|
||||
if (color_space == OPJ_CLRSPC_UNSPECIFIED) {
|
||||
if (color_space == OPJ_CLRSPC_UNKNOWN || color_space == OPJ_CLRSPC_UNSPECIFIED) {
|
||||
switch (image->numcomps) {
|
||||
case 1:
|
||||
case 2:
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ char *libjpeg_turbo_version = NULL;
|
|||
#endif
|
||||
|
||||
int
|
||||
ImagingJpegUseJCSExtensions() {
|
||||
ImagingJpegUseJCSExtensions(void) {
|
||||
int use_jcs_extensions = 0;
|
||||
#ifdef JCS_EXTENSIONS
|
||||
#if defined(LIBJPEG_TURBO_VERSION_NUMBER)
|
||||
|
|
|
|||
2
tox.ini
2
tox.ini
|
|
@ -36,4 +36,4 @@ deps =
|
|||
extras =
|
||||
typing
|
||||
commands =
|
||||
mypy docs src winbuild Tests {posargs}
|
||||
mypy conftest.py selftest.py setup.py docs src winbuild Tests {posargs}
|
||||
|
|
|
|||
|
|
@ -110,9 +110,9 @@ ARCHITECTURES = {
|
|||
|
||||
V = {
|
||||
"BROTLI": "1.1.0",
|
||||
"FREETYPE": "2.13.2",
|
||||
"FREETYPE": "2.13.3",
|
||||
"FRIBIDI": "1.0.15",
|
||||
"HARFBUZZ": "8.5.0",
|
||||
"HARFBUZZ": "9.0.0",
|
||||
"JPEGTURBO": "3.0.3",
|
||||
"LCMS2": "2.16",
|
||||
"LIBPNG": "1.6.43",
|
||||
|
|
@ -292,12 +292,8 @@ DEPS: dict[str, dict[str, Any]] = {
|
|||
},
|
||||
"build": [
|
||||
cmd_rmdir("objs"),
|
||||
cmd_msbuild(
|
||||
r"builds\windows\vc2010\freetype.sln", "Release Static", "Clean"
|
||||
),
|
||||
cmd_msbuild(
|
||||
r"builds\windows\vc2010\freetype.sln", "Release Static", "Build"
|
||||
),
|
||||
cmd_msbuild("MSBuild.sln", "Release Static", "Clean"),
|
||||
cmd_msbuild("MSBuild.sln", "Release Static", "Build"),
|
||||
cmd_xcopy("include", "{inc_dir}"),
|
||||
],
|
||||
"libs": [r"objs\{msbuild_arch}\Release Static\freetype.lib"],
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user