bitstring 4.2.2__tar.gz → 4.2.3__tar.gz

{bitstring-4.2.2 → bitstring-4.2.3}/MANIFEST.in

@@ -1,7 +1,7 @@
 include tests/test.m1v
 include tests/smalltestfile
 include tests/__init__.py
-include release_notes.txt
+include release_notes.md
 include README.md
 include bitstring/py.typed
 prune doc

{bitstring-4.2.2/bitstring.egg-info → bitstring-4.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bitstring
-Version: 4.2.2
+Version: 4.2.3
 Summary: Simple construction, analysis and modification of binary data.
 Author-email: Scott Griffiths <dr.scottgriffiths@gmail.com>
 Project-URL: homepage, https://github.com/scott-griffiths/bitstring
@@ -40,26 +40,13 @@ It has been actively maintained since 2006.
 [![Pepy Total Downlods](https://img.shields.io/pepy/dt/bitstring?logo=python&logoColor=white&labelColor=blue&color=blue)](https://www.pepy.tech/projects/bitstring)
 [![PyPI - Downloads](https://img.shields.io/pypi/dm/bitstring?label=%40&labelColor=blue&color=blue)](https://pypistats.org/packages/bitstring)
 
-
-News
 ----
-**May 2024**: bitstring 4.2.2 released.
- 
-New in version 4.2:
-
-* Dropped support for Python 3.7. Minimum version is now 3.8.
-* A new `Dtype` class can be optionally used to specify types.
-* The `bitstring.options` object is now the preferred method for changing module options.
-* New `fromstring` method as another way to create bitstrings from formatted strings.
-* More types can now be pretty printed.
-* A range of 8-bit, 6-bit and even 4-bit floating point formats added (beta):
-* Performance improvements.
 
-See the [release notes](https://github.com/scott-griffiths/bitstring/blob/main/release_notes.txt) for details. Please let me know if you encounter any problems.
+> [!NOTE]
+> To see what been added, improved or fixed, and also to see what's coming in the next version, see the [release notes](https://github.com/scott-griffiths/bitstring/blob/main/release_notes.md).
 
 
-Overview
---------
+# Overview
 
 * Efficiently store and manipulate binary data in idiomatic Python.
 * Create bitstrings from hex, octal, binary, files, formatted strings, bytes, integers and floats of different endiannesses.
@@ -70,8 +57,8 @@ Overview
 * Rich API - chances are that whatever you want to do there's a simple and elegant way of doing it.
 * Open source software, released under the MIT licence.
 
-Documentation
--------------
+# Documentation
+
 Extensive documentation for the bitstring module is available.
 Some starting points are given below:
 
@@ -81,67 +68,66 @@ Some starting points are given below:
 
 There is also an introductory walkthrough notebook on [binder](https://mybinder.org/v2/gh/scott-griffiths/bitstring/main?labpath=doc%2Fwalkthrough.ipynb).
 
-Release Notes
--------------
-
-To see what been added, improved or fixed, and also to see what's coming in the next version, see the [release notes](https://github.com/scott-griffiths/bitstring/blob/main/release_notes.txt).
-
-Examples
---------
+# Examples
 
 ### Installation
-
-    $ pip install bitstring
+```
+$ pip install bitstring
+```
 
 ### Creation
-
-     >>> from bitstring import Bits, BitArray, BitStream, pack
-     >>> a = BitArray(bin='00101')
-     >>> b = Bits(a_file_object)
-     >>> c = BitArray('0xff, 0b101, 0o65, uint6=22')
-     >>> d = pack('intle16, hex=a, 0b1', 100, a='0x34f')
-     >>> e = pack('<16h', *range(16))
+```pycon
+>>> from bitstring import Bits, BitArray, BitStream, pack
+>>> a = BitArray(bin='00101')
+>>> b = Bits(a_file_object)
+>>> c = BitArray('0xff, 0b101, 0o65, uint6=22')
+>>> d = pack('intle16, hex=a, 0b1', 100, a='0x34f')
+>>> e = pack('<16h', *range(16))
+```
 
 ### Different interpretations, slicing and concatenation
-
-     >>> a = BitArray('0x3348')
-     >>> a.hex, a.bin, a.uint, a.float, a.bytes
-     ('3348', '0011001101001000', 13128, 0.2275390625, b'3H')
-     >>> a[10:3:-1].bin
-     '0101100'
-     >>> '0b100' + 3*a
-     BitArray('0x866906690669, 0b000')
+```pycon
+>>> a = BitArray('0x3348')
+>>> a.hex, a.bin, a.uint, a.float, a.bytes
+('3348', '0011001101001000', 13128, 0.2275390625, b'3H')
+>>> a[10:3:-1].bin
+'0101100'
+>>> '0b100' + 3*a
+BitArray('0x866906690669, 0b000')
+```
 
 ### Reading data sequentially
-
-     >>> b = BitStream('0x160120f')
-     >>> b.read(12).hex
-     '160'
-     >>> b.pos = 0
-     >>> b.read('uint12')
-     352
-     >>> b.readlist('uint12, bin3')
-     [288, '111']
+```pycon
+>>> b = BitStream('0x160120f')
+>>> b.read(12).hex
+'160'
+>>> b.pos = 0
+>>> b.read('uint12')
+352
+>>> b.readlist('uint12, bin3')
+[288, '111']
+```
 
 ### Searching, inserting and deleting
-
-     >>> c = BitArray('0b00010010010010001111')   # c.hex == '0x1248f'
-     >>> c.find('0x48')
-     (8,)
-     >>> c.replace('0b001', '0xabc')
-     >>> c.insert('0b0000', pos=3)
-     >>> del c[12:16]
+```pycon
+>>> c = BitArray('0b00010010010010001111')   # c.hex == '0x1248f'
+>>> c.find('0x48')
+(8,)
+>>> c.replace('0b001', '0xabc')
+>>> c.insert('0b0000', pos=3)
+>>> del c[12:16]
+```
 
 ### Arrays of fixed-length formats
-
-     >>> from bitstring import Array
-     >>> a = Array('uint7', [9, 100, 3, 1])
-     >>> a.data
-     BitArray('0x1390181')
-     >>> a[::2] *= 5
-     >>> a
-     Array('uint7', [45, 100, 15, 1])
-
+```pycon
+>>> from bitstring import Array
+>>> a = Array('uint7', [9, 100, 3, 1])
+>>> a.data
+BitArray('0x1390181')
+>>> a[::2] *= 5
+>>> a
+Array('uint7', [45, 100, 15, 1])
+```
 
 
 <sub>Copyright (c) 2006 - 2024 Scott Griffiths</sub>

{bitstring-4.2.2 → bitstring-4.2.3}/README.md

@@ -16,26 +16,13 @@ It has been actively maintained since 2006.
 [![Pepy Total Downlods](https://img.shields.io/pepy/dt/bitstring?logo=python&logoColor=white&labelColor=blue&color=blue)](https://www.pepy.tech/projects/bitstring)
 [![PyPI - Downloads](https://img.shields.io/pypi/dm/bitstring?label=%40&labelColor=blue&color=blue)](https://pypistats.org/packages/bitstring)
 
-
-News
 ----
-**May 2024**: bitstring 4.2.2 released.
- 
-New in version 4.2:
-
-* Dropped support for Python 3.7. Minimum version is now 3.8.
-* A new `Dtype` class can be optionally used to specify types.
-* The `bitstring.options` object is now the preferred method for changing module options.
-* New `fromstring` method as another way to create bitstrings from formatted strings.
-* More types can now be pretty printed.
-* A range of 8-bit, 6-bit and even 4-bit floating point formats added (beta):
-* Performance improvements.
 
-See the [release notes](https://github.com/scott-griffiths/bitstring/blob/main/release_notes.txt) for details. Please let me know if you encounter any problems.
+> [!NOTE]
+> To see what been added, improved or fixed, and also to see what's coming in the next version, see the [release notes](https://github.com/scott-griffiths/bitstring/blob/main/release_notes.md).
 
 
-Overview
---------
+# Overview
 
 * Efficiently store and manipulate binary data in idiomatic Python.
 * Create bitstrings from hex, octal, binary, files, formatted strings, bytes, integers and floats of different endiannesses.
@@ -46,8 +33,8 @@ Overview
 * Rich API - chances are that whatever you want to do there's a simple and elegant way of doing it.
 * Open source software, released under the MIT licence.
 
-Documentation
--------------
+# Documentation
+
 Extensive documentation for the bitstring module is available.
 Some starting points are given below:
 
@@ -57,67 +44,66 @@ Some starting points are given below:
 
 There is also an introductory walkthrough notebook on [binder](https://mybinder.org/v2/gh/scott-griffiths/bitstring/main?labpath=doc%2Fwalkthrough.ipynb).
 
-Release Notes
--------------
-
-To see what been added, improved or fixed, and also to see what's coming in the next version, see the [release notes](https://github.com/scott-griffiths/bitstring/blob/main/release_notes.txt).
-
-Examples
---------
+# Examples
 
 ### Installation
-
-    $ pip install bitstring
+```
+$ pip install bitstring
+```
 
 ### Creation
-
-     >>> from bitstring import Bits, BitArray, BitStream, pack
-     >>> a = BitArray(bin='00101')
-     >>> b = Bits(a_file_object)
-     >>> c = BitArray('0xff, 0b101, 0o65, uint6=22')
-     >>> d = pack('intle16, hex=a, 0b1', 100, a='0x34f')
-     >>> e = pack('<16h', *range(16))
+```pycon
+>>> from bitstring import Bits, BitArray, BitStream, pack
+>>> a = BitArray(bin='00101')
+>>> b = Bits(a_file_object)
+>>> c = BitArray('0xff, 0b101, 0o65, uint6=22')
+>>> d = pack('intle16, hex=a, 0b1', 100, a='0x34f')
+>>> e = pack('<16h', *range(16))
+```
 
 ### Different interpretations, slicing and concatenation
-
-     >>> a = BitArray('0x3348')
-     >>> a.hex, a.bin, a.uint, a.float, a.bytes
-     ('3348', '0011001101001000', 13128, 0.2275390625, b'3H')
-     >>> a[10:3:-1].bin
-     '0101100'
-     >>> '0b100' + 3*a
-     BitArray('0x866906690669, 0b000')
+```pycon
+>>> a = BitArray('0x3348')
+>>> a.hex, a.bin, a.uint, a.float, a.bytes
+('3348', '0011001101001000', 13128, 0.2275390625, b'3H')
+>>> a[10:3:-1].bin
+'0101100'
+>>> '0b100' + 3*a
+BitArray('0x866906690669, 0b000')
+```
 
 ### Reading data sequentially
-
-     >>> b = BitStream('0x160120f')
-     >>> b.read(12).hex
-     '160'
-     >>> b.pos = 0
-     >>> b.read('uint12')
-     352
-     >>> b.readlist('uint12, bin3')
-     [288, '111']
+```pycon
+>>> b = BitStream('0x160120f')
+>>> b.read(12).hex
+'160'
+>>> b.pos = 0
+>>> b.read('uint12')
+352
+>>> b.readlist('uint12, bin3')
+[288, '111']
+```
 
 ### Searching, inserting and deleting
-
-     >>> c = BitArray('0b00010010010010001111')   # c.hex == '0x1248f'
-     >>> c.find('0x48')
-     (8,)
-     >>> c.replace('0b001', '0xabc')
-     >>> c.insert('0b0000', pos=3)
-     >>> del c[12:16]
+```pycon
+>>> c = BitArray('0b00010010010010001111')   # c.hex == '0x1248f'
+>>> c.find('0x48')
+(8,)
+>>> c.replace('0b001', '0xabc')
+>>> c.insert('0b0000', pos=3)
+>>> del c[12:16]
+```
 
 ### Arrays of fixed-length formats
-
-     >>> from bitstring import Array
-     >>> a = Array('uint7', [9, 100, 3, 1])
-     >>> a.data
-     BitArray('0x1390181')
-     >>> a[::2] *= 5
-     >>> a
-     Array('uint7', [45, 100, 15, 1])
-
+```pycon
+>>> from bitstring import Array
+>>> a = Array('uint7', [9, 100, 3, 1])
+>>> a.data
+BitArray('0x1390181')
+>>> a[::2] *= 5
+>>> a
+Array('uint7', [45, 100, 15, 1])
+```
 
 
 <sub>Copyright (c) 2006 - 2024 Scott Griffiths</sub>

{bitstring-4.2.2 → bitstring-4.2.3}/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.2.3"
 
 __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-4.2.2 → bitstring-4.2.3}/bitstring/__main__.py

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

{bitstring-4.2.2 → bitstring-4.2.3}/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:

{bitstring-4.2.2 → bitstring-4.2.3}/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-4.2.2 → bitstring-4.2.3}/bitstring/bits.py

@@ -1699,34 +1699,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-4.2.2 → bitstring-4.2.3}/bitstring/bitstore.py

@@ -14,7 +14,8 @@ def offset_slice_indices_lsb0(key: slice, length: int) -> slice:
     # 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:
+
+def offset_start_stop_lsb0(start: Optional[int], stop: Optional[int], length: int) -> tuple[int, int]:
     # First convert slice to all integers
     # Length already should take account of the offset
     start, stop, _ = slice(start, stop, None).indices(length)
@@ -218,7 +219,6 @@ class BitStore:
     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 +269,4 @@ class BitStore:
             self._bitarray.__setitem__(key, value)
 
     def delitem_msb0(self, key, /):
-        self._bitarray.__delitem__(key)
+        self._bitarray.__delitem__(key)