Apply black formatting to modified files

Co-authored-by: thewtex <[email protected]>

Author: Copilot

Wrapping/Generators/Python/Tests/CMakeLists.txt

@@ -201,6 +201,11 @@ if(ITK_WRAP_unsigned_char AND WRAP_2)
       COMMAND
       ${CMAKE_CURRENT_SOURCE_DIR}/test_xarray.py
       DATA{${WrapITK_SOURCE_DIR}/images/cthead1.png})
+    itk_python_add_test(
+      NAME
+      PythonImreadSingleFileListTest
+      COMMAND
+      ${CMAKE_CURRENT_SOURCE_DIR}/test_imread_single_file_list.py)
   endif()
 endif()
 

Wrapping/Generators/Python/Tests/test_imread_single_file_list.py

@@ -34,20 +34,20 @@ def test_imread_single_element_list():
     """Test that imread works with a list containing a single file path."""
     # Create a temporary image file
     temp_dir = tempfile.mkdtemp()
-    filename = os.path.join(temp_dir, 'test_image.png')
-    
+    filename = os.path.join(temp_dir, "test_image.png")
+
     try:
         # Create and save a test image
         arr = np.random.randint(0, 256, (10, 10), dtype=np.uint8)
         image = itk.image_from_array(arr)
         itk.imwrite(image, filename)
-        
+
         # Test 1: imread with a string (baseline - should always work)
         img_from_string = itk.imread(filename)
         assert img_from_string is not None
         assert itk.size(img_from_string)[0] == 10
         assert itk.size(img_from_string)[1] == 10
-        
+
         # Test 2: imread with a single-element list (the bug case)
         img_from_list = itk.imread([filename])
         assert img_from_list is not None
@@ -56,9 +56,9 @@ def test_imread_single_element_list():
         assert itk.size(img_from_list)[0] == 10
         assert itk.size(img_from_list)[1] == 10
         assert itk.size(img_from_list)[2] == 1
-        
+
         print("✓ Test passed: imread works with single-element list")
-        
+
     finally:
         # Cleanup
         if os.path.exists(filename):
@@ -71,16 +71,16 @@ def test_imread_multi_element_list():
     """Test that imread still works with a list containing multiple file paths."""
     # Create temporary image files
     temp_dir = tempfile.mkdtemp()
-    filename1 = os.path.join(temp_dir, 'test_image1.png')
-    filename2 = os.path.join(temp_dir, 'test_image2.png')
-    
+    filename1 = os.path.join(temp_dir, "test_image1.png")
+    filename2 = os.path.join(temp_dir, "test_image2.png")
+
     try:
         # Create and save test images
         arr = np.random.randint(0, 256, (10, 10), dtype=np.uint8)
         image = itk.image_from_array(arr)
         itk.imwrite(image, filename1)
         itk.imwrite(image, filename2)
-        
+
         # Test: imread with a multi-element list (should work as before)
         img_from_list = itk.imread([filename1, filename2])
         assert img_from_list is not None
@@ -89,9 +89,9 @@ def test_imread_multi_element_list():
         assert itk.size(img_from_list)[0] == 10
         assert itk.size(img_from_list)[1] == 10
         assert itk.size(img_from_list)[2] == 2
-        
+
         print("✓ Test passed: imread works with multi-element list")
-        
+
     finally:
         # Cleanup
         if os.path.exists(filename1):

Wrapping/Generators/Python/itk/support/extras.py

@@ -361,8 +361,13 @@ def GetArrayViewFromImage(
 array_view_from_image = GetArrayViewFromImage
 
 
-def _GetImageFromArray(arr: ArrayLike, function_name: str, is_vector: bool,
-        ttype, need_contiguous:bool = True):
+def _GetImageFromArray(
+    arr: ArrayLike,
+    function_name: str,
+    is_vector: bool,
+    ttype,
+    need_contiguous: bool = True,
+):
     """Get an ITK image from a Python array."""
     import itk
 
@@ -419,7 +424,6 @@ def _GetImageFromArray(arr: ArrayLike, function_name: str, is_vector: bool,
         return templatedFunction(arr, is_vector)
 
 
-
 def GetImageFromArray(
     arr: ArrayLike, is_vector: bool = False, ttype=None
 ) -> "itkt.ImageBase":
@@ -471,8 +475,9 @@ def GetImageViewFromArray(
     array, since a copy is performed and care must be taken to keep a reference
     to the copied array. This warning can be suppressed with need_contiguous=False
     """
-    return _GetImageFromArray(arr, "GetImageViewFromArray", is_vector, ttype,
-            need_contiguous=need_contiguous)
+    return _GetImageFromArray(
+        arr, "GetImageViewFromArray", is_vector, ttype, need_contiguous=need_contiguous
+    )
 
 
 image_view_from_array = GetImageViewFromArray
@@ -752,7 +757,7 @@ def image_from_vtk_image(vtk_image: "vtk.vtkImageData") -> "itkt.ImageBase":
         dims = dims[:-1]  # 2D, not 3D
     dims.reverse()
     if is_vector:
-      dims.append(number_of_components)
+        dims.append(number_of_components)
     array.shape = tuple(dims)
     l_image = itk.image_view_from_array(array, is_vector)
 
@@ -790,7 +795,10 @@ def dict_from_image(image: "itkt.Image") -> Dict:
     pixel_arr = itk.array_from_image(image)
     imageType = wasm_type_from_image_type(image)
     buffered_region = image.GetBufferedRegion()
-    bufferedRegion = { "index": tuple(buffered_region.GetIndex()), "size": tuple(buffered_region.GetSize())}
+    bufferedRegion = {
+        "index": tuple(buffered_region.GetIndex()),
+        "size": tuple(buffered_region.GetSize()),
+    }
     return dict(
         imageType=imageType,
         name=image.GetObjectName(),
@@ -959,9 +967,7 @@ def dict_from_pointset(pointset: "itkt.PointSet") -> Dict:
     if number_of_points == 0:
         points_array = np.array([], np.float32)
     else:
-        points_array = itk.array_from_vector_container(
-            pointset.GetPoints()
-        ).flatten()
+        points_array = itk.array_from_vector_container(pointset.GetPoints()).flatten()
 
     point_data = pointset.GetPointData()
     if point_data.Size() == 0:
@@ -993,6 +999,7 @@ def dict_from_pointset(pointset: "itkt.PointSet") -> Dict:
         pointData=point_data_numpy,
     )
 
+
 def polyline_from_dict(polyline_dict: Dict) -> "itkt.PolylineParametricPath":
     """Deserialize an dictionary representing an itk.PolylineParametricPath object."""
     import itk
@@ -1006,6 +1013,7 @@ def polyline_from_dict(polyline_dict: Dict) -> "itkt.PolylineParametricPath":
 
     return polyline
 
+
 def dict_from_polyline(polyline: "itkt.PolylineParametricPath") -> Dict:
     """Serialize a Python itk.PolylineParametricPath object to a pickable Python dictionary."""
     import itk
@@ -1017,22 +1025,28 @@ def dict_from_polyline(polyline: "itkt.PolylineParametricPath") -> Dict:
         vertexList=vertex_list_array,
     )
 
-def dict_from_transform(transform: Union["itkt.TransformBase", List["itkt.TransformBase"]]) -> Union[List[Dict], Dict]:
+
+def dict_from_transform(
+    transform: Union["itkt.TransformBase", List["itkt.TransformBase"]],
+) -> Union[List[Dict], Dict]:
     """Serialize a Python itk.Transform object to a pickable Python dictionary.
 
     If the transform is a list of transforms, then a list of dictionaries is returned.
     If the transform is a single, non-Composite transform, then a single dictionary is returned.
     Composite transforms and nested composite transforms are flattened into a list of dictionaries.
     """
     import itk
+
     datatype_dict = {"double": itk.D, "float": itk.F}
 
     def update_transform_dict(current_transform):
         current_transform_type = current_transform.GetTransformTypeAsString()
         current_transform_type_split = current_transform_type.split("_")
 
         transform_type = dict()
-        transform_parameterization = current_transform_type_split[0].replace("Transform", "")
+        transform_parameterization = current_transform_type_split[0].replace(
+            "Transform", ""
+        )
         transform_type["transformParameterization"] = transform_parameterization
 
         transform_type["parametersValueType"] = python_to_js(
@@ -1042,7 +1056,7 @@ def update_transform_dict(current_transform):
         transform_type["outputDimension"] = int(current_transform_type_split[3])
 
         transform_dict = dict()
-        transform_dict['transformType'] = transform_type
+        transform_dict["transformType"] = transform_type
         transform_dict["name"] = current_transform.GetObjectName()
 
         transform_dict["inputSpaceName"] = current_transform.GetInputSpaceName()
@@ -1064,6 +1078,7 @@ def update_transform_dict(current_transform):
 
     dict_array = []
     multi = False
+
     def add_transform_dict(transform):
         transform_type = transform.GetTransformTypeAsString()
         if "CompositeTransform" in transform_type:
@@ -1076,6 +1091,7 @@ def add_transform_dict(transform):
         else:
             dict_array.append(update_transform_dict(transform))
             return False
+
     if isinstance(transform, list):
         multi = True
         for t in transform:
@@ -1088,13 +1104,19 @@ def add_transform_dict(transform):
     else:
         return dict_array[0]
 
-def transform_from_dict(transform_dict: Union[Dict, List[Dict]]) -> "itkt.TransformBase":
+
+def transform_from_dict(
+    transform_dict: Union[Dict, List[Dict]],
+) -> "itkt.TransformBase":
     """Deserialize a dictionary representing an itk.Transform object.
 
-    If the dictionary represents a list of transforms, then a Composite Transform is returned."""
+    If the dictionary represents a list of transforms, then a Composite Transform is returned.
+    """
     import itk
 
-    def set_parameters(transform, transform_parameters, transform_fixed_parameters, data_type):
+    def set_parameters(
+        transform, transform_parameters, transform_fixed_parameters, data_type
+    ):
         # First set fixed parameters then parameters
         o1 = itk.OptimizerParameters[data_type](list(transform_fixed_parameters))
         transform.SetFixedParameters(o1)
@@ -1124,7 +1146,9 @@ def special_transform_check(transform_name):
         transform_type = transform_dict[i]["transformType"]
         data_type = parametersValueType_dict[transform_type["parametersValueType"]]
 
-        transform_parameterization = transform_type["transformParameterization"] + 'Transform'
+        transform_parameterization = (
+            transform_type["transformParameterization"] + "Transform"
+        )
 
         # No template parameter needed for transforms having 2D or 3D name
         # Also for some selected transforms
@@ -1145,7 +1169,9 @@ def special_transform_check(transform_name):
             transform_template = getattr(itk, transform_parameterization)
             if len(transform_template.items()[0][0]) > 2:
                 transform = transform_template[
-                    data_type, transform_type["inputDimension"], transform_type["outputDimension"]
+                    data_type,
+                    transform_type["inputDimension"],
+                    transform_type["outputDimension"],
                 ].New()
             else:
                 transform = transform_template[
@@ -1160,16 +1186,20 @@ def special_transform_check(transform_name):
             transform,
             transform_dict[i]["parameters"],
             transform_dict[i]["fixedParameters"],
-            data_type
+            data_type,
         )
         transforms_list.append(transform)
 
     # If array has length more than 1 then it's a composite transform
     if len(transforms_list) > 1:
         # Create a Composite Transform object
         # and add all the transforms in it.
-        data_type = parametersValueType_dict[transform_dict[0]["transformType"]["parametersValueType"]]
-        transform = itk.CompositeTransform[data_type, transforms_list[0]["transformType"]['inputDimension']].New()
+        data_type = parametersValueType_dict[
+            transform_dict[0]["transformType"]["parametersValueType"]
+        ]
+        transform = itk.CompositeTransform[
+            data_type, transforms_list[0]["transformType"]["inputDimension"]
+        ].New()
         for current_transform in transforms_list:
             transform.AddTransform(current_transform)
     else:
@@ -1550,8 +1580,6 @@ def search(s: str, case_sensitive: bool = False) -> List[str]:  # , fuzzy=True):
     return res
 
 
-
-
 def set_inputs(
     new_itk_object,
     inargs: Optional[Sequence[Any]] = None,
@@ -1667,7 +1695,6 @@ def SetInputs(self, *args, **kargs):
 
 
 class templated_class:
-
     """This class is used to mimic the behavior of the templated C++ classes.
 
     It is used this way:
@@ -1760,7 +1787,6 @@ def add_image_templates(self, *args) -> None:
                 self.add_template(name, tuple(parameters))
 
     class __templated_class_and_parameters__:
-
         """Inner class used to store the pair class-template parameters ready
         to instantiate.
         """
@@ -1818,7 +1844,6 @@ def __len__(self):
 
 
 class pipeline:
-
     """A convenient class to store the reference to the filters of a pipeline
 
     With this class, a method can create a pipeline of several filters and
@@ -2317,7 +2342,8 @@ def tuple_to_string_type(t):
         python_input_type = tuple_to_string_type(input_type)
         type_list = "\n".join([python_type(x[0]) for x in template_type.keys()])
         eg_type = ", ".join([python_type(x) for x in list(template_type.keys())[0]])
-        msg: str = """{template_type} is not wrapped for input type `{input_type}`.
+        msg: str = (
+            """{template_type} is not wrapped for input type `{input_type}`.
 
 To limit the size of the package, only a limited number of
 types are available in ITK Python. To print the supported
@@ -2346,11 +2372,12 @@ def tuple_to_string_type(t):
 
 {type_list}
 """.format(
-            template_type=python_template_type,
-            input_type=python_input_type,
-            type_list=type_list,
-            eg_type=eg_type,
-            extra_eg=extra_eg,
+                template_type=python_template_type,
+                input_type=python_input_type,
+                type_list=type_list,
+                eg_type=eg_type,
+                extra_eg=extra_eg,
+            )
         )
         TypeError.__init__(self, msg)