Bitstring

Fixing a few regressions introduced in 4.2.0.

* Module crashes on import with 32-bit Python. Bug 317.
* Lists of integers not converted to bytes when using the bytes constructor. Bug 318.
* Empty comma separated tokens not handled correctly. Bug 319.
* Crash on import when docstrings not present due to optimize flag. Bug 321.

This release contains a fairly large refactor of how different types are managed. This
shouldn't affect the end user, and the main noticeable change should be the new `Dtype`
class, which is optional to use.

Support for 8-bit and smaller floats has been reworked and expanded. These are still
a 'beta' feature.

Backwardly incompatible changes:

* Dropped support for Python 3.7. Minimum version is now 3.8.
* For tokens that use a non-numeric length, a ':' is now compulsory rather than
recommended. For example use `'uint:foo'` instead of `'uintfoo'`.
* The previous e4m3float and e5m2float formats have become the slightly modified
p4binary8 and p3binary8 formats.
* Some parameters are now enforced as positional only, such as `auto` in constructors.

Other changes:

* The Array class is no longer 'beta'.

* A new Dtype class can be optionally used to specify types.

* The bitstring.options object is now the preferred method for changing module options.
The `bitstring.lsb0` and `bitstring.bytealigned` variables are now deprecated, use
`bitstring.options.lsb0` and `bitstring.options.bytealigned` instead.

* New fromstring method as another way to create bitstrings from formatted strings.
Instead of relying on the `auto` parameter you can now optionally use `fromstring`.

>>> s1 = BitArray('u24=1000') This is still fine
>>> s2 = BitArray.fromstring('u24=1000') This may be clearer and more efficient.


* More types can now be pretty printed. For example integer and float formats can be used.

>>> s.pp('u15, bin')


* Pretty printing is now prettier - optional terminal colours added.

* A range of 8-bit, 6-bit and even 4-bit float formats added (beta):
`p3binary8`: IEEE 8-bit floating point with 3 bit precision.
`p4binary8`: IEEE 8-bit floating point with 4 bit precision.
`e5m2mxfp`: OCP 8-bit floating point with 3 bit precision.
`e4m3mxfp`: OCP 8-bit floating point with 4 bit precision.
`e2m3mxfp`: OCP 6-bit floating point with 4 bit precision.
`e3m2mxfp`: OCP 6-bit floating point with 3 bit precision.
`e2m1mxfp`: OCP 4-bit floating point with 2 bit precision.
`e8m0mxfp`: OCP 8-bit unsigned floating point designed to scale the other formats.
`mxint`: OCP 8-bit floating point that is a scaled integer representation.

* Performance improvements.

A maintenance release, with some changes to the beta features introduced in 4.1.

* Removed a couple of files that accidentally got included in the previous release. Bug 293.
* The 8-bit float formats have been renamed 'e4m3float' and 'e5m2float'.
* Some refactoring and performance optimizations.

Another maintenance release. Once again some small changes to the 'beta' Array class,
plus new Array functionality.

* Fix for the module command-line usage. Bug 290.
* Fix for when creating bitstrings from memoryview objects.
* Renamed the 'fmt' parameter for Arrays to 'dtype'.
* More Array operator coverage.
* Added operators that act on two Arrays of the same size.
* Added comparison operators for Arrays that return an Array of bools.
* Added Array.equals method as `==` will now return an Array (see above item).
* Added astype() method for Arrays to easily cast to a new dtype.

A maintenance release, with some changes to the Array class which is still in 'beta'.

* bitarray dependency now pinned to ">=2.8.0, <3.0.0" rather than a specific version. Bug 283.
* Fix for using numpy integers as integer parameters. Bug 286.
* Removed ability to extend an Array with the '+' operator. Use the 'extend' method instead.
* Improvements when pretty-printing the Array.
* Array.count() can now count 'nan' values for floating point types.