idx int64 0 251k | question stringlengths 53 3.53k | target stringlengths 5 1.23k | len_question int64 20 893 | len_target int64 3 238 |
|---|---|---|---|---|
249,700 | def _prependstore ( self , store ) : if not store . bitlength : return # Set the offset of copy of store so that it's final byte # ends in a position that matches the offset of self, # then join self on to the end of it. store = offsetcopy ( store , ( self . offset - store . bitlength ) % 8 ) assert ( store . offset + ... | Join another store on to the start of this one . | 264 | 11 |
249,701 | def _assertsanity ( self ) : assert self . len >= 0 assert 0 <= self . _offset , "offset={0}" . format ( self . _offset ) assert ( self . len + self . _offset + 7 ) // 8 == self . _datastore . bytelength + self . _datastore . byteoffset return True | Check internal self consistency as a debugging aid . | 74 | 9 |
249,702 | def _setauto ( self , s , length , offset ) : # As s can be so many different things it's important to do the checks # in the correct order, as some types are also other allowed types. # So basestring must be checked before Iterable # and bytes/bytearray before Iterable but after basestring! if isinstance ( s , Bits ) ... | Set bitstring from a bitstring file bool integer array iterable or string . | 623 | 16 |
249,703 | def _setfile ( self , filename , length , offset ) : source = open ( filename , 'rb' ) if offset is None : offset = 0 if length is None : length = os . path . getsize ( source . name ) * 8 - offset byteoffset , offset = divmod ( offset , 8 ) bytelength = ( length + byteoffset * 8 + offset + 7 ) // 8 - byteoffset m = Mm... | Use file as source of bits . | 156 | 7 |
249,704 | def _setbytes_safe ( self , data , length = None , offset = 0 ) : data = bytearray ( data ) if length is None : # Use to the end of the data length = len ( data ) * 8 - offset self . _datastore = ByteStore ( data , length , offset ) else : if length + offset > len ( data ) * 8 : msg = "Not enough data present. Need {0}... | Set the data from a string . | 159 | 7 |
249,705 | def _setbytes_unsafe ( self , data , length , offset ) : self . _datastore = ByteStore ( data [ : ] , length , offset ) assert self . _assertsanity ( ) | Unchecked version of _setbytes_safe . | 45 | 10 |
249,706 | def _readbytes ( self , length , start ) : assert length % 8 == 0 assert start + length <= self . len if not ( start + self . _offset ) % 8 : return bytes ( self . _datastore . getbyteslice ( ( start + self . _offset ) // 8 , ( start + self . _offset + length ) // 8 ) ) return self . _slice ( start , start + length ) .... | Read bytes and return them . Note that length is in bits . | 96 | 13 |
249,707 | def _setuint ( self , uint , length = None ) : try : if length is None : # Use the whole length. Deliberately not using .len here. length = self . _datastore . bitlength except AttributeError : # bitstring doesn't have a _datastore as it hasn't been created! pass # TODO: All this checking code should be hoisted out of ... | Reset the bitstring to have given unsigned int interpretation . | 358 | 12 |
249,708 | def _readuint ( self , length , start ) : if not length : raise InterpretError ( "Cannot interpret a zero length bitstring " "as an integer." ) offset = self . _offset startbyte = ( start + offset ) // 8 endbyte = ( start + offset + length - 1 ) // 8 b = binascii . hexlify ( bytes ( self . _datastore . getbyteslice ( s... | Read bits and interpret as an unsigned int . | 153 | 9 |
249,709 | def _setint ( self , int_ , length = None ) : # If no length given, and we've previously been given a length, use it. if length is None and hasattr ( self , 'len' ) and self . len != 0 : length = self . len if length is None or length == 0 : raise CreationError ( "A non-zero length must be specified with an int initial... | Reset the bitstring to have given signed int interpretation . | 299 | 12 |
249,710 | def _readint ( self , length , start ) : ui = self . _readuint ( length , start ) if not ui >> ( length - 1 ) : # Top bit not set, number is positive return ui # Top bit is set, so number is negative tmp = ( ~ ( ui - 1 ) ) & ( ( 1 << length ) - 1 ) return - tmp | Read bits and interpret as a signed int | 82 | 8 |
249,711 | def _setuintbe ( self , uintbe , length = None ) : if length is not None and length % 8 != 0 : raise CreationError ( "Big-endian integers must be whole-byte. " "Length = {0} bits." , length ) self . _setuint ( uintbe , length ) | Set the bitstring to a big - endian unsigned int interpretation . | 67 | 14 |
249,712 | def _readuintbe ( self , length , start ) : if length % 8 : raise InterpretError ( "Big-endian integers must be whole-byte. " "Length = {0} bits." , length ) return self . _readuint ( length , start ) | Read bits and interpret as a big - endian unsigned int . | 57 | 13 |
249,713 | def _setintbe ( self , intbe , length = None ) : if length is not None and length % 8 != 0 : raise CreationError ( "Big-endian integers must be whole-byte. " "Length = {0} bits." , length ) self . _setint ( intbe , length ) | Set bitstring to a big - endian signed int interpretation . | 67 | 13 |
249,714 | def _readintbe ( self , length , start ) : if length % 8 : raise InterpretError ( "Big-endian integers must be whole-byte. " "Length = {0} bits." , length ) return self . _readint ( length , start ) | Read bits and interpret as a big - endian signed int . | 57 | 13 |
249,715 | def _readuintle ( self , length , start ) : if length % 8 : raise InterpretError ( "Little-endian integers must be whole-byte. " "Length = {0} bits." , length ) assert start + length <= self . len absolute_pos = start + self . _offset startbyte , offset = divmod ( absolute_pos , 8 ) val = 0 if not offset : endbyte = ( ... | Read bits and interpret as a little - endian unsigned int . | 270 | 13 |
249,716 | def _readintle ( self , length , start ) : ui = self . _readuintle ( length , start ) if not ui >> ( length - 1 ) : # Top bit not set, number is positive return ui # Top bit is set, so number is negative tmp = ( ~ ( ui - 1 ) ) & ( ( 1 << length ) - 1 ) return - tmp | Read bits and interpret as a little - endian signed int . | 84 | 13 |
249,717 | def _readfloat ( self , length , start ) : if not ( start + self . _offset ) % 8 : startbyte = ( start + self . _offset ) // 8 if length == 32 : f , = struct . unpack ( '>f' , bytes ( self . _datastore . getbyteslice ( startbyte , startbyte + 4 ) ) ) elif length == 64 : f , = struct . unpack ( '>d' , bytes ( self . _da... | Read bits and interpret as a float . | 217 | 8 |
249,718 | def _readfloatle ( self , length , start ) : startbyte , offset = divmod ( start + self . _offset , 8 ) if not offset : if length == 32 : f , = struct . unpack ( '<f' , bytes ( self . _datastore . getbyteslice ( startbyte , startbyte + 4 ) ) ) elif length == 64 : f , = struct . unpack ( '<d' , bytes ( self . _datastore... | Read bits and interpret as a little - endian float . | 215 | 12 |
249,719 | def _setue ( self , i ) : if i < 0 : raise CreationError ( "Cannot use negative initialiser for unsigned " "exponential-Golomb." ) if not i : self . _setbin_unsafe ( '1' ) return tmp = i + 1 leadingzeros = - 1 while tmp > 0 : tmp >>= 1 leadingzeros += 1 remainingpart = i + 1 - ( 1 << leadingzeros ) binstring = '0' * le... | Initialise bitstring with unsigned exponential - Golomb code for integer i . | 139 | 15 |
249,720 | def _readue ( self , pos ) : oldpos = pos try : while not self [ pos ] : pos += 1 except IndexError : raise ReadError ( "Read off end of bitstring trying to read code." ) leadingzeros = pos - oldpos codenum = ( 1 << leadingzeros ) - 1 if leadingzeros > 0 : if pos + leadingzeros + 1 > self . len : raise ReadError ( "Rea... | Return interpretation of next bits as unsigned exponential - Golomb code . | 143 | 13 |
249,721 | def _getue ( self ) : try : value , newpos = self . _readue ( 0 ) if value is None or newpos != self . len : raise ReadError except ReadError : raise InterpretError ( "Bitstring is not a single exponential-Golomb code." ) return value | Return data as unsigned exponential - Golomb code . | 63 | 10 |
249,722 | def _setse ( self , i ) : if i > 0 : u = ( i * 2 ) - 1 else : u = - 2 * i self . _setue ( u ) | Initialise bitstring with signed exponential - Golomb code for integer i . | 40 | 15 |
249,723 | def _getse ( self ) : try : value , newpos = self . _readse ( 0 ) if value is None or newpos != self . len : raise ReadError except ReadError : raise InterpretError ( "Bitstring is not a single exponential-Golomb code." ) return value | Return data as signed exponential - Golomb code . | 63 | 10 |
249,724 | def _readse ( self , pos ) : codenum , pos = self . _readue ( pos ) m = ( codenum + 1 ) // 2 if not codenum % 2 : return - m , pos else : return m , pos | Return interpretation of next bits as a signed exponential - Golomb code . | 51 | 14 |
249,725 | def _setuie ( self , i ) : if i < 0 : raise CreationError ( "Cannot use negative initialiser for unsigned " "interleaved exponential-Golomb." ) self . _setbin_unsafe ( '1' if i == 0 else '0' + '0' . join ( bin ( i + 1 ) [ 3 : ] ) + '1' ) | Initialise bitstring with unsigned interleaved exponential - Golomb code for integer i . | 84 | 18 |
249,726 | def _getuie ( self ) : try : value , newpos = self . _readuie ( 0 ) if value is None or newpos != self . len : raise ReadError except ReadError : raise InterpretError ( "Bitstring is not a single interleaved exponential-Golomb code." ) return value | Return data as unsigned interleaved exponential - Golomb code . | 68 | 13 |
249,727 | def _setsie ( self , i ) : if not i : self . _setbin_unsafe ( '1' ) else : self . _setuie ( abs ( i ) ) self . _append ( Bits ( [ i < 0 ] ) ) | Initialise bitstring with signed interleaved exponential - Golomb code for integer i . | 55 | 18 |
249,728 | def _getsie ( self ) : try : value , newpos = self . _readsie ( 0 ) if value is None or newpos != self . len : raise ReadError except ReadError : raise InterpretError ( "Bitstring is not a single interleaved exponential-Golomb code." ) return value | Return data as signed interleaved exponential - Golomb code . | 66 | 13 |
249,729 | def _readsie ( self , pos ) : codenum , pos = self . _readuie ( pos ) if not codenum : return 0 , pos try : if self [ pos ] : return - codenum , pos + 1 else : return codenum , pos + 1 except IndexError : raise ReadError ( "Read off end of bitstring trying to read code." ) | Return interpretation of next bits as a signed interleaved exponential - Golomb code . | 79 | 17 |
249,730 | def _setbin_safe ( self , binstring ) : binstring = tidy_input_string ( binstring ) # remove any 0b if present binstring = binstring . replace ( '0b' , '' ) self . _setbin_unsafe ( binstring ) | Reset the bitstring to the value given in binstring . | 65 | 14 |
249,731 | def _setbin_unsafe ( self , binstring ) : length = len ( binstring ) # pad with zeros up to byte boundary if needed boundary = ( ( length + 7 ) // 8 ) * 8 padded_binstring = binstring + '0' * ( boundary - length ) if len ( binstring ) < boundary else binstring try : bytelist = [ int ( padded_binstring [ x : x + 8 ] , 2... | Same as _setbin_safe but input isn t sanity checked . binstring mustn t start with 0b . | 170 | 25 |
249,732 | def _readbin ( self , length , start ) : if not length : return '' # Get the byte slice containing our bit slice startbyte , startoffset = divmod ( start + self . _offset , 8 ) endbyte = ( start + self . _offset + length - 1 ) // 8 b = self . _datastore . getbyteslice ( startbyte , endbyte + 1 ) # Convert to a string o... | Read bits and interpret as a binary string . | 217 | 9 |
249,733 | def _setoct ( self , octstring ) : octstring = tidy_input_string ( octstring ) # remove any 0o if present octstring = octstring . replace ( '0o' , '' ) binlist = [ ] for i in octstring : try : if not 0 <= int ( i ) < 8 : raise ValueError binlist . append ( OCT_TO_BITS [ int ( i ) ] ) except ValueError : raise CreationE... | Reset the bitstring to have the value given in octstring . | 131 | 14 |
249,734 | def _readoct ( self , length , start ) : if length % 3 : raise InterpretError ( "Cannot convert to octal unambiguously - " "not multiple of 3 bits." ) if not length : return '' # Get main octal bit by converting from int. # Strip starting 0 or 0o depending on Python version. end = oct ( self . _readuint ( length , star... | Read bits and interpret as an octal string . | 137 | 10 |
249,735 | def _sethex ( self , hexstring ) : hexstring = tidy_input_string ( hexstring ) # remove any 0x if present hexstring = hexstring . replace ( '0x' , '' ) length = len ( hexstring ) if length % 2 : hexstring += '0' try : try : data = bytearray . fromhex ( hexstring ) except TypeError : # Python 2.6 needs a unicode string ... | Reset the bitstring to have the value given in hexstring . | 159 | 14 |
249,736 | def _readhex ( self , length , start ) : if length % 4 : raise InterpretError ( "Cannot convert to hex unambiguously - " "not multiple of 4 bits." ) if not length : return '' s = self . _slice ( start , start + length ) . tobytes ( ) try : s = s . hex ( ) # Available in Python 3.5 except AttributeError : # This monstro... | Read bits and interpret as a hex string . | 179 | 9 |
249,737 | def _ensureinmemory ( self ) : self . _setbytes_unsafe ( self . _datastore . getbyteslice ( 0 , self . _datastore . bytelength ) , self . len , self . _offset ) | Ensure the data is held in memory not in a file . | 54 | 13 |
249,738 | def _converttobitstring ( cls , bs , offset = 0 , cache = { } ) : if isinstance ( bs , Bits ) : return bs try : return cache [ ( bs , offset ) ] except KeyError : if isinstance ( bs , basestring ) : b = cls ( ) try : _ , tokens = tokenparser ( bs ) except ValueError as e : raise CreationError ( * e . args ) if tokens :... | Convert bs to a bitstring and return it . | 233 | 12 |
249,739 | def _slice ( self , start , end ) : if end == start : return self . __class__ ( ) offset = self . _offset startbyte , newoffset = divmod ( start + offset , 8 ) endbyte = ( end + offset - 1 ) // 8 bs = self . __class__ ( ) bs . _setbytes_unsafe ( self . _datastore . getbyteslice ( startbyte , endbyte + 1 ) , end - start... | Used internally to get a slice without error checking . | 108 | 10 |
249,740 | def _readtoken ( self , name , pos , length ) : if length is not None and int ( length ) > self . length - pos : raise ReadError ( "Reading off the end of the data. " "Tried to read {0} bits when only {1} available." . format ( int ( length ) , self . length - pos ) ) try : val = name_to_read [ name ] ( self , length ,... | Reads a token from the bitstring and returns the result . | 184 | 13 |
249,741 | def _reverse ( self ) : # Reverse the contents of each byte n = [ BYTE_REVERSAL_DICT [ b ] for b in self . _datastore . rawbytes ] # Then reverse the order of the bytes n . reverse ( ) # The new offset is the number of bits that were unused at the end. newoffset = 8 - ( self . _offset + self . len ) % 8 if newoffset ==... | Reverse all bits in - place . | 126 | 9 |
249,742 | def _truncateend ( self , bits ) : assert 0 <= bits <= self . len if not bits : return if bits == self . len : self . _clear ( ) return newlength_in_bytes = ( self . _offset + self . len - bits + 7 ) // 8 self . _setbytes_unsafe ( self . _datastore . getbyteslice ( 0 , newlength_in_bytes ) , self . len - bits , self . ... | Truncate bits from the end of the bitstring . | 113 | 12 |
249,743 | def _insert ( self , bs , pos ) : assert 0 <= pos <= self . len if pos > self . len // 2 : # Inserting nearer end, so cut off end. end = self . _slice ( pos , self . len ) self . _truncateend ( self . len - pos ) self . _append ( bs ) self . _append ( end ) else : # Inserting nearer start, so cut off start. start = sel... | Insert bs at pos . | 162 | 6 |
249,744 | def _overwrite ( self , bs , pos ) : assert 0 <= pos < self . len if bs is self : # Just overwriting with self, so do nothing. assert pos == 0 return firstbytepos = ( self . _offset + pos ) // 8 lastbytepos = ( self . _offset + pos + bs . len - 1 ) // 8 bytepos , bitoffset = divmod ( self . _offset + pos , 8 ) if first... | Overwrite with bs at pos . | 550 | 8 |
249,745 | def _delete ( self , bits , pos ) : assert 0 <= pos <= self . len assert pos + bits <= self . len if not pos : # Cutting bits off at the start. self . _truncatestart ( bits ) return if pos + bits == self . len : # Cutting bits off at the end. self . _truncateend ( bits ) return if pos > self . len - pos - bits : # More... | Delete bits at pos . | 199 | 5 |
249,746 | def _reversebytes ( self , start , end ) : # Make the start occur on a byte boundary # TODO: We could be cleverer here to avoid changing the offset. newoffset = 8 - ( start % 8 ) if newoffset == 8 : newoffset = 0 self . _datastore = offsetcopy ( self . _datastore , newoffset ) # Now just reverse the byte data toreverse... | Reverse bytes in - place . | 163 | 8 |
249,747 | def _set ( self , pos ) : assert 0 <= pos < self . len self . _datastore . setbit ( pos ) | Set bit at pos to 1 . | 29 | 7 |
249,748 | def _unset ( self , pos ) : assert 0 <= pos < self . len self . _datastore . unsetbit ( pos ) | Set bit at pos to 0 . | 31 | 7 |
249,749 | def _invert_all ( self ) : set = self . _datastore . setbyte get = self . _datastore . getbyte for p in xrange ( self . _datastore . byteoffset , self . _datastore . byteoffset + self . _datastore . bytelength ) : set ( p , 256 + ~ get ( p ) ) | Invert every bit . | 82 | 5 |
249,750 | def _ilshift ( self , n ) : assert 0 < n <= self . len self . _append ( Bits ( n ) ) self . _truncatestart ( n ) return self | Shift bits by n to the left in place . Return self . | 41 | 13 |
249,751 | def _irshift ( self , n ) : assert 0 < n <= self . len self . _prepend ( Bits ( n ) ) self . _truncateend ( n ) return self | Shift bits by n to the right in place . Return self . | 41 | 13 |
249,752 | def _imul ( self , n ) : assert n >= 0 if not n : self . _clear ( ) return self m = 1 old_len = self . len while m * 2 < n : self . _append ( self ) m *= 2 self . _append ( self [ 0 : ( n - m ) * old_len ] ) return self | Concatenate n copies of self in place . Return self . | 76 | 14 |
249,753 | def _validate_slice ( self , start , end ) : if start is None : start = 0 elif start < 0 : start += self . len if end is None : end = self . len elif end < 0 : end += self . len if not 0 <= end <= self . len : raise ValueError ( "end is not a valid position in the bitstring." ) if not 0 <= start <= self . len : raise V... | Validate start and end and return them as positive bit positions . | 131 | 13 |
249,754 | def _findbytes ( self , bytes_ , start , end , bytealigned ) : assert self . _datastore . offset == 0 assert bytealigned is True # Extract data bytes from bitstring to be found. bytepos = ( start + 7 ) // 8 found = False p = bytepos finalpos = end // 8 increment = max ( 1024 , len ( bytes_ ) * 10 ) buffersize = increme... | Quicker version of find when everything s whole byte and byte aligned . | 189 | 14 |
249,755 | def _findregex ( self , reg_ex , start , end , bytealigned ) : p = start length = len ( reg_ex . pattern ) # We grab overlapping chunks of the binary representation and # do an ordinary string search within that. increment = max ( 4096 , length * 10 ) buffersize = increment + length while p < end : buf = self . _readbi... | Find first occurrence of a compiled regular expression . | 209 | 9 |
249,756 | def find ( self , bs , start = None , end = None , bytealigned = None ) : bs = Bits ( bs ) if not bs . len : raise ValueError ( "Cannot find an empty bitstring." ) start , end = self . _validate_slice ( start , end ) if bytealigned is None : bytealigned = globals ( ) [ 'bytealigned' ] if bytealigned and not bs . len % ... | Find first occurrence of substring bs . | 197 | 9 |
249,757 | def findall ( self , bs , start = None , end = None , count = None , bytealigned = None ) : if count is not None and count < 0 : raise ValueError ( "In findall, count must be >= 0." ) bs = Bits ( bs ) start , end = self . _validate_slice ( start , end ) if bytealigned is None : bytealigned = globals ( ) [ 'bytealigned'... | Find all occurrences of bs . Return generator of bit positions . | 255 | 13 |
249,758 | def rfind ( self , bs , start = None , end = None , bytealigned = None ) : bs = Bits ( bs ) start , end = self . _validate_slice ( start , end ) if bytealigned is None : bytealigned = globals ( ) [ 'bytealigned' ] if not bs . len : raise ValueError ( "Cannot find an empty bitstring." ) # Search chunks starting near the... | Find final occurrence of substring bs . | 211 | 9 |
249,759 | def cut ( self , bits , start = None , end = None , count = None ) : start , end = self . _validate_slice ( start , end ) if count is not None and count < 0 : raise ValueError ( "Cannot cut - count must be >= 0." ) if bits <= 0 : raise ValueError ( "Cannot cut - bits must be >= 0." ) c = 0 while count is None or c < co... | Return bitstring generator by cutting into bits sized chunks . | 147 | 11 |
249,760 | def split ( self , delimiter , start = None , end = None , count = None , bytealigned = None ) : delimiter = Bits ( delimiter ) if not delimiter . len : raise ValueError ( "split delimiter cannot be empty." ) start , end = self . _validate_slice ( start , end ) if bytealigned is None : bytealigned = globals ( ) [ 'byte... | Return bitstring generator by splittling using a delimiter . | 366 | 13 |
249,761 | def join ( self , sequence ) : s = self . __class__ ( ) i = iter ( sequence ) try : s . _append ( Bits ( next ( i ) ) ) while True : n = next ( i ) s . _append ( self ) s . _append ( Bits ( n ) ) except StopIteration : pass return s | Return concatenation of bitstrings joined by self . | 72 | 11 |
249,762 | def tobytes ( self ) : d = offsetcopy ( self . _datastore , 0 ) . rawbytes # Need to ensure that unused bits at end are set to zero unusedbits = 8 - self . len % 8 if unusedbits != 8 : d [ - 1 ] &= ( 0xff << unusedbits ) return bytes ( d ) | Return the bitstring as bytes padding with zero bits if needed . | 72 | 13 |
249,763 | def tofile ( self , f ) : # If the bitstring is file based then we don't want to read it all # in to memory. chunksize = 1024 * 1024 # 1 MB chunks if not self . _offset : a = 0 bytelen = self . _datastore . bytelength p = self . _datastore . getbyteslice ( a , min ( a + chunksize , bytelen - 1 ) ) while len ( p ) == ch... | Write the bitstring to a file object padding with zero bits if needed . | 306 | 15 |
249,764 | def startswith ( self , prefix , start = None , end = None ) : prefix = Bits ( prefix ) start , end = self . _validate_slice ( start , end ) if end < start + prefix . len : return False end = start + prefix . len return self . _slice ( start , end ) == prefix | Return whether the current bitstring starts with prefix . | 70 | 10 |
249,765 | def endswith ( self , suffix , start = None , end = None ) : suffix = Bits ( suffix ) start , end = self . _validate_slice ( start , end ) if start + suffix . len > end : return False start = end - suffix . len return self . _slice ( start , end ) == suffix | Return whether the current bitstring ends with suffix . | 70 | 10 |
249,766 | def all ( self , value , pos = None ) : value = bool ( value ) length = self . len if pos is None : pos = xrange ( self . len ) for p in pos : if p < 0 : p += length if not 0 <= p < length : raise IndexError ( "Bit position {0} out of range." . format ( p ) ) if not self . _datastore . getbit ( p ) is value : return Fa... | Return True if one or many bits are all set to value . | 99 | 13 |
249,767 | def count ( self , value ) : if not self . len : return 0 # count the number of 1s (from which it's easy to work out the 0s). # Don't count the final byte yet. count = sum ( BIT_COUNT [ self . _datastore . getbyte ( i ) ] for i in xrange ( self . _datastore . bytelength - 1 ) ) # adjust for bits at start that aren't pa... | Return count of total number of either zero or one bits . | 219 | 12 |
249,768 | def replace ( self , old , new , start = None , end = None , count = None , bytealigned = None ) : old = Bits ( old ) new = Bits ( new ) if not old . len : raise ValueError ( "Empty bitstring cannot be replaced." ) start , end = self . _validate_slice ( start , end ) if bytealigned is None : bytealigned = globals ( ) [... | Replace all occurrences of old with new in place . | 393 | 11 |
249,769 | def insert ( self , bs , pos = None ) : bs = Bits ( bs ) if not bs . len : return self if bs is self : bs = self . __copy__ ( ) if pos is None : try : pos = self . _pos except AttributeError : raise TypeError ( "insert require a bit position for this type." ) if pos < 0 : pos += self . len if not 0 <= pos <= self . len... | Insert bs at bit position pos . | 119 | 8 |
249,770 | def overwrite ( self , bs , pos = None ) : bs = Bits ( bs ) if not bs . len : return if pos is None : try : pos = self . _pos except AttributeError : raise TypeError ( "overwrite require a bit position for this type." ) if pos < 0 : pos += self . len if pos < 0 or pos + bs . len > self . len : raise ValueError ( "Overw... | Overwrite with bs at bit position pos . | 133 | 10 |
249,771 | def append ( self , bs ) : # The offset is a hint to make bs easily appendable. bs = self . _converttobitstring ( bs , offset = ( self . len + self . _offset ) % 8 ) self . _append ( bs ) | Append a bitstring to the current bitstring . | 62 | 11 |
249,772 | def reverse ( self , start = None , end = None ) : start , end = self . _validate_slice ( start , end ) if start == 0 and end == self . len : self . _reverse ( ) return s = self . _slice ( start , end ) s . _reverse ( ) self [ start : end ] = s | Reverse bits in - place . | 73 | 8 |
249,773 | def set ( self , value , pos = None ) : f = self . _set if value else self . _unset if pos is None : pos = xrange ( self . len ) try : length = self . len for p in pos : if p < 0 : p += length if not 0 <= p < length : raise IndexError ( "Bit position {0} out of range." . format ( p ) ) f ( p ) except TypeError : # Sing... | Set one or many bits to 1 or 0 . | 141 | 10 |
249,774 | def invert ( self , pos = None ) : if pos is None : self . _invert_all ( ) return if not isinstance ( pos , collections . Iterable ) : pos = ( pos , ) length = self . len for p in pos : if p < 0 : p += length if not 0 <= p < length : raise IndexError ( "Bit position {0} out of range." . format ( p ) ) self . _invert ( ... | Invert one or many bits from 0 to 1 or vice versa . | 99 | 14 |
249,775 | def ror ( self , bits , start = None , end = None ) : if not self . len : raise Error ( "Cannot rotate an empty bitstring." ) if bits < 0 : raise ValueError ( "Cannot rotate right by negative amount." ) start , end = self . _validate_slice ( start , end ) bits %= ( end - start ) if not bits : return rhs = self . _slice... | Rotate bits to the right in - place . | 119 | 10 |
249,776 | def rol ( self , bits , start = None , end = None ) : if not self . len : raise Error ( "Cannot rotate an empty bitstring." ) if bits < 0 : raise ValueError ( "Cannot rotate left by negative amount." ) start , end = self . _validate_slice ( start , end ) bits %= ( end - start ) if not bits : return lhs = self . _slice ... | Rotate bits to the left in - place . | 119 | 10 |
249,777 | def byteswap ( self , fmt = None , start = None , end = None , repeat = True ) : start , end = self . _validate_slice ( start , end ) if fmt is None or fmt == 0 : # reverse all of the whole bytes. bytesizes = [ ( end - start ) // 8 ] elif isinstance ( fmt , numbers . Integral ) : if fmt < 0 : raise ValueError ( "Improp... | Change the endianness in - place . Return number of repeats of fmt done . | 514 | 17 |
249,778 | def _setbitpos ( self , pos ) : if pos < 0 : raise ValueError ( "Bit position cannot be negative." ) if pos > self . len : raise ValueError ( "Cannot seek past the end of the data." ) self . _pos = pos | Move to absolute postion bit in bitstream . | 57 | 10 |
249,779 | def read ( self , fmt ) : if isinstance ( fmt , numbers . Integral ) : if fmt < 0 : raise ValueError ( "Cannot read negative amount." ) if fmt > self . len - self . _pos : raise ReadError ( "Cannot read {0} bits, only {1} available." , fmt , self . len - self . _pos ) bs = self . _slice ( self . _pos , self . _pos + fm... | Interpret next bits according to the format string and return result . | 225 | 13 |
249,780 | def readto ( self , bs , bytealigned = None ) : if isinstance ( bs , numbers . Integral ) : raise ValueError ( "Integers cannot be searched for" ) bs = Bits ( bs ) oldpos = self . _pos p = self . find ( bs , self . _pos , bytealigned = bytealigned ) if not p : raise ReadError ( "Substring not found" ) self . _pos += bs... | Read up to and including next occurrence of bs and return result . | 114 | 14 |
249,781 | def peek ( self , fmt ) : pos_before = self . _pos value = self . read ( fmt ) self . _pos = pos_before return value | Interpret next bits according to format string and return result . | 34 | 12 |
249,782 | def bytealign ( self ) : skipped = ( 8 - ( self . _pos % 8 ) ) % 8 self . pos += self . _offset + skipped assert self . _assertsanity ( ) return skipped | Align to next byte and return number of skipped bits . | 44 | 12 |
249,783 | def prepend ( self , bs ) : bs = self . _converttobitstring ( bs ) self . _prepend ( bs ) self . _pos += bs . len | Prepend a bitstring to the current bitstring . | 44 | 11 |
249,784 | def find_inodes_in_use ( fds ) : self_pid = os . getpid ( ) id_fd_assoc = collections . defaultdict ( list ) for fd in fds : st = os . fstat ( fd ) id_fd_assoc [ ( st . st_dev , st . st_ino ) ] . append ( fd ) def st_id_candidates ( it ) : # map proc paths to stat identifiers (devno and ino) for proc_path in it : try :... | Find which of these inodes are in use and give their open modes . | 477 | 15 |
249,785 | def set_idle_priority ( pid = None ) : if pid is None : pid = os . getpid ( ) lib . ioprio_set ( lib . IOPRIO_WHO_PROCESS , pid , lib . IOPRIO_PRIO_VALUE ( lib . IOPRIO_CLASS_IDLE , 0 ) ) | Puts a process in the idle io priority class . | 76 | 11 |
249,786 | def futimens ( fd , ns ) : # ctime can't easily be reset # also, we have no way to do mandatory locking without # changing the ctime. times = ffi . new ( 'struct timespec[2]' ) atime , mtime = ns assert 0 <= atime . tv_nsec < 1e9 assert 0 <= mtime . tv_nsec < 1e9 times [ 0 ] = atime times [ 1 ] = mtime if lib . futimen... | set inode atime and mtime | 172 | 8 |
249,787 | def fopenat ( base_fd , path ) : return os . fdopen ( openat ( base_fd , path , os . O_RDONLY ) , 'rb' ) | Does openat read - only then does fdopen to get a file object | 41 | 16 |
249,788 | def fopenat_rw ( base_fd , path ) : return os . fdopen ( openat ( base_fd , path , os . O_RDWR ) , 'rb+' ) | Does openat read - write then does fdopen to get a file object | 43 | 16 |
249,789 | def fiemap ( fd ) : count = 72 fiemap_cbuf = ffi . new ( 'char[]' , ffi . sizeof ( 'struct fiemap' ) + count * ffi . sizeof ( 'struct fiemap_extent' ) ) fiemap_pybuf = ffi . buffer ( fiemap_cbuf ) fiemap_ptr = ffi . cast ( 'struct fiemap*' , fiemap_cbuf ) assert ffi . sizeof ( fiemap_cbuf ) <= 4096 while True : fiemap_... | Gets a map of file extents . | 299 | 9 |
249,790 | def getflags ( fd ) : flags_ptr = ffi . new ( 'uint64_t*' ) flags_buf = ffi . buffer ( flags_ptr ) fcntl . ioctl ( fd , lib . FS_IOC_GETFLAGS , flags_buf ) return flags_ptr [ 0 ] | Gets per - file filesystem flags . | 71 | 8 |
249,791 | def editflags ( fd , add_flags = 0 , remove_flags = 0 ) : if add_flags & remove_flags != 0 : raise ValueError ( 'Added and removed flags shouldn\'t overlap' , add_flags , remove_flags ) # The ext2progs code uses int or unsigned long, # the kernel uses an implicit int, # let's be explicit here. flags_ptr = ffi . new ( '... | Sets and unsets per - file filesystem flags . | 233 | 11 |
249,792 | def connect ( host , username , password , * * kwargs ) : arguments = ChainMap ( kwargs , defaults ) transport = create_transport ( host , * * arguments ) protocol = ApiProtocol ( transport = transport , encoding = arguments [ 'encoding' ] ) api = arguments [ 'subclass' ] ( protocol = protocol ) for method in arguments... | Connect and login to routeros device . Upon success return a Api class . | 133 | 16 |
249,793 | def _readSentence ( self ) : reply_word , words = self . protocol . readSentence ( ) words = dict ( parseWord ( word ) for word in words ) return reply_word , words | Read one sentence and parse words . | 44 | 7 |
249,794 | def _readResponse ( self ) : traps = [ ] reply_word = None while reply_word != '!done' : reply_word , words = self . _readSentence ( ) if reply_word == '!trap' : traps . append ( TrapError ( * * words ) ) elif reply_word in ( '!re' , '!done' ) and words : yield words if len ( traps ) > 1 : raise MultiTrapError ( * trap... | Yield each row of response untill !done is received . | 116 | 13 |
249,795 | def encodeSentence ( self , * words ) : encoded = map ( self . encodeWord , words ) encoded = b'' . join ( encoded ) # append EOS (end of sentence) byte encoded += b'\x00' return encoded | Encode given sentence in API format . | 51 | 8 |
249,796 | def encodeWord ( self , word ) : encoded_word = word . encode ( encoding = self . encoding , errors = 'strict' ) return Encoder . encodeLength ( len ( word ) ) + encoded_word | Encode word in API format . | 46 | 7 |
249,797 | def encodeLength ( length ) : if length < 128 : ored_length = length offset = - 1 elif length < 16384 : ored_length = length | 0x8000 offset = - 2 elif length < 2097152 : ored_length = length | 0xC00000 offset = - 3 elif length < 268435456 : ored_length = length | 0xE0000000 offset = - 4 else : raise ConnectionError ( ... | Encode given length in mikrotik format . | 128 | 11 |
249,798 | def determineLength ( length ) : integer = ord ( length ) if integer < 128 : return 0 elif integer < 192 : return 1 elif integer < 224 : return 2 elif integer < 240 : return 3 else : raise ConnectionError ( 'Unknown controll byte {}' . format ( length ) ) | Given first read byte determine how many more bytes needs to be known in order to get fully encoded length . | 63 | 21 |
249,799 | def decodeLength ( length ) : bytes_length = len ( length ) if bytes_length < 2 : offset = b'\x00\x00\x00' XOR = 0 elif bytes_length < 3 : offset = b'\x00\x00' XOR = 0x8000 elif bytes_length < 4 : offset = b'\x00' XOR = 0xC00000 elif bytes_length < 5 : offset = b'' XOR = 0xE0000000 else : raise ConnectionError ( 'Unabl... | Decode length based on given bytes . | 157 | 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.