bitarray 3.12.2__tar.gz → 3.12.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitarray
-Version: 3.12.2
+Version: 3.12.4
 Summary: efficient arrays of booleans -- C extension
 Home-page: https://github.com/ilanschnell/bitarray
 Author: Ilan Schnell
@@ -20,7 +20,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
-Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
+Classifier: Programming Language :: Python :: Free Threading :: 3 - Stable
 Classifier: Topic :: Utilities
 Requires-Python: >=3.7
 License-File: LICENSE
@@ -57,6 +57,7 @@ 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)
+* Written to support all `platforms supported <https://github.com/ilanschnell/bitarray/blob/master/doc/platforms.rst>`__ by CPython and PyPy.
 * 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>`__
@@ -92,7 +93,7 @@ versions.  Which means you can simply:
 
 .. code-block:: shell-session
 
-    $ pip install bitarray
+    $ python -m pip install bitarray
 
 Once you have installed the package, you may want to test it:
 
@@ -101,26 +102,27 @@ 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.2
+    bitarray version: 3.12.4
+    platform.machine(): arm64
+    platform.platform(): macOS-14.3-arm64-arm-64bit-Mach-O
+    sys.platform: darwin
     sys.version: 3.15.0 (main, Oct  9 2026) [Clang 21.1.8]
     sys.abiflags: ''
     sys._is_gil_enabled(): True
     pointer size: 64 bit
-    sizeof(size_t): 8
-    sizeof(bitarrayobject): 80
     HAVE_BUILTIN_BSWAP64: 1
     default bit-endianness: big
     machine byte-order: little
     Py_GIL_DISABLED: 0
     Py_DEBUG: 0
     DEBUG: 0
-    .....................................s...................................
-    ..........s.....................................s........................
+    .........................................................................
+    ................................................s........................
     ......s.........................................................
     ----------------------------------------------------------------------
-    Ran 711 tests in 0.161s
+    Ran 723 tests in 0.163s
 
-    OK (skipped=4)
+    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
@@ -312,7 +314,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.12.2 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.12.4 -- `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.

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

@@ -21,6 +21,7 @@ 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)
+* Written to support all `platforms supported <https://github.com/ilanschnell/bitarray/blob/master/doc/platforms.rst>`__ by CPython and PyPy.
 * 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>`__
@@ -56,7 +57,7 @@ versions.  Which means you can simply:
 
 .. code-block:: shell-session
 
-    $ pip install bitarray
+    $ python -m pip install bitarray
 
 Once you have installed the package, you may want to test it:
 
@@ -65,26 +66,27 @@ 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.2
+    bitarray version: 3.12.4
+    platform.machine(): arm64
+    platform.platform(): macOS-14.3-arm64-arm-64bit-Mach-O
+    sys.platform: darwin
     sys.version: 3.15.0 (main, Oct  9 2026) [Clang 21.1.8]
     sys.abiflags: ''
     sys._is_gil_enabled(): True
     pointer size: 64 bit
-    sizeof(size_t): 8
-    sizeof(bitarrayobject): 80
     HAVE_BUILTIN_BSWAP64: 1
     default bit-endianness: big
     machine byte-order: little
     Py_GIL_DISABLED: 0
     Py_DEBUG: 0
     DEBUG: 0
-    .....................................s...................................
-    ..........s.....................................s........................
+    .........................................................................
+    ................................................s........................
     ......s.........................................................
     ----------------------------------------------------------------------
-    Ran 711 tests in 0.161s
+    Ran 723 tests in 0.163s
 
-    OK (skipped=4)
+    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
@@ -276,7 +278,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.12.2 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.12.4 -- `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.

{bitarray-3.12.2 → bitarray-3.12.4}/bitarray/__init__.pyi

@@ -6,9 +6,11 @@ from abc import ABCMeta
 from collections.abc import Iterable, Iterator, Sequence
 from unittest.runner import TextTestResult
 
-from typing import Any, BinaryIO, Dict, Union, overload, NamedTuple
+from typing import Any, BinaryIO, Dict, Union, overload, NamedTuple, TypeVar
 
 
+_BitarrayT = TypeVar("_BitarrayT", bound="bitarray")
+
 CodeDict = Dict[Any, bitarray]
 # Python 3.12 has abc.Buffer which should be used instead
 BytesLike = Union[bytes, bytearray]
@@ -52,7 +54,7 @@ class bitarray:
                     stop: int = ...) -> None: ...
 
     def clear(self) -> None: ...
-    def copy(self) -> bitarray: ...
+    def copy(self: _BitarrayT) -> _BitarrayT: ...
     def count(self,
               sub_bitarray: Union[bitarray, int] = ...,
               start: int = ...,
@@ -111,8 +113,8 @@ class bitarray:
     @overload
     def __getitem__(self, i: int) -> int: ...
     @overload
-    def __getitem__(self,
-                    s: Union[slice, bitarray, Sequence]) -> bitarray: ...
+    def __getitem__(self: _BitarrayT,
+                    s: Union[slice, bitarray, Sequence]) -> _BitarrayT: ...
     @overload
     def __setitem__(self,
                     i: Union[int, slice, Sequence],
@@ -127,28 +129,28 @@ class bitarray:
     def __buffer__(self, flags: int, /) -> memoryview: ...
     def __release_buffer__(self, buffer: memoryview, /) -> None: ...
 
-    def __add__(self, other: bitarray) -> bitarray: ...
-    def __iadd__(self, other: bitarray) -> bitarray: ...
-    def __mul__(self, n: int) -> bitarray: ...
-    def __imul__(self, n: int) -> bitarray: ...
-    def __rmul__(self, n: int) -> bitarray: ...
+    def __add__(self: _BitarrayT, other: bitarray) -> _BitarrayT: ...
+    def __iadd__(self: _BitarrayT, other: bitarray) -> _BitarrayT: ...
+    def __mul__(self: _BitarrayT, n: int) -> _BitarrayT: ...
+    def __imul__(self: _BitarrayT, n: int) -> _BitarrayT: ...
+    def __rmul__(self: _BitarrayT, n: int) -> _BitarrayT: ...
 
     def __ge__(self, other: bitarray) -> bool: ...
     def __gt__(self, other: bitarray) -> bool: ...
     def __le__(self, other: bitarray) -> bool: ...
     def __lt__(self, other: bitarray) -> bool: ...
 
-    def __and__(self, other: bitarray) -> bitarray: ...
-    def __or__(self, other: bitarray) -> bitarray: ...
-    def __xor__(self, other: bitarray) -> bitarray: ...
-    def __iand__(self, other: bitarray) -> bitarray: ...
-    def __ior__(self, other: bitarray) -> bitarray: ...
-    def __ixor__(self, other: bitarray) -> bitarray: ...
-    def __invert__(self) -> bitarray: ...
-    def __lshift__(self, n: int) -> bitarray: ...
-    def __rshift__(self, n: int) -> bitarray: ...
-    def __ilshift__(self, n: int) -> bitarray: ...
-    def __irshift__(self, n: int) -> bitarray: ...
+    def __and__(self: _BitarrayT, other: bitarray) -> _BitarrayT: ...
+    def __or__(self: _BitarrayT, other: bitarray) -> _BitarrayT: ...
+    def __xor__(self: _BitarrayT, other: bitarray) -> _BitarrayT: ...
+    def __iand__(self: _BitarrayT, other: bitarray) -> _BitarrayT: ...
+    def __ior__(self: _BitarrayT, other: bitarray) -> _BitarrayT: ...
+    def __ixor__(self: _BitarrayT, other: bitarray) -> _BitarrayT: ...
+    def __invert__(self: _BitarrayT) -> _BitarrayT: ...
+    def __lshift__(self: _BitarrayT, n: int) -> _BitarrayT: ...
+    def __rshift__(self: _BitarrayT, n: int) -> _BitarrayT: ...
+    def __ilshift__(self: _BitarrayT, n: int) -> _BitarrayT: ...
+    def __irshift__(self: _BitarrayT, n: int) -> _BitarrayT: ...
 
     # data descriptors
     @property

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

@@ -224,16 +224,16 @@ bytereverse(char *p, Py_ssize_t n)
 static void
 shift_r8le(unsigned char *buff, Py_ssize_t n, int k)
 {
-    Py_ssize_t w = 0;
+    Py_ssize_t w = 0, r = n;
 
 #if HAVE_BUILTIN_BSWAP64 || PY_LITTLE_ENDIAN   /* use shift word */
     w = n / 8;                    /* number of words used for shifting */
-    n %= 8;                       /* number of remaining bytes */
+    r = n % 8;                    /* number of remaining bytes */
 #endif
-    while (n--) {                 /* shift in byte-range(8 * w, n) */
-        Py_ssize_t i = n + 8 * w;
+    while (r--) {                 /* shift in byte-range(8 * w, n) */
+        Py_ssize_t i = r + 8 * w;
         buff[i] <<= k;            /* shift byte */
-        if (n || w)               /* add shifted next lower byte */
+        if (r || w)               /* add shifted next lower byte */
             buff[i] |= buff[i - 1] >> (8 - k);
     }
     assert(w == 0 || ((uintptr_t) buff) % 8 == 0);
@@ -254,16 +254,16 @@ shift_r8le(unsigned char *buff, Py_ssize_t n, int k)
 static void
 shift_r8be(unsigned char *buff, Py_ssize_t n, int k)
 {
-    Py_ssize_t w = 0;
+    Py_ssize_t w = 0, r = n;
 
 #if HAVE_BUILTIN_BSWAP64 || PY_BIG_ENDIAN      /* use shift word */
     w = n / 8;                    /* number of words used for shifting */
-    n %= 8;                       /* number of remaining bytes */
+    r = n % 8;                    /* number of remaining bytes */
 #endif
-    while (n--) {                 /* shift in byte-range(8 * w, n) */
-        Py_ssize_t i = n + 8 * w;
+    while (r--) {                 /* shift in byte-range(8 * w, n) */
+        Py_ssize_t i = r + 8 * w;
         buff[i] >>= k;            /* shift byte */
-        if (n || w)               /* add shifted next lower byte */
+        if (r || w)               /* add shifted next lower byte */
             buff[i] |= buff[i - 1] << (8 - k);
     }
     assert(w == 0 || ((uintptr_t) buff) % 8 == 0);
@@ -285,7 +285,7 @@ shift_r8be(unsigned char *buff, Py_ssize_t n, int k)
 static void
 shift_r8(bitarrayobject *self, Py_ssize_t a, Py_ssize_t b, int k)
 {
-    unsigned char *buff = (unsigned char *) self->ob_item + a;
+    unsigned char *buff;
     Py_ssize_t n = b - a;       /* number of bytes to be shifted */
     Py_ssize_t s = 0;           /* distance to next aligned pointer */
 
@@ -296,8 +296,11 @@ shift_r8(bitarrayobject *self, Py_ssize_t a, Py_ssize_t b, int k)
     if (k == 0 || n <= 0)
         return;
 
+    assert(Py_SIZE(self));
+    buff = (unsigned char *) self->ob_item + a;
+
     if (n >= 8) {
-        s = to_aligned((void *) buff);
+        s = to_aligned(buff);
         buff += s;  /* align pointer for casting to (uint64_t *) */
         n -= s;
     }
@@ -464,14 +467,18 @@ invert_span(bitarrayobject *self, Py_ssize_t a, Py_ssize_t b)
     assert(self->readonly == 0);
 
     if (n >= 64) {
-        const Py_ssize_t wa = (a + 63) / 64;  /* word-range(wa, wb) */
-        const Py_ssize_t wb = b / 64;
-        uint64_t *wbuff = WBUFF(self);
+        uint64_t *words;
+        Py_ssize_t p1, p2, w;
+
+        w = aligned_words(self->ob_item, BYTES(a), b / 8, &p1, &p2);
+
+        invert_span(self, a, 8 * p1);
 
-        invert_span(self, a, 64 * wa);
-        for (i = wa; i < wb; i++)
-            wbuff[i] = ~wbuff[i];
-        invert_span(self, 64 * wb, b);
+        words = w ? (uint64_t *) (self->ob_item + p1) : NULL;
+        for (i = 0; i < w; i++)
+            words[i] = ~words[i];
+
+        invert_span(self, 8 * p2, b);
     }
     else if (n >= 8) {
         const Py_ssize_t ca = BYTES(a);       /* char-range(ca, cb) */
@@ -574,15 +581,14 @@ count_span(bitarrayobject *self, Py_ssize_t a, Py_ssize_t b)
     assert(0 <= b && b <= self->nbits);
 
     if (n >= 64) {
-        Py_ssize_t p = BYTES(a), w;  /* first full byte */
-        p += to_aligned((void *) (self->ob_item + p));  /* align pointer */
-        w = (b / 8 - p) / 8;         /* number of (full) words to count */
+        Py_ssize_t p1, p2, w;
 
-        assert(8 * p - a < 64 && b - (8 * (p + 8 * w)) < 64 && w >= 0);
+        w = aligned_words(self->ob_item, BYTES(a), b / 8, &p1, &p2);
 
-        cnt += count_span(self, a, 8 * p);
-        cnt += popcnt_words((uint64_t *) (self->ob_item + p), w);
-        cnt += count_span(self, 8 * (p + 8 * w), b);
+        cnt += count_span(self, a, 8 * p1);
+        if (w)
+            cnt += popcnt_words((uint64_t *) (self->ob_item + p1), w);
+        cnt += count_span(self, 8 * p2, b);
     }
     else if (n >= 8) {
         const Py_ssize_t ca = BYTES(a);   /* char-range(ca, cb) */
@@ -636,31 +642,36 @@ 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;
+    const uint64_t word = vi ? 0 : ~0;
+    const uint64_t *words;
+    Py_ssize_t p1, p2, n, q, res, i;
+
+    n = aligned_words(self->ob_item, BYTES(a), b / 8, &p1, &p2);
+    words = n ? (uint64_t *) (self->ob_item + p1) : NULL;
 
     if (right) {
-        if ((res = find_bit(self, vi, 64 * wb, b, 1)) >= 0)
+        if ((res = find_bit(self, vi, 8 * p2, 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);
+        for (i = n - 1; i >= 0; i--) {  /* skip uint64 words */
+            if (word ^ words[i]) {
+                q = 8 * p1 + 64 * i;
+                return find_bit(self, vi, q, q + 64, 1);
+            }
         }
-        return find_bit(self, vi, a, 64 * wa, 1);
+        return find_bit(self, vi, a, 8 * p1, 1);
     }
     else {
-        if ((res = find_bit(self, vi, a, 64 * wa, 0)) >= 0)
+        if ((res = find_bit(self, vi, a, 8 * p1, 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);
+        for (i = 0; i < n; i++) {       /* skip uint64 words */
+            if (word ^ words[i]) {
+                q = 8 * p1 + 64 * i;
+                return find_bit(self, vi, q, q + 64, 0);
+            }
         }
-        return find_bit(self, vi, 64 * wb, b, 0);
+        return find_bit(self, vi, 8 * p2, b, 0);
     }
 }
 
@@ -3428,16 +3439,25 @@ bitwise_lock_held(bitarrayobject *self,
                   bitarrayobject *other, const char oper)
 {
     const Py_ssize_t nbytes = Py_SIZE(self);
-    const Py_ssize_t cwords = nbytes / 8;      /* complete 64-bit words */
-    Py_ssize_t i;
+    Py_ssize_t cwords, i;
     char *buff_s = self->ob_item;
     char *buff_o = other->ob_item;
-    uint64_t *wbuff_s = WBUFF(self);
-    uint64_t *wbuff_o = WBUFF(other);
+    uint64_t *wbuff_s, *wbuff_o;
 
     assert(self->nbits == other->nbits);
     assert(self->endian == other->endian);
     assert(self->readonly == 0);
+
+    if (((uintptr_t) buff_s) % 8 == 0 &&
+        ((uintptr_t) buff_o) % 8 == 0) {
+        cwords = nbytes / 8;      /* complete aligned 64-bit words */
+        wbuff_s = WBUFF(self);
+        wbuff_o = WBUFF(other);
+    }
+    else {
+        cwords = 0;
+    }
+
     switch (oper) {
     case '&':
         for (i = 0; i < cwords; i++)
@@ -5120,7 +5140,7 @@ static PyTypeObject Bitarray_Type = {
     &bitarray_as_number,                      /* tp_as_number */
     &bitarray_as_sequence,                    /* tp_as_sequence */
     &bitarray_as_mapping,                     /* tp_as_mapping */
-    PyObject_HashNotImplemented,              /* tp_hash */
+    0,                                        /* tp_hash */
     0,                                        /* tp_call */
     0,                                        /* tp_str */
     PyObject_GenericGetAttr,                  /* tp_getattro */
@@ -5374,48 +5394,63 @@ PyInit__bitarray(void)
        reverse_trans = {0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, ..., 0xff} */
     setup_table(reverse_trans, 'r');
 
-    if ((m = PyModule_Create(&moduledef)) == NULL)
+    m = PyModule_Create(&moduledef);
+    if (m == NULL)
         return NULL;
 
 #ifdef Py_GIL_DISABLED
     if (PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED) < 0)
-        return NULL;
+        goto error;
 #endif
 
     if (PyType_Ready(&Bitarray_Type) < 0)
-        return NULL;
+        goto error;
     Py_SET_TYPE(&Bitarray_Type, &PyType_Type);
     Py_INCREF((PyObject *) &Bitarray_Type);
-    PyModule_AddObject(m, "bitarray", (PyObject *) &Bitarray_Type);
+    if (PyModule_AddObject(m, "bitarray", (PyObject *) &Bitarray_Type) < 0) {
+        Py_DECREF((PyObject *) &Bitarray_Type);
+        goto error;
+    }
 
     if (add_capsule(m) < 0)
-        return NULL;
+        goto error;
 
     if (register_abc() < 0)
-        return NULL;
+        goto error;
 
     if (PyType_Ready(&DecodeTree_Type) < 0)
-        return NULL;
+        goto error;
     Py_SET_TYPE(&DecodeTree_Type, &PyType_Type);
     Py_INCREF((PyObject *) &DecodeTree_Type);
-    PyModule_AddObject(m, "decodetree", (PyObject *) &DecodeTree_Type);
+    if (PyModule_AddObject(m, "decodetree",
+                           (PyObject *) &DecodeTree_Type) < 0) {
+        Py_DECREF((PyObject *) &DecodeTree_Type);
+        goto error;
+    }
 
     if (PyType_Ready(&DecodeIter_Type) < 0)
-        return NULL;
+        goto error;
     Py_SET_TYPE(&DecodeIter_Type, &PyType_Type);
     Py_INCREF((PyObject *) &DecodeIter_Type);
-    PyModule_AddObject(m, "decodeiterator", (PyObject *) &DecodeIter_Type);
+    if (PyModule_AddObject(m, "decodeiterator",
+                           (PyObject *) &DecodeIter_Type) < 0) {
+        Py_DECREF((PyObject *) &DecodeIter_Type);
+        goto error;
+    }
 
     if (PyType_Ready(&BitarrayIter_Type) < 0)
-        return NULL;
+        goto error;
     Py_SET_TYPE(&BitarrayIter_Type, &PyType_Type);
 
     if (PyType_Ready(&SearchIter_Type) < 0)
-        return NULL;
+        goto error;
     Py_SET_TYPE(&SearchIter_Type, &PyType_Type);
 
     if (PyModule_AddStringMacro(m, BITARRAY_VERSION) < 0)
-        return NULL;
+        goto error;
 
     return m;
+ error:
+    Py_DECREF(m);
+    return NULL;
 }