Simplify code

Author: radarhere

Tests/test_file_png.py

@@ -766,12 +766,10 @@ def test_specify_bits_fewer_palette_entries(self, tmp_path: Path) -> None:
         im.save(out, bits=4)
 
         with Image.open(out) as reloaded:
-            assert isinstance(reloaded, PngImagePlugin.PngImageFile)
-            assert reloaded.png is not None
-            assert reloaded.png.im_palette is not None
-            # Only the 5 actual palette entries are written, rather than
-            # padding the PLTE chunk out to 2 ** 4 == 16 entries.
-            assert len(reloaded.png.im_palette[1]) == 15
+            # Only the 5 actual palette entries are written,
+            # rather than padding the PLTE chunk out to 16 entries (1 << 4).
+            assert reloaded.palette is not None
+            assert len(reloaded.palette.palette) == 5 * 3
 
             assert_image_equal(im.convert("RGB"), reloaded.convert("RGB"))
 

docs/releasenotes/13.0.0.rst

@@ -135,7 +135,7 @@ Other changes
 =============
 
 PNG palettes are no longer padded when saving with the ``bits`` argument
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 When saving a ``P`` mode image as a PNG with the ``bits`` argument, Pillow used to pad
 the ``PLTE`` chunk with zeroes up to ``2 ** bits`` entries. The ``PLTE`` chunk now only

src/PIL/PngImagePlugin.py

@@ -1397,25 +1397,17 @@ def _save(
             palette_frame_with_alpha = im if im.palette.mode == "RGBA" else None
 
     outmode = mode
-    palette_colors = None
     if mode == "P":
-        #
-        # attempt to minimize storage requirements for palette images
-        if "bits" in im.encoderinfo:
-            # number of bits specified by user
-            colors = min(1 << im.encoderinfo["bits"], 256)
-
-            if palette:
-                # write only as many PLTE entries as the palette actually
-                # contains, rather than padding out to the full 2**bits
-                palette_colors = max(min(len(palette) // 3, colors), 1)
-        else:
-            # check palette contents
-            if palette:
-                colors = max(min(len(palette) // 3, 256), 1)
-            else:
-                colors = 256
-
+        colors = max(
+            1,
+            min(
+                # number of bits specified by user
+                1 << im.encoderinfo.get("bits", 8),
+                # write only as many PLTE entries as the palette actually contains
+                len(palette) // 3 if palette else 0,
+                256,
+            ),
+        )
         if colors <= 16:
             if colors <= 2:
                 bits = 1
@@ -1425,12 +1417,6 @@ def _save(
                 bits = 4
             outmode += f";{bits}"
 
-    if palette_colors is None:
-        # no palette was available above to trim the PLTE/tRNS chunks to
-        # actual content, so fall back to the number of colors used to
-        # determine the bit depth
-        palette_colors = colors if mode == "P" else None
-
     # get the corresponding PNG mode
     try:
         rawmode, bit_depth, color_type = _OUTMODES[outmode]
@@ -1487,20 +1473,16 @@ def _save(
                 if not after_idat:
                     chunk(fp, cid, data)
 
-    if mode == "P" and palette is not None:
-        assert palette_colors is not None
-        palette_byte_number = palette_colors * 3
-        palette_bytes = bytes(palette[:palette_byte_number])
-        while len(palette_bytes) < palette_byte_number:
-            palette_bytes += b"\0"
+    if mode == "P":
+        palette_bytes = (palette and bytes(palette[: colors * 3])) or b"\x00\x00\x00"
         chunk(fp, b"PLTE", palette_bytes)
 
     transparency = im.encoderinfo.get("transparency", im.info.get("transparency"))
 
     if transparency is not None:
         if mode == "P":
             # limit to actual palette size
-            alpha_bytes = palette_colors
+            alpha_bytes = colors
             if isinstance(transparency, bytes):
                 chunk(fp, b"tRNS", transparency[:alpha_bytes])
             elif isinstance(transparency, int):
@@ -1534,7 +1516,7 @@ def _save(
             raise OSError(msg)
     elif mode == "P" and palette_frame_with_alpha:
         alpha = palette_frame_with_alpha.im.getpalette("RGBA", "A")
-        alpha_bytes = palette_colors
+        alpha_bytes = colors
         chunk(fp, b"tRNS", alpha[:alpha_bytes])
 
     if dpi := im.encoderinfo.get("dpi"):