bitarray 3.12.1__tar.gz → 3.12.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitarray
-Version: 3.12.1
+Version: 3.12.3
 Summary: efficient arrays of booleans -- C extension
 Home-page: https://github.com/ilanschnell/bitarray
 Author: Ilan Schnell
@@ -57,7 +57,9 @@ Key features
   their in-place versions ``&=``, ``|=``, ``^=``, ``<<=``, ``>>=``).
 * `Free-threading support <https://github.com/ilanschnell/bitarray/blob/master/doc/free_threading.rst>`__
   (for GIL-disabled CPython 3.14 and later)
-* Fast methods for encoding and decoding variable-length prefix codes.
+* 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>`__
   (both importing and exporting buffers).
 * Efficient packing and unpacking for interoperability with byte-oriented
@@ -91,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:
 
@@ -100,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.1
+    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
@@ -289,59 +292,6 @@ this topic, please read `buffer protocol <https://github.com/ilanschnell/bitarra
 to memory-map a file to a bitarray: `mmapped-file.py <https://github.com/ilanschnell/bitarray/blob/master/examples/mmapped-file.py>`__
 
 
-Variable-length prefix codes
-----------------------------
-
-The ``.encode()`` method takes a dictionary mapping symbols to bitarrays
-and an iterable, and extends the bitarray object with the encoded symbols
-found while iterating.  For example:
-
-.. code-block:: python
-
-    >>> d = {'H':bitarray('111'), 'e':bitarray('0'),
-    ...      'l':bitarray('110'), 'o':bitarray('10')}
-    ...
-    >>> a = bitarray()
-    >>> a.encode(d, 'Hello')
-    >>> a
-    bitarray('111011011010')
-
-Note that the string ``'Hello'`` is an iterable, but the symbols are not
-limited to characters, in fact any immutable Python object can be a symbol.
-Taking the same dictionary, we can apply the ``.decode()`` method which will
-return an iterable of the symbols:
-
-.. code-block:: python
-
-    >>> list(a.decode(d))
-    ['H', 'e', 'l', 'l', 'o']
-    >>> ''.join(a.decode(d))
-    'Hello'
-
-Symbols are not limited to being characters.
-The above dictionary ``d`` can be efficiently constructed using the function
-``bitarray.util.huffman_code()``.  I also wrote `Huffman coding in Python
-using bitarray <http://ilan.schnell-web.net/prog/huffman/>`__ for more
-background information.
-
-When the codes are large, and you have many decode calls, most time will
-be spent creating the (same) internal decode tree objects.  In this case,
-it will be much faster to create a ``decodetree`` object, which can be
-passed to bitarray's ``.decode()`` method, instead of passing the prefix
-code dictionary to those methods itself:
-
-.. code-block:: python
-
-    >>> from bitarray import bitarray, decodetree
-    >>> t = decodetree({'a': bitarray('0'), 'b': bitarray('1')})
-    >>> a = bitarray('0110')
-    >>> list(a.decode(t))
-    ['a', 'b', 'b', 'a']
-
-The sole purpose of the immutable ``decodetree`` object is to be passed
-to bitarray's ``.decode()`` method.
-
-
 Frozenbitarrays
 ---------------
 
@@ -364,7 +314,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.12.1 -- `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.
@@ -475,7 +425,7 @@ bitarray methods:
    corresponding symbols.
    The prefix code length cannot exceed 256 bits.
 
-   See also: `Bitarray 3 transition <https://github.com/ilanschnell/bitarray/blob/master/doc/bitarray3.rst>`__
+   See also: `Bitarray 3 transition <https://github.com/ilanschnell/bitarray/blob/master/doc/bitarray3.rst>`__, `Variable-length prefix codes <https://github.com/ilanschnell/bitarray/blob/master/doc/prefix_codes.rst>`__
 
    New in version 3.0: returns iterator (equivalent to past ``.iterdecode()``)
 
@@ -487,6 +437,8 @@ bitarray methods:
    iterate over the iterable object with symbols, and extend bitarray
    with corresponding bitarray for each symbol.
 
+   See also: `Variable-length prefix codes <https://github.com/ilanschnell/bitarray/blob/master/doc/prefix_codes.rst>`__
+
 
 ``extend(iterable, /)``
    Append items from iterable to the end of the bitarray.
@@ -725,6 +677,8 @@ Other objects:
    create a binary tree object to be passed to ``.decode()``.
    The prefix code length cannot exceed 256 bits.
 
+   See also: `Variable-length prefix codes <https://github.com/ilanschnell/bitarray/blob/master/doc/prefix_codes.rst>`__
+
    New in version 1.6
 
 
@@ -911,6 +865,8 @@ This sub-module was added in version 1.2.
    frozenbitarrays (with given bit-endianness).  Note that the symbols are not
    limited to being strings.  Symbols may be any hashable object.
 
+   See also: `Variable-length prefix codes <https://github.com/ilanschnell/bitarray/blob/master/doc/prefix_codes.rst>`__
+
    New in version 3.10: return a codedict mapping to frozenbitarrays
 
 

{bitarray-3.12.1 → bitarray-3.12.3}/README.rst

@@ -21,7 +21,9 @@ Key features
   their in-place versions ``&=``, ``|=``, ``^=``, ``<<=``, ``>>=``).
 * `Free-threading support <https://github.com/ilanschnell/bitarray/blob/master/doc/free_threading.rst>`__
   (for GIL-disabled CPython 3.14 and later)
-* Fast methods for encoding and decoding variable-length prefix codes.
+* 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>`__
   (both importing and exporting buffers).
 * Efficient packing and unpacking for interoperability with byte-oriented
@@ -55,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:
 
@@ -64,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.1
+    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
@@ -253,59 +256,6 @@ this topic, please read `buffer protocol <https://github.com/ilanschnell/bitarra
 to memory-map a file to a bitarray: `mmapped-file.py <https://github.com/ilanschnell/bitarray/blob/master/examples/mmapped-file.py>`__
 
 
-Variable-length prefix codes
-----------------------------
-
-The ``.encode()`` method takes a dictionary mapping symbols to bitarrays
-and an iterable, and extends the bitarray object with the encoded symbols
-found while iterating.  For example:
-
-.. code-block:: python
-
-    >>> d = {'H':bitarray('111'), 'e':bitarray('0'),
-    ...      'l':bitarray('110'), 'o':bitarray('10')}
-    ...
-    >>> a = bitarray()
-    >>> a.encode(d, 'Hello')
-    >>> a
-    bitarray('111011011010')
-
-Note that the string ``'Hello'`` is an iterable, but the symbols are not
-limited to characters, in fact any immutable Python object can be a symbol.
-Taking the same dictionary, we can apply the ``.decode()`` method which will
-return an iterable of the symbols:
-
-.. code-block:: python
-
-    >>> list(a.decode(d))
-    ['H', 'e', 'l', 'l', 'o']
-    >>> ''.join(a.decode(d))
-    'Hello'
-
-Symbols are not limited to being characters.
-The above dictionary ``d`` can be efficiently constructed using the function
-``bitarray.util.huffman_code()``.  I also wrote `Huffman coding in Python
-using bitarray <http://ilan.schnell-web.net/prog/huffman/>`__ for more
-background information.
-
-When the codes are large, and you have many decode calls, most time will
-be spent creating the (same) internal decode tree objects.  In this case,
-it will be much faster to create a ``decodetree`` object, which can be
-passed to bitarray's ``.decode()`` method, instead of passing the prefix
-code dictionary to those methods itself:
-
-.. code-block:: python
-
-    >>> from bitarray import bitarray, decodetree
-    >>> t = decodetree({'a': bitarray('0'), 'b': bitarray('1')})
-    >>> a = bitarray('0110')
-    >>> list(a.decode(t))
-    ['a', 'b', 'b', 'a']
-
-The sole purpose of the immutable ``decodetree`` object is to be passed
-to bitarray's ``.decode()`` method.
-
-
 Frozenbitarrays
 ---------------
 
@@ -328,7 +278,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.12.1 -- `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.
@@ -439,7 +389,7 @@ bitarray methods:
    corresponding symbols.
    The prefix code length cannot exceed 256 bits.
 
-   See also: `Bitarray 3 transition <https://github.com/ilanschnell/bitarray/blob/master/doc/bitarray3.rst>`__
+   See also: `Bitarray 3 transition <https://github.com/ilanschnell/bitarray/blob/master/doc/bitarray3.rst>`__, `Variable-length prefix codes <https://github.com/ilanschnell/bitarray/blob/master/doc/prefix_codes.rst>`__
 
    New in version 3.0: returns iterator (equivalent to past ``.iterdecode()``)
 
@@ -451,6 +401,8 @@ bitarray methods:
    iterate over the iterable object with symbols, and extend bitarray
    with corresponding bitarray for each symbol.
 
+   See also: `Variable-length prefix codes <https://github.com/ilanschnell/bitarray/blob/master/doc/prefix_codes.rst>`__
+
 
 ``extend(iterable, /)``
    Append items from iterable to the end of the bitarray.
@@ -689,6 +641,8 @@ Other objects:
    create a binary tree object to be passed to ``.decode()``.
    The prefix code length cannot exceed 256 bits.
 
+   See also: `Variable-length prefix codes <https://github.com/ilanschnell/bitarray/blob/master/doc/prefix_codes.rst>`__
+
    New in version 1.6
 
 
@@ -875,6 +829,8 @@ This sub-module was added in version 1.2.
    frozenbitarrays (with given bit-endianness).  Note that the symbols are not
    limited to being strings.  Symbols may be any hashable object.
 
+   See also: `Variable-length prefix codes <https://github.com/ilanschnell/bitarray/blob/master/doc/prefix_codes.rst>`__
+
    New in version 3.10: return a codedict mapping to frozenbitarrays
 
 

{bitarray-3.12.1 → 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.1 → bitarray-3.12.3}/bitarray/_bitarray.c

@@ -224,19 +224,19 @@ 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) % 4 == 0);
+    assert(w == 0 || ((uintptr_t) buff) % 8 == 0);
     while (w--) {                 /* shift in word-range(0, w) */
         uint64_t *p = ((uint64_t *) buff) + w;
 #if HAVE_BUILTIN_BSWAP64 && PY_BIG_ENDIAN
@@ -254,19 +254,19 @@ 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) % 4 == 0);
+    assert(w == 0 || ((uintptr_t) buff) % 8 == 0);
     while (w--) {                 /* shift in word-range(0, w) */
         uint64_t *p = ((uint64_t *) buff) + w;
 #if HAVE_BUILTIN_BSWAP64 && PY_LITTLE_ENDIAN
@@ -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 */