STYLE: Format code using ruff

Format the code using `ruff`: supersedes `flake8` and `blue`.

`blue` was not being applied previously as the relevant `pre-commit`
hook config block was commented in the.

Remove the `.flake8` config file: in practice few rules were being
applied as the config file contained a significant number fo ignored
rules.

Bump `ruff-pre-commit` pre-commit hook version to v0.4.3 (May 3, 2024):
the version being used previously was v0.1.7 was from Dec 4, 2023. Made
changes consistent between changes being observed locally vs on the
GitHub action.

Sort the imports according to the new version: new sorting is dictated
by the default value of `force-sort-within-sections` (`false`): imports
are sorted by module.

Fix the warnings reported by `ruff`, e.g. C408, F401, etc.

.pre-commit-config.yaml

@@ -16,15 +16,6 @@ repos:
       - id: detect-aws-credentials
         args: [--allow-missing-credentials]
       - id: detect-private-key
-  # - repo: https://github.com/grantjenks/blue
-  #   rev: v0.9.1
-  #   hooks:
-  #     - id: blue
-  - repo: https://github.com/pycqa/flake8
-    rev: 6.0.0
-    hooks:
-      - id: flake8
-        exclude: "^(docs/experimental|tools)/"
   - repo: https://github.com/codespell-project/codespell
     rev: v2.2.2
     hooks:
@@ -47,8 +38,10 @@ repos:
         args: ["fury"]
         pass_filenames: false
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.1.7
+    rev: v0.4.3
     hooks:
       # Run the linter
       - id: ruff
-        args: [ --fix ]
+        args: [ --fix]
+      # Run the formatter
+      - id: ruff-format

docs/examples/collision-particles.py

@@ -24,7 +24,6 @@
 
 
 def box_edges(box_lx, box_ly, box_lz):
-
     edge1 = 0.5 * np.array(
         [
             [box_lx, box_ly, box_lz],
@@ -54,7 +53,6 @@ def collision():
     sec = int(num_vertices / num_particles)
 
     for i, j in np.ndindex(num_particles, num_particles):
-
         if i == j:
             continue
         distance = np.linalg.norm(xyz[i] - xyz[j])
@@ -148,7 +146,7 @@ def collision():
 counter = itertools.count()
 
 vertices = utils.vertices_from_actor(sphere_actor)
-vcolors = utils.colors_from_actor(sphere_actor, 'colors')
+vcolors = utils.colors_from_actor(sphere_actor, "colors")
 no_vertices_per_sphere = len(vertices) / num_particles
 initial_vertices = vertices.copy() - np.repeat(xyz, no_vertices_per_sphere, axis=0)
 
@@ -177,4 +175,4 @@ def timer_callback(_obj, _event):
 if interactive:
     showm.start()
 
-window.record(showm.scene, size=(900, 768), out_path='simple_collisions.png')
+window.record(showm.scene, size=(900, 768), out_path="simple_collisions.png")

docs/examples/viz_advanced.py

@@ -46,19 +46,19 @@
 # ``af left`` (left arcuate fasciculus) and maps, e.g. FA for a specific
 # subject.
 
-res = read_bundles_2_subjects('subj_1', ['t1', 'fa'], ['af.left', 'cst.right', 'cc_1'])
+res = read_bundles_2_subjects("subj_1", ["t1", "fa"], ["af.left", "cst.right", "cc_1"])
 
 ###############################################################################
 # We will use 3 bundles, FA and the affine transformation that brings the voxel
 # coordinates to world coordinates (RAS 1mm).
 
-streamlines = Streamlines(res['af.left'])
-streamlines.extend(res['cst.right'])
-streamlines.extend(res['cc_1'])
+streamlines = Streamlines(res["af.left"])
+streamlines.extend(res["cst.right"])
+streamlines.extend(res["cc_1"])
 
-data = res['fa']
+data = res["fa"]
 shape = data.shape
-affine = res['affine']
+affine = res["affine"]
 
 ###############################################################################
 # With our current design it is easy to decide in which space you want the
@@ -134,23 +134,23 @@
     min_value=0,
     max_value=shape[2] - 1,
     initial_value=shape[2] / 2,
-    text_template='{value:.0f}',
+    text_template="{value:.0f}",
     length=140,
 )
 
 line_slider_x = ui.LineSlider2D(
     min_value=0,
     max_value=shape[0] - 1,
     initial_value=shape[0] / 2,
-    text_template='{value:.0f}',
+    text_template="{value:.0f}",
     length=140,
 )
 
 line_slider_y = ui.LineSlider2D(
     min_value=0,
     max_value=shape[1] - 1,
     initial_value=shape[1] / 2,
-    text_template='{value:.0f}',
+    text_template="{value:.0f}",
     length=140,
 )
 
@@ -197,8 +197,8 @@ def build_label(text):
     label = ui.TextBlock2D()
     label.message = text
     label.font_size = 18
-    label.font_family = 'Arial'
-    label.justification = 'left'
+    label.font_family = "Arial"
+    label.justification = "left"
     label.bold = False
     label.italic = False
     label.shadow = False
@@ -208,15 +208,15 @@ def build_label(text):
     return label
 
 
-line_slider_label_z = build_label(text='Z Slice')
-line_slider_label_x = build_label(text='X Slice')
-line_slider_label_y = build_label(text='Y Slice')
-opacity_slider_label = build_label(text='Opacity')
+line_slider_label_z = build_label(text="Z Slice")
+line_slider_label_x = build_label(text="X Slice")
+line_slider_label_y = build_label(text="Y Slice")
+opacity_slider_label = build_label(text="Opacity")
 
 ###############################################################################
 # Now we will create a ``panel`` to contain the sliders and labels.
 
-panel = ui.Panel2D(size=(300, 200), color=(1, 1, 1), opacity=0.1, align='right')
+panel = ui.Panel2D(size=(300, 200), color=(1, 1, 1), opacity=0.1, align="right")
 panel.center = (1030, 120)
 
 panel.add_element(line_slider_label_x, (0.1, 0.75))
@@ -262,15 +262,13 @@ def win_callback(obj, _event):
 scene.reset_clipping_range()
 
 if interactive:
-
     show_m.add_window_callback(win_callback)
     show_m.render()
     show_m.start()
 
 else:
-
     window.record(
-        scene, out_path='bundles_and_3_slices.png', size=(1200, 900), reset_camera=False
+        scene, out_path="bundles_and_3_slices.png", size=(1200, 900), reset_camera=False
     )
 
 del show_m

docs/examples/viz_animated_surfaces.py

@@ -24,8 +24,7 @@
 # the z coordinate is a function of time.
 
 
-def update_surface(x, y, equation, cmap_name='viridis'):
-
+def update_surface(x, y, equation, cmap_name="viridis"):
     # z is the function F i.e. F(x, y, t)
     z = eval(equation)
     xyz = np.vstack([x, y, z]).T
@@ -100,17 +99,17 @@ def create_surface(x, y, equation, colormap_name):
 
 ###############################################################################
 # Equations to be plotted
-eq1 = 'np.abs(np.sin(x*2*np.pi*np.cos(time/2)))**1*np.cos(time/2)*\
-      np.abs(np.cos(y*2*np.pi*np.sin(time/2)))**1*np.sin(time/2)*1.2'
-eq2 = '((x**2 - y**2)/(x**2 + y**2))**(2)*np.cos(6*np.pi*x*y-1.8*time)*0.24'
-eq3 = '(np.sin(np.pi*2*x-np.sin(1.8*time))*np.cos(np.pi*2*y+np.cos(1.8*time)))\
-      *0.48'
-eq4 = 'np.cos(24*np.sqrt(x**2 + y**2) - 2*time)*0.18'
+eq1 = "np.abs(np.sin(x*2*np.pi*np.cos(time/2)))**1*np.cos(time/2)*\
+      np.abs(np.cos(y*2*np.pi*np.sin(time/2)))**1*np.sin(time/2)*1.2"
+eq2 = "((x**2 - y**2)/(x**2 + y**2))**(2)*np.cos(6*np.pi*x*y-1.8*time)*0.24"
+eq3 = "(np.sin(np.pi*2*x-np.sin(1.8*time))*np.cos(np.pi*2*y+np.cos(1.8*time)))\
+      *0.48"
+eq4 = "np.cos(24*np.sqrt(x**2 + y**2) - 2*time)*0.18"
 equations = [eq1, eq2, eq3, eq4]
 
 ###############################################################################
 # List of colormaps to be used for the various functions.
-cmap_names = ['hot', 'plasma', 'viridis', 'ocean']
+cmap_names = ["hot", "plasma", "viridis", "ocean"]
 
 ###############################################################################
 # Creating a list of surfaces.
@@ -137,7 +136,7 @@ def create_surface(x, y, equation, colormap_name):
 text = []
 for i in range(4):
     t_actor = actor.vector_text(
-        'Function ' + str(i + 1), pos=(0, 0, 0), scale=(0.17, 0.2, 0.2)
+        "Function " + str(i + 1), pos=(0, 0, 0), scale=(0.17, 0.2, 0.2)
     )
     text.append(t_actor)
 
@@ -159,7 +158,7 @@ def create_surface(x, y, equation, colormap_name):
 ###############################################################################
 # Initializing text box to print the title of the animation
 tb = ui.TextBlock2D(bold=True, position=(200, 60))
-tb.message = 'Animated 2D functions'
+tb.message = "Animated 2D functions"
 scene.add(tb)
 
 ###############################################################################
@@ -207,4 +206,4 @@ def timer_callback(_obj, _event):
 if interactive:
     showm.start()
 
-window.record(showm.scene, size=(600, 600), out_path='viz_animated_surfaces.png')
+window.record(showm.scene, size=(600, 600), out_path="viz_animated_surfaces.png")

docs/examples/viz_arrow.py

@@ -50,4 +50,4 @@
 if interactive:
     window.show(scene, size=(600, 600))
 
-window.record(scene, out_path='viz_arrow.png', size=(600, 600))
+window.record(scene, out_path="viz_arrow.png", size=(600, 600))

docs/examples/viz_ball_collide.py

@@ -9,6 +9,7 @@
 
 First some imports.
 """
+
 import itertools
 
 import numpy as np
@@ -86,7 +87,7 @@ def sync_actor(actor, multibody):
 
 
 apply_force = True
-tb = ui.TextBlock2D(position=(0, 600), font_size=30, color=(1, 0.5, 0), text='')
+tb = ui.TextBlock2D(position=(0, 600), font_size=30, color=(1, 0.5, 0), text="")
 scene.add(tb)
 scene.set_camera(
     position=(0.30, -18.78, 0.89), focal_point=(0.15, 0.25, 0.40), view_up=(0, 0, 1.00)
@@ -122,7 +123,7 @@ def timer_callback(_obj, _event):
     # Get various collision information using `p.getContactPoints`.
     contact = p.getContactPoints(red_ball, blue_ball, -1, -1)
     if len(contact) != 0:
-        tb.message = 'Collision!!'
+        tb.message = "Collision!!"
 
     p.stepSimulation()
 
@@ -137,4 +138,4 @@ def timer_callback(_obj, _event):
 if interactive:
     showm.start()
 
-window.record(scene, size=(900, 700), out_path='viz_ball_collide.png')
+window.record(scene, size=(900, 700), out_path="viz_ball_collide.png")

docs/examples/viz_bezier_interpolator.py

@@ -5,6 +5,7 @@
 
 Keyframe animation using cubic Bezier interpolator.
 """
+
 import numpy as np
 
 from fury import actor, window
@@ -44,19 +45,19 @@
 #         keyframe 1            ----------------->         keyframe 2
 # (time-1) (value-1) (out-cp-1) -----------------> (time-2) (value-2) (in-cp-2)
 
-keyframe_1 = {'value': [-2, 0, 0], 'out_cp': [-15, 6, 0]}
-keyframe_2 = {'value': [18, 0, 0], 'in_cp': [27, 18, 0]}
+keyframe_1 = {"value": [-2, 0, 0], "out_cp": [-15, 6, 0]}
+keyframe_2 = {"value": [18, 0, 0], "in_cp": [27, 18, 0]}
 
 ###############################################################################
 # Visualizing points
 pts_actor = actor.sphere(
-    np.array([keyframe_1.get('value'), keyframe_2.get('value')]), (1, 0, 0), radii=0.3
+    np.array([keyframe_1.get("value"), keyframe_2.get("value")]), (1, 0, 0), radii=0.3
 )
 
 ###############################################################################
 # Visualizing the control points
 cps_actor = actor.sphere(
-    np.array([keyframe_2.get('in_cp'), keyframe_1.get('out_cp')]), (0, 0, 1), radii=0.6
+    np.array([keyframe_2.get("in_cp"), keyframe_1.get("out_cp")]), (0, 0, 1), radii=0.6
 )
 
 ###############################################################################
@@ -86,10 +87,10 @@
 # will be the same as the position itself.
 
 animation.set_position(
-    0.0, np.array(keyframe_1.get('value')), out_cp=np.array(keyframe_1.get('out_cp'))
+    0.0, np.array(keyframe_1.get("value")), out_cp=np.array(keyframe_1.get("out_cp"))
 )
 animation.set_position(
-    5.0, np.array(keyframe_2.get('value')), in_cp=np.array(keyframe_2.get('in_cp'))
+    5.0, np.array(keyframe_2.get("value")), in_cp=np.array(keyframe_2.get("in_cp"))
 )
 
 ###############################################################################
@@ -109,7 +110,7 @@
 if interactive:
     showm.start()
 
-window.record(scene, out_path='viz_keyframe_animation_bezier_1.png', size=(900, 768))
+window.record(scene, out_path="viz_keyframe_animation_bezier_1.png", size=(900, 768))
 
 ###############################################################################
 # A more complex scene scene
@@ -126,9 +127,9 @@
 # point it controls.
 keyframes = {
     # time - position - in control point  - out control point
-    0.0: {'value': [-2, 0, 0], 'out_cp': [-15, 6, 0]},
-    5.0: {'value': [18, 0, 0], 'in_cp': [27, 18, 0], 'out_cp': [27, -18, 0]},
-    9.0: {'value': [-5, -10, -10]},
+    0.0: {"value": [-2, 0, 0], "out_cp": [-15, 6, 0]},
+    5.0: {"value": [18, 0, 0], "in_cp": [27, 18, 0], "out_cp": [27, -18, 0]},
+    9.0: {"value": [-5, -10, -10]},
 }
 
 ###############################################################################
@@ -149,10 +150,10 @@
 
 ###########################################################################
 # visualizing the points and control points (only for demonstration)
-for t, keyframe in keyframes.items():
-    pos = keyframe.get('value')
-    in_control_point = keyframe.get('in_cp')
-    out_control_point = keyframe.get('out_cp')
+for keyframe in keyframes.values():
+    pos = keyframe.get("value")
+    in_control_point = keyframe.get("in_cp")
+    out_control_point = keyframe.get("out_cp")
 
     ###########################################################################
     # visualizing position keyframe
@@ -181,4 +182,4 @@
 if interactive:
     show_manager.start()
 
-window.record(scene, out_path='viz_keyframe_animation_bezier_2.png', size=(900, 768))
+window.record(scene, out_path="viz_keyframe_animation_bezier_2.png", size=(900, 768))