Merge branch 'python-pillow:main' into palala_pixelsize

.appveyor.yml

@@ -25,8 +25,8 @@ install:
 - mv c:\pillow-depends-main c:\pillow-depends
 - xcopy /S /Y c:\pillow-depends\test_images\* c:\pillow\tests\images
 - 7z x ..\pillow-depends\nasm-2.15.05-win64.zip -oc:\
-- ..\pillow-depends\gs9561w32.exe /S
+- ..\pillow-depends\gs1000w32.exe /S
-- path c:\nasm-2.15.05;C:\Program Files (x86)\gs\gs9.56.1\bin;%PATH%
+- path c:\nasm-2.15.05;C:\Program Files (x86)\gs\gs10.0.0\bin;%PATH%
 - cd c:\pillow\winbuild\
 - ps: |
         c:\python37\python.exe c:\pillow\winbuild\build_prepare.py -v --depends=C:\pillow-depends\

.github/renovate.json

@@ -0,0 +1,17 @@
+{
+    "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+    "extends": [
+        "config:base"
+    ],
+    "labels": [
+        "Dependency"
+    ],
+    "packageRules": [
+        {
+            "groupName": "github-actions",
+            "matchManagers": ["github-actions"],
+            "separateMajorMinor": "false"
+        }
+    ],
+    "schedule": ["on the 3rd day of the month"]
+}

.github/workflows/cifuzz.yml

@@ -14,6 +14,10 @@ on:
 permissions:
   contents: read
 
+concurrency: 
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   Fuzzing:
     runs-on: ubuntu-latest

.github/workflows/lint.yml

@@ -5,6 +5,10 @@ on: [push, pull_request, workflow_dispatch]
 permissions:
   contents: read
 
+concurrency: 
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   build:
 
@@ -16,7 +20,7 @@ jobs:
     - uses: actions/checkout@v3
 
     - name: pre-commit cache
-      uses: actions/cache@v2
+      uses: actions/cache@v3
       with:
         path: ~/.cache/pre-commit
         key: lint-pre-commit-${{ hashFiles('**/.pre-commit-config.yaml') }}
@@ -24,7 +28,7 @@ jobs:
           lint-pre-commit-
 
     - name: Set up Python
-      uses: actions/setup-python@v3
+      uses: actions/setup-python@v4
       with:
         python-version: "3.10"
         cache: pip

.github/workflows/release-drafter.yml

@@ -10,6 +10,10 @@ on:
 permissions:
   contents: read
 
+concurrency: 
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   update_release_draft:
     permissions:

.github/workflows/stale.yml

@@ -8,6 +8,10 @@ on:
 permissions:
   issues: write
 
+concurrency: 
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   stale:
     if: github.repository_owner == 'python-pillow'
@@ -16,7 +20,7 @@ jobs:
 
     steps:
     - name: "Check issues"
-      uses: actions/stale@v5
+      uses: actions/stale@v6
       with:
         repo-token: ${{ secrets.GITHUB_TOKEN }}
         only-labels: "Awaiting OP Action"

.github/workflows/test-cygwin.yml

@@ -5,6 +5,10 @@ on: [push, pull_request, workflow_dispatch]
 permissions:
   contents: read
 
+concurrency: 
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   build:
     runs-on: windows-latest
@@ -44,7 +48,7 @@ jobs:
             qt5-devel-tools subversion xorg-server-extra zlib-devel
 
       - name: Add Lapack to PATH
-        uses: egor-tensin/cleanup-path@v1
+        uses: egor-tensin/cleanup-path@v2
         with:
           dirs: 'C:\cygwin\bin;C:\cygwin\lib\lapack'
 

.github/workflows/test-docker.yml

@@ -5,6 +5,10 @@ on: [push, pull_request, workflow_dispatch]
 permissions:
   contents: read
 
+concurrency: 
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   build:
 
@@ -79,7 +83,7 @@ jobs:
         MATRIX_DOCKER: ${{ matrix.docker }}
 
     - name: Upload coverage
-      uses: codecov/codecov-action@v1
+      uses: codecov/codecov-action@v3
       with:
         flags: GHA_Docker
         name: ${{ matrix.docker }}

.github/workflows/test-mingw.yml

@@ -5,6 +5,10 @@ on: [push, pull_request, workflow_dispatch]
 permissions:
   contents: read
 
+concurrency: 
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   build:
     runs-on: windows-latest
@@ -73,11 +77,11 @@ jobs:
           python3 -m pytest -vx --cov PIL --cov Tests --cov-report term --cov-report xml Tests
 
       - name: Upload coverage
-        run: |
+        uses: codecov/codecov-action@v3
-          python3 -m pip install codecov
+        with:
-          bash <(curl -s https://codecov.io/bash) -F GHA_Windows
+          file: ./coverage.xml
-        env:
+          flags: GHA_Windows
-          CODECOV_NAME: ${{ matrix.name }}
+          name: ${{ matrix.name }}
 
   success:
     permissions:

.github/workflows/test-valgrind.yml

@@ -16,6 +16,10 @@ on:
 permissions:
   contents: read
 
+concurrency: 
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   build:
 

.github/workflows/test-windows.yml

@@ -5,6 +5,10 @@ on: [push, pull_request, workflow_dispatch]
 permissions:
   contents: read
 
+concurrency: 
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   build:
     runs-on: windows-latest
@@ -36,7 +40,7 @@ jobs:
 
     # sets env: pythonLocation
     - name: Set up Python
-      uses: actions/setup-python@v3
+      uses: actions/setup-python@v4
       with:
         python-version: ${{ matrix.python-version }}
         architecture: ${{ matrix.architecture }}
@@ -55,8 +59,8 @@ jobs:
         7z x winbuild\depends\nasm-2.15.05-win64.zip "-o$env:RUNNER_WORKSPACE\"
         echo "$env:RUNNER_WORKSPACE\nasm-2.15.05" >> $env:GITHUB_PATH
 
-        winbuild\depends\gs9561w32.exe /S
+        winbuild\depends\gs1000w32.exe /S
-        echo "C:\Program Files (x86)\gs\gs9.56.1\bin" >> $env:GITHUB_PATH
+        echo "C:\Program Files (x86)\gs\gs10.0.0\bin" >> $env:GITHUB_PATH
 
         xcopy /S /Y winbuild\depends\test_images\* Tests\images\
 
@@ -66,7 +70,7 @@ jobs:
 
     - name: Cache build
       id: build-cache
-      uses: actions/cache@v2
+      uses: actions/cache@v3
       with:
         path: winbuild\build
         key:
@@ -171,7 +175,7 @@ jobs:
       shell: pwsh
 
     - name: Upload coverage
-      uses: codecov/codecov-action@v1
+      uses: codecov/codecov-action@v3
       with:
         file: ./coverage.xml
         flags: GHA_Windows

.github/workflows/test.yml

@@ -5,6 +5,10 @@ on: [push, pull_request, workflow_dispatch]
 permissions:
   contents: read
 
+concurrency: 
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   build:
 
@@ -30,11 +34,6 @@ jobs:
           REVERSE: "--reverse"
         - python-version: "3.8"
           PYTHONOPTIMIZE: 2
-        # Include new variables for Codecov
-        - os: ubuntu-latest
-          codecov-flag: GHA_Ubuntu
-        - os: macos-latest
-          codecov-flag: GHA_macOS
 
     runs-on: ${{ matrix.os }}
     name: ${{ matrix.os }} Python ${{ matrix.python-version }}
@@ -43,7 +42,7 @@ jobs:
     - uses: actions/checkout@v3
 
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v3
+      uses: actions/setup-python@v4
       with:
         python-version: ${{ matrix.python-version }}
         cache: pip
@@ -99,7 +98,6 @@ jobs:
     - name: Docs
       if: startsWith(matrix.os, 'ubuntu') && matrix.python-version == 3.10
       run: |
-        python3 -m pip install furo sphinx-copybutton sphinx-issues sphinx-removed-in sphinxext-opengraph
         make doccheck
 
     - name: After success
@@ -107,9 +105,11 @@ jobs:
         .ci/after_success.sh
 
     - name: Upload coverage
-      run: bash <(curl -s https://codecov.io/bash) -F ${{ matrix.codecov-flag }}
+      uses: codecov/codecov-action@v3
-      env:
+      with:
-        CODECOV_NAME: ${{ matrix.os }} Python ${{ matrix.python-version }}
+        file: ./coverage.xml
+        flags: ${{ matrix.os == 'macos-latest' && 'GHA_macOS' || 'GHA_Ubuntu' }}
+        name: ${{ matrix.os }} Python ${{ matrix.python-version }}
 
   success:
     permissions:

.github/workflows/tidelift.yml

@@ -1,4 +1,5 @@
 name: Tidelift Align
+
 on:
   schedule:
     - cron: "30 2 * * *"  # daily at 02:30 UTC
@@ -15,6 +16,10 @@ on:
 permissions:
   contents: read
 
+concurrency: 
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   build:
     if: github.repository_owner == 'python-pillow'

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/psf/black
-    rev: 22.6.0
+    rev: 22.8.0
     hooks:
       - id: black
         args: ["--target-version", "py37"]
@@ -14,18 +14,18 @@ repos:
       - id: isort
 
   - repo: https://github.com/asottile/yesqa
-    rev: v1.3.0
+    rev: v1.4.0
     hooks:
       - id: yesqa
 
   - repo: https://github.com/Lucas-C/pre-commit-hooks
-    rev: v1.3.0
+    rev: v1.3.1
     hooks:
       - id: remove-tabs
         exclude: (Makefile$|\.bat$|\.cmake$|\.eps$|\.fits$|\.opt$)
 
   - repo: https://github.com/PyCQA/flake8
-    rev: 5.0.2
+    rev: 5.0.4
     hooks:
       - id: flake8
         additional_dependencies: [flake8-2020, flake8-implicit-str-concat]
@@ -40,6 +40,7 @@ repos:
     rev: v4.3.0
     hooks:
       - id: check-merge-conflict
+      - id: check-json
       - id: check-yaml
 
   - repo: https://github.com/sphinx-contrib/sphinx-lint

CHANGES.rst

@@ -5,6 +5,33 @@ Changelog (Pillow)
 9.3.0 (unreleased)
 ------------------
 
+- Added reading of TIFF child images #6569
+  [radarhere]
+
+- Improved ImageOps palette handling #6596
+  [PososikTeam, radarhere]
+
+- Defer parsing of palette into colors #6567
+  [radarhere]
+
+- Apply transparency to P images in ImageTk.PhotoImage #6559
+  [radarhere]
+
+- Use rounding in ImageOps contain() and pad() #6522
+  [bibinhashley, radarhere]
+
+- Fixed GIF remapping to palette with duplicate entries #6548
+  [radarhere]
+
+- Allow remap_palette() to return an image with less than 256 palette entries #6543
+  [radarhere]
+
+- Corrected BMP and TGA palette size when saving #6500
+  [radarhere]
+
+- Do not call load() before draft() in Image.thumbnail #6539
+  [radarhere]
+
 - Copy palette when converting from P to PA #6497
   [radarhere]
 

MANIFEST.in

@@ -25,6 +25,7 @@ exclude .coveragerc
 exclude .editorconfig
 exclude .readthedocs.yml
 exclude codecov.yml
+exclude renovate.json
 global-exclude .git*
 global-exclude *.pyc
 global-exclude *.so

Makefile

@@ -17,11 +17,12 @@ coverage:
 
 .PHONY: doc
 doc:
+	python3 -c "import PIL" > /dev/null 2>&1 || python3 -m pip install .
 	$(MAKE) -C docs html
 
 .PHONY: doccheck
 doccheck:
-	$(MAKE) -C docs html
+	$(MAKE) doc
 # Don't make our tests rely on the links in the docs being up every single build.
 # We don't control them.  But do check, and update them to the target of their redirects.
 	$(MAKE) -C docs linkcheck || true

README.md

@@ -74,6 +74,9 @@ As of 2019, Pillow development is
             <a href="https://pypi.org/project/Pillow/"><img
                 alt="Number of PyPI downloads"
                 src="https://img.shields.io/pypi/dm/pillow.svg"></a>
+            <a href="https://bestpractices.coreinfrastructure.org/projects/6331"><img
+                alt="OpenSSF Best Practices"
+                src="https://bestpractices.coreinfrastructure.org/projects/6331/badge"></a>
         </td>
     </tr>
     <tr>

Tests/test_000_sanity.py

@@ -1,19 +1,18 @@
-import PIL
+from PIL import Image
-import PIL.Image
 
 
 def test_sanity():
     # Make sure we have the binary extension
-    PIL.Image.core.new("L", (100, 100))
+    Image.core.new("L", (100, 100))
 
     # Create an image and do stuff with it.
-    im = PIL.Image.new("1", (100, 100))
+    im = Image.new("1", (100, 100))
     assert (im.mode, im.size) == ("1", (100, 100))
     assert len(im.tobytes()) == 1300
 
     # Create images in all remaining major modes.
-    PIL.Image.new("L", (100, 100))
+    Image.new("L", (100, 100))
-    PIL.Image.new("P", (100, 100))
+    Image.new("P", (100, 100))
-    PIL.Image.new("RGB", (100, 100))
+    Image.new("RGB", (100, 100))
-    PIL.Image.new("I", (100, 100))
+    Image.new("I", (100, 100))
-    PIL.Image.new("F", (100, 100))
+    Image.new("F", (100, 100))

Tests/test_features.py

@@ -70,14 +70,14 @@ def test_libimagequant_version():
     assert re.search(r"\d+\.\d+\.\d+$", features.version("libimagequant"))
 
 
-def test_check_modules():
+@pytest.mark.parametrize("feature", features.modules)
-    for feature in features.modules:
+def test_check_modules(feature):
-        assert features.check_module(feature) in [True, False]
+    assert features.check_module(feature) in [True, False]
 
 
-def test_check_codecs():
+@pytest.mark.parametrize("feature", features.codecs)
-    for feature in features.codecs:
+def test_check_codecs(feature):
-        assert features.check_codec(feature) in [True, False]
+    assert features.check_codec(feature) in [True, False]
 
 
 def test_check_warns_on_nonexistent():

Tests/test_file_apng.py

@@ -39,13 +39,12 @@ def test_apng_basic():
         assert im.getpixel((64, 32)) == (0, 255, 0, 255)
 
 
-def test_apng_fdat():
+@pytest.mark.parametrize(
-    with Image.open("Tests/images/apng/split_fdat.png") as im:
+    "filename",
-        im.seek(im.n_frames - 1)
+    ("Tests/images/apng/split_fdat.png", "Tests/images/apng/split_fdat_zero_chunk.png"),
-        assert im.getpixel((0, 0)) == (0, 255, 0, 255)
+)
-        assert im.getpixel((64, 32)) == (0, 255, 0, 255)
+def test_apng_fdat(filename):
-
+    with Image.open(filename) as im:
-    with Image.open("Tests/images/apng/split_fdat_zero_chunk.png") as im:
         im.seek(im.n_frames - 1)
         assert im.getpixel((0, 0)) == (0, 255, 0, 255)
         assert im.getpixel((64, 32)) == (0, 255, 0, 255)

Tests/test_file_bmp.py

@@ -58,6 +58,18 @@ def test_save_to_bytes():
         assert reloaded.format == "BMP"
 
 
+def test_small_palette(tmp_path):
+    im = Image.new("P", (1, 1))
+    colors = [0, 0, 0, 125, 125, 125, 255, 255, 255]
+    im.putpalette(colors)
+
+    out = str(tmp_path / "temp.bmp")
+    im.save(out)
+
+    with Image.open(out) as reloaded:
+        assert reloaded.getpalette() == colors
+
+
 def test_save_too_large(tmp_path):
     outfile = str(tmp_path / "temp.bmp")
     with Image.new("RGB", (1, 1)) as im:

Tests/test_file_eps.py

@@ -124,14 +124,6 @@ def test_file_object(tmp_path):
             image1.save(fh, "EPS")
 
 
-@pytest.mark.skipif(not HAS_GHOSTSCRIPT, reason="Ghostscript not available")
-def test_iobase_object(tmp_path):
-    # issue 479
-    with Image.open(FILE1) as image1:
-        with open(str(tmp_path / "temp_iobase.eps"), "wb") as fh:
-            image1.save(fh, "EPS")
-
-
 @pytest.mark.skipif(not HAS_GHOSTSCRIPT, reason="Ghostscript not available")
 def test_bytesio_object():
     with open(FILE1, "rb") as f:
@@ -203,25 +195,23 @@ def test_render_scale2():
 
 
 @pytest.mark.skipif(not HAS_GHOSTSCRIPT, reason="Ghostscript not available")
-def test_resize():
+@pytest.mark.parametrize("filename", (FILE1, FILE2, "Tests/images/illu10_preview.eps"))
-    files = [FILE1, FILE2, "Tests/images/illu10_preview.eps"]
+def test_resize(filename):
-    for fn in files:
+    with Image.open(filename) as im:
-        with Image.open(fn) as im:
+        new_size = (100, 100)
-            new_size = (100, 100)
+        im = im.resize(new_size)
-            im = im.resize(new_size)
+        assert im.size == new_size
-            assert im.size == new_size
 
 
 @pytest.mark.skipif(not HAS_GHOSTSCRIPT, reason="Ghostscript not available")
-def test_thumbnail():
+@pytest.mark.parametrize("filename", (FILE1, FILE2))
+def test_thumbnail(filename):
     # Issue #619
     # Arrange
-    files = [FILE1, FILE2]
+    with Image.open(filename) as im:
-    for fn in files:
+        new_size = (100, 100)
-        with Image.open(FILE1) as im:
+        im.thumbnail(new_size)
-            new_size = (100, 100)
+        assert max(im.size) == max(new_size)
-            im.thumbnail(new_size)
-            assert max(im.size) == max(new_size)
 
 
 def test_read_binary_preview():
@@ -266,20 +256,19 @@ def test_readline(tmp_path):
         _test_readline_file_psfile(s, ending)
 
 
-def test_open_eps():
+@pytest.mark.parametrize(
-    # https://github.com/python-pillow/Pillow/issues/1104
+    "filename",
-    # Arrange
+    (
-    FILES = [
         "Tests/images/illu10_no_preview.eps",
         "Tests/images/illu10_preview.eps",
         "Tests/images/illuCS6_no_preview.eps",
         "Tests/images/illuCS6_preview.eps",
-    ]
+    ),
-
+)
-    # Act / Assert
+def test_open_eps(filename):
-    for filename in FILES:
+    # https://github.com/python-pillow/Pillow/issues/1104
-        with Image.open(filename) as img:
+    with Image.open(filename) as img:
-            assert img.mode == "RGB"
+        assert img.mode == "RGB"
 
 
 @pytest.mark.skipif(not HAS_GHOSTSCRIPT, reason="Ghostscript not available")

Tests/test_file_gif.py

@@ -793,24 +793,24 @@ def test_identical_frames(tmp_path):
         assert reread.info["duration"] == 4500
 
 
-def test_identical_frames_to_single_frame(tmp_path):
+@pytest.mark.parametrize(
-    for duration in ([1000, 1500, 2000, 4000], (1000, 1500, 2000, 4000), 8500):
+    "duration", ([1000, 1500, 2000, 4000], (1000, 1500, 2000, 4000), 8500)
-        out = str(tmp_path / "temp.gif")
+)
-        im_list = [
+def test_identical_frames_to_single_frame(duration, tmp_path):
-            Image.new("L", (100, 100), "#000"),
+    out = str(tmp_path / "temp.gif")
-            Image.new("L", (100, 100), "#000"),
+    im_list = [
-            Image.new("L", (100, 100), "#000"),
+        Image.new("L", (100, 100), "#000"),
-        ]
+        Image.new("L", (100, 100), "#000"),
+        Image.new("L", (100, 100), "#000"),
+    ]
 
-        im_list[0].save(
+    im_list[0].save(out, save_all=True, append_images=im_list[1:], duration=duration)
-            out, save_all=True, append_images=im_list[1:], duration=duration
+    with Image.open(out) as reread:
-        )
+        # Assert that all frames were combined
-        with Image.open(out) as reread:
+        assert reread.n_frames == 1
-            # Assert that all frames were combined
-            assert reread.n_frames == 1
 
-            # Assert that the new duration is the total of the identical frames
+        # Assert that the new duration is the total of the identical frames
-            assert reread.info["duration"] == 8500
+        assert reread.info["duration"] == 8500
 
 
 def test_number_of_loops(tmp_path):
@@ -1087,6 +1087,19 @@ def test_palette_save_P(tmp_path):
         assert_image_equal(reloaded, im)
 
 
+def test_palette_save_duplicate_entries(tmp_path):
+    im = Image.new("P", (1, 2))
+    im.putpixel((0, 1), 1)
+
+    im.putpalette((0, 0, 0, 0, 0, 0))
+
+    out = str(tmp_path / "temp.gif")
+    im.save(out, palette=[0, 0, 0, 0, 0, 0, 1, 1, 1])
+
+    with Image.open(out) as reloaded:
+        assert reloaded.convert("RGB").getpixel((0, 1)) == (0, 0, 0)
+
+
 def test_palette_save_all_P(tmp_path):
     frames = []
     colors = ((255, 0, 0), (0, 255, 0))

Tests/test_file_jpeg.py

@@ -150,27 +150,30 @@ class TestFileJpeg:
             assert not im1.info.get("icc_profile")
             assert im2.info.get("icc_profile")
 
-    def test_icc_big(self):
+    @pytest.mark.parametrize(
+        "n",
+        (
+            0,
+            1,
+            3,
+            4,
+            5,
+            65533 - 14,  # full JPEG marker block
+            65533 - 14 + 1,  # full block plus one byte
+            ImageFile.MAXBLOCK,  # full buffer block
+            ImageFile.MAXBLOCK + 1,  # full buffer block plus one byte
+            ImageFile.MAXBLOCK * 4 + 3,  # large block
+        ),
+    )
+    def test_icc_big(self, n):
         # Make sure that the "extra" support handles large blocks
-        def test(n):
+        # The ICC APP marker can store 65519 bytes per marker, so
-            # The ICC APP marker can store 65519 bytes per marker, so
+        # using a 4-byte test code should allow us to detect out of
-            # using a 4-byte test code should allow us to detect out of
+        # order issues.
-            # order issues.
+        icc_profile = (b"Test" * int(n / 4 + 1))[:n]
-            icc_profile = (b"Test" * int(n / 4 + 1))[:n]
+        assert len(icc_profile) == n  # sanity
-            assert len(icc_profile) == n  # sanity
+        im1 = self.roundtrip(hopper(), icc_profile=icc_profile)
-            im1 = self.roundtrip(hopper(), icc_profile=icc_profile)
+        assert im1.info.get("icc_profile") == (icc_profile or None)
-            assert im1.info.get("icc_profile") == (icc_profile or None)
-
-        test(0)
-        test(1)
-        test(3)
-        test(4)
-        test(5)
-        test(65533 - 14)  # full JPEG marker block
-        test(65533 - 14 + 1)  # full block plus one byte
-        test(ImageFile.MAXBLOCK)  # full buffer block
-        test(ImageFile.MAXBLOCK + 1)  # full buffer block plus one byte
-        test(ImageFile.MAXBLOCK * 4 + 3)  # large block
 
     @mark_if_feature_version(
         pytest.mark.valgrind_known_error, "libjpeg_turbo", "2.0", reason="Known Failing"
@@ -649,19 +652,19 @@ class TestFileJpeg:
             # Assert
             assert im.format == "JPEG"
 
-    def test_save_correct_modes(self):
+    @pytest.mark.parametrize("mode", ("1", "L", "RGB", "RGBX", "CMYK", "YCbCr"))
+    def test_save_correct_modes(self, mode):
         out = BytesIO()
-        for mode in ["1", "L", "RGB", "RGBX", "CMYK", "YCbCr"]:
+        img = Image.new(mode, (20, 20))
-            img = Image.new(mode, (20, 20))
+        img.save(out, "JPEG")
-            img.save(out, "JPEG")
 
-    def test_save_wrong_modes(self):
+    @pytest.mark.parametrize("mode", ("LA", "La", "RGBA", "RGBa", "P"))
+    def test_save_wrong_modes(self, mode):
         # ref https://github.com/python-pillow/Pillow/issues/2005
         out = BytesIO()
-        for mode in ["LA", "La", "RGBA", "RGBa", "P"]:
+        img = Image.new(mode, (20, 20))
-            img = Image.new(mode, (20, 20))
+        with pytest.raises(OSError):
-            with pytest.raises(OSError):
+            img.save(out, "JPEG")
-                img.save(out, "JPEG")
 
     def test_save_tiff_with_dpi(self, tmp_path):
         # Arrange

Tests/test_file_jpeg2k.py

@@ -126,14 +126,14 @@ def test_prog_res_rt():
     assert_image_equal(im, test_card)
 
 
-def test_default_num_resolutions():
+@pytest.mark.parametrize("num_resolutions", range(2, 6))
-    for num_resolutions in range(2, 6):
+def test_default_num_resolutions(num_resolutions):
-        d = 1 << (num_resolutions - 1)
+    d = 1 << (num_resolutions - 1)
-        im = test_card.resize((d - 1, d - 1))
+    im = test_card.resize((d - 1, d - 1))
-        with pytest.raises(OSError):
+    with pytest.raises(OSError):
-            roundtrip(im, num_resolutions=num_resolutions)
+        roundtrip(im, num_resolutions=num_resolutions)
-        reloaded = roundtrip(im)
+    reloaded = roundtrip(im)
-        assert_image_equal(im, reloaded)
+    assert_image_equal(im, reloaded)
 
 
 def test_reduce():
@@ -266,14 +266,11 @@ def test_rgba():
             assert jp2.mode == "RGBA"
 
 
-def test_16bit_monochrome_has_correct_mode():
+@pytest.mark.parametrize("ext", (".j2k", ".jp2"))
-    with Image.open("Tests/images/16bit.cropped.j2k") as j2k:
+def test_16bit_monochrome_has_correct_mode(ext):
-        j2k.load()
+    with Image.open("Tests/images/16bit.cropped" + ext) as im:
-        assert j2k.mode == "I;16"
+        im.load()
-
+        assert im.mode == "I;16"
-    with Image.open("Tests/images/16bit.cropped.jp2") as jp2:
-        jp2.load()
-        assert jp2.mode == "I;16"
 
 
 def test_16bit_monochrome_jp2_like_tiff():

Tests/test_file_libtiff.py

@@ -509,20 +509,13 @@ class TestFileLibTiff(LibTiffTestCase):
             # colormap/palette tag
             assert len(reloaded.tag_v2[320]) == 768
 
-    def xtest_bw_compression_w_rgb(self, tmp_path):
+    @pytest.mark.parametrize("compression", ("tiff_ccitt", "group3", "group4"))
-        """This test passes, but when running all tests causes a failure due
+    def test_bw_compression_w_rgb(self, compression, tmp_path):
-        to output on stderr from the error thrown by libtiff. We need to
-        capture that but not now"""
-
         im = hopper("RGB")
         out = str(tmp_path / "temp.tif")
 
         with pytest.raises(OSError):
-            im.save(out, compression="tiff_ccitt")
+            im.save(out, compression=compression)
-        with pytest.raises(OSError):
-            im.save(out, compression="group3")
-        with pytest.raises(OSError):
-            im.save(out, compression="group4")
 
     def test_fp_leak(self):
         im = Image.open("Tests/images/hopper_g4_500.tif")

Tests/test_file_palm.py

@@ -63,19 +63,7 @@ def test_p_mode(tmp_path):
     roundtrip(tmp_path, mode)
 
 
-def test_l_oserror(tmp_path):
+@pytest.mark.parametrize("mode", ("L", "RGB"))
-    # Arrange
+def test_oserror(tmp_path, mode):
-    mode = "L"
-
-    # Act / Assert
-    with pytest.raises(OSError):
-        helper_save_as_palm(tmp_path, mode)
-
-
-def test_rgb_oserror(tmp_path):
-    # Arrange
-    mode = "RGB"
-
-    # Act / Assert
     with pytest.raises(OSError):
         helper_save_as_palm(tmp_path, mode)

Tests/test_file_pcx.py

@@ -39,14 +39,14 @@ def test_invalid_file():
         PcxImagePlugin.PcxImageFile(invalid_file)
 
 
-def test_odd(tmp_path):
+@pytest.mark.parametrize("mode", ("1", "L", "P", "RGB"))
+def test_odd(tmp_path, mode):
     # See issue #523, odd sized images should have a stride that's even.
     # Not that ImageMagick or GIMP write PCX that way.
     # We were not handling properly.
-    for mode in ("1", "L", "P", "RGB"):
+    # larger, odd sized images are better here to ensure that
-        # larger, odd sized images are better here to ensure that
+    # we handle interrupted scan lines properly.
-        # we handle interrupted scan lines properly.
+    _roundtrip(tmp_path, hopper(mode).resize((511, 511)))
-        _roundtrip(tmp_path, hopper(mode).resize((511, 511)))
 
 
 def test_odd_read():

Tests/test_file_pdf.py

@@ -37,6 +37,11 @@ def helper_save_as_pdf(tmp_path, mode, **kwargs):
     return outfile
 
 
+@pytest.mark.parametrize("mode", ("L", "P", "RGB", "CMYK"))
+def test_save(tmp_path, mode):
+    helper_save_as_pdf(tmp_path, mode)
+
+
 @pytest.mark.valgrind_known_error(reason="Temporary skip")
 def test_monochrome(tmp_path):
     # Arrange
@@ -47,38 +52,6 @@ def test_monochrome(tmp_path):
     assert os.path.getsize(outfile) < (5000 if features.check("libtiff") else 15000)
 
 
-def test_greyscale(tmp_path):
-    # Arrange
-    mode = "L"
-
-    # Act / Assert
-    helper_save_as_pdf(tmp_path, mode)
-
-
-def test_rgb(tmp_path):
-    # Arrange
-    mode = "RGB"
-
-    # Act / Assert
-    helper_save_as_pdf(tmp_path, mode)
-
-
-def test_p_mode(tmp_path):
-    # Arrange
-    mode = "P"
-
-    # Act / Assert
-    helper_save_as_pdf(tmp_path, mode)
-
-
-def test_cmyk_mode(tmp_path):
-    # Arrange
-    mode = "CMYK"
-
-    # Act / Assert
-    helper_save_as_pdf(tmp_path, mode)
-
-
 def test_unsupported_mode(tmp_path):
     im = hopper("LA")
     outfile = str(tmp_path / "temp_LA.pdf")

Tests/test_file_tga.py

@@ -120,6 +120,18 @@ def test_save(tmp_path):
         assert test_im.size == (100, 100)
 
 
+def test_small_palette(tmp_path):
+    im = Image.new("P", (1, 1))
+    colors = [0, 0, 0]
+    im.putpalette(colors)
+
+    out = str(tmp_path / "temp.tga")
+    im.save(out)
+
+    with Image.open(out) as reloaded:
+        assert reloaded.getpalette() == colors
+
+
 def test_save_wrong_mode(tmp_path):
     im = hopper("PA")
     out = str(tmp_path / "temp.tga")

Tests/test_file_tiff.py

@@ -84,6 +84,24 @@ class TestFileTiff:
             with Image.open("Tests/images/multipage.tiff") as im:
                 im.load()
 
+    @pytest.mark.parametrize(
+        "path, sizes",
+        (
+            ("Tests/images/hopper.tif", ()),
+            ("Tests/images/child_ifd.tiff", (16, 8)),
+            ("Tests/images/child_ifd_jpeg.tiff", (20,)),
+        ),
+    )
+    def test_get_child_images(self, path, sizes):
+        with Image.open(path) as im:
+            ims = im.get_child_images()
+
+        assert len(ims) == len(sizes)
+        for i, im in enumerate(ims):
+            w = sizes[i]
+            expected = Image.new("RGB", (w, w), "#f00")
+            assert_image_similar(im, expected, 1)
+
     def test_mac_tiff(self):
         # Read RGBa images from macOS [@PIL136]
 
@@ -293,14 +311,17 @@ class TestFileTiff:
             with Image.open("Tests/images/hopper_unknown_pixel_mode.tif"):
                 pass
 
-    def test_n_frames(self):
+    @pytest.mark.parametrize(
-        for path, n_frames in [
+        "path, n_frames",
-            ["Tests/images/multipage-lastframe.tif", 1],
+        (
-            ["Tests/images/multipage.tiff", 3],
+            ("Tests/images/multipage-lastframe.tif", 1),
-        ]:
+            ("Tests/images/multipage.tiff", 3),
-            with Image.open(path) as im:
+        ),
-                assert im.n_frames == n_frames
+    )
-                assert im.is_animated == (n_frames != 1)
+    def test_n_frames(self, path, n_frames):
+        with Image.open(path) as im:
+            assert im.n_frames == n_frames
+            assert im.is_animated == (n_frames != 1)
 
     def test_eoferror(self):
         with Image.open("Tests/images/multipage-lastframe.tif") as im:
@@ -416,12 +437,12 @@ class TestFileTiff:
             len_after = len(dict(im.ifd))
             assert len_before == len_after + 1
 
-    def test_load_byte(self):
+    @pytest.mark.parametrize("legacy_api", (False, True))
-        for legacy_api in [False, True]:
+    def test_load_byte(self, legacy_api):
-            ifd = TiffImagePlugin.ImageFileDirectory_v2()
+        ifd = TiffImagePlugin.ImageFileDirectory_v2()
-            data = b"abc"
+        data = b"abc"
-            ret = ifd.load_byte(data, legacy_api)
+        ret = ifd.load_byte(data, legacy_api)
-            assert ret == b"abc"
+        assert ret == b"abc"
 
     def test_load_string(self):
         ifd = TiffImagePlugin.ImageFileDirectory_v2()
@@ -667,18 +688,15 @@ class TestFileTiff:
             with Image.open(outfile) as reloaded:
                 assert_image_equal_tofile(reloaded, infile)
 
-    def test_palette(self, tmp_path):
+    @pytest.mark.parametrize("mode", ("P", "PA"))
-        def roundtrip(mode):
+    def test_palette(self, mode, tmp_path):
-            outfile = str(tmp_path / "temp.tif")
+        outfile = str(tmp_path / "temp.tif")
 
-            im = hopper(mode)
+        im = hopper(mode)
-            im.save(outfile)
+        im.save(outfile)
 
-            with Image.open(outfile) as reloaded:
+        with Image.open(outfile) as reloaded:
-                assert_image_equal(im.convert("RGB"), reloaded.convert("RGB"))
+            assert_image_equal(im.convert("RGB"), reloaded.convert("RGB"))
-
-        for mode in ["P", "PA"]:
-            roundtrip(mode)
 
     def test_tiff_save_all(self):
         mp = BytesIO()

Tests/test_font_pcf_charsets.py

@@ -1,5 +1,7 @@
 import os
 
+import pytest
+
 from PIL import FontFile, Image, ImageDraw, ImageFont, PcfFontFile
 
 from .helper import (
@@ -59,23 +61,13 @@ def save_font(request, tmp_path, encoding):
     return tempname
 
 
-def _test_sanity(request, tmp_path, encoding):
+@pytest.mark.parametrize("encoding", ("iso8859-1", "iso8859-2", "cp1250"))
+def test_sanity(request, tmp_path, encoding):
     save_font(request, tmp_path, encoding)
 
 
-def test_sanity_iso8859_1(request, tmp_path):
+@pytest.mark.parametrize("encoding", ("iso8859-1", "iso8859-2", "cp1250"))
-    _test_sanity(request, tmp_path, "iso8859-1")
+def test_draw(request, tmp_path, encoding):
-
-
-def test_sanity_iso8859_2(request, tmp_path):
-    _test_sanity(request, tmp_path, "iso8859-2")
-
-
-def test_sanity_cp1250(request, tmp_path):
-    _test_sanity(request, tmp_path, "cp1250")
-
-
-def _test_draw(request, tmp_path, encoding):
     tempname = save_font(request, tmp_path, encoding)
     font = ImageFont.load(tempname)
     im = Image.new("L", (150, 30), "white")
@@ -85,19 +77,8 @@ def _test_draw(request, tmp_path, encoding):
     assert_image_similar_tofile(im, charsets[encoding]["image1"], 0)
 
 
-def test_draw_iso8859_1(request, tmp_path):
+@pytest.mark.parametrize("encoding", ("iso8859-1", "iso8859-2", "cp1250"))
-    _test_draw(request, tmp_path, "iso8859-1")
+def test_textsize(request, tmp_path, encoding):
-
-
-def test_draw_iso8859_2(request, tmp_path):
-    _test_draw(request, tmp_path, "iso8859-2")
-
-
-def test_draw_cp1250(request, tmp_path):
-    _test_draw(request, tmp_path, "cp1250")
-
-
-def _test_textsize(request, tmp_path, encoding):
     tempname = save_font(request, tmp_path, encoding)
     font = ImageFont.load(tempname)
     for i in range(255):
@@ -112,15 +93,3 @@ def _test_textsize(request, tmp_path, encoding):
         msg = message[: i + 1]
         assert font.getlength(msg) == len(msg) * 10
         assert font.getbbox(msg) == (0, 0, len(msg) * 10, 20)
-
-
-def test_textsize_iso8859_1(request, tmp_path):
-    _test_textsize(request, tmp_path, "iso8859-1")
-
-
-def test_textsize_iso8859_2(request, tmp_path):
-    _test_textsize(request, tmp_path, "iso8859-2")
-
-
-def test_textsize_cp1250(request, tmp_path):
-    _test_textsize(request, tmp_path, "cp1250")

Tests/test_image.py

@@ -671,6 +671,7 @@ class TestImage:
 
         im_remapped = im.remap_palette([1, 0])
         assert im_remapped.info["transparency"] == 1
+        assert len(im_remapped.getpalette()) == 6
 
         # Test unused transparency
         im.info["transparency"] = 2

Tests/test_image_filter.py

@@ -5,90 +5,109 @@ from PIL import Image, ImageFilter
 from .helper import assert_image_equal, hopper
 
 
-def test_sanity():
+@pytest.mark.parametrize(
-    def apply_filter(filter_to_apply):
+    "filter_to_apply",
-        for mode in ["L", "RGB", "CMYK"]:
+    (
-            im = hopper(mode)
+        ImageFilter.BLUR,
-            out = im.filter(filter_to_apply)
+        ImageFilter.CONTOUR,
-            assert out.mode == im.mode
+        ImageFilter.DETAIL,
-            assert out.size == im.size
+        ImageFilter.EDGE_ENHANCE,
+        ImageFilter.EDGE_ENHANCE_MORE,
+        ImageFilter.EMBOSS,
+        ImageFilter.FIND_EDGES,
+        ImageFilter.SMOOTH,
+        ImageFilter.SMOOTH_MORE,
+        ImageFilter.SHARPEN,
+        ImageFilter.MaxFilter,
+        ImageFilter.MedianFilter,
+        ImageFilter.MinFilter,
+        ImageFilter.ModeFilter,
+        ImageFilter.GaussianBlur,
+        ImageFilter.GaussianBlur(5),
+        ImageFilter.BoxBlur(5),
+        ImageFilter.UnsharpMask,
+        ImageFilter.UnsharpMask(10),
+    ),
+)
+@pytest.mark.parametrize("mode", ("L", "RGB", "CMYK"))
+def test_sanity(filter_to_apply, mode):
+    im = hopper(mode)
+    out = im.filter(filter_to_apply)
+    assert out.mode == im.mode
+    assert out.size == im.size
 
-    apply_filter(ImageFilter.BLUR)
-    apply_filter(ImageFilter.CONTOUR)
-    apply_filter(ImageFilter.DETAIL)
-    apply_filter(ImageFilter.EDGE_ENHANCE)
-    apply_filter(ImageFilter.EDGE_ENHANCE_MORE)
-    apply_filter(ImageFilter.EMBOSS)
-    apply_filter(ImageFilter.FIND_EDGES)
-    apply_filter(ImageFilter.SMOOTH)
-    apply_filter(ImageFilter.SMOOTH_MORE)
-    apply_filter(ImageFilter.SHARPEN)
-    apply_filter(ImageFilter.MaxFilter)
-    apply_filter(ImageFilter.MedianFilter)
-    apply_filter(ImageFilter.MinFilter)
-    apply_filter(ImageFilter.ModeFilter)
-    apply_filter(ImageFilter.GaussianBlur)
-    apply_filter(ImageFilter.GaussianBlur(5))
-    apply_filter(ImageFilter.BoxBlur(5))
-    apply_filter(ImageFilter.UnsharpMask)
-    apply_filter(ImageFilter.UnsharpMask(10))
 
+@pytest.mark.parametrize("mode", ("L", "RGB", "CMYK"))
+def test_sanity_error(mode):
     with pytest.raises(TypeError):
-        apply_filter("hello")
+        im = hopper(mode)
+        im.filter("hello")
 
 
-def test_crash():
+# crashes on small images
-
+@pytest.mark.parametrize("size", ((1, 1), (2, 2), (3, 3)))
-    # crashes on small images
+def test_crash(size):
-    im = Image.new("RGB", (1, 1))
+    im = Image.new("RGB", size)
-    im.filter(ImageFilter.SMOOTH)
-
-    im = Image.new("RGB", (2, 2))
-    im.filter(ImageFilter.SMOOTH)
-
-    im = Image.new("RGB", (3, 3))
     im.filter(ImageFilter.SMOOTH)
 
 
-def test_modefilter():
+@pytest.mark.parametrize(
-    def modefilter(mode):
+    "mode, expected",
-        im = Image.new(mode, (3, 3), None)
+    (
-        im.putdata(list(range(9)))
+        ("1", (4, 0)),
-        # image is:
+        ("L", (4, 0)),
-        #   0 1 2
+        ("P", (4, 0)),
-        #   3 4 5
+        ("RGB", ((4, 0, 0), (0, 0, 0))),
-        #   6 7 8
+    ),
-        mod = im.filter(ImageFilter.ModeFilter).getpixel((1, 1))
+)
-        im.putdata([0, 0, 1, 2, 5, 1, 5, 2, 0])  # mode=0
+def test_modefilter(mode, expected):
-        mod2 = im.filter(ImageFilter.ModeFilter).getpixel((1, 1))
+    im = Image.new(mode, (3, 3), None)
-        return mod, mod2
+    im.putdata(list(range(9)))
-
+    # image is:
-    assert modefilter("1") == (4, 0)
+    #   0 1 2
-    assert modefilter("L") == (4, 0)
+    #   3 4 5
-    assert modefilter("P") == (4, 0)
+    #   6 7 8
-    assert modefilter("RGB") == ((4, 0, 0), (0, 0, 0))
+    mod = im.filter(ImageFilter.ModeFilter).getpixel((1, 1))
+    im.putdata([0, 0, 1, 2, 5, 1, 5, 2, 0])  # mode=0
+    mod2 = im.filter(ImageFilter.ModeFilter).getpixel((1, 1))
+    assert (mod, mod2) == expected
 
 
-def test_rankfilter():
+@pytest.mark.parametrize(
-    def rankfilter(mode):
+    "mode, expected",
-        im = Image.new(mode, (3, 3), None)
+    (
-        im.putdata(list(range(9)))
+        ("1", (0, 4, 8)),
-        # image is:
+        ("L", (0, 4, 8)),
-        #   0 1 2
+        ("RGB", ((0, 0, 0), (4, 0, 0), (8, 0, 0))),
-        #   3 4 5
+        ("I", (0, 4, 8)),
-        #   6 7 8
+        ("F", (0.0, 4.0, 8.0)),
-        minimum = im.filter(ImageFilter.MinFilter).getpixel((1, 1))
+    ),
-        med = im.filter(ImageFilter.MedianFilter).getpixel((1, 1))
+)
-        maximum = im.filter(ImageFilter.MaxFilter).getpixel((1, 1))
+def test_rankfilter(mode, expected):
-        return minimum, med, maximum
+    im = Image.new(mode, (3, 3), None)
+    im.putdata(list(range(9)))
+    # image is:
+    #   0 1 2
+    #   3 4 5
+    #   6 7 8
+    minimum = im.filter(ImageFilter.MinFilter).getpixel((1, 1))
+    med = im.filter(ImageFilter.MedianFilter).getpixel((1, 1))
+    maximum = im.filter(ImageFilter.MaxFilter).getpixel((1, 1))
+    assert (minimum, med, maximum) == expected
 
-    assert rankfilter("1") == (0, 4, 8)
+
-    assert rankfilter("L") == (0, 4, 8)
+@pytest.mark.parametrize(
+    "filter", (ImageFilter.MinFilter, ImageFilter.MedianFilter, ImageFilter.MaxFilter)
+)
+def test_rankfilter_error(filter):
     with pytest.raises(ValueError):
-        rankfilter("P")
+        im = Image.new("P", (3, 3), None)
-    assert rankfilter("RGB") == ((0, 0, 0), (4, 0, 0), (8, 0, 0))
+        im.putdata(list(range(9)))
-    assert rankfilter("I") == (0, 4, 8)
+        # image is:
-    assert rankfilter("F") == (0.0, 4.0, 8.0)
+        #   0 1 2
+        #   3 4 5
+        #   6 7 8
+        im.filter(filter).getpixel((1, 1))
 
 
 def test_rankfilter_properties():
@@ -110,7 +129,8 @@ def test_kernel_not_enough_coefficients():
         ImageFilter.Kernel((3, 3), (0, 0))
 
 
-def test_consistency_3x3():
+@pytest.mark.parametrize("mode", ("L", "LA", "RGB", "CMYK"))
+def test_consistency_3x3(mode):
     with Image.open("Tests/images/hopper.bmp") as source:
         with Image.open("Tests/images/hopper_emboss.bmp") as reference:
             kernel = ImageFilter.Kernel(
@@ -125,14 +145,14 @@ def test_consistency_3x3():
             source = source.split() * 2
             reference = reference.split() * 2
 
-            for mode in ["L", "LA", "RGB", "CMYK"]:
+            assert_image_equal(
-                assert_image_equal(
+                Image.merge(mode, source[: len(mode)]).filter(kernel),
-                    Image.merge(mode, source[: len(mode)]).filter(kernel),
+                Image.merge(mode, reference[: len(mode)]),
-                    Image.merge(mode, reference[: len(mode)]),
+            )
-                )
 
 
-def test_consistency_5x5():
+@pytest.mark.parametrize("mode", ("L", "LA", "RGB", "CMYK"))
+def test_consistency_5x5(mode):
     with Image.open("Tests/images/hopper.bmp") as source:
         with Image.open("Tests/images/hopper_emboss_more.bmp") as reference:
             kernel = ImageFilter.Kernel(
@@ -149,8 +169,7 @@ def test_consistency_5x5():
             source = source.split() * 2
             reference = reference.split() * 2
 
-            for mode in ["L", "LA", "RGB", "CMYK"]:
+            assert_image_equal(
-                assert_image_equal(
+                Image.merge(mode, source[: len(mode)]).filter(kernel),
-                    Image.merge(mode, source[: len(mode)]).filter(kernel),
+                Image.merge(mode, reference[: len(mode)]),
-                    Image.merge(mode, reference[: len(mode)]),
+            )
-                )

Tests/test_image_reduce.py

@@ -38,58 +38,64 @@ gradients_image = Image.open("Tests/images/radial_gradients.png")
 gradients_image.load()
 
 
-def test_args_factor():
+@pytest.mark.parametrize(
+    "size, expected",
+    (
+        (3, (4, 4)),
+        ((3, 1), (4, 10)),
+        ((1, 3), (10, 4)),
+    ),
+)
+def test_args_factor(size, expected):
     im = Image.new("L", (10, 10))
-
+    assert expected == im.reduce(size).size
-    assert (4, 4) == im.reduce(3).size
-    assert (4, 10) == im.reduce((3, 1)).size
-    assert (10, 4) == im.reduce((1, 3)).size
-
-    with pytest.raises(ValueError):
-        im.reduce(0)
-    with pytest.raises(TypeError):
-        im.reduce(2.0)
-    with pytest.raises(ValueError):
-        im.reduce((0, 10))
 
 
-def test_args_box():
+@pytest.mark.parametrize(
+    "size, expected_error", ((0, ValueError), (2.0, TypeError), ((0, 10), ValueError))
+)
+def test_args_factor_error(size, expected_error):
     im = Image.new("L", (10, 10))
-
+    with pytest.raises(expected_error):
-    assert (5, 5) == im.reduce(2, (0, 0, 10, 10)).size
+        im.reduce(size)
-    assert (1, 1) == im.reduce(2, (5, 5, 6, 6)).size
-
-    with pytest.raises(TypeError):
-        im.reduce(2, "stri")
-    with pytest.raises(TypeError):
-        im.reduce(2, 2)
-    with pytest.raises(ValueError):
-        im.reduce(2, (0, 0, 11, 10))
-    with pytest.raises(ValueError):
-        im.reduce(2, (0, 0, 10, 11))
-    with pytest.raises(ValueError):
-        im.reduce(2, (-1, 0, 10, 10))
-    with pytest.raises(ValueError):
-        im.reduce(2, (0, -1, 10, 10))
-    with pytest.raises(ValueError):
-        im.reduce(2, (0, 5, 10, 5))
-    with pytest.raises(ValueError):
-        im.reduce(2, (5, 0, 5, 10))
 
 
-def test_unsupported_modes():
+@pytest.mark.parametrize(
+    "size, expected",
+    (
+        ((0, 0, 10, 10), (5, 5)),
+        ((5, 5, 6, 6), (1, 1)),
+    ),
+)
+def test_args_box(size, expected):
+    im = Image.new("L", (10, 10))
+    assert expected == im.reduce(2, size).size
+
+
+@pytest.mark.parametrize(
+    "size, expected_error",
+    (
+        ("stri", TypeError),
+        ((0, 0, 11, 10), ValueError),
+        ((0, 0, 10, 11), ValueError),
+        ((-1, 0, 10, 10), ValueError),
+        ((0, -1, 10, 10), ValueError),
+        ((0, 5, 10, 5), ValueError),
+        ((5, 0, 5, 10), ValueError),
+    ),
+)
+def test_args_box_error(size, expected_error):
+    im = Image.new("L", (10, 10))
+    with pytest.raises(expected_error):
+        im.reduce(2, size).size
+
+
+@pytest.mark.parametrize("mode", ("P", "1", "I;16"))
+def test_unsupported_modes(mode):
     im = Image.new("P", (10, 10))
     with pytest.raises(ValueError):
         im.reduce(3)
 
-    im = Image.new("1", (10, 10))
-    with pytest.raises(ValueError):
-        im.reduce(3)
-
-    im = Image.new("I;16", (10, 10))
-    with pytest.raises(ValueError):
-        im.reduce(3)
-
 
 def get_image(mode):
     mode_info = ImageMode.getmode(mode)
@@ -190,70 +196,76 @@ def assert_compare_images(a, b, max_average_diff, max_diff=255):
         )
 
 
-def test_mode_L():
+@pytest.mark.parametrize("factor", remarkable_factors)
+def test_mode_L(factor):
     im = get_image("L")
-    for factor in remarkable_factors:
+    compare_reduce_with_reference(im, factor)
-        compare_reduce_with_reference(im, factor)
+    compare_reduce_with_box(im, factor)
-        compare_reduce_with_box(im, factor)
 
 
-def test_mode_LA():
+@pytest.mark.parametrize("factor", remarkable_factors)
+def test_mode_LA(factor):
     im = get_image("LA")
-    for factor in remarkable_factors:
+    compare_reduce_with_reference(im, factor, 0.8, 5)
-        compare_reduce_with_reference(im, factor, 0.8, 5)
 
+
+@pytest.mark.parametrize("factor", remarkable_factors)
+def test_mode_LA_opaque(factor):
+    im = get_image("LA")
     # With opaque alpha, an error should be way smaller.
     im.putalpha(Image.new("L", im.size, 255))
-    for factor in remarkable_factors:
+    compare_reduce_with_reference(im, factor)
-        compare_reduce_with_reference(im, factor)
+    compare_reduce_with_box(im, factor)
-        compare_reduce_with_box(im, factor)
 
 
-def test_mode_La():
+@pytest.mark.parametrize("factor", remarkable_factors)
+def test_mode_La(factor):
     im = get_image("La")
-    for factor in remarkable_factors:
+    compare_reduce_with_reference(im, factor)
-        compare_reduce_with_reference(im, factor)
+    compare_reduce_with_box(im, factor)
-        compare_reduce_with_box(im, factor)
 
 
-def test_mode_RGB():
+@pytest.mark.parametrize("factor", remarkable_factors)
+def test_mode_RGB(factor):
     im = get_image("RGB")
-    for factor in remarkable_factors:
+    compare_reduce_with_reference(im, factor)
-        compare_reduce_with_reference(im, factor)
+    compare_reduce_with_box(im, factor)
-        compare_reduce_with_box(im, factor)
 
 
-def test_mode_RGBA():
+@pytest.mark.parametrize("factor", remarkable_factors)
+def test_mode_RGBA(factor):
     im = get_image("RGBA")
-    for factor in remarkable_factors:
+    compare_reduce_with_reference(im, factor, 0.8, 5)
-        compare_reduce_with_reference(im, factor, 0.8, 5)
 
+
+@pytest.mark.parametrize("factor", remarkable_factors)
+def test_mode_RGBA_opaque(factor):
+    im = get_image("RGBA")
     # With opaque alpha, an error should be way smaller.
     im.putalpha(Image.new("L", im.size, 255))
-    for factor in remarkable_factors:
+    compare_reduce_with_reference(im, factor)
-        compare_reduce_with_reference(im, factor)
+    compare_reduce_with_box(im, factor)
-        compare_reduce_with_box(im, factor)
 
 
-def test_mode_RGBa():
+@pytest.mark.parametrize("factor", remarkable_factors)
+def test_mode_RGBa(factor):
     im = get_image("RGBa")
-    for factor in remarkable_factors:
+    compare_reduce_with_reference(im, factor)
-        compare_reduce_with_reference(im, factor)
+    compare_reduce_with_box(im, factor)
-        compare_reduce_with_box(im, factor)
 
 
-def test_mode_I():
+@pytest.mark.parametrize("factor", remarkable_factors)
+def test_mode_I(factor):
     im = get_image("I")
-    for factor in remarkable_factors:
+    compare_reduce_with_reference(im, factor)
-        compare_reduce_with_reference(im, factor)
+    compare_reduce_with_box(im, factor)
-        compare_reduce_with_box(im, factor)
 
 
-def test_mode_F():
+@pytest.mark.parametrize("factor", remarkable_factors)
+def test_mode_F(factor):
     im = get_image("F")
-    for factor in remarkable_factors:
+    compare_reduce_with_reference(im, factor, 0, 0)
-        compare_reduce_with_reference(im, factor, 0, 0)
+    compare_reduce_with_box(im, factor)
-        compare_reduce_with_box(im, factor)
 
 
 @skip_unless_feature("jpg_2000")

Tests/test_image_resample.py

@@ -554,44 +554,48 @@ class TestCoreResampleBox:
                 # check that the difference at least that much
                 assert_image_similar(res, im.crop(box), 20, f">>> {size} {box}")
 
-    def test_skip_horizontal(self):
+    @pytest.mark.parametrize(
+        "flt", (Image.Resampling.NEAREST, Image.Resampling.BICUBIC)
+    )
+    def test_skip_horizontal(self, flt):
         # Can skip resize for one dimension
         im = hopper()
 
-        for flt in [Image.Resampling.NEAREST, Image.Resampling.BICUBIC]:
+        for size, box in [
-            for size, box in [
+            ((40, 50), (0, 0, 40, 90)),
-                ((40, 50), (0, 0, 40, 90)),
+            ((40, 50), (0, 20, 40, 90)),
-                ((40, 50), (0, 20, 40, 90)),
+            ((40, 50), (10, 0, 50, 90)),
-                ((40, 50), (10, 0, 50, 90)),
+            ((40, 50), (10, 20, 50, 90)),
-                ((40, 50), (10, 20, 50, 90)),
+        ]:
-            ]:
+            res = im.resize(size, flt, box)
-                res = im.resize(size, flt, box)
+            assert res.size == size
-                assert res.size == size
+            # Borders should be slightly different
-                # Borders should be slightly different
+            assert_image_similar(
-                assert_image_similar(
+                res,
-                    res,
+                im.crop(box).resize(size, flt),
-                    im.crop(box).resize(size, flt),
+                0.4,
-                    0.4,
+                f">>> {size} {box} {flt}",
-                    f">>> {size} {box} {flt}",
+            )
-                )
 
-    def test_skip_vertical(self):
+    @pytest.mark.parametrize(
+        "flt", (Image.Resampling.NEAREST, Image.Resampling.BICUBIC)
+    )
+    def test_skip_vertical(self, flt):
         # Can skip resize for one dimension
         im = hopper()
 
-        for flt in [Image.Resampling.NEAREST, Image.Resampling.BICUBIC]:
+        for size, box in [
-            for size, box in [
+            ((40, 50), (0, 0, 90, 50)),
-                ((40, 50), (0, 0, 90, 50)),
+            ((40, 50), (20, 0, 90, 50)),
-                ((40, 50), (20, 0, 90, 50)),
+            ((40, 50), (0, 10, 90, 60)),
-                ((40, 50), (0, 10, 90, 60)),
+            ((40, 50), (20, 10, 90, 60)),
-                ((40, 50), (20, 10, 90, 60)),
+        ]:
-            ]:
+            res = im.resize(size, flt, box)
-                res = im.resize(size, flt, box)
+            assert res.size == size
-                assert res.size == size
+            # Borders should be slightly different
-                # Borders should be slightly different
+            assert_image_similar(
-                assert_image_similar(
+                res,
-                    res,
+                im.crop(box).resize(size, flt),
-                    im.crop(box).resize(size, flt),
+                0.4,
-                    0.4,
+                f">>> {size} {box} {flt}",
-                    f">>> {size} {box} {flt}",
+            )
-                )

Tests/test_image_split.py

@@ -1,3 +1,5 @@
+import pytest
+
 from PIL import Image, features
 
 from .helper import assert_image_equal, hopper
@@ -29,19 +31,12 @@ def test_split():
     assert split("YCbCr") == [("L", 128, 128), ("L", 128, 128), ("L", 128, 128)]
 
 
-def test_split_merge():
+@pytest.mark.parametrize(
-    def split_merge(mode):
+    "mode", ("1", "L", "I", "F", "P", "RGB", "RGBA", "CMYK", "YCbCr")
-        return Image.merge(mode, hopper(mode).split())
+)
-
+def test_split_merge(mode):
-    assert_image_equal(hopper("1"), split_merge("1"))
+    expected = Image.merge(mode, hopper(mode).split())
-    assert_image_equal(hopper("L"), split_merge("L"))
+    assert_image_equal(hopper(mode), expected)
-    assert_image_equal(hopper("I"), split_merge("I"))
-    assert_image_equal(hopper("F"), split_merge("F"))
-    assert_image_equal(hopper("P"), split_merge("P"))
-    assert_image_equal(hopper("RGB"), split_merge("RGB"))
-    assert_image_equal(hopper("RGBA"), split_merge("RGBA"))
-    assert_image_equal(hopper("CMYK"), split_merge("CMYK"))
-    assert_image_equal(hopper("YCbCr"), split_merge("YCbCr"))
 
 
 def test_split_open(tmp_path):

Tests/test_image_thumbnail.py

@@ -97,6 +97,28 @@ def test_load_first():
         im.thumbnail((64, 64))
         assert im.size == (64, 10)
 
+    # Test thumbnail(), without draft(),
+    # on an image that is large enough once load() has changed the size
+    with Image.open("Tests/images/g4_orientation_5.tif") as im:
+        im.thumbnail((590, 88), reducing_gap=None)
+        assert im.size == (590, 88)
+
+
+def test_load_first_unless_jpeg():
+    # Test that thumbnail() still uses draft() for JPEG
+    with Image.open("Tests/images/hopper.jpg") as im:
+        draft = im.draft
+
+        def im_draft(mode, size):
+            result = draft(mode, size)
+            assert result is not None
+
+            return result
+
+        im.draft = im_draft
+
+        im.thumbnail((64, 64))
+
 
 # valgrind test is failing with memory allocated in libjpeg
 @pytest.mark.valgrind_known_error(reason="Known Failing")

Tests/test_image_transform.py

@@ -75,23 +75,25 @@ class TestImageTransform:
 
         assert_image_equal(transformed, scaled)
 
-    def test_fill(self):
+    @pytest.mark.parametrize(
-        for mode, pixel in [
+        "mode, expected_pixel",
-            ["RGB", (255, 0, 0)],
+        (
-            ["RGBA", (255, 0, 0, 255)],
+            ("RGB", (255, 0, 0)),
-            ["LA", (76, 0)],
+            ("RGBA", (255, 0, 0, 255)),
-        ]:
+            ("LA", (76, 0)),
-            im = hopper(mode)
+        ),
-            (w, h) = im.size
+    )
-            transformed = im.transform(
+    def test_fill(self, mode, expected_pixel):
-                im.size,
+        im = hopper(mode)
-                Image.Transform.EXTENT,
+        (w, h) = im.size
-                (0, 0, w * 2, h * 2),
+        transformed = im.transform(
-                Image.Resampling.BILINEAR,
+            im.size,
-                fillcolor="red",
+            Image.Transform.EXTENT,
-            )
+            (0, 0, w * 2, h * 2),
-
+            Image.Resampling.BILINEAR,
-            assert transformed.getpixel((w - 1, h - 1)) == pixel
+            fillcolor="red",
+        )
+        assert transformed.getpixel((w - 1, h - 1)) == expected_pixel
 
     def test_mesh(self):
         # this should be a checkerboard of halfsized hoppers in ul, lr
@@ -222,14 +224,12 @@ class TestImageTransform:
             with pytest.raises(ValueError):
                 im.transform((100, 100), None)
 
-    def test_unknown_resampling_filter(self):
+    @pytest.mark.parametrize("resample", (Image.Resampling.BOX, "unknown"))
+    def test_unknown_resampling_filter(self, resample):
         with hopper() as im:
             (w, h) = im.size
-            for resample in (Image.Resampling.BOX, "unknown"):
+            with pytest.raises(ValueError):
-                with pytest.raises(ValueError):
+                im.transform((100, 100), Image.Transform.EXTENT, (0, 0, w, h), resample)
-                    im.transform(
-                        (100, 100), Image.Transform.EXTENT, (0, 0, w, h), resample
-                    )
 
 
 class TestImageTransformAffine:
@@ -239,7 +239,16 @@ class TestImageTransformAffine:
         im = hopper("RGB")
         return im.crop((10, 20, im.width - 10, im.height - 20))
 
-    def _test_rotate(self, deg, transpose):
+    @pytest.mark.parametrize(
+        "deg, transpose",
+        (
+            (0, None),
+            (90, Image.Transpose.ROTATE_90),
+            (180, Image.Transpose.ROTATE_180),
+            (270, Image.Transpose.ROTATE_270),
+        ),
+    )
+    def test_rotate(self, deg, transpose):
         im = self._test_image()
 
         angle = -math.radians(deg)
@@ -271,77 +280,65 @@ class TestImageTransformAffine:
             )
             assert_image_equal(transposed, transformed)
 
-    def test_rotate_0_deg(self):
+    @pytest.mark.parametrize(
-        self._test_rotate(0, None)
+        "scale, epsilon_scale",
-
+        (
-    def test_rotate_90_deg(self):
+            (1.1, 6.9),
-        self._test_rotate(90, Image.Transpose.ROTATE_90)
+            (1.5, 5.5),
-
+            (2.0, 5.5),
-    def test_rotate_180_deg(self):
+            (2.3, 3.7),
-        self._test_rotate(180, Image.Transpose.ROTATE_180)
+            (2.5, 3.7),
-
+        ),
-    def test_rotate_270_deg(self):
+    )
-        self._test_rotate(270, Image.Transpose.ROTATE_270)
+    @pytest.mark.parametrize(
-
+        "resample,epsilon",
-    def _test_resize(self, scale, epsilonscale):
+        (
+            (Image.Resampling.NEAREST, 0),
+            (Image.Resampling.BILINEAR, 2),
+            (Image.Resampling.BICUBIC, 1),
+        ),
+    )
+    def test_resize(self, scale, epsilon_scale, resample, epsilon):
         im = self._test_image()
 
         size_up = int(round(im.width * scale)), int(round(im.height * scale))
         matrix_up = [1 / scale, 0, 0, 0, 1 / scale, 0, 0, 0]
         matrix_down = [scale, 0, 0, 0, scale, 0, 0, 0]
 
-        for resample, epsilon in [
+        transformed = im.transform(size_up, self.transform, matrix_up, resample)
+        transformed = transformed.transform(
+            im.size, self.transform, matrix_down, resample
+        )
+        assert_image_similar(transformed, im, epsilon * epsilon_scale)
+
+    @pytest.mark.parametrize(
+        "x, y, epsilon_scale",
+        (
+            (0.1, 0, 3.7),
+            (0.6, 0, 9.1),
+            (50, 50, 0),
+        ),
+    )
+    @pytest.mark.parametrize(
+        "resample, epsilon",
+        (
             (Image.Resampling.NEAREST, 0),
-            (Image.Resampling.BILINEAR, 2),
+            (Image.Resampling.BILINEAR, 1.5),
             (Image.Resampling.BICUBIC, 1),
-        ]:
+        ),
-            transformed = im.transform(size_up, self.transform, matrix_up, resample)
+    )
-            transformed = transformed.transform(
+    def test_translate(self, x, y, epsilon_scale, resample, epsilon):
-                im.size, self.transform, matrix_down, resample
-            )
-            assert_image_similar(transformed, im, epsilon * epsilonscale)
-
-    def test_resize_1_1x(self):
-        self._test_resize(1.1, 6.9)
-
-    def test_resize_1_5x(self):
-        self._test_resize(1.5, 5.5)
-
-    def test_resize_2_0x(self):
-        self._test_resize(2.0, 5.5)
-
-    def test_resize_2_3x(self):
-        self._test_resize(2.3, 3.7)
-
-    def test_resize_2_5x(self):
-        self._test_resize(2.5, 3.7)
-
-    def _test_translate(self, x, y, epsilonscale):
         im = self._test_image()
 
         size_up = int(round(im.width + x)), int(round(im.height + y))
         matrix_up = [1, 0, -x, 0, 1, -y, 0, 0]
         matrix_down = [1, 0, x, 0, 1, y, 0, 0]
 
-        for resample, epsilon in [
+        transformed = im.transform(size_up, self.transform, matrix_up, resample)
-            (Image.Resampling.NEAREST, 0),
+        transformed = transformed.transform(
-            (Image.Resampling.BILINEAR, 1.5),
+            im.size, self.transform, matrix_down, resample
-            (Image.Resampling.BICUBIC, 1),
+        )
-        ]:
+        assert_image_similar(transformed, im, epsilon * epsilon_scale)
-            transformed = im.transform(size_up, self.transform, matrix_up, resample)
-            transformed = transformed.transform(
-                im.size, self.transform, matrix_down, resample
-            )
-            assert_image_similar(transformed, im, epsilon * epsilonscale)
-
-    def test_translate_0_1(self):
-        self._test_translate(0.1, 0, 3.7)
-
-    def test_translate_0_6(self):
-        self._test_translate(0.6, 0, 9.1)
-
-    def test_translate_50(self):
-        self._test_translate(50, 50, 0)
 
 
 class TestImageTransformPerspective(TestImageTransformAffine):

Tests/test_imagedraw.py

@@ -64,7 +64,9 @@ def test_mode_mismatch():
         ImageDraw.ImageDraw(im, mode="L")
 
 
-def helper_arc(bbox, start, end):
+@pytest.mark.parametrize("bbox", (BBOX1, BBOX2))
+@pytest.mark.parametrize("start, end", ((0, 180), (0.5, 180.4)))
+def test_arc(bbox, start, end):
     # Arrange
     im = Image.new("RGB", (W, H))
     draw = ImageDraw.Draw(im)
@@ -76,16 +78,6 @@ def helper_arc(bbox, start, end):
     assert_image_similar_tofile(im, "Tests/images/imagedraw_arc.png", 1)
 
 
-def test_arc1():
-    helper_arc(BBOX1, 0, 180)
-    helper_arc(BBOX1, 0.5, 180.4)
-
-
-def test_arc2():
-    helper_arc(BBOX2, 0, 180)
-    helper_arc(BBOX2, 0.5, 180.4)
-
-
 def test_arc_end_le_start():
     # Arrange
     im = Image.new("RGB", (W, H))
@@ -192,29 +184,21 @@ def test_bitmap():
     assert_image_equal_tofile(im, "Tests/images/imagedraw_bitmap.png")
 
 
-def helper_chord(mode, bbox, start, end):
+@pytest.mark.parametrize("mode", ("RGB", "L"))
+@pytest.mark.parametrize("bbox", (BBOX1, BBOX2))
+def test_chord(mode, bbox):
     # Arrange
     im = Image.new(mode, (W, H))
     draw = ImageDraw.Draw(im)
     expected = f"Tests/images/imagedraw_chord_{mode}.png"
 
     # Act
-    draw.chord(bbox, start, end, fill="red", outline="yellow")
+    draw.chord(bbox, 0, 180, fill="red", outline="yellow")
 
     # Assert
     assert_image_similar_tofile(im, expected, 1)
 
 
-def test_chord1():
-    for mode in ["RGB", "L"]:
-        helper_chord(mode, BBOX1, 0, 180)
-
-
-def test_chord2():
-    for mode in ["RGB", "L"]:
-        helper_chord(mode, BBOX2, 0, 180)
-
-
 def test_chord_width():
     # Arrange
     im = Image.new("RGB", (W, H))
@@ -263,7 +247,9 @@ def test_chord_too_fat():
     assert_image_equal_tofile(im, "Tests/images/imagedraw_chord_too_fat.png")
 
 
-def helper_ellipse(mode, bbox):
+@pytest.mark.parametrize("mode", ("RGB", "L"))
+@pytest.mark.parametrize("bbox", (BBOX1, BBOX2))
+def test_ellipse(mode, bbox):
     # Arrange
     im = Image.new(mode, (W, H))
     draw = ImageDraw.Draw(im)
@@ -276,16 +262,6 @@ def helper_ellipse(mode, bbox):
     assert_image_similar_tofile(im, expected, 1)
 
 
-def test_ellipse1():
-    for mode in ["RGB", "L"]:
-        helper_ellipse(mode, BBOX1)
-
-
-def test_ellipse2():
-    for mode in ["RGB", "L"]:
-        helper_ellipse(mode, BBOX2)
-
-
 def test_ellipse_translucent():
     # Arrange
     im = Image.new("RGB", (W, H))
@@ -405,7 +381,8 @@ def test_ellipse_various_sizes_filled():
     )
 
 
-def helper_line(points):
+@pytest.mark.parametrize("points", (POINTS1, POINTS2))
+def test_line(points):
     # Arrange
     im = Image.new("RGB", (W, H))
     draw = ImageDraw.Draw(im)
@@ -417,14 +394,6 @@ def helper_line(points):
     assert_image_equal_tofile(im, "Tests/images/imagedraw_line.png")
 
 
-def test_line1():
-    helper_line(POINTS1)
-
-
-def test_line2():
-    helper_line(POINTS2)
-
-
 def test_shape1():
     # Arrange
     im = Image.new("RGB", (100, 100), "white")
@@ -484,7 +453,9 @@ def test_transform():
     assert_image_equal(im, expected)
 
 
-def helper_pieslice(bbox, start, end):
+@pytest.mark.parametrize("bbox", (BBOX1, BBOX2))
+@pytest.mark.parametrize("start, end", ((-92, 46), (-92.2, 46.2)))
+def test_pieslice(bbox, start, end):
     # Arrange
     im = Image.new("RGB", (W, H))
     draw = ImageDraw.Draw(im)
@@ -496,16 +467,6 @@ def helper_pieslice(bbox, start, end):
     assert_image_similar_tofile(im, "Tests/images/imagedraw_pieslice.png", 1)
 
 
-def test_pieslice1():
-    helper_pieslice(BBOX1, -92, 46)
-    helper_pieslice(BBOX1, -92.2, 46.2)
-
-
-def test_pieslice2():
-    helper_pieslice(BBOX2, -92, 46)
-    helper_pieslice(BBOX2, -92.2, 46.2)
-
-
 def test_pieslice_width():
     # Arrange
     im = Image.new("RGB", (W, H))
@@ -585,7 +546,8 @@ def test_pieslice_no_spikes():
     assert_image_equal(im, im_pre_erase)
 
 
-def helper_point(points):
+@pytest.mark.parametrize("points", (POINTS1, POINTS2))
+def test_point(points):
     # Arrange
     im = Image.new("RGB", (W, H))
     draw = ImageDraw.Draw(im)
@@ -597,15 +559,8 @@ def helper_point(points):
     assert_image_equal_tofile(im, "Tests/images/imagedraw_point.png")
 
 
-def test_point1():
+@pytest.mark.parametrize("points", (POINTS1, POINTS2))
-    helper_point(POINTS1)
+def test_polygon(points):
-
-
-def test_point2():
-    helper_point(POINTS2)
-
-
-def helper_polygon(points):
     # Arrange
     im = Image.new("RGB", (W, H))
     draw = ImageDraw.Draw(im)
@@ -617,14 +572,6 @@ def helper_polygon(points):
     assert_image_equal_tofile(im, "Tests/images/imagedraw_polygon.png")
 
 
-def test_polygon1():
-    helper_polygon(POINTS1)
-
-
-def test_polygon2():
-    helper_polygon(POINTS2)
-
-
 @pytest.mark.parametrize("mode", ("RGB", "L"))
 def test_polygon_kite(mode):
     # Test drawing lines of different gradients (dx>dy, dy>dx) and
@@ -682,7 +629,8 @@ def test_polygon_translucent():
     assert_image_equal_tofile(im, expected)
 
 
-def helper_rectangle(bbox):
+@pytest.mark.parametrize("bbox", (BBOX1, BBOX2))
+def test_rectangle(bbox):
     # Arrange
     im = Image.new("RGB", (W, H))
     draw = ImageDraw.Draw(im)
@@ -694,14 +642,6 @@ def helper_rectangle(bbox):
     assert_image_equal_tofile(im, "Tests/images/imagedraw_rectangle.png")
 
 
-def test_rectangle1():
-    helper_rectangle(BBOX1)
-
-
-def test_rectangle2():
-    helper_rectangle(BBOX2)
-
-
 def test_big_rectangle():
     # Test drawing a rectangle bigger than the image
     # Arrange
@@ -1503,7 +1443,7 @@ def test_discontiguous_corners_polygon():
     assert_image_similar_tofile(img, expected, 1)
 
 
-def test_polygon():
+def test_polygon2():
     im = Image.new("RGB", (W, H))
     draw = ImageDraw.Draw(im)
     draw.polygon([(18, 30), (19, 31), (18, 30), (85, 30), (60, 72)], "red")

Tests/test_imagedraw2.py

@@ -52,27 +52,19 @@ def test_sanity():
     draw.line(list(range(10)), pen)
 
 
-def helper_ellipse(mode, bbox):
+@pytest.mark.parametrize("bbox", (BBOX1, BBOX2))
+def test_ellipse(bbox):
     # Arrange
     im = Image.new("RGB", (W, H))
     draw = ImageDraw2.Draw(im)
     pen = ImageDraw2.Pen("blue", width=2)
     brush = ImageDraw2.Brush("green")
-    expected = f"Tests/images/imagedraw_ellipse_{mode}.png"
 
     # Act
     draw.ellipse(bbox, pen, brush)
 
     # Assert
-    assert_image_similar_tofile(im, expected, 1)
+    assert_image_similar_tofile(im, "Tests/images/imagedraw_ellipse_RGB.png", 1)
-
-
-def test_ellipse1():
-    helper_ellipse("RGB", BBOX1)
-
-
-def test_ellipse2():
-    helper_ellipse("RGB", BBOX2)
 
 
 def test_ellipse_edge():
@@ -88,7 +80,8 @@ def test_ellipse_edge():
     assert_image_similar_tofile(im, "Tests/images/imagedraw_ellipse_edge.png", 1)
 
 
-def helper_line(points):
+@pytest.mark.parametrize("points", (POINTS1, POINTS2))
+def test_line(points):
     # Arrange
     im = Image.new("RGB", (W, H))
     draw = ImageDraw2.Draw(im)
@@ -101,14 +94,6 @@ def helper_line(points):
     assert_image_equal_tofile(im, "Tests/images/imagedraw_line.png")
 
 
-def test_line1_pen():
-    helper_line(POINTS1)
-
-
-def test_line2_pen():
-    helper_line(POINTS2)
-
-
 def test_line_pen_as_brush():
     # Arrange
     im = Image.new("RGB", (W, H))
@@ -124,7 +109,8 @@ def test_line_pen_as_brush():
     assert_image_equal_tofile(im, "Tests/images/imagedraw_line.png")
 
 
-def helper_polygon(points):
+@pytest.mark.parametrize("points", (POINTS1, POINTS2))
+def test_polygon(points):
     # Arrange
     im = Image.new("RGB", (W, H))
     draw = ImageDraw2.Draw(im)
@@ -138,15 +124,8 @@ def helper_polygon(points):
     assert_image_equal_tofile(im, "Tests/images/imagedraw_polygon.png")
 
 
-def test_polygon1():
+@pytest.mark.parametrize("bbox", (BBOX1, BBOX2))
-    helper_polygon(POINTS1)
+def test_rectangle(bbox):
-
-
-def test_polygon2():
-    helper_polygon(POINTS2)
-
-
-def helper_rectangle(bbox):
     # Arrange
     im = Image.new("RGB", (W, H))
     draw = ImageDraw2.Draw(im)
@@ -160,14 +139,6 @@ def helper_rectangle(bbox):
     assert_image_equal_tofile(im, "Tests/images/imagedraw_rectangle.png")
 
 
-def test_rectangle1():
-    helper_rectangle(BBOX1)
-
-
-def test_rectangle2():
-    helper_rectangle(BBOX2)
-
-
 def test_big_rectangle():
     # Test drawing a rectangle bigger than the image
     # Arrange

Tests/test_imageenhance.py

@@ -1,3 +1,5 @@
+import pytest
+
 from PIL import Image, ImageEnhance
 
 from .helper import assert_image_equal, hopper
@@ -39,17 +41,17 @@ def _check_alpha(im, original, op, amount):
     )
 
 
-def test_alpha():
+@pytest.mark.parametrize("op", ("Color", "Brightness", "Contrast", "Sharpness"))
+def test_alpha(op):
     # Issue https://github.com/python-pillow/Pillow/issues/899
     # Is alpha preserved through image enhancement?
 
     original = _half_transparent_image()
 
-    for op in ["Color", "Brightness", "Contrast", "Sharpness"]:
+    for amount in [0, 0.5, 1.0]:
-        for amount in [0, 0.5, 1.0]:
+        _check_alpha(
-            _check_alpha(
+            getattr(ImageEnhance, op)(original).enhance(amount),
-                getattr(ImageEnhance, op)(original).enhance(amount),
+            original,
-                original,
+            op,
-                op,
+            amount,
-                amount,
+        )
-            )

Tests/test_imagemorph.py

@@ -65,14 +65,16 @@ def create_lut():
 
 
 # create_lut()
-def test_lut():
+@pytest.mark.parametrize(
-    for op in ("corner", "dilation4", "dilation8", "erosion4", "erosion8", "edge"):
+    "op", ("corner", "dilation4", "dilation8", "erosion4", "erosion8", "edge")
-        lb = ImageMorph.LutBuilder(op_name=op)
+)
-        assert lb.get_lut() is None
+def test_lut(op):
+    lb = ImageMorph.LutBuilder(op_name=op)
+    assert lb.get_lut() is None
 
-        lut = lb.build_lut()
+    lut = lb.build_lut()
-        with open(f"Tests/images/{op}.lut", "rb") as f:
+    with open(f"Tests/images/{op}.lut", "rb") as f:
-            assert lut == bytearray(f.read())
+        assert lut == bytearray(f.read())
 
 
 def test_no_operator_loaded():

Tests/test_imageops.py

@@ -110,6 +110,16 @@ def test_contain(new_size):
     assert new_im.size == (256, 256)
 
 
+def test_contain_round():
+    im = Image.new("1", (43, 63), 1)
+    new_im = ImageOps.contain(im, (5, 7))
+    assert new_im.width == 5
+
+    im = Image.new("1", (63, 43), 1)
+    new_im = ImageOps.contain(im, (7, 5))
+    assert new_im.height == 5
+
+
 def test_pad():
     # Same ratio
     im = hopper()
@@ -130,6 +140,30 @@ def test_pad():
             )
 
 
+def test_pad_round():
+    im = Image.new("1", (1, 1), 1)
+    new_im = ImageOps.pad(im, (4, 1))
+    assert new_im.load()[2, 0] == 1
+
+    new_im = ImageOps.pad(im, (1, 4))
+    assert new_im.load()[0, 2] == 1
+
+
+@pytest.mark.parametrize("mode", ("P", "PA"))
+def test_palette(mode):
+    im = hopper(mode)
+
+    # Expand
+    expanded_im = ImageOps.expand(im)
+    assert_image_equal(im.convert("RGB"), expanded_im.convert("RGB"))
+
+    # Pad
+    padded_im = ImageOps.pad(im, (256, 128), centering=(0, 0))
+    assert_image_equal(
+        im.convert("RGB"), padded_im.convert("RGB").crop((0, 0, 128, 128))
+    )
+
+
 def test_pil163():
     # Division by zero in equalize if < 255 pixels in image (@PIL163)
 

Tests/test_imageshow.py

@@ -45,10 +45,10 @@ def test_viewer_show(order):
     not on_ci() or is_win32(),
     reason="Only run on CIs; hangs on Windows CIs",
 )
-def test_show():
+@pytest.mark.parametrize("mode", ("1", "I;16", "LA", "RGB", "RGBA"))
-    for mode in ("1", "I;16", "LA", "RGB", "RGBA"):
+def test_show(mode):
-        im = hopper(mode)
+    im = hopper(mode)
-        assert ImageShow.show(im)
+    assert ImageShow.show(im)
 
 
 def test_show_without_viewers():
@@ -70,12 +70,12 @@ def test_viewer():
         viewer.get_command(None)
 
 
-def test_viewers():
+@pytest.mark.parametrize("viewer", ImageShow._viewers)
-    for viewer in ImageShow._viewers:
+def test_viewers(viewer):
-        try:
+    try:
-            viewer.get_command("test.jpg")
+        viewer.get_command("test.jpg")
-        except NotImplementedError:
+    except NotImplementedError:
-            pass
+        pass
 
 
 def test_ipythonviewer():
@@ -95,14 +95,14 @@ def test_ipythonviewer():
     not on_ci() or is_win32(),
     reason="Only run on CIs; hangs on Windows CIs",
 )
-def test_file_deprecated(tmp_path):
+@pytest.mark.parametrize("viewer", ImageShow._viewers)
+def test_file_deprecated(tmp_path, viewer):
     f = str(tmp_path / "temp.jpg")
-    for viewer in ImageShow._viewers:
+    hopper().save(f)
-        hopper().save(f)
+    with pytest.warns(DeprecationWarning):
-        with pytest.warns(DeprecationWarning):
+        try:
-            try:
+            viewer.show_file(file=f)
-                viewer.show_file(file=f)
+        except NotImplementedError:
-            except NotImplementedError:
+            pass
-                pass
+    with pytest.raises(TypeError):
-        with pytest.raises(TypeError):
+        viewer.show_file()
-            viewer.show_file()

Tests/test_imagetk.py

@@ -54,32 +54,39 @@ def test_kw():
     assert im is None
 
 
-def test_photoimage():
+@pytest.mark.parametrize("mode", TK_MODES)
-    for mode in TK_MODES:
+def test_photoimage(mode):
-        # test as image:
+    # test as image:
-        im = hopper(mode)
+    im = hopper(mode)
 
-        # this should not crash
+    # this should not crash
+    im_tk = ImageTk.PhotoImage(im)
+
+    assert im_tk.width() == im.width
+    assert im_tk.height() == im.height
+
+    reloaded = ImageTk.getimage(im_tk)
+    assert_image_equal(reloaded, im.convert("RGBA"))
+
+
+def test_photoimage_apply_transparency():
+    with Image.open("Tests/images/pil123p.png") as im:
         im_tk = ImageTk.PhotoImage(im)
-
-        assert im_tk.width() == im.width
-        assert im_tk.height() == im.height
-
         reloaded = ImageTk.getimage(im_tk)
         assert_image_equal(reloaded, im.convert("RGBA"))
 
 
-def test_photoimage_blank():
+@pytest.mark.parametrize("mode", TK_MODES)
+def test_photoimage_blank(mode):
     # test a image using mode/size:
-    for mode in TK_MODES:
+    im_tk = ImageTk.PhotoImage(mode, (100, 100))
-        im_tk = ImageTk.PhotoImage(mode, (100, 100))
 
-        assert im_tk.width() == 100
+    assert im_tk.width() == 100
-        assert im_tk.height() == 100
+    assert im_tk.height() == 100
 
-        im = Image.new(mode, (100, 100))
+    im = Image.new(mode, (100, 100))
-        reloaded = ImageTk.getimage(im_tk)
+    reloaded = ImageTk.getimage(im_tk)
-        assert_image_equal(reloaded.convert(mode), im)
+    assert_image_equal(reloaded.convert(mode), im)
 
 
 def test_box_deprecation():

Tests/test_mode_i16.py

@@ -1,3 +1,5 @@
+import pytest
+
 from PIL import Image
 
 from .helper import hopper
@@ -20,65 +22,56 @@ def verify(im1):
             ), f"got {repr(p1)} from mode {im1.mode} at {xy}, expected {repr(p2)}"
 
 
-def test_basic(tmp_path):
+@pytest.mark.parametrize("mode", ("L", "I;16", "I;16B", "I;16L", "I"))
+def test_basic(tmp_path, mode):
     # PIL 1.1 has limited support for 16-bit image data.  Check that
     # create/copy/transform and save works as expected.
 
-    def basic(mode):
+    im_in = original.convert(mode)
+    verify(im_in)
 
-        im_in = original.convert(mode)
+    w, h = im_in.size
-        verify(im_in)
 
-        w, h = im_in.size
+    im_out = im_in.copy()
+    verify(im_out)  # copy
 
-        im_out = im_in.copy()
+    im_out = im_in.transform((w, h), Image.Transform.EXTENT, (0, 0, w, h))
-        verify(im_out)  # copy
+    verify(im_out)  # transform
 
-        im_out = im_in.transform((w, h), Image.Transform.EXTENT, (0, 0, w, h))
+    filename = str(tmp_path / "temp.im")
-        verify(im_out)  # transform
+    im_in.save(filename)
 
-        filename = str(tmp_path / "temp.im")
+    with Image.open(filename) as im_out:
-        im_in.save(filename)
-
-        with Image.open(filename) as im_out:
-
-            verify(im_in)
-            verify(im_out)
-
-        im_out = im_in.crop((0, 0, w, h))
-        verify(im_out)
-
-        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(im_in)
         verify(im_out)
 
-        im_in = Image.new(mode, (1, 1), 1)
+    im_out = im_in.crop((0, 0, w, h))
-        assert im_in.getpixel((0, 0)) == 1
+    verify(im_out)
 
-        im_in.putpixel((0, 0), 2)
+    im_out = Image.new(mode, (w, h), None)
-        assert im_in.getpixel((0, 0)) == 2
+    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))
 
-        if mode == "L":
+    verify(im_in)
-            maximum = 255
+    verify(im_out)
-        else:
-            maximum = 32767
 
-        im_in = Image.new(mode, (1, 1), 256)
+    im_in = Image.new(mode, (1, 1), 1)
-        assert im_in.getpixel((0, 0)) == min(256, maximum)
+    assert im_in.getpixel((0, 0)) == 1
 
-        im_in.putpixel((0, 0), 512)
+    im_in.putpixel((0, 0), 2)
-        assert im_in.getpixel((0, 0)) == min(512, maximum)
+    assert im_in.getpixel((0, 0)) == 2
 
-    basic("L")
+    if mode == "L":
+        maximum = 255
+    else:
+        maximum = 32767
 
-    basic("I;16")
+    im_in = Image.new(mode, (1, 1), 256)
-    basic("I;16B")
+    assert im_in.getpixel((0, 0)) == min(256, maximum)
-    basic("I;16L")
 
-    basic("I")
+    im_in.putpixel((0, 0), 512)
+    assert im_in.getpixel((0, 0)) == min(512, maximum)
 
 
 def test_tobytes():

Tests/test_numpy.py

@@ -137,19 +137,9 @@ def test_save_tiff_uint16():
     assert img_px[0, 0] == pixel_value
 
 
-def test_to_array():
+@pytest.mark.parametrize(
-    def _to_array(mode, dtype):
+    "mode, dtype",
-        img = hopper(mode)
+    (
-
-        # Resize to non-square
-        img = img.crop((3, 0, 124, 127))
-        assert img.size == (121, 127)
-
-        np_img = numpy.array(img)
-        _test_img_equals_nparray(img, np_img)
-        assert np_img.dtype == dtype
-
-    modes = [
         ("L", numpy.uint8),
         ("I", numpy.int32),
         ("F", numpy.float32),
@@ -163,10 +153,18 @@ def test_to_array():
         ("I;16B", ">u2"),
         ("I;16L", "<u2"),
         ("HSV", numpy.uint8),
-    ]
+    ),
+)
+def test_to_array(mode, dtype):
+    img = hopper(mode)
 
-    for mode in modes:
+    # Resize to non-square
-        _to_array(*mode)
+    img = img.crop((3, 0, 124, 127))
+    assert img.size == (121, 127)
+
+    np_img = numpy.array(img)
+    _test_img_equals_nparray(img, np_img)
+    assert np_img.dtype == dtype
 
 
 def test_point_lut():

Tests/test_pickle.py

@@ -60,11 +60,11 @@ def helper_pickle_string(pickle, protocol, test_file, mode):
         ("Tests/images/itxt_chunks.png", None),
     ],
 )
-def test_pickle_image(tmp_path, test_file, test_mode):
+@pytest.mark.parametrize("protocol", range(0, pickle.HIGHEST_PROTOCOL + 1))
+def test_pickle_image(tmp_path, test_file, test_mode, protocol):
     # Act / Assert
-    for protocol in range(0, pickle.HIGHEST_PROTOCOL + 1):
+    helper_pickle_string(pickle, protocol, test_file, test_mode)
-        helper_pickle_string(pickle, protocol, test_file, test_mode)
+    helper_pickle_file(tmp_path, pickle, protocol, test_file, test_mode)
-        helper_pickle_file(tmp_path, pickle, protocol, test_file, test_mode)
 
 
 def test_pickle_la_mode_with_palette(tmp_path):

docs/Makefile

@@ -43,8 +43,7 @@ clean:
 	-rm -rf $(BUILDDIR)/*
 
 install-sphinx:
-	$(PYTHON) -c "import sphinx" > /dev/null 2>&1 || $(PYTHON) -m pip install sphinx
+	$(PYTHON) -m pip install --quiet sphinx sphinx-copybutton sphinx-issues sphinx-removed-in sphinxext-opengraph furo olefile
-	$(PYTHON) -c "import furo" > /dev/null 2>&1 || $(PYTHON) -m pip install furo
 
 html:
 	$(MAKE) install-sphinx

docs/deprecations.rst

@@ -178,6 +178,8 @@ Image.coerce_e
 This undocumented method has been deprecated and will be removed in Pillow 10
 (2023-07-01).
 
+.. _Font size and offset methods:
+
 Font size and offset methods
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -197,6 +199,40 @@ Deprecated                                                                  Use
 :py:meth:`.ImageDraw2.Draw.textsize`                                        :py:meth:`.ImageDraw2.Draw.textbbox` and :py:meth:`.ImageDraw2.Draw.textlength`
 =========================================================================== =============================================================================================================
 
+Previous code:
+
+.. code-block:: python
+
+    from PIL import Image, ImageDraw, ImageFont
+
+    font = ImageFont.truetype("Tests/fonts/FreeMono.ttf")
+    width, height = font.getsize("Hello world")
+    left, top = font.getoffset("Hello world")
+
+    im = Image.new("RGB", (100, 100))
+    draw = ImageDraw.Draw(im)
+    width, height = draw.textsize("Hello world")
+
+    width, height = font.getsize_multiline("Hello\nworld")
+    width, height = draw.multiline_textsize("Hello\nworld")
+
+Use instead:
+
+.. code-block:: python
+
+    from PIL import Image, ImageDraw, ImageFont
+
+    font = ImageFont.truetype("Tests/fonts/FreeMono.ttf")
+    left, top, right, bottom = font.getbbox("Hello world")
+    width, height = right - left, bottom - top
+
+    im = Image.new("RGB", (100, 100))
+    draw = ImageDraw.Draw(im)
+    width = draw.textlength("Hello world")
+
+    left, top, right, bottom = draw.multiline_textbbox((0, 0), "Hello\nworld")
+    width, height = right - left, bottom - top
+
 Removed features
 ----------------
 
@@ -253,7 +289,7 @@ Support for FreeType 2.7 has been removed.
 We recommend upgrading to at least `FreeType`_ 2.10.4, which fixed a severe
 vulnerability introduced in FreeType 2.6 (:cve:`CVE-2020-15999`).
 
-.. _FreeType: https://www.freetype.org
+.. _FreeType: https://freetype.org/
 
 im.offset
 ~~~~~~~~~

docs/handbook/image-file-formats.rst

@@ -31,6 +31,9 @@ BLP is the Blizzard Mipmap Format, a texture format used in World of
 Warcraft. Pillow supports reading ``JPEG`` Compressed or raw ``BLP1``
 images, and all types of ``BLP2`` images.
 
+Saving
+~~~~~~
+
 Pillow supports writing BLP images. The :py:meth:`~PIL.Image.Image.save` method
 can take the following keyword arguments:
 
@@ -46,6 +49,9 @@ or ``RGB`` data. 16-colour images are read as ``P`` images. 4-bit run-length enc
 is not supported. Support for reading 8-bit run-length encoding was added in Pillow
 9.1.0.
 
+Opening
+~~~~~~~
+
 The :py:meth:`~PIL.Image.open` method sets the following
 :py:attr:`~PIL.Image.Image.info` properties:
 
@@ -78,6 +84,9 @@ EPS images. The EPS driver can read EPS images in ``L``, ``LAB``, ``RGB`` and
 than leaving them in the original color space. The EPS driver can write images
 in ``L``, ``RGB`` and ``CMYK`` modes.
 
+Loading
+~~~~~~~
+
 If Ghostscript is available, you can call the :py:meth:`~PIL.Image.Image.load`
 method with the following parameters to affect how Ghostscript renders the EPS
 
@@ -134,6 +143,11 @@ To restore the default behavior, where ``P`` mode images are only converted to
     from PIL import GifImagePlugin
     GifImagePlugin.LOADING_STRATEGY = GifImagePlugin.LoadingStrategy.RGB_AFTER_FIRST
 
+.. _gif-opening:
+
+Opening
+~~~~~~~
+
 The :py:meth:`~PIL.Image.open` method sets the following
 :py:attr:`~PIL.Image.Image.info` properties:
 
@@ -171,6 +185,8 @@ to seek to the next frame (``im.seek(im.tell() + 1)``).
 
 ``im.seek()`` raises an :py:exc:`EOFError` if you try to seek after the last frame.
 
+.. _gif-saving:
+
 Saving
 ~~~~~~
 
@@ -278,6 +294,11 @@ sets the following :py:attr:`~PIL.Image.Image.info` property:
     ask for ``(512, 512, 2)``, the final value of
     :py:attr:`~PIL.Image.Image.size` will be ``(1024, 1024)``).
 
+.. _icns-saving:
+
+Saving
+~~~~~~
+
 The :py:meth:`~PIL.Image.Image.save` method can take the following keyword arguments:
 
 **append_images**
@@ -292,6 +313,11 @@ ICO
 
 ICO is used to store icons on Windows. The largest available icon is read.
 
+.. _ico-saving:
+
+Saving
+~~~~~~
+
 The :py:meth:`~PIL.Image.Image.save` method supports the following options:
 
 **sizes**
@@ -337,6 +363,11 @@ their original size while loading them.
 By default Pillow doesn't allow loading of truncated JPEG files, set
 :data:`.ImageFile.LOAD_TRUNCATED_IMAGES` to override this.
 
+.. _jpeg-opening:
+
+Opening
+~~~~~~~
+
 The :py:meth:`~PIL.Image.open` method may set the following
 :py:attr:`~PIL.Image.Image.info` properties if available:
 
@@ -383,6 +414,10 @@ The :py:meth:`~PIL.Image.open` method may set the following
 
     .. versionadded:: 7.1.0
 
+.. _jpeg-saving:
+
+Saving
+~~~~~~
 
 The :py:meth:`~PIL.Image.Image.save` method supports the following options:
 
@@ -464,6 +499,11 @@ itself.  It is also possible to set ``reduce`` to the number of resolutions to
 discard (each one reduces the size of the resulting image by a factor of 2),
 and ``layers`` to specify the number of quality layers to load.
 
+.. _jpeg-2000-saving:
+
+Saving
+~~~~~~
+
 The :py:meth:`~PIL.Image.Image.save` method supports the following options:
 
 **offset**
@@ -575,6 +615,11 @@ called.
 By default Pillow doesn't allow loading of truncated PNG files, set
 :data:`.ImageFile.LOAD_TRUNCATED_IMAGES` to override this.
 
+.. _png-opening:
+
+Opening
+~~~~~~~
+
 The :py:func:`~PIL.Image.open` function sets the following
 :py:attr:`~PIL.Image.Image.info` properties, when appropriate:
 
@@ -613,6 +658,11 @@ decompression bombs. Additionally, the total size of all of the text
 chunks is limited to :data:`.PngImagePlugin.MAX_TEXT_MEMORY`, defaulting to
 64MB.
 
+.. _png-saving:
+
+Saving
+~~~~~~
+
 The :py:meth:`~PIL.Image.Image.save` method supports the following options:
 
 **optimize**
@@ -803,6 +853,11 @@ Pillow also reads SPIDER stack files containing sequences of SPIDER images. The
 :py:meth:`~PIL.Image.Image.seek` and :py:meth:`~PIL.Image.Image.tell` methods are supported, and
 random access is allowed.
 
+.. _spider-opening:
+
+Opening
+~~~~~~~
+
 The :py:meth:`~PIL.Image.open` method sets the following attributes:
 
 **format**
@@ -819,8 +874,10 @@ is provided for converting floating point data to byte data (mode ``L``)::
 
     im = Image.open("image001.spi").convert2byte()
 
-Writing files in SPIDER format
+.. _spider-saving:
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Saving
+~~~~~~
 
 The extension of SPIDER files may be any 3 alphanumeric characters. Therefore
 the output format must be specified explicitly::
@@ -837,6 +894,11 @@ Pillow reads and writes TGA images containing ``L``, ``LA``, ``P``,
 ``RGB``, and ``RGBA`` data. Pillow can read and write both uncompressed and
 run-length encoded TGAs.
 
+.. _tga-saving:
+
+Saving
+~~~~~~
+
 The :py:meth:`~PIL.Image.Image.save` method can take the following keyword arguments:
 
 **compression**
@@ -871,6 +933,11 @@ uncompressed files.
     support for reading Packbits, LZW and JPEG compressed TIFFs
     without using libtiff.
 
+.. _tiff-opening:
+
+Opening
+~~~~~~~
+
 The :py:meth:`~PIL.Image.open` method sets the following
 :py:attr:`~PIL.Image.Image.info` properties:
 
@@ -922,8 +989,10 @@ and can be accessed in any order.
 ``im.seek()`` raises an :py:exc:`EOFError` if you try to seek after the
 last frame.
 
-Saving Tiff Images
+.. _tiff-saving:
-~~~~~~~~~~~~~~~~~~
+
+Saving
+~~~~~~
 
 The :py:meth:`~PIL.Image.Image.save` method can take the following keyword arguments:
 
@@ -1035,6 +1104,11 @@ WebP
 Pillow reads and writes WebP files. The specifics of Pillow's capabilities with
 this format are currently undocumented.
 
+.. _webp-saving:
+
+Saving
+~~~~~~
+
 The :py:meth:`~PIL.Image.Image.save` method supports the following options:
 
 **lossless**
@@ -1058,7 +1132,7 @@ The :py:meth:`~PIL.Image.Image.save` method supports the following options:
     the system WebP library was built with webpmux support.
 
 Saving sequences
-~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~
 
 .. note::
 
@@ -1173,6 +1247,11 @@ GBR
 
 The GBR decoder reads GIMP brush files, version 1 and 2.
 
+.. _gbr-opening:
+
+Opening
+~~~~~~~
+
 The :py:meth:`~PIL.Image.open` method sets the following
 :py:attr:`~PIL.Image.Image.info` properties:
 
@@ -1188,6 +1267,11 @@ GD
 Pillow reads uncompressed GD2 files. Note that you must use
 :py:func:`PIL.GdImageFile.open` to read such a file.
 
+.. _gd-opening:
+
+Opening
+~~~~~~~
+
 The :py:meth:`~PIL.Image.open` method sets the following
 :py:attr:`~PIL.Image.Image.info` properties:
 
@@ -1227,6 +1311,11 @@ image when first opened. The :py:meth:`~PIL.Image.Image.seek` and :py:meth:`~PIL
 methods may be used to read other pictures from the file. The pictures are
 zero-indexed and random access is supported.
 
+.. _mpo-saving:
+
+Saving
+~~~~~~
+
 When calling :py:meth:`~PIL.Image.Image.save` to write an MPO file, by default
 only the first frame of a multiframe image will be saved. If the ``save_all``
 argument is present and true, then all frames will be saved, and the following
@@ -1326,6 +1415,11 @@ XPM
 
 Pillow reads X pixmap files (mode ``P``) with 256 colors or less.
 
+.. _xpm-opening:
+
+Opening
+~~~~~~~
+
 The :py:meth:`~PIL.Image.open` method sets the following
 :py:attr:`~PIL.Image.Image.info` properties:
 
@@ -1350,6 +1444,11 @@ Pillow can write PDF (Acrobat) images. Such images are written as binary PDF 1.4
 files, using either JPEG or HEX encoding depending on the image mode (and
 whether JPEG support is available or not).
 
+.. _pdf-saving:
+
+Saving
+~~~~~~
+
 The :py:meth:`~PIL.Image.Image.save` method can take the following keyword arguments:
 
 **save_all**

docs/index.rst

@@ -69,6 +69,10 @@ Pillow for enterprise is available via the Tidelift Subscription. `Learn more <h
    :target: https://pypi.org/project/Pillow/
    :alt: Number of PyPI downloads
 
+.. image:: https://bestpractices.coreinfrastructure.org/projects/6331/badge
+   :target: https://bestpractices.coreinfrastructure.org/projects/6331
+   :alt: OpenSSF Best Practices
+
 Overview
 ========
 

docs/installation.rst

@@ -184,7 +184,7 @@ Many of Pillow's features require external libraries:
     loads libfribidi at runtime if it is installed.
     On Windows this requires compiling FriBiDi and installing ``fribidi.dll``
     into a directory listed in the `Dynamic-Link Library Search Order (Microsoft Docs)
-    <https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order#search-order-for-desktop-applications>`_
+    <https://learn.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order#search-order-for-desktop-applications>`_
     (``fribidi-0.dll`` or ``libfribidi-0.dll`` are also detected).
     See `Build Options`_ to see how to build this version.
   * Previous versions of Pillow (5.0.0 to 8.1.2) linked libraqm dynamically at runtime.

docs/reference/ExifTags.rst

@@ -10,7 +10,7 @@ provide constants and clear-text names for various well-known EXIF tags.
 .. py:data:: TAGS
     :type: dict
 
-    The TAG dictionary maps 16-bit integer EXIF tag enumerations to
+    The TAGS dictionary maps 16-bit integer EXIF tag enumerations to
     descriptive string names.  For instance:
 
         >>> from PIL.ExifTags import TAGS

docs/reference/Image.rst

@@ -53,9 +53,9 @@ Functions
         To protect against potential DOS attacks caused by "`decompression bombs`_" (i.e. malicious files
         which decompress into a huge amount of data and are designed to crash or cause disruption by using up
         a lot of memory), Pillow will issue a ``DecompressionBombWarning`` if the number of pixels in an
-        image is over a certain limit, :py:data:`PIL.Image.MAX_IMAGE_PIXELS`.
+        image is over a certain limit, :py:data:`MAX_IMAGE_PIXELS`.
 
-        This threshold can be changed by setting :py:data:`PIL.Image.MAX_IMAGE_PIXELS`. It can be disabled
+        This threshold can be changed by setting :py:data:`MAX_IMAGE_PIXELS`. It can be disabled
         by setting ``Image.MAX_IMAGE_PIXELS = None``.
 
         If desired, the warning can be turned into an error with
@@ -63,7 +63,7 @@ Functions
         ``warnings.simplefilter('ignore', Image.DecompressionBombWarning)``. See also
         `the logging documentation`_ to have warnings output to the logging facility instead of stderr.
 
-        If the number of pixels is greater than twice :py:data:`PIL.Image.MAX_IMAGE_PIXELS`, then a
+        If the number of pixels is greater than twice :py:data:`MAX_IMAGE_PIXELS`, then a
         ``DecompressionBombError`` will be raised instead.
 
     .. _decompression bombs: https://en.wikipedia.org/wiki/Zip_bomb
@@ -255,7 +255,7 @@ This rotates the input image by ``theta`` degrees counter clockwise:
 .. automethod:: PIL.Image.Image.transform
 .. automethod:: PIL.Image.Image.transpose
 
-This flips the input image by using the :data:`PIL.Image.Transpose.FLIP_LEFT_RIGHT`
+This flips the input image by using the :data:`Transpose.FLIP_LEFT_RIGHT`
 method.
 
 .. code-block:: python

docs/reference/ImageDraw.rst

@@ -285,8 +285,8 @@ Methods
     Draws a rectangle.
 
     :param xy: Two points to define the bounding box. Sequence of either
-            ``[(x0, y0), (x1, y1)]`` or ``[x0, y0, x1, y1]``. The second point
+            ``[(x0, y0), (x1, y1)]`` or ``[x0, y0, x1, y1]``. The bounding box
-            is just outside the drawn rectangle.
+            is inclusive of both endpoints.
     :param outline: Color to use for the outline.
     :param fill: Color to use for the fill.
     :param width: The line width, in pixels.
@@ -298,8 +298,8 @@ Methods
     Draws a rounded rectangle.
 
     :param xy: Two points to define the bounding box. Sequence of either
-            ``[(x0, y0), (x1, y1)]`` or ``[x0, y0, x1, y1]``. The second point
+            ``[(x0, y0), (x1, y1)]`` or ``[x0, y0, x1, y1]``. The bounding box
-            is just outside the drawn rectangle.
+            is inclusive of both endpoints.
     :param radius: Radius of the corners.
     :param outline: Color to use for the outline.
     :param fill: Color to use for the fill.
@@ -443,6 +443,8 @@ Methods
 
     .. deprecated:: 9.2.0
 
+    See :ref:`deprecations <Font size and offset methods>` for more information.
+
     Use :py:meth:`textlength()` to measure the offset of following text with
     1/64 pixel precision.
     Use :py:meth:`textbbox()` to get the exact bounding box based on an anchor.
@@ -489,10 +491,14 @@ Methods
 
                      .. versionadded:: 6.2.0
 
+    :return: (width, height)
+
 .. py:method:: ImageDraw.multiline_textsize(text, font=None, spacing=4, direction=None, features=None, language=None, stroke_width=0)
 
     .. deprecated:: 9.2.0
 
+    See :ref:`deprecations <Font size and offset methods>` for more information.
+
     Use :py:meth:`.multiline_textbbox` instead.
 
     Return the size of the given string, in pixels.
@@ -541,6 +547,8 @@ Methods
 
                      .. versionadded:: 6.2.0
 
+    :return: (width, height)
+
 .. py:method:: ImageDraw.textlength(text, font=None, direction=None, features=None, language=None, embedded_color=False)
 
     Returns length (in pixels with 1/64 precision) of given text when rendered
@@ -608,6 +616,7 @@ Methods
                      It should be a `BCP 47 language code`_.
                      Requires libraqm.
     :param embedded_color: Whether to use font embedded color glyphs (COLR, CBDT, SBIX).
+    :return: Width for horizontal, height for vertical text.
 
 .. py:method:: ImageDraw.textbbox(xy, text, font=None, anchor=None, spacing=4, align="left", direction=None, features=None, language=None, stroke_width=0, embedded_color=False)
 
@@ -657,6 +666,7 @@ Methods
                      Requires libraqm.
     :param stroke_width: The width of the text stroke.
     :param embedded_color: Whether to use font embedded color glyphs (COLR, CBDT, SBIX).
+    :return: ``(left, top, right, bottom)`` bounding box
 
 .. py:method:: ImageDraw.multiline_textbbox(xy, text, font=None, anchor=None, spacing=4, align="left", direction=None, features=None, language=None, stroke_width=0, embedded_color=False)
 
@@ -700,6 +710,7 @@ Methods
                      Requires libraqm.
     :param stroke_width: The width of the text stroke.
     :param embedded_color: Whether to use font embedded color glyphs (COLR, CBDT, SBIX).
+    :return: ``(left, top, right, bottom)`` bounding box
 
 .. py:method:: getdraw(im=None, hints=None)
 
@@ -731,4 +742,4 @@ Methods
         homogeneous, but similar, colors.
 
 .. _BCP 47 language code: https://www.w3.org/International/articles/language-tags/
-.. _OpenType docs: https://docs.microsoft.com/en-us/typography/opentype/spec/featurelist
+.. _OpenType docs: https://learn.microsoft.com/en-us/typography/opentype/spec/featurelist

docs/releasenotes/5.2.0.rst

@@ -105,7 +105,7 @@ Resolve confusion getting PIL / Pillow version string
 Re: "version constants deprecated" listed above, as user gnbl notes in #3082:
 
 - it's confusing that PIL.VERSION returns the version string of the former PIL instead of Pillow's
-- there does not seem to be documentation on this version number (why this, will it ever change, ..) e.g. at https://pillow.readthedocs.io/en/5.1.x/about.html#why-a-fork
+- ReadTheDocs documentation is missing for some version branches (why is this, will it ever change, ...)
 - it's confusing that PIL.version is a module and does not return the version information directly or hints on how to get it
 - the package information header is essentially useless (placeholder, does not even mention Pillow, nor the version)
 - PIL._version module documentation comment could explain how to access the version information

docs/releasenotes/9.2.0.rst

@@ -59,6 +59,40 @@ Deprecated                                                                  Use
 :py:meth:`.ImageDraw2.Draw.textsize`                                        :py:meth:`.ImageDraw2.Draw.textbbox` and :py:meth:`.ImageDraw2.Draw.textlength`
 =========================================================================== =============================================================================================================
 
+Previous code:
+
+.. code-block:: python
+
+    from PIL import Image, ImageDraw, ImageFont
+
+    font = ImageFont.truetype("Tests/fonts/FreeMono.ttf")
+    width, height = font.getsize("Hello world")
+    left, top = font.getoffset("Hello world")
+
+    im = Image.new("RGB", (100, 100))
+    draw = ImageDraw.Draw(im)
+    width, height = draw.textsize("Hello world")
+
+    width, height = font.getsize_multiline("Hello\nworld")
+    width, height = draw.multiline_textsize("Hello\nworld")
+
+Use instead:
+
+.. code-block:: python
+
+    from PIL import Image, ImageDraw, ImageFont
+
+    font = ImageFont.truetype("Tests/fonts/FreeMono.ttf")
+    left, top, right, bottom = font.getbbox("Hello world")
+    width, height = right - left, bottom - top
+
+    im = Image.new("RGB", (100, 100))
+    draw = ImageDraw.Draw(im)
+    width = draw.textlength("Hello world")
+
+    left, top, right, bottom = draw.multiline_textbbox((0, 0), "Hello\nworld")
+    width, height = right - left, bottom - top
+
 API Additions
 =============
 

docs/releasenotes/versioning.rst

@@ -11,7 +11,7 @@ Pillow follows `Semantic Versioning <https://semver.org/>`_:
     2. MINOR version when you add functionality in a backwards compatible manner, and
     3. PATCH version when you make backwards compatible bug fixes.
 
-Quarterly releases ("`Main Release <https://github.com/python-pillow/Pillow/blob/main/RELEASING.md#main-release>`_")
+Quarterly releases ("`Main Release <https://github.com/python-pillow/Pillow/blob/main/RELEASING.md#user-content-main-release>`_")
 bump at least the MINOR version, as new functionality has likely been added in the
 prior three months.
 
@@ -21,8 +21,8 @@ these occur every 12-18 months, guided by
 `Python's EOL schedule <https://devguide.python.org/#status-of-python-branches>`_, and
 any APIs that have been deprecated for at least a year are removed at the same time.
 
-PATCH versions ("`Point Release <https://github.com/python-pillow/Pillow/blob/main/RELEASING.md#point-release>`_"
+PATCH versions ("`Point Release <https://github.com/python-pillow/Pillow/blob/main/RELEASING.md#user-content-point-release>`_"
-or "`Embargoed Release <https://github.com/python-pillow/Pillow/blob/main/RELEASING.md#embargoed-release>`_")
+or "`Embargoed Release <https://github.com/python-pillow/Pillow/blob/main/RELEASING.md#user-content-embargoed-release>`_")
 are for security, installation or critical bug fixes. These are less common as it is
 preferred to stick to quarterly releases.
 

setup.cfg

@@ -34,7 +34,11 @@ project_urls =
     Twitter=https://twitter.com/PythonPillow
 
 [options]
+packages = PIL
 python_requires = >=3.7
+include_package_data = True
+package_dir =
+    = src
 
 [options.extras_require]
 docs =

setup.py

@@ -999,9 +999,6 @@ try:
         version=PILLOW_VERSION,
         cmdclass={"build_ext": pil_build_ext},
         ext_modules=ext_modules,
-        include_package_data=True,
-        packages=["PIL"],
-        package_dir={"": "src"},
         zip_safe=not (debug_build() or PLATFORM_MINGW),
     )
 except RequiredDependencyException as err:

src/PIL/BmpImagePlugin.py

@@ -375,6 +375,16 @@ def _save(im, fp, filename, bitmap_header=True):
     header = 40  # or 64 for OS/2 version 2
     image = stride * im.size[1]
 
+    if im.mode == "1":
+        palette = b"".join(o8(i) * 4 for i in (0, 255))
+    elif im.mode == "L":
+        palette = b"".join(o8(i) * 4 for i in range(256))
+    elif im.mode == "P":
+        palette = im.im.getpalette("RGB", "BGRX")
+        colors = len(palette) // 4
+    else:
+        palette = None
+
     # bitmap header
     if bitmap_header:
         offset = 14 + header + colors * 4
@@ -405,14 +415,8 @@ def _save(im, fp, filename, bitmap_header=True):
 
     fp.write(b"\0" * (header - 40))  # padding (for OS/2 format)
 
-    if im.mode == "1":
+    if palette:
-        for i in (0, 255):
+        fp.write(palette)
-            fp.write(o8(i) * 4)
-    elif im.mode == "L":
-        for i in range(256):
-            fp.write(o8(i) * 4)
-    elif im.mode == "P":
-        fp.write(im.im.getpalette("RGB", "BGRX"))
 
     ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, stride, -1))])
 

src/PIL/GifImagePlugin.py

@@ -519,9 +519,8 @@ def _normalize_palette(im, palette, info):
         used_palette_colors = []
         for i in range(0, len(source_palette), 3):
             source_color = tuple(source_palette[i : i + 3])
-            try:
+            index = im.palette.colors.get(source_color)
-                index = im.palette.colors[source_color]
+            if index in used_palette_colors:
-            except KeyError:
                 index = None
             used_palette_colors.append(index)
         for i, index in enumerate(used_palette_colors):

src/PIL/Image.py

@@ -1949,11 +1949,7 @@ class Image:
 
         m_im = m_im.convert("L")
 
-        # Internally, we require 256 palette entries.
+        m_im.putpalette(palette_bytes, palette_mode)
-        new_palette_bytes = (
-            palette_bytes + ((256 * bands) - len(palette_bytes)) * b"\x00"
-        )
-        m_im.putpalette(new_palette_bytes, palette_mode)
         m_im.palette = ImagePalette.ImagePalette(palette_mode, palette=palette_bytes)
 
         if "transparency" in self.info:
@@ -1989,18 +1985,14 @@ class Image:
         :param size: The requested size in pixels, as a 2-tuple:
            (width, height).
         :param resample: An optional resampling filter.  This can be
-           one of :py:data:`PIL.Image.Resampling.NEAREST`,
+           one of :py:data:`Resampling.NEAREST`, :py:data:`Resampling.BOX`,
-           :py:data:`PIL.Image.Resampling.BOX`,
+           :py:data:`Resampling.BILINEAR`, :py:data:`Resampling.HAMMING`,
-           :py:data:`PIL.Image.Resampling.BILINEAR`,
+           :py:data:`Resampling.BICUBIC` or :py:data:`Resampling.LANCZOS`.
-           :py:data:`PIL.Image.Resampling.HAMMING`,
-           :py:data:`PIL.Image.Resampling.BICUBIC` or
-           :py:data:`PIL.Image.Resampling.LANCZOS`.
            If the image has mode "1" or "P", it is always set to
-           :py:data:`PIL.Image.Resampling.NEAREST`.
+           :py:data:`Resampling.NEAREST`. If the image mode specifies a number
-           If the image mode specifies a number of bits, such as "I;16", then the
+           of bits, such as "I;16", then the default filter is
-           default filter is :py:data:`PIL.Image.Resampling.NEAREST`.
+           :py:data:`Resampling.NEAREST`. Otherwise, the default filter is
-           Otherwise, the default filter is
+           :py:data:`Resampling.BICUBIC`. See: :ref:`concept-filters`.
-           :py:data:`PIL.Image.Resampling.BICUBIC`. See: :ref:`concept-filters`.
         :param box: An optional 4-tuple of floats providing
            the source image region to be scaled.
            The values must be within (0, 0, width, height) rectangle.
@@ -2140,12 +2132,12 @@ class Image:
 
         :param angle: In degrees counter clockwise.
         :param resample: An optional resampling filter.  This can be
-           one of :py:data:`PIL.Image.Resampling.NEAREST` (use nearest neighbour),
+           one of :py:data:`Resampling.NEAREST` (use nearest neighbour),
-           :py:data:`PIL.Image.BILINEAR` (linear interpolation in a 2x2
+           :py:data:`Resampling.BILINEAR` (linear interpolation in a 2x2
-           environment), or :py:data:`PIL.Image.Resampling.BICUBIC`
+           environment), or :py:data:`Resampling.BICUBIC` (cubic spline
-           (cubic spline interpolation in a 4x4 environment).
+           interpolation in a 4x4 environment). If omitted, or if the image has
-           If omitted, or if the image has mode "1" or "P", it is
+           mode "1" or "P", it is set to :py:data:`Resampling.NEAREST`.
-           set to :py:data:`PIL.Image.Resampling.NEAREST`. See :ref:`concept-filters`.
+           See :ref:`concept-filters`.
         :param expand: Optional expansion flag.  If true, expands the output
            image to make it large enough to hold the entire rotated image.
            If false or omitted, make the output image the same size as the
@@ -2452,14 +2444,11 @@ class Image:
 
         :param size: Requested size.
         :param resample: Optional resampling filter.  This can be one
-           of :py:data:`PIL.Image.Resampling.NEAREST`,
+           of :py:data:`Resampling.NEAREST`, :py:data:`Resampling.BOX`,
-           :py:data:`PIL.Image.Resampling.BOX`,
+           :py:data:`Resampling.BILINEAR`, :py:data:`Resampling.HAMMING`,
-           :py:data:`PIL.Image.Resampling.BILINEAR`,
+           :py:data:`Resampling.BICUBIC` or :py:data:`Resampling.LANCZOS`.
-           :py:data:`PIL.Image.Resampling.HAMMING`,
+           If omitted, it defaults to :py:data:`Resampling.BICUBIC`.
-           :py:data:`PIL.Image.Resampling.BICUBIC` or
+           (was :py:data:`Resampling.NEAREST` prior to version 2.5.0).
-           :py:data:`PIL.Image.Resampling.LANCZOS`.
-           If omitted, it defaults to :py:data:`PIL.Image.Resampling.BICUBIC`.
-           (was :py:data:`PIL.Image.Resampling.NEAREST` prior to version 2.5.0).
            See: :ref:`concept-filters`.
         :param reducing_gap: Apply optimization by resizing the image
            in two steps. First, reducing the image by integer times
@@ -2478,29 +2467,41 @@ class Image:
         :returns: None
         """
 
-        self.load()
+        provided_size = tuple(map(math.floor, size))
-        x, y = map(math.floor, size)
-        if x >= self.width and y >= self.height:
-            return
 
-        def round_aspect(number, key):
+        def preserve_aspect_ratio():
-            return max(min(math.floor(number), math.ceil(number), key=key), 1)
+            def round_aspect(number, key):
+                return max(min(math.floor(number), math.ceil(number), key=key), 1)
 
-        # preserve aspect ratio
+            x, y = provided_size
-        aspect = self.width / self.height
+            if x >= self.width and y >= self.height:
-        if x / y >= aspect:
+                return
-            x = round_aspect(y * aspect, key=lambda n: abs(aspect - n / y))
+
-        else:
+            aspect = self.width / self.height
-            y = round_aspect(
+            if x / y >= aspect:
-                x / aspect, key=lambda n: 0 if n == 0 else abs(aspect - x / n)
+                x = round_aspect(y * aspect, key=lambda n: abs(aspect - n / y))
-            )
+            else:
-        size = (x, y)
+                y = round_aspect(
+                    x / aspect, key=lambda n: 0 if n == 0 else abs(aspect - x / n)
+                )
+            return x, y
 
         box = None
         if reducing_gap is not None:
+            size = preserve_aspect_ratio()
+            if size is None:
+                return
+
             res = self.draft(None, (size[0] * reducing_gap, size[1] * reducing_gap))
             if res is not None:
                 box = res[1]
+        if box is None:
+            self.load()
+
+            # load() may have changed the size of the image
+            size = preserve_aspect_ratio()
+            if size is None:
+                return
 
         if self.size != size:
             im = self.resize(size, resample, box=box, reducing_gap=reducing_gap)
@@ -2530,11 +2531,11 @@ class Image:
 
         :param size: The output size.
         :param method: The transformation method.  This is one of
-          :py:data:`PIL.Image.Transform.EXTENT` (cut out a rectangular subregion),
+          :py:data:`Transform.EXTENT` (cut out a rectangular subregion),
-          :py:data:`PIL.Image.Transform.AFFINE` (affine transform),
+          :py:data:`Transform.AFFINE` (affine transform),
-          :py:data:`PIL.Image.Transform.PERSPECTIVE` (perspective transform),
+          :py:data:`Transform.PERSPECTIVE` (perspective transform),
-          :py:data:`PIL.Image.Transform.QUAD` (map a quadrilateral to a rectangle), or
+          :py:data:`Transform.QUAD` (map a quadrilateral to a rectangle), or
-          :py:data:`PIL.Image.Transform.MESH` (map a number of source quadrilaterals
+          :py:data:`Transform.MESH` (map a number of source quadrilaterals
           in one operation).
 
           It may also be an :py:class:`~PIL.Image.ImageTransformHandler`
@@ -2554,11 +2555,11 @@ class Image:
                     return method, data
         :param data: Extra data to the transformation method.
         :param resample: Optional resampling filter.  It can be one of
-           :py:data:`PIL.Image.Resampling.NEAREST` (use nearest neighbour),
+           :py:data:`Resampling.NEAREST` (use nearest neighbour),
-           :py:data:`PIL.Image.Resampling.BILINEAR` (linear interpolation in a 2x2
+           :py:data:`Resampling.BILINEAR` (linear interpolation in a 2x2
-           environment), or :py:data:`PIL.Image.BICUBIC` (cubic spline
+           environment), or :py:data:`Resampling.BICUBIC` (cubic spline
            interpolation in a 4x4 environment). If omitted, or if the image
-           has mode "1" or "P", it is set to :py:data:`PIL.Image.Resampling.NEAREST`.
+           has mode "1" or "P", it is set to :py:data:`Resampling.NEAREST`.
            See: :ref:`concept-filters`.
         :param fill: If ``method`` is an
           :py:class:`~PIL.Image.ImageTransformHandler` object, this is one of
@@ -2685,13 +2686,10 @@ class Image:
         """
         Transpose image (flip or rotate in 90 degree steps)
 
-        :param method: One of :py:data:`PIL.Image.Transpose.FLIP_LEFT_RIGHT`,
+        :param method: One of :py:data:`Transpose.FLIP_LEFT_RIGHT`,
-          :py:data:`PIL.Image.Transpose.FLIP_TOP_BOTTOM`,
+          :py:data:`Transpose.FLIP_TOP_BOTTOM`, :py:data:`Transpose.ROTATE_90`,
-          :py:data:`PIL.Image.Transpose.ROTATE_90`,
+          :py:data:`Transpose.ROTATE_180`, :py:data:`Transpose.ROTATE_270`,
-          :py:data:`PIL.Image.Transpose.ROTATE_180`,
+          :py:data:`Transpose.TRANSPOSE` or :py:data:`Transpose.TRANSVERSE`.
-          :py:data:`PIL.Image.Transpose.ROTATE_270`,
-          :py:data:`PIL.Image.Transpose.TRANSPOSE` or
-          :py:data:`PIL.Image.Transpose.TRANSVERSE`.
         :returns: Returns a flipped or rotated copy of this image.
         """
 

src/PIL/ImageFont.py

@@ -141,6 +141,8 @@ class ImageFont:
 
         Use :py:meth:`.getbbox` or :py:meth:`.getlength` instead.
 
+        See :ref:`deprecations <Font size and offset methods>` for more information.
+
         Returns width and height (in pixels) of given text.
 
         :param text: Text to measure.
@@ -338,7 +340,7 @@ class FreeTypeFont:
                          example '-liga' to disable ligatures or '-kern'
                          to disable kerning.  To get all supported
                          features, see
-                         https://docs.microsoft.com/en-us/typography/opentype/spec/featurelist
+                         https://learn.microsoft.com/en-us/typography/opentype/spec/featurelist
                          Requires libraqm.
 
         :param language: Language of the text. Different languages may use
@@ -391,7 +393,7 @@ class FreeTypeFont:
                          example '-liga' to disable ligatures or '-kern'
                          to disable kerning.  To get all supported
                          features, see
-                         https://docs.microsoft.com/en-us/typography/opentype/spec/featurelist
+                         https://learn.microsoft.com/en-us/typography/opentype/spec/featurelist
                          Requires libraqm.
 
         :param language: Language of the text. Different languages may use
@@ -432,6 +434,8 @@ class FreeTypeFont:
         1/64 pixel precision.
         Use :py:meth:`getbbox()` to get the exact bounding box based on an anchor.
 
+        See :ref:`deprecations <Font size and offset methods>` for more information.
+
         Returns width and height (in pixels) of given text if rendered in font with
         provided direction, features, and language.
 
@@ -456,7 +460,7 @@ class FreeTypeFont:
                          example '-liga' to disable ligatures or '-kern'
                          to disable kerning.  To get all supported
                          features, see
-                         https://docs.microsoft.com/en-us/typography/opentype/spec/featurelist
+                         https://learn.microsoft.com/en-us/typography/opentype/spec/featurelist
                          Requires libraqm.
 
                          .. versionadded:: 4.2.0
@@ -500,6 +504,8 @@ class FreeTypeFont:
 
         Use :py:meth:`.ImageDraw.multiline_textbbox` instead.
 
+        See :ref:`deprecations <Font size and offset methods>` for more information.
+
         Returns width and height (in pixels) of given text if rendered in font
         with provided direction, features, and language, while respecting
         newline characters.
@@ -520,7 +526,7 @@ class FreeTypeFont:
                          example '-liga' to disable ligatures or '-kern'
                          to disable kerning.  To get all supported
                          features, see
-                         https://docs.microsoft.com/en-us/typography/opentype/spec/featurelist
+                         https://learn.microsoft.com/en-us/typography/opentype/spec/featurelist
                          Requires libraqm.
 
         :param language: Language of the text. Different languages may use
@@ -559,6 +565,8 @@ class FreeTypeFont:
 
         Use :py:meth:`.getbbox` instead.
 
+        See :ref:`deprecations <Font size and offset methods>` for more information.
+
         Returns the offset of given text. This is the gap between the
         starting coordinate and the first marking. Note that this gap is
         included in the result of :py:func:`~PIL.ImageFont.FreeTypeFont.getsize`.
@@ -610,7 +618,7 @@ class FreeTypeFont:
                          example '-liga' to disable ligatures or '-kern'
                          to disable kerning.  To get all supported
                          features, see
-                         https://docs.microsoft.com/en-us/typography/opentype/spec/featurelist
+                         https://learn.microsoft.com/en-us/typography/opentype/spec/featurelist
                          Requires libraqm.
 
                          .. versionadded:: 4.2.0
@@ -702,7 +710,7 @@ class FreeTypeFont:
                          example '-liga' to disable ligatures or '-kern'
                          to disable kerning.  To get all supported
                          features, see
-                         https://docs.microsoft.com/en-us/typography/opentype/spec/featurelist
+                         https://learn.microsoft.com/en-us/typography/opentype/spec/featurelist
                          Requires libraqm.
 
                          .. versionadded:: 4.2.0
@@ -852,6 +860,8 @@ class TransposedFont:
         .. deprecated:: 9.2.0
 
         Use :py:meth:`.getbbox` or :py:meth:`.getlength` instead.
+
+        See :ref:`deprecations <Font size and offset methods>` for more information.
         """
         deprecate("getsize", 10, "getbbox or getlength")
         with warnings.catch_warnings():

src/PIL/ImageOps.py

@@ -21,7 +21,7 @@ import functools
 import operator
 import re
 
-from . import Image
+from . import Image, ImagePalette
 
 #
 # helpers
@@ -255,11 +255,11 @@ def contain(image, size, method=Image.Resampling.BICUBIC):
 
     if im_ratio != dest_ratio:
         if im_ratio > dest_ratio:
-            new_height = int(image.height / image.width * size[0])
+            new_height = round(image.height / image.width * size[0])
             if new_height != size[1]:
                 size = (size[0], new_height)
         else:
-            new_width = int(image.width / image.height * size[1])
+            new_width = round(image.width / image.height * size[1])
             if new_width != size[0]:
                 size = (new_width, size[1])
     return image.resize(size, resample=method)
@@ -291,11 +291,13 @@ def pad(image, size, method=Image.Resampling.BICUBIC, color=None, centering=(0.5
         out = resized
     else:
         out = Image.new(image.mode, size, color)
+        if resized.palette:
+            out.putpalette(resized.getpalette())
         if resized.width != size[0]:
-            x = int((size[0] - resized.width) * max(0, min(centering[0], 1)))
+            x = round((size[0] - resized.width) * max(0, min(centering[0], 1)))
             out.paste(resized, (x, 0))
         else:
-            y = int((size[1] - resized.height) * max(0, min(centering[1], 1)))
+            y = round((size[1] - resized.height) * max(0, min(centering[1], 1)))
             out.paste(resized, (0, y))
     return out
 
@@ -396,9 +398,8 @@ def expand(image, border=0, fill=0):
     width = left + image.size[0] + right
     height = top + image.size[1] + bottom
     color = _color(fill, image.mode)
-    if image.mode == "P" and image.palette:
+    if image.palette:
-        image.load()
+        palette = ImagePalette.ImagePalette(palette=image.getpalette())
-        palette = image.palette.copy()
         if isinstance(color, tuple):
             color = palette.getcolor(color)
     else:

src/PIL/ImagePalette.py

@@ -50,15 +50,24 @@ class ImagePalette:
 
     @palette.setter
     def palette(self, palette):
+        self._colors = None
         self._palette = palette
 
-        mode_len = len(self.mode)
+    @property
-        self.colors = {}
+    def colors(self):
-        for i in range(0, len(self.palette), mode_len):
+        if self._colors is None:
-            color = tuple(self.palette[i : i + mode_len])
+            mode_len = len(self.mode)
-            if color in self.colors:
+            self._colors = {}
-                continue
+            for i in range(0, len(self.palette), mode_len):
-            self.colors[color] = i // mode_len
+                color = tuple(self.palette[i : i + mode_len])
+                if color in self._colors:
+                    continue
+                self._colors[color] = i // mode_len
+        return self._colors
+
+    @colors.setter
+    def colors(self, colors):
+        self._colors = colors
 
     def copy(self):
         new = ImagePalette()

src/PIL/ImageTk.py

@@ -107,6 +107,7 @@ class PhotoImage:
             mode = image.mode
             if mode == "P":
                 # palette mapped data
+                image.apply_transparency()
                 image.load()
                 try:
                     mode = image.palette.mode

src/PIL/TgaImagePlugin.py

@@ -193,9 +193,10 @@ def _save(im, fp, filename):
         warnings.warn("id_section has been trimmed to 255 characters")
 
     if colormaptype:
-        colormapfirst, colormaplength, colormapentry = 0, 256, 24
+        palette = im.im.getpalette("RGB", "BGR")
+        colormaplength, colormapentry = len(palette) // 3, 24
     else:
-        colormapfirst, colormaplength, colormapentry = 0, 0, 0
+        colormaplength, colormapentry = 0, 0
 
     if im.mode in ("LA", "RGBA"):
         flags = 8
@@ -210,7 +211,7 @@ def _save(im, fp, filename):
         o8(id_len)
         + o8(colormaptype)
         + o8(imagetype)
-        + o16(colormapfirst)
+        + o16(0)  # colormapfirst
         + o16(colormaplength)
         + o8(colormapentry)
         + o16(0)
@@ -225,7 +226,7 @@ def _save(im, fp, filename):
         fp.write(id_section)
 
     if colormaptype:
-        fp.write(im.im.getpalette("RGB", "BGR"))
+        fp.write(palette)
 
     if rle:
         ImageFile._save(

src/PIL/TiffImagePlugin.py

@@ -1148,6 +1148,39 @@ class TiffImageFile(ImageFile.ImageFile):
         """Return the current frame number"""
         return self.__frame
 
+    def get_child_images(self):
+        if SUBIFD not in self.tag_v2:
+            return []
+        child_images = []
+        exif = self.getexif()
+        offset = None
+        for im_offset in self.tag_v2[SUBIFD]:
+            # reset buffered io handle in case fp
+            # was passed to libtiff, invalidating the buffer
+            current_offset = self._fp.tell()
+            if offset is None:
+                offset = current_offset
+
+            fp = self._fp
+            ifd = exif._get_ifd_dict(im_offset)
+            jpegInterchangeFormat = ifd.get(513)
+            if jpegInterchangeFormat is not None:
+                fp.seek(jpegInterchangeFormat)
+                jpeg_data = fp.read(ifd.get(514))
+
+                fp = io.BytesIO(jpeg_data)
+
+            with Image.open(fp) as im:
+                if jpegInterchangeFormat is None:
+                    im._frame_pos = [im_offset]
+                    im._seek(0)
+                im.load()
+                child_images.append(im)
+
+        if offset is not None:
+            self._fp.seek(offset)
+        return child_images
+
     def getxmp(self):
         """
         Returns a dictionary containing the XMP tags.

src/PIL/TiffTags.py

@@ -160,6 +160,7 @@ TAGS_V2 = {
     323: ("TileLength", LONG, 1),
     324: ("TileOffsets", LONG, 0),
     325: ("TileByteCounts", LONG, 0),
+    330: ("SubIFDs", LONG, 0),
     332: ("InkSet", SHORT, 1),
     333: ("InkNames", ASCII, 1),
     334: ("NumberOfInks", SHORT, 1),

src/libImaging/TiffDecode.c

@@ -24,7 +24,7 @@
  *
  * This cast is safe, as the top 32-bits of HFILE are guaranteed to be zero,
  * see
- * https://docs.microsoft.com/en-us/windows/win32/winprog64/interprocess-communication
+ * https://learn.microsoft.com/en-us/windows/win32/winprog64/interprocess-communication
  */
 #ifndef USE_WIN32_FILEIO
 #define fd_to_tiff_fd(fd) (fd)

src/thirdparty/raqm/README.md

@@ -81,5 +81,5 @@ The following projects have patches to support complex text layout using Raqm:
 [1]: https://github.com/fribidi/fribidi
 [2]: https://github.com/Tehreer/SheenBidi
 [3]: https://github.com/harfbuzz/harfbuzz
-[4]: https://www.freetype.org
+[4]: https://freetype.org/
 [5]: https://www.gtk.org/gtk-doc

winbuild/build_prepare.py

@@ -281,9 +281,9 @@ deps = {
         "libs": [r"imagequant.lib"],
     },
     "harfbuzz": {
-        "url": "https://github.com/harfbuzz/harfbuzz/archive/5.1.0.zip",
+        "url": "https://github.com/harfbuzz/harfbuzz/archive/5.2.0.zip",
-        "filename": "harfbuzz-5.1.0.zip",
+        "filename": "harfbuzz-5.2.0.zip",
-        "dir": "harfbuzz-5.1.0",
+        "dir": "harfbuzz-5.2.0",
         "build": [
             cmd_cmake("-DHB_HAVE_FREETYPE:BOOL=TRUE"),
             cmd_nmake(target="clean"),