[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Tests/test_arrow.py

@@ -1,19 +1,20 @@
 from __future__ import annotations
 
-import warnings
+from typing import Any  # undone
 
 import pytest
 
 from PIL import Image
 
-from .helper import assert_deep_equal, assert_image, hopper, skip_unless_feature, assert_image_equal
-
-from typing import Any # undone
+from .helper import (
+    assert_deep_equal,
+    assert_image_equal,
+    hopper,
+)
 
 pyarrow = pytest.importorskip("pyarrow", reason="PyArrow not installed")
 
 TEST_IMAGE_SIZE = (10, 10)
-from numbers import Number
 
 
 def _test_img_equals_pyarray(img: Image.Image, arr: Any, mask) -> None:
@@ -24,36 +25,33 @@ def _test_img_equals_pyarray(img: Image.Image, arr: Any, mask) -> None:
         for y in range(0, img.size[1], int(img.size[1] / 10)):
             if mask:
                 for ix, elt in enumerate(mask):
-                    assert px[x,y][ix] == arr[y * img.width + x].as_py()[elt]
+                    assert px[x, y][ix] == arr[y * img.width + x].as_py()[elt]
             else:
                 assert_deep_equal(px[x, y], arr[y * img.width + x].as_py())
 
 
 # really hard to get a non-nullable list type
-fl_uint8_4_type = pyarrow.field("_",
-                           pyarrow.list_(
-                               pyarrow.field("_",
-                                        pyarrow.uint8()
-                                        ).with_nullable(False)
-                               ,4)
-                           ).type
+fl_uint8_4_type = pyarrow.field(
+    "_", pyarrow.list_(pyarrow.field("_", pyarrow.uint8()).with_nullable(False), 4)
+).type
+
 
 @pytest.mark.parametrize(
     "mode, dtype, mask",
     (
         ("L", pyarrow.uint8(), None),
         ("I", pyarrow.int32(), None),
         ("F", pyarrow.float32(), None),
-        ("LA", fl_uint8_4_type, [0,3]),
-        ("RGB", fl_uint8_4_type, [0,1,2]),
+        ("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]),
+        ("YCbCr", fl_uint8_4_type, [0, 1, 2]),
+        ("HSV", fl_uint8_4_type, [0, 1, 2]),
     ),
 )
-def test_to_array(mode: str, dtype: Any, mask: Any ) -> None:
+def test_to_array(mode: str, dtype: Any, mask: Any) -> None:
     img = hopper(mode)
 
     # Resize to non-square
@@ -70,39 +68,40 @@ def test_to_array(mode: str, dtype: Any, mask: Any ) -> None:
 
     assert_image_equal(img, reloaded)
 
+
 def test_lifetime():
     # valgrind shouldn't error out here.
     # arrays should be accessible after the image is deleted.
 
-    img = hopper('L')
+    img = hopper("L")
 
     arr_1 = pyarrow.array(img)
     arr_2 = pyarrow.array(img)
 
-    del(img)
+    del img
 
     assert arr_1.sum().as_py() > 0
-    del(arr_1)
+    del arr_1
 
     assert arr_2.sum().as_py() > 0
-    del(arr_2)
+    del arr_2
+
 
 def test_lifetime2():
     # valgrind shouldn't error out here.
     # img should remain after the arrays are collected.
 
-    img = hopper('L')
+    img = hopper("L")
 
     arr_1 = pyarrow.array(img)
     arr_2 = pyarrow.array(img)
 
-
     assert arr_1.sum().as_py() > 0
-    del(arr_1)
+    del arr_1
 
     assert arr_2.sum().as_py() > 0
-    del(arr_2)
+    del arr_2
 
     img2 = img.copy()
     px = img2.load()
-    assert isinstance(px[0,0], int)
+    assert isinstance(px[0, 0], int)

pyproject.toml

@@ -61,12 +61,12 @@ optional-dependencies.tests = [
   "markdown2",
   "olefile",
   "packaging",
+  "pyarrow",
   "pyroma",
   "pytest",
   "pytest-cov",
   "pytest-timeout",
   "trove-classifiers>=2024.10.12",
-  "pyarrow",
 ]
 optional-dependencies.typing = [
   "typing-extensions; python_version<'3.10'",

src/PIL/Image.py

@@ -748,12 +748,13 @@ def __array_interface__(self) -> dict[str, str | bytes | int | tuple[int, ...]]:
         new["shape"], new["typestr"] = _conv_type_shape(self)
         return new
 
-
     def __arrow_c_schema__(self) -> object:
         self.load()
         return self.im.__arrow_c_schema__()
 
-    def __arrow_c_array__(self, requested_schema: object | None = None) -> Tuple[object, object]:
+    def __arrow_c_array__(
+        self, requested_schema: object | None = None
+    ) -> Tuple[object, object]:
         self.load()
         return (self.im.__arrow_c_schema__(), self.im.__arrow_c_array__())
 
@@ -3258,12 +3259,15 @@ class SupportsArrayInterface(Protocol):
     def __array_interface__(self) -> dict[str, Any]:
         raise NotImplementedError()
 
+
 class SupportsArrowArrayInterface(Protocol):
     """
     An object that has an ``__arrow_c_array__`` method corresponding to the arrow c data interface.
     """
 
-    def __arrow_c_array__(self, requested_schema:"PyCapsule"=None) -> tuple["PyCapsule", "PyCapsule"]:
+    def __arrow_c_array__(
+        self, requested_schema: PyCapsule = None
+    ) -> tuple[PyCapsule, PyCapsule]:
         raise NotImplementedError()
 
 
@@ -3356,12 +3360,12 @@ def fromarray(obj: SupportsArrayInterface, mode: str | None = None) -> Image:
 
 
 def fromarrow(obj: SupportsArrowArrayIngerface, mode, size) -> ImageFile.ImageFile:
-    if not hasattr(obj, '__arrow_c_array__'):
+    if not hasattr(obj, "__arrow_c_array__"):
         raise ValueError("arrow_c_array interface not found")
 
     (schema_capsule, array_capsule) = obj.__arrow_c_array__()
     _im = core.new_arrow(mode, size, schema_capsule, array_capsule)
-    if (_im):
+    if _im:
         return Image()._new(_im)
 
     return None

src/_imaging.c

@@ -227,71 +227,73 @@ PyImaging_GetBuffer(PyObject *buffer, Py_buffer *view) {
 /* Arrow HANDLING                                                       */
 /* -------------------------------------------------------------------- */
 
-void ReleaseArrowSchemaPyCapsule(PyObject* capsule) {
-    struct ArrowSchema* schema =
-        (struct ArrowSchema*)PyCapsule_GetPointer(capsule, "arrow_schema");
+void
+ReleaseArrowSchemaPyCapsule(PyObject *capsule) {
+    struct ArrowSchema *schema =
+        (struct ArrowSchema *)PyCapsule_GetPointer(capsule, "arrow_schema");
     if (schema->release != NULL) {
         schema->release(schema);
     }
     free(schema);
 }
 
-PyObject* ExportArrowSchemaPyCapsule(ImagingObject *self) {
-    struct ArrowSchema* schema =
-      (struct ArrowSchema*)calloc(1, sizeof(struct ArrowSchema));
+PyObject *
+ExportArrowSchemaPyCapsule(ImagingObject *self) {
+    struct ArrowSchema *schema =
+        (struct ArrowSchema *)calloc(1, sizeof(struct ArrowSchema));
     export_imaging_schema(self->image, schema);
     return PyCapsule_New(schema, "arrow_schema", ReleaseArrowSchemaPyCapsule);
 }
 
-void ReleaseArrowArrayPyCapsule(PyObject* capsule) {
-    struct ArrowArray* array =
-        (struct ArrowArray*)PyCapsule_GetPointer(capsule, "arrow_array");
+void
+ReleaseArrowArrayPyCapsule(PyObject *capsule) {
+    struct ArrowArray *array =
+        (struct ArrowArray *)PyCapsule_GetPointer(capsule, "arrow_array");
     if (array->release != NULL) {
         array->release(array);
     }
     free(array);
 }
 
-PyObject* ExportArrowArrayPyCapsule(ImagingObject *self) {
-    struct ArrowArray* array =
-      (struct ArrowArray*)calloc(1, sizeof(struct ArrowArray));
+PyObject *
+ExportArrowArrayPyCapsule(ImagingObject *self) {
+    struct ArrowArray *array =
+        (struct ArrowArray *)calloc(1, sizeof(struct ArrowArray));
     export_imaging_array(self->image, array);
     return PyCapsule_New(array, "arrow_array", ReleaseArrowArrayPyCapsule);
 }
 
-
 static PyObject *
 _new_arrow(PyObject *self, PyObject *args) {
     char *mode;
     int xsize, ysize;
     PyObject *schema_capsule, *array_capsule;
     PyObject *ret;
 
-    if (!PyArg_ParseTuple(args, "s(ii)OO", &mode, &xsize, &ysize,
-                          &schema_capsule, &array_capsule)) {
+    if (!PyArg_ParseTuple(
+            args, "s(ii)OO", &mode, &xsize, &ysize, &schema_capsule, &array_capsule
+        )) {
         return NULL;
     }
 
-    struct ArrowSchema* schema =
-      (struct ArrowSchema*)PyCapsule_GetPointer(schema_capsule, "arrow_schema");
+    struct ArrowSchema *schema =
+        (struct ArrowSchema *)PyCapsule_GetPointer(schema_capsule, "arrow_schema");
 
-    struct ArrowArray* array =
-      (struct ArrowArray*)PyCapsule_GetPointer(array_capsule, "arrow_array");
+    struct ArrowArray *array =
+        (struct ArrowArray *)PyCapsule_GetPointer(array_capsule, "arrow_array");
 
     ret = PyImagingNew(ImagingNewArrow(mode, xsize, ysize, schema, array));
-    if (schema->release){
-      schema->release(schema);
-      schema->release = NULL;
+    if (schema->release) {
+        schema->release(schema);
+        schema->release = NULL;
     }
     if (!ret && array->release) {
-      array->release(array);
-      array->release = NULL;
+        array->release(array);
+        array->release = NULL;
     }
     return ret;
 }
 
-
-
 /* -------------------------------------------------------------------- */
 /* EXCEPTION REROUTING                                                  */
 /* -------------------------------------------------------------------- */