[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/analyzer_extension_core.py

@@ -693,7 +693,6 @@ class ComputeNoiseLevels(AnalyzerExtension):
     need_job_kwargs = False
     need_backward_compatibility_on_load = True
 
-
     def __init__(self, sorting_analyzer):
         AnalyzerExtension.__init__(self, sorting_analyzer)
 

src/spikeinterface/core/job_tools.py

@@ -184,6 +184,7 @@ def ensure_n_jobs(recording, n_jobs=1):
 
     return n_jobs
 
+
 def chunk_duration_to_chunk_size(chunk_duration, recording):
     if isinstance(chunk_duration, float):
         chunk_size = int(chunk_duration * recording.get_sampling_frequency())
@@ -196,7 +197,7 @@ def chunk_duration_to_chunk_size(chunk_duration, recording):
             raise ValueError("chunk_duration must ends with s or ms")
         chunk_size = int(chunk_duration * recording.get_sampling_frequency())
     else:
-        raise ValueError("chunk_duration must be str or float")    
+        raise ValueError("chunk_duration must be str or float")
     return chunk_size
 
 

src/spikeinterface/core/recording_tools.py

@@ -514,15 +514,15 @@ def determine_cast_unsigned(recording, dtype):
     return cast_unsigned
 
 
-
-
-def get_random_recording_slices(recording,
-                                method="full_random",
-                                num_chunks_per_segment=20,
-                                chunk_duration="500ms",
-                                chunk_size=None,
-                                margin_frames=0,
-                                seed=None):
+def get_random_recording_slices(
+    recording,
+    method="full_random",
+    num_chunks_per_segment=20,
+    chunk_duration="500ms",
+    chunk_size=None,
+    margin_frames=0,
+    seed=None,
+):
     """
     Get random slice of a recording across segments.
 
@@ -593,19 +593,14 @@ def get_random_recording_slices(recording,
             ]
     else:
         raise ValueError(f"get_random_recording_slices : wrong method {method}")
-    
+
     return recording_slices
 
 
-def get_random_data_chunks(
-    recording,
-    return_scaled=False,
-    concatenated=True,
-    **random_slices_kwargs
-):
+def get_random_data_chunks(recording, return_scaled=False, concatenated=True, **random_slices_kwargs):
     """
     Extract random chunks across segments.
-    
+
     Internally, it uses `get_random_recording_slices()` and retrieves the traces chunk as a list
     or a concatenated unique array.
 
@@ -698,15 +693,14 @@ def get_closest_channels(recording, channel_ids=None, num_channels=None):
 
 def _noise_level_chunk(segment_index, start_frame, end_frame, worker_ctx):
     recording = worker_ctx["recording"]
-    
+
     one_chunk = recording.get_traces(
         start_frame=start_frame,
         end_frame=end_frame,
         segment_index=segment_index,
         return_scaled=worker_ctx["return_scaled"],
     )
 
-
     if worker_ctx["method"] == "mad":
         med = np.median(one_chunk, axis=0, keepdims=True)
         # hard-coded so that core doesn't depend on scipy
@@ -724,12 +718,13 @@ def _noise_level_chunk_init(recording, return_scaled, method):
     worker_ctx["method"] = method
     return worker_ctx
 
+
 def get_noise_levels(
     recording: "BaseRecording",
     return_scaled: bool = True,
     method: Literal["mad", "std"] = "mad",
     force_recompute: bool = False,
-    random_slices_kwargs : dict = {},
+    random_slices_kwargs: dict = {},
     **kwargs,
 ) -> np.ndarray:
     """
@@ -759,7 +754,7 @@ def get_noise_levels(
         function for more details.
 
     {}
-    
+
     Returns
     -------
     noise_levels : array
@@ -774,7 +769,7 @@ def get_noise_levels(
     if key in recording.get_property_keys() and not force_recompute:
         noise_levels = recording.get_property(key=key)
     else:
-        # This is to keep backward compatibility 
+        # This is to keep backward compatibility
         # lets keep for a while and remove this maybe in 0.103.0
         # chunk_size used to be in the signature and now is ambiguous
         random_slices_kwargs_, job_kwargs = split_job_kwargs(kwargs)
@@ -794,15 +789,22 @@ def get_noise_levels(
         recording_slices = get_random_recording_slices(recording, **random_slices_kwargs)
 
         noise_levels_chunks = []
+
         def append_noise_chunk(res):
             noise_levels_chunks.append(res)
 
         func = _noise_level_chunk
         init_func = _noise_level_chunk_init
         init_args = (recording, return_scaled, method)
         executor = ChunkRecordingExecutor(
-            recording, func, init_func, init_args, job_name="noise_level", verbose=False,
-            gather_func=append_noise_chunk, **job_kwargs
+            recording,
+            func,
+            init_func,
+            init_args,
+            job_name="noise_level",
+            verbose=False,
+            gather_func=append_noise_chunk,
+            **job_kwargs,
         )
         executor.run(all_chunks=recording_slices)
         noise_levels_chunks = np.stack(noise_levels_chunks)
@@ -813,6 +815,7 @@ def append_noise_chunk(res):
 
     return noise_levels
 
+
 get_noise_levels.__doc__ = get_noise_levels.__doc__.format(_shared_job_kwargs_doc)
 
 

src/spikeinterface/core/tests/test_analyzer_extension_core.py

@@ -259,7 +259,7 @@ def test_compute_several(create_cache_folder):
     # test_ComputeWaveforms(format="binary_folder", sparse=False, create_cache_folder=cache_folder)
     # test_ComputeWaveforms(format="zarr", sparse=True, create_cache_folder=cache_folder)
     # test_ComputeWaveforms(format="zarr", sparse=False, create_cache_folder=cache_folder)
-    #test_ComputeRandomSpikes(format="memory", sparse=True, create_cache_folder=cache_folder)
+    # test_ComputeRandomSpikes(format="memory", sparse=True, create_cache_folder=cache_folder)
     test_ComputeRandomSpikes(format="binary_folder", sparse=False, create_cache_folder=cache_folder)
     test_ComputeTemplates(format="memory", sparse=True, create_cache_folder=cache_folder)
     test_ComputeNoiseLevels(format="memory", sparse=False, create_cache_folder=cache_folder)

src/spikeinterface/core/tests/test_recording_tools.py

@@ -167,19 +167,18 @@ def test_write_memory_recording():
     for shm in shms:
         shm.unlink()
 
+
 def test_get_random_recording_slices():
     rec = generate_recording(num_channels=1, sampling_frequency=1000.0, durations=[10.0, 20.0])
-    rec_slices = get_random_recording_slices(rec,
-                                method="full_random",
-                                num_chunks_per_segment=20,
-                                chunk_duration="500ms",
-                                margin_frames=0,
-                                seed=0)
+    rec_slices = get_random_recording_slices(
+        rec, method="full_random", num_chunks_per_segment=20, chunk_duration="500ms", margin_frames=0, seed=0
+    )
     assert len(rec_slices) == 40
     for seg_ind, start, stop in rec_slices:
         assert stop - start == 500
         assert seg_ind in (0, 1)
 
+
 def test_get_random_data_chunks():
     rec = generate_recording(num_channels=1, sampling_frequency=1000.0, durations=[10.0, 20.0])
     chunks = get_random_data_chunks(rec, num_chunks_per_segment=50, chunk_size=500, seed=0)
@@ -216,7 +215,9 @@ def test_get_noise_levels():
 
     assert np.all(noise_levels_1 == noise_levels_2)
     assert np.allclose(get_noise_levels(recording, return_scaled=False, **job_kwargs), [std, std], rtol=1e-2, atol=1e-3)
-    assert np.allclose(get_noise_levels(recording, method="std", return_scaled=False, **job_kwargs), [std, std], rtol=1e-2, atol=1e-3)
+    assert np.allclose(
+        get_noise_levels(recording, method="std", return_scaled=False, **job_kwargs), [std, std], rtol=1e-2, atol=1e-3
+    )
 
 
 def test_get_noise_levels_output():
@@ -230,13 +231,21 @@ def test_get_noise_levels_output():
     traces = rng.normal(loc=10.0, scale=std, size=(num_samples, num_channels))
     recording = NumpyRecording(traces_list=traces, sampling_frequency=sampling_frequency)
 
-    std_estimated_with_mad = get_noise_levels(recording, method="mad", return_scaled=False,
-                                              random_slices_kwargs=dict(num_chunks_per_segment=40, chunk_size=1_000, seed=seed))
+    std_estimated_with_mad = get_noise_levels(
+        recording,
+        method="mad",
+        return_scaled=False,
+        random_slices_kwargs=dict(num_chunks_per_segment=40, chunk_size=1_000, seed=seed),
+    )
     print(std_estimated_with_mad)
     assert np.allclose(std_estimated_with_mad, [std, std], rtol=1e-2, atol=1e-3)
 
-    std_estimated_with_std = get_noise_levels(recording, method="std", return_scaled=False,
-                                              random_slices_kwargs=dict(num_chunks_per_segment=40, chunk_size=1_000, seed=seed))
+    std_estimated_with_std = get_noise_levels(
+        recording,
+        method="std",
+        return_scaled=False,
+        random_slices_kwargs=dict(num_chunks_per_segment=40, chunk_size=1_000, seed=seed),
+    )
     assert np.allclose(std_estimated_with_std, [std, std], rtol=1e-2, atol=1e-3)
 
 
@@ -358,8 +367,8 @@ def test_do_recording_attributes_match():
     # test_write_memory_recording()
 
     test_get_random_recording_slices()
-    # test_get_random_data_chunks()
+    # test_get_random_data_chunks()
     # test_get_closest_channels()
     # test_get_noise_levels()
-    # test_get_noise_levels_output()
+    # test_get_noise_levels_output()
     # test_order_channels_by_depth()

src/spikeinterface/preprocessing/tests/test_silence.py

@@ -48,5 +48,5 @@ def test_silence(create_cache_folder):
 
 
 if __name__ == "__main__":
-    cache_folder = Path(__file__).resolve().parents[4] / "cache_folder" 
+    cache_folder = Path(__file__).resolve().parents[4] / "cache_folder"
     test_silence(cache_folder)

src/spikeinterface/preprocessing/tests/test_whiten.py

@@ -49,5 +49,5 @@ def test_whiten(create_cache_folder):
 
 
 if __name__ == "__main__":
-    cache_folder = Path(__file__).resolve().parents[4] / "cache_folder" 
+    cache_folder = Path(__file__).resolve().parents[4] / "cache_folder"
     test_whiten(cache_folder)