Merge branch 'main' into mode_enums

.ci/install.sh

@@ -51,10 +51,10 @@ pushd depends && ./install_webp.sh && popd
 pushd depends && ./install_imagequant.sh && popd
 
 # raqm
-pushd depends && ./install_raqm.sh && popd
+pushd depends && sudo ./install_raqm.sh && popd
 
 # libavif
-pushd depends && ./install_libavif.sh && popd
+pushd depends && sudo ./install_libavif.sh && popd
 
 # extra test images
 pushd depends && ./install_extra_test_images.sh && popd

.ci/requirements-cibw.txt

@@ -1 +1 @@
-cibuildwheel==3.1.4
+cibuildwheel==3.2.1

.ci/requirements-mypy.txt

@@ -1,4 +1,4 @@
-mypy==1.17.1
+mypy==1.18.2
 IceSpringPySideStubs-PyQt6
 IceSpringPySideStubs-PySide6
 ipython

.github/workflows/docs.yml

@@ -37,7 +37,7 @@ jobs:
         persist-credentials: false
 
     - name: Set up Python
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v6
       with:
         python-version: "3.x"
         cache: pip

.github/workflows/lint.yml

@@ -33,7 +33,7 @@ jobs:
           lint-pre-commit-
 
     - name: Set up Python
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v6
       with:
         python-version: "3.x"
         cache: pip

.github/workflows/macos-install.sh

@@ -2,9 +2,6 @@
 
 set -e
 
-if [[ "$ImageOS" == "macos13" ]]; then
-    brew uninstall gradle maven
-fi
 brew install \
     aom \
     dav1d \

.github/workflows/stale.yml

@@ -22,7 +22,7 @@ jobs:
 
     steps:
     - name: "Check issues"
-      uses: actions/stale@v9
+      uses: actions/stale@v10
       with:
         repo-token: ${{ secrets.GITHUB_TOKEN }}
         only-labels: "Awaiting OP Action"

.github/workflows/test-windows.yml

@@ -67,7 +67,7 @@ jobs:
 
     # sets env: pythonLocation
     - name: Set up Python
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v6
       with:
         python-version: ${{ matrix.python-version }}
         allow-prereleases: true
@@ -97,8 +97,8 @@ jobs:
         choco install nasm --no-progress
         echo "C:\Program Files\NASM" >> $env:GITHUB_PATH
 
-        choco install ghostscript --version=10.5.1 --no-progress
+        choco install ghostscript --version=10.6.0 --no-progress
-        echo "C:\Program Files\gs\gs10.05.1\bin" >> $env:GITHUB_PATH
+        echo "C:\Program Files\gs\gs10.06.0\bin" >> $env:GITHUB_PATH
 
         # Install extra test images
         xcopy /S /Y Tests\test-images\* Tests\images

.github/workflows/test.yml

@@ -57,7 +57,7 @@ jobs:
         - { python-version: "3.14t", disable-gil: true }
         - { python-version: "3.13t", disable-gil: true }
         # Intel
-        - { os: "macos-13", python-version: "3.10" }
+        - { os: "macos-15-intel", python-version: "3.10" }
         exclude:
         - { os: "macos-latest", python-version: "3.10" }
 
@@ -70,7 +70,7 @@ jobs:
         persist-credentials: false
 
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v6
       with:
         python-version: ${{ matrix.python-version }}
         allow-prereleases: true

.github/workflows/wheels-dependencies.sh

@@ -93,16 +93,20 @@ ARCHIVE_SDIR=pillow-depends-main
 # Package versions for fresh source builds. Version numbers with "Patched"
 # annotations have a source code patch that is required for some platforms. If
 # you change those versions, ensure the patch is also updated.
-FREETYPE_VERSION=2.13.3
+if [[ -n "$IOS_SDK" ]]; then
-HARFBUZZ_VERSION=11.3.3
+  FREETYPE_VERSION=2.13.3
+else
+  FREETYPE_VERSION=2.14.1
+fi
+HARFBUZZ_VERSION=12.1.0
 LIBPNG_VERSION=1.6.50
-JPEGTURBO_VERSION=3.1.1
+JPEGTURBO_VERSION=3.1.2
-OPENJPEG_VERSION=2.5.3
+OPENJPEG_VERSION=2.5.4
 XZ_VERSION=5.8.1
-TIFF_VERSION=4.7.0
+ZSTD_VERSION=1.5.7
+TIFF_VERSION=4.7.1
 LCMS2_VERSION=2.17
-ZLIB_VERSION=1.3.1
+ZLIB_NG_VERSION=2.2.5
-ZLIB_NG_VERSION=2.2.4
 LIBWEBP_VERSION=1.6.0
 BZIP2_VERSION=1.0.8
 LIBXCB_VERSION=1.17.0
@@ -254,13 +258,21 @@ function build_libavif {
     touch libavif-stamp
 }
 
+function build_zstd {
+    if [ -e zstd-stamp ]; then return; fi
+    local out_dir=$(fetch_unpack https://github.com/facebook/zstd/releases/download/v$ZSTD_VERSION/zstd-$ZSTD_VERSION.tar.gz)
+    (cd $out_dir \
+        && make -j4 install)
+    touch zstd-stamp
+}
+
 function build {
     build_xz
     if [ -z "$IS_ALPINE" ] && [ -z "$SANITIZER" ] && [ -z "$IS_MACOS" ]; then
         yum remove -y zlib-devel
     fi
-    if [[ -n "$IS_MACOS" ]] && [[ "$MACOSX_DEPLOYMENT_TARGET" == "10.10" || "$MACOSX_DEPLOYMENT_TARGET" == "10.13" ]]; then
+    if [[ -n "$IS_MACOS" ]]; then
-        build_new_zlib
+        CFLAGS="$CFLAGS -headerpad_max_install_names" build_zlib_ng
     else
         build_zlib_ng
     fi
@@ -285,6 +297,7 @@ function build {
             --with-jpeg-include-dir=$BUILD_PREFIX/include --with-jpeg-lib-dir=$BUILD_PREFIX/lib \
             --disable-webp --disable-libdeflate --disable-zstd
     else
+        build_zstd
         build_tiff
     fi
 
@@ -309,6 +322,10 @@ function build {
 
     if [[ -n "$IS_MACOS" ]]; then
         # Custom freetype build
+        if [[ -z "$IOS_SDK" ]]; then
+          build_simple sed 4.9 https://mirrors.middlendian.com/gnu/sed
+        fi
+
         build_simple freetype $FREETYPE_VERSION https://download.savannah.gnu.org/releases/freetype tar.gz --with-harfbuzz=no
     else
         build_freetype

.github/workflows/wheels.yml

@@ -39,6 +39,7 @@ concurrency:
   cancel-in-progress: true
 
 env:
+  EXPECTED_DISTS: 91
   FORCE_COLOR: 1
 
 jobs:
@@ -52,21 +53,21 @@ jobs:
         include:
           - name: "macOS 10.10 x86_64"
             platform: macos
-            os: macos-13
+            os: macos-15-intel
             cibw_arch: x86_64
-            build: "cp3{9,10,11}*"
+            build: "cp3{10,11}*"
             macosx_deployment_target: "10.10"
           - name: "macOS 10.13 x86_64"
             platform: macos
-            os: macos-13
+            os: macos-15-intel
             cibw_arch: x86_64
-            build: "cp3{12,13,14}*"
+            build: "cp3{12,13}*"
             macosx_deployment_target: "10.13"
           - name: "macOS 10.15 x86_64"
             platform: macos
-            os: macos-13
+            os: macos-15-intel
             cibw_arch: x86_64
-            build: "pp3*"
+            build: "{cp314,pp3}*"
             macosx_deployment_target: "10.15"
           - name: "macOS arm64"
             platform: macos
@@ -99,11 +100,11 @@ jobs:
             cibw_arch: arm64_iphoneos
           - name: "iOS arm64 simulator"
             platform: ios
-            os: macos-14
+            os: macos-latest
             cibw_arch: arm64_iphonesimulator
           - name: "iOS x86_64 simulator"
             platform: ios
-            os: macos-13
+            os: macos-15-intel
             cibw_arch: x86_64_iphonesimulator
     steps:
       - uses: actions/checkout@v5
@@ -111,7 +112,7 @@ jobs:
           persist-credentials: false
           submodules: true
 
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: "3.x"
 
@@ -164,7 +165,7 @@ jobs:
           repository: python-pillow/test-images
           path: Tests\test-images
 
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: "3.x"
 
@@ -231,7 +232,7 @@ jobs:
           path: winbuild\build\bin\fribidi*
 
   sdist:
-    if: github.event_name != 'schedule'
+    if: github.event_name != 'schedule' || github.repository_owner == 'python-pillow'
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v5
@@ -239,7 +240,7 @@ jobs:
         persist-credentials: false
 
     - name: Set up Python
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v6
       with:
         python-version: "3.x"
 
@@ -250,15 +251,33 @@ jobs:
         name: dist-sdist
         path: dist/*.tar.gz
 
+  count-dists:
+    needs: [build-native-wheels, windows, sdist]
+    runs-on: ubuntu-latest
+    name: Count dists
+    steps:
+      - uses: actions/download-artifact@v5
+        with:
+          pattern: dist-*
+          path: dist
+          merge-multiple: true
+      - name: "What did we get?"
+        run: |
+          ls -alR
+          echo "Number of dists, should be $EXPECTED_DISTS:"
+          files=$(ls dist 2>/dev/null | wc -l)
+          echo $files
+          [ "$files" -eq $EXPECTED_DISTS ] || exit 1
+
   scientific-python-nightly-wheels-publish:
     if: github.repository_owner == 'python-pillow' && (github.event_name == 'schedule' || github.event_name == 'workflow_dispatch')
-    needs: [build-native-wheels, windows]
+    needs: count-dists
     runs-on: ubuntu-latest
     name: Upload wheels to scientific-python-nightly-wheels
     steps:
       - uses: actions/download-artifact@v5
         with:
-          pattern: dist-*
+          pattern: dist-!(sdist)*
           path: dist
           merge-multiple: true
       - name: Upload wheels to scientific-python-nightly-wheels
@@ -269,7 +288,7 @@ jobs:
 
   pypi-publish:
     if: github.repository_owner == 'python-pillow' && github.event_name == 'push' && startsWith(github.ref, 'refs/tags')
-    needs: [build-native-wheels, windows, sdist]
+    needs: count-dists
     runs-on: ubuntu-latest
     name: Upload release to PyPI
     environment:

.pre-commit-config.yaml

@@ -1,12 +1,12 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.12.7
+    rev: v0.13.3
     hooks:
       - id: ruff-check
         args: [--exit-non-zero-on-fix]
 
   - repo: https://github.com/psf/black-pre-commit-mirror
-    rev: 25.1.0
+    rev: 25.9.0
     hooks:
       - id: black
 
@@ -24,7 +24,7 @@ repos:
         exclude: (Makefile$|\.bat$|\.cmake$|\.eps$|\.fits$|\.gd$|\.opt$|\.patch$)
 
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v20.1.8
+    rev: v21.1.2
     hooks:
       - id: clang-format
         types: [c]
@@ -36,7 +36,7 @@ repos:
       - id: rst-backticks
 
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
+    rev: v6.0.0
     hooks:
       - id: check-executables-have-shebangs
       - id: check-shebang-scripts-are-executable
@@ -51,14 +51,14 @@ repos:
         exclude: ^.github/.*TEMPLATE|^Tests/(fonts|images)/|\.patch$
 
   - repo: https://github.com/python-jsonschema/check-jsonschema
-    rev: 0.33.2
+    rev: 0.34.0
     hooks:
       - id: check-github-workflows
       - id: check-readthedocs
       - id: check-renovate
 
   - repo: https://github.com/zizmorcore/zizmor-pre-commit
-    rev: v1.11.0
+    rev: v1.14.2
     hooks:
       - id: zizmor
 
@@ -68,7 +68,7 @@ repos:
       - id: sphinx-lint
 
   - repo: https://github.com/tox-dev/pyproject-fmt
-    rev: v2.6.0
+    rev: v2.7.0
     hooks:
       - id: pyproject-fmt
 

Tests/createfontdatachunk.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python3
 from __future__ import annotations
 
 import base64

Tests/test_arro3.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+import json
+from typing import Any, NamedTuple
+
+import pytest
+
+from PIL import Image
+
+from .helper import (
+    assert_deep_equal,
+    assert_image_equal,
+    hopper,
+    is_big_endian,
+)
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from arro3 import compute  #  type: ignore [import-not-found]
+    from arro3.core import (  #  type: ignore [import-not-found]
+        Array,
+        DataType,
+        Field,
+        fixed_size_list_array,
+    )
+else:
+    arro3 = pytest.importorskip("arro3", reason="Arro3 not installed")
+    from arro3 import compute
+    from arro3.core import Array, DataType, Field, fixed_size_list_array
+
+TEST_IMAGE_SIZE = (10, 10)
+
+
+def _test_img_equals_pyarray(
+    img: Image.Image, arr: Any, mask: list[int] | None, elts_per_pixel: int = 1
+) -> None:
+    assert img.height * img.width * elts_per_pixel == len(arr)
+    px = img.load()
+    assert px is not None
+    if elts_per_pixel > 1 and mask is None:
+        # have to do element-wise comparison when we're comparing
+        # flattened r,g,b,a to a pixel.
+        mask = list(range(elts_per_pixel))
+    for x in range(0, img.size[0], int(img.size[0] / 10)):
+        for y in range(0, img.size[1], int(img.size[1] / 10)):
+            if mask:
+                pixel = px[x, y]
+                assert isinstance(pixel, tuple)
+                for ix, elt in enumerate(mask):
+                    if elts_per_pixel == 1:
+                        assert pixel[ix] == arr[y * img.width + x].as_py()[elt]
+                    else:
+                        assert (
+                            pixel[ix]
+                            == arr[(y * img.width + x) * elts_per_pixel + elt].as_py()
+                        )
+            else:
+                assert_deep_equal(px[x, y], arr[y * img.width + x].as_py())
+
+
+def _test_img_equals_int32_pyarray(
+    img: Image.Image, arr: Any, mask: list[int] | None, elts_per_pixel: int = 1
+) -> None:
+    assert img.height * img.width * elts_per_pixel == len(arr)
+    px = img.load()
+    assert px is not None
+    if mask is None:
+        # have to do element-wise comparison when we're comparing
+        # flattened rgba in an uint32 to a pixel.
+        mask = list(range(elts_per_pixel))
+    for x in range(0, img.size[0], int(img.size[0] / 10)):
+        for y in range(0, img.size[1], int(img.size[1] / 10)):
+            pixel = px[x, y]
+            assert isinstance(pixel, tuple)
+            arr_pixel_int = arr[y * img.width + x].as_py()
+            arr_pixel_tuple = (
+                arr_pixel_int % 256,
+                (arr_pixel_int // 256) % 256,
+                (arr_pixel_int // 256**2) % 256,
+                (arr_pixel_int // 256**3),
+            )
+            if is_big_endian():
+                arr_pixel_tuple = arr_pixel_tuple[::-1]
+
+            for ix, elt in enumerate(mask):
+                assert pixel[ix] == arr_pixel_tuple[elt]
+
+
+fl_uint8_4_type = DataType.list(Field("_", DataType.uint8()).with_nullable(False), 4)
+
+
+@pytest.mark.parametrize(
+    "mode, dtype, mask",
+    (
+        ("L", DataType.uint8(), None),
+        ("I", DataType.int32(), None),
+        ("F", DataType.float32(), None),
+        ("LA", fl_uint8_4_type, [0, 3]),
+        ("RGB", fl_uint8_4_type, [0, 1, 2]),
+        ("RGBA", fl_uint8_4_type, None),
+        ("RGBX", fl_uint8_4_type, None),
+        ("CMYK", fl_uint8_4_type, None),
+        ("YCbCr", fl_uint8_4_type, [0, 1, 2]),
+        ("HSV", fl_uint8_4_type, [0, 1, 2]),
+    ),
+)
+def test_to_array(mode: str, dtype: DataType, mask: list[int] | None) -> None:
+    img = hopper(mode)
+
+    # Resize to non-square
+    img = img.crop((3, 0, 124, 127))
+    assert img.size == (121, 127)
+
+    arr = Array(img)
+    _test_img_equals_pyarray(img, arr, mask)
+    assert arr.type == dtype
+
+    reloaded = Image.fromarrow(arr, mode, img.size)
+    assert_image_equal(img, reloaded)
+
+
+def test_lifetime() -> None:
+    # valgrind shouldn't error out here.
+    # arrays should be accessible after the image is deleted.
+
+    img = hopper("L")
+
+    arr_1 = Array(img)
+    arr_2 = Array(img)
+
+    del img
+
+    assert compute.sum(arr_1).as_py() > 0
+    del arr_1
+
+    assert compute.sum(arr_2).as_py() > 0
+    del arr_2
+
+
+def test_lifetime2() -> None:
+    # valgrind shouldn't error out here.
+    # img should remain after the arrays are collected.
+
+    img = hopper("L")
+
+    arr_1 = Array(img)
+    arr_2 = Array(img)
+
+    assert compute.sum(arr_1).as_py() > 0
+    del arr_1
+
+    assert compute.sum(arr_2).as_py() > 0
+    del arr_2
+
+    img2 = img.copy()
+    px = img2.load()
+    assert px  # make mypy happy
+    assert isinstance(px[0, 0], int)
+
+
+class DataShape(NamedTuple):
+    dtype: DataType
+    # Strictly speaking, elt should be a pixel or pixel component, so
+    # list[uint8][4], float, int, uint32, uint8, etc.  But more
+    # correctly, it should be exactly the dtype from the line above.
+    elt: Any
+    elts_per_pixel: int
+
+
+UINT_ARR = DataShape(
+    dtype=fl_uint8_4_type,
+    elt=[1, 2, 3, 4],  # array of 4 uint8 per pixel
+    elts_per_pixel=1,  # only one array per pixel
+)
+
+UINT = DataShape(
+    dtype=DataType.uint8(),
+    elt=3,  # one uint8,
+    elts_per_pixel=4,  # but repeated 4x per pixel
+)
+
+UINT32 = DataShape(
+    dtype=DataType.uint32(),
+    elt=0xABCDEF45,  # one packed int, doesn't fit in a int32 > 0x80000000
+    elts_per_pixel=1,  # one per pixel
+)
+
+INT32 = DataShape(
+    dtype=DataType.uint32(),
+    elt=0x12CDEF45,  # one packed int
+    elts_per_pixel=1,  # one per pixel
+)
+
+
+@pytest.mark.parametrize(
+    "mode, data_tp, mask",
+    (
+        ("L", DataShape(DataType.uint8(), 3, 1), None),
+        ("I", DataShape(DataType.int32(), 1 << 24, 1), None),
+        ("F", DataShape(DataType.float32(), 3.14159, 1), None),
+        ("LA", UINT_ARR, [0, 3]),
+        ("LA", UINT, [0, 3]),
+        ("RGB", UINT_ARR, [0, 1, 2]),
+        ("RGBA", UINT_ARR, None),
+        ("CMYK", UINT_ARR, None),
+        ("YCbCr", UINT_ARR, [0, 1, 2]),
+        ("HSV", UINT_ARR, [0, 1, 2]),
+        ("RGB", UINT, [0, 1, 2]),
+        ("RGBA", UINT, None),
+        ("CMYK", UINT, None),
+        ("YCbCr", UINT, [0, 1, 2]),
+        ("HSV", UINT, [0, 1, 2]),
+    ),
+)
+def test_fromarray(mode: str, data_tp: DataShape, mask: list[int] | None) -> None:
+    (dtype, elt, elts_per_pixel) = data_tp
+
+    ct_pixels = TEST_IMAGE_SIZE[0] * TEST_IMAGE_SIZE[1]
+    if dtype == fl_uint8_4_type:
+        tmp_arr = Array(elt * (ct_pixels * elts_per_pixel), type=DataType.uint8())
+        arr = fixed_size_list_array(tmp_arr, 4)
+    else:
+        arr = Array([elt] * (ct_pixels * elts_per_pixel), type=dtype)
+    img = Image.fromarrow(arr, mode, TEST_IMAGE_SIZE)
+
+    _test_img_equals_pyarray(img, arr, mask, elts_per_pixel)
+
+
+@pytest.mark.parametrize(
+    "mode, mask",
+    (
+        ("LA", [0, 3]),
+        ("RGB", [0, 1, 2]),
+        ("RGBA", None),
+        ("CMYK", None),
+        ("YCbCr", [0, 1, 2]),
+        ("HSV", [0, 1, 2]),
+    ),
+)
+@pytest.mark.parametrize("data_tp", (UINT32, INT32))
+def test_from_int32array(mode: str, mask: list[int] | None, data_tp: DataShape) -> None:
+    (dtype, elt, elts_per_pixel) = data_tp
+
+    ct_pixels = TEST_IMAGE_SIZE[0] * TEST_IMAGE_SIZE[1]
+    arr = Array([elt] * (ct_pixels * elts_per_pixel), type=dtype)
+    img = Image.fromarrow(arr, mode, TEST_IMAGE_SIZE)
+
+    _test_img_equals_int32_pyarray(img, arr, mask, elts_per_pixel)
+
+
+@pytest.mark.parametrize(
+    "mode, metadata",
+    (
+        ("LA", ["L", "X", "X", "A"]),
+        ("RGB", ["R", "G", "B", "X"]),
+        ("RGBX", ["R", "G", "B", "X"]),
+        ("RGBA", ["R", "G", "B", "A"]),
+        ("CMYK", ["C", "M", "Y", "K"]),
+        ("YCbCr", ["Y", "Cb", "Cr", "X"]),
+        ("HSV", ["H", "S", "V", "X"]),
+    ),
+)
+def test_image_metadata(mode: str, metadata: list[str]) -> None:
+    img = hopper(mode)
+
+    arr = Array(img)
+
+    assert arr.type.value_field
+    assert arr.type.value_field.metadata
+    assert arr.type.value_field.metadata[b"image"]
+
+    parsed_metadata = json.loads(arr.type.value_field.metadata[b"image"].decode("utf8"))
+
+    assert "bands" in parsed_metadata
+    assert parsed_metadata["bands"] == metadata

Tests/test_file_avif.py

@@ -14,6 +14,7 @@ import pytest
 
 from PIL import (
     AvifImagePlugin,
+    GifImagePlugin,
     Image,
     ImageDraw,
     ImageFile,
@@ -220,6 +221,7 @@ class TestFileAvif:
     def test_background_from_gif(self, tmp_path: Path) -> None:
         with Image.open("Tests/images/chi.gif") as im:
             original_value = im.convert("RGB").getpixel((1, 1))
+            assert isinstance(original_value, tuple)
 
             # Save as AVIF
             out_avif = tmp_path / "temp.avif"
@@ -232,6 +234,7 @@ class TestFileAvif:
 
         with Image.open(out_gif) as reread:
             reread_value = reread.convert("RGB").getpixel((1, 1))
+        assert isinstance(reread_value, tuple)
         difference = sum([abs(original_value[i] - reread_value[i]) for i in range(3)])
         assert difference <= 6
 
@@ -240,6 +243,7 @@ class TestFileAvif:
         with Image.open("Tests/images/chi.gif") as im:
             im.save(temp_file)
         with Image.open(temp_file) as im:
+            assert isinstance(im, AvifImagePlugin.AvifImageFile)
             assert im.n_frames == 1
 
     def test_invalid_file(self) -> None:
@@ -598,10 +602,12 @@ class TestAvifAnimation:
         """
 
         with Image.open(TEST_AVIF_FILE) as im:
+            assert isinstance(im, AvifImagePlugin.AvifImageFile)
             assert im.n_frames == 1
             assert not im.is_animated
 
         with Image.open("Tests/images/avif/star.avifs") as im:
+            assert isinstance(im, AvifImagePlugin.AvifImageFile)
             assert im.n_frames == 5
             assert im.is_animated
 
@@ -612,11 +618,13 @@ class TestAvifAnimation:
         """
 
         with Image.open("Tests/images/avif/star.gif") as original:
+            assert isinstance(original, GifImagePlugin.GifImageFile)
             assert original.n_frames > 1
 
             temp_file = tmp_path / "temp.avif"
             original.save(temp_file, save_all=True)
             with Image.open(temp_file) as im:
+                assert isinstance(im, AvifImagePlugin.AvifImageFile)
                 assert im.n_frames == original.n_frames
 
                 # Compare first frame in P mode to frame from original GIF
@@ -636,6 +644,7 @@ class TestAvifAnimation:
 
         def check(temp_file: Path) -> None:
             with Image.open(temp_file) as im:
+                assert isinstance(im, AvifImagePlugin.AvifImageFile)
                 assert im.n_frames == 4
 
                 # Compare first frame to original
@@ -708,6 +717,7 @@ class TestAvifAnimation:
             )
 
         with Image.open(temp_file) as im:
+            assert isinstance(im, AvifImagePlugin.AvifImageFile)
             assert im.n_frames == 5
             assert im.is_animated
 
@@ -737,6 +747,7 @@ class TestAvifAnimation:
             )
 
         with Image.open(temp_file) as im:
+            assert isinstance(im, AvifImagePlugin.AvifImageFile)
             assert im.n_frames == 5
             assert im.is_animated
 

Tests/test_file_bmp.py

@@ -6,6 +6,8 @@ from pathlib import Path
 import pytest
 
 from PIL import BmpImagePlugin, Image, _binary
+from PIL._binary import o16le as o16
+from PIL._binary import o32le as o32
 
 from .helper import (
     assert_image_equal,
@@ -114,7 +116,7 @@ def test_save_float_dpi(tmp_path: Path) -> None:
 
 
 def test_load_dib() -> None:
-    # test for #1293, Imagegrab returning Unsupported Bitfields Format
+    # test for #1293, ImageGrab returning Unsupported Bitfields Format
     with Image.open("Tests/images/clipboard.dib") as im:
         assert im.format == "DIB"
         assert im.get_format_mimetype() == "image/bmp"
@@ -219,6 +221,18 @@ def test_rle8_eof(file_name: str, length: int) -> None:
             im.load()
 
 
+def test_unsupported_bmp_bitfields_layout() -> None:
+    fp = io.BytesIO(
+        o32(40)  # header size
+        + b"\x00" * 10
+        + o16(1)  # bits
+        + o32(3)  # BITFIELDS compression
+        + b"\x00" * 32
+    )
+    with pytest.raises(OSError, match="Unsupported BMP bitfields layout"):
+        Image.open(fp)
+
+
 def test_offset() -> None:
     # This image has been hexedited
     # to exclude the palette size from the pixel data offset

Tests/test_file_cur.py

@@ -1,8 +1,13 @@
 from __future__ import annotations
 
+from io import BytesIO
+
 import pytest
 
 from PIL import CurImagePlugin, Image
+from PIL._binary import o8
+from PIL._binary import o16le as o16
+from PIL._binary import o32le as o32
 
 TEST_FILE = "Tests/images/deerstalker.cur"
 
@@ -17,6 +22,24 @@ def test_sanity() -> None:
         assert im.getpixel((16, 16)) == (84, 87, 86, 255)
 
 
+def test_largest_cursor() -> None:
+    magic = b"\x00\x00\x02\x00"
+    sizes = ((1, 1), (8, 8), (4, 4))
+    data = magic + o16(len(sizes))
+    for w, h in sizes:
+        image_offset = 6 + len(sizes) * 16 if (w, h) == max(sizes) else 0
+        data += o8(w) + o8(h) + o8(0) * 10 + o32(image_offset)
+    data += (
+        o32(12)  # header size
+        + o16(8)  # width
+        + o16(16)  # height
+        + o16(0)  # planes
+        + o16(1)  # bits
+    )
+    with Image.open(BytesIO(data)) as im:
+        assert im.size == (8, 8)
+
+
 def test_invalid_file() -> None:
     invalid_file = "Tests/images/flower.jpg"
 
@@ -26,6 +49,7 @@ def test_invalid_file() -> None:
     no_cursors_file = "Tests/images/no_cursors.cur"
 
     cur = CurImagePlugin.CurImageFile(TEST_FILE)
+    assert cur.fp is not None
     cur.fp.close()
     with open(no_cursors_file, "rb") as cur.fp:
         with pytest.raises(TypeError):

Tests/test_file_eps.py

@@ -197,6 +197,14 @@ def test_load_long_binary_data(prefix: bytes) -> None:
         assert img.format == "EPS"
 
 
+def test_begin_binary() -> None:
+    with open("Tests/images/eps/binary_preview_map.eps", "rb") as fp:
+        data = bytearray(fp.read())
+    data[76875 : 76875 + 11] = b"%" * 11
+    with Image.open(io.BytesIO(data)) as img:
+        assert img.size == (399, 480)
+
+
 @mark_if_feature_version(
     pytest.mark.valgrind_known_error, "libjpeg_turbo", "2.0", reason="Known Failing"
 )

Tests/test_file_fli.py

@@ -48,6 +48,7 @@ def test_sanity() -> None:
 def test_prefix_chunk(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr(ImageFile, "LOAD_TRUNCATED_IMAGES", True)
     with Image.open(animated_test_file_with_prefix_chunk) as im:
+        assert isinstance(im, FliImagePlugin.FliImageFile)
         assert im.mode == "P"
         assert im.size == (320, 200)
         assert im.format == "FLI"
@@ -55,6 +56,7 @@ def test_prefix_chunk(monkeypatch: pytest.MonkeyPatch) -> None:
         assert im.is_animated
 
         palette = im.getpalette()
+        assert palette is not None
         assert palette[3:6] == [255, 255, 255]
         assert palette[381:384] == [204, 204, 12]
         assert palette[765:] == [252, 0, 0]

Tests/test_file_gd.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from io import BytesIO
+
 import pytest
 
 from PIL import GdImageFile, UnidentifiedImageError
@@ -16,6 +18,14 @@ def test_sanity() -> None:
         assert_image_similar_tofile(im.convert("RGB"), "Tests/images/hopper.jpg", 14)
 
 
+def test_transparency() -> None:
+    with open(TEST_GD_FILE, "rb") as fp:
+        data = bytearray(fp.read())
+    data[7:11] = b"\x00\x00\x00\x05"
+    with GdImageFile.open(BytesIO(data)) as im:
+        assert im.info["transparency"] == 5
+
+
 def test_bad_mode() -> None:
     with pytest.raises(ValueError):
         GdImageFile.open(TEST_GD_FILE, "bad mode")

Tests/test_file_gif.py

@@ -293,6 +293,7 @@ def test_roundtrip_save_all(tmp_path: Path) -> None:
         im.save(out, save_all=True)
 
     with Image.open(out) as reread:
+        assert isinstance(reread, GifImagePlugin.GifImageFile)
         assert reread.n_frames == 5
 
 
@@ -1374,6 +1375,7 @@ def test_palette_save_all_P(tmp_path: Path) -> None:
 
     with Image.open(out) as im:
         # Assert that the frames are correct, and each frame has the same palette
+        assert isinstance(im, GifImagePlugin.GifImageFile)
         assert_image_equal(im.convert("RGB"), frames[0].convert("RGB"))
         assert im.palette is not None
         assert im.global_palette is not None

Tests/test_file_iptc.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from io import BytesIO
 
+import pytest
+
 from PIL import Image, IptcImagePlugin, TiffImagePlugin, TiffTags
 
 from .helper import assert_image_equal, hopper
@@ -9,21 +11,78 @@ from .helper import assert_image_equal, hopper
 TEST_FILE = "Tests/images/iptc.jpg"
 
 
+def create_iptc_image(info: dict[str, int] = {}) -> BytesIO:
+    def field(tag, value):
+        return bytes((0x1C,) + tag + (0, len(value))) + value
+
+    data = field((3, 60), bytes((info.get("layers", 1), info.get("component", 0))))
+    data += field((3, 120), bytes((info.get("compression", 1),)))
+    if "band" in info:
+        data += field((3, 65), bytes((info["band"] + 1,)))
+    data += field((3, 20), b"\x01")  # width
+    data += field((3, 30), b"\x01")  # height
+    data += field(
+        (8, 10),
+        bytes((info.get("data", 0),)),
+    )
+
+    return BytesIO(data)
+
+
 def test_open() -> None:
     expected = Image.new("L", (1, 1))
 
-    f = BytesIO(
+    f = create_iptc_image()
-        b"\x1c\x03<\x00\x02\x01\x00\x1c\x03x\x00\x01\x01\x1c\x03\x14\x00\x01\x01"
-        b"\x1c\x03\x1e\x00\x01\x01\x1c\x08\n\x00\x01\x00"
-    )
     with Image.open(f) as im:
-        assert im.tile == [("iptc", (0, 0, 1, 1), 25, "raw")]
+        assert im.tile == [("iptc", (0, 0, 1, 1), 25, ("raw", None))]
         assert_image_equal(im, expected)
 
     with Image.open(f) as im:
         assert im.load() is not None
 
 
+def test_field_length() -> None:
+    f = create_iptc_image()
+    f.seek(28)
+    f.write(b"\xff")
+    with pytest.raises(OSError, match="illegal field length in IPTC/NAA file"):
+        with Image.open(f):
+            pass
+
+
+@pytest.mark.parametrize("layers, mode", ((3, "RGB"), (4, "CMYK")))
+def test_layers(layers: int, mode: str) -> None:
+    for band in range(-1, layers):
+        info = {"layers": layers, "component": 1, "data": 5}
+        if band != -1:
+            info["band"] = band
+        f = create_iptc_image(info)
+        with Image.open(f) as im:
+            assert im.mode == mode
+
+            data = [0] * layers
+            data[max(band, 0)] = 5
+            assert im.getpixel((0, 0)) == tuple(data)
+
+
+def test_unknown_compression() -> None:
+    f = create_iptc_image({"compression": 2})
+    with pytest.raises(OSError, match="Unknown IPTC image compression"):
+        with Image.open(f):
+            pass
+
+
+def test_getiptcinfo() -> None:
+    f = create_iptc_image()
+    with Image.open(f) as im:
+        assert IptcImagePlugin.getiptcinfo(im) == {
+            (3, 60): b"\x01\x00",
+            (3, 120): b"\x01",
+            (3, 20): b"\x01",
+            (3, 30): b"\x01",
+        }
+
+
 def test_getiptcinfo_jpg_none() -> None:
     # Arrange
     with hopper() as im:

Tests/test_file_jpeg.py

@@ -330,8 +330,10 @@ class TestFileJpeg:
 
         # Reading
         with Image.open("Tests/images/exif_gps.jpg") as im:
-            exif = im._getexif()
+            assert isinstance(im, JpegImagePlugin.JpegImageFile)
-            assert exif[gps_index] == expected_exif_gps
+            exif_data = im._getexif()
+            assert exif_data is not None
+            assert exif_data[gps_index] == expected_exif_gps
 
         # Writing
         f = tmp_path / "temp.jpg"
@@ -340,8 +342,10 @@ class TestFileJpeg:
         hopper().save(f, exif=exif)
 
         with Image.open(f) as reloaded:
-            exif = reloaded._getexif()
+            assert isinstance(reloaded, JpegImagePlugin.JpegImageFile)
-            assert exif[gps_index] == expected_exif_gps
+            exif_data = reloaded._getexif()
+            assert exif_data is not None
+            assert exif_data[gps_index] == expected_exif_gps
 
     def test_empty_exif_gps(self) -> None:
         with Image.open("Tests/images/empty_gps_ifd.jpg") as im:
@@ -368,6 +372,7 @@ class TestFileJpeg:
         exifs = []
         for i in range(2):
             with Image.open("Tests/images/exif-200dpcm.jpg") as im:
+                assert isinstance(im, JpegImagePlugin.JpegImageFile)
                 exifs.append(im._getexif())
         assert exifs[0] == exifs[1]
 
@@ -401,13 +406,17 @@ class TestFileJpeg:
         }
 
         with Image.open("Tests/images/exif_gps.jpg") as im:
+            assert isinstance(im, JpegImagePlugin.JpegImageFile)
             exif = im._getexif()
+        assert exif is not None
 
         for tag, value in expected_exif.items():
             assert value == exif[tag]
 
     def test_exif_gps_typeerror(self) -> None:
         with Image.open("Tests/images/exif_gps_typeerror.jpg") as im:
+            assert isinstance(im, JpegImagePlugin.JpegImageFile)
+
             # Should not raise a TypeError
             im._getexif()
 
@@ -487,7 +496,9 @@ class TestFileJpeg:
 
     def test_exif(self) -> None:
         with Image.open("Tests/images/pil_sample_rgb.jpg") as im:
+            assert isinstance(im, JpegImagePlugin.JpegImageFile)
             info = im._getexif()
+            assert info is not None
             assert info[305] == "Adobe Photoshop CS Macintosh"
 
     def test_get_child_images(self) -> None:
@@ -690,11 +701,13 @@ class TestFileJpeg:
 
     def test_save_multiple_16bit_qtables(self) -> None:
         with Image.open("Tests/images/hopper_16bit_qtables.jpg") as im:
+            assert isinstance(im, JpegImagePlugin.JpegImageFile)
             im2 = self.roundtrip(im, qtables="keep")
             assert im.quantization == im2.quantization
 
     def test_save_single_16bit_qtable(self) -> None:
         with Image.open("Tests/images/hopper_16bit_qtables.jpg") as im:
+            assert isinstance(im, JpegImagePlugin.JpegImageFile)
             im2 = self.roundtrip(im, qtables={0: im.quantization[0]})
             assert len(im2.quantization) == 1
             assert im2.quantization[0] == im.quantization[0]
@@ -898,7 +911,10 @@ class TestFileJpeg:
         # in contrast to normal 8
         with Image.open("Tests/images/exif-ifd-offset.jpg") as im:
             # Act / Assert
-            assert im._getexif()[306] == "2017:03:13 23:03:09"
+            assert isinstance(im, JpegImagePlugin.JpegImageFile)
+            exif = im._getexif()
+            assert exif is not None
+            assert exif[306] == "2017:03:13 23:03:09"
 
     def test_multiple_exif(self) -> None:
         with Image.open("Tests/images/multiple_exif.jpg") as im:

Tests/test_file_libtiff.py

@@ -355,6 +355,27 @@ class TestFileLibTiff(LibTiffTestCase):
             # Should not segfault
             im.save(outfile)
 
+    def test_whitepoint_tag(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+    ) -> None:
+        monkeypatch.setattr(TiffImagePlugin, "WRITE_LIBTIFF", True)
+
+        out = tmp_path / "temp.tif"
+        hopper().save(out, tiffinfo={318: (0.3127, 0.3289)})
+
+        with Image.open(out) as reloaded:
+            assert isinstance(reloaded, TiffImagePlugin.TiffImageFile)
+            assert reloaded.tag_v2[318] == pytest.approx((0.3127, 0.3289))
+
+        # Save tag by default
+        out = tmp_path / "temp2.tif"
+        with Image.open("Tests/images/rdf.tif") as im:
+            im.save(out)
+
+        with Image.open(out) as reloaded:
+            assert isinstance(reloaded, TiffImagePlugin.TiffImageFile)
+            assert reloaded.tag_v2[318] == pytest.approx((0.3127, 0.3289999))
+
     def test_xmlpacket_tag(
         self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
     ) -> None:
@@ -365,8 +386,7 @@ class TestFileLibTiff(LibTiffTestCase):
 
         with Image.open(out) as reloaded:
             assert isinstance(reloaded, TiffImagePlugin.TiffImageFile)
-            if 700 in reloaded.tag_v2:
+            assert reloaded.tag_v2[700] == b"xmlpacket tag"
-                assert reloaded.tag_v2[700] == b"xmlpacket tag"
 
     def test_int_dpi(self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
         # issue #1765

Tests/test_file_mpo.py

@@ -104,25 +104,27 @@ def test_exif(test_file: str) -> None:
 
 
 def test_frame_size() -> None:
-    # This image has been hexedited to contain a different size
+    with Image.open("Tests/images/frame_size.mpo") as im:
-    # in the SOF marker of the second frame
+        assert im.size == (56, 70)
-    with Image.open("Tests/images/sugarshack_frame_size.mpo") as im:
+        im.load()
-        assert im.size == (640, 480)
 
         im.seek(1)
-        assert im.size == (680, 480)
+        assert im.size == (349, 434)
+        im.load()
 
         im.seek(0)
-        assert im.size == (640, 480)
+        assert im.size == (56, 70)
 
 
 def test_ignore_frame_size() -> None:
     # Ignore the different size of the second frame
     # since this is not a "Large Thumbnail" image
     with Image.open("Tests/images/ignore_frame_size.mpo") as im:
+        assert isinstance(im, MpoImagePlugin.MpoImageFile)
         assert im.size == (64, 64)
 
         im.seek(1)
+        assert im.mpinfo is not None
         assert (
             im.mpinfo[0xB002][1]["Attribute"]["MPType"]
             == "Multi-Frame Image: (Disparity)"
@@ -155,6 +157,7 @@ def test_reload_exif_after_seek() -> None:
 @pytest.mark.parametrize("test_file", test_files)
 def test_mp(test_file: str) -> None:
     with Image.open(test_file) as im:
+        assert isinstance(im, MpoImagePlugin.MpoImageFile)
         mpinfo = im._getmp()
         assert mpinfo is not None
         assert mpinfo[45056] == b"0100"
@@ -165,6 +168,7 @@ def test_mp_offset() -> None:
     # This image has been manually hexedited to have an IFD offset of 10
     # in APP2 data, in contrast to normal 8
     with Image.open("Tests/images/sugarshack_ifd_offset.mpo") as im:
+        assert isinstance(im, MpoImagePlugin.MpoImageFile)
         mpinfo = im._getmp()
         assert mpinfo is not None
         assert mpinfo[45056] == b"0100"
@@ -182,6 +186,7 @@ def test_mp_no_data() -> None:
 @pytest.mark.parametrize("test_file", test_files)
 def test_mp_attribute(test_file: str) -> None:
     with Image.open(test_file) as im:
+        assert isinstance(im, MpoImagePlugin.MpoImageFile)
         mpinfo = im._getmp()
     assert mpinfo is not None
     for frame_number, mpentry in enumerate(mpinfo[0xB002]):

Tests/test_file_pcd.py

@@ -6,6 +6,8 @@ import pytest
 
 from PIL import Image
 
+from .helper import assert_image_equal
+
 
 def test_load_raw() -> None:
     with Image.open("Tests/images/hopper.pcd") as im:
@@ -30,3 +32,8 @@ def test_rotated(orientation: int) -> None:
     f = BytesIO(data)
     with Image.open(f) as im:
         assert im.size == (512, 768)
+
+        with Image.open("Tests/images/hopper.pcd") as expected:
+            assert_image_equal(
+                im, expected.rotate(90 if orientation == 1 else 270, expand=True)
+            )

Tests/test_file_png.py

@@ -229,7 +229,9 @@ class TestFilePng:
         assert_image(im, "RGBA", (162, 150))
 
         # image has 124 unique alpha values
-        assert len(im.getchannel("A").getcolors()) == 124
+        colors = im.getchannel("A").getcolors()
+        assert colors is not None
+        assert len(colors) == 124
 
     def test_load_transparent_rgb(self) -> None:
         test_file = "Tests/images/rgb_trns.png"
@@ -241,7 +243,9 @@ class TestFilePng:
         assert_image(im, "RGBA", (64, 64))
 
         # image has 876 transparent pixels
-        assert im.getchannel("A").getcolors()[0][0] == 876
+        colors = im.getchannel("A").getcolors()
+        assert colors is not None
+        assert colors[0][0] == 876
 
     def test_save_p_transparent_palette(self, tmp_path: Path) -> None:
         in_file = "Tests/images/pil123p.png"
@@ -262,7 +266,9 @@ class TestFilePng:
         assert_image(im, "RGBA", (162, 150))
 
         # image has 124 unique alpha values
-        assert len(im.getchannel("A").getcolors()) == 124
+        colors = im.getchannel("A").getcolors()
+        assert colors is not None
+        assert len(colors) == 124
 
     def test_save_p_single_transparency(self, tmp_path: Path) -> None:
         in_file = "Tests/images/p_trns_single.png"
@@ -285,7 +291,9 @@ class TestFilePng:
         assert im.getpixel((31, 31)) == (0, 255, 52, 0)
 
         # image has 876 transparent pixels
-        assert im.getchannel("A").getcolors()[0][0] == 876
+        colors = im.getchannel("A").getcolors()
+        assert colors is not None
+        assert colors[0][0] == 876
 
     def test_save_p_transparent_black(self, tmp_path: Path) -> None:
         # check if solid black image with full transparency
@@ -313,7 +321,9 @@ class TestFilePng:
                 assert im.info["transparency"] == 255
 
                 im_rgba = im.convert("RGBA")
-            assert im_rgba.getchannel("A").getcolors()[0][0] == num_transparent
+            colors = im_rgba.getchannel("A").getcolors()
+            assert colors is not None
+            assert colors[0][0] == num_transparent
 
             test_file = tmp_path / "temp.png"
             im.save(test_file)
@@ -324,7 +334,9 @@ class TestFilePng:
                 assert_image_equal(im, test_im)
 
             test_im_rgba = test_im.convert("RGBA")
-            assert test_im_rgba.getchannel("A").getcolors()[0][0] == num_transparent
+            colors = test_im_rgba.getchannel("A").getcolors()
+            assert colors is not None
+            assert colors[0][0] == num_transparent
 
     def test_save_rgb_single_transparency(self, tmp_path: Path) -> None:
         in_file = "Tests/images/caption_6_33_22.png"
@@ -671,6 +683,9 @@ class TestFilePng:
         im.save(out, bits=4, save_all=save_all)
 
         with Image.open(out) as reloaded:
+            assert isinstance(reloaded, PngImagePlugin.PngImageFile)
+            assert reloaded.png is not None
+            assert reloaded.png.im_palette is not None
             assert len(reloaded.png.im_palette[1]) == 48
 
     def test_plte_length(self, tmp_path: Path) -> None:
@@ -681,6 +696,9 @@ class TestFilePng:
         im.save(out)
 
         with Image.open(out) as reloaded:
+            assert isinstance(reloaded, PngImagePlugin.PngImageFile)
+            assert reloaded.png is not None
+            assert reloaded.png.im_palette is not None
             assert len(reloaded.png.im_palette[1]) == 3
 
     def test_getxmp(self) -> None:
@@ -702,13 +720,17 @@ class TestFilePng:
     def test_exif(self) -> None:
         # With an EXIF chunk
         with Image.open("Tests/images/exif.png") as im:
-            exif = im._getexif()
+            assert isinstance(im, PngImagePlugin.PngImageFile)
-        assert exif[274] == 1
+            exif_data = im._getexif()
+        assert exif_data is not None
+        assert exif_data[274] == 1
 
         # With an ImageMagick zTXt chunk
         with Image.open("Tests/images/exif_imagemagick.png") as im:
-            exif = im._getexif()
+            assert isinstance(im, PngImagePlugin.PngImageFile)
-            assert exif[274] == 1
+            exif_data = im._getexif()
+            assert exif_data is not None
+            assert exif_data[274] == 1
 
             # Assert that info still can be extracted
             # when the image is no longer a PngImageFile instance
@@ -717,8 +739,10 @@ class TestFilePng:
 
         # With a tEXt chunk
         with Image.open("Tests/images/exif_text.png") as im:
-            exif = im._getexif()
+            assert isinstance(im, PngImagePlugin.PngImageFile)
-        assert exif[274] == 1
+            exif_data = im._getexif()
+        assert exif_data is not None
+        assert exif_data[274] == 1
 
         # With XMP tags
         with Image.open("Tests/images/xmp_tags_orientation.png") as im:
@@ -740,8 +764,10 @@ class TestFilePng:
             im.save(test_file, exif=im.getexif())
 
         with Image.open(test_file) as reloaded:
-            exif = reloaded._getexif()
+            assert isinstance(reloaded, PngImagePlugin.PngImageFile)
-        assert exif[274] == 1
+            exif_data = reloaded._getexif()
+        assert exif_data is not None
+        assert exif_data[274] == 1
 
     @mark_if_feature_version(
         pytest.mark.valgrind_known_error, "libjpeg_turbo", "2.0", reason="Known Failing"

Tests/test_file_ppm.py

@@ -92,6 +92,13 @@ def test_16bit_pgm() -> None:
         assert_image_equal_tofile(im, "Tests/images/16_bit_binary_pgm.tiff")
 
 
+def test_p4_save(tmp_path: Path) -> None:
+    with Image.open("Tests/images/hopper_1bit.pbm") as im:
+        filename = tmp_path / "temp.pbm"
+        im.save(filename)
+        assert_image_equal_tofile(im, filename)
+
+
 def test_16bit_pgm_write(tmp_path: Path) -> None:
     with Image.open("Tests/images/16_bit_binary.pgm") as im:
         filename = tmp_path / "temp.pgm"
@@ -134,6 +141,12 @@ def test_pfm_big_endian(tmp_path: Path) -> None:
         assert_image_equal_tofile(im, filename)
 
 
+def test_save_unsupported_mode(tmp_path: Path) -> None:
+    im = hopper("P")
+    with pytest.raises(OSError, match="cannot write mode P as PPM"):
+        im.save(tmp_path / "out.ppm")
+
+
 @pytest.mark.parametrize(
     "data",
     [

Tests/test_file_tga.py

@@ -274,13 +274,17 @@ def test_save_l_transparency(tmp_path: Path) -> None:
     in_file = "Tests/images/la.tga"
     with Image.open(in_file) as im:
         assert im.mode == "LA"
-        assert im.getchannel("A").getcolors()[0][0] == num_transparent
+        colors = im.getchannel("A").getcolors()
+        assert colors is not None
+        assert colors[0][0] == num_transparent
 
         out = tmp_path / "temp.tga"
         im.save(out)
 
     with Image.open(out) as test_im:
         assert test_im.mode == "LA"
-        assert test_im.getchannel("A").getcolors()[0][0] == num_transparent
+        colors = test_im.getchannel("A").getcolors()
+        assert colors is not None
+        assert colors[0][0] == num_transparent
 
         assert_image_equal(im, test_im)

Tests/test_file_wal.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from io import BytesIO
+
 from PIL import WalImageFile
 
 from .helper import assert_image_equal_tofile
@@ -13,12 +15,22 @@ def test_open() -> None:
         assert im.format_description == "Quake2 Texture"
         assert im.mode == "P"
         assert im.size == (128, 128)
+        assert "next_name" not in im.info
 
         assert isinstance(im, WalImageFile.WalImageFile)
 
         assert_image_equal_tofile(im, "Tests/images/hopper_wal.png")
 
 
+def test_next_name() -> None:
+    with open(TEST_FILE, "rb") as fp:
+        data = bytearray(fp.read())
+    data[56:60] = b"Test"
+    f = BytesIO(data)
+    with WalImageFile.open(f) as im:
+        assert im.info["next_name"] == b"Test"
+
+
 def test_load() -> None:
     with WalImageFile.open(TEST_FILE) as im:
         px = im.load()

Tests/test_file_webp_metadata.py

@@ -22,11 +22,13 @@ except ImportError:
 def test_read_exif_metadata() -> None:
     file_path = "Tests/images/flower.webp"
     with Image.open(file_path) as image:
+        assert isinstance(image, WebPImagePlugin.WebPImageFile)
         assert image.format == "WEBP"
         exif_data = image.info.get("exif", None)
         assert exif_data
 
         exif = image._getexif()
+        assert exif is not None
 
         # Camera make
         assert exif[271] == "Canon"

Tests/test_font_crash.py

@@ -9,7 +9,8 @@ from .helper import skip_unless_feature
 
 class TestFontCrash:
     def _fuzz_font(self, font: ImageFont.FreeTypeFont) -> None:
-        # from fuzzers.fuzz_font
+        # Copy of the code from fuzz_font() in Tests/oss-fuzz/fuzzers.py
+        # that triggered a problem when fuzzing
         font.getbbox("ABC")
         font.getmask("test text")
         with Image.new(mode="RGBA", size=(200, 200)) as im:

Tests/test_image.py

@@ -19,6 +19,7 @@ from PIL import (
     ImageDraw,
     ImageFile,
     ImagePalette,
+    ImageShow,
     UnidentifiedImageError,
     features,
 )
@@ -283,33 +284,6 @@ class TestImage:
         assert item is not None
         assert item != num
 
-    def test_expand_x(self) -> None:
-        # Arrange
-        im = hopper()
-        orig_size = im.size
-        xmargin = 5
-
-        # Act
-        im = im._expand(xmargin)
-
-        # Assert
-        assert im.size[0] == orig_size[0] + 2 * xmargin
-        assert im.size[1] == orig_size[1] + 2 * xmargin
-
-    def test_expand_xy(self) -> None:
-        # Arrange
-        im = hopper()
-        orig_size = im.size
-        xmargin = 5
-        ymargin = 3
-
-        # Act
-        im = im._expand(xmargin, ymargin)
-
-        # Assert
-        assert im.size[0] == orig_size[0] + 2 * xmargin
-        assert im.size[1] == orig_size[1] + 2 * ymargin
-
     def test_getbands(self) -> None:
         # Assert
         assert hopper("RGB").getbands() == ("R", "G", "B")
@@ -1047,6 +1021,13 @@ class TestImage:
         with pytest.warns(DeprecationWarning, match="Image.Image.get_child_images"):
             assert im.get_child_images() == []
 
+    def test_show(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(ImageShow, "_viewers", [])
+
+        im = Image.new("RGB", (1, 1))
+        with pytest.warns(DeprecationWarning, match="Image._show"):
+            Image._show(im)
+
     @pytest.mark.parametrize("size", ((1, 0), (0, 1), (0, 0)))
     def test_zero_tobytes(self, size: tuple[int, int]) -> None:
         im = Image.new("RGB", size)
@@ -1118,6 +1099,12 @@ class TestImage:
             assert im.palette is not None
             assert im.palette.colors[(27, 35, 6, 214)] == 24
 
+    def test_merge_pa(self) -> None:
+        p = hopper("P")
+        a = Image.new("L", p.size)
+        pa = Image.merge("PA", (p, a))
+        assert p.getpalette() == pa.getpalette()
+
     def test_constants(self) -> None:
         for enum in (
             Image.Transpose,

Tests/test_image_array.py

@@ -101,9 +101,8 @@ def test_fromarray_strides_without_tobytes() -> None:
             self.__array_interface__ = arr_params
 
     with pytest.raises(ValueError):
-        wrapped = Wrapper({"shape": (1, 1), "strides": (1, 1)})
+        wrapped = Wrapper({"shape": (1, 1), "strides": (1, 1), "typestr": "|u1"})
-        with pytest.warns(DeprecationWarning, match="'mode' parameter"):
+        Image.fromarray(wrapped, "L")
-            Image.fromarray(wrapped, "L")
 
 
 def test_fromarray_palette() -> None:
@@ -112,9 +111,16 @@ def test_fromarray_palette() -> None:
     a = numpy.array(i)
 
     # Act
-    with pytest.warns(DeprecationWarning, match="'mode' parameter"):
+    out = Image.fromarray(a, "P")
-        out = Image.fromarray(a, "P")
 
     # Assert that the Python and C palettes match
     assert out.palette is not None
     assert len(out.palette.colors) == len(out.im.getpalette()) / 3
+
+
+def test_deprecation() -> None:
+    a = numpy.array(im.convert("L"))
+    with pytest.warns(
+        DeprecationWarning, match="'mode' parameter for changing data types"
+    ):
+        Image.fromarray(a, "1")

Tests/test_image_convert.py

@@ -97,6 +97,13 @@ def test_opaque() -> None:
     assert_image_equal(alpha, solid)
 
 
+def test_rgba() -> None:
+    with Image.open("Tests/images/transparent.png") as im:
+        assert im.mode == "RGBA"
+
+        assert_image_similar(im.convert("RGBa").convert("RGB"), im.convert("RGB"), 1.5)
+
+
 def test_rgba_p() -> None:
     im = hopper("RGBA")
     im.putalpha(hopper("L"))
@@ -107,11 +114,19 @@ def test_rgba_p() -> None:
     assert_image_similar(im, comparable, 20)
 
 
-def test_rgba() -> None:
+def test_rgba_pa() -> None:
-    with Image.open("Tests/images/transparent.png") as im:
+    im = hopper("RGBA").convert("PA").convert("RGB")
-        assert im.mode == "RGBA"
+    expected = hopper("RGB")
 
-        assert_image_similar(im.convert("RGBa").convert("RGB"), im.convert("RGB"), 1.5)
+    assert_image_similar(im, expected, 9.3)
+
+
+def test_pa() -> None:
+    im = hopper().convert("PA")
+
+    palette = im.palette
+    assert palette is not None
+    assert palette.colors != {}
 
 
 def test_trns_p(tmp_path: Path) -> None:

Tests/test_image_paste.py

@@ -124,6 +124,21 @@ class TestImagingPaste:
         im = im.crop((12, 23, im2.width + 12, im2.height + 23))
         assert_image_equal(im, im2)
 
+    @pytest.mark.parametrize("y", [10, -10])
+    @pytest.mark.parametrize("mode", ["L", "RGB"])
+    @pytest.mark.parametrize("mask_mode", ["", "1", "L", "LA", "RGBa"])
+    def test_image_self(self, y: int, mode: str, mask_mode: str) -> None:
+        im = getattr(self, "gradient_" + mode)
+        mask = Image.new(mask_mode, im.size, 0xFFFFFFFF) if mask_mode else None
+
+        im_self = im.copy()
+        im_self.paste(im_self, (0, y), mask)
+
+        im_copy = im.copy()
+        im_copy.paste(im_copy.copy(), (0, y), mask)
+
+        assert_image_equal(im_self, im_copy)
+
     @pytest.mark.parametrize("mode", ["RGBA", "RGB", "L"])
     def test_image_mask_1(self, mode: str) -> None:
         im = Image.new(mode, (200, 200), "white")

Tests/test_image_putpalette.py

@@ -62,6 +62,7 @@ def test_putpalette_with_alpha_values() -> None:
         expected = im.convert("RGBA")
 
         palette = im.getpalette()
+        assert palette is not None
         transparency = im.info.pop("transparency")
 
         palette_with_alpha_values = []

Tests/test_image_quantize.py

@@ -118,6 +118,15 @@ def test_quantize_kmeans(method: Image.Quantize) -> None:
         im.quantize(kmeans=-1, method=method)
 
 
+@skip_unless_feature("libimagequant")
+def test_resize() -> None:
+    im = hopper().resize((100, 100))
+    converted = im.quantize(100, Image.Quantize.LIBIMAGEQUANT)
+    colors = converted.getcolors()
+    assert colors is not None
+    assert len(colors) == 100
+
+
 def test_colors() -> None:
     im = hopper()
     colors = 2

Tests/test_imagedraw.py

@@ -1494,7 +1494,9 @@ def test_default_font_size() -> None:
 
     def draw_text() -> None:
         draw.text((0, 0), text, font_size=16)
-        assert_image_equal_tofile(im, "Tests/images/imagedraw_default_font_size.png")
+        assert_image_similar_tofile(
+            im, "Tests/images/imagedraw_default_font_size.png", 1
+        )
 
     check(draw_text)
 
@@ -1513,7 +1515,9 @@ def test_default_font_size() -> None:
 
     def draw_multiline_text() -> None:
         draw.multiline_text((0, 0), text, font_size=16)
-        assert_image_equal_tofile(im, "Tests/images/imagedraw_default_font_size.png")
+        assert_image_similar_tofile(
+            im, "Tests/images/imagedraw_default_font_size.png", 1
+        )
 
     check(draw_multiline_text)
 

Tests/test_imagefile.py

@@ -164,6 +164,11 @@ class TestImageFile:
         with pytest.raises(OSError):
             p.close()
 
+    def test_negative_offset(self) -> None:
+        with Image.open("Tests/images/raw_negative_stride.bin") as im:
+            with pytest.raises(ValueError, match="Tile offset cannot be negative"):
+                im.load()
+
     def test_no_format(self) -> None:
         buf = BytesIO(b"\x00" * 255)
 

Tests/test_imagefont.py

@@ -19,6 +19,7 @@ from .helper import (
     assert_image_equal,
     assert_image_equal_tofile,
     assert_image_similar_tofile,
+    has_feature_version,
     is_win32,
     skip_unless_feature,
     skip_unless_feature_version,
@@ -492,6 +493,11 @@ def test_stroke_mask() -> None:
     assert mask.getpixel((42, 5)) == 255
 
 
+def test_load_invalid_file() -> None:
+    with pytest.raises(SyntaxError, match="Not a PILfont file"):
+        ImageFont.load("Tests/images/1_trns.png")
+
+
 def test_load_when_image_not_found() -> None:
     with tempfile.NamedTemporaryFile(delete=False) as tmp:
         pass
@@ -549,7 +555,7 @@ def test_default_font() -> None:
     draw.text((10, 60), txt, font=larger_default_font)
 
     # Assert
-    assert_image_equal_tofile(im, "Tests/images/default_font_freetype.png")
+    assert_image_similar_tofile(im, "Tests/images/default_font_freetype.png", 0.13)
 
 
 @pytest.mark.parametrize("mode", ("", "1", "RGBA"))
@@ -1055,7 +1061,10 @@ def test_colr(layout_engine: ImageFont.Layout) -> None:
 
     d.text((15, 5), "Bungee", font=font, embedded_color=True)
 
-    assert_image_similar_tofile(im, "Tests/images/colr_bungee.png", 21)
+    if has_feature_version("freetype2", "2.14.0"):
+        assert_image_similar_tofile(im, "Tests/images/colr_bungee.png", 6.1)
+    else:
+        assert_image_similar_tofile(im, "Tests/images/colr_bungee_older.png", 21)
 
 
 @skip_unless_feature_version("freetype2", "2.10.0")
@@ -1071,7 +1080,7 @@ def test_colr_mask(layout_engine: ImageFont.Layout) -> None:
 
     d.text((15, 5), "Bungee", "black", font=font)
 
-    assert_image_similar_tofile(im, "Tests/images/colr_bungee_mask.png", 22)
+    assert_image_similar_tofile(im, "Tests/images/colr_bungee_mask.png", 14.1)
 
 
 def test_woff2(layout_engine: ImageFont.Layout) -> None:

Tests/test_imagefontctl.py

@@ -183,7 +183,7 @@ def test_x_max_and_y_offset() -> None:
     draw.text((0, 0), "لح", font=ttf, fill=500)
 
     target = "Tests/images/test_x_max_and_y_offset.png"
-    assert_image_similar_tofile(im, target, 0.5)
+    assert_image_similar_tofile(im, target, 3.8)
 
 
 def test_language() -> None:

Tests/test_imagefontpil.py

@@ -30,6 +30,14 @@ def test_default_font(font: ImageFont.ImageFont) -> None:
     assert_image_equal_tofile(im, "Tests/images/default_font.png")
 
 
+def test_invalid_mode() -> None:
+    font = ImageFont.ImageFont()
+    fp = BytesIO()
+    with Image.open("Tests/images/hopper.png") as im:
+        with pytest.raises(TypeError, match="invalid font image mode"):
+            font._load_pilfont_data(fp, im)
+
+
 def test_without_freetype() -> None:
     original_core = ImageFont.core
     if features.check_module("freetype2"):

Tests/test_imagemorph.py

@@ -7,7 +7,7 @@ import pytest
 
 from PIL import Image, ImageMorph, _imagingmorph
 
-from .helper import assert_image_equal_tofile, hopper
+from .helper import assert_image_equal_tofile, hopper, timeout_unless_slower_valgrind
 
 
 def string_to_img(image_string: str) -> Image.Image:
@@ -266,16 +266,18 @@ def test_unknown_pattern() -> None:
         ImageMorph.LutBuilder(op_name="unknown")
 
 
-def test_pattern_syntax_error() -> None:
+@pytest.mark.parametrize(
+    "pattern", ("a pattern with a syntax error", "4:(" + "X" * 30000)
+)
+@timeout_unless_slower_valgrind(1)
+def test_pattern_syntax_error(pattern: str) -> None:
     # Arrange
     lb = ImageMorph.LutBuilder(op_name="corner")
-    new_patterns = ["a pattern with a syntax error"]
+    new_patterns = [pattern]
     lb.add_patterns(new_patterns)
 
     # Act / Assert
-    with pytest.raises(
+    with pytest.raises(Exception, match='Syntax error in pattern "'):
-        Exception, match='Syntax error in pattern "a pattern with a syntax error"'
-    ):
         lb.build_lut()
 
 

Tests/test_imageops.py

@@ -186,6 +186,21 @@ def test_palette(mode: str) -> None:
     )
 
 
+def test_rgba_palette() -> None:
+    im = Image.new("P", (1, 1))
+
+    red = (255, 0, 0, 255)
+    translucent_black = (0, 0, 0, 127)
+    im.putpalette(red + translucent_black, "RGBA")
+
+    expanded_im = ImageOps.expand(im, 1, 1)
+
+    palette = expanded_im.palette
+    assert palette is not None
+    assert palette.mode == "RGBA"
+    assert expanded_im.convert("RGBA").getpixel((0, 0)) == translucent_black
+
+
 def test_pil163() -> None:
     # Division by zero in equalize if < 255 pixels in image (@PIL163)
 

Tests/test_imagesequence.py

@@ -76,9 +76,14 @@ def test_consecutive() -> None:
 def test_palette_mmap() -> None:
     # Using mmap in ImageFile can require to reload the palette.
     with Image.open("Tests/images/multipage-mmap.tiff") as im:
-        color1 = im.getpalette()[:3]
+        palette = im.getpalette()
+        assert palette is not None
+        color1 = palette[:3]
         im.seek(0)
-        color2 = im.getpalette()[:3]
+
+        palette = im.getpalette()
+        assert palette is not None
+        color2 = palette[:3]
         assert color1 == color2
 
 

Tests/test_imageshow.py

@@ -59,15 +59,12 @@ def test_show(mode: str) -> None:
     assert ImageShow.show(im)
 
 
-def test_show_without_viewers() -> None:
+def test_show_without_viewers(monkeypatch: pytest.MonkeyPatch) -> None:
-    viewers = ImageShow._viewers
+    monkeypatch.setattr(ImageShow, "_viewers", [])
-    ImageShow._viewers = []
 
     with hopper() as im:
         assert not ImageShow.show(im)
 
-    ImageShow._viewers = viewers
-
 
 @pytest.mark.parametrize(
     "viewer",

Tests/test_nanoarrow.py

@@ -0,0 +1,302 @@
+from __future__ import annotations
+
+import json
+from typing import Any, NamedTuple
+
+import pytest
+
+from PIL import Image
+
+from .helper import (
+    assert_deep_equal,
+    assert_image_equal,
+    hopper,
+    is_big_endian,
+)
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    import nanoarrow  # type: ignore [import-not-found]
+else:
+    nanoarrow = pytest.importorskip("nanoarrow", reason="Nanoarrow not installed")
+
+TEST_IMAGE_SIZE = (10, 10)
+
+
+def _test_img_equals_pyarray(
+    img: Image.Image, arr: Any, mask: list[int] | None, elts_per_pixel: int = 1
+) -> None:
+    assert img.height * img.width * elts_per_pixel == len(arr)
+    px = img.load()
+    assert px is not None
+    if elts_per_pixel > 1 and mask is None:
+        # have to do element-wise comparison when we're comparing
+        # flattened r,g,b,a to a pixel.
+        mask = list(range(elts_per_pixel))
+    for x in range(0, img.size[0], int(img.size[0] / 10)):
+        for y in range(0, img.size[1], int(img.size[1] / 10)):
+            if mask:
+                pixel = px[x, y]
+                assert isinstance(pixel, tuple)
+                for ix, elt in enumerate(mask):
+                    if elts_per_pixel == 1:
+                        assert pixel[ix] == arr[y * img.width + x].as_py()[elt]
+                    else:
+                        assert (
+                            pixel[ix]
+                            == arr[(y * img.width + x) * elts_per_pixel + elt].as_py()
+                        )
+            else:
+                assert_deep_equal(px[x, y], arr[y * img.width + x].as_py())
+
+
+def _test_img_equals_int32_pyarray(
+    img: Image.Image, arr: Any, mask: list[int] | None, elts_per_pixel: int = 1
+) -> None:
+    assert img.height * img.width * elts_per_pixel == len(arr)
+    px = img.load()
+    assert px is not None
+    if mask is None:
+        # have to do element-wise comparison when we're comparing
+        # flattened rgba in an uint32 to a pixel.
+        mask = list(range(elts_per_pixel))
+    for x in range(0, img.size[0], int(img.size[0] / 10)):
+        for y in range(0, img.size[1], int(img.size[1] / 10)):
+            pixel = px[x, y]
+            assert isinstance(pixel, tuple)
+            arr_pixel_int = arr[y * img.width + x].as_py()
+            arr_pixel_tuple = (
+                arr_pixel_int % 256,
+                (arr_pixel_int // 256) % 256,
+                (arr_pixel_int // 256**2) % 256,
+                (arr_pixel_int // 256**3),
+            )
+            if is_big_endian():
+                arr_pixel_tuple = arr_pixel_tuple[::-1]
+
+            for ix, elt in enumerate(mask):
+                assert pixel[ix] == arr_pixel_tuple[elt]
+
+
+fl_uint8_4_type = nanoarrow.fixed_size_list(
+    value_type=nanoarrow.uint8(nullable=False), list_size=4, nullable=False
+)
+
+
+@pytest.mark.parametrize(
+    "mode, dtype, mask",
+    (
+        ("L", nanoarrow.uint8(nullable=False), None),
+        ("I", nanoarrow.int32(nullable=False), None),
+        ("F", nanoarrow.float32(nullable=False), None),
+        ("LA", fl_uint8_4_type, [0, 3]),
+        ("RGB", fl_uint8_4_type, [0, 1, 2]),
+        ("RGBA", fl_uint8_4_type, None),
+        ("RGBX", fl_uint8_4_type, None),
+        ("CMYK", fl_uint8_4_type, None),
+        ("YCbCr", fl_uint8_4_type, [0, 1, 2]),
+        ("HSV", fl_uint8_4_type, [0, 1, 2]),
+    ),
+)
+def test_to_array(mode: str, dtype: nanoarrow, mask: list[int] | None) -> None:
+    img = hopper(mode)
+
+    # Resize to non-square
+    img = img.crop((3, 0, 124, 127))
+    assert img.size == (121, 127)
+
+    arr = nanoarrow.Array(img)
+    _test_img_equals_pyarray(img, arr, mask)
+    assert arr.schema.type == dtype.type
+    assert arr.schema.nullable == dtype.nullable
+
+    reloaded = Image.fromarrow(arr, mode, img.size)
+    assert_image_equal(img, reloaded)
+
+
+def test_lifetime() -> None:
+    # valgrind shouldn't error out here.
+    # arrays should be accessible after the image is deleted.
+
+    img = hopper("L")
+
+    arr_1 = nanoarrow.Array(img)
+    arr_2 = nanoarrow.Array(img)
+
+    del img
+
+    assert sum(arr_1.iter_py()) > 0
+    del arr_1
+
+    assert sum(arr_2.iter_py()) > 0
+    del arr_2
+
+
+def test_lifetime2() -> None:
+    # valgrind shouldn't error out here.
+    # img should remain after the arrays are collected.
+
+    img = hopper("L")
+
+    arr_1 = nanoarrow.Array(img)
+    arr_2 = nanoarrow.Array(img)
+
+    assert sum(arr_1.iter_py()) > 0
+    del arr_1
+
+    assert sum(arr_2.iter_py()) > 0
+    del arr_2
+
+    img2 = img.copy()
+    px = img2.load()
+    assert px  # make mypy happy
+    assert isinstance(px[0, 0], int)
+
+
+class DataShape(NamedTuple):
+    dtype: nanoarrow
+    # Strictly speaking, elt should be a pixel or pixel component, so
+    # list[uint8][4], float, int, uint32, uint8, etc.  But more
+    # correctly, it should be exactly the dtype from the line above.
+    elt: Any
+    elts_per_pixel: int
+
+
+UINT_ARR = DataShape(
+    dtype=fl_uint8_4_type,
+    elt=[1, 2, 3, 4],  # array of 4 uint8 per pixel
+    elts_per_pixel=1,  # only one array per pixel
+)
+
+UINT = DataShape(
+    dtype=nanoarrow.uint8(),
+    elt=3,  # one uint8,
+    elts_per_pixel=4,  # but repeated 4x per pixel
+)
+
+UINT32 = DataShape(
+    dtype=nanoarrow.uint32(),
+    elt=0xABCDEF45,  # one packed int, doesn't fit in a int32 > 0x80000000
+    elts_per_pixel=1,  # one per pixel
+)
+
+INT32 = DataShape(
+    dtype=nanoarrow.uint32(),
+    elt=0x12CDEF45,  # one packed int
+    elts_per_pixel=1,  # one per pixel
+)
+
+
+@pytest.mark.parametrize(
+    "mode, data_tp, mask",
+    (
+        ("L", DataShape(nanoarrow.uint8(), 3, 1), None),
+        ("I", DataShape(nanoarrow.int32(), 1 << 24, 1), None),
+        ("F", DataShape(nanoarrow.float32(), 3.14159, 1), None),
+        ("LA", UINT_ARR, [0, 3]),
+        ("LA", UINT, [0, 3]),
+        ("RGB", UINT_ARR, [0, 1, 2]),
+        ("RGBA", UINT_ARR, None),
+        ("CMYK", UINT_ARR, None),
+        ("YCbCr", UINT_ARR, [0, 1, 2]),
+        ("HSV", UINT_ARR, [0, 1, 2]),
+        ("RGB", UINT, [0, 1, 2]),
+        ("RGBA", UINT, None),
+        ("CMYK", UINT, None),
+        ("YCbCr", UINT, [0, 1, 2]),
+        ("HSV", UINT, [0, 1, 2]),
+    ),
+)
+def test_fromarray(mode: str, data_tp: DataShape, mask: list[int] | None) -> None:
+    (dtype, elt, elts_per_pixel) = data_tp
+
+    ct_pixels = TEST_IMAGE_SIZE[0] * TEST_IMAGE_SIZE[1]
+    if dtype == fl_uint8_4_type:
+        tmp_arr = nanoarrow.Array(
+            elt * (ct_pixels * elts_per_pixel), schema=nanoarrow.uint8()
+        )
+        c_array = nanoarrow.c_array_from_buffers(
+            dtype, ct_pixels, buffers=[], children=[tmp_arr]
+        )
+        arr = nanoarrow.Array(c_array)
+    else:
+        arr = nanoarrow.Array(
+            nanoarrow.c_array([elt] * (ct_pixels * elts_per_pixel), schema=dtype)
+        )
+    img = Image.fromarrow(arr, mode, TEST_IMAGE_SIZE)
+
+    _test_img_equals_pyarray(img, arr, mask, elts_per_pixel)
+
+
+@pytest.mark.parametrize(
+    "mode, mask",
+    (
+        ("LA", [0, 3]),
+        ("RGB", [0, 1, 2]),
+        ("RGBA", None),
+        ("CMYK", None),
+        ("YCbCr", [0, 1, 2]),
+        ("HSV", [0, 1, 2]),
+    ),
+)
+@pytest.mark.parametrize("data_tp", (UINT32, INT32))
+def test_from_int32array(mode: str, mask: list[int] | None, data_tp: DataShape) -> None:
+    (dtype, elt, elts_per_pixel) = data_tp
+
+    ct_pixels = TEST_IMAGE_SIZE[0] * TEST_IMAGE_SIZE[1]
+    arr = nanoarrow.Array(
+        nanoarrow.c_array([elt] * (ct_pixels * elts_per_pixel), schema=dtype)
+    )
+    img = Image.fromarrow(arr, mode, TEST_IMAGE_SIZE)
+
+    _test_img_equals_int32_pyarray(img, arr, mask, elts_per_pixel)
+
+
+@pytest.mark.parametrize(
+    "mode, metadata",
+    (
+        ("LA", ["L", "X", "X", "A"]),
+        ("RGB", ["R", "G", "B", "X"]),
+        ("RGBX", ["R", "G", "B", "X"]),
+        ("RGBA", ["R", "G", "B", "A"]),
+        ("CMYK", ["C", "M", "Y", "K"]),
+        ("YCbCr", ["Y", "Cb", "Cr", "X"]),
+        ("HSV", ["H", "S", "V", "X"]),
+    ),
+)
+def test_image_nested_metadata(mode: str, metadata: list[str]) -> None:
+    img = hopper(mode)
+
+    arr = nanoarrow.Array(img)
+
+    assert arr.schema.value_type.metadata
+    assert arr.schema.value_type.metadata[b"image"]
+
+    parsed_metadata = json.loads(
+        arr.schema.value_type.metadata[b"image"].decode("utf8")
+    )
+
+    assert "bands" in parsed_metadata
+    assert parsed_metadata["bands"] == metadata
+
+
+@pytest.mark.parametrize(
+    "mode, metadata",
+    (
+        ("L", ["L"]),
+        ("I", ["I"]),
+        ("F", ["F"]),
+    ),
+)
+def test_image_flat_metadata(mode: str, metadata: list[str]) -> None:
+    img = hopper(mode)
+
+    arr = nanoarrow.Array(img)
+
+    assert arr.schema.metadata
+    assert arr.schema.metadata[b"image"]
+
+    parsed_metadata = json.loads(arr.schema.metadata[b"image"].decode("utf8"))
+
+    assert "bands" in parsed_metadata
+    assert parsed_metadata["bands"] == metadata

Tests/test_pyarrow.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 from typing import Any, NamedTuple
 
 import pytest
@@ -244,3 +245,29 @@ def test_from_int32array(mode: str, data_tp: DataShape, mask: list[int] | None)
     img = Image.fromarrow(arr, mode, TEST_IMAGE_SIZE)
 
     _test_img_equals_int32_pyarray(img, arr, mask, elts_per_pixel)
+
+
+@pytest.mark.parametrize(
+    "mode, metadata",
+    (
+        ("LA", ["L", "X", "X", "A"]),
+        ("RGB", ["R", "G", "B", "X"]),
+        ("RGBX", ["R", "G", "B", "X"]),
+        ("RGBA", ["R", "G", "B", "A"]),
+        ("CMYK", ["C", "M", "Y", "K"]),
+        ("YCbCr", ["Y", "Cb", "Cr", "X"]),
+        ("HSV", ["H", "S", "V", "X"]),
+    ),
+)
+def test_image_metadata(mode: str, metadata: list[str]) -> None:
+    img = hopper(mode)
+
+    arr = pyarrow.array(img)  # type: ignore[call-overload]
+
+    assert arr.type.field(0).metadata
+    assert arr.type.field(0).metadata[b"image"]
+
+    parsed_metadata = json.loads(arr.type.field(0).metadata[b"image"].decode("utf8"))
+
+    assert "bands" in parsed_metadata
+    assert parsed_metadata["bands"] == metadata

Tests/test_pyroma.py

@@ -9,7 +9,7 @@ from PIL import __version__
 pyroma = pytest.importorskip("pyroma", reason="Pyroma not installed")
 
 
-def map_metadata_keys(metadata):
+def map_metadata_keys(md):
     # Convert installed wheel metadata into canonical Core Metadata 2.4 format.
     # This was a utility method in pyroma 4.3.3; it was removed in 5.0.
     # This implementation is constructed from the relevant logic from
@@ -17,8 +17,8 @@ def map_metadata_keys(metadata):
     # upstream to Pyroma as https://github.com/regebro/pyroma/pull/116,
     # so it may be possible to simplify this test in future.
     data = {}
-    for key in set(metadata.keys()):
+    for key in set(md.keys()):
-        value = metadata.get_all(key)
+        value = md.get_all(key)
         key = pyroma.projectdata.normalize(key)
 
         if len(value) == 1:

checks/32bit_segfault_check.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python3
 from __future__ import annotations
 
 import sys

checks/check_imaging_leaks.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python3
 from __future__ import annotations
 
 import sys

checks/check_wheel.py

@@ -4,7 +4,6 @@ import platform
 import sys
 
 from PIL import features
-from Tests.helper import is_pypy
 
 
 def test_wheel_modules() -> None:
@@ -48,8 +47,6 @@ def test_wheel_features() -> None:
 
     if sys.platform == "win32":
         expected_features.remove("xcb")
-    elif sys.platform == "darwin" and not is_pypy() and platform.processor() != "arm":
-        expected_features.remove("zlib_ng")
     elif sys.platform == "ios":
         # Can't distribute raqm due to licensing, and there's no system version;
         # fribidi and harfbuzz won't be available if raqm isn't available.

depends/install_libavif.sh

@@ -59,6 +59,6 @@ cmake \
     "${LIBAVIF_CMAKE_FLAGS[@]}" \
     .
 
-sudo make install
+make install
 
 popd

depends/install_openjpeg.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 # install openjpeg
 
-archive=openjpeg-2.5.3
+archive=openjpeg-2.5.4
 
 ./download-and-extract.sh $archive https://raw.githubusercontent.com/python-pillow/pillow-depends/main/$archive.tar.gz
 

depends/install_raqm.sh

@@ -2,12 +2,12 @@
 # install raqm
 
 
-archive=libraqm-0.10.2
+archive=libraqm-0.10.3
 
 ./download-and-extract.sh $archive https://raw.githubusercontent.com/python-pillow/pillow-depends/main/$archive.tar.gz
 
 pushd $archive
 
-meson build --prefix=/usr && sudo ninja -C build install
+meson build --prefix=/usr && ninja -C build install
 
 popd

docs/deprecations.rst

@@ -35,8 +35,12 @@ Image.fromarray mode parameter
 
 .. deprecated:: 11.3.0
 
-The ``mode`` parameter in :py:meth:`~PIL.Image.fromarray()` has been deprecated. The
+Using the ``mode`` parameter in :py:meth:`~PIL.Image.fromarray()` was deprecated in
-mode can be automatically determined from the object's shape and type instead.
+Pillow 11.3.0. In Pillow 12.0.0, this was partially reverted, and it is now only
+deprecated when changing data types. Since pixel values do not contain information
+about palettes or color spaces, the parameter can still be used to place grayscale L
+mode data within a P mode image, or read RGB data as YCbCr for example. If omitted, the
+mode will be automatically determined from the object's shape and type.
 
 Saving I mode images as PNG
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,6 +65,14 @@ ImageCms.ImageCmsProfile.product_name and .product_info
 ``.product_info`` attributes have been deprecated, and will be removed in
 Pillow 13 (2026-10-15). They have been set to ``None`` since Pillow 2.3.0.
 
+Image._show
+~~~~~~~~~~~
+
+.. deprecated:: 12.0.0
+
+``Image._show`` has been deprecated, and will be removed in Pillow 13 (2026-10-15).
+Use :py:meth:`~PIL.ImageShow.show` instead.
+
 Removed features
 ----------------
 

docs/installation/building-from-source.rst

@@ -44,7 +44,7 @@ Many of Pillow's features require external libraries:
 
 * **libtiff** provides compressed TIFF functionality
 
-  * Pillow has been tested with libtiff versions **4.0-4.7.0**
+  * Pillow has been tested with libtiff versions **4.0-4.7.1**
 
 * **libfreetype** provides type related services
 
@@ -58,7 +58,7 @@ Many of Pillow's features require external libraries:
 * **openjpeg** provides JPEG 2000 functionality.
 
   * Pillow has been tested with openjpeg **2.0.0**, **2.1.0**, **2.3.1**,
-    **2.4.0**, **2.5.0**, **2.5.2** and **2.5.3**.
+    **2.4.0**, **2.5.0**, **2.5.2**, **2.5.3** and **2.5.4**.
   * Pillow does **not** support the earlier **1.5** series which ships
     with Debian Jessie.
 

docs/installation/platform-support.rst

@@ -39,9 +39,9 @@ These platforms are built and tested for every change.
 +----------------------------------+----------------------------+---------------------+
 | Gentoo                           | 3.12                       | x86-64              |
 +----------------------------------+----------------------------+---------------------+
-| macOS 13 Ventura                 | 3.10                       | x86-64              |
+| macOS 15 Sequoia                 | 3.10                       | x86-64              |
-+----------------------------------+----------------------------+---------------------+
+|                                  +----------------------------+---------------------+
-| macOS 15 Sequoia                 | 3.11, 3.12, 3.13, 3.14     | arm64               |
+|                                  | 3.11, 3.12, 3.13, 3.14,    | arm64               |
 |                                  | PyPy3                      |                     |
 +----------------------------------+----------------------------+---------------------+
 | Ubuntu Linux 22.04 LTS (Jammy)   | 3.10                       | x86-64              |
@@ -75,6 +75,8 @@ These platforms have been reported to work at the versions mentioned.
 | Operating system                 | | Tested Python            | | Latest tested  | | Tested     |
 |                                  | | versions                 | | Pillow version | | processors |
 +==================================+============================+==================+==============+
+| macOS 26 Tahoe                   | 3.9, 3.10, 3.11, 3.12, 3.13| 11.3.0           |arm           |
++----------------------------------+----------------------------+------------------+--------------+
 | macOS 15 Sequoia                 | 3.9, 3.10, 3.11, 3.12, 3.13| 11.3.0           |arm           |
 |                                  +----------------------------+------------------+              |
 |                                  | 3.8                        | 10.4.0           |              |

docs/reference/ImageDraw.rst

@@ -57,6 +57,43 @@ Color names
 
 See :ref:`color-names` for the color names supported by Pillow.
 
+Alpha channel
+^^^^^^^^^^^^^
+
+By default, when drawing onto an existing image, the image's pixel values are simply
+replaced by the new color::
+
+    im = Image.new("RGBA", (1, 1), (255, 0, 0))
+    d = ImageDraw.Draw(im)
+    d.rectangle((0, 0, 1, 1), (0, 255, 0, 127))
+    assert im.getpixel((0, 0)) == (0, 255, 0, 127)
+
+    # Alpha channel values have no effect when drawing with RGB mode
+    im = Image.new("RGB", (1, 1), (255, 0, 0))
+    d = ImageDraw.Draw(im)
+    d.rectangle((0, 0, 1, 1), (0, 255, 0, 127))
+    assert im.getpixel((0, 0)) == (0, 255, 0)
+
+If you would like to combine translucent color with an RGB image, then initialize the
+ImageDraw instance with the RGBA mode::
+
+    from PIL import Image, ImageDraw
+    im = Image.new("RGB", (1, 1), (255, 0, 0))
+    d = ImageDraw.Draw(im, "RGBA")
+    d.rectangle((0, 0, 1, 1), (0, 255, 0, 127))
+    assert im.getpixel((0, 0)) == (128, 127, 0)
+
+If you would like to combine translucent color with an RGBA image underneath, you will
+need to combine multiple images::
+
+    from PIL import Image, ImageDraw
+    im = Image.new("RGBA", (1, 1), (255, 0, 0, 255))
+    im2 = Image.new("RGBA", (1, 1))
+    d = ImageDraw.Draw(im2)
+    d.rectangle((0, 0, 1, 1), (0, 255, 0, 127))
+    im.paste(im2.convert("RGB"), mask=im2)
+    assert im.getpixel((0, 0)) == (128, 127, 0, 255)
+
 Fonts
 ^^^^^
 

docs/reference/ImageGrab.rst

@@ -20,7 +20,9 @@ or the clipboard to a PIL image memory.
     used as a fallback if they are installed. To disable this behaviour, pass
     ``xdisplay=""`` instead.
 
-    .. versionadded:: 1.1.3 (Windows), 3.0.0 (macOS), 7.1.0 (Linux)
+    .. versionadded:: 1.1.3 Windows support
+    .. versionadded:: 3.0.0 macOS support
+    .. versionadded:: 7.1.0 Linux support
 
     :param bbox: What region to copy. Default is the entire screen.
                  On macOS, this is not increased to 2x for Retina screens, so the full
@@ -53,7 +55,9 @@ or the clipboard to a PIL image memory.
 
     On Linux, ``wl-paste`` or ``xclip`` is required.
 
-    .. versionadded:: 1.1.4 (Windows), 3.3.0 (macOS), 9.4.0 (Linux)
+    .. versionadded:: 1.1.4 Windows support
+    .. versionadded:: 3.3.0 macOS support
+    .. versionadded:: 9.4.0 Linux support
 
     :return: On Windows, an image, a list of filenames,
              or None if the clipboard does not contain image data or filenames.

docs/releasenotes/11.3.0.rst

@@ -29,6 +29,13 @@ Image.fromarray mode parameter
 The ``mode`` parameter in :py:meth:`~PIL.Image.fromarray()` has been deprecated. The
 mode can be automatically determined from the object's shape and type instead.
 
+.. note::
+
+    Since pixel values do not contain information about palettes or color spaces, part
+    of this functionality was restored in Pillow 12.0.0. The parameter can be used to
+    place grayscale L mode data within a P mode image, or read RGB data as YCbCr for
+    example.
+
 Saving I mode images as PNG
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 

docs/releasenotes/12.0.0.rst

@@ -1,19 +1,6 @@
 12.0.0
 ------
 
-Security
-========
-
-TODO
-^^^^
-
-TODO
-
-:cve:`YYYY-XXXXX`: TODO
-^^^^^^^^^^^^^^^^^^^^^^^
-
-TODO
-
 Backwards incompatible changes
 ==============================
 
@@ -116,6 +103,12 @@ vulnerability introduced in FreeType 2.6 (:cve:`2020-15999`).
 Deprecations
 ============
 
+Image._show
+^^^^^^^^^^^
+
+``Image._show`` has been deprecated, and will be removed in Pillow 13 (2026-10-15).
+Use :py:meth:`~PIL.ImageShow.show` instead.
+
 ImageCms.ImageCmsProfile.product_name and .product_info
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -126,18 +119,10 @@ Pillow 13 (2026-10-15). They have been set to ``None`` since Pillow 2.3.0.
 API changes
 ===========
 
-TODO
+Image.alpha_composite: LA images
-^^^^
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-TODO
+:py:meth:`~PIL.Image.alpha_composite` can now use LA images as well as RGBA.
-
-API additions
-=============
-
-TODO
-^^^^
-
-TODO
 
 Other changes
 =============
@@ -150,3 +135,19 @@ others prepare for 3.14, and to ensure Pillow could be used immediately at the r
 of 3.14.0 final (2025-10-07, :pep:`745`).
 
 Pillow 12.0.0 now officially supports Python 3.14.
+
+Image.fromarray mode parameter
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In Pillow 11.3.0, the ``mode`` parameter in :py:meth:`~PIL.Image.fromarray()` was
+deprecated. Part of this functionality has been restored in Pillow 12.0.0. Since pixel
+values do not contain information about palettes or color spaces, the parameter can be
+used to place grayscale L mode data within a P mode image, or read RGB data as YCbCr
+for example.
+
+ImageMorph operations must have length 1
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Valid ImageMorph operations are 4, N, 1 and M. By limiting the length to 1 character
+within Pillow, long execution times can be avoided if a user provided long pattern
+strings. Reported by `Jang Choi <https://github.com/uko3211>`__.

pyproject.toml

@@ -57,6 +57,9 @@ optional-dependencies.mic = [
   "olefile",
 ]
 optional-dependencies.test-arrow = [
+  "arro3-compute",
+  "arro3-core",
+  "nanoarrow",
   "pyarrow",
 ]
 

src/PIL/CurImagePlugin.py

@@ -17,7 +17,7 @@
 #
 from __future__ import annotations
 
-from . import BmpImagePlugin, Image, ImageFile
+from . import BmpImagePlugin, Image
 from ._binary import i16le as i16
 from ._binary import i32le as i32
 
@@ -38,6 +38,7 @@ class CurImageFile(BmpImagePlugin.BmpImageFile):
     format_description = "Windows Cursor"
 
     def _open(self) -> None:
+        assert self.fp is not None
         offset = self.fp.tell()
 
         # check magic
@@ -63,8 +64,7 @@ class CurImageFile(BmpImagePlugin.BmpImageFile):
 
         # patch up the bitmap height
         self._size = self.size[0], self.size[1] // 2
-        d, e, o, a = self.tile[0]
+        self.tile = [self.tile[0]._replace(extents=(0, 0) + self.size)]
-        self.tile[0] = ImageFile._Tile(d, (0, 0) + self.size, o, a)
 
 
 #

src/PIL/EpsImagePlugin.py

@@ -354,6 +354,9 @@ class EpsImageFile(ImageFile.ImageFile):
                 read_comment(s)
             elif bytes_mv[:9] == b"%%Trailer":
                 trailer_reached = True
+            elif bytes_mv[:14] == b"%%BeginBinary:":
+                bytecount = int(byte_arr[14:bytes_read])
+                self.fp.seek(bytecount, os.SEEK_CUR)
             bytes_read = 0
 
         # A "BoundingBox" is always required,

src/PIL/FliImagePlugin.py

@@ -48,8 +48,14 @@ class FliImageFile(ImageFile.ImageFile):
 
     def _open(self) -> None:
         # HEAD
+        assert self.fp is not None
         s = self.fp.read(128)
-        if not (_accept(s) and s[20:22] == b"\x00\x00"):
+        if not (
+            _accept(s)
+            and s[20:22] == b"\x00" * 2
+            and s[42:80] == b"\x00" * 38
+            and s[88:] == b"\x00" * 40
+        ):
             msg = "not an FLI/FLC file"
             raise SyntaxError(msg)
 
@@ -77,8 +83,7 @@ class FliImageFile(ImageFile.ImageFile):
 
         if i16(s, 4) == 0xF100:
             # prefix chunk; ignore it
-            self.__offset = self.__offset + i32(s)
+            self.fp.seek(self.__offset + i32(s))
-            self.fp.seek(self.__offset)
             s = self.fp.read(16)
 
         if i16(s, 4) == 0xF1FA:
@@ -111,6 +116,7 @@ class FliImageFile(ImageFile.ImageFile):
         # load palette
 
         i = 0
+        assert self.fp is not None
         for e in range(i16(self.fp.read(2))):
             s = self.fp.read(2)
             i = i + s[0]

src/PIL/Image.py

@@ -1009,8 +1009,14 @@ class Image:
                 new_im.info["transparency"] = transparency
             return new_im
 
-        if mode == "P" and self.mode == "RGBA":
+        if self.mode == "RGBA":
-            return self.quantize(colors)
+            if mode == "P":
+                return self.quantize(colors)
+            elif mode == "PA":
+                r, g, b, a = self.split()
+                rgb = merge("RGB", (r, g, b))
+                p = rgb.quantize(colors)
+                return merge("PA", (p, a))
 
         trns = None
         delete_trns = False
@@ -1142,7 +1148,7 @@ class Image:
                 raise ValueError(msg) from e
 
         new_im = self._new(im)
-        if mode == "P" and palette != Palette.ADAPTIVE:
+        if mode in ("P", "PA") and palette != Palette.ADAPTIVE:
             from . import ImagePalette
 
             new_im.palette = ImagePalette.ImagePalette("RGB", im.getpalette("RGB"))
@@ -1336,12 +1342,6 @@ class Image:
         """
         pass
 
-    def _expand(self, xmargin: int, ymargin: int | None = None) -> Image:
-        if ymargin is None:
-            ymargin = xmargin
-        self.load()
-        return self._new(self.im.expand(xmargin, ymargin))
-
     def filter(self, filter: ImageFilter.Filter | type[ImageFilter.Filter]) -> Image:
         """
         Filters this image using the given filter.  For a list of
@@ -2070,9 +2070,7 @@ class Image:
         :param value: The pixel value.
         """
 
-        if self.readonly:
+        self._ensure_mutable()
-            self._copy()
-        self.load()
 
         if (
             self.mode in ("P", "PA")
@@ -2632,7 +2630,9 @@ class Image:
         :param title: Optional title to use for the image window, where possible.
         """
 
-        _show(self, title=title)
+        from . import ImageShow
+
+        ImageShow.show(self, title)
 
     def split(self) -> tuple[Image, ...]:
         """
@@ -3257,19 +3257,10 @@ def fromarray(obj: SupportsArrayInterface, mode: str | None = None) -> Image:
     transferred. This means that P and PA mode images will lose their palette.
 
     :param obj: Object with array interface
-    :param mode: Optional mode to use when reading ``obj``. Will be determined from
+    :param mode: Optional mode to use when reading ``obj``. Since pixel values do not
-      type if ``None``. Deprecated.
+      contain information about palettes or color spaces, this can be used to place
-
+      grayscale L mode data within a P mode image, or read RGB data as YCbCr for
-      This will not be used to convert the data after reading, but will be used to
+      example.
-      change how the data is read::
-
-        from PIL import Image
-        import numpy as np
-        a = np.full((1, 1), 300)
-        im = Image.fromarray(a, mode="L")
-        im.getpixel((0, 0))  # 44
-        im = Image.fromarray(a, mode="RGB")
-        im.getpixel((0, 0))  # (44, 1, 0)
 
       See: :ref:`concept-modes` for general information about modes.
     :returns: An image object.
@@ -3280,21 +3271,28 @@ def fromarray(obj: SupportsArrayInterface, mode: str | None = None) -> Image:
     shape = arr["shape"]
     ndim = len(shape)
     strides = arr.get("strides", None)
-    if mode is None:
+    try:
-        try:
+        typekey = (1, 1) + shape[2:], arr["typestr"]
-            typekey = (1, 1) + shape[2:], arr["typestr"]
+    except KeyError as e:
-        except KeyError as e:
+        if mode is not None:
+            typekey = None
+            color_modes: list[str] = []
+        else:
             msg = "Cannot handle this data type"
             raise TypeError(msg) from e
+    if typekey is not None:
         try:
-            mode, rawmode = _fromarray_typemap[typekey]
+            typemode, rawmode, color_modes = _fromarray_typemap[typekey]
         except KeyError as e:
             typekey_shape, typestr = typekey
             msg = f"Cannot handle this data type: {typekey_shape}, {typestr}"
             raise TypeError(msg) from e
-    else:
+    if mode is not None:
-        deprecate("'mode' parameter", 13)
+        if mode != typemode and mode not in color_modes:
+            deprecate("'mode' parameter for changing data types", 13)
         rawmode = mode
+    else:
+        mode = typemode
     if mode in ["1", "L", "I", "P", "F"]:
         ndmax = 2
     elif mode == "RGB":
@@ -3391,29 +3389,29 @@ def fromqpixmap(im: ImageQt.QPixmap) -> ImageFile.ImageFile:
 
 
 _fromarray_typemap = {
-    # (shape, typestr) => mode, rawmode
+    # (shape, typestr) => mode, rawmode, color modes
     # first two members of shape are set to one
-    ((1, 1), "|b1"): ("1", "1;8"),
+    ((1, 1), "|b1"): ("1", "1;8", []),
-    ((1, 1), "|u1"): ("L", "L"),
+    ((1, 1), "|u1"): ("L", "L", ["P"]),
-    ((1, 1), "|i1"): ("I", "I;8"),
+    ((1, 1), "|i1"): ("I", "I;8", []),
-    ((1, 1), "<u2"): ("I", "I;16"),
+    ((1, 1), "<u2"): ("I", "I;16", []),
-    ((1, 1), ">u2"): ("I", "I;16B"),
+    ((1, 1), ">u2"): ("I", "I;16B", []),
-    ((1, 1), "<i2"): ("I", "I;16S"),
+    ((1, 1), "<i2"): ("I", "I;16S", []),
-    ((1, 1), ">i2"): ("I", "I;16BS"),
+    ((1, 1), ">i2"): ("I", "I;16BS", []),
-    ((1, 1), "<u4"): ("I", "I;32"),
+    ((1, 1), "<u4"): ("I", "I;32", []),
-    ((1, 1), ">u4"): ("I", "I;32B"),
+    ((1, 1), ">u4"): ("I", "I;32B", []),
-    ((1, 1), "<i4"): ("I", "I;32S"),
+    ((1, 1), "<i4"): ("I", "I;32S", []),
-    ((1, 1), ">i4"): ("I", "I;32BS"),
+    ((1, 1), ">i4"): ("I", "I;32BS", []),
-    ((1, 1), "<f4"): ("F", "F;32F"),
+    ((1, 1), "<f4"): ("F", "F;32F", []),
-    ((1, 1), ">f4"): ("F", "F;32BF"),
+    ((1, 1), ">f4"): ("F", "F;32BF", []),
-    ((1, 1), "<f8"): ("F", "F;64F"),
+    ((1, 1), "<f8"): ("F", "F;64F", []),
-    ((1, 1), ">f8"): ("F", "F;64BF"),
+    ((1, 1), ">f8"): ("F", "F;64BF", []),
-    ((1, 1, 2), "|u1"): ("LA", "LA"),
+    ((1, 1, 2), "|u1"): ("LA", "LA", ["La", "PA"]),
-    ((1, 1, 3), "|u1"): ("RGB", "RGB"),
+    ((1, 1, 3), "|u1"): ("RGB", "RGB", ["YCbCr", "LAB", "HSV"]),
-    ((1, 1, 4), "|u1"): ("RGBA", "RGBA"),
+    ((1, 1, 4), "|u1"): ("RGBA", "RGBA", ["RGBa", "RGBX", "CMYK"]),
     # shortcuts:
-    ((1, 1), f"{_ENDIAN}i4"): ("I", "I"),
+    ((1, 1), f"{_ENDIAN}i4"): ("I", "I", []),
-    ((1, 1), f"{_ENDIAN}f4"): ("F", "F"),
+    ((1, 1), f"{_ENDIAN}f4"): ("F", "F", []),
 }
 
 
@@ -3797,6 +3795,7 @@ def register_encoder(name: str, encoder: type[ImageFile.PyEncoder]) -> None:
 def _show(image: Image, **options: Any) -> None:
     from . import ImageShow
 
+    deprecate("Image._show", 13, "ImageShow.show")
     ImageShow.show(image, **options)
 
 

src/PIL/ImageDraw.py

@@ -76,9 +76,7 @@ class ImageDraw:
            must be the same as the image mode.  If omitted, the mode
            defaults to the mode of the image.
         """
-        im.load()
+        im._ensure_mutable()
-        if im.readonly:
-            im._copy()  # make it writeable
         blend = 0
         if mode is None:
             mode = im.mode

src/PIL/ImageFile.py

@@ -313,6 +313,9 @@ class ImageFile(Image.Image):
                 and args[0] == self.mode
                 and args[0] in Image._MAPMODES
             ):
+                if offset < 0:
+                    msg = "Tile offset cannot be negative"
+                    raise ValueError(msg)
                 try:
                     # use mmap, if possible
                     import mmap

src/PIL/ImageFont.py

@@ -125,11 +125,16 @@ class ImageFont:
             image.close()
 
     def _load_pilfont_data(self, file: IO[bytes], image: Image.Image) -> None:
+        # check image
+        if image.mode not in ("1", "L"):
+            msg = "invalid font image mode"
+            raise TypeError(msg)
+
         # read PILfont header
-        if file.readline() != b"PILfont\n":
+        if file.read(8) != b"PILfont\n":
             msg = "Not a PILfont file"
             raise SyntaxError(msg)
-        file.readline().split(b";")
+        file.readline()
         self.info = []  # FIXME: should be a dictionary
         while True:
             s = file.readline()
@@ -140,11 +145,6 @@ class ImageFont:
         # read PILfont metrics
         data = file.read(256 * 20)
 
-        # check image
-        if image.mode not in ("1", "L"):
-            msg = "invalid font image mode"
-            raise TypeError(msg)
-
         image.load()
 
         self.font = Image.core.font(image.im, data)

src/PIL/ImageMorph.py

@@ -150,7 +150,7 @@ class LutBuilder:
 
         # Parse and create symmetries of the patterns strings
         for p in self.patterns:
-            m = re.search(r"(\w*):?\s*\((.+?)\)\s*->\s*(\d)", p.replace("\n", ""))
+            m = re.search(r"(\w):?\s*\((.+?)\)\s*->\s*(\d)", p.replace("\n", ""))
             if not m:
                 msg = 'Syntax error in pattern "' + p + '"'
                 raise Exception(msg)

src/PIL/ImageOps.py

@@ -499,14 +499,15 @@ def expand(
     height = top + image.size[1] + bottom
     color = _color(fill, image.mode)
     if image.palette:
-        palette = ImagePalette.ImagePalette(palette=image.getpalette())
+        mode = image.palette.mode
+        palette = ImagePalette.ImagePalette(mode, image.getpalette(mode))
         if isinstance(color, tuple) and (len(color) == 3 or len(color) == 4):
             color = palette.getcolor(color)
     else:
         palette = None
     out = Image.new(image.mode, (width, height), color)
     if palette:
-        out.putpalette(palette.palette)
+        out.putpalette(palette.palette, mode)
     out.paste(image, (left, top))
     return out
 

src/PIL/IptcImagePlugin.py

@@ -34,10 +34,6 @@ def _i(c: bytes) -> int:
     return i32((b"\0\0\0\0" + c)[-4:])
 
 
-def _i8(c: int | bytes) -> int:
-    return c if isinstance(c, int) else c[0]
-
-
 ##
 # Image plugin for IPTC/NAA datastreams.  To read IPTC/NAA fields
 # from TIFF and JPEG files, use the <b>getiptcinfo</b> function.
@@ -100,16 +96,18 @@ class IptcImageFile(ImageFile.ImageFile):
         # mode
         layers = self.info[(3, 60)][0]
         component = self.info[(3, 60)][1]
-        if (3, 65) in self.info:
-            id = self.info[(3, 65)][0] - 1
-        else:
-            id = 0
         if layers == 1 and not component:
             self._mode = "L"
-        elif layers == 3 and component:
+            band = None
-            self._mode = "RGB"[id]
+        else:
-        elif layers == 4 and component:
+            if layers == 3 and component:
-            self._mode = "CMYK"[id]
+                self._mode = "RGB"
+            elif layers == 4 and component:
+                self._mode = "CMYK"
+            if (3, 65) in self.info:
+                band = self.info[(3, 65)][0] - 1
+            else:
+                band = 0
 
         # size
         self._size = self.getint((3, 20)), self.getint((3, 30))
@@ -124,39 +122,44 @@ class IptcImageFile(ImageFile.ImageFile):
         # tile
         if tag == (8, 10):
             self.tile = [
-                ImageFile._Tile("iptc", (0, 0) + self.size, offset, compression)
+                ImageFile._Tile("iptc", (0, 0) + self.size, offset, (compression, band))
             ]
 
     def load(self) -> Image.core.PixelAccess | None:
-        if len(self.tile) != 1 or self.tile[0][0] != "iptc":
+        if self.tile:
-            return ImageFile.ImageFile.load(self)
+            args = self.tile[0].args
+            assert isinstance(args, tuple)
+            compression, band = args
 
-        offset, compression = self.tile[0][2:]
+            self.fp.seek(self.tile[0].offset)
 
-        self.fp.seek(offset)
+            # Copy image data to temporary file
-
+            o = BytesIO()
-        # Copy image data to temporary file
+            if compression == "raw":
-        o = BytesIO()
+                # To simplify access to the extracted file,
-        if compression == "raw":
+                # prepend a PPM header
-            # To simplify access to the extracted file,
+                o.write(b"P5\n%d %d\n255\n" % self.size)
-            # prepend a PPM header
+            while True:
-            o.write(b"P5\n%d %d\n255\n" % self.size)
+                type, size = self.field()
-        while True:
+                if type != (8, 10):
-            type, size = self.field()
-            if type != (8, 10):
-                break
-            while size > 0:
-                s = self.fp.read(min(size, 8192))
-                if not s:
                     break
-                o.write(s)
+                while size > 0:
-                size -= len(s)
+                    s = self.fp.read(min(size, 8192))
+                    if not s:
+                        break
+                    o.write(s)
+                    size -= len(s)
 
-        with Image.open(o) as _im:
+            with Image.open(o) as _im:
-            _im.load()
+                if band is not None:
-            self.im = _im.im
+                    bands = [Image.new("L", _im.size)] * Image.getmodebands(self.mode)
-        self.tile = []
+                    bands[band] = _im
-        return Image.Image.load(self)
+                    _im = Image.merge(self.mode, bands)
+                else:
+                    _im.load()
+                self.im = _im.im
+            self.tile = []
+        return ImageFile.ImageFile.load(self)
 
 
 Image.register_open(IptcImageFile.format, IptcImageFile)

src/PIL/JpegImagePlugin.py

@@ -193,6 +193,8 @@ def SOF(self: JpegImageFile, marker: int) -> None:
     n = i16(self.fp.read(2)) - 2
     s = ImageFile._safe_read(self.fp, n)
     self._size = i16(s, 3), i16(s, 1)
+    if self._im is not None and self.size != self.im.size:
+        self._im = None
 
     self.bits = s[0]
     if self.bits != 8:

src/PIL/PcdImagePlugin.py

@@ -43,16 +43,21 @@ class PcdImageFile(ImageFile.ImageFile):
         if orientation == 1:
             self.tile_post_rotate = 90
         elif orientation == 3:
-            self.tile_post_rotate = -90
+            self.tile_post_rotate = 270
 
         self._mode = "RGB"
         self._size = (512, 768) if orientation in (1, 3) else (768, 512)
-        self.tile = [ImageFile._Tile("pcd", (0, 0) + self.size, 96 * 2048)]
+        self.tile = [ImageFile._Tile("pcd", (0, 0, 768, 512), 96 * 2048)]
+
+    def load_prepare(self) -> None:
+        if self._im is None and self.tile_post_rotate:
+            self.im = Image.core.new(self.mode, (768, 512))
+        ImageFile.ImageFile.load_prepare(self)
 
     def load_end(self) -> None:
         if self.tile_post_rotate:
             # Handle rotated PCDs
-            self.im = self.im.rotate(self.tile_post_rotate)
+            self.im = self.rotate(self.tile_post_rotate, expand=True).im
 
 
 #

src/PIL/PdfImagePlugin.py

@@ -27,7 +27,7 @@ import os
 import time
 from typing import IO, Any
 
-from . import Image, ImageFile, ImageSequence, PdfParser, __version__, features
+from . import Image, ImageFile, ImageSequence, PdfParser, features
 
 #
 # --------------------------------------------------------------------
@@ -221,7 +221,7 @@ def _save(
 
     existing_pdf.start_writing()
     existing_pdf.write_header()
-    existing_pdf.write_comment(f"created by Pillow {__version__} PDF driver")
+    existing_pdf.write_comment("created by Pillow PDF driver")
 
     #
     # pages

src/PIL/TiffImagePlugin.py

@@ -252,6 +252,7 @@ OPEN_INFO = {
     (II, 3, (1,), 1, (8,), ()): ("P", "P"),
     (MM, 3, (1,), 1, (8,), ()): ("P", "P"),
     (II, 3, (1,), 1, (8, 8), (0,)): ("P", "PX"),
+    (MM, 3, (1,), 1, (8, 8), (0,)): ("P", "PX"),
     (II, 3, (1,), 1, (8, 8), (2,)): ("PA", "PA"),
     (MM, 3, (1,), 1, (8, 8), (2,)): ("PA", "PA"),
     (II, 3, (1,), 2, (8,), ()): ("P", "P;R"),
@@ -1177,6 +1178,7 @@ class TiffImageFile(ImageFile.ImageFile):
         """Open the first image in a TIFF file"""
 
         # Header
+        assert self.fp is not None
         ifh = self.fp.read(8)
         if ifh[2] == 43:
             ifh += self.fp.read(8)
@@ -1343,6 +1345,7 @@ class TiffImageFile(ImageFile.ImageFile):
         # To be nice on memory footprint, if there's a
         # file descriptor, use that instead of reading
         # into a string in python.
+        assert self.fp is not None
         try:
             fp = hasattr(self.fp, "fileno") and self.fp.fileno()
             # flush the file descriptor, prevents error on pypy 2.4+
@@ -1936,9 +1939,10 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
                     types[tag] = TiffTags.LONG8
                 elif tag in ifd.tagtype:
                     types[tag] = ifd.tagtype[tag]
-                elif not (isinstance(value, (int, float, str, bytes))):
+                elif isinstance(value, (int, float, str, bytes)) or (
-                    continue
+                    isinstance(value, tuple)
-                else:
+                    and all(isinstance(v, (int, float, IFDRational)) for v in value)
+                ):
                     type = TiffTags.lookup(tag).type
                     if type:
                         types[tag] = type

src/PIL/TiffTags.py

@@ -203,6 +203,11 @@ _tags_v2: dict[int, tuple[str, int, int] | tuple[str, int, int, dict[str, int]]]
     531: ("YCbCrPositioning", SHORT, 1),
     532: ("ReferenceBlackWhite", RATIONAL, 6),
     700: ("XMP", BYTE, 0),
+    # Four private SGI tags
+    32995: ("Matteing", SHORT, 1),
+    32996: ("DataType", SHORT, 0),
+    32997: ("ImageDepth", LONG, 1),
+    32998: ("TileDepth", LONG, 1),
     33432: ("Copyright", ASCII, 1),
     33723: ("IptcNaaInfo", UNDEFINED, 1),
     34377: ("PhotoshopInfo", BYTE, 0),

src/PIL/WalImageFile.py

@@ -49,8 +49,7 @@ class WalImageFile(ImageFile.ImageFile):
 
         # strings are null-terminated
         self.info["name"] = header[:32].split(b"\0", 1)[0]
-        next_name = header[56 : 56 + 32].split(b"\0", 1)[0]
+        if next_name := header[56 : 56 + 32].split(b"\0", 1)[0]:
-        if next_name:
             self.info["next_name"] = next_name
 
     def load(self) -> Image.core.PixelAccess | None:

src/_imaging.c

@@ -2470,7 +2470,12 @@ _merge(PyObject *self, PyObject *args) {
         bands[3] = band3->image;
     }
 
-    return PyImagingNew(ImagingMerge(mode, bands));
+    Imaging imOut = ImagingMerge(mode, bands);
+    if (!imOut) {
+        return NULL;
+    }
+    ImagingCopyPalette(imOut, bands[0]);
+    return PyImagingNew(imOut);
 }
 
 static PyObject *

src/decode.c

@@ -906,8 +906,6 @@ PyImaging_Jpeg2KDecoderNew(PyObject *self, PyObject *args) {
 
     if (strcmp(format, "j2k") == 0) {
         codec_format = OPJ_CODEC_J2K;
-    } else if (strcmp(format, "jpt") == 0) {
-        codec_format = OPJ_CODEC_JPT;
     } else if (strcmp(format, "jp2") == 0) {
         codec_format = OPJ_CODEC_JP2;
     } else {

src/encode.c

@@ -955,6 +955,18 @@ PyImaging_LibTiffEncoderNew(PyObject *self, PyObject *args) {
                     );
                     free(av);
                 }
+            } else if (type == TIFF_RATIONAL) {
+                FLOAT32 *av;
+                /* malloc check ok, calloc checks for overflow */
+                av = calloc(len, sizeof(FLOAT32));
+                if (av) {
+                    for (i = 0; i < len; i++) {
+                        av[i] = (FLOAT32)PyFloat_AsDouble(PyTuple_GetItem(value, i));
+                    }
+                    status =
+                        ImagingLibTiffSetField(&encoder->state, (ttag_t)key_int, av);
+                    free(av);
+                }
             }
         } else {
             if (type == TIFF_SHORT) {

src/libImaging/Access.c

@@ -31,7 +31,7 @@ static void
 get_pixel_16L(Imaging im, int x, int y, void *color) {
     UINT8 *in = (UINT8 *)&im->image[y][x + x];
 #ifdef WORDS_BIGENDIAN
-    UINT16 out = in[0] + (in[1] << 8);
+    UINT16 out = in[0] + ((UINT16)in[1] << 8);
     memcpy(color, &out, sizeof(out));
 #else
     memcpy(color, in, sizeof(UINT16));
@@ -44,7 +44,7 @@ get_pixel_16B(Imaging im, int x, int y, void *color) {
 #ifdef WORDS_BIGENDIAN
     memcpy(color, in, sizeof(UINT16));
 #else
-    UINT16 out = in[1] + (in[0] << 8);
+    UINT16 out = in[1] + ((UINT16)in[0] << 8);
     memcpy(color, &out, sizeof(out));
 #endif
 }
@@ -54,28 +54,6 @@ get_pixel_32(Imaging im, int x, int y, void *color) {
     memcpy(color, &im->image32[y][x], sizeof(INT32));
 }
 
-static void
-get_pixel_32L(Imaging im, int x, int y, void *color) {
-    UINT8 *in = (UINT8 *)&im->image[y][x * 4];
-#ifdef WORDS_BIGENDIAN
-    INT32 out = in[0] + (in[1] << 8) + (in[2] << 16) + (in[3] << 24);
-    memcpy(color, &out, sizeof(out));
-#else
-    memcpy(color, in, sizeof(INT32));
-#endif
-}
-
-static void
-get_pixel_32B(Imaging im, int x, int y, void *color) {
-    UINT8 *in = (UINT8 *)&im->image[y][x * 4];
-#ifdef WORDS_BIGENDIAN
-    memcpy(color, in, sizeof(INT32));
-#else
-    INT32 out = in[3] + (in[2] << 8) + (in[1] << 16) + (in[0] << 24);
-    memcpy(color, &out, sizeof(out));
-#endif
-}
-
 /* store individual pixel */
 
 static void
@@ -96,21 +74,6 @@ put_pixel_16B(Imaging im, int x, int y, const void *color) {
     out[1] = in[0];
 }
 
-static void
-put_pixel_32L(Imaging im, int x, int y, const void *color) {
-    memcpy(&im->image8[y][x * 4], color, 4);
-}
-
-static void
-put_pixel_32B(Imaging im, int x, int y, const void *color) {
-    const char *in = color;
-    UINT8 *out = (UINT8 *)&im->image8[y][x * 4];
-    out[0] = in[3];
-    out[1] = in[2];
-    out[2] = in[1];
-    out[3] = in[0];
-}
-
 static void
 put_pixel_32(Imaging im, int x, int y, const void *color) {
     memcpy(&im->image32[y][x], color, sizeof(INT32));
@@ -130,8 +93,6 @@ static struct ImagingAccessInstance accessors[] = {
 #else
     {IMAGING_MODE_I_16N, get_pixel_16L, put_pixel_16L},
 #endif
-    {IMAGING_MODE_I_32L, get_pixel_32L, put_pixel_32L},
-    {IMAGING_MODE_I_32B, get_pixel_32B, put_pixel_32B},
     {IMAGING_MODE_F, get_pixel_32, put_pixel_32},
     {IMAGING_MODE_P, get_pixel_8, put_pixel_8},
     {IMAGING_MODE_PA, get_pixel_32_2bands, put_pixel_32},

src/libImaging/Arrow.c

@@ -55,6 +55,98 @@ ReleaseExportedSchema(struct ArrowSchema *array) {
     // Mark array released
     array->release = NULL;
 }
+char *
+image_band_json(Imaging im) {
+    char *format = "{\"bands\": [\"%s\", \"%s\", \"%s\", \"%s\"]}";
+    char *json;
+    // Bands can be 4 bands * 2 characters each
+    int len = strlen(format) + 8 + 1;
+    int err;
+
+    json = calloc(1, len);
+
+    if (!json) {
+        return NULL;
+    }
+
+    err = PyOS_snprintf(
+        json,
+        len,
+        format,
+        im->band_names[0],
+        im->band_names[1],
+        im->band_names[2],
+        im->band_names[3]
+    );
+    if (err < 0) {
+        return NULL;
+    }
+    return json;
+}
+
+char *
+single_band_json(Imaging im) {
+    char *format = "{\"bands\": [\"%s\"]}";
+    char *json;
+    // Bands can be 1 band * (maybe but probably not) 2 characters each
+    int len = strlen(format) + 2 + 1;
+    int err;
+
+    json = calloc(1, len);
+
+    if (!json) {
+        return NULL;
+    }
+
+    err = PyOS_snprintf(json, len, format, im->band_names[0]);
+    if (err < 0) {
+        return NULL;
+    }
+    return json;
+}
+
+char *
+assemble_metadata(const char *band_json) {
+    /* format is
+       int32: number of key/value pairs (noted N below)
+       int32: byte length of key 0
+       key 0 (not null-terminated)
+       int32: byte length of value 0
+       value 0 (not null-terminated)
+       ...
+       int32: byte length of key N - 1
+       key N - 1 (not null-terminated)
+       int32: byte length of value N - 1
+       value N - 1 (not null-terminated)
+    */
+    const char *key = "image";
+    INT32 key_len = strlen(key);
+    INT32 band_json_len = strlen(band_json);
+
+    char *buf;
+    INT32 *dest_int;
+    char *dest;
+
+    buf = calloc(1, key_len + band_json_len + 4 + 1 * 8);
+    if (!buf) {
+        return NULL;
+    }
+
+    dest_int = (void *)buf;
+
+    dest_int[0] = 1;
+    dest_int[1] = key_len;
+    dest_int += 2;
+    dest = (void *)dest_int;
+    memcpy(dest, key, key_len);
+    dest += key_len;
+    dest_int = (void *)dest;
+    dest_int[0] = band_json_len;
+    dest_int += 1;
+    memcpy(dest_int, band_json, band_json_len);
+
+    return buf;
+}
 
 int
 export_named_type(struct ArrowSchema *schema, char *format, char *name) {
@@ -95,6 +187,7 @@ export_named_type(struct ArrowSchema *schema, char *format, char *name) {
 int
 export_imaging_schema(Imaging im, struct ArrowSchema *schema) {
     int retval = 0;
+    char *band_json;
 
     if (strcmp(im->arrow_band_format, "") == 0) {
         return IMAGING_ARROW_INCOMPATIBLE_MODE;
@@ -106,7 +199,17 @@ export_imaging_schema(Imaging im, struct ArrowSchema *schema) {
     }
 
     if (im->bands == 1) {
-        return export_named_type(schema, im->arrow_band_format, im->band_names[0]);
+        retval = export_named_type(schema, im->arrow_band_format, im->band_names[0]);
+        if (retval != 0) {
+            return retval;
+        }
+        // band related metadata
+        band_json = single_band_json(im);
+        if (band_json) {
+            schema->metadata = assemble_metadata(band_json);
+            free(band_json);
+        }
+        return retval;
     }
 
     retval = export_named_type(schema, "+w:4", "");
@@ -117,13 +220,26 @@ export_imaging_schema(Imaging im, struct ArrowSchema *schema) {
     schema->n_children = 1;
     schema->children = calloc(1, sizeof(struct ArrowSchema *));
     schema->children[0] = (struct ArrowSchema *)calloc(1, sizeof(struct ArrowSchema));
-    retval = export_named_type(schema->children[0], im->arrow_band_format, "pixel");
+    retval = export_named_type(
+        schema->children[0], im->arrow_band_format, getModeData(im->mode)->name
+    );
     if (retval != 0) {
         free(schema->children[0]);
         free(schema->children);
         schema->release(schema);
         return retval;
     }
+
+    // band related metadata
+    band_json = image_band_json(im);
+    if (band_json) {
+        // adding the metadata to the child array.
+        // Accessible in pyarrow via pa.array(img).type.field(0).metadata
+        // adding it to the top level is not accessible.
+        schema->children[0]->metadata = assemble_metadata(band_json);
+        free(band_json);
+    }
+
     return 0;
 }
 

src/libImaging/BcnEncode.c

@@ -36,10 +36,9 @@ decode_565(UINT16 x) {
 
 static UINT16
 encode_565(rgba item) {
-    UINT8 r, g, b;
+    UINT16 r = item.color[0] >> (8 - 5);
-    r = item.color[0] >> (8 - 5);
+    UINT8 g = item.color[1] >> (8 - 6);
-    g = item.color[1] >> (8 - 6);
+    UINT8 b = item.color[2] >> (8 - 5);
-    b = item.color[2] >> (8 - 5);
     return (r << (5 + 6)) | (g << 5) | b;
 }
 
@@ -157,7 +156,8 @@ encode_bc1_color(Imaging im, ImagingCodecState state, UINT8 *dst, int separate_a
 static void
 encode_bc2_block(Imaging im, ImagingCodecState state, UINT8 *dst) {
     int i, j;
-    UINT8 block[16], current_alpha;
+    UINT8 block[16];
+    UINT32 current_alpha;
     for (i = 0; i < 4; i++) {
         for (j = 0; j < 4; j++) {
             int x = state->x + i * im->pixelsize;

src/libImaging/FliDecode.c

@@ -16,9 +16,11 @@
 
 #include "Imaging.h"
 
-#define I16(ptr) ((ptr)[0] + ((ptr)[1] << 8))
+#define I16(ptr) ((ptr)[0] + ((int)(ptr)[1] << 8))
 
-#define I32(ptr) ((ptr)[0] + ((ptr)[1] << 8) + ((ptr)[2] << 16) + ((ptr)[3] << 24))
+#define I32(ptr)                                                   \
+    ((ptr)[0] + ((INT32)(ptr)[1] << 8) + ((INT32)(ptr)[2] << 16) + \
+     ((INT32)(ptr)[3] << 24))
 
 #define ERR_IF_DATA_OOB(offset)                 \
     if ((data + (offset)) > ptr + bytes) {      \

src/libImaging/GetBBox.c

@@ -212,7 +212,7 @@ ImagingGetExtrema(Imaging im, void *extrema) {
                 UINT16 v;
                 UINT8 *pixel = *im->image8;
 #ifdef WORDS_BIGENDIAN
-                v = pixel[0] + (pixel[1] << 8);
+                v = pixel[0] + ((UINT16)pixel[1] << 8);
 #else
                 memcpy(&v, pixel, sizeof(v));
 #endif
@@ -221,7 +221,7 @@ ImagingGetExtrema(Imaging im, void *extrema) {
                     for (x = 0; x < im->xsize; x++) {
                         pixel = (UINT8 *)im->image[y] + x * sizeof(v);
 #ifdef WORDS_BIGENDIAN
-                        v = pixel[0] + (pixel[1] << 8);
+                        v = pixel[0] + ((UINT16)pixel[1] << 8);
 #else
                         memcpy(&v, pixel, sizeof(v));
 #endif

src/libImaging/Imaging.h

@@ -145,7 +145,7 @@ struct ImagingAccessInstance {
 struct ImagingHistogramInstance {
     /* Format */
     ModeID mode; /* Mode ID of corresponding source image */
-    int bands;   /* Number of bands (1, 3, or 4) */
+    int bands;   /* Number of bands (1, 2, 3, or 4) */
 
     /* Data */
     long *histogram; /* Histogram (bands*256 longs) */

src/libImaging/Mode.c

@@ -9,18 +9,18 @@
 const ModeData MODES[] = {
     [IMAGING_MODE_UNKNOWN] = {""},
 
-    [IMAGING_MODE_1] = {"1"},           [IMAGING_MODE_CMYK] = {"CMYK"},
+    [IMAGING_MODE_1] = {"1"},         [IMAGING_MODE_CMYK] = {"CMYK"},
-    [IMAGING_MODE_F] = {"F"},           [IMAGING_MODE_HSV] = {"HSV"},
+    [IMAGING_MODE_F] = {"F"},         [IMAGING_MODE_HSV] = {"HSV"},
-    [IMAGING_MODE_I] = {"I"},           [IMAGING_MODE_L] = {"L"},
+    [IMAGING_MODE_I] = {"I"},         [IMAGING_MODE_L] = {"L"},
-    [IMAGING_MODE_LA] = {"LA"},         [IMAGING_MODE_LAB] = {"LAB"},
+    [IMAGING_MODE_LA] = {"LA"},       [IMAGING_MODE_LAB] = {"LAB"},
-    [IMAGING_MODE_La] = {"La"},         [IMAGING_MODE_P] = {"P"},
+    [IMAGING_MODE_La] = {"La"},       [IMAGING_MODE_P] = {"P"},
-    [IMAGING_MODE_PA] = {"PA"},         [IMAGING_MODE_RGB] = {"RGB"},
+    [IMAGING_MODE_PA] = {"PA"},       [IMAGING_MODE_RGB] = {"RGB"},
-    [IMAGING_MODE_RGBA] = {"RGBA"},     [IMAGING_MODE_RGBX] = {"RGBX"},
+    [IMAGING_MODE_RGBA] = {"RGBA"},   [IMAGING_MODE_RGBX] = {"RGBX"},
-    [IMAGING_MODE_RGBa] = {"RGBa"},     [IMAGING_MODE_YCbCr] = {"YCbCr"},
+    [IMAGING_MODE_RGBa] = {"RGBa"},   [IMAGING_MODE_YCbCr] = {"YCbCr"},
 
-    [IMAGING_MODE_I_16] = {"I;16"},     [IMAGING_MODE_I_16L] = {"I;16L"},
+    [IMAGING_MODE_I_16] = {"I;16"},   [IMAGING_MODE_I_16L] = {"I;16L"},
-    [IMAGING_MODE_I_16B] = {"I;16B"},   [IMAGING_MODE_I_16N] = {"I;16N"},
+    [IMAGING_MODE_I_16B] = {"I;16B"}, [IMAGING_MODE_I_16N] = {"I;16N"},
-    [IMAGING_MODE_I_32L] = {"I;32L"},   [IMAGING_MODE_I_32B] = {"I;32B"},
+    [IMAGING_MODE_I_32L] = {"I;32L"}, [IMAGING_MODE_I_32B] = {"I;32B"},
 };
 
 const ModeID

src/libImaging/Palette.c

@@ -147,7 +147,7 @@ ImagingPaletteDelete(ImagingPalette palette) {
 
 #define BOX 8
 
-#define BOXVOLUME BOX *BOX *BOX
+#define BOXVOLUME BOX * BOX * BOX
 
 void
 ImagingPaletteCacheUpdate(ImagingPalette palette, int r, int g, int b) {

src/libImaging/Paste.c

@@ -23,6 +23,18 @@
 
 #include "Imaging.h"
 
+#define PREPARE_PASTE_LOOP()        \
+    int y, y_end, offset;           \
+    if (imOut == imIn && dy > sy) { \
+        y = ysize - 1;              \
+        y_end = -1;                 \
+        offset = -1;                \
+    } else {                        \
+        y = 0;                      \
+        y_end = ysize;              \
+        offset = 1;                 \
+    }
+
 static inline void
 paste(
     Imaging imOut,
@@ -37,14 +49,13 @@ paste(
 ) {
     /* paste opaque region */
 
-    int y;
-
     dx *= pixelsize;
     sx *= pixelsize;
 
     xsize *= pixelsize;
 
-    for (y = 0; y < ysize; y++) {
+    PREPARE_PASTE_LOOP();
+    for (; y != y_end; y += offset) {
         memcpy(imOut->image[y + dy] + dx, imIn->image[y + sy] + sx, xsize);
     }
 }
@@ -64,12 +75,13 @@ paste_mask_1(
 ) {
     /* paste with mode "1" mask */
 
-    int x, y;
+    int x;
 
+    PREPARE_PASTE_LOOP();
     if (imOut->image8) {
         int in_i16 = isModeI16(imIn->mode);
         int out_i16 = isModeI16(imOut->mode);
-        for (y = 0; y < ysize; y++) {
+        for (; y != y_end; y += offset) {
             UINT8 *out = imOut->image8[y + dy] + dx;
             if (out_i16) {
                 out += dx;
@@ -97,7 +109,7 @@ paste_mask_1(
         }
 
     } else {
-        for (y = 0; y < ysize; y++) {
+        for (; y != y_end; y += offset) {
             INT32 *out = imOut->image32[y + dy] + dx;
             INT32 *in = imIn->image32[y + sy] + sx;
             UINT8 *mask = imMask->image8[y + sy] + sx;
@@ -126,11 +138,12 @@ paste_mask_L(
 ) {
     /* paste with mode "L" matte */
 
-    int x, y;
+    int x;
     unsigned int tmp1;
 
+    PREPARE_PASTE_LOOP();
     if (imOut->image8) {
-        for (y = 0; y < ysize; y++) {
+        for (; y != y_end; y += offset) {
             UINT8 *out = imOut->image8[y + dy] + dx;
             UINT8 *in = imIn->image8[y + sy] + sx;
             UINT8 *mask = imMask->image8[y + sy] + sx;
@@ -141,7 +154,7 @@ paste_mask_L(
         }
 
     } else {
-        for (y = 0; y < ysize; y++) {
+        for (; y != y_end; y += offset) {
             UINT8 *out = (UINT8 *)(imOut->image32[y + dy] + dx);
             UINT8 *in = (UINT8 *)(imIn->image32[y + sy] + sx);
             UINT8 *mask = (UINT8 *)(imMask->image8[y + sy] + sx);
@@ -174,11 +187,12 @@ paste_mask_RGBA(
 ) {
     /* paste with mode "RGBA" matte */
 
-    int x, y;
+    int x;
     unsigned int tmp1;
 
+    PREPARE_PASTE_LOOP();
     if (imOut->image8) {
-        for (y = 0; y < ysize; y++) {
+        for (; y != y_end; y += offset) {
             UINT8 *out = imOut->image8[y + dy] + dx;
             UINT8 *in = imIn->image8[y + sy] + sx;
             UINT8 *mask = (UINT8 *)imMask->image[y + sy] + sx * 4 + 3;
@@ -189,7 +203,7 @@ paste_mask_RGBA(
         }
 
     } else {
-        for (y = 0; y < ysize; y++) {
+        for (; y != y_end; y += offset) {
             UINT8 *out = (UINT8 *)(imOut->image32[y + dy] + dx);
             UINT8 *in = (UINT8 *)(imIn->image32[y + sy] + sx);
             UINT8 *mask = (UINT8 *)(imMask->image32[y + sy] + sx);
@@ -222,11 +236,12 @@ paste_mask_RGBa(
 ) {
     /* paste with mode "RGBa" matte */
 
-    int x, y;
+    int x;
     unsigned int tmp1;
 
+    PREPARE_PASTE_LOOP();
     if (imOut->image8) {
-        for (y = 0; y < ysize; y++) {
+        for (; y != y_end; y += offset) {
             UINT8 *out = imOut->image8[y + dy] + dx;
             UINT8 *in = imIn->image8[y + sy] + sx;
             UINT8 *mask = (UINT8 *)imMask->image[y + sy] + sx * 4 + 3;
@@ -237,7 +252,7 @@ paste_mask_RGBa(
         }
 
     } else {
-        for (y = 0; y < ysize; y++) {
+        for (; y != y_end; y += offset) {
             UINT8 *out = (UINT8 *)(imOut->image32[y + dy] + dx);
             UINT8 *in = (UINT8 *)(imIn->image32[y + sy] + sx);
             UINT8 *mask = (UINT8 *)(imMask->image32[y + sy] + sx);