UnitMatchPy 2.1__tar.gz → 2.4__tar.gz

UnitMatchPy-2.4/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.1
+Name: UnitMatchPy
+Version: 2.4
+Author: Enny van Beest, Celian Bimbard and Sam Dodgson
+Author-email: e.beest@ucl.ac.uk
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Unit Match - Python
+
+## Run UMPy
+
+To run UMPy standard spike sorting data is needed; channel positions and 2 extracted raw waveforms for each unit. This can be calculated externally [BombCell](https://github.com/Julie-Fabre/bombcell) or using *extract_raw_demo.ipynb* to extract these waveforms from compressed data (.cbin and .ch) or raw data. There is also a [Spike Interface](https://spikeinterface.readthedocs.io/en/latest/) integrated notebook *UMPy_spike_interface_demo.ipynb* which uses spike interface to get this data.
+Be careful not to mix and match the different ways of extracting raw waveforms, as there are difference between the methods.
+
+There are to example notebooks for running UMPy *UMPy_example.ipynb* and *UMPy_example_detailed.ipynb*. These notebooks will guide you through running Unit Match all you need to supply is paths to the data. *UMPy_example.ipynb* is recommended to use first as it is simpler, however *UMPy_example_detailed.ipynb* may be useful in unique cases as it is more modular.
+
+The GUI is a optional step to curated and investigate the information Unit Match has calculated; for efficient usage of the GUI please look at *GUI_Reference_Guide.md* in the Demo Notebooks folder.
+
+## Dependencies
+
+This version relies on many core python packages: [numpy](https://numpy.org/), [scipy](https://scipy.org/), [JobLib](https://joblib.readthedocs.io/en/stable/), [pandas](https://pandas.pydata.org/), [tkinter](https://docs.python.org/3/library/tkinter.html) and [matplotlib](https://matplotlib.org/). All of these libaries come with a [Anaconda](https://www.anaconda.com/download/) version of python. 
+For extracting raw data, the library [mtscomp](https://github.com/int-brain-lab/mtscomp) is needed, and can be installed by `pip install mtscomp`.
+
+
+## Installation 
+
+After creating an python environment
+
+```
+conda create --name UnitMatch python 
+conda activate UnitMatch
+```
+
+You can install UnitMatchPy with pip. It will automatically install all the dependencies.
+
+```
+pip install UnitMatchPy
+```

UnitMatchPy-2.4/README.md

@@ -0,0 +1,31 @@
+# Unit Match - Python
+
+## Run UMPy
+
+To run UMPy standard spike sorting data is needed; channel positions and 2 extracted raw waveforms for each unit. This can be calculated externally [BombCell](https://github.com/Julie-Fabre/bombcell) or using *extract_raw_demo.ipynb* to extract these waveforms from compressed data (.cbin and .ch) or raw data. There is also a [Spike Interface](https://spikeinterface.readthedocs.io/en/latest/) integrated notebook *UMPy_spike_interface_demo.ipynb* which uses spike interface to get this data.
+Be careful not to mix and match the different ways of extracting raw waveforms, as there are difference between the methods.
+
+There are to example notebooks for running UMPy *UMPy_example.ipynb* and *UMPy_example_detailed.ipynb*. These notebooks will guide you through running Unit Match all you need to supply is paths to the data. *UMPy_example.ipynb* is recommended to use first as it is simpler, however *UMPy_example_detailed.ipynb* may be useful in unique cases as it is more modular.
+
+The GUI is a optional step to curated and investigate the information Unit Match has calculated; for efficient usage of the GUI please look at *GUI_Reference_Guide.md* in the Demo Notebooks folder.
+
+## Dependencies
+
+This version relies on many core python packages: [numpy](https://numpy.org/), [scipy](https://scipy.org/), [JobLib](https://joblib.readthedocs.io/en/stable/), [pandas](https://pandas.pydata.org/), [tkinter](https://docs.python.org/3/library/tkinter.html) and [matplotlib](https://matplotlib.org/). All of these libaries come with a [Anaconda](https://www.anaconda.com/download/) version of python. 
+For extracting raw data, the library [mtscomp](https://github.com/int-brain-lab/mtscomp) is needed, and can be installed by `pip install mtscomp`.
+
+
+## Installation 
+
+After creating an python environment
+
+```
+conda create --name UnitMatch python 
+conda activate UnitMatch
+```
+
+You can install UnitMatchPy with pip. It will automatically install all the dependencies.
+
+```
+pip install UnitMatchPy
+```

{UnitMatchPy-2.1 → UnitMatchPy-2.4}/UnitMatchPy/GUI.py

@@ -55,14 +55,17 @@ def run_GUI():
     not_match = []
     root = Tk()
     # downloaded theme from https://sourceforge.net/projects/tcl-awthemes/
-    theme_path = os.path.join(os.path.dirname(os.path.abspath(__file__)) , r'TkinterTheme\awthemes-10.4.0')
+    theme_path_rel = os.path.normpath(r'TkinterTheme\awthemes-10.4.0')
+    theme_path = os.path.join(os.path.dirname(os.path.abspath(__file__)) , theme_path_rel)
+
     root.tk.call('lappend', 'auto_path', theme_path)
     root.tk.call('package', 'require', 'awdark')
     s = ttk.Style(root)
     s.theme_use('awdark')
     root.title('UMPy - Manual Curation')
     #root.geometry('800x800')
-    root.iconbitmap(os.path.join(os.path.dirname(os.path.abspath(__file__)) , r'UM Logo.ico'))
+    icon = PhotoImage(file = os.path.join(os.path.dirname(os.path.abspath(__file__)) , 'GUI_icon.png'))
+    root.iconphoto(False, icon)
     background = ttk.Frame(root)
     background.place(x=0, y=0, relwidth=1.0, relheight=1.0)
 
@@ -909,7 +912,7 @@ def add_original_ID(UnitA, UnitB):
     if original_id_label.winfo_exists():
         original_id_label.destroy()
 
-    original_id_label = ttk.Label(root, text = f'The Original Unit IDs are:\nUnit A: {int(clus_info["original_id"][UnitA].squeeze())}   Unit B: {int(clus_info["original_id"][UnitB].squeeze())}', borderwidth = 2 , relief= 'groove')
+    original_id_label = ttk.Label(root, text = f'The Original Unit IDs are:\nUnit A: {int(clus_info["original_ids"][UnitA].squeeze())}   Unit B: {int(clus_info["original_ids"][UnitB].squeeze())}', borderwidth = 2 , relief= 'groove')
     original_id_label.grid( row = 0, column = 2, ipadx = 5, ipady = 5)
 
 

{UnitMatchPy-2.1 → UnitMatchPy-2.4}/UnitMatchPy/Overlord.py

@@ -124,7 +124,6 @@ def extract_metric_scores(extracted_wave_properties, session_switch, within_sess
     thrs_opt = mf.get_threshold(total_score, within_session, euclid_dist, param, is_first_pass = False)
     param['n_expected_matches'] = np.sum( (total_score > thrs_opt).astype(int))
     prior_match = 1 - ( param['n_expected_matches'] / len(include_these_pairs))
-
     thrs_opt = np.quantile(total_score[include_these_pairs_idx.astype(bool)], prior_match)
     candidate_pairs = total_score > thrs_opt
 

{UnitMatchPy-2.1 → UnitMatchPy-2.4}/UnitMatchPy/Save_utils.py

@@ -5,7 +5,7 @@ import numpy as np
 
 def make_match_table(scores_to_include, matches, output_prob, total_score, output_threshold, clus_info, param, UIDs = None, matches_curated = None):
     """
-    Creates the match table showing information for every pair of units
+    Creates the match table showing information for every pair of units.
 
     Parameters
     ----------
@@ -46,8 +46,8 @@ def make_match_table(scores_to_include, matches, output_prob, total_score, outpu
     unit_a_list = xx.reshape(n_units*n_units)
     unit_b_list = yy.reshape(n_units*n_units)
 
-    sessions_ids = clus_info['sessions_ids']
-    xx, yy = np.meshgrid(sessions_ids, sessions_ids)
+    session_id = clus_info['session_id']
+    xx, yy = np.meshgrid(session_id, session_id)
     unit_a_session_list = xx.reshape(n_units*n_units) + 1 # Add one here so it counts from one not 0
     unit_b_session_list = yy.reshape(n_units*n_units) + 1
 
@@ -442,10 +442,10 @@ def save_prob_for_phy(probability, param, clus_info):
         session_output = probability[session_switch[sid]:session_switch[sid+1], session_switch[sid]:session_switch[sid+1]]
         #If Only good units where used add values know to a matrix of NaNs 
         if session_switch[sid+1] - session_switch[sid] != n_units_per_session[sid]:
-            all_good_units = clus_info['GoodUnits'][sid].squeeze().astype(int)
-            for id, gid in enumerate(clus_info['GoodUnits'][sid].astype(int)):
+            all_good_units = clus_info['good_units'][sid].squeeze().astype(int)
+            for id, gid in enumerate(clus_info['good_units'][sid].astype(int)):
                 matrix_prob[gid, all_good_units] = session_output[id,:]
         else:
             matrix_prob = session_output
 
-        np.save(save_file_tmp, matrix_prob)
+        np.save(save_file_tmp, matrix_prob)

{UnitMatchPy-2.1 → UnitMatchPy-2.4}/UnitMatchPy/assign_unique_id.py

@@ -42,7 +42,7 @@ def assign_unique_id(output_prob_array, param, clus_info):
     List
         A list of arrays which gives each unit its group ID for each case
     """
-    all_cluster_ids = clus_info['original_id'] # each units has unique ID
+    all_cluster_ids = clus_info['original_ids'] # each units has unique ID
 
     #create arrays for the unique ids
     unique_id_liberal = np.arange(all_cluster_ids.shape[0])

{UnitMatchPy-2.1 → UnitMatchPy-2.4}/UnitMatchPy/default_params.py

@@ -23,8 +23,7 @@ def get_default_param(param = None):
             'stepsz' : 0.01, # size of of a step in probability distributions
             'smooth_prob' : 9, # probability smoothing size
             'min_angle_dist' : 0.1, # smallest distance for and angle to be consider
-            'no_shanks' : 4,  # No. probe shanks -default neuropixels 2
-            'shank_dist' : 175, # distance between shanks
+            'min_new_shank_distance' : 100, #The smallest distance which separates 2 shanks
             'units_per_shank_thrs' : 15, # threshold for doing per shank drift correction
             'match_threshold' : 0.5 # probability threshold to consider as a match
         }

{UnitMatchPy-2.1 → UnitMatchPy-2.4}/UnitMatchPy/metric_functions.py

@@ -506,7 +506,6 @@ def drift_correction_basic(candidate_pairs, session_switch, avg_centroid, avg_wa
 
     drift = np.nanmedian( np.nanmean( avg_centroid[:, best_pairs[idx,0].squeeze(),:], axis = 2) - np.nanmean( avg_centroid[:,best_pairs[idx,1].squeeze(),:], axis = 2), axis = 1)
 
-
     ##need to add the drift to the location
     avg_waveform_per_tp[0,session_switch[1]:,:,:] += drift[0]
     avg_waveform_per_tp[1,session_switch[1]:,:,:] += drift[1]
@@ -547,7 +546,7 @@ def apply_drift_correction_basic(pairs, sid, session_switch, avg_centroid, avg_w
     ##need to add the drift to the location
     avg_waveform_per_tp[0,session_switch[sid+1]:session_switch[sid+2],:,:] += drift[0]
     avg_waveform_per_tp[1,session_switch[sid+1]:session_switch[sid+2],:,:] += drift[1]
-    avg_waveform_per_tp[2,session_switch[sid+1]:session_switch[sid]+2,:,:] += drift[2]
+    avg_waveform_per_tp[2,session_switch[sid+1]:session_switch[sid+2],:,:] += drift[2]
 
     avg_centroid[0,session_switch[sid+1]:session_switch[sid+2],:] += drift[0]
     avg_centroid[1,session_switch[sid+1]:session_switch[sid+2],:] += drift[1]
@@ -555,7 +554,7 @@ def apply_drift_correction_basic(pairs, sid, session_switch, avg_centroid, avg_w
 
     return drift, avg_waveform_per_tp, avg_centroid
 
-def appply_drift_correction_per_shank(pairs, sid, session_switch, avg_centroid, avg_waveform_per_tp, param):
+def apply_drift_correction_per_shank(pairs, sid, session_switch, avg_centroid, avg_waveform_per_tp, param):
     """
     This is the same as "basic" drift correction, however treats each shank separately, if there is enough units per shank
 
@@ -587,18 +586,23 @@ def appply_drift_correction_per_shank(pairs, sid, session_switch, avg_centroid,
 
     max_dist = 0
     min_dist = 0
-    drift_per_shank = np.zeros([4,3])
+    drift_per_shank = np.zeros([n_shanks,3])
 
     for i in range(n_shanks):
-        max_dist += shank_dist
+        max_dist += shank_dist #beginning of loop shift maximum distance
 
-        #test to see if a centroid is within the area of that shank
+        #get which shank each unit is on
         correct_shank_a = np.logical_and(centroid_a[1,:] < max_dist,  centroid_a[1,:] > min_dist)
         correct_shank_b = np.logical_and(centroid_b[1,:] < max_dist,  centroid_b[1,:] > min_dist)
 
         if np.all(correct_shank_a == correct_shank_b) != True:
             print(f'These pairs may be bad {np.argwhere(correct_shank_a != correct_shank_b)}')
+            #delete pairs which are on different shanks ##sam's fix
+                bad_idxs = np.argwhere(correct_shank_a != correct_shank_b)
+                correct_shank_a = np.delete(correct_shank_a, bad_idxs)
+                correct_shank_b = np.delete(correct_shank_b, bad_idxs)
 
+            
         drifts = centroid_a[:,correct_shank_a] - centroid_b[:,correct_shank_b]
         drift =  np.nanmedian(drifts, axis = 1)
         drift_per_shank[i,:] = drift
@@ -694,25 +698,31 @@ def test_matches_per_shank(pairs, avg_centroid, sid, param):
     n_shanks = param['no_shanks']
     shank_dist = param['shank_dist']
 
-    for i in range(n_shanks):
-        max_dist += shank_dist
+    if n_shanks != 1:
+        for i in range(n_shanks):
+            max_dist += shank_dist
 
-        correct_shank_a = np.logical_and(centroid_a[1,:] < max_dist,  centroid_a[1,:] > min_dist)
-        correct_shank_b = np.logical_and(centroid_b[1,:] < max_dist,  centroid_b[1,:] > min_dist)
+            correct_shank_a = np.logical_and(centroid_a[1,:] < max_dist,  centroid_a[1,:] > min_dist)
+            correct_shank_b = np.logical_and(centroid_b[1,:] < max_dist,  centroid_b[1,:] > min_dist)
 
-        if np.all(correct_shank_a == correct_shank_b) != True:
-            print(f'These pairs may be bad {np.argwhere(correct_shank_a != correct_shank_b)}')
-            
-        shank_id_tmp[correct_shank_a] = i
+            if np.all(correct_shank_a == correct_shank_b) != True:
+                print(f'These pairs may be bad {np.argwhere(correct_shank_a != correct_shank_b)}')
+                #delete pairs which are one different shanks
+                bad_idxs = np.argwhere(correct_shank_a != correct_shank_b)
+                correct_shank_a = np.delete(correct_shank_a, bad_idxs)
+                correct_shank_b = np.delete(correct_shank_b, bad_idxs)
+                
+            shank_id_tmp[correct_shank_a] = i
 
-        min_dist += shank_dist
+            min_dist += shank_dist
 
-    __, counts = np.unique(shank_id_tmp, return_counts=True)
+        __, counts = np.unique(shank_id_tmp, return_counts=True)
 
-    if np.any(counts < units_per_shank_thrs):
+        if np.any(counts < units_per_shank_thrs):
+            do_per_shank_correction = False
+            print(f'Session pair {sid+1}/{sid+2} has {counts} matches per shank, which is below threshold to do per shank drift correction')
+    else:
         do_per_shank_correction = False
-        print(f'Session pair {sid+1}/{sid+2} has {counts} matches per shank, which is below threshold to do per shank drift correction')
-
     return do_per_shank_correction
 
 
@@ -765,13 +775,14 @@ def drift_n_sessions(candidate_pairs, session_switch, avg_centroid, avg_waveform
 
             #Test to see if there are enough matches to do drift correction per shank
             if test_matches_per_shank(pairs, avg_centroid, did, param) == True and best_drift == True:
-                drifts = np.zeros( (n_sessions - 1, param['no_shanks'], 3)) 
-                drifts[did,:,:], avg_waveform_per_tp, avg_centroid = appply_drift_correction_per_shank(pairs, did, session_switch, avg_centroid, avg_waveform_per_tp, param)
+                drifts = np.zeros( (n_sessions - 1, param['no_shanks'], 3))
+                drifts[did,:,:], avg_waveform_per_tp, avg_centroid = apply_drift_correction_per_shank(pairs, did, session_switch, avg_centroid, avg_waveform_per_tp, param)
                 print(f'Done drift correction per shank for session pair {did+1} and {did+2}')
-            else:
+            elif len(pairs)>0: #if there exist pairs across sessions:
                 drifts = np.zeros( (n_sessions - 1, 3))
                 drifts[did,:], avg_waveform_per_tp, avg_centroid = apply_drift_correction_basic(pairs, did, session_switch, avg_centroid, avg_waveform_per_tp)
-
+            elif len(pairs)==0:
+                print('No pairs across sessions to perform drift correction.')
     return drifts, avg_centroid, avg_waveform_per_tp
 
 

{UnitMatchPy-2.1 → UnitMatchPy-2.4}/UnitMatchPy/utils.py

@@ -124,19 +124,23 @@ def load_good_waveforms(wave_paths, unit_label_paths, param, good_units_only = T
 
     good_units = []
     n_units_per_session_all = []
+    all_units = []
 
     for i in range(len(unit_label_paths)):
     #see if bombcell unit labels
         if os.path.split(unit_label_paths[0])[1] == 'cluster_bc_unitType.tsv':
             unit_label = load_tsv(unit_label_paths[i])
             tmp_idx = np.array([s for s in unit_label if 'GOOD' in s or 'NON-SOMA GOOD' in s])[:,0].astype(np.int32)
+            tmp_idx = tmp_idx[:, np.newaxis] # keep the array shape consitant between different methodss
         else:
             unit_label = load_tsv(unit_label_paths[i])
             tmp_idx = np.argwhere(unit_label[:,1] == 'good')
 
+
         n_units_per_session_all.append(unit_label.shape[0])
         good_unit_idx = unit_label[tmp_idx, 0]
         good_units.append(good_unit_idx)
+        all_units.append(unit_label[:,0]) #get all the unit labels 
 
     waveforms = []
     if good_units_only:
@@ -160,16 +164,17 @@ def load_good_waveforms(wave_paths, unit_label_paths, param, good_units_only = T
     else:
         for ls in range(len(wave_paths)):
             #load in the first good unit, to get the shape of each waveform
-            p_file = os.path.join(wave_paths[ls],f'Unit{int(good_units[ls][0].squeeze())}_RawSpikes.npy')
+            p_file = os.path.join(wave_paths[ls],f'Unit{int(all_units[ls][0])}_RawSpikes.npy')
             tmp = np.load(p_file)
             tmp_waveform = np.zeros( (len(os.listdir(wave_paths[ls])), tmp.shape[0], tmp.shape[1], tmp.shape[2]))
 
             for i in range(len(os.listdir(wave_paths[ls]))):
                 #loads in all GoodUnits for that session
-                p_file_good = os.path.join(wave_paths[ls], f'Unit{int(good_units[ls][0].squeeze())}_RawSpikes.npy')
+                p_file_good = os.path.join(wave_paths[ls], f'Unit{int(all_units[ls][i])}_RawSpikes.npy')
                 tmp_waveform[i] = np.load(p_file_good)
             #adds that session to the list
             waveforms.append(tmp_waveform)
+            print(f'UnitMatch is treating all the units as good and including all units from {wave_paths[ls]}, we recommended using curated data!')
 
         del tmp_waveform
         del tmp
@@ -228,6 +233,7 @@ def get_good_units(unit_label_paths, good = True):
                 tmp_idx = np.array([s for s in unit_label if 'GOOD' in s or 'NON-SOMA GOOD' in s])[:,0].astype(np.int32)
             else:
                 tmp_idx = unit_label[:,0].astype(np.int32)
+            tmp_idx = tmp_idx[:, np.newaxis] # keep the array shape consitant between different methodss
         else:
             unit_label = load_tsv(unit_label_paths[i])
             if good == True:
@@ -602,4 +608,50 @@ def paths_from_KS(KS_dirs):
         else:
             raise Exception('Could not find RawWaveforms folder')
     
-    return wave_paths, unit_label_paths, channel_pos
+    return wave_paths, unit_label_paths, channel_pos
+
+def get_probe_geometry(channel_pos, param, verbose = False):
+    """
+    From the channel positions, estimate the number of shanks and there spacing used to 
+    identify a unit to a probe.
+    needmin_new_shank_distance from param.
+
+    Parameters
+    ----------
+    channel_pos : ndarray
+        The channel positions of a session 
+    param : dict
+        The param dict
+    verbose : bool, optional
+        If True will print the calculated results, by default False
+
+    Returns
+    -------
+    param
+        The param dictionary updated with the calculated params
+    """
+    min_new_shank_distance = param['min_new_shank_distance']
+    x_val = np.unique(channel_pos[:,0])
+    x_val = np.sort(x_val) #make sure they are in ascending order 
+    x_spacing = np.diff(x_val)
+    too_close = np.argwhere(x_spacing < min_new_shank_distance)
+
+    #remove when shanks are two close
+    x_val = np.delete(x_val, too_close + 1)
+
+    n_shanks = x_val.size
+    if n_shanks == 1:
+        shank_spacing = 100 #make it cover the full possible range
+    else:
+        shank_spacing = np.abs(np.diff(x_val))[0]
+
+    #NOTE this shank_dist is the distance within a centroid would be assigned to a shank!
+    shank_dist = shank_spacing * 0.9 #the area from the start which is assigned to each probe
+    #e.g 0 -> 0.9to shank 1, 0.9-1.8 to shank 2...
+    #NOTE current shank identification doesn't work for 9+ shanks
+
+    param['no_shanks'] = n_shanks
+    param['shank_dist'] = shank_dist
+    if verbose == True:
+        print(f'We have found {n_shanks} with spacing ~ {shank_spacing}')
+    return param

UnitMatchPy-2.4/UnitMatchPy.egg-info/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.1
+Name: UnitMatchPy
+Version: 2.4
+Author: Enny van Beest, Celian Bimbard and Sam Dodgson
+Author-email: e.beest@ucl.ac.uk
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Unit Match - Python
+
+## Run UMPy
+
+To run UMPy standard spike sorting data is needed; channel positions and 2 extracted raw waveforms for each unit. This can be calculated externally [BombCell](https://github.com/Julie-Fabre/bombcell) or using *extract_raw_demo.ipynb* to extract these waveforms from compressed data (.cbin and .ch) or raw data. There is also a [Spike Interface](https://spikeinterface.readthedocs.io/en/latest/) integrated notebook *UMPy_spike_interface_demo.ipynb* which uses spike interface to get this data.
+Be careful not to mix and match the different ways of extracting raw waveforms, as there are difference between the methods.
+
+There are to example notebooks for running UMPy *UMPy_example.ipynb* and *UMPy_example_detailed.ipynb*. These notebooks will guide you through running Unit Match all you need to supply is paths to the data. *UMPy_example.ipynb* is recommended to use first as it is simpler, however *UMPy_example_detailed.ipynb* may be useful in unique cases as it is more modular.
+
+The GUI is a optional step to curated and investigate the information Unit Match has calculated; for efficient usage of the GUI please look at *GUI_Reference_Guide.md* in the Demo Notebooks folder.
+
+## Dependencies
+
+This version relies on many core python packages: [numpy](https://numpy.org/), [scipy](https://scipy.org/), [JobLib](https://joblib.readthedocs.io/en/stable/), [pandas](https://pandas.pydata.org/), [tkinter](https://docs.python.org/3/library/tkinter.html) and [matplotlib](https://matplotlib.org/). All of these libaries come with a [Anaconda](https://www.anaconda.com/download/) version of python. 
+For extracting raw data, the library [mtscomp](https://github.com/int-brain-lab/mtscomp) is needed, and can be installed by `pip install mtscomp`.
+
+
+## Installation 
+
+After creating an python environment
+
+```
+conda create --name UnitMatch python 
+conda activate UnitMatch
+```
+
+You can install UnitMatchPy with pip. It will automatically install all the dependencies.
+
+```
+pip install UnitMatchPy
+```

{UnitMatchPy-2.1 → UnitMatchPy-2.4}/UnitMatchPy.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ README.md
 setup.py
 UnitMatchPy/Extract_raw_data.py
 UnitMatchPy/GUI.py
+UnitMatchPy/GUI_icon.png
 UnitMatchPy/Overlord.py
 UnitMatchPy/Save_utils.py
 UnitMatchPy/UM Logo.ico

{UnitMatchPy-2.1 → UnitMatchPy-2.4}/setup.py

@@ -5,7 +5,7 @@ with open('README.md', 'r') as f:
 
 setup(
     name="UnitMatchPy",
-    version="2.1",
+    version="2.4",
     descriptin="Description of the package",
     author="Enny van Beest, Celian Bimbard and Sam Dodgson",
     author_email="e.beest@ucl.ac.uk",

UnitMatchPy-2.1/PKG-INFO

@@ -1,38 +0,0 @@
-Metadata-Version: 2.1
-Name: UnitMatchPy
-Version: 2.1
-Author: Enny van Beest, Celian Bimbard and Sam Dodgson
-Author-email: e.beest@ucl.ac.uk
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# Unit Match - Python
-
-## Run UMPy
-
-To run UMPy standard spike sorting data is needed; channel positions and 2 extractracted raw waveforms for each unit. This can be calculated exteranlly [BombCell](https://github.com/Julie-Fabre/bombcell) or using *ExtractRawDataDemo.ipynb* to extract these waveforms from compressed data (.cbin and .ch) or raw data. There is also a [Spike Interface](https://spikeinterface.readthedocs.io/en/latest/) intergrated notebook *UMPy_spike_interface_demo.ipynb* which uses spike interface to get this data.
-Be careful not to mix and match the different ways of exrtacting raw waveforms, as there are difference between the methods.
-
-There are to example notebooks for running UMPy *UMPyExample.ipynb* and *UMPyExampleBrief.ipynb*. These notebooks will guide you throuh running Unit Match all you need to supply is paths to the data. *UMPyExampleBried.ipynb* is reccomened to use first as it is simpler, however *UMPyExample.ipynb* may be useful in unique cases as it is more modular.
-
-The GUI is a optional step to curated and investigate the infomation Unit Match has calculated; for efficent usage of the GUI please look at *GUI_Reference_Guide.md* in the Demo Notebooks folder.
-## Dependencies
-This version relies on many core python packages [numpy](https://numpy.org/), [scipy](https://scipy.org/), [JobLib](https://joblib.readthedocs.io/en/stable/), [pandas](https://pandas.pydata.org/), [tkinter](https://docs.python.org/3/library/tkinter.html) and [matplotlib](https://matplotlib.org/). All of these libaries come with a [Anaconda](https://www.anaconda.com/download/) version of python. 
-For extracting raw data the library [mtscomp](https://github.com/int-brain-lab/mtscomp) is needed, this can be installed by `pip install mtscomp`.
-
-
-## Installation 
-
-After creating an python environment
-
-```
-conda create --name UnitMatch python 
-conda activate UnitMatch
-```
-
-You can install UnitMatchPy with pip. It will automatically install all the dependency.
-
-```
-pip install UnitMatchPy
-```

UnitMatchPy-2.1/README.md

@@ -1,29 +0,0 @@
-# Unit Match - Python
-
-## Run UMPy
-
-To run UMPy standard spike sorting data is needed; channel positions and 2 extractracted raw waveforms for each unit. This can be calculated exteranlly [BombCell](https://github.com/Julie-Fabre/bombcell) or using *ExtractRawDataDemo.ipynb* to extract these waveforms from compressed data (.cbin and .ch) or raw data. There is also a [Spike Interface](https://spikeinterface.readthedocs.io/en/latest/) intergrated notebook *UMPy_spike_interface_demo.ipynb* which uses spike interface to get this data.
-Be careful not to mix and match the different ways of exrtacting raw waveforms, as there are difference between the methods.
-
-There are to example notebooks for running UMPy *UMPyExample.ipynb* and *UMPyExampleBrief.ipynb*. These notebooks will guide you throuh running Unit Match all you need to supply is paths to the data. *UMPyExampleBried.ipynb* is reccomened to use first as it is simpler, however *UMPyExample.ipynb* may be useful in unique cases as it is more modular.
-
-The GUI is a optional step to curated and investigate the infomation Unit Match has calculated; for efficent usage of the GUI please look at *GUI_Reference_Guide.md* in the Demo Notebooks folder.
-## Dependencies
-This version relies on many core python packages [numpy](https://numpy.org/), [scipy](https://scipy.org/), [JobLib](https://joblib.readthedocs.io/en/stable/), [pandas](https://pandas.pydata.org/), [tkinter](https://docs.python.org/3/library/tkinter.html) and [matplotlib](https://matplotlib.org/). All of these libaries come with a [Anaconda](https://www.anaconda.com/download/) version of python. 
-For extracting raw data the library [mtscomp](https://github.com/int-brain-lab/mtscomp) is needed, this can be installed by `pip install mtscomp`.
-
-
-## Installation 
-
-After creating an python environment
-
-```
-conda create --name UnitMatch python 
-conda activate UnitMatch
-```
-
-You can install UnitMatchPy with pip. It will automatically install all the dependency.
-
-```
-pip install UnitMatchPy
-```

UnitMatchPy-2.1/UnitMatchPy.egg-info/PKG-INFO

@@ -1,38 +0,0 @@
-Metadata-Version: 2.1
-Name: UnitMatchPy
-Version: 2.1
-Author: Enny van Beest, Celian Bimbard and Sam Dodgson
-Author-email: e.beest@ucl.ac.uk
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# Unit Match - Python
-
-## Run UMPy
-
-To run UMPy standard spike sorting data is needed; channel positions and 2 extractracted raw waveforms for each unit. This can be calculated exteranlly [BombCell](https://github.com/Julie-Fabre/bombcell) or using *ExtractRawDataDemo.ipynb* to extract these waveforms from compressed data (.cbin and .ch) or raw data. There is also a [Spike Interface](https://spikeinterface.readthedocs.io/en/latest/) intergrated notebook *UMPy_spike_interface_demo.ipynb* which uses spike interface to get this data.
-Be careful not to mix and match the different ways of exrtacting raw waveforms, as there are difference between the methods.
-
-There are to example notebooks for running UMPy *UMPyExample.ipynb* and *UMPyExampleBrief.ipynb*. These notebooks will guide you throuh running Unit Match all you need to supply is paths to the data. *UMPyExampleBried.ipynb* is reccomened to use first as it is simpler, however *UMPyExample.ipynb* may be useful in unique cases as it is more modular.
-
-The GUI is a optional step to curated and investigate the infomation Unit Match has calculated; for efficent usage of the GUI please look at *GUI_Reference_Guide.md* in the Demo Notebooks folder.
-## Dependencies
-This version relies on many core python packages [numpy](https://numpy.org/), [scipy](https://scipy.org/), [JobLib](https://joblib.readthedocs.io/en/stable/), [pandas](https://pandas.pydata.org/), [tkinter](https://docs.python.org/3/library/tkinter.html) and [matplotlib](https://matplotlib.org/). All of these libaries come with a [Anaconda](https://www.anaconda.com/download/) version of python. 
-For extracting raw data the library [mtscomp](https://github.com/int-brain-lab/mtscomp) is needed, this can be installed by `pip install mtscomp`.
-
-
-## Installation 
-
-After creating an python environment
-
-```
-conda create --name UnitMatch python 
-conda activate UnitMatch
-```
-
-You can install UnitMatchPy with pip. It will automatically install all the dependency.
-
-```
-pip install UnitMatchPy
-```