idx int64 0 251k | question stringlengths 53 3.53k | target stringlengths 5 1.23k | len_question int64 20 893 | len_target int64 3 238 |
|---|---|---|---|---|
239,600 | def _get_shortcut_string ( shortcut ) : if shortcut is None : return '' if isinstance ( shortcut , ( tuple , list ) ) : return ', ' . join ( [ _get_shortcut_string ( s ) for s in shortcut ] ) if isinstance ( shortcut , string_types ) : if hasattr ( QKeySequence , shortcut ) : shortcut = QKeySequence ( getattr ( QKeySequence , shortcut ) ) else : return shortcut . lower ( ) assert isinstance ( shortcut , QKeySequence ) s = shortcut . toString ( ) or '' return str ( s ) . lower ( ) | Return a string representation of a shortcut . | 134 | 8 |
239,601 | def _get_qkeysequence ( shortcut ) : if shortcut is None : return [ ] if isinstance ( shortcut , ( tuple , list ) ) : return [ _get_qkeysequence ( s ) for s in shortcut ] assert isinstance ( shortcut , string_types ) if hasattr ( QKeySequence , shortcut ) : return QKeySequence ( getattr ( QKeySequence , shortcut ) ) sequence = QKeySequence . fromString ( shortcut ) assert not sequence . isEmpty ( ) return sequence | Return a QKeySequence or list of QKeySequence from a shortcut string . | 109 | 18 |
239,602 | def _show_shortcuts ( shortcuts , name = None ) : name = name or '' print ( '' ) if name : name = ' for ' + name print ( 'Keyboard shortcuts' + name ) for name in sorted ( shortcuts ) : shortcut = _get_shortcut_string ( shortcuts [ name ] ) if not name . startswith ( '_' ) : print ( '- {0:<40}: {1:s}' . format ( name , shortcut ) ) | Display shortcuts . | 103 | 3 |
239,603 | def add ( self , callback = None , name = None , shortcut = None , alias = None , docstring = None , menu = None , verbose = True ) : if callback is None : # Allow to use either add(func) or @add or @add(...). return partial ( self . add , name = name , shortcut = shortcut , alias = alias , menu = menu ) assert callback # Get the name from the callback function if needed. name = name or callback . __name__ alias = alias or _alias ( name ) name = name . replace ( '&' , '' ) shortcut = shortcut or self . _default_shortcuts . get ( name , None ) # Skip existing action. if name in self . _actions_dict : return # Set the status tip from the function's docstring. docstring = docstring or callback . __doc__ or name docstring = re . sub ( r'[ \t\r\f\v]{2,}' , ' ' , docstring . strip ( ) ) # Create and register the action. action = _create_qaction ( self . gui , name , callback , shortcut , docstring = docstring , alias = alias , ) action_obj = Bunch ( qaction = action , name = name , alias = alias , shortcut = shortcut , callback = callback , menu = menu ) if verbose and not name . startswith ( '_' ) : logger . log ( 5 , "Add action `%s` (%s)." , name , _get_shortcut_string ( action . shortcut ( ) ) ) self . gui . addAction ( action ) # Add the action to the menu. menu = menu or self . menu # Do not show private actions in the menu. if menu and not name . startswith ( '_' ) : self . gui . get_menu ( menu ) . addAction ( action ) self . _actions_dict [ name ] = action_obj # Register the alias -> name mapping. self . _aliases [ alias ] = name # Set the callback method. if callback : setattr ( self , name , callback ) | Add an action with a keyboard shortcut . | 451 | 8 |
239,604 | def separator ( self , menu = None ) : self . gui . get_menu ( menu or self . menu ) . addSeparator ( ) | Add a separator | 32 | 4 |
239,605 | def disable ( self , name = None ) : if name is None : for name in self . _actions_dict : self . disable ( name ) return self . _actions_dict [ name ] . qaction . setEnabled ( False ) | Disable one or all actions . | 50 | 6 |
239,606 | def enable ( self , name = None ) : if name is None : for name in self . _actions_dict : self . enable ( name ) return self . _actions_dict [ name ] . qaction . setEnabled ( True ) | Enable one or all actions . | 50 | 6 |
239,607 | def run ( self , name , * args ) : assert isinstance ( name , string_types ) # Resolve the alias if it is an alias. name = self . _aliases . get ( name , name ) # Get the action. action = self . _actions_dict . get ( name , None ) if not action : raise ValueError ( "Action `{}` doesn't exist." . format ( name ) ) if not name . startswith ( '_' ) : logger . debug ( "Execute action `%s`." , name ) return action . callback ( * args ) | Run an action as specified by its name . | 127 | 9 |
239,608 | def remove ( self , name ) : self . gui . removeAction ( self . _actions_dict [ name ] . qaction ) del self . _actions_dict [ name ] delattr ( self , name ) | Remove an action . | 45 | 4 |
239,609 | def remove_all ( self ) : names = sorted ( self . _actions_dict . keys ( ) ) for name in names : self . remove ( name ) | Remove all actions . | 34 | 4 |
239,610 | def shortcuts ( self ) : return { name : action . shortcut for name , action in self . _actions_dict . items ( ) } | A dictionary of action shortcuts . | 29 | 6 |
239,611 | def show_shortcuts ( self ) : gui_name = self . gui . name actions_name = self . name name = ( '{} - {}' . format ( gui_name , actions_name ) if actions_name else gui_name ) _show_shortcuts ( self . shortcuts , name ) | Print all shortcuts . | 66 | 4 |
239,612 | def command ( self ) : msg = self . gui . status_message n = len ( msg ) n_cur = len ( self . cursor ) return msg [ : n - n_cur ] | This is used to write a snippet message in the status bar . | 41 | 13 |
239,613 | def _backspace ( self ) : if self . command == ':' : return logger . log ( 5 , "Snippet keystroke `Backspace`." ) self . command = self . command [ : - 1 ] | Erase the last character in the snippet command . | 47 | 10 |
239,614 | def _enter ( self ) : command = self . command logger . log ( 5 , "Snippet keystroke `Enter`." ) # NOTE: we need to set back the actions (mode_off) before running # the command. self . mode_off ( ) self . run ( command ) | Disable the snippet mode and execute the command . | 63 | 9 |
239,615 | def _create_snippet_actions ( self ) : # One action per allowed character. for i , char in enumerate ( self . _snippet_chars ) : def _make_func ( char ) : def callback ( ) : logger . log ( 5 , "Snippet keystroke `%s`." , char ) self . command += char return callback self . actions . add ( name = '_snippet_{}' . format ( i ) , shortcut = char , callback = _make_func ( char ) ) self . actions . add ( name = '_snippet_backspace' , shortcut = 'backspace' , callback = self . _backspace ) self . actions . add ( name = '_snippet_activate' , shortcut = ( 'enter' , 'return' ) , callback = self . _enter ) self . actions . add ( name = '_snippet_disable' , shortcut = 'escape' , callback = self . mode_off ) | Add mock Qt actions for snippet keystrokes . | 216 | 10 |
239,616 | def run ( self , snippet ) : assert snippet [ 0 ] == ':' snippet = snippet [ 1 : ] snippet_args = _parse_snippet ( snippet ) name = snippet_args [ 0 ] logger . info ( "Processing snippet `%s`." , snippet ) try : # Try to run the snippet on all attached Actions instances. for actions in self . gui . actions : try : actions . run ( name , * snippet_args [ 1 : ] ) return except ValueError : # This Actions instance doesn't contain the requested # snippet, trying the next attached Actions instance. pass logger . warn ( "Couldn't find action `%s`." , name ) except Exception as e : logger . warn ( "Error when executing snippet: \"%s\"." , str ( e ) ) logger . debug ( '' . join ( traceback . format_exception ( * sys . exc_info ( ) ) ) ) | Executes a snippet command . | 196 | 6 |
239,617 | def _before_after ( n_samples ) : if not isinstance ( n_samples , ( tuple , list ) ) : before = n_samples // 2 after = n_samples - before else : assert len ( n_samples ) == 2 before , after = n_samples n_samples = before + after assert before >= 0 assert after >= 0 assert before + after == n_samples return before , after | Get the number of samples before and after . | 94 | 9 |
239,618 | def _slice ( index , n_samples , margin = None ) : if margin is None : margin = ( 0 , 0 ) assert isinstance ( n_samples , ( tuple , list ) ) assert len ( n_samples ) == 2 before , after = n_samples assert isinstance ( margin , ( tuple , list ) ) assert len ( margin ) == 2 margin_before , margin_after = margin before += margin_before after += margin_after index = int ( index ) before = int ( before ) after = int ( after ) return slice ( max ( 0 , index - before ) , index + after , None ) | Return a waveform slice . | 135 | 6 |
239,619 | def _load_at ( self , time , channels = None ) : if channels is None : channels = slice ( None , None , None ) time = int ( time ) time_o = time ns = self . n_samples_trace if not ( 0 <= time_o < ns ) : raise ValueError ( "Invalid time {0:d}/{1:d}." . format ( time_o , ns ) ) slice_extract = _slice ( time_o , self . n_samples_before_after , self . _filter_margin ) extract = self . _traces [ slice_extract ] [ : , channels ] . astype ( np . float32 ) # Pad the extracted chunk if needed. if slice_extract . start <= 0 : extract = _pad ( extract , self . _n_samples_extract , 'left' ) elif slice_extract . stop >= ns - 1 : extract = _pad ( extract , self . _n_samples_extract , 'right' ) assert extract . shape [ 0 ] == self . _n_samples_extract return extract | Load a waveform at a given time . | 244 | 9 |
239,620 | def get ( self , spike_ids , channels = None ) : if isinstance ( spike_ids , slice ) : spike_ids = _range_from_slice ( spike_ids , start = 0 , stop = self . n_spikes , ) if not hasattr ( spike_ids , '__len__' ) : spike_ids = [ spike_ids ] if channels is None : channels = slice ( None , None , None ) nc = self . n_channels else : channels = np . asarray ( channels , dtype = np . int32 ) assert np . all ( channels < self . n_channels ) nc = len ( channels ) # Ensure a list of time samples are being requested. spike_ids = _as_array ( spike_ids ) n_spikes = len ( spike_ids ) # Initialize the array. # NOTE: last dimension is time to simplify things. shape = ( n_spikes , nc , self . _n_samples_extract ) waveforms = np . zeros ( shape , dtype = np . float32 ) # No traces: return null arrays. if self . n_samples_trace == 0 : return np . transpose ( waveforms , ( 0 , 2 , 1 ) ) # Load all spikes. for i , spike_id in enumerate ( spike_ids ) : assert 0 <= spike_id < self . n_spikes time = self . _spike_samples [ spike_id ] # Extract the waveforms on the unmasked channels. try : w = self . _load_at ( time , channels ) except ValueError as e : # pragma: no cover logger . warn ( "Error while loading waveform: %s" , str ( e ) ) continue assert w . shape == ( self . _n_samples_extract , nc ) waveforms [ i , : , : ] = w . T # Filter the waveforms. waveforms_f = waveforms . reshape ( ( - 1 , self . _n_samples_extract ) ) # Only filter the non-zero waveforms. unmasked = waveforms_f . max ( axis = 1 ) != 0 waveforms_f [ unmasked ] = self . _filter ( waveforms_f [ unmasked ] , axis = 1 ) waveforms_f = waveforms_f . reshape ( ( n_spikes , nc , self . _n_samples_extract ) ) # Remove the margin. margin_before , margin_after = self . _filter_margin if margin_after > 0 : assert margin_before >= 0 waveforms_f = waveforms_f [ : , : , margin_before : - margin_after ] assert waveforms_f . shape == ( n_spikes , nc , self . n_samples_waveforms , ) # NOTE: we transpose before returning the array. return np . transpose ( waveforms_f , ( 0 , 2 , 1 ) ) | Load the waveforms of the specified spikes . | 649 | 9 |
239,621 | def get_waveform_amplitude ( mean_masks , mean_waveforms ) : assert mean_waveforms . ndim == 2 n_samples , n_channels = mean_waveforms . shape assert mean_masks . ndim == 1 assert mean_masks . shape == ( n_channels , ) mean_waveforms = mean_waveforms * mean_masks assert mean_waveforms . shape == ( n_samples , n_channels ) # Amplitudes. m , M = mean_waveforms . min ( axis = 0 ) , mean_waveforms . max ( axis = 0 ) return M - m | Return the amplitude of the waveforms on all channels . | 140 | 11 |
239,622 | def get_mean_masked_features_distance ( mean_features_0 , mean_features_1 , mean_masks_0 , mean_masks_1 , n_features_per_channel = None , ) : assert n_features_per_channel > 0 mu_0 = mean_features_0 . ravel ( ) mu_1 = mean_features_1 . ravel ( ) omeg_0 = mean_masks_0 omeg_1 = mean_masks_1 omeg_0 = np . repeat ( omeg_0 , n_features_per_channel ) omeg_1 = np . repeat ( omeg_1 , n_features_per_channel ) d_0 = mu_0 * omeg_0 d_1 = mu_1 * omeg_1 return np . linalg . norm ( d_0 - d_1 ) | Compute the distance between the mean masked features . | 195 | 10 |
239,623 | def _extend_spikes ( spike_ids , spike_clusters ) : # We find the spikes belonging to modified clusters. # What are the old clusters that are modified by the assignment? old_spike_clusters = spike_clusters [ spike_ids ] unique_clusters = _unique ( old_spike_clusters ) # Now we take all spikes from these clusters. changed_spike_ids = _spikes_in_clusters ( spike_clusters , unique_clusters ) # These are the new spikes that need to be reassigned. extended_spike_ids = np . setdiff1d ( changed_spike_ids , spike_ids , assume_unique = True ) return extended_spike_ids | Return all spikes belonging to the clusters containing the specified spikes . | 161 | 12 |
239,624 | def reset ( self ) : self . _undo_stack . clear ( ) self . _spike_clusters = self . _spike_clusters_base self . _new_cluster_id = self . _new_cluster_id_0 | Reset the clustering to the original clustering . | 56 | 11 |
239,625 | def _do_assign ( self , spike_ids , new_spike_clusters ) : # Ensure spike_clusters has the right shape. spike_ids = _as_array ( spike_ids ) if len ( new_spike_clusters ) == 1 and len ( spike_ids ) > 1 : new_spike_clusters = ( np . ones ( len ( spike_ids ) , dtype = np . int64 ) * new_spike_clusters [ 0 ] ) old_spike_clusters = self . _spike_clusters [ spike_ids ] assert len ( spike_ids ) == len ( old_spike_clusters ) assert len ( new_spike_clusters ) == len ( spike_ids ) # Update the spikes per cluster structure. old_clusters = _unique ( old_spike_clusters ) # NOTE: shortcut to a merge if this assignment is effectively a merge # i.e. if all spikes are assigned to a single cluster. # The fact that spike selection has been previously extended to # whole clusters is critical here. new_clusters = _unique ( new_spike_clusters ) if len ( new_clusters ) == 1 : return self . _do_merge ( spike_ids , old_clusters , new_clusters [ 0 ] ) # We return the UpdateInfo structure. up = _assign_update_info ( spike_ids , old_spike_clusters , new_spike_clusters ) # We update the new cluster id (strictly increasing during a session). self . _new_cluster_id = max ( self . _new_cluster_id , max ( up . added ) + 1 ) # We make the assignments. self . _spike_clusters [ spike_ids ] = new_spike_clusters # OPTIM: we update spikes_per_cluster manually. new_spc = _spikes_per_cluster ( new_spike_clusters , spike_ids ) self . _update_cluster_ids ( to_remove = old_clusters , to_add = new_spc ) return up | Make spike - cluster assignments after the spike selection has been extended to full clusters . | 472 | 16 |
239,626 | def merge ( self , cluster_ids , to = None ) : if not _is_array_like ( cluster_ids ) : raise ValueError ( "The first argument should be a list or " "an array." ) cluster_ids = sorted ( cluster_ids ) if not set ( cluster_ids ) <= set ( self . cluster_ids ) : raise ValueError ( "Some clusters do not exist." ) # Find the new cluster number. if to is None : to = self . new_cluster_id ( ) if to < self . new_cluster_id ( ) : raise ValueError ( "The new cluster numbers should be higher than " "{0}." . format ( self . new_cluster_id ( ) ) ) # NOTE: we could have called self.assign() here, but we don't. # We circumvent self.assign() for performance reasons. # assign() is a relatively costly operation, whereas merging is a much # cheaper operation. # Find all spikes in the specified clusters. spike_ids = _spikes_in_clusters ( self . spike_clusters , cluster_ids ) up = self . _do_merge ( spike_ids , cluster_ids , to ) undo_state = self . emit ( 'request_undo_state' , up ) # Add to stack. self . _undo_stack . add ( ( spike_ids , [ to ] , undo_state ) ) self . emit ( 'cluster' , up ) return up | Merge several clusters to a new cluster . | 319 | 9 |
239,627 | def assign ( self , spike_ids , spike_clusters_rel = 0 ) : assert not isinstance ( spike_ids , slice ) # Ensure `spike_clusters_rel` is an array-like. if not hasattr ( spike_clusters_rel , '__len__' ) : spike_clusters_rel = spike_clusters_rel * np . ones ( len ( spike_ids ) , dtype = np . int64 ) spike_ids = _as_array ( spike_ids ) if len ( spike_ids ) == 0 : return UpdateInfo ( ) assert len ( spike_ids ) == len ( spike_clusters_rel ) assert spike_ids . min ( ) >= 0 assert spike_ids . max ( ) < self . _n_spikes , "Some spikes don't exist." # Normalize the spike-cluster assignment such that # there are only new or dead clusters, not modified clusters. # This implies that spikes not explicitly selected, but that # belong to clusters affected by the operation, will be assigned # to brand new clusters. spike_ids , cluster_ids = _extend_assignment ( spike_ids , self . _spike_clusters , spike_clusters_rel , self . new_cluster_id ( ) , ) up = self . _do_assign ( spike_ids , cluster_ids ) undo_state = self . emit ( 'request_undo_state' , up ) # Add the assignment to the undo stack. self . _undo_stack . add ( ( spike_ids , cluster_ids , undo_state ) ) self . emit ( 'cluster' , up ) return up | Make new spike cluster assignments . | 359 | 6 |
239,628 | def undo ( self ) : _ , _ , undo_state = self . _undo_stack . back ( ) # Retrieve the initial spike_cluster structure. spike_clusters_new = self . _spike_clusters_base . copy ( ) # Loop over the history (except the last item because we undo). for spike_ids , cluster_ids , _ in self . _undo_stack : # We update the spike clusters accordingly. if spike_ids is not None : spike_clusters_new [ spike_ids ] = cluster_ids # What are the spikes affected by the last changes? changed = np . nonzero ( self . _spike_clusters != spike_clusters_new ) [ 0 ] clusters_changed = spike_clusters_new [ changed ] up = self . _do_assign ( changed , clusters_changed ) up . history = 'undo' # Add the undo_state object from the undone object. up . undo_state = undo_state self . emit ( 'cluster' , up ) return up | Undo the last cluster assignment operation . | 226 | 8 |
239,629 | def redo ( self ) : # Go forward in the stack, and retrieve the new assignment. item = self . _undo_stack . forward ( ) if item is None : # No redo has been performed: abort. return # NOTE: the undo_state object is only returned when undoing. # It represents data associated to the state # *before* the action. What might be more useful would be the # undo_state object of the next item in the list (if it exists). spike_ids , cluster_ids , undo_state = item assert spike_ids is not None # We apply the new assignment. up = self . _do_assign ( spike_ids , cluster_ids ) up . history = 'redo' self . emit ( 'cluster' , up ) return up | Redo the last cluster assignment operation . | 168 | 8 |
239,630 | def _increment ( arr , indices ) : arr = _as_array ( arr ) indices = _as_array ( indices ) bbins = np . bincount ( indices ) arr [ : len ( bbins ) ] += bbins return arr | Increment some indices in a 1D vector of non - negative integers . Repeated indices are taken into account . | 56 | 23 |
239,631 | def _symmetrize_correlograms ( correlograms ) : n_clusters , _ , n_bins = correlograms . shape assert n_clusters == _ # We symmetrize c[i, j, 0]. # This is necessary because the algorithm in correlograms() # is sensitive to the order of identical spikes. correlograms [ ... , 0 ] = np . maximum ( correlograms [ ... , 0 ] , correlograms [ ... , 0 ] . T ) sym = correlograms [ ... , 1 : ] [ ... , : : - 1 ] sym = np . transpose ( sym , ( 1 , 0 , 2 ) ) return np . dstack ( ( sym , correlograms ) ) | Return the symmetrized version of the CCG arrays . | 152 | 13 |
239,632 | def correlograms ( spike_times , spike_clusters , cluster_ids = None , sample_rate = 1. , bin_size = None , window_size = None , symmetrize = True , ) : assert sample_rate > 0. assert np . all ( np . diff ( spike_times ) >= 0 ) , ( "The spike times must be " "increasing." ) # Get the spike samples. spike_times = np . asarray ( spike_times , dtype = np . float64 ) spike_samples = ( spike_times * sample_rate ) . astype ( np . int64 ) spike_clusters = _as_array ( spike_clusters ) assert spike_samples . ndim == 1 assert spike_samples . shape == spike_clusters . shape # Find `binsize`. bin_size = np . clip ( bin_size , 1e-5 , 1e5 ) # in seconds binsize = int ( sample_rate * bin_size ) # in samples assert binsize >= 1 # Find `winsize_bins`. window_size = np . clip ( window_size , 1e-5 , 1e5 ) # in seconds winsize_bins = 2 * int ( .5 * window_size / bin_size ) + 1 assert winsize_bins >= 1 assert winsize_bins % 2 == 1 # Take the cluster oder into account. if cluster_ids is None : clusters = _unique ( spike_clusters ) else : clusters = _as_array ( cluster_ids ) n_clusters = len ( clusters ) # Like spike_clusters, but with 0..n_clusters-1 indices. spike_clusters_i = _index_of ( spike_clusters , clusters ) # Shift between the two copies of the spike trains. shift = 1 # At a given shift, the mask precises which spikes have matching spikes # within the correlogram time window. mask = np . ones_like ( spike_samples , dtype = np . bool ) correlograms = _create_correlograms_array ( n_clusters , winsize_bins ) # The loop continues as long as there is at least one spike with # a matching spike. while mask [ : - shift ] . any ( ) : # Number of time samples between spike i and spike i+shift. spike_diff = _diff_shifted ( spike_samples , shift ) # Binarize the delays between spike i and spike i+shift. spike_diff_b = spike_diff // binsize # Spikes with no matching spikes are masked. mask [ : - shift ] [ spike_diff_b > ( winsize_bins // 2 ) ] = False # Cache the masked spike delays. m = mask [ : - shift ] . copy ( ) d = spike_diff_b [ m ] # # Update the masks given the clusters to update. # m0 = np.in1d(spike_clusters[:-shift], clusters) # m = m & m0 # d = spike_diff_b[m] d = spike_diff_b [ m ] # Find the indices in the raveled correlograms array that need # to be incremented, taking into account the spike clusters. indices = np . ravel_multi_index ( ( spike_clusters_i [ : - shift ] [ m ] , spike_clusters_i [ + shift : ] [ m ] , d ) , correlograms . shape ) # Increment the matching spikes in the correlograms array. _increment ( correlograms . ravel ( ) , indices ) shift += 1 # Remove ACG peaks. correlograms [ np . arange ( n_clusters ) , np . arange ( n_clusters ) , 0 ] = 0 if symmetrize : return _symmetrize_correlograms ( correlograms ) else : return correlograms | Compute all pairwise cross - correlograms among the clusters appearing in spike_clusters . | 845 | 19 |
239,633 | def set_bin_window ( self , bin_size = None , window_size = None ) : bin_size = bin_size or self . bin_size window_size = window_size or self . window_size assert 1e-6 < bin_size < 1e3 assert 1e-6 < window_size < 1e3 assert bin_size < window_size self . bin_size = bin_size self . window_size = window_size # Set the status message. b , w = self . bin_size * 1000 , self . window_size * 1000 self . set_status ( 'Bin: {:.1f} ms. Window: {:.1f} ms.' . format ( b , w ) ) | Set the bin and window sizes . | 159 | 7 |
239,634 | def _md5 ( path , blocksize = 2 ** 20 ) : m = hashlib . md5 ( ) with open ( path , 'rb' ) as f : while True : buf = f . read ( blocksize ) if not buf : break m . update ( buf ) return m . hexdigest ( ) | Compute the checksum of a file . | 67 | 9 |
239,635 | def download_file ( url , output_path ) : output_path = op . realpath ( output_path ) assert output_path is not None if op . exists ( output_path ) : checked = _check_md5_of_url ( output_path , url ) if checked is False : logger . debug ( "The file `%s` already exists " "but is invalid: redownloading." , output_path ) elif checked is True : logger . debug ( "The file `%s` already exists: skipping." , output_path ) return output_path r = _download ( url , stream = True ) _save_stream ( r , output_path ) if _check_md5_of_url ( output_path , url ) is False : logger . debug ( "The checksum doesn't match: retrying the download." ) r = _download ( url , stream = True ) _save_stream ( r , output_path ) if _check_md5_of_url ( output_path , url ) is False : raise RuntimeError ( "The checksum of the downloaded file " "doesn't match the provided checksum." ) return | Download a binary file from an URL . | 250 | 8 |
239,636 | def _make_class ( cls , * * kwargs ) : kwargs = { k : ( v if v is not None else getattr ( cls , k , None ) ) for k , v in kwargs . items ( ) } # The class name contains a hash of the custom parameters. name = cls . __name__ + '_' + _hash ( kwargs ) if name not in _CLASSES : logger . log ( 5 , "Create class %s %s." , name , kwargs ) cls = type ( name , ( cls , ) , kwargs ) _CLASSES [ name ] = cls return _CLASSES [ name ] | Return a custom Visual class with given parameters . | 149 | 9 |
239,637 | def _add_item ( self , cls , * args , * * kwargs ) : box_index = kwargs . pop ( 'box_index' , self . _default_box_index ) data = cls . validate ( * args , * * kwargs ) n = cls . vertex_count ( * * data ) if not isinstance ( box_index , np . ndarray ) : k = len ( self . _default_box_index ) box_index = _get_array ( box_index , ( n , k ) ) data [ 'box_index' ] = box_index if cls not in self . _items : self . _items [ cls ] = [ ] self . _items [ cls ] . append ( data ) return data | Add a plot item . | 171 | 5 |
239,638 | def scatter ( self , * args , * * kwargs ) : cls = _make_class ( ScatterVisual , _default_marker = kwargs . pop ( 'marker' , None ) , ) return self . _add_item ( cls , * args , * * kwargs ) | Add a scatter plot . | 68 | 5 |
239,639 | def build ( self ) : for cls , data_list in self . _items . items ( ) : # Some variables are not concatenated. They are specified # in `allow_list`. data = _accumulate ( data_list , cls . allow_list ) box_index = data . pop ( 'box_index' ) visual = cls ( ) self . add_visual ( visual ) visual . set_data ( * * data ) # NOTE: visual.program.__contains__ is implemented in vispy master # so we can replace this with `if 'a_box_index' in visual.program` # after the next VisPy release. if 'a_box_index' in visual . program . _code_variables : visual . program [ 'a_box_index' ] = box_index . astype ( np . float32 ) # TODO: refactor this when there is the possibility to update existing # visuals without recreating the whole scene. if self . lasso : self . lasso . create_visual ( ) self . update ( ) | Build all added items . | 233 | 5 |
239,640 | def _range_from_slice ( myslice , start = None , stop = None , step = None , length = None ) : assert isinstance ( myslice , slice ) # Find 'step'. step = myslice . step if myslice . step is not None else step if step is None : step = 1 # Find 'start'. start = myslice . start if myslice . start is not None else start if start is None : start = 0 # Find 'stop' as a function of length if 'stop' is unspecified. stop = myslice . stop if myslice . stop is not None else stop if length is not None : stop_inferred = floor ( start + step * length ) if stop is not None and stop < stop_inferred : raise ValueError ( "'stop' ({stop}) and " . format ( stop = stop ) + "'length' ({length}) " . format ( length = length ) + "are not compatible." ) stop = stop_inferred if stop is None and length is None : raise ValueError ( "'stop' and 'length' cannot be both unspecified." ) myrange = np . arange ( start , stop , step ) # Check the length if it was specified. if length is not None : assert len ( myrange ) == length return myrange | Convert a slice to an array of integers . | 273 | 10 |
239,641 | def _index_of ( arr , lookup ) : # Equivalent of np.digitize(arr, lookup) - 1, but much faster. # TODO: assertions to disable in production for performance reasons. # TODO: np.searchsorted(lookup, arr) is faster on small arrays with large # values lookup = np . asarray ( lookup , dtype = np . int32 ) m = ( lookup . max ( ) if len ( lookup ) else 0 ) + 1 tmp = np . zeros ( m + 1 , dtype = np . int ) # Ensure that -1 values are kept. tmp [ - 1 ] = - 1 if len ( lookup ) : tmp [ lookup ] = np . arange ( len ( lookup ) ) return tmp [ arr ] | Replace scalars in an array by their indices in a lookup table . | 164 | 15 |
239,642 | def _pad ( arr , n , dir = 'right' ) : assert dir in ( 'left' , 'right' ) if n < 0 : raise ValueError ( "'n' must be positive: {0}." . format ( n ) ) elif n == 0 : return np . zeros ( ( 0 , ) + arr . shape [ 1 : ] , dtype = arr . dtype ) n_arr = arr . shape [ 0 ] shape = ( n , ) + arr . shape [ 1 : ] if n_arr == n : assert arr . shape == shape return arr elif n_arr < n : out = np . zeros ( shape , dtype = arr . dtype ) if dir == 'left' : out [ - n_arr : , ... ] = arr elif dir == 'right' : out [ : n_arr , ... ] = arr assert out . shape == shape return out else : if dir == 'left' : out = arr [ - n : , ... ] elif dir == 'right' : out = arr [ : n , ... ] assert out . shape == shape return out | Pad an array with zeros along the first axis . | 240 | 11 |
239,643 | def _in_polygon ( points , polygon ) : from matplotlib . path import Path points = _as_array ( points ) polygon = _as_array ( polygon ) assert points . ndim == 2 assert polygon . ndim == 2 if len ( polygon ) : polygon = np . vstack ( ( polygon , polygon [ 0 ] ) ) path = Path ( polygon , closed = True ) return path . contains_points ( points ) | Return the points that are inside a polygon . | 102 | 10 |
239,644 | def read_array ( path , mmap_mode = None ) : file_ext = op . splitext ( path ) [ 1 ] if file_ext == '.npy' : return np . load ( path , mmap_mode = mmap_mode ) raise NotImplementedError ( "The file extension `{}` " . format ( file_ext ) + "is not currently supported." ) | Read a . npy array . | 88 | 7 |
239,645 | def write_array ( path , arr ) : file_ext = op . splitext ( path ) [ 1 ] if file_ext == '.npy' : return np . save ( path , arr ) raise NotImplementedError ( "The file extension `{}` " . format ( file_ext ) + "is not currently supported." ) | Write an array to a . npy file . | 75 | 10 |
239,646 | def _concatenate_virtual_arrays ( arrs , cols = None , scaling = None ) : return None if not len ( arrs ) else ConcatenatedArrays ( arrs , cols , scaling = scaling ) | Return a virtual concatenate of several NumPy arrays . | 52 | 12 |
239,647 | def _excerpt_step ( n_samples , n_excerpts = None , excerpt_size = None ) : assert n_excerpts >= 2 step = max ( ( n_samples - excerpt_size ) // ( n_excerpts - 1 ) , excerpt_size ) return step | Compute the step of an excerpt set as a function of the number of excerpts or their sizes . | 66 | 20 |
239,648 | def chunk_bounds ( n_samples , chunk_size , overlap = 0 ) : s_start = 0 s_end = chunk_size keep_start = s_start keep_end = s_end - overlap // 2 yield s_start , s_end , keep_start , keep_end while s_end - overlap + chunk_size < n_samples : s_start = s_end - overlap s_end = s_start + chunk_size keep_start = keep_end keep_end = s_end - overlap // 2 if s_start < s_end : yield s_start , s_end , keep_start , keep_end s_start = s_end - overlap s_end = n_samples keep_start = keep_end keep_end = s_end if s_start < s_end : yield s_start , s_end , keep_start , keep_end | Return chunk bounds . | 201 | 4 |
239,649 | def data_chunk ( data , chunk , with_overlap = False ) : assert isinstance ( chunk , tuple ) if len ( chunk ) == 2 : i , j = chunk elif len ( chunk ) == 4 : if with_overlap : i , j = chunk [ : 2 ] else : i , j = chunk [ 2 : ] else : raise ValueError ( "'chunk' should have 2 or 4 elements, " "not {0:d}" . format ( len ( chunk ) ) ) return data [ i : j , ... ] | Get a data chunk . | 117 | 5 |
239,650 | def _spikes_in_clusters ( spike_clusters , clusters ) : if len ( spike_clusters ) == 0 or len ( clusters ) == 0 : return np . array ( [ ] , dtype = np . int ) return np . nonzero ( np . in1d ( spike_clusters , clusters ) ) [ 0 ] | Return the ids of all spikes belonging to the specified clusters . | 74 | 13 |
239,651 | def grouped_mean ( arr , spike_clusters ) : arr = np . asarray ( arr ) spike_clusters = np . asarray ( spike_clusters ) assert arr . ndim == 1 assert arr . shape [ 0 ] == len ( spike_clusters ) cluster_ids = _unique ( spike_clusters ) spike_clusters_rel = _index_of ( spike_clusters , cluster_ids ) spike_counts = np . bincount ( spike_clusters_rel ) assert len ( spike_counts ) == len ( cluster_ids ) t = np . zeros ( len ( cluster_ids ) ) # Compute the sum with possible repetitions. np . add . at ( t , spike_clusters_rel , arr ) return t / spike_counts | Compute the mean of a spike - dependent quantity for every cluster . | 173 | 14 |
239,652 | def regular_subset ( spikes , n_spikes_max = None , offset = 0 ) : assert spikes is not None # Nothing to do if the selection already satisfies n_spikes_max. if n_spikes_max is None or len ( spikes ) <= n_spikes_max : # pragma: no cover return spikes step = math . ceil ( np . clip ( 1. / n_spikes_max * len ( spikes ) , 1 , len ( spikes ) ) ) step = int ( step ) # Note: randomly-changing selections are confusing... my_spikes = spikes [ offset : : step ] [ : n_spikes_max ] assert len ( my_spikes ) <= len ( spikes ) assert len ( my_spikes ) <= n_spikes_max return my_spikes | Prune the current selection to get at most n_spikes_max spikes . | 177 | 17 |
239,653 | def select_spikes ( cluster_ids = None , max_n_spikes_per_cluster = None , spikes_per_cluster = None , batch_size = None , subset = None , ) : subset = subset or 'regular' assert _is_array_like ( cluster_ids ) if not len ( cluster_ids ) : return np . array ( [ ] , dtype = np . int64 ) if max_n_spikes_per_cluster in ( None , 0 ) : selection = { c : spikes_per_cluster ( c ) for c in cluster_ids } else : assert max_n_spikes_per_cluster > 0 selection = { } n_clusters = len ( cluster_ids ) for cluster in cluster_ids : # Decrease the number of spikes per cluster when there # are more clusters. n = int ( max_n_spikes_per_cluster * exp ( - .1 * ( n_clusters - 1 ) ) ) n = max ( 1 , n ) spike_ids = spikes_per_cluster ( cluster ) if subset == 'regular' : # Regular subselection. if batch_size is None or len ( spike_ids ) <= max ( batch_size , n ) : spike_ids = regular_subset ( spike_ids , n_spikes_max = n ) else : # Batch selections of spikes. spike_ids = get_excerpts ( spike_ids , n // batch_size , batch_size ) elif subset == 'random' and len ( spike_ids ) > n : # Random subselection. spike_ids = np . random . choice ( spike_ids , n , replace = False ) spike_ids = np . unique ( spike_ids ) selection [ cluster ] = spike_ids return _flatten_per_cluster ( selection ) | Return a selection of spikes belonging to the specified clusters . | 402 | 11 |
239,654 | def _get_recording ( self , index ) : assert index >= 0 recs = np . nonzero ( ( index - self . offsets [ : - 1 ] ) >= 0 ) [ 0 ] if len ( recs ) == 0 : # pragma: no cover # If the index is greater than the total size, # return the last recording. return len ( self . arrs ) - 1 # Return the last recording such that the index is greater than # its offset. return recs [ - 1 ] | Return the recording that contains a given index . | 107 | 9 |
239,655 | def bandpass_filter ( rate = None , low = None , high = None , order = None ) : assert low < high assert order >= 1 return signal . butter ( order , ( low / ( rate / 2. ) , high / ( rate / 2. ) ) , 'pass' ) | Butterworth bandpass filter . | 62 | 7 |
239,656 | def apply_filter ( x , filter = None , axis = 0 ) : x = _as_array ( x ) if x . shape [ axis ] == 0 : return x b , a = filter return signal . filtfilt ( b , a , x , axis = axis ) | Apply a filter to an array . | 59 | 7 |
239,657 | def fit ( self , x , fudge = 1e-18 ) : assert x . ndim == 2 ns , nc = x . shape x_cov = np . cov ( x , rowvar = 0 ) assert x_cov . shape == ( nc , nc ) d , v = np . linalg . eigh ( x_cov ) d = np . diag ( 1. / np . sqrt ( d + fudge ) ) # This is equivalent, but seems much slower... # w = np.einsum('il,lk,jk->ij', v, d, v) w = np . dot ( np . dot ( v , d ) , v . T ) self . _matrix = w return w | Compute the whitening matrix . | 164 | 7 |
239,658 | def current_item ( self ) : if self . _history and self . _index >= 0 : self . _check_index ( ) return self . _history [ self . _index ] | Return the current element . | 40 | 5 |
239,659 | def _check_index ( self ) : assert 0 <= self . _index <= len ( self . _history ) - 1 # There should always be the base item at least. assert len ( self . _history ) >= 1 | Check that the index is without the bounds of _history . | 47 | 12 |
239,660 | def iter ( self , start = 0 , end = None ) : if end is None : end = self . _index + 1 elif end == 0 : raise StopIteration ( ) if start >= end : raise StopIteration ( ) # Check arguments. assert 0 <= end <= len ( self . _history ) assert 0 <= start <= end - 1 for i in range ( start , end ) : yield self . _history [ i ] | Iterate through successive history items . | 92 | 7 |
239,661 | def add ( self , item ) : self . _check_index ( ) # Possibly truncate the history up to the current point. self . _history = self . _history [ : self . _index + 1 ] # Append the item self . _history . append ( item ) # Increment the index. self . _index += 1 self . _check_index ( ) # Check that the current element is what was provided to the function. assert id ( self . current_item ) == id ( item ) | Add an item in the history . | 108 | 7 |
239,662 | def back ( self ) : if self . _index <= 0 : return None undone = self . current_item self . _index -= 1 self . _check_index ( ) return undone | Go back in history if possible . | 39 | 7 |
239,663 | def forward ( self ) : if self . _index >= len ( self . _history ) - 1 : return None self . _index += 1 self . _check_index ( ) return self . current_item | Go forward in history if possible . | 44 | 7 |
239,664 | def add_to_current_action ( self , controller ) : item = self . current_item self . _history [ self . _index ] = item + ( controller , ) | Add a controller to the current action . | 38 | 8 |
239,665 | def redo ( self ) : controllers = self . forward ( ) if controllers is None : ups = ( ) else : ups = tuple ( [ controller . redo ( ) for controller in controllers ] ) if self . process_ups is not None : return self . process_ups ( ups ) else : return ups | Redo the last action . | 65 | 6 |
239,666 | def _insert_glsl ( vertex , fragment , to_insert ) : # Find the place where to insert the GLSL snippet. # This is "gl_Position = transform(data_var_name);" where # data_var_name is typically an attribute. vs_regex = re . compile ( r'gl_Position = transform\(([\S]+)\);' ) r = vs_regex . search ( vertex ) if not r : logger . debug ( "The vertex shader doesn't contain the transform " "placeholder: skipping the transform chain " "GLSL insertion." ) return vertex , fragment assert r logger . log ( 5 , "Found transform placeholder in vertex code: `%s`" , r . group ( 0 ) ) # Find the GLSL variable with the data (should be a `vec2`). var = r . group ( 1 ) assert var and var in vertex # Headers. vertex = to_insert [ 'vert' , 'header' ] + '\n\n' + vertex fragment = to_insert [ 'frag' , 'header' ] + '\n\n' + fragment # Get the pre and post transforms. vs_insert = to_insert [ 'vert' , 'before_transforms' ] vs_insert += to_insert [ 'vert' , 'transforms' ] vs_insert += to_insert [ 'vert' , 'after_transforms' ] # Insert the GLSL snippet in the vertex shader. vertex = vs_regex . sub ( indent ( vs_insert ) , vertex ) # Now, we make the replacements in the fragment shader. fs_regex = re . compile ( r'(void main\(\)\s*\{)' ) # NOTE: we add the `void main(){` that was removed by the regex. fs_insert = '\\1\n' + to_insert [ 'frag' , 'before_transforms' ] fragment = fs_regex . sub ( indent ( fs_insert ) , fragment ) # Replace the transformed variable placeholder by its name. vertex = vertex . replace ( '{{ var }}' , var ) return vertex , fragment | Insert snippets in a shader . | 465 | 6 |
239,667 | def on_draw ( self ) : # Skip the drawing if the program hasn't been built yet. # The program is built by the interact. if self . program : # Draw the program. self . program . draw ( self . gl_primitive_type ) else : # pragma: no cover logger . debug ( "Skipping drawing visual `%s` because the program " "has not been built yet." , self ) | Draw the visual . | 91 | 4 |
239,668 | def add_transform_chain ( self , tc ) : # Generate the transforms snippet. for t in tc . gpu_transforms : if isinstance ( t , Clip ) : # Set the varying value in the vertex shader. self . insert_vert ( 'v_temp_pos_tr = temp_pos_tr;' ) continue self . insert_vert ( t . glsl ( 'temp_pos_tr' ) ) # Clipping. clip = tc . get ( 'Clip' ) if clip : self . insert_frag ( clip . glsl ( 'v_temp_pos_tr' ) , 'before_transforms' ) | Insert the GLSL snippets of a transform chain . | 141 | 11 |
239,669 | def insert_into_shaders ( self , vertex , fragment ) : to_insert = defaultdict ( str ) to_insert . update ( { key : '\n' . join ( self . _to_insert [ key ] ) + '\n' for key in self . _to_insert } ) return _insert_glsl ( vertex , fragment , to_insert ) | Apply the insertions to shader code . | 81 | 8 |
239,670 | def add_visual ( self , visual ) : # Retrieve the visual's GLSL inserter. inserter = visual . inserter # Add the visual's transforms. inserter . add_transform_chain ( visual . transforms ) # Then, add the canvas' transforms. canvas_transforms = visual . canvas_transforms_filter ( self . transforms ) inserter . add_transform_chain ( canvas_transforms ) # Also, add the canvas' inserter. inserter += self . inserter # Now, we insert the transforms GLSL into the shaders. vs , fs = visual . vertex_shader , visual . fragment_shader vs , fs = inserter . insert_into_shaders ( vs , fs ) # Finally, we create the visual's program. visual . program = gloo . Program ( vs , fs ) logger . log ( 5 , "Vertex shader: %s" , vs ) logger . log ( 5 , "Fragment shader: %s" , fs ) # Initialize the size. visual . on_resize ( self . size ) # Register the visual in the list of visuals in the canvas. self . visuals . append ( visual ) self . events . visual_added ( visual = visual ) | Add a visual to the canvas and build its program by the same occasion . | 273 | 15 |
239,671 | def on_resize ( self , event ) : self . context . set_viewport ( 0 , 0 , event . size [ 0 ] , event . size [ 1 ] ) for visual in self . visuals : visual . on_resize ( event . size ) self . update ( ) | Resize the OpenGL context . | 61 | 6 |
239,672 | def on_draw ( self , e ) : gloo . clear ( ) for visual in self . visuals : logger . log ( 5 , "Draw visual `%s`." , visual ) visual . on_draw ( ) | Draw all visuals . | 47 | 4 |
239,673 | def update ( self ) : if not self . canvas : return for visual in self . canvas . visuals : self . update_program ( visual . program ) self . canvas . update ( ) | Update all visuals in the attached canvas . | 39 | 8 |
239,674 | def _add_log_file ( filename ) : handler = logging . FileHandler ( filename ) handler . setLevel ( logging . DEBUG ) formatter = _Formatter ( fmt = _logger_fmt , datefmt = '%Y-%m-%d %H:%M:%S' ) handler . setFormatter ( formatter ) logging . getLogger ( ) . addHandler ( handler ) | Create a phy . log log file with DEBUG level in the current directory . | 90 | 16 |
239,675 | def _run_cmd ( cmd , ctx , glob , loc ) : # pragma: no cover if PDB : _enable_pdb ( ) if IPYTHON : from IPython import start_ipython args_ipy = [ '-i' , '--gui=qt' ] ns = glob . copy ( ) ns . update ( loc ) return start_ipython ( args_ipy , user_ns = ns ) # Profiling. The builtin `profile` is added in __init__. prof = __builtins__ . get ( 'profile' , None ) if prof : prof = __builtins__ [ 'profile' ] return _profile ( prof , cmd , glob , loc ) return exec_ ( cmd , glob , loc ) | Run a command with optionally a debugger IPython or profiling . | 163 | 12 |
239,676 | def load_cli_plugins ( cli , config_dir = None ) : from . config import load_master_config config = load_master_config ( config_dir = config_dir ) plugins = discover_plugins ( config . Plugins . dirs ) for plugin in plugins : if not hasattr ( plugin , 'attach_to_cli' ) : # pragma: no cover continue logger . debug ( "Attach plugin `%s` to CLI." , _fullname ( plugin ) ) # NOTE: plugin is a class, so we need to instantiate it. try : plugin ( ) . attach_to_cli ( cli ) except Exception as e : # pragma: no cover logger . error ( "Error when loading plugin `%s`: %s" , plugin , e ) | Load all plugins and attach them to a CLI object . | 170 | 11 |
239,677 | def get_mouse_pos ( self , pos ) : position = np . asarray ( self . _normalize ( pos ) ) zoom = np . asarray ( self . _zoom_aspect ( ) ) pan = np . asarray ( self . pan ) mouse_pos = ( ( position / zoom ) - pan ) return mouse_pos | Return the mouse coordinates in NDC taking panzoom into account . | 74 | 14 |
239,678 | def pan ( self , value ) : assert len ( value ) == 2 self . _pan [ : ] = value self . _constrain_pan ( ) self . update ( ) | Pan translation . | 39 | 3 |
239,679 | def zoom ( self , value ) : if isinstance ( value , ( int , float ) ) : value = ( value , value ) assert len ( value ) == 2 self . _zoom = np . clip ( value , self . _zmin , self . _zmax ) # Constrain bounding box. self . _constrain_pan ( ) self . _constrain_zoom ( ) self . update ( ) | Zoom level . | 93 | 4 |
239,680 | def pan_delta ( self , d ) : dx , dy = d pan_x , pan_y = self . pan zoom_x , zoom_y = self . _zoom_aspect ( self . _zoom ) self . pan = ( pan_x + dx / zoom_x , pan_y + dy / zoom_y ) self . update ( ) | Pan the view by a given amount . | 80 | 8 |
239,681 | def zoom_delta ( self , d , p = ( 0. , 0. ) , c = 1. ) : dx , dy = d x0 , y0 = p pan_x , pan_y = self . _pan zoom_x , zoom_y = self . _zoom zoom_x_new , zoom_y_new = ( zoom_x * math . exp ( c * self . _zoom_coeff * dx ) , zoom_y * math . exp ( c * self . _zoom_coeff * dy ) ) zoom_x_new = max ( min ( zoom_x_new , self . _zmax ) , self . _zmin ) zoom_y_new = max ( min ( zoom_y_new , self . _zmax ) , self . _zmin ) self . zoom = zoom_x_new , zoom_y_new if self . _zoom_to_pointer : zoom_x , zoom_y = self . _zoom_aspect ( ( zoom_x , zoom_y ) ) zoom_x_new , zoom_y_new = self . _zoom_aspect ( ( zoom_x_new , zoom_y_new ) ) self . pan = ( pan_x - x0 * ( 1. / zoom_x - 1. / zoom_x_new ) , pan_y - y0 * ( 1. / zoom_y - 1. / zoom_y_new ) ) self . update ( ) | Zoom the view by a given amount . | 326 | 9 |
239,682 | def set_range ( self , bounds , keep_aspect = False ) : # a * (v0 + t) = -1 # a * (v1 + t) = +1 # => # a * (v1 - v0) = 2 bounds = np . asarray ( bounds , dtype = np . float64 ) v0 = bounds [ : 2 ] v1 = bounds [ 2 : ] pan = - .5 * ( v0 + v1 ) zoom = 2. / ( v1 - v0 ) if keep_aspect : zoom = zoom . min ( ) * np . ones ( 2 ) self . set_pan_zoom ( pan = pan , zoom = zoom ) | Zoom to fit a box . | 150 | 7 |
239,683 | def get_range ( self ) : p , z = np . asarray ( self . pan ) , np . asarray ( self . zoom ) x0 , y0 = - 1. / z - p x1 , y1 = + 1. / z - p return ( x0 , y0 , x1 , y1 ) | Return the bounds currently visible . | 71 | 6 |
239,684 | def on_mouse_move ( self , event ) : if event . modifiers : return if event . is_dragging : x0 , y0 = self . _normalize ( event . press_event . pos ) x1 , y1 = self . _normalize ( event . last_event . pos ) x , y = self . _normalize ( event . pos ) dx , dy = x - x1 , y - y1 if event . button == 1 : self . pan_delta ( ( dx , dy ) ) elif event . button == 2 : c = np . sqrt ( self . size [ 0 ] ) * .03 self . zoom_delta ( ( dx , dy ) , ( x0 , y0 ) , c = c ) | Pan and zoom with the mouse . | 163 | 7 |
239,685 | def on_mouse_wheel ( self , event ) : # NOTE: not called on OS X because of touchpad if event . modifiers : return dx = np . sign ( event . delta [ 1 ] ) * self . _wheel_coeff # Zoom toward the mouse pointer. x0 , y0 = self . _normalize ( event . pos ) self . zoom_delta ( ( dx , dx ) , ( x0 , y0 ) ) | Zoom with the mouse wheel . | 95 | 7 |
239,686 | def on_key_press ( self , event ) : # Zooming with the keyboard. key = event . key if event . modifiers : return # Pan. if self . enable_keyboard_pan and key in self . _arrows : self . _pan_keyboard ( key ) # Zoom. if key in self . _pm : self . _zoom_keyboard ( key ) # Reset with 'R'. if key == 'R' : self . reset ( ) | Pan and zoom with the keyboard . | 101 | 7 |
239,687 | def _replace_docstring_header ( paragraph ) : # Replace Markdown headers in docstrings with light headers in bold. paragraph = re . sub ( _docstring_header_pattern , r'*\1*' , paragraph , ) paragraph = re . sub ( _docstring_parameters_pattern , r'\n* `\1` (\2)\n' , paragraph , ) return paragraph | Process NumPy - like function docstrings . | 87 | 9 |
239,688 | def _iter_vars ( mod ) : vars = sorted ( var for var in dir ( mod ) if _is_public ( var ) ) for var in vars : yield getattr ( mod , var ) | Iterate through a list of variables define in a module s public namespace . | 46 | 15 |
239,689 | def _function_header ( subpackage , func ) : args = inspect . formatargspec ( * inspect . getfullargspec ( func ) ) return "{name}{args}" . format ( name = _full_name ( subpackage , func ) , args = args , ) | Generate the docstring of a function . | 58 | 9 |
239,690 | def _doc_method ( klass , func ) : argspec = inspect . getfullargspec ( func ) # Remove first 'self' argument. if argspec . args and argspec . args [ 0 ] == 'self' : del argspec . args [ 0 ] args = inspect . formatargspec ( * argspec ) header = "{klass}.{name}{args}" . format ( klass = klass . __name__ , name = _name ( func ) , args = args , ) docstring = _doc ( func ) return _concat ( header , docstring ) | Generate the docstring of a method . | 125 | 9 |
239,691 | def _doc_property ( klass , prop ) : header = "{klass}.{name}" . format ( klass = klass . __name__ , name = _name ( prop ) , ) docstring = _doc ( prop ) return _concat ( header , docstring ) | Generate the docstring of a property . | 61 | 9 |
239,692 | def _generate_paragraphs ( package , subpackages ) : # API doc of each module. for subpackage in _iter_subpackages ( package , subpackages ) : subpackage_name = subpackage . __name__ yield "## {}" . format ( subpackage_name ) # Subpackage documentation. yield _doc ( _import_module ( subpackage_name ) ) # List of top-level functions in the subpackage. for func in _iter_functions ( subpackage ) : yield '##### ' + _doc_function ( subpackage , func ) # All public classes. for klass in _iter_classes ( subpackage ) : # Class documentation. yield "### {}" . format ( _full_name ( subpackage , klass ) ) yield _doc ( klass ) yield "#### Methods" for method in _iter_methods ( klass , package ) : yield '##### ' + _doc_method ( klass , method ) yield "#### Properties" for prop in _iter_properties ( klass , package ) : yield '##### ' + _doc_property ( klass , prop ) | Generate the paragraphs of the API documentation . | 242 | 9 |
239,693 | def _add_field_column ( self , field ) : # pragma: no cover @ self . add_column ( name = field ) def get_my_label ( cluster_id ) : return self . cluster_meta . get ( field , cluster_id ) | Add a column for a given label field . | 57 | 9 |
239,694 | def _emit_select ( self , cluster_ids , * * kwargs ) : # Remove non-existing clusters from the selection. cluster_ids = self . _keep_existing_clusters ( cluster_ids ) logger . debug ( "Select cluster(s): %s." , ', ' . join ( map ( str , cluster_ids ) ) ) self . emit ( 'select' , cluster_ids , * * kwargs ) | Choose spikes from the specified clusters and emit the select event on the GUI . | 95 | 15 |
239,695 | def _update_cluster_view ( self ) : logger . log ( 5 , "Update the cluster view." ) cluster_ids = [ int ( c ) for c in self . clustering . cluster_ids ] self . cluster_view . set_rows ( cluster_ids ) | Initialize the cluster view with cluster data . | 60 | 9 |
239,696 | def _update_similarity_view ( self ) : if not self . similarity : return selection = self . cluster_view . selected if not len ( selection ) : return cluster_id = selection [ 0 ] cluster_ids = self . clustering . cluster_ids self . _best = cluster_id logger . log ( 5 , "Update the similarity view." ) # This is a list of pairs (closest_cluster, similarity). similarities = self . similarity ( cluster_id ) # We save the similarity values wrt the currently-selected clusters. # Note that we keep the order of the output of the self.similary() # function. clusters_sim = OrderedDict ( [ ( int ( cl ) , s ) for ( cl , s ) in similarities ] ) # List of similar clusters, remove non-existing ones. clusters = [ c for c in clusters_sim . keys ( ) if c in cluster_ids ] # The similarity view will use these values. self . _current_similarity_values = clusters_sim # Set the rows of the similarity view. # TODO: instead of the self._current_similarity_values hack, # give the possibility to specify the values here (?). self . similarity_view . set_rows ( [ c for c in clusters if c not in selection ] ) | Update the similarity view with matches for the specified clusters . | 282 | 11 |
239,697 | def on_cluster ( self , up ) : similar = self . similarity_view . selected # Reinitialize the cluster view if clusters have changed. if up . added : self . _update_cluster_view ( ) # Select all new clusters in view 1. if up . history == 'undo' : # Select the clusters that were selected before the undone # action. clusters_0 , clusters_1 = up . undo_state [ 0 ] [ 'selection' ] # Select rows in the tables. self . cluster_view . select ( clusters_0 , up = up ) self . similarity_view . select ( clusters_1 , up = up ) elif up . added : if up . description == 'assign' : # NOTE: we change the order such that the last selected # cluster (with a new color) is the split cluster. added = list ( up . added [ 1 : ] ) + [ up . added [ 0 ] ] else : added = up . added # Select the new clusters in the cluster view. self . cluster_view . select ( added , up = up ) if similar : self . similarity_view . next ( ) elif up . metadata_changed : # Select next in similarity view if all moved are in that view. if set ( up . metadata_changed ) <= set ( similar ) : next_cluster = self . similarity_view . get_next_id ( ) self . _update_similarity_view ( ) if next_cluster is not None : # Select the cluster in the similarity view. self . similarity_view . select ( [ next_cluster ] ) # Otherwise, select next in cluster view. else : self . _update_cluster_view ( ) # Determine if there is a next cluster set from a # previous clustering action. cluster = up . metadata_changed [ 0 ] next_cluster = self . cluster_meta . get ( 'next_cluster' , cluster ) logger . debug ( "Get next_cluster for %d: %s." , cluster , next_cluster ) # If there is not, fallback on the next cluster in the list. if next_cluster is None : self . cluster_view . select ( [ cluster ] , do_emit = False ) self . cluster_view . next ( ) else : self . cluster_view . select ( [ next_cluster ] ) | Update the cluster views after clustering actions . | 509 | 9 |
239,698 | def select ( self , * cluster_ids ) : # HACK: allow for `select(1, 2, 3)` in addition to `select([1, 2, 3])` # This makes it more convenient to select multiple clusters with # the snippet: `:c 1 2 3` instead of `:c 1,2,3`. if cluster_ids and isinstance ( cluster_ids [ 0 ] , ( tuple , list ) ) : cluster_ids = list ( cluster_ids [ 0 ] ) + list ( cluster_ids [ 1 : ] ) # Remove non-existing clusters from the selection. cluster_ids = self . _keep_existing_clusters ( cluster_ids ) # Update the cluster view selection. self . cluster_view . select ( cluster_ids ) | Select a list of clusters . | 166 | 6 |
239,699 | def merge ( self , cluster_ids = None , to = None ) : if cluster_ids is None : cluster_ids = self . selected if len ( cluster_ids or [ ] ) <= 1 : return self . clustering . merge ( cluster_ids , to = to ) self . _global_history . action ( self . clustering ) | Merge the selected clusters . | 73 | 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.