bitstring 4.2.2__py3-none-any.whl → 4.3.0__py3-none-any.whl

bitstring/__init__.py

@@ -55,7 +55,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 """
 
-__version__ = "4.2.2"
+__version__ = "4.3.0"
 
 __author__ = "Scott Griffiths"
 
@@ -111,31 +111,38 @@ class _MyModuleType(types.ModuleType):
 
 sys.modules[__name__].__class__ = _MyModuleType
 
-"""These methods convert a bit length to the number of characters needed to print it for different interpretations."""
+
+# These methods convert a bit length to the number of characters needed to print it for different interpretations.
 def hex_bits2chars(bitlength: int):
     # One character for every 4 bits
     return bitlength // 4
 
+
 def oct_bits2chars(bitlength: int):
     # One character for every 3 bits
     return bitlength // 3
 
+
 def bin_bits2chars(bitlength: int):
     # One character for each bit
     return bitlength
 
+
 def bytes_bits2chars(bitlength: int):
     # One character for every 8 bits
     return bitlength // 8
 
+
 def uint_bits2chars(bitlength: int):
     # How many characters is largest possible int of this length?
     return len(str((1 << bitlength) - 1))
 
+
 def int_bits2chars(bitlength: int):
     # How many characters is largest negative int of this length? (To include minus sign).
     return len(str((-1 << (bitlength - 1))))
 
+
 def float_bits2chars(bitlength: Literal[16, 32, 64]):
     # These bit lengths were found by looking at lots of possible values
     if bitlength in [16, 32]:
@@ -143,53 +150,65 @@ def float_bits2chars(bitlength: Literal[16, 32, 64]):
     else:
         return 24  # Empirical value
 
-def p3binary_bits2chars(bitlength: Literal[8]):
+
+def p3binary_bits2chars(_: Literal[8]):
     return 19  # Empirical value
 
-def p4binary_bits2chars(bitlength: Literal[8]):
+
+def p4binary_bits2chars(_: Literal[8]):
     # Found by looking at all the possible values
     return 13  # Empirical value
 
-def e4m3mxfp_bits2chars(bitlength: Literal[8]):
+
+def e4m3mxfp_bits2chars(_: Literal[8]):
     return 13
 
-def e5m2mxfp_bits2chars(bitlength: Literal[8]):
+
+def e5m2mxfp_bits2chars(_: Literal[8]):
     return 19
 
-def e3m2mxfp_bits2chars(bitlength: Literal[6]):
+
+def e3m2mxfp_bits2chars(_: Literal[6]):
     # Not sure what the best value is here. It's 7 without considering the scale that could be applied.
     return 7
 
-def e2m3mxfp_bits2chars(bitlength: Literal[6]):
+
+def e2m3mxfp_bits2chars(_: Literal[6]):
     # Not sure what the best value is here.
     return 7
 
-def e2m1mxfp_bits2chars(bitlength: Literal[4]):
+
+def e2m1mxfp_bits2chars(_: Literal[4]):
     # Not sure what the best value is here.
     return 7
 
-def e8m0mxfp_bits2chars(bitlength: Literal[8]):
-    # Can range same as float32
+
+def e8m0mxfp_bits2chars(_: Literal[8]):
+    # Has same range as float32
     return 23
 
-def mxint_bits2chars(bitlength: Literal[8]):
+
+def mxint_bits2chars(_: Literal[8]):
     # Not sure what the best value is here.
     return 10
 
 
-def bfloat_bits2chars(bitlength: Literal[16]):
+def bfloat_bits2chars(_: Literal[16]):
     # Found by looking at all the possible values
     return 23  # Empirical value
 
+
 def bits_bits2chars(bitlength: int):
     # For bits type we can see how long it needs to be printed by trying any value
     temp = Bits(bitlength)
     return len(str(temp))
 
-def bool_bits2chars(bitlength: Literal[1]):
+
+def bool_bits2chars(_: Literal[1]):
     # Bools are printed as 1 or 0, not True or False, so are one character each
     return 1
 
+
 dtype_definitions = [
     # Integer types
     DtypeDefinition('uint', Bits._setuint, Bits._getuint, int, False, uint_bits2chars,

bitstring/__main__.py

@@ -47,4 +47,4 @@ $ python -m bitstring hex=01, uint:12=352.hex
 
 
 if __name__ == '__main__':
-    main()
+    main()

bitstring/array_.py

@@ -93,6 +93,7 @@ class Array:
             self.data += BitArray._create_from_bitstype(trailing_bits)
 
     _largest_values = None
+
     @staticmethod
     def _calculate_auto_scale(initializer, name: str, length: Optional[int]) -> float:
         # Now need to find the largest power of 2 representable with this format.
@@ -112,12 +113,15 @@ class Array:
             }
         if f'{name}{length}' in Array._largest_values.keys():
             float_values = Array('float64', initializer).tolist()
+            if not float_values:
+                raise ValueError("Can't calculate an 'auto' scale with an empty Array initializer.")
             max_float_value = max(abs(x) for x in float_values)
             if max_float_value == 0:
                 # This special case isn't covered in the standard. I'm choosing to return no scale.
                 return 1.0
-            log2 = int(math.log2(max_float_value))
-            lp2 = int(math.log2(Array._largest_values[f'{name}{length}']))
+            # We need to find the largest power of 2 that is less than the max value
+            log2 = math.floor(math.log2(max_float_value))
+            lp2 = math.floor(math.log2(Array._largest_values[f'{name}{length}']))
             lg_scale = log2 - lp2
             # Saturate at values representable in E8M0 format.
             if lg_scale > 127:
@@ -155,7 +159,7 @@ class Array:
             except ValueError:
                 name_length = utils.parse_single_struct_token(new_dtype)
                 if name_length is not None:
-                    dtype = Dtype(*name_length)
+                    dtype = Dtype(name_length[0], name_length[1])
                 else:
                     raise ValueError(f"Inappropriate Dtype for Array: '{new_dtype}'.")
             if dtype.length is None:
@@ -270,7 +274,7 @@ class Array:
         return new_array
 
     def tolist(self) -> List[ElementType]:
-        return  [self._dtype.read_fn(self.data, start=start)
+        return [self._dtype.read_fn(self.data, start=start)
                 for start in range(0, len(self.data) - self._dtype.length + 1, self._dtype.length)]
 
     def append(self, x: ElementType) -> None:
@@ -408,9 +412,11 @@ class Array:
             token_list = utils.preprocess_tokens(fmt)
             if len(token_list) not in [1, 2]:
                 raise ValueError(f"Only one or two tokens can be used in an Array.pp() format - '{fmt}' has {len(token_list)} tokens.")
-            dtype1 = Dtype(*utils.parse_name_length_token(token_list[0]))
+            name1, length1 = utils.parse_name_length_token(token_list[0])
+            dtype1 = Dtype(name1, length1)
             if len(token_list) == 2:
-                dtype2 = Dtype(*utils.parse_name_length_token(token_list[1]))
+                name2, length2 = utils.parse_name_length_token(token_list[1])
+                dtype2 = Dtype(name2, length2)
 
         token_length = dtype1.bitlength
         if dtype2 is not None:
@@ -754,12 +760,8 @@ class Array:
     def _eq_ne(self, op, other: Any) -> Array:
         if isinstance(other, (int, float, str, Bits)):
             return self._apply_op_to_all_elements(op, other, is_comparison=True)
-        try:
-            other = self.__class__(self.dtype, other)
-        except:
-            return NotImplemented
-        finally:
-            return self._apply_op_between_arrays(op, other, is_comparison=True)
+        other = self.__class__(self.dtype, other)
+        return self._apply_op_between_arrays(op, other, is_comparison=True)
 
     def __eq__(self, other: Any) -> Array:
         return self._eq_ne(operator.eq, other)

bitstring/bitarray_.py

@@ -11,6 +11,7 @@ from bitstring.bits import Bits, BitsType, TBits
 
 import bitstring.dtypes
 
+
 class BitArray(Bits):
     """A container holding a mutable sequence of bits.
 
@@ -71,7 +72,6 @@ class BitArray(Bits):
     # As BitArray objects are mutable, we shouldn't allow them to be hashed.
     __hash__: None = None
 
-
     def __init__(self, auto: Optional[Union[BitsType, int]] = None, /, length: Optional[int] = None,
                  offset: Optional[int] = None, **kwargs) -> None:
         """Either specify an 'auto' initialiser:
@@ -172,6 +172,7 @@ class BitArray(Bits):
 
     def _setitem_slice(self, key: slice, value: BitsType) -> None:
         if isinstance(value, numbers.Integral):
+            value = int(value)
             if key.step not in [None, -1, 1]:
                 if value in [0, 1]:
                     self.set(value, range(*key.indices(len(self))))
@@ -195,7 +196,7 @@ class BitArray(Bits):
 
     def __setitem__(self, key: Union[slice, int], value: BitsType) -> None:
         if isinstance(key, numbers.Integral):
-            self._setitem_int(key, value)
+            self._setitem_int(int(key), value)
         else:
             self._setitem_slice(key, value)
 
@@ -573,5 +574,3 @@ class BitArray(Bits):
     def clear(self) -> None:
         """Remove all bits, reset to zero length."""
         self._clear()
-
-

bitstring/bits.py

@@ -231,13 +231,8 @@ class Bits:
     def __getitem__(self: TBits, key: Union[slice, int], /) -> Union[TBits, bool]:
         """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])
+        >>> print(Bits('0b00110')[1:4])
         '0b011'
-        >>> print(BitArray('0x00112233')[1:3:8])
-        '0x1122'
 
         """
         if isinstance(key, numbers.Integral):
@@ -1699,34 +1694,37 @@ class Bits:
 
     @staticmethod
     def _process_pp_tokens(token_list, fmt):
+        if len(token_list) not in [1, 2]:
+            raise ValueError(
+                f"Only one or two tokens can be used in an pp() format - '{fmt}' has {len(token_list)} tokens.")
         has_length_in_fmt = True
-        if len(token_list) == 1:
-            dtype1 = Dtype(*utils.parse_name_length_token(token_list[0]))
-            dtype2 = None
-            bits_per_group = dtype1.bitlength
+        name1, length1 = utils.parse_name_length_token(token_list[0])
+        dtype1 = Dtype(name1, length1)
+        bits_per_group = dtype1.bitlength
+        dtype2 = None
+
+        if len(token_list) == 2:
+            name2, length2 = utils.parse_name_length_token(token_list[1])
+            dtype2 = Dtype(name2, length2)
+            if None not in {dtype1.bitlength, dtype2.bitlength} and dtype1.bitlength != dtype2.bitlength:
+                raise ValueError(
+                    f"Differing bit lengths of {dtype1.bitlength} and {dtype2.bitlength} in format string '{fmt}'.")
             if bits_per_group is None:
-                has_length_in_fmt = False
+                bits_per_group = dtype2.bitlength
+
+        if bits_per_group is None:
+            has_length_in_fmt = False
+            if len(token_list) == 1:
                 bits_per_group = {'bin': 8, 'hex': 8, 'oct': 12, 'bytes': 32}.get(dtype1.name)
                 if bits_per_group is None:
                     raise ValueError(f"No length or default length available for pp() format '{fmt}'.")
-        elif len(token_list) == 2:
-            dtype1 = Dtype(*utils.parse_name_length_token(token_list[0]))
-            dtype2 = Dtype(*utils.parse_name_length_token(token_list[1]))
-            if dtype1.bitlength is not None and dtype2.bitlength is not None and dtype1.bitlength != dtype2.bitlength:
-                raise ValueError(
-                    f"Differing bit lengths of {dtype1.bitlength} and {dtype2.bitlength} in format string '{fmt}'.")
-            bits_per_group = dtype1.bitlength if dtype1.bitlength is not None else dtype2.bitlength
-            if bits_per_group is None:
-                has_length_in_fmt = False
+            else:
                 try:
                     bits_per_group = 2 * Bits._bits_per_char(dtype1.name) * Bits._bits_per_char(dtype2.name)
                 except ValueError:
                     raise ValueError(f"Can't find a default bitlength to use for pp() format '{fmt}'.")
                 if bits_per_group >= 24:
                     bits_per_group //= 2
-        else:
-            raise ValueError(
-                f"Only one or two tokens can be used in an pp() format - '{fmt}' has {len(token_list)} tokens.")
         return dtype1, dtype2, bits_per_group, has_length_in_fmt
 
     def pp(self, fmt: Optional[str] = None, width: int = 120, sep: str = ' ',

bitstring/bitstore.py

@@ -4,23 +4,38 @@ import bitarray
 from bitstring.exceptions import CreationError
 from typing import Union, Iterable, Optional, overload, Iterator, Any
 
+if bitarray.__version__.startswith("2."):
+    raise ImportError(f"bitstring version 4.3 requires bitarray version 3 or higher. Found version {bitarray.__version__}.")
+
+def indices(s: slice, length: int) -> tuple[int, int | None, int]:
+    """A better implementation of slice.indices such that a
+    slice made from [start:stop:step] will actually equal the original slice."""
+    if s.step is None or s.step > 0:
+        return s.indices(length)
+    assert s.step < 0
+    start, stop, step = s.indices(length)
+    if stop < 0:
+        stop = None
+    return start, stop, step
 
 def offset_slice_indices_lsb0(key: slice, length: int) -> slice:
-    # First convert slice to all integers
-    # Length already should take account of the offset
-    start, stop, step = key.indices(length)
-    new_start = length - stop
-    new_stop = length - start
-    # For negative step we sometimes get a negative stop, which can't be used correctly in a new slice
-    return slice(new_start, None if new_stop < 0 else new_stop, step)
-
-def offset_start_stop_lsb0(start: Optional[int], stop: Optional[int], length: int) -> slice:
-    # First convert slice to all integers
-    # Length already should take account of the offset
-    start, stop, _ = slice(start, stop, None).indices(length)
-    new_start = length - stop
-    new_stop = length - start
-    return new_start, new_stop
+    start, stop, step = indices(key, length)
+    if step is not None and step < 0:
+        if stop is None:
+            new_start = start + 1
+            new_stop = None
+        else:
+            first_element = start
+            last_element = start + ((stop + 1 - start) // step) * step
+            new_start = length - last_element
+            new_stop = length - first_element - 1
+    else:
+        first_element = start
+        # The last element will usually be stop - 1, but needs to be adjusted if step != 1.
+        last_element = start + ((stop - 1 - start) // step) * step
+        new_start = length - last_element - 1
+        new_stop = length - first_element
+    return slice(new_start, new_stop, key.step)
 
 
 class BitStore:
@@ -149,7 +164,7 @@ class BitStore:
                 byte_pos = byte_pos + 1
             return
         # General case
-        i = self._bitarray.itersearch(bs._bitarray, start, end)
+        i = self._bitarray.search(bs._bitarray, start, end)
         if not bytealigned:
             for p in i:
                 yield p
@@ -159,7 +174,7 @@ class BitStore:
                     yield p
 
     def rfindall_msb0(self, bs: BitStore, start: int, end: int, bytealigned: bool = False) -> Iterator[int]:
-        i = self._bitarray.itersearch(bs._bitarray, start, end, right=True)
+        i = self._bitarray.search(bs._bitarray, start, end, right=True)
         if not bytealigned:
             for p in i:
                 yield p
@@ -212,13 +227,12 @@ class BitStore:
         return BitStore(self._bitarray[start:stop])
 
     def getslice_lsb0(self, start: Optional[int], stop: Optional[int], /) -> BitStore:
-        start, stop = offset_start_stop_lsb0(start, stop, len(self))
-        return BitStore(self._bitarray[start:stop])
+        s = offset_slice_indices_lsb0(slice(start, stop, None), len(self))
+        return BitStore(self._bitarray[s.start:s.stop])
 
     def getindex_lsb0(self, index: int, /) -> bool:
         return bool(self._bitarray.__getitem__(-index - 1))
 
-
     @overload
     def setitem_lsb0(self, key: int, value: int, /) -> None:
         ...
@@ -269,4 +283,4 @@ class BitStore:
             self._bitarray.__setitem__(key, value)
 
     def delitem_msb0(self, key, /):
-        self._bitarray.__delitem__(key)
+        self._bitarray.__delitem__(key)

bitstring/bitstore_helpers.py

@@ -8,7 +8,8 @@ import bitarray
 from bitstring.bitstore import BitStore
 import bitstring
 from bitstring.fp8 import p4binary_fmt, p3binary_fmt
-from bitstring.mxfp import e3m2mxfp_fmt, e2m3mxfp_fmt, e2m1mxfp_fmt, e4m3mxfp_saturate_fmt, e5m2mxfp_saturate_fmt, e4m3mxfp_overflow_fmt, e5m2mxfp_overflow_fmt
+from bitstring.mxfp import (e3m2mxfp_fmt, e2m3mxfp_fmt, e2m1mxfp_fmt, e4m3mxfp_saturate_fmt,
+                            e5m2mxfp_saturate_fmt, e4m3mxfp_overflow_fmt, e5m2mxfp_overflow_fmt)
 
 # The size of various caches used to improve performance
 CACHE_SIZE = 256
@@ -121,11 +122,13 @@ def p4binary2bitstore(f: Union[str, float]) -> BitStore:
     u = p4binary_fmt.float_to_int8(f)
     return int2bitstore(u, 8, False)
 
+
 def p3binary2bitstore(f: Union[str, float]) -> BitStore:
     f = float(f)
     u = p3binary_fmt.float_to_int8(f)
     return int2bitstore(u, 8, False)
 
+
 def e4m3mxfp2bitstore(f: Union[str, float]) -> BitStore:
     f = float(f)
     if bitstring.options.mxfp_overflow == 'saturate':
@@ -134,6 +137,7 @@ def e4m3mxfp2bitstore(f: Union[str, float]) -> BitStore:
         u = e4m3mxfp_overflow_fmt.float_to_int(f)
     return int2bitstore(u, 8, False)
 
+
 def e5m2mxfp2bitstore(f: Union[str, float]) -> BitStore:
     f = float(f)
     if bitstring.options.mxfp_overflow == 'saturate':
@@ -142,6 +146,7 @@ def e5m2mxfp2bitstore(f: Union[str, float]) -> BitStore:
         u = e5m2mxfp_overflow_fmt.float_to_int(f)
     return int2bitstore(u, 8, False)
 
+
 def e3m2mxfp2bitstore(f: Union[str, float]) -> BitStore:
     f = float(f)
     if math.isnan(f):
@@ -149,6 +154,7 @@ def e3m2mxfp2bitstore(f: Union[str, float]) -> BitStore:
     u = e3m2mxfp_fmt.float_to_int(f)
     return int2bitstore(u, 6, False)
 
+
 def e2m3mxfp2bitstore(f: Union[str, float]) -> BitStore:
     f = float(f)
     if math.isnan(f):
@@ -156,6 +162,7 @@ def e2m3mxfp2bitstore(f: Union[str, float]) -> BitStore:
     u = e2m3mxfp_fmt.float_to_int(f)
     return int2bitstore(u, 6, False)
 
+
 def e2m1mxfp2bitstore(f: Union[str, float]) -> BitStore:
     f = float(f)
     if math.isnan(f):
@@ -165,6 +172,8 @@ def e2m1mxfp2bitstore(f: Union[str, float]) -> BitStore:
 
 
 e8m0mxfp_allowed_values = [float(2 ** x) for x in range(-127, 128)]
+
+
 def e8m0mxfp2bitstore(f: Union[str, float]) -> BitStore:
     f = float(f)
     if math.isnan(f):
@@ -199,6 +208,7 @@ def mxint2bitstore(f: Union[str, float]) -> BitStore:
             i += 1
     return int2bitstore(i, 8, True)
 
+
 def int2bitstore(i: int, length: int, signed: bool) -> BitStore:
     i = int(i)
     try:

bitstring/bitstream.py

@@ -57,7 +57,7 @@ class ConstBitStream(Bits):
     pos -- The current bit position in the bitstring.
     """
 
-    __slots__ = ('_pos')
+    __slots__ = ('_pos',)
 
     def __init__(self, auto: Optional[Union[BitsType, int]] = None, /, length: Optional[int] = None,
                  offset: Optional[int] = None, pos: int = 0, **kwargs) -> None:

bitstring/bitstring_options.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import bitstring
 import os
 
+
 class Options:
     """Internal class to create singleton module options instance."""
 
@@ -91,4 +92,4 @@ class Colour:
             cls.off = '\033[0m'
         else:
             cls.blue = cls.purple = cls.green = cls.off = ''
-        return x
+        return x

bitstring/dtypes.py

@@ -55,7 +55,6 @@ class Dtype:
     _length: Optional[int]
     _scale: Union[None, float, int]
 
-
     def __new__(cls, token: Union[str, Dtype], /, length: Optional[int] = None, scale: Union[None, float, int] = None) -> Dtype:
         if isinstance(token, cls):
             return token
@@ -253,7 +252,7 @@ class DtypeDefinition:
     """Represents a class of dtypes, such as uint or float, rather than a concrete dtype such as uint8.
     Not (yet) part of the public interface."""
 
-    def __init__(self, name: str, set_fn, get_fn, return_type: Any = Any, is_signed: bool = False, bitlength2chars_fn = None,
+    def __init__(self, name: str, set_fn, get_fn, return_type: Any = Any, is_signed: bool = False, bitlength2chars_fn=None,
                  variable_length: bool = False, allowed_lengths: Tuple[int, ...] = tuple(), multiplier: int = 1, description: str = ''):
 
         # Consistency checks
@@ -277,7 +276,7 @@ class DtypeDefinition:
         self.set_fn_needs_length = set_fn is not None and 'length' in inspect.signature(set_fn).parameters
         self.set_fn = set_fn
 
-        if self.allowed_lengths:
+        if self.allowed_lengths.values:
             def allowed_length_checked_get_fn(bs):
                 if len(bs) not in self.allowed_lengths:
                     if self.allowed_lengths.only_one_value():
@@ -401,4 +400,4 @@ class Register:
 
 
 # Create the Register singleton
-dtype_register = Register()
+dtype_register = Register()

bitstring/exceptions.py

@@ -21,4 +21,3 @@ class ByteAlignError(Error):
 
 CreationError = ValueError
 """Inappropriate argument during bitstring creation."""
-