bitarray 3.8.2__tar.gz → 3.9.0__tar.gz

{bitarray-3.8.2 → bitarray-3.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitarray
-Version: 3.8.2
+Version: 3.9.0
 Summary: efficient arrays of booleans -- C extension
 Home-page: https://github.com/ilanschnell/bitarray
 Author: Ilan Schnell
@@ -21,6 +21,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Free Threading :: 1 - Unstable
 Classifier: Topic :: Utilities
+Requires-Python: >=3.7
 License-File: LICENSE
 Dynamic: author
 Dynamic: author-email
@@ -29,6 +30,7 @@ Dynamic: description
 Dynamic: home-page
 Dynamic: license
 Dynamic: license-file
+Dynamic: requires-python
 Dynamic: summary
 
 bitarray: efficient arrays of booleans
@@ -90,8 +92,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
-    bitarray version: 3.8.2
-    sys.version: 3.13.5 (main, Jun 16 2025) [Clang 18.1.8]
+    bitarray version: 3.9.0
+    sys.version: 3.14.5 (main, May 20 2026) [Clang 20.1.8]
     sys.prefix: /Users/ilan/miniforge
     pointer size: 64 bit
     sizeof(size_t): 8
@@ -103,12 +105,12 @@ Once you have installed the package, you may want to test it:
     Py_DEBUG: 0
     DEBUG: 0
     .........................................................................
-    .........................................................................
-    ................................................................
+    ................................................s........................
+    ......s.........................................................
     ----------------------------------------------------------------------
-    Ran 598 tests in 0.165s
+    Ran 622 tests in 0.191s
 
-    OK
+    OK (skipped=2)
 
 The ``test()`` function is part of the API.  It will return
 a ``unittest.runner.TextTestResult`` object, such that one can verify that
@@ -353,7 +355,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.8.2 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.9.0 -- `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.
@@ -455,7 +457,7 @@ bitarray methods:
    New in version 2.9: add non-overlapping sub-bitarray count
 
 
-``decode(code, /)`` -> iterator
+``decode(code, /)`` -> decodeiterator
    Given a prefix code (a dict mapping symbols to bitarrays, or ``decodetree``
    object), decode content of bitarray and return an iterator over
    corresponding symbols.
@@ -464,6 +466,8 @@ bitarray methods:
 
    New in version 3.0: returns iterator (equivalent to past ``.iterdecode()``)
 
+   New in version 3.9: returns public ``decodeiterator`` object
+
 
 ``encode(code, iterable, /)``
    Given a prefix code (a dict mapping symbols to bitarrays),
@@ -556,6 +560,19 @@ bitarray methods:
    Reverse all bits in bitarray (in-place).
 
 
+``rotate(k=1, /)``
+   Rotate bitarray in-place by ``k`` positions.
+   Positive ``k`` rotates right, negative ``k`` rotates left.
+
+   When bitarray is not empty, rotating one step to the right is
+   equivalent to ``a.insert(0, a.pop())``, and rotating one step to the left
+   is equivalent to ``a.append(a.pop(0))``.
+   The same convention is used by the ``.rotate()`` method of
+   the ``collections.deque`` object.
+
+   New in version 3.9
+
+
 ``search(sub_bitarray, start=0, stop=<end>, /, right=False)`` -> iterator
    Return iterator over indices where sub_bitarray is found, such that
    sub_bitarray is contained within ``[start:stop]``.
@@ -634,6 +651,25 @@ Data descriptors were added in version 2.6.
    bool indicating whether buffer is read-only
 
 
+decodeiterator methods:
+-----------------------
+
+``skipbits(n, /)`` -> bitarray
+   Skip over the next ``n`` bits and return them.
+   Raises ``ValueError`` if count is out of range.
+
+   New in version 3.9
+
+
+decodeiterator data descriptors:
+--------------------------------
+
+``index`` -> int
+   current bit position to be decoded by subsequent ``next``
+
+   New in version 3.9
+
+
 Other objects:
 --------------
 

{bitarray-3.8.2 → bitarray-3.9.0}/README.rst

@@ -57,8 +57,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
-    bitarray version: 3.8.2
-    sys.version: 3.13.5 (main, Jun 16 2025) [Clang 18.1.8]
+    bitarray version: 3.9.0
+    sys.version: 3.14.5 (main, May 20 2026) [Clang 20.1.8]
     sys.prefix: /Users/ilan/miniforge
     pointer size: 64 bit
     sizeof(size_t): 8
@@ -70,12 +70,12 @@ Once you have installed the package, you may want to test it:
     Py_DEBUG: 0
     DEBUG: 0
     .........................................................................
-    .........................................................................
-    ................................................................
+    ................................................s........................
+    ......s.........................................................
     ----------------------------------------------------------------------
-    Ran 598 tests in 0.165s
+    Ran 622 tests in 0.191s
 
-    OK
+    OK (skipped=2)
 
 The ``test()`` function is part of the API.  It will return
 a ``unittest.runner.TextTestResult`` object, such that one can verify that
@@ -320,7 +320,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.8.2 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.9.0 -- `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.
@@ -422,7 +422,7 @@ bitarray methods:
    New in version 2.9: add non-overlapping sub-bitarray count
 
 
-``decode(code, /)`` -> iterator
+``decode(code, /)`` -> decodeiterator
    Given a prefix code (a dict mapping symbols to bitarrays, or ``decodetree``
    object), decode content of bitarray and return an iterator over
    corresponding symbols.
@@ -431,6 +431,8 @@ bitarray methods:
 
    New in version 3.0: returns iterator (equivalent to past ``.iterdecode()``)
 
+   New in version 3.9: returns public ``decodeiterator`` object
+
 
 ``encode(code, iterable, /)``
    Given a prefix code (a dict mapping symbols to bitarrays),
@@ -523,6 +525,19 @@ bitarray methods:
    Reverse all bits in bitarray (in-place).
 
 
+``rotate(k=1, /)``
+   Rotate bitarray in-place by ``k`` positions.
+   Positive ``k`` rotates right, negative ``k`` rotates left.
+
+   When bitarray is not empty, rotating one step to the right is
+   equivalent to ``a.insert(0, a.pop())``, and rotating one step to the left
+   is equivalent to ``a.append(a.pop(0))``.
+   The same convention is used by the ``.rotate()`` method of
+   the ``collections.deque`` object.
+
+   New in version 3.9
+
+
 ``search(sub_bitarray, start=0, stop=<end>, /, right=False)`` -> iterator
    Return iterator over indices where sub_bitarray is found, such that
    sub_bitarray is contained within ``[start:stop]``.
@@ -601,6 +616,25 @@ Data descriptors were added in version 2.6.
    bool indicating whether buffer is read-only
 
 
+decodeiterator methods:
+-----------------------
+
+``skipbits(n, /)`` -> bitarray
+   Skip over the next ``n`` bits and return them.
+   Raises ``ValueError`` if count is out of range.
+
+   New in version 3.9
+
+
+decodeiterator data descriptors:
+--------------------------------
+
+``index`` -> int
+   current bit position to be decoded by subsequent ``next``
+
+   New in version 3.9
+
+
 Other objects:
 --------------
 

{bitarray-3.8.2 → bitarray-3.9.0}/bitarray/__init__.py

@@ -12,11 +12,13 @@ Author: Ilan Schnell
 from collections import namedtuple
 
 from bitarray._bitarray import (
-    bitarray, decodetree, bits2bytes, _bitarray_reconstructor,
-    get_default_endian, _sysinfo, BITARRAY_VERSION as __version__
+    bitarray, decodetree, decodeiterator, _bitarray_reconstructor,
+    get_default_endian, bits2bytes, _sysinfo,
+    BITARRAY_VERSION as __version__
 )
 
-__all__ = ['bitarray', 'frozenbitarray', 'decodetree', 'bits2bytes']
+__all__ = ['bitarray', 'frozenbitarray', 'decodetree', 'decodeiterator',
+           'bits2bytes']
 
 BufferInfo = namedtuple('BufferInfo',
                         ['address', 'nbytes', 'endian', 'padbits',
@@ -51,7 +53,7 @@ and may therefore be used as a dictionary key.
 
     append = bytereverse = clear = extend = encode = fill = __delitem__
     frombytes = fromfile = insert = invert = pack = pop = __delitem__
-    remove = reverse = setall = sort = __setitem__ = __delitem__
+    remove = rotate = reverse = setall = sort = __setitem__ = __delitem__
     __iadd__ = __iand__ = __imul__ = __ior__ = __ixor__ = __delitem__
     __ilshift__ = __irshift__ = __delitem__
 

{bitarray-3.8.2 → bitarray-3.9.0}/bitarray/__init__.pyi

@@ -2,6 +2,7 @@
 #
 # This stub, as well as util.pyi, are tested with Python 3.10 and mypy 1.11.2
 
+from abc import ABCMeta
 from collections.abc import Iterable, Iterator, Sequence
 from unittest.runner import TextTestResult
 
@@ -31,6 +32,12 @@ class decodetree:
     def todict(self) -> CodeDict: ...
 
 
+class decodeiterator(Iterator, metaclass=ABCMeta):
+    @property
+    def index(self) -> int: ...
+    def skipbits(self, count: int = ...) -> bitarray: ...
+
+
 class bitarray:
     def __init__(self,
                  initializer: Union[int, str, Iterable[int], None] = ...,
@@ -55,7 +62,7 @@ class bitarray:
 
     def encode(self, code: CodeDict, x: Iterable) -> None: ...
     def decode(self,
-               code: Union[CodeDict, decodetree]) -> Iterator: ...
+               code: Union[CodeDict, decodetree]) -> decodeiterator: ...
 
     def extend(self, x: Union[str, Iterable[int]]) -> None: ...
     def fill(self) -> int: ...
@@ -85,6 +92,7 @@ class bitarray:
     def pack(self, b: BytesLike) -> None: ...
     def pop(self, i: int = ...) -> int: ...
     def remove(self, value: int) -> None: ...
+    def rotate(self, k: int = ...) -> None: ...
     def reverse(self) -> None: ...
 
     def setall(self, value: int) -> None: ...

{bitarray-3.8.2 → bitarray-3.9.0}/bitarray/_bitarray.c

@@ -11,6 +11,7 @@
 #define PY_SSIZE_T_CLEAN
 #include "Python.h"
 #include "pythoncapi_compat.h"
+#include "structmember.h"
 #include "bitarray.h"
 
 /* size used when reading / writing blocks from files (in bytes) */
@@ -609,11 +610,78 @@ count_range(bitarrayobject *self,
 
 /* return first (or rightmost in case right=1) occurrence
    of vi in self[a:b], -1 when not found */
+static Py_ssize_t
+find_bit(bitarrayobject *self, int vi, Py_ssize_t a, Py_ssize_t b, int right);
+
+static Py_ssize_t
+find_bit_words(bitarrayobject *self, int vi,
+               Py_ssize_t a, Py_ssize_t b, int right)
+{
+    const Py_ssize_t wa = (a + 63) / 64;  /* word-range(wa, wb) */
+    const Py_ssize_t wb = b / 64;
+    const uint64_t *wbuff = WBUFF(self);
+    const uint64_t w = vi ? 0 : ~0;
+    Py_ssize_t res, i;
+
+    if (right) {
+        if ((res = find_bit(self, vi, 64 * wb, b, 1)) >= 0)
+            return res;
+
+        for (i = wb - 1; i >= wa; i--) {  /* skip uint64 words */
+            if (w ^ wbuff[i])
+                return find_bit(self, vi, 64 * i, 64 * i + 64, 1);
+        }
+        return find_bit(self, vi, a, 64 * wa, 1);
+    }
+    else {
+        if ((res = find_bit(self, vi, a, 64 * wa, 0)) >= 0)
+            return res;
+
+        for (i = wa; i < wb; i++) {       /* skip uint64 words */
+            if (w ^ wbuff[i])
+                return find_bit(self, vi, 64 * i, 64 * i + 64, 0);
+        }
+        return find_bit(self, vi, 64 * wb, b, 0);
+    }
+}
+
+static Py_ssize_t
+find_bit_bytes(bitarrayobject *self, int vi,
+               Py_ssize_t a, Py_ssize_t b, int right)
+{
+    const Py_ssize_t ca = BYTES(a);  /* char-range(ca, cb) */
+    const Py_ssize_t cb = b / 8;
+    const char *buff = self->ob_item;
+    const char c = vi ? 0 : ~0;
+    Py_ssize_t res, i;
+
+    if (right) {
+        if ((res = find_bit(self, vi, 8 * cb, b, 1)) >= 0)
+            return res;
+
+        for (i = cb - 1; i >= ca; i--) {  /* skip bytes */
+            if (c ^ buff[i])
+                return find_bit(self, vi, 8 * i, 8 * i + 8, 1);
+        }
+        return find_bit(self, vi, a, 8 * ca, 1);
+    }
+    else {
+        if ((res = find_bit(self, vi, a, 8 * ca, 0)) >= 0)
+            return res;
+
+        for (i = ca; i < cb; i++) {       /* skip bytes */
+            if (c ^ buff[i])
+                return find_bit(self, vi, 8 * i, 8 * i + 8, 0);
+        }
+        return find_bit(self, vi, 8 * cb, b, 0);
+    }
+}
+
 static Py_ssize_t
 find_bit(bitarrayobject *self, int vi, Py_ssize_t a, Py_ssize_t b, int right)
 {
     const Py_ssize_t n = b - a;
-    Py_ssize_t res, i;
+    Py_ssize_t i;
 
     assert(0 <= a && a <= self->nbits);
     assert(0 <= b && b <= self->nbits);
@@ -624,63 +692,13 @@ find_bit(bitarrayobject *self, int vi, Py_ssize_t a, Py_ssize_t b, int right)
     /* When the search range is greater than 64 bits, we skip uint64 words.
        Note that we cannot check for n >= 64 here as the function could then
        go into an infinite recursive loop when a word is found. */
-    if (n > 64) {
-        const Py_ssize_t wa = (a + 63) / 64;  /* word-range(wa, wb) */
-        const Py_ssize_t wb = b / 64;
-        const uint64_t *wbuff = WBUFF(self);
-        const uint64_t w = vi ? 0 : ~0;
-
-        if (right) {
-            if ((res = find_bit(self, vi, 64 * wb, b, 1)) >= 0)
-                return res;
-
-            for (i = wb - 1; i >= wa; i--) {  /* skip uint64 words */
-                if (w ^ wbuff[i])
-                    return find_bit(self, vi, 64 * i, 64 * i + 64, 1);
-            }
-            return find_bit(self, vi, a, 64 * wa, 1);
-        }
-        else {
-            if ((res = find_bit(self, vi, a, 64 * wa, 0)) >= 0)
-                return res;
+    if (n > 64)
+        return find_bit_words(self, vi, a, b, right);
 
-            for (i = wa; i < wb; i++) {       /* skip uint64 words */
-                if (w ^ wbuff[i])
-                    return find_bit(self, vi, 64 * i, 64 * i + 64, 0);
-            }
-            return find_bit(self, vi, 64 * wb, b, 0);
-        }
-    }
     /* For the same reason as above, we cannot check for n >= 8 here. */
-    if (n > 8) {
-        const Py_ssize_t ca = BYTES(a);  /* char-range(ca, cb) */
-        const Py_ssize_t cb = b / 8;
-        const char *buff = self->ob_item;
-        const char c = vi ? 0 : ~0;
+    if (n > 8)
+        return find_bit_bytes(self, vi, a, b, right);
 
-        if (right) {
-            if ((res = find_bit(self, vi, 8 * cb, b, 1)) >= 0)
-                return res;
-
-            for (i = cb - 1; i >= ca; i--) {  /* skip bytes */
-                assert_byte_in_range(self, i);
-                if (c ^ buff[i])
-                    return find_bit(self, vi, 8 * i, 8 * i + 8, 1);
-            }
-            return find_bit(self, vi, a, 8 * ca, 1);
-        }
-        else {
-            if ((res = find_bit(self, vi, a, 8 * ca, 0)) >= 0)
-                return res;
-
-            for (i = ca; i < cb; i++) {       /* skip bytes */
-                assert_byte_in_range(self, i);
-                if (c ^ buff[i])
-                    return find_bit(self, vi, 8 * i, 8 * i + 8, 0);
-            }
-            return find_bit(self, vi, 8 * cb, b, 0);
-        }
-    }
     /* finally, search for the desired bit by stepping one-by-one */
     for (i = right ? b - 1 : a; a <= i && i < b; i += right ? -1 : 1)
         if (getbit(self, i) == vi)
@@ -1874,6 +1892,56 @@ Remove the first occurrence of `value`.\n\
 Raises `ValueError` if value is not present.");
 
 
+static PyObject *
+bitarray_rotate(bitarrayobject *self, PyObject *args)
+{
+    bitarrayobject *tmp;
+    Py_ssize_t n = self->nbits, k = 1;
+
+    RAISE_IF_READONLY(self, NULL);
+    if (!PyArg_ParseTuple(args, "|n:rotate", &k))
+        return NULL;
+
+    if (n < 2)
+        Py_RETURN_NONE;
+
+    k %= n;  /* C remainder may be negative, as it preserves the sign of k */
+    if (k < 0)
+        k += n;  /* make it equivalent to Python's k %= n */
+    if (k == 0)
+        Py_RETURN_NONE;
+
+    assert(0 < k && k < n);
+
+    /* temporary bitarray to store head or tail (whichever is smaller) */
+    tmp = newbitarrayobject(&Bitarray_Type, Py_MIN(k, n - k), self->endian);
+    if (tmp == NULL)
+        return NULL;
+
+    assert(tmp->nbits <= n / 2);  /* at most half size */
+
+    if (tmp->nbits == k) {      /* tail is smaller */
+        copy_n(tmp, 0, self, n - k, k);   /* save tail */
+        copy_n(self, k, self, 0, n - k);  /* shift whole array right by k */
+        copy_n(self, 0, tmp, 0, k);       /* copy stored tail at front */
+    }
+    else {                      /* head is smaller */
+        assert(tmp->nbits == n - k);
+        copy_n(tmp, 0, self, 0, n - k);   /* save head */
+        copy_n(self, 0, self, n - k, k);  /* shift whole array left by n-k */
+        copy_n(self, k, tmp, 0, n - k);   /* copy stored head at end */
+    }
+    Py_DECREF(tmp);
+    Py_RETURN_NONE;
+}
+
+PyDoc_STRVAR(rotate_doc,
+"rotate(k=1, /)\n\
+\n\
+Rotate bitarray in-place by `k` positions.\n\
+Positive `k` rotates right, negative `k` rotates left.");
+
+
 static PyObject *
 bitarray_sizeof(bitarrayobject *self)
 {
@@ -2096,18 +2164,13 @@ static PySequenceMethods bitarray_as_sequence = {
 
 /* ----------------------- bitarray_as_mapping ------------------------- */
 
-/* return new bitarray with item in self, specified by slice */
+/* return new bitarray with item in self, specified by slice indices */
 static PyObject *
-getslice(bitarrayobject *self, PyObject *slice)
+getslice_indices(bitarrayobject *self, Py_ssize_t start, Py_ssize_t step,
+                 Py_ssize_t slicelength)
 {
-    Py_ssize_t start, stop, step, slicelength;
     bitarrayobject *res;
 
-    assert(PySlice_Check(slice));
-    if (PySlice_GetIndicesEx(slice, self->nbits,
-                             &start, &stop, &step, &slicelength) < 0)
-        return NULL;
-
     res = newbitarrayobject(Py_TYPE(self), slicelength, self->endian);
     if (res == NULL)
         return NULL;
@@ -2124,6 +2187,20 @@ getslice(bitarrayobject *self, PyObject *slice)
     return freeze_if_frozen(res);
 }
 
+/* return new bitarray with item in self, specified by slice */
+static PyObject *
+getslice(bitarrayobject *self, PyObject *slice)
+{
+    Py_ssize_t start, stop, step, slicelength;
+
+    assert(PySlice_Check(slice));
+    if (PySlice_GetIndicesEx(slice, self->nbits,
+                             &start, &stop, &step, &slicelength) < 0)
+        return NULL;
+
+    return getslice_indices(self, start, step, slicelength);
+}
+
 static int
 ensure_mask_size(bitarrayobject *self, bitarrayobject *mask)
 {
@@ -3334,7 +3411,7 @@ bitarray_decode(bitarrayobject *self, PyObject *obj)
 }
 
 PyDoc_STRVAR(decode_doc,
-"decode(code, /) -> iterator\n\
+"decode(code, /) -> decodeiterator\n\
 \n\
 Given a prefix code (a dict mapping symbols to bitarrays, or `decodetree`\n\
 object), decode content of bitarray and return an iterator over\n\
@@ -3374,6 +3451,51 @@ decodeiter_traverse(decodeiterobject *it, visitproc visit, void *arg)
     return 0;
 }
 
+static PyObject *
+decodeiter_skipbits(decodeiterobject *it, PyObject *args)
+{
+    PyObject *skipped;
+    Py_ssize_t n;  /* number of bits to skip */
+
+    if (!PyArg_ParseTuple(args, "n:skipbits", &n))
+        return NULL;
+
+    if (n < 0)
+        return PyErr_Format(PyExc_ValueError, "skip count cannot be "
+                            "negative, got %zd", n);
+
+    if (n > it->self->nbits - it->index)
+        return PyErr_Format(PyExc_ValueError, "skip count %zd cannot be "
+                            "larger than remaining bits %zd",
+                            n, it->self->nbits - it->index);
+
+    skipped = getslice_indices(it->self, it->index, 1, n);
+    if (skipped == NULL)
+        return NULL;
+
+    it->index += n;
+    return skipped;
+}
+
+PyDoc_STRVAR(decodeiter_skipbits_doc,
+"skipbits(n, /) -> bitarray\n\
+\n\
+Skip over the next `n` bits and return them.\n\
+Raises `ValueError` if count is out of range.");
+
+
+static PyMethodDef decodeiter_methods[] = {
+    {"skipbits",    (PyCFunction) decodeiter_skipbits, METH_VARARGS,
+     decodeiter_skipbits_doc},
+    {NULL}
+};
+
+static PyMemberDef decodeiter_members[] = {
+    {"index", Py_T_PYSSIZET, offsetof(decodeiterobject, index), Py_READONLY,
+     PyDoc_STR("current bit position to be decoded by subsequent `next`")},
+    {NULL}
+};
+
 static PyTypeObject DecodeIter_Type = {
     PyVarObject_HEAD_INIT(NULL, 0)
     "bitarray.decodeiterator",                /* tp_name */
@@ -3403,7 +3525,8 @@ static PyTypeObject DecodeIter_Type = {
     0,                                        /* tp_weaklistoffset */
     PyObject_SelfIter,                        /* tp_iter */
     (iternextfunc) decodeiter_next,           /* tp_iternext */
-    0,                                        /* tp_methods */
+    decodeiter_methods,                       /* tp_methods */
+    decodeiter_members,                       /* tp_members */
 };
 
 /*********************** (Bitarray) Search Iterator ***********************/
@@ -3586,6 +3709,8 @@ static PyMethodDef bitarray_methods[] = {
      remove_doc},
     {"reverse",      (PyCFunction) bitarray_reverse,     METH_NOARGS,
      reverse_doc},
+    {"rotate",       (PyCFunction) bitarray_rotate,      METH_VARARGS,
+     rotate_doc},
     {"search",       (PyCFunction) bitarray_search,      METH_VARARGS |
                                                          METH_KEYWORDS,
      search_doc},
@@ -4298,6 +4423,8 @@ PyInit__bitarray(void)
     if (PyType_Ready(&DecodeIter_Type) < 0)
         return NULL;
     Py_SET_TYPE(&DecodeIter_Type, &PyType_Type);
+    Py_INCREF((PyObject *) &DecodeIter_Type);
+    PyModule_AddObject(m, "decodeiterator", (PyObject *) &DecodeIter_Type);
 
     if (PyType_Ready(&BitarrayIter_Type) < 0)
         return NULL;

{bitarray-3.8.2 → bitarray-3.9.0}/bitarray/bitarray.h

@@ -4,7 +4,7 @@
 
    Author: Ilan Schnell
 */
-#define BITARRAY_VERSION  "3.8.2"
+#define BITARRAY_VERSION  "3.9.0"
 
 #ifdef STDC_HEADERS
 #  include <stddef.h>
@@ -77,10 +77,6 @@ typedef struct {
 /* assert that .nbits is in agreement with .ob_size */
 #define assert_nbits(self)  assert(BYTES((self)->nbits) == Py_SIZE(self))
 
-/* assert byte index is in range */
-#define assert_byte_in_range(self, j)  \
-    assert(self->ob_item && 0 <= (j) && (j) < Py_SIZE(self))
-
 /* ------------ low level access to bits in bitarrayobject ------------- */
 
 static inline int