bitarray 3.12.0__tar.gz → 3.12.2__tar.gz

{bitarray-3.12.0 → bitarray-3.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitarray
-Version: 3.12.0
+Version: 3.12.2
 Summary: efficient arrays of booleans -- C extension
 Home-page: https://github.com/ilanschnell/bitarray
 Author: Ilan Schnell
@@ -57,11 +57,12 @@ Key features
   their in-place versions ``&=``, ``|=``, ``^=``, ``<<=``, ``>>=``).
 * `Free-threading support <https://github.com/ilanschnell/bitarray/blob/master/doc/free_threading.rst>`__
   (for GIL-disabled CPython 3.14 and later)
-* Fast methods for encoding and decoding variable-length prefix codes.
+* Fast methods for encoding and decoding variable-length
+  `prefix codes <https://github.com/ilanschnell/bitarray/blob/master/doc/prefix_codes.rst>`__.
 * Bitarray objects support the `buffer protocol <https://github.com/ilanschnell/bitarray/blob/master/doc/buffer.rst>`__
   (both importing and exporting buffers).
 * Efficient packing and unpacking for interoperability with byte-oriented
-  objects such as NumPy arrays.
+  objects such as `NumPy arrays <https://github.com/ilanschnell/bitarray/blob/master/doc/ndarray.rst>`__.
 * Pickling and unpickling of bitarray objects.
 * Immutable ``frozenbitarray`` objects which are hashable
 * Fast searching for bits and bit patterns
@@ -100,8 +101,8 @@ Once you have installed the package, you may want to test it:
     $ python -c 'import bitarray; bitarray.test()'
     bitarray is installed in: /Users/ilan/bitarray/bitarray
     sys.prefix: /Users/ilan/miniforge
-    bitarray version: 3.12.0
-    sys.version: 3.14.5 (main, May 20 2026) [Clang 20.1.8]
+    bitarray version: 3.12.2
+    sys.version: 3.15.0 (main, Oct  9 2026) [Clang 21.1.8]
     sys.abiflags: ''
     sys._is_gil_enabled(): True
     pointer size: 64 bit
@@ -117,7 +118,7 @@ Once you have installed the package, you may want to test it:
     ..........s.....................................s........................
     ......s.........................................................
     ----------------------------------------------------------------------
-    Ran 711 tests in 0.196s
+    Ran 711 tests in 0.161s
 
     OK (skipped=4)
 
@@ -289,59 +290,6 @@ this topic, please read `buffer protocol <https://github.com/ilanschnell/bitarra
 to memory-map a file to a bitarray: `mmapped-file.py <https://github.com/ilanschnell/bitarray/blob/master/examples/mmapped-file.py>`__
 
 
-Variable-length prefix codes
-----------------------------
-
-The ``.encode()`` method takes a dictionary mapping symbols to bitarrays
-and an iterable, and extends the bitarray object with the encoded symbols
-found while iterating.  For example:
-
-.. code-block:: python
-
-    >>> d = {'H':bitarray('111'), 'e':bitarray('0'),
-    ...      'l':bitarray('110'), 'o':bitarray('10')}
-    ...
-    >>> a = bitarray()
-    >>> a.encode(d, 'Hello')
-    >>> a
-    bitarray('111011011010')
-
-Note that the string ``'Hello'`` is an iterable, but the symbols are not
-limited to characters, in fact any immutable Python object can be a symbol.
-Taking the same dictionary, we can apply the ``.decode()`` method which will
-return an iterable of the symbols:
-
-.. code-block:: python
-
-    >>> list(a.decode(d))
-    ['H', 'e', 'l', 'l', 'o']
-    >>> ''.join(a.decode(d))
-    'Hello'
-
-Symbols are not limited to being characters.
-The above dictionary ``d`` can be efficiently constructed using the function
-``bitarray.util.huffman_code()``.  I also wrote `Huffman coding in Python
-using bitarray <http://ilan.schnell-web.net/prog/huffman/>`__ for more
-background information.
-
-When the codes are large, and you have many decode calls, most time will
-be spent creating the (same) internal decode tree objects.  In this case,
-it will be much faster to create a ``decodetree`` object, which can be
-passed to bitarray's ``.decode()`` method, instead of passing the prefix
-code dictionary to those methods itself:
-
-.. code-block:: python
-
-    >>> from bitarray import bitarray, decodetree
-    >>> t = decodetree({'a': bitarray('0'), 'b': bitarray('1')})
-    >>> a = bitarray('0110')
-    >>> list(a.decode(t))
-    ['a', 'b', 'b', 'a']
-
-The sole purpose of the immutable ``decodetree`` object is to be passed
-to bitarray's ``.decode()`` method.
-
-
 Frozenbitarrays
 ---------------
 
@@ -364,7 +312,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.12.0 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.12.2 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
 
 In the following, ``item`` and ``value`` are usually a single bit -
 an integer 0 or 1.
@@ -475,7 +423,7 @@ bitarray methods:
    corresponding symbols.
    The prefix code length cannot exceed 256 bits.
 
-   See also: `Bitarray 3 transition <https://github.com/ilanschnell/bitarray/blob/master/doc/bitarray3.rst>`__
+   See also: `Bitarray 3 transition <https://github.com/ilanschnell/bitarray/blob/master/doc/bitarray3.rst>`__, `Variable-length prefix codes <https://github.com/ilanschnell/bitarray/blob/master/doc/prefix_codes.rst>`__
 
    New in version 3.0: returns iterator (equivalent to past ``.iterdecode()``)
 
@@ -487,6 +435,8 @@ bitarray methods:
    iterate over the iterable object with symbols, and extend bitarray
    with corresponding bitarray for each symbol.
 
+   See also: `Variable-length prefix codes <https://github.com/ilanschnell/bitarray/blob/master/doc/prefix_codes.rst>`__
+
 
 ``extend(iterable, /)``
    Append items from iterable to the end of the bitarray.
@@ -725,6 +675,8 @@ Other objects:
    create a binary tree object to be passed to ``.decode()``.
    The prefix code length cannot exceed 256 bits.
 
+   See also: `Variable-length prefix codes <https://github.com/ilanschnell/bitarray/blob/master/doc/prefix_codes.rst>`__
+
    New in version 1.6
 
 
@@ -911,6 +863,8 @@ This sub-module was added in version 1.2.
    frozenbitarrays (with given bit-endianness).  Note that the symbols are not
    limited to being strings.  Symbols may be any hashable object.
 
+   See also: `Variable-length prefix codes <https://github.com/ilanschnell/bitarray/blob/master/doc/prefix_codes.rst>`__
+
    New in version 3.10: return a codedict mapping to frozenbitarrays
 
 

{bitarray-3.12.0 → bitarray-3.12.2}/README.rst

@@ -21,11 +21,12 @@ Key features
   their in-place versions ``&=``, ``|=``, ``^=``, ``<<=``, ``>>=``).
 * `Free-threading support <https://github.com/ilanschnell/bitarray/blob/master/doc/free_threading.rst>`__
   (for GIL-disabled CPython 3.14 and later)
-* Fast methods for encoding and decoding variable-length prefix codes.
+* Fast methods for encoding and decoding variable-length
+  `prefix codes <https://github.com/ilanschnell/bitarray/blob/master/doc/prefix_codes.rst>`__.
 * Bitarray objects support the `buffer protocol <https://github.com/ilanschnell/bitarray/blob/master/doc/buffer.rst>`__
   (both importing and exporting buffers).
 * Efficient packing and unpacking for interoperability with byte-oriented
-  objects such as NumPy arrays.
+  objects such as `NumPy arrays <https://github.com/ilanschnell/bitarray/blob/master/doc/ndarray.rst>`__.
 * Pickling and unpickling of bitarray objects.
 * Immutable ``frozenbitarray`` objects which are hashable
 * Fast searching for bits and bit patterns
@@ -64,8 +65,8 @@ Once you have installed the package, you may want to test it:
     $ python -c 'import bitarray; bitarray.test()'
     bitarray is installed in: /Users/ilan/bitarray/bitarray
     sys.prefix: /Users/ilan/miniforge
-    bitarray version: 3.12.0
-    sys.version: 3.14.5 (main, May 20 2026) [Clang 20.1.8]
+    bitarray version: 3.12.2
+    sys.version: 3.15.0 (main, Oct  9 2026) [Clang 21.1.8]
     sys.abiflags: ''
     sys._is_gil_enabled(): True
     pointer size: 64 bit
@@ -81,7 +82,7 @@ Once you have installed the package, you may want to test it:
     ..........s.....................................s........................
     ......s.........................................................
     ----------------------------------------------------------------------
-    Ran 711 tests in 0.196s
+    Ran 711 tests in 0.161s
 
     OK (skipped=4)
 
@@ -253,59 +254,6 @@ this topic, please read `buffer protocol <https://github.com/ilanschnell/bitarra
 to memory-map a file to a bitarray: `mmapped-file.py <https://github.com/ilanschnell/bitarray/blob/master/examples/mmapped-file.py>`__
 
 
-Variable-length prefix codes
-----------------------------
-
-The ``.encode()`` method takes a dictionary mapping symbols to bitarrays
-and an iterable, and extends the bitarray object with the encoded symbols
-found while iterating.  For example:
-
-.. code-block:: python
-
-    >>> d = {'H':bitarray('111'), 'e':bitarray('0'),
-    ...      'l':bitarray('110'), 'o':bitarray('10')}
-    ...
-    >>> a = bitarray()
-    >>> a.encode(d, 'Hello')
-    >>> a
-    bitarray('111011011010')
-
-Note that the string ``'Hello'`` is an iterable, but the symbols are not
-limited to characters, in fact any immutable Python object can be a symbol.
-Taking the same dictionary, we can apply the ``.decode()`` method which will
-return an iterable of the symbols:
-
-.. code-block:: python
-
-    >>> list(a.decode(d))
-    ['H', 'e', 'l', 'l', 'o']
-    >>> ''.join(a.decode(d))
-    'Hello'
-
-Symbols are not limited to being characters.
-The above dictionary ``d`` can be efficiently constructed using the function
-``bitarray.util.huffman_code()``.  I also wrote `Huffman coding in Python
-using bitarray <http://ilan.schnell-web.net/prog/huffman/>`__ for more
-background information.
-
-When the codes are large, and you have many decode calls, most time will
-be spent creating the (same) internal decode tree objects.  In this case,
-it will be much faster to create a ``decodetree`` object, which can be
-passed to bitarray's ``.decode()`` method, instead of passing the prefix
-code dictionary to those methods itself:
-
-.. code-block:: python
-
-    >>> from bitarray import bitarray, decodetree
-    >>> t = decodetree({'a': bitarray('0'), 'b': bitarray('1')})
-    >>> a = bitarray('0110')
-    >>> list(a.decode(t))
-    ['a', 'b', 'b', 'a']
-
-The sole purpose of the immutable ``decodetree`` object is to be passed
-to bitarray's ``.decode()`` method.
-
-
 Frozenbitarrays
 ---------------
 
@@ -328,7 +276,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.12.0 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.12.2 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
 
 In the following, ``item`` and ``value`` are usually a single bit -
 an integer 0 or 1.
@@ -439,7 +387,7 @@ bitarray methods:
    corresponding symbols.
    The prefix code length cannot exceed 256 bits.
 
-   See also: `Bitarray 3 transition <https://github.com/ilanschnell/bitarray/blob/master/doc/bitarray3.rst>`__
+   See also: `Bitarray 3 transition <https://github.com/ilanschnell/bitarray/blob/master/doc/bitarray3.rst>`__, `Variable-length prefix codes <https://github.com/ilanschnell/bitarray/blob/master/doc/prefix_codes.rst>`__
 
    New in version 3.0: returns iterator (equivalent to past ``.iterdecode()``)
 
@@ -451,6 +399,8 @@ bitarray methods:
    iterate over the iterable object with symbols, and extend bitarray
    with corresponding bitarray for each symbol.
 
+   See also: `Variable-length prefix codes <https://github.com/ilanschnell/bitarray/blob/master/doc/prefix_codes.rst>`__
+
 
 ``extend(iterable, /)``
    Append items from iterable to the end of the bitarray.
@@ -689,6 +639,8 @@ Other objects:
    create a binary tree object to be passed to ``.decode()``.
    The prefix code length cannot exceed 256 bits.
 
+   See also: `Variable-length prefix codes <https://github.com/ilanschnell/bitarray/blob/master/doc/prefix_codes.rst>`__
+
    New in version 1.6
 
 
@@ -875,6 +827,8 @@ This sub-module was added in version 1.2.
    frozenbitarrays (with given bit-endianness).  Note that the symbols are not
    limited to being strings.  Symbols may be any hashable object.
 
+   See also: `Variable-length prefix codes <https://github.com/ilanschnell/bitarray/blob/master/doc/prefix_codes.rst>`__
+
    New in version 3.10: return a codedict mapping to frozenbitarrays
 
 

{bitarray-3.12.0 → bitarray-3.12.2}/bitarray/_bitarray.c

@@ -236,7 +236,7 @@ shift_r8le(unsigned char *buff, Py_ssize_t n, int k)
         if (n || w)               /* add shifted next lower byte */
             buff[i] |= buff[i - 1] >> (8 - k);
     }
-    assert(w == 0 || ((uintptr_t) buff) % 4 == 0);
+    assert(w == 0 || ((uintptr_t) buff) % 8 == 0);
     while (w--) {                 /* shift in word-range(0, w) */
         uint64_t *p = ((uint64_t *) buff) + w;
 #if HAVE_BUILTIN_BSWAP64 && PY_BIG_ENDIAN
@@ -266,7 +266,7 @@ shift_r8be(unsigned char *buff, Py_ssize_t n, int k)
         if (n || w)               /* add shifted next lower byte */
             buff[i] |= buff[i - 1] << (8 - k);
     }
-    assert(w == 0 || ((uintptr_t) buff) % 4 == 0);
+    assert(w == 0 || ((uintptr_t) buff) % 8 == 0);
     while (w--) {                 /* shift in word-range(0, w) */
         uint64_t *p = ((uint64_t *) buff) + w;
 #if HAVE_BUILTIN_BSWAP64 && PY_LITTLE_ENDIAN

{bitarray-3.12.0 → bitarray-3.12.2}/bitarray/_util.c

@@ -854,6 +854,12 @@ When grouped, the string `sep` is inserted between groups\n\
 of `group` characters, default is a space.");
 
 
+static int
+ascii_isspace(unsigned char c)  /* Py_ISSPACE is not defined on PyPy */
+{
+    return c == ' ' || ('\t' <= c && c <= '\r');
+}
+
 /* Translate hexadecimal digits from 'hexstr' into the bitarray 'a' buffer,
    which must be initialized to zeros.
    Each digit corresponds to 4 bits in the bitarray.
@@ -872,7 +878,7 @@ hex2ba_lock_held(bitarrayobject *a, Py_buffer hexstr)
         int x = hex_to_int(c);
 
         if (x < 0) {
-            if (Py_ISSPACE(c))  /* ASCII whitespace */
+            if (ascii_isspace(c))
                 continue;
             PyErr_Format(PyExc_ValueError, "invalid digit found for "
                          "base16, got '%c' (0x%02x)", c, c);
@@ -1105,7 +1111,7 @@ base2ba_lock_held(bitarrayobject *a, Py_buffer asciistr, int m)
         int k, x = digit_to_int(m, c);
 
         if (x < 0) {
-            if (Py_ISSPACE(c))  /* ASCII whitespace */
+            if (ascii_isspace(c))
                 continue;
             PyErr_Format(PyExc_ValueError, "invalid digit found for "
                          "base%d, got '%c' (0x%02x)", 1 << m, c, c);

{bitarray-3.12.0 → bitarray-3.12.2}/bitarray/bitarray.h

@@ -4,7 +4,7 @@
 
    Author: Ilan Schnell
 */
-#define BITARRAY_VERSION  "3.12.0"
+#define BITARRAY_VERSION  "3.12.2"
 
 #ifdef STDC_HEADERS
 #  include <stddef.h>
@@ -247,15 +247,15 @@ setup_table(char *table, char kop)
     }
 }
 
-/* Return distance [0..3] to next aligned pointer.
+/* Return distance [0..7] to next aligned pointer.
    While on modern compilers uint64_t pointers may be misaligned, it may
    cause problems on older ones.  Moreover, it may lead to slowdown (even
    on modern compilers). */
 static inline int
 to_aligned(void *p)
 {
-    int r = ((uintptr_t) p) % 4;
-    return (4 - r) % 4;
+    int r = ((uintptr_t) p) % 8;
+    return (8 - r) % 8;
 }
 
 /* population count of n words starting at uint64_t pointer w */
@@ -264,7 +264,8 @@ popcnt_words(uint64_t *w, Py_ssize_t n)
 {
     Py_ssize_t cnt = 0;
 
-    assert(n >= 0 && ((uintptr_t) w) % 4 == 0);
+    assert(n >= 0);
+    assert(n == 0 || ((uintptr_t) w) % 8 == 0);
     while (n--)
         cnt += popcnt_64(*w++);
     return cnt;