idx int64 0 251k | question stringlengths 53 3.53k | target stringlengths 5 1.23k | len_question int64 20 893 | len_target int64 3 238 |
|---|---|---|---|---|
18,800 | def parse_record ( self , lines ) : # Break lines up temp_lines = [ ] for line in lines : fields = line . rstrip ( "\r\n" ) . split ( None , 1 ) if len ( fields ) == 1 : fields . append ( "" ) temp_lines . append ( fields ) lines = temp_lines # Fill in motif from lines motif = TransfacMotif ( ) current_line = 0 while 1 : # Done parsing if no more lines to consume if current_line >= len ( lines ) : break # Remove prefix and first separator from line prefix , rest = lines [ current_line ] # No action for this prefix, just ignore the line if prefix not in self . parse_actions : current_line += 1 continue # Get action for line action = self . parse_actions [ prefix ] # Store a single line value if action [ 0 ] == "store_single" : key = action [ 1 ] setattr ( motif , key , rest ) current_line += 1 # Add a single line value to a list if action [ 0 ] == "store_single_list" : key = action [ 1 ] if not getattr ( motif , key ) : setattr ( motif , key , [ ] ) getattr ( motif , key ) . append ( rest ) current_line += 1 # Add a single line value to a dictionary if action [ 0 ] == "store_single_key_value" : key = action [ 1 ] k , v = rest . strip ( ) . split ( '=' , 1 ) if not getattr ( motif , key ) : setattr ( motif , key , { } ) getattr ( motif , key ) [ k ] = v current_line += 1 # Store a block of text if action [ 0 ] == "store_block" : key = action [ 1 ] value = [ ] while current_line < len ( lines ) and lines [ current_line ] [ 0 ] == prefix : value . append ( lines [ current_line ] [ 1 ] ) current_line += 1 setattr ( motif , key , str . join ( "\n" , value ) ) # Store a matrix if action [ 0 ] == "store_matrix" : # First line is alphabet alphabet = rest . split ( ) alphabet_size = len ( alphabet ) rows = [ ] pattern = "" current_line += 1 # Next lines are the rows of the matrix (we allow 0 rows) while current_line < len ( lines ) : prefix , rest = lines [ current_line ] # Prefix should be a two digit 0 padded row number if not prefix . isdigit ( ) : break # The first `alphabet_size` fields are the row values values = rest . split ( ) rows . append ( [ float ( _ ) for _ in values [ : alphabet_size ] ] ) # TRANSFAC includes an extra column with the IUPAC code if len ( values ) > alphabet_size : pattern += values [ alphabet_size ] current_line += 1 # Only store the pattern if it is the correct length (meaning # that every row had an extra field) if len ( pattern ) != len ( rows ) : pattern = None matrix = FrequencyMatrix . from_rows ( alphabet , rows ) setattr ( motif , action [ 1 ] , matrix ) # Only return a motif if we saw at least ID or AC or NA if motif . id or motif . accession or motif . name : return motif | Parse a TRANSFAC record out of lines and return a motif . | 728 | 15 |
18,801 | def bit_clone ( bits ) : new = BitSet ( bits . size ) new . ior ( bits ) return new | Clone a bitset | 26 | 5 |
18,802 | def throw_random ( lengths , mask ) : saved = None for i in range ( maxtries ) : try : return throw_random_bits ( lengths , mask ) except MaxtriesException as e : saved = e continue raise e | Try multiple times to run throw_random | 50 | 8 |
18,803 | def as_bits ( region_start , region_length , intervals ) : bits = BitSet ( region_length ) for chr , start , stop in intervals : bits . set_range ( start - region_start , stop - start ) return bits | Convert a set of intervals overlapping a region of a chromosome into a bitset for just that region with the bits covered by the intervals set . | 53 | 29 |
18,804 | def interval_lengths ( bits ) : end = 0 while 1 : start = bits . next_set ( end ) if start == bits . size : break end = bits . next_clear ( start ) yield end - start | Get the length distribution of all contiguous runs of set bits from | 47 | 12 |
18,805 | def count_overlap ( bits1 , bits2 ) : b = BitSet ( bits1 . size ) b |= bits1 b &= bits2 return b . count_range ( 0 , b . size ) | Count the number of bits that overlap between two sets | 46 | 10 |
18,806 | def overlapping_in_bed ( fname , r_chr , r_start , r_stop ) : rval = [ ] for line in open ( fname ) : if line . startswith ( "#" ) or line . startswith ( "track" ) : continue fields = line . split ( ) chr , start , stop = fields [ 0 ] , int ( fields [ 1 ] ) , int ( fields [ 2 ] ) if chr == r_chr and start < r_stop and stop >= r_start : rval . append ( ( chr , max ( start , r_start ) , min ( stop , r_stop ) ) ) return rval | Get from a bed all intervals that overlap the region defined by r_chr r_start r_stop . | 147 | 23 |
18,807 | def tile_interval ( sources , index , ref_src , start , end , seq_db = None ) : # First entry in sources should also be on the reference species assert sources [ 0 ] . split ( '.' ) [ 0 ] == ref_src . split ( '.' ) [ 0 ] , "%s != %s" % ( sources [ 0 ] . split ( '.' ) [ 0 ] , ref_src . split ( '.' ) [ 0 ] ) base_len = end - start blocks = index . get ( ref_src , start , end ) # From low to high score blocks . sort ( key = lambda t : t . score ) mask = [ - 1 ] * base_len ref_src_size = None for i , block in enumerate ( blocks ) : ref = block . get_component_by_src_start ( ref_src ) ref_src_size = ref . src_size assert ref . strand == "+" slice_start = max ( start , ref . start ) slice_end = min ( end , ref . end ) for j in range ( slice_start , slice_end ) : mask [ j - start ] = i tiled = [ ] for i in range ( len ( sources ) ) : tiled . append ( [ ] ) for ss , ee , index in intervals_from_mask ( mask ) : # Interval with no covering alignments if index < 0 : # Get sequence if available, otherwise just use 'N' if seq_db : tiled [ 0 ] . append ( bx . seq . nib . NibFile ( open ( seq_db [ ref_src ] ) ) . get ( start + ss , ee - ss ) ) else : tiled [ 0 ] . append ( "N" * ( ee - ss ) ) # Gaps in all other species for row in tiled [ 1 : ] : row . append ( "-" * ( ee - ss ) ) else : slice_start = start + ss slice_end = start + ee block = blocks [ index ] ref = block . get_component_by_src_start ( ref_src ) sliced = block . slice_by_component ( ref , slice_start , slice_end ) sliced = sliced . limit_to_species ( sources ) sliced . remove_all_gap_columns ( ) for i , src in enumerate ( sources ) : comp = sliced . get_component_by_src_start ( src ) if comp : tiled [ i ] . append ( comp . text ) else : tiled [ i ] . append ( "-" * sliced . text_size ) return [ "" . join ( t ) for t in tiled ] | Tile maf blocks onto an interval . The resulting block will span the interval exactly and contain the column from the highest scoring alignment at each position . | 576 | 29 |
18,808 | def get_fill_char ( maf_status ) : ## assert maf_status not in ( maf.MAF_CONTIG_NESTED_STATUS, maf.MAF_NEW_NESTED_STATUS, ## maf.MAF_MAYBE_NEW_NESTED_STATUS ), \ ## "Nested rows do not make sense in a single coverage MAF (or do they?)" if maf_status in ( maf . MAF_NEW_STATUS , maf . MAF_MAYBE_NEW_STATUS , maf . MAF_NEW_NESTED_STATUS , maf . MAF_MAYBE_NEW_NESTED_STATUS ) : return "*" elif maf_status in ( maf . MAF_INVERSE_STATUS , maf . MAF_INSERT_STATUS ) : return "=" elif maf_status in ( maf . MAF_CONTIG_STATUS , maf . MAF_CONTIG_NESTED_STATUS ) : return "#" elif maf_status == maf . MAF_MISSING_STATUS : return "X" else : raise ValueError ( "Unknwon maf status" ) | Return the character that should be used to fill between blocks having a given status | 283 | 15 |
18,809 | def guess_fill_char ( left_comp , right_comp ) : # No left component, obiously new return "*" # First check that the blocks have the same src (not just species) and # orientation if ( left_comp . src == right_comp . src and left_comp . strand != right_comp . strand ) : # Are they completely contiguous? Easy to call that a gap if left_comp . end == right_comp . start : return "-" # TODO: should be able to make some guesses about short insertions # here # All other cases we have no clue about return "*" | For the case where there is no annotated synteny we will try to guess it | 131 | 17 |
18,810 | def remove_all_gap_columns ( texts ) : seqs = [ list ( t ) for t in texts ] i = 0 text_size = len ( texts [ 0 ] ) while i < text_size : all_gap = True for seq in seqs : if seq [ i ] not in ( '-' , '#' , '*' , '=' , 'X' , '@' ) : all_gap = False if all_gap : for seq in seqs : del seq [ i ] text_size -= 1 else : i += 1 return [ '' . join ( s ) for s in seqs ] | Remove any columns containing only gaps from alignment texts | 134 | 9 |
18,811 | def cross_lists ( * sets ) : wheels = [ iter ( _ ) for _ in sets ] digits = [ next ( it ) for it in wheels ] while True : yield digits [ : ] for i in range ( len ( digits ) - 1 , - 1 , - 1 ) : try : digits [ i ] = next ( wheels [ i ] ) break except StopIteration : wheels [ i ] = iter ( sets [ i ] ) digits [ i ] = next ( wheels [ i ] ) else : break | Return the cross product of the arguments | 107 | 7 |
18,812 | def read_lengths_file ( name ) : chrom_to_length = { } f = file ( name , "rt" ) for line in f : line = line . strip ( ) if line == '' or line [ 0 ] == '#' : continue try : fields = line . split ( ) if len ( fields ) != 2 : raise chrom = fields [ 0 ] length = int ( fields [ 1 ] ) except : raise ValueError ( "bad length file line: %s" % line ) if chrom in chrom_to_length and length != chrom_to_length [ chrom ] : raise ValueError ( "%s has more than one length!" % chrom ) chrom_to_length [ chrom ] = length f . close ( ) return chrom_to_length | Returns a hash from sequence name to length . | 163 | 9 |
18,813 | def IntervalReader ( f ) : current_chrom = None current_pos = None current_step = None # always for wiggle data strand = '+' mode = "bed" for line in f : if line . isspace ( ) or line . startswith ( "track" ) or line . startswith ( "#" ) or line . startswith ( "browser" ) : continue elif line . startswith ( "variableStep" ) : header = parse_header ( line ) current_chrom = header [ 'chrom' ] current_pos = None current_step = None if 'span' in header : current_span = int ( header [ 'span' ] ) else : current_span = 1 mode = "variableStep" elif line . startswith ( "fixedStep" ) : header = parse_header ( line ) current_chrom = header [ 'chrom' ] current_pos = int ( header [ 'start' ] ) - 1 current_step = int ( header [ 'step' ] ) if 'span' in header : current_span = int ( header [ 'span' ] ) else : current_span = 1 mode = "fixedStep" elif mode == "bed" : fields = line . split ( ) if len ( fields ) > 3 : if len ( fields ) > 5 : yield fields [ 0 ] , int ( fields [ 1 ] ) , int ( fields [ 2 ] ) , fields [ 5 ] , float ( fields [ 3 ] ) else : yield fields [ 0 ] , int ( fields [ 1 ] ) , int ( fields [ 2 ] ) , strand , float ( fields [ 3 ] ) elif mode == "variableStep" : fields = line . split ( ) pos = int ( fields [ 0 ] ) - 1 yield current_chrom , pos , pos + current_span , strand , float ( fields [ 1 ] ) elif mode == "fixedStep" : yield current_chrom , current_pos , current_pos + current_span , strand , float ( line . split ( ) [ 0 ] ) current_pos += current_step else : raise ValueError ( "Unexpected input line: %s" % line . strip ( ) ) | Iterator yielding chrom start end strand value . Values are zero - based half - open . Regions which lack a score are ignored . | 468 | 25 |
18,814 | def fuse_list ( mafs ) : last = None for m in mafs : if last is None : last = m else : fused = fuse ( last , m ) if fused : last = fused else : yield last last = m if last : yield last | Try to fuse a list of blocks by progressively fusing each adjacent pair . | 56 | 15 |
18,815 | def setBreak ( self , breakFlag = True ) : if breakFlag : _parseMethod = self . _parse def breaker ( instring , loc , doActions = True , callPreParse = True ) : import pdb pdb . set_trace ( ) _parseMethod ( instring , loc , doActions , callPreParse ) breaker . _originalParseMethod = _parseMethod self . _parse = breaker else : if hasattr ( self . _parse , "_originalParseMethod" ) : self . _parse = self . _parse . _originalParseMethod return self | Method to invoke the Python pdb debugger when this element is about to be parsed . Set breakFlag to True to enable False to disable . | 128 | 28 |
18,816 | def searchString ( self , instring , maxMatches = _MAX_INT ) : return ParseResults ( [ t for t , s , e in self . scanString ( instring , maxMatches ) ] ) | Another extension to scanString simplifying the access to the tokens found to match the given parse expression . May be called with optional maxMatches argument to clip searching after n matches are found . | 47 | 38 |
18,817 | def _strfactory ( cls , line ) : assert type ( line ) == str , "this is a factory from string" line = line . rstrip ( ) . split ( ) [ 1 : ] # the first component is the keyword "chain" tup = [ t [ 0 ] ( t [ 1 ] ) for t in zip ( [ int , str , int , str , int , int , str , int , str , int , int , str ] , line ) ] return tuple . __new__ ( cls , tup ) | factory class method for Chain | 115 | 6 |
18,818 | def bedInterval ( self , who ) : if who == 't' : st , en = self . tStart , self . tEnd if self . tStrand == '-' : st , en = self . tSize - en , self . tSize - st return ( self . tName , st , en , self . id , self . score , self . tStrand ) else : st , en = self . qStart , self . qEnd if self . qStrand == '-' : st , en = self . qSize - en , self . qSize - st assert en - st == self . qEnd - self . qStart return ( self . qName , st , en , self . id , self . score , self . qStrand ) | return a BED6 entry thus DOES coordinate conversion for minus strands | 163 | 13 |
18,819 | def _strfactory ( cls , line ) : cmp = line . rstrip ( ) . split ( ) chrom = cmp [ 2 ] if not chrom . startswith ( "chr" ) : chrom = "chr%s" % chrom instance = tuple . __new__ ( cls , ( cmp [ 0 ] , cmp [ 1 ] , chrom , int ( cmp [ 3 ] ) , int ( cmp [ 4 ] ) , { '1' : '+' , '-1' : '-' } [ cmp [ 5 ] ] , cmp [ 6 ] ) ) span = instance . end - instance . start + 1 m_num = sum ( ( t [ 1 ] == "M" and [ t [ 0 ] ] or [ 0 ] ) [ 0 ] for t in instance . cigar_iter ( False ) ) if span != m_num : log . warning ( "[{gabid}] {species}.{chrom}:{start}-{end}." . format ( * * instance . _asdict ( ) ) + "(span) %d != %d (matches)" % ( span , m_num ) ) return None return instance | factory method for an EPOitem | 256 | 8 |
18,820 | def binned_bitsets_proximity ( f , chrom_col = 0 , start_col = 1 , end_col = 2 , strand_col = 5 , upstream = 0 , downstream = 0 ) : last_chrom = None last_bitset = None bitsets = dict ( ) for line in f : if line . startswith ( "#" ) : continue # print "input=%s" % ( line ), fields = line . split ( ) strand = "+" if len ( fields ) >= strand_col + 1 : if fields [ strand_col ] == "-" : strand = "-" chrom = fields [ chrom_col ] if chrom != last_chrom : if chrom not in bitsets : bitsets [ chrom ] = BinnedBitSet ( MAX ) last_chrom = chrom last_bitset = bitsets [ chrom ] start , end = int ( fields [ start_col ] ) , int ( fields [ end_col ] ) if strand == "+" : if upstream : start = max ( 0 , start - upstream ) if downstream : end = min ( MAX , end + downstream ) if strand == "-" : if upstream : end = min ( MAX , end + upstream ) if downstream : start = max ( 0 , start - downstream ) # print "set: start=%d\tend=%d" % ( start, end ) if end - start > 0 : last_bitset . set_range ( start , end - start ) return bitsets | Read a file into a dictionary of bitsets | 314 | 9 |
18,821 | def binned_bitsets_from_list ( list = [ ] ) : last_chrom = None last_bitset = None bitsets = dict ( ) for l in list : chrom = l [ 0 ] if chrom != last_chrom : if chrom not in bitsets : bitsets [ chrom ] = BinnedBitSet ( MAX ) last_chrom = chrom last_bitset = bitsets [ chrom ] start , end = int ( l [ 1 ] ) , int ( l [ 2 ] ) last_bitset . set_range ( start , end - start ) return bitsets | Read a list into a dictionary of bitsets | 124 | 9 |
18,822 | def binned_bitsets_by_chrom ( f , chrom , chrom_col = 0 , start_col = 1 , end_col = 2 ) : bitset = BinnedBitSet ( MAX ) for line in f : if line . startswith ( "#" ) : continue fields = line . split ( ) if fields [ chrom_col ] == chrom : start , end = int ( fields [ start_col ] ) , int ( fields [ end_col ] ) bitset . set_range ( start , end - start ) return bitset | Read a file by chrom name into a bitset | 117 | 10 |
18,823 | def _double_as_bytes ( dval ) : tmp = list ( struct . unpack ( '8B' , struct . pack ( 'd' , dval ) ) ) if not _big_endian : tmp . reverse ( ) return tmp | Use struct . unpack to decode a double precision float into eight bytes | 54 | 14 |
18,824 | def _mantissa ( dval ) : bb = _double_as_bytes ( dval ) mantissa = bb [ 1 ] & 0x0f << 48 mantissa += bb [ 2 ] << 40 mantissa += bb [ 3 ] << 32 mantissa += bb [ 4 ] return mantissa | Extract the _mantissa bits from a double - precision floating point value . | 69 | 17 |
18,825 | def _zero_mantissa ( dval ) : bb = _double_as_bytes ( dval ) return ( ( bb [ 1 ] & 0x0f ) | reduce ( operator . or_ , bb [ 2 : ] ) ) == 0 | Determine whether the mantissa bits of the given double are all zero . | 57 | 16 |
18,826 | def load_scores_wiggle ( fname ) : scores_by_chrom = dict ( ) for chrom , pos , val in bx . wiggle . Reader ( misc . open_compressed ( fname ) ) : if chrom not in scores_by_chrom : scores_by_chrom [ chrom ] = BinnedArray ( ) scores_by_chrom [ chrom ] [ pos ] = val return scores_by_chrom | Read a wiggle file and return a dict of BinnedArray objects keyed by chromosome . | 92 | 19 |
18,827 | def new ( self , min , max ) : # Ensure the range will fit given the shifting strategy assert MIN <= min <= max <= MAX self . min = min self . max = max # Determine offsets to use self . offsets = offsets_for_max_size ( max ) # Determine the largest bin we will actually use self . bin_count = bin_for_range ( max - 1 , max , offsets = self . offsets ) + 1 # Create empty bins self . bins = [ [ ] for i in range ( self . bin_count ) ] | Create an empty index for intervals in the range min max | 117 | 11 |
18,828 | def seek ( self , offset , whence = 0 ) : # Determine absolute target position if whence == 0 : target_pos = offset elif whence == 1 : target_pos = self . file_pos + offset elif whence == 2 : target_pos = self . size - offset else : raise Exception ( "Invalid `whence` argument: %r" , whence ) # Check if this is a noop if target_pos == self . file_pos : return # Verify it is valid assert 0 <= target_pos < self . size , "Attempt to seek outside file" # Move the position self . file_pos = target_pos # Mark as dirty, the next time a read is done we need to actually # move the position in the bzip2 file self . dirty = True | Move the file pointer to a particular offset . | 166 | 9 |
18,829 | def mtime ( self , key ) : if key not in self . __dict : raise CacheKeyError ( key ) else : node = self . __dict [ key ] return node . mtime | Return the last modification time for the cache record with key . May be useful for cache instances where the stored values can get stale such as caching file or network resource contents . | 41 | 34 |
18,830 | def class_space ( classlevel = 3 ) : frame = sys . _getframe ( classlevel ) classname = frame . f_code . co_name classdict = frame . f_locals return classname , classdict | returns the calling class name and dictionary | 49 | 8 |
18,831 | def build_alignment ( self , score , pieces ) : # build text self . open_seqs ( ) text1 = text2 = "" end1 = end2 = None for ( start1 , start2 , length , pctId ) in pieces : if ( end1 != None ) : if ( start1 == end1 ) : # insertion in sequence 2 text1 += self . seq1_gap * ( start2 - end2 ) text2 += self . seq2_file . get ( end2 , start2 - end2 ) else : # insertion in sequence 1 text1 += self . seq1_file . get ( end1 , start1 - end1 ) text2 += self . seq2_gap * ( start1 - end1 ) text1 += self . seq1_file . get ( start1 , length ) text2 += self . seq2_file . get ( start2 , length ) end1 = start1 + length end2 = start2 + length # create alignment start1 = pieces [ 0 ] [ 0 ] start2 = pieces [ 0 ] [ 1 ] end1 = pieces [ - 1 ] [ 0 ] + pieces [ - 1 ] [ 2 ] end2 = pieces [ - 1 ] [ 1 ] + pieces [ - 1 ] [ 2 ] size1 = end1 - start1 size2 = end2 - start2 a = Alignment ( score = score , species_to_lengths = self . species_to_lengths ) #if (self.seq1_strand == "-"): start1 = self.seq1_file.length - end1 a . add_component ( Component ( self . seq1_src , start1 , size1 , self . seq1_strand , text = text1 ) ) #if (self.seq2_strand == "-"): start2 = self.seq2_file.length - end2 a . add_component ( Component ( self . seq2_src , start2 , size2 , self . seq2_strand , text = text2 ) ) return a | converts a score and pieces to an alignment | 440 | 9 |
18,832 | def bits_clear_in_range ( bits , range_start , range_end ) : end = range_start while 1 : start = bits . next_clear ( end ) if start >= range_end : break end = min ( bits . next_set ( start ) , range_end ) yield start , end | Yield start end tuples for each span of clear bits in [ range_start range_end ) | 67 | 21 |
18,833 | def iterprogress ( sized_iterable ) : pb = ProgressBar ( 0 , len ( sized_iterable ) ) for i , value in enumerate ( sized_iterable ) : yield value pb . update_and_print ( i , sys . stderr ) | Iterate something printing progress bar to stdout | 59 | 9 |
18,834 | def to_file ( Class , dict , file , is_little_endian = True ) : io = BinaryFileWriter ( file , is_little_endian = is_little_endian ) start_offset = io . tell ( ) # Header is of fixed length io . seek ( start_offset + ( 8 * 256 ) ) # For each item, key and value length (written as length prefixed # strings). We also calculate the subtables on this pass. # NOTE: This requires the key and value be byte strings, support for # dealing with encoding specific value types should be # added to this wrapper subtables = [ [ ] for i in range ( 256 ) ] for key , value in dict . items ( ) : pair_offset = io . tell ( ) io . write_uint32 ( len ( key ) ) io . write_uint32 ( len ( value ) ) io . write ( key ) io . write ( value ) hash = cdbhash ( key ) subtables [ hash % 256 ] . append ( ( hash , pair_offset ) ) # Save the offset where the subtables will start subtable_offset = io . tell ( ) # Write subtables for subtable in subtables : if len ( subtable ) > 0 : # Construct hashtable to be twice the size of the number # of items in the subtable, and built it in memory ncells = len ( subtable ) * 2 cells = [ ( 0 , 0 ) for i in range ( ncells ) ] for hash , pair_offset in subtable : index = ( hash >> 8 ) % ncells while cells [ index ] [ 1 ] != 0 : index = ( index + 1 ) % ncells # Guaranteed to find a non-empty cell cells [ index ] = ( hash , pair_offset ) # Write subtable for hash , pair_offset in cells : io . write_uint32 ( hash ) io . write_uint32 ( pair_offset ) # Go back and write the header end_offset = io . tell ( ) io . seek ( start_offset ) index = subtable_offset for subtable in subtables : io . write_uint32 ( index ) io . write_uint32 ( len ( subtable * 2 ) ) # For each cell in the subtable, a hash and a pointer to a value index += ( len ( subtable ) * 2 ) * 8 # Leave fp at end of cdb io . seek ( end_offset ) | For constructing a CDB structure in a file . Able to calculate size on disk and write to a file | 521 | 21 |
18,835 | def read_len ( f ) : mapping = dict ( ) for line in f : fields = line . split ( ) mapping [ fields [ 0 ] ] = int ( fields [ 1 ] ) return mapping | Read a LEN file and return a mapping from chromosome to length | 42 | 13 |
18,836 | def eps_logo ( matrix , base_width , height , colors = DNA_DEFAULT_COLORS ) : alphabet = matrix . sorted_alphabet rval = StringIO ( ) # Read header ans substitute in width / height header = Template ( pkg_resources . resource_string ( __name__ , "template.ps" ) ) rval . write ( header . substitute ( bounding_box_width = ceil ( base_width * matrix . width ) + PAD , bounding_box_height = ceil ( height ) + PAD ) ) # Determine heights heights = freqs_to_heights ( matrix ) height_scale = height / log2 ( len ( alphabet ) ) # Draw each "row" of the matrix for i , row in enumerate ( heights ) : x = ( i * base_width ) y = 0 for j , base_height in enumerate ( row ) : char = alphabet [ j ] page_height = height_scale * base_height # print matrix.alphabet[j], base_height, height_scale, page_height if page_height > 1 : # Draw letter rval . write ( "%s setrgbcolor\n" % colors . get ( char , '0 0 0' ) ) rval . write ( "%3.2f " % x ) rval . write ( "%3.2f " % y ) rval . write ( "%3.2f " % ( x + base_width ) ) rval . write ( "%3.2f " % ( y + page_height ) ) rval . write ( "(%s) textInBox\n" % char ) y += page_height rval . write ( "showpage" ) return rval . getvalue ( ) | Return an EPS document containing a sequence logo for matrix where each bases is shown as a column of base_width points and the total logo height is height points . If colors is provided it is a mapping from characters to rgb color strings . | 381 | 47 |
18,837 | def transform ( elem , chain_CT_CQ , max_gap ) : ( chain , CT , CQ ) = chain_CT_CQ start , end = max ( elem [ 'start' ] , chain . tStart ) - chain . tStart , min ( elem [ 'end' ] , chain . tEnd ) - chain . tStart assert np . all ( ( CT [ : , 1 ] - CT [ : , 0 ] ) == ( CQ [ : , 1 ] - CQ [ : , 0 ] ) ) to_chrom = chain . qName to_gab_start = chain . qStart start_idx = np . where ( CT [ : , 1 ] > start ) [ 0 ] [ 0 ] end_idx = np . where ( CT [ : , 0 ] < end ) [ 0 ] [ - 1 ] if start_idx > end_idx : #maps to a gap region on the other species return [ ] ## apply the gap threshold if max_gap >= 0 and start_idx < end_idx - 1 : if np . max ( CT [ ( start_idx + 1 ) : end_idx , 0 ] - CT [ start_idx : ( end_idx - 1 ) , 1 ] ) > max_gap or np . max ( CQ [ ( start_idx + 1 ) : end_idx , 0 ] - CQ [ start_idx : ( end_idx - 1 ) , 1 ] ) > max_gap : return [ ] assert start < CT [ start_idx , 1 ] assert CT [ end_idx , 0 ] < end to_start = CQ [ start_idx , 0 ] + max ( 0 , start - CT [ start_idx , 0 ] ) # correct if on middle of interval to_end = CQ [ end_idx , 1 ] - max ( 0 , CT [ end_idx , 1 ] - end ) # idem if start_idx == end_idx : #elem falls in a single run of matches slices = [ ( to_start , to_end ) ] else : slices = [ ( to_start , CQ [ start_idx , 1 ] ) ] slices += [ ( CQ [ i , 0 ] , CQ [ i , 1 ] ) for i in range ( start_idx + 1 , end_idx ) ] slices . append ( ( CQ [ end_idx , 0 ] , to_end ) ) if chain . qStrand == '-' : Sz = chain . qEnd - chain . qStart slices = [ ( Sz - t [ 1 ] , Sz - t [ 0 ] ) for t in slices ] return [ ( to_chrom , to_gab_start + t [ 0 ] , to_gab_start + t [ 1 ] , elem [ 'id' ] ) for t in slices ] | transform the coordinates of this elem into the other species . | 632 | 12 |
18,838 | def loadChains ( path ) : EPO = epo . Chain . _parse_file ( path , True ) ## convert coordinates w.r.t the forward strand (into slices) ## compute cummulative intervals for i in range ( len ( EPO ) ) : ch , S , T , Q = EPO [ i ] if ch . tStrand == '-' : ch = ch . _replace ( tEnd = ch . tSize - ch . tStart , tStart = ch . tSize - ch . tEnd ) if ch . qStrand == '-' : ch = ch . _replace ( qEnd = ch . qSize - ch . qStart , qStart = ch . qSize - ch . qEnd ) EPO [ i ] = ( ch , epo . cummulative_intervals ( S , T ) , epo . cummulative_intervals ( S , Q ) ) ##now each element of epo is (chain_header, target_intervals, query_intervals) assert all ( t [ 0 ] . tStrand == '+' for t in EPO ) , "all target strands should be +" return EPO | name says it . | 252 | 4 |
18,839 | def loadFeatures ( path , opt ) : log . info ( "loading from %s ..." % path ) data = [ ] if opt . in_format == "BED" : with open ( path ) as fd : for line in fd : cols = line . split ( ) data . append ( ( cols [ 0 ] , int ( cols [ 1 ] ) , int ( cols [ 2 ] ) , cols [ 3 ] ) ) data = np . array ( data , dtype = elem_t ) else : with open ( path ) as fd : for line in fd : cols = line . split ( ) data . append ( ( cols [ 0 ] , int ( cols [ 1 ] ) , int ( cols [ 2 ] ) , cols [ 3 ] , int ( cols [ 4 ] ) , cols [ 5 ] , float ( cols [ 6 ] ) , float ( cols [ 7 ] ) , float ( cols [ 8 ] ) , int ( cols [ - 1 ] ) + int ( cols [ 1 ] ) ) ) data = np . array ( data , dtype = narrowPeak_t ) return data | Load features . For BED only BED4 columns are loaded . For narrowPeak all columns are loaded . | 254 | 23 |
18,840 | def add ( self , chrom , element ) : self . _trees . setdefault ( chrom , IntervalTree ( ) ) . insert_interval ( element ) | insert an element . use this method as the IntervalTree one . this will simply call the IntervalTree . add method on the right tree | 35 | 29 |
18,841 | def find ( self , chrom , start , end ) : tree = self . _trees . get ( chrom , None ) if tree : return tree . find ( start , end ) #return always a list return [ ] | find the intersecting elements | 46 | 5 |
18,842 | def create_from_other ( Class , other , values = None ) : m = Class ( ) m . alphabet = other . alphabet m . sorted_alphabet = other . sorted_alphabet m . char_to_index = other . char_to_index if values is not None : m . values = values else : m . values = other . values return m | Create a new Matrix with attributes taken from other but with the values taken from values if provided | 78 | 18 |
18,843 | def to_logodds_scoring_matrix ( self , background = None , correction = DEFAULT_CORRECTION ) : alphabet_size = len ( self . alphabet ) if background is None : background = ones ( alphabet_size , float32 ) / alphabet_size # Row totals as a one column array totals = numpy . sum ( self . values , 1 ) [ : , newaxis ] values = log2 ( maximum ( self . values , correction ) ) - log2 ( totals ) - log2 ( maximum ( background , correction ) ) return ScoringMatrix . create_from_other ( self , values . astype ( float32 ) ) | Create a standard logodds scoring matrix . | 138 | 9 |
18,844 | def score_string ( self , string ) : rval = zeros ( len ( string ) , float32 ) rval [ : ] = nan _pwm . score_string ( self . values , self . char_to_index , string , rval ) return rval | Score each valid position in string using this scoring matrix . Positions which were not scored are set to nan . | 59 | 22 |
18,845 | def _calc_resp ( password_hash , server_challenge ) : # padding with zeros to make the hash 21 bytes long password_hash += b'\x00' * ( 21 - len ( password_hash ) ) res = b'' dobj = DES ( DES . key56_to_key64 ( password_hash [ 0 : 7 ] ) ) res = res + dobj . encrypt ( server_challenge [ 0 : 8 ] ) dobj = DES ( DES . key56_to_key64 ( password_hash [ 7 : 14 ] ) ) res = res + dobj . encrypt ( server_challenge [ 0 : 8 ] ) dobj = DES ( DES . key56_to_key64 ( password_hash [ 14 : 21 ] ) ) res = res + dobj . encrypt ( server_challenge [ 0 : 8 ] ) return res | Generate the LM response given a 16 - byte password hash and the challenge from the CHALLENGE_MESSAGE | 188 | 26 |
18,846 | def encrypt ( self , data , pad = True ) : encrypted_data = b"" for i in range ( 0 , len ( data ) , 8 ) : block = data [ i : i + 8 ] block_length = len ( block ) if block_length != 8 and pad : block += b"\x00" * ( 8 - block_length ) elif block_length != 8 : raise ValueError ( "DES encryption must be a multiple of 8 " "bytes" ) encrypted_data += self . _encode_block ( block ) return encrypted_data | DES encrypts the data based on the key it was initialised with . | 120 | 15 |
18,847 | def decrypt ( self , data ) : decrypted_data = b"" for i in range ( 0 , len ( data ) , 8 ) : block = data [ i : i + 8 ] block_length = len ( block ) if block_length != 8 : raise ValueError ( "DES decryption must be a multiple of 8 " "bytes" ) decrypted_data += self . _decode_block ( block ) return decrypted_data | DES decrypts the data based on the key it was initialised with . | 94 | 15 |
18,848 | def key56_to_key64 ( key ) : if len ( key ) != 7 : raise ValueError ( "DES 7-byte key is not 7 bytes in length, " "actual: %d" % len ( key ) ) new_key = b"" for i in range ( 0 , 8 ) : if i == 0 : new_value = struct . unpack ( "B" , key [ i : i + 1 ] ) [ 0 ] elif i == 7 : new_value = struct . unpack ( "B" , key [ 6 : 7 ] ) [ 0 ] new_value = ( new_value << 1 ) & 0xFF else : new_value = struct . unpack ( "B" , key [ i - 1 : i ] ) [ 0 ] next_value = struct . unpack ( "B" , key [ i : i + 1 ] ) [ 0 ] new_value = ( ( new_value << ( 8 - i ) ) & 0xFF ) | next_value >> i # clear the last bit so the count isn't off new_value = new_value & ~ ( 1 << 0 ) # set the last bit if the number of set bits are even new_value = new_value | int ( not DES . bit_count ( new_value ) & 0x1 ) new_key += struct . pack ( "B" , new_value ) return new_key | This takes in an a bytes string of 7 bytes and converts it to a bytes string of 8 bytes with the odd parity bit being set to every 8 bits | 303 | 31 |
18,849 | def visit_Method ( self , method ) : resolved_method = method . resolved . type def get_params ( method , extra_bindings ) : # The Method should already be the resolved version. result = [ ] for param in method . params : resolved_param = texpr ( param . resolved . type , param . resolved . bindings , extra_bindings ) result . append ( resolved_param . id ) return result def get_return_type ( method , extra_bindings ) : # The Method should already be the resolved version. return texpr ( method . type . resolved . type , method . type . resolved . bindings , extra_bindings ) . id def signature ( method , return_type , params ) : return "%s %s(%s)" % ( return_type , method . name . text , ", " . join ( params ) ) # Ensure the method has the same signature as matching methods on parent # interfaces: interfaces = list ( t for t in method . clazz . bases if isinstance ( t . resolved . type , Interface ) ) for interface in interfaces : interfaceTypeExpr = interface . resolved for definition in interfaceTypeExpr . type . definitions : if definition . name . text == method . name . text : resolved_definition = definition . resolved . type method_params = get_params ( resolved_method , method . clazz . resolved . bindings ) definition_params = get_params ( resolved_definition , interfaceTypeExpr . bindings ) method_return = get_return_type ( resolved_method , method . clazz . resolved . bindings ) definition_return = get_return_type ( resolved_definition , interfaceTypeExpr . bindings ) if method_params != definition_params or method_return != definition_return : self . errors . append ( "%s: method signature '%s' on %s does not match method '%s' on interface %s" % ( lineinfo ( method ) , signature ( resolved_method , method_return , method_params ) , method . clazz . resolved . type . id , signature ( resolved_definition , definition_return , definition_params ) , interface . resolved . type . id ) ) | Ensure method has the same signature matching method on parent interface . | 462 | 13 |
18,850 | def get_doc ( node ) : res = " " . join ( get_doc_annotations ( node ) ) if not res : res = "(%s)" % node . __class__ . __name__ . lower ( ) return res | Return a node s documentation as a string pulling from annotations or constructing a simple fake as needed . | 51 | 19 |
18,851 | def get_code ( node , coder = Coder ( ) ) : return cgi . escape ( str ( coder . code ( node ) ) , quote = True ) | Return a node s code | 37 | 5 |
18,852 | def setup_environ ( self ) : SimpleHandler . setup_environ ( self ) self . environ [ 'ws4py.socket' ] = get_connection ( self . environ [ 'wsgi.input' ] ) self . http_version = self . environ [ 'SERVER_PROTOCOL' ] . rsplit ( '/' ) [ - 1 ] | Setup the environ dictionary and add the ws4py . socket key . Its associated value is the real socket underlying socket . | 82 | 26 |
18,853 | def handle ( self ) : self . raw_requestline = self . rfile . readline ( ) if not self . parse_request ( ) : # An error code has been sent, just exit return # next line is where we'd have expect a configuration key somehow handler = self . WebSocketWSGIHandler ( self . rfile , self . wfile , self . get_stderr ( ) , self . get_environ ( ) ) handler . request_handler = self # backpointer for logging handler . run ( self . server . get_app ( ) ) | Unfortunately the base class forces us to override the whole method to actually provide our wsgi handler . | 121 | 20 |
18,854 | def configure ( self , voltage_range = RANGE_32V , gain = GAIN_AUTO , bus_adc = ADC_12BIT , shunt_adc = ADC_12BIT ) : self . __validate_voltage_range ( voltage_range ) self . _voltage_range = voltage_range if self . _max_expected_amps is not None : if gain == self . GAIN_AUTO : self . _auto_gain_enabled = True self . _gain = self . _determine_gain ( self . _max_expected_amps ) else : self . _gain = gain else : if gain != self . GAIN_AUTO : self . _gain = gain else : self . _auto_gain_enabled = True self . _gain = self . GAIN_1_40MV logging . info ( 'gain set to %.2fV' % self . __GAIN_VOLTS [ self . _gain ] ) logging . debug ( self . __LOG_MSG_1 % ( self . _shunt_ohms , self . __BUS_RANGE [ voltage_range ] , self . __GAIN_VOLTS [ self . _gain ] , self . __max_expected_amps_to_string ( self . _max_expected_amps ) , bus_adc , shunt_adc ) ) self . _calibrate ( self . __BUS_RANGE [ voltage_range ] , self . __GAIN_VOLTS [ self . _gain ] , self . _max_expected_amps ) self . _configure ( voltage_range , self . _gain , bus_adc , shunt_adc ) | Configures and calibrates how the INA219 will take measurements . | 369 | 14 |
18,855 | def wake ( self ) : configuration = self . _read_configuration ( ) self . _configuration_register ( configuration | 0x0007 ) # 40us delay to recover from powerdown (p14 of spec) time . sleep ( 0.00004 ) | Wake the INA219 from power down mode | 56 | 10 |
18,856 | def _return_response_and_status_code ( response , json_results = True ) : if response . status_code == requests . codes . ok : return dict ( results = response . json ( ) if json_results else response . content , response_code = response . status_code ) elif response . status_code == 400 : return dict ( error = 'package sent is either malformed or not within the past 24 hours.' , response_code = response . status_code ) elif response . status_code == 204 : return dict ( error = 'You exceeded the public API request rate limit (4 requests of any nature per minute)' , response_code = response . status_code ) elif response . status_code == 403 : return dict ( error = 'You tried to perform calls to functions for which you require a Private API key.' , response_code = response . status_code ) elif response . status_code == 404 : return dict ( error = 'File not found.' , response_code = response . status_code ) else : return dict ( response_code = response . status_code ) | Output the requests response content or content as json and status code | 237 | 12 |
18,857 | def put_comments ( self , resource , comment , timeout = None ) : params = { 'apikey' : self . api_key , 'resource' : resource , 'comment' : comment } try : response = requests . post ( self . base + 'comments/put' , params = params , proxies = self . proxies , timeout = timeout ) except requests . RequestException as e : return dict ( error = str ( e ) ) return _return_response_and_status_code ( response ) | Post a comment on a file or URL . | 107 | 9 |
18,858 | def get_ip_report ( self , this_ip , timeout = None ) : params = { 'apikey' : self . api_key , 'ip' : this_ip } try : response = requests . get ( self . base + 'ip-address/report' , params = params , proxies = self . proxies , timeout = timeout ) except requests . RequestException as e : return dict ( error = str ( e ) ) return _return_response_and_status_code ( response ) | Get IP address reports . | 107 | 5 |
18,859 | def get_domain_report ( self , this_domain , timeout = None ) : params = { 'apikey' : self . api_key , 'domain' : this_domain } try : response = requests . get ( self . base + 'domain/report' , params = params , proxies = self . proxies , timeout = timeout ) except requests . RequestException as e : return dict ( error = str ( e ) ) return _return_response_and_status_code ( response ) | Get information about a given domain . | 105 | 7 |
18,860 | def get_upload_url ( self , timeout = None ) : params = { 'apikey' : self . api_key } try : response = requests . get ( self . base + 'file/scan/upload_url' , params = params , proxies = self . proxies , timeout = timeout ) if response . status_code == requests . codes . ok : return response . json ( ) . get ( 'upload_url' ) else : return dict ( response_code = response . status_code ) except requests . RequestException as e : return dict ( error = str ( e ) ) | Get a special URL for submitted files bigger than 32MB . | 126 | 12 |
18,861 | def file_search ( self , query , offset = None , timeout = None ) : params = dict ( apikey = self . api_key , query = query , offset = offset ) try : response = requests . get ( self . base + 'file/search' , params = params , proxies = self . proxies , timeout = timeout ) except requests . RequestException as e : return dict ( error = str ( e ) ) return _return_response_and_status_code ( response ) | Search for samples . | 104 | 4 |
18,862 | def get_file_clusters ( self , this_date , timeout = None ) : params = { 'apikey' : self . api_key , 'date' : this_date } try : response = requests . get ( self . base + 'file/clusters' , params = params , proxies = self . proxies , timeout = timeout ) except requests . RequestException as e : return dict ( error = str ( e ) ) return _return_response_and_status_code ( response ) | File similarity clusters for a given time frame . | 107 | 9 |
18,863 | def get_url_distribution ( self , after = None , reports = 'true' , limit = 1000 , timeout = None ) : params = { 'apikey' : self . api_key , 'after' : after , 'reports' : reports , 'limit' : limit } try : response = requests . get ( self . base + 'url/distribution' , params = params , proxies = self . proxies , timeout = timeout ) except requests . RequestException as e : return dict ( error = str ( e ) ) return _return_response_and_status_code ( response ) | Get a live feed with the lastest URLs submitted to VirusTotal . | 127 | 14 |
18,864 | def get_url_feed ( self , package = None , timeout = None ) : if package is None : now = datetime . utcnow ( ) five_minutes_ago = now - timedelta ( minutes = now . minute % 5 + 5 , seconds = now . second , microseconds = now . microsecond ) package = five_minutes_ago . strftime ( '%Y%m%dT%H%M' ) params = { 'apikey' : self . api_key , 'package' : package } try : response = requests . get ( self . base + 'url/feed' , params = params , proxies = self . proxies , timeout = timeout ) except requests . RequestException as e : return dict ( error = str ( e ) ) return _return_response_and_status_code ( response , json_results = False ) | Get a live file feed with the latest files submitted to VirusTotal . | 186 | 14 |
18,865 | def get_intel_notifications_feed ( self , page = None , timeout = None ) : params = { 'apikey' : self . api_key , 'next' : page } try : response = requests . get ( self . base + 'hunting/notifications-feed/' , params = params , proxies = self . proxies , timeout = timeout ) # VT returns an empty result, len(content)==0, and status OK if there are no pending notifications. # To keep the API consistent we generate an empty object instead. # This might not be necessary with a later release of the VTI API. (bug has been submitted) if len ( response . content ) == 0 : response . __dict__ [ '_content' ] = b'{"notifications":[],"verbose_msg":"No pending notification","result":0,"next":null}' except requests . RequestException as e : return dict ( error = str ( e ) ) return _return_response_and_status_code ( response ) | Get notification feed in JSON for further processing . | 217 | 9 |
18,866 | def delete_intel_notifications ( self , ids , timeout = None ) : if not isinstance ( ids , list ) : raise TypeError ( "ids must be a list" ) # VirusTotal needs ids as a stringified array data = json . dumps ( ids ) try : response = requests . post ( self . base + 'hunting/delete-notifications/programmatic/?key=' + self . api_key , data = data , proxies = self . proxies , timeout = timeout ) except requests . RequestException as e : return dict ( error = str ( e ) ) return _return_response_and_status_code ( response ) | Programmatically delete notifications via the Intel API . | 140 | 9 |
18,867 | def get_credentials ( self ) : return Credentials ( access_key = self . aws_access_key_id , secret_key = self . aws_secret_access_key , token = self . aws_session_token ) | Returns botocore . credential . Credential object . | 56 | 12 |
18,868 | def form_valid ( self , form ) : form_valid_from_parent = super ( HostCreate , self ) . form_valid ( form ) messages . success ( self . request , 'Host {} Successfully Created' . format ( self . object ) ) return form_valid_from_parent | First call the parent s form valid then let the user know it worked . | 63 | 15 |
18,869 | def post ( self , * args , * * kwargs ) : existing_ssh = models . SSHConfig . objects . all ( ) if existing_ssh . exists ( ) : return self . get_view ( ) remote_user = self . request . POST . get ( 'remote_user' , 'root' ) create_ssh_config ( remote_user = remote_user ) return self . get_view ( ) | Create the SSH file & then return the normal get method ... | 90 | 12 |
18,870 | def update_sandbox_site ( comment_text ) : file_to_deliver = NamedTemporaryFile ( delete = False ) file_text = "Deployed at: {} <br /> Comment: {}" . format ( datetime . datetime . now ( ) . strftime ( '%c' ) , cgi . escape ( comment_text ) ) file_to_deliver . write ( file_text ) file_to_deliver . close ( ) put ( file_to_deliver . name , '/var/www/html/index.html' , use_sudo = True ) | put s a text file on the server | 130 | 8 |
18,871 | def web_hooks ( self , include_global = True ) : from fabric_bolt . web_hooks . models import Hook ors = [ Q ( project = self ) ] if include_global : ors . append ( Q ( project = None ) ) hooks = Hook . objects . filter ( reduce ( operator . or_ , ors ) ) return hooks | Get all web hooks for this project . Includes global hooks . | 77 | 12 |
18,872 | def get_deployment_count ( self ) : ret = self . stage_set . annotate ( num_deployments = Count ( 'deployment' ) ) . aggregate ( total_deployments = Sum ( 'num_deployments' ) ) return ret [ 'total_deployments' ] | Utility function to get the number of deployments a given project has | 69 | 13 |
18,873 | def get_configurations ( self ) : project_configurations_dictionary = { } project_configurations = self . project . project_configurations ( ) # Create project specific configurations dictionary for config in project_configurations : project_configurations_dictionary [ config . key ] = config stage_configurations_dictionary = { } stage_configurations = self . stage_configurations ( ) # Create stage specific configurations dictionary for s in stage_configurations : stage_configurations_dictionary [ s . key ] = s # override project specific configuration with the ones in the stage if they are there project_configurations_dictionary . update ( stage_configurations_dictionary ) # Return the updated configurations return project_configurations_dictionary | Generates a dictionary that s made up of the configurations on the project . Any configurations on a project that are duplicated on a stage the stage configuration will take precedence . | 159 | 34 |
18,874 | def get_absolute_url ( self ) : # Determine if this configuration is on a stage if self . stage : # Stage specific configurations go back to the stage view url = reverse ( 'projects_stage_view' , args = ( self . project . pk , self . stage . pk ) ) else : # Project specific configurations go back to the project page url = self . project . get_absolute_url ( ) return url | Determine where I am coming from and where I am going | 92 | 13 |
18,875 | def gravatar ( self , size = 20 ) : default = "mm" gravatar_url = "//www.gravatar.com/avatar/" + hashlib . md5 ( self . email . lower ( ) ) . hexdigest ( ) + "?" gravatar_url += urllib . urlencode ( { 'd' : default , 's' : str ( size ) } ) return gravatar_url | Construct a gravatar image address for the user | 93 | 9 |
18,876 | def hooks ( self , project ) : return self . get_queryset ( ) . filter ( Q ( project = None ) | Q ( project = project ) ) . distinct ( 'url' ) | Look up the urls we need to post to | 42 | 10 |
18,877 | def web_hook_receiver ( sender , * * kwargs ) : deployment = Deployment . objects . get ( pk = kwargs . get ( 'deployment_id' ) ) hooks = deployment . web_hooks if not hooks : return for hook in hooks : data = payload_generator ( deployment ) deliver_hook ( deployment , hook . url , data ) | Generic receiver for the web hook firing piece . | 83 | 9 |
18,878 | def paginate ( self , klass = Paginator , per_page = None , page = 1 , * args , * * kwargs ) : self . per_page_options = [ 25 , 50 , 100 , 200 ] # This should probably be a passed in option self . per_page = per_page = per_page or self . _meta . per_page self . paginator = klass ( self . rows , per_page , * args , * * kwargs ) self . page = self . paginator . page ( page ) # Calc variables for use in displaying first, adjacent, and last page links adjacent_pages = 1 # This should probably be a passed in option # Starting page (first page between the ellipsis) start_page = max ( self . page . number - adjacent_pages , 1 ) if start_page <= 3 : start_page = 1 # Ending page (last page between the ellipsis) end_page = self . page . number + adjacent_pages + 1 if end_page >= self . paginator . num_pages - 1 : end_page = self . paginator . num_pages + 1 # Paging vars used in template self . page_numbers = [ n for n in range ( start_page , end_page ) if 0 < n <= self . paginator . num_pages ] self . show_first = 1 not in self . page_numbers self . show_last = self . paginator . num_pages not in self . page_numbers | Paginates the table using a paginator and creates a page property containing information for the current page . | 328 | 21 |
18,879 | def get_fabric_tasks ( self , project ) : cache_key = 'project_{}_fabfile_tasks' . format ( project . pk ) cached_result = cache . get ( cache_key ) if cached_result : return cached_result try : fabfile_path , activate_loc = self . get_fabfile_path ( project ) if activate_loc : output = self . check_output ( 'source {};fab --list --list-format=short --fabfile={}' . format ( activate_loc , fabfile_path ) , shell = True ) else : output = self . check_output ( 'fab --list --list-format=short --fabfile={}' . format ( fabfile_path ) , shell = True ) lines = output . splitlines ( ) tasks = [ ] for line in lines : name = line . strip ( ) if activate_loc : o = self . check_output ( 'source {};fab --display={} --fabfile={}' . format ( activate_loc , name , fabfile_path ) , shell = True ) else : o = self . check_output ( [ 'fab' , '--display={}' . format ( name ) , '--fabfile={}' . format ( fabfile_path ) ] ) tasks . append ( self . parse_task_details ( name , o ) ) cache . set ( cache_key , tasks , settings . FABRIC_TASK_CACHE_TIMEOUT ) except Exception as e : tasks = [ ] return tasks | Generate a list of fabric tasks that are available | 338 | 10 |
18,880 | def get_initial ( self ) : initial = super ( ProjectCopy , self ) . get_initial ( ) if self . copy_object : initial . update ( { 'name' : '%s copy' % self . copy_object . name , 'description' : self . copy_object . description , 'use_repo_fabfile' : self . copy_object . use_repo_fabfile , 'fabfile_requirements' : self . copy_object . fabfile_requirements , 'repo_url' : self . copy_object . repo_url } ) return initial | Returns the initial data to use for forms on this view . | 129 | 12 |
18,881 | def get_success_url ( self ) : if self . stage_id : url = reverse ( 'projects_stage_view' , args = ( self . project_id , self . stage_id ) ) else : url = reverse ( 'projects_project_view' , args = ( self . project_id , ) ) return url | Get the url depending on what type of configuration I deleted . | 72 | 12 |
18,882 | def create_ssh_config ( remote_user = 'root' , name = 'Auto Generated SSH Key' , file_name = 'fabricbolt_private.key' , email = 'deployments@fabricbolt.io' , public_key_text = None , private_key_text = None ) : if not private_key_text and not public_key_text : key = RSA . generate ( 2048 ) pubkey = key . publickey ( ) private_key_text = key . exportKey ( 'PEM' ) public_key_text = pubkey . exportKey ( 'OpenSSH' ) ssh_config = models . SSHConfig ( ) ssh_config . name = name ssh_config . private_key_file . save ( file_name , ContentFile ( private_key_text ) ) ssh_config . public_key = '{} {}' . format ( public_key_text , email ) ssh_config . remote_user = remote_user ssh_config . save ( ) return ssh_config | Create SSH Key | 225 | 3 |
18,883 | def convert ( self , json = "" , table_attributes = 'border="1"' , clubbing = True , encode = False , escape = True ) : # table attributes such as class, id, data-attr-*, etc. # eg: table_attributes = 'class = "table table-bordered sortable"' self . table_init_markup = "<table %s>" % table_attributes self . clubbing = clubbing self . escape = escape json_input = None if not json : json_input = { } elif type ( json ) in text_types : try : json_input = json_parser . loads ( json , object_pairs_hook = OrderedDict ) except ValueError as e : #so the string passed here is actually not a json string # - let's analyze whether we want to pass on the error or use the string as-is as a text node if u"Expecting property name" in text ( e ) : #if this specific json loads error is raised, then the user probably actually wanted to pass json, but made a mistake raise e json_input = json else : json_input = json converted = self . convert_json_node ( json_input ) if encode : return converted . encode ( 'ascii' , 'xmlcharrefreplace' ) return converted | Convert JSON to HTML Table format | 284 | 7 |
18,884 | def column_headers_from_list_of_dicts ( self , json_input ) : if not json_input or not hasattr ( json_input , '__getitem__' ) or not hasattr ( json_input [ 0 ] , 'keys' ) : return None column_headers = json_input [ 0 ] . keys ( ) for entry in json_input : if not hasattr ( entry , 'keys' ) or not hasattr ( entry , '__iter__' ) or len ( entry . keys ( ) ) != len ( column_headers ) : return None for header in column_headers : if header not in entry : return None return column_headers | This method is required to implement clubbing . It tries to come up with column headers for your input | 144 | 20 |
18,885 | def convert_list ( self , list_input ) : if not list_input : return "" converted_output = "" column_headers = None if self . clubbing : column_headers = self . column_headers_from_list_of_dicts ( list_input ) if column_headers is not None : converted_output += self . table_init_markup converted_output += '<thead>' converted_output += '<tr><th>' + '</th><th>' . join ( column_headers ) + '</th></tr>' converted_output += '</thead>' converted_output += '<tbody>' for list_entry in list_input : converted_output += '<tr><td>' converted_output += '</td><td>' . join ( [ self . convert_json_node ( list_entry [ column_header ] ) for column_header in column_headers ] ) converted_output += '</td></tr>' converted_output += '</tbody>' converted_output += '</table>' return converted_output #so you don't want or need clubbing eh? This makes @muellermichel very sad... ;( #alright, let's fall back to a basic list here... converted_output = '<ul><li>' converted_output += '</li><li>' . join ( [ self . convert_json_node ( child ) for child in list_input ] ) converted_output += '</li></ul>' return converted_output | Iterate over the JSON list and process it to generate either an HTML table or a HTML list depending on what s inside . If suppose some key has array of objects and all the keys are same instead of creating a new row for each such entry club such values thus it makes more sense and more readable table . | 336 | 62 |
18,886 | def convert_object ( self , json_input ) : if not json_input : return "" #avoid empty tables converted_output = self . table_init_markup + "<tr>" converted_output += "</tr><tr>" . join ( [ "<th>%s</th><td>%s</td>" % ( self . convert_json_node ( k ) , self . convert_json_node ( v ) ) for k , v in json_input . items ( ) ] ) converted_output += '</tr></table>' return converted_output | Iterate over the JSON object and process it to generate the super awesome HTML Table format | 122 | 17 |
18,887 | def personsAtHome ( self , home = None ) : if not home : home = self . default_home home_data = self . homeByName ( home ) atHome = [ ] for p in home_data [ 'persons' ] : #Only check known persons if 'pseudo' in p : if not p [ "out_of_sight" ] : atHome . append ( p [ 'pseudo' ] ) return atHome | Return the list of known persons who are currently at home | 95 | 11 |
18,888 | def getProfileImage ( self , name ) : for p in self . persons : if 'pseudo' in self . persons [ p ] : if name == self . persons [ p ] [ 'pseudo' ] : image_id = self . persons [ p ] [ 'face' ] [ 'id' ] key = self . persons [ p ] [ 'face' ] [ 'key' ] return self . getCameraPicture ( image_id , key ) return None , None | Retrieve the face of a given person | 101 | 8 |
18,889 | def updateEvent ( self , event = None , home = None ) : if not home : home = self . default_home if not event : #If not event is provided we need to retrieve the oldest of the last event seen by each camera listEvent = dict ( ) for cam_id in self . lastEvent : listEvent [ self . lastEvent [ cam_id ] [ 'time' ] ] = self . lastEvent [ cam_id ] event = listEvent [ sorted ( listEvent ) [ 0 ] ] home_data = self . homeByName ( home ) postParams = { "access_token" : self . getAuthToken , "home_id" : home_data [ 'id' ] , "event_id" : event [ 'id' ] } resp = postRequest ( _GETEVENTSUNTIL_REQ , postParams ) eventList = resp [ 'body' ] [ 'events_list' ] for e in eventList : self . events [ e [ 'camera_id' ] ] [ e [ 'time' ] ] = e for camera in self . events : self . lastEvent [ camera ] = self . events [ camera ] [ sorted ( self . events [ camera ] ) [ - 1 ] ] | Update the list of event with the latest ones | 266 | 9 |
18,890 | def personSeenByCamera ( self , name , home = None , camera = None ) : try : cam_id = self . cameraByName ( camera = camera , home = home ) [ 'id' ] except TypeError : logger . warning ( "personSeenByCamera: Camera name or home is unknown" ) return False #Check in the last event is someone known has been seen if self . lastEvent [ cam_id ] [ 'type' ] == 'person' : person_id = self . lastEvent [ cam_id ] [ 'person_id' ] if 'pseudo' in self . persons [ person_id ] : if self . persons [ person_id ] [ 'pseudo' ] == name : return True return False | Return True if a specific person has been seen by a camera | 159 | 12 |
18,891 | def someoneKnownSeen ( self , home = None , camera = None ) : try : cam_id = self . cameraByName ( camera = camera , home = home ) [ 'id' ] except TypeError : logger . warning ( "personSeenByCamera: Camera name or home is unknown" ) return False #Check in the last event is someone known has been seen if self . lastEvent [ cam_id ] [ 'type' ] == 'person' : if self . lastEvent [ cam_id ] [ 'person_id' ] in self . _knownPersons ( ) : return True return False | Return True if someone known has been seen | 130 | 8 |
18,892 | def motionDetected ( self , home = None , camera = None ) : try : cam_id = self . cameraByName ( camera = camera , home = home ) [ 'id' ] except TypeError : logger . warning ( "personSeenByCamera: Camera name or home is unknown" ) return False if self . lastEvent [ cam_id ] [ 'type' ] == 'movement' : return True return False | Return True if movement has been detected | 91 | 7 |
18,893 | def batch ( sequence , callback , size = 100 , * * kwargs ) : batch_len , rem = divmod ( len ( sequence ) , size ) if rem > 0 : batch_len += 1 for i in range ( batch_len ) : offset = i * size yield callback ( sequence [ offset : offset + size ] , * * kwargs ) | Helper to setup batch requests . | 77 | 6 |
18,894 | def _handle_retry ( self , resp ) : exc_t , exc_v , exc_tb = sys . exc_info ( ) if exc_t is None : raise TypeError ( 'Must be called in except block.' ) retry_on_exc = tuple ( ( x for x in self . _retry_on if inspect . isclass ( x ) ) ) retry_on_codes = tuple ( ( x for x in self . _retry_on if isinstance ( x , int ) ) ) if issubclass ( exc_t , ZendeskError ) : code = exc_v . error_code if exc_t not in retry_on_exc and code not in retry_on_codes : six . reraise ( exc_t , exc_v , exc_tb ) else : if not issubclass ( exc_t , retry_on_exc ) : six . reraise ( exc_t , exc_v , exc_tb ) if resp is not None : try : retry_after = float ( resp . headers . get ( 'Retry-After' , 0 ) ) time . sleep ( retry_after ) except ( TypeError , ValueError ) : pass return True | Handle any exceptions during API request or parsing its response status code . | 270 | 13 |
18,895 | def notification_redirect ( request , ctx ) : if request . is_ajax ( ) : return JsonResponse ( ctx ) else : next_page = request . POST . get ( 'next' , reverse ( 'notifications:all' ) ) if not ctx [ 'success' ] : return HttpResponseBadRequest ( ctx [ 'msg' ] ) if is_safe_url ( next_page ) : return HttpResponseRedirect ( next_page ) else : return HttpResponseRedirect ( reverse ( 'notifications:all' ) ) | Helper to handle HTTP response after an action is performed on notification | 123 | 12 |
18,896 | def mark ( request ) : notification_id = request . POST . get ( 'id' , None ) action = request . POST . get ( 'action' , None ) success = True if notification_id : try : notification = Notification . objects . get ( pk = notification_id , recipient = request . user ) if action == 'read' : notification . mark_as_read ( ) msg = _ ( "Marked as read" ) elif action == 'unread' : notification . mark_as_unread ( ) msg = _ ( "Marked as unread" ) else : success = False msg = _ ( "Invalid mark action." ) except Notification . DoesNotExist : success = False msg = _ ( "Notification does not exists." ) else : success = False msg = _ ( "Invalid Notification ID" ) ctx = { 'msg' : msg , 'success' : success , 'action' : action } return notification_redirect ( request , ctx ) | Handles marking of individual notifications as read or unread . Takes notification id and mark action as POST data . | 211 | 22 |
18,897 | def mark_all ( request ) : action = request . POST . get ( 'action' , None ) success = True if action == 'read' : request . user . notifications . read_all ( ) msg = _ ( "Marked all notifications as read" ) elif action == 'unread' : request . user . notifications . unread_all ( ) msg = _ ( "Marked all notifications as unread" ) else : msg = _ ( "Invalid mark action" ) success = False ctx = { 'msg' : msg , 'success' : success , 'action' : action } return notification_redirect ( request , ctx ) | Marks notifications as either read or unread depending of POST parameters . Takes action as POST data it can either be read or unread . | 139 | 28 |
18,898 | def delete ( request ) : notification_id = request . POST . get ( 'id' , None ) success = True if notification_id : try : notification = Notification . objects . get ( pk = notification_id , recipient = request . user ) soft_delete = getattr ( settings , 'NOTIFY_SOFT_DELETE' , True ) if soft_delete : notification . deleted = True notification . save ( ) else : notification . delete ( ) msg = _ ( "Deleted notification successfully" ) except Notification . DoesNotExist : success = False msg = _ ( "Notification does not exists." ) else : success = False msg = _ ( "Invalid Notification ID" ) ctx = { 'msg' : msg , 'success' : success , } return notification_redirect ( request , ctx ) | Deletes notification of supplied notification ID . | 176 | 8 |
18,899 | def notification_update ( request ) : flag = request . GET . get ( 'flag' , None ) target = request . GET . get ( 'target' , 'box' ) last_notification = int ( flag ) if flag . isdigit ( ) else None if last_notification : new_notifications = request . user . notifications . filter ( id__gt = last_notification ) . active ( ) . prefetch ( ) msg = _ ( "Notifications successfully retrieved." ) if new_notifications else _ ( "No new notifications." ) notification_list = [ ] for nf in new_notifications : notification = nf . as_json ( ) notification_list . append ( notification ) notification [ 'html' ] = render_notification ( nf , render_target = target , * * notification ) ctx = { "retrieved" : len ( new_notifications ) , "unread_count" : request . user . notifications . unread ( ) . count ( ) , "notifications" : notification_list , "success" : True , "msg" : msg , } return JsonResponse ( ctx ) else : msg = _ ( "Notification flag not sent." ) ctx = { "success" : False , "msg" : msg } return JsonResponse ( ctx ) | Handles live updating of notifications follows ajax - polling approach . | 283 | 14 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.