chore: black fix

Author: blessedcoolant

invokeai/backend/stable_diffusion/diffusion/cross_attention_control.py

@@ -265,7 +265,7 @@ def einsum_op_mps_v1(self, q, k, v):
         if q.shape[1] <= 4096:  # (512x512) max q.shape[1]: 4096
             return self.einsum_lowest_level(q, k, v, None, None, None)
         else:
-            slice_size = math.floor(2 ** 30 / (q.shape[0] * q.shape[1]))
+            slice_size = math.floor(2**30 / (q.shape[0] * q.shape[1]))
             return self.einsum_op_slice_dim1(q, k, v, slice_size)
 
     def einsum_op_mps_v2(self, q, k, v):

invokeai/backend/stable_diffusion/diffusion/shared_invokeai_diffusion.py

@@ -215,7 +215,10 @@ def do_controlnet_step(
                                 dim=0,
                             ),
                         }
-                    (encoder_hidden_states, encoder_attention_mask,) = self._concat_conditionings_for_batch(
+                    (
+                        encoder_hidden_states,
+                        encoder_attention_mask,
+                    ) = self._concat_conditionings_for_batch(
                         conditioning_data.unconditioned_embeddings.embeds,
                         conditioning_data.text_embeddings.embeds,
                     )
@@ -277,23 +280,32 @@ def do_unet_step(
         wants_cross_attention_control = len(cross_attention_control_types_to_do) > 0
 
         if wants_cross_attention_control:
-            (unconditioned_next_x, conditioned_next_x,) = self._apply_cross_attention_controlled_conditioning(
+            (
+                unconditioned_next_x,
+                conditioned_next_x,
+            ) = self._apply_cross_attention_controlled_conditioning(
                 sample,
                 timestep,
                 conditioning_data,
                 cross_attention_control_types_to_do,
                 **kwargs,
             )
         elif self.sequential_guidance:
-            (unconditioned_next_x, conditioned_next_x,) = self._apply_standard_conditioning_sequentially(
+            (
+                unconditioned_next_x,
+                conditioned_next_x,
+            ) = self._apply_standard_conditioning_sequentially(
                 sample,
                 timestep,
                 conditioning_data,
                 **kwargs,
             )
 
         else:
-            (unconditioned_next_x, conditioned_next_x,) = self._apply_standard_conditioning(
+            (
+                unconditioned_next_x,
+                conditioned_next_x,
+            ) = self._apply_standard_conditioning(
                 sample,
                 timestep,
                 conditioning_data,

invokeai/backend/stable_diffusion/image_degradation/bsrgan.py

@@ -395,7 +395,7 @@ def add_Gaussian_noise(img, noise_level1=2, noise_level2=25):
         D = np.diag(np.random.rand(3))
         U = orth(np.random.rand(3, 3))
         conv = np.dot(np.dot(np.transpose(U), D), U)
-        img = img + np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
+        img = img + np.random.multivariate_normal([0, 0, 0], np.abs(L**2 * conv), img.shape[:2]).astype(np.float32)
     img = np.clip(img, 0.0, 1.0)
     return img
 
@@ -413,7 +413,7 @@ def add_speckle_noise(img, noise_level1=2, noise_level2=25):
         D = np.diag(np.random.rand(3))
         U = orth(np.random.rand(3, 3))
         conv = np.dot(np.dot(np.transpose(U), D), U)
-        img += img * np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
+        img += img * np.random.multivariate_normal([0, 0, 0], np.abs(L**2 * conv), img.shape[:2]).astype(np.float32)
     img = np.clip(img, 0.0, 1.0)
     return img
 

invokeai/backend/stable_diffusion/image_degradation/bsrgan_light.py

@@ -399,7 +399,7 @@ def add_Gaussian_noise(img, noise_level1=2, noise_level2=25):
         D = np.diag(np.random.rand(3))
         U = orth(np.random.rand(3, 3))
         conv = np.dot(np.dot(np.transpose(U), D), U)
-        img = img + np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
+        img = img + np.random.multivariate_normal([0, 0, 0], np.abs(L**2 * conv), img.shape[:2]).astype(np.float32)
     img = np.clip(img, 0.0, 1.0)
     return img
 
@@ -417,7 +417,7 @@ def add_speckle_noise(img, noise_level1=2, noise_level2=25):
         D = np.diag(np.random.rand(3))
         U = orth(np.random.rand(3, 3))
         conv = np.dot(np.dot(np.transpose(U), D), U)
-        img += img * np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
+        img += img * np.random.multivariate_normal([0, 0, 0], np.abs(L**2 * conv), img.shape[:2]).astype(np.float32)
     img = np.clip(img, 0.0, 1.0)
     return img
 

invokeai/backend/stable_diffusion/image_degradation/utils_image.py

@@ -562,18 +562,14 @@ def rgb2ycbcr(img, only_y=True):
     if only_y:
         rlt = np.dot(img, [65.481, 128.553, 24.966]) / 255.0 + 16.0
     else:
-        rlt = (
-            np.matmul(
-                img,
-                [
-                    [65.481, -37.797, 112.0],
-                    [128.553, -74.203, -93.786],
-                    [24.966, 112.0, -18.214],
-                ],
-            )
-            / 255.0
-            + [16, 128, 128]
-        )
+        rlt = np.matmul(
+            img,
+            [
+                [65.481, -37.797, 112.0],
+                [128.553, -74.203, -93.786],
+                [24.966, 112.0, -18.214],
+            ],
+        ) / 255.0 + [16, 128, 128]
     if in_img_type == np.uint8:
         rlt = rlt.round()
     else:
@@ -592,18 +588,14 @@ def ycbcr2rgb(img):
     if in_img_type != np.uint8:
         img *= 255.0
     # convert
-    rlt = (
-        np.matmul(
-            img,
-            [
-                [0.00456621, 0.00456621, 0.00456621],
-                [0, -0.00153632, 0.00791071],
-                [0.00625893, -0.00318811, 0],
-            ],
-        )
-        * 255.0
-        + [-222.921, 135.576, -276.836]
-    )
+    rlt = np.matmul(
+        img,
+        [
+            [0.00456621, 0.00456621, 0.00456621],
+            [0, -0.00153632, 0.00791071],
+            [0.00625893, -0.00318811, 0],
+        ],
+    ) * 255.0 + [-222.921, 135.576, -276.836]
     if in_img_type == np.uint8:
         rlt = rlt.round()
     else:
@@ -626,18 +618,14 @@ def bgr2ycbcr(img, only_y=True):
     if only_y:
         rlt = np.dot(img, [24.966, 128.553, 65.481]) / 255.0 + 16.0
     else:
-        rlt = (
-            np.matmul(
-                img,
-                [
-                    [24.966, 112.0, -18.214],
-                    [128.553, -74.203, -93.786],
-                    [65.481, -37.797, 112.0],
-                ],
-            )
-            / 255.0
-            + [16, 128, 128]
-        )
+        rlt = np.matmul(
+            img,
+            [
+                [24.966, 112.0, -18.214],
+                [128.553, -74.203, -93.786],
+                [65.481, -37.797, 112.0],
+            ],
+        ) / 255.0 + [16, 128, 128]
     if in_img_type == np.uint8:
         rlt = rlt.round()
     else:
@@ -728,11 +716,11 @@ def ssim(img1, img2):
 
     mu1 = cv2.filter2D(img1, -1, window)[5:-5, 5:-5]  # valid
     mu2 = cv2.filter2D(img2, -1, window)[5:-5, 5:-5]
-    mu1_sq = mu1 ** 2
-    mu2_sq = mu2 ** 2
+    mu1_sq = mu1**2
+    mu2_sq = mu2**2
     mu1_mu2 = mu1 * mu2
-    sigma1_sq = cv2.filter2D(img1 ** 2, -1, window)[5:-5, 5:-5] - mu1_sq
-    sigma2_sq = cv2.filter2D(img2 ** 2, -1, window)[5:-5, 5:-5] - mu2_sq
+    sigma1_sq = cv2.filter2D(img1**2, -1, window)[5:-5, 5:-5] - mu1_sq
+    sigma2_sq = cv2.filter2D(img2**2, -1, window)[5:-5, 5:-5] - mu2_sq
     sigma12 = cv2.filter2D(img1 * img2, -1, window)[5:-5, 5:-5] - mu1_mu2
 
     ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) * (sigma1_sq + sigma2_sq + C2))
@@ -749,8 +737,8 @@ def ssim(img1, img2):
 # matlab 'imresize' function, now only support 'bicubic'
 def cubic(x):
     absx = torch.abs(x)
-    absx2 = absx ** 2
-    absx3 = absx ** 3
+    absx2 = absx**2
+    absx3 = absx**3
     return (1.5 * absx3 - 2.5 * absx2 + 1) * ((absx <= 1).type_as(absx)) + (
         -0.5 * absx3 + 2.5 * absx2 - 4 * absx + 2
     ) * (((absx > 1) * (absx <= 2)).type_as(absx))

invokeai/backend/training/textual_inversion_training.py

@@ -475,7 +475,10 @@ def __getitem__(self, i):
 
         if self.center_crop:
             crop = min(img.shape[0], img.shape[1])
-            (h, w,) = (
+            (
+                h,
+                w,
+            ) = (
                 img.shape[0],
                 img.shape[1],
             )

invokeai/backend/util/mps_fixes.py

@@ -1,7 +1,7 @@
 import math
-import torch
-import diffusers
 
+import diffusers
+import torch
 
 if torch.backends.mps.is_available():
     torch.empty = torch.zeros
@@ -203,7 +203,7 @@ def get_attention_scores_chunked(self, attn, query, key, attention_mask, hidden_
         if attn.upcast_attention:
             out_item_size = 4
 
-        chunk_size = 2 ** 29
+        chunk_size = 2**29
 
         out_size = query.shape[1] * key.shape[1] * out_item_size
         chunks_count = min(query.shape[1], math.ceil((out_size - 1) / chunk_size))

invokeai/backend/util/util.py

@@ -207,7 +207,7 @@ def parallel_data_prefetch(
         return gather_res
 
 
-def rand_perlin_2d(shape, res, device, fade=lambda t: 6 * t ** 5 - 15 * t ** 4 + 10 * t ** 3):
+def rand_perlin_2d(shape, res, device, fade=lambda t: 6 * t**5 - 15 * t**4 + 10 * t**3):
     delta = (res[0] / shape[0], res[1] / shape[1])
     d = (shape[0] // res[0], shape[1] // res[1])