idx int64 0 251k | question stringlengths 53 3.53k | target stringlengths 5 1.23k | len_question int64 20 893 | len_target int64 3 238 |
|---|---|---|---|---|
245,800 | def indirect_age_standardization ( e , b , s_e , s_b , n , alpha = 0.05 ) : smr = standardized_mortality_ratio ( e , b , s_e , s_b , n ) s_r_all = sum ( s_e * 1.0 ) / sum ( s_b * 1.0 ) adjusted_r = s_r_all * smr e_by_n = sum_by_n ( e , 1.0 , n ) log_smr = np . log ( smr ) log_smr_sd = 1.0 / np . sqrt ( e_by_n ) norm_th... | A utility function to compute rate through indirect age standardization | 278 | 11 |
245,801 | def _univariate_handler ( df , cols , stat = None , w = None , inplace = True , pvalue = 'sim' , outvals = None , swapname = '' , * * kwargs ) : ### Preprocess if not inplace : new_df = df . copy ( ) _univariate_handler ( new_df , cols , stat = stat , w = w , pvalue = pvalue , inplace = True , outvals = outvals , swapn... | Compute a univariate descriptive statistic stat over columns cols in df . | 644 | 15 |
245,802 | def _bivariate_handler ( df , x , y = None , w = None , inplace = True , pvalue = 'sim' , outvals = None , * * kwargs ) : real_swapname = kwargs . pop ( 'swapname' , '' ) if isinstance ( y , str ) : y = [ y ] if isinstance ( x , str ) : x = [ x ] if not inplace : new_df = df . copy ( ) _bivariate_handler ( new_df , x ,... | Compute a descriptive bivariate statistic over two sets of columns x and y contained in df . | 299 | 19 |
245,803 | def _swap_ending ( s , ending , delim = '_' ) : parts = [ x for x in s . split ( delim ) [ : - 1 ] if x != '' ] parts . append ( ending ) return delim . join ( parts ) | Replace the ending of a string delimited into an arbitrary number of chunks by delim with the ending provided | 54 | 21 |
245,804 | def is_sequence ( i , include = None ) : return ( hasattr ( i , '__getitem__' ) and iterable ( i ) or bool ( include ) and isinstance ( i , include ) ) | Return a boolean indicating whether i is a sequence in the SymPy sense . If anything that fails the test below should be included as being a sequence for your application set include to that object s type ; multiple types should be passed as a tuple of types . | 46 | 51 |
245,805 | def as_int ( n ) : try : result = int ( n ) if result != n : raise TypeError except TypeError : raise ValueError ( '%s is not an integer' % n ) return result | Convert the argument to a builtin integer . | 45 | 10 |
245,806 | def default_sort_key ( item , order = None ) : from sympy . core import S , Basic from sympy . core . sympify import sympify , SympifyError from sympy . core . compatibility import iterable if isinstance ( item , Basic ) : return item . sort_key ( order = order ) if iterable ( item , exclude = string_types ) : if isins... | Return a key that can be used for sorting . | 332 | 10 |
245,807 | def var ( names , * * args ) : def traverse ( symbols , frame ) : """Recursively inject symbols to the global namespace. """ for symbol in symbols : if isinstance ( symbol , Basic ) : frame . f_globals [ symbol . __str__ ( ) ] = symbol # Once we hace an undefined function class # implemented, put a check for function h... | Create symbols and inject them into the global namespace . | 197 | 10 |
245,808 | def _combine_attribute_arguments ( self , attr_dict , attr ) : # Note: Code & comments unchanged from DirectedHypergraph # If no attribute dict was passed, treat the keyword # arguments as the dict if attr_dict is None : attr_dict = attr # Otherwise, combine the passed attribute dict with # the keyword arguments else :... | Combines attr_dict and attr dictionaries by updating attr_dict with attr . | 118 | 21 |
245,809 | def remove_node ( self , node ) : if not self . has_node ( node ) : raise ValueError ( "No such node exists." ) # Loop over every hyperedge in the star of the node; # i.e., over every hyperedge that contains the node for hyperedge_id in self . _star [ node ] : frozen_nodes = self . _hyperedge_attributes [ hyperedge_id ... | Removes a node and its attributes from the hypergraph . Removes every hyperedge that contains this node . | 193 | 23 |
245,810 | def add_hyperedge ( self , nodes , attr_dict = None , * * attr ) : attr_dict = self . _combine_attribute_arguments ( attr_dict , attr ) # Don't allow empty node set (invalid hyperedge) if not nodes : raise ValueError ( "nodes argument cannot be empty." ) # Use frozensets for node sets to allow for hashable keys frozen_... | Adds a hyperedge to the hypergraph along with any related attributes of the hyperedge . This method will automatically add any node from the node set that was not in the hypergraph . A hyperedge without a weight attribute specified will be assigned the default value of 1 . | 469 | 57 |
245,811 | def add_hyperedges ( self , hyperedges , attr_dict = None , * * attr ) : attr_dict = self . _combine_attribute_arguments ( attr_dict , attr ) hyperedge_ids = [ ] for nodes in hyperedges : hyperedge_id = self . add_hyperedge ( nodes , attr_dict . copy ( ) ) hyperedge_ids . append ( hyperedge_id ) return hyperedge_ids | Adds multiple hyperedges to the graph along with any related attributes of the hyperedges . If any node of a hyperedge has not previously been added to the hypergraph it will automatically be added here . Hyperedges without a weight attribute specified will be assigned the default value of 1 . | 112 | 61 |
245,812 | def get_hyperedge_id ( self , nodes ) : frozen_nodes = frozenset ( nodes ) if not self . has_hyperedge ( frozen_nodes ) : raise ValueError ( "No such hyperedge exists." ) return self . _node_set_to_hyperedge [ frozen_nodes ] | From a set of nodes returns the ID of the hyperedge that this set comprises . | 76 | 18 |
245,813 | def get_hyperedge_attribute ( self , hyperedge_id , attribute_name ) : # Note: Code unchanged from DirectedHypergraph if not self . has_hyperedge_id ( hyperedge_id ) : raise ValueError ( "No such hyperedge exists." ) elif attribute_name not in self . _hyperedge_attributes [ hyperedge_id ] : raise ValueError ( "No such ... | Given a hyperedge ID and the name of an attribute get a copy of that hyperedge s attribute . | 132 | 23 |
245,814 | def get_hyperedge_attributes ( self , hyperedge_id ) : if not self . has_hyperedge_id ( hyperedge_id ) : raise ValueError ( "No such hyperedge exists." ) dict_to_copy = self . _hyperedge_attributes [ hyperedge_id ] . items ( ) attributes = { } for attr_name , attr_value in dict_to_copy : if attr_name != "__frozen_nodes... | Given a hyperedge ID get a dictionary of copies of that hyperedge s attributes . | 135 | 19 |
245,815 | def get_star ( self , node ) : if node not in self . _node_attributes : raise ValueError ( "No such node exists." ) return self . _star [ node ] . copy ( ) | Given a node get a copy of that node s star that is the set of hyperedges that the node belongs to . | 45 | 25 |
245,816 | def _F_outdegree ( H , F ) : if not isinstance ( H , DirectedHypergraph ) : raise TypeError ( "Algorithm only applicable to directed hypergraphs" ) return F ( [ len ( H . get_forward_star ( node ) ) for node in H . get_node_set ( ) ] ) | Returns the result of a function F applied to the set of outdegrees in in the hypergraph . | 72 | 21 |
245,817 | def _F_indegree ( H , F ) : if not isinstance ( H , DirectedHypergraph ) : raise TypeError ( "Algorithm only applicable to directed hypergraphs" ) return F ( [ len ( H . get_backward_star ( node ) ) for node in H . get_node_set ( ) ] ) | Returns the result of a function F applied to the list of indegrees in in the hypergraph . | 74 | 21 |
245,818 | def _F_hyperedge_tail_cardinality ( H , F ) : if not isinstance ( H , DirectedHypergraph ) : raise TypeError ( "Algorithm only applicable to directed hypergraphs" ) return F ( [ len ( H . get_hyperedge_tail ( hyperedge_id ) ) for hyperedge_id in H . get_hyperedge_id_set ( ) ] ) | Returns the result of a function F applied to the set of cardinalities of hyperedge tails in the hypergraph . | 96 | 24 |
245,819 | def _F_hyperedge_head_cardinality ( H , F ) : if not isinstance ( H , DirectedHypergraph ) : raise TypeError ( "Algorithm only applicable to directed hypergraphs" ) return F ( [ len ( H . get_hyperedge_head ( hyperedge_id ) ) for hyperedge_id in H . get_hyperedge_id_set ( ) ] ) | Returns the result of a function F applied to the set of cardinalities of hyperedge heads in the hypergraph . | 96 | 24 |
245,820 | def get_hyperedge_weight_matrix ( H , hyperedge_ids_to_indices ) : # Combined 2 methods into 1; this could be written better hyperedge_weights = { } for hyperedge_id in H . hyperedge_id_iterator ( ) : hyperedge_weights . update ( { hyperedge_ids_to_indices [ hyperedge_id ] : H . get_hyperedge_weight ( hyperedge_id ) } ... | Creates the diagonal matrix W of hyperedge weights as a sparse matrix . | 182 | 16 |
245,821 | def get_hyperedge_degree_matrix ( M ) : degrees = M . sum ( 0 ) . transpose ( ) new_degree = [ ] for degree in degrees : new_degree . append ( int ( degree [ 0 : ] ) ) return sparse . diags ( [ new_degree ] , [ 0 ] ) | Creates the diagonal matrix of hyperedge degrees D_e as a sparse matrix where a hyperedge degree is the cardinality of the hyperedge . | 71 | 33 |
245,822 | def fast_inverse ( M ) : diags = M . diagonal ( ) new_diag = [ ] for value in diags : new_diag . append ( 1.0 / value ) return sparse . diags ( [ new_diag ] , [ 0 ] ) | Computes the inverse of a diagonal matrix . | 60 | 9 |
245,823 | def node_iterator ( self ) : return iter ( self . _node_attributes ) def has_hypernode ( self , hypernode ) : """Determines if a specific hypernode is present in the hypergraph. :param node: reference to hypernode whose presence is being checked. :returns: bool -- true iff the node exists in the hypergraph. """ return ... | Provides an iterator over the nodes . | 91 | 8 |
245,824 | def add_hypernode ( self , hypernode , composing_nodes = set ( ) , attr_dict = None , * * attr ) : attr_dict = self . _combine_attribute_arguments ( attr_dict , attr ) # If the hypernode hasn't previously been added, add it along # with its attributes if not self . has_hypernode ( hypernode ) : attr_dict [ "__composing... | Adds a hypernode to the graph along with any related attributes of the hypernode . | 335 | 17 |
245,825 | def _create_random_starter ( node_count ) : pi = np . zeros ( node_count , dtype = float ) for i in range ( node_count ) : pi [ i ] = random . random ( ) summation = np . sum ( pi ) for i in range ( node_count ) : pi [ i ] = pi [ i ] / summation return pi | Creates the random starter for the random walk . | 82 | 10 |
245,826 | def _has_converged ( pi_star , pi ) : node_count = pi . shape [ 0 ] EPS = 10e-6 for i in range ( node_count ) : if pi [ i ] - pi_star [ i ] > EPS : return False return True | Checks if the random walk has converged . | 60 | 10 |
245,827 | def add_element ( self , priority , element , count = None ) : if count is None : count = next ( self . counter ) entry = [ priority , count , element ] self . element_finder [ element ] = entry heapq . heappush ( self . pq , entry ) | Adds an element with a specific priority . | 62 | 8 |
245,828 | def reprioritize ( self , priority , element ) : if element not in self . element_finder : raise ValueError ( "No such element in the priority queue." ) entry = self . element_finder [ element ] self . add_element ( priority , element , entry [ 1 ] ) entry [ 1 ] = self . INVALID | Updates the priority of an element . | 72 | 8 |
245,829 | def contains_element ( self , element ) : return ( element in self . element_finder ) and ( self . element_finder [ element ] [ 1 ] != self . INVALID ) | Determines if an element is contained in the priority queue . | 40 | 13 |
245,830 | def is_empty ( self ) : while self . pq : if self . pq [ 0 ] [ 1 ] != self . INVALID : return False else : _ , _ , element = heapq . heappop ( self . pq ) if element in self . element_finder : del self . element_finder [ element ] return True | Determines if the priority queue has any elements . Performs removal of any elements that were marked - as - invalid . | 74 | 25 |
245,831 | def is_connected ( H , source_node , target_node ) : visited_nodes , Pv , Pe = visit ( H , source_node ) return target_node in visited_nodes | Checks if a target node is connected to a source node . That is this method determines if a target node can be visited from the source node in the sense of the Visit algorithm . | 42 | 37 |
245,832 | def is_b_connected ( H , source_node , target_node ) : b_visited_nodes , Pv , Pe , v = b_visit ( H , source_node ) return target_node in b_visited_nodes | Checks if a target node is B - connected to a source node . | 55 | 15 |
245,833 | def is_f_connected ( H , source_node , target_node ) : f_visited_nodes , Pv , Pe , v = f_visit ( H , source_node ) return target_node in f_visited_nodes | Checks if a target node is F - connected to a source node . | 55 | 15 |
245,834 | def from_networkx_graph ( nx_graph ) : import networkx as nx if not isinstance ( nx_graph , nx . Graph ) : raise TypeError ( "Transformation only applicable to undirected \ NetworkX graphs" ) G = UndirectedHypergraph ( ) for node in nx_graph . nodes_iter ( ) : G . add_node ( node , copy . copy ( nx_graph . node [ node ... | Returns an UndirectedHypergraph object that is the graph equivalent of the given NetworkX Graph object . | 160 | 21 |
245,835 | def from_networkx_digraph ( nx_digraph ) : import networkx as nx if not isinstance ( nx_digraph , nx . DiGraph ) : raise TypeError ( "Transformation only applicable to directed \ NetworkX graphs" ) G = DirectedHypergraph ( ) for node in nx_digraph . nodes_iter ( ) : G . add_node ( node , copy . copy ( nx_digraph . node... | Returns a DirectedHypergraph object that is the graph equivalent of the given NetworkX DiGraph object . | 175 | 21 |
245,836 | def get_tail_incidence_matrix ( H , nodes_to_indices , hyperedge_ids_to_indices ) : if not isinstance ( H , DirectedHypergraph ) : raise TypeError ( "Algorithm only applicable to directed hypergraphs" ) rows , cols = [ ] , [ ] for hyperedge_id , hyperedge_index in hyperedge_ids_to_indices . items ( ) : for node in H . ... | Creates the incidence matrix of the tail nodes of the given hypergraph as a sparse matrix . | 246 | 19 |
245,837 | def add_node ( self , node , attr_dict = None , * * attr ) : attr_dict = self . _combine_attribute_arguments ( attr_dict , attr ) # If the node hasn't previously been added, add it along # with its attributes if not self . has_node ( node ) : self . _node_attributes [ node ] = attr_dict self . _forward_star [ node ] = ... | Adds a node to the graph along with any related attributes of the node . | 145 | 15 |
245,838 | def add_nodes ( self , nodes , attr_dict = None , * * attr ) : attr_dict = self . _combine_attribute_arguments ( attr_dict , attr ) for node in nodes : # Note: This won't behave properly if the node is actually a tuple if type ( node ) is tuple : # See ("B", {label="negative"}) in the documentation example new_node , n... | Adds multiple nodes to the graph along with any related attributes of the nodes . | 200 | 15 |
245,839 | def remove_node ( self , node ) : if not self . has_node ( node ) : raise ValueError ( "No such node exists." ) # Remove every hyperedge which is in the forward star of the node forward_star = self . get_forward_star ( node ) for hyperedge_id in forward_star : self . remove_hyperedge ( hyperedge_id ) # Remove every hyp... | Removes a node and its attributes from the hypergraph . Removes every hyperedge that contains this node in either the head or the tail . | 215 | 30 |
245,840 | def get_node_attribute ( self , node , attribute_name ) : if not self . has_node ( node ) : raise ValueError ( "No such node exists." ) elif attribute_name not in self . _node_attributes [ node ] : raise ValueError ( "No such attribute exists." ) else : return copy . copy ( self . _node_attributes [ node ] [ attribute_... | Given a node and the name of an attribute get a copy of that node s attribute . | 90 | 18 |
245,841 | def get_node_attributes ( self , node ) : if not self . has_node ( node ) : raise ValueError ( "No such node exists." ) attributes = { } for attr_name , attr_value in self . _node_attributes [ node ] . items ( ) : attributes [ attr_name ] = copy . copy ( attr_value ) return attributes | Given a node get a dictionary with copies of that node s attributes . | 84 | 14 |
245,842 | def add_hyperedge ( self , tail , head , attr_dict = None , * * attr ) : attr_dict = self . _combine_attribute_arguments ( attr_dict , attr ) # Don't allow both empty tail and head containers (invalid hyperedge) if not tail and not head : raise ValueError ( "tail and head arguments \ cannot both be empty." ) # Use froz... | Adds a hyperedge to the hypergraph along with any related attributes of the hyperedge . This method will automatically add any node from the tail and head that was not in the hypergraph . A hyperedge without a weight attribute specified will be assigned the default value of 1 . | 643 | 58 |
245,843 | def add_hyperedges ( self , hyperedges , attr_dict = None , * * attr ) : attr_dict = self . _combine_attribute_arguments ( attr_dict , attr ) hyperedge_ids = [ ] for hyperedge in hyperedges : if len ( hyperedge ) == 3 : # See ("A", "C"), ("B"), {weight: 2}) in the # documentation example tail , head , hyperedge_attr_di... | Adds multiple hyperedges to the graph along with any related attributes of the hyperedges . If any node in the tail or head of any hyperedge has not previously been added to the hypergraph it will automatically be added here . Hyperedges without a weight attribute specified will be assigned the default value of 1 . | 273 | 66 |
245,844 | def get_hyperedge_id ( self , tail , head ) : frozen_tail = frozenset ( tail ) frozen_head = frozenset ( head ) if not self . has_hyperedge ( frozen_tail , frozen_head ) : raise ValueError ( "No such hyperedge exists." ) return self . _successors [ frozen_tail ] [ frozen_head ] | From a tail and head set of nodes returns the ID of the hyperedge that these sets comprise . | 86 | 21 |
245,845 | def get_forward_star ( self , node ) : if node not in self . _node_attributes : raise ValueError ( "No such node exists." ) return self . _forward_star [ node ] . copy ( ) | Given a node get a copy of that node s forward star . | 49 | 13 |
245,846 | def get_backward_star ( self , node ) : if node not in self . _node_attributes : raise ValueError ( "No such node exists." ) return self . _backward_star [ node ] . copy ( ) | Given a node get a copy of that node s backward star . | 51 | 13 |
245,847 | def get_successors ( self , tail ) : frozen_tail = frozenset ( tail ) # If this node set isn't any tail in the hypergraph, then it has # no successors; thus, return an empty list if frozen_tail not in self . _successors : return set ( ) return set ( self . _successors [ frozen_tail ] . values ( ) ) | Given a tail set of nodes get a list of edges of which the node set is the tail of each edge . | 82 | 23 |
245,848 | def get_predecessors ( self , head ) : frozen_head = frozenset ( head ) # If this node set isn't any head in the hypergraph, then it has # no predecessors; thus, return an empty list if frozen_head not in self . _predecessors : return set ( ) return set ( self . _predecessors [ frozen_head ] . values ( ) ) | Given a head set of nodes get a list of edges of which the node set is the head of each edge . | 85 | 23 |
245,849 | def is_BF_hypergraph ( self ) : for hyperedge_id in self . _hyperedge_attributes : tail = self . get_hyperedge_tail ( hyperedge_id ) head = self . get_hyperedge_head ( hyperedge_id ) if len ( tail ) > 1 and len ( head ) > 1 : return False return True | Indicates whether the hypergraph is a BF - hypergraph . A BF - hypergraph consists of only B - hyperedges and F - hyperedges . See is_B_hypergraph or is_F_hypergraph for more details . | 86 | 51 |
245,850 | def get_induced_subhypergraph ( self , nodes ) : sub_H = self . copy ( ) sub_H . remove_nodes ( sub_H . get_node_set ( ) - set ( nodes ) ) return sub_H | Gives a new hypergraph that is the subhypergraph of the current hypergraph induced by the provided set of nodes . That is the induced subhypergraph s node set corresponds precisely to the nodes provided and the coressponding hyperedges in the subhypergraph are only those from the original graph consist of tail and head... | 53 | 77 |
245,851 | def getall ( self , key , default = _marker ) : identity = self . _title ( key ) res = [ v for i , k , v in self . _impl . _items if i == identity ] if res : return res if not res and default is not _marker : return default raise KeyError ( 'Key not found: %r' % key ) | Return a list of all values matching the key . | 80 | 10 |
245,852 | def extend ( self , * args , * * kwargs ) : self . _extend ( args , kwargs , 'extend' , self . _extend_items ) | Extend current MultiDict with more values . | 40 | 10 |
245,853 | def setdefault ( self , key , default = None ) : identity = self . _title ( key ) for i , k , v in self . _impl . _items : if i == identity : return v self . add ( key , default ) return default | Return value for key set value to default if key is not present . | 54 | 14 |
245,854 | def popall ( self , key , default = _marker ) : found = False identity = self . _title ( key ) ret = [ ] for i in range ( len ( self . _impl . _items ) - 1 , - 1 , - 1 ) : item = self . _impl . _items [ i ] if item [ 0 ] == identity : ret . append ( item [ 2 ] ) del self . _impl . _items [ i ] self . _impl . incr_versi... | Remove all occurrences of key and return the list of corresponding values . | 140 | 13 |
245,855 | def total ( self , xbin1 = 1 , xbin2 = - 2 ) : return self . hist . integral ( xbin1 = xbin1 , xbin2 = xbin2 , error = True ) | Return the total yield and its associated statistical uncertainty . | 46 | 10 |
245,856 | def iter_sys ( self ) : names = self . sys_names ( ) for name in names : osys = self . GetOverallSys ( name ) hsys = self . GetHistoSys ( name ) yield name , osys , hsys | Iterate over sys_name overall_sys histo_sys . overall_sys or histo_sys may be None for any given sys_name . | 53 | 32 |
245,857 | def sys_hist ( self , name = None ) : if name is None : low = self . hist . Clone ( shallow = True ) high = self . hist . Clone ( shallow = True ) return low , high osys = self . GetOverallSys ( name ) hsys = self . GetHistoSys ( name ) if osys is None : osys_high , osys_low = 1. , 1. else : osys_high , osys_low = osys... | Return the effective low and high histogram for a given systematic . If this sample does not contain the named systematic then return the nominal histogram for both low and high variations . | 200 | 35 |
245,858 | def sys_hist ( self , name = None , where = None ) : total_low , total_high = None , None for sample in self . samples : if where is not None and not where ( sample ) : continue low , high = sample . sys_hist ( name ) if total_low is None : total_low = low . Clone ( shallow = True ) else : total_low += low if total_hig... | Return the effective total low and high histogram for a given systematic over samples in this channel . If a sample does not contain the named systematic then its nominal histogram is used for both low and high variations . | 119 | 42 |
245,859 | def apply_snapshot ( self , argset ) : clone = self . Clone ( ) args = [ var for var in argset if not ( var . name . startswith ( 'binWidth_obs_x_' ) or var . name . startswith ( 'gamma_stat' ) or var . name . startswith ( 'nom_' ) ) ] # handle NormFactors first nargs = [ ] for var in args : is_norm = False name = var ... | Create a clone of this Channel where histograms are modified according to the values of the nuisance parameters in the snapshot . This is useful when creating post - fit distribution plots . | 454 | 34 |
245,860 | def printcodelist ( codelist , to = sys . stdout ) : labeldict = { } pendinglabels = [ ] for i , ( op , arg ) in enumerate ( codelist ) : if isinstance ( op , Label ) : pendinglabels . append ( op ) elif op is SetLineno : pass else : while pendinglabels : labeldict [ pendinglabels . pop ( ) ] = i lineno = None islabel ... | Get a code list . Print it nicely . | 302 | 9 |
245,861 | def recompile ( filename ) : # Most of the code here based on the compile.py module. import os import imp import marshal import struct f = open ( filename , 'U' ) try : timestamp = long ( os . fstat ( f . fileno ( ) ) . st_mtime ) except AttributeError : timestamp = long ( os . stat ( filename ) . st_mtime ) codestring... | Create a . pyc by disassembling the file and assembling it again printing a message that the reassembled file was loaded . | 418 | 26 |
245,862 | def recompile_all ( path ) : import os if os . path . isdir ( path ) : for root , dirs , files in os . walk ( path ) : for name in files : if name . endswith ( '.py' ) : filename = os . path . abspath ( os . path . join ( root , name ) ) print >> sys . stderr , filename recompile ( filename ) else : filename = os . pat... | recursively recompile all . py files in the directory | 106 | 12 |
245,863 | def from_code ( cls , co ) : co_code = co . co_code labels = dict ( ( addr , Label ( ) ) for addr in findlabels ( co_code ) ) linestarts = dict ( cls . _findlinestarts ( co ) ) cellfree = co . co_cellvars + co . co_freevars code = CodeList ( ) n = len ( co_code ) i = 0 extended_arg = 0 while i < n : op = Opcode ( ord (... | Disassemble a Python code object into a Code object . | 697 | 12 |
245,864 | def effective_sample_size ( h ) : sum = 0 ew = 0 w = 0 for bin in h . bins ( overflow = False ) : sum += bin . value ew = bin . error w += ew * ew esum = sum * sum / w return esum | Calculate the effective sample size for a histogram the same way as ROOT does . | 61 | 19 |
245,865 | def critical_value ( n , p ) : dn = 1 delta = 0.5 res = ROOT . TMath . KolmogorovProb ( dn * sqrt ( n ) ) while res > 1.0001 * p or res < 0.9999 * p : if ( res > 1.0001 * p ) : dn = dn + delta if ( res < 0.9999 * p ) : dn = dn - delta delta = delta / 2. res = ROOT . TMath . KolmogorovProb ( dn * sqrt ( n ) ) return dn | This function calculates the critical value given n and p and confidence level = 1 - p . | 131 | 18 |
245,866 | def dump ( obj , root_file , proto = 0 , key = None ) : if isinstance ( root_file , string_types ) : root_file = root_open ( root_file , 'recreate' ) own_file = True else : own_file = False ret = Pickler ( root_file , proto ) . dump ( obj , key ) if own_file : root_file . Close ( ) return ret | Dump an object into a ROOT TFile . | 92 | 11 |
245,867 | def load ( root_file , use_proxy = True , key = None ) : if isinstance ( root_file , string_types ) : root_file = root_open ( root_file ) own_file = True else : own_file = False obj = Unpickler ( root_file , use_proxy ) . load ( key ) if own_file : root_file . Close ( ) return obj | Load an object from a ROOT TFile . | 88 | 10 |
245,868 | def dump ( self , obj , key = None ) : if key is None : key = '_pickle' with preserve_current_directory ( ) : self . __file . cd ( ) if sys . version_info [ 0 ] < 3 : pickle . Pickler . dump ( self , obj ) else : super ( Pickler , self ) . dump ( obj ) s = ROOT . TObjString ( self . __io . getvalue ( ) ) self . __io . ... | Write a pickled representation of obj to the open TFile . | 135 | 13 |
245,869 | def load ( self , key = None ) : if key is None : key = '_pickle' obj = None if _compat_hooks : save = _compat_hooks [ 0 ] ( ) try : self . __n += 1 s = self . __file . Get ( key + ';{0:d}' . format ( self . __n ) ) self . __io . setvalue ( s . GetName ( ) ) if sys . version_info [ 0 ] < 3 : obj = pickle . Unpickler . ... | Read a pickled object representation from the open file . | 172 | 11 |
245,870 | def iter_ROOT_classes ( ) : class_index = "http://root.cern.ch/root/html/ClassIndex.html" for s in minidom . parse ( urlopen ( class_index ) ) . getElementsByTagName ( "span" ) : if ( "class" , "typename" ) in s . attributes . items ( ) : class_name = s . childNodes [ 0 ] . nodeValue try : yield getattr ( QROOT , class... | Iterator over all available ROOT classes | 118 | 7 |
245,871 | def CMS_label ( text = "Preliminary 2012" , sqrts = 8 , pad = None ) : if pad is None : pad = ROOT . gPad with preserve_current_canvas ( ) : pad . cd ( ) left_margin = pad . GetLeftMargin ( ) top_margin = pad . GetTopMargin ( ) ypos = 1 - top_margin / 2. l = ROOT . TLatex ( left_margin , ypos , "CMS " + text ) l . SetT... | Add a CMS Preliminary style label to the current Pad . | 306 | 12 |
245,872 | def make_channel ( name , samples , data = None , verbose = False ) : if verbose : llog = log [ 'make_channel' ] llog . info ( "creating channel {0}" . format ( name ) ) # avoid segfault if name begins with a digit by using "channel_" prefix chan = Channel ( 'channel_{0}' . format ( name ) ) chan . SetStatErrorConfig (... | Create a Channel from a list of Samples | 175 | 9 |
245,873 | def make_measurement ( name , channels , lumi = 1.0 , lumi_rel_error = 0.1 , output_prefix = './histfactory' , POI = None , const_params = None , verbose = False ) : if verbose : llog = log [ 'make_measurement' ] llog . info ( "creating measurement {0}" . format ( name ) ) if not isinstance ( channels , ( list , tuple ... | Create a Measurement from a list of Channels | 398 | 10 |
245,874 | def make_workspace ( measurement , channel = None , name = None , silence = False ) : context = silence_sout_serr if silence else do_nothing with context ( ) : hist2workspace = ROOT . RooStats . HistFactory . HistoToWorkspaceFactoryFast ( measurement ) if channel is not None : workspace = hist2workspace . MakeSingleCha... | Create a workspace containing the model for a measurement | 146 | 9 |
245,875 | def measurements_from_xml ( filename , collect_histograms = True , cd_parent = False , silence = False ) : if not os . path . isfile ( filename ) : raise OSError ( "the file {0} does not exist" . format ( filename ) ) silence_context = silence_sout_serr if silence else do_nothing filename = os . path . abspath ( os . p... | Read in a list of Measurements from XML | 295 | 9 |
245,876 | def write_measurement ( measurement , root_file = None , xml_path = None , output_path = None , output_suffix = None , write_workspaces = False , apply_xml_patches = True , silence = False ) : context = silence_sout_serr if silence else do_nothing output_name = measurement . name if output_suffix is not None : output_n... | Write a measurement and RooWorkspaces for all contained channels into a ROOT file and write the XML files into a directory . | 586 | 26 |
245,877 | def patch_xml ( files , root_file = None , float_precision = 3 ) : if float_precision < 0 : raise ValueError ( "precision must be greater than 0" ) def fix_path ( match ) : path = match . group ( 1 ) if path : head , tail = os . path . split ( path ) new_path = os . path . join ( os . path . basename ( head ) , tail ) ... | Apply patches to HistFactory XML output from PrintXML | 859 | 11 |
245,878 | def path ( self ) : if isinstance ( self . dir , Directory ) : return self . dir . _path elif isinstance ( self . dir , ROOT . TDirectory ) : return self . dir . GetPath ( ) elif isinstance ( self . dir , _FolderView ) : return self . dir . path ( ) else : return str ( self . dir ) | Get the path of the wrapped folder | 81 | 7 |
245,879 | def Get ( self , path ) : return self . merge_views ( x . Get ( path ) for x in self . dirs ) | Merge the objects at path in all subdirectories | 29 | 11 |
245,880 | def python_logging_error_handler ( level , root_says_abort , location , msg ) : from . . utils import quickroot as QROOT if not Initialized . value : try : QROOT . kTRUE except AttributeError : # Python is exiting. Do nothing. return QROOT . kInfo , QROOT . kWarning , QROOT . kError , QROOT . kFatal , QROOT . kSysError... | A python error handler for ROOT which maps ROOT s errors and warnings on to python s . | 712 | 20 |
245,881 | def preserve_current_canvas ( ) : old = ROOT . gPad try : yield finally : if old : old . cd ( ) elif ROOT . gPad : # Put things back how they were before. with invisible_canvas ( ) : # This is a round-about way of resetting gPad to None. # No other technique I tried could do it. pass | Context manager which ensures that the current canvas remains the current canvas when the context is left . | 82 | 18 |
245,882 | def preserve_batch_state ( ) : with LOCK : old = ROOT . gROOT . IsBatch ( ) try : yield finally : ROOT . gROOT . SetBatch ( old ) | Context manager which ensures the batch state is the same on exit as it was on entry . | 45 | 18 |
245,883 | def invisible_canvas ( ) : with preserve_current_canvas ( ) : with preserve_batch_state ( ) : ROOT . gROOT . SetBatch ( ) c = ROOT . TCanvas ( ) try : c . cd ( ) yield c finally : c . Close ( ) c . IsA ( ) . Destructor ( c ) | Context manager yielding a temporary canvas drawn in batch mode invisible to the user . Original state is restored on exit . | 78 | 22 |
245,884 | def thread_specific_tmprootdir ( ) : with preserve_current_directory ( ) : dname = "rootpy-tmp/thread/{0}" . format ( threading . current_thread ( ) . ident ) d = ROOT . gROOT . mkdir ( dname ) if not d : d = ROOT . gROOT . GetDirectory ( dname ) assert d , "Unexpected failure, can't cd to tmpdir." d . cd ( ) yield d | Context manager which makes a thread specific gDirectory to avoid interfering with the current file . | 105 | 17 |
245,885 | def working_directory ( path ) : prev_cwd = os . getcwd ( ) os . chdir ( path ) try : yield finally : os . chdir ( prev_cwd ) | A context manager that changes the working directory to the given path and then changes it back to its previous value on exit . | 42 | 24 |
245,886 | def autobinning ( data , method = "freedman_diaconis" ) : name = method . replace ( "-" , "_" ) try : method = getattr ( BinningMethods , name ) if not isinstance ( method , types . FunctionType ) : raise AttributeError except AttributeError : raise ValueError ( "`{0}` is not a valid binning method" . format ( name ) )... | This method determines the optimal binning for histogramming . | 143 | 12 |
245,887 | def all_methods ( cls ) : def name ( fn ) : return fn . __get__ ( cls ) . __name__ . replace ( "_" , "-" ) return sorted ( name ( f ) for f in cls . __dict__ . values ( ) if isinstance ( f , staticmethod ) ) | Return the names of all available binning methods | 69 | 9 |
245,888 | def doane ( data ) : from scipy . stats import skew n = len ( data ) sigma = np . sqrt ( 6. * ( n - 2. ) / ( n + 1. ) / ( n + 3. ) ) return 1 + np . log2 ( n ) + np . log2 ( 1 + np . abs ( skew ( data ) ) / sigma ) | Modified Doane modified | 84 | 5 |
245,889 | def lock ( path , poll_interval = 5 , max_age = 60 ) : if max_age < 30 : raise ValueError ( "`max_age` must be at least 30 seconds" ) if poll_interval < 1 : raise ValueError ( "`poll_interval` must be at least 1 second" ) if poll_interval >= max_age : raise ValueError ( "`poll_interval` must be less than `max_age`" ) p... | Aquire a file lock in a thread - safe manner that also reaps stale locks possibly left behind by processes that crashed hard . | 553 | 26 |
245,890 | def proxy_global ( name , no_expand_macro = False , fname = 'func' , args = ( ) ) : if no_expand_macro : # pragma: no cover # handle older ROOT versions without _ExpandMacroFunction wrapping @ property def gSomething_no_func ( self ) : glob = self ( getattr ( ROOT , name ) ) # create a fake func() that just returns sel... | Used to automatically asrootpy ROOT s thread local variables | 176 | 12 |
245,891 | def AddEntry ( self , thing , label = None , style = None ) : if isinstance ( thing , HistStack ) : things = thing else : things = [ thing ] for thing in things : if getattr ( thing , 'inlegend' , True ) : thing_label = thing . GetTitle ( ) if label is None else label thing_style = getattr ( thing , 'legendstyle' , 'P'... | Add an entry to the legend . | 126 | 7 |
245,892 | def get_seh ( ) : if ON_RTD : return lambda x : x ErrorHandlerFunc_t = ctypes . CFUNCTYPE ( None , ctypes . c_int , ctypes . c_bool , ctypes . c_char_p , ctypes . c_char_p ) # Required to avoid strange dynamic linker problem on OSX. # See https://github.com/rootpy/rootpy/issues/256 import ROOT dll = get_dll ( "libCore"... | Makes a function which can be used to set the ROOT error handler with a python function and returns the existing error handler . | 305 | 26 |
245,893 | def get_f_code_idx ( ) : frame = sys . _getframe ( ) frame_ptr = id ( frame ) LARGE_ENOUGH = 20 # Look through the frame object until we find the f_tstate variable, whose # value we know from above. ptrs = [ ctypes . c_voidp . from_address ( frame_ptr + i * svp ) for i in range ( LARGE_ENOUGH ) ] # Find its index into ... | How many pointers into PyFrame is the f_code variable? | 173 | 13 |
245,894 | def get_frame_pointers ( frame = None ) : if frame is None : frame = sys . _getframe ( 2 ) frame = id ( frame ) # http://hg.python.org/cpython/file/3aa530c2db06/Include/frameobject.h#l28 F_TRACE_OFFSET = 6 Ppy_object = ctypes . POINTER ( ctypes . py_object ) trace = Ppy_object . from_address ( frame + ( F_CODE_IDX + F_... | Obtain writable pointers to frame . f_trace and frame . f_lineno . | 229 | 19 |
245,895 | def set_linetrace_on_frame ( f , localtrace = None ) : traceptr , _ , _ = get_frame_pointers ( f ) if localtrace is not None : # Need to incref to avoid the frame causing a double-delete ctypes . pythonapi . Py_IncRef ( localtrace ) # Not sure if this is the best way to do this, but it works. addr = id ( localtrace ) e... | Non - portable function to modify linetracing . | 116 | 10 |
245,896 | def re_execute_with_exception ( frame , exception , traceback ) : if sys . gettrace ( ) == globaltrace : # If our trace handler is already installed, that means that this # function has been called twice before the line tracer had a chance to # run. That can happen if more than one exception was logged. return call_lin... | Dark magic . Causes frame to raise an exception at the current location with traceback appended to it . | 433 | 21 |
245,897 | def _inject_jump ( self , where , dest ) : # We're about to do dangerous things to a function's code content. # We can't make a lock to prevent the interpreter from using those # bytes, so the best we can do is to set the check interval to be high # and just pray that this keeps other threads at bay. if sys . version_i... | Monkeypatch bytecode at where to force it to jump to dest . | 374 | 15 |
245,898 | def Draw ( self , * args , * * kwargs ) : self . reset ( ) output = None while self . _rollover ( ) : if output is None : # Make our own copy of the drawn histogram output = self . _tree . Draw ( * args , * * kwargs ) if output is not None : output = output . Clone ( ) # Make it memory resident (histograms) if hasattr ... | Loop over subfiles draw each and sum the output into a single histogram . | 164 | 16 |
245,899 | def interact_plain ( header = UP_LINE , local_ns = None , module = None , dummy = None , stack_depth = 1 , global_ns = None ) : frame = sys . _getframe ( stack_depth ) variables = { } if local_ns is not None : variables . update ( local_ns ) else : variables . update ( frame . f_locals ) if global_ns is not None : vari... | Create an interactive python console | 131 | 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.