From d3c9a6504e84f87379554b6b671a1fb6c66a449e Mon Sep 17 00:00:00 2001 From: Hugo van Kemenade Date: Sun, 10 Apr 2022 21:23:31 +0300 Subject: [PATCH] Variable in function should be snake_case --- Tests/test_color_lut.py | 26 ++++---- Tests/test_file_mpo.py | 6 +- Tests/test_file_pdf.py | 6 +- Tests/test_file_tiff_metadata.py | 44 ++++++------- Tests/test_image_copy.py | 12 ++-- Tests/test_image_filter.py | 4 +- Tests/test_imagefile.py | 4 +- Tests/test_imagesequence.py | 8 +-- Tests/test_mode_i16.py | 52 ++++++++-------- src/PIL/GdImageFile.py | 15 +++-- src/PIL/ImageDraw.py | 6 +- src/PIL/ImageFilter.py | 30 ++++----- src/PIL/ImageStat.py | 6 +- src/PIL/PcfFontFile.py | 22 +++---- src/PIL/PdfImagePlugin.py | 28 ++++----- src/PIL/SgiImagePlugin.py | 10 +-- src/PIL/TiffImagePlugin.py | 102 +++++++++++++++---------------- 17 files changed, 193 insertions(+), 188 deletions(-) diff --git a/Tests/test_color_lut.py b/Tests/test_color_lut.py index 120ff777e..abe13cf13 100644 --- a/Tests/test_color_lut.py +++ b/Tests/test_color_lut.py @@ -15,27 +15,27 @@ except ImportError: class TestColorLut3DCoreAPI: def generate_identity_table(self, channels, size): if isinstance(size, tuple): - size1D, size2D, size3D = size + size_1d, size_2d, size_3d = size else: - size1D, size2D, size3D = (size, size, size) + size_1d, size_2d, size_3d = (size, size, size) table = [ [ - r / (size1D - 1) if size1D != 1 else 0, - g / (size2D - 1) if size2D != 1 else 0, - b / (size3D - 1) if size3D != 1 else 0, - r / (size1D - 1) if size1D != 1 else 0, - g / (size2D - 1) if size2D != 1 else 0, + r / (size_1d - 1) if size_1d != 1 else 0, + g / (size_2d - 1) if size_2d != 1 else 0, + b / (size_3d - 1) if size_3d != 1 else 0, + r / (size_1d - 1) if size_1d != 1 else 0, + g / (size_2d - 1) if size_2d != 1 else 0, ][:channels] - for b in range(size3D) - for g in range(size2D) - for r in range(size1D) + for b in range(size_3d) + for g in range(size_2d) + for r in range(size_1d) ] return ( channels, - size1D, - size2D, - size3D, + size_1d, + size_2d, + size_3d, [item for sublist in table for item in sublist], ) diff --git a/Tests/test_file_mpo.py b/Tests/test_file_mpo.py index 0fa3b6382..ca3ea8419 100644 --- a/Tests/test_file_mpo.py +++ b/Tests/test_file_mpo.py @@ -145,10 +145,10 @@ def test_mp_attribute(): for test_file in test_files: with Image.open(test_file) as im: mpinfo = im._getmp() - frameNumber = 0 + frame_number = 0 for mpentry in mpinfo[0xB002]: mpattr = mpentry["Attribute"] - if frameNumber: + if frame_number: assert not mpattr["RepresentativeImageFlag"] else: assert mpattr["RepresentativeImageFlag"] @@ -157,7 +157,7 @@ def test_mp_attribute(): assert mpattr["ImageDataFormat"] == "JPEG" assert mpattr["MPType"] == "Multi-Frame Image: (Disparity)" assert mpattr["Reserved"] == 0 - frameNumber += 1 + frame_number += 1 def test_seek(): diff --git a/Tests/test_file_pdf.py b/Tests/test_file_pdf.py index 10daa414b..b6f327844 100644 --- a/Tests/test_file_pdf.py +++ b/Tests/test_file_pdf.py @@ -253,9 +253,9 @@ def test_pdf_append(tmp_path): check_pdf_pages_consistency(pdf) # append two images - mode_CMYK = hopper("CMYK") - mode_P = hopper("P") - mode_CMYK.save(pdf_filename, append=True, save_all=True, append_images=[mode_P]) + mode_cmyk = hopper("CMYK") + mode_p = hopper("P") + mode_cmyk.save(pdf_filename, append=True, save_all=True, append_images=[mode_p]) # open the PDF again, check pages and info again with PdfParser.PdfParser(pdf_filename) as pdf: diff --git a/Tests/test_file_tiff_metadata.py b/Tests/test_file_tiff_metadata.py index 056295516..b11ab1643 100644 --- a/Tests/test_file_tiff_metadata.py +++ b/Tests/test_file_tiff_metadata.py @@ -28,26 +28,26 @@ def test_rt_metadata(tmp_path): # For text items, we still have to decode('ascii','replace') because # the tiff file format can't take 8 bit bytes in that field. - basetextdata = "This is some arbitrary metadata for a text field" - bindata = basetextdata.encode("ascii") + b" \xff" - textdata = basetextdata + " " + chr(255) - reloaded_textdata = basetextdata + " ?" - floatdata = 12.345 - doubledata = 67.89 + base_text_data = "This is some arbitrary metadata for a text field" + bin_data = base_text_data.encode("ascii") + b" \xff" + text_data = base_text_data + " " + chr(255) + reloaded_text_data = base_text_data + " ?" + float_data = 12.345 + double_data = 67.89 info = TiffImagePlugin.ImageFileDirectory() ImageJMetaData = TAG_IDS["ImageJMetaData"] ImageJMetaDataByteCounts = TAG_IDS["ImageJMetaDataByteCounts"] ImageDescription = TAG_IDS["ImageDescription"] - info[ImageJMetaDataByteCounts] = len(bindata) - info[ImageJMetaData] = bindata - info[TAG_IDS["RollAngle"]] = floatdata + info[ImageJMetaDataByteCounts] = len(bin_data) + info[ImageJMetaData] = bin_data + info[TAG_IDS["RollAngle"]] = float_data info.tagtype[TAG_IDS["RollAngle"]] = 11 - info[TAG_IDS["YawAngle"]] = doubledata + info[TAG_IDS["YawAngle"]] = double_data info.tagtype[TAG_IDS["YawAngle"]] = 12 - info[ImageDescription] = textdata + info[ImageDescription] = text_data f = str(tmp_path / "temp.tif") @@ -55,28 +55,28 @@ def test_rt_metadata(tmp_path): with Image.open(f) as loaded: - assert loaded.tag[ImageJMetaDataByteCounts] == (len(bindata),) - assert loaded.tag_v2[ImageJMetaDataByteCounts] == (len(bindata),) + assert loaded.tag[ImageJMetaDataByteCounts] == (len(bin_data),) + assert loaded.tag_v2[ImageJMetaDataByteCounts] == (len(bin_data),) - assert loaded.tag[ImageJMetaData] == bindata - assert loaded.tag_v2[ImageJMetaData] == bindata + assert loaded.tag[ImageJMetaData] == bin_data + assert loaded.tag_v2[ImageJMetaData] == bin_data - assert loaded.tag[ImageDescription] == (reloaded_textdata,) - assert loaded.tag_v2[ImageDescription] == reloaded_textdata + assert loaded.tag[ImageDescription] == (reloaded_text_data,) + assert loaded.tag_v2[ImageDescription] == reloaded_text_data loaded_float = loaded.tag[TAG_IDS["RollAngle"]][0] - assert round(abs(loaded_float - floatdata), 5) == 0 + assert round(abs(loaded_float - float_data), 5) == 0 loaded_double = loaded.tag[TAG_IDS["YawAngle"]][0] - assert round(abs(loaded_double - doubledata), 7) == 0 + assert round(abs(loaded_double - double_data), 7) == 0 # check with 2 element ImageJMetaDataByteCounts, issue #2006 - info[ImageJMetaDataByteCounts] = (8, len(bindata) - 8) + info[ImageJMetaDataByteCounts] = (8, len(bin_data) - 8) img.save(f, tiffinfo=info) with Image.open(f) as loaded: - assert loaded.tag[ImageJMetaDataByteCounts] == (8, len(bindata) - 8) - assert loaded.tag_v2[ImageJMetaDataByteCounts] == (8, len(bindata) - 8) + assert loaded.tag[ImageJMetaDataByteCounts] == (8, len(bin_data) - 8) + assert loaded.tag_v2[ImageJMetaDataByteCounts] == (8, len(bin_data) - 8) def test_read_metadata(): diff --git a/Tests/test_image_copy.py b/Tests/test_image_copy.py index ad0391dbe..21e438654 100644 --- a/Tests/test_image_copy.py +++ b/Tests/test_image_copy.py @@ -6,8 +6,8 @@ from .helper import hopper def test_copy(): - croppedCoordinates = (10, 10, 20, 20) - croppedSize = (10, 10) + cropped_coordinates = (10, 10, 20, 20) + cropped_size = (10, 10) for mode in "1", "P", "L", "RGB", "I", "F": # Internal copy method im = hopper(mode) @@ -23,15 +23,15 @@ def test_copy(): # Internal copy method on a cropped image im = hopper(mode) - out = im.crop(croppedCoordinates).copy() + out = im.crop(cropped_coordinates).copy() assert out.mode == im.mode - assert out.size == croppedSize + assert out.size == cropped_size # Python's copy method on a cropped image im = hopper(mode) - out = copy.copy(im.crop(croppedCoordinates)) + out = copy.copy(im.crop(cropped_coordinates)) assert out.mode == im.mode - assert out.size == croppedSize + assert out.size == cropped_size def test_copy_zero(): diff --git a/Tests/test_image_filter.py b/Tests/test_image_filter.py index df8c353f3..14a8da9f1 100644 --- a/Tests/test_image_filter.py +++ b/Tests/test_image_filter.py @@ -99,10 +99,10 @@ def test_rankfilter_properties(): def test_builtinfilter_p(): - builtinFilter = ImageFilter.BuiltinFilter() + builtin_filter = ImageFilter.BuiltinFilter() with pytest.raises(ValueError): - builtinFilter.filter(hopper("P")) + builtin_filter.filter(hopper("P")) def test_kernel_not_enough_coefficients(): diff --git a/Tests/test_imagefile.py b/Tests/test_imagefile.py index 1c444fe27..0b3aecd08 100644 --- a/Tests/test_imagefile.py +++ b/Tests/test_imagefile.py @@ -35,9 +35,9 @@ class TestImageFile: parser = ImageFile.Parser() parser.feed(data) - imOut = parser.close() + im_out = parser.close() - return im, imOut + return im, im_out assert_image_equal(*roundtrip("BMP")) im1, im2 = roundtrip("GIF") diff --git a/Tests/test_imagesequence.py b/Tests/test_imagesequence.py index 7cf237b46..628120cc4 100644 --- a/Tests/test_imagesequence.py +++ b/Tests/test_imagesequence.py @@ -65,12 +65,12 @@ def test_libtiff(): def test_consecutive(): with Image.open("Tests/images/multipage.tiff") as im: - firstFrame = None + first_frame = None for frame in ImageSequence.Iterator(im): - if firstFrame is None: - firstFrame = frame.copy() + if first_frame is None: + first_frame = frame.copy() for frame in ImageSequence.Iterator(im): - assert_image_equal(frame, firstFrame) + assert_image_equal(frame, first_frame) break diff --git a/Tests/test_mode_i16.py b/Tests/test_mode_i16.py index 688af7113..6e8a2ac58 100644 --- a/Tests/test_mode_i16.py +++ b/Tests/test_mode_i16.py @@ -26,51 +26,51 @@ def test_basic(tmp_path): def basic(mode): - imIn = original.convert(mode) - verify(imIn) + im_in = original.convert(mode) + verify(im_in) - w, h = imIn.size + w, h = im_in.size - imOut = imIn.copy() - verify(imOut) # copy + im_out = im_in.copy() + verify(im_out) # copy - imOut = imIn.transform((w, h), Image.Transform.EXTENT, (0, 0, w, h)) - verify(imOut) # transform + im_out = im_in.transform((w, h), Image.Transform.EXTENT, (0, 0, w, h)) + verify(im_out) # transform filename = str(tmp_path / "temp.im") - imIn.save(filename) + im_in.save(filename) - with Image.open(filename) as imOut: + with Image.open(filename) as im_out: - verify(imIn) - verify(imOut) + verify(im_in) + verify(im_out) - imOut = imIn.crop((0, 0, w, h)) - verify(imOut) + im_out = im_in.crop((0, 0, w, h)) + verify(im_out) - imOut = Image.new(mode, (w, h), None) - imOut.paste(imIn.crop((0, 0, w // 2, h)), (0, 0)) - imOut.paste(imIn.crop((w // 2, 0, w, h)), (w // 2, 0)) + im_out = Image.new(mode, (w, h), None) + im_out.paste(im_in.crop((0, 0, w // 2, h)), (0, 0)) + im_out.paste(im_in.crop((w // 2, 0, w, h)), (w // 2, 0)) - verify(imIn) - verify(imOut) + verify(im_in) + verify(im_out) - imIn = Image.new(mode, (1, 1), 1) - assert imIn.getpixel((0, 0)) == 1 + im_in = Image.new(mode, (1, 1), 1) + assert im_in.getpixel((0, 0)) == 1 - imIn.putpixel((0, 0), 2) - assert imIn.getpixel((0, 0)) == 2 + im_in.putpixel((0, 0), 2) + assert im_in.getpixel((0, 0)) == 2 if mode == "L": maximum = 255 else: maximum = 32767 - imIn = Image.new(mode, (1, 1), 256) - assert imIn.getpixel((0, 0)) == min(256, maximum) + im_in = Image.new(mode, (1, 1), 256) + assert im_in.getpixel((0, 0)) == min(256, maximum) - imIn.putpixel((0, 0), 512) - assert imIn.getpixel((0, 0)) == min(512, maximum) + im_in.putpixel((0, 0), 512) + assert im_in.getpixel((0, 0)) == min(512, maximum) basic("L") diff --git a/src/PIL/GdImageFile.py b/src/PIL/GdImageFile.py index 9c34adaa6..1965c7fbd 100644 --- a/src/PIL/GdImageFile.py +++ b/src/PIL/GdImageFile.py @@ -54,20 +54,25 @@ class GdImageFile(ImageFile.ImageFile): self.mode = "L" # FIXME: "P" self._size = i16(s, 2), i16(s, 4) - trueColor = s[6] - trueColorOffset = 2 if trueColor else 0 + true_color = s[6] + true_color_offset = 2 if true_color else 0 # transparency index - tindex = i32(s, 7 + trueColorOffset) + tindex = i32(s, 7 + true_color_offset) if tindex < 256: self.info["transparency"] = tindex self.palette = ImagePalette.raw( - "XBGR", s[7 + trueColorOffset + 4 : 7 + trueColorOffset + 4 + 256 * 4] + "XBGR", s[7 + true_color_offset + 4 : 7 + true_color_offset + 4 + 256 * 4] ) self.tile = [ - ("raw", (0, 0) + self.size, 7 + trueColorOffset + 4 + 256 * 4, ("L", 0, 1)) + ( + "raw", + (0, 0) + self.size, + 7 + true_color_offset + 4 + 256 * 4, + ("L", 0, 1), + ) ] diff --git a/src/PIL/ImageDraw.py b/src/PIL/ImageDraw.py index 610ccd4c7..f9782bc50 100644 --- a/src/PIL/ImageDraw.py +++ b/src/PIL/ImageDraw.py @@ -197,18 +197,18 @@ class ImageDraw: if width > 8: # Cover potential gaps between the line and the joint if flipped: - gapCoords = [ + gap_coords = [ coord_at_angle(point, angles[0] + 90), point, coord_at_angle(point, angles[1] + 90), ] else: - gapCoords = [ + gap_coords = [ coord_at_angle(point, angles[0] - 90), point, coord_at_angle(point, angles[1] - 90), ] - self.line(gapCoords, fill, width=3) + self.line(gap_coords, fill, width=3) def shape(self, shape, fill=None, outline=None): """(Experimental) Draw a shape.""" diff --git a/src/PIL/ImageFilter.py b/src/PIL/ImageFilter.py index 1320af8f9..af33c547e 100644 --- a/src/PIL/ImageFilter.py +++ b/src/PIL/ImageFilter.py @@ -439,22 +439,22 @@ class Color3DLUT(MultibandFilter): :param target_mode: Passed to the constructor of the resulting lookup table. """ - size1D, size2D, size3D = cls._check_size(size) + size_1d, size_2d, size_3d = cls._check_size(size) if channels not in (3, 4): raise ValueError("Only 3 or 4 output channels are supported") - table = [0] * (size1D * size2D * size3D * channels) + table = [0] * (size_1d * size_2d * size_3d * channels) idx_out = 0 - for b in range(size3D): - for g in range(size2D): - for r in range(size1D): + for b in range(size_3d): + for g in range(size_2d): + for r in range(size_1d): table[idx_out : idx_out + channels] = callback( - r / (size1D - 1), g / (size2D - 1), b / (size3D - 1) + r / (size_1d - 1), g / (size_2d - 1), b / (size_3d - 1) ) idx_out += channels return cls( - (size1D, size2D, size3D), + (size_1d, size_2d, size_3d), table, channels=channels, target_mode=target_mode, @@ -484,20 +484,20 @@ class Color3DLUT(MultibandFilter): raise ValueError("Only 3 or 4 output channels are supported") ch_in = self.channels ch_out = channels or ch_in - size1D, size2D, size3D = self.size + size_1d, size_2d, size_3d = self.size - table = [0] * (size1D * size2D * size3D * ch_out) + table = [0] * (size_1d * size_2d * size_3d * ch_out) idx_in = 0 idx_out = 0 - for b in range(size3D): - for g in range(size2D): - for r in range(size1D): + for b in range(size_3d): + for g in range(size_2d): + for r in range(size_1d): values = self.table[idx_in : idx_in + ch_in] if with_normals: values = callback( - r / (size1D - 1), - g / (size2D - 1), - b / (size3D - 1), + r / (size_1d - 1), + g / (size_2d - 1), + b / (size_3d - 1), *values, ) else: diff --git a/src/PIL/ImageStat.py b/src/PIL/ImageStat.py index ef4a1d633..1baef7db4 100644 --- a/src/PIL/ImageStat.py +++ b/src/PIL/ImageStat.py @@ -78,10 +78,10 @@ class Stat: v = [] for i in range(0, len(self.h), 256): - layerSum = 0.0 + layer_sum = 0.0 for j in range(256): - layerSum += j * self.h[i + j] - v.append(layerSum) + layer_sum += j * self.h[i + j] + v.append(layer_sum) return v def _getsum2(self): diff --git a/src/PIL/PcfFontFile.py b/src/PIL/PcfFontFile.py index 6a4eb22a6..0556c2bbc 100644 --- a/src/PIL/PcfFontFile.py +++ b/src/PIL/PcfFontFile.py @@ -193,15 +193,15 @@ class PcfFontFile(FontFile.FontFile): for i in range(nbitmaps): offsets.append(i32(fp.read(4))) - bitmapSizes = [] + bitmap_sizes = [] for i in range(4): - bitmapSizes.append(i32(fp.read(4))) + bitmap_sizes.append(i32(fp.read(4))) # byteorder = format & 4 # non-zero => MSB bitorder = format & 8 # non-zero => MSB padindex = format & 3 - bitmapsize = bitmapSizes[padindex] + bitmapsize = bitmap_sizes[padindex] offsets.append(bitmapsize) data = fp.read(bitmapsize) @@ -225,22 +225,22 @@ class PcfFontFile(FontFile.FontFile): fp, format, i16, i32 = self._getformat(PCF_BDF_ENCODINGS) - firstCol, lastCol = i16(fp.read(2)), i16(fp.read(2)) - firstRow, lastRow = i16(fp.read(2)), i16(fp.read(2)) + first_col, last_col = i16(fp.read(2)), i16(fp.read(2)) + first_row, last_row = i16(fp.read(2)), i16(fp.read(2)) i16(fp.read(2)) # default - nencoding = (lastCol - firstCol + 1) * (lastRow - firstRow + 1) + nencoding = (last_col - first_col + 1) * (last_row - first_row + 1) - encodingOffsets = [i16(fp.read(2)) for _ in range(nencoding)] + encoding_offsets = [i16(fp.read(2)) for _ in range(nencoding)] - for i in range(firstCol, len(encoding)): + for i in range(first_col, len(encoding)): try: - encodingOffset = encodingOffsets[ + encoding_offset = encoding_offsets[ ord(bytearray([i]).decode(self.charset_encoding)) ] - if encodingOffset != 0xFFFF: - encoding[i] = encodingOffset + if encoding_offset != 0xFFFF: + encoding[i] = encoding_offset except UnicodeDecodeError: # character is not supported in selected encoding pass diff --git a/src/PIL/PdfImagePlugin.py b/src/PIL/PdfImagePlugin.py index 544035c8b..2109a6f52 100644 --- a/src/PIL/PdfImagePlugin.py +++ b/src/PIL/PdfImagePlugin.py @@ -87,21 +87,21 @@ def _save(im, fp, filename, save_all=False): for append_im in append_images: append_im.encoderinfo = im.encoderinfo.copy() ims.append(append_im) - numberOfPages = 0 + number_of_pages = 0 image_refs = [] page_refs = [] contents_refs = [] for im in ims: - im_numberOfPages = 1 + im_number_of_pages = 1 if save_all: try: - im_numberOfPages = im.n_frames + im_number_of_pages = im.n_frames except AttributeError: # Image format does not have n_frames. # It is a single frame image pass - numberOfPages += im_numberOfPages - for i in range(im_numberOfPages): + number_of_pages += im_number_of_pages + for i in range(im_number_of_pages): image_refs.append(existing_pdf.next_object_id(0)) page_refs.append(existing_pdf.next_object_id(0)) contents_refs.append(existing_pdf.next_object_id(0)) @@ -111,9 +111,9 @@ def _save(im, fp, filename, save_all=False): # catalog and list of pages existing_pdf.write_catalog() - pageNumber = 0 - for imSequence in ims: - im_pages = ImageSequence.Iterator(imSequence) if save_all else [imSequence] + page_number = 0 + for im_sequence in ims: + im_pages = ImageSequence.Iterator(im_sequence) if save_all else [im_sequence] for im in im_pages: # FIXME: Should replace ASCIIHexDecode with RunLengthDecode # (packbits) or LZWDecode (tiff/lzw compression). Note that @@ -176,7 +176,7 @@ def _save(im, fp, filename, save_all=False): width, height = im.size existing_pdf.write_obj( - image_refs[pageNumber], + image_refs[page_number], stream=op.getvalue(), Type=PdfParser.PdfName("XObject"), Subtype=PdfParser.PdfName("Image"), @@ -193,10 +193,10 @@ def _save(im, fp, filename, save_all=False): # page existing_pdf.write_page( - page_refs[pageNumber], + page_refs[page_number], Resources=PdfParser.PdfDict( ProcSet=[PdfParser.PdfName("PDF"), PdfParser.PdfName(procset)], - XObject=PdfParser.PdfDict(image=image_refs[pageNumber]), + XObject=PdfParser.PdfDict(image=image_refs[page_number]), ), MediaBox=[ 0, @@ -204,7 +204,7 @@ def _save(im, fp, filename, save_all=False): width * 72.0 / resolution, height * 72.0 / resolution, ], - Contents=contents_refs[pageNumber], + Contents=contents_refs[page_number], ) # @@ -215,9 +215,9 @@ def _save(im, fp, filename, save_all=False): height * 72.0 / resolution, ) - existing_pdf.write_obj(contents_refs[pageNumber], stream=page_contents) + existing_pdf.write_obj(contents_refs[page_number], stream=page_contents) - pageNumber += 1 + page_number += 1 # # trailer diff --git a/src/PIL/SgiImagePlugin.py b/src/PIL/SgiImagePlugin.py index 5f1ef6edc..0ef58cf41 100644 --- a/src/PIL/SgiImagePlugin.py +++ b/src/PIL/SgiImagePlugin.py @@ -138,7 +138,7 @@ def _save(im, fp, filename): # Flip the image, since the origin of SGI file is the bottom-left corner orientation = -1 # Define the file as SGI File Format - magicNumber = 474 + magic_number = 474 # Run-Length Encoding Compression - Unsupported at this time rle = 0 @@ -167,11 +167,11 @@ def _save(im, fp, filename): # Maximum Byte value (255 = 8bits per pixel) pinmax = 255 # Image name (79 characters max, truncated below in write) - imgName = os.path.splitext(os.path.basename(filename))[0] - imgName = imgName.encode("ascii", "ignore") + img_name = os.path.splitext(os.path.basename(filename))[0] + img_name = img_name.encode("ascii", "ignore") # Standard representation of pixel in the file colormap = 0 - fp.write(struct.pack(">h", magicNumber)) + fp.write(struct.pack(">h", magic_number)) fp.write(o8(rle)) fp.write(o8(bpc)) fp.write(struct.pack(">H", dim)) @@ -181,7 +181,7 @@ def _save(im, fp, filename): fp.write(struct.pack(">l", pinmin)) fp.write(struct.pack(">l", pinmax)) fp.write(struct.pack("4s", b"")) # dummy - fp.write(struct.pack("79s", imgName)) # truncates to 79 chars + fp.write(struct.pack("79s", img_name)) # truncates to 79 chars fp.write(struct.pack("s", b"")) # force null byte after imgname fp.write(struct.pack(">l", colormap)) fp.write(struct.pack("404s", b"")) # dummy diff --git a/src/PIL/TiffImagePlugin.py b/src/PIL/TiffImagePlugin.py index e96f58440..8b7144c83 100644 --- a/src/PIL/TiffImagePlugin.py +++ b/src/PIL/TiffImagePlugin.py @@ -1336,14 +1336,14 @@ class TiffImageFile(ImageFile.ImageFile): logger.debug(f"- size: {self.size}") - sampleFormat = self.tag_v2.get(SAMPLEFORMAT, (1,)) - if len(sampleFormat) > 1 and max(sampleFormat) == min(sampleFormat) == 1: + sample_format = self.tag_v2.get(SAMPLEFORMAT, (1,)) + if len(sample_format) > 1 and max(sample_format) == min(sample_format) == 1: # SAMPLEFORMAT is properly per band, so an RGB image will # be (1,1,1). But, we don't support per band pixel types, # and anything more than one band is a uint8. So, just # take the first element. Revisit this if adding support # for more exotic images. - sampleFormat = (1,) + sample_format = (1,) bps_tuple = self.tag_v2.get(BITSPERSAMPLE, (1,)) extra_tuple = self.tag_v2.get(EXTRASAMPLES, ()) @@ -1364,18 +1364,18 @@ class TiffImageFile(ImageFile.ImageFile): # presume it is the same number of bits for all of the samples. bps_tuple = bps_tuple * bps_count - samplesPerPixel = self.tag_v2.get( + samples_per_pixel = self.tag_v2.get( SAMPLESPERPIXEL, 3 if self._compression == "tiff_jpeg" and photo in (2, 6) else 1, ) - if len(bps_tuple) != samplesPerPixel: + if len(bps_tuple) != samples_per_pixel: raise SyntaxError("unknown data organization") # mode: check photometric interpretation and bits per pixel key = ( self.tag_v2.prefix, photo, - sampleFormat, + sample_format, fillorder, bps_tuple, extra_tuple, @@ -1904,20 +1904,20 @@ class AppendingTiffWriter: # fix offsets self.f.seek(self.offsetOfNewPage) - IIMM = self.f.read(4) - if not IIMM: + iimm = self.f.read(4) + if not iimm: # raise RuntimeError("nothing written into new page") # Make it easy to finish a frame without committing to a new one. return - if IIMM != self.IIMM: + if iimm != self.IIMM: raise RuntimeError("IIMM of new page doesn't match IIMM of first page") - IFDoffset = self.readLong() - IFDoffset += self.offsetOfNewPage + ifd_offset = self.readLong() + ifd_offset += self.offsetOfNewPage self.f.seek(self.whereToWriteNewIFDOffset) - self.writeLong(IFDoffset) - self.f.seek(IFDoffset) + self.writeLong(ifd_offset) + self.f.seek(ifd_offset) self.fixIFD() def newFrame(self): @@ -1948,9 +1948,9 @@ class AppendingTiffWriter: pos = self.f.tell() # pad to 16 byte boundary - padBytes = 16 - pos % 16 - if 0 < padBytes < 16: - self.f.write(bytes(padBytes)) + pad_bytes = 16 - pos % 16 + if 0 < pad_bytes < 16: + self.f.write(bytes(pad_bytes)) self.offsetOfNewPage = self.f.tell() def setEndian(self, endian): @@ -1961,14 +1961,14 @@ class AppendingTiffWriter: def skipIFDs(self): while True: - IFDoffset = self.readLong() - if IFDoffset == 0: + ifd_offset = self.readLong() + if ifd_offset == 0: self.whereToWriteNewIFDOffset = self.f.tell() - 4 break - self.f.seek(IFDoffset) - numTags = self.readShort() - self.f.seek(numTags * 12, os.SEEK_CUR) + self.f.seek(ifd_offset) + num_tags = self.readShort() + self.f.seek(num_tags * 12, os.SEEK_CUR) def write(self, data): return self.f.write(data) @@ -1983,68 +1983,68 @@ class AppendingTiffWriter: def rewriteLastShortToLong(self, value): self.f.seek(-2, os.SEEK_CUR) - bytesWritten = self.f.write(struct.pack(self.longFmt, value)) - if bytesWritten is not None and bytesWritten != 4: - raise RuntimeError(f"wrote only {bytesWritten} bytes but wanted 4") + bytes_written = self.f.write(struct.pack(self.longFmt, value)) + if bytes_written is not None and bytes_written != 4: + raise RuntimeError(f"wrote only {bytes_written} bytes but wanted 4") def rewriteLastShort(self, value): self.f.seek(-2, os.SEEK_CUR) - bytesWritten = self.f.write(struct.pack(self.shortFmt, value)) - if bytesWritten is not None and bytesWritten != 2: - raise RuntimeError(f"wrote only {bytesWritten} bytes but wanted 2") + bytes_written = self.f.write(struct.pack(self.shortFmt, value)) + if bytes_written is not None and bytes_written != 2: + raise RuntimeError(f"wrote only {bytes_written} bytes but wanted 2") def rewriteLastLong(self, value): self.f.seek(-4, os.SEEK_CUR) - bytesWritten = self.f.write(struct.pack(self.longFmt, value)) - if bytesWritten is not None and bytesWritten != 4: - raise RuntimeError(f"wrote only {bytesWritten} bytes but wanted 4") + bytes_written = self.f.write(struct.pack(self.longFmt, value)) + if bytes_written is not None and bytes_written != 4: + raise RuntimeError(f"wrote only {bytes_written} bytes but wanted 4") def writeShort(self, value): - bytesWritten = self.f.write(struct.pack(self.shortFmt, value)) - if bytesWritten is not None and bytesWritten != 2: - raise RuntimeError(f"wrote only {bytesWritten} bytes but wanted 2") + bytes_written = self.f.write(struct.pack(self.shortFmt, value)) + if bytes_written is not None and bytes_written != 2: + raise RuntimeError(f"wrote only {bytes_written} bytes but wanted 2") def writeLong(self, value): - bytesWritten = self.f.write(struct.pack(self.longFmt, value)) - if bytesWritten is not None and bytesWritten != 4: - raise RuntimeError(f"wrote only {bytesWritten} bytes but wanted 4") + bytes_written = self.f.write(struct.pack(self.longFmt, value)) + if bytes_written is not None and bytes_written != 4: + raise RuntimeError(f"wrote only {bytes_written} bytes but wanted 4") def close(self): self.finalize() self.f.close() def fixIFD(self): - numTags = self.readShort() + num_tags = self.readShort() - for i in range(numTags): - tag, fieldType, count = struct.unpack(self.tagFormat, self.f.read(8)) + for i in range(num_tags): + tag, field_type, count = struct.unpack(self.tagFormat, self.f.read(8)) - fieldSize = self.fieldSizes[fieldType] - totalSize = fieldSize * count - isLocal = totalSize <= 4 - if not isLocal: + field_size = self.fieldSizes[field_type] + total_size = field_size * count + is_local = total_size <= 4 + if not is_local: offset = self.readLong() offset += self.offsetOfNewPage self.rewriteLastLong(offset) if tag in self.Tags: - curPos = self.f.tell() + cur_pos = self.f.tell() - if isLocal: + if is_local: self.fixOffsets( - count, isShort=(fieldSize == 2), isLong=(fieldSize == 4) + count, isShort=(field_size == 2), isLong=(field_size == 4) ) - self.f.seek(curPos + 4) + self.f.seek(cur_pos + 4) else: self.f.seek(offset) self.fixOffsets( - count, isShort=(fieldSize == 2), isLong=(fieldSize == 4) + count, isShort=(field_size == 2), isLong=(field_size == 4) ) - self.f.seek(curPos) + self.f.seek(cur_pos) - offset = curPos = None + offset = cur_pos = None - elif isLocal: + elif is_local: # skip the locally stored value that is not an offset self.f.seek(4, os.SEEK_CUR)