black

Author: Jammy2211

autoarray/fixtures.py

@@ -110,7 +110,6 @@ def make_blurring_grid_2d_7x7():
     return aa.Grid2D.from_mask(mask=make_blurring_mask_2d_7x7())
 
 
-
 def make_image_7x7():
     return aa.Array2D.ones(shape_native=(7, 7), pixel_scales=(1.0, 1.0))
 

autoarray/geometry/geometry_util.py

@@ -181,6 +181,7 @@ def convert_pixel_scales_2d(pixel_scales: ty.PixelScales) -> Tuple[float, float]
 
     return pixel_scales
 
+
 @numba_util.jit()
 def central_pixel_coordinates_2d_numba_from(
     shape_native: Tuple[int, int],
@@ -205,6 +206,7 @@ def central_pixel_coordinates_2d_numba_from(
     """
     return (float(shape_native[0] - 1) / 2, float(shape_native[1] - 1) / 2)
 
+
 @numba_util.jit()
 def central_scaled_coordinate_2d_numba_from(
     shape_native: Tuple[int, int],
@@ -305,6 +307,7 @@ def central_scaled_coordinate_2d_from(
 
     return (y_pixel, x_pixel)
 
+
 def pixel_coordinates_2d_from(
     scaled_coordinates_2d: Tuple[float, float],
     shape_native: Tuple[int, int],
@@ -589,9 +592,9 @@ def grid_pixel_centres_2d_slim_from(
     centres_scaled = np.array(centres_scaled)
     pixel_scales = np.array(pixel_scales)
     sign = np.array([-1.0, 1.0])
-    return (
-        (sign * grid_scaled_2d_slim / pixel_scales) + centres_scaled + 0.5
-    ).astype(int)
+    return ((sign * grid_scaled_2d_slim / pixel_scales) + centres_scaled + 0.5).astype(
+        int
+    )
 
 
 def grid_pixel_indexes_2d_slim_from(
@@ -647,9 +650,7 @@ def grid_pixel_indexes_2d_slim_from(
     )
 
     return (
-        (grid_pixels_2d_slim * np.array([shape_native[1], 1]))
-        .sum(axis=1)
-        .astype(int)
+        (grid_pixels_2d_slim * np.array([shape_native[1], 1])).sum(axis=1).astype(int)
     )
 
 
@@ -698,9 +699,7 @@ def grid_scaled_2d_slim_from(
     centres_scaled = np.array(centres_scaled)
     pixel_scales = np.array(pixel_scales)
     sign = np.array([-1, 1])
-    return (
-        (grid_pixels_2d_slim - centres_scaled - 0.5) * pixel_scales * sign
-    )
+    return (grid_pixels_2d_slim - centres_scaled - 0.5) * pixel_scales * sign
 
 
 def grid_pixel_centres_2d_from(
@@ -750,9 +749,7 @@ def grid_pixel_centres_2d_from(
     centres_scaled = np.array(centres_scaled)
     pixel_scales = np.array(pixel_scales)
     sign = np.array([-1.0, 1.0])
-    return (
-        (sign * grid_scaled_2d / pixel_scales) + centres_scaled + 0.5
-    ).astype(int)
+    return ((sign * grid_scaled_2d / pixel_scales) + centres_scaled + 0.5).astype(int)
 
 
 def extent_symmetric_from(

autoarray/inversion/inversion/imaging/w_tilde.py

@@ -526,8 +526,7 @@ def mapped_reconstructed_data_dict(self) -> Dict[LinearObj, Array2D]:
                 )
 
                 mapped_reconstructed_image = self.convolver.convolve_image_no_blurring(
-                    image=mapped_reconstructed_image,
-                    mask=self.mask
+                    image=mapped_reconstructed_image, mask=self.mask
                 )
 
             else:

autoarray/mask/derive/indexes_2d.py

@@ -198,9 +198,9 @@ def edge_slim(self) -> np.ndarray:
 
             print(derive_indexes_2d.edge_slim)
         """
-        return mask_2d_util.edge_1d_indexes_from(mask_2d=np.array(self.mask).astype("bool")).astype(
-            "int"
-        )
+        return mask_2d_util.edge_1d_indexes_from(
+            mask_2d=np.array(self.mask).astype("bool")
+        ).astype("int")
 
     @property
     def edge_native(self) -> np.ndarray:

autoarray/mask/mask_1d.py

@@ -25,6 +25,7 @@ class Mask1DKeys(Enum):
     PIXSCA = "PIXSCA"
     ORIGIN = "ORIGIN"
 
+
 class Mask1D(Mask):
     def __init__(
         self,

autoarray/mask/mask_2d_util.py

@@ -6,6 +6,7 @@
 from autoarray import exc
 from autoarray.numpy_wrapper import np as jnp
 
+
 def native_index_for_slim_index_2d_from(
     mask_2d: np.ndarray,
 ) -> np.ndarray:
@@ -400,6 +401,7 @@ def mask_2d_via_pixel_coordinates_from(
         return mask_2d
     return buffed_mask_2d_from(mask_2d=mask_2d, buffer=buffer)  # Apply buf
 
+
 def min_false_distance_to_edge(mask: np.ndarray) -> Tuple[int, int]:
     """
     Compute the minimum 1D distance in the y and x directions from any `False` value at the mask's extreme positions
@@ -618,14 +620,18 @@ def edge_1d_indexes_from(mask_2d: np.ndarray) -> np.ndarray:
     array([0, 1, 2, 3, 5, 6, 7, 8])
     """
     # Pad the mask to handle edge cases without index errors
-    padded_mask = np.pad(mask_2d, pad_width=1, mode='constant', constant_values=True)
+    padded_mask = np.pad(mask_2d, pad_width=1, mode="constant", constant_values=True)
 
     # Identify neighbors in 3x3 regions around each pixel
     neighbors = (
-            padded_mask[:-2, 1:-1] | padded_mask[2:, 1:-1] |  # Up, Down
-            padded_mask[1:-1, :-2] | padded_mask[1:-1, 2:] |  # Left, Right
-            padded_mask[:-2, :-2] | padded_mask[:-2, 2:] |  # Top-left, Top-right
-            padded_mask[2:, :-2] | padded_mask[2:, 2:]  # Bottom-left, Bottom-right
+        padded_mask[:-2, 1:-1]
+        | padded_mask[2:, 1:-1]  # Up, Down
+        | padded_mask[1:-1, :-2]
+        | padded_mask[1:-1, 2:]  # Left, Right
+        | padded_mask[:-2, :-2]
+        | padded_mask[:-2, 2:]  # Top-left, Top-right
+        | padded_mask[2:, :-2]
+        | padded_mask[2:, 2:]  # Bottom-left, Bottom-right
     )
 
     # Identify edge pixels: False values with at least one True neighbor
@@ -708,10 +714,10 @@ def border_slim_indexes_from(mask_2d: np.ndarray) -> np.ndarray:
 
     # Identify border pixels: where the full length in any direction is True
     border_mask = (
-        (up_sums == np.arange(height)[:, None]) |
-        (down_sums == np.arange(height - 1, -1, -1)[:, None]) |
-        (left_sums == np.arange(width)[None, :]) |
-        (right_sums == np.arange(width - 1, -1, -1)[None, :])
+        (up_sums == np.arange(height)[:, None])
+        | (down_sums == np.arange(height - 1, -1, -1)[:, None])
+        | (left_sums == np.arange(width)[None, :])
+        | (right_sums == np.arange(width - 1, -1, -1)[None, :])
     ) & ~mask_2d
 
     # Create an index array where False entries get sequential 1D indices
@@ -767,14 +773,16 @@ def buffed_mask_2d_from(mask_2d: np.ndarray, buffer: int = 1) -> np.ndarray:
     buffer_range = np.arange(-buffer, buffer + 1)
 
     # Generate all possible neighbors for each False entry
-    dy, dx = np.meshgrid(buffer_range, buffer_range, indexing='ij')
+    dy, dx = np.meshgrid(buffer_range, buffer_range, indexing="ij")
     neighbors = np.stack([dy.ravel(), dx.ravel()], axis=-1)
 
     # Calculate all neighboring positions for all False coordinates
     all_neighbors = np.add(np.array(false_coords).T[:, np.newaxis], neighbors)
 
     # Clip the neighbors to stay within the bounds of the mask
-    valid_neighbors = np.clip(all_neighbors, [0, 0], [mask_2d.shape[0] - 1, mask_2d.shape[1] - 1])
+    valid_neighbors = np.clip(
+        all_neighbors, [0, 0], [mask_2d.shape[0] - 1, mask_2d.shape[1] - 1]
+    )
 
     # Update the buffed mask: set all the neighbors to False
     buffed_mask_2d[valid_neighbors[:, :, 0], valid_neighbors[:, :, 1]] = False
@@ -833,6 +841,3 @@ def rescaled_mask_2d_from(mask_2d: np.ndarray, rescale_factor: float) -> np.ndar
     rescaled_mask_2d[:, 0] = 1
     rescaled_mask_2d[:, rescaled_mask_2d.shape[1] - 1] = 1
     return np.isclose(rescaled_mask_2d, 1)
-
-
-

autoarray/operators/over_sampling/over_sample_util.py

@@ -463,16 +463,10 @@ def grid_2d_slim_over_sampled_via_mask_from(
                         #     )
                         # else:
                         grid_slim[sub_index, 0] = -(
-                            y_scaled
-                            - y_sub_half
-                            + y1 * y_sub_step
-                            + (y_sub_step / 2.0)
+                            y_scaled - y_sub_half + y1 * y_sub_step + (y_sub_step / 2.0)
                         )
                         grid_slim[sub_index, 1] = (
-                            x_scaled
-                            - x_sub_half
-                            + x1 * x_sub_step
-                            + (x_sub_step / 2.0)
+                            x_scaled - x_sub_half + x1 * x_sub_step + (x_sub_step / 2.0)
                         )
                         sub_index += 1
 

autoarray/operators/over_sampling/over_sampler.py

@@ -226,7 +226,9 @@ def binned_array_2d_from(self, array: Array2D) -> "Array2D":
         #     sub_size=np.array(self.sub_size).astype("int"),
         # )
 
-        binned_array_2d = array.reshape(self.mask.shape_slim, self.sub_size[0]**2).mean(axis=1)
+        binned_array_2d = array.reshape(
+            self.mask.shape_slim, self.sub_size[0] ** 2
+        ).mean(axis=1)
 
         return Array2D(
             values=binned_array_2d,

autoarray/structures/arrays/array_2d_util.py

@@ -27,10 +27,7 @@ def convert_array(array: Union[np.ndarray, List]) -> np.ndarray:
         array = np.asarray(array)
     elif isinstance(array, jnp.ndarray):
         array = jax.lax.cond(
-            type(array) is list,
-            lambda _: jnp.asarray(array),
-            lambda _: array,
-            None
+            type(array) is list, lambda _: jnp.asarray(array), lambda _: array, None
         )
     return array
 
@@ -41,6 +38,7 @@ def check_array_2d(array_2d: np.ndarray):
             "An array input into the Array2D.__new__ method is not of shape 1."
         )
 
+
 def check_array_2d_and_mask_2d(array_2d: np.ndarray, mask_2d: Mask2D):
     """
     The `manual` classmethods in the `Array2D` object take as input a list or ndarray which is returned as an
@@ -90,6 +88,7 @@ def check_array_2d_and_mask_2d(array_2d: np.ndarray, mask_2d: Mask2D):
                 """
             )
 
+
 def convert_array_2d(
     array_2d: Union[np.ndarray, List],
     mask_2d: Mask2D,
@@ -489,6 +488,7 @@ def index_slim_for_index_2d_from(indexes_2d: np.ndarray, shape_native) -> np.nda
 
     return index_slim_for_index_native_2d
 
+
 def array_2d_slim_from(
     array_2d_native: np.ndarray,
     mask_2d: np.ndarray,
@@ -534,6 +534,7 @@ def array_2d_slim_from(
     """
     return array_2d_native[~mask_2d.astype(bool)]
 
+
 def array_2d_native_from(
     array_2d_slim: np.ndarray,
     mask_2d: np.ndarray,
@@ -620,9 +621,7 @@ def array_2d_via_indexes_from(
         The native 2D array of values mapped from the slimmed array with dimensions (total_values, total_values).
     """
     return (
-        jnp.zeros(shape)
-        .at[tuple(native_index_for_slim_index_2d.T)]
-        .set(array_2d_slim)
+        jnp.zeros(shape).at[tuple(native_index_for_slim_index_2d.T)].set(array_2d_slim)
     )
 
 

autoarray/structures/arrays/kernel_2d.py

@@ -474,7 +474,9 @@ def convolved_array_from(self, array: Array2D) -> Array2D:
 
         array_2d = array.native
 
-        convolved_array_2d = scipy.signal.convolve2d(array_2d._array, np.array(self.native._array), mode="same")
+        convolved_array_2d = scipy.signal.convolve2d(
+            array_2d._array, np.array(self.native._array), mode="same"
+        )
 
         convolved_array_1d = array_2d_util.array_2d_slim_from(
             mask_2d=np.array(array_2d.mask),
@@ -543,15 +545,11 @@ def convolve_image_no_blurring(self, image, mask, jax_method="fft"):
             kernels that are more than about 5x5. Default is `fft`.
         """
 
-        slim_to_native = jnp.nonzero(
-            jnp.logical_not(mask.array), size=image.shape[0]
-        )
+        slim_to_native = jnp.nonzero(jnp.logical_not(mask.array), size=image.shape[0])
 
         expanded_array_native = jnp.zeros(mask.shape)
 
-        expanded_array_native = expanded_array_native.at[slim_to_native].set(
-            image
-        )
+        expanded_array_native = expanded_array_native.at[slim_to_native].set(image)
 
         kernel = np.array(self.native.array)
 
@@ -571,4 +569,6 @@ def convolve_mapping_matrix(self, mapping_matrix, mask):
         image
             1D array of the values which are to be blurred with the convolver's PSF.
         """
-        return jax.vmap(self.convolve_image_no_blurring, in_axes=(1, None))(mapping_matrix, mask).T
+        return jax.vmap(self.convolve_image_no_blurring, in_axes=(1, None))(
+            mapping_matrix, mask
+        ).T