bitarray 3.12.2__tar.gz → 3.12.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitarray
-Version: 3.12.2
+Version: 3.12.3
 Summary: efficient arrays of booleans -- C extension
 Home-page: https://github.com/ilanschnell/bitarray
 Author: Ilan Schnell
@@ -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 by CPython and PyPy <https://github.com/ilanschnell/bitarray/blob/master/doc/platforms.rst>`__.
 * 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.3
+    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.3 -- `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.3}/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 by CPython and PyPy <https://github.com/ilanschnell/bitarray/blob/master/doc/platforms.rst>`__.
 * 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.3
+    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.3 -- `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.3}/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.3}/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);
+
+        words = w ? (uint64_t *) (self->ob_item + p1) : NULL;
+        for (i = 0; i < w; i++)
+            words[i] = ~words[i];
 
-        invert_span(self, a, 64 * wa);
-        for (i = wa; i < wb; i++)
-            wbuff[i] = ~wbuff[i];
-        invert_span(self, 64 * wb, b);
+        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 */

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

@@ -205,6 +205,21 @@ count_n_lock_held(bitarrayobject *a, Py_ssize_t n, int vi)
     return i;
 }
 
+static inline int
+check_aligned(bitarrayobject *a)
+{
+#ifdef __sparc__
+    if (((uintptr_t) a->ob_item) % 8) {
+        PyErr_SetString(PyExc_NotImplementedError, "unaligned buffers "
+                        "not supported on SPARC for this function");
+        return -1;
+    }
+#else
+    (void) a;  /* silence potential compiler warning about unused a */
+#endif
+    return 0;
+}
+
 static PyObject *
 count_n(PyObject *module, PyObject *args)
 {
@@ -220,6 +235,8 @@ count_n(PyObject *module, PyObject *args)
         PyErr_SetString(PyExc_ValueError, "non-negative integer expected");
         return NULL;
     }
+    if (check_aligned(a) < 0)
+        return NULL;
 
     Py_BEGIN_CRITICAL_SECTION(a);
     nbits = a->nbits;
@@ -250,19 +267,22 @@ static PyObject *
 parity(PyObject *module, PyObject *obj)
 {
     bitarrayobject *a;
-    uint64_t x, *wbuff;
-    Py_ssize_t i;
+    uint64_t x;
+    Py_ssize_t i, p1, p2;
 
     if (ensure_bitarray(obj) < 0)
         return NULL;
 
     a = (bitarrayobject *) obj;
     Py_BEGIN_CRITICAL_SECTION(a);
-    wbuff = WBUFF(a);
-    x = zlw(a);
-    i = a->nbits / 64;
-    while (i--)
-        x ^= *wbuff++;
+    x = (unsigned char) zlc(a);
+    aligned_words(a->ob_item, 0, a->nbits / 8, &p1, &p2);
+    for (i = 0; i < p1; i++)
+        x ^= (unsigned char) a->ob_item[i];
+    for (i = p1; i < p2; i += 8)
+        x ^= *((uint64_t *) (a->ob_item + i));
+    for (i = p2; i < a->nbits / 8; i++)
+        x ^= (unsigned char) a->ob_item[i];
     Py_END_CRITICAL_SECTION();
     return PyLong_FromLong(parity_64(x));
 }
@@ -460,6 +480,8 @@ binary_function(PyObject *args, const char *format, const char oper)
                           bitarray_type, (PyObject *) &a,
                           bitarray_type, (PyObject *) &b))
         return NULL;
+    if (check_aligned(a) < 0 || check_aligned(b) < 0)
+        return NULL;
 
     Py_BEGIN_CRITICAL_SECTION2(a, b);
     if (ensure_eq_size_endian(a, b) == 0)
@@ -562,6 +584,8 @@ correspond_all(PyObject *module, PyObject *args)
                           bitarray_type, (PyObject *) &a,
                           bitarray_type, (PyObject *) &b))
         return NULL;
+    if (check_aligned(a) < 0 || check_aligned(b) < 0)
+        return NULL;
 
     Py_BEGIN_CRITICAL_SECTION2(a, b);
     if (ensure_eq_size_endian(a, b) == 0)
@@ -582,21 +606,22 @@ byteswap_lock_held(Py_buffer view, Py_ssize_t n)
 {
     char *buff = view.buf;
     Py_ssize_t m = view.len / n, k;
+    int is_aligned = ((uintptr_t) buff) % 8 == 0;
 
     assert(n >= 1 && n * m == view.len);
 
-    if (n == 8 && HAVE_BUILTIN_BSWAP64) {
+    if (is_aligned && n == 8 && HAVE_BUILTIN_BSWAP64) {
         uint64_t *w = (uint64_t *) buff;
         for (k = 0; k < m; k++)
             w[k] = builtin_bswap64(w[k]);
     }
 #if (defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5)))
-    else if (n == 4) {
+    else if (is_aligned && n == 4) {
         uint32_t *w = (uint32_t *) buff;
         for (k = 0; k < m; k++)
             w[k] = __builtin_bswap32(w[k]);
     }
-    else if (n == 2) {
+    else if (is_aligned && n == 2) {
         uint16_t *w = (uint16_t *) buff;
         for (k = 0; k < m; k++)
             w[k] = __builtin_bswap16(w[k]);
@@ -1523,7 +1548,7 @@ sc_last_pop_seg(const Py_ssize_t *rts, Py_ssize_t nseg)
 /* expose sc_rts() to Python during debug mode for testing */
 #ifndef NDEBUG
 static PyObject *
-module_sc_rts(PyObject *module, PyObject *obj)
+mod_sc_rts(PyObject *module, PyObject *obj)
 {
     PyObject *list;
     bitarrayobject *a;
@@ -1857,6 +1882,8 @@ sc_encode(PyObject *module, PyObject *obj)
 
     if (ensure_bitarray(obj) < 0)
         return NULL;
+    if (check_aligned((bitarrayobject *) obj) < 0)
+        return NULL;
 
     out = PyBytes_FromStringAndSize(NULL, ALLOC_SIZE);
     if (out == NULL)
@@ -2627,7 +2654,7 @@ static PyTypeObject CHDI_Type = {
 
 #ifndef NDEBUG
 static PyObject *
-module_setup_table(PyObject *module, PyObject *obj)
+mod_setup_table(PyObject *module, PyObject *obj)
 {
     char table[256];
 
@@ -2641,7 +2668,7 @@ module_setup_table(PyObject *module, PyObject *obj)
    This makes testing easier, because the int result would depend
    on the machine byteorder. */
 static PyObject *
-module_zlw(PyObject *module, PyObject *obj)
+mod_zlw(PyObject *module, PyObject *obj)
 {
     bitarrayobject *a, *res;
     uint64_t w;
@@ -2663,7 +2690,22 @@ module_zlw(PyObject *module, PyObject *obj)
 }
 
 static PyObject *
-module_adjust_slice(PyObject *module, PyObject *args)
+mod_aligned_words(PyObject *module, PyObject *args)
+{
+    Py_ssize_t start, stop, p1, p2, n;
+    bitarrayobject *a;
+
+    if (!PyArg_ParseTuple(args, "O!nn", bitarray_type, (PyObject *) &a,
+                          &start, &stop))
+        return NULL;
+    Py_BEGIN_CRITICAL_SECTION(a);
+    n = aligned_words(a->ob_item, start, stop, &p1, &p2);
+    Py_END_CRITICAL_SECTION();
+    return Py_BuildValue("nnn", n, p1, p2);
+}
+
+static PyObject *
+mod_adjust_slice(PyObject *module, PyObject *args)
 {
     Py_ssize_t length, slicelength, start, stop, step;
 
@@ -2674,7 +2716,7 @@ module_adjust_slice(PyObject *module, PyObject *args)
 }
 
 static PyObject *
-module_cfw(PyObject *module, PyObject *args)  /* count_from_word() */
+mod_cfw(PyObject *module, PyObject *args)  /* count_from_word() */
 {
     bitarrayobject *a;
     Py_ssize_t res, i;
@@ -2690,7 +2732,7 @@ module_cfw(PyObject *module, PyObject *args)  /* count_from_word() */
 }
 
 static PyObject *
-module_d2i(PyObject *module, PyObject *args)
+mod_d2i(PyObject *module, PyObject *args)
 {
     int m;
     char c;
@@ -2701,7 +2743,7 @@ module_d2i(PyObject *module, PyObject *args)
 }
 
 static PyObject *
-module_read_n(PyObject *module, PyObject *args)
+mod_read_n(PyObject *module, PyObject *args)
 {
     PyObject *iter;
     Py_ssize_t i;
@@ -2715,7 +2757,7 @@ module_read_n(PyObject *module, PyObject *args)
 }
 
 static PyObject *
-module_write_n(PyObject *module, PyObject *args)
+mod_write_n(PyObject *module, PyObject *args)
 {
     PyObject *res;
     char *str;
@@ -2803,14 +2845,15 @@ static PyMethodDef module_functions[] = {
 
 #ifndef NDEBUG
     /* functions exposed in debug mode for testing */
-    {"_setup_table",  (PyCFunction) module_setup_table,  METH_O,       0},
-    {"_zlw",          (PyCFunction) module_zlw,          METH_O,       0},
-    {"_adjust_slice", (PyCFunction) module_adjust_slice, METH_VARARGS, 0},
-    {"_cfw",          (PyCFunction) module_cfw,          METH_VARARGS, 0},
-    {"_d2i",          (PyCFunction) module_d2i,          METH_VARARGS, 0},
-    {"_read_n",       (PyCFunction) module_read_n,       METH_VARARGS, 0},
-    {"_write_n",      (PyCFunction) module_write_n,      METH_VARARGS, 0},
-    {"_sc_rts",       (PyCFunction) module_sc_rts,       METH_O,       0},
+    {"_setup_table",   (PyCFunction) mod_setup_table,   METH_O,       0},
+    {"_zlw",           (PyCFunction) mod_zlw,           METH_O,       0},
+    {"_aligned_words", (PyCFunction) mod_aligned_words, METH_VARARGS, 0},
+    {"_adjust_slice",  (PyCFunction) mod_adjust_slice,  METH_VARARGS, 0},
+    {"_cfw",           (PyCFunction) mod_cfw,           METH_VARARGS, 0},
+    {"_d2i",           (PyCFunction) mod_d2i,           METH_VARARGS, 0},
+    {"_read_n",        (PyCFunction) mod_read_n,        METH_VARARGS, 0},
+    {"_write_n",       (PyCFunction) mod_write_n,       METH_VARARGS, 0},
+    {"_sc_rts",        (PyCFunction) mod_sc_rts,        METH_O,       0},
 #endif
 
     {NULL}  /* sentinel */

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

@@ -4,7 +4,7 @@
 
    Author: Ilan Schnell
 */
-#define BITARRAY_VERSION  "3.12.2"
+#define BITARRAY_VERSION  "3.12.3"
 
 #ifdef STDC_HEADERS
 #  include <stddef.h>
@@ -124,19 +124,22 @@ zlc(bitarrayobject *self)       /* zlc = zeroed last char */
 /* Return a uint64_t word representing the last (up to 63) remaining bits
    of the buffer.  All missing bytes (to complete the word) and padbits are
    treated as zeros.
+   The remaining bytes are copied, so the buffer need not be word-aligned.
+   The result does not, in general, correspond to an aligned 64-bit
+   word in the buffer.
    If the length of the bitarray is a multiple of 64 (which also includes
    an empty bitarray), 0 is returned. */
 static inline uint64_t
 zlw(bitarrayobject *self)       /* zlw = zeroed last word */
 {
     const size_t nbits = self->nbits;
-    const size_t nw = (nbits / 64) * 8;   /* bytes in complete words */
-    const size_t nr = (nbits % 64) / 8;   /* complete remaining bytes */
+    const size_t offset = (nbits / 64) * 8;   /* bytes in complete words */
+    const size_t nr = (nbits % 64) / 8;       /* complete remaining bytes */
     uint64_t res = 0;
 
-    assert(nw + nr == nbits / 8 && 8 * (nw + nr) + nbits % 8 == nbits);
+    assert(offset + nr == nbits / 8);
     if (nr)
-        memcpy((char *) &res, self->ob_item + nw, nr);
+        memcpy((char *) &res, self->ob_item + offset, nr);
     if (nbits % 8)
         *(((char *) &res) + nr) = zlc(self);
 
@@ -252,12 +255,35 @@ setup_table(char *table, char kop)
    cause problems on older ones.  Moreover, it may lead to slowdown (even
    on modern compilers). */
 static inline int
-to_aligned(void *p)
+to_aligned(const void *p)
 {
     int r = ((uintptr_t) p) % 8;
     return (8 - r) % 8;
 }
 
+/* Return number of complete aligned words in byte-range(start, stop).
+   Set byte offsets *p1 and *p2 such that the aligned words are in
+   byte-range(*p1, *p2). */
+static inline Py_ssize_t
+aligned_words(const char *buff, Py_ssize_t start, Py_ssize_t stop,
+              Py_ssize_t *p1, Py_ssize_t *p2)
+{
+    Py_ssize_t n = 0;
+
+    assert(0 <= start && start <= stop);
+
+    if (start < stop) {
+        /* non-empty buffer cannot be NULL */
+        start += to_aligned(buff + start);
+        if (start > stop)
+            start = stop;
+        n = (stop - start) / 8;
+    }
+    *p1 = start;
+    *p2 = start + 8 * n;
+    return n;
+}
+
 /* population count of n words starting at uint64_t pointer w */
 static inline Py_ssize_t
 popcnt_words(uint64_t *w, Py_ssize_t n)
@@ -265,7 +291,6 @@ popcnt_words(uint64_t *w, Py_ssize_t n)
     Py_ssize_t cnt = 0;
 
     assert(n >= 0);
-    assert(n == 0 || ((uintptr_t) w) % 8 == 0);
     while (n--)
         cnt += popcnt_64(*w++);
     return cnt;

{bitarray-3.12.2 → bitarray-3.12.3}/bitarray/test_bitarray.py

@@ -33,6 +33,7 @@ import weakref
 
 is_emscripten = platform.machine() in ('wasm32', 'wasm64')
 is_pypy = platform.python_implementation() == 'PyPy'
+is_sparc = platform.machine().lower().startswith("sparc")
 
 
 from bitarray import (bitarray, frozenbitarray, bits2bytes, decodetree,
@@ -73,6 +74,26 @@ class Util:
         for a in self.randombitarrays():
             yield a.tolist()
 
+    def unaligned_buffers(self, size=32, endian=None):
+        for remainder in range(8):
+            owner = bytearray(size + 8)
+            base = bitarray(buffer=owner).buffer_info().address
+            offset = (remainder - base) % 8
+            buffer = memoryview(owner)[offset:offset + size]
+            a = bitarray(buffer=buffer, endian=endian)
+
+            self.assertEqual(len(a), 8 * size)
+            self.assertEqual(a.buffer_info().address % 8, remainder)
+            yield a
+
+            self.assertEqual(owner[:offset], bytearray(offset))
+            self.assertEqual(owner[offset + size:], bytearray(8 - offset))
+
+    @staticmethod
+    def is_unaligned(a):
+        info = a.buffer_info()
+        return info.address % 8 != 0
+
     @staticmethod
     def opposite_endian(endian):
         t = {'little': 'big',
@@ -1735,6 +1756,20 @@ class MiscTests(unittest.TestCase, Util):
             for i in range(len(a)):
                 self.assertEqual(a[i], b[i + 1234])
 
+    def test_subclass_inplace(self) -> None:
+        class SubBitarray(bitarray):
+            pass
+
+        a: SubBitarray = SubBitarray('101')
+        a += bitarray()
+        a *= 1
+        a &= bitarray('110')
+        a |= bitarray('001')
+        a ^= bitarray('010')
+        a <<= 1
+        a >>= 1
+        self.assertIs(type(a), SubBitarray)
+
     @unittest.skipIf(is_pypy, "skip test on PyPy")
     def test_overflow(self):
         a = bitarray(1)
@@ -1773,8 +1808,7 @@ class MiscTests(unittest.TestCase, Util):
         self.assertIsInstance(a, abc.MutableSequence)
         if sys.version_info[:2] >= (3, 12):
             self.assertIsInstance(a, abc.Buffer)
-        if sys.platform != "win32":
-            self.assertFalse(isinstance(a, abc.Hashable))
+        self.assertFalse(isinstance(a, abc.Hashable))
 
 # ---------------------------------------------------------------------------
 
@@ -2080,14 +2114,16 @@ class SpecialMethodTests(unittest.TestCase, Util):
 
 # -------------------------- Sequence methods tests -------------------------
 
-class SequenceTests(unittest.TestCase, Util):
+class SequenceTests(unittest.TestCase):
 
     def test_len(self):
         for n in range(100):
             a = bitarray(n)
             self.assertEqual(len(a), n)
 
-    def test_concat(self):
+class ConcatTests(unittest.TestCase, Util):
+
+    def test_simple(self):
         a = bitarray('001')
         b = a + bitarray('110')
         self.assertEQUAL(b, bitarray('001110'))
@@ -2103,7 +2139,7 @@ class SequenceTests(unittest.TestCase, Util):
         self.assertRaises(TypeError, a.__add__, 42)
         self.assertRaises(ValueError, a.__add__, b'1101')
 
-    def test_concat_random(self):
+    def test_random(self):
         for a in self.randombitarrays():
             aa = a.copy()
             for b in self.randombitarrays():
@@ -2116,7 +2152,7 @@ class SequenceTests(unittest.TestCase, Util):
                 self.assertEQUAL(a, aa)
                 self.assertEQUAL(b, bb)
 
-    def test_concat_frozenbitarray(self):
+    def test_frozenbitarray(self):
         a = frozenbitarray('001')
         b = a + bitarray('011')
         self.assertIs(type(b), frozenbitarray)
@@ -2124,7 +2160,7 @@ class SequenceTests(unittest.TestCase, Util):
         self.assertTrue(b.readonly)
         self.check_obj(b)
 
-    def test_inplace_concat(self):
+    def test_inplace(self):
         a = bitarray('001')
         a += bitarray('110')
         self.assertEqual(a, bitarray('001110'))
@@ -2151,7 +2187,9 @@ class SequenceTests(unittest.TestCase, Util):
                 self.assertIs(c, d)
                 self.check_obj(d)
 
-    def test_repeat_explicit(self):
+class RepeatTests(unittest.TestCase, Util):
+
+    def test_explicit(self):
         for m, s, r in [
                 ( 0,        '',      ''),
                 ( 0, '1001111',      ''),
@@ -2168,14 +2206,14 @@ class SequenceTests(unittest.TestCase, Util):
             c *= m
             self.assertEqual(c, bitarray(r))
 
-    def test_repeat_wrong_args(self):
+    def test_wrong_args(self):
         a = bitarray()
         self.assertRaises(TypeError, a.__mul__, None)
         self.assertRaises(TypeError, a.__mul__, 2.0)
         self.assertRaises(TypeError, a.__imul__, None)
         self.assertRaises(TypeError, a.__imul__, 3.0)
 
-    def test_repeat_frozenbitarray(self):
+    def test_frozenbitarray(self):
         a = frozenbitarray('001')
         b = 3 * a
         self.assertIs(type(b), frozenbitarray)
@@ -2183,7 +2221,7 @@ class SequenceTests(unittest.TestCase, Util):
         self.assertTrue(b.readonly)
         self.check_obj(b)
 
-    def test_repeat_random(self):
+    def test_random(self):
         for a in self.randombitarrays():
             b = a.copy()
             for m in list(range(-3, 5)) + [randint(5, 200)]:
@@ -2200,7 +2238,9 @@ class SequenceTests(unittest.TestCase, Util):
 
             self.assertEQUAL(a, b)
 
-    def test_contains_simple(self):
+class ContainsTests(unittest.TestCase):
+
+    def test_simple(self):
         a = bitarray()
         self.assertFalse(0 in a)
         self.assertFalse(1 in a)
@@ -2215,7 +2255,7 @@ class SequenceTests(unittest.TestCase, Util):
         self.assertTrue(0 in a)
         self.assertTrue(1 in a)
 
-    def test_contains_errors(self):
+    def test_errors(self):
         a = bitarray()
         self.assertFalse(a.__contains__(1))
         a.append(1)
@@ -2227,7 +2267,7 @@ class SequenceTests(unittest.TestCase, Util):
         self.assertRaises(ValueError, a.__contains__, 2)
         self.assertRaises(ValueError, a.__contains__, -1)
 
-    def test_contains_range(self):
+    def test_range(self):
         for n in range(2, 50):
             a = zeros(n)
             self.assertTrue(0 in a)
@@ -2242,7 +2282,7 @@ class SequenceTests(unittest.TestCase, Util):
             self.assertTrue(True in a)
             self.assertTrue(False in a)
 
-    def test_contains_explicit(self):
+    def test_explicit(self):
         a = bitarray('011010000001')
         for s, r in [('', True), # every bitarray contains an empty one
                      ('1', True), ('11', True), ('111', False),
@@ -2431,6 +2471,18 @@ class NumberTests(unittest.TestCase, Util):
         b[16:] &= bitarray("1111 0000 1111 0000", 'big')
         self.assertEqual(a, bytearray([0xfc, 0x88, 0x10, 0xe0]))
 
+    def test_unaligned_buffers(self):
+        for a in self.unaligned_buffers():
+            for b in self.unaligned_buffers():
+                a.setall(0)
+                a[187] = a[193] = b[193] = b[194] = 1
+                a &= b
+                self.assertEqual(list(a.search(1)), [193])
+                a ^= b
+                self.assertEqual(list(a.search(1)), [194])
+                a |= b
+                self.assertEqual(list(a.search(1)), [193, 194])
+
 
 class ShiftTests(unittest.TestCase, Util):
 
@@ -2593,6 +2645,18 @@ class ShiftTests(unittest.TestCase, Util):
         b >>= 8
         self.assertEqual(a, bytearray([0x00, 0xfc, 0x88, 0x10]))
 
+    def test_unaligned_buffers(self):
+        for endian in ENDIANS:
+            for a in self.unaligned_buffers(endian=endian):
+                a[0] = a[193] = a[-1] = 1
+                expected = self.shift(a, 3, 'left')
+                a <<= 3
+                self.assertEQUAL(a, expected)
+
+                expected = self.shift(a, 5, 'right')
+                a >>= 5
+                self.assertEQUAL(a, expected)
+
 # --------------------------------   .extend()   ----------------------------
 
 class ExtendTests(unittest.TestCase, Util):
@@ -3115,6 +3179,22 @@ class InvertTests(unittest.TestCase, Util):
         b.invert()
         self.assertEqual(a, bytearray([255, 254, 253, 252, 223, 0]))
 
+    def test_unaligned_buffers(self):
+        for n in range(20):
+            for endian in ENDIANS:
+                for a in self.unaligned_buffers(size=n, endian=endian):
+                    a.invert()
+                    self.assertEqual(a, ones(len(a)))
+                    if n == 0:
+                        continue
+                    i = randrange(len(a))
+                    a.invert(i)
+                    self.assertEqual(a.find(0), i)
+                    self.assertEqual(a.endian, endian)
+                    a.invert(slice(0, i))
+                    a.invert(slice(i + 1, None))
+                    self.assertEqual(a, zeros(8 * n))
+
 class SortTests(unittest.TestCase, Util):
 
     def test_simple(self):
@@ -3813,13 +3893,15 @@ class CountTests(unittest.TestCase, Util):
             self.assertEqual(a.count(v, s.start, s.stop, s.step),
                              a[s].count(v))
 
-    def test_offset_buffer(self):
-        # this tests if words are aligned in popcnt_words()
-        N = 1 << 16
-        for i in range(20):
-            a = urandom_2(N, 'little')
-            b = bitarray(buffer=memoryview(a)[i:], endian='little')
-            self.assertEqual(b.count(), a.count(1, 8 * i))
+    def test_unaligned_buffers(self):
+        for n in range(20):
+            for endian in ENDIANS:
+                for a in self.unaligned_buffers(size=n, endian=endian):
+                    b = urandom_2(8 * n)
+                    expected = b.count()
+                    a[:] = b
+                    self.assertEqual(a.count(), expected)
+                    self.assertEqual(a.endian, endian)
 
 # -------------------------- .find() and .index() ---------------------------
 
@@ -3993,6 +4075,23 @@ class IndexTests(unittest.TestCase, Util):
                 self.assertEqual(a.find(v, i, j, 0), ref_l)
                 self.assertEqual(a.find(v, i, j, 1), ref_r)
 
+    def test_unaligned_buffers(self):
+        for n in range(20):
+            for endian in ENDIANS:
+                for a in self.unaligned_buffers(size=n, endian=endian):
+                    self.assertEqual(a.find(1), -1)
+                    if n == 0:
+                        continue
+                    i = randrange(len(a))
+                    a[i] = 1
+                    self.assertEqual(a.find(1), i)
+                    self.assertEqual(a.find(1, right=1), i)
+                    a.setall(1)
+                    self.assertEqual(a.find(0), -1)
+                    a[i] = 0
+                    self.assertEqual(a.find(0), i)
+                    self.assertEqual(a.find(0, right=1), i)
+
 # ----------------------------- .search() -----------------------------------
 
 class SearchTests(unittest.TestCase, Util):
@@ -5623,12 +5722,17 @@ class FrozenbitarrayTests(unittest.TestCase, Util):
 
         self.check_obj(a)
 
-    def test_copy(self):
+    def test_copy(self) -> None:
         a = frozenbitarray('101')
-        # not only .copy() creates new frozenbitarray which are read-only
-        for b in [a, a.copy(), 3 * a, 5 * a, a & bitarray('110'),
-                  a >> 2, ~a, a + bitarray(8*'1'),
-                  a[:], a[::2], a[[0, 1]], a[bitarray('011')]]:
+        # Check the stub return types as well as the runtime types.
+        copies: list[frozenbitarray] = [
+            a.copy(), 3 * a, a * 5, a & bitarray('110'),
+            a | bitarray('110'), a ^ bitarray('110'),
+            a & frozenbitarray('110'), a | frozenbitarray('110'),
+            a ^ frozenbitarray('110'), a >> 2, a << 1, ~a,
+            a + bitarray(8*'1'), a[:], a[::2], a[[0, 1]], a[bitarray('011')],
+        ]
+        for b in copies:
             self.assertIs(type(b), frozenbitarray)
             self.assertTrue(b.readonly)
             self.check_obj(b)
@@ -5748,14 +5852,15 @@ def show_info(verbosity=1):
 
     if verbosity >= 2:
         print('bitarray version: %s' % __version__)
+        print('platform.machine(): %s' % platform.machine())
+        print('platform.platform(): %s' % platform.platform())
+        print('sys.platform: %s' % sys.platform)
         print('sys.version: %s' % sys.version)
         if os.name == "posix":
             print('sys.abiflags: %r' % sys.abiflags)
         if sys.version_info[:2] >= (3, 14):
             print('sys._is_gil_enabled(): %s' % sys._is_gil_enabled())
         print('pointer size: %d bit' % (8 * PTRSIZE))
-        print('sizeof(size_t): %d' % sysinfo("size_t"))
-        print('sizeof(bitarrayobject): %d' % sysinfo("bitarrayobject"))
         print('HAVE_BUILTIN_BSWAP64: %d' % sysinfo("HAVE_BUILTIN_BSWAP64"))
         print('default bit-endianness: %s' % get_default_endian())
         print('machine byte-order: %s' % sys.byteorder)

{bitarray-3.12.2 → bitarray-3.12.3}/bitarray/test_util.py

@@ -24,7 +24,8 @@ from collections import Counter
 
 from bitarray import (bitarray, frozenbitarray, decodetree, bits2bytes,
                       get_default_endian)
-from bitarray.test_bitarray import Util, is_pypy, urandom_2, ENDIANS, PTRSIZE
+from bitarray.test_bitarray import (Util, is_pypy, is_sparc, urandom_2,
+                                    ENDIANS, PTRSIZE)
 
 from bitarray.util import (
     zeros, ones, urandom, random_k, random_p, pprint, strip, count_n,
@@ -687,6 +688,15 @@ class CountN_Tests(unittest.TestCase, Util):
                 i = count_n(a, n, v)
                 self.check_result(a, n, i, v)
 
+    def test_unaligned_buffers(self):
+        # size=1000 means that 8000 bits > BLOCK_BITS 4096
+        for a in self.unaligned_buffers(size=1000):
+            a[-1] = 1
+            if is_sparc and self.is_unaligned(a):
+                self.assertRaises(NotImplementedError, count_n, a, 1)
+            else:
+                self.assertEqual(count_n(a, 1), len(a))
+
 # ---------------------------------------------------------------------------
 
 class BitwiseCountTests(unittest.TestCase, Util):
@@ -771,6 +781,16 @@ class BitwiseCountTests(unittest.TestCase, Util):
             self.assertEqual(all(a ^ b), count_xor(a, b) == n)
             self.assertEqual(all(a ^ b), a == ~b)
 
+    def test_unaligned_buffers(self):
+        for f in count_and, count_or, count_xor, any_and, subset:
+            for a in self.unaligned_buffers():
+                for b in self.unaligned_buffers():
+                    if is_sparc and (self.is_unaligned(a) or
+                                     self.is_unaligned(b)):
+                        self.assertRaises(NotImplementedError, f, a, b)
+                    else:
+                        self.assertEqual(f(a, b), f == subset)
+
 # ---------------------------  any_and()  -----------------------------------
 
 class BitwiseAnyTests(unittest.TestCase, Util):
@@ -905,7 +925,7 @@ class SubsetTests(unittest.TestCase, Util):
 
 # -------------------------  correspond_all()  ------------------------------
 
-class CorrespondAllTests(unittest.TestCase):
+class CorrespondAllTests(unittest.TestCase, Util):
 
     def test_basic(self):
         a = frozenbitarray('0101')
@@ -941,10 +961,20 @@ class CorrespondAllTests(unittest.TestCase):
             self.assertEqual(res[1] + res[2], count_xor(a, b))
             self.assertEqual(sum(res), n)
 
+    def test_unaligned_buffers(self):
+        for a in self.unaligned_buffers():
+            for b in self.unaligned_buffers():
+                if is_sparc and (self.is_unaligned(a) or
+                                 self.is_unaligned(b)):
+                    self.assertRaises(NotImplementedError,
+                                      correspond_all, a, b)
+                else:
+                    self.assertEqual(correspond_all(a, b), (len(a), 0, 0, 0))
+
 # -----------------------------  byteswap()  --------------------------------
 
 @unittest.skipIf(is_pypy, "skip test on PyPy")
-class ByteSwapTests(unittest.TestCase):
+class ByteSwapTests(unittest.TestCase, Util):
 
     def test_basic_bytearray(self):
         a = bytearray(b"ABCD")
@@ -1039,9 +1069,15 @@ class ByteSwapTests(unittest.TestCase):
             a.bytereverse()
             self.assertEqual(a, b[::-1])
 
+    def test_unaligned_buffers(self):
+        for n in 2, 4, 8, 16:
+            for a in self.unaligned_buffers():
+                byteswap(a, n)
+                self.assertEqual(a, zeros(256))
+
 # ------------------------------  parity()  ---------------------------------
 
-class ParityTests(unittest.TestCase):
+class ParityTests(unittest.TestCase, Util):
 
     def test_explicit(self):
         for s, res in [('', 0), ('1', 1), ('0010011', 1), ('10100110', 0)]:
@@ -1072,6 +1108,27 @@ class ParityTests(unittest.TestCase):
         self.assertRaises(TypeError, parity)
         self.assertRaises(TypeError, parity, bitarray("110"), 1)
 
+    def test_unaligned_buffers(self):
+        for a in self.unaligned_buffers():
+            self.assertEqual(parity(a), 0)
+            a[0] = 1
+            self.assertEqual(parity(a), 1)
+            a[193] = 1
+            self.assertEqual(parity(a), 0)
+            a[-1] = 1
+            self.assertEqual(parity(a), 1)
+
+    def test_unaligned_buffers_random(self):
+        for n in range(20):
+            for endian in ENDIANS:
+                for a in self.unaligned_buffers(size=n, endian=endian):
+                    b = urandom(8 * n)
+                    expected = b.count() % 2
+                    a[:] = b
+                    self.assertEqual(len(a), 8 * n)
+                    self.assertEqual(a.endian, endian)
+                    self.assertEqual(parity(a), expected)
+
 # ----------------------------  sum_indices()  ------------------------------
 
 class SumIndicesTests(unittest.TestCase):
@@ -2143,6 +2200,12 @@ class SC_Tests(unittest.TestCase, Util, SC_Util):
                 a &= urandom(n, endian)
                 self.round_trip(a)
 
+    def test_unaligned_buffers(self):
+        for a in self.unaligned_buffers(size=1000):
+            if is_sparc and self.is_unaligned(a):
+                self.assertRaises(NotImplementedError, sc_encode, a)
+            else:
+                self.assertEqual(sc_decode(sc_encode(a)), a)
 
 # ------------------------   variable length codec   ------------------------
 

{bitarray-3.12.2 → bitarray-3.12.3}/bitarray.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitarray
-Version: 3.12.2
+Version: 3.12.3
 Summary: efficient arrays of booleans -- C extension
 Home-page: https://github.com/ilanschnell/bitarray
 Author: Ilan Schnell
@@ -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 by CPython and PyPy <https://github.com/ilanschnell/bitarray/blob/master/doc/platforms.rst>`__.
 * 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.3
+    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.3 -- `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.