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 . appe... | 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 ... | 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 . getsi... | 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 = Mm... | 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 Creat... | 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 ) .... | 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 a... | 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 ( s... | 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 ... | 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 = ( ... | 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 . _da... | 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... | 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' * le... | 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 ( "Rea... | 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... | 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 ) ... | 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}... | 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' * ( leng... | 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 Val... | 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 ) . dec... | 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 :... | 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... | 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 ,... | 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 . ... | 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 . _... | 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 .... | 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 - po... | 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 . ... | 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 V... | 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 = by... | 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 bytea... | 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 % ... | 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'... | 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... | 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 < co... | 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 ( ) [ 'byte... | 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 + chu... | 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 Fa... | 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... | 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 ( ) [... | 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... | 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 ( "Overw... | 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... | 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 ( ... | 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... | 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 ... | 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 ( fm... | 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 + fm... | 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... | 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 : i... | 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... | 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_... | 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 ) ... | 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 [... | 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... | 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 ( ... | 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.