idx int64 0 63k | question stringlengths 53 5.28k | target stringlengths 5 805 |
|---|---|---|
5,000 | def weighted_mean ( data , weights = None ) : if weights is None : return mean ( data ) total_weight = float ( sum ( weights ) ) weights = [ weight / total_weight for weight in weights ] w_mean = 0 for i , weight in enumerate ( weights ) : w_mean += weight * data [ i ] return w_mean | Calculate the weighted mean of a list . |
5,001 | def median ( data ) : data . sort ( ) num_values = len ( data ) half = num_values // 2 if num_values % 2 : return data [ half ] return 0.5 * ( data [ half - 1 ] + data [ half ] ) | Calculate the median of a list . |
5,002 | def weighted_median ( data , weights = None ) : if weights is None : return median ( data ) midpoint = 0.5 * sum ( weights ) if any ( [ j > midpoint for j in weights ] ) : return data [ weights . index ( max ( weights ) ) ] if any ( [ j > 0 for j in weights ] ) : sorted_data , sorted_weights = zip ( * sorted ( zip ( data , weights ) ) ) cumulative_weight = 0 below_midpoint_index = 0 while cumulative_weight <= midpoint : below_midpoint_index += 1 cumulative_weight += sorted_weights [ below_midpoint_index - 1 ] cumulative_weight -= sorted_weights [ below_midpoint_index - 1 ] if cumulative_weight - midpoint < sys . float_info . epsilon : bounds = sorted_data [ below_midpoint_index - 2 : below_midpoint_index ] return sum ( bounds ) / float ( len ( bounds ) ) return sorted_data [ below_midpoint_index - 1 ] | Calculate the weighted median of a list . |
5,003 | def init_app ( self , app , config_prefix = None ) : config_prefix = ( config_prefix or 'REDIS' ) . rstrip ( '_' ) . upper ( ) if not hasattr ( app , 'extensions' ) : app . extensions = dict ( ) if config_prefix . lower ( ) in app . extensions : raise ValueError ( 'Already registered config prefix {0!r}.' . format ( config_prefix ) ) app . extensions [ config_prefix . lower ( ) ] = _RedisState ( self , app ) args = read_config ( app . config , config_prefix ) super ( Redis , self ) . __init__ ( ** args ) | Actual method to read Redis settings from app configuration and initialize the StrictRedis instance . |
5,004 | def _recursive_remove ( fs , path ) : if not fs . is_link ( path = path ) and fs . is_dir ( path = path ) : for child in fs . children ( path = path ) : _recursive_remove ( fs = fs , path = child ) fs . remove_empty_directory ( path = path ) else : fs . remove_file ( path = path ) | A recursive non - atomic directory removal . |
5,005 | def create ( name , create_file , open_file , remove_file , create_directory , list_directory , remove_empty_directory , temporary_directory , stat , lstat , link , readlink , realpath = _realpath , remove = _recursive_remove , ) : methods = dict ( create = create_file , open = lambda fs , path , mode = "r" : open_file ( fs = fs , path = path , mode = mode , ) , remove_file = remove_file , create_directory = create_directory , list_directory = list_directory , remove_empty_directory = remove_empty_directory , temporary_directory = temporary_directory , get_contents = _get_contents , set_contents = _set_contents , create_with_contents = _create_with_contents , remove = remove , removing = _removing , stat = stat , lstat = lstat , link = link , readlink = readlink , realpath = realpath , exists = _exists , is_dir = _is_dir , is_file = _is_file , is_link = _is_link , touch = _touch , children = _children , glob_children = _glob_children , ) return attr . s ( hash = True ) ( type ( name , ( object , ) , methods ) ) | Create a new kind of filesystem . |
5,006 | def _exists ( fs , path ) : try : fs . stat ( path ) except ( exceptions . FileNotFound , exceptions . NotADirectory ) : return False return True | Check that the given path exists on the filesystem . |
5,007 | def _is_dir ( fs , path ) : try : return stat . S_ISDIR ( fs . stat ( path ) . st_mode ) except exceptions . FileNotFound : return False | Check that the given path is a directory . |
5,008 | def _is_file ( fs , path ) : try : return stat . S_ISREG ( fs . stat ( path ) . st_mode ) except exceptions . FileNotFound : return False | Check that the given path is a file . |
5,009 | def _is_link ( fs , path ) : try : return stat . S_ISLNK ( fs . lstat ( path ) . st_mode ) except exceptions . FileNotFound : return False | Check that the given path is a symbolic link . |
5,010 | def list ( self , ** kwargs ) : return ModelList ( self . ghost . execute_get ( '%s/' % self . _type_name , ** kwargs ) , self . _type_name , self , kwargs , model_type = self . _model_type ) | Fetch a list of resources from the API . |
5,011 | def get ( self , id = None , slug = None , ** kwargs ) : if id : items = self . ghost . execute_get ( '%s/%s/' % ( self . _type_name , id ) , ** kwargs ) elif slug : items = self . ghost . execute_get ( '%s/slug/%s/' % ( self . _type_name , slug ) , ** kwargs ) else : raise GhostException ( 500 , 'Either the ID or the Slug of the resource needs to be specified' ) return self . _model_type ( items [ self . _type_name ] [ 0 ] ) | Fetch a resource from the API . Either the id or the slug has to be present . |
5,012 | def create ( self , ** kwargs ) : response = self . ghost . execute_post ( '%s/' % self . _type_name , json = { self . _type_name : [ kwargs ] } ) return self . _model_type ( response . get ( self . _type_name ) [ 0 ] ) | Creates a new resource . |
5,013 | def create ( self , ** kwargs ) : return super ( PostController , self ) . create ( ** self . _with_markdown ( kwargs ) ) | Creates a new post . When the markdown property is present it will be automatically converted to mobiledoc on v1 . + of the server . |
5,014 | def update ( self , id , ** kwargs ) : return super ( PostController , self ) . update ( id , ** self . _with_markdown ( kwargs ) ) | Updates an existing post . When the markdown property is present it will be automatically converted to mobiledoc on v1 . + of the server . |
5,015 | def define_residues_for_plotting_traj ( self , analysis_cutoff ) : self . residue_counts_fraction = { } for traj in self . residue_counts : self . residue_counts_fraction [ traj ] = { residue : float ( values ) / len ( self . contacts_per_timeframe [ traj ] ) for residue , values in self . residue_counts [ traj ] . items ( ) } for traj in self . residue_counts_fraction : for residue in self . residue_counts_fraction [ traj ] : self . frequency [ residue ] . append ( self . residue_counts_fraction [ traj ] [ residue ] ) self . topology_data . dict_of_plotted_res = { i : self . frequency [ i ] for i in self . frequency if sum ( self . frequency [ i ] ) > ( int ( len ( self . trajectory ) ) * analysis_cutoff ) } assert len ( self . topology_data . dict_of_plotted_res ) != 0 , "Nothing to draw for this ligand:(residue number: " + str ( self . topology_data . universe . ligand . resids [ 0 ] ) + " on the chain " + str ( self . topology_data . universe . ligand . segids [ 0 ] ) + ") - try reducing the analysis cutoff." | Since plotting all residues that have made contact with the ligand over a lenghty simulation is not always feasible or desirable . Therefore only the residues that have been in contact with ligand for a long amount of time will be plotted in the final image . |
5,016 | def detect_aromatic_rings_in_ligand ( self ) : self . ligrings = { } try : ring_info = self . topology_data . mol . GetRingInfo ( ) self . ligand_ring_num = ring_info . NumRings ( ) except Exception as e : m = Chem . MolFromPDBFile ( "lig.pdb" ) ring_info = m . GetRingInfo ( ) self . ligand_ring_num = ring_info . NumRings ( ) i = 0 for ring in range ( self . ligand_ring_num ) : if 4 < len ( ring_info . AtomRings ( ) [ ring ] ) <= 6 and False not in [ self . topology_data . mol . GetAtomWithIdx ( x ) . GetIsAromatic ( ) for x in ring_info . AtomRings ( ) [ ring ] ] : atom_ids_in_ring = [ ] for atom in ring_info . AtomRings ( ) [ ring ] : atom_ids_in_ring . append ( self . topology_data . universe . ligand . atoms [ atom ] . name ) self . ligrings [ i ] = atom_ids_in_ring i += 1 | Using rdkit to detect aromatic rings in ligand - size 4 - 6 atoms and all atoms are part of the ring . Saves this data in self . ligrings . |
5,017 | def define_all_protein_rings ( self ) : self . protein_rings = { } i = 0 for residue in self . topology_data . dict_of_plotted_res : for ring in self . rings : if ring [ 0 ] == residue [ 0 ] : atom_names = "" for atom in self . rings [ ring ] : atom_names = atom_names + " " + atom self . protein_rings [ i ] = self . topology_data . universe . select_atoms ( "resname " + residue [ 0 ] + " and resid " + residue [ 1 ] + " and segid " + residue [ 2 ] + " and name " + atom_names ) i += 1 | Make MDAnalysis atom selections for rings in protein residues that will be plotted in the final figure - since they are the only ones that should be analysed . Saves the rings in self . protein_rings dictionary . |
5,018 | def count_by_type ( self ) : pistack = defaultdict ( int ) for contact in self . timeseries : pkey = ( contact . ligandring , contact . type , contact . resid , contact . resname , contact . segid ) pistack [ pkey ] += 1 dtype = [ ( "ligand_ring_ids" , list ) , ( "type" , "|U4" ) , ( "resid" , int ) , ( "resname" , "|U4" ) , ( "segid" , "|U8" ) , ( "frequency" , float ) ] out = np . empty ( ( len ( pistack ) , ) , dtype = dtype ) tsteps = float ( len ( self . timesteps ) ) for cursor , ( key , count ) in enumerate ( pistack . iteritems ( ) ) : out [ cursor ] = key + ( count / tsteps , ) return out . view ( np . recarray ) | Count how many times each individual pi - pi interaction occured throughout the simulation . Returns numpy array . |
5,019 | def main ( master_dsn , slave_dsn , tables , blocking = False ) : assert master_dsn . startswith ( "mysql" ) logger = logging . getLogger ( __name__ ) logger . info ( "replicating tables: %s" % ", " . join ( tables ) ) repl_db_sub ( master_dsn , slave_dsn , tables ) mysql_pub ( master_dsn , blocking = blocking ) | DB Replication app . |
5,020 | def get_text_position_in_ax_coord ( ax , pos , scale = default_text_relative_padding ) : ratio = get_axes_ratio ( ax ) x , y = scale , scale if ratio > 1 : y /= ratio elif 0 < ratio : x *= ratio pos = pos . lower ( ) if pos == 'nw' : y = 1 - y elif pos == 'ne' : x , y = 1 - x , 1 - y elif pos == 'sw' : pass elif pos == 'se' : x = 1 - x else : raise ValueError ( "Unknown value for 'pos': %s" % ( str ( pos ) ) ) return x , y | Return text position corresponding to given pos . The text alignment in the bounding box should be set accordingly in order to have a good - looking layout . This corresponding text alignment can be obtained by get_text_alignment or get_text_position_and_inner_alignment function . |
5,021 | def get_text_position_and_inner_alignment ( ax , pos , scale = default_text_relative_padding , with_transAxes_kwargs = True ) : xy = get_text_position_in_ax_coord ( ax , pos , scale = scale ) alignment_fontdict = get_text_alignment ( pos ) if with_transAxes_kwargs : alignment_fontdict = { ** alignment_fontdict , ** { 'transform' : ax . transAxes } } return xy , alignment_fontdict | Return text position and its alignment in its bounding box . The returned position is given in Axes coordinate as defined in matplotlib documentation on transformation . |
5,022 | def get_text_position ( fig , ax , ha = 'left' , va = 'top' , pad_scale = 1.0 ) : try : pad_scale = float ( pad_scale ) except : raise TypeError ( "'pad_scale should be of type 'float'" ) for arg in [ va , ha ] : assert type ( arg ) is str arg = arg . lower ( ) ax_height , ax_width = get_ax_size_in_inch ( fig , ax ) length_x = ax . get_xlim ( ) [ 1 ] - ax . get_xlim ( ) [ 0 ] length_y = ax . get_ylim ( ) [ 1 ] - ax . get_ylim ( ) [ 0 ] inch2coord_x = length_x / ax_width inch2coord_y = length_y / ax_height ax_length_geom_average = ( ax_height * ax_width ) ** 0.5 pad_inch = ax_length_geom_average * 0.03 * pad_scale pad_inch_x , pad_inch_y = pad_inch , pad_inch pad_coord_x = pad_inch_x * inch2coord_x pad_coord_y = pad_inch_y * inch2coord_y if ha == 'left' : pos_x = ax . get_xlim ( ) [ 0 ] + pad_coord_x elif ha == 'right' : pos_x = ax . get_xlim ( ) [ 1 ] - pad_coord_x else : raise Exception ( "Unsupported value for 'ha'" ) if va in [ 'top' , 'up' , 'upper' ] : pos_y = ax . get_ylim ( ) [ 1 ] - pad_coord_y elif va in [ 'bottom' , 'down' , 'lower' ] : pos_y = ax . get_ylim ( ) [ 0 ] + pad_coord_y else : raise Exception ( "Unsupported value for 'va'" ) return pos_x , pos_y | Return text position inside of the given axis |
5,023 | def create_app ( config = None , config_obj = None ) : app = Flask ( __name__ ) configure_app ( app , config = config , config_obj = config_obj ) register_blueprints ( app ) bind_extensions ( app ) return app | Flask app factory function . |
5,024 | def configure_app ( app , config = None , config_obj = None ) : app . config . from_object ( config_obj or BaseConfig ) if config is not None : app . config . from_pyfile ( config ) | Configure application instance . |
5,025 | def bind_extensions ( app ) : app . db = app . config [ 'PUZZLE_BACKEND' ] app . db . init_app ( app ) bootstrap . init_app ( app ) markdown ( app ) @ app . template_filter ( 'islist' ) def islist ( object ) : return isinstance ( object , ( tuple , list ) ) | Configure extensions . |
5,026 | def find_donors_and_acceptors_in_ligand ( self ) : atom_names = [ x . name for x in self . topology_data . universe . ligand ] try : for atom in self . topology_data . mol . GetSubstructMatches ( self . HDonorSmarts , uniquify = 1 ) : self . donors . append ( atom_names [ atom [ 0 ] ] ) for atom in self . topology_data . mol . GetSubstructMatches ( self . HAcceptorSmarts , uniquify = 1 ) : self . acceptors . append ( atom_names [ atom [ 0 ] ] ) except Exception as e : m = Chem . MolFromPDBFile ( "lig.pdb" ) self . donors = [ ] self . acceptors = [ ] for atom in m . GetSubstructMatches ( self . HDonorSmarts , uniquify = 1 ) : self . donors . append ( atom_names [ atom [ 0 ] ] ) haccep = "[$([O,S;H1;v2]-[!$(*=[O,N,P,S])]),$([O,S;H0;v2]),$([O,S;-]),$([N;v3;!$(N-*=!@[O,N,P,S])]),$([nH0,o,s;+0])]" self . HAcceptorSmarts = Chem . MolFromSmarts ( haccep ) for atom in m . GetSubstructMatches ( self . HAcceptorSmarts , uniquify = 1 ) : self . acceptors . append ( atom_names [ atom [ 0 ] ] ) | Since MDAnalysis a pre - set list for acceptor and donor atoms for proteins and solvents from specific forcefields it is necessary to find donor and acceptor atoms for the ligand molecule . This function uses RDKit and searches through ligand atoms to find matches for pre - set list of possible donor and acceptor atoms . The resulting list is then parsed to MDAnalysis through the donors and acceptors arguments . |
5,027 | def count_by_type ( self , table , timesteps ) : hbonds = defaultdict ( int ) for contact in table : pkey = ( contact . donor_idx , contact . acceptor_idx , contact . donor_atom , contact . acceptor_atom , contact . donor_resnm , contact . donor_resid , contact . acceptor_resnm , contact . acceptor_resid ) hbonds [ pkey ] += 1 dtype = [ ( "donor_idx" , int ) , ( "acceptor_idx" , int ) , ( "donor_atom" , "|U4" ) , ( "acceptor_atom" , "|U4" ) , ( "donor_resnm" , "|U8" ) , ( "donor_resid" , "|U8" ) , ( "acceptor_resnm" , "|U8" ) , ( "acceptor_resid" , "|U8" ) , ( "frequency" , float ) ] out = np . empty ( ( len ( hbonds ) , ) , dtype = dtype ) tsteps = float ( len ( timesteps ) ) for cursor , ( key , count ) in enumerate ( hbonds . iteritems ( ) ) : out [ cursor ] = key + ( count / tsteps , ) return out . view ( np . recarray ) | Count how many times each individual hydrogen bonds occured throughout the simulation . Returns numpy array . |
5,028 | def determine_hbonds_for_drawing ( self , analysis_cutoff ) : self . frequency = defaultdict ( int ) for traj in self . hbonds_by_type : for bond in self . hbonds_by_type [ traj ] : if bond [ "donor_resnm" ] != "LIG" : self . frequency [ ( bond [ "donor_idx" ] , bond [ "acceptor_atom" ] , bond [ "donor_atom" ] , bond [ "acceptor_idx" ] ) ] += bond [ "frequency" ] else : self . frequency [ ( bond [ "acceptor_idx" ] , bond [ "donor_atom" ] , bond [ "acceptor_atom" ] , bond [ "donor_idx" ] ) ] += bond [ "frequency" ] self . frequency = { i : self . frequency [ i ] for i in self . frequency if self . frequency [ i ] > ( int ( len ( self . trajectory ) ) * analysis_cutoff ) } self . hbonds_for_drawing = { } for bond in self . frequency : atomname = bond [ 1 ] if atomname . startswith ( "O" , 0 ) or atomname . startswith ( "N" , 0 ) : lig_atom = atomname else : atomindex = [ index for index , atom in enumerate ( self . topology_data . universe . ligand . atoms ) if atom . name == atomname ] [ 0 ] rdkit_atom = self . topology_data . mol . GetAtomWithIdx ( atomindex ) for neigh in rdkit_atom . GetNeighbors ( ) : neigh_atom_id = neigh . GetIdx ( ) lig_atom = [ atom . name for index , atom in enumerate ( self . topology_data . universe . ligand . atoms ) if index == neigh_atom_id ] [ 0 ] self . hbonds_for_drawing [ ( bond [ 0 ] , lig_atom , bond [ 2 ] , bond [ 3 ] ) ] = self . frequency [ bond ] | Since plotting all hydrogen bonds could lead to a messy plot a cutoff has to be imple - mented . In this function the frequency of each hydrogen bond is summated and the total compared against analysis cutoff - a fraction multiplied by trajectory count . Those hydrogen bonds that are present for longer than analysis cutoff will be plotted in the final plot . |
5,029 | def convert2dbus ( value , signature ) : if len ( signature ) == 2 and signature . startswith ( 'a' ) : return dbus . Array ( value , signature = signature [ - 1 ] ) dbus_string_type = dbus . String if PY3 else dbus . UTF8String type_map = { 'b' : dbus . Boolean , 'y' : dbus . Byte , 'n' : dbus . Int16 , 'i' : dbus . Int32 , 'x' : dbus . Int64 , 'q' : dbus . UInt16 , 'u' : dbus . UInt32 , 't' : dbus . UInt64 , 'd' : dbus . Double , 'o' : dbus . ObjectPath , 'g' : dbus . Signature , 's' : dbus_string_type } return type_map [ signature ] ( value ) | Converts value type from python to dbus according signature . |
5,030 | def convert ( dbus_obj ) : _isinstance = partial ( isinstance , dbus_obj ) ConvertType = namedtuple ( 'ConvertType' , 'pytype dbustypes' ) pyint = ConvertType ( int , ( dbus . Byte , dbus . Int16 , dbus . Int32 , dbus . Int64 , dbus . UInt16 , dbus . UInt32 , dbus . UInt64 ) ) pybool = ConvertType ( bool , ( dbus . Boolean , ) ) pyfloat = ConvertType ( float , ( dbus . Double , ) ) pylist = ConvertType ( lambda _obj : list ( map ( convert , dbus_obj ) ) , ( dbus . Array , ) ) pytuple = ConvertType ( lambda _obj : tuple ( map ( convert , dbus_obj ) ) , ( dbus . Struct , ) ) types_str = ( dbus . ObjectPath , dbus . Signature , dbus . String ) if not PY3 : types_str += ( dbus . UTF8String , ) pystr = ConvertType ( str if PY3 else unicode , types_str ) pydict = ConvertType ( lambda _obj : dict ( zip ( map ( convert , dbus_obj . keys ( ) ) , map ( convert , dbus_obj . values ( ) ) ) ) , ( dbus . Dictionary , ) ) for conv in ( pyint , pybool , pyfloat , pylist , pytuple , pystr , pydict ) : if any ( map ( _isinstance , conv . dbustypes ) ) : return conv . pytype ( dbus_obj ) else : return dbus_obj | Converts dbus_obj from dbus type to python type . |
5,031 | def converter ( f ) : @ wraps ( f ) def wrapper ( * args , ** kwds ) : return convert ( f ( * args , ** kwds ) ) return wrapper | Decorator to convert value from dbus type to python type . |
5,032 | def exception_wrapper ( f ) : @ wraps ( f ) def wrapper ( * args , ** kwds ) : try : return f ( * args , ** kwds ) except dbus . exceptions . DBusException as err : _args = err . args raise PyMPRISException ( * _args ) return wrapper | Decorator to convert dbus exception to pympris exception . |
5,033 | def available_players ( ) : bus = dbus . SessionBus ( ) players = set ( ) for name in filter ( lambda item : item . startswith ( MPRIS_NAME_PREFIX ) , bus . list_names ( ) ) : owner_name = bus . get_name_owner ( name ) players . add ( convert ( owner_name ) ) return players | Searchs and returns set of unique names of objects which implements MPRIS2 interfaces . |
5,034 | def signal_wrapper ( f ) : @ wraps ( f ) def wrapper ( * args , ** kwds ) : args = map ( convert , args ) kwds = { convert ( k ) : convert ( v ) for k , v in kwds . items ( ) } return f ( * args , ** kwds ) return wrapper | Decorator converts function s arguments from dbus types to python . |
5,035 | def filter_properties_signals ( f , signal_iface_name ) : @ wraps ( f ) def wrapper ( iface , changed_props , invalidated_props , * args , ** kwargs ) : if iface == signal_iface_name : f ( changed_props , invalidated_props ) return wrapper | Filters signals by iface name . |
5,036 | def distance_function_match ( l1 , l2 , thresh , dist_fn , norm_funcs = [ ] ) : common = [ ] l1 = list ( enumerate ( l1 ) ) l2 = list ( enumerate ( l2 ) ) for norm_fn in norm_funcs : new_common , l1 , l2 = _match_by_norm_func ( l1 , l2 , lambda a : norm_fn ( a [ 1 ] ) , lambda a1 , a2 : dist_fn ( a1 [ 1 ] , a2 [ 1 ] ) , thresh ) common . extend ( ( c1 [ 0 ] , c2 [ 0 ] ) for c1 , c2 in new_common ) dist_matrix = [ [ dist_fn ( e1 , e2 ) for i2 , e2 in l2 ] for i1 , e1 in l1 ] components = BipartiteConnectedComponents ( ) for l1_i in range ( len ( l1 ) ) : for l2_i in range ( len ( l2 ) ) : if dist_matrix [ l1_i ] [ l2_i ] > thresh : continue components . add_edge ( l1_i , l2_i ) for l1_indices , l2_indices in components . get_connected_components ( ) : part_l1 = [ l1 [ i ] for i in l1_indices ] part_l2 = [ l2 [ i ] for i in l2_indices ] part_dist_matrix = [ [ dist_matrix [ l1_i ] [ l2_i ] for l2_i in l2_indices ] for l1_i in l1_indices ] part_cmn = _match_munkres ( part_l1 , part_l2 , part_dist_matrix , thresh ) common . extend ( ( c1 [ 0 ] , c2 [ 0 ] ) for c1 , c2 in part_cmn ) return common | Returns pairs of matching indices from l1 and l2 . |
5,037 | def _match_by_norm_func ( l1 , l2 , norm_fn , dist_fn , thresh ) : common = [ ] l1_only_idx = set ( range ( len ( l1 ) ) ) l2_only_idx = set ( range ( len ( l2 ) ) ) buckets_l1 = _group_by_fn ( enumerate ( l1 ) , lambda x : norm_fn ( x [ 1 ] ) ) buckets_l2 = _group_by_fn ( enumerate ( l2 ) , lambda x : norm_fn ( x [ 1 ] ) ) for normed , l1_elements in buckets_l1 . items ( ) : l2_elements = buckets_l2 . get ( normed , [ ] ) if not l1_elements or not l2_elements : continue _ , ( _ , e1_first ) = l1_elements [ 0 ] _ , ( _ , e2_first ) = l2_elements [ 0 ] match_is_ambiguous = not ( len ( l1_elements ) == len ( l2_elements ) and ( all ( e2 == e2_first for ( _ , ( _ , e2 ) ) in l2_elements ) or all ( e1 == e1_first for ( _ , ( _ , e1 ) ) in l1_elements ) ) ) if match_is_ambiguous : continue for ( e1_idx , e1 ) , ( e2_idx , e2 ) in zip ( l1_elements , l2_elements ) : if dist_fn ( e1 , e2 ) > thresh : continue l1_only_idx . remove ( e1_idx ) l2_only_idx . remove ( e2_idx ) common . append ( ( e1 , e2 ) ) l1_only = [ l1 [ i ] for i in l1_only_idx ] l2_only = [ l2 [ i ] for i in l2_only_idx ] return common , l1_only , l2_only | Matches elements in l1 and l2 using normalization functions . |
5,038 | def _match_munkres ( l1 , l2 , dist_matrix , thresh ) : equal_dist_matches = set ( ) m = Munkres ( ) indices = m . compute ( dist_matrix ) for l1_idx , l2_idx in indices : dst = dist_matrix [ l1_idx ] [ l2_idx ] if dst > thresh : continue for eq_l2_idx , eq_val in enumerate ( dist_matrix [ l1_idx ] ) : if abs ( dst - eq_val ) < 1e-9 : equal_dist_matches . add ( ( l1_idx , eq_l2_idx ) ) for eq_l1_idx , eq_row in enumerate ( dist_matrix ) : if abs ( dst - eq_row [ l2_idx ] ) < 1e-9 : equal_dist_matches . add ( ( eq_l1_idx , l2_idx ) ) return [ ( l1 [ l1_idx ] , l2 [ l2_idx ] ) for l1_idx , l2_idx in equal_dist_matches ] | Matches two lists using the Munkres algorithm . |
5,039 | def add_suspect ( self , case_obj , variant_obj ) : new_suspect = Suspect ( case = case_obj , variant_id = variant_obj . variant_id , name = variant_obj . display_name ) self . session . add ( new_suspect ) self . save ( ) return new_suspect | Link a suspect to a case . |
5,040 | def delete_suspect ( self , suspect_id ) : suspect_obj = self . suspect ( suspect_id ) logger . debug ( "Deleting suspect {0}" . format ( suspect_obj . name ) ) self . session . delete ( suspect_obj ) self . save ( ) | De - link a suspect from a case . |
5,041 | def configure_stream ( level = 'WARNING' ) : root_logger = logging . getLogger ( ) root_logger . setLevel ( level ) template = "[%(asctime)s] %(name)-25s %(levelname)-8s %(message)s" formatter = logging . Formatter ( template ) console = logging . StreamHandler ( ) console . setLevel ( level ) console . setFormatter ( formatter ) root_logger . addHandler ( console ) return root_logger | Configure root logger using a standard stream handler . |
5,042 | def _is_same_type_as_root ( self , obj ) : if not self . ALLOWS_SAME_TYPE_AS_ROOT_COLLECT : obj_model = get_model_from_instance ( obj ) obj_key = get_key_from_instance ( obj ) is_same_type_as_root = obj_model == self . root_obj_model and obj_key != self . root_obj_key if is_same_type_as_root : self . emit_event ( type = 'same_type_as_root' , obj = obj ) return is_same_type_as_root else : return False | Testing if we try to collect an object of the same type as root . This is not really a good sign because it means that we are going to collect a whole new tree that will maybe collect a new tree that will ... |
5,043 | def initialize ( self , data ) : for item in data : if hasattr ( self , item ) : setattr ( self , item , data [ item ] ) | initialize variable from loaded data |
5,044 | def _add_transcripts ( self , variant_obj , info_dict ) : vep_string = info_dict . get ( 'CSQ' ) snpeff_string = info_dict . get ( 'ANN' ) if vep_string : vep_info = get_vep_info ( vep_string = vep_string , vep_header = self . vep_header ) for transcript_info in vep_info : transcript = self . _get_vep_transcript ( transcript_info ) variant_obj . add_transcript ( transcript ) elif snpeff_string : snpeff_info = get_snpeff_info ( snpeff_string = snpeff_string , snpeff_header = self . snpeff_header ) for transcript_info in snpeff_info : transcript = self . _get_snpeff_transcript ( transcript_info ) variant_obj . add_transcript ( transcript ) | Return all transcripts sound in the vcf file |
5,045 | def _get_vep_transcript ( self , transcript_info ) : transcript = Transcript ( hgnc_symbol = transcript_info . get ( 'SYMBOL' ) , transcript_id = transcript_info . get ( 'Feature' ) , ensembl_id = transcript_info . get ( 'Gene' ) , biotype = transcript_info . get ( 'BIOTYPE' ) , consequence = transcript_info . get ( 'Consequence' ) , strand = transcript_info . get ( 'STRAND' ) , sift = transcript_info . get ( 'SIFT' ) , polyphen = transcript_info . get ( 'PolyPhen' ) , exon = transcript_info . get ( 'EXON' ) , HGVSc = transcript_info . get ( 'HGVSc' ) , HGVSp = transcript_info . get ( 'HGVSp' ) , GMAF = transcript_info . get ( 'GMAF' ) , ExAC_MAF = transcript_info . get ( 'ExAC_MAF' ) ) return transcript | Create a Transcript based on the vep annotation |
5,046 | def _get_snpeff_transcript ( self , transcript_info ) : transcript = Transcript ( hgnc_symbol = transcript_info . get ( 'Gene_Name' ) , transcript_id = transcript_info . get ( 'Feature' ) , ensembl_id = transcript_info . get ( 'Gene_ID' ) , biotype = transcript_info . get ( 'Transcript_BioType' ) , consequence = transcript_info . get ( 'Annotation' ) , exon = transcript_info . get ( 'Rank' ) , HGVSc = transcript_info . get ( 'HGVS.c' ) , HGVSp = transcript_info . get ( 'HGVS.p' ) ) return transcript | Create a transcript based on the snpeff annotation |
5,047 | def _makes_clone ( _func , * args , ** kw ) : self = args [ 0 ] . _clone ( ) _func ( self , * args [ 1 : ] , ** kw ) return self | A decorator that returns a clone of the current object so that we can re - use the object for similar requests . |
5,048 | def _handle_response ( self , response , data ) : if data and response . get ( 'content-type' , '' ) . split ( ';' ) [ 0 ] in ( 'application/json' , 'application/x-javascript' , 'text/javascript' , 'text/x-javascript' , 'text/x-json' ) : return json . loads ( data ) else : return data | Deserializes JSON if the content - type matches otherwise returns the response body as is . |
5,049 | def get_url ( self , * paths , ** params ) : path_stack = self . _attribute_stack [ : ] if paths : path_stack . extend ( paths ) u = self . _stack_collapser ( path_stack ) url = self . _url_template % { "domain" : self . _api_url , "generated_url" : u , } if self . _params or params : internal_params = self . _params . copy ( ) internal_params . update ( params ) url += self . _generate_params ( internal_params ) return url | Returns the URL for this request . |
5,050 | def _clone ( self ) : cls = self . __class__ q = cls . __new__ ( cls ) q . __dict__ = self . __dict__ . copy ( ) q . _params = self . _params . copy ( ) q . _headers = self . _headers . copy ( ) q . _attribute_stack = self . _attribute_stack [ : ] return q | Clones the state of the current operation . |
5,051 | def delete ( ctx , family_id , individual_id , root ) : root = root or ctx . obj . get ( 'root' ) or os . path . expanduser ( "~/.puzzle" ) if os . path . isfile ( root ) : logger . error ( "'root' can't be a file" ) ctx . abort ( ) logger . info ( "Root directory is: {}" . format ( root ) ) db_path = os . path . join ( root , 'puzzle_db.sqlite3' ) logger . info ( "db path is: {}" . format ( db_path ) ) if not os . path . exists ( db_path ) : logger . warn ( "database not initialized, run 'puzzle init'" ) ctx . abort ( ) store = SqlStore ( db_path ) if family_id : case_obj = store . case ( case_id = family_id ) if case_obj is None : logger . warning ( "Family {0} does not exist in database" . format ( family_id ) ) ctx . abort ( ) store . delete_case ( case_obj ) elif individual_id : ind_obj = store . individual ( ind_id = individual_id ) if ind_obj . ind_id != individual_id : logger . warning ( "Individual {0} does not exist in database" . format ( individual_id ) ) ctx . abort ( ) store . delete_individual ( ind_obj ) else : logger . warning ( "Please provide a family or individual id" ) ctx . abort ( ) | Delete a case or individual from the database . |
5,052 | def variants ( case_id ) : filters = parse_filters ( ) values = [ value for key , value in iteritems ( filters ) if not isinstance ( value , dict ) and key != 'skip' ] is_active = any ( values ) variants , nr_of_variants = app . db . variants ( case_id , skip = filters [ 'skip' ] , filters = { 'gene_ids' : filters [ 'gene_symbols' ] , 'frequency' : filters . get ( 'frequency' ) , 'cadd' : filters . get ( 'cadd' ) , 'sv_len' : filters . get ( 'sv_len' ) , 'consequence' : filters [ 'selected_consequences' ] , 'genetic_models' : filters [ 'selected_models' ] , 'sv_types' : filters [ 'selected_sv_types' ] , 'gene_lists' : filters [ 'gene_lists' ] , 'impact_severities' : filters [ 'impact_severities' ] , 'gemini_query' : filters [ 'gemini_query' ] , 'range' : filters [ 'range' ] , } ) gene_lists = ( [ gene_list . list_id for gene_list in app . db . gene_lists ( ) ] if app . config [ 'STORE_ENABLED' ] else [ ] ) queries = ( [ ( query . name or query . query , query . query ) for query in app . db . gemini_queries ( ) ] if app . config [ 'STORE_ENABLED' ] else [ ] ) kwargs = dict ( variants = variants , case_id = case_id , db = app . db , filters = filters , consequences = SO_TERMS , inheritance_models = INHERITANCE_MODELS_SHORT , gene_lists = gene_lists , impact_severities = IMPACT_LEVELS , is_active = is_active , nr_of_variants = nr_of_variants , queries = queries ) if app . db . variant_type == 'sv' : return render_template ( 'sv_variants.html' , sv_types = SV_TYPES , ** kwargs ) else : return render_template ( 'variants.html' , ** kwargs ) | Show all variants for a case . |
5,053 | def variant ( case_id , variant_id ) : case_obj = app . db . case ( case_id ) variant = app . db . variant ( case_id , variant_id ) if variant is None : return abort ( 404 , "variant not found" ) comments = app . db . comments ( variant_id = variant . md5 ) template = 'sv_variant.html' if app . db . variant_type == 'sv' else 'variant.html' return render_template ( template , variant = variant , case_id = case_id , comments = comments , case = case_obj ) | Show a single variant . |
5,054 | def parse_filters ( ) : genes_str = request . args . get ( 'gene_symbol' ) filters = { } for key in ( 'frequency' , 'cadd' , 'sv_len' ) : try : filters [ key ] = float ( request . args . get ( key ) ) except ( ValueError , TypeError ) : pass filters [ 'gene_symbols' ] = genes_str . split ( ',' ) if genes_str else None filters [ 'selected_models' ] = request . args . getlist ( 'inheritance_models' ) filters [ 'selected_consequences' ] = request . args . getlist ( 'consequences' ) filters [ 'selected_sv_types' ] = request . args . getlist ( 'sv_types' ) filters [ 'skip' ] = int ( request . args . get ( 'skip' , 0 ) ) filters [ 'gene_lists' ] = request . args . getlist ( 'gene_lists' ) filters [ 'gemini_query' ] = ( request . args . get ( 'gemini_query' ) or request . args . get ( 'preset_gemini_query' ) ) filters [ 'impact_severities' ] = request . args . getlist ( 'impact_severities' ) filters [ 'range' ] = None if request . args . get ( 'range' ) : chromosome , raw_pos = request . args . get ( 'range' ) . split ( ':' ) start , end = map ( int , raw_pos . split ( '-' ) ) filters [ 'range' ] = { 'chromosome' : chromosome , 'start' : start , 'end' : end } filters [ 'query_dict' ] = { key : request . args . getlist ( key ) for key in request . args . keys ( ) } filters [ 'query_dict' ] . update ( { 'skip' : ( filters [ 'skip' ] + 30 ) } ) return filters | Parse variant filters from the request object . |
5,055 | def suspects ( case_id , variant_id ) : case_obj = app . db . case ( case_id ) variant_obj = app . db . variant ( case_id , variant_id ) app . db . add_suspect ( case_obj , variant_obj ) return redirect ( request . referrer ) | Pin a variant as a suspect for a given case . |
5,056 | def queries ( ) : query = request . form [ 'query' ] name = request . form . get ( 'name' ) app . db . add_gemini_query ( name , query ) return redirect ( request . referrer ) | Store a new GEMINI query . |
5,057 | def load ( fp , object_pairs_hook = dict ) : return object_pairs_hook ( ( k , v ) for k , v , _ in parse ( fp ) if k is not None ) | Parse the contents of the ~io . IOBase . readline - supporting file - like object fp as a simple line - oriented . properties file and return a dict of the key - value pairs . |
5,058 | def loads ( s , object_pairs_hook = dict ) : fp = BytesIO ( s ) if isinstance ( s , binary_type ) else StringIO ( s ) return load ( fp , object_pairs_hook = object_pairs_hook ) | Parse the contents of the string s as a simple line - oriented . properties file and return a dict of the key - value pairs . |
5,059 | def _extractClipData ( self , audioClipSpec , showLogs = False ) : command = [ self . _ffmpegPath ] if not showLogs : command += [ '-nostats' , '-loglevel' , '0' ] command += [ '-i' , self . _audioFilePath , '-ss' , '%.3f' % audioClipSpec . start , '-t' , '%.3f' % audioClipSpec . duration ( ) , '-c' , 'copy' , '-map' , '0' , '-acodec' , 'libmp3lame' , '-ab' , '128k' , '-f' , 'mp3' ] metadata = { self . _textMetadataName : audioClipSpec . text } for k , v in metadata . items ( ) : command . append ( '-metadata' ) command . append ( "{}='{}'" . format ( k , v ) ) command . append ( 'pipe:1' ) return subprocess . check_output ( command ) | Extracts a single clip according to audioClipSpec . |
5,060 | def add_phenotype ( self , ind_obj , phenotype_id ) : if phenotype_id . startswith ( 'HP:' ) or len ( phenotype_id ) == 7 : logger . debug ( 'querying on HPO term' ) hpo_results = phizz . query_hpo ( [ phenotype_id ] ) else : logger . debug ( 'querying on OMIM term' ) hpo_results = phizz . query_disease ( [ phenotype_id ] ) added_terms = [ ] if hpo_results else None existing_ids = set ( term . phenotype_id for term in ind_obj . phenotypes ) for result in hpo_results : if result [ 'hpo_term' ] not in existing_ids : term = PhenotypeTerm ( phenotype_id = result [ 'hpo_term' ] , description = result [ 'description' ] ) logger . info ( 'adding new HPO term: %s' , term . phenotype_id ) ind_obj . phenotypes . append ( term ) added_terms . append ( term ) logger . debug ( 'storing new HPO terms' ) self . save ( ) if added_terms is not None and len ( added_terms ) > 0 : for case_obj in ind_obj . cases : self . update_hpolist ( case_obj ) return added_terms | Add a phenotype term to the case . |
5,061 | def update_hpolist ( self , case_obj ) : hpo_list = self . case_genelist ( case_obj ) hpo_results = hpo_genes ( case_obj . phenotype_ids ( ) , * self . phenomizer_auth ) if hpo_results is None : pass else : gene_ids = [ result [ 'gene_id' ] for result in hpo_results if result [ 'gene_id' ] ] hpo_list . gene_ids = gene_ids self . save ( ) | Update the HPO gene list for a case based on current terms . |
5,062 | def remove_phenotype ( self , ind_obj , phenotypes = None ) : if phenotypes is None : logger . info ( "delete all phenotypes related to %s" , ind_obj . ind_id ) self . query ( PhenotypeTerm ) . filter_by ( ind_id = ind_obj . id ) . delete ( ) else : for term in ind_obj . phenotypes : if term . phenotype_id in phenotypes : logger . info ( "delete phenotype: %s from %s" , term . phenotype_id , ind_obj . ind_id ) self . session . delete ( term ) logger . debug ( 'persist removals' ) self . save ( ) for case_obj in ind_obj . cases : self . update_hpolist ( case_obj ) | Remove multiple phenotypes from an individual . |
5,063 | def match ( mode_lst : list , obj : 'object that has __destruct__ method' ) : try : structure = obj . __destruct__ ( ) except AttributeError : return False n = len ( mode_lst ) if n > len ( structure ) : return False for i in range ( n ) : mode = mode_lst [ i ] elem = obj [ i ] if isinstance ( mode , PatternList ) : if not match ( mode , elem ) : return False elif mode is P : mode_lst [ i ] = elem elif mode is any : pass elif mode != elem : return False return True | >>> from Redy . ADT . Core import match data P >>> from Redy . ADT . traits import ConsInd Discrete >>> |
5,064 | def gemini_query ( self , query_id ) : logger . debug ( "Looking for query with id {0}" . format ( query_id ) ) return self . query ( GeminiQuery ) . filter_by ( id = query_id ) . first ( ) | Return a gemini query |
5,065 | def add_gemini_query ( self , name , query ) : logger . info ( "Adding query {0} with text {1}" . format ( name , query ) ) new_query = GeminiQuery ( name = name , query = query ) self . session . add ( new_query ) self . save ( ) return new_query | Add a user defined gemini query |
5,066 | def delete_gemini_query ( self , query_id ) : query_obj = self . gemini_query ( query_id ) logger . debug ( "Delete query: {0}" . format ( query_obj . name_query ) ) self . session . delete ( query_obj ) self . save ( ) | Delete a gemini query |
5,067 | def distance_to ( self , point , unit = 'km' ) : assert isinstance ( point , GeoPoint ) , ( 'Other point should also be a Point instance.' ) if self == point : return 0.0 coefficient = 69.09 theta = self . longitude - point . longitude unit = unit . lower ( ) if unit else None distance = math . degrees ( math . acos ( math . sin ( self . rad_latitude ) * math . sin ( point . rad_latitude ) + math . cos ( self . rad_latitude ) * math . cos ( point . rad_latitude ) * math . cos ( math . radians ( theta ) ) ) ) * coefficient if unit == 'km' : return utils . mi_to_km ( distance ) return distance | Calculate distance in miles or kilometers between current and other passed point . |
5,068 | def rad_latitude ( self ) : if self . _rad_latitude is None : self . _rad_latitude = math . radians ( self . latitude ) return self . _rad_latitude | Lazy conversion degrees latitude to radians . |
5,069 | def rad_longitude ( self ) : if self . _rad_longitude is None : self . _rad_longitude = math . radians ( self . longitude ) return self . _rad_longitude | Lazy conversion degrees longitude to radians . |
5,070 | def send ( term , stream ) : payload = erlang . term_to_binary ( term ) header = struct . pack ( '!I' , len ( payload ) ) stream . write ( header ) stream . write ( payload ) stream . flush ( ) | Write an Erlang term to an output stream . |
5,071 | def recv ( stream ) : header = stream . read ( 4 ) if len ( header ) != 4 : return None ( length , ) = struct . unpack ( '!I' , header ) payload = stream . read ( length ) if len ( payload ) != length : return None term = erlang . binary_to_term ( payload ) return term | Read an Erlang term from an input stream . |
5,072 | def recv_loop ( stream ) : message = recv ( stream ) while message : yield message message = recv ( stream ) | Yield Erlang terms from an input stream . |
5,073 | def _add_genotype_calls ( self , variant_obj , variant_line , case_obj ) : variant_line = variant_line . split ( '\t' ) if len ( variant_line ) > 8 : gt_format = variant_line [ 8 ] . split ( ':' ) for individual in case_obj . individuals : sample_id = individual . ind_id index = individual . ind_index gt_call = variant_line [ 9 + index ] . split ( ':' ) raw_call = dict ( zip ( gt_format , gt_call ) ) genotype = Genotype ( ** raw_call ) variant_obj . add_individual ( puzzle_genotype ( sample_id = sample_id , genotype = genotype . genotype , case_id = case_obj . name , phenotype = individual . phenotype , ref_depth = genotype . ref_depth , alt_depth = genotype . alt_depth , genotype_quality = genotype . genotype_quality , depth = genotype . depth_of_coverage , supporting_evidence = genotype . supporting_evidence , pe_support = genotype . pe_support , sr_support = genotype . sr_support , ) ) | Add the genotype calls for the variant |
5,074 | def with_prefix ( self , root_path ) : return Conflict ( self . conflict_type , root_path + self . path , self . body ) | Returns a new conflict with a prepended prefix as a path . |
5,075 | def to_json ( self ) : path = self . path if self . conflict_type in ( 'REORDER' , 'SET_FIELD' ) : op = 'replace' elif self . conflict_type in ( 'MANUAL_MERGE' , 'ADD_BACK_TO_HEAD' ) : op = 'add' path += ( '-' , ) elif self . conflict_type == 'REMOVE_FIELD' : op = 'remove' else : raise ValueError ( 'Conflict Type %s can not be mapped to a json-patch operation' % conflict_type ) json_pointer = '/' + '/' . join ( str ( el ) for el in path ) conflict_values = force_list ( self . body ) conflicts = [ ] for value in conflict_values : if value is not None or self . conflict_type == 'REMOVE_FIELD' : conflicts . append ( { 'path' : json_pointer , 'op' : op , 'value' : value , '$type' : self . conflict_type } ) return json . dumps ( conflicts ) | Deserializes conflict to a JSON object . |
5,076 | def dump ( props , fp , separator = '=' , comments = None , timestamp = True , sort_keys = False ) : if comments is not None : print ( to_comment ( comments ) , file = fp ) if timestamp is not None and timestamp is not False : print ( to_comment ( java_timestamp ( timestamp ) ) , file = fp ) for k , v in itemize ( props , sort_keys = sort_keys ) : print ( join_key_value ( k , v , separator ) , file = fp ) | Write a series of key - value pairs to a file in simple line - oriented . properties format . |
5,077 | def dumps ( props , separator = '=' , comments = None , timestamp = True , sort_keys = False ) : s = StringIO ( ) dump ( props , s , separator = separator , comments = comments , timestamp = timestamp , sort_keys = sort_keys ) return s . getvalue ( ) | Convert a series of key - value pairs to a text string in simple line - oriented . properties format . |
5,078 | def join_key_value ( key , value , separator = '=' ) : r return escape ( key ) + separator + re . sub ( r'^ +' , lambda m : r'\ ' * m . end ( ) , _base_escape ( value ) ) | r Join a key and value together into a single line suitable for adding to a simple line - oriented . properties file . No trailing newline is added . |
5,079 | def GetPlaylists ( self , start , max_count , order , reversed ) : cv = convert2dbus return self . iface . GetPlaylists ( cv ( start , 'u' ) , cv ( max_count , 'u' ) , cv ( order , 's' ) , cv ( reversed , 'b' ) ) | Gets a set of playlists . |
5,080 | def init_app ( self , app ) : self . algorithm = app . config . get ( 'HASHING_METHOD' , 'sha256' ) if self . algorithm not in algs : raise ValueError ( '{} not one of {}' . format ( self . algorithm , algs ) ) self . rounds = app . config . get ( 'HASHING_ROUNDS' , 1 ) if not isinstance ( self . rounds , int ) : raise TypeError ( 'HASHING_ROUNDS must be type int' ) | Initializes the Flask application with this extension . It grabs the necessary configuration values from app . config those being HASHING_METHOD and HASHING_ROUNDS . HASHING_METHOD defaults to sha256 but can be any one of hashlib . algorithms . HASHING_ROUNDS specifies the number of times to hash the input with the specified algorithm . This defaults to 1 . |
5,081 | def hash_value ( self , value , salt = '' ) : def hashit ( value , salt ) : h = hashlib . new ( self . algorithm ) tgt = salt + value h . update ( tgt ) return h . hexdigest ( ) def fix_unicode ( value ) : if VER < 3 and isinstance ( value , unicode ) : value = str ( value ) elif VER >= 3 and isinstance ( value , str ) : value = str . encode ( value ) return value salt = fix_unicode ( salt ) for i in range ( self . rounds ) : value = fix_unicode ( value ) value = hashit ( value , salt ) return value | Hashes the specified value combined with the specified salt . The hash is done HASHING_ROUNDS times as specified by the application configuration . |
5,082 | def check_value ( self , value_hash , value , salt = '' ) : h = self . hash_value ( value , salt = salt ) return h == value_hash | Checks the specified hash value against the hash of the provided salt and value . |
5,083 | def AddTrack ( self , uri , after_track , set_as_current ) : self . iface . AddTrack ( uri , convert2dbus ( after_track , 'o' ) , convert2dbus ( set_as_current , 'b' ) ) | Adds a URI in the TrackList . |
5,084 | def delete_gene ( self , * gene_ids ) : self . gene_ids = [ gene_id for gene_id in self . gene_ids if gene_id not in gene_ids ] | Delete one or more gene ids form the list . |
5,085 | def healthy_update_timer ( self ) : state = None if self . update_status_timer and self . update_status_timer . is_alive ( ) : _LOGGER . debug ( "Timer: healthy" ) state = True else : _LOGGER . debug ( "Timer: not healthy" ) state = False return state | Check state of update timer . |
5,086 | def initialize ( self ) : self . network_status = self . get_network_status ( ) self . name = self . network_status . get ( 'network_name' , 'Unknown' ) self . location_info = self . get_location_info ( ) self . device_info = self . get_device_info ( ) self . device_id = ( self . device_info . get ( 'device_id' ) if self . device_info else "Unknown" ) self . initialize_socket ( ) self . initialize_worker ( ) self . initialize_zones ( ) | initialize the object |
5,087 | def initialize_socket ( self ) : try : _LOGGER . debug ( "Trying to open socket." ) self . _socket = socket . socket ( socket . AF_INET , socket . SOCK_DGRAM ) self . _socket . bind ( ( '' , self . _udp_port ) ) except socket . error as err : raise err else : _LOGGER . debug ( "Socket open." ) socket_thread = threading . Thread ( name = "SocketThread" , target = socket_worker , args = ( self . _socket , self . messages , ) ) socket_thread . setDaemon ( True ) socket_thread . start ( ) | initialize the socket |
5,088 | def initialize_worker ( self ) : worker_thread = threading . Thread ( name = "WorkerThread" , target = message_worker , args = ( self , ) ) worker_thread . setDaemon ( True ) worker_thread . start ( ) | initialize the worker thread |
5,089 | def initialize_zones ( self ) : zone_list = self . location_info . get ( 'zone_list' , { 'main' : True } ) for zone_id in zone_list : if zone_list [ zone_id ] : self . zones [ zone_id ] = Zone ( self , zone_id = zone_id ) else : _LOGGER . debug ( "Ignoring zone: %s" , zone_id ) | initialize receiver zones |
5,090 | def handle_status ( self ) : status = self . get_status ( ) if status : self . zones [ 'main' ] . update_status ( status ) | Handle status from device |
5,091 | def handle_netusb ( self , message ) : needs_update = 0 if self . _yamaha : if 'play_info_updated' in message : play_info = self . get_play_info ( ) if play_info : new_media_status = MediaStatus ( play_info , self . _ip_address ) if self . _yamaha . media_status != new_media_status : self . _yamaha . new_media_status ( new_media_status ) needs_update += 1 playback = play_info . get ( 'playback' ) if playback == "play" : new_status = STATE_PLAYING elif playback == "stop" : new_status = STATE_IDLE elif playback == "pause" : new_status = STATE_PAUSED else : new_status = STATE_UNKNOWN if self . _yamaha . status is not new_status : _LOGGER . debug ( "playback: %s" , new_status ) self . _yamaha . status = new_status needs_update += 1 return needs_update | Handles netusb in message |
5,092 | def handle_features ( self , device_features ) : self . device_features = device_features if device_features and 'zone' in device_features : for zone in device_features [ 'zone' ] : zone_id = zone . get ( 'id' ) if zone_id in self . zones : _LOGGER . debug ( "handle_features: %s" , zone_id ) input_list = zone . get ( 'input_list' , [ ] ) input_list . sort ( ) self . zones [ zone_id ] . source_list = input_list | Handles features of the device |
5,093 | def handle_event ( self , message ) : needs_update = 0 for zone in self . zones : if zone in message : _LOGGER . debug ( "Received message for zone: %s" , zone ) self . zones [ zone ] . update_status ( message [ zone ] ) if 'netusb' in message : needs_update += self . handle_netusb ( message [ 'netusb' ] ) if needs_update > 0 : _LOGGER . debug ( "needs_update: %d" , needs_update ) self . update_hass ( ) | Dispatch all event messages |
5,094 | def update_status ( self , reset = False ) : if self . healthy_update_timer and not reset : return if not self . device_features : self . handle_features ( self . get_features ( ) ) self . handle_status ( ) self . setup_update_timer ( ) | Update device status . |
5,095 | def setup_update_timer ( self , reset = False ) : _LOGGER . debug ( "Timer: firing again in %d seconds" , self . _interval ) self . update_status_timer = threading . Timer ( self . _interval , self . update_status , [ True ] ) self . update_status_timer . setDaemon ( True ) self . update_status_timer . start ( ) | Schedule a Timer Thread . |
5,096 | def set_playback ( self , playback ) : req_url = ENDPOINTS [ "setPlayback" ] . format ( self . _ip_address ) params = { "playback" : playback } return request ( req_url , params = params ) | Send Playback command . |
5,097 | def build_gemini_query ( self , query , extra_info ) : if 'WHERE' in query : return "{0} AND {1}" . format ( query , extra_info ) else : return "{0} WHERE {1}" . format ( query , extra_info ) | Append sql to a gemini query |
5,098 | def variants ( self , case_id , skip = 0 , count = 1000 , filters = None ) : filters = filters or { } logger . debug ( "Looking for variants in {0}" . format ( case_id ) ) limit = count + skip gemini_query = filters . get ( 'gemini_query' ) or "SELECT * from variants v" any_filter = False if filters . get ( 'frequency' ) : frequency = filters [ 'frequency' ] extra_info = "(v.max_aaf_all < {0} or v.max_aaf_all is" " Null)" . format ( frequency ) gemini_query = self . build_gemini_query ( gemini_query , extra_info ) if filters . get ( 'cadd' ) : cadd_score = filters [ 'cadd' ] extra_info = "(v.cadd_scaled > {0})" . format ( cadd_score ) gemini_query = self . build_gemini_query ( gemini_query , extra_info ) if filters . get ( 'gene_ids' ) : gene_list = [ gene_id . strip ( ) for gene_id in filters [ 'gene_ids' ] ] gene_string = "v.gene in (" for index , gene_id in enumerate ( gene_list ) : if index == 0 : gene_string += "'{0}'" . format ( gene_id ) else : gene_string += ", '{0}'" . format ( gene_id ) gene_string += ")" gemini_query = self . build_gemini_query ( gemini_query , gene_string ) if filters . get ( 'range' ) : chrom = filters [ 'range' ] [ 'chromosome' ] if not chrom . startswith ( 'chr' ) : chrom = "chr{0}" . format ( chrom ) range_string = "v.chrom = '{0}' AND " "((v.start BETWEEN {1} AND {2}) OR " "(v.end BETWEEN {1} AND {2}))" . format ( chrom , filters [ 'range' ] [ 'start' ] , filters [ 'range' ] [ 'end' ] ) gemini_query = self . build_gemini_query ( gemini_query , range_string ) filtered_variants = self . _variants ( case_id = case_id , gemini_query = gemini_query , ) if filters . get ( 'consequence' ) : consequences = set ( filters [ 'consequence' ] ) filtered_variants = ( variant for variant in filtered_variants if set ( variant . consequences ) . intersection ( consequences ) ) if filters . get ( 'impact_severities' ) : severities = set ( [ severity . strip ( ) for severity in filters [ 'impact_severities' ] ] ) new_filtered_variants = [ ] filtered_variants = ( variant for variant in filtered_variants if set ( [ variant . impact_severity ] ) . intersection ( severities ) ) if filters . get ( 'sv_len' ) : sv_len = int ( filters [ 'sv_len' ] ) filtered_variants = ( variant for variant in filtered_variants if variant . sv_len >= sv_len ) variants = [ ] for index , variant_obj in enumerate ( filtered_variants ) : if index >= skip : if index < limit : variants . append ( variant_obj ) else : break return Results ( variants , len ( variants ) ) | Return count variants for a case . |
5,099 | def _variants ( self , case_id , gemini_query ) : individuals = [ ] case_obj = self . case ( case_id ) for individual in case_obj . individuals : individuals . append ( individual ) self . db = case_obj . variant_source self . variant_type = case_obj . variant_type gq = GeminiQuery ( self . db ) gq . run ( gemini_query ) index = 0 for gemini_variant in gq : variant = None is_variant = self . _is_variant ( gemini_variant , individuals ) if self . variant_type == 'snv' and not is_variant : variant = None else : index += 1 logger . debug ( "Updating index to: {0}" . format ( index ) ) variant = self . _format_variant ( case_id = case_id , gemini_variant = gemini_variant , individual_objs = individuals , index = index ) if variant : yield variant | Return variants found in the gemini database |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.