idx int64 0 252k | question stringlengths 48 5.28k | target stringlengths 5 1.23k |
|---|---|---|
250,700 | def _appendstore ( self , store ) : if not store . bitlength : return store = offsetcopy ( store , ( self . offset + self . bitlength ) % 8 ) if store . offset : joinval = ( self . _rawarray . pop ( ) & ( 255 ^ ( 255 >> store . offset ) ) | ( store . getbyte ( 0 ) & ( 255 >> store . offset ) ) ) self . _rawarray . append ( joinval ) self . _rawarray . extend ( store . _rawarray [ 1 : ] ) else : self . _rawarray . extend ( store . _rawarray ) self . bitlength += store . bitlength | Join another store on to the end of this one . |
250,701 | def _prependstore ( self , store ) : if not store . bitlength : return 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 : 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 . |
250,702 | 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 . |
250,703 | def _setauto ( self , s , length , offset ) : 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 ) : 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 ) : 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 . |
250,704 | 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 . |
250,705 | def _setbytes_safe ( self , data , length = None , offset = 0 ) : data = bytearray ( data ) if length is None : 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 . |
250,706 | def _setbytes_unsafe ( self , data , length , offset ) : self . _datastore = ByteStore ( data [ : ] , length , offset ) assert self . _assertsanity ( ) | Unchecked version of _setbytes_safe . |
250,707 | 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 . |
250,708 | def _setuint ( self , uint , length = None ) : try : if length is None : length = self . _datastore . bitlength except AttributeError : pass 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 : data = binascii . unhexlify ( s ) 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 . |
250,709 | 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 . |
250,710 | def _setint ( self , int_ , length = None ) : 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 int_ += 1 self . _setuint ( - int_ , length ) self . _invert_all ( ) | Reset the bitstring to have given signed int interpretation . |
250,711 | def _readint ( self , length , start ) : ui = self . _readuint ( length , start ) if not ui >> ( length - 1 ) : return ui tmp = ( ~ ( ui - 1 ) ) & ( ( 1 << length ) - 1 ) return - tmp | Read bits and interpret as a signed int |
250,712 | 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 . |
250,713 | 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 . |
250,714 | 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 . |
250,715 | 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 . |
250,716 | 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 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 . |
250,717 | def _readintle ( self , length , start ) : ui = self . _readuintle ( length , start ) if not ui >> ( length - 1 ) : return ui tmp = ( ~ ( ui - 1 ) ) & ( ( 1 << length ) - 1 ) return - tmp | Read bits and interpret as a little - endian signed int . |
250,718 | 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 . |
250,719 | 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 . |
250,720 | 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 . |
250,721 | 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 . |
250,722 | 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 . |
250,723 | 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 . |
250,724 | 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 . |
250,725 | 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 . |
250,726 | 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 . |
250,727 | 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 . |
250,728 | 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 . |
250,729 | 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 . |
250,730 | 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 . |
250,731 | def _setbin_safe ( self , binstring ) : binstring = tidy_input_string ( binstring ) binstring = binstring . replace ( '0b' , '' ) self . _setbin_unsafe ( binstring ) | Reset the bitstring to the value given in binstring . |
250,732 | def _setbin_unsafe ( self , binstring ) : length = len ( binstring ) 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 . |
250,733 | def _readbin ( self , length , start ) : if not length : return '' startbyte , startoffset = divmod ( start + self . _offset , 8 ) endbyte = ( start + self . _offset + length - 1 ) // 8 b = self . _datastore . getbyteslice ( startbyte , endbyte + 1 ) try : c = "{:0{}b}" . format ( int ( binascii . hexlify ( b ) , 16 ) , 8 * len ( b ) ) except TypeError : c = "{0:0{1}b}" . format ( int ( binascii . hexlify ( str ( b ) ) , 16 ) , 8 * len ( b ) ) return c [ startoffset : startoffset + length ] | Read bits and interpret as a binary string . |
250,734 | def _setoct ( self , octstring ) : octstring = tidy_input_string ( octstring ) 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 . |
250,735 | def _readoct ( self , length , start ) : if length % 3 : raise InterpretError ( "Cannot convert to octal unambiguously - " "not multiple of 3 bits." ) if not length : return '' 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 . |
250,736 | def _sethex ( self , hexstring ) : hexstring = tidy_input_string ( hexstring ) hexstring = hexstring . replace ( '0x' , '' ) length = len ( hexstring ) if length % 2 : hexstring += '0' try : try : data = bytearray . fromhex ( hexstring ) except TypeError : 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 . |
250,737 | 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 ( ) except AttributeError : s = str ( binascii . hexlify ( s ) . decode ( 'utf-8' ) ) return s [ : - 1 ] if ( length // 4 ) % 2 else s | Read bits and interpret as a hex string . |
250,738 | 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 . |
250,739 | 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 : pass return cls ( bs ) | Convert bs to a bitstring and return it . |
250,740 | 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 . |
250,741 | 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 : return name_to_read [ name ] ( self , pos ) | Reads a token from the bitstring and returns the result . |
250,742 | def _reverse ( self ) : n = [ BYTE_REVERSAL_DICT [ b ] for b in self . _datastore . rawbytes ] n . reverse ( ) 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 . |
250,743 | 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 . |
250,744 | def _insert ( self , bs , pos ) : assert 0 <= pos <= self . len if pos > self . len // 2 : end = self . _slice ( pos , self . len ) self . _truncateend ( self . len - pos ) self . _append ( bs ) self . _append ( end ) else : 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 . |
250,745 | def _overwrite ( self , bs , pos ) : assert 0 <= pos < self . len if bs is self : 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 : 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 ) ) self . _datastore . setbyteslice ( firstbytepos + 1 , lastbytepos , d . getbyteslice ( 1 , lastbytepos - firstbytepos ) ) 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 . |
250,746 | def _delete ( self , bits , pos ) : assert 0 <= pos <= self . len assert pos + bits <= self . len if not pos : self . _truncatestart ( bits ) return if pos + bits == self . len : self . _truncateend ( bits ) return if pos > self . len - pos - bits : end = self . _slice ( pos + bits , self . len ) assert self . len - pos > 0 self . _truncateend ( self . len - pos ) self . _append ( end ) return start = self . _slice ( 0 , pos ) self . _truncatestart ( pos + bits ) self . _prepend ( start ) return | Delete bits at pos . |
250,747 | def _reversebytes ( self , start , end ) : newoffset = 8 - ( start % 8 ) if newoffset == 8 : newoffset = 0 self . _datastore = offsetcopy ( self . _datastore , newoffset ) 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 . |
250,748 | def _set ( self , pos ) : assert 0 <= pos < self . len self . _datastore . setbit ( pos ) | Set bit at pos to 1 . |
250,749 | def _unset ( self , pos ) : assert 0 <= pos < self . len self . _datastore . unsetbit ( pos ) | Set bit at pos to 0 . |
250,750 | 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 . |
250,751 | 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 . |
250,752 | 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 . |
250,753 | 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 . |
250,754 | 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 . |
250,755 | def _findbytes ( self , bytes_ , start , end , bytealigned ) : assert self . _datastore . offset == 0 assert bytealigned is True bytepos = ( start + 7 ) // 8 found = False p = bytepos finalpos = end // 8 increment = max ( 1024 , len ( bytes_ ) * 10 ) buffersize = increment + len ( bytes_ ) while p < finalpos : 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 . |
250,756 | def _findregex ( self , reg_ex , start , end , bytealigned ) : p = start length = len ( reg_ex . pattern ) increment = max ( 4096 , length * 10 ) buffersize = increment + length while p < end : buf = self . _readbin ( min ( buffersize , end - p ) , p ) m = reg_ex . search ( buf ) if m : pos = m . start ( ) if not bytealigned or ( p + pos ) % 8 == 0 : return ( p + pos , ) if bytealigned : p += pos + 1 continue p += increment return ( ) | Find first occurrence of a compiled regular expression . |
250,757 | 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 ) try : self . _pos = p [ 0 ] except ( AttributeError , IndexError ) : pass return p | Find first occurrence of substring bs . |
250,758 | 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 : 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 . |
250,759 | 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." ) 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 . |
250,760 | 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 . |
250,761 | 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 : f = self . _findbytes x = delimiter . _getbytes ( ) else : f = self . _findregex x = re . compile ( delimiter . _getbin ( ) ) found = f ( x , start , end , bytealigned ) if not found : yield self . _slice ( start , end ) return 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 : yield self . _slice ( startpos , end ) return c += 1 yield self . _slice ( startpos , found [ 0 ] ) startpos = pos = found [ 0 ] return | Return bitstring generator by splittling using a delimiter . |
250,762 | 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 . |
250,763 | def tobytes ( self ) : d = offsetcopy ( self . _datastore , 0 ) . rawbytes 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 . |
250,764 | def tofile ( self , f ) : chunksize = 1024 * 1024 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 ) 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 : 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 . |
250,765 | 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 . |
250,766 | 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 . |
250,767 | 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 . |
250,768 | def count ( self , value ) : if not self . len : return 0 count = sum ( BIT_COUNT [ self . _datastore . getbyte ( i ) ] for i in xrange ( self . _datastore . bytelength - 1 ) ) if self . _offset : count -= BIT_COUNT [ self . _datastore . getbyte ( 0 ) >> ( 8 - self . _offset ) ] 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 . |
250,769 | 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' ] 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 : return 0 if new is self : new = copy . copy ( self ) positions = [ lengths [ 0 ] + start ] for l in lengths [ 1 : - 1 ] : positions . append ( positions [ - 1 ] + l ) positions . reverse ( ) try : 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 . |
250,770 | 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 . |
250,771 | 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 . |
250,772 | def append ( self , bs ) : bs = self . _converttobitstring ( bs , offset = ( self . len + self . _offset ) % 8 ) self . _append ( bs ) | Append a bitstring to the current bitstring . |
250,773 | 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 . |
250,774 | 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 : 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 . |
250,775 | 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 . |
250,776 | 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 . |
250,777 | 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 . |
250,778 | 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 : 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 ) ) formatlist = re . findall ( STRUCT_SPLIT_RE , m . group ( 'fmt' ) ) 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 : finalbit = end else : 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 . |
250,779 | 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 . |
250,780 | 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 . |
250,781 | 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 . |
250,782 | 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 . |
250,783 | 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 . |
250,784 | def prepend ( self , bs ) : bs = self . _converttobitstring ( bs ) self . _prepend ( bs ) self . _pos += bs . len | Prepend a bitstring to the current bitstring . |
250,785 | 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 ) : for proc_path in it : try : st = os . stat ( proc_path ) except OSError as e : 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 ) 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 . |
250,786 | 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 . |
250,787 | def futimens ( fd , ns ) : 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 |
250,788 | 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 |
250,789 | 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 |
250,790 | 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 . |
250,791 | 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 . |
250,792 | 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 ) 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 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 . |
250,793 | 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 . |
250,794 | 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 . |
250,795 | 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 . |
250,796 | def encodeSentence ( self , * words ) : encoded = map ( self . encodeWord , words ) encoded = b'' . join ( encoded ) encoded += b'\x00' return encoded | Encode given sentence in API format . |
250,797 | 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 . |
250,798 | 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 . |
250,799 | 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 . |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.