mirror of
https://github.com/python-pillow/Pillow.git
synced 2024-11-10 19:56:47 +03:00
Merge branch 'python-pillow:main' into type_comparison
This commit is contained in:
commit
282f740141
|
@ -51,7 +51,7 @@ build_script:
|
|||
|
||||
test_script:
|
||||
- cd c:\pillow
|
||||
- '%PYTHON%\%EXECUTABLE% -m pip install pytest pytest-cov pytest-timeout defusedxml numpy olefile pyroma'
|
||||
- '%PYTHON%\%EXECUTABLE% -m pip install pytest pytest-cov pytest-timeout defusedxml ipython numpy olefile pyroma'
|
||||
- c:\"Program Files (x86)"\"Windows Kits"\10\Debuggers\x86\gflags.exe /p /enable %PYTHON%\%EXECUTABLE%
|
||||
- '%PYTHON%\%EXECUTABLE% -c "from PIL import Image"'
|
||||
- '%PYTHON%\%EXECUTABLE% -m pytest -vx --cov PIL --cov Tests --cov-report term --cov-report xml Tests'
|
||||
|
|
|
@ -30,6 +30,7 @@ python3 -m pip install --upgrade pip
|
|||
python3 -m pip install --upgrade wheel
|
||||
python3 -m pip install coverage
|
||||
python3 -m pip install defusedxml
|
||||
python3 -m pip install ipython
|
||||
python3 -m pip install olefile
|
||||
python3 -m pip install -U pytest
|
||||
python3 -m pip install -U pytest-cov
|
||||
|
@ -52,10 +53,7 @@ if [[ $(uname) != CYGWIN* ]]; then
|
|||
fi
|
||||
|
||||
# Pyroma uses non-isolated build and fails with old setuptools
|
||||
if [[
|
||||
$GHA_PYTHON_VERSION == pypy3.9
|
||||
|| $GHA_PYTHON_VERSION == 3.9
|
||||
]]; then
|
||||
if [[ $GHA_PYTHON_VERSION == 3.9 ]]; then
|
||||
# To match pyproject.toml
|
||||
python3 -m pip install "setuptools>=67.8"
|
||||
fi
|
||||
|
|
|
@ -1 +1 @@
|
|||
cibuildwheel==2.19.2
|
||||
cibuildwheel==2.20.0
|
||||
|
|
|
@ -1 +1,12 @@
|
|||
mypy==1.11.0
|
||||
mypy==1.11.2
|
||||
IceSpringPySideStubs-PyQt6
|
||||
IceSpringPySideStubs-PySide6
|
||||
ipython
|
||||
numpy
|
||||
packaging
|
||||
pytest
|
||||
sphinx
|
||||
types-atheris
|
||||
types-defusedxml
|
||||
types-olefile
|
||||
types-setuptools
|
||||
|
|
4
.github/workflows/macos-install.sh
vendored
4
.github/workflows/macos-install.sh
vendored
|
@ -2,6 +2,9 @@
|
|||
|
||||
set -e
|
||||
|
||||
if [[ "$ImageOS" == "macos13" ]]; then
|
||||
brew uninstall gradle maven
|
||||
fi
|
||||
brew install \
|
||||
freetype \
|
||||
ghostscript \
|
||||
|
@ -20,6 +23,7 @@ export PKG_CONFIG_PATH="/usr/local/opt/openblas/lib/pkgconfig"
|
|||
|
||||
python3 -m pip install coverage
|
||||
python3 -m pip install defusedxml
|
||||
python3 -m pip install ipython
|
||||
python3 -m pip install olefile
|
||||
python3 -m pip install -U pytest
|
||||
python3 -m pip install -U pytest-cov
|
||||
|
|
1
.github/workflows/test-cygwin.yml
vendored
1
.github/workflows/test-cygwin.yml
vendored
|
@ -74,6 +74,7 @@ jobs:
|
|||
perl
|
||||
python3${{ matrix.python-minor-version }}-cython
|
||||
python3${{ matrix.python-minor-version }}-devel
|
||||
python3${{ matrix.python-minor-version }}-ipython
|
||||
python3${{ matrix.python-minor-version }}-numpy
|
||||
python3${{ matrix.python-minor-version }}-sip
|
||||
python3${{ matrix.python-minor-version }}-tkinter
|
||||
|
|
4
.github/workflows/test-windows.yml
vendored
4
.github/workflows/test-windows.yml
vendored
|
@ -35,7 +35,7 @@ jobs:
|
|||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
python-version: ["pypy3.10", "pypy3.9", "3.9", "3.10", "3.11", "3.12", "3.13"]
|
||||
python-version: ["pypy3.10", "3.9", "3.10", "3.11", "3.12", "3.13"]
|
||||
|
||||
timeout-minutes: 30
|
||||
|
||||
|
@ -87,7 +87,7 @@ jobs:
|
|||
echo "C:\Program Files\NASM" >> $env:GITHUB_PATH
|
||||
|
||||
choco install ghostscript --version=10.3.1 --no-progress
|
||||
echo "C:\Program Files\gs\gs10.00.0\bin" >> $env:GITHUB_PATH
|
||||
echo "C:\Program Files\gs\gs10.03.1\bin" >> $env:GITHUB_PATH
|
||||
|
||||
# Install extra test images
|
||||
xcopy /S /Y Tests\test-images\* Tests\images
|
||||
|
|
1
.github/workflows/test.yml
vendored
1
.github/workflows/test.yml
vendored
|
@ -42,7 +42,6 @@ jobs:
|
|||
]
|
||||
python-version: [
|
||||
"pypy3.10",
|
||||
"pypy3.9",
|
||||
"3.13",
|
||||
"3.12",
|
||||
"3.11",
|
||||
|
|
2
.github/workflows/wheels.yml
vendored
2
.github/workflows/wheels.yml
vendored
|
@ -48,7 +48,6 @@ jobs:
|
|||
fail-fast: false
|
||||
matrix:
|
||||
python-version:
|
||||
- pp39
|
||||
- pp310
|
||||
- cp3{9,10,11}
|
||||
- cp3{12,13}
|
||||
|
@ -57,7 +56,6 @@ jobs:
|
|||
- manylinux_2_28
|
||||
- musllinux
|
||||
exclude:
|
||||
- { python-version: pp39, spec: musllinux }
|
||||
- { python-version: pp310, spec: musllinux }
|
||||
|
||||
steps:
|
||||
|
|
|
@ -1,12 +1,12 @@
|
|||
repos:
|
||||
- repo: https://github.com/astral-sh/ruff-pre-commit
|
||||
rev: v0.5.0
|
||||
rev: v0.6.3
|
||||
hooks:
|
||||
- id: ruff
|
||||
args: [--exit-non-zero-on-fix]
|
||||
|
||||
- repo: https://github.com/psf/black-pre-commit-mirror
|
||||
rev: 24.4.2
|
||||
rev: 24.8.0
|
||||
hooks:
|
||||
- id: black
|
||||
|
||||
|
@ -50,7 +50,7 @@ repos:
|
|||
exclude: ^.github/.*TEMPLATE|^Tests/(fonts|images)/
|
||||
|
||||
- repo: https://github.com/python-jsonschema/check-jsonschema
|
||||
rev: 0.28.6
|
||||
rev: 0.29.2
|
||||
hooks:
|
||||
- id: check-github-workflows
|
||||
- id: check-readthedocs
|
||||
|
@ -62,12 +62,12 @@ repos:
|
|||
- id: sphinx-lint
|
||||
|
||||
- repo: https://github.com/tox-dev/pyproject-fmt
|
||||
rev: 2.1.3
|
||||
rev: 2.2.1
|
||||
hooks:
|
||||
- id: pyproject-fmt
|
||||
|
||||
- repo: https://github.com/abravalheri/validate-pyproject
|
||||
rev: v0.18
|
||||
rev: v0.19
|
||||
hooks:
|
||||
- id: validate-pyproject
|
||||
|
||||
|
|
30
CHANGES.rst
30
CHANGES.rst
|
@ -5,6 +5,36 @@ Changelog (Pillow)
|
|||
11.0.0 (unreleased)
|
||||
-------------------
|
||||
|
||||
- Treat unknown JPEG2000 colorspace as unspecified #8343
|
||||
[radarhere]
|
||||
|
||||
- Updated error message when saving WebP with invalid width or height #8322
|
||||
[radarhere, hugovk]
|
||||
|
||||
- Remove warning if NumPy failed to raise an error during conversion #8326
|
||||
[radarhere]
|
||||
|
||||
- If left and right sides meet in ImageDraw.rounded_rectangle(), do not draw rectangle to fill gap #8304
|
||||
[radarhere]
|
||||
|
||||
- Remove WebP support without anim, mux/demux, and with buggy alpha #8213
|
||||
[homm, radarhere]
|
||||
|
||||
- Add missing TIFF CMYK;16B reader #8298
|
||||
[homm]
|
||||
|
||||
- Remove all WITH_* flags from _imaging.c and other flags #8211
|
||||
[homm]
|
||||
|
||||
- Improve ImageDraw2 shape methods #8265
|
||||
[radarhere]
|
||||
|
||||
- Lock around usages of imaging memory arenas #8238
|
||||
[lysnikolaou]
|
||||
|
||||
- Deprecate JpegImageFile huffman_ac and huffman_dc #8274
|
||||
[radarhere]
|
||||
|
||||
- Deprecate ImageMath lambda_eval and unsafe_eval options argument #8242
|
||||
[radarhere]
|
||||
|
||||
|
|
Binary file not shown.
After Width: | Height: | Size: 411 B |
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,
|
||||
|
|
|
@ -105,91 +105,65 @@ class TestColorLut3DCoreAPI:
|
|||
with pytest.raises(TypeError):
|
||||
im.im.color_lut_3d("RGB", Image.Resampling.BILINEAR, 3, 2, 2, 2, 16)
|
||||
|
||||
def test_correct_args(self) -> None:
|
||||
@pytest.mark.parametrize(
|
||||
"lut_mode, table_channels, table_size",
|
||||
[
|
||||
("RGB", 3, 3),
|
||||
("CMYK", 4, 3),
|
||||
("RGB", 3, (2, 3, 3)),
|
||||
("RGB", 3, (65, 3, 3)),
|
||||
("RGB", 3, (3, 65, 3)),
|
||||
("RGB", 3, (2, 3, 65)),
|
||||
],
|
||||
)
|
||||
def test_correct_args(
|
||||
self, lut_mode: str, table_channels: int, table_size: int | tuple[int, int, int]
|
||||
) -> None:
|
||||
im = Image.new("RGB", (10, 10), 0)
|
||||
|
||||
im.im.color_lut_3d(
|
||||
"RGB", Image.Resampling.BILINEAR, *self.generate_identity_table(3, 3)
|
||||
)
|
||||
|
||||
im.im.color_lut_3d(
|
||||
"CMYK", Image.Resampling.BILINEAR, *self.generate_identity_table(4, 3)
|
||||
)
|
||||
|
||||
im.im.color_lut_3d(
|
||||
"RGB",
|
||||
lut_mode,
|
||||
Image.Resampling.BILINEAR,
|
||||
*self.generate_identity_table(3, (2, 3, 3)),
|
||||
*self.generate_identity_table(table_channels, table_size),
|
||||
)
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"image_mode, lut_mode, table_channels, table_size",
|
||||
[
|
||||
("L", "RGB", 3, 3),
|
||||
("RGB", "L", 3, 3),
|
||||
("L", "L", 3, 3),
|
||||
("RGB", "RGBA", 3, 3),
|
||||
("RGB", "RGB", 4, 3),
|
||||
],
|
||||
)
|
||||
def test_wrong_mode(
|
||||
self, image_mode: str, lut_mode: str, table_channels: int, table_size: int
|
||||
) -> None:
|
||||
with pytest.raises(ValueError, match="wrong mode"):
|
||||
im = Image.new(image_mode, (10, 10), 0)
|
||||
im.im.color_lut_3d(
|
||||
"RGB",
|
||||
lut_mode,
|
||||
Image.Resampling.BILINEAR,
|
||||
*self.generate_identity_table(3, (65, 3, 3)),
|
||||
*self.generate_identity_table(table_channels, table_size),
|
||||
)
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"image_mode, lut_mode, table_channels, table_size",
|
||||
[
|
||||
("RGBA", "RGBA", 3, 3),
|
||||
("RGBA", "RGBA", 4, 3),
|
||||
("RGB", "HSV", 3, 3),
|
||||
("RGB", "RGBA", 4, 3),
|
||||
],
|
||||
)
|
||||
def test_correct_mode(
|
||||
self, image_mode: str, lut_mode: str, table_channels: int, table_size: int
|
||||
) -> None:
|
||||
im = Image.new(image_mode, (10, 10), 0)
|
||||
im.im.color_lut_3d(
|
||||
"RGB",
|
||||
lut_mode,
|
||||
Image.Resampling.BILINEAR,
|
||||
*self.generate_identity_table(3, (3, 65, 3)),
|
||||
)
|
||||
|
||||
im.im.color_lut_3d(
|
||||
"RGB",
|
||||
Image.Resampling.BILINEAR,
|
||||
*self.generate_identity_table(3, (3, 3, 65)),
|
||||
)
|
||||
|
||||
def test_wrong_mode(self) -> None:
|
||||
with pytest.raises(ValueError, match="wrong mode"):
|
||||
im = Image.new("L", (10, 10), 0)
|
||||
im.im.color_lut_3d(
|
||||
"RGB", Image.Resampling.BILINEAR, *self.generate_identity_table(3, 3)
|
||||
)
|
||||
|
||||
with pytest.raises(ValueError, match="wrong mode"):
|
||||
im = Image.new("RGB", (10, 10), 0)
|
||||
im.im.color_lut_3d(
|
||||
"L", Image.Resampling.BILINEAR, *self.generate_identity_table(3, 3)
|
||||
)
|
||||
|
||||
with pytest.raises(ValueError, match="wrong mode"):
|
||||
im = Image.new("L", (10, 10), 0)
|
||||
im.im.color_lut_3d(
|
||||
"L", Image.Resampling.BILINEAR, *self.generate_identity_table(3, 3)
|
||||
)
|
||||
|
||||
with pytest.raises(ValueError, match="wrong mode"):
|
||||
im = Image.new("RGB", (10, 10), 0)
|
||||
im.im.color_lut_3d(
|
||||
"RGBA", Image.Resampling.BILINEAR, *self.generate_identity_table(3, 3)
|
||||
)
|
||||
|
||||
with pytest.raises(ValueError, match="wrong mode"):
|
||||
im = Image.new("RGB", (10, 10), 0)
|
||||
im.im.color_lut_3d(
|
||||
"RGB", Image.Resampling.BILINEAR, *self.generate_identity_table(4, 3)
|
||||
)
|
||||
|
||||
def test_correct_mode(self) -> None:
|
||||
im = Image.new("RGBA", (10, 10), 0)
|
||||
im.im.color_lut_3d(
|
||||
"RGBA", Image.Resampling.BILINEAR, *self.generate_identity_table(3, 3)
|
||||
)
|
||||
|
||||
im = Image.new("RGBA", (10, 10), 0)
|
||||
im.im.color_lut_3d(
|
||||
"RGBA", Image.Resampling.BILINEAR, *self.generate_identity_table(4, 3)
|
||||
)
|
||||
|
||||
im = Image.new("RGB", (10, 10), 0)
|
||||
im.im.color_lut_3d(
|
||||
"HSV", Image.Resampling.BILINEAR, *self.generate_identity_table(3, 3)
|
||||
)
|
||||
|
||||
im = Image.new("RGB", (10, 10), 0)
|
||||
im.im.color_lut_3d(
|
||||
"RGBA", Image.Resampling.BILINEAR, *self.generate_identity_table(4, 3)
|
||||
*self.generate_identity_table(table_channels, table_size),
|
||||
)
|
||||
|
||||
def test_identities(self) -> None:
|
||||
|
|
|
@ -10,11 +10,6 @@ from PIL import features
|
|||
|
||||
from .helper import skip_unless_feature
|
||||
|
||||
try:
|
||||
from PIL import _webp
|
||||
except ImportError:
|
||||
pass
|
||||
|
||||
|
||||
def test_check() -> None:
|
||||
# Check the correctness of the convenience function
|
||||
|
@ -23,6 +18,10 @@ def test_check() -> None:
|
|||
for codec in features.codecs:
|
||||
assert features.check_codec(codec) == features.check(codec)
|
||||
for feature in features.features:
|
||||
if "webp" in feature:
|
||||
with pytest.warns(DeprecationWarning):
|
||||
assert features.check_feature(feature) == features.check(feature)
|
||||
else:
|
||||
assert features.check_feature(feature) == features.check(feature)
|
||||
|
||||
|
||||
|
@ -48,23 +47,26 @@ def test_version() -> None:
|
|||
for codec in features.codecs:
|
||||
test(codec, features.version_codec)
|
||||
for feature in features.features:
|
||||
if "webp" in feature:
|
||||
with pytest.warns(DeprecationWarning):
|
||||
test(feature, features.version_feature)
|
||||
else:
|
||||
test(feature, features.version_feature)
|
||||
|
||||
|
||||
@skip_unless_feature("webp")
|
||||
def test_webp_transparency() -> None:
|
||||
assert features.check("transp_webp") != _webp.WebPDecoderBuggyAlpha()
|
||||
assert features.check("transp_webp") == _webp.HAVE_TRANSPARENCY
|
||||
with pytest.warns(DeprecationWarning):
|
||||
assert features.check("transp_webp") == features.check_module("webp")
|
||||
|
||||
|
||||
@skip_unless_feature("webp")
|
||||
def test_webp_mux() -> None:
|
||||
assert features.check("webp_mux") == _webp.HAVE_WEBPMUX
|
||||
with pytest.warns(DeprecationWarning):
|
||||
assert features.check("webp_mux") == features.check_module("webp")
|
||||
|
||||
|
||||
@skip_unless_feature("webp")
|
||||
def test_webp_anim() -> None:
|
||||
assert features.check("webp_anim") == _webp.HAVE_WEBPANIM
|
||||
with pytest.warns(DeprecationWarning):
|
||||
assert features.check("webp_anim") == features.check_module("webp")
|
||||
|
||||
|
||||
@skip_unless_feature("libjpeg_turbo")
|
||||
|
|
|
@ -152,7 +152,7 @@ def test_sanity_ati2_bc5u(image_path: str) -> None:
|
|||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("image_path", "expected_path"),
|
||||
"image_path, expected_path",
|
||||
(
|
||||
# hexeditted to be typeless
|
||||
(TEST_FILE_DX10_BC5_TYPELESS, TEST_FILE_DX10_BC5_UNORM),
|
||||
|
@ -248,7 +248,7 @@ def test_dx10_r8g8b8a8_unorm_srgb() -> None:
|
|||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("mode", "size", "test_file"),
|
||||
"mode, size, test_file",
|
||||
[
|
||||
("L", (128, 128), TEST_FILE_UNCOMPRESSED_L),
|
||||
("LA", (128, 128), TEST_FILE_UNCOMPRESSED_L_WITH_ALPHA),
|
||||
|
@ -373,7 +373,7 @@ def test_save_unsupported_mode(tmp_path: Path) -> None:
|
|||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("mode", "test_file"),
|
||||
"mode, test_file",
|
||||
[
|
||||
("L", "Tests/images/linear_gradient.png"),
|
||||
("LA", "Tests/images/uncompressed_la.png"),
|
||||
|
|
|
@ -80,9 +80,7 @@ simple_eps_file_with_long_binary_data = (
|
|||
|
||||
|
||||
@pytest.mark.skipif(not HAS_GHOSTSCRIPT, reason="Ghostscript not available")
|
||||
@pytest.mark.parametrize(
|
||||
("filename", "size"), ((FILE1, (460, 352)), (FILE2, (360, 252)))
|
||||
)
|
||||
@pytest.mark.parametrize("filename, size", ((FILE1, (460, 352)), (FILE2, (360, 252))))
|
||||
@pytest.mark.parametrize("scale", (1, 2))
|
||||
def test_sanity(filename: str, size: tuple[int, int], scale: int) -> None:
|
||||
expected_size = tuple(s * scale for s in size)
|
||||
|
|
|
@ -978,7 +978,7 @@ def test_webp_background(tmp_path: Path) -> None:
|
|||
out = str(tmp_path / "temp.gif")
|
||||
|
||||
# Test opaque WebP background
|
||||
if features.check("webp") and features.check("webp_anim"):
|
||||
if features.check("webp"):
|
||||
with Image.open("Tests/images/hopper.webp") as im:
|
||||
assert im.info["background"] == (255, 255, 255, 255)
|
||||
im.save(out)
|
||||
|
@ -1378,8 +1378,24 @@ 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, loading_strategy) -> 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 +1405,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,
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -77,6 +77,16 @@ def test_getiptcinfo_zero_padding() -> None:
|
|||
assert len(iptc) == 3
|
||||
|
||||
|
||||
def test_getiptcinfo_tiff() -> None:
|
||||
# Arrange
|
||||
with Image.open("Tests/images/hopper.Lab.tif") as im:
|
||||
# Act
|
||||
iptc = IptcImagePlugin.getiptcinfo(im)
|
||||
|
||||
# Assert
|
||||
assert iptc == {(1, 90): b"\x1b%G", (2, 0): b"\xcf\xc0"}
|
||||
|
||||
|
||||
def test_getiptcinfo_tiff_none() -> None:
|
||||
# Arrange
|
||||
with Image.open("Tests/images/hopper.tif") as im:
|
||||
|
|
|
@ -991,6 +991,21 @@ 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
|
||||
|
@ -1019,13 +1034,16 @@ class TestFileJpeg:
|
|||
|
||||
# SOI, EOI
|
||||
for marker in b"\xff\xd8", b"\xff\xd9":
|
||||
assert marker in data[1] and marker in data[2]
|
||||
assert marker in data[1]
|
||||
assert marker in data[2]
|
||||
# DHT, DQT
|
||||
for marker in b"\xff\xc4", b"\xff\xdb":
|
||||
assert marker in data[1] and marker not in data[2]
|
||||
assert marker in data[1]
|
||||
assert marker not in data[2]
|
||||
# SOF0, SOS, APP0 (JFIF header)
|
||||
for marker in b"\xff\xc0", b"\xff\xda", b"\xff\xe0":
|
||||
assert marker not in data[1] and marker in data[2]
|
||||
assert marker not in data[1]
|
||||
assert marker in data[2]
|
||||
|
||||
with Image.open(BytesIO(data[0])) as interchange_im:
|
||||
with Image.open(BytesIO(data[1] + data[2])) as combined_im:
|
||||
|
@ -1045,6 +1063,13 @@ class TestFileJpeg:
|
|||
|
||||
assert im._repr_jpeg_() is None
|
||||
|
||||
def test_deprecation(self) -> None:
|
||||
with Image.open(TEST_FILE) as im:
|
||||
with pytest.warns(DeprecationWarning):
|
||||
assert im.huffman_ac == {}
|
||||
with pytest.warns(DeprecationWarning):
|
||||
assert im.huffman_dc == {}
|
||||
|
||||
|
||||
@pytest.mark.skipif(not is_win32(), reason="Windows only")
|
||||
@skip_unless_feature("jpg")
|
||||
|
|
|
@ -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",
|
||||
|
@ -233,7 +242,7 @@ def test_layers() -> None:
|
|||
("foo.jp2", {"no_jp2": True}, 0, b"\xff\x4f"),
|
||||
("foo.j2k", {"no_jp2": False}, 0, b"\xff\x4f"),
|
||||
("foo.jp2", {"no_jp2": False}, 4, b"jP"),
|
||||
("foo.jp2", {"no_jp2": False}, 4, b"jP"),
|
||||
(None, {"no_jp2": False}, 4, b"jP"),
|
||||
),
|
||||
)
|
||||
def test_no_jp2(name: str, args: dict[str, bool], offset: int, data: bytes) -> None:
|
||||
|
@ -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)
|
||||
|
||||
|
||||
|
|
|
@ -684,6 +684,13 @@ class TestFileTiff:
|
|||
with Image.open(outfile) as reloaded:
|
||||
assert_image_equal_tofile(reloaded, infile)
|
||||
|
||||
def test_invalid_tiled_dimensions(self) -> None:
|
||||
with open("Tests/images/tiff_tiled_planar_raw.tif", "rb") as fp:
|
||||
data = fp.read()
|
||||
b = BytesIO(data[:144] + b"\x02" + data[145:])
|
||||
with pytest.raises(ValueError):
|
||||
Image.open(b)
|
||||
|
||||
@pytest.mark.parametrize("mode", ("P", "PA"))
|
||||
def test_palette(self, mode: str, tmp_path: Path) -> None:
|
||||
outfile = str(tmp_path / "temp.tif")
|
||||
|
|
|
@ -48,8 +48,6 @@ class TestFileWebp:
|
|||
self.rgb_mode = "RGB"
|
||||
|
||||
def test_version(self) -> None:
|
||||
_webp.WebPDecoderVersion()
|
||||
_webp.WebPDecoderBuggyAlpha()
|
||||
version = features.version_module("webp")
|
||||
assert version is not None
|
||||
assert re.search(r"\d+\.\d+\.\d+$", version)
|
||||
|
@ -117,7 +115,6 @@ class TestFileWebp:
|
|||
hopper().save(buffer_method, format="WEBP", method=6)
|
||||
assert buffer_no_args.getbuffer() != buffer_method.getbuffer()
|
||||
|
||||
@skip_unless_feature("webp_anim")
|
||||
def test_save_all(self, tmp_path: Path) -> None:
|
||||
temp_file = str(tmp_path / "temp.webp")
|
||||
im = Image.new("RGB", (1, 1))
|
||||
|
@ -132,7 +129,6 @@ class TestFileWebp:
|
|||
|
||||
def test_icc_profile(self, tmp_path: Path) -> None:
|
||||
self._roundtrip(tmp_path, self.rgb_mode, 12.5, {"icc_profile": None})
|
||||
if _webp.HAVE_WEBPANIM:
|
||||
self._roundtrip(
|
||||
tmp_path, self.rgb_mode, 12.5, {"icc_profile": None, "save_all": True}
|
||||
)
|
||||
|
@ -161,27 +157,32 @@ class TestFileWebp:
|
|||
im.save(temp_file, method=0)
|
||||
assert str(e.value) == "encoding error 6"
|
||||
|
||||
@pytest.mark.skipif(sys.maxsize <= 2**32, reason="Requires 64-bit system")
|
||||
def test_write_encoding_error_bad_dimension(self, tmp_path: Path) -> None:
|
||||
temp_file = str(tmp_path / "temp.webp")
|
||||
im = Image.new("L", (16384, 16384))
|
||||
with pytest.raises(ValueError) as e:
|
||||
im.save(temp_file)
|
||||
assert (
|
||||
str(e.value)
|
||||
== "encoding error 5: Image size exceeds WebP limit of 16383 pixels"
|
||||
)
|
||||
|
||||
def test_WebPEncode_with_invalid_args(self) -> None:
|
||||
"""
|
||||
Calling encoder functions with no arguments should result in an error.
|
||||
"""
|
||||
|
||||
if _webp.HAVE_WEBPANIM:
|
||||
with pytest.raises(TypeError):
|
||||
_webp.WebPAnimEncoder()
|
||||
with pytest.raises(TypeError):
|
||||
_webp.WebPEncode()
|
||||
|
||||
def test_WebPDecode_with_invalid_args(self) -> None:
|
||||
def test_WebPAnimDecoder_with_invalid_args(self) -> None:
|
||||
"""
|
||||
Calling decoder functions with no arguments should result in an error.
|
||||
"""
|
||||
|
||||
if _webp.HAVE_WEBPANIM:
|
||||
with pytest.raises(TypeError):
|
||||
_webp.WebPAnimDecoder()
|
||||
with pytest.raises(TypeError):
|
||||
_webp.WebPDecode()
|
||||
|
||||
def test_no_resource_warning(self, tmp_path: Path) -> None:
|
||||
file_path = "Tests/images/hopper.webp"
|
||||
|
@ -200,7 +201,6 @@ class TestFileWebp:
|
|||
"background",
|
||||
(0, (0,), (-1, 0, 1, 2), (253, 254, 255, 256)),
|
||||
)
|
||||
@skip_unless_feature("webp_anim")
|
||||
def test_invalid_background(
|
||||
self, background: int | tuple[int, ...], tmp_path: Path
|
||||
) -> None:
|
||||
|
@ -209,7 +209,6 @@ class TestFileWebp:
|
|||
with pytest.raises(OSError):
|
||||
im.save(temp_file, save_all=True, append_images=[im], background=background)
|
||||
|
||||
@skip_unless_feature("webp_anim")
|
||||
def test_background_from_gif(self, tmp_path: Path) -> None:
|
||||
# Save L mode GIF with background
|
||||
with Image.open("Tests/images/no_palette_with_background.gif") as im:
|
||||
|
@ -234,7 +233,6 @@ class TestFileWebp:
|
|||
difference = sum(abs(original_value[i] - reread_value[i]) for i in range(0, 3))
|
||||
assert difference < 5
|
||||
|
||||
@skip_unless_feature("webp_anim")
|
||||
def test_duration(self, tmp_path: Path) -> None:
|
||||
with Image.open("Tests/images/dispose_bgnd.gif") as im:
|
||||
assert im.info["duration"] == 1000
|
||||
|
@ -250,6 +248,7 @@ class TestFileWebp:
|
|||
temp_file = str(tmp_path / "temp.webp")
|
||||
im = Image.new("RGBA", (1, 1)).convert("P")
|
||||
assert im.mode == "P"
|
||||
assert im.palette is not None
|
||||
assert im.palette.mode == "RGBA"
|
||||
im.save(temp_file)
|
||||
|
||||
|
|
|
@ -13,12 +13,7 @@ from .helper import (
|
|||
hopper,
|
||||
)
|
||||
|
||||
_webp = pytest.importorskip("PIL._webp", reason="WebP support not installed")
|
||||
|
||||
|
||||
def setup_module() -> None:
|
||||
if _webp.WebPDecoderBuggyAlpha():
|
||||
pytest.skip("Buggy early version of WebP installed, not testing transparency")
|
||||
pytest.importorskip("PIL._webp", reason="WebP support not installed")
|
||||
|
||||
|
||||
def test_read_rgba() -> None:
|
||||
|
@ -81,9 +76,6 @@ def test_write_rgba(tmp_path: Path) -> None:
|
|||
pil_image = Image.new("RGBA", (10, 10), (255, 0, 0, 20))
|
||||
pil_image.save(temp_file)
|
||||
|
||||
if _webp.WebPDecoderBuggyAlpha():
|
||||
return
|
||||
|
||||
with Image.open(temp_file) as image:
|
||||
image.load()
|
||||
|
||||
|
@ -93,11 +85,6 @@ def test_write_rgba(tmp_path: Path) -> None:
|
|||
image.load()
|
||||
image.getdata()
|
||||
|
||||
# Early versions of WebP are known to produce higher deviations:
|
||||
# deal with it
|
||||
if _webp.WebPDecoderVersion() <= 0x201:
|
||||
assert_image_similar(image, pil_image, 3.0)
|
||||
else:
|
||||
assert_image_similar(image, pil_image, 1.0)
|
||||
|
||||
|
||||
|
|
|
@ -15,10 +15,7 @@ from .helper import (
|
|||
skip_unless_feature,
|
||||
)
|
||||
|
||||
pytestmark = [
|
||||
skip_unless_feature("webp"),
|
||||
skip_unless_feature("webp_anim"),
|
||||
]
|
||||
pytestmark = skip_unless_feature("webp")
|
||||
|
||||
|
||||
def test_n_frames() -> None:
|
||||
|
|
|
@ -8,14 +8,11 @@ from PIL import Image
|
|||
|
||||
from .helper import assert_image_equal, hopper
|
||||
|
||||
_webp = pytest.importorskip("PIL._webp", reason="WebP support not installed")
|
||||
pytest.importorskip("PIL._webp", reason="WebP support not installed")
|
||||
RGB_MODE = "RGB"
|
||||
|
||||
|
||||
def test_write_lossless_rgb(tmp_path: Path) -> None:
|
||||
if _webp.WebPDecoderVersion() < 0x0200:
|
||||
pytest.skip("lossless not included")
|
||||
|
||||
temp_file = str(tmp_path / "temp.webp")
|
||||
|
||||
hopper(RGB_MODE).save(temp_file, lossless=True)
|
||||
|
|
|
@ -10,10 +10,7 @@ from PIL import Image
|
|||
|
||||
from .helper import mark_if_feature_version, skip_unless_feature
|
||||
|
||||
pytestmark = [
|
||||
skip_unless_feature("webp"),
|
||||
skip_unless_feature("webp_mux"),
|
||||
]
|
||||
pytestmark = skip_unless_feature("webp")
|
||||
|
||||
ElementTree: ModuleType | None
|
||||
try:
|
||||
|
@ -119,7 +116,15 @@ def test_read_no_exif() -> None:
|
|||
def test_getxmp() -> None:
|
||||
with Image.open("Tests/images/flower.webp") as im:
|
||||
assert "xmp" not in im.info
|
||||
assert im.getxmp() == {}
|
||||
if ElementTree is None:
|
||||
with pytest.warns(
|
||||
UserWarning,
|
||||
match="XMP data cannot be read without defusedxml dependency",
|
||||
):
|
||||
xmp = im.getxmp()
|
||||
else:
|
||||
xmp = im.getxmp()
|
||||
assert xmp == {}
|
||||
|
||||
with Image.open("Tests/images/flower2.webp") as im:
|
||||
if ElementTree is None:
|
||||
|
@ -136,7 +141,6 @@ def test_getxmp() -> None:
|
|||
)
|
||||
|
||||
|
||||
@skip_unless_feature("webp_anim")
|
||||
def test_write_animated_metadata(tmp_path: Path) -> None:
|
||||
iccp_data = b"<iccp_data>"
|
||||
exif_data = b"<exif_data>"
|
||||
|
|
|
@ -42,6 +42,12 @@ try:
|
|||
except ImportError:
|
||||
ElementTree = None
|
||||
|
||||
PrettyPrinter: type | None
|
||||
try:
|
||||
from IPython.lib.pretty import PrettyPrinter
|
||||
except ImportError:
|
||||
PrettyPrinter = None
|
||||
|
||||
|
||||
# Deprecation helper
|
||||
def helper_image_new(mode: str, size: tuple[int, int]) -> Image.Image:
|
||||
|
@ -91,16 +97,15 @@ class TestImage:
|
|||
# with pytest.raises(MemoryError):
|
||||
# Image.new("L", (1000000, 1000000))
|
||||
|
||||
@pytest.mark.skipif(PrettyPrinter is None, reason="IPython is not installed")
|
||||
def test_repr_pretty(self) -> None:
|
||||
class Pretty:
|
||||
def text(self, text: str) -> None:
|
||||
self.pretty_output = text
|
||||
|
||||
im = Image.new("L", (100, 100))
|
||||
|
||||
p = Pretty()
|
||||
output = io.StringIO()
|
||||
assert PrettyPrinter is not None
|
||||
p = PrettyPrinter(output)
|
||||
im._repr_pretty_(p, False)
|
||||
assert p.pretty_output == "<PIL.Image.Image image mode=L size=100x100>"
|
||||
assert output.getvalue() == "<PIL.Image.Image image mode=L size=100x100>"
|
||||
|
||||
def test_open_formats(self) -> None:
|
||||
PNGFILE = "Tests/images/hopper.png"
|
||||
|
@ -700,6 +705,7 @@ class TestImage:
|
|||
assert new_image.size == image.size
|
||||
assert new_image.info == base_image.info
|
||||
if palette_result is not None:
|
||||
assert new_image.palette is not None
|
||||
assert new_image.palette.tobytes() == palette_result.tobytes()
|
||||
else:
|
||||
assert new_image.palette is None
|
||||
|
@ -769,6 +775,14 @@ class TestImage:
|
|||
exif.load(b"Exif\x00\x00")
|
||||
assert not dict(exif)
|
||||
|
||||
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"
|
||||
)
|
||||
|
@ -817,7 +831,6 @@ class TestImage:
|
|||
assert reloaded_exif[305] == "Pillow test"
|
||||
|
||||
@skip_unless_feature("webp")
|
||||
@skip_unless_feature("webp_anim")
|
||||
def test_exif_webp(self, tmp_path: Path) -> None:
|
||||
with Image.open("Tests/images/hopper.webp") as im:
|
||||
exif = im.getexif()
|
||||
|
@ -939,7 +952,15 @@ class TestImage:
|
|||
|
||||
def test_empty_xmp(self) -> None:
|
||||
with Image.open("Tests/images/hopper.gif") as im:
|
||||
assert im.getxmp() == {}
|
||||
if ElementTree is None:
|
||||
with pytest.warns(
|
||||
UserWarning,
|
||||
match="XMP data cannot be read without defusedxml dependency",
|
||||
):
|
||||
xmp = im.getxmp()
|
||||
else:
|
||||
xmp = im.getxmp()
|
||||
assert xmp == {}
|
||||
|
||||
def test_getxmp_padded(self) -> None:
|
||||
im = Image.new("RGB", (1, 1))
|
||||
|
@ -990,12 +1011,14 @@ class TestImage:
|
|||
# P mode with RGBA palette
|
||||
im = Image.new("RGBA", (1, 1)).convert("P")
|
||||
assert im.mode == "P"
|
||||
assert im.palette is not None
|
||||
assert im.palette.mode == "RGBA"
|
||||
assert im.has_transparency_data
|
||||
|
||||
def test_apply_transparency(self) -> None:
|
||||
im = Image.new("P", (1, 1))
|
||||
im.putpalette((0, 0, 0, 1, 1, 1))
|
||||
assert im.palette is not None
|
||||
assert im.palette.colors == {(0, 0, 0): 0, (1, 1, 1): 1}
|
||||
|
||||
# Test that no transformation is applied without transparency
|
||||
|
@ -1013,13 +1036,16 @@ class TestImage:
|
|||
im.putpalette((0, 0, 0, 255, 1, 1, 1, 128), "RGBA")
|
||||
im.info["transparency"] = 0
|
||||
im.apply_transparency()
|
||||
assert im.palette is not None
|
||||
assert im.palette.colors == {(0, 0, 0, 0): 0, (1, 1, 1, 128): 1}
|
||||
|
||||
# Test that transparency bytes are applied
|
||||
with Image.open("Tests/images/pil123p.png") as im:
|
||||
assert isinstance(im.info["transparency"], bytes)
|
||||
assert im.palette is not None
|
||||
assert im.palette.colors[(27, 35, 6)] == 24
|
||||
im.apply_transparency()
|
||||
assert im.palette is not None
|
||||
assert im.palette.colors[(27, 35, 6, 214)] == 24
|
||||
|
||||
def test_constants(self) -> None:
|
||||
|
|
|
@ -230,7 +230,7 @@ class TestImagePutPixelError:
|
|||
im.putpixel((0, 0), v) # type: ignore[arg-type]
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("mode", "band_numbers", "match"),
|
||||
"mode, band_numbers, match",
|
||||
(
|
||||
("L", (0, 2), "color must be int or single-element tuple"),
|
||||
("LA", (0, 3), "color must be int, or tuple of one or two elements"),
|
||||
|
|
|
@ -47,7 +47,7 @@ def test_toarray() -> None:
|
|||
with pytest.raises(OSError):
|
||||
numpy.array(im_truncated)
|
||||
else:
|
||||
with pytest.warns(UserWarning):
|
||||
with pytest.warns(DeprecationWarning):
|
||||
numpy.array(im_truncated)
|
||||
|
||||
|
||||
|
@ -113,4 +113,5 @@ def test_fromarray_palette() -> None:
|
|||
out = Image.fromarray(a, "P")
|
||||
|
||||
# Assert that the Python and C palettes match
|
||||
assert out.palette is not None
|
||||
assert len(out.palette.colors) == len(out.im.getpalette()) / 3
|
||||
|
|
|
@ -218,6 +218,7 @@ def test_trns_RGB(tmp_path: Path) -> None:
|
|||
def test_l_macro_rounding(convert_mode: str) -> None:
|
||||
for mode in ("P", "PA"):
|
||||
im = Image.new(mode, (1, 1))
|
||||
assert im.palette is not None
|
||||
im.palette.getcolor((0, 1, 2))
|
||||
|
||||
converted_im = im.convert(convert_mode)
|
||||
|
|
|
@ -86,6 +86,7 @@ def test_rgba_palette(mode: str, palette: tuple[int, ...]) -> None:
|
|||
im = Image.new("P", (1, 1))
|
||||
im.putpalette(palette, mode)
|
||||
assert im.getpalette() == [1, 2, 3]
|
||||
assert im.palette is not None
|
||||
assert im.palette.colors == {(1, 2, 3, 4): 0}
|
||||
|
||||
|
||||
|
|
|
@ -69,6 +69,7 @@ def test_quantize_no_dither() -> None:
|
|||
|
||||
converted = image.quantize(dither=Image.Dither.NONE, palette=palette)
|
||||
assert converted.mode == "P"
|
||||
assert converted.palette is not None
|
||||
assert converted.palette.palette == palette.palette.palette
|
||||
|
||||
|
||||
|
@ -81,6 +82,7 @@ def test_quantize_no_dither2() -> None:
|
|||
palette.putpalette(data)
|
||||
quantized = im.quantize(dither=Image.Dither.NONE, palette=palette)
|
||||
|
||||
assert quantized.palette is not None
|
||||
assert tuple(quantized.palette.palette) == data
|
||||
|
||||
px = quantized.load()
|
||||
|
@ -117,6 +119,7 @@ def test_colors() -> None:
|
|||
im = hopper()
|
||||
colors = 2
|
||||
converted = im.quantize(colors)
|
||||
assert converted.palette is not None
|
||||
assert len(converted.palette.palette) == colors * len("RGB")
|
||||
|
||||
|
||||
|
@ -147,6 +150,7 @@ def test_palette(method: Image.Quantize, color: tuple[int, ...]) -> None:
|
|||
converted = im.quantize(method=method)
|
||||
converted_px = converted.load()
|
||||
assert converted_px is not None
|
||||
assert converted.palette is not None
|
||||
assert converted_px[0, 0] == converted.palette.colors[color]
|
||||
|
||||
|
||||
|
|
|
@ -398,7 +398,8 @@ def test_logical() -> None:
|
|||
for y in (a, b):
|
||||
imy = Image.new("1", (1, 1), y)
|
||||
value = op(imx, imy).getpixel((0, 0))
|
||||
assert not isinstance(value, tuple) and value is not None
|
||||
assert not isinstance(value, tuple)
|
||||
assert value is not None
|
||||
out.append(value)
|
||||
return out
|
||||
|
||||
|
|
|
@ -857,6 +857,27 @@ def test_rounded_rectangle_corners(
|
|||
)
|
||||
|
||||
|
||||
def test_rounded_rectangle_joined_x_different_corners() -> None:
|
||||
# Arrange
|
||||
im = Image.new("RGB", (W, H))
|
||||
draw = ImageDraw.Draw(im, "RGBA")
|
||||
|
||||
# Act
|
||||
draw.rounded_rectangle(
|
||||
(20, 10, 80, 90),
|
||||
30,
|
||||
fill="red",
|
||||
outline="green",
|
||||
width=5,
|
||||
corners=(True, False, False, False),
|
||||
)
|
||||
|
||||
# Assert
|
||||
assert_image_equal_tofile(
|
||||
im, "Tests/images/imagedraw_rounded_rectangle_joined_x_different_corners.png"
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"xy, radius, type",
|
||||
[
|
||||
|
|
|
@ -65,6 +65,36 @@ def test_mode() -> None:
|
|||
ImageDraw2.Draw("L")
|
||||
|
||||
|
||||
@pytest.mark.parametrize("bbox", BBOX)
|
||||
@pytest.mark.parametrize("start, end", ((0, 180), (0.5, 180.4)))
|
||||
def test_arc(bbox: Coords, start: float, end: float) -> None:
|
||||
# Arrange
|
||||
im = Image.new("RGB", (W, H))
|
||||
draw = ImageDraw2.Draw(im)
|
||||
pen = ImageDraw2.Pen("white", width=1)
|
||||
|
||||
# Act
|
||||
draw.arc(bbox, pen, start, end)
|
||||
|
||||
# Assert
|
||||
assert_image_similar_tofile(im, "Tests/images/imagedraw_arc.png", 1)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("bbox", BBOX)
|
||||
def test_chord(bbox: Coords) -> None:
|
||||
# Arrange
|
||||
im = Image.new("RGB", (W, H))
|
||||
draw = ImageDraw2.Draw(im)
|
||||
pen = ImageDraw2.Pen("yellow")
|
||||
brush = ImageDraw2.Brush("red")
|
||||
|
||||
# Act
|
||||
draw.chord(bbox, pen, 0, 180, brush)
|
||||
|
||||
# Assert
|
||||
assert_image_similar_tofile(im, "Tests/images/imagedraw_chord_RGB.png", 1)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("bbox", BBOX)
|
||||
def test_ellipse(bbox: Coords) -> None:
|
||||
# Arrange
|
||||
|
@ -123,6 +153,22 @@ def test_line_pen_as_brush(points: Coords) -> None:
|
|||
assert_image_equal_tofile(im, "Tests/images/imagedraw_line.png")
|
||||
|
||||
|
||||
@pytest.mark.parametrize("bbox", BBOX)
|
||||
@pytest.mark.parametrize("start, end", ((-92, 46), (-92.2, 46.2)))
|
||||
def test_pieslice(bbox: Coords, start: float, end: float) -> None:
|
||||
# Arrange
|
||||
im = Image.new("RGB", (W, H))
|
||||
draw = ImageDraw2.Draw(im)
|
||||
pen = ImageDraw2.Pen("blue")
|
||||
brush = ImageDraw2.Brush("white")
|
||||
|
||||
# Act
|
||||
draw.pieslice(bbox, pen, start, end, brush)
|
||||
|
||||
# Assert
|
||||
assert_image_similar_tofile(im, "Tests/images/imagedraw_pieslice.png", 1)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("points", POINTS)
|
||||
def test_polygon(points: Coords) -> None:
|
||||
# Arrange
|
||||
|
|
|
@ -94,7 +94,6 @@ class TestImageFile:
|
|||
assert (48, 48) == p.image.size
|
||||
|
||||
@skip_unless_feature("webp")
|
||||
@skip_unless_feature("webp_anim")
|
||||
def test_incremental_webp(self) -> None:
|
||||
with ImageFile.Parser() as p:
|
||||
with open("Tests/images/hopper.webp", "rb") as f:
|
||||
|
@ -239,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:
|
||||
|
@ -269,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()
|
||||
|
||||
|
@ -282,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()
|
||||
|
||||
|
@ -295,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()
|
||||
|
||||
|
@ -318,7 +327,13 @@ class TestPyEncoder(CodecsTest):
|
|||
|
||||
fp = BytesIO()
|
||||
ImageFile._save(
|
||||
im, fp, [("MOCK", (xoff, yoff, xoff + xsize, yoff + ysize), 0, "RGB")]
|
||||
im,
|
||||
fp,
|
||||
[
|
||||
ImageFile._Tile(
|
||||
"MOCK", (xoff, yoff, xoff + xsize, yoff + ysize), 0, "RGB"
|
||||
)
|
||||
],
|
||||
)
|
||||
|
||||
assert MockPyEncoder.last
|
||||
|
@ -331,10 +346,10 @@ 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, [("MOCK", None, 0, "RGB")])
|
||||
ImageFile._save(im, fp, [ImageFile._Tile("MOCK", None, 0, "RGB")])
|
||||
|
||||
assert MockPyEncoder.last
|
||||
assert MockPyEncoder.last.state.xoff == 0
|
||||
|
@ -351,7 +366,9 @@ class TestPyEncoder(CodecsTest):
|
|||
MockPyEncoder.last = None
|
||||
with pytest.raises(ValueError):
|
||||
ImageFile._save(
|
||||
im, fp, [("MOCK", (xoff, yoff, -10, yoff + ysize), 0, "RGB")]
|
||||
im,
|
||||
fp,
|
||||
[ImageFile._Tile("MOCK", (xoff, yoff, -10, yoff + ysize), 0, "RGB")],
|
||||
)
|
||||
last: MockPyEncoder | None = MockPyEncoder.last
|
||||
assert last
|
||||
|
@ -359,7 +376,9 @@ class TestPyEncoder(CodecsTest):
|
|||
|
||||
with pytest.raises(ValueError):
|
||||
ImageFile._save(
|
||||
im, fp, [("MOCK", (xoff, yoff, xoff + xsize, -10), 0, "RGB")]
|
||||
im,
|
||||
fp,
|
||||
[ImageFile._Tile("MOCK", (xoff, yoff, xoff + xsize, -10), 0, "RGB")],
|
||||
)
|
||||
|
||||
def test_oversize(self) -> None:
|
||||
|
@ -372,14 +391,22 @@ class TestPyEncoder(CodecsTest):
|
|||
ImageFile._save(
|
||||
im,
|
||||
fp,
|
||||
[("MOCK", (xoff, yoff, xoff + xsize + 100, yoff + ysize), 0, "RGB")],
|
||||
[
|
||||
ImageFile._Tile(
|
||||
"MOCK", (xoff, yoff, xoff + xsize + 100, yoff + ysize), 0, "RGB"
|
||||
)
|
||||
],
|
||||
)
|
||||
|
||||
with pytest.raises(ValueError):
|
||||
ImageFile._save(
|
||||
im,
|
||||
fp,
|
||||
[("MOCK", (xoff, yoff, xoff + xsize, yoff + ysize + 100), 0, "RGB")],
|
||||
[
|
||||
ImageFile._Tile(
|
||||
"MOCK", (xoff, yoff, xoff + xsize, yoff + ysize + 100), 0, "RGB"
|
||||
)
|
||||
],
|
||||
)
|
||||
|
||||
def test_encode(self) -> None:
|
||||
|
@ -395,9 +422,8 @@ class TestPyEncoder(CodecsTest):
|
|||
with pytest.raises(NotImplementedError):
|
||||
encoder.encode_to_pyfd()
|
||||
|
||||
fh = BytesIO()
|
||||
with pytest.raises(NotImplementedError):
|
||||
encoder.encode_to_file(fh, 0)
|
||||
encoder.encode_to_file(0, 0)
|
||||
|
||||
def test_zero_height(self) -> None:
|
||||
with pytest.raises(UnidentifiedImageError):
|
||||
|
|
|
@ -1113,6 +1113,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",
|
||||
|
|
|
@ -46,7 +46,8 @@ def img_to_string(im: Image.Image) -> str:
|
|||
line = ""
|
||||
for c in range(im.width):
|
||||
value = im.getpixel((c, r))
|
||||
assert not isinstance(value, tuple) and value is not None
|
||||
assert not isinstance(value, tuple)
|
||||
assert value is not None
|
||||
line += chars[value > 0]
|
||||
result.append(line)
|
||||
return "\n".join(result)
|
||||
|
|
|
@ -390,7 +390,7 @@ def test_colorize_3color_offset() -> None:
|
|||
|
||||
def test_exif_transpose() -> None:
|
||||
exts = [".jpg"]
|
||||
if features.check("webp") and features.check("webp_anim"):
|
||||
if features.check("webp"):
|
||||
exts.append(".webp")
|
||||
for ext in exts:
|
||||
with Image.open("Tests/images/hopper" + ext) as base_im:
|
||||
|
|
|
@ -46,7 +46,7 @@ def helper_pickle_string(protocol: int, test_file: str, mode: str | None) -> Non
|
|||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("test_file", "test_mode"),
|
||||
"test_file, test_mode",
|
||||
[
|
||||
("Tests/images/hopper.jpg", None),
|
||||
("Tests/images/hopper.jpg", "L"),
|
||||
|
|
|
@ -5,8 +5,6 @@ import sys
|
|||
from io import BytesIO
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from PIL import Image, PSDraw
|
||||
|
||||
|
||||
|
@ -49,15 +47,14 @@ def test_draw_postscript(tmp_path: Path) -> None:
|
|||
assert os.path.getsize(tempfile) > 0
|
||||
|
||||
|
||||
@pytest.mark.parametrize("buffer", (True, False))
|
||||
def test_stdout(buffer: bool) -> None:
|
||||
def test_stdout() -> None:
|
||||
# Temporarily redirect stdout
|
||||
old_stdout = sys.stdout
|
||||
|
||||
class MyStdOut:
|
||||
buffer = BytesIO()
|
||||
|
||||
mystdout: MyStdOut | BytesIO = MyStdOut() if buffer else BytesIO()
|
||||
mystdout = MyStdOut()
|
||||
|
||||
sys.stdout = mystdout
|
||||
|
||||
|
@ -67,6 +64,4 @@ def test_stdout(buffer: bool) -> None:
|
|||
# Reset stdout
|
||||
sys.stdout = old_stdout
|
||||
|
||||
if isinstance(mystdout, MyStdOut):
|
||||
mystdout = mystdout.buffer
|
||||
assert mystdout.getvalue() != b""
|
||||
assert mystdout.buffer.getvalue() != b""
|
||||
|
|
|
@ -1,6 +1,7 @@
|
|||
from __future__ import annotations
|
||||
|
||||
from pathlib import Path
|
||||
from typing import TYPE_CHECKING, Union
|
||||
|
||||
import pytest
|
||||
|
||||
|
@ -8,6 +9,20 @@ from PIL import Image, ImageQt
|
|||
|
||||
from .helper import assert_image_equal_tofile, assert_image_similar, hopper
|
||||
|
||||
if TYPE_CHECKING:
|
||||
import PyQt6
|
||||
import PySide6
|
||||
|
||||
QApplication = Union[PyQt6.QtWidgets.QApplication, PySide6.QtWidgets.QApplication]
|
||||
QHBoxLayout = Union[PyQt6.QtWidgets.QHBoxLayout, PySide6.QtWidgets.QHBoxLayout]
|
||||
QImage = Union[PyQt6.QtGui.QImage, PySide6.QtGui.QImage]
|
||||
QLabel = Union[PyQt6.QtWidgets.QLabel, PySide6.QtWidgets.QLabel]
|
||||
QPainter = Union[PyQt6.QtGui.QPainter, PySide6.QtGui.QPainter]
|
||||
QPixmap = Union[PyQt6.QtGui.QPixmap, PySide6.QtGui.QPixmap]
|
||||
QPoint = Union[PyQt6.QtCore.QPoint, PySide6.QtCore.QPoint]
|
||||
QRegion = Union[PyQt6.QtGui.QRegion, PySide6.QtGui.QRegion]
|
||||
QWidget = Union[PyQt6.QtWidgets.QWidget, PySide6.QtWidgets.QWidget]
|
||||
|
||||
if ImageQt.qt_is_installed:
|
||||
from PIL.ImageQt import QPixmap
|
||||
|
||||
|
@ -20,7 +35,7 @@ if ImageQt.qt_is_installed:
|
|||
from PySide6.QtGui import QImage, QPainter, QRegion
|
||||
from PySide6.QtWidgets import QApplication, QHBoxLayout, QLabel, QWidget
|
||||
|
||||
class Example(QWidget):
|
||||
class Example(QWidget): # type: ignore[misc]
|
||||
def __init__(self) -> None:
|
||||
super().__init__()
|
||||
|
||||
|
@ -28,11 +43,12 @@ if ImageQt.qt_is_installed:
|
|||
|
||||
qimage = ImageQt.ImageQt(img)
|
||||
|
||||
pixmap1 = ImageQt.QPixmap.fromImage(qimage)
|
||||
pixmap1 = getattr(ImageQt.QPixmap, "fromImage")(qimage)
|
||||
|
||||
QHBoxLayout(self) # hbox
|
||||
# hbox
|
||||
QHBoxLayout(self) # type: ignore[operator]
|
||||
|
||||
lbl = QLabel(self)
|
||||
lbl = QLabel(self) # type: ignore[operator]
|
||||
# Segfault in the problem
|
||||
lbl.setPixmap(pixmap1.copy())
|
||||
|
||||
|
@ -46,7 +62,7 @@ def roundtrip(expected: Image.Image) -> None:
|
|||
@pytest.mark.skipif(not ImageQt.qt_is_installed, reason="Qt bindings are not installed")
|
||||
def test_sanity(tmp_path: Path) -> None:
|
||||
# Segfault test
|
||||
app: QApplication | None = QApplication([])
|
||||
app: QApplication | None = QApplication([]) # type: ignore[operator]
|
||||
ex = Example()
|
||||
assert app # Silence warning
|
||||
assert ex # Silence warning
|
||||
|
@ -56,7 +72,7 @@ def test_sanity(tmp_path: Path) -> None:
|
|||
im = hopper(mode)
|
||||
data = ImageQt.toqpixmap(im)
|
||||
|
||||
assert isinstance(data, QPixmap)
|
||||
assert data.__class__.__name__ == "QPixmap"
|
||||
assert not data.isNull()
|
||||
|
||||
# Test saving the file
|
||||
|
@ -64,14 +80,14 @@ def test_sanity(tmp_path: Path) -> None:
|
|||
data.save(tempfile)
|
||||
|
||||
# Render the image
|
||||
qimage = ImageQt.ImageQt(im)
|
||||
data = QPixmap.fromImage(qimage)
|
||||
qt_format = QImage.Format if ImageQt.qt_version == "6" else QImage
|
||||
qimage = QImage(128, 128, qt_format.Format_ARGB32)
|
||||
painter = QPainter(qimage)
|
||||
image_label = QLabel()
|
||||
imageqt = ImageQt.ImageQt(im)
|
||||
data = getattr(QPixmap, "fromImage")(imageqt)
|
||||
qt_format = getattr(QImage, "Format") if ImageQt.qt_version == "6" else QImage
|
||||
qimage = QImage(128, 128, getattr(qt_format, "Format_ARGB32")) # type: ignore[operator]
|
||||
painter = QPainter(qimage) # type: ignore[operator]
|
||||
image_label = QLabel() # type: ignore[operator]
|
||||
image_label.setPixmap(data)
|
||||
image_label.render(painter, QPoint(0, 0), QRegion(0, 0, 128, 128))
|
||||
image_label.render(painter, QPoint(0, 0), QRegion(0, 0, 128, 128)) # type: ignore[operator]
|
||||
painter.end()
|
||||
rendered_tempfile = str(tmp_path / f"temp_rendered_{mode}.png")
|
||||
qimage.save(rendered_tempfile)
|
||||
|
|
|
@ -21,7 +21,7 @@ def test_sanity(mode: str, tmp_path: Path) -> None:
|
|||
src = hopper(mode)
|
||||
data = ImageQt.toqimage(src)
|
||||
|
||||
assert isinstance(data, QImage)
|
||||
assert isinstance(data, QImage) # type: ignore[arg-type, misc]
|
||||
assert not data.isNull()
|
||||
|
||||
# reload directly from the qimage
|
||||
|
|
|
@ -54,8 +54,8 @@ def test_nonetype() -> None:
|
|||
assert xres.denominator is not None
|
||||
assert yres._val is not None
|
||||
|
||||
assert xres and 1
|
||||
assert xres and yres
|
||||
assert xres
|
||||
assert yres
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
# install libimagequant
|
||||
|
||||
archive_name=libimagequant
|
||||
archive_version=4.3.1
|
||||
archive_version=4.3.3
|
||||
|
||||
archive=$archive_name-$archive_version
|
||||
|
||||
|
|
|
@ -118,6 +118,24 @@ 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.
|
||||
|
||||
JpegImageFile.huffman_ac and JpegImageFile.huffman_dc
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. deprecated:: 11.0.0
|
||||
|
||||
The ``huffman_ac`` and ``huffman_dc`` dictionaries on JPEG images were unused. They
|
||||
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
|
||||
12.0.0 (2025-10-15).
|
||||
|
||||
Removed features
|
||||
----------------
|
||||
|
||||
|
|
|
@ -14,6 +14,7 @@ from __future__ import annotations
|
|||
|
||||
import struct
|
||||
from io import BytesIO
|
||||
from typing import IO
|
||||
|
||||
from PIL import Image, ImageFile
|
||||
|
||||
|
@ -94,26 +95,26 @@ DXT3_FOURCC = 0x33545844
|
|||
DXT5_FOURCC = 0x35545844
|
||||
|
||||
|
||||
def _decode565(bits):
|
||||
def _decode565(bits: int) -> tuple[int, int, int]:
|
||||
a = ((bits >> 11) & 0x1F) << 3
|
||||
b = ((bits >> 5) & 0x3F) << 2
|
||||
c = (bits & 0x1F) << 3
|
||||
return a, b, c
|
||||
|
||||
|
||||
def _c2a(a, b):
|
||||
def _c2a(a: int, b: int) -> int:
|
||||
return (2 * a + b) // 3
|
||||
|
||||
|
||||
def _c2b(a, b):
|
||||
def _c2b(a: int, b: int) -> int:
|
||||
return (a + b) // 2
|
||||
|
||||
|
||||
def _c3(a, b):
|
||||
def _c3(a: int, b: int) -> int:
|
||||
return (2 * b + a) // 3
|
||||
|
||||
|
||||
def _dxt1(data, width, height):
|
||||
def _dxt1(data: IO[bytes], width: int, height: int) -> bytes:
|
||||
# TODO implement this function as pixel format in decode.c
|
||||
ret = bytearray(4 * width * height)
|
||||
|
||||
|
@ -151,7 +152,7 @@ def _dxt1(data, width, height):
|
|||
return bytes(ret)
|
||||
|
||||
|
||||
def _dxtc_alpha(a0, a1, ac0, ac1, ai):
|
||||
def _dxtc_alpha(a0: int, a1: int, ac0: int, ac1: int, ai: int) -> int:
|
||||
if ai <= 12:
|
||||
ac = (ac0 >> ai) & 7
|
||||
elif ai == 15:
|
||||
|
@ -175,7 +176,7 @@ def _dxtc_alpha(a0, a1, ac0, ac1, ai):
|
|||
return alpha
|
||||
|
||||
|
||||
def _dxt5(data, width, height):
|
||||
def _dxt5(data: IO[bytes], width: int, height: int) -> bytes:
|
||||
# TODO implement this function as pixel format in decode.c
|
||||
ret = bytearray(4 * width * height)
|
||||
|
||||
|
@ -211,7 +212,7 @@ class DdsImageFile(ImageFile.ImageFile):
|
|||
format = "DDS"
|
||||
format_description = "DirectDraw Surface"
|
||||
|
||||
def _open(self):
|
||||
def _open(self) -> None:
|
||||
if not _accept(self.fp.read(4)):
|
||||
msg = "not a DDS file"
|
||||
raise SyntaxError(msg)
|
||||
|
@ -242,19 +243,22 @@ class DdsImageFile(ImageFile.ImageFile):
|
|||
elif fourcc == b"DXT5":
|
||||
self.decoder = "DXT5"
|
||||
else:
|
||||
msg = f"Unimplemented pixel format {fourcc}"
|
||||
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):
|
||||
def load_seek(self, pos: int) -> None:
|
||||
pass
|
||||
|
||||
|
||||
class DXT1Decoder(ImageFile.PyDecoder):
|
||||
_pulls_fd = True
|
||||
|
||||
def decode(self, buffer):
|
||||
def decode(self, buffer: bytes) -> tuple[int, int]:
|
||||
assert self.fd is not None
|
||||
try:
|
||||
self.set_as_raw(_dxt1(self.fd, self.state.xsize, self.state.ysize))
|
||||
except struct.error as e:
|
||||
|
@ -266,7 +270,8 @@ class DXT1Decoder(ImageFile.PyDecoder):
|
|||
class DXT5Decoder(ImageFile.PyDecoder):
|
||||
_pulls_fd = True
|
||||
|
||||
def decode(self, buffer):
|
||||
def decode(self, buffer: bytes) -> tuple[int, int]:
|
||||
assert self.fd is not None
|
||||
try:
|
||||
self.set_as_raw(_dxt5(self.fd, self.state.xsize, self.state.ysize))
|
||||
except struct.error as e:
|
||||
|
@ -279,7 +284,7 @@ Image.register_decoder("DXT1", DXT1Decoder)
|
|||
Image.register_decoder("DXT5", DXT5Decoder)
|
||||
|
||||
|
||||
def _accept(prefix):
|
||||
def _accept(prefix: bytes) -> bool:
|
||||
return prefix[:4] == b"DDS "
|
||||
|
||||
|
||||
|
|
|
@ -1220,8 +1220,7 @@ using the general tags available through tiffinfo.
|
|||
WebP
|
||||
^^^^
|
||||
|
||||
Pillow reads and writes WebP files. The specifics of Pillow's capabilities with
|
||||
this format are currently undocumented.
|
||||
Pillow reads and writes WebP files. Requires libwebp v0.5.0 or later.
|
||||
|
||||
.. _webp-saving:
|
||||
|
||||
|
@ -1249,29 +1248,19 @@ The :py:meth:`~PIL.Image.Image.save` method supports the following options:
|
|||
**exact**
|
||||
If true, preserve the transparent RGB values. Otherwise, discard
|
||||
invisible RGB values for better compression. Defaults to false.
|
||||
Requires libwebp 0.5.0 or later.
|
||||
|
||||
**icc_profile**
|
||||
The ICC Profile to include in the saved file. Only supported if
|
||||
the system WebP library was built with webpmux support.
|
||||
The ICC Profile to include in the saved file.
|
||||
|
||||
**exif**
|
||||
The exif data to include in the saved file. Only supported if
|
||||
the system WebP library was built with webpmux support.
|
||||
The exif data to include in the saved file.
|
||||
|
||||
**xmp**
|
||||
The XMP data to include in the saved file. Only supported if
|
||||
the system WebP library was built with webpmux support.
|
||||
The XMP data to include in the saved file.
|
||||
|
||||
Saving sequences
|
||||
~~~~~~~~~~~~~~~~
|
||||
|
||||
.. note::
|
||||
|
||||
Support for animated WebP files will only be enabled if the system WebP
|
||||
library is v0.5.0 or later. You can check webp animation support at
|
||||
runtime by calling ``features.check("webp_anim")``.
|
||||
|
||||
When calling :py:meth:`~PIL.Image.Image.save` to write a WebP file, by default
|
||||
only the first frame of a multiframe image will be saved. If the ``save_all``
|
||||
argument is present and true, then all frames will be saved, and the following
|
||||
|
@ -1528,19 +1517,21 @@ To add other read or write support, use
|
|||
:py:func:`PIL.WmfImagePlugin.register_handler` to register a WMF and EMF
|
||||
handler. ::
|
||||
|
||||
from PIL import Image
|
||||
from typing import IO
|
||||
|
||||
from PIL import Image, ImageFile
|
||||
from PIL import WmfImagePlugin
|
||||
|
||||
|
||||
class WmfHandler:
|
||||
def open(self, im):
|
||||
class WmfHandler(ImageFile.StubHandler):
|
||||
def open(self, im: ImageFile.StubImageFile) -> None:
|
||||
...
|
||||
|
||||
def load(self, im):
|
||||
def load(self, im: ImageFile.StubImageFile) -> Image.Image:
|
||||
...
|
||||
return image
|
||||
|
||||
def save(self, im, fp, filename):
|
||||
def save(self, im: Image.Image, fp: IO[bytes], filename: str) -> None:
|
||||
...
|
||||
|
||||
|
||||
|
|
|
@ -186,7 +186,7 @@ Rolling an image
|
|||
|
||||
::
|
||||
|
||||
def roll(im, delta):
|
||||
def roll(im: Image.Image, delta: int) -> Image.Image:
|
||||
"""Roll an image sideways."""
|
||||
xsize, ysize = im.size
|
||||
|
||||
|
@ -211,7 +211,7 @@ Merging images
|
|||
|
||||
::
|
||||
|
||||
def merge(im1, im2):
|
||||
def merge(im1: Image.Image, im2: Image.Image) -> Image.Image:
|
||||
w = im1.size[0] + im2.size[0]
|
||||
h = max(im1.size[1], im2.size[1])
|
||||
im = Image.new("RGBA", (w, h))
|
||||
|
@ -704,7 +704,7 @@ in the current directory can be saved as JPEGs at reduced quality.
|
|||
import glob
|
||||
from PIL import Image
|
||||
|
||||
def compress_image(source_path, dest_path):
|
||||
def compress_image(source_path: str, dest_path: str) -> None:
|
||||
with Image.open(source_path) as img:
|
||||
if img.mode != "RGB":
|
||||
img = img.convert("RGB")
|
||||
|
|
|
@ -53,7 +53,7 @@ true color.
|
|||
from PIL import Image, ImageFile
|
||||
|
||||
|
||||
def _accept(prefix):
|
||||
def _accept(prefix: bytes) -> bool:
|
||||
return prefix[:4] == b"SPAM"
|
||||
|
||||
|
||||
|
@ -62,7 +62,7 @@ true color.
|
|||
format = "SPAM"
|
||||
format_description = "Spam raster image"
|
||||
|
||||
def _open(self):
|
||||
def _open(self) -> None:
|
||||
|
||||
header = self.fp.read(128).split()
|
||||
|
||||
|
@ -82,7 +82,7 @@ true color.
|
|||
raise SyntaxError(msg)
|
||||
|
||||
# data descriptor
|
||||
self.tile = [("raw", (0, 0) + self.size, 128, (self.mode, 0, 1))]
|
||||
self.tile = [ImageFile._Tile("raw", (0, 0) + self.size, 128, (self.mode, 0, 1))]
|
||||
|
||||
|
||||
Image.register_open(SpamImageFile.format, SpamImageFile, _accept)
|
||||
|
|
|
@ -55,10 +55,6 @@ Many of Pillow's features require external libraries:
|
|||
|
||||
* **libwebp** provides the WebP format.
|
||||
|
||||
* Pillow has been tested with version **0.1.3**, which does not read
|
||||
transparent WebP files. Versions **0.3.0** and above support
|
||||
transparency.
|
||||
|
||||
* **openjpeg** provides JPEG 2000 functionality.
|
||||
|
||||
* Pillow has been tested with openjpeg **2.0.0**, **2.1.0**, **2.3.1**,
|
||||
|
@ -68,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.
|
||||
|
@ -275,18 +271,18 @@ Build Options
|
|||
|
||||
* Config settings: ``-C zlib=disable``, ``-C jpeg=disable``,
|
||||
``-C tiff=disable``, ``-C freetype=disable``, ``-C raqm=disable``,
|
||||
``-C lcms=disable``, ``-C webp=disable``, ``-C webpmux=disable``,
|
||||
``-C lcms=disable``, ``-C webp=disable``,
|
||||
``-C jpeg2000=disable``, ``-C imagequant=disable``, ``-C xcb=disable``.
|
||||
Disable building the corresponding feature even if the development
|
||||
libraries are present on the building machine.
|
||||
|
||||
* Config settings: ``-C zlib=enable``, ``-C jpeg=enable``,
|
||||
``-C tiff=enable``, ``-C freetype=enable``, ``-C raqm=enable``,
|
||||
``-C lcms=enable``, ``-C webp=enable``, ``-C webpmux=enable``,
|
||||
``-C lcms=enable``, ``-C webp=enable``,
|
||||
``-C jpeg2000=enable``, ``-C imagequant=enable``, ``-C xcb=enable``.
|
||||
Require that the corresponding feature is built. The build will raise
|
||||
an exception if the libraries are not found. Webpmux (WebP metadata)
|
||||
relies on WebP support. Tcl and Tk also must be used together.
|
||||
an exception if the libraries are not found. Tcl and Tk must be used
|
||||
together.
|
||||
|
||||
* Config settings: ``-C raqm=vendor``, ``-C fribidi=vendor``.
|
||||
These flags are used to compile a modified version of libraqm and
|
||||
|
|
|
@ -362,6 +362,7 @@ Classes
|
|||
:undoc-members:
|
||||
:show-inheritance:
|
||||
.. autoclass:: PIL.Image.ImagePointHandler
|
||||
.. autoclass:: PIL.Image.ImagePointTransform
|
||||
.. autoclass:: PIL.Image.ImageTransformHandler
|
||||
|
||||
Protocols
|
||||
|
|
|
@ -54,12 +54,12 @@ Feature version numbers are available only where stated.
|
|||
Support for the following features can be checked:
|
||||
|
||||
* ``libjpeg_turbo``: (compile time) Whether Pillow was compiled against the libjpeg-turbo version of libjpeg. Compile-time version number is available.
|
||||
* ``transp_webp``: Support for transparency in WebP images.
|
||||
* ``webp_mux``: (compile time) Support for EXIF data in WebP images.
|
||||
* ``webp_anim``: (compile time) Support for animated WebP images.
|
||||
* ``raqm``: Raqm library, required for ``ImageFont.Layout.RAQM`` in :py:func:`PIL.ImageFont.truetype`. Run-time version number is available for Raqm 0.7.0 or newer.
|
||||
* ``libimagequant``: (compile time) ImageQuant quantization support in :py:func:`PIL.Image.Image.quantize`. Run-time version number is available.
|
||||
* ``xcb``: (compile time) Support for X11 in :py:func:`PIL.ImageGrab.grab` via the XCB library.
|
||||
* ``transp_webp``: Deprecated. Always ``True`` if WebP module is installed.
|
||||
* ``webp_mux``: Deprecated. Always ``True`` if WebP module is installed.
|
||||
* ``webp_anim``: Deprecated. Always ``True`` if WebP module is installed.
|
||||
|
||||
.. autofunction:: PIL.features.check_feature
|
||||
.. autofunction:: PIL.features.version_feature
|
||||
|
|
|
@ -33,6 +33,10 @@ Internal Modules
|
|||
Provides a convenient way to import type hints that are not available
|
||||
on some Python versions.
|
||||
|
||||
.. py:class:: IntegralLike
|
||||
|
||||
Typing alias.
|
||||
|
||||
.. py:class:: NumpyArray
|
||||
|
||||
Typing alias.
|
||||
|
|
|
@ -50,6 +50,22 @@ 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.
|
||||
|
||||
JpegImageFile.huffman_ac and JpegImageFile.huffman_dc
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. deprecated:: 11.0.0
|
||||
|
||||
The ``huffman_ac`` and ``huffman_dc`` dictionaries on JPEG images were unused. They
|
||||
have been deprecated, and will be removed in Pillow 12 (2025-10-15).
|
||||
|
||||
Specific WebP Feature Checks
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
``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
|
||||
12.0.0 (2025-10-15).
|
||||
|
||||
API Changes
|
||||
===========
|
||||
|
||||
|
@ -77,3 +93,10 @@ others prepare for 3.13, and to ensure Pillow could be used immediately at the r
|
|||
of 3.13.0 final (2024-10-01, :pep:`719`).
|
||||
|
||||
Pillow 11.0.0 now officially supports Python 3.13.
|
||||
|
||||
C-level Flags
|
||||
^^^^^^^^^^^^^
|
||||
|
||||
Some compiling flags like ``WITH_THREADING``, ``WITH_IMAGECHOPS``, and other
|
||||
``WITH_*`` were removed. These flags were not available through the build system,
|
||||
but they could be edited in the C source.
|
||||
|
|
|
@ -109,6 +109,7 @@ lint.select = [
|
|||
"ISC", # flake8-implicit-str-concat
|
||||
"LOG", # flake8-logging
|
||||
"PGH", # pygrep-hooks
|
||||
"PT", # flake8-pytest-style
|
||||
"PYI", # flake8-pyi
|
||||
"RUF100", # unused noqa (yesqa)
|
||||
"UP", # pyupgrade
|
||||
|
@ -120,6 +121,12 @@ lint.ignore = [
|
|||
"E221", # Multiple spaces before operator
|
||||
"E226", # Missing whitespace around arithmetic operator
|
||||
"E241", # Multiple spaces after ','
|
||||
"PT001", # pytest-fixture-incorrect-parentheses-style
|
||||
"PT007", # pytest-parametrize-values-wrong-type
|
||||
"PT011", # pytest-raises-too-broad
|
||||
"PT012", # pytest-raises-with-multiple-statements
|
||||
"PT016", # pytest-fail-without-message
|
||||
"PT017", # pytest-assert-in-except
|
||||
"PYI026", # flake8-pyi: typing.TypeAlias added in Python 3.10
|
||||
"PYI034", # flake8-pyi: typing.Self added in Python 3.11
|
||||
]
|
||||
|
@ -129,6 +136,7 @@ lint.per-file-ignores."Tests/oss-fuzz/fuzz_font.py" = [
|
|||
lint.per-file-ignores."Tests/oss-fuzz/fuzz_pillow.py" = [
|
||||
"I002",
|
||||
]
|
||||
lint.flake8-pytest-style.parametrize-names-type = "csv"
|
||||
lint.isort.known-first-party = [
|
||||
"PIL",
|
||||
]
|
||||
|
@ -155,8 +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$',
|
||||
'^Tests/test_qt_image_qapplication.py$',
|
||||
]
|
||||
|
|
|
@ -52,7 +52,7 @@ def testimage() -> None:
|
|||
or you call the "load" method:
|
||||
|
||||
>>> im = Image.open("Tests/images/hopper.ppm")
|
||||
>>> print(im.im) # internal image attribute
|
||||
>>> print(im._im) # internal image attribute
|
||||
None
|
||||
>>> a = im.load()
|
||||
>>> type(im.im) # doctest: +ELLIPSIS
|
||||
|
|
43
setup.py
43
setup.py
|
@ -295,7 +295,6 @@ class pil_build_ext(build_ext):
|
|||
"raqm",
|
||||
"lcms",
|
||||
"webp",
|
||||
"webpmux",
|
||||
"jpeg2000",
|
||||
"imagequant",
|
||||
"xcb",
|
||||
|
@ -794,28 +793,18 @@ class pil_build_ext(build_ext):
|
|||
|
||||
if feature.want("webp"):
|
||||
_dbg("Looking for webp")
|
||||
if _find_include_file(self, "webp/encode.h") and _find_include_file(
|
||||
self, "webp/decode.h"
|
||||
if all(
|
||||
_find_include_file(self, "webp/" + include)
|
||||
for include in ("encode.h", "decode.h", "mux.h", "demux.h")
|
||||
):
|
||||
# In Google's precompiled zip it is call "libwebp":
|
||||
if _find_library_file(self, "webp"):
|
||||
feature.webp = "webp"
|
||||
elif _find_library_file(self, "libwebp"):
|
||||
feature.webp = "libwebp"
|
||||
|
||||
if feature.want("webpmux"):
|
||||
_dbg("Looking for webpmux")
|
||||
if _find_include_file(self, "webp/mux.h") and _find_include_file(
|
||||
self, "webp/demux.h"
|
||||
# In Google's precompiled zip it is called "libwebp"
|
||||
for prefix in ("", "lib"):
|
||||
if all(
|
||||
_find_library_file(self, prefix + library)
|
||||
for library in ("webp", "webpmux", "webpdemux")
|
||||
):
|
||||
if _find_library_file(self, "webpmux") and _find_library_file(
|
||||
self, "webpdemux"
|
||||
):
|
||||
feature.webpmux = "webpmux"
|
||||
if _find_library_file(self, "libwebpmux") and _find_library_file(
|
||||
self, "libwebpdemux"
|
||||
):
|
||||
feature.webpmux = "libwebpmux"
|
||||
feature.webp = prefix + "webp"
|
||||
break
|
||||
|
||||
if feature.want("xcb"):
|
||||
_dbg("Looking for xcb")
|
||||
|
@ -904,15 +893,8 @@ class pil_build_ext(build_ext):
|
|||
self._remove_extension("PIL._imagingcms")
|
||||
|
||||
if feature.webp:
|
||||
libs = [feature.webp]
|
||||
defs = []
|
||||
|
||||
if feature.webpmux:
|
||||
defs.append(("HAVE_WEBPMUX", None))
|
||||
libs.append(feature.webpmux)
|
||||
libs.append(feature.webpmux.replace("pmux", "pdemux"))
|
||||
|
||||
self._update_extension("PIL._webp", libs, defs)
|
||||
libs = [feature.webp, feature.webp + "mux", feature.webp + "demux"]
|
||||
self._update_extension("PIL._webp", libs)
|
||||
else:
|
||||
self._remove_extension("PIL._webp")
|
||||
|
||||
|
@ -953,7 +935,6 @@ class pil_build_ext(build_ext):
|
|||
(feature.raqm, "RAQM (Text shaping)", raqm_extra_info),
|
||||
(feature.lcms, "LITTLECMS2"),
|
||||
(feature.webp, "WEBP"),
|
||||
(feature.webpmux, "WEBPMUX"),
|
||||
(feature.xcb, "XCB (X protocol)"),
|
||||
]
|
||||
|
||||
|
|
|
@ -273,7 +273,7 @@ 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):
|
||||
|
@ -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())
|
||||
|
@ -467,6 +470,7 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
|
|||
magic = b"BLP1" if im.encoderinfo.get("blp_version") == "BLP1" else b"BLP2"
|
||||
fp.write(magic)
|
||||
|
||||
assert im.palette is not None
|
||||
fp.write(struct.pack("<i", 1)) # Uncompressed or DirectX compression
|
||||
fp.write(struct.pack("<b", Encoding.UNCOMPRESSED))
|
||||
fp.write(struct.pack("<b", 1 if im.palette.mode == "RGBA" else 0))
|
||||
|
@ -477,7 +481,7 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
|
|||
fp.write(struct.pack("<i", 5))
|
||||
fp.write(struct.pack("<i", 0))
|
||||
|
||||
ImageFile._save(im, fp, [("BLP", (0, 0) + im.size, 0, im.mode)])
|
||||
ImageFile._save(im, fp, [ImageFile._Tile("BLP", (0, 0) + im.size, 0, im.mode)])
|
||||
|
||||
|
||||
Image.register_open(BlpImageFile.format, BlpImageFile, _accept)
|
||||
|
|
|
@ -170,6 +170,8 @@ class BmpImageFile(ImageFile.ImageFile):
|
|||
|
||||
# ------------------ Special case : header is reported 40, which
|
||||
# ---------------------- is shorter than real size for bpp >= 16
|
||||
assert isinstance(file_info["width"], int)
|
||||
assert isinstance(file_info["height"], int)
|
||||
self._size = file_info["width"], file_info["height"]
|
||||
|
||||
# ------- If color count was not found in the header, compute from bits
|
||||
|
@ -294,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(),
|
||||
|
@ -385,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
|
||||
|
||||
|
||||
|
@ -482,7 +484,9 @@ def _save(
|
|||
if palette:
|
||||
fp.write(palette)
|
||||
|
||||
ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, stride, -1))])
|
||||
ImageFile._save(
|
||||
im, fp, [ImageFile._Tile("raw", (0, 0) + im.size, 0, (rawmode, stride, -1))]
|
||||
)
|
||||
|
||||
|
||||
#
|
||||
|
|
|
@ -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:
|
||||
|
|
|
@ -71,7 +71,7 @@ def Ghostscript(
|
|||
fp: IO[bytes],
|
||||
scale: int = 1,
|
||||
transparency: bool = False,
|
||||
) -> Image.Image:
|
||||
) -> Image.core.ImagingCore:
|
||||
"""Render an image using Ghostscript"""
|
||||
global gs_binary
|
||||
if not has_ghostscript():
|
||||
|
@ -190,7 +190,6 @@ class EpsImageFile(ImageFile.ImageFile):
|
|||
self.fp.seek(offset)
|
||||
|
||||
self._mode = "RGB"
|
||||
self._size = None
|
||||
|
||||
byte_arr = bytearray(255)
|
||||
bytes_mv = memoryview(byte_arr)
|
||||
|
@ -228,7 +227,7 @@ class EpsImageFile(ImageFile.ImageFile):
|
|||
if k == "BoundingBox":
|
||||
if v == "(atend)":
|
||||
reading_trailer_comments = True
|
||||
elif not self._size or (trailer_reached and reading_trailer_comments):
|
||||
elif not self.tile or (trailer_reached and reading_trailer_comments):
|
||||
try:
|
||||
# Note: The DSC spec says that BoundingBox
|
||||
# fields should be integers, but some drivers
|
||||
|
@ -346,7 +345,7 @@ class EpsImageFile(ImageFile.ImageFile):
|
|||
trailer_reached = True
|
||||
bytes_read = 0
|
||||
|
||||
if not self._size:
|
||||
if not self.tile:
|
||||
msg = "cannot determine EPS bounding box"
|
||||
raise OSError(msg)
|
||||
|
||||
|
@ -434,7 +433,7 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes, eps: int = 1) -
|
|||
if hasattr(fp, "flush"):
|
||||
fp.flush()
|
||||
|
||||
ImageFile._save(im, fp, [("eps", (0, 0) + im.size, 0, None)])
|
||||
ImageFile._save(im, fp, [ImageFile._Tile("eps", (0, 0) + im.size, 0, None)])
|
||||
|
||||
fp.write(b"\n%%%%EndBinary\n")
|
||||
fp.write(b"grestore end\n")
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
||||
|
|
|
@ -81,6 +81,8 @@ class FpxImageFile(ImageFile.ImageFile):
|
|||
|
||||
# size (highest resolution)
|
||||
|
||||
assert isinstance(prop[0x1000002], int)
|
||||
assert isinstance(prop[0x1000003], int)
|
||||
self._size = prop[0x1000002], prop[0x1000003]
|
||||
|
||||
size = max(self.size)
|
||||
|
@ -164,7 +166,7 @@ class FpxImageFile(ImageFile.ImageFile):
|
|||
|
||||
if compression == 0:
|
||||
self.tile.append(
|
||||
(
|
||||
ImageFile._Tile(
|
||||
"raw",
|
||||
(x, y, x1, y1),
|
||||
i32(s, i) + 28,
|
||||
|
@ -175,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,
|
||||
|
@ -203,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)
|
||||
|
|
|
@ -89,7 +89,7 @@ class GbrImageFile(ImageFile.ImageFile):
|
|||
self._data_size = width * height * color_depth
|
||||
|
||||
def load(self) -> Image.core.PixelAccess | None:
|
||||
if not self.im:
|
||||
if self._im is None:
|
||||
self.im = Image.core.new(self.mode, self.size)
|
||||
self.frombytes(self.fp.read(self._data_size))
|
||||
return Image.Image.load(self)
|
||||
|
|
|
@ -72,7 +72,7 @@ class GdImageFile(ImageFile.ImageFile):
|
|||
)
|
||||
|
||||
self.tile = [
|
||||
(
|
||||
ImageFile._Tile(
|
||||
"raw",
|
||||
(0, 0) + self.size,
|
||||
7 + true_color_offset + 4 + 256 * 4,
|
||||
|
|
|
@ -155,7 +155,7 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
if not self._seek_check(frame):
|
||||
return
|
||||
if frame < self.__frame:
|
||||
self.im = None
|
||||
self._im = None
|
||||
self._seek(0)
|
||||
|
||||
last_frame = self.__frame
|
||||
|
@ -320,11 +320,14 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
else:
|
||||
self._mode = "L"
|
||||
|
||||
if not palette and self.global_palette:
|
||||
if palette:
|
||||
self.palette = palette
|
||||
elif self.global_palette:
|
||||
from copy import copy
|
||||
|
||||
palette = copy(self.global_palette)
|
||||
self.palette = palette
|
||||
self.palette = copy(self.global_palette)
|
||||
else:
|
||||
self.palette = None
|
||||
else:
|
||||
if self.mode == "P":
|
||||
if (
|
||||
|
@ -376,7 +379,7 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
self.dispose = Image.core.fill(dispose_mode, dispose_size, color)
|
||||
else:
|
||||
# replace with previous contents
|
||||
if self.im is not None:
|
||||
if self._im is not None:
|
||||
# only dispose the extent in this frame
|
||||
self.dispose = self._crop(self.im, self.dispose_extent)
|
||||
elif frame_transparency is not None:
|
||||
|
@ -404,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,
|
||||
|
@ -434,7 +437,14 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
self.im = Image.core.fill("P", self.size, self._frame_transparency or 0)
|
||||
self.im.putpalette("RGB", *self._frame_palette.getdata())
|
||||
else:
|
||||
self.im = None
|
||||
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
|
||||
|
||||
|
@ -452,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")
|
||||
|
@ -495,6 +516,7 @@ def _normalize_mode(im: Image.Image) -> Image.Image:
|
|||
return im
|
||||
if Image.getmodebase(im.mode) == "RGB":
|
||||
im = im.convert("P", palette=Image.Palette.ADAPTIVE)
|
||||
assert im.palette is not None
|
||||
if im.palette.mode == "RGBA":
|
||||
for rgba in im.palette.colors:
|
||||
if rgba[3] == 0:
|
||||
|
@ -536,11 +558,11 @@ def _normalize_palette(
|
|||
if not source_palette:
|
||||
source_palette = bytearray(i // 3 for i in range(768))
|
||||
im.palette = ImagePalette.ImagePalette("RGB", palette=source_palette)
|
||||
|
||||
used_palette_colors: list[int] | None
|
||||
if palette:
|
||||
used_palette_colors = []
|
||||
assert source_palette is not None
|
||||
|
||||
if palette:
|
||||
used_palette_colors: list[int | None] = []
|
||||
assert im.palette is not None
|
||||
for i in range(0, len(source_palette), 3):
|
||||
source_color = tuple(source_palette[i : i + 3])
|
||||
index = im.palette.colors.get(source_color)
|
||||
|
@ -553,20 +575,25 @@ def _normalize_palette(
|
|||
if j not in used_palette_colors:
|
||||
used_palette_colors[i] = j
|
||||
break
|
||||
im = im.remap_palette(used_palette_colors)
|
||||
dest_map: list[int] = []
|
||||
for index in used_palette_colors:
|
||||
assert index is not None
|
||||
dest_map.append(index)
|
||||
im = im.remap_palette(dest_map)
|
||||
else:
|
||||
used_palette_colors = _get_optimize(im, info)
|
||||
if used_palette_colors is not None:
|
||||
im = im.remap_palette(used_palette_colors, source_palette)
|
||||
optimized_palette_colors = _get_optimize(im, info)
|
||||
if optimized_palette_colors is not None:
|
||||
im = im.remap_palette(optimized_palette_colors, source_palette)
|
||||
if "transparency" in info:
|
||||
try:
|
||||
info["transparency"] = used_palette_colors.index(
|
||||
info["transparency"] = optimized_palette_colors.index(
|
||||
info["transparency"]
|
||||
)
|
||||
except ValueError:
|
||||
del info["transparency"]
|
||||
return im
|
||||
|
||||
assert im.palette is not None
|
||||
im.palette.palette = source_palette
|
||||
return im
|
||||
|
||||
|
@ -578,6 +605,7 @@ def _write_single_frame(
|
|||
) -> None:
|
||||
im_out = _normalize_mode(im)
|
||||
for k, v in im_out.info.items():
|
||||
if isinstance(k, str):
|
||||
im.encoderinfo.setdefault(k, v)
|
||||
im_out = _normalize_palette(im_out, palette, im.encoderinfo)
|
||||
|
||||
|
@ -591,7 +619,9 @@ def _write_single_frame(
|
|||
_write_local_header(fp, im, (0, 0), flags)
|
||||
|
||||
im_out.encoderconfig = (8, get_interlace(im))
|
||||
ImageFile._save(im_out, fp, [("gif", (0, 0) + im.size, 0, RAWMODE[im_out.mode])])
|
||||
ImageFile._save(
|
||||
im_out, fp, [ImageFile._Tile("gif", (0, 0) + im.size, 0, RAWMODE[im_out.mode])]
|
||||
)
|
||||
|
||||
fp.write(b"\0") # end of image data
|
||||
|
||||
|
@ -630,6 +660,7 @@ def _write_multiple_frames(
|
|||
for k, v in im_frame.info.items():
|
||||
if k == "transparency":
|
||||
continue
|
||||
if isinstance(k, str):
|
||||
im.encoderinfo.setdefault(k, v)
|
||||
|
||||
encoderinfo = im.encoderinfo.copy()
|
||||
|
@ -660,10 +691,12 @@ def _write_multiple_frames(
|
|||
)
|
||||
background = _get_background(im_frame, color)
|
||||
background_im = Image.new("P", im_frame.size, background)
|
||||
assert im_frames[0].im.palette is not None
|
||||
background_im.putpalette(im_frames[0].im.palette)
|
||||
bbox = _getbbox(background_im, im_frame)[1]
|
||||
elif encoderinfo.get("optimize") and im_frame.mode != "1":
|
||||
if "transparency" not in encoderinfo:
|
||||
assert im_frame.palette is not None
|
||||
try:
|
||||
encoderinfo["transparency"] = (
|
||||
im_frame.palette._new_color_index(im_frame)
|
||||
|
@ -901,6 +934,7 @@ def _get_optimize(im: Image.Image, info: dict[str, Any]) -> list[int] | None:
|
|||
if optimise or max(used_palette_colors) >= len(used_palette_colors):
|
||||
return used_palette_colors
|
||||
|
||||
assert im.palette is not None
|
||||
num_palette_colors = len(im.palette.palette) // Image.getmodebands(
|
||||
im.palette.mode
|
||||
)
|
||||
|
@ -950,7 +984,7 @@ def _get_palette_bytes(im: Image.Image) -> bytes:
|
|||
:param im: Image object
|
||||
:returns: Bytes, len<=768 suitable for inclusion in gif header
|
||||
"""
|
||||
return im.palette.palette if im.palette else b""
|
||||
return bytes(im.palette.palette) if im.palette else b""
|
||||
|
||||
|
||||
def _get_background(
|
||||
|
@ -963,6 +997,7 @@ def _get_background(
|
|||
# WebPImagePlugin stores an RGBA value in info["background"]
|
||||
# So it must be converted to the same format as GifImagePlugin's
|
||||
# info["background"] - a global color table index
|
||||
assert im.palette is not None
|
||||
try:
|
||||
background = im.palette.getcolor(info_background, im)
|
||||
except ValueError as e:
|
||||
|
@ -1054,7 +1089,9 @@ def _write_frame_data(
|
|||
_write_local_header(fp, im_frame, offset, 0)
|
||||
|
||||
ImageFile._save(
|
||||
im_frame, fp, [("gif", (0, 0) + im_frame.size, 0, RAWMODE[im_frame.mode])]
|
||||
im_frame,
|
||||
fp,
|
||||
[ImageFile._Tile("gif", (0, 0) + im_frame.size, 0, RAWMODE[im_frame.mode])],
|
||||
)
|
||||
|
||||
fp.write(b"\0") # end of image data
|
||||
|
|
|
@ -308,7 +308,7 @@ class IcnsImageFile(ImageFile.ImageFile):
|
|||
)
|
||||
|
||||
px = Image.Image.load(self)
|
||||
if self.im is not None and self.im.size == self.size:
|
||||
if self._im is not None and self.im.size == self.size:
|
||||
# Already loaded
|
||||
return px
|
||||
self.load_prepare()
|
||||
|
|
|
@ -97,7 +97,9 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
|
|||
if bits != 32:
|
||||
and_mask = Image.new("1", size)
|
||||
ImageFile._save(
|
||||
and_mask, image_io, [("raw", (0, 0) + size, 0, ("1", 0, -1))]
|
||||
and_mask,
|
||||
image_io,
|
||||
[ImageFile._Tile("raw", (0, 0) + size, 0, ("1", 0, -1))],
|
||||
)
|
||||
else:
|
||||
frame.save(image_io, "png")
|
||||
|
@ -226,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:
|
||||
|
@ -241,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)
|
||||
|
@ -248,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]
|
||||
|
@ -265,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)
|
||||
|
@ -272,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)
|
||||
|
||||
|
@ -317,18 +332,18 @@ class IcoImageFile(ImageFile.ImageFile):
|
|||
self.load()
|
||||
|
||||
@property
|
||||
def size(self):
|
||||
def size(self) -> tuple[int, int]:
|
||||
return self._size
|
||||
|
||||
@size.setter
|
||||
def size(self, value):
|
||||
def size(self, value: tuple[int, int]) -> None:
|
||||
if value not in self.info["sizes"]:
|
||||
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 self.im is not None and self.im.size == self.size:
|
||||
if self._im is not None and self.im.size == self.size:
|
||||
# Already loaded
|
||||
return Image.Image.load(self)
|
||||
im = self.ico.getimage(self.size)
|
||||
|
|
|
@ -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
|
||||
|
@ -360,7 +370,9 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
|
|||
palette += im_palette[colors * i : colors * (i + 1)]
|
||||
palette += b"\x00" * (256 - colors)
|
||||
fp.write(palette) # 768 bytes
|
||||
ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, 0, -1))])
|
||||
ImageFile._save(
|
||||
im, fp, [ImageFile._Tile("raw", (0, 0) + im.size, 0, (rawmode, 0, -1))]
|
||||
)
|
||||
|
||||
|
||||
#
|
||||
|
|
195
src/PIL/Image.py
195
src/PIL/Image.py
|
@ -218,10 +218,18 @@ if hasattr(core, "DEFAULT_STRATEGY"):
|
|||
# Registries
|
||||
|
||||
if TYPE_CHECKING:
|
||||
import mmap
|
||||
from xml.etree.ElementTree import Element
|
||||
|
||||
from . import ImageFile, ImagePalette, TiffImagePlugin
|
||||
from IPython.lib.pretty import PrettyPrinter
|
||||
|
||||
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,
|
||||
|
@ -467,43 +475,53 @@ def _getencoder(
|
|||
# Simple expression analyzer
|
||||
|
||||
|
||||
class _E:
|
||||
class ImagePointTransform:
|
||||
"""
|
||||
Used with :py:meth:`~PIL.Image.Image.point` for single band images with more than
|
||||
8 bits, this represents an affine transformation, where the value is multiplied by
|
||||
``scale`` and ``offset`` is added.
|
||||
"""
|
||||
|
||||
def __init__(self, scale: float, offset: float) -> None:
|
||||
self.scale = scale
|
||||
self.offset = offset
|
||||
|
||||
def __neg__(self) -> _E:
|
||||
return _E(-self.scale, -self.offset)
|
||||
def __neg__(self) -> ImagePointTransform:
|
||||
return ImagePointTransform(-self.scale, -self.offset)
|
||||
|
||||
def __add__(self, other: _E | float) -> _E:
|
||||
if isinstance(other, _E):
|
||||
return _E(self.scale + other.scale, self.offset + other.offset)
|
||||
return _E(self.scale, self.offset + other)
|
||||
def __add__(self, other: ImagePointTransform | float) -> ImagePointTransform:
|
||||
if isinstance(other, ImagePointTransform):
|
||||
return ImagePointTransform(
|
||||
self.scale + other.scale, self.offset + other.offset
|
||||
)
|
||||
return ImagePointTransform(self.scale, self.offset + other)
|
||||
|
||||
__radd__ = __add__
|
||||
|
||||
def __sub__(self, other: _E | float) -> _E:
|
||||
def __sub__(self, other: ImagePointTransform | float) -> ImagePointTransform:
|
||||
return self + -other
|
||||
|
||||
def __rsub__(self, other: _E | float) -> _E:
|
||||
def __rsub__(self, other: ImagePointTransform | float) -> ImagePointTransform:
|
||||
return other + -self
|
||||
|
||||
def __mul__(self, other: _E | float) -> _E:
|
||||
if isinstance(other, _E):
|
||||
def __mul__(self, other: ImagePointTransform | float) -> ImagePointTransform:
|
||||
if isinstance(other, ImagePointTransform):
|
||||
return NotImplemented
|
||||
return _E(self.scale * other, self.offset * other)
|
||||
return ImagePointTransform(self.scale * other, self.offset * other)
|
||||
|
||||
__rmul__ = __mul__
|
||||
|
||||
def __truediv__(self, other: _E | float) -> _E:
|
||||
if isinstance(other, _E):
|
||||
def __truediv__(self, other: ImagePointTransform | float) -> ImagePointTransform:
|
||||
if isinstance(other, ImagePointTransform):
|
||||
return NotImplemented
|
||||
return _E(self.scale / other, self.offset / other)
|
||||
return ImagePointTransform(self.scale / other, self.offset / other)
|
||||
|
||||
|
||||
def _getscaleoffset(expr) -> tuple[float, float]:
|
||||
a = expr(_E(1, 0))
|
||||
return (a.scale, a.offset) if isinstance(a, _E) else (0, a)
|
||||
def _getscaleoffset(
|
||||
expr: Callable[[ImagePointTransform], ImagePointTransform | float]
|
||||
) -> tuple[float, float]:
|
||||
a = expr(ImagePointTransform(1, 0))
|
||||
return (a.scale, a.offset) if isinstance(a, ImagePointTransform) else (0, a)
|
||||
|
||||
|
||||
# --------------------------------------------------------------------
|
||||
|
@ -532,16 +550,27 @@ class Image:
|
|||
format_description: str | None = None
|
||||
_close_exclusive_fp_after_loading = True
|
||||
|
||||
def __init__(self):
|
||||
def __init__(self) -> None:
|
||||
# FIXME: take "new" parameters / other image?
|
||||
# FIXME: turn mode and size into delegating properties?
|
||||
self.im = None
|
||||
self._im: core.ImagingCore | DeferredError | None = None
|
||||
self._mode = ""
|
||||
self._size = (0, 0)
|
||||
self.palette = None
|
||||
self.info = {}
|
||||
self.palette: ImagePalette.ImagePalette | None = None
|
||||
self.info: dict[str | tuple[int, int], Any] = {}
|
||||
self.readonly = 0
|
||||
self._exif = None
|
||||
self._exif: Exif | None = None
|
||||
|
||||
@property
|
||||
def im(self) -> core.ImagingCore:
|
||||
if isinstance(self._im, DeferredError):
|
||||
raise self._im.ex
|
||||
assert self._im is not None
|
||||
return self._im
|
||||
|
||||
@im.setter
|
||||
def im(self, im: core.ImagingCore) -> None:
|
||||
self._im = im
|
||||
|
||||
@property
|
||||
def width(self) -> int:
|
||||
|
@ -612,12 +641,12 @@ class Image:
|
|||
logger.debug("Error closing: %s", msg)
|
||||
|
||||
if getattr(self, "map", None):
|
||||
self.map = None
|
||||
self.map: mmap.mmap | None = None
|
||||
|
||||
# Instead of simply setting to None, we're setting up a
|
||||
# deferred error that will better explain that the core image
|
||||
# object is gone.
|
||||
self.im = DeferredError(ValueError("Operation on closed image"))
|
||||
self._im = DeferredError(ValueError("Operation on closed image"))
|
||||
|
||||
def _copy(self) -> None:
|
||||
self.load()
|
||||
|
@ -676,7 +705,7 @@ class Image:
|
|||
id(self),
|
||||
)
|
||||
|
||||
def _repr_pretty_(self, p, cycle: bool) -> None:
|
||||
def _repr_pretty_(self, p: PrettyPrinter, cycle: bool) -> None:
|
||||
"""IPython plain text display support"""
|
||||
|
||||
# Same as __repr__ but without unpredictable id(self),
|
||||
|
@ -723,24 +752,12 @@ class Image:
|
|||
def __array_interface__(self) -> dict[str, str | bytes | int | tuple[int, ...]]:
|
||||
# numpy array interface support
|
||||
new: dict[str, str | bytes | int | tuple[int, ...]] = {"version": 3}
|
||||
try:
|
||||
if self.mode == "1":
|
||||
# Binary images need to be extended from bits to bytes
|
||||
# See: https://github.com/python-pillow/Pillow/issues/350
|
||||
new["data"] = self.tobytes("raw", "L")
|
||||
else:
|
||||
new["data"] = self.tobytes()
|
||||
except Exception as e:
|
||||
if not isinstance(e, (MemoryError, RecursionError)):
|
||||
try:
|
||||
import numpy
|
||||
from packaging.version import parse as parse_version
|
||||
except ImportError:
|
||||
pass
|
||||
else:
|
||||
if parse_version(numpy.__version__) < parse_version("1.23"):
|
||||
warnings.warn(str(e))
|
||||
raise
|
||||
new["shape"], new["typestr"] = _conv_type_shape(self)
|
||||
return new
|
||||
|
||||
|
@ -887,7 +904,7 @@ class Image:
|
|||
:returns: An image access object.
|
||||
:rtype: :py:class:`.PixelAccess`
|
||||
"""
|
||||
if self.im is not None and self.palette and self.palette.dirty:
|
||||
if self._im is not None and self.palette and self.palette.dirty:
|
||||
# realize palette
|
||||
mode, arr = self.palette.getdata()
|
||||
self.im.putpalette(self.palette.mode, mode, arr)
|
||||
|
@ -904,7 +921,7 @@ class Image:
|
|||
self.palette.mode, self.palette.mode
|
||||
)
|
||||
|
||||
if self.im is not None:
|
||||
if self._im is not None:
|
||||
return self.im.pixel_access(self.readonly)
|
||||
return None
|
||||
|
||||
|
@ -1045,9 +1062,11 @@ class Image:
|
|||
# use existing conversions
|
||||
trns_im = new(self.mode, (1, 1))
|
||||
if self.mode == "P":
|
||||
assert self.palette is not None
|
||||
trns_im.putpalette(self.palette)
|
||||
if isinstance(t, tuple):
|
||||
err = "Couldn't allocate a palette color for transparency"
|
||||
assert trns_im.palette is not None
|
||||
try:
|
||||
t = trns_im.palette.getcolor(t, self)
|
||||
except ValueError as e:
|
||||
|
@ -1149,7 +1168,9 @@ class Image:
|
|||
if trns is not None:
|
||||
if new_im.mode == "P" and new_im.palette:
|
||||
try:
|
||||
new_im.info["transparency"] = new_im.palette.getcolor(trns, new_im)
|
||||
new_im.info["transparency"] = new_im.palette.getcolor(
|
||||
cast(tuple[int, ...], trns), new_im # trns was converted to RGB
|
||||
)
|
||||
except ValueError as e:
|
||||
del new_im.info["transparency"]
|
||||
if str(e) != "cannot allocate more than 256 colors":
|
||||
|
@ -1227,6 +1248,7 @@ class Image:
|
|||
raise ValueError(msg)
|
||||
im = self.im.convert("P", dither, palette.im)
|
||||
new_im = self._new(im)
|
||||
assert palette.palette is not None
|
||||
new_im.palette = palette.palette.copy()
|
||||
return new_im
|
||||
|
||||
|
@ -1336,9 +1358,6 @@ class Image:
|
|||
self.load()
|
||||
return self._new(self.im.expand(xmargin, ymargin))
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from . import ImageFilter
|
||||
|
||||
def filter(self, filter: ImageFilter.Filter | type[ImageFilter.Filter]) -> Image:
|
||||
"""
|
||||
Filters this image using the given filter. For a list of
|
||||
|
@ -1584,7 +1603,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.
|
||||
|
||||
|
@ -1628,11 +1647,15 @@ class Image:
|
|||
|
||||
:returns: A boolean.
|
||||
"""
|
||||
return (
|
||||
if (
|
||||
self.mode in ("LA", "La", "PA", "RGBA", "RGBa")
|
||||
or (self.mode == "P" and self.palette.mode.endswith("A"))
|
||||
or "transparency" in self.info
|
||||
)
|
||||
):
|
||||
return True
|
||||
if self.mode == "P":
|
||||
assert self.palette is not None
|
||||
return self.palette.mode.endswith("A")
|
||||
return False
|
||||
|
||||
def apply_transparency(self) -> None:
|
||||
"""
|
||||
|
@ -1815,26 +1838,30 @@ class Image:
|
|||
raise ValueError(msg)
|
||||
box += (box[0] + size[0], box[1] + size[1])
|
||||
|
||||
source: core.ImagingCore | str | float | tuple[float, ...]
|
||||
if isinstance(im, str):
|
||||
from . import ImageColor
|
||||
|
||||
im = ImageColor.getcolor(im, self.mode)
|
||||
|
||||
source = ImageColor.getcolor(im, self.mode)
|
||||
elif isImageType(im):
|
||||
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)
|
||||
im = im.im
|
||||
source = im.im
|
||||
elif isinstance(im, tuple):
|
||||
source = im
|
||||
else:
|
||||
source = cast(float, im)
|
||||
|
||||
self._ensure_mutable()
|
||||
|
||||
if mask:
|
||||
mask.load()
|
||||
self.im.paste(im, box, mask.im)
|
||||
self.im.paste(source, box, mask.im)
|
||||
else:
|
||||
self.im.paste(im, box)
|
||||
self.im.paste(source, box)
|
||||
|
||||
def alpha_composite(
|
||||
self, im: Image, dest: Sequence[int] = (0, 0), source: Sequence[int] = (0, 0)
|
||||
|
@ -1894,7 +1921,13 @@ class Image:
|
|||
|
||||
def point(
|
||||
self,
|
||||
lut: Sequence[float] | NumpyArray | Callable[[int], float] | ImagePointHandler,
|
||||
lut: (
|
||||
Sequence[float]
|
||||
| NumpyArray
|
||||
| Callable[[int], float]
|
||||
| Callable[[ImagePointTransform], ImagePointTransform | float]
|
||||
| ImagePointHandler
|
||||
),
|
||||
mode: str | None = None,
|
||||
) -> Image:
|
||||
"""
|
||||
|
@ -1911,7 +1944,7 @@ class Image:
|
|||
object::
|
||||
|
||||
class Example(Image.ImagePointHandler):
|
||||
def point(self, data):
|
||||
def point(self, im: Image) -> Image:
|
||||
# Return result
|
||||
:param mode: Output mode (default is same as input). This can only be used if
|
||||
the source image has mode "L" or "P", and the output has mode "1" or the
|
||||
|
@ -1930,10 +1963,10 @@ class Image:
|
|||
# check if the function can be used with point_transform
|
||||
# UNDONE wiredfool -- I think this prevents us from ever doing
|
||||
# a gamma function point transform on > 8bit images.
|
||||
scale, offset = _getscaleoffset(lut)
|
||||
scale, offset = _getscaleoffset(lut) # type: ignore[arg-type]
|
||||
return self._new(self.im.point_transform(scale, offset))
|
||||
# for other modes, convert the function to a table
|
||||
flatLut = [lut(i) for i in range(256)] * self.im.bands
|
||||
flatLut = [lut(i) for i in range(256)] * self.im.bands # type: ignore[arg-type]
|
||||
else:
|
||||
flatLut = lut
|
||||
|
||||
|
@ -2105,7 +2138,8 @@ class Image:
|
|||
if self.mode == "PA":
|
||||
alpha = value[3] if len(value) == 4 else 255
|
||||
value = value[:3]
|
||||
palette_index = self.palette.getcolor(value, self)
|
||||
assert self.palette is not None
|
||||
palette_index = self.palette.getcolor(tuple(value), self)
|
||||
value = (palette_index, alpha) if self.mode == "PA" else palette_index
|
||||
return self.im.putpixel(xy, value)
|
||||
|
||||
|
@ -2869,11 +2903,11 @@ class Image:
|
|||
self,
|
||||
box: tuple[int, int, int, int],
|
||||
image: Image,
|
||||
method,
|
||||
data,
|
||||
method: Transform,
|
||||
data: Sequence[float],
|
||||
resample: int = Resampling.NEAREST,
|
||||
fill: bool = True,
|
||||
):
|
||||
) -> None:
|
||||
w = box[2] - box[0]
|
||||
h = box[3] - box[1]
|
||||
|
||||
|
@ -2974,7 +3008,7 @@ class Image:
|
|||
self.load()
|
||||
return self._new(self.im.effect_spread(distance))
|
||||
|
||||
def toqimage(self):
|
||||
def toqimage(self) -> ImageQt.ImageQt:
|
||||
"""Returns a QImage copy of this image"""
|
||||
from . import ImageQt
|
||||
|
||||
|
@ -2983,7 +3017,7 @@ class Image:
|
|||
raise ImportError(msg)
|
||||
return ImageQt.toqimage(self)
|
||||
|
||||
def toqpixmap(self):
|
||||
def toqpixmap(self) -> ImageQt.QPixmap:
|
||||
"""Returns a QPixmap copy of this image"""
|
||||
from . import ImageQt
|
||||
|
||||
|
@ -3310,7 +3344,7 @@ def fromarray(obj: SupportsArrayInterface, mode: str | None = None) -> Image:
|
|||
return frombuffer(mode, size, obj, "raw", rawmode, 0, 1)
|
||||
|
||||
|
||||
def fromqimage(im) -> ImageFile.ImageFile:
|
||||
def fromqimage(im: ImageQt.QImage) -> ImageFile.ImageFile:
|
||||
"""Creates an image instance from a QImage image"""
|
||||
from . import ImageQt
|
||||
|
||||
|
@ -3320,7 +3354,7 @@ def fromqimage(im) -> ImageFile.ImageFile:
|
|||
return ImageQt.fromqimage(im)
|
||||
|
||||
|
||||
def fromqpixmap(im) -> ImageFile.ImageFile:
|
||||
def fromqpixmap(im: ImageQt.QPixmap) -> ImageFile.ImageFile:
|
||||
"""Creates an image instance from a QPixmap image"""
|
||||
from . import ImageQt
|
||||
|
||||
|
@ -3612,7 +3646,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:
|
||||
"""
|
||||
|
@ -4008,15 +4045,19 @@ class Exif(_ExifBase):
|
|||
ifd[tag] = value
|
||||
return b"Exif\x00\x00" + head + ifd.tobytes(offset)
|
||||
|
||||
def get_ifd(self, tag):
|
||||
def get_ifd(self, tag: int) -> dict[int, Any]:
|
||||
if tag not in self._ifds:
|
||||
if tag == ExifTags.IFD.IFD1:
|
||||
if self._info is not None and self._info.next != 0:
|
||||
self._ifds[tag] = self._get_ifd_dict(self._info.next)
|
||||
ifd = self._get_ifd_dict(self._info.next)
|
||||
if ifd is not None:
|
||||
self._ifds[tag] = ifd
|
||||
elif tag in [ExifTags.IFD.Exif, ExifTags.IFD.GPSInfo]:
|
||||
offset = self._hidden_data.get(tag, self.get(tag))
|
||||
if offset is not None:
|
||||
self._ifds[tag] = self._get_ifd_dict(offset, tag)
|
||||
ifd = self._get_ifd_dict(offset, tag)
|
||||
if ifd is not None:
|
||||
self._ifds[tag] = ifd
|
||||
elif tag in [ExifTags.IFD.Interop, ExifTags.IFD.Makernote]:
|
||||
if ExifTags.IFD.Exif not in self._ifds:
|
||||
self.get_ifd(ExifTags.IFD.Exif)
|
||||
|
@ -4073,7 +4114,9 @@ class Exif(_ExifBase):
|
|||
(offset,) = struct.unpack(">L", data)
|
||||
self.fp.seek(offset)
|
||||
|
||||
camerainfo = {"ModelID": self.fp.read(4)}
|
||||
camerainfo: dict[str, int | bytes] = {
|
||||
"ModelID": self.fp.read(4)
|
||||
}
|
||||
|
||||
self.fp.read(4)
|
||||
# Seconds since 2000
|
||||
|
@ -4089,17 +4132,19 @@ class Exif(_ExifBase):
|
|||
][1]
|
||||
camerainfo["Parallax"] = handler(
|
||||
ImageFileDirectory_v2(), parallax, False
|
||||
)
|
||||
)[0]
|
||||
|
||||
self.fp.read(4)
|
||||
camerainfo["Category"] = self.fp.read(2)
|
||||
|
||||
makernote = {0x1101: dict(self._fixup_dict(camerainfo))}
|
||||
makernote = {0x1101: camerainfo}
|
||||
self._ifds[tag] = makernote
|
||||
else:
|
||||
# Interop
|
||||
self._ifds[tag] = self._get_ifd_dict(tag_data, tag)
|
||||
ifd = self._ifds.get(tag, {})
|
||||
ifd = self._get_ifd_dict(tag_data, tag)
|
||||
if ifd is not None:
|
||||
self._ifds[tag] = ifd
|
||||
ifd = self._ifds.setdefault(tag, {})
|
||||
if tag == ExifTags.IFD.Exif and self._hidden_data:
|
||||
ifd = {
|
||||
k: v
|
||||
|
|
|
@ -32,7 +32,6 @@
|
|||
from __future__ import annotations
|
||||
|
||||
import math
|
||||
import numbers
|
||||
import struct
|
||||
from collections.abc import Sequence
|
||||
from types import ModuleType
|
||||
|
@ -160,13 +159,13 @@ class ImageDraw:
|
|||
if ink is not None:
|
||||
if isinstance(ink, str):
|
||||
ink = ImageColor.getcolor(ink, self.mode)
|
||||
if self.palette and not isinstance(ink, numbers.Number):
|
||||
if self.palette and isinstance(ink, tuple):
|
||||
ink = self.palette.getcolor(ink, self._image)
|
||||
result_ink = self.draw.draw_ink(ink)
|
||||
if fill is not None:
|
||||
if isinstance(fill, str):
|
||||
fill = ImageColor.getcolor(fill, self.mode)
|
||||
if self.palette and not isinstance(fill, numbers.Number):
|
||||
if self.palette and isinstance(fill, tuple):
|
||||
fill = self.palette.getcolor(fill, self._image)
|
||||
result_fill = self.draw.draw_ink(fill)
|
||||
return result_ink, result_fill
|
||||
|
@ -505,7 +504,7 @@ class ImageDraw:
|
|||
|
||||
if full_x:
|
||||
self.draw.draw_rectangle((x0, y0 + r + 1, x1, y1 - r - 1), fill_ink, 1)
|
||||
else:
|
||||
elif x1 - r - 1 > x0 + r + 1:
|
||||
self.draw.draw_rectangle((x0 + r + 1, y0, x1 - r - 1, y1), fill_ink, 1)
|
||||
if not full_x and not full_y:
|
||||
left = [x0, y0, x0 + r, y1]
|
||||
|
|
|
@ -80,7 +80,12 @@ class Draw:
|
|||
return self.image
|
||||
|
||||
def render(
|
||||
self, op: str, xy: Coords, pen: Pen | Brush, brush: Brush | Pen | None = None
|
||||
self,
|
||||
op: str,
|
||||
xy: Coords,
|
||||
pen: Pen | Brush | None,
|
||||
brush: Brush | Pen | None = None,
|
||||
**kwargs: Any,
|
||||
) -> None:
|
||||
# handle color arguments
|
||||
outline = fill = None
|
||||
|
@ -101,60 +106,85 @@ class Draw:
|
|||
path.transform(self.transform)
|
||||
xy = path
|
||||
# render the item
|
||||
if op == "line":
|
||||
self.draw.line(xy, fill=outline, width=width)
|
||||
if op in ("arc", "line"):
|
||||
kwargs.setdefault("fill", outline)
|
||||
else:
|
||||
getattr(self.draw, op)(xy, fill=fill, outline=outline)
|
||||
kwargs.setdefault("fill", fill)
|
||||
kwargs.setdefault("outline", outline)
|
||||
if op == "line":
|
||||
kwargs.setdefault("width", width)
|
||||
getattr(self.draw, op)(xy, **kwargs)
|
||||
|
||||
def settransform(self, offset: tuple[float, float]) -> None:
|
||||
"""Sets a transformation offset."""
|
||||
(xoffset, yoffset) = offset
|
||||
self.transform = (1, 0, xoffset, 0, 1, yoffset)
|
||||
|
||||
def arc(self, xy: Coords, start, end, *options: Any) -> None:
|
||||
def arc(
|
||||
self,
|
||||
xy: Coords,
|
||||
pen: Pen | Brush | None,
|
||||
start: float,
|
||||
end: float,
|
||||
*options: Any,
|
||||
) -> None:
|
||||
"""
|
||||
Draws an arc (a portion of a circle outline) between the start and end
|
||||
angles, inside the given bounding box.
|
||||
|
||||
.. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.arc`
|
||||
"""
|
||||
self.render("arc", xy, start, end, *options)
|
||||
self.render("arc", xy, pen, *options, start=start, end=end)
|
||||
|
||||
def chord(self, xy: Coords, start, end, *options: Any) -> None:
|
||||
def chord(
|
||||
self,
|
||||
xy: Coords,
|
||||
pen: Pen | Brush | None,
|
||||
start: float,
|
||||
end: float,
|
||||
*options: Any,
|
||||
) -> None:
|
||||
"""
|
||||
Same as :py:meth:`~PIL.ImageDraw2.Draw.arc`, but connects the end points
|
||||
with a straight line.
|
||||
|
||||
.. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.chord`
|
||||
"""
|
||||
self.render("chord", xy, start, end, *options)
|
||||
self.render("chord", xy, pen, *options, start=start, end=end)
|
||||
|
||||
def ellipse(self, xy: Coords, *options: Any) -> None:
|
||||
def ellipse(self, xy: Coords, pen: Pen | Brush | None, *options: Any) -> None:
|
||||
"""
|
||||
Draws an ellipse inside the given bounding box.
|
||||
|
||||
.. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.ellipse`
|
||||
"""
|
||||
self.render("ellipse", xy, *options)
|
||||
self.render("ellipse", xy, pen, *options)
|
||||
|
||||
def line(self, xy: Coords, *options: Any) -> None:
|
||||
def line(self, xy: Coords, pen: Pen | Brush | None, *options: Any) -> None:
|
||||
"""
|
||||
Draws a line between the coordinates in the ``xy`` list.
|
||||
|
||||
.. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.line`
|
||||
"""
|
||||
self.render("line", xy, *options)
|
||||
self.render("line", xy, pen, *options)
|
||||
|
||||
def pieslice(self, xy: Coords, start, end, *options: Any) -> None:
|
||||
def pieslice(
|
||||
self,
|
||||
xy: Coords,
|
||||
pen: Pen | Brush | None,
|
||||
start: float,
|
||||
end: float,
|
||||
*options: Any,
|
||||
) -> None:
|
||||
"""
|
||||
Same as arc, but also draws straight lines between the end points and the
|
||||
center of the bounding box.
|
||||
|
||||
.. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.pieslice`
|
||||
"""
|
||||
self.render("pieslice", xy, start, end, *options)
|
||||
self.render("pieslice", xy, pen, *options, start=start, end=end)
|
||||
|
||||
def polygon(self, xy: Coords, *options: Any) -> None:
|
||||
def polygon(self, xy: Coords, pen: Pen | Brush | None, *options: Any) -> None:
|
||||
"""
|
||||
Draws a polygon.
|
||||
|
||||
|
@ -165,15 +195,15 @@ class Draw:
|
|||
|
||||
.. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.polygon`
|
||||
"""
|
||||
self.render("polygon", xy, *options)
|
||||
self.render("polygon", xy, pen, *options)
|
||||
|
||||
def rectangle(self, xy: Coords, *options: Any) -> None:
|
||||
def rectangle(self, xy: Coords, pen: Pen | Brush | None, *options: Any) -> None:
|
||||
"""
|
||||
Draws a rectangle.
|
||||
|
||||
.. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.rectangle`
|
||||
"""
|
||||
self.render("rectangle", xy, *options)
|
||||
self.render("rectangle", xy, pen, *options)
|
||||
|
||||
def text(self, xy: tuple[float, float], text: AnyStr, font: Font) -> None:
|
||||
"""
|
||||
|
|
|
@ -31,14 +31,18 @@ from __future__ import annotations
|
|||
import abc
|
||||
import io
|
||||
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
|
||||
|
@ -93,7 +97,7 @@ def _tilesort(t: _Tile) -> int:
|
|||
|
||||
class _Tile(NamedTuple):
|
||||
codec_name: str
|
||||
extents: tuple[int, int, int, int]
|
||||
extents: tuple[int, int, int, int] | None
|
||||
offset: int
|
||||
args: tuple[Any, ...] | str | None
|
||||
|
||||
|
@ -106,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:
|
||||
|
@ -154,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
|
||||
|
@ -174,10 +183,10 @@ class ImageFile(Image.Image):
|
|||
self.fp.close()
|
||||
self.fp = None
|
||||
|
||||
def load(self):
|
||||
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)
|
||||
|
||||
|
@ -185,7 +194,7 @@ class ImageFile(Image.Image):
|
|||
if not self.tile:
|
||||
return pixel
|
||||
|
||||
self.map = None
|
||||
self.map: mmap.mmap | None = None
|
||||
use_mmap = self.filename and len(self.tile) == 1
|
||||
# As of pypy 2.1.0, memory mapping was failing here.
|
||||
use_mmap = use_mmap and not hasattr(sys, "pypy_version_info")
|
||||
|
@ -193,17 +202,17 @@ class ImageFile(Image.Image):
|
|||
readonly = 0
|
||||
|
||||
# look for read/seek overrides
|
||||
try:
|
||||
if hasattr(self, "load_read"):
|
||||
read = self.load_read
|
||||
# don't use mmap if there are custom read/seek functions
|
||||
use_mmap = False
|
||||
except AttributeError:
|
||||
else:
|
||||
read = self.fp.read
|
||||
|
||||
try:
|
||||
if hasattr(self, "load_seek"):
|
||||
seek = self.load_seek
|
||||
use_mmap = False
|
||||
except AttributeError:
|
||||
else:
|
||||
seek = self.fp.seek
|
||||
|
||||
if use_mmap:
|
||||
|
@ -213,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
|
||||
|
@ -243,11 +253,8 @@ class ImageFile(Image.Image):
|
|||
# sort tiles in file order
|
||||
self.tile.sort(key=_tilesort)
|
||||
|
||||
try:
|
||||
# FIXME: This is a hack to handle TIFF's JpegTables tag.
|
||||
prefix = self.tile_prefix
|
||||
except AttributeError:
|
||||
prefix = b""
|
||||
prefix = getattr(self, "tile_prefix", b"")
|
||||
|
||||
# Remove consecutive duplicates that only differ by their offset
|
||||
self.tile = [
|
||||
|
@ -315,7 +322,7 @@ class ImageFile(Image.Image):
|
|||
|
||||
def load_prepare(self) -> None:
|
||||
# create image memory if necessary
|
||||
if not self.im or self.im.mode != self.mode or self.im.size != self.size:
|
||||
if self._im is None or self.im.mode != self.mode or self.im.size != self.size:
|
||||
self.im = Image.core.new(self.mode, self.size)
|
||||
# create palette (optional)
|
||||
if self.mode == "P":
|
||||
|
@ -525,7 +532,7 @@ class Parser:
|
|||
# --------------------------------------------------------------------
|
||||
|
||||
|
||||
def _save(im: Image.Image, fp: IO[bytes], tile, bufsize: int = 0) -> None:
|
||||
def _save(im: Image.Image, fp: IO[bytes], tile: list[_Tile], bufsize: int = 0) -> None:
|
||||
"""Helper to save image based on tile list
|
||||
|
||||
:param im: Image object.
|
||||
|
@ -558,7 +565,7 @@ def _encode_tile(
|
|||
fp: IO[bytes],
|
||||
tile: list[_Tile],
|
||||
bufsize: int,
|
||||
fh,
|
||||
fh: int | None,
|
||||
exc: BaseException | None = None,
|
||||
) -> None:
|
||||
for encoder_name, extents, offset, args in tile:
|
||||
|
@ -580,6 +587,7 @@ def _encode_tile(
|
|||
break
|
||||
else:
|
||||
# slight speedup: compress to real file object
|
||||
assert fh is not None
|
||||
errcode = encoder.encode_to_file(fh, bufsize)
|
||||
if errcode < 0:
|
||||
raise _get_oserror(errcode, encoder=True) from exc
|
||||
|
@ -737,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)
|
||||
|
@ -804,7 +815,7 @@ class PyEncoder(PyCodec):
|
|||
self.fd.write(data)
|
||||
return bytes_consumed, errcode
|
||||
|
||||
def encode_to_file(self, fh: IO[bytes], bufsize: int) -> int:
|
||||
def encode_to_file(self, fh: int, bufsize: int) -> int:
|
||||
"""
|
||||
:param fh: File handle.
|
||||
:param bufsize: Buffer size.
|
||||
|
@ -817,5 +828,5 @@ class PyEncoder(PyCodec):
|
|||
while errcode == 0:
|
||||
status, errcode, buf = self.encode(bufsize)
|
||||
if status > 0:
|
||||
fh.write(buf[status:])
|
||||
os.write(fh, buf[status:])
|
||||
return errcode
|
||||
|
|
|
@ -34,7 +34,7 @@ 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 ._typing import StrOrBytesPath
|
||||
|
@ -212,7 +212,7 @@ class FreeTypeFont:
|
|||
|
||||
def __init__(
|
||||
self,
|
||||
font: StrOrBytesPath | BinaryIO | None = None,
|
||||
font: StrOrBytesPath | BinaryIO,
|
||||
size: float = 10,
|
||||
index: int = 0,
|
||||
encoding: str = "",
|
||||
|
@ -245,7 +245,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
|
||||
|
@ -267,7 +267,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]
|
||||
|
@ -781,7 +781,7 @@ def load(filename: str) -> ImageFont:
|
|||
|
||||
|
||||
def truetype(
|
||||
font: StrOrBytesPath | BinaryIO | None = None,
|
||||
font: StrOrBytesPath | BinaryIO,
|
||||
size: float = 10,
|
||||
index: int = 0,
|
||||
encoding: str = "",
|
||||
|
@ -852,7 +852,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:
|
||||
|
|
|
@ -19,14 +19,23 @@ from __future__ import annotations
|
|||
|
||||
import sys
|
||||
from io import BytesIO
|
||||
from typing import TYPE_CHECKING, Callable
|
||||
from typing import TYPE_CHECKING, Any, Callable, Union
|
||||
|
||||
from . import Image
|
||||
from ._util import is_path
|
||||
|
||||
if TYPE_CHECKING:
|
||||
import PyQt6
|
||||
import PySide6
|
||||
|
||||
from . import ImageFile
|
||||
|
||||
QBuffer: type
|
||||
QByteArray = Union[PyQt6.QtCore.QByteArray, PySide6.QtCore.QByteArray]
|
||||
QIODevice = Union[PyQt6.QtCore.QIODevice, PySide6.QtCore.QIODevice]
|
||||
QImage = Union[PyQt6.QtGui.QImage, PySide6.QtGui.QImage]
|
||||
QPixmap = Union[PyQt6.QtGui.QPixmap, PySide6.QtGui.QPixmap]
|
||||
|
||||
qt_version: str | None
|
||||
qt_versions = [
|
||||
["6", "PyQt6"],
|
||||
|
@ -37,10 +46,6 @@ qt_versions = [
|
|||
qt_versions.sort(key=lambda version: version[1] in sys.modules, reverse=True)
|
||||
for version, qt_module in qt_versions:
|
||||
try:
|
||||
QBuffer: type
|
||||
QIODevice: type
|
||||
QImage: type
|
||||
QPixmap: type
|
||||
qRgba: Callable[[int, int, int, int], int]
|
||||
if qt_module == "PyQt6":
|
||||
from PyQt6.QtCore import QBuffer, QIODevice
|
||||
|
@ -65,19 +70,20 @@ def rgb(r: int, g: int, b: int, a: int = 255) -> int:
|
|||
return qRgba(r, g, b, a) & 0xFFFFFFFF
|
||||
|
||||
|
||||
def fromqimage(im):
|
||||
def fromqimage(im: QImage | QPixmap) -> ImageFile.ImageFile:
|
||||
"""
|
||||
:param im: QImage or PIL ImageQt object
|
||||
"""
|
||||
buffer = QBuffer()
|
||||
qt_openmode: object
|
||||
if qt_version == "6":
|
||||
try:
|
||||
qt_openmode = QIODevice.OpenModeFlag
|
||||
qt_openmode = getattr(QIODevice, "OpenModeFlag")
|
||||
except AttributeError:
|
||||
qt_openmode = QIODevice.OpenMode
|
||||
qt_openmode = getattr(QIODevice, "OpenMode")
|
||||
else:
|
||||
qt_openmode = QIODevice
|
||||
buffer.open(qt_openmode.ReadWrite)
|
||||
buffer.open(getattr(qt_openmode, "ReadWrite"))
|
||||
# preserve alpha channel with png
|
||||
# otherwise ppm is more friendly with Image.open
|
||||
if im.hasAlphaChannel():
|
||||
|
@ -93,7 +99,7 @@ def fromqimage(im):
|
|||
return Image.open(b)
|
||||
|
||||
|
||||
def fromqpixmap(im) -> ImageFile.ImageFile:
|
||||
def fromqpixmap(im: QPixmap) -> ImageFile.ImageFile:
|
||||
return fromqimage(im)
|
||||
|
||||
|
||||
|
@ -123,7 +129,7 @@ def align8to32(bytes: bytes, width: int, mode: str) -> bytes:
|
|||
return b"".join(new_data)
|
||||
|
||||
|
||||
def _toqclass_helper(im):
|
||||
def _toqclass_helper(im: Image.Image | str | QByteArray) -> dict[str, Any]:
|
||||
data = None
|
||||
colortable = None
|
||||
exclusive_fp = False
|
||||
|
@ -135,30 +141,32 @@ def _toqclass_helper(im):
|
|||
if is_path(im):
|
||||
im = Image.open(im)
|
||||
exclusive_fp = True
|
||||
assert isinstance(im, Image.Image)
|
||||
|
||||
qt_format = QImage.Format if qt_version == "6" else QImage
|
||||
qt_format = getattr(QImage, "Format") if qt_version == "6" else QImage
|
||||
if im.mode == "1":
|
||||
format = qt_format.Format_Mono
|
||||
format = getattr(qt_format, "Format_Mono")
|
||||
elif im.mode == "L":
|
||||
format = qt_format.Format_Indexed8
|
||||
format = getattr(qt_format, "Format_Indexed8")
|
||||
colortable = [rgb(i, i, i) for i in range(256)]
|
||||
elif im.mode == "P":
|
||||
format = qt_format.Format_Indexed8
|
||||
format = getattr(qt_format, "Format_Indexed8")
|
||||
palette = im.getpalette()
|
||||
assert palette is not None
|
||||
colortable = [rgb(*palette[i : i + 3]) for i in range(0, len(palette), 3)]
|
||||
elif im.mode == "RGB":
|
||||
# Populate the 4th channel with 255
|
||||
im = im.convert("RGBA")
|
||||
|
||||
data = im.tobytes("raw", "BGRA")
|
||||
format = qt_format.Format_RGB32
|
||||
format = getattr(qt_format, "Format_RGB32")
|
||||
elif im.mode == "RGBA":
|
||||
data = im.tobytes("raw", "BGRA")
|
||||
format = qt_format.Format_ARGB32
|
||||
format = getattr(qt_format, "Format_ARGB32")
|
||||
elif im.mode == "I;16":
|
||||
im = im.point(lambda i: i * 256)
|
||||
|
||||
format = qt_format.Format_Grayscale16
|
||||
format = getattr(qt_format, "Format_Grayscale16")
|
||||
else:
|
||||
if exclusive_fp:
|
||||
im.close()
|
||||
|
@ -174,8 +182,8 @@ def _toqclass_helper(im):
|
|||
|
||||
if qt_is_installed:
|
||||
|
||||
class ImageQt(QImage):
|
||||
def __init__(self, im) -> None:
|
||||
class ImageQt(QImage): # type: ignore[misc]
|
||||
def __init__(self, im: Image.Image | str | QByteArray) -> None:
|
||||
"""
|
||||
An PIL image wrapper for Qt. This is a subclass of PyQt's QImage
|
||||
class.
|
||||
|
@ -199,10 +207,10 @@ if qt_is_installed:
|
|||
self.setColorTable(im_data["colortable"])
|
||||
|
||||
|
||||
def toqimage(im) -> ImageQt:
|
||||
def toqimage(im: Image.Image | str | QByteArray) -> ImageQt:
|
||||
return ImageQt(im)
|
||||
|
||||
|
||||
def toqpixmap(im):
|
||||
def toqpixmap(im: Image.Image | str | QByteArray) -> QPixmap:
|
||||
qimage = toqimage(im)
|
||||
return QPixmap.fromImage(qimage)
|
||||
return getattr(QPixmap, "fromImage")(qimage)
|
||||
|
|
|
@ -127,10 +127,7 @@ class PhotoImage:
|
|||
# palette mapped data
|
||||
image.apply_transparency()
|
||||
image.load()
|
||||
try:
|
||||
mode = image.palette.mode
|
||||
except AttributeError:
|
||||
mode = "RGB" # default
|
||||
mode = image.palette.mode if image.palette else "RGB"
|
||||
size = image.size
|
||||
kw["width"], kw["height"] = size
|
||||
|
||||
|
|
|
@ -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":
|
||||
|
@ -199,9 +201,13 @@ def getiptcinfo(
|
|||
|
||||
data = None
|
||||
|
||||
info: dict[tuple[int, int], bytes | list[bytes]] = {}
|
||||
if isinstance(im, IptcImageFile):
|
||||
# return info dictionary right away
|
||||
return im.info
|
||||
for k, v in im.info.items():
|
||||
if isinstance(k, tuple):
|
||||
info[k] = v
|
||||
return info
|
||||
|
||||
elif isinstance(im, JpegImagePlugin.JpegImageFile):
|
||||
# extract the IPTC/NAA resource
|
||||
|
@ -213,8 +219,8 @@ def getiptcinfo(
|
|||
# get raw data from the IPTC/NAA tag (PhotoShop tags the data
|
||||
# as 4-byte integers, so we cannot use the get method...)
|
||||
try:
|
||||
data = im.tag.tagdata[TiffImagePlugin.IPTC_NAA_CHUNK]
|
||||
except (AttributeError, KeyError):
|
||||
data = im.tag_v2[TiffImagePlugin.IPTC_NAA_CHUNK]
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
if data is None:
|
||||
|
@ -237,4 +243,7 @@ def getiptcinfo(
|
|||
except (IndexError, KeyError):
|
||||
pass # expected failure
|
||||
|
||||
return iptc_im.info
|
||||
for k, v in iptc_im.info.items():
|
||||
if isinstance(k, tuple):
|
||||
info[k] = v
|
||||
return info
|
||||
|
|
|
@ -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)
|
||||
|
||||
|
@ -419,7 +426,7 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
|
|||
plt,
|
||||
)
|
||||
|
||||
ImageFile._save(im, fp, [("jpeg2k", (0, 0) + im.size, 0, kind)])
|
||||
ImageFile._save(im, fp, [ImageFile._Tile("jpeg2k", (0, 0) + im.size, 0, kind)])
|
||||
|
||||
|
||||
# ------------------------------------------------------------
|
||||
|
|
|
@ -49,6 +49,7 @@ from ._binary import i16be as i16
|
|||
from ._binary import i32be as i32
|
||||
from ._binary import o8
|
||||
from ._binary import o16be as o16
|
||||
from ._deprecate import deprecate
|
||||
from .JpegPresets import presets
|
||||
|
||||
if TYPE_CHECKING:
|
||||
|
@ -346,8 +347,8 @@ class JpegImageFile(ImageFile.ImageFile):
|
|||
|
||||
# JPEG specifics (internal)
|
||||
self.layer: list[tuple[int, int, int, int]] = []
|
||||
self.huffman_dc: dict[Any, Any] = {}
|
||||
self.huffman_ac: dict[Any, Any] = {}
|
||||
self._huffman_dc: dict[Any, Any] = {}
|
||||
self._huffman_ac: dict[Any, Any] = {}
|
||||
self.quantization: dict[int, list[int]] = {}
|
||||
self.app: dict[str, bytes] = {} # compatibility
|
||||
self.applist: list[tuple[str, bytes]] = []
|
||||
|
@ -371,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)
|
||||
|
@ -386,6 +389,12 @@ class JpegImageFile(ImageFile.ImageFile):
|
|||
|
||||
self._read_dpi_from_exif()
|
||||
|
||||
def __getattr__(self, name: str) -> Any:
|
||||
if name in ("huffman_ac", "huffman_dc"):
|
||||
deprecate(name, 12)
|
||||
return getattr(self, "_" + name)
|
||||
raise AttributeError(name)
|
||||
|
||||
def load_read(self, read_bytes: int) -> bytes:
|
||||
"""
|
||||
internal: read more image data
|
||||
|
@ -416,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, ""
|
||||
|
@ -425,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],
|
||||
|
@ -434,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)
|
||||
|
@ -740,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
|
||||
|
@ -819,7 +840,9 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
|
|||
# Ensure that our buffer is big enough. Same with the icc_profile block.
|
||||
bufsize = max(bufsize, len(exif) + 5, len(extra) + 1)
|
||||
|
||||
ImageFile._save(im, fp, [("jpeg", (0, 0) + im.size, 0, rawmode)], bufsize)
|
||||
ImageFile._save(
|
||||
im, fp, [ImageFile._Tile("jpeg", (0, 0) + im.size, 0, rawmode)], bufsize
|
||||
)
|
||||
|
||||
|
||||
def _save_cjpeg(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
|
||||
|
@ -835,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):
|
||||
|
@ -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
|
||||
|
||||
|
@ -188,7 +188,7 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
|
|||
fp.write(o16(h))
|
||||
|
||||
# image body
|
||||
ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 32, ("1", 0, 1))])
|
||||
ImageFile._save(im, fp, [ImageFile._Tile("raw", (0, 0) + im.size, 32, ("1", 0, 1))])
|
||||
|
||||
|
||||
#
|
||||
|
|
|
@ -17,7 +17,7 @@
|
|||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
from typing import TYPE_CHECKING
|
||||
from typing import IO, TYPE_CHECKING
|
||||
|
||||
from . import EpsImagePlugin
|
||||
|
||||
|
@ -28,15 +28,12 @@ from . import EpsImagePlugin
|
|||
class PSDraw:
|
||||
"""
|
||||
Sets up printing to the given file. If ``fp`` is omitted,
|
||||
``sys.stdout.buffer`` or ``sys.stdout`` is assumed.
|
||||
``sys.stdout.buffer`` is assumed.
|
||||
"""
|
||||
|
||||
def __init__(self, fp=None):
|
||||
def __init__(self, fp: IO[bytes] | None = None) -> None:
|
||||
if not fp:
|
||||
try:
|
||||
fp = sys.stdout.buffer
|
||||
except AttributeError:
|
||||
fp = sys.stdout
|
||||
self.fp = fp
|
||||
|
||||
def begin_document(self, id: str | None = None) -> None:
|
||||
|
|
|
@ -173,6 +173,7 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
|
|||
|
||||
flags = 0
|
||||
if im.mode == "P" and "custom-colormap" in im.info:
|
||||
assert im.palette is not None
|
||||
flags = flags & _FLAGS["custom-colormap"]
|
||||
colormapsize = 4 * 256 + 2
|
||||
colormapmode = im.palette.mode
|
||||
|
@ -213,7 +214,9 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
|
|||
)
|
||||
|
||||
# now convert data to raw form
|
||||
ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, rowbytes, 1))])
|
||||
ImageFile._save(
|
||||
im, fp, [ImageFile._Tile("raw", (0, 0) + im.size, 0, (rawmode, rowbytes, 1))]
|
||||
)
|
||||
|
||||
if hasattr(fp, "flush"):
|
||||
fp.flush()
|
||||
|
|
|
@ -47,13 +47,11 @@ 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:
|
||||
# Handle rotated PCDs
|
||||
assert self.im is not None
|
||||
|
||||
self.im = self.im.rotate(self.tile_post_rotate)
|
||||
self._size = self.im.size
|
||||
|
||||
|
|
|
@ -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))
|
||||
]
|
||||
|
||||
|
||||
# --------------------------------------------------------------------
|
||||
|
@ -198,12 +200,12 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
|
|||
|
||||
assert fp.tell() == 128
|
||||
|
||||
ImageFile._save(im, fp, [("pcx", (0, 0) + im.size, 0, (rawmode, bits * planes))])
|
||||
ImageFile._save(
|
||||
im, fp, [ImageFile._Tile("pcx", (0, 0) + im.size, 0, (rawmode, bits * planes))]
|
||||
)
|
||||
|
||||
if im.mode == "P":
|
||||
# colour palette
|
||||
assert im.im is not None
|
||||
|
||||
fp.write(o8(12))
|
||||
palette = im.im.getpalette("RGB", "RGB")
|
||||
palette += b"\x00" * (768 - len(palette))
|
||||
|
|
|
@ -138,7 +138,7 @@ def _write_image(
|
|||
op = io.BytesIO()
|
||||
|
||||
if decode_filter == "ASCIIHexDecode":
|
||||
ImageFile._save(im, op, [("hex", (0, 0) + im.size, 0, im.mode)])
|
||||
ImageFile._save(im, op, [ImageFile._Tile("hex", (0, 0) + im.size, 0, im.mode)])
|
||||
elif decode_filter == "CCITTFaxDecode":
|
||||
im.save(
|
||||
op,
|
||||
|
|
|
@ -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))
|
||||
]
|
||||
|
||||
|
||||
#
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user