python-pillow/Pillow
1
1
Fork 0
mirror of https://github.com/python-pillow/Pillow.git synced 2025-03-13 01:05:48 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into typing

Browse Source
This commit is contained in:
Andrew Murray 2025-01-31 22:46:38 +11:00 committed by GitHub
commit e69c9ca753
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
31 changed files with 290 additions and 444 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
Tests/check_png_dos.py
View File

@ -3,26 +3,25 @@ from __future__ import annotations
import zlib
from io import BytesIO
import pytest
from PIL import Image, ImageFile, PngImagePlugin
TEST_FILE = "Tests/images/png_decompression_dos.png"
def test_ignore_dos_text() -> None:
ImageFile.LOAD_TRUNCATED_IMAGES = True
def test_ignore_dos_text(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr(ImageFile, "LOAD_TRUNCATED_IMAGES", True)
try:
im = Image.open(TEST_FILE)
with Image.open(TEST_FILE) as im:
im.load()
finally:
ImageFile.LOAD_TRUNCATED_IMAGES = False
assert isinstance(im, PngImagePlugin.PngImageFile)
for s in im.text.values():
assert len(s) < 1024 * 1024, "Text chunk larger than 1M"
assert isinstance(im, PngImagePlugin.PngImageFile)
for s in im.text.values():
assert len(s) < 1024 * 1024, "Text chunk larger than 1M"
for s in im.info.values():
assert len(s) < 1024 * 1024, "Text chunk larger than 1M"
for s in im.info.values():
assert len(s) < 1024 * 1024, "Text chunk larger than 1M"
def test_dos_text() -> None:

19
Tests/test_decompression_bomb.py
View File

@ -12,19 +12,16 @@ ORIGINAL_LIMIT = Image.MAX_IMAGE_PIXELS
class TestDecompressionBomb:
def teardown_method(self) -> None:
Image.MAX_IMAGE_PIXELS = ORIGINAL_LIMIT
def test_no_warning_small_file(self) -> None:
# Implicit assert: no warning.
# A warning would cause a failure.
with Image.open(TEST_FILE):
pass
def test_no_warning_no_limit(self) -> None:
def test_no_warning_no_limit(self, monkeypatch: pytest.MonkeyPatch) -> None:
# Arrange
# Turn limit off
Image.MAX_IMAGE_PIXELS = None
monkeypatch.setattr(Image, "MAX_IMAGE_PIXELS", None)
assert Image.MAX_IMAGE_PIXELS is None
# Act / Assert
@ -33,18 +30,18 @@ class TestDecompressionBomb:
with Image.open(TEST_FILE):
pass
def test_warning(self) -> None:
def test_warning(self, monkeypatch: pytest.MonkeyPatch) -> None:
# Set limit to trigger warning on the test file
Image.MAX_IMAGE_PIXELS = 128 * 128 - 1
monkeypatch.setattr(Image, "MAX_IMAGE_PIXELS", 128 * 128 - 1)
assert Image.MAX_IMAGE_PIXELS == 128 * 128 - 1
with pytest.warns(Image.DecompressionBombWarning):
with Image.open(TEST_FILE):
pass
def test_exception(self) -> None:
def test_exception(self, monkeypatch: pytest.MonkeyPatch) -> None:
# Set limit to trigger exception on the test file
Image.MAX_IMAGE_PIXELS = 64 * 128 - 1
monkeypatch.setattr(Image, "MAX_IMAGE_PIXELS", 64 * 128 - 1)
assert Image.MAX_IMAGE_PIXELS == 64 * 128 - 1
with pytest.raises(Image.DecompressionBombError):
@ -66,9 +63,9 @@ class TestDecompressionBomb:
with pytest.raises(Image.DecompressionBombError):
im.seek(1)
def test_exception_gif_zero_width(self) -> None:
def test_exception_gif_zero_width(self, monkeypatch: pytest.MonkeyPatch) -> None:
# Set limit to trigger exception on the test file
Image.MAX_IMAGE_PIXELS = 4 * 64 * 128
monkeypatch.setattr(Image, "MAX_IMAGE_PIXELS", 4 * 64 * 128)
assert Image.MAX_IMAGE_PIXELS == 4 * 64 * 128
with pytest.raises(Image.DecompressionBombError):

27
Tests/test_file_fli.py
View File

@ -35,22 +35,19 @@ def test_sanity() -> None:
assert im.is_animated
def test_prefix_chunk() -> None:
ImageFile.LOAD_TRUNCATED_IMAGES = True
try:
with Image.open(animated_test_file_with_prefix_chunk) as im:
assert im.mode == "P"
assert im.size == (320, 200)
assert im.format == "FLI"
assert im.info["duration"] == 171
assert im.is_animated
def test_prefix_chunk(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr(ImageFile, "LOAD_TRUNCATED_IMAGES", True)
with Image.open(animated_test_file_with_prefix_chunk) as im:
assert im.mode == "P"
assert im.size == (320, 200)
assert im.format == "FLI"
assert im.info["duration"] == 171
assert im.is_animated
palette = im.getpalette()
assert palette[3:6] == [255, 255, 255]
assert palette[381:384] == [204, 204, 12]
assert palette[765:] == [252, 0, 0]
finally:
ImageFile.LOAD_TRUNCATED_IMAGES = False
palette = im.getpalette()
assert palette[3:6] == [255, 255, 255]
assert palette[381:384] == [204, 204, 12]
assert palette[765:] == [252, 0, 0]
@pytest.mark.skipif(is_pypy(), reason="Requires CPython")

96
Tests/test_file_gif.py
View File

@ -109,7 +109,7 @@ def test_palette_not_needed_for_second_frame() -> None:
assert_image_similar(im, hopper("L").convert("RGB"), 8)
def test_strategy() -> None:
def test_strategy(monkeypatch: pytest.MonkeyPatch) -> None:
with Image.open("Tests/images/iss634.gif") as im:
expected_rgb_always = im.convert("RGB")
@ -119,35 +119,36 @@ def test_strategy() -> None:
im.seek(1)
expected_different = im.convert("RGB")
try:
GifImagePlugin.LOADING_STRATEGY = GifImagePlugin.LoadingStrategy.RGB_ALWAYS
with Image.open("Tests/images/iss634.gif") as im:
assert im.mode == "RGB"
assert_image_equal(im, expected_rgb_always)
monkeypatch.setattr(
GifImagePlugin, "LOADING_STRATEGY", GifImagePlugin.LoadingStrategy.RGB_ALWAYS
)
with Image.open("Tests/images/iss634.gif") as im:
assert im.mode == "RGB"
assert_image_equal(im, expected_rgb_always)
with Image.open("Tests/images/chi.gif") as im:
assert im.mode == "RGBA"
assert_image_equal(im, expected_rgb_always_rgba)
with Image.open("Tests/images/chi.gif") as im:
assert im.mode == "RGBA"
assert_image_equal(im, expected_rgb_always_rgba)
GifImagePlugin.LOADING_STRATEGY = (
GifImagePlugin.LoadingStrategy.RGB_AFTER_DIFFERENT_PALETTE_ONLY
)
# Stay in P mode with only a global palette
with Image.open("Tests/images/chi.gif") as im:
assert im.mode == "P"
monkeypatch.setattr(
GifImagePlugin,
"LOADING_STRATEGY",
GifImagePlugin.LoadingStrategy.RGB_AFTER_DIFFERENT_PALETTE_ONLY,
)
# Stay in P mode with only a global palette
with Image.open("Tests/images/chi.gif") as im:
assert im.mode == "P"
im.seek(1)
assert im.mode == "P"
assert_image_equal(im.convert("RGB"), expected_different)
im.seek(1)
assert im.mode == "P"
assert_image_equal(im.convert("RGB"), expected_different)
# Change to RGB mode when a frame has an individual palette
with Image.open("Tests/images/iss634.gif") as im:
assert im.mode == "P"
# Change to RGB mode when a frame has an individual palette
with Image.open("Tests/images/iss634.gif") as im:
assert im.mode == "P"
im.seek(1)
assert im.mode == "RGB"
finally:
GifImagePlugin.LOADING_STRATEGY = GifImagePlugin.LoadingStrategy.RGB_AFTER_FIRST
im.seek(1)
assert im.mode == "RGB"
def test_optimize() -> None:
@ -555,17 +556,15 @@ def test_dispose_background_transparency() -> None:
def test_transparent_dispose(
loading_strategy: GifImagePlugin.LoadingStrategy,
expected_colors: tuple[tuple[int | tuple[int, int, int, int], ...]],
monkeypatch: pytest.MonkeyPatch,
) -> None:
GifImagePlugin.LOADING_STRATEGY = loading_strategy
try:
with Image.open("Tests/images/transparent_dispose.gif") as img:
for frame in range(3):
img.seek(frame)
for x in range(3):
color = img.getpixel((x, 0))
assert color == expected_colors[frame][x]
finally:
GifImagePlugin.LOADING_STRATEGY = GifImagePlugin.LoadingStrategy.RGB_AFTER_FIRST
monkeypatch.setattr(GifImagePlugin, "LOADING_STRATEGY", loading_strategy)
with Image.open("Tests/images/transparent_dispose.gif") as img:
for frame in range(3):
img.seek(frame)
for x in range(3):
color = img.getpixel((x, 0))
assert color == expected_colors[frame][x]
def test_dispose_previous() -> None:
@ -1398,24 +1397,23 @@ def test_lzw_bits() -> None:
),
)
def test_extents(
test_file: str, loading_strategy: GifImagePlugin.LoadingStrategy
test_file: str,
loading_strategy: GifImagePlugin.LoadingStrategy,
monkeypatch: pytest.MonkeyPatch,
) -> None:
GifImagePlugin.LOADING_STRATEGY = loading_strategy
try:
with Image.open("Tests/images/" + test_file) as im:
assert im.size == (100, 100)
monkeypatch.setattr(GifImagePlugin, "LOADING_STRATEGY", loading_strategy)
with Image.open("Tests/images/" + test_file) as im:
assert im.size == (100, 100)
# Check that n_frames does not change the size
assert im.n_frames == 2
assert im.size == (100, 100)
# Check that n_frames does not change the size
assert im.n_frames == 2
assert im.size == (100, 100)
im.seek(1)
assert im.size == (150, 150)
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
im.load()
assert im.im.size == (150, 150)
def test_missing_background() -> None:

25
Tests/test_file_ico.py
View File

@ -243,26 +243,23 @@ def test_draw_reloaded(tmp_path: Path) -> None:
assert_image_equal_tofile(im, "Tests/images/hopper_draw.ico")
def test_truncated_mask() -> None:
def test_truncated_mask(monkeypatch: pytest.MonkeyPatch) -> None:
# 1 bpp
with open("Tests/images/hopper_mask.ico", "rb") as fp:
data = fp.read()
ImageFile.LOAD_TRUNCATED_IMAGES = True
monkeypatch.setattr(ImageFile, "LOAD_TRUNCATED_IMAGES", True)
data = data[:-3]
try:
with Image.open(io.BytesIO(data)) as im:
assert im.mode == "1"
with Image.open(io.BytesIO(data)) as im:
assert im.mode == "1"
# 32 bpp
output = io.BytesIO()
expected = hopper("RGBA")
expected.save(output, "ico", bitmap_format="bmp")
# 32 bpp
output = io.BytesIO()
expected = hopper("RGBA")
expected.save(output, "ico", bitmap_format="bmp")
data = output.getvalue()[:-1]
data = output.getvalue()[:-1]
with Image.open(io.BytesIO(data)) as im:
assert im.mode == "RGB"
finally:
ImageFile.LOAD_TRUNCATED_IMAGES = False
with Image.open(io.BytesIO(data)) as im:
assert im.mode == "RGB"

12
Tests/test_file_jpeg.py
View File

@ -530,12 +530,13 @@ class TestFileJpeg:
@mark_if_feature_version(
pytest.mark.valgrind_known_error, "libjpeg_turbo", "2.0", reason="Known Failing"
)
def test_truncated_jpeg_should_read_all_the_data(self) -> None:
def test_truncated_jpeg_should_read_all_the_data(
self, monkeypatch: pytest.MonkeyPatch
) -> None:
filename = "Tests/images/truncated_jpeg.jpg"
ImageFile.LOAD_TRUNCATED_IMAGES = True
monkeypatch.setattr(ImageFile, "LOAD_TRUNCATED_IMAGES", True)
with Image.open(filename) as im:
im.load()
ImageFile.LOAD_TRUNCATED_IMAGES = False
assert im.getbbox() is not None
def test_truncated_jpeg_throws_oserror(self) -> None:
@ -1024,7 +1025,7 @@ class TestFileJpeg:
im.save(f, xmp=b"1" * 65505)
@pytest.mark.timeout(timeout=1)
def test_eof(self) -> None:
def test_eof(self, monkeypatch: pytest.MonkeyPatch) -> None:
# Even though this decoder never says that it is finished
# the image should still end when there is no new data
class InfiniteMockPyDecoder(ImageFile.PyDecoder):
@ -1039,9 +1040,8 @@ class TestFileJpeg:
im.tile = [
ImageFile._Tile("INFINITE", (0, 0, 128, 128), 0, ("RGB", 0, 1)),
]
ImageFile.LOAD_TRUNCATED_IMAGES = True
monkeypatch.setattr(ImageFile, "LOAD_TRUNCATED_IMAGES", True)
im.load()
ImageFile.LOAD_TRUNCATED_IMAGES = False
def test_separate_tables(self) -> None:
im = hopper()

13
Tests/test_file_jpeg2k.py
View File

@ -181,14 +181,11 @@ def test_load_dpi() -> None:
assert "dpi" not in im.info
def test_restricted_icc_profile() -> None:
ImageFile.LOAD_TRUNCATED_IMAGES = True
try:
# JPEG2000 image with a restricted ICC profile and a known colorspace
with Image.open("Tests/images/balloon_eciRGBv2_aware.jp2") as im:
assert im.mode == "RGB"
finally:
ImageFile.LOAD_TRUNCATED_IMAGES = False
def test_restricted_icc_profile(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr(ImageFile, "LOAD_TRUNCATED_IMAGES", True)
# JPEG2000 image with a restricted ICC profile and a known colorspace
with Image.open("Tests/images/balloon_eciRGBv2_aware.jp2") as im:
assert im.mode == "RGB"
@pytest.mark.skipif(

35
Tests/test_file_libtiff.py
View File

@ -1103,13 +1103,15 @@ class TestFileLibTiff(LibTiffTestCase):
)
def test_buffering(self, test_file: str) -> None:
# load exif first
with Image.open(open(test_file, "rb", buffering=1048576)) as im:
exif = dict(im.getexif())
with open(test_file, "rb", buffering=1048576) as f:
with Image.open(f) as im:
exif = dict(im.getexif())
# load image before exif
with Image.open(open(test_file, "rb", buffering=1048576)) as im2:
im2.load()
exif_after_load = dict(im2.getexif())
with open(test_file, "rb", buffering=1048576) as f:
with Image.open(f) as im2:
im2.load()
exif_after_load = dict(im2.getexif())
assert exif == exif_after_load
@ -1156,23 +1158,22 @@ class TestFileLibTiff(LibTiffTestCase):
assert len(im.tag_v2[STRIPOFFSETS]) > 1
@pytest.mark.parametrize("argument", (True, False))
def test_save_single_strip(self, argument: bool, tmp_path: Path) -> None:
def test_save_single_strip(
self, argument: bool, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
im = hopper("RGB").resize((256, 256))
out = str(tmp_path / "temp.tif")
if not argument:
TiffImagePlugin.STRIP_SIZE = 2**18
try:
arguments: dict[str, str | int] = {"compression": "tiff_adobe_deflate"}
if argument:
arguments["strip_size"] = 2**18
im.save(out, "TIFF", **arguments)
monkeypatch.setattr(TiffImagePlugin, "STRIP_SIZE", 2**18)
arguments: dict[str, str | int] = {"compression": "tiff_adobe_deflate"}
if argument:
arguments["strip_size"] = 2**18
im.save(out, "TIFF", **arguments)
with Image.open(out) as im:
assert isinstance(im, TiffImagePlugin.TiffImageFile)
assert len(im.tag_v2[STRIPOFFSETS]) == 1
finally:
TiffImagePlugin.STRIP_SIZE = 65536
with Image.open(out) as im:
assert isinstance(im, TiffImagePlugin.TiffImageFile)
assert len(im.tag_v2[STRIPOFFSETS]) == 1
@pytest.mark.parametrize("compression", ("tiff_adobe_deflate", None))
def test_save_zero(self, compression: str | None, tmp_path: Path) -> None:

64
Tests/test_file_png.py
View File

@ -363,7 +363,7 @@ class TestFilePng:
with pytest.raises((OSError, SyntaxError)):
im.verify()
def test_verify_ignores_crc_error(self) -> None:
def test_verify_ignores_crc_error(self, monkeypatch: pytest.MonkeyPatch) -> None:
# check ignores crc errors in ancillary chunks
chunk_data = chunk(b"tEXt", b"spam")
@ -373,24 +373,20 @@ class TestFilePng:
with pytest.raises(SyntaxError):
PngImagePlugin.PngImageFile(BytesIO(image_data))
ImageFile.LOAD_TRUNCATED_IMAGES = True
try:
im = load(image_data)
assert im is not None
finally:
ImageFile.LOAD_TRUNCATED_IMAGES = False
monkeypatch.setattr(ImageFile, "LOAD_TRUNCATED_IMAGES", True)
im = load(image_data)
assert im is not None
def test_verify_not_ignores_crc_error_in_required_chunk(self) -> None:
def test_verify_not_ignores_crc_error_in_required_chunk(
self, monkeypatch: pytest.MonkeyPatch
) -> None:
# check does not ignore crc errors in required chunks
image_data = MAGIC + IHDR[:-1] + b"q" + TAIL
ImageFile.LOAD_TRUNCATED_IMAGES = True
try:
with pytest.raises(SyntaxError):
PngImagePlugin.PngImageFile(BytesIO(image_data))
finally:
ImageFile.LOAD_TRUNCATED_IMAGES = False
monkeypatch.setattr(ImageFile, "LOAD_TRUNCATED_IMAGES", True)
with pytest.raises(SyntaxError):
PngImagePlugin.PngImageFile(BytesIO(image_data))
def test_roundtrip_dpi(self) -> None:
# Check dpi roundtripping
@ -600,7 +596,7 @@ class TestFilePng:
(b"prIV", b"VALUE3", True),
]
def test_textual_chunks_after_idat(self) -> None:
def test_textual_chunks_after_idat(self, monkeypatch: pytest.MonkeyPatch) -> None:
with Image.open("Tests/images/hopper.png") as im:
assert "comment" in im.text
for k, v in {
@ -614,18 +610,17 @@ class TestFilePng:
with pytest.raises(OSError):
assert isinstance(im.text, dict)
# Raises an EOFError in load_end
with Image.open("Tests/images/hopper_idat_after_image_end.png") as im:
assert im.text == {"TXT": "VALUE", "ZIP": "VALUE"}
# Raises a UnicodeDecodeError in load_end
with Image.open("Tests/images/truncated_image.png") as im:
# The file is truncated
with pytest.raises(OSError):
im.text
ImageFile.LOAD_TRUNCATED_IMAGES = True
monkeypatch.setattr(ImageFile, "LOAD_TRUNCATED_IMAGES", True)
assert isinstance(im.text, dict)
ImageFile.LOAD_TRUNCATED_IMAGES = False
# Raises an EOFError in load_end
with Image.open("Tests/images/hopper_idat_after_image_end.png") as im:
assert im.text == {"TXT": "VALUE", "ZIP": "VALUE"}
def test_unknown_compression_method(self) -> None:
with pytest.raises(SyntaxError, match="Unknown compression method"):
@ -651,15 +646,16 @@ class TestFilePng:
@pytest.mark.parametrize(
"cid", (b"IHDR", b"sRGB", b"pHYs", b"acTL", b"fcTL", b"fdAT")
)
def test_truncated_chunks(self, cid: bytes) -> None:
def test_truncated_chunks(
self, cid: bytes, monkeypatch: pytest.MonkeyPatch
) -> None:
fp = BytesIO()
with PngImagePlugin.PngStream(fp) as png:
with pytest.raises(ValueError):
png.call(cid, 0, 0)
ImageFile.LOAD_TRUNCATED_IMAGES = True
monkeypatch.setattr(ImageFile, "LOAD_TRUNCATED_IMAGES", True)
png.call(cid, 0, 0)
ImageFile.LOAD_TRUNCATED_IMAGES = False
@pytest.mark.parametrize("save_all", (True, False))
def test_specify_bits(self, save_all: bool, tmp_path: Path) -> None:
@ -789,17 +785,14 @@ class TestFilePng:
with Image.open(mystdout) as reloaded:
assert_image_equal_tofile(reloaded, TEST_PNG_FILE)
def test_truncated_end_chunk(self) -> None:
def test_truncated_end_chunk(self, monkeypatch: pytest.MonkeyPatch) -> None:
with Image.open("Tests/images/truncated_end_chunk.png") as im:
with pytest.raises(OSError):
im.load()
ImageFile.LOAD_TRUNCATED_IMAGES = True
try:
with Image.open("Tests/images/truncated_end_chunk.png") as im:
assert_image_equal_tofile(im, "Tests/images/hopper.png")
finally:
ImageFile.LOAD_TRUNCATED_IMAGES = False
monkeypatch.setattr(ImageFile, "LOAD_TRUNCATED_IMAGES", True)
with Image.open("Tests/images/truncated_end_chunk.png") as im:
assert_image_equal_tofile(im, "Tests/images/hopper.png")
@pytest.mark.skipif(is_win32(), reason="Requires Unix or macOS")
@ -808,11 +801,11 @@ class TestTruncatedPngPLeaks(PillowLeakTestCase):
mem_limit = 2 * 1024 # max increase in K
iterations = 100 # Leak is 56k/iteration, this will leak 5.6megs
def test_leak_load(self) -> None:
def test_leak_load(self, monkeypatch: pytest.MonkeyPatch) -> None:
with open("Tests/images/hopper.png", "rb") as f:
DATA = BytesIO(f.read(16 * 1024))
ImageFile.LOAD_TRUNCATED_IMAGES = True
monkeypatch.setattr(ImageFile, "LOAD_TRUNCATED_IMAGES", True)
with Image.open(DATA) as im:
im.load()
@ -820,7 +813,4 @@ class TestTruncatedPngPLeaks(PillowLeakTestCase):
with Image.open(DATA) as im:
im.load()
try:
self._test_leak(core)
finally:
ImageFile.LOAD_TRUNCATED_IMAGES = False
self._test_leak(core)

5
Tests/test_file_tiff.py
View File

@ -939,11 +939,10 @@ class TestFileTiff:
@pytest.mark.timeout(6)
@pytest.mark.filterwarnings("ignore:Truncated File Read")
def test_timeout(self) -> None:
def test_timeout(self, monkeypatch: pytest.MonkeyPatch) -> None:
with Image.open("Tests/images/timeout-6646305047838720") as im:
ImageFile.LOAD_TRUNCATED_IMAGES = True
monkeypatch.setattr(ImageFile, "LOAD_TRUNCATED_IMAGES", True)
im.load()
ImageFile.LOAD_TRUNCATED_IMAGES = False
@pytest.mark.parametrize(
"test_file",

7
Tests/test_file_webp.py
View File

@ -28,9 +28,9 @@ except ImportError:
class TestUnsupportedWebp:
def test_unsupported(self) -> None:
def test_unsupported(self, monkeypatch: pytest.MonkeyPatch) -> None:
if HAVE_WEBP:
WebPImagePlugin.SUPPORTED = False
monkeypatch.setattr(WebPImagePlugin, "SUPPORTED", False)
file_path = "Tests/images/hopper.webp"
with pytest.warns(UserWarning):
@ -38,9 +38,6 @@ class TestUnsupportedWebp:
with Image.open(file_path):
pass
if HAVE_WEBP:
WebPImagePlugin.SUPPORTED = True
@skip_unless_feature("webp")
class TestFileWebp:

22
Tests/test_imagedraw.py
View File

@ -1396,6 +1396,28 @@ def test_stroke_descender() -> None:
assert_image_similar_tofile(im, "Tests/images/imagedraw_stroke_descender.png", 6.76)
@skip_unless_feature("freetype2")
def test_stroke_inside_gap() -> None:
# Arrange
im = Image.new("RGB", (120, 130))
draw = ImageDraw.Draw(im)
font = ImageFont.truetype("Tests/fonts/FreeMono.ttf", 120)
# Act
draw.text((12, 12), "i", "#f00", font, stroke_width=20)
# Assert
for y in range(im.height):
glyph = ""
for x in range(im.width):
if im.getpixel((x, y)) == (0, 0, 0):
if glyph == "started":
glyph = "ended"
else:
assert glyph != "ended", "Gap inside stroked glyph"
glyph = "started"
@skip_unless_feature("freetype2")
def test_split_word() -> None:
# Arrange

20
Tests/test_imagefile.py
View File

@ -191,13 +191,10 @@ class TestImageFile:
im.load()
@skip_unless_feature("zlib")
def test_truncated_without_errors(self) -> None:
def test_truncated_without_errors(self, monkeypatch: pytest.MonkeyPatch) -> None:
with Image.open("Tests/images/truncated_image.png") as im:
ImageFile.LOAD_TRUNCATED_IMAGES = True
try:
im.load()
finally:
ImageFile.LOAD_TRUNCATED_IMAGES = False
monkeypatch.setattr(ImageFile, "LOAD_TRUNCATED_IMAGES", True)
im.load()
@skip_unless_feature("zlib")
def test_broken_datastream_with_errors(self) -> None:
@ -206,13 +203,12 @@ class TestImageFile:
im.load()
@skip_unless_feature("zlib")
def test_broken_datastream_without_errors(self) -> None:
def test_broken_datastream_without_errors(
self, monkeypatch: pytest.MonkeyPatch
) -> None:
with Image.open("Tests/images/broken_data_stream.png") as im:
ImageFile.LOAD_TRUNCATED_IMAGES = True
try:
im.load()
finally:
ImageFile.LOAD_TRUNCATED_IMAGES = False
monkeypatch.setattr(ImageFile, "LOAD_TRUNCATED_IMAGES", True)
im.load()
class MockPyDecoder(ImageFile.PyDecoder):

14
Tests/test_imagefont.py
View File

@ -461,6 +461,20 @@ def test_free_type_font_get_mask(font: ImageFont.FreeTypeFont) -> None:
assert mask.size == (108, 13)
def test_stroke_mask() -> None:
# Arrange
text = "i"
# Act
font = ImageFont.truetype(FONT_PATH, 128)
mask = font.getmask(text, stroke_width=2)
# Assert
assert mask.getpixel((34, 5)) == 255
assert mask.getpixel((38, 5)) == 0
assert mask.getpixel((42, 5)) == 255
def test_load_when_image_not_found() -> None:
with tempfile.NamedTemporaryFile(delete=False) as tmp:
pass

14
Tests/test_map.py
View File

@ -7,36 +7,30 @@ import pytest
from PIL import Image
def test_overflow() -> None:
def test_overflow(monkeypatch: pytest.MonkeyPatch) -> None:
# There is the potential to overflow comparisons in map.c
# if there are > SIZE_MAX bytes in the image or if
# the file encodes an offset that makes
# (offset + size(bytes)) > SIZE_MAX
# Note that this image triggers the decompression bomb warning:
max_pixels = Image.MAX_IMAGE_PIXELS
Image.MAX_IMAGE_PIXELS = None
monkeypatch.setattr(Image, "MAX_IMAGE_PIXELS", None)
# This image hits the offset test.
with Image.open("Tests/images/l2rgb_read.bmp") as im:
with pytest.raises((ValueError, MemoryError, OSError)):
im.load()
Image.MAX_IMAGE_PIXELS = max_pixels
def test_tobytes() -> None:
def test_tobytes(monkeypatch: pytest.MonkeyPatch) -> None:
# Note that this image triggers the decompression bomb warning:
max_pixels = Image.MAX_IMAGE_PIXELS
Image.MAX_IMAGE_PIXELS = None
monkeypatch.setattr(Image, "MAX_IMAGE_PIXELS", None)
# Previously raised an access violation on Windows
with Image.open("Tests/images/l2rgb_read.bmp") as im:
with pytest.raises((ValueError, MemoryError, OSError)):
im.tobytes()
Image.MAX_IMAGE_PIXELS = max_pixels
@pytest.mark.skipif(sys.maxsize <= 2**32, reason="Requires 64-bit system")
def test_ysize() -> None:

4
src/PIL/ImageDraw.py
View File

@ -645,6 +645,7 @@ class ImageDraw:
features=features,
language=language,
stroke_width=stroke_width,
stroke_filled=True,
anchor=anchor,
ink=ink,
start=start,
@ -694,7 +695,8 @@ class ImageDraw:
draw_text(stroke_ink, stroke_width)
# Draw normal text
draw_text(ink, 0)
if ink != stroke_ink:
draw_text(ink)
else:
# Only draw normal text
draw_text(ink)

1
src/PIL/ImageFont.py
View File

@ -673,6 +673,7 @@ class FreeTypeFont:
features,
language,
stroke_width,
kwargs.get("stroke_filled", False),
anchor,
ink,
start[0],

2
src/PIL/PngImagePlugin.py
View File

@ -1382,7 +1382,7 @@ def _save(
b"\0", # 12: interlace flag
)
chunks = [b"cHRM", b"gAMA", b"sBIT", b"sRGB", b"tIME"]
chunks = [b"cHRM", b"cICP", b"gAMA", b"sBIT", b"sRGB", b"tIME"]
icc = im.encoderinfo.get("icc_profile", im.info.get("icc_profile"))
if icc:

1
src/PIL/_imagingft.pyi
View File

@ -28,6 +28,7 @@ class Font:
features: list[str] | None,
lang: str | None,
stroke_width: float,
stroke_filled: bool,
anchor: ImageFont.Anchor | None,
foreground_ink_long: int,
x_start: float,

93
src/_imaging.c
View File

@ -473,8 +473,7 @@ getpixel(Imaging im, ImagingAccess access, int x, int y) {
}
/* unknown type */
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static char *
@ -965,8 +964,7 @@ _convert2(ImagingObject *self, PyObject *args) {
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -1214,8 +1212,7 @@ _getpixel(ImagingObject *self, PyObject *args) {
}
if (self->access == NULL) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
return getpixel(self->image, self->access, x, y);
@ -1417,8 +1414,7 @@ _paste(ImagingObject *self, PyObject *args) {
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -1691,8 +1687,7 @@ _putdata(ImagingObject *self, PyObject *args) {
Py_XDECREF(seq);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -1752,8 +1747,7 @@ _putpalette(ImagingObject *self, PyObject *args) {
self->image->palette->size = palettesize * 8 / bits;
unpack(self->image->palette->palette, palette, self->image->palette->size);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -1777,8 +1771,7 @@ _putpalettealpha(ImagingObject *self, PyObject *args) {
strcpy(self->image->palette->mode, "RGBA");
self->image->palette->palette[index * 4 + 3] = (UINT8)alpha;
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -1805,8 +1798,7 @@ _putpalettealphas(ImagingObject *self, PyObject *args) {
self->image->palette->palette[i * 4 + 3] = (UINT8)values[i];
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -1842,8 +1834,7 @@ _putpixel(ImagingObject *self, PyObject *args) {
self->access->put_pixel(im, x, y, ink);
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -2010,8 +2001,7 @@ im_setmode(ImagingObject *self, PyObject *args) {
}
self->access = ImagingAccessNew(im);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -2074,8 +2064,7 @@ _transform(ImagingObject *self, PyObject *args) {
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -2202,8 +2191,7 @@ _getbbox(ImagingObject *self, PyObject *args) {
}
if (!ImagingGetBBox(self->image, bbox, alpha_only)) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
return Py_BuildValue("iiii", bbox[0], bbox[1], bbox[2], bbox[3]);
@ -2283,8 +2271,7 @@ _getextrema(ImagingObject *self) {
}
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -2347,8 +2334,7 @@ _fillband(ImagingObject *self, PyObject *args) {
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -2363,8 +2349,7 @@ _putband(ImagingObject *self, PyObject *args) {
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -2950,8 +2935,7 @@ _draw_arc(ImagingDrawObject *self, PyObject *args) {
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -2988,8 +2972,7 @@ _draw_bitmap(ImagingDrawObject *self, PyObject *args) {
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -3045,8 +3028,7 @@ _draw_chord(ImagingDrawObject *self, PyObject *args) {
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -3100,8 +3082,7 @@ _draw_ellipse(ImagingDrawObject *self, PyObject *args) {
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -3164,8 +3145,7 @@ _draw_lines(ImagingDrawObject *self, PyObject *args) {
free(xy);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -3196,8 +3176,7 @@ _draw_points(ImagingDrawObject *self, PyObject *args) {
free(xy);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
/* from outline.c */
@ -3225,8 +3204,7 @@ _draw_outline(ImagingDrawObject *self, PyObject *args) {
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -3282,8 +3260,7 @@ _draw_pieslice(ImagingDrawObject *self, PyObject *args) {
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -3334,8 +3311,7 @@ _draw_polygon(ImagingDrawObject *self, PyObject *args) {
free(ixy);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -3389,8 +3365,7 @@ _draw_rectangle(ImagingDrawObject *self, PyObject *args) {
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static struct PyMethodDef _draw_methods[] = {
@ -3595,8 +3570,7 @@ _save_ppm(ImagingObject *self, PyObject *args) {
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
/* -------------------------------------------------------------------- */
@ -3984,8 +3958,7 @@ _reset_stats(PyObject *self, PyObject *args) {
arena->stats_freed_blocks = 0;
MUTEX_UNLOCK(&ImagingDefaultArena.mutex);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -4045,8 +4018,7 @@ _set_alignment(PyObject *self, PyObject *args) {
ImagingDefaultArena.alignment = alignment;
MUTEX_UNLOCK(&ImagingDefaultArena.mutex);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -4070,8 +4042,7 @@ _set_block_size(PyObject *self, PyObject *args) {
ImagingDefaultArena.block_size = block_size;
MUTEX_UNLOCK(&ImagingDefaultArena.mutex);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -4099,8 +4070,7 @@ _set_blocks_max(PyObject *self, PyObject *args) {
return ImagingError_MemoryError();
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -4115,8 +4085,7 @@ _clear_cache(PyObject *self, PyObject *args) {
ImagingMemoryClearCache(&ImagingDefaultArena, i);
MUTEX_UNLOCK(&ImagingDefaultArena.mutex);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
/* -------------------------------------------------------------------- */

90
src/_imagingcms.c
View File

@ -654,8 +654,7 @@ cms_get_display_profile_win32(PyObject *self, PyObject *args) {
return PyUnicode_FromStringAndSize(filename, filename_size - 1);
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
#endif
@ -672,20 +671,17 @@ _profile_read_mlu(CmsProfileObject *self, cmsTagSignature info) {
wchar_t *buf;
if (!cmsIsTag(self->profile, info)) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
mlu = cmsReadTag(self->profile, info);
if (!mlu) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
len = cmsMLUgetWide(mlu, lc, cc, NULL, 0);
if (len == 0) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
buf = malloc(len);
@ -723,14 +719,12 @@ _profile_read_signature(CmsProfileObject *self, cmsTagSignature info) {
unsigned int *sig;
if (!cmsIsTag(self->profile, info)) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
sig = (unsigned int *)cmsReadTag(self->profile, info);
if (!sig) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
return _profile_read_int_as_string(*sig);
@ -780,14 +774,12 @@ _profile_read_ciexyz(CmsProfileObject *self, cmsTagSignature info, int multi) {
cmsCIEXYZ *XYZ;
if (!cmsIsTag(self->profile, info)) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
XYZ = (cmsCIEXYZ *)cmsReadTag(self->profile, info);
if (!XYZ) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
if (multi) {
return _xyz3_py(XYZ);
@ -801,14 +793,12 @@ _profile_read_ciexyy_triple(CmsProfileObject *self, cmsTagSignature info) {
cmsCIExyYTRIPLE *triple;
if (!cmsIsTag(self->profile, info)) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
triple = (cmsCIExyYTRIPLE *)cmsReadTag(self->profile, info);
if (!triple) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
/* Note: lcms does all the heavy lifting and error checking (nr of
@ -835,21 +825,18 @@ _profile_read_named_color_list(CmsProfileObject *self, cmsTagSignature info) {
PyObject *result;
if (!cmsIsTag(self->profile, info)) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
ncl = (cmsNAMEDCOLORLIST *)cmsReadTag(self->profile, info);
if (ncl == NULL) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
n = cmsNamedColorCount(ncl);
result = PyList_New(n);
if (!result) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
for (i = 0; i < n; i++) {
@ -858,8 +845,7 @@ _profile_read_named_color_list(CmsProfileObject *self, cmsTagSignature info) {
str = PyUnicode_FromString(name);
if (str == NULL) {
Py_DECREF(result);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
PyList_SET_ITEM(result, i, str);
}
@ -926,8 +912,7 @@ _is_intent_supported(CmsProfileObject *self, int clut) {
result = PyDict_New();
if (result == NULL) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
n = cmsGetSupportedIntents(INTENTS, intent_ids, intent_descs);
@ -957,8 +942,7 @@ _is_intent_supported(CmsProfileObject *self, int clut) {
Py_XDECREF(id);
Py_XDECREF(entry);
Py_XDECREF(result);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
PyDict_SetItem(result, id, entry);
Py_DECREF(id);
@ -1042,8 +1026,7 @@ cms_profile_getattr_creation_date(CmsProfileObject *self, void *closure) {
result = cmsGetHeaderCreationDateTime(self->profile, &ct);
if (!result) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
return PyDateTime_FromDateAndTime(
@ -1141,8 +1124,7 @@ cms_profile_getattr_saturation_rendering_intent_gamut(
static PyObject *
cms_profile_getattr_red_colorant(CmsProfileObject *self, void *closure) {
if (!cmsIsMatrixShaper(self->profile)) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
return _profile_read_ciexyz(self, cmsSigRedColorantTag, 0);
}
@ -1150,8 +1132,7 @@ cms_profile_getattr_red_colorant(CmsProfileObject *self, void *closure) {
static PyObject *
cms_profile_getattr_green_colorant(CmsProfileObject *self, void *closure) {
if (!cmsIsMatrixShaper(self->profile)) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
return _profile_read_ciexyz(self, cmsSigGreenColorantTag, 0);
}
@ -1159,8 +1140,7 @@ cms_profile_getattr_green_colorant(CmsProfileObject *self, void *closure) {
static PyObject *
cms_profile_getattr_blue_colorant(CmsProfileObject *self, void *closure) {
if (!cmsIsMatrixShaper(self->profile)) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
return _profile_read_ciexyz(self, cmsSigBlueColorantTag, 0);
}
@ -1176,21 +1156,18 @@ cms_profile_getattr_media_white_point_temperature(
cmsBool result;
if (!cmsIsTag(self->profile, info)) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
XYZ = (cmsCIEXYZ *)cmsReadTag(self->profile, info);
if (XYZ == NULL || XYZ->X == 0) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
cmsXYZ2xyY(&xyY, XYZ);
result = cmsTempFromWhitePoint(&tempK, &xyY);
if (!result) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
return PyFloat_FromDouble(tempK);
}
@ -1229,8 +1206,7 @@ cms_profile_getattr_red_primary(CmsProfileObject *self, void *closure) {
result = _calculate_rgb_primaries(self, &primaries);
}
if (!result) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
return _xyz_py(&primaries.Red);
@ -1245,8 +1221,7 @@ cms_profile_getattr_green_primary(CmsProfileObject *self, void *closure) {
result = _calculate_rgb_primaries(self, &primaries);
}
if (!result) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
return _xyz_py(&primaries.Green);
@ -1261,8 +1236,7 @@ cms_profile_getattr_blue_primary(CmsProfileObject *self, void *closure) {
result = _calculate_rgb_primaries(self, &primaries);
}
if (!result) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
return _xyz_py(&primaries.Blue);
@ -1321,14 +1295,12 @@ cms_profile_getattr_icc_measurement_condition(CmsProfileObject *self, void *clos
const char *geo;
if (!cmsIsTag(self->profile, info)) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
mc = (cmsICCMeasurementConditions *)cmsReadTag(self->profile, info);
if (!mc) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
if (mc->Geometry == 1) {
@ -1362,14 +1334,12 @@ cms_profile_getattr_icc_viewing_condition(CmsProfileObject *self, void *closure)
cmsTagSignature info = cmsSigViewingConditionsTag;
if (!cmsIsTag(self->profile, info)) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
vc = (cmsICCViewingConditions *)cmsReadTag(self->profile, info);
if (!vc) {
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
return Py_BuildValue(

13
src/_imagingft.c
View File

@ -834,6 +834,7 @@ font_render(FontObject *self, PyObject *args) {
int mask = 0; /* is FT_LOAD_TARGET_MONO enabled? */
int color = 0; /* is FT_LOAD_COLOR enabled? */
float stroke_width = 0;
int stroke_filled = 0;
PY_LONG_LONG foreground_ink_long = 0;
unsigned int foreground_ink;
const char *mode = NULL;
@ -853,7 +854,7 @@ font_render(FontObject *self, PyObject *args) {
if (!PyArg_ParseTuple(
args,
"OO|zzOzfzLffO:render",
"OO|zzOzfpzLffO:render",
&string,
&fill,
&mode,
@ -861,6 +862,7 @@ font_render(FontObject *self, PyObject *args) {
&features,
&lang,
&stroke_width,
&stroke_filled,
&anchor,
&foreground_ink_long,
&x_start,
@ -1005,7 +1007,8 @@ font_render(FontObject *self, PyObject *args) {
if (stroker != NULL) {
error = FT_Get_Glyph(glyph_slot, &glyph);
if (!error) {
error = FT_Glyph_Stroke(&glyph, stroker, 1);
error = stroke_filled ? FT_Glyph_StrokeBorder(&glyph, stroker, 0, 1)
: FT_Glyph_Stroke(&glyph, stroker, 1);
}
if (!error) {
FT_Vector origin = {0, 0};
@ -1371,8 +1374,7 @@ font_setvarname(FontObject *self, PyObject *args) {
return geterror(error);
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -1426,8 +1428,7 @@ font_setvaraxes(FontObject *self, PyObject *args) {
return geterror(error);
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
#endif

6
src/_imagingmath.c
View File

@ -192,8 +192,7 @@ _unop(PyObject *self, PyObject *args) {
unop(out, im1);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -226,8 +225,7 @@ _binop(PyObject *self, PyObject *args) {
binop(out, im1, im2);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyMethodDef _functions[] = {

3
src/_imagingtk.c
View File

@ -37,8 +37,7 @@ _tkinit(PyObject *self, PyObject *args) {
/* This will bomb if interp is invalid... */
TkImaging_Init(interp);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyMethodDef functions[] = {

6
src/decode.c
View File

@ -213,8 +213,7 @@ _setimage(ImagingDecoderObject *decoder, PyObject *args) {
Py_XDECREF(decoder->lock);
decoder->lock = op;
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -231,8 +230,7 @@ _setfd(ImagingDecoderObject *decoder, PyObject *args) {
Py_XINCREF(fd);
state->fd = fd;
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *

18
src/display.c
View File

@ -85,8 +85,7 @@ _expose(ImagingDisplayObject *display, PyObject *args) {
ImagingExposeDIB(display->dib, hdc);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -112,8 +111,7 @@ _draw(ImagingDisplayObject *display, PyObject *args) {
ImagingDrawDIB(display->dib, hdc, dst, src);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
extern Imaging
@ -143,8 +141,7 @@ _paste(ImagingDisplayObject *display, PyObject *args) {
ImagingPasteDIB(display->dib, im, xy);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -190,8 +187,7 @@ _releasedc(ImagingDisplayObject *display, PyObject *args) {
ReleaseDC(window, dc);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -211,8 +207,7 @@ _frombytes(ImagingDisplayObject *display, PyObject *args) {
memcpy(display->dib->bits, buffer.buf, buffer.len);
PyBuffer_Release(&buffer);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -709,8 +704,7 @@ PyImaging_EventLoopWin32(PyObject *self, PyObject *args) {
}
Py_END_ALLOW_THREADS;
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
/* -------------------------------------------------------------------- */

6
src/encode.c
View File

@ -278,8 +278,7 @@ _setimage(ImagingEncoderObject *encoder, PyObject *args) {
Py_XDECREF(encoder->lock);
encoder->lock = op;
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -296,8 +295,7 @@ _setfd(ImagingEncoderObject *encoder, PyObject *args) {
Py_XINCREF(fd);
state->fd = fd;
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *

72
src/libImaging/Except.c
View File

@ -1,72 +0,0 @@
/*
* The Python Imaging Library
* $Id$
*
* default exception handling
*
* This module is usually overridden by application code (e.g.
* _imaging.c for PIL's standard Python bindings). If you get
* linking errors, remove this file from your project/library.
*
* history:
* 1995-06-15 fl Created
* 1998-12-29 fl Minor tweaks
* 2003-09-13 fl Added ImagingEnter/LeaveSection()
*
* Copyright (c) 1997-2003 by Secret Labs AB.
* Copyright (c) 1995-2003 by Fredrik Lundh.
*
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
/* exception state */
void *
ImagingError_OSError(void) {
fprintf(stderr, "*** exception: file access error\n");
return NULL;
}
void *
ImagingError_MemoryError(void) {
fprintf(stderr, "*** exception: out of memory\n");
return NULL;
}
void *
ImagingError_ModeError(void) {
return ImagingError_ValueError("bad image mode");
}
void *
ImagingError_Mismatch(void) {
return ImagingError_ValueError("images don't match");
}
void *
ImagingError_ValueError(const char *message) {
if (!message) {
message = "exception: bad argument to function";
}
fprintf(stderr, "*** %s\n", message);
return NULL;
}
void
ImagingError_Clear(void) {
/* nop */;
}
/* thread state */
void
ImagingSectionEnter(ImagingSectionCookie *cookie) {
/* pass */
}
void
ImagingSectionLeave(ImagingSectionCookie *cookie) {
/* pass */
}

4
src/libImaging/Imaging.h
View File

@ -609,10 +609,6 @@ ImagingLibTiffDecode(
extern int
ImagingLibTiffEncode(Imaging im, ImagingCodecState state, UINT8 *buffer, int bytes);
#endif
#ifdef HAVE_LIBMPEG
extern int
ImagingMpegDecode(Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
#endif
extern int
ImagingMspDecode(Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
extern int

15
src/outline.c
View File

@ -89,8 +89,7 @@ _outline_move(OutlineObject *self, PyObject *args) {
ImagingOutlineMove(self->outline, x0, y0);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -102,8 +101,7 @@ _outline_line(OutlineObject *self, PyObject *args) {
ImagingOutlineLine(self->outline, x1, y1);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -115,8 +113,7 @@ _outline_curve(OutlineObject *self, PyObject *args) {
ImagingOutlineCurve(self->outline, x1, y1, x2, y2, x3, y3);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -127,8 +124,7 @@ _outline_close(OutlineObject *self, PyObject *args) {
ImagingOutlineClose(self->outline);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static PyObject *
@ -140,8 +136,7 @@ _outline_transform(OutlineObject *self, PyObject *args) {
ImagingOutlineTransform(self->outline, a);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static struct PyMethodDef _outline_methods[] = {

6
src/path.c
View File

@ -415,8 +415,7 @@ path_map(PyPathObject *self, PyObject *args) {
}
self->mapping = 0;
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static int
@ -528,8 +527,7 @@ path_transform(PyPathObject *self, PyObject *args) {
}
}
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
static struct PyMethodDef methods[] = {