Bits Class Reference

Inheritance diagram for Bits:

Public Member Functions
def	__init__ (self, auto=None, length=None, offset=None, **kwargs)
def	__new__ (cls, auto=None, length=None, offset=None, _cache=None, **kwargs)
def	__copy__ (self)
def	__lt__ (self, other)
def	__gt__ (self, other)
def	__le__ (self, other)
def	__ge__ (self, other)
def	__add__ (self, bs)
def	__radd__ (self, bs)
def	__getitem__ (self, key)
def	__len__ (self)
def	__str__ (self)
def	__repr__ (self)
def	__eq__ (self, bs)
def	__ne__ (self, bs)
def	__invert__ (self)
def	__lshift__ (self, n)
def	__rshift__ (self, n)
def	__mul__ (self, n)
def	__rmul__ (self, n)
def	__and__ (self, bs)
def	__rand__ (self, bs)
def	__or__ (self, bs)
def	__ror__ (self, bs)
def	__xor__ (self, bs)
def	__rxor__ (self, bs)
def	__contains__ (self, bs)
def	__hash__ (self)
def	__nonzero__ (self)
def	unpack (self, fmt, **kwargs)
def	find (self, bs, start=None, end=None, bytealigned=None)
def	findall (self, bs, start=None, end=None, count=None, bytealigned=None)
def	rfind (self, bs, start=None, end=None, bytealigned=None)
def	cut (self, bits, start=None, end=None, count=None)
def	split (self, delimiter, start=None, end=None, count=None, bytealigned=None)
def	join (self, sequence)
def	tobytes (self)
def	tofile (self, f)
def	startswith (self, prefix, start=None, end=None)
def	endswith (self, suffix, start=None, end=None)
def	all (self, value, pos=None)
def	any (self, value, pos=None)
def	count (self, value)

Static Public Attributes
	else :

Protected Member Functions
def	_initialise (self, auto, length, offset, **kwargs)
def	_initialise_from_auto (self, auto, length, offset)
def	_assertsanity (self)
def	_init_with_token (cls, name, token_length, value)
def	_clear (self)
def	_setauto (self, s, length, offset)
def	_setfile (self, filename, length, offset)
def	_setbytes_safe (self, data, length=None, offset=0)
def	_setbytes_unsafe (self, data, length, offset)
def	_readbytes (self, length, start)
def	_getbytes (self)
def	_setuint (self, uint, length=None)
def	_readuint (self, length, start)
def	_getuint (self)
def	_setint (self, int_, length=None)
def	_readint (self, length, start)
def	_getint (self)
def	_setuintbe (self, uintbe, length=None)
def	_readuintbe (self, length, start)
def	_getuintbe (self)
def	_setintbe (self, intbe, length=None)
def	_readintbe (self, length, start)
def	_getintbe (self)
def	_setuintle (self, uintle, length=None)
def	_readuintle (self, length, start)
def	_getuintle (self)
def	_setintle (self, intle, length=None)
def	_readintle (self, length, start)
def	_getintle (self)
def	_setfloat (self, f, length=None)
def	_readfloat (self, length, start)
def	_getfloat (self)
def	_setfloatle (self, f, length=None)
def	_readfloatle (self, length, start)
def	_getfloatle (self)
def	_setue (self, i)
def	_readue (self, pos)
def	_getue (self)
def	_setse (self, i)
def	_getse (self)
def	_readse (self, pos)
def	_setuie (self, i)
def	_readuie (self, pos)
def	_getuie (self)
def	_setsie (self, i)
def	_getsie (self)
def	_readsie (self, pos)
def	_setbool (self, value)
def	_getbool (self)
def	_readbool (self, pos)
def	_setbin_safe (self, binstring)
def	_setbin_unsafe (self, binstring)
def	_readbin (self, length, start)
def	_getbin (self)
def	_setoct (self, octstring)
def	_readoct (self, length, start)
def	_getoct (self)
def	_sethex (self, hexstring)
def	_readhex (self, length, start)
def	_gethex (self)
def	_getoffset (self)
def	_getlength (self)
def	_ensureinmemory (self)
def	_converttobitstring (cls, bs, offset=0, cache=None)
def	_copy (self)
def	_slice (self, start, end)
def	_readtoken (self, name, pos, length)
def	_append (self, bs)
def	_prepend (self, bs)
def	_reverse (self)
def	_truncatestart (self, bits)
def	_truncateend (self, bits)
def	_insert (self, bs, pos)
def	_overwrite (self, bs, pos)
def	_delete (self, bits, pos)
def	_reversebytes (self, start, end)
def	_set (self, pos)
def	_unset (self, pos)
def	_invert (self, pos)
def	_invert_all (self)
def	_ilshift (self, n)
def	_irshift (self, n)
def	_imul (self, n)
def	_inplace_logical_helper (self, bs, f)
def	_ior (self, bs)
def	_iand (self, bs)
def	_ixor (self, bs)
def	_readbits (self, length, start)
def	_validate_slice (self, start, end)
def	_readlist (self, fmt, pos, **kwargs)
def	_findbytes (self, bytes_, start, end, bytealigned)
def	_findregex (self, reg_ex, start, end, bytealigned)

Protected Attributes
	_pos
	_datastore

Static Protected Attributes
def	_setfloatne = _setfloatle
def	_readfloatne = _readfloatle
def	_getfloatne = _getfloatle
def	_setuintne = _setuintle
def	_readuintne = _readuintle
def	_getuintne = _getuintle
def	_setintne = _setintle
def	_readintne = _readintle
def	_getintne = _getintle

Properties
property	_offset = property(_getoffset)
property	len
property	length
property	bool
property	hex
property	bin
property	oct
property	bytes
property	int
property	uint
property	float
property	intbe
property	uintbe
property	floatbe
property	intle
property	uintle
property	floatle
property	intne
property	uintne
property	floatne
property	ue
property	se
property	uie
property	sie

Static Private Attributes
tuple	__slots__ = ('_datastore')
def	__bool__ = __nonzero__

Detailed Description

A container holding an immutable sequence of bits.

For a mutable container use the BitArray class instead.

Methods:

all() -- Check if all specified bits are set to 1 or 0.
any() -- Check if any of specified bits are set to 1 or 0.
count() -- Count the number of bits set to 1 or 0.
cut() -- Create generator of constant sized chunks.
endswith() -- Return whether the bitstring ends with a sub-string.
find() -- Find a sub-bitstring in the current bitstring.
findall() -- Find all occurrences of a sub-bitstring in the current bitstring.
join() -- Join bitstrings together using current bitstring.
rfind() -- Seek backwards to find a sub-bitstring.
split() -- Create generator of chunks split by a delimiter.
startswith() -- Return whether the bitstring starts with a sub-bitstring.
tobytes() -- Return bitstring as bytes, padding if needed.
tofile() -- Write bitstring to file, padding if needed.
unpack() -- Interpret bits using format string.

Special methods:

Also available are the operators [], ==, !=, +, *, ~, <<, >>, &, |, ^.

Properties:

bin -- The bitstring as a binary string.
bool -- For single bit bitstrings, interpret as True or False.
bytes -- The bitstring as a bytes object.
float -- Interpret as a floating point number.
floatbe -- Interpret as a big-endian floating point number.
floatle -- Interpret as a little-endian floating point number.
floatne -- Interpret as a native-endian floating point number.
hex -- The bitstring as a hexadecimal string.
int -- Interpret as a two's complement signed integer.
intbe -- Interpret as a big-endian signed integer.
intle -- Interpret as a little-endian signed integer.
intne -- Interpret as a native-endian signed integer.
len -- Length of the bitstring in bits.
oct -- The bitstring as an octal string.
se -- Interpret as a signed exponential-Golomb code.
ue -- Interpret as an unsigned exponential-Golomb code.
sie -- Interpret as a signed interleaved exponential-Golomb code.
uie -- Interpret as an unsigned interleaved exponential-Golomb code.
uint -- Interpret as a two's complement unsigned integer.
uintbe -- Interpret as a big-endian unsigned integer.
uintle -- Interpret as a little-endian unsigned integer.
uintne -- Interpret as a native-endian unsigned integer.

Definition at line 687 of file bitstring.py.

Constructor & Destructor Documentation

__init__()

def __init__	(		self,
			auto = None,
			length = None,
			offset = None,
		**	kwargs
	)

Either specify an 'auto' initialiser:
auto -- a string of comma separated tokens, an integer, a file object,
        a bytearray, a boolean iterable, an array or another bitstring.

Or initialise via **kwargs with one (and only one) of:
bytes -- raw data as a string, for example read from a binary file.
bin -- binary string representation, e.g. '0b001010'.
hex -- hexadecimal string representation, e.g. '0x2ef'
oct -- octal string representation, e.g. '0o777'.
uint -- an unsigned integer.
int -- a signed integer.
float -- a floating point number.
uintbe -- an unsigned big-endian whole byte integer.
intbe -- a signed big-endian whole byte integer.
floatbe - a big-endian floating point number.
uintle -- an unsigned little-endian whole byte integer.
intle -- a signed little-endian whole byte integer.
floatle -- a little-endian floating point number.
uintne -- an unsigned native-endian whole byte integer.
intne -- a signed native-endian whole byte integer.
floatne -- a native-endian floating point number.
se -- a signed exponential-Golomb code.
ue -- an unsigned exponential-Golomb code.
sie -- a signed interleaved exponential-Golomb code.
uie -- an unsigned interleaved exponential-Golomb code.
bool -- a boolean (True or False).
filename -- a file which will be opened in binary read-only mode.

Other keyword arguments:
length -- length of the bitstring in bits, if needed and appropriate.
          It must be supplied for all integer and float initialisers.
offset -- bit offset to the data. These offset bits are
          ignored and this is mainly intended for use when
          initialising using 'bytes' or 'filename'.

Reimplemented in BitArray, ConstBitStream, and BitStream.

Definition at line 742 of file bitstring.py.

    def __init__(self, auto=None, length=None, offset=None, **kwargs):
        """Either specify an 'auto' initialiser:
        auto -- a string of comma separated tokens, an integer, a file object,
                a bytearray, a boolean iterable, an array or another bitstring.
 
        Or initialise via **kwargs with one (and only one) of:
        bytes -- raw data as a string, for example read from a binary file.
        bin -- binary string representation, e.g. '0b001010'.
        hex -- hexadecimal string representation, e.g. '0x2ef'
        oct -- octal string representation, e.g. '0o777'.
        uint -- an unsigned integer.
        int -- a signed integer.
        float -- a floating point number.
        uintbe -- an unsigned big-endian whole byte integer.
        intbe -- a signed big-endian whole byte integer.
        floatbe - a big-endian floating point number.
        uintle -- an unsigned little-endian whole byte integer.
        intle -- a signed little-endian whole byte integer.
        floatle -- a little-endian floating point number.
        uintne -- an unsigned native-endian whole byte integer.
        intne -- a signed native-endian whole byte integer.
        floatne -- a native-endian floating point number.
        se -- a signed exponential-Golomb code.
        ue -- an unsigned exponential-Golomb code.
        sie -- a signed interleaved exponential-Golomb code.
        uie -- an unsigned interleaved exponential-Golomb code.
        bool -- a boolean (True or False).
        filename -- a file which will be opened in binary read-only mode.
 
        Other keyword arguments:
        length -- length of the bitstring in bits, if needed and appropriate.
                  It must be supplied for all integer and float initialisers.
        offset -- bit offset to the data. These offset bits are
                  ignored and this is mainly intended for use when
                  initialising using 'bytes' or 'filename'.
 
        """
 

Member Function Documentation

__add__()

def __add__	(		self,
			bs
	)

Concatenate bitstrings and return new bitstring.

bs -- the bitstring to append.

Reimplemented in ConstBitStream.

Definition at line 868 of file bitstring.py.

    def __add__(self, bs):
        """Concatenate bitstrings and return new bitstring.
 
        bs -- the bitstring to append.
 
        """
        bs = Bits(bs)
        if bs.len <= self.len:
            s = self._copy()
            s._append(bs)
        else:
            s = bs._copy()
            s = self.__class__(s)
            s._prepend(self)
        return s
 

__and__()

def __and__	(		self,
			bs
	)

Bit-wise 'and' between two bitstrings. Returns new bitstring.

bs -- The bitstring to '&' with.

Raises ValueError if the two bitstrings have differing lengths.

Definition at line 1079 of file bitstring.py.

    def __and__(self, bs):
        """Bit-wise 'and' between two bitstrings. Returns new bitstring.
 
        bs -- The bitstring to '&' with.
 
        Raises ValueError if the two bitstrings have differing lengths.
 
        """
        bs = Bits(bs)
        if self.len != bs.len:
            raise ValueError("Bitstrings must have the same length "
                             "for & operator.")
        s = self._copy()
        s._iand(bs)
        return s
 

__contains__()

def __contains__	(		self,
			bs
	)

Return whether bs is contained in the current bitstring.

bs -- The bitstring to search for.

Definition at line 1157 of file bitstring.py.

    def __contains__(self, bs):
        """Return whether bs is contained in the current bitstring.
 
        bs -- The bitstring to search for.
 
        """
        # Don't want to change pos
        try:
            pos = self._pos
        except AttributeError:
            pass
        found = Bits.find(self, bs, bytealigned=False)
        try:
            self._pos = pos
        except AttributeError:
            pass
        return bool(found)
 

__copy__()

def __copy__

(

self

)

Return a new copy of the Bits for the copy module.

Reimplemented in BitArray, ConstBitStream, and BitStream.

Definition at line 850 of file bitstring.py.

    def __copy__(self):
        """Return a new copy of the Bits for the copy module."""
        # Note that if you want a new copy (different ID), use _copy instead.
        # The copy can return self as it's immutable.
        return self
 

__eq__()

def __eq__	(		self,
			bs
	)

Return True if two bitstrings have the same binary representation.

>>> BitArray('0b1110') == '0xe'
True

Definition at line 990 of file bitstring.py.

    def __eq__(self, bs):
        """Return True if two bitstrings have the same binary representation.
 
        >>> BitArray('0b1110') == '0xe'
        True
 
        """
        try:
            bs = Bits(bs)
        except TypeError:
            return False
        return equal(self._datastore, bs._datastore)
 

__ge__()

def __ge__	(		self,
			other
	)

Definition at line 865 of file bitstring.py.

    def __ge__(self, other):
        raise TypeError("unorderable type: {0}".format(type(self).__name__))
 

__getitem__()

def __getitem__	(		self,
			key
	)

Return a new bitstring representing a slice of the current bitstring.

Indices are in units of the step parameter (default 1 bit).
Stepping is used to specify the number of bits in each item.

>>> print BitArray('0b00110')[1:4]
'0b011'
>>> print BitArray('0x00112233')[1:3:8]
'0x1122'

Definition at line 893 of file bitstring.py.

    def __getitem__(self, key):
        """Return a new bitstring representing a slice of the current bitstring.
 
        Indices are in units of the step parameter (default 1 bit).
        Stepping is used to specify the number of bits in each item.
 
        >>> print BitArray('0b00110')[1:4]
        '0b011'
        >>> print BitArray('0x00112233')[1:3:8]
        '0x1122'
 
        """
        length = self.len
        try:
            step = key.step if key.step is not None else 1
        except AttributeError:
            # single element
            if key < 0:
                key += length
            if not 0 <= key < length:
                raise IndexError("Slice index out of range.")
            # Single bit, return True or False
            return self._datastore.getbit(key)
        else:
            if step != 1:
                # convert to binary string and use string slicing
                bs = self.__class__()
                bs._setbin_unsafe(self._getbin().__getitem__(key))
                return bs
            start, stop = 0, length
            if key.start is not None:
                start = key.start
                if key.start < 0:
                    start += stop
            if key.stop is not None:
                stop = key.stop
                if key.stop < 0:
                    stop += length
            start = max(start, 0)
            stop = min(stop, length)
            if start < stop:
                return self._slice(start, stop)
            else:
                return self.__class__()
 

__gt__()

def __gt__	(		self,
			other
	)

Definition at line 859 of file bitstring.py.

    def __gt__(self, other):
        raise TypeError("unorderable type: {0}".format(type(self).__name__))
 

__hash__()

def __hash__

(

self

)

Return an integer hash of the object.

Definition at line 1175 of file bitstring.py.

    def __hash__(self):
        """Return an integer hash of the object."""
        # We can't in general hash the whole bitstring (it could take hours!)
        # So instead take some bits from the start and end.
        if self.len <= 160:
            # Use the whole bitstring.
            shorter = self
        else:
            # Take 10 bytes from start and end
            shorter = self[:80] + self[-80:]
        h = 0
        for byte in shorter.tobytes():
            try:
                h = (h << 4) + ord(byte)
            except TypeError:
                # Python 3
                h = (h << 4) + byte
            g = h & 0xf0000000
            if g & (1 << 31):
                h ^= (g >> 24)
                h ^= g
        return h % 1442968193
 

__invert__()

def __invert__

(

self

)

Return bitstring with every bit inverted.

Raises Error if the bitstring is empty.

Definition at line 1012 of file bitstring.py.

    def __invert__(self):
        """Return bitstring with every bit inverted.
 
        Raises Error if the bitstring is empty.
 
        """
        if not self.len:
            raise Error("Cannot invert empty bitstring.")
        s = self._copy()
        s._invert_all()
        return s
 

__le__()

def __le__	(		self,
			other
	)

Definition at line 862 of file bitstring.py.

    def __le__(self, other):
        raise TypeError("unorderable type: {0}".format(type(self).__name__))
 

__len__()

def __len__

(

self

)

Return the length of the bitstring in bits.

Definition at line 938 of file bitstring.py.

    def __len__(self):
        """Return the length of the bitstring in bits."""
        return self._getlength()
 

__lshift__()

def __lshift__	(		self,
			n
	)

Return bitstring with bits shifted by n to the left.

n -- the number of bits to shift. Must be >= 0.

Definition at line 1024 of file bitstring.py.

    def __lshift__(self, n):
        """Return bitstring with bits shifted by n to the left.
 
        n -- the number of bits to shift. Must be >= 0.
 
        """
        if n < 0:
            raise ValueError("Cannot shift by a negative amount.")
        if not self.len:
            raise ValueError("Cannot shift an empty bitstring.")
        n = min(n, self.len)
        s = self._slice(n, self.len)
        s._append(Bits(n))
        return s
 

__lt__()

def __lt__	(		self,
			other
	)

Definition at line 856 of file bitstring.py.

    def __lt__(self, other):
        raise TypeError("unorderable type: {0}".format(type(self).__name__))
 

__mul__()

def __mul__	(		self,
			n
	)

Return bitstring consisting of n concatenations of self.

Called for expression of the form 'a = b*3'.
n -- The number of concatenations. Must be >= 0.

Definition at line 1055 of file bitstring.py.

    def __mul__(self, n):
        """Return bitstring consisting of n concatenations of self.
 
        Called for expression of the form 'a = b*3'.
        n -- The number of concatenations. Must be >= 0.
 
        """
        if n < 0:
            raise ValueError("Cannot multiply by a negative integer.")
        if not n:
            return self.__class__()
        s = self._copy()
        s._imul(n)
        return s
 

__ne__()

def __ne__	(		self,
			bs
	)

Return False if two bitstrings have the same binary representation.

>>> BitArray('0b111') == '0x7'
False

Definition at line 1003 of file bitstring.py.

    def __ne__(self, bs):
        """Return False if two bitstrings have the same binary representation.
 
        >>> BitArray('0b111') == '0x7'
        False
 
        """
        return not self.__eq__(bs)
 

__new__()

def __new__	(		cls,
			auto = None,
			length = None,
			offset = None,
			_cache = None,
		**	kwargs
	)

Definition at line 780 of file bitstring.py.

    def __new__(cls, auto=None, length=None, offset=None, _cache=None, **kwargs):
        # For instances auto-initialised with a string we intern the
        # instance for re-use.
        if _cache is None:
            _cache = {}
        try:
            if isinstance(auto, basestring):
                try:
                    return _cache[auto]
                except KeyError:
                    x = object.__new__(Bits)
                    try:
                        _, tokens = tokenparser(auto)
                    except ValueError as e:
                        raise CreationError(*e.args)
                    x._datastore = ConstByteStore(bytearray(0), 0, 0)
                    for token in tokens:
                        x._datastore._appendstore(Bits._init_with_token(*token)._datastore)
                    assert x._assertsanity()
                    if len(_cache) < CACHE_SIZE:
                        _cache[auto] = x
                    return x
            if isinstance(auto, Bits):
                return auto
        except TypeError:
            pass
        x = super(Bits, cls).__new__(cls)
        x._initialise(auto, length, offset, **kwargs)
        return x
 

__nonzero__()

def __nonzero__

(

self

)

Return True if any bits are set to 1, otherwise return False.

Definition at line 1199 of file bitstring.py.

    def __nonzero__(self):
        """Return True if any bits are set to 1, otherwise return False."""
        return self.any(True)
 

__or__()

def __or__	(		self,
			bs
	)

Bit-wise 'or' between two bitstrings. Returns new bitstring.

bs -- The bitstring to '|' with.

Raises ValueError if the two bitstrings have differing lengths.

Definition at line 1105 of file bitstring.py.

    def __or__(self, bs):
        """Bit-wise 'or' between two bitstrings. Returns new bitstring.
 
        bs -- The bitstring to '|' with.
 
        Raises ValueError if the two bitstrings have differing lengths.
 
        """
        bs = Bits(bs)
        if self.len != bs.len:
            raise ValueError("Bitstrings must have the same length "
                             "for | operator.")
        s = self._copy()
        s._ior(bs)
        return s
 

__radd__()

def __radd__	(		self,
			bs
	)

Append current bitstring to bs and return new bitstring.

bs -- the string for the 'auto' initialiser that will be appended to.

Definition at line 884 of file bitstring.py.

    def __radd__(self, bs):
        """Append current bitstring to bs and return new bitstring.
 
        bs -- the string for the 'auto' initialiser that will be appended to.
 
        """
        bs = self._converttobitstring(bs)
        return bs.__add__(self)
 

__rand__()

def __rand__	(		self,
			bs
	)

Bit-wise 'and' between two bitstrings. Returns new bitstring.

bs -- the bitstring to '&' with.

Raises ValueError if the two bitstrings have differing lengths.

Definition at line 1095 of file bitstring.py.

    def __rand__(self, bs):
        """Bit-wise 'and' between two bitstrings. Returns new bitstring.
 
        bs -- the bitstring to '&' with.
 
        Raises ValueError if the two bitstrings have differing lengths.
 
        """
        return self.__and__(bs)
 

__repr__()

def __repr__

(

self

)

Return representation that could be used to recreate the bitstring.

If the returned string is too long it will be truncated. See __str__().

Definition at line 969 of file bitstring.py.

    def __repr__(self):
        """Return representation that could be used to recreate the bitstring.
 
        If the returned string is too long it will be truncated. See __str__().
 
        """
        length = self.len
        if isinstance(self._datastore._rawarray, MmapByteArray):
            offsetstring = ''
            if self._datastore.byteoffset or self._offset:
                offsetstring = ", offset=%d" % (self._datastore._rawarray.byteoffset * 8 + self._offset)
            lengthstring = ", length=%d" % length
            return "{0}(filename='{1}'{2}{3})".format(self.__class__.__name__,
                                                      self._datastore._rawarray.source.name, lengthstring, offsetstring)
        else:
            s = self.__str__()
            lengthstring = ''
            if s.endswith('...'):
                lengthstring = " # length={0}".format(length)
            return "{0}('{1}'){2}".format(self.__class__.__name__, s, lengthstring)
 

__rmul__()

def __rmul__	(		self,
			n
	)

Return bitstring consisting of n concatenations of self.

Called for expressions of the form 'a = 3*b'.
n -- The number of concatenations. Must be >= 0.

Definition at line 1070 of file bitstring.py.

    def __rmul__(self, n):
        """Return bitstring consisting of n concatenations of self.
 
        Called for expressions of the form 'a = 3*b'.
        n -- The number of concatenations. Must be >= 0.
 
        """
        return self.__mul__(n)
 

__ror__()

def __ror__	(		self,
			bs
	)

Bit-wise 'or' between two bitstrings. Returns new bitstring.

bs -- The bitstring to '|' with.

Raises ValueError if the two bitstrings have differing lengths.

Definition at line 1121 of file bitstring.py.

    def __ror__(self, bs):
        """Bit-wise 'or' between two bitstrings. Returns new bitstring.
 
        bs -- The bitstring to '|' with.
 
        Raises ValueError if the two bitstrings have differing lengths.
 
        """
        return self.__or__(bs)
 

__rshift__()

def __rshift__	(		self,
			n
	)

Return bitstring with bits shifted by n to the right.

n -- the number of bits to shift. Must be >= 0.

Definition at line 1039 of file bitstring.py.

    def __rshift__(self, n):
        """Return bitstring with bits shifted by n to the right.
 
        n -- the number of bits to shift. Must be >= 0.
 
        """
        if n < 0:
            raise ValueError("Cannot shift by a negative amount.")
        if not self.len:
            raise ValueError("Cannot shift an empty bitstring.")
        if not n:
            return self._copy()
        s = self.__class__(length=min(n, self.len))
        s._append(self[:-n])
        return s
 

__rxor__()

def __rxor__	(		self,
			bs
	)

Bit-wise 'xor' between two bitstrings. Returns new bitstring.

bs -- The bitstring to '^' with.

Raises ValueError if the two bitstrings have differing lengths.

Definition at line 1147 of file bitstring.py.

    def __rxor__(self, bs):
        """Bit-wise 'xor' between two bitstrings. Returns new bitstring.
 
        bs -- The bitstring to '^' with.
 
        Raises ValueError if the two bitstrings have differing lengths.
 
        """
        return self.__xor__(bs)
 

__str__()

def __str__

(

self

)

Return approximate string representation of bitstring for printing.

Short strings will be given wholly in hexadecimal or binary. Longer
strings may be part hexadecimal and part binary. Very long strings will
be truncated with '...'.

Definition at line 942 of file bitstring.py.

    def __str__(self):
        """Return approximate string representation of bitstring for printing.
 
        Short strings will be given wholly in hexadecimal or binary. Longer
        strings may be part hexadecimal and part binary. Very long strings will
        be truncated with '...'.
 
        """
        length = self.len
        if not length:
            return ''
        if length > MAX_CHARS * 4:
            # Too long for hex. Truncate...
            return ''.join(('0x', self._readhex(MAX_CHARS * 4, 0), '...'))
        # If it's quite short and we can't do hex then use bin
        if length < 32 and length % 4 != 0:
            return '0b' + self.bin
        # If we can use hex then do so
        if not length % 4:
            return '0x' + self.hex
        # Otherwise first we do as much as we can in hex
        # then add on 1, 2 or 3 bits on at the end
        bits_at_end = length % 4
        return ''.join(('0x', self._readhex(length - bits_at_end, 0),
                        ', ', '0b',
                        self._readbin(bits_at_end, length - bits_at_end)))
 

__xor__()

def __xor__	(		self,
			bs
	)

Bit-wise 'xor' between two bitstrings. Returns new bitstring.

bs -- The bitstring to '^' with.

Raises ValueError if the two bitstrings have differing lengths.

Definition at line 1131 of file bitstring.py.

    def __xor__(self, bs):
        """Bit-wise 'xor' between two bitstrings. Returns new bitstring.
 
        bs -- The bitstring to '^' with.
 
        Raises ValueError if the two bitstrings have differing lengths.
 
        """
        bs = Bits(bs)
        if self.len != bs.len:
            raise ValueError("Bitstrings must have the same length "
                             "for ^ operator.")
        s = self._copy()
        s._ixor(bs)
        return s
 

_append()

def _append (   self,   bs  )

protected

Append a bitstring to the current bitstring.

Definition at line 2035 of file bitstring.py.

    def _append(self, bs):
        """Append a bitstring to the current bitstring."""
        self._datastore._appendstore(bs._datastore)
 

_assertsanity()

def _assertsanity (   self )

protected

Check internal self consistency as a debugging aid.

Definition at line 1206 of file bitstring.py.

    def _assertsanity(self):
        """Check internal self consistency as a debugging aid."""
        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
 

_clear()

def _clear (   self )

protected

Reset the bitstring to an empty state.

Reimplemented in ConstBitStream.

Definition at line 1252 of file bitstring.py.

    def _clear(self):
        """Reset the bitstring to an empty state."""
        self._datastore = ByteStore(bytearray(0))
 

_converttobitstring()

def _converttobitstring (   cls,   bs,   offset = 0,   cache = None  )

protected

Convert bs to a bitstring and return it.

offset gives the suggested bit offset of first significant
bit, to optimise append etc.

Definition at line 1966 of file bitstring.py.

    def _converttobitstring(cls, bs, offset=0, cache=None):
        """Convert bs to a bitstring and return it.
 
        offset gives the suggested bit offset of first significant
        bit, to optimise append etc.
 
        """
        if cache is None:
            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)
 

_copy()

def _copy (   self )

protected

Create and return a new copy of the Bits (always in memory).

Definition at line 2001 of file bitstring.py.

    def _copy(self):
        """Create and return a new copy of the Bits (always in memory)."""
        s_copy = self.__class__()
        s_copy._setbytes_unsafe(self._datastore.getbyteslice(0, self._datastore.bytelength),
                                self.len, self._offset)
        return s_copy
 

_delete()

def _delete (   self,   bits,   pos  )

protected

Delete bits at pos.

Definition at line 2135 of file bitstring.py.

    def _delete(self, bits, pos):
        """Delete bits at 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
 

_ensureinmemory()

def _ensureinmemory (   self )

protected

Ensure the data is held in memory, not in a file.

Definition at line 1960 of file bitstring.py.

    def _ensureinmemory(self):
        """Ensure the data is held in memory, not in a file."""
        self._setbytes_unsafe(self._datastore.getbyteslice(0, self._datastore.bytelength),
                              self.len, self._offset)
 

_findbytes()

def _findbytes (   self,   bytes_,   start,   end,   bytealigned  )

protected

Quicker version of find when everything's whole byte
and byte aligned.

Definition at line 2365 of file bitstring.py.

    def _findbytes(self, bytes_, start, end, bytealigned):
        """Quicker version of find when everything's whole byte
        and byte aligned.
 
        """
        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,)
 

_findregex()

def _findregex (   self,   reg_ex,   start,   end,   bytealigned  )

protected

Find first occurrence of a compiled regular expression.

Note that this doesn't support arbitrary regexes, in particular they
must match a known length.

Definition at line 2392 of file bitstring.py.

    def _findregex(self, reg_ex, start, end, bytealigned):
        """Find first occurrence of a compiled regular expression.
 
        Note that this doesn't support arbitrary regexes, in particular they
        must match a known length.
 
        """
        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 ()
 

_getbin()

def _getbin (   self )

protected

Return interpretation as a binary string.

Definition at line 1872 of file bitstring.py.

    def _getbin(self):
        """Return interpretation as a binary string."""
        return self._readbin(self.len, 0)
 

_getbool()

def _getbool (   self )

protected

Definition at line 1825 of file bitstring.py.

    def _getbool(self):
        if self.length != 1:
            msg = "For a bool interpretation a bitstring must be 1 bit long, not {0} bits."
            raise InterpretError(msg, self.length)
        return self[0]
 

_getbytes()

def _getbytes (   self )

protected

Return the data as an ordinary string.

Definition at line 1355 of file bitstring.py.

    def _getbytes(self):
        """Return the data as an ordinary string."""
        if self.len % 8:
            raise InterpretError("Cannot interpret as bytes unambiguously - "
                                 "not multiple of 8 bits.")
        return self._readbytes(self.len, 0)
 

_getfloat()

def _getfloat (   self )

protected

Interpret the whole bitstring as a float.

Definition at line 1586 of file bitstring.py.

    def _getfloat(self):
        """Interpret the whole bitstring as a float."""
        return self._readfloat(self.len, 0)
 

_getfloatle()

def _getfloatle (   self )

protected

Interpret the whole bitstring as a little-endian float.

Definition at line 1625 of file bitstring.py.

    def _getfloatle(self):
        """Interpret the whole bitstring as a little-endian float."""
        return self._readfloatle(self.len, 0)
 

_gethex()

def _gethex (   self )

protected

Return the hexadecimal representation as a string prefixed with '0x'.

Raises an InterpretError if the bitstring's length is not a multiple of 4.

Definition at line 1945 of file bitstring.py.

    def _gethex(self):
        """Return the hexadecimal representation as a string prefixed with '0x'.
 
        Raises an InterpretError if the bitstring's length is not a multiple of 4.
 
        """
        return self._readhex(self.len, 0)
 

_getint()

def _getint (   self )

protected

Return data as a two's complement signed int.

Definition at line 1454 of file bitstring.py.

    def _getint(self):
        """Return data as a two's complement signed int."""
        return self._readint(self.len, 0)
 

_getintbe()

def _getintbe (   self )

protected

Return data as a big-endian two's complement signed int.

Definition at line 1490 of file bitstring.py.

    def _getintbe(self):
        """Return data as a big-endian two's complement signed int."""
        return self._readintbe(self.len, 0)
 

_getintle()

def _getintle (   self )

protected

Definition at line 1549 of file bitstring.py.

    def _getintle(self):
        return self._readintle(self.len, 0)
 

_getlength()

def _getlength (   self )

protected

Return the length of the bitstring in bits.

Definition at line 1956 of file bitstring.py.

    def _getlength(self):
        """Return the length of the bitstring in bits."""
        return self._datastore.bitlength
 

_getoct()

def _getoct (   self )

protected

Return interpretation as an octal string.

Definition at line 1906 of file bitstring.py.

    def _getoct(self):
        """Return interpretation as an octal string."""
        return self._readoct(self.len, 0)
 

_getoffset()

def _getoffset (   self )

protected

Definition at line 1953 of file bitstring.py.

    def _getoffset(self):
        return self._datastore.offset
 

_getse()

def _getse (   self )

protected

Return data as signed exponential-Golomb code.

Raises InterpretError if bitstring is not a single exponential-Golomb code.

Definition at line 1698 of file bitstring.py.

    def _getse(self):
        """Return data as signed exponential-Golomb code.
 
        Raises InterpretError if bitstring is not a single exponential-Golomb code.
 
        """
        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
 

_getsie()

def _getsie (   self )

protected

Return data as signed interleaved exponential-Golomb code.

Raises InterpretError if bitstring is not a single exponential-Golomb code.

Definition at line 1781 of file bitstring.py.

    def _getsie(self):
        """Return data as signed interleaved exponential-Golomb code.
 
        Raises InterpretError if bitstring is not a single exponential-Golomb code.
 
        """
        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
 

_getue()

def _getue (   self )

protected

Return data as unsigned exponential-Golomb code.

Raises InterpretError if bitstring is not a single exponential-Golomb code.

Definition at line 1676 of file bitstring.py.

    def _getue(self):
        """Return data as unsigned exponential-Golomb code.
 
        Raises InterpretError if bitstring is not a single exponential-Golomb code.
 
        """
        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
 

_getuie()

def _getuie (   self )

protected

Return data as unsigned interleaved exponential-Golomb code.

Raises InterpretError if bitstring is not a single exponential-Golomb code.

Definition at line 1759 of file bitstring.py.

    def _getuie(self):
        """Return data as unsigned interleaved exponential-Golomb code.
 
        Raises InterpretError if bitstring is not a single exponential-Golomb code.
 
        """
        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
 

_getuint()

def _getuint (   self )

protected

Return data as an unsigned int.

Definition at line 1417 of file bitstring.py.

    def _getuint(self):
        """Return data as an unsigned int."""
        return self._readuint(self.len, 0)
 

_getuintbe()

def _getuintbe (   self )

protected

Return data as a big-endian two's complement unsigned int.

Definition at line 1472 of file bitstring.py.

    def _getuintbe(self):
        """Return data as a big-endian two's complement unsigned int."""
        return self._readuintbe(self.len, 0)
 

_getuintle()

def _getuintle (   self )

protected

Definition at line 1529 of file bitstring.py.

    def _getuintle(self):
        return self._readuintle(self.len, 0)
 

_iand()

def _iand (   self,   bs  )

protected

Definition at line 2243 of file bitstring.py.

    def _iand(self, bs):
        return self._inplace_logical_helper(bs, operator.iand)
 

_ilshift()

def _ilshift (   self,   n  )

protected

Shift bits by n to the left in place. Return self.

Definition at line 2196 of file bitstring.py.

    def _ilshift(self, n):
        """Shift bits by n to the left in place. Return self."""
        assert 0 < n <= self.len
        self._append(Bits(n))
        self._truncatestart(n)
        return self
 

_imul()

def _imul (   self,   n  )

protected

Concatenate n copies of self in place. Return self.

Definition at line 2210 of file bitstring.py.

    def _imul(self, n):
        """Concatenate n copies of self in place. Return self."""
        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
 

_init_with_token()

def _init_with_token (   cls,   name,   token_length,   value  )

protected

Definition at line 1214 of file bitstring.py.

    def _init_with_token(cls, name, token_length, value):
        if token_length is not None:
            token_length = int(token_length)
        if token_length == 0:
            return cls()
        # For pad token just return the length in zero bits
        if name == 'pad':
            return cls(token_length)
 
        if value is None:
            if token_length is None:
                error = "Token has no value ({0}=???).".format(name)
            else:
                error = "Token has no value ({0}:{1}=???).".format(name, token_length)
            raise ValueError(error)
        try:
            b = cls(**{_tokenname_to_initialiser[name]: value})
        except KeyError:
            if name in ('se', 'ue', 'sie', 'uie'):
                b = cls(**{name: int(value)})
            elif name in ('uint', 'int', 'uintbe', 'intbe', 'uintle', 'intle', 'uintne', 'intne'):
                b = cls(**{name: int(value), 'length': token_length})
            elif name in ('float', 'floatbe', 'floatle', 'floatne'):
                b = cls(**{name: float(value), 'length': token_length})
            elif name == 'bool':
                if value in (1, 'True', '1'):
                    b = cls(bool=True)
                elif value in (0, 'False', '0'):
                    b = cls(bool=False)
                else:
                    raise CreationError("bool token can only be 'True' or 'False'.")
            else:
                raise CreationError("Can't parse token name {0}.", name)
        if token_length is not None and b.len != token_length:
            msg = "Token with length {0} packed with value of length {1} ({2}:{3}={4})."
            raise CreationError(msg, token_length, b.len, name, token_length, value)
        return b
 

_initialise()

def _initialise (   self,   auto,   length,   offset, **  kwargs  )

protected

Definition at line 810 of file bitstring.py.

    def _initialise(self, auto, length, offset, **kwargs):
        if length is not None and length < 0:
            raise CreationError("bitstring length cannot be negative.")
        if offset is not None and offset < 0:
            raise CreationError("offset must be >= 0.")
        if auto is not None:
            self._initialise_from_auto(auto, length, offset)
            return
        if not kwargs:
            # No initialisers, so initialise with nothing or zero bits
            if length is not None and length != 0:
                data = bytearray((length + 7) // 8)
                self._setbytes_unsafe(data, length, 0)
                return
            self._setbytes_unsafe(bytearray(0), 0, 0)
            return
        k, v = kwargs.popitem()
        try:
            init_without_length_or_offset[k](self, v)
            if length is not None or offset is not None:
                raise CreationError("Cannot use length or offset with this initialiser.")
        except KeyError:
            try:
                init_with_length_only[k](self, v, length)
                if offset is not None:
                    raise CreationError("Cannot use offset with this initialiser.")
            except KeyError:
                if offset is None:
                    offset = 0
                try:
                    init_with_length_and_offset[k](self, v, length, offset)
                except KeyError:
                    raise CreationError("Unrecognised keyword '{0}' used to initialise.", k)
 

_initialise_from_auto()

def _initialise_from_auto (   self,   auto,   length,   offset  )

protected

Definition at line 844 of file bitstring.py.

    def _initialise_from_auto(self, auto, length, offset):
        if offset is None:
            offset = 0
        self._setauto(auto, length, offset)
        return
 

_inplace_logical_helper()

def _inplace_logical_helper (   self,   bs,   f  )

protected

Helper function containing most of the __ior__, __iand__, __ixor__ code.

Definition at line 2224 of file bitstring.py.

    def _inplace_logical_helper(self, bs, f):
        """Helper function containing most of the __ior__, __iand__, __ixor__ code."""
        # Give the two bitstrings the same offset (modulo 8)
        self_byteoffset, self_bitoffset = divmod(self._offset, 8)
        bs_byteoffset, bs_bitoffset = divmod(bs._offset, 8)
        if bs_bitoffset != self_bitoffset:
            if not self_bitoffset:
                bs._datastore = offsetcopy(bs._datastore, 0)
            else:
                self._datastore = offsetcopy(self._datastore, bs_bitoffset)
        a = self._datastore.rawbytes
        b = bs._datastore.rawbytes
        for i in xrange(len(a)):
            a[i] = f(a[i + self_byteoffset], b[i + bs_byteoffset])
        return self
 

_insert()

def _insert (   self,   bs,   pos  )

protected

Insert bs at pos.

Definition at line 2081 of file bitstring.py.

    def _insert(self, bs, pos):
        """Insert bs at 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()
 

_invert()

def _invert (   self,   pos  )

protected

Flip bit at pos 1<->0.

Definition at line 2184 of file bitstring.py.

    def _invert(self, pos):
        """Flip bit at pos 1<->0."""
        assert 0 <= pos < self.len
        self._datastore.invertbit(pos)
 

_invert_all()

def _invert_all (   self )

protected

Invert every bit.

Definition at line 2189 of file bitstring.py.

    def _invert_all(self):
        """Invert every bit."""
        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))
 

_ior()

def _ior (   self,   bs  )

protected

Definition at line 2240 of file bitstring.py.

    def _ior(self, bs):
        return self._inplace_logical_helper(bs, operator.ior)
 

_irshift()

def _irshift (   self,   n  )

protected

Shift bits by n to the right in place. Return self.

Definition at line 2203 of file bitstring.py.

    def _irshift(self, n):
        """Shift bits by n to the right in place. Return self."""
        assert 0 < n <= self.len
        self._prepend(Bits(n))
        self._truncateend(n)
        return self
 

_ixor()

def _ixor (   self,   bs  )

protected

Definition at line 2246 of file bitstring.py.

    def _ixor(self, bs):
        return self._inplace_logical_helper(bs, operator.xor)
 

_overwrite()

def _overwrite (   self,   bs,   pos  )

protected

Overwrite with bs at pos.

Definition at line 2102 of file bitstring.py.

    def _overwrite(self, bs, pos):
        """Overwrite with bs at 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()
 

_prepend()

def _prepend (   self,   bs  )

protected

Prepend a bitstring to the current bitstring.

Definition at line 2039 of file bitstring.py.

    def _prepend(self, bs):
        """Prepend a bitstring to the current bitstring."""
        self._datastore._prependstore(bs._datastore)
 

_readbin()

def _readbin (   self,   length,   start  )

protected

Read bits and interpret as a binary string.

Definition at line 1855 of file bitstring.py.

    def _readbin(self, length, start):
        """Read bits and interpret as a binary string."""
        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]
 

_readbits()

def _readbits (   self,   length,   start  )

protected

Read some bits from the bitstring and return newly constructed bitstring.

Definition at line 2249 of file bitstring.py.

    def _readbits(self, length, start):
        """Read some bits from the bitstring and return newly constructed bitstring."""
        return self._slice(start, start + length)
 

_readbool()

def _readbool (   self,   pos  )

protected

Definition at line 1831 of file bitstring.py.

    def _readbool(self, pos):
        return self[pos], pos + 1
 

_readbytes()

def _readbytes (   self,   length,   start  )

protected

Read bytes and return them. Note that length is in bits.

Definition at line 1346 of file bitstring.py.

    def _readbytes(self, length, start):
        """Read bytes and return them. Note that length is in bits."""
        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()
 

_readfloat()

def _readfloat (   self,   length,   start  )

protected

Read bits and interpret as a float.

Definition at line 1568 of file bitstring.py.

    def _readfloat(self, length, start):
        """Read bits and interpret as a float."""
        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)
 

_readfloatle()

def _readfloatle (   self,   length,   start  )

protected

Read bits and interpret as a little-endian float.

Definition at line 1606 of file bitstring.py.

    def _readfloatle(self, length, start):
        """Read bits and interpret as a little-endian float."""
        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)
 

_readhex()

def _readhex (   self,   length,   start  )

protected

Read bits and interpret as a hex string.

Definition at line 1928 of file bitstring.py.

    def _readhex(self, length, start):
        """Read bits and interpret as a hex string."""
        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
 

_readint()

def _readint (   self,   length,   start  )

protected

Read bits and interpret as a signed int

Definition at line 1444 of file bitstring.py.

    def _readint(self, length, start):
        """Read bits and interpret as a signed int"""
        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
 

_readintbe()

def _readintbe (   self,   length,   start  )

protected

Read bits and interpret as a big-endian signed int.

Definition at line 1483 of file bitstring.py.

    def _readintbe(self, length, start):
        """Read bits and interpret as a big-endian signed int."""
        if length % 8:
            raise InterpretError("Big-endian integers must be whole-byte. "
                                 "Length = {0} bits.", length)
        return self._readint(length, start)
 

_readintle()

def _readintle (   self,   length,   start  )

protected

Read bits and interpret as a little-endian signed int.

Definition at line 1539 of file bitstring.py.

    def _readintle(self, length, start):
        """Read bits and interpret as a little-endian signed int."""
        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
 

_readlist()

def _readlist (   self,   fmt,   pos, **  kwargs  )

protected

Definition at line 2288 of file bitstring.py.

    def _readlist(self, fmt, pos, **kwargs):
        tokens = []
        stretchy_token = None
        if isinstance(fmt, basestring):
            fmt = [fmt]
        # Not very optimal this, but replace integers with 'bits' tokens
        # TODO: optimise
        for i, f in enumerate(fmt):
            if isinstance(f, numbers.Integral):
                fmt[i] = "bits:{0}".format(f)
        for f_item in fmt:
            stretchy, tkns = tokenparser(f_item, tuple(sorted(kwargs.keys())))
            if stretchy:
                if stretchy_token:
                    raise Error("It's not possible to have more than one 'filler' token.")
                stretchy_token = stretchy
            tokens.extend(tkns)
        if not stretchy_token:
            lst = []
            for name, length, _ in tokens:
                if length in kwargs:
                    length = kwargs[length]
                    if name == 'bytes':
                        length *= 8
                if name in kwargs and length is None:
                    # Using default 'uint' - the name is really the length.
                    value, pos = self._readtoken('uint', pos, kwargs[name])
                    lst.append(value)
                    continue
                value, pos = self._readtoken(name, pos, length)
                if value is not None:  # Don't append pad tokens
                    lst.append(value)
            return lst, pos
        stretchy_token = False
        bits_after_stretchy_token = 0
        for token in tokens:
            name, length, _ = token
            if length in kwargs:
                length = kwargs[length]
                if name == 'bytes':
                    length *= 8
            if name in kwargs and length is None:
                # Default 'uint'.
                length = kwargs[name]
            if stretchy_token:
                if name in ('se', 'ue', 'sie', 'uie'):
                    raise Error("It's not possible to parse a variable"
                                "length token after a 'filler' token.")
                else:
                    if length is None:
                        raise Error("It's not possible to have more than "
                                    "one 'filler' token.")
                    bits_after_stretchy_token += length
            if length is None and name not in ('se', 'ue', 'sie', 'uie'):
                assert not stretchy_token
                stretchy_token = token
        bits_left = self.len - pos
        return_values = []
        for token in tokens:
            name, length, _ = token
            if token is stretchy_token:
                # Set length to the remaining bits
                length = max(bits_left - bits_after_stretchy_token, 0)
            if length in kwargs:
                length = kwargs[length]
                if name == 'bytes':
                    length *= 8
            if name in kwargs and length is None:
                # Default 'uint'
                length = kwargs[name]
            if length is not None:
                bits_left -= length
            value, pos = self._readtoken(name, pos, length)
            if value is not None:
                return_values.append(value)
        return return_values, pos
 

_readoct()

def _readoct (   self,   length,   start  )

protected

Read bits and interpret as an octal string.

Definition at line 1891 of file bitstring.py.

    def _readoct(self, length, start):
        """Read bits and interpret as an octal string."""
        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
 

_readse()

def _readse (   self,   pos  )

protected

Return interpretation of next bits as a signed exponential-Golomb code.

Advances position to after the read code.

Raises ReadError if the end of the bitstring is encountered while
reading the code.

Definition at line 1712 of file bitstring.py.

    def _readse(self, pos):
        """Return interpretation of next bits as a signed exponential-Golomb code.
 
        Advances position to after the read code.
 
        Raises ReadError if the end of the bitstring is encountered while
        reading the code.
 
        """
        codenum, pos = self._readue(pos)
        m = (codenum + 1) // 2
        if not codenum % 2:
            return -m, pos
        else:
            return m, pos
 

_readsie()

def _readsie (   self,   pos  )

protected

Return interpretation of next bits as a signed interleaved exponential-Golomb code.

Advances position to after the read code.

Raises ReadError if the end of the bitstring is encountered while
reading the code.

Definition at line 1795 of file bitstring.py.

    def _readsie(self, pos):
        """Return interpretation of next bits as a signed interleaved exponential-Golomb code.
 
        Advances position to after the read code.
 
        Raises ReadError if the end of the bitstring is encountered while
        reading the code.
 
        """
        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.")
 

_readtoken()

def _readtoken (   self,   name,   pos,   length  )

protected

Reads a token from the bitstring and returns the result.

Definition at line 2019 of file bitstring.py.

    def _readtoken(self, name, pos, length):
        """Reads a token from the bitstring and returns the result."""
        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)
 

_readue()

def _readue (   self,   pos  )

protected

Return interpretation of next bits as unsigned exponential-Golomb code.

Raises ReadError if the end of the bitstring is encountered while
reading the code.

Definition at line 1651 of file bitstring.py.

    def _readue(self, pos):
        """Return interpretation of next bits as unsigned exponential-Golomb code.
 
        Raises ReadError if the end of the bitstring is encountered while
        reading the code.
 
        """
        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
 

_readuie()

def _readuie (   self,   pos  )

protected

Return interpretation of next bits as unsigned interleaved exponential-Golomb code.

Raises ReadError if the end of the bitstring is encountered while
reading the code.

Definition at line 1739 of file bitstring.py.

    def _readuie(self, pos):
        """Return interpretation of next bits as unsigned interleaved exponential-Golomb code.
 
        Raises ReadError if the end of the bitstring is encountered while
        reading the code.
 
        """
        try:
            codenum = 1
            while not self[pos]:
                pos += 1
                codenum <<= 1
                codenum += self[pos]
                pos += 1
            pos += 1
        except IndexError:
            raise ReadError("Read off end of bitstring trying to read code.")
        codenum -= 1
        return codenum, pos
 

_readuint()

def _readuint (   self,   length,   start  )

protected

Read bits and interpret as an unsigned int.

Definition at line 1399 of file bitstring.py.

    def _readuint(self, length, start):
        """Read bits and interpret as an unsigned int."""
        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
 

_readuintbe()

def _readuintbe (   self,   length,   start  )

protected

Read bits and interpret as a big-endian unsigned int.

Definition at line 1465 of file bitstring.py.

    def _readuintbe(self, length, start):
        """Read bits and interpret as a big-endian unsigned int."""
        if length % 8:
            raise InterpretError("Big-endian integers must be whole-byte. "
                                 "Length = {0} bits.", length)
        return self._readuint(length, start)
 

_readuintle()

def _readuintle (   self,   length,   start  )

protected

Read bits and interpret as a little-endian unsigned int.

Definition at line 1501 of file bitstring.py.

    def _readuintle(self, length, start):
        """Read bits and interpret as a little-endian unsigned int."""
        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
 

_reverse()

def _reverse (   self )

protected

Reverse all bits in-place.

Definition at line 2043 of file bitstring.py.

    def _reverse(self):
        """Reverse all bits in-place."""
        # 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)
 

_reversebytes()

def _reversebytes (   self,   start,   end  )

protected

Reverse bytes in-place.

Definition at line 2161 of file bitstring.py.

    def _reversebytes(self, start, end):
        """Reverse bytes in-place."""
        # 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)
 

_set()

def _set (   self,   pos  )

protected

Set bit at pos to 1.

Definition at line 2174 of file bitstring.py.

    def _set(self, pos):
        """Set bit at pos to 1."""
        assert 0 <= pos < self.len
        self._datastore.setbit(pos)
 

_setauto()

def _setauto (   self,   s,   length,   offset  )

protected

Set bitstring from a bitstring, file, bool, integer, array, iterable or string.

Definition at line 1256 of file bitstring.py.

    def _setauto(self, s, length, offset):
        """Set bitstring from a bitstring, file, bool, integer, array, iterable or string."""
        # 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.abc.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)))
 

_setbin_safe()

def _setbin_safe (   self,   binstring  )

protected

Reset the bitstring to the value given in binstring.

Definition at line 1834 of file bitstring.py.

    def _setbin_safe(self, binstring):
        """Reset the bitstring to the value given in binstring."""
        binstring = tidy_input_string(binstring)
        # remove any 0b if present
        binstring = binstring.replace('0b', '')
        self._setbin_unsafe(binstring)
 

_setbin_unsafe()

def _setbin_unsafe (   self,   binstring  )

protected

Same as _setbin_safe, but input isn't sanity checked. binstring mustn't start with '0b'.

Definition at line 1841 of file bitstring.py.

    def _setbin_unsafe(self, binstring):
        """Same as _setbin_safe, but input isn't sanity checked. binstring mustn't start with '0b'."""
        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)
 

_setbool()

def _setbool (   self,   value  )

protected

Definition at line 1815 of file bitstring.py.

    def _setbool(self, value):
        # We deliberately don't want to have implicit conversions to bool here.
        # If we did then it would be difficult to deal with the 'False' string.
        if value in (1, 'True'):
            self._setbytes_unsafe(bytearray(b'\x80'), 1, 0)
        elif value in (0, 'False'):
            self._setbytes_unsafe(bytearray(b'\x00'), 1, 0)
        else:
            raise CreationError('Cannot initialise boolean with {0}.', value)
 

_setbytes_safe()

def _setbytes_safe (   self,   data,   length = None,   offset = 0  )

protected

Set the data from a string.

Definition at line 1325 of file bitstring.py.

    def _setbytes_safe(self, data, length=None, offset=0):
        """Set the data from a string."""
        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)
 

_setbytes_unsafe()

def _setbytes_unsafe (   self,   data,   length,   offset  )

protected

Unchecked version of _setbytes_safe.

Definition at line 1341 of file bitstring.py.

    def _setbytes_unsafe(self, data, length, offset):
        """Unchecked version of _setbytes_safe."""
        self._datastore = ByteStore(data[:], length, offset)
        assert self._assertsanity()
 

_setfile()

def _setfile (   self,   filename,   length,   offset  )

protected

Use file as source of bits.

Definition at line 1310 of file bitstring.py.

    def _setfile(self, filename, length, offset):
        """Use file as source of bits."""
        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)
 

_setfloat()

def _setfloat (   self,   f,   length = None  )

protected

Definition at line 1552 of file bitstring.py.

    def _setfloat(self, f, 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 a "
                                "float initialiser.")
        if length == 32:
            b = struct.pack('>f', f)
        elif length == 64:
            b = struct.pack('>d', f)
        else:
            raise CreationError("floats can only be 32 or 64 bits long, "
                                "not {0} bits", length)
        self._setbytes_unsafe(bytearray(b), length, 0)
 

_setfloatle()

def _setfloatle (   self,   f,   length = None  )

protected

Definition at line 1590 of file bitstring.py.

    def _setfloatle(self, f, 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 a "
                                "float initialiser.")
        if length == 32:
            b = struct.pack('<f', f)
        elif length == 64:
            b = struct.pack('<d', f)
        else:
            raise CreationError("floats can only be 32 or 64 bits long, "
                                "not {0} bits", length)
        self._setbytes_unsafe(bytearray(b), length, 0)
 

_sethex()

def _sethex (   self,   hexstring  )

protected

Reset the bitstring to have the value given in hexstring.

Definition at line 1910 of file bitstring.py.

    def _sethex(self, hexstring):
        """Reset the bitstring to have the value given in 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))  # noqa
        except ValueError:
            raise CreationError("Invalid symbol in hex initialiser.")
        self._setbytes_unsafe(data, length * 4, 0)
 

_setint()

def _setint (   self,   int_,   length = None  )

protected

Reset the bitstring to have given signed int interpretation.

Definition at line 1421 of file bitstring.py.

    def _setint(self, int_, length=None):
        """Reset the bitstring to have given signed int interpretation."""
        # 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()
 

_setintbe()

def _setintbe (   self,   intbe,   length = None  )

protected

Set bitstring to a big-endian signed int interpretation.

Definition at line 1476 of file bitstring.py.

    def _setintbe(self, intbe, length=None):
        """Set bitstring to a big-endian signed int interpretation."""
        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)
 

_setintle()

def _setintle (   self,   intle,   length = None  )

protected

Definition at line 1532 of file bitstring.py.

    def _setintle(self, intle, length=None):
        if length is not None and length % 8 != 0:
            raise CreationError("Little-endian integers must be whole-byte. "
                                "Length = {0} bits.", length)
        self._setint(intle, length)
        self._reversebytes(0, self.len)
 

_setoct()

def _setoct (   self,   octstring  )

protected

Reset the bitstring to have the value given in octstring.

Definition at line 1876 of file bitstring.py.

    def _setoct(self, octstring):
        """Reset the bitstring to have the value given in 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))
 

_setse()

def _setse (   self,   i  )

protected

Initialise bitstring with signed exponential-Golomb code for integer i.

Definition at line 1690 of file bitstring.py.

    def _setse(self, i):
        """Initialise bitstring with signed exponential-Golomb code for integer i."""
        if i > 0:
            u = (i * 2) - 1
        else:
            u = -2 * i
        self._setue(u)
 

_setsie()

def _setsie (   self,   i  )

protected

Initialise bitstring with signed interleaved exponential-Golomb code for integer i.

Definition at line 1773 of file bitstring.py.

    def _setsie(self, i):
        """Initialise bitstring with signed interleaved exponential-Golomb code for integer i."""
        if not i:
            self._setbin_unsafe('1')
        else:
            self._setuie(abs(i))
            self._append(Bits([i < 0]))
 

_setue()

def _setue (   self,   i  )

protected

Initialise bitstring with unsigned exponential-Golomb code for integer i.

Raises CreationError if i < 0.

Definition at line 1629 of file bitstring.py.

    def _setue(self, i):
        """Initialise bitstring with unsigned exponential-Golomb code for integer i.
 
        Raises CreationError if i < 0.
 
        """
        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)
 

_setuie()

def _setuie (   self,   i  )

protected

Initialise bitstring with unsigned interleaved exponential-Golomb code for integer i.

Raises CreationError if i < 0.

Definition at line 1728 of file bitstring.py.

    def _setuie(self, i):
        """Initialise bitstring with unsigned interleaved exponential-Golomb code for integer i.
 
        Raises CreationError if i < 0.
 
        """
        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')
 

_setuint()

def _setuint (   self,   uint,   length = None  )

protected

Reset the bitstring to have given unsigned int interpretation.

Definition at line 1362 of file bitstring.py.

    def _setuint(self, uint, length=None):
        """Reset the bitstring to have given unsigned int interpretation."""
        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)
 

_setuintbe()

def _setuintbe (   self,   uintbe,   length = None  )

protected

Set the bitstring to a big-endian unsigned int interpretation.

Definition at line 1458 of file bitstring.py.

    def _setuintbe(self, uintbe, length=None):
        """Set the bitstring to a big-endian unsigned int interpretation."""
        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)
 

_setuintle()

def _setuintle (   self,   uintle,   length = None  )

protected

Definition at line 1494 of file bitstring.py.

    def _setuintle(self, uintle, length=None):
        if length is not None and length % 8 != 0:
            raise CreationError("Little-endian integers must be whole-byte. "
                                "Length = {0} bits.", length)
        self._setuint(uintle, length)
        self._reversebytes(0, self.len)
 

_slice()

def _slice (   self,   start,   end  )

protected

Used internally to get a slice, without error checking.

Definition at line 2008 of file bitstring.py.

    def _slice(self, start, end):
        """Used internally to get a slice, without error checking."""
        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
 

_truncateend()

def _truncateend (   self,   bits  )

protected

Truncate bits from the end of the bitstring.

Definition at line 2068 of file bitstring.py.

    def _truncateend(self, bits):
        """Truncate bits from the end of the bitstring."""
        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()
 

_truncatestart()

def _truncatestart (   self,   bits  )

protected

Truncate bits from the start of the bitstring.

Definition at line 2055 of file bitstring.py.

    def _truncatestart(self, bits):
        """Truncate bits from the start of the bitstring."""
        assert 0 <= bits <= self.len
        if not bits:
            return
        if bits == self.len:
            self._clear()
            return
        bytepos, offset = divmod(self._offset + bits, 8)
        self._setbytes_unsafe(self._datastore.getbyteslice(bytepos, self._datastore.bytelength), self.len - bits,
                              offset)
        assert self._assertsanity()
 

_unset()

def _unset (   self,   pos  )

protected

Set bit at pos to 0.

Definition at line 2179 of file bitstring.py.

    def _unset(self, pos):
        """Set bit at pos to 0."""
        assert 0 <= pos < self.len
        self._datastore.unsetbit(pos)
 

_validate_slice()

def _validate_slice (   self,   start,   end  )

protected

Validate start and end and return them as positive bit positions.

Definition at line 2253 of file bitstring.py.

    def _validate_slice(self, start, end):
        """Validate start and end and return them as positive bit positions."""
        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
 

all()

def all	(		self,
			value,
			pos = None
	)

Return True if one or many bits are all set to value.

value -- If value is True then checks for bits set to 1, otherwise
         checks for bits set to 0.
pos -- An iterable of bit positions. Negative numbers are treated in
       the same way as slice indices. Defaults to the whole bitstring.

Definition at line 2732 of file bitstring.py.

    def all(self, value, pos=None):
        """Return True if one or many bits are all set to value.
 
        value -- If value is True then checks for bits set to 1, otherwise
                 checks for bits set to 0.
        pos -- An iterable of bit positions. Negative numbers are treated in
               the same way as slice indices. Defaults to the whole bitstring.
 
        """
        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
 

any()

def any	(		self,
			value,
			pos = None
	)

Return True if any of one or many bits are set to value.

value -- If value is True then checks for bits set to 1, otherwise
         checks for bits set to 0.
pos -- An iterable of bit positions. Negative numbers are treated in
       the same way as slice indices. Defaults to the whole bitstring.

Definition at line 2754 of file bitstring.py.

    def any(self, value, pos=None):
        """Return True if any of one or many bits are set to value.
 
        value -- If value is True then checks for bits set to 1, otherwise
                 checks for bits set to 0.
        pos -- An iterable of bit positions. Negative numbers are treated in
               the same way as slice indices. Defaults to the whole bitstring.
 
        """
        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 self._datastore.getbit(p) is value:
                return True
        return False
 

count()

def count	(		self,
			value
	)

Return count of total number of either zero or one bits.

value -- If True then bits set to 1 are counted, otherwise bits set
         to 0 are counted.

>>> Bits('0xef').count(1)
7

Definition at line 2776 of file bitstring.py.

    def count(self, value):
        """Return count of total number of either zero or one bits.
 
        value -- If True then bits set to 1 are counted, otherwise bits set
                 to 0 are counted.
 
        >>> Bits('0xef').count(1)
        7
 
        """
        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
 

cut()

def cut	(		self,
			bits,
			start = None,
			end = None,
			count = None
	)

Return bitstring generator by cutting into bits sized chunks.

bits -- The size in bits of the bitstring chunks to generate.
start -- The bit position to start the first cut. Defaults to 0.
end -- The bit position one past the last bit to use in the cut.
       Defaults to self.len.
count -- If specified then at most count items are generated.
         Default is to cut as many times as possible.

Definition at line 2553 of file bitstring.py.

    def cut(self, bits, start=None, end=None, count=None):
        """Return bitstring generator by cutting into bits sized chunks.
 
        bits -- The size in bits of the bitstring chunks to generate.
        start -- The bit position to start the first cut. Defaults to 0.
        end -- The bit position one past the last bit to use in the cut.
               Defaults to self.len.
        count -- If specified then at most count items are generated.
                 Default is to cut as many times as possible.
 
        """
        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
 

endswith()

def endswith	(		self,
			suffix,
			start = None,
			end = None
	)

Return whether the current bitstring ends with suffix.

suffix -- The bitstring to search for.
start -- The bit position to start from. Defaults to 0.
end -- The bit position to end at. Defaults to self.len.

Definition at line 2717 of file bitstring.py.

    def endswith(self, suffix, start=None, end=None):
        """Return whether the current bitstring ends with suffix.
 
        suffix -- The bitstring to search for.
        start -- The bit position to start from. Defaults to 0.
        end -- The bit position to end at. Defaults to self.len.
 
        """
        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
 

find()

def find	(		self,
			bs,
			start = None,
			end = None,
			bytealigned = None
	)

Find first occurrence of substring bs.

Returns a single item tuple with the bit position if found, or an
empty tuple if not found. The bit position (pos property) will
also be set to the start of the substring if it is found.

bs -- The bitstring to find.
start -- The bit position to start the search. Defaults to 0.
end -- The bit position one past the last bit to search.
       Defaults to self.len.
bytealigned -- If True the bitstring will only be
               found on byte boundaries.

Raises ValueError if bs is empty, if start < 0, if end > self.len or
if end < start.

>>> BitArray('0xc3e').find('0b1111')
(6,)

Definition at line 2424 of file bitstring.py.

    def find(self, bs, start=None, end=None, bytealigned=None):
        """Find first occurrence of substring bs.
 
        Returns a single item tuple with the bit position if found, or an
        empty tuple if not found. The bit position (pos property) will
        also be set to the start of the substring if it is found.
 
        bs -- The bitstring to find.
        start -- The bit position to start the search. Defaults to 0.
        end -- The bit position one past the last bit to search.
               Defaults to self.len.
        bytealigned -- If True the bitstring will only be
                       found on byte boundaries.
 
        Raises ValueError if bs is empty, if start < 0, if end > self.len or
        if end < start.
 
        >>> BitArray('0xc3e').find('0b1111')
        (6,)
 
        """
        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
 

findall()

def findall	(		self,
			bs,
			start = None,
			end = None,
			count = None,
			bytealigned = None
	)

Find all occurrences of bs. Return generator of bit positions.

bs -- The bitstring to find.
start -- The bit position to start the search. Defaults to 0.
end -- The bit position one past the last bit to search.
       Defaults to self.len.
count -- The maximum number of occurrences to find.
bytealigned -- If True the bitstring will only be found on
               byte boundaries.

Raises ValueError if bs is empty, if start < 0, if end > self.len or
if end < start.

Note that all occurrences of bs are found, even if they overlap.

Definition at line 2462 of file bitstring.py.

    def findall(self, bs, start=None, end=None, count=None, bytealigned=None):
        """Find all occurrences of bs. Return generator of bit positions.
 
        bs -- The bitstring to find.
        start -- The bit position to start the search. Defaults to 0.
        end -- The bit position one past the last bit to search.
               Defaults to self.len.
        count -- The maximum number of occurrences to find.
        bytealigned -- If True the bitstring will only be found on
                       byte boundaries.
 
        Raises ValueError if bs is empty, if start < 0, if end > self.len or
        if end < start.
 
        Note that all occurrences of bs are found, even if they overlap.
 
        """
        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
 

join()

def join	(		self,
			sequence
	)

Return concatenation of bitstrings joined by self.

sequence -- A sequence of bitstrings.

Definition at line 2637 of file bitstring.py.

    def join(self, sequence):
        """Return concatenation of bitstrings joined by self.
 
        sequence -- A sequence of bitstrings.
 
        """
        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
 

rfind()

def rfind	(		self,
			bs,
			start = None,
			end = None,
			bytealigned = None
	)

Find final occurrence of substring bs.

Returns a single item tuple with the bit position if found, or an
empty tuple if not found. The bit position (pos property) will
also be set to the start of the substring if it is found.

bs -- The bitstring to find.
start -- The bit position to end the reverse search. Defaults to 0.
end -- The bit position one past the first bit to reverse search.
       Defaults to self.len.
bytealigned -- If True the bitstring will only be found on byte
               boundaries.

Raises ValueError if bs is empty, if start < 0, if end > self.len or
if end < start.

Definition at line 2514 of file bitstring.py.

    def rfind(self, bs, start=None, end=None, bytealigned=None):
        """Find final occurrence of substring bs.
 
        Returns a single item tuple with the bit position if found, or an
        empty tuple if not found. The bit position (pos property) will
        also be set to the start of the substring if it is found.
 
        bs -- The bitstring to find.
        start -- The bit position to end the reverse search. Defaults to 0.
        end -- The bit position one past the first bit to reverse search.
               Defaults to self.len.
        bytealigned -- If True the bitstring will only be found on byte
                       boundaries.
 
        Raises ValueError if bs is empty, if start < 0, if end > self.len or
        if end < start.
 
        """
        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],)
 

split()

def split	(		self,
			delimiter,
			start = None,
			end = None,
			count = None,
			bytealigned = None
	)

Return bitstring generator by splittling using a delimiter.

The first item returned is the initial bitstring before the delimiter,
which may be an empty bitstring.

delimiter -- The bitstring used as the divider.
start -- The bit position to start the split. Defaults to 0.
end -- The bit position one past the last bit to use in the split.
       Defaults to self.len.
count -- If specified then at most count items are generated.
         Default is to split as many times as possible.
bytealigned -- If True splits will only occur on byte boundaries.

Raises ValueError if the delimiter is empty.

Definition at line 2580 of file bitstring.py.

              bytealigned=None):
        """Return bitstring generator by splittling using a delimiter.
 
        The first item returned is the initial bitstring before the delimiter,
        which may be an empty bitstring.
 
        delimiter -- The bitstring used as the divider.
        start -- The bit position to start the split. Defaults to 0.
        end -- The bit position one past the last bit to use in the split.
               Defaults to self.len.
        count -- If specified then at most count items are generated.
                 Default is to split as many times as possible.
        bytealigned -- If True splits will only occur on byte boundaries.
 
        Raises ValueError if the delimiter is empty.
 
        """
        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
 

startswith()

def startswith	(		self,
			prefix,
			start = None,
			end = None
	)

Return whether the current bitstring starts with prefix.

prefix -- The bitstring to search for.
start -- The bit position to start from. Defaults to 0.
end -- The bit position to end at. Defaults to self.len.

Definition at line 2702 of file bitstring.py.

    def startswith(self, prefix, start=None, end=None):
        """Return whether the current bitstring starts with prefix.
 
        prefix -- The bitstring to search for.
        start -- The bit position to start from. Defaults to 0.
        end -- The bit position to end at. Defaults to self.len.
 
        """
        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
 

tobytes()

def tobytes

(

self

)

Return the bitstring as bytes, padding with zero bits if needed.

Up to seven zero bits will be added at the end to byte align.

Definition at line 2655 of file bitstring.py.

    def tobytes(self):
        """Return the bitstring as bytes, padding with zero bits if needed.
 
        Up to seven zero bits will be added at the end to byte align.
 
        """
        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)
 

tofile()

def tofile	(		self,
			f
	)

Write the bitstring to a file object, padding with zero bits if needed.

Up to seven zero bits will be added at the end to byte align.

Definition at line 2668 of file bitstring.py.

    def tofile(self, f):
        """Write the bitstring to a file object, padding with zero bits if needed.
 
        Up to seven zero bits will be added at the end to byte align.
 
        """
        # 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())
 

unpack()

def unpack	(		self,
			fmt,
		**	kwargs
	)

Interpret the whole bitstring using fmt and return list.

fmt -- A single string or a list of strings with comma separated tokens
       describing how to interpret the bits in the bitstring. Items
       can also be integers, for reading new bitstring of the given length.
kwargs -- A dictionary or keyword-value pairs - the keywords used in the
          format string will be replaced with their given value.

Raises ValueError if the format is not understood. If not enough bits
are available then all bits to the end of the bitstring will be used.

See the docstring for 'read' for token examples.

Definition at line 2271 of file bitstring.py.

    def unpack(self, fmt, **kwargs):
        """Interpret the whole bitstring using fmt and return list.
 
        fmt -- A single string or a list of strings with comma separated tokens
               describing how to interpret the bits in the bitstring. Items
               can also be integers, for reading new bitstring of the given length.
        kwargs -- A dictionary or keyword-value pairs - the keywords used in the
                  format string will be replaced with their given value.
 
        Raises ValueError if the format is not understood. If not enough bits
        are available then all bits to the end of the bitstring will be used.
 
        See the docstring for 'read' for token examples.
 
        """
        return self._readlist(fmt, 0, **kwargs)[0]
 

Member Data Documentation

__bool__

def __bool__ = __nonzero__

staticprivate

Definition at line 1204 of file bitstring.py.

__slots__

tuple __slots__ = ('_datastore')

staticprivate

Definition at line 740 of file bitstring.py.

_datastore

_datastore

protected

Definition at line 1254 of file bitstring.py.

_getfloatne

def _getfloatne = _getfloatle

staticprotected

Definition at line 2803 of file bitstring.py.

_getintne

def _getintne = _getintle

staticprotected

Definition at line 2809 of file bitstring.py.

_getuintne

def _getuintne = _getuintle

staticprotected

Definition at line 2806 of file bitstring.py.

_pos

_pos

protected

Definition at line 1170 of file bitstring.py.

_readfloatne

def _readfloatne = _readfloatle

staticprotected

Definition at line 2802 of file bitstring.py.

_readintne

def _readintne = _readintle

staticprotected

Definition at line 2808 of file bitstring.py.

_readuintne

def _readuintne = _readuintle

staticprotected

Definition at line 2805 of file bitstring.py.

_setfloatne

def _setfloatne = _setfloatle

staticprotected

Definition at line 2801 of file bitstring.py.

_setintne

def _setintne = _setintle

staticprotected

Definition at line 2807 of file bitstring.py.

_setuintne

def _setuintne = _setuintle

staticprotected

Definition at line 2804 of file bitstring.py.

else

else :

static

Definition at line 2810 of file bitstring.py.

Property Documentation

_offset

property _offset = property(_getoffset)

staticprotected

Definition at line 2821 of file bitstring.py.

bin

property bin

static

Initial value:

=  property(_getbin,
                   doc=)

Definition at line 2835 of file bitstring.py.

bool

property bool

static

Initial value:

=  property(_getbool,
                    doc=)

Definition at line 2829 of file bitstring.py.

bytes

property bytes

static

Initial value:

=  property(_getbytes,
                     doc=)

Definition at line 2841 of file bitstring.py.

float

property float

static

Initial value:

=  property(_getfloat,
                     doc=)

Definition at line 2850 of file bitstring.py.

floatbe

property floatbe

static

Initial value:

=  property(_getfloat,
                       doc=)

Definition at line 2859 of file bitstring.py.

floatle

property floatle

static

Initial value:

=  property(_getfloatle,
                       doc=)

Definition at line 2868 of file bitstring.py.

floatne

property floatne

static

Initial value:

=  property(_getfloatne,
                       doc=)

Definition at line 2877 of file bitstring.py.

hex

property hex

static

Initial value:

=  property(_gethex,
                   doc=)

Definition at line 2832 of file bitstring.py.

int

property int

static

Initial value:

=  property(_getint,
                   doc=)

Definition at line 2844 of file bitstring.py.

intbe

property intbe

static

Initial value:

=  property(_getintbe,
                     doc=)

Definition at line 2853 of file bitstring.py.

intle

property intle

static

Initial value:

=  property(_getintle,
                     doc=)

Definition at line 2862 of file bitstring.py.

intne

property intne

static

Initial value:

=  property(_getintne,
                     doc=)

Definition at line 2871 of file bitstring.py.

len

property len

static

Initial value:

=  property(_getlength,
                   doc=)

Definition at line 2823 of file bitstring.py.

length

property length

static

Initial value:

=  property(_getlength,
                      doc=)

Definition at line 2826 of file bitstring.py.

oct

property oct

static

Initial value:

=  property(_getoct,
                   doc=)

Definition at line 2838 of file bitstring.py.

se

property se

static

Initial value:

=  property(_getse,
                  doc=)

Definition at line 2883 of file bitstring.py.

sie

property sie

static

Initial value:

=  property(_getsie,
                   doc=)

Definition at line 2889 of file bitstring.py.

ue

property ue

static

Initial value:

=  property(_getue,
                  doc=)

Definition at line 2880 of file bitstring.py.

uie

property uie

static

Initial value:

=  property(_getuie,
                   doc=)

Definition at line 2886 of file bitstring.py.

uint

property uint

static

Initial value:

=  property(_getuint,
                    doc=)

Definition at line 2847 of file bitstring.py.

uintbe

property uintbe

static

Initial value:

=  property(_getuintbe,
                      doc=)

Definition at line 2856 of file bitstring.py.

uintle

property uintle

static

Initial value:

=  property(_getuintle,
                      doc=)

Definition at line 2865 of file bitstring.py.

uintne

property uintne

static

Initial value:

=  property(_getuintne,
                      doc=)

Definition at line 2874 of file bitstring.py.

---

The documentation for this class was generated from the following file:

• trg/scripts/bitstring.py