"""A container holding an immutable sequence of bits.

__slots__ = ('_bitstore', '_filename')

def __init__(self, auto: Optional[Union[BitsType, int]]=None, /, length: Optional[int]=None, offset: Optional[int]=None, **kwargs) -> None:

"""Either specify an 'auto' initialiser:

self._bitstore.immutable = True

def __new__(cls: Type[TBits], auto: Optional[Union[BitsType, int]]=None, /, length: Optional[int]=None, offset: Optional[int]=None, pos: Optional[int]=None, **kwargs) -> TBits:

x = super().__new__(cls)

if auto is None and (not kwargs):

if length is not None:

x._bitstore = BitStore(length)

x._bitstore.setall(0)

else:

x._bitstore = BitStore()

return x

x._initialise(auto, length, offset, **kwargs)

return x

def __getattr__(self, attribute: str) -> Any:

try:

d = Dtype(attribute)

except ValueError:

raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{attribute}'.")

if d.bitlength is not None and len(self) != d.bitlength:

raise ValueError(f"bitstring length {len(self)} doesn't match length {d.bitlength} of property '{attribute}'.")

return d.get_fn(self)

def __iter__(self) -> Iterable[bool]:

return iter(self._bitstore)

def __copy__(self: TBits) -> TBits:

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

return self

def __lt__(self, other: Any) -> bool:

return NotImplemented

def __gt__(self, other: Any) -> bool:

return NotImplemented

def __le__(self, other: Any) -> bool:

return NotImplemented

def __ge__(self, other: Any) -> bool:

return NotImplemented

def __add__(self: TBits, bs: BitsType) -> TBits:

"""Concatenate bitstrings and return new bitstring.

bs = self.__class__._create_from_bitstype(bs)

s = self._copy() if len(bs) <= len(self) else bs._copy()

if len(bs) <= len(self):

s._addright(bs)

else:

s._addleft(self)

return s

def __radd__(self: TBits, bs: BitsType) -> TBits:

"""Append current bitstring to bs and return new bitstring.

bs = self.__class__._create_from_bitstype(bs)

return bs.__add__(self)

@overload

def __getitem__(self: TBits, key: slice, /) -> TBits:

...

@overload

def __getitem__(self, key: int, /) -> bool:

...

def __getitem__(self: TBits, key: Union[slice, int], /) -> Union[TBits, bool]:

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

if isinstance(key, numbers.Integral):

return bool(self._bitstore.getindex(key))

bs = super().__new__(self.__class__)

bs._bitstore = self._bitstore.getslice_withstep(key)

return bs

def __len__(self) -> int:

"""Return the length of the bitstring in bits."""

return self._getlength()

def __bytes__(self) -> bytes:

return self.tobytes()

def __str__(self) -> str:

"""Return approximate string representation of bitstring for printing.

length = len(self)

if not length:

return ''

if length > MAX_CHARS * 4:

return ''.join(('0x', self[0:MAX_CHARS * 4]._gethex(), '...'))

if length < 32 and length % 4 != 0:

return '0b' + self.bin

if not length % 4:

return '0x' + self.hex

bits_at_end = length % 4

return ''.join(('0x', self[0:length - bits_at_end]._gethex(), ', ', '0b', self[length - bits_at_end:]._getbin()))

def __repr__(self) -> str:

"""Return representation that could be used to recreate the bitstring.

return self._repr(self.__class__.__name__, len(self), 0)

def __eq__(self, bs: Any, /) -> bool:

"""Return True if two bitstrings have the same binary representation.

try:

return self._bitstore == Bits._create_from_bitstype(bs)._bitstore

except TypeError:

return False

def __ne__(self, bs: Any, /) -> bool:

"""Return False if two bitstrings have the same binary representation.

return not self.__eq__(bs)

def __invert__(self: TBits) -> TBits:

"""Return bitstring with every bit inverted.

if len(self) == 0:

raise bitstring.Error('Cannot invert empty bitstring.')

s = self._copy()

s._invert_all()

return s

def __lshift__(self: TBits, n: int, /) -> TBits:

"""Return bitstring with bits shifted by n to the left.

if n < 0:

raise ValueError('Cannot shift by a negative amount.')

if len(self) == 0:

raise ValueError('Cannot shift an empty bitstring.')

n = min(n, len(self))

s = self._absolute_slice(n, len(self))

s._addright(Bits(n))

return s

def __rshift__(self: TBits, n: int, /) -> TBits:

"""Return bitstring with bits shifted by n to the right.

if n < 0:

raise ValueError('Cannot shift by a negative amount.')

if len(self) == 0:

raise ValueError('Cannot shift an empty bitstring.')

if not n:

return self._copy()

s = self.__class__(length=min(n, len(self)))

n = min(n, len(self))

s._addright(self._absolute_slice(0, len(self) - n))

return s

def __mul__(self: TBits, n: int, /) -> TBits:

"""Return bitstring consisting of n concatenations of self.

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

def __rmul__(self: TBits, n: int, /) -> TBits:

"""Return bitstring consisting of n concatenations of self.

return self.__mul__(n)

def __and__(self: TBits, bs: BitsType, /) -> TBits:

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

if bs is self:

return self.copy()

bs = Bits._create_from_bitstype(bs)

s = object.__new__(self.__class__)

s._bitstore = self._bitstore & bs._bitstore

return s

def __rand__(self: TBits, bs: BitsType, /) -> TBits:

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

return self.__and__(bs)

def __or__(self: TBits, bs: BitsType, /) -> TBits:

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

if bs is self:

return self.copy()

bs = Bits._create_from_bitstype(bs)

s = object.__new__(self.__class__)

s._bitstore = self._bitstore | bs._bitstore

return s

def __ror__(self: TBits, bs: BitsType, /) -> TBits:

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

return self.__or__(bs)

def __xor__(self: TBits, bs: BitsType, /) -> TBits:

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

bs = Bits._create_from_bitstype(bs)

s = object.__new__(self.__class__)

s._bitstore = self._bitstore ^ bs._bitstore

return s

def __rxor__(self: TBits, bs: BitsType, /) -> TBits:

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

return self.__xor__(bs)

def __contains__(self, bs: BitsType, /) -> bool:

"""Return whether bs is contained in the current bitstring.

found = Bits.find(self, bs, bytealigned=False)

return bool(found)

def __hash__(self) -> int:

"""Return an integer hash of the object."""

if len(self) <= 2000:

return hash((self.tobytes(), len(self)))

else:

return hash(((self[:800] + self[-800:]).tobytes(), len(self)))

def __bool__(self) -> bool:

"""Return False if bitstring is empty, otherwise return True."""

return len(self) != 0

def _clear(self) -> None:

"""Reset the bitstring to an empty state."""

pass

def _setauto_no_length_or_offset(self, s: BitsType, /) -> None:

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

pass

def _setauto(self, s: BitsType, length: Optional[int], offset: Optional[int], /) -> None:

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

pass

def _setfile(self, filename: str, length: Optional[int]=None, offset: Optional[int]=None) -> None:

"""Use file as source of bits."""

pass

def _setbytes(self, data: Union[bytearray, bytes, List], length: None=None) -> None:

"""Set the data from a bytes or bytearray object."""

pass

def _setbytes_with_truncation(self, data: Union[bytearray, bytes], length: Optional[int]=None, offset: Optional[int]=None) -> None:

"""Set the data from a bytes or bytearray object, with optional offset and length truncations."""

pass

def _getbytes(self) -> bytes:

"""Return the data as an ordinary bytes object."""

pass

_unprintable = list(range(0, 32))

_unprintable.extend(range(127, 255))

def _getbytes_printable(self) -> str:

"""Return an approximation of the data as a string of printable characters."""

pass

def _setuint(self, uint: int, length: Optional[int]=None) -> None:

"""Reset the bitstring to have given unsigned int interpretation."""

pass

def _setuintle(self, uint: int, length: Optional[int]=None) -> None:

"""Reset the bitstring to have given unsigned int interpretation in little-endian."""

if length is None:

# Calculate the minimum number of bits needed

length = max(uint.bit_length(), 1)

if length % 8:

length += 8 - (length % 8)

if length % 8:

raise ValueError("Little-endian integers must be whole-byte. Length = {0} bits.".format(length))

if uint < 0:

raise ValueError("Little-endian unsigned integer cannot be negative.")

if uint >= (1 << length):

raise ValueError("Little-endian unsigned integer is too large for length {0}.".format(length))

# Convert to bytes in little-endian order

num_bytes = length // 8

byte_data = uint.to_bytes(num_bytes, byteorder='little', signed=False)

self._setbytes(byte_data)

def _setintle(self, value: int, length: Optional[int]=None) -> None:

"""Reset the bitstring to have given signed int interpretation in little-endian."""

if length is None:

# Calculate the minimum number of bits needed

length = max(value.bit_length() + 1, 1) # +1 for sign bit

if length % 8:

length += 8 - (length % 8)

if length % 8:

raise ValueError("Little-endian integers must be whole-byte. Length = {0} bits.".format(length))

num_bytes = length // 8

try:

byte_data = value.to_bytes(num_bytes, byteorder='little', signed=True)

except OverflowError:

raise ValueError("Little-endian signed integer is too large for length {0}.".format(length))

self._setbytes(byte_data)

def _setfloatbe(self, value: float, length: Optional[int]=None) -> None:

"""Reset the bitstring to have given float interpretation in big-endian."""

if length is None:

raise ValueError("A length must be specified with float initialisation.")

if length == 16:

fmt = '>e'

elif length == 32:

fmt = '>f'

elif length == 64:

fmt = '>d'

else:

raise ValueError("float length must be 16, 32 or 64 bits.")

try:

byte_data = struct.pack(fmt, value)

except (struct.error, OverflowError):

raise ValueError("Float is too large for length {0}.".format(length))

self._setbytes(byte_data)

def _setfloatle(self, value: float, length: Optional[int]=None) -> None:

"""Reset the bitstring to have given float interpretation in little-endian."""

if length is None:

raise ValueError("A length must be specified with float initialisation.")

if length == 16:

fmt = '<e'

elif length == 32:

fmt = '<f'

elif length == 64:

fmt = '<d'

else:

raise ValueError("float length must be 16, 32 or 64 bits.")

try:

byte_data = struct.pack(fmt, value)

except (struct.error, OverflowError):

raise ValueError("Float is too large for length {0}.".format(length))

self._setbytes(byte_data)

def _setbfloatbe(self, value: float, length: Optional[int]=None) -> None:

"""Reset the bitstring to have given bfloat interpretation in big-endian."""

if length is not None and length != 16:

raise ValueError("bfloat must be 16 bits.")

# Convert to 32-bit float first

try:

byte_data = struct.pack('>f', value)

# Take only the first two bytes (16 bits) for bfloat

self._setbytes(byte_data[:2])

except (struct.error, OverflowError):

raise ValueError("Float is too large for bfloat format.")

def _getbfloatbe(self) -> float:

"""Return data as a bfloat in big-endian format."""

if len(self) != 16:

raise bitstring.InterpretError("bfloat requires 16 bits.")

# Convert to 32-bit float by appending two zero bytes

byte_data = self._getbytes() + b'\x00\x00'

try:

return struct.unpack('>f', byte_data)[0]

except struct.error:

raise bitstring.InterpretError("Cannot interpret as bfloat.")

def _setbfloatle(self, value: float, length: Optional[int]=None) -> None:

"""Reset the bitstring to have given bfloat interpretation in little-endian."""

if length is not None and length != 16:

raise ValueError("bfloat must be 16 bits.")

# Convert to 32-bit float first

try:

byte_data = struct.pack('<f', value)

# Take only the last two bytes (16 bits) for bfloat

self._setbytes(byte_data[2:])

except (struct.error, OverflowError):

raise ValueError("Float is too large for bfloat format.")

def _getbfloatle(self) -> float:

"""Return data as a bfloat in little-endian format."""

if len(self) != 16:

raise bitstring.InterpretError("bfloat requires 16 bits.")

# Convert to 32-bit float by prepending two zero bytes

byte_data = b'\x00\x00' + self._getbytes()

try:

return struct.unpack('<f', byte_data)[0]

except struct.error:

raise bitstring.InterpretError("Cannot interpret as bfloat.")

def _setbits(self, bits: Bits, length: Optional[int]=None) -> None:

"""Reset the bitstring to have given bits interpretation."""

if length is not None and len(bits) != length:

raise ValueError("Bits length {0} does not match required length {1}.".format(len(bits), length))

self._bitstore = bits._bitstore.copy()

def _getbits(self) -> Bits:

"""Return data as a Bits object."""

return self.copy()

def _setbool(self, value: bool, length: Optional[int]=None) -> None:

"""Reset the bitstring to have given bool interpretation."""

if length is not None and length != 1:

raise ValueError("Boolean values must be 1 bit long.")

self._bitstore = BitStore(1)

self._bitstore.setall(1 if value else 0)

def _getbool(self) -> bool:

"""Return data as a bool."""

if len(self) != 1:

raise bitstring.InterpretError("Cannot interpret as bool: length must be 1 bit.")

return bool(self._bitstore.getindex(0))

def _setse(self, value: int, length: Optional[int]=None) -> None:

"""Reset the bitstring to have given signed exponential-Golomb code interpretation."""

if length is not None:

raise ValueError("Length cannot be specified for signed exponential-Golomb codes.")

# Convert to unsigned by mapping negative values to positive ones

unsigned = (abs(value) << 1) - (1 if value > 0 else 0)

# Get the number of bits needed for the unsigned value

num_bits = unsigned.bit_length()

# Add leading zeros and the code

self._bitstore = BitStore(num_bits * 2 + 1)

self._bitstore.setall(0)

# Set the code bits

for i in range(num_bits):

self._bitstore.setindex(num_bits + i, (unsigned >> (num_bits - 1 - i)) & 1)

def _getse(self) -> int:

"""Return data as a signed exponential-Golomb code."""

# Find the first 1 bit

for i in range(len(self)):

if self._bitstore.getindex(i):

# Get the code bits

code_bits = 0

for j in range(i + 1, min(2 * i + 1, len(self))):

code_bits = (code_bits << 1) | self._bitstore.getindex(j)

# Convert back to signed value

unsigned = code_bits + (1 << i)

# Map back to signed value

return (unsigned + 1) >> 1 if unsigned & 1 else -(unsigned >> 1)

raise bitstring.InterpretError("Cannot find any 1 bits in exponential-Golomb code.")

def _setue(self, value: int, length: Optional[int]=None) -> None:

"""Reset the bitstring to have given unsigned exponential-Golomb code interpretation."""

if length is not None:

raise ValueError("Length cannot be specified for unsigned exponential-Golomb codes.")

if value < 0:

raise ValueError("Unsigned exponential-Golomb codes cannot be negative.")

# Get the number of bits needed for the value + 1

num_bits = (value + 1).bit_length()

# Add leading zeros and the code

self._bitstore = BitStore(num_bits * 2)

self._bitstore.setall(0)

# Set the code bits

for i in range(num_bits - 1):

self._bitstore.setindex(num_bits - 1 + i, (value >> (num_bits - 2 - i)) & 1)

# Set the terminating 1 bit

self._bitstore.setindex(num_bits - 1, 1)

def _getue(self) -> int:

"""Return data as an unsigned exponential-Golomb code."""

# Find the first 1 bit

for i in range(len(self)):

if self._bitstore.getindex(i):

# Get the code bits

code_bits = 0

for j in range(i + 1, min(2 * i + 1, len(self))):

code_bits = (code_bits << 1) | self._bitstore.getindex(j)

# Convert back to unsigned value

return code_bits + (1 << i) - 1

raise bitstring.InterpretError("Cannot find any 1 bits in exponential-Golomb code.")

def _setsie(self, value: int, length: Optional[int]=None) -> None:

"""Reset the bitstring to have given signed interleaved exponential-Golomb code interpretation."""

if length is not None:

raise ValueError("Length cannot be specified for signed interleaved exponential-Golomb codes.")

# Convert to unsigned by mapping negative values to positive ones

unsigned = abs(value) << 1

if value < 0:

unsigned -= 1

# Get the number of bits needed for the unsigned value

num_bits = unsigned.bit_length()

# Add leading zeros and the code

self._bitstore = BitStore(num_bits * 2)

self._bitstore.setall(0)

# Set the code bits

for i in range(num_bits - 1):

self._bitstore.setindex(num_bits - 1 + i, (unsigned >> (num_bits - 2 - i)) & 1)

# Set the terminating 1 bit

self._bitstore.setindex(num_bits - 1, 1)

def _getsie(self) -> int:

"""Return data as a signed interleaved exponential-Golomb code."""

# Find the first 1 bit

for i in range(len(self)):

if self._bitstore.getindex(i):

# Get the code bits

code_bits = 0

for j in range(i + 1, min(2 * i + 1, len(self))):

code_bits = (code_bits << 1) | self._bitstore.getindex(j)

# Convert back to unsigned value

unsigned = code_bits + (1 << i) - 1

# Map back to signed value

return -(unsigned >> 1) - 1 if unsigned & 1 else unsigned >> 1

raise bitstring.InterpretError("Cannot find any 1 bits in exponential-Golomb code.")

def _setuie(self, value: int, length: Optional[int]=None) -> None:

"""Reset the bitstring to have given unsigned interleaved exponential-Golomb code interpretation."""

if length is not None:

raise ValueError("Length cannot be specified for unsigned interleaved exponential-Golomb codes.")

if value < 0:

raise ValueError("Unsigned interleaved exponential-Golomb codes cannot be negative.")

# Get the number of bits needed for the value + 1

num_bits = (value + 1).bit_length()

# Add leading zeros and the code

self._bitstore = BitStore(num_bits * 2)

self._bitstore.setall(0)

# Set the code bits

for i in range(num_bits - 1):

self._bitstore.setindex(num_bits - 1 + i, (value >> (num_bits - 2 - i)) & 1)

# Set the terminating 1 bit

self._bitstore.setindex(num_bits - 1, 1)

def _getuie(self) -> int:

"""Return data as an unsigned interleaved exponential-Golomb code."""

# Find the first 1 bit

for i in range(len(self)):

if self._bitstore.getindex(i):

# Get the code bits

code_bits = 0

for j in range(i + 1, min(2 * i + 1, len(self))):

code_bits = (code_bits << 1) | self._bitstore.getindex(j)

# Convert back to unsigned value

return code_bits + (1 << i) - 1

raise bitstring.InterpretError("Cannot find any 1 bits in exponential-Golomb code.")

def _setpad(self, value: None, length: Optional[int]=None) -> None:

"""Reset the bitstring to have given padding bits interpretation."""

if length is None:

raise ValueError("Length must be specified for padding bits.")

if value is not None:

raise ValueError("Padding bits cannot have a value.")

self._bitstore = BitStore(length)

self._bitstore.setall(0)

def _getpad(self) -> None:

"""Return data as padding bits (always returns None)."""

return None

def _setp3binary(self, value: float, length: Optional[int]=None) -> None:

"""Reset the bitstring to have given p3binary float interpretation."""

if length is not None and length != 8:

raise ValueError("p3binary must be 8 bits.")

# Convert to bytes using the p3binary format

byte_data = p3binary_fmt.float_to_int8(value).to_bytes(1, byteorder='big', signed=False)

self._setbytes(byte_data)

def _getp3binary(self) -> float:

"""Return data as a p3binary float."""

if len(self) != 8:

raise bitstring.InterpretError("p3binary requires 8 bits.")

# Convert from bytes using the p3binary format

byte_data = self._getbytes()

return p3binary_fmt.lut_binary8_to_float[byte_data[0]]

def _setp4binary(self, value: float, length: Optional[int]=None) -> None:

"""Reset the bitstring to have given p4binary float interpretation."""

if length is not None and length != 8:

raise ValueError("p4binary must be 8 bits.")

# Convert to bytes using the p4binary format

byte_data = p4binary_fmt.float_to_int8(value).to_bytes(1, byteorder='big', signed=False)

self._setbytes(byte_data)

def _getp4binary(self) -> float:

"""Return data as a p4binary float."""

if len(self) != 8:

raise bitstring.InterpretError("p4binary requires 8 bits.")

# Convert from bytes using the p4binary format

byte_data = self._getbytes()

return p4binary_fmt.lut_binary8_to_float[byte_data[0]]

def _sete4m3mxfp(self, value: float, length: Optional[int]=None) -> None:

"""Reset the bitstring to have given e4m3mxfp float interpretation."""

if length is not None and length != 8:

raise ValueError("e4m3mxfp must be 8 bits.")

# Convert to bytes using the e4m3mxfp format

byte_data = e4m3mxfp_fmt.float_to_int(value).to_bytes(1, byteorder='big', signed=False)

self._setbytes(byte_data)

def _gete4m3mxfp(self) -> float:

"""Return data as an e4m3mxfp float."""

if len(self) != 8:

raise bitstring.InterpretError("e4m3mxfp requires 8 bits.")

# Convert from bytes using the e4m3mxfp format

byte_data = self._getbytes()

return e4m3mxfp_fmt.lut_int_to_float[byte_data[0]]

pass

def _getuint(self) -> int:

"""Return data as an unsigned int."""

pass

def _setint(self, int_: int, length: Optional[int]=None) -> None:

"""Reset the bitstring to have given signed int interpretation."""

pass

def _getint(self) -> int:

"""Return data as a two's complement signed int."""

pass

def _setuintbe(self, uintbe: int, length: Optional[int]=None) -> None:

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

pass

def _getuintbe(self) -> int:

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

pass

def _setintbe(self, intbe: int, length: Optional[int]=None) -> None:

"""Set bitstring to a big-endian signed int interpretation."""

pass

def _getintbe(self) -> int:

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

pass

def _getuintle(self) -> int:

"""Interpret as a little-endian unsigned int."""

pass

def _getintle(self) -> int:

"""Interpret as a little-endian signed int."""

pass

def _getfloatbe(self) -> float:

"""Interpret the whole bitstring as a big-endian float."""

pass

def _getfloatle(self) -> float:

"""Interpret the whole bitstring as a little-endian float."""

pass

def _setue(self, i: int) -> None:

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

pass

def _readue(self, pos: int) -> Tuple[int, int]:

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

pass

def _setse(self, i: int) -> None:

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

pass

def _readse(self, pos: int) -> Tuple[int, int]:

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

pass

def _setuie(self, i: int) -> None:

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

pass

def _readuie(self, pos: int) -> Tuple[int, int]:

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

pass

def _setsie(self, i: int) -> None:

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

pass

def _readsie(self, pos: int) -> Tuple[int, int]:

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

pass

def _setbin_safe(self, binstring: str, length: None=None) -> None:

"""Reset the bitstring to the value given in binstring."""

pass

def _setbin_unsafe(self, binstring: str, length: None=None) -> None:

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

pass

def _getbin(self) -> str:

"""Return interpretation as a binary string."""

pass

def _setoct(self, octstring: str, length: None=None) -> None:

"""Reset the bitstring to have the value given in octstring."""

pass

def _getoct(self) -> str:

"""Return interpretation as an octal string."""

pass

def _sethex(self, hexstring: str, length: None=None) -> None:

"""Reset the bitstring to have the value given in hexstring."""

pass

def _gethex(self) -> str:

"""Return the hexadecimal representation as a string.

pass

def _getlength(self) -> int:

"""Return the length of the bitstring in bits."""

pass

def _copy(self: TBits) -> TBits:

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

pass

def _slice(self: TBits, start: int, end: int) -> TBits:

"""Used internally to get a slice, without error checking."""

pass

def _absolute_slice(self: TBits, start: int, end: int) -> TBits:

"""Used internally to get a slice, without error checking.

pass

def _readtoken(self, name: str, pos: int, length: Optional[int]) -> Tuple[Union[float, int, str, None, Bits], int]:

"""Reads a token from the bitstring and returns the result."""

pass

def _addright(self, bs: Bits, /) -> None:

"""Add a bitstring to the RHS of the current bitstring."""

pass

def _addleft(self, bs: Bits, /) -> None:

"""Prepend a bitstring to the current bitstring."""

pass

def _truncateleft(self: TBits, bits: int, /) -> TBits:

"""Truncate bits from the start of the bitstring. Return the truncated bits."""

pass

def _truncateright(self: TBits, bits: int, /) -> TBits:

"""Truncate bits from the end of the bitstring. Return the truncated bits."""

pass

def _insert(self, bs: Bits, pos: int, /) -> None:

"""Insert bs at pos."""

pass

def _overwrite(self, bs: Bits, pos: int, /) -> None:

"""Overwrite with bs at pos."""

pass

def _delete(self, bits: int, pos: int, /) -> None:

"""Delete bits at pos."""

pass

def _reversebytes(self, start: int, end: int) -> None:

"""Reverse bytes in-place."""

pass

def _invert(self, pos: int, /) -> None:

"""Flip bit at pos 1<->0."""

pass

def _invert_all(self) -> None:

"""Invert every bit."""

pass

def _ilshift(self: TBits, n: int, /) -> TBits:

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

pass

def _irshift(self: TBits, n: int, /) -> TBits:

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

pass

def _imul(self: TBits, n: int, /) -> TBits:

"""Concatenate n copies of self in place. Return self."""

pass

def _validate_slice(self, start: Optional[int], end: Optional[int]) -> Tuple[int, int]:

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

pass

def unpack(self, fmt: Union[str, List[Union[str, int]]], **kwargs) -> List[Union[int, float, str, Bits, bool, bytes, None]]:

"""Interpret the whole bitstring using fmt and return list.