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 + store . bitlength ) % 8 == self . offset % 8 bit_offset = self . offset % 8 if bit_offset : # first do the byte with the join. store . setbyte ( - 1 , ( store . getbyte ( - 1 ) & ( 255 ^ ( 255 >> bit_offset ) ) | ( self . _rawarray [ self . byteoffset ] & ( 255 >> bit_offset ) ) ) ) store . _rawarray . extend ( self . _rawarray [ self . byteoffset + 1 : self . byteoffset + self . bytelength ] ) else : store . _rawarray . extend ( self . _rawarray [ self . byteoffset : self . byteoffset + self . bytelength ] ) self . _rawarray = store . _rawarray self . offset = store . offset self . bitlength += store . bitlength | 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 ) : if length is None : length = s . len - offset self . _setbytes_unsafe ( s . _datastore . rawbytes , length , s . _offset + offset ) return if isinstance ( s , file ) : if offset is None : offset = 0 if length is None : length = os . path . getsize ( s . name ) * 8 - offset byteoffset , offset = divmod ( offset , 8 ) bytelength = ( length + byteoffset * 8 + offset + 7 ) // 8 - byteoffset m = MmapByteArray ( s , bytelength , byteoffset ) if length + byteoffset * 8 + offset > m . filelength * 8 : raise CreationError ( "File is not long enough for specified " "length and offset." ) self . _datastore = ConstByteStore ( m , length , offset ) return if length is not None : raise CreationError ( "The length keyword isn't applicable to this initialiser." ) if offset : raise CreationError ( "The offset keyword isn't applicable to this initialiser." ) if isinstance ( s , basestring ) : bs = self . _converttobitstring ( s ) assert bs . _offset == 0 self . _setbytes_unsafe ( bs . _datastore . rawbytes , bs . length , 0 ) return if isinstance ( s , ( bytes , bytearray ) ) : self . _setbytes_unsafe ( bytearray ( s ) , len ( s ) * 8 , 0 ) return if isinstance ( s , array . array ) : b = s . tostring ( ) self . _setbytes_unsafe ( bytearray ( b ) , len ( b ) * 8 , 0 ) return if isinstance ( s , numbers . Integral ) : # Initialise with s zero bits. if s < 0 : msg = "Can't create bitstring of negative length {0}." raise CreationError ( msg , s ) data = bytearray ( ( s + 7 ) // 8 ) self . _datastore = ByteStore ( data , s , 0 ) return if isinstance ( s , collections . Iterable ) : # Evaluate each item as True or False and set bits to 1 or 0. self . _setbin_unsafe ( '' . join ( str ( int ( bool ( x ) ) ) for x in s ) ) return raise TypeError ( "Cannot initialise bitstring from {0}." . format ( type ( s ) ) ) | 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 = MmapByteArray ( source , bytelength , byteoffset ) if length + byteoffset * 8 + offset > m . filelength * 8 : raise CreationError ( "File is not long enough for specified " "length and offset." ) self . _datastore = ConstByteStore ( m , length , offset ) | 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} bits, have {1}." raise CreationError ( msg , length + offset , len ( data ) * 8 ) if length == 0 : self . _datastore = ByteStore ( bytearray ( 0 ) ) else : self . _datastore = ByteStore ( data , length , offset ) | 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 ) . tobytes ( ) | 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 here! if length is None or length == 0 : raise CreationError ( "A non-zero length must be specified with a " "uint initialiser." ) if uint >= ( 1 << length ) : msg = "{0} is too large an unsigned integer for a bitstring of length {1}. " "The allowed range is [0, {2}]." raise CreationError ( msg , uint , length , ( 1 << length ) - 1 ) if uint < 0 : raise CreationError ( "uint cannot be initialsed by a negative number." ) s = hex ( uint ) [ 2 : ] s = s . rstrip ( 'L' ) if len ( s ) & 1 : s = '0' + s try : data = bytes . fromhex ( s ) except AttributeError : # the Python 2.x way data = binascii . unhexlify ( s ) # Now add bytes as needed to get the right length. extrabytes = ( ( length + 7 ) // 8 ) - len ( data ) if extrabytes > 0 : data = b'\x00' * extrabytes + data offset = 8 - ( length % 8 ) if offset == 8 : offset = 0 self . _setbytes_unsafe ( bytearray ( data ) , length , offset ) | 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 ( startbyte , endbyte + 1 ) ) ) assert b i = int ( b , 16 ) final_bits = 8 - ( ( start + offset + length ) % 8 ) if final_bits != 8 : i >>= final_bits i &= ( 1 << length ) - 1 return i | 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 initialiser." ) if int_ >= ( 1 << ( length - 1 ) ) or int_ < - ( 1 << ( length - 1 ) ) : raise CreationError ( "{0} is too large a signed integer for a bitstring of length {1}. " "The allowed range is [{2}, {3}]." , int_ , length , - ( 1 << ( length - 1 ) ) , ( 1 << ( length - 1 ) ) - 1 ) if int_ >= 0 : self . _setuint ( int_ , length ) return # TODO: We should decide whether to just use the _setuint, or to do the bit flipping, # based upon which will be quicker. If the -ive number is less than half the maximum # possible then it's probably quicker to do the bit flipping... # Do the 2's complement thing. Add one, set to minus number, then flip bits. int_ += 1 self . _setuint ( - int_ , length ) self . _invert_all ( ) | 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 = ( absolute_pos + length - 1 ) // 8 chunksize = 4 # for 'L' format while endbyte - chunksize + 1 >= startbyte : val <<= 8 * chunksize val += struct . unpack ( '<L' , bytes ( self . _datastore . getbyteslice ( endbyte + 1 - chunksize , endbyte + 1 ) ) ) [ 0 ] endbyte -= chunksize for b in xrange ( endbyte , startbyte - 1 , - 1 ) : val <<= 8 val += self . _datastore . getbyte ( b ) else : data = self . _slice ( start , start + length ) assert data . len % 8 == 0 data . _reversebytes ( 0 , self . len ) for b in bytearray ( data . bytes ) : val <<= 8 val += b return val | 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 . _datastore . getbyteslice ( startbyte , startbyte + 8 ) ) ) else : if length == 32 : f , = struct . unpack ( '>f' , self . _readbytes ( 32 , start ) ) elif length == 64 : f , = struct . unpack ( '>d' , self . _readbytes ( 64 , start ) ) try : return f except NameError : raise InterpretError ( "floats can only be 32 or 64 bits long, not {0} bits" , length ) | 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 . getbyteslice ( startbyte , startbyte + 8 ) ) ) else : if length == 32 : f , = struct . unpack ( '<f' , self . _readbytes ( 32 , start ) ) elif length == 64 : f , = struct . unpack ( '<d' , self . _readbytes ( 64 , start ) ) try : return f except NameError : raise InterpretError ( "floats can only be 32 or 64 bits long, " "not {0} bits" , length ) | 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' * leadingzeros + '1' + Bits ( uint = remainingpart , length = leadingzeros ) . bin self . _setbin_unsafe ( binstring ) | 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 ( "Read off end of bitstring trying to read code." ) codenum += self . _readuint ( leadingzeros , pos + 1 ) pos += leadingzeros + 1 else : assert codenum == 0 pos += 1 return codenum , pos | 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 ) for x in xrange ( 0 , len ( padded_binstring ) , 8 ) ] except ValueError : raise CreationError ( "Invalid character in bin initialiser {0}." , binstring ) self . _setbytes_unsafe ( bytearray ( bytelist ) , length , 0 ) | 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 of '0' and '1's (via a hex string an and int!) try : c = "{:0{}b}" . format ( int ( binascii . hexlify ( b ) , 16 ) , 8 * len ( b ) ) except TypeError : # Hack to get Python 2.6 working c = "{0:0{1}b}" . format ( int ( binascii . hexlify ( str ( b ) ) , 16 ) , 8 * len ( b ) ) # Finally chop off any extra bits. return c [ startoffset : startoffset + length ] | 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 CreationError ( "Invalid symbol '{0}' in oct initialiser." , i ) self . _setbin_unsafe ( '' . join ( binlist ) ) | 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 , start ) ) [ LEADING_OCT_CHARS : ] if end . endswith ( 'L' ) : end = end [ : - 1 ] middle = '0' * ( length // 3 - len ( end ) ) return middle + end | 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 (a bug). 2.7 and 3.x work fine. data = bytearray . fromhex ( unicode ( hexstring ) ) except ValueError : raise CreationError ( "Invalid symbol in hex initialiser." ) self . _setbytes_unsafe ( data , length * 4 , 0 ) | 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 monstrosity is the only thing I could get to work for both 2.6 and 3.1. # TODO: Is utf-8 really what we mean here? s = str ( binascii . hexlify ( s ) . decode ( 'utf-8' ) ) # If there's one nibble too many then cut it off return s [ : - 1 ] if ( length // 4 ) % 2 else s | 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 : b . _append ( Bits . _init_with_token ( * tokens [ 0 ] ) ) b . _datastore = offsetcopy ( b . _datastore , offset ) for token in tokens [ 1 : ] : b . _append ( Bits . _init_with_token ( * token ) ) assert b . _assertsanity ( ) assert b . len == 0 or b . _offset == offset if len ( cache ) < CACHE_SIZE : cache [ ( bs , offset ) ] = b return b except TypeError : # Unhashable type pass return cls ( bs ) | 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 , newoffset ) return bs | 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 , pos ) return val , pos + length except KeyError : if name == 'pad' : return None , pos + length raise ValueError ( "Can't parse token {0}:{1}" . format ( name , length ) ) except TypeError : # This is for the 'ue', 'se' and 'bool' tokens. They will also return the new pos. return name_to_read [ name ] ( self , pos ) | 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 == 8 : newoffset = 0 self . _setbytes_unsafe ( bytearray ( ) . join ( n ) , self . length , 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 . _offset ) assert self . _assertsanity ( ) | 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 = self . _slice ( 0 , pos ) self . _truncatestart ( pos ) self . _prepend ( bs ) self . _prepend ( start ) try : self . _pos = pos + bs . len except AttributeError : pass assert self . _assertsanity ( ) | 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 firstbytepos == lastbytepos : mask = ( ( 1 << bs . len ) - 1 ) << ( 8 - bs . len - bitoffset ) self . _datastore . setbyte ( bytepos , self . _datastore . getbyte ( bytepos ) & ( ~ mask ) ) d = offsetcopy ( bs . _datastore , bitoffset ) self . _datastore . setbyte ( bytepos , self . _datastore . getbyte ( bytepos ) | ( d . getbyte ( 0 ) & mask ) ) else : # Do first byte mask = ( 1 << ( 8 - bitoffset ) ) - 1 self . _datastore . setbyte ( bytepos , self . _datastore . getbyte ( bytepos ) & ( ~ mask ) ) d = offsetcopy ( bs . _datastore , bitoffset ) self . _datastore . setbyte ( bytepos , self . _datastore . getbyte ( bytepos ) | ( d . getbyte ( 0 ) & mask ) ) # Now do all the full bytes self . _datastore . setbyteslice ( firstbytepos + 1 , lastbytepos , d . getbyteslice ( 1 , lastbytepos - firstbytepos ) ) # and finally the last byte bitsleft = ( self . _offset + pos + bs . len ) % 8 if not bitsleft : bitsleft = 8 mask = ( 1 << ( 8 - bitsleft ) ) - 1 self . _datastore . setbyte ( lastbytepos , self . _datastore . getbyte ( lastbytepos ) & mask ) self . _datastore . setbyte ( lastbytepos , self . _datastore . getbyte ( lastbytepos ) | ( d . getbyte ( d . bytelength - 1 ) & ~ mask ) ) assert self . _assertsanity ( ) | 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 bits before cut point than after it, so do bit shifting # on the final bits. end = self . _slice ( pos + bits , self . len ) assert self . len - pos > 0 self . _truncateend ( self . len - pos ) self . _append ( end ) return # More bits after the cut point than before it. start = self . _slice ( 0 , pos ) self . _truncatestart ( pos + bits ) self . _prepend ( start ) return | 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 = bytearray ( self . _datastore . getbyteslice ( ( newoffset + start ) // 8 , ( newoffset + end ) // 8 ) ) toreverse . reverse ( ) self . _datastore . setbyteslice ( ( newoffset + start ) // 8 , ( newoffset + end ) // 8 , 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 ValueError ( "start is not a valid position in the bitstring." ) if end < start : raise ValueError ( "end must not be less than start." ) return start , end | 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 = increment + len ( bytes_ ) while p < finalpos : # Read in file or from memory in overlapping chunks and search the chunks. buf = bytearray ( self . _datastore . getbyteslice ( p , min ( p + buffersize , finalpos ) ) ) pos = buf . find ( bytes_ ) if pos != - 1 : found = True p += pos break p += increment if not found : return ( ) return ( p * 8 , ) | 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 . _readbin ( min ( buffersize , end - p ) , p ) # Test using regular expressions... m = reg_ex . search ( buf ) if m : pos = m . start ( ) # pos = buf.find(targetbin) # if pos != -1: # if bytealigned then we only accept byte aligned positions. if not bytealigned or ( p + pos ) % 8 == 0 : return ( p + pos , ) if bytealigned : # Advance to just beyond the non-byte-aligned match and try again... p += pos + 1 continue p += increment # Not found, return empty tuple return ( ) | 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 % 8 and not self . _datastore . offset : p = self . _findbytes ( bs . bytes , start , end , bytealigned ) else : p = self . _findregex ( re . compile ( bs . _getbin ( ) ) , start , end , bytealigned ) # If called from a class that has a pos, set it try : self . _pos = p [ 0 ] except ( AttributeError , IndexError ) : pass return p | 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' ] c = 0 if bytealigned and not bs . len % 8 and not self . _datastore . offset : # Use the quick find method f = self . _findbytes x = bs . _getbytes ( ) else : f = self . _findregex x = re . compile ( bs . _getbin ( ) ) while True : p = f ( x , start , end , bytealigned ) if not p : break if count is not None and c >= count : return c += 1 try : self . _pos = p [ 0 ] except AttributeError : pass yield p [ 0 ] if bytealigned : start = p [ 0 ] + 8 else : start = p [ 0 ] + 1 if start >= end : break return | 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 end and then moving back # until we find bs. increment = max ( 8192 , bs . len * 80 ) buffersize = min ( increment + bs . len , end - start ) pos = max ( start , end - buffersize ) while True : found = list ( self . findall ( bs , start = pos , end = pos + buffersize , bytealigned = bytealigned ) ) if not found : if pos == start : return ( ) pos = max ( start , pos - increment ) continue return ( found [ - 1 ] , ) | 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 < count : c += 1 nextchunk = self . _slice ( start , min ( start + bits , end ) ) if nextchunk . len != bits : return assert nextchunk . _assertsanity ( ) yield nextchunk start += bits return | 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 ( ) [ 'bytealigned' ] if count is not None and count < 0 : raise ValueError ( "Cannot split - count must be >= 0." ) if count == 0 : return if bytealigned and not delimiter . len % 8 and not self . _datastore . offset : # Use the quick find method f = self . _findbytes x = delimiter . _getbytes ( ) else : f = self . _findregex x = re . compile ( delimiter . _getbin ( ) ) found = f ( x , start , end , bytealigned ) if not found : # Initial bits are the whole bitstring being searched yield self . _slice ( start , end ) return # yield the bytes before the first occurrence of the delimiter, even if empty yield self . _slice ( start , found [ 0 ] ) startpos = pos = found [ 0 ] c = 1 while count is None or c < count : pos += delimiter . len found = f ( x , pos , end , bytealigned ) if not found : # No more occurrences, so return the rest of the bitstring yield self . _slice ( startpos , end ) return c += 1 yield self . _slice ( startpos , found [ 0 ] ) startpos = pos = found [ 0 ] # Have generated count bitstrings, so time to quit. return | 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 ) == chunksize : f . write ( p ) a += chunksize p = self . _datastore . getbyteslice ( a , min ( a + chunksize , bytelen - 1 ) ) f . write ( p ) # Now the final byte, ensuring that unused bits at end are set to 0. bits_in_final_byte = self . len % 8 if not bits_in_final_byte : bits_in_final_byte = 8 f . write ( self [ - bits_in_final_byte : ] . tobytes ( ) ) else : # Really quite inefficient... a = 0 b = a + chunksize * 8 while b <= self . len : f . write ( self . _slice ( a , b ) . _getbytes ( ) ) a += chunksize * 8 b += chunksize * 8 if a != self . len : f . write ( self . _slice ( a , self . len ) . tobytes ( ) ) | 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 False return True | 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 part of the bitstring if self . _offset : count -= BIT_COUNT [ self . _datastore . getbyte ( 0 ) >> ( 8 - self . _offset ) ] # and count the last 1 - 8 bits at the end. endbits = self . _datastore . bytelength * 8 - ( self . _offset + self . len ) count += BIT_COUNT [ self . _datastore . getbyte ( self . _datastore . bytelength - 1 ) >> endbits ] return count if value else self . len - count | 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 ( ) [ 'bytealigned' ] # Adjust count for use in split() if count is not None : count += 1 sections = self . split ( old , start , end , count , bytealigned ) lengths = [ s . len for s in sections ] if len ( lengths ) == 1 : # Didn't find anything to replace. return 0 # no replacements done if new is self : # Prevent self assignment woes new = copy . copy ( self ) positions = [ lengths [ 0 ] + start ] for l in lengths [ 1 : - 1 ] : # Next position is the previous one plus the length of the next section. positions . append ( positions [ - 1 ] + l ) # We have all the positions that need replacements. We do them # in reverse order so that they won't move around as we replace. positions . reverse ( ) try : # Need to calculate new pos, if this is a bitstream newpos = self . _pos for p in positions : self [ p : p + old . len ] = new if old . len != new . len : diff = new . len - old . len for p in positions : if p >= newpos : continue if p + old . len <= newpos : newpos += diff else : newpos = p self . _pos = newpos except AttributeError : for p in positions : self [ p : p + old . len ] = new assert self . _assertsanity ( ) return len ( lengths ) - 1 | 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 : raise ValueError ( "Invalid insert position." ) self . _insert ( bs , pos ) | 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 ( "Overwrite exceeds boundary of bitstring." ) self . _overwrite ( bs , pos ) try : self . _pos = pos + bs . len except AttributeError : pass | 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 : # Single pos if pos < 0 : pos += self . len if not 0 <= pos < length : raise IndexError ( "Bit position {0} out of range." . format ( pos ) ) f ( pos ) | 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 ( p ) | 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 ( end - bits , end ) self . _delete ( bits , end - bits ) self . _insert ( rhs , start ) | 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 ( start , start + bits ) self . _delete ( bits , start ) self . _insert ( lhs , end - bits ) | 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 ( "Improper byte length {0}." . format ( fmt ) ) bytesizes = [ fmt ] elif isinstance ( fmt , basestring ) : m = STRUCT_PACK_RE . match ( fmt ) if not m : raise ValueError ( "Cannot parse format string {0}." . format ( fmt ) ) # Split the format string into a list of 'q', '4h' etc. formatlist = re . findall ( STRUCT_SPLIT_RE , m . group ( 'fmt' ) ) # Now deal with multiplicative factors, 4h -> hhhh etc. bytesizes = [ ] for f in formatlist : if len ( f ) == 1 : bytesizes . append ( PACK_CODE_SIZE [ f ] ) else : bytesizes . extend ( [ PACK_CODE_SIZE [ f [ - 1 ] ] ] * int ( f [ : - 1 ] ) ) elif isinstance ( fmt , collections . Iterable ) : bytesizes = fmt for bytesize in bytesizes : if not isinstance ( bytesize , numbers . Integral ) or bytesize < 0 : raise ValueError ( "Improper byte length {0}." . format ( bytesize ) ) else : raise TypeError ( "Format must be an integer, string or iterable." ) repeats = 0 totalbitsize = 8 * sum ( bytesizes ) if not totalbitsize : return 0 if repeat : # Try to repeat up to the end of the bitstring. finalbit = end else : # Just try one (set of) byteswap(s). finalbit = start + totalbitsize for patternend in xrange ( start + totalbitsize , finalbit + 1 , totalbitsize ) : bytestart = patternend - totalbitsize for bytesize in bytesizes : byteend = bytestart + bytesize * 8 self . _reversebytes ( bytestart , byteend ) bytestart += bytesize * 8 repeats += 1 return repeats | 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 + fmt ) self . _pos += fmt return bs p = self . _pos _ , token = tokenparser ( fmt ) if len ( token ) != 1 : self . _pos = p raise ValueError ( "Format string should be a single token, not {0} " "tokens - use readlist() instead." . format ( len ( token ) ) ) name , length , _ = token [ 0 ] if length is None : length = self . len - self . _pos value , self . _pos = self . _readtoken ( name , self . _pos , length ) return value | 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 . len return self . _slice ( oldpos , self . _pos ) | 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 : st = os . stat ( proc_path ) except OSError as e : # glob opens directories during matching, # and other processes might close their fds in the meantime. # This isn't a problem for the immutable-locked use case. # ESTALE could happen with NFS or Docker if e . errno in ( errno . ENOENT , errno . ESTALE ) : continue raise st_id = ( st . st_dev , st . st_ino ) if st_id not in id_fd_assoc : continue yield proc_path , st_id for proc_path , st_id in st_id_candidates ( glob . glob ( '/proc/[1-9]*/fd/*' ) ) : other_pid , other_fd = map ( int , PROC_PATH_RE . match ( proc_path ) . groups ( ) ) original_fds = id_fd_assoc [ st_id ] if other_pid == self_pid : if other_fd in original_fds : continue use_info = proc_use_info ( proc_path ) if not use_info : continue for fd in original_fds : yield ( fd , use_info ) # Requires Linux 3.3 for proc_path , st_id in st_id_candidates ( glob . glob ( '/proc/[1-9]*/map_files/*' ) ) : use_info = proc_use_info ( proc_path ) if not use_info : continue original_fds = id_fd_assoc [ st_id ] for fd in original_fds : yield ( fd , use_info ) | 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 . futimens ( fd , times ) != 0 : raise IOError ( ffi . errno , os . strerror ( ffi . errno ) , ( fd , atime . tv_sec , atime . tv_nsec , mtime . tv_sec , mtime . tv_nsec ) ) | 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_ptr . fm_length = lib . FIEMAP_MAX_OFFSET fiemap_ptr . fm_extent_count = count fcntl . ioctl ( fd , lib . FS_IOC_FIEMAP , fiemap_pybuf ) if fiemap_ptr . fm_mapped_extents == 0 : break for i in range ( fiemap_ptr . fm_mapped_extents ) : extent = fiemap_ptr . fm_extents [ i ] yield FiemapExtent ( extent . fe_logical , extent . fe_physical , extent . fe_length , extent . fe_flags ) fiemap_ptr . fm_start = extent . fe_logical + extent . fe_length | 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 ( 'uint64_t*' ) flags_buf = ffi . buffer ( flags_ptr ) fcntl . ioctl ( fd , lib . FS_IOC_GETFLAGS , flags_buf ) prev_flags = flags_ptr [ 0 ] flags_ptr [ 0 ] |= add_flags # Python represents negative numbers with an infinite number of # ones in bitops, so this will work correctly. flags_ptr [ 0 ] &= ~ remove_flags fcntl . ioctl ( fd , lib . FS_IOC_SETFLAGS , flags_buf ) return prev_flags & ( add_flags | remove_flags ) | 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 [ 'login_methods' ] : try : method ( api = api , username = username , password = password ) return api except ( TrapError , MultiTrapError ) : pass except ( ConnectionError , FatalError ) : transport . close ( ) raise | 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 ( * traps ) elif len ( traps ) == 1 : raise traps [ 0 ] | 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 ( 'Unable to encode length of {}' . format ( length ) ) return pack ( '!I' , ored_length ) [ offset : ] | 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 ( 'Unable to decode length of {}' . format ( length ) ) decoded = unpack ( '!I' , ( offset + length ) ) [ 0 ] decoded ^= XOR return decoded | 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.