Remove deprecated spike sorting loader functions

Author: k1o0

brainbox/examples/raster_depths.py

@@ -3,7 +3,6 @@
 import gc
 import logging
 import re
-import os
 from pathlib import Path
 from collections import defaultdict
 
@@ -410,191 +409,6 @@ def load_channel_locations(eid, probe=None, one=None, aligned=False, brain_atlas
     return channels
 
 
-def load_spike_sorting_fast(eid, one=None, probe=None, dataset_types=None, spike_sorter=None, revision=None,
-                            brain_regions=None, nested=True, collection=None, return_collection=False):
-    """
-    From an eid, loads spikes and clusters for all probes
-    The following set of dataset types are loaded:
-        'clusters.channels',
-        'clusters.depths',
-        'clusters.metrics',
-        'spikes.clusters',
-        'spikes.times',
-        'probes.description'
-    :param eid: experiment UUID or pathlib.Path of the local session
-    :param one: an instance of OneAlyx
-    :param probe: name of probe to load in, if not given all probes for session will be loaded
-    :param dataset_types: additional spikes/clusters objects to add to the standard default list
-    :param spike_sorter: name of the spike sorting you want to load (None for default)
-    :param collection: name of the spike sorting collection to load - exclusive with spike sorter name ex: "alf/probe00"
-    :param brain_regions: iblatlas.regions.BrainRegions object - will label acronyms if provided
-    :param nested: if a single probe is required, do not output a dictionary with the probe name as key
-    :param return_collection: (False) if True, will return the collection used to load
-    :return: spikes, clusters, channels (dict of bunch, 1 bunch per probe)
-    """
-    _logger.warning('Deprecation warning: brainbox.io.one.load_spike_sorting_fast will be removed in future versions.'
-                    'Use brainbox.io.one.SpikeSortingLoader instead')
-    if collection is None:
-        collection = _collection_filter_from_args(probe, spike_sorter)
-    _logger.debug(f"load spike sorting with collection filter {collection}")
-    kwargs = dict(eid=eid, one=one, collection=collection, revision=revision, dataset_types=dataset_types,
-                  brain_regions=brain_regions)
-    spikes, clusters, channels = _load_spike_sorting(**kwargs, return_channels=True)
-    clusters = merge_clusters_channels(clusters, channels, keys_to_add_extra=None)
-    if nested is False and len(spikes.keys()) == 1:
-        k = list(spikes.keys())[0]
-        channels = channels[k]
-        clusters = clusters[k]
-        spikes = spikes[k]
-    if return_collection:
-        return spikes, clusters, channels, collection
-    else:
-        return spikes, clusters, channels
-
-
-def load_spike_sorting(eid, one=None, probe=None, dataset_types=None, spike_sorter=None, revision=None,
-                       brain_regions=None, return_collection=False):
-    """
-    From an eid, loads spikes and clusters for all probes
-    The following set of dataset types are loaded:
-        'clusters.channels',
-        'clusters.depths',
-        'clusters.metrics',
-        'spikes.clusters',
-        'spikes.times',
-        'probes.description'
-    :param eid: experiment UUID or pathlib.Path of the local session
-    :param one: an instance of OneAlyx
-    :param probe: name of probe to load in, if not given all probes for session will be loaded
-    :param dataset_types: additional spikes/clusters objects to add to the standard default list
-    :param spike_sorter: name of the spike sorting you want to load (None for default)
-    :param brain_regions: iblatlas.regions.BrainRegions object - will label acronyms if provided
-    :param return_collection:(bool - False) if True, returns the collection for loading the data
-    :return: spikes, clusters (dict of bunch, 1 bunch per probe)
-    """
-    _logger.warning('Deprecation warning: brainbox.io.one.load_spike_sorting will be removed in future versions.'
-                    'Use brainbox.io.one.SpikeSortingLoader instead')
-    collection = _collection_filter_from_args(probe, spike_sorter)
-    _logger.debug(f"load spike sorting with collection filter {collection}")
-    spikes, clusters = _load_spike_sorting(eid=eid, one=one, collection=collection, revision=revision,
-                                           return_channels=False, dataset_types=dataset_types,
-                                           brain_regions=brain_regions)
-    if return_collection:
-        return spikes, clusters, collection
-    else:
-        return spikes, clusters
-
-
-def load_spike_sorting_with_channel(eid, one=None, probe=None, aligned=False, dataset_types=None,
-                                    spike_sorter=None, brain_atlas=None, nested=True, return_collection=False):
-    """
-    For a given eid, get spikes, clusters and channels information, and merges clusters
-    and channels information before returning all three variables.
-
-    Parameters
-    ----------
-    eid : [str, UUID, Path, dict]
-        Experiment session identifier; may be a UUID, URL, experiment reference string
-        details dict or Path
-    one : one.api.OneAlyx
-        An instance of ONE (shouldn't be in 'local' mode)
-    probe : [str, list of str]
-        The probe label(s), e.g. 'probe01'
-    aligned : bool
-        Whether to get the latest user aligned channel when not resolved or use histology track
-    dataset_types : list of str
-        Optional additional spikes/clusters objects to add to the standard default list
-    spike_sorter : str
-        Name of the spike sorting you want to load (None for default which is pykilosort if it's
-        available otherwise the default MATLAB kilosort)
-    brain_atlas : iblatlas.atlas.BrainAtlas
-        Brain atlas object (default: Allen atlas)
-    return_collection: bool
-        Returns an extra argument with the collection chosen
-
-    Returns
-    -------
-    spikes : dict of one.alf.io.AlfBunch
-        A dict with probe labels as keys, contains bunch(es) of spike data for the provided
-        session and spike sorter, with keys ('clusters', 'times')
-    clusters : dict of one.alf.io.AlfBunch
-        A dict with probe labels as keys, contains bunch(es) of cluster data, with keys
-        ('channels', 'depths', 'metrics')
-    channels : dict of one.alf.io.AlfBunch
-        A dict with probe labels as keys, contains channel locations with keys ('acronym',
-        'atlas_id', 'x', 'y', 'z').  Atlas IDs non-lateralized.
-    """
-    # --- Get spikes and clusters data
-    _logger.warning('Deprecation warning: brainbox.io.one.load_spike_sorting will be removed in future versions.'
-                    'Use brainbox.io.one.SpikeSortingLoader instead')
-    one = one or ONE()
-    brain_atlas = brain_atlas or AllenAtlas()
-    spikes, clusters, collection = load_spike_sorting(
-        eid, one=one, probe=probe, dataset_types=dataset_types, spike_sorter=spike_sorter, return_collection=True)
-    # -- Get brain regions and assign to clusters
-    channels = load_channel_locations(eid, one=one, probe=probe, aligned=aligned,
-                                      brain_atlas=brain_atlas)
-    clusters = merge_clusters_channels(clusters, channels, keys_to_add_extra=None)
-    if nested is False and len(spikes.keys()) == 1:
-        k = list(spikes.keys())[0]
-        channels = channels[k]
-        clusters = clusters[k]
-        spikes = spikes[k]
-    if return_collection:
-        return spikes, clusters, channels, collection
-    else:
-        return spikes, clusters, channels
-
-
-def load_ephys_session(eid, one=None):
-    """
-    From an eid, hits the Alyx database and downloads a standard default set of dataset types
-    From a local session Path (pathlib.Path), loads a standard default set of dataset types
-     to perform analysis:
-        'clusters.channels',
-        'clusters.depths',
-        'clusters.metrics',
-        'spikes.clusters',
-        'spikes.times',
-        'probes.description'
-
-    Parameters
-    ----------
-    eid : [str, UUID, Path, dict]
-        Experiment session identifier; may be a UUID, URL, experiment reference string
-        details dict or Path
-    one : oneibl.one.OneAlyx, optional
-        ONE object to use for loading. Will generate internal one if not used, by default None
-
-    Returns
-    -------
-    spikes : dict of one.alf.io.AlfBunch
-        A dict with probe labels as keys, contains bunch(es) of spike data for the provided
-        session and spike sorter, with keys ('clusters', 'times')
-    clusters : dict of one.alf.io.AlfBunch
-        A dict with probe labels as keys, contains bunch(es) of cluster data, with keys
-        ('channels', 'depths', 'metrics')
-    trials : one.alf.io.AlfBunch of numpy.ndarray
-        The session trials data
-    """
-    assert one
-    spikes, clusters = load_spike_sorting(eid, one=one)
-    trials = one.load_object(eid, 'trials')
-    return spikes, clusters, trials
-
-
-def _remove_old_clusters(session_path, probe):
-    # gets clusters and spikes from a local session folder
-    probe_path = session_path.joinpath('alf', probe)
-
-    # look for clusters.metrics.csv file, if it exists delete as we now have .pqt file instead
-    cluster_file = probe_path.joinpath('clusters.metrics.csv')
-
-    if cluster_file.exists():
-        os.remove(cluster_file)
-        _logger.info('Deleting old clusters.metrics.csv file')
-
-
 def merge_clusters_channels(dic_clus, channels, keys_to_add_extra=None):
     """
     Takes (default and any extra) values in given keys from channels and assign them to clusters.

brainbox/io/one.py

@@ -1,70 +1,8 @@
-import json
-from pathlib import Path
 import unittest
-import tempfile
-import shutil
 
 import numpy as np
-import numpy.testing
 
 from brainbox.io import one as bbone
-from one.api import ONE
-from one.alf.cache import make_parquet_db
-
-
-class TestIO_ALF(unittest.TestCase):
-
-    def setUp(self) -> None:
-        """
-        Creates a mock ephys alf data folder with minimal spikes info for loading
-        :return:
-        """
-        self.tmpdir = Path(tempfile.gettempdir()) / 'test_bbio'
-        self.tmpdir.mkdir(exist_ok=True)
-        self.one = ONE(mode='local', cache_dir=self.tmpdir)
-        self.alf_path = self.tmpdir.joinpath(
-            'lab', 'Subjects', 'subject', '2019-08-12', '001', 'alf'
-        )
-        self.session_path = self.alf_path.parent
-        self.probes = ['probe00', 'probe01']
-        nspi = [10000, 10001]
-        nclusters = [420, 421]
-        nch = [64, 62]
-        probe_description = []
-        for i, prb in enumerate(self.probes):
-            prb_path = self.alf_path.joinpath(prb)
-            prb_path.mkdir(exist_ok=True, parents=True)
-            np.save(prb_path.joinpath('clusters.channels.npy'),
-                    np.random.randint(0, nch[i], nclusters[i]))
-            np.save(prb_path.joinpath('spikes.depths.npy'),
-                    np.random.rand(nspi[i]) * 3200)
-            np.save(prb_path.joinpath('spikes.clusters.npy'),
-                    np.random.randint(0, nclusters[i], nspi[i]))
-            np.save(prb_path.joinpath('spikes.times.npy'),
-                    np.sort(np.random.random(nspi[i]) * 1200))
-
-            probe_description.append({'label': prb,
-                                      'model': '3B1',
-                                      'serial': int(456248),
-                                      'raw_file_name': 'gnagnagnaga',
-                                      })
-        # create session level
-        with open(self.alf_path.joinpath('probes.description.json'), 'w+') as fid:
-            fid.write(json.dumps(probe_description))
-        np.save(self.alf_path.joinpath('trials.gnagnag.npy'), np.random.rand(50))
-        # Add some fake records to the cache
-        if not self.one.search(subject='subject', date='2019-08-12', number='001'):
-            make_parquet_db(self.tmpdir)
-            self.one.load_cache(cache_dir=self.tmpdir)
-
-    def test_load_ephys(self):
-        # straight test
-        spikes, clusters, trials = bbone.load_ephys_session(self.session_path, one=self.one)
-        self.assertTrue(set(spikes.keys()) == set(self.probes))
-        self.assertTrue(set(clusters.keys()) == set(self.probes))
-
-    def tearDown(self) -> None:
-        shutil.rmtree(self.tmpdir)
 
 
 class TestIO_ONE(unittest.TestCase):