[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

src/spikeinterface/core/generate.py

@@ -2156,19 +2156,18 @@ def generate_channel_locations(num_channels, num_columns, contact_spacing_um):
     return channel_locations
 
 
-
 def _generate_multimodal(rng, size, num_modes, lim0, lim1):
     bins = np.linspace(lim0, lim1, 10000)
     bin_step = bins[1] - bins[0]
     prob = np.zeros(bins.size)
     mode_step = (lim1 - lim0) / (num_modes + 1)
     for i in range(num_modes):
         center = mode_step * (i + 1)
-        sigma = mode_step / 5.
-        prob += np.exp( -(bins - center)**2 / ( 2 * sigma **2))
+        sigma = mode_step / 5.0
+        prob += np.exp(-((bins - center) ** 2) / (2 * sigma**2))
     prob /= np.sum(prob)
     choices = np.random.choice(np.arange(bins.size), size, p=prob)
-    values = bins[choices] + rng.uniform(low=-bin_step/2, high=bin_step/2, size=size)
+    values = bins[choices] + rng.uniform(low=-bin_step / 2, high=bin_step / 2, size=size)
     return values
 
 
@@ -2227,7 +2226,7 @@ def generate_unit_locations(
         How units are spread.
         "uniform" is units everywhere
         "multimodal" mimic the distribution of units 'by layer'  on the 'y' axis (dim=1)
-        Important note, when using multimodal in conjonction of minimum_distance not None, there is not garanty 
+        Important note, when using multimodal in conjonction of minimum_distance not None, there is not garanty
         of a true multimodal because units that do not respect the distance of move again and are most chance to be in between layers.
     num_modes : int, default 2
         In case of distribution="multimodal", this is the number of modes (layers)
@@ -2275,9 +2274,11 @@ def generate_unit_locations(
                 units_locations[:, 0][renew_inds] = rng.uniform(minimum_x, maximum_x, size=renew_inds.size)
                 if distribution == "uniform":
                     units_locations[:, 1][renew_inds] = rng.uniform(minimum_y, maximum_y, size=renew_inds.size)
-                    
+
                 elif distribution == "multimodal":
-                    units_locations[:, 1][renew_inds] =  _generate_multimodal(rng, renew_inds.size, num_modes, minimum_y, maximum_y)
+                    units_locations[:, 1][renew_inds] = _generate_multimodal(
+                        rng, renew_inds.size, num_modes, minimum_y, maximum_y
+                    )
                 units_locations[:, 2][renew_inds] = rng.uniform(minimum_z, maximum_z, size=renew_inds.size)
 
             else:

src/spikeinterface/generation/drifting_generator.py

@@ -150,19 +150,18 @@ def make_one_displacement_vector(
                 displacement_vector[ind0:ind1] = 0.5
             else:
                 displacement_vector[ind0:ind1] = -0.5
-    
+
     elif drift_mode == "random_walk":
         rg = np.random.RandomState(seed=seed)
         steps = rg.random_integers(low=0, high=1, size=num_samples)
-        steps = steps.astype('float64')
+        steps = steps.astype("float64")
         # 0 -> -1 and 1 -> 1
-        steps = steps * 2 -1
+        steps = steps * 2 - 1
         steps[:start_drift_index] = 0
         steps[end_drift_index:] = 0
-        displacement_vector = np.cumsum(steps, dtype='float64')
+        displacement_vector = np.cumsum(steps, dtype="float64")
         displacement_vector /= np.max(np.abs(displacement_vector)) * 2
 
-
     else:
         raise ValueError("drift_mode must be 'zigzag' or 'bump' or 'random_walk'")
 
@@ -276,9 +275,8 @@ def generate_displacement_vector(
                 factors = 1 - factors
             f = np.abs(non_rigid_gradient)
             displacement_unit_factor[:, m] = factors * (1 - f) + f
-    
-    displacement_vectors = np.concatenate(displacement_vectors, axis=2)
 
+    displacement_vectors = np.concatenate(displacement_vectors, axis=2)
 
     # unit_displacements is the sum of all discplacements (times, units, direction_x_y)
     unit_displacements = np.zeros((displacement_vectors.shape[0], num_units, 2))
@@ -296,7 +294,13 @@ def generate_displacement_vector(
                 "Please consider a smaller 'amplitude_factor' for each motion"
             )
 
-    return unit_displacements, displacement_vectors, displacement_unit_factor, displacement_sampling_frequency, displacements_steps
+    return (
+        unit_displacements,
+        displacement_vectors,
+        displacement_unit_factor,
+        displacement_sampling_frequency,
+        displacements_steps,
+    )
 
 
 def generate_drifting_recording(
@@ -417,9 +421,13 @@ def generate_drifting_recording(
         **generate_unit_locations_kwargs,
     )
 
-    unit_displacements, displacement_vectors, displacement_unit_factor, displacement_sampling_frequency, displacements_steps = (
-        generate_displacement_vector(duration, unit_locations[:, :2], seed=seed, **generate_displacement_vector_kwargs)
-    )
+    (
+        unit_displacements,
+        displacement_vectors,
+        displacement_unit_factor,
+        displacement_sampling_frequency,
+        displacements_steps,
+    ) = generate_displacement_vector(duration, unit_locations[:, :2], seed=seed, **generate_displacement_vector_kwargs)
 
     # unit_params need to be fixed before the displacement steps
     generate_templates_kwargs = generate_templates_kwargs.copy()

src/spikeinterface/generation/tests/test_drifing_generator.py

@@ -33,40 +33,48 @@ def test_generate_displacement_vector():
     unit_locations[:, 1] = np.linspace(-50, 50, 10)
 
     # one motion Y only
-    unit_displacements, displacement_vectors, displacement_unit_factor, displacement_sampling_frequency, displacements_steps = (
-        generate_displacement_vector(duration, unit_locations)
-    )
+    (
+        unit_displacements,
+        displacement_vectors,
+        displacement_unit_factor,
+        displacement_sampling_frequency,
+        displacements_steps,
+    ) = generate_displacement_vector(duration, unit_locations)
     assert unit_locations.shape[0] == unit_displacements.shape[1]
     assert unit_locations.shape[0] == displacement_unit_factor.shape[0]
     assert displacement_vectors.shape[2] == displacement_unit_factor.shape[1]
     assert displacement_vectors.shape[2] == 1
 
     # two motion X and Y
-    unit_displacements, displacement_vectors, displacement_unit_factor, displacement_sampling_frequency, displacements_steps = (
-        generate_displacement_vector(
-            duration,
-            unit_locations,
-            drift_start_um=[-5, 20.0],
-            drift_stop_um=[5, -20.0],
-            motion_list=[
-                dict(
-                    drift_mode="zigzag",
-                    amplitude_factor=0.7,
-                    non_rigid_gradient=0.4,
-                    t_start_drift=60.0,
-                    t_end_drift=None,
-                    period_s=200,
-                ),
-                dict(
-                    drift_mode="bump",
-                    amplitude_factor=0.3,
-                    non_rigid_gradient=0.4,
-                    t_start_drift=60.0,
-                    t_end_drift=None,
-                    bump_interval_s=(30, 90.0),
-                ),
-            ],
-        )
+    (
+        unit_displacements,
+        displacement_vectors,
+        displacement_unit_factor,
+        displacement_sampling_frequency,
+        displacements_steps,
+    ) = generate_displacement_vector(
+        duration,
+        unit_locations,
+        drift_start_um=[-5, 20.0],
+        drift_stop_um=[5, -20.0],
+        motion_list=[
+            dict(
+                drift_mode="zigzag",
+                amplitude_factor=0.7,
+                non_rigid_gradient=0.4,
+                t_start_drift=60.0,
+                t_end_drift=None,
+                period_s=200,
+            ),
+            dict(
+                drift_mode="bump",
+                amplitude_factor=0.3,
+                non_rigid_gradient=0.4,
+                t_start_drift=60.0,
+                t_end_drift=None,
+                bump_interval_s=(30, 90.0),
+            ),
+        ],
     )
     assert unit_locations.shape[0] == displacement_unit_factor.shape[0]
     assert displacement_vectors.shape[2] == displacement_unit_factor.shape[1]