Classes
class	BitArray

class	Bits

class	BitStream

class	ByteAlignError

class	ByteStore

class	ConstBitStream

class	ConstByteStore

class	CreationError

class	Error

class	InterpretError

class	MmapByteArray

class	ReadError

Functions
def	offsetcopy (s, newoffset)

def	equal (a, b)

def	tidy_input_string (s)

def	structparser (token)

def	tokenparser (fmt, keys=None, token_cache={})

def	expand_brackets (s)

def	pack (fmt, values, *kwargs)

Variables
string	__licence__

string	__version__ = "3.1.5"

string	__author__ = "Scott Griffiths"

	byteorder = sys.byteorder

bool	bytealigned = False

int	MAX_CHARS = 250

int	CACHE_SIZE = 1000

	BYTE_REVERSAL_DICT = dict()

	xrange = range

	basestring = str

int	LEADING_OCT_CHARS = len(oct(1)) - 1

tuple	INIT_NAMES

	TOKEN_RE

	DEFAULT_UINT = re.compile(r'(?P<len>[^=]+)?(=(?P<value>.*))?$', re.IGNORECASE)

	MULTIPLICATIVE_RE = re.compile(r'(?P<factor>.)\(?P<token>.+)')

	LITERAL_RE = re.compile(r'(?P<name>0(x\|o\|b))(?P<value>.+)', re.IGNORECASE)

	STRUCT_PACK_RE = re.compile(r'(?P<endian><\|>\|@)?(?P<fmt>(?:\d*[bBhHlLqQfd])+)$')

	STRUCT_SPLIT_RE = re.compile(r'\d*[bBhHlLqQfd]')

dictionary	REPLACEMENTS_BE

dictionary	REPLACEMENTS_LE

dictionary	PACK_CODE_SIZE

dictionary	_tokenname_to_initialiser

	BRACKET_RE = re.compile(r'(?P<factor>\d+)\*\(')

list	OCT_TO_BITS = ['{0:03b}'.format(i) for i in xrange(8)]

	BIT_COUNT = dict(zip(xrange(256), [bin(i).count('1') for i in xrange(256)]))

dictionary	name_to_read

dictionary	init_with_length_and_offset

dictionary	init_with_length_only

dictionary	init_without_length_or_offset

	ConstBitArray = Bits

	BitString = BitStream

list	__all__

Detailed Description

This package defines classes that simplify bit-wise creation, manipulation and
interpretation of data.

Classes:

Bits -- An immutable container for binary data.
BitArray -- A mutable container for binary data.
ConstBitStream -- An immutable container with streaming methods.
BitStream -- A mutable container with streaming methods.

                  Bits (base class)
                 /    \
 + mutating methods /      \ + streaming methods
               /        \
          BitArray   ConstBitStream
               \        /
                \      /
                 \    /
                BitStream

Functions:

pack -- Create a BitStream from a format string.

Exceptions:

Error -- Module exception base class.
CreationError -- Error during creation.
InterpretError -- Inappropriate interpretation of binary data.
ByteAlignError -- Whole byte position or length needed.
ReadError -- Reading or peeking past the end of a bitstring.

https://github.com/scott-griffiths/bitstring

Function Documentation

◆ equal()

def scripts.bitstring.equal	(	a,
		b
	)

Return True if ByteStores a == b.

Not part of public interface.

Definition at line 291 of file bitstring.py.

 def equal(a, b):
     """Return True if ByteStores a == b.
  
     Not part of public interface.
     """
     # We want to return False for inequality as soon as possible, which
     # means we get lots of special cases.
     # First the easy one - compare lengths:
     a_bitlength = a.bitlength
     b_bitlength = b.bitlength
     if a_bitlength != b_bitlength:
         return False
     if not a_bitlength:
         assert b_bitlength == 0
         return True
     # Make 'a' the one with the smaller offset
     if (a.offset % 8) > (b.offset % 8):
         a, b = b, a
     # and create some aliases
     a_bitoff = a.offset % 8
     b_bitoff = b.offset % 8
     a_byteoffset = a.byteoffset
     b_byteoffset = b.byteoffset
     a_bytelength = a.bytelength
     b_bytelength = b.bytelength
     da = a._rawarray
     db = b._rawarray
  
     # If they are pointing to the same data, they must be equal
     if da is db and a.offset == b.offset:
         return True
  
     if a_bitoff == b_bitoff:
         bits_spare_in_last_byte = 8 - (a_bitoff + a_bitlength) % 8
         if bits_spare_in_last_byte == 8:
             bits_spare_in_last_byte = 0
         # Special case for a, b contained in a single byte
         if a_bytelength == 1:
             a_val = ((da[a_byteoffset] << a_bitoff) & 0xff) >> (8 - a_bitlength)
             b_val = ((db[b_byteoffset] << b_bitoff) & 0xff) >> (8 - b_bitlength)
             return a_val == b_val
         # Otherwise check first byte
         if da[a_byteoffset] & (0xff >> a_bitoff) != db[b_byteoffset] & (0xff >> b_bitoff):
             return False
         # then everything up to the last
         b_a_offset = b_byteoffset - a_byteoffset
         for x in range(1 + a_byteoffset, a_byteoffset + a_bytelength - 1):
             if da[x] != db[b_a_offset + x]:
                 return False
         # and finally the last byte
         return (da[a_byteoffset + a_bytelength - 1] >> bits_spare_in_last_byte ==
                 db[b_byteoffset + b_bytelength - 1] >> bits_spare_in_last_byte)
  
     assert a_bitoff != b_bitoff
     # This is how much we need to shift a to the right to compare with b:
     shift = b_bitoff - a_bitoff
     # Special case for b only one byte long
     if b_bytelength == 1:
         assert a_bytelength == 1
         a_val = ((da[a_byteoffset] << a_bitoff) & 0xff) >> (8 - a_bitlength)
         b_val = ((db[b_byteoffset] << b_bitoff) & 0xff) >> (8 - b_bitlength)
         return a_val == b_val
     # Special case for a only one byte long
     if a_bytelength == 1:
         assert b_bytelength == 2
         a_val = ((da[a_byteoffset] << a_bitoff) & 0xff) >> (8 - a_bitlength)
         b_val = ((db[b_byteoffset] << 8) + db[b_byteoffset + 1]) << b_bitoff
         b_val &= 0xffff
         b_val >>= 16 - b_bitlength
         return a_val == b_val
  
     # Compare first byte of b with bits from first byte of a
     if (da[a_byteoffset] & (0xff >> a_bitoff)) >> shift != db[b_byteoffset] & (0xff >> b_bitoff):
         return False
     # Now compare every full byte of b with bits from 2 bytes of a
     for x in range(1, b_bytelength - 1):
         # Construct byte from 2 bytes in a to compare to byte in b
         b_val = db[b_byteoffset + x]
         a_val = ((da[a_byteoffset + x - 1] << 8) + da[a_byteoffset + x]) >> shift
         a_val &= 0xff
         if a_val != b_val:
             return False
  
     # Now check bits in final byte of b
     final_b_bits = (b.offset + b_bitlength) % 8
     if not final_b_bits:
         final_b_bits = 8
     b_val = db[b_byteoffset + b_bytelength - 1] >> (8 - final_b_bits)
     final_a_bits = (a.offset + a_bitlength) % 8
     if not final_a_bits:
         final_a_bits = 8
     if b.bytelength > a_bytelength:
         assert b_bytelength == a_bytelength + 1
         a_val = da[a_byteoffset + a_bytelength - 1] >> (8 - final_a_bits)
         a_val &= 0xff >> (8 - final_b_bits)
         return a_val == b_val
     assert a_bytelength == b_bytelength
     a_val = da[a_byteoffset + a_bytelength - 2] << 8
     a_val += da[a_byteoffset + a_bytelength - 1]
     a_val >>= (8 - final_a_bits)
     a_val &= 0xff >> (8 - final_b_bits)
     return a_val == b_val
  
  

◆ expand_brackets()

def scripts.bitstring.expand_brackets ( s )

Remove whitespace and expand all brackets.

Definition at line 645 of file bitstring.py.

◆ offsetcopy()

def scripts.bitstring.offsetcopy	(	s,
		newoffset
	)

Return a copy of a ByteStore with the newoffset.

Not part of public interface.

Definition at line 249 of file bitstring.py.

◆ pack()

def scripts.bitstring.pack	(		fmt,
		*	values,
		**	kwargs
	)

Pack the values according to the format string and return a new BitStream.

fmt -- A single string or a list of strings with comma separated tokens
       describing how to create the BitStream.
values -- Zero or more values to pack according to the format.
kwargs -- A dictionary or keyword-value pairs - the keywords used in the
          format string will be replaced with their given value.

Token examples: 'int:12'    : 12 bits as a signed integer
                'uint:8'    : 8 bits as an unsigned integer
                'float:64'  : 8 bytes as a big-endian float
                'intbe:16'  : 2 bytes as a big-endian signed integer
                'uintbe:16' : 2 bytes as a big-endian unsigned integer
                'intle:32'  : 4 bytes as a little-endian signed integer
                'uintle:32' : 4 bytes as a little-endian unsigned integer
                'floatle:64': 8 bytes as a little-endian float
                'intne:24'  : 3 bytes as a native-endian signed integer
                'uintne:24' : 3 bytes as a native-endian unsigned integer
                'floatne:32': 4 bytes as a native-endian float
                'hex:80'    : 80 bits as a hex string
                'oct:9'     : 9 bits as an octal string
                'bin:1'     : single bit binary string
                'ue' / 'uie': next bits as unsigned exp-Golomb code
                'se' / 'sie': next bits as signed exp-Golomb code
                'bits:5'    : 5 bits as a bitstring object
                'bytes:10'  : 10 bytes as a bytes object
                'bool'      : 1 bit as a bool
                'pad:3'     : 3 zero bits as padding

>>> s = pack('uint:12, bits', 100, '0xffe')
>>> t = pack(['bits', 'bin:3'], s, '111')
>>> u = pack('uint:8=a, uint:8=b, uint:55=a', a=6, b=44)

Definition at line 4164 of file bitstring.py.

◆ structparser()

def scripts.bitstring.structparser ( token )

Parse struct-like format string token into sub-token list.

Definition at line 510 of file bitstring.py.

◆ tidy_input_string()

def scripts.bitstring.tidy_input_string ( s )

Return string made lowercase and with all whitespace removed.

Definition at line 462 of file bitstring.py.

◆ tokenparser()

def scripts.bitstring.tokenparser	(	fmt,
		keys = `None`,
		token_cache = `{}`
	)

Divide the format string into tokens and parse them.

Return stretchy token and list of [initialiser, length, value]
initialiser is one of: hex, oct, bin, uint, int, se, ue, 0x, 0o, 0b etc.
length is None if not known, as is value.

If the token is in the keyword dictionary (keys) then it counts as a
special case and isn't messed with.

tokens must be of the form: [factor*][initialiser][:][length][=value]

Definition at line 539 of file bitstring.py.

Variable Documentation

◆ all

list __all__

private

Initial value:

 =  ['ConstBitArray', 'ConstBitStream', 'BitStream', 'BitArray',
            'Bits', 'BitString', 'pack', 'Error', 'ReadError',
            'InterpretError', 'ByteAlignError', 'CreationError', 'bytealigned']

Definition at line 4243 of file bitstring.py.

◆ licence

string __licence__

private

Initial value:

 =  """
 The MIT License
  
 Copyright (c) 2006-2016 Scott Griffiths (dr.scottgriffiths@gmail.com)
  
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
  
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
  
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 """

Definition at line 38 of file bitstring.py.

◆ _tokenname_to_initialiser

dictionary _tokenname_to_initialiser

private

Initial value:

 =  {'hex': 'hex', '0x': 'hex', '0X': 'hex', 'oct': 'oct',
                              '0o': 'oct', '0O': 'oct', 'bin': 'bin', '0b': 'bin',
                              '0B': 'bin', 'bits': 'auto', 'bytes': 'bytes', 'pad': 'pad'}

Definition at line 505 of file bitstring.py.

◆ INIT_NAMES

tuple INIT_NAMES

Initial value:

 =  ('uint', 'int', 'ue', 'se', 'sie', 'uie', 'hex', 'oct', 'bin', 'bits',
               'uintbe', 'intbe', 'uintle', 'intle', 'uintne', 'intne',
               'float', 'floatbe', 'floatle', 'floatne', 'bytes', 'bool', 'pad')

Definition at line 468 of file bitstring.py.

◆ init_with_length_and_offset

dictionary init_with_length_and_offset

Initial value:

 =  {'bytes': Bits._setbytes_safe,
                                'filename': Bits._setfile,
                                }

Definition at line 2914 of file bitstring.py.

◆ init_with_length_only

dictionary init_with_length_only

Initial value:

 =  {'uint': Bits._setuint,
                          'int': Bits._setint,
                          'float': Bits._setfloat,
                          'uintbe': Bits._setuintbe,
                          'intbe': Bits._setintbe,
                          'floatbe': Bits._setfloat,
                          'uintle': Bits._setuintle,
                          'intle': Bits._setintle,
                          'floatle': Bits._setfloatle,
                          'uintne': Bits._setuintne,
                          'intne': Bits._setintne,
                          'floatne': Bits._setfloatne,
                          }

Definition at line 2918 of file bitstring.py.

◆ init_without_length_or_offset

dictionary init_without_length_or_offset

Initial value:

 =  {'bin': Bits._setbin_safe,
                                  'hex': Bits._sethex,
                                  'oct': Bits._setoct,
                                  'ue': Bits._setue,
                                  'se': Bits._setse,
                                  'uie': Bits._setuie,
                                  'sie': Bits._setsie,
                                  'bool': Bits._setbool,
                                  }

Definition at line 2932 of file bitstring.py.

◆ name_to_read

dictionary name_to_read

Initial value:

 =  {'uint': Bits._readuint,
                 'uintle': Bits._readuintle,
                 'uintbe': Bits._readuintbe,
                 'uintne': Bits._readuintne,
                 'int': Bits._readint,
                 'intle': Bits._readintle,
                 'intbe': Bits._readintbe,
                 'intne': Bits._readintne,
                 'float': Bits._readfloat,
                 'floatbe': Bits._readfloat,  # floatbe is a synonym for float
                 'floatle': Bits._readfloatle,
                 'floatne': Bits._readfloatne,
                 'hex': Bits._readhex,
                 'oct': Bits._readoct,
                 'bin': Bits._readbin,
                 'bits': Bits._readbits,
                 'bytes': Bits._readbytes,
                 'ue': Bits._readue,
                 'se': Bits._readse,
                 'uie': Bits._readuie,
                 'sie': Bits._readsie,
                 'bool': Bits._readbool,
                 }

Definition at line 2889 of file bitstring.py.

◆ PACK_CODE_SIZE

dictionary PACK_CODE_SIZE

Initial value:

1 = {'b': 1, 'B': 1, 'h': 2, 'H': 2, 'l': 4, 'L': 4,

2 'q': 8, 'Q': 8, 'f': 4, 'd': 8}

Definition at line 502 of file bitstring.py.

◆ REPLACEMENTS_BE

dictionary REPLACEMENTS_BE

Initial value:

 =  {'b': 'intbe:8', 'B': 'uintbe:8',
                    'h': 'intbe:16', 'H': 'uintbe:16',
                    'l': 'intbe:32', 'L': 'uintbe:32',
                    'q': 'intbe:64', 'Q': 'uintbe:64',
                    'f': 'floatbe:32', 'd': 'floatbe:64'}

Definition at line 489 of file bitstring.py.

◆ REPLACEMENTS_LE

dictionary REPLACEMENTS_LE

Initial value:

 =  {'b': 'intle:8', 'B': 'uintle:8',
                    'h': 'intle:16', 'H': 'uintle:16',
                    'l': 'intle:32', 'L': 'uintle:32',
                    'q': 'intle:64', 'Q': 'uintle:64',
                    'f': 'floatle:32', 'd': 'floatle:64'}

Definition at line 495 of file bitstring.py.

◆ TOKEN_RE

TOKEN_RE

Initial value:

1 = re.compile(r'(?P<name>' + '|'.join(INIT_NAMES) +

2 r')((:(?P<len>[^=]+)))?(=(?P<value>.*))?$', re.IGNORECASE)

Definition at line 472 of file bitstring.py.

Classes

Functions

Variables

Detailed Description

Function Documentation

◆ equal()

◆ expand_brackets()

◆ offsetcopy()

◆ pack()

◆ structparser()

◆ tidy_input_string()

◆ tokenparser()

Variable Documentation

◆ __all__

◆ __licence__

◆ _tokenname_to_initialiser

◆ INIT_NAMES

◆ init_with_length_and_offset

◆ init_with_length_only

◆ init_without_length_or_offset

◆ name_to_read

◆ PACK_CODE_SIZE

◆ REPLACEMENTS_BE

◆ REPLACEMENTS_LE

◆ TOKEN_RE

◆ all

◆ licence