Merge branch 'main' into doc-spacing

Author: zm711

doc/modules/postprocessing.rst

@@ -208,9 +208,11 @@ For dense waveforms, sparsity can also be passed as an argument.
 
 .. code-block:: python
 
-    pc = sorting_analyzer.compute(input="principal_components",
-                             n_components=3,
-                             mode="by_channel_local")
+    pc = sorting_analyzer.compute(
+        input="principal_components",
+        n_components=3,
+        mode="by_channel_local"
+    )
 
 For more information, see :py:func:`~spikeinterface.postprocessing.compute_principal_components`
 
@@ -243,9 +245,7 @@ each spike.
 
 .. code-block:: python
 
-    amplitudes = sorting_analyzer.compute(input="spike_amplitudes",
-                             peak_sign="neg",
-                             outputs="concatenated")
+    amplitudes = sorting_analyzer.compute(input="spike_amplitudes", peak_sign="neg")
 
 For more information, see :py:func:`~spikeinterface.postprocessing.compute_spike_amplitudes`
 
@@ -263,15 +263,17 @@ with center of mass (:code:`method="center_of_mass"` - fast, but less accurate),
 
 .. code-block:: python
 
-    spike_locations = sorting_analyzer.compute(input="spike_locations",
-                             ms_before=0.5,
-                             ms_after=0.5,
-                             spike_retriever_kwargs=dict(
-                                channel_from_template=True,
-                                radius_um=50,
-                                peak_sign="neg"
-                                              ),
-                             method="center_of_mass")
+    spike_locations = sorting_analyzer.compute(
+        input="spike_locations",
+        ms_before=0.5,
+        ms_after=0.5,
+        spike_retriever_kwargs=dict(
+            channel_from_template=True,
+            radius_um=50,
+            peak_sign="neg"
+        ),
+        method="center_of_mass"
+    )
 
 
 For more information, see :py:func:`~spikeinterface.postprocessing.compute_spike_locations`
@@ -329,6 +331,12 @@ Optionally, the following multi-channel metrics can be computed by setting:
     Visualization of template metrics. Image from `ecephys_spike_sorting <https://github.com/AllenInstitute/ecephys_spike_sorting/tree/v0.2/ecephys_spike_sorting/modules/mean_waveforms>`_
     from the Allen Institute.
 
+
+.. code-block:: python
+
+    tm = sorting_analyzer.compute(input="template_metrics", include_multi_channel_metrics=True)
+
+
 For more information, see :py:func:`~spikeinterface.postprocessing.compute_template_metrics`
 
 
@@ -340,10 +348,12 @@ with shape (num_units, num_units, num_bins) with all correlograms for each pair
 
 .. code-block:: python
 
-    ccg = sorting_analyzer.compute(input="correlograms",
-                            window_ms=50.0,
-                            bin_ms=1.0,
-                            method="auto")
+    ccg = sorting_analyzer.compute(
+        input="correlograms",
+        window_ms=50.0,
+        bin_ms=1.0,
+        method="auto"
+    )
 
 For more information, see :py:func:`~spikeinterface.postprocessing.compute_correlograms`
 
@@ -357,10 +367,12 @@ This extension computes the histograms of inter-spike-intervals. The computed ou
 
 .. code-block:: python
 
-   isi =  sorting_analyer.compute(input="isi_histograms"
-                            window_ms=50.0,
-                            bin_ms=1.0,
-                            method="auto")
+    isi =  sorting_analyer.compute(
+        input="isi_histograms"
+        window_ms=50.0,
+        bin_ms=1.0,
+        method="auto"
+    )
 
 For more information, see :py:func:`~spikeinterface.postprocessing.compute_isi_histograms`
 

doc/modules/qualitymetrics.rst

@@ -57,7 +57,7 @@ This code snippet shows how to compute quality metrics (with or without principa
 
     # with PCs (depends on "pca" in addition to the above metrics)
 
-    qm_ext = sorting_analyzer.compute(input={"pca": dict(n_components=5, mode="by_channel_local"),
+    qm_ext = sorting_analyzer.compute(input={"principal_components": dict(n_components=5, mode="by_channel_local"),
                                     "quality_metrics": dict(skip_pc_metrics=False)})
      metrics = qm_ext.get_data()
      assert 'isolation_distance' in metrics.columns

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "spikeinterface"
-version = "0.101.0"
+version = "0.101.1"
 authors = [
   { name="Alessio Buccino", email="alessiop.buccino@gmail.com" },
   { name="Samuel Garcia", email="sam.garcia.die@gmail.com" },
@@ -125,16 +125,16 @@ test_core = [
 
     # for github test : probeinterface and neo from master
     # for release we need pypi, so this need to be commented
-    # "probeinterface @ git+https://github.com/SpikeInterface/probeinterface.git",
-    # "neo @ git+https://github.com/NeuralEnsemble/python-neo.git",
+    "probeinterface @ git+https://github.com/SpikeInterface/probeinterface.git",
+    "neo @ git+https://github.com/NeuralEnsemble/python-neo.git",
 ]
 
 test_extractors = [
     # Functions to download data in neo test suite
     "pooch>=1.8.2",
     "datalad>=1.0.2",
-    # "probeinterface @ git+https://github.com/SpikeInterface/probeinterface.git",
-    # "neo @ git+https://github.com/NeuralEnsemble/python-neo.git",
+    "probeinterface @ git+https://github.com/SpikeInterface/probeinterface.git",
+    "neo @ git+https://github.com/NeuralEnsemble/python-neo.git",
 ]
 
 test_preprocessing = [
@@ -175,8 +175,8 @@ test = [
 
     # for github test : probeinterface and neo from master
     # for release we need pypi, so this need to be commented
-    # "probeinterface @ git+https://github.com/SpikeInterface/probeinterface.git",
-    # "neo @ git+https://github.com/NeuralEnsemble/python-neo.git",
+    "probeinterface @ git+https://github.com/SpikeInterface/probeinterface.git",
+    "neo @ git+https://github.com/NeuralEnsemble/python-neo.git",
 ]
 
 docs = [
@@ -199,8 +199,8 @@ docs = [
     "datalad>=1.0.2",
 
     # for release we need pypi, so this needs to be commented
-    # "probeinterface @ git+https://github.com/SpikeInterface/probeinterface.git",  # We always build from the latest version
-    # "neo @ git+https://github.com/NeuralEnsemble/python-neo.git",  # We always build from the latest version
+    "probeinterface @ git+https://github.com/SpikeInterface/probeinterface.git",  # We always build from the latest version
+    "neo @ git+https://github.com/NeuralEnsemble/python-neo.git",  # We always build from the latest version
 
 ]
 

src/spikeinterface/__init__.py

@@ -30,5 +30,5 @@
 # This flag must be set to False for release
 # This avoids using versioning that contains ".dev0" (and this is a better choice)
 # This is mainly useful when using run_sorter in a container and spikeinterface install
-# DEV_MODE = True
-DEV_MODE = False
+DEV_MODE = True
+# DEV_MODE = False

src/spikeinterface/postprocessing/spike_amplitudes.py

@@ -44,8 +44,8 @@ class ComputeSpikeAmplitudes(AnalyzerExtension):
         The localization method to use
     method_kwargs : dict, default: dict()
         Other kwargs depending on the method.
-    outputs : "concatenated" | "by_unit", default: "concatenated"
-        The output format
+    outputs : "numpy" | "by_unit", default: "numpy"
+        The output format, either concatenated as numpy array or separated on a per unit basis
 
     Returns
     -------
@@ -148,7 +148,7 @@ def _get_data(self, outputs="numpy"):
                     amplitudes_by_units[segment_index][unit_id] = all_amplitudes[inds]
             return amplitudes_by_units
         else:
-            raise ValueError(f"Wrong .get_data(outputs={outputs})")
+            raise ValueError(f"Wrong .get_data(outputs={outputs}); possibilities are `numpy` or `by_unit`")
 
 
 register_result_extension(ComputeSpikeAmplitudes)

src/spikeinterface/sorters/external/herdingspikes.py

@@ -19,6 +19,7 @@ class HerdingspikesSorter(BaseSorter):
         "chunk_size": None,
         "rescale": True,
         "rescale_value": -1280.0,
+        "lowpass": True,
         "common_reference": "median",
         "spike_duration": 1.0,
         "amp_avg_duration": 0.4,
@@ -53,6 +54,7 @@ class HerdingspikesSorter(BaseSorter):
         "out_file": "Path and filename to store detection and clustering results. (`str`, `HS2_detected`)",
         "verbose": "Print progress information. (`bool`, `True`)",
         "chunk_size": " Number of samples per chunk during detection. If `None`, a suitable value will be estimated. (`int`, `None`)",
+        "lowpass": "Enable internal low-pass filtering (simple two-step average). (`bool`, `True`)",
         "common_reference": "Method for common reference filtering, can be `average` or `median` (`str`, `median`)",
         "rescale": "Automatically re-scale the data.  (`bool`, `True`)",
         "rescale_value": "Factor by which data is re-scaled. (`float`, `-1280.0`)",
@@ -122,20 +124,21 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
 
         hs_version = version.parse(hs.__version__)
 
-        if hs_version >= version.parse("0.4.001"):
+        if hs_version >= version.parse("0.4.1"):
             lightning_api = True
         else:
             lightning_api = False
 
         assert (
             lightning_api
-        ), "HerdingSpikes version <0.4.001 is no longer supported. run:\n>>> pip install --upgrade herdingspikes"
+        ), "HerdingSpikes version <0.4.1 is no longer supported. To upgrade, run:\n>>> pip install --upgrade herdingspikes"
 
         recording = cls.load_recording_from_folder(sorter_output_folder.parent, with_warnings=False)
 
         sorted_file = str(sorter_output_folder / "HS2_sorted.hdf5")
         params["out_file"] = str(sorter_output_folder / "HS2_detected")
         p = params
+        p.update({"verbose": verbose})
 
         det = hs.HSDetectionLightning(recording, p)
         det.DetectFromRaw()

src/spikeinterface/sorters/external/kilosortbase.py

@@ -146,7 +146,7 @@ def _setup_recording(cls, recording, sorter_output_folder, params, verbose):
                 padding_start = 0
                 padding_end = pad
                 padded_recording = TracePaddedRecording(
-                    parent_recording=recording,
+                    recording=recording,
                     padding_start=padding_start,
                     padding_end=padding_end,
                 )

src/spikeinterface/sortingcomponents/tools.py

@@ -70,18 +70,18 @@ def extract_waveform_at_max_channel(rec, peaks, ms_before=0.5, ms_after=1.5, **j
 
 
 def get_prototype_spike(recording, peaks, ms_before=0.5, ms_after=0.5, nb_peaks=1000, **job_kwargs):
+    from spikeinterface.sortingcomponents.peak_selection import select_peaks
+
     nbefore = int(ms_before * recording.sampling_frequency / 1000.0)
     nafter = int(ms_after * recording.sampling_frequency / 1000.0)
 
-    from spikeinterface.sortingcomponents.peak_selection import select_peaks
-
     few_peaks = select_peaks(peaks, recording=recording, method="uniform", n_peaks=nb_peaks, margin=(nbefore, nafter))
 
     waveforms = extract_waveform_at_max_channel(
         recording, few_peaks, ms_before=ms_before, ms_after=ms_after, **job_kwargs
     )
     with np.errstate(divide="ignore", invalid="ignore"):
-        prototype = np.median(waveforms[:, :, 0] / (np.abs(waveforms[:, nbefore, 0][:, np.newaxis])), axis=0)
+        prototype = np.nanmedian(waveforms[:, :, 0] / (np.abs(waveforms[:, nbefore, 0][:, np.newaxis])), axis=0)
     return prototype