utils: Fix Python formatting and lint issues

Run ruff check --fix and ruff format across all Python utility
scripts to fix lint warnings and standardise formatting.

Signed-off-by: Naushir Patuck <naush@raspberrypi.com>

Author: naushir

utils/colourspace_calcs.py

@@ -9,33 +9,48 @@
 
 import numpy as np
 
-BT601 = np.array([[0.299, 0.5870, 0.1140], [-0.168736, -0.331264, 0.5], [0.5, -0.418688, -0.081312]])
-REC709 = np.array([[0.2126, 0.7152, 0.0722], [-0.1146, -0.3854, 0.5], [0.5, -0.4542, -0.0458]])
-REC2020 = np.array([[0.2627, 0.6780, 0.0593], [-0.13963006, -0.36036994, 0.5], [0.5, -0.4597857, -0.0402143]])
+BT601 = np.array(
+    [[0.299, 0.5870, 0.1140], [-0.168736, -0.331264, 0.5], [0.5, -0.418688, -0.081312]]
+)
+REC709 = np.array(
+    [[0.2126, 0.7152, 0.0722], [-0.1146, -0.3854, 0.5], [0.5, -0.4542, -0.0458]]
+)
+REC2020 = np.array(
+    [
+        [0.2627, 0.6780, 0.0593],
+        [-0.13963006, -0.36036994, 0.5],
+        [0.5, -0.4597857, -0.0402143],
+    ]
+)
 
 colour_spaces = {"select": "default"}
 
+
 def flatten(array):
     return [round(num) for num in list(array.flatten())]
 
+
 def add_entry(name, M, limited):
     offsets = np.array([0, 128, 128])
-    scaling = np.array([[(235 - 16) / 255, 0, 0], [0, (240 - 16) / 255, 0], [0, 0, (240 - 16) / 255]])
+    scaling = np.array(
+        [[(235 - 16) / 255, 0, 0], [0, (240 - 16) / 255, 0], [0, 0, (240 - 16) / 255]]
+    )
     if limited:
         offsets = np.array([16, 128, 128])
         M = np.matmul(scaling, M)
     Mi = np.linalg.inv(M)
     colour_spaces[name] = {}
     colour_spaces[name]["ycbcr"] = {}
     colour_spaces[name]["ycbcr"]["coeffs"] = flatten(M * 1024)
-    colour_spaces[name]["ycbcr"]["offsets"] = flatten(offsets * (2 ** 18))
+    colour_spaces[name]["ycbcr"]["offsets"] = flatten(offsets * (2**18))
     colour_spaces[name]["ycbcr_inverse"] = {}
     colour_spaces[name]["ycbcr_inverse"]["coeffs"] = flatten(Mi * 1024)
-    inv_offsets = np.rint(np.dot(Mi, -offsets) * (2 ** 18))
+    inv_offsets = np.rint(np.dot(Mi, -offsets) * (2**18))
     colour_spaces[name]["ycbcr_inverse"]["offsets"] = flatten(inv_offsets)
-    if inv_offsets.min() < -2 ** 26 or inv_offsets.max() >= 2 ** 26:
+    if inv_offsets.min() < -(2**26) or inv_offsets.max() >= 2**26:
         print("WARNING:", name, "will overflow!")
 
+
 add_entry("default", BT601, limited=False)
 add_entry("jpeg", BT601, limited=False)
 add_entry("smpte170m", BT601, limited=True)
@@ -44,18 +59,20 @@ def add_entry(name, M, limited):
 add_entry("bt2020", REC2020, limited=True)
 add_entry("bt2020_full", REC2020, limited=False)
 
+
 def print_dict(d, indent=0):
     print("{")
     indent += 4
     for i, (k, v) in enumerate(d.items()):
         if type(v) is dict:
-            print(" " * indent, f'"{k}"', ": ", end='', sep='')
+            print(" " * indent, f'"{k}"', ": ", end="", sep="")
             print_dict(v, indent)
         else:
-            print(" " * indent, f'"{k}"', ": ", v, end='', sep='')
+            print(" " * indent, f'"{k}"', ": ", v, end="", sep="")
         print("," if i < len(d) - 1 else "")
     indent -= 4
-    print(" " * indent, "}", end ='', sep='')
+    print(" " * indent, "}", end="", sep="")
+
 
 final_dict = {"colour_encoding": colour_spaces}
 print_dict(final_dict)

utils/generate_filter.py

@@ -28,9 +28,18 @@ def mitchell(B, C, N):
     for i in range(N):
         ax = abs(x[i])
         if ax < 1:
-            h[i] = ((12 - 9 * B - 6 * C) * ax**3 + (-18 + 12 * B + 6 * C) * ax**2 + (6 - 2 * B)) / 6
+            h[i] = (
+                (12 - 9 * B - 6 * C) * ax**3
+                + (-18 + 12 * B + 6 * C) * ax**2
+                + (6 - 2 * B)
+            ) / 6
         elif (ax >= 1) and (ax < 2):
-            h[i] = ((-B - 6 * C) * ax**3 + (6 * B + 30 * C) * ax**2 + (-12 * B - 48 * C) * ax + (8 * B + 24 * C)) / 6
+            h[i] = (
+                (-B - 6 * C) * ax**3
+                + (6 * B + 30 * C) * ax**2
+                + (-12 * B - 48 * C) * ax
+                + (8 * B + 24 * C)
+            ) / 6
     return h
 
 
@@ -50,14 +59,33 @@ def bicubic_spline(a, N):
 
 def main():
     parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter)
-    parser.add_argument('--phases', metavar='P', type=int, help='Number of phases.', default=16)
-    parser.add_argument('--taps', metavar='T', type=int, help='Number of filter taps per phase.', default=6)
-    parser.add_argument('--precision', metavar='PR', type=int, help='Filter precision required.', default=10)
-    parser.add_argument('--filter', type=str, metavar='F',
-                        help='Filter type and parameters, e.g.: \n'
-                        '"Mitchell, b = 0.333, c = 0.333"\n'
-                        '"Lanczos, order = 3"\n'
-                        '"bicubic_spline, a=-0.5"', required=True)
+    parser.add_argument(
+        "--phases", metavar="P", type=int, help="Number of phases.", default=16
+    )
+    parser.add_argument(
+        "--taps",
+        metavar="T",
+        type=int,
+        help="Number of filter taps per phase.",
+        default=6,
+    )
+    parser.add_argument(
+        "--precision",
+        metavar="PR",
+        type=int,
+        help="Filter precision required.",
+        default=10,
+    )
+    parser.add_argument(
+        "--filter",
+        type=str,
+        metavar="F",
+        help="Filter type and parameters, e.g.: \n"
+        '"Mitchell, b = 0.333, c = 0.333"\n'
+        '"Lanczos, order = 3"\n'
+        '"bicubic_spline, a=-0.5"',
+        required=True,
+    )
 
     args = parser.parse_args()
 
@@ -66,24 +94,26 @@ def main():
     precision = args.precision
 
     # Parse the filter string and pick out the needed parameters.
-    filt = args.filter.split(',')
-    params = {'a': 0., 'b': 0., 'c': 0., 'order': 0}
+    filt = args.filter.split(",")
+    params = {"a": 0.0, "b": 0.0, "c": 0.0, "order": 0}
     for param in filt[1:]:
-        p = param.replace(' ', '').split('=')
+        p = param.replace(" ", "").split("=")
         params[p[0]] = type(params[p[0]])(p[1])
 
     # Generate the filter.
-    if (filt[0].lower() == 'mitchell'):
-        filter = f'"Michell - Netravali (B = {params["b"]:.3f}, C = {params["c"]:.3f})": [\n'
-        h = mitchell(params['b'], params['c'], phases * taps)
-    elif (filt[0].lower() == 'lanczos'):
+    if filt[0].lower() == "mitchell":
+        filter = (
+            f'"Michell - Netravali (B = {params["b"]:.3f}, C = {params["c"]:.3f})": [\n'
+        )
+        h = mitchell(params["b"], params["c"], phases * taps)
+    elif filt[0].lower() == "lanczos":
         filter = f'"Lanczos order {params["order"]}": [\n'
-        h = lanczos(params['order'], phases * taps)
-    elif (filt[0].lower() == 'bicubic_spline'):
+        h = lanczos(params["order"], phases * taps)
+    elif filt[0].lower() == "bicubic_spline":
         filter = f'"Bicubic-spline (a = {params["a"]:.3f})": [\n'
-        h = bicubic_spline(params['a'], phases * taps)
+        h = bicubic_spline(params["a"], phases * taps)
     else:
-        print(f'Invalid filter ({filt[0]}) selected!')
+        print(f"Invalid filter ({filt[0]}) selected!")
         exit()
 
     # Normalise and convert to fixed-point.
@@ -98,13 +128,13 @@ def main():
         max_index = np.nonzero(ppf[i] == ppf[i].max())[0]
         ppf[i, max_index] += (1 << precision) - np.int32(ppf[i].sum() / max_index.size)
 
-    nl = '\n'
+    nl = "\n"
     for i in range(phases):
-        phase = ', '.join([f'{c:>4}' for c in ppf[i, :]])
-        filter += f'    {phase}{nl+"]" if i==phases-1 else ","+nl}'
+        phase = ", ".join([f"{c:>4}" for c in ppf[i, :]])
+        filter += f"    {phase}{nl + ']' if i == phases - 1 else ',' + nl}"
 
     print(filter)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()