Pillow/Tests/test_imagefile.py

332 lines
9.8 KiB
Python
Raw Normal View History

2014-06-10 13:10:47 +04:00
from io import BytesIO
import pytest
from PIL import EpsImagePlugin, Image, ImageFile, features
from .helper import (
PillowTestCase,
assert_image,
assert_image_equal,
assert_image_similar,
fromstring,
hopper,
skip_unless_feature,
tostring,
)
# save original block sizes
MAXBLOCK = ImageFile.MAXBLOCK
SAFEBLOCK = ImageFile.SAFEBLOCK
class TestImageFile(PillowTestCase):
2014-06-10 13:10:47 +04:00
def test_parser(self):
def roundtrip(format):
im = hopper("L").resize((1000, 1000), Image.NEAREST)
2014-06-10 13:10:47 +04:00
if format in ("MSP", "XBM"):
im = im.convert("1")
2015-04-24 11:24:52 +03:00
test_file = BytesIO()
2014-06-10 13:10:47 +04:00
im.copy().save(test_file, format)
2014-06-10 13:10:47 +04:00
2015-04-24 11:24:52 +03:00
data = test_file.getvalue()
2014-06-10 13:10:47 +04:00
parser = ImageFile.Parser()
parser.feed(data)
imOut = parser.close()
2014-06-10 13:10:47 +04:00
return im, imOut
assert_image_equal(*roundtrip("BMP"))
im1, im2 = roundtrip("GIF")
assert_image_similar(im1.convert("P"), im2, 1)
assert_image_equal(*roundtrip("IM"))
assert_image_equal(*roundtrip("MSP"))
if features.check("zlib"):
2014-06-10 13:10:47 +04:00
try:
# force multiple blocks in PNG driver
ImageFile.MAXBLOCK = 8192
assert_image_equal(*roundtrip("PNG"))
2014-06-10 13:10:47 +04:00
finally:
ImageFile.MAXBLOCK = MAXBLOCK
assert_image_equal(*roundtrip("PPM"))
assert_image_equal(*roundtrip("TIFF"))
assert_image_equal(*roundtrip("XBM"))
assert_image_equal(*roundtrip("TGA"))
assert_image_equal(*roundtrip("PCX"))
2014-06-10 13:10:47 +04:00
if EpsImagePlugin.has_ghostscript():
im1, im2 = roundtrip("EPS")
2014-09-30 09:14:26 +04:00
# This test fails on Ubuntu 12.04, PPC (Bigendian) It
# appears to be a ghostscript 9.05 bug, since the
# ghostscript rendering is wonky and the file is identical
2015-04-24 02:26:52 +03:00
# to that written on ubuntu 12.04 x64
2014-09-30 09:14:26 +04:00
# md5sum: ba974835ff2d6f3f2fd0053a23521d4a
2014-06-10 13:10:47 +04:00
# EPS comes back in RGB:
assert_image_similar(im1, im2.convert("L"), 20)
if features.check("jpg"):
2014-06-10 13:10:47 +04:00
im1, im2 = roundtrip("JPEG") # lossy compression
assert_image(im1, im2.mode, im2.size)
with pytest.raises(IOError):
roundtrip("PDF")
2014-06-10 13:10:47 +04:00
def test_ico(self):
2019-06-13 18:54:46 +03:00
with open("Tests/images/python.ico", "rb") as f:
2014-06-10 13:10:47 +04:00
data = f.read()
2017-10-07 15:18:23 +03:00
with ImageFile.Parser() as p:
p.feed(data)
assert (48, 48) == p.image.size
2014-06-10 13:10:47 +04:00
@skip_unless_feature("zlib")
2014-06-10 13:10:47 +04:00
def test_safeblock(self):
im1 = hopper()
try:
2014-06-10 13:10:47 +04:00
ImageFile.SAFEBLOCK = 1
im2 = fromstring(tostring(im1, "PNG"))
finally:
2014-06-10 13:10:47 +04:00
ImageFile.SAFEBLOCK = SAFEBLOCK
assert_image_equal(im1, im2)
2014-06-10 13:10:47 +04:00
2015-07-03 08:03:25 +03:00
def test_raise_ioerror(self):
with pytest.raises(IOError):
ImageFile.raise_ioerror(1)
2015-07-03 08:03:25 +03:00
2017-05-13 19:07:05 +03:00
def test_raise_typeerror(self):
with pytest.raises(TypeError):
2017-05-13 19:07:05 +03:00
parser = ImageFile.Parser()
parser.feed(1)
2019-09-29 07:16:30 +03:00
def test_negative_stride(self):
with open("Tests/images/raw_negative_stride.bin", "rb") as f:
input = f.read()
p = ImageFile.Parser()
p.feed(input)
with pytest.raises(IOError):
2019-09-29 07:16:30 +03:00
p.close()
@skip_unless_feature("zlib")
def test_truncated_with_errors(self):
Improve handling of file resources Follow Python's file object semantics. User code is responsible for closing resources (usually through a context manager) in a deterministic way. To achieve this, remove __del__ functions. These functions used to closed open file handlers in an attempt to silence Python ResourceWarnings. However, using __del__ has the following drawbacks: - __del__ isn't called until the object's reference count reaches 0. Therefore, resource handlers remain open or in use longer than necessary. - The __del__ method isn't guaranteed to execute on system exit. See the Python documentation: https://docs.python.org/3/reference/datamodel.html#object.__del__ > It is not guaranteed that __del__() methods are called for objects > that still exist when the interpreter exits. - Exceptions that occur inside __del__ are ignored instead of raised. This has the potential of hiding bugs. This is also in the Python documentation: > Warning: Due to the precarious circumstances under which __del__() > methods are invoked, exceptions that occur during their execution > are ignored, and a warning is printed to sys.stderr instead. Instead, always close resource handlers when they are no longer in use. This will close the file handler at a specified point in the user's code and not wait until the interpreter chooses to. It is always guaranteed to run. And, if an exception occurs while closing the file handler, the bug will not be ignored. Now, when code receives a ResourceWarning, it will highlight an area that is mishandling resources. It should not simply be silenced, but fixed by closing resources with a context manager. All warnings that were emitted during tests have been cleaned up. To enable warnings, I passed the `-Wa` CLI option to Python. This exposed some mishandling of resources in ImageFile.__init__() and SpiderImagePlugin.loadImageSeries(), they too were fixed.
2019-05-25 19:30:58 +03:00
with Image.open("Tests/images/truncated_image.png") as im:
with pytest.raises(IOError):
Improve handling of file resources Follow Python's file object semantics. User code is responsible for closing resources (usually through a context manager) in a deterministic way. To achieve this, remove __del__ functions. These functions used to closed open file handlers in an attempt to silence Python ResourceWarnings. However, using __del__ has the following drawbacks: - __del__ isn't called until the object's reference count reaches 0. Therefore, resource handlers remain open or in use longer than necessary. - The __del__ method isn't guaranteed to execute on system exit. See the Python documentation: https://docs.python.org/3/reference/datamodel.html#object.__del__ > It is not guaranteed that __del__() methods are called for objects > that still exist when the interpreter exits. - Exceptions that occur inside __del__ are ignored instead of raised. This has the potential of hiding bugs. This is also in the Python documentation: > Warning: Due to the precarious circumstances under which __del__() > methods are invoked, exceptions that occur during their execution > are ignored, and a warning is printed to sys.stderr instead. Instead, always close resource handlers when they are no longer in use. This will close the file handler at a specified point in the user's code and not wait until the interpreter chooses to. It is always guaranteed to run. And, if an exception occurs while closing the file handler, the bug will not be ignored. Now, when code receives a ResourceWarning, it will highlight an area that is mishandling resources. It should not simply be silenced, but fixed by closing resources with a context manager. All warnings that were emitted during tests have been cleaned up. To enable warnings, I passed the `-Wa` CLI option to Python. This exposed some mishandling of resources in ImageFile.__init__() and SpiderImagePlugin.loadImageSeries(), they too were fixed.
2019-05-25 19:30:58 +03:00
im.load()
Improve handling of file resources Follow Python's file object semantics. User code is responsible for closing resources (usually through a context manager) in a deterministic way. To achieve this, remove __del__ functions. These functions used to closed open file handlers in an attempt to silence Python ResourceWarnings. However, using __del__ has the following drawbacks: - __del__ isn't called until the object's reference count reaches 0. Therefore, resource handlers remain open or in use longer than necessary. - The __del__ method isn't guaranteed to execute on system exit. See the Python documentation: https://docs.python.org/3/reference/datamodel.html#object.__del__ > It is not guaranteed that __del__() methods are called for objects > that still exist when the interpreter exits. - Exceptions that occur inside __del__ are ignored instead of raised. This has the potential of hiding bugs. This is also in the Python documentation: > Warning: Due to the precarious circumstances under which __del__() > methods are invoked, exceptions that occur during their execution > are ignored, and a warning is printed to sys.stderr instead. Instead, always close resource handlers when they are no longer in use. This will close the file handler at a specified point in the user's code and not wait until the interpreter chooses to. It is always guaranteed to run. And, if an exception occurs while closing the file handler, the bug will not be ignored. Now, when code receives a ResourceWarning, it will highlight an area that is mishandling resources. It should not simply be silenced, but fixed by closing resources with a context manager. All warnings that were emitted during tests have been cleaned up. To enable warnings, I passed the `-Wa` CLI option to Python. This exposed some mishandling of resources in ImageFile.__init__() and SpiderImagePlugin.loadImageSeries(), they too were fixed.
2019-05-25 19:30:58 +03:00
# Test that the error is raised if loaded a second time
with pytest.raises(IOError):
Improve handling of file resources Follow Python's file object semantics. User code is responsible for closing resources (usually through a context manager) in a deterministic way. To achieve this, remove __del__ functions. These functions used to closed open file handlers in an attempt to silence Python ResourceWarnings. However, using __del__ has the following drawbacks: - __del__ isn't called until the object's reference count reaches 0. Therefore, resource handlers remain open or in use longer than necessary. - The __del__ method isn't guaranteed to execute on system exit. See the Python documentation: https://docs.python.org/3/reference/datamodel.html#object.__del__ > It is not guaranteed that __del__() methods are called for objects > that still exist when the interpreter exits. - Exceptions that occur inside __del__ are ignored instead of raised. This has the potential of hiding bugs. This is also in the Python documentation: > Warning: Due to the precarious circumstances under which __del__() > methods are invoked, exceptions that occur during their execution > are ignored, and a warning is printed to sys.stderr instead. Instead, always close resource handlers when they are no longer in use. This will close the file handler at a specified point in the user's code and not wait until the interpreter chooses to. It is always guaranteed to run. And, if an exception occurs while closing the file handler, the bug will not be ignored. Now, when code receives a ResourceWarning, it will highlight an area that is mishandling resources. It should not simply be silenced, but fixed by closing resources with a context manager. All warnings that were emitted during tests have been cleaned up. To enable warnings, I passed the `-Wa` CLI option to Python. This exposed some mishandling of resources in ImageFile.__init__() and SpiderImagePlugin.loadImageSeries(), they too were fixed.
2019-05-25 19:30:58 +03:00
im.load()
@skip_unless_feature("zlib")
def test_truncated_without_errors(self):
2019-11-25 23:03:23 +03:00
with Image.open("Tests/images/truncated_image.png") as im:
ImageFile.LOAD_TRUNCATED_IMAGES = True
try:
im.load()
finally:
ImageFile.LOAD_TRUNCATED_IMAGES = False
2014-06-10 13:10:47 +04:00
@skip_unless_feature("zlib")
2015-09-15 20:12:16 +03:00
def test_broken_datastream_with_errors(self):
2019-11-25 23:03:23 +03:00
with Image.open("Tests/images/broken_data_stream.png") as im:
with pytest.raises(IOError):
2019-11-25 23:03:23 +03:00
im.load()
2015-09-15 20:12:16 +03:00
@skip_unless_feature("zlib")
2015-09-15 20:12:16 +03:00
def test_broken_datastream_without_errors(self):
2019-11-25 23:03:23 +03:00
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
2015-09-15 20:12:16 +03:00
2017-03-11 18:35:03 +03:00
class MockPyDecoder(ImageFile.PyDecoder):
def decode(self, buffer):
2017-04-20 14:14:23 +03:00
# eof
2018-10-02 11:55:28 +03:00
return -1, 0
2017-03-11 18:35:03 +03:00
2018-03-03 12:54:00 +03:00
2017-03-11 18:35:03 +03:00
xoff, yoff, xsize, ysize = 10, 20, 100, 100
2017-04-20 14:14:23 +03:00
2017-03-11 18:35:03 +03:00
class MockImageFile(ImageFile.ImageFile):
def _open(self):
2019-06-13 18:54:46 +03:00
self.rawmode = "RGBA"
self.mode = "RGBA"
self._size = (200, 200)
2019-06-13 18:54:46 +03:00
self.tile = [("MOCK", (xoff, yoff, xoff + xsize, yoff + ysize), 32, None)]
2017-03-11 18:35:03 +03:00
2017-04-20 14:14:23 +03:00
2017-03-11 18:35:03 +03:00
class TestPyDecoder(PillowTestCase):
def get_decoder(self):
decoder = MockPyDecoder(None)
def closure(mode, *args):
decoder.__init__(mode, *args)
return decoder
2019-06-13 18:54:46 +03:00
Image.register_decoder("MOCK", closure)
2017-03-11 18:35:03 +03:00
return decoder
def test_setimage(self):
2019-06-13 18:54:46 +03:00
buf = BytesIO(b"\x00" * 255)
2017-03-11 18:35:03 +03:00
im = MockImageFile(buf)
d = self.get_decoder()
im.load()
assert d.state.xoff == xoff
assert d.state.yoff == yoff
assert d.state.xsize == xsize
assert d.state.ysize == ysize
2017-03-11 18:35:03 +03:00
with pytest.raises(ValueError):
d.set_as_raw(b"\x00")
2017-03-11 18:35:03 +03:00
2017-03-11 19:43:44 +03:00
def test_extents_none(self):
2019-06-13 18:54:46 +03:00
buf = BytesIO(b"\x00" * 255)
2017-03-11 19:43:44 +03:00
im = MockImageFile(buf)
im.tile = [("MOCK", None, 32, None)]
d = self.get_decoder()
im.load()
assert d.state.xoff == 0
assert d.state.yoff == 0
assert d.state.xsize == 200
assert d.state.ysize == 200
2017-03-11 19:43:44 +03:00
2017-03-11 18:35:03 +03:00
def test_negsize(self):
2019-06-13 18:54:46 +03:00
buf = BytesIO(b"\x00" * 255)
2017-03-11 18:35:03 +03:00
im = MockImageFile(buf)
2019-06-13 18:54:46 +03:00
im.tile = [("MOCK", (xoff, yoff, -10, yoff + ysize), 32, None)]
2018-10-02 11:44:43 +03:00
self.get_decoder()
2017-03-11 18:35:03 +03:00
with pytest.raises(ValueError):
im.load()
2017-03-11 18:35:03 +03:00
2019-06-13 18:54:46 +03:00
im.tile = [("MOCK", (xoff, yoff, xoff + xsize, -10), 32, None)]
with pytest.raises(ValueError):
im.load()
2017-03-11 18:35:03 +03:00
def test_oversize(self):
2019-06-13 18:54:46 +03:00
buf = BytesIO(b"\x00" * 255)
2017-03-11 18:35:03 +03:00
im = MockImageFile(buf)
2019-06-13 18:54:46 +03:00
im.tile = [("MOCK", (xoff, yoff, xoff + xsize + 100, yoff + ysize), 32, None)]
2018-10-02 11:44:43 +03:00
self.get_decoder()
2017-03-11 18:35:03 +03:00
with pytest.raises(ValueError):
im.load()
2017-03-11 18:35:03 +03:00
2019-06-13 18:54:46 +03:00
im.tile = [("MOCK", (xoff, yoff, xoff + xsize, yoff + ysize + 100), 32, None)]
with pytest.raises(ValueError):
im.load()
2017-03-11 18:35:03 +03:00
def test_no_format(self):
2019-06-13 18:54:46 +03:00
buf = BytesIO(b"\x00" * 255)
im = MockImageFile(buf)
assert im.format is None
assert im.get_format_mimetype() is None
2019-03-12 02:27:43 +03:00
def test_exif_jpeg(self):
2019-11-25 23:03:23 +03:00
with Image.open("Tests/images/exif-72dpi-int.jpg") as im: # Little endian
exif = im.getexif()
assert 258 not in exif
assert 40960 in exif
assert exif[40963] == 450
assert exif[11] == "gThumb 3.0.1"
2019-11-25 23:03:23 +03:00
out = self.tempfile("temp.jpg")
exif[258] = 8
del exif[40960]
exif[40963] = 455
exif[11] = "Pillow test"
im.save(out, exif=exif)
Improve handling of file resources Follow Python's file object semantics. User code is responsible for closing resources (usually through a context manager) in a deterministic way. To achieve this, remove __del__ functions. These functions used to closed open file handlers in an attempt to silence Python ResourceWarnings. However, using __del__ has the following drawbacks: - __del__ isn't called until the object's reference count reaches 0. Therefore, resource handlers remain open or in use longer than necessary. - The __del__ method isn't guaranteed to execute on system exit. See the Python documentation: https://docs.python.org/3/reference/datamodel.html#object.__del__ > It is not guaranteed that __del__() methods are called for objects > that still exist when the interpreter exits. - Exceptions that occur inside __del__ are ignored instead of raised. This has the potential of hiding bugs. This is also in the Python documentation: > Warning: Due to the precarious circumstances under which __del__() > methods are invoked, exceptions that occur during their execution > are ignored, and a warning is printed to sys.stderr instead. Instead, always close resource handlers when they are no longer in use. This will close the file handler at a specified point in the user's code and not wait until the interpreter chooses to. It is always guaranteed to run. And, if an exception occurs while closing the file handler, the bug will not be ignored. Now, when code receives a ResourceWarning, it will highlight an area that is mishandling resources. It should not simply be silenced, but fixed by closing resources with a context manager. All warnings that were emitted during tests have been cleaned up. To enable warnings, I passed the `-Wa` CLI option to Python. This exposed some mishandling of resources in ImageFile.__init__() and SpiderImagePlugin.loadImageSeries(), they too were fixed.
2019-05-25 19:30:58 +03:00
with Image.open(out) as reloaded:
reloaded_exif = reloaded.getexif()
assert reloaded_exif[258] == 8
assert 40960 not in exif
assert reloaded_exif[40963] == 455
assert exif[11] == "Pillow test"
2019-03-12 02:27:43 +03:00
2019-11-25 23:03:23 +03:00
with Image.open("Tests/images/no-dpi-in-exif.jpg") as im: # Big endian
exif = im.getexif()
assert 258 not in exif
assert 40962 in exif
assert exif[40963] == 200
assert exif[305] == "Adobe Photoshop CC 2017 (Macintosh)"
2019-11-25 23:03:23 +03:00
out = self.tempfile("temp.jpg")
exif[258] = 8
del exif[34665]
exif[40963] = 455
exif[305] = "Pillow test"
im.save(out, exif=exif)
Improve handling of file resources Follow Python's file object semantics. User code is responsible for closing resources (usually through a context manager) in a deterministic way. To achieve this, remove __del__ functions. These functions used to closed open file handlers in an attempt to silence Python ResourceWarnings. However, using __del__ has the following drawbacks: - __del__ isn't called until the object's reference count reaches 0. Therefore, resource handlers remain open or in use longer than necessary. - The __del__ method isn't guaranteed to execute on system exit. See the Python documentation: https://docs.python.org/3/reference/datamodel.html#object.__del__ > It is not guaranteed that __del__() methods are called for objects > that still exist when the interpreter exits. - Exceptions that occur inside __del__ are ignored instead of raised. This has the potential of hiding bugs. This is also in the Python documentation: > Warning: Due to the precarious circumstances under which __del__() > methods are invoked, exceptions that occur during their execution > are ignored, and a warning is printed to sys.stderr instead. Instead, always close resource handlers when they are no longer in use. This will close the file handler at a specified point in the user's code and not wait until the interpreter chooses to. It is always guaranteed to run. And, if an exception occurs while closing the file handler, the bug will not be ignored. Now, when code receives a ResourceWarning, it will highlight an area that is mishandling resources. It should not simply be silenced, but fixed by closing resources with a context manager. All warnings that were emitted during tests have been cleaned up. To enable warnings, I passed the `-Wa` CLI option to Python. This exposed some mishandling of resources in ImageFile.__init__() and SpiderImagePlugin.loadImageSeries(), they too were fixed.
2019-05-25 19:30:58 +03:00
with Image.open(out) as reloaded:
reloaded_exif = reloaded.getexif()
assert reloaded_exif[258] == 8
assert 40960 not in exif
assert reloaded_exif[40963] == 455
assert exif[305] == "Pillow test"
2019-03-12 02:27:43 +03:00
@skip_unless_feature("webp")
@skip_unless_feature("webp_anim")
2019-03-12 02:27:43 +03:00
def test_exif_webp(self):
2019-11-25 23:03:23 +03:00
with Image.open("Tests/images/hopper.webp") as im:
exif = im.getexif()
assert exif == {}
2019-11-25 23:03:23 +03:00
out = self.tempfile("temp.webp")
exif[258] = 8
exif[40963] = 455
exif[305] = "Pillow test"
def check_exif():
with Image.open(out) as reloaded:
reloaded_exif = reloaded.getexif()
assert reloaded_exif[258] == 8
assert reloaded_exif[40963] == 455
assert exif[305] == "Pillow test"
2019-11-25 23:03:23 +03:00
im.save(out, exif=exif)
check_exif()
im.save(out, exif=exif, save_all=True)
check_exif()
2019-03-12 02:27:43 +03:00
def test_exif_png(self):
2019-11-25 23:03:23 +03:00
with Image.open("Tests/images/exif.png") as im:
exif = im.getexif()
assert exif == {274: 1}
2019-11-25 23:03:23 +03:00
out = self.tempfile("temp.png")
exif[258] = 8
del exif[274]
exif[40963] = 455
exif[305] = "Pillow test"
im.save(out, exif=exif)
2019-03-12 02:27:43 +03:00
Improve handling of file resources Follow Python's file object semantics. User code is responsible for closing resources (usually through a context manager) in a deterministic way. To achieve this, remove __del__ functions. These functions used to closed open file handlers in an attempt to silence Python ResourceWarnings. However, using __del__ has the following drawbacks: - __del__ isn't called until the object's reference count reaches 0. Therefore, resource handlers remain open or in use longer than necessary. - The __del__ method isn't guaranteed to execute on system exit. See the Python documentation: https://docs.python.org/3/reference/datamodel.html#object.__del__ > It is not guaranteed that __del__() methods are called for objects > that still exist when the interpreter exits. - Exceptions that occur inside __del__ are ignored instead of raised. This has the potential of hiding bugs. This is also in the Python documentation: > Warning: Due to the precarious circumstances under which __del__() > methods are invoked, exceptions that occur during their execution > are ignored, and a warning is printed to sys.stderr instead. Instead, always close resource handlers when they are no longer in use. This will close the file handler at a specified point in the user's code and not wait until the interpreter chooses to. It is always guaranteed to run. And, if an exception occurs while closing the file handler, the bug will not be ignored. Now, when code receives a ResourceWarning, it will highlight an area that is mishandling resources. It should not simply be silenced, but fixed by closing resources with a context manager. All warnings that were emitted during tests have been cleaned up. To enable warnings, I passed the `-Wa` CLI option to Python. This exposed some mishandling of resources in ImageFile.__init__() and SpiderImagePlugin.loadImageSeries(), they too were fixed.
2019-05-25 19:30:58 +03:00
with Image.open(out) as reloaded:
reloaded_exif = reloaded.getexif()
assert reloaded_exif == {258: 8, 40963: 455, 305: "Pillow test"}
def test_exif_interop(self):
Improve handling of file resources Follow Python's file object semantics. User code is responsible for closing resources (usually through a context manager) in a deterministic way. To achieve this, remove __del__ functions. These functions used to closed open file handlers in an attempt to silence Python ResourceWarnings. However, using __del__ has the following drawbacks: - __del__ isn't called until the object's reference count reaches 0. Therefore, resource handlers remain open or in use longer than necessary. - The __del__ method isn't guaranteed to execute on system exit. See the Python documentation: https://docs.python.org/3/reference/datamodel.html#object.__del__ > It is not guaranteed that __del__() methods are called for objects > that still exist when the interpreter exits. - Exceptions that occur inside __del__ are ignored instead of raised. This has the potential of hiding bugs. This is also in the Python documentation: > Warning: Due to the precarious circumstances under which __del__() > methods are invoked, exceptions that occur during their execution > are ignored, and a warning is printed to sys.stderr instead. Instead, always close resource handlers when they are no longer in use. This will close the file handler at a specified point in the user's code and not wait until the interpreter chooses to. It is always guaranteed to run. And, if an exception occurs while closing the file handler, the bug will not be ignored. Now, when code receives a ResourceWarning, it will highlight an area that is mishandling resources. It should not simply be silenced, but fixed by closing resources with a context manager. All warnings that were emitted during tests have been cleaned up. To enable warnings, I passed the `-Wa` CLI option to Python. This exposed some mishandling of resources in ImageFile.__init__() and SpiderImagePlugin.loadImageSeries(), they too were fixed.
2019-05-25 19:30:58 +03:00
with Image.open("Tests/images/flower.jpg") as im:
exif = im.getexif()
assert exif.get_ifd(0xA005) == {
1: "R98",
2: b"0100",
4097: 2272,
4098: 1704,
}