bitstring 4.4.0__tar.gz → 5.0.0__tar.gz

bitstring-5.0.0/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: bitstring
+Version: 5.0.0
+Summary: Simple construction, analysis and modification of binary data: bit arrays, bitfields and unaligned binary formats.
+Author-email: Scott Griffiths <dr.scottgriffiths@gmail.com>
+License: MIT
+Project-URL: homepage, https://github.com/scott-griffiths/bitstring
+Project-URL: documentation, https://bitstring.readthedocs.io/
+Project-URL: source, https://github.com/scott-griffiths/bitstring
+Project-URL: issues, https://github.com/scott-griffiths/bitstring/issues
+Project-URL: changelog, https://github.com/scott-griffiths/bitstring/blob/main/release_notes.md
+Keywords: binary,bits,bitstring,bit array,bitarray,bit vector,bitvector,bitfield,bitset,bit manipulation,binary parsing,unaligned,packet,struct,endianness,file format
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tibs<3.0,>=2.0.2
+Dynamic: license-file
+
+
+
+![bitstring](https://raw.githubusercontent.com/scott-griffiths/bitstring/main/doc/bitstring_logo_small.png "bitstring")
+
+**bitstring** is a Python library to help make the creation and analysis of all types of bit-level binary data as simple and efficient as possible. It has been actively maintained since 2006.
+
+
+[![CI badge](https://github.com/scott-griffiths/bitstring/actions/workflows/.github/workflows/ci.yml/badge.svg)](https://github.com/scott-griffiths/bitstring/actions/workflows/ci.yml)
+[![Docs](https://img.shields.io/readthedocs/bitstring?logo=readthedocs&logoColor=white)](https://bitstring.readthedocs.io/en/stable/)
+[![Dependents](https://img.shields.io/librariesio/dependents/pypi/bitstring?logo=libraries.io&logoColor=white)](https://libraries.io/pypi/bitstring)
+&nbsp; &nbsp;
+[![Pepy Total Downloads](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)
+
+----
+
+> [!NOTE]
+> To see what's been added, improved or fixed, see the [release notes](https://github.com/scott-griffiths/bitstring/blob/main/release_notes.md).
+
+# Version 5.0
+
+This is a major update with breaking changes.
+
+* Significantly better performance using the new [tibs](https://github.com/scott-griffiths/tibs) Rust core - around 4x faster across the benchmark suite, and far more for bulk `Array` work, searching and packing.
+* A simpler model for sequential reading: `Bits` and `BitArray` store data, while `Reader` stores the current bit position.
+* A clearer, more explicit API for construction, conversion and dtype names.
+* Some things have also been removed, including the `bitarray` dependency, LSB0 mode and the old stream classes.
+
+
+## Upgrading from version 4
+
+Version 5 is worth moving to if you need the improved performance, want the cleaner API and other new features.
+The changes are quite broad, so if your existing code is stable and performance
+is not a problem, there is no need to migrate immediately - pin your dependency to `bitstring<5` to stay on 4.x.
+The 4.x line is maintained on the `4.x-maintenance` branch.
+
+For details on the source changes you may need, see the [Upgrading to version 5](https://bitstring.readthedocs.io/en/stable/upgrading_to_version_5.html) guide.
+
+## What's this 'tibs' thing that everyone is talking about?
+
+bitstring 5 is built on [tibs](https://github.com/scott-griffiths/tibs), a more focussed Python library for
+binary data, written in Rust and highly optimised for speed. It's by the same author as bitstring.
+For new projects, starting with [tibs]([tibs](https://github.com/scott-griffiths/tibs)) could be a better choice in many cases.
+
+
+Tibs has now reached its 2.0 release. Please do try it, as all feedback is welcome.
+
+<a href="https://github.com/scott-griffiths/tibs">
+  <img src="https://raw.githubusercontent.com/scott-griffiths/tibs/main/doc/tibs.png" alt="tibs" width="30%">
+</a>
+
+A sleek Python library for binary data
+
+----
+
+# Bitstring 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.
+* Powerful binary packing and unpacking functions.
+* Bit-level slicing, joining, searching, replacing and more.
+* Create and manipulate arrays of fixed-length bitstrings.
+* Use `Reader` to read from and interpret bitstrings sequentially.
+* 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
+
+Extensive documentation for the bitstring library is available.
+Some starting points:
+
+* [Overview](https://bitstring.readthedocs.io/en/stable/index.html)
+* [Quick reference](https://bitstring.readthedocs.io/en/stable/quick_reference.html)
+* [Upgrading from 4.x to 5.0](https://bitstring.readthedocs.io/en/stable/upgrading_to_version_5.html)
+* [Version 4.4 documentation](https://bitstring.readthedocs.io/en/4.4.0/)
+
+There is also an introductory walkthrough notebook on [binder](https://mybinder.org/v2/gh/scott-griffiths/bitstring/main?labpath=doc%2Fwalkthrough.ipynb).
+
+# Examples
+
+### Creation
+```pycon
+>>> from bitstring import Bits, BitArray, Reader, pack
+>>> a = BitArray(bin='00101')
+>>> b = Bits.from_file(a_file_object)
+>>> c = BitArray('0xff, 0b101, 0o65, u6=22')
+>>> d = pack('ile16, hex=a, 0b1', 100, a='0x34f')
+>>> e = pack('<16h', *range(16))
+```
+
+### Different interpretations, slicing and concatenation
+```pycon
+>>> a = BitArray('0x3348')
+>>> a.hex, a.bin, a.u, a.f, a.bytes
+('3348', '0011001101001000', 13128, 0.2275390625, b'3H')
+>>> a[10:3:-1].bin
+'0101100'
+>>> '0b100' + 3*a
+BitArray('0x866906690669, 0b000')
+```
+
+### Reading data sequentially
+```pycon
+>>> b = Reader(Bits('0x160120f'))
+>>> b.read_bits(12).hex
+'160'
+>>> b.pos = 0
+>>> b.read_value('u12')
+352
+>>> b.read_list('u12, bin3')
+[288, '111']
+```
+
+### Searching, inserting and deleting
+```pycon
+>>> c = BitArray('0b00010010010010001111')   # c.hex == '0x1248f'
+>>> c.find('0x48')
+8
+>>> c.replace('0b001', '0xabc')
+5
+>>> c.insert(3, '0b0000')
+>>> del c[12:16]
+```
+
+### Arrays of fixed-length formats
+```pycon
+>>> from bitstring import Array
+>>> a = Array('u7', [9, 100, 3, 1])
+>>> a.data
+BitArray('0x1390181')
+>>> a[::2] *= 5
+>>> a
+Array('u7', [45, 100, 15, 1])
+```
+
+
+<sub>Copyright (c) 2006 - 2026 Scott Griffiths</sub>

bitstring-5.0.0/README.md

@@ -0,0 +1,137 @@
+
+
+![bitstring](https://raw.githubusercontent.com/scott-griffiths/bitstring/main/doc/bitstring_logo_small.png "bitstring")
+
+**bitstring** is a Python library to help make the creation and analysis of all types of bit-level binary data as simple and efficient as possible. It has been actively maintained since 2006.
+
+
+[![CI badge](https://github.com/scott-griffiths/bitstring/actions/workflows/.github/workflows/ci.yml/badge.svg)](https://github.com/scott-griffiths/bitstring/actions/workflows/ci.yml)
+[![Docs](https://img.shields.io/readthedocs/bitstring?logo=readthedocs&logoColor=white)](https://bitstring.readthedocs.io/en/stable/)
+[![Dependents](https://img.shields.io/librariesio/dependents/pypi/bitstring?logo=libraries.io&logoColor=white)](https://libraries.io/pypi/bitstring)
+   
+[![Pepy Total Downloads](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)
+
+----
+
+> [!NOTE]
+> To see what's been added, improved or fixed, see the [release notes](https://github.com/scott-griffiths/bitstring/blob/main/release_notes.md).
+
+# Version 5.0
+
+This is a major update with breaking changes.
+
+* Significantly better performance using the new [tibs](https://github.com/scott-griffiths/tibs) Rust core - around 4x faster across the benchmark suite, and far more for bulk `Array` work, searching and packing.
+* A simpler model for sequential reading: `Bits` and `BitArray` store data, while `Reader` stores the current bit position.
+* A clearer, more explicit API for construction, conversion and dtype names.
+* Some things have also been removed, including the `bitarray` dependency, LSB0 mode and the old stream classes.
+
+
+## Upgrading from version 4
+
+Version 5 is worth moving to if you need the improved performance, want the cleaner API and other new features.
+The changes are quite broad, so if your existing code is stable and performance
+is not a problem, there is no need to migrate immediately - pin your dependency to `bitstring<5` to stay on 4.x.
+The 4.x line is maintained on the `4.x-maintenance` branch.
+
+For details on the source changes you may need, see the [Upgrading to version 5](https://bitstring.readthedocs.io/en/stable/upgrading_to_version_5.html) guide.
+
+## What's this 'tibs' thing that everyone is talking about?
+
+bitstring 5 is built on [tibs](https://github.com/scott-griffiths/tibs), a more focussed Python library for
+binary data, written in Rust and highly optimised for speed. It's by the same author as bitstring.
+For new projects, starting with [tibs]([tibs](https://github.com/scott-griffiths/tibs)) could be a better choice in many cases.
+
+
+Tibs has now reached its 2.0 release. Please do try it, as all feedback is welcome.
+
+<a href="https://github.com/scott-griffiths/tibs">
+  <img src="https://raw.githubusercontent.com/scott-griffiths/tibs/main/doc/tibs.png" alt="tibs" width="30%">
+</a>
+
+A sleek Python library for binary data
+
+----
+
+# Bitstring 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.
+* Powerful binary packing and unpacking functions.
+* Bit-level slicing, joining, searching, replacing and more.
+* Create and manipulate arrays of fixed-length bitstrings.
+* Use `Reader` to read from and interpret bitstrings sequentially.
+* 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
+
+Extensive documentation for the bitstring library is available.
+Some starting points:
+
+* [Overview](https://bitstring.readthedocs.io/en/stable/index.html)
+* [Quick reference](https://bitstring.readthedocs.io/en/stable/quick_reference.html)
+* [Upgrading from 4.x to 5.0](https://bitstring.readthedocs.io/en/stable/upgrading_to_version_5.html)
+* [Version 4.4 documentation](https://bitstring.readthedocs.io/en/4.4.0/)
+
+There is also an introductory walkthrough notebook on [binder](https://mybinder.org/v2/gh/scott-griffiths/bitstring/main?labpath=doc%2Fwalkthrough.ipynb).
+
+# Examples
+
+### Creation
+```pycon
+>>> from bitstring import Bits, BitArray, Reader, pack
+>>> a = BitArray(bin='00101')
+>>> b = Bits.from_file(a_file_object)
+>>> c = BitArray('0xff, 0b101, 0o65, u6=22')
+>>> d = pack('ile16, hex=a, 0b1', 100, a='0x34f')
+>>> e = pack('<16h', *range(16))
+```
+
+### Different interpretations, slicing and concatenation
+```pycon
+>>> a = BitArray('0x3348')
+>>> a.hex, a.bin, a.u, a.f, a.bytes
+('3348', '0011001101001000', 13128, 0.2275390625, b'3H')
+>>> a[10:3:-1].bin
+'0101100'
+>>> '0b100' + 3*a
+BitArray('0x866906690669, 0b000')
+```
+
+### Reading data sequentially
+```pycon
+>>> b = Reader(Bits('0x160120f'))
+>>> b.read_bits(12).hex
+'160'
+>>> b.pos = 0
+>>> b.read_value('u12')
+352
+>>> b.read_list('u12, bin3')
+[288, '111']
+```
+
+### Searching, inserting and deleting
+```pycon
+>>> c = BitArray('0b00010010010010001111')   # c.hex == '0x1248f'
+>>> c.find('0x48')
+8
+>>> c.replace('0b001', '0xabc')
+5
+>>> c.insert(3, '0b0000')
+>>> del c[12:16]
+```
+
+### Arrays of fixed-length formats
+```pycon
+>>> from bitstring import Array
+>>> a = Array('u7', [9, 100, 3, 1])
+>>> a.data
+BitArray('0x1390181')
+>>> a[::2] *= 5
+>>> a
+Array('u7', [45, 100, 15, 1])
+```
+
+
+<sub>Copyright (c) 2006 - 2026 Scott Griffiths</sub>

bitstring-5.0.0/bitstring/__init__.py

@@ -0,0 +1,337 @@
+#!/usr/bin/env python
+r"""
+This package defines classes that simplify bit-wise creation, manipulation and
+interpretation of data. Lengths and positions are in bits throughout, so fields
+need not be byte aligned.
+
+Classes:
+
+Bits -- An immutable container for binary data.
+BitArray -- A mutable container for binary data. Adds in-place methods such as
+            append, insert, overwrite, replace and set to those of Bits.
+Reader -- Wraps a Bits or BitArray with a bit position for sequential reading.
+Array -- An efficient list-like container where each item has a fixed-length binary format.
+Dtype -- A data type such as 'u12', 'f32' or 'hex', used to create and interpret bits.
+
+Functions:
+
+pack -- Create a Bits object from a format string and values.
+
+Exceptions:
+
+ReadError -- Reading or peeking past the end of a bitstring. Subclasses ValueError.
+
+Creation:
+
+Bits('0x4f8e220')                 -- from a string of hex, '0b' binary or '0o' octal.
+Bits('0b101, u12=100, f32=0.25')  -- comma-separated tokens, each a literal or dtype=value.
+Bits(u=100, length=12)            -- from a single keyword value.
+Bits.from_bytes(b), Bits.from_file(path), Bits.from_zeros(n), Bits.from_dtype('i8', -1)
+pack('u12, f32, bool', 100, 0.25, True)
+
+Interpretation:
+
+Properties such as .hex, .bin, .bytes, .u, .i and .f interpret the whole
+bitstring. Endian variants include .ule, .ibe and .fle. Use unpack() to
+interpret it as several fields, or a Reader to read fields one at a time.
+
+Example:
+
+>>> from bitstring import Bits, BitArray, Reader, Array, pack
+>>> s = Bits('0x4f8e220')
+>>> s.unpack('u12, hex8, bin')
+[1272, 'e2', '00100000']
+>>> s[:12].u
+1272
+>>> r = Reader(pack('u12, f32, bool', 100, 0.25, True))
+>>> r.read_value('u12'), r.read_value('f32'), r.read_value('bool')
+(100, 0.25, True)
+>>> b = BitArray('0x0f')
+>>> b.insert(4, '0b11')
+>>> b.bin
+'0000111111'
+>>> Array('u5', [1, 2, 31]).data
+BitArray('0b000010001011111')
+
+The core is the tibs Rust library (https://github.com/scott-griffiths/tibs),
+which can also be used directly for performance-critical bit work.
+
+Documentation: https://bitstring.readthedocs.io/
+https://github.com/scott-griffiths/bitstring
+"""
+
+__licence__ = """
+The MIT License
+
+Copyright (c) 2006 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.
+"""
+
+__version__ = "5.0.0"
+
+__author__ = "Scott Griffiths"
+
+import bitstring.bitstore as bitstore  # noqa: F401 - the core must be initialised before the classes that use it.
+
+from .bits import Bits
+from .bitarray_ import BitArray
+from .reader import Reader
+from .methods import pack
+from .array_ import Array
+from .exceptions import ReadError
+from .dtypes import DtypeDefinition as _DtypeDefinition, dtype_register as _dtype_register, Dtype
+from typing import Literal as _Literal
+
+# 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]:
+        return 23  # Empirical value
+    else:
+        return 24  # Empirical value
+
+
+def _p3binary_bits2chars(_: _Literal[8]):
+    return 19  # Empirical value
+
+
+def _p4binary_bits2chars(_: _Literal[8]):
+    # Found by looking at all the possible values
+    return 13  # Empirical value
+
+
+def _e4m3mxfp_bits2chars(_: _Literal[8]):
+    return 13
+
+
+def _e5m2mxfp_bits2chars(_: _Literal[8]):
+    return 19
+
+
+def _e3m2mxfp_bits2chars(_: _Literal[6]):
+    # Not sure what the best value is here.
+    return 7
+
+
+def _e2m3mxfp_bits2chars(_: _Literal[6]):
+    # Not sure what the best value is here.
+    return 7
+
+
+def _e2m1mxfp_bits2chars(_: _Literal[4]):
+    # Not sure what the best value is here.
+    return 7
+
+
+def _e8m0mxfp_bits2chars(_: _Literal[8]):
+    # Has same range as float32
+    return 23
+
+
+def _mxint_bits2chars(_: _Literal[8]):
+    # Not sure what the best value is here.
+    return 10
+
+
+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.from_zeros(bitlength)
+    return len(str(temp))
+
+
+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('u', Bits._setuint, Bits._getuint, int, False, _uint_bits2chars,
+                    read_fn=Bits._readuint,
+                    allowed_lengths=(1, 2, ...), description="a two's complement unsigned int"),
+    _DtypeDefinition('ule', Bits._setuintle, Bits._getuintle, int, False, _uint_bits2chars,
+                    read_fn=Bits._readuintle,
+                    allowed_lengths=(8, 16, 24, ...), description="a two's complement little-endian unsigned int"),
+    _DtypeDefinition('ube', Bits._setuintbe, Bits._getuintbe, int, False, _uint_bits2chars,
+                    read_fn=Bits._readuintbe,
+                    allowed_lengths=(8, 16, 24, ...), description="a two's complement big-endian unsigned int"),
+    _DtypeDefinition('i', Bits._setint, Bits._getint, int, True, _int_bits2chars,
+                    read_fn=Bits._readint,
+                    allowed_lengths=(1, 2, ...), description="a two's complement signed int"),
+    _DtypeDefinition('ile', Bits._setintle, Bits._getintle, int, True, _int_bits2chars,
+                    read_fn=Bits._readintle,
+                    allowed_lengths=(8, 16, 24, ...), description="a two's complement little-endian signed int"),
+    _DtypeDefinition('ibe', Bits._setintbe, Bits._getintbe, int, True, _int_bits2chars,
+                    read_fn=Bits._readintbe,
+                    allowed_lengths=(8, 16, 24, ...), description="a two's complement big-endian signed int"),
+    # String types
+    _DtypeDefinition('hex', Bits._sethex, Bits._gethex, str, False, _hex_bits2chars,
+                    read_fn=Bits._readhex,
+                    allowed_lengths=(0, 4, 8, ...), description="a hexadecimal string"),
+    _DtypeDefinition('bin', Bits._setbin, Bits._getbin, str, False, _bin_bits2chars,
+                    read_fn=Bits._readbin,
+                    description="a binary string"),
+    _DtypeDefinition('oct', Bits._setoct, Bits._getoct, str, False, _oct_bits2chars,
+                    read_fn=Bits._readoct,
+                    allowed_lengths=(0, 3, 6, ...), description="an octal string"),
+    # Float types
+    _DtypeDefinition('f', Bits._setfloatbe, Bits._getfloatbe, float, True, _float_bits2chars,
+                    read_fn=Bits._readfloatbe,
+                    allowed_lengths=(16, 32, 64), description="a big-endian floating point number"),
+    _DtypeDefinition('fle', Bits._setfloatle, Bits._getfloatle, float, True, _float_bits2chars,
+                    read_fn=Bits._readfloatle,
+                    allowed_lengths=(16, 32, 64), description="a little-endian floating point number"),
+    _DtypeDefinition('bfloat', Bits._setbfloatbe, Bits._getbfloatbe, float, True, _bfloat_bits2chars,
+                    read_fn=Bits._readbfloatbe,
+                    allowed_lengths=(16,), description="a 16 bit big-endian bfloat floating point number"),
+    _DtypeDefinition('bfloatle', Bits._setbfloatle, Bits._getbfloatle, float, True, _bfloat_bits2chars,
+                    read_fn=Bits._readbfloatle,
+                    allowed_lengths=(16,), description="a 16 bit little-endian bfloat floating point number"),
+    # Other known length types
+    _DtypeDefinition('bits', Bits._setbits, Bits._getbits, Bits, False, _bits_bits2chars,
+                    is_property=False, description="a bitstring object"),
+    _DtypeDefinition('bool', Bits._setbool, Bits._getbool, bool, False, _bool_bits2chars,
+                    read_fn=Bits._readbool,
+                    allowed_lengths=(1,), description="a bool (True or False)"),
+    _DtypeDefinition('bytes', Bits._setbytes, Bits._getbytes, bytes, False, _bytes_bits2chars,
+                    read_fn=Bits._readbytes,
+                    multiplier=8, description="a bytes object"),
+    # Unknown length types
+    _DtypeDefinition('se', Bits._setse, Bits._getse, int, True, None,
+                    read_fn=Bits._readse, variable_length=True, description="a signed exponential-Golomb code"),
+    _DtypeDefinition('ue', Bits._setue, Bits._getue, int, False, None,
+                    read_fn=Bits._readue, variable_length=True, description="an unsigned exponential-Golomb code"),
+    _DtypeDefinition('sie', Bits._setsie, Bits._getsie, int, True, None,
+                    read_fn=Bits._readsie, variable_length=True, description="a signed interleaved exponential-Golomb code"),
+    _DtypeDefinition('uie', Bits._setuie, Bits._getuie, int, False, None,
+                    read_fn=Bits._readuie, variable_length=True, description="an unsigned interleaved exponential-Golomb code"),
+    # Special case pad type
+    _DtypeDefinition('pad', Bits._setpad, Bits._getpad, None, False, None,
+                    read_fn=Bits._readpad, is_property=False,
+                    description="a skipped section of padding"),
+
+    # MXFP and IEEE 8-bit float types
+    _DtypeDefinition('p3binary', Bits._setp3binary, Bits._getp3binary, float, True, _p3binary_bits2chars,
+                    read_fn=Bits._readp3binary,
+                    allowed_lengths=(8,), description="an 8 bit float with binary8p3 format"),
+    _DtypeDefinition('p4binary', Bits._setp4binary, Bits._getp4binary, float, True, _p4binary_bits2chars,
+                    read_fn=Bits._readp4binary,
+                    allowed_lengths=(8,), description="an 8 bit float with binary8p4 format"),
+    _DtypeDefinition('e4m3mxfp_saturate', Bits._sete4m3mxfp_saturate, Bits._gete4m3mxfp, float, True, _e4m3mxfp_bits2chars,
+                    read_fn=Bits._reade4m3mxfp,
+                    allowed_lengths=(8,), description="an 8 bit float with MXFP E4M3 format, saturating out-of-range values"),
+    _DtypeDefinition('e4m3mxfp_overflow', Bits._sete4m3mxfp_overflow, Bits._gete4m3mxfp, float, True, _e4m3mxfp_bits2chars,
+                    read_fn=Bits._reade4m3mxfp,
+                    allowed_lengths=(8,), description="an 8 bit float with MXFP E4M3 format, overflowing out-of-range values to NaN"),
+    _DtypeDefinition('e5m2mxfp_saturate', Bits._sete5m2mxfp_saturate, Bits._gete5m2mxfp, float, True, _e5m2mxfp_bits2chars,
+                    read_fn=Bits._reade5m2mxfp,
+                    allowed_lengths=(8,), description="an 8 bit float with MXFP E5M2 format, saturating out-of-range values"),
+    _DtypeDefinition('e5m2mxfp_overflow', Bits._sete5m2mxfp_overflow, Bits._gete5m2mxfp, float, True, _e5m2mxfp_bits2chars,
+                    read_fn=Bits._reade5m2mxfp,
+                    allowed_lengths=(8,), description="an 8 bit float with MXFP E5M2 format, overflowing out-of-range values to ±inf"),
+    _DtypeDefinition('e3m2mxfp', Bits._sete3m2mxfp, Bits._gete3m2mxfp, float, True, _e3m2mxfp_bits2chars,
+                    read_fn=Bits._reade3m2mxfp,
+                    allowed_lengths=(6,), description="a 6 bit float with MXFP E3M2 format"),
+    _DtypeDefinition('e2m3mxfp', Bits._sete2m3mxfp, Bits._gete2m3mxfp, float, True, _e2m3mxfp_bits2chars,
+                    read_fn=Bits._reade2m3mxfp,
+                    allowed_lengths=(6,), description="a 6 bit float with MXFP E2M3 format"),
+    _DtypeDefinition('e2m1mxfp', Bits._sete2m1mxfp, Bits._gete2m1mxfp, float, True, _e2m1mxfp_bits2chars,
+                    read_fn=Bits._reade2m1mxfp,
+                    allowed_lengths=(4,), description="a 4 bit float with MXFP E2M1 format"),
+    _DtypeDefinition('e8m0mxfp', Bits._sete8m0mxfp, Bits._gete8m0mxfp, float, False, _e8m0mxfp_bits2chars,
+                    read_fn=Bits._reade8m0mxfp,
+                    allowed_lengths=(8,), description="an 8 bit float with MXFP E8M0 format"),
+    _DtypeDefinition('mxint', Bits._setmxint, Bits._getmxint, float, True, _mxint_bits2chars,
+                    read_fn=Bits._readmxint,
+                    allowed_lengths=(8,), description="an 8 bit float with MXFP INT8 format"),
+]
+
+
+_aliases: list[tuple[str, str]] = [
+    # Floats default to big endian
+    ('f', 'float'),
+    ('f', 'floatbe'),
+    ('f', 'fbe'),
+    ('bfloat', 'bfloatbe'),
+
+    # Longer compatibility aliases for the short core type names
+    ('i', 'int'),
+    ('u', 'uint'),
+
+    # Longer compatibility aliases for endian-specific type names
+    ('ube', 'uintbe'),
+    ('ule', 'uintle'),
+    ('ibe', 'intbe'),
+    ('ile', 'intle'),
+    ('fle', 'floatle'),
+]
+
+
+for _dt in _dtype_definitions:
+    _dtype_register.add_dtype(_dt)
+for _alias in _aliases:
+    _dtype_register.add_dtype_alias(_alias[0], _alias[1])
+del _dt, _alias
+
+_property_docstrings = [f'{name} -- Interpret as {_dtype_register[name].description}.'
+                        for name in _dtype_register.names if _dtype_register[name].is_property]
+_property_docstring = '\n    '.join(_property_docstrings)
+
+# We can't be sure the docstrings are present, as it might be compiled without docstrings.
+if Bits.__doc__ is not None:
+    Bits.__doc__ = Bits.__doc__.replace('[GENERATED_PROPERTY_DESCRIPTIONS]', _property_docstring)
+if BitArray.__doc__ is not None:
+    BitArray.__doc__ = BitArray.__doc__.replace('[GENERATED_PROPERTY_DESCRIPTIONS]', _property_docstring)
+__all__ = ['Reader', 'BitArray', 'Array',
+           'Bits', 'pack', 'ReadError', 'Dtype']