bitarray 3.8.1__tar.gz → 3.8.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitarray
-Version: 3.8.1
+Version: 3.8.2
 Summary: efficient arrays of booleans -- C extension
 Home-page: https://github.com/ilanschnell/bitarray
 Author: Ilan Schnell
@@ -11,7 +11,6 @@ Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: C
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
@@ -91,7 +90,7 @@ Once you have installed the package, you may want to test it:
 
     $ python -c 'import bitarray; bitarray.test()'
     bitarray is installed in: /Users/ilan/bitarray/bitarray
-    bitarray version: 3.8.1
+    bitarray version: 3.8.2
     sys.version: 3.13.5 (main, Jun 16 2025) [Clang 18.1.8]
     sys.prefix: /Users/ilan/miniforge
     pointer size: 64 bit
@@ -354,7 +353,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.8.1 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.8.2 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
 
 In the following, ``item`` and ``value`` are usually a single bit -
 an integer 0 or 1.
@@ -378,7 +377,7 @@ The bitarray object:
 
    ``endian``: Specifies the bit-endianness of the created bitarray object.
    Allowed values are ``big`` and ``little`` (the default is ``big``).
-   The bit-endianness effects the buffer representation of the bitarray.
+   The bit-endianness affects the buffer representation of the bitarray.
 
    ``buffer``: Any object which exposes a buffer.  When provided, ``initializer``
    cannot be present (or has to be ``None``).  The imported buffer may be
@@ -473,7 +472,7 @@ bitarray methods:
 
 
 ``extend(iterable, /)``
-   Append items from to the end of the bitarray.
+   Append items from iterable to the end of the bitarray.
    If ``iterable`` is a (Unicode) string, each ``0`` and ``1`` are appended as
    bits (ignoring whitespace and underscore).
 
@@ -504,7 +503,7 @@ bitarray methods:
 
 ``fromfile(f, n=-1, /)``
    Extend bitarray with up to ``n`` bytes read from file object ``f`` (or any
-   other binary stream what supports a ``.read()`` method, e.g. ``io.BytesIO``).
+   other binary stream that supports a ``.read()`` method, e.g. ``io.BytesIO``).
    Each read byte will add eight bits to the bitarray.  When ``n`` is omitted
    or negative, reads and extends all data until EOF.
    When ``n`` is non-negative but exceeds the available data, ``EOFError`` is
@@ -524,8 +523,9 @@ bitarray methods:
 
 
 ``invert(index=<all bits>, /)``
-   Invert all bits in bitarray (in-place).
-   When the optional ``index`` is given, only invert the single bit at ``index``.
+   Invert bits in-place.  When ``index`` is omitted, invert all bits.
+   When ``index`` is an integer, invert the single bit at index.
+   When ``index`` is a slice, invert the selected bits.
 
    New in version 1.5.3: optional index argument
 
@@ -608,7 +608,7 @@ bitarray methods:
 
 ``unpack(zero=b'\x00', one=b'\x01')`` -> bytes
    Return bytes that contain one byte for each bit in the bitarray,
-   using specified mapping.
+   using the specified mapping.
 
 
 bitarray data descriptors:
@@ -683,7 +683,8 @@ This sub-module was added in version 1.2.
 ``ba2base(n, bitarray, /, group=0, sep=' ')`` -> str
    Return a string containing the base ``n`` ASCII representation of
    the bitarray.  Allowed values for ``n`` are 2, 4, 8, 16, 32 and 64.
-   The bitarray has to be multiple of length 1, 2, 3, 4, 5 or 6 respectively.
+   The bitarray has to have a length divisible by 1, 2, 3, 4, 5 or 6
+   respectively.
    For ``n=32`` the RFC 4648 Base32 alphabet is used, and for ``n=64`` the
    standard base 64 alphabet is used.
    When grouped, the string ``sep`` is inserted between groups

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

@@ -57,7 +57,7 @@ Once you have installed the package, you may want to test it:
 
     $ python -c 'import bitarray; bitarray.test()'
     bitarray is installed in: /Users/ilan/bitarray/bitarray
-    bitarray version: 3.8.1
+    bitarray version: 3.8.2
     sys.version: 3.13.5 (main, Jun 16 2025) [Clang 18.1.8]
     sys.prefix: /Users/ilan/miniforge
     pointer size: 64 bit
@@ -320,7 +320,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.8.1 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.8.2 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
 
 In the following, ``item`` and ``value`` are usually a single bit -
 an integer 0 or 1.
@@ -344,7 +344,7 @@ The bitarray object:
 
    ``endian``: Specifies the bit-endianness of the created bitarray object.
    Allowed values are ``big`` and ``little`` (the default is ``big``).
-   The bit-endianness effects the buffer representation of the bitarray.
+   The bit-endianness affects the buffer representation of the bitarray.
 
    ``buffer``: Any object which exposes a buffer.  When provided, ``initializer``
    cannot be present (or has to be ``None``).  The imported buffer may be
@@ -439,7 +439,7 @@ bitarray methods:
 
 
 ``extend(iterable, /)``
-   Append items from to the end of the bitarray.
+   Append items from iterable to the end of the bitarray.
    If ``iterable`` is a (Unicode) string, each ``0`` and ``1`` are appended as
    bits (ignoring whitespace and underscore).
 
@@ -470,7 +470,7 @@ bitarray methods:
 
 ``fromfile(f, n=-1, /)``
    Extend bitarray with up to ``n`` bytes read from file object ``f`` (or any
-   other binary stream what supports a ``.read()`` method, e.g. ``io.BytesIO``).
+   other binary stream that supports a ``.read()`` method, e.g. ``io.BytesIO``).
    Each read byte will add eight bits to the bitarray.  When ``n`` is omitted
    or negative, reads and extends all data until EOF.
    When ``n`` is non-negative but exceeds the available data, ``EOFError`` is
@@ -490,8 +490,9 @@ bitarray methods:
 
 
 ``invert(index=<all bits>, /)``
-   Invert all bits in bitarray (in-place).
-   When the optional ``index`` is given, only invert the single bit at ``index``.
+   Invert bits in-place.  When ``index`` is omitted, invert all bits.
+   When ``index`` is an integer, invert the single bit at index.
+   When ``index`` is a slice, invert the selected bits.
 
    New in version 1.5.3: optional index argument
 
@@ -574,7 +575,7 @@ bitarray methods:
 
 ``unpack(zero=b'\x00', one=b'\x01')`` -> bytes
    Return bytes that contain one byte for each bit in the bitarray,
-   using specified mapping.
+   using the specified mapping.
 
 
 bitarray data descriptors:
@@ -649,7 +650,8 @@ This sub-module was added in version 1.2.
 ``ba2base(n, bitarray, /, group=0, sep=' ')`` -> str
    Return a string containing the base ``n`` ASCII representation of
    the bitarray.  Allowed values for ``n`` are 2, 4, 8, 16, 32 and 64.
-   The bitarray has to be multiple of length 1, 2, 3, 4, 5 or 6 respectively.
+   The bitarray has to have a length divisible by 1, 2, 3, 4, 5 or 6
+   respectively.
    For ``n=32`` the RFC 4648 Base32 alphabet is used, and for ``n=64`` the
    standard base 64 alphabet is used.
    When grouped, the string ``sep`` is inserted between groups

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

@@ -24,6 +24,34 @@ static PyTypeObject Bitarray_Type;
 #define bitarray_Check(obj)  PyObject_TypeCheck((obj), &Bitarray_Type)
 
 
+static size_t
+new_allocation(size_t size, size_t allocated, size_t newsize)
+{
+    assert(allocated >= size);
+    assert(newsize > 0);
+
+    if (allocated >= newsize) {
+        /* current buffer is large enough to host the requested size */
+        if (newsize >= allocated / 2)
+            return allocated;  /* minor downsize - keep current allocation */
+
+        return newsize;  /* major downsize - shrink to exact size */
+    }
+    else {
+          /* need to grow buffer */
+          size_t new_alloc = newsize;
+          /* overallocate when previous size isn't zero and when growth
+             is moderate */
+          if (size != 0 && newsize / 2 <= allocated) {
+              /* overallocate proportional to the bitarray size and
+                 add padding to make the allocated size multiple of 4 */
+              new_alloc += (newsize >> 4) + (newsize < 8 ? 3 : 7);
+              new_alloc &= ~(size_t) 3;
+          }
+          return new_alloc;
+    }
+}
+
 static int
 resize(bitarrayobject *self, Py_ssize_t nbits)
 {
@@ -69,28 +97,13 @@ resize(bitarrayobject *self, Py_ssize_t nbits)
         return 0;
     }
 
-    if (allocated >= newsize) {
-        /* current buffer is large enough to host the requested size */
-        if (newsize >= allocated / 2) {
-            /* minor downsize, bypass reallocation */
-            Py_SET_SIZE(self, newsize);
-            self->nbits = nbits;
-            return 0;
-        }
-        /* major downsize, resize down to exact size */
-        new_allocated = newsize;
-    }
-    else {
-        /* need to grow buffer */
-        new_allocated = newsize;
-        /* overallocate when previous size isn't zero and when growth
-           is moderate */
-        if (size != 0 && newsize / 2 <= allocated) {
-            /* overallocate proportional to the bitarray size and
-               add padding to make the allocated size multiple of 4 */
-            new_allocated += (newsize >> 4) + (newsize < 8 ? 3 : 7);
-            new_allocated &= ~(size_t) 3;
-        }
+    new_allocated = new_allocation(size, allocated, newsize);
+
+    if (new_allocated == allocated) {
+        /* bypass reallocation */
+        Py_SET_SIZE(self, newsize);
+        self->nbits = nbits;
+        return 0;
     }
 
     assert(new_allocated >= newsize);
@@ -203,7 +216,7 @@ bytereverse(char *p, Py_ssize_t n)
 /* The following two functions operate on first n bytes in buffer.
    Within this region, they shift all bits by k positions to right,
    i.e. towards higher addresses.
-   They operate on little-endian and bit-endian bitarrays respectively.
+   They operate on little-endian and big-endian bitarrays respectively.
    As we shift right, we need to start with the highest address and loop
    downwards such that lower bytes are still unaltered.
    See also devel/shift_r8.c
@@ -1194,7 +1207,7 @@ bitarray_extend(bitarrayobject *self, PyObject *obj)
 PyDoc_STRVAR(extend_doc,
 "extend(iterable, /)\n\
 \n\
-Append items from to the end of the bitarray.\n\
+Append items from iterable to the end of the bitarray.\n\
 If `iterable` is a (Unicode) string, each `0` and `1` are appended as\n\
 bits (ignoring whitespace and underscore).");
 
@@ -1346,7 +1359,8 @@ bitarray_invert(bitarrayobject *self, PyObject *args)
         invert_span(self, 0, self->nbits);
     }
     else {
-        return PyErr_Format(PyExc_TypeError, "index expect, not '%s' object",
+        return PyErr_Format(PyExc_TypeError,
+                            "index expected, not '%s' object",
                             Py_TYPE(arg)->tp_name);
     }
     Py_RETURN_NONE;
@@ -1355,8 +1369,9 @@ bitarray_invert(bitarrayobject *self, PyObject *args)
 PyDoc_STRVAR(invert_doc,
 "invert(index=<all bits>, /)\n\
 \n\
-Invert all bits in bitarray (in-place).\n\
-When the optional `index` is given, only invert the single bit at `index`.");
+Invert bits in-place.  When `index` is omitted, invert all bits.\n\
+When `index` is an integer, invert the single bit at index.\n\
+When `index` is a slice, invert the selected bits.");
 
 
 static PyObject *
@@ -1557,7 +1572,7 @@ bitarray_frombytes(bitarrayobject *self, PyObject *buffer)
     assert(Py_SIZE(self) == n + view.len);
     memcpy(self->ob_item + n, (char *) view.buf, (size_t) view.len);
 
-    /* remove pad bits staring at previous bit length (8 * n - p) */
+    /* remove pad bits starting at previous bit length (8 * n - p) */
     if (delete_n(self, 8 * n - p, p) < 0)
         goto error;
 
@@ -1654,7 +1669,7 @@ PyDoc_STRVAR(fromfile_doc,
 "fromfile(f, n=-1, /)\n\
 \n\
 Extend bitarray with up to `n` bytes read from file object `f` (or any\n\
-other binary stream what supports a `.read()` method, e.g. `io.BytesIO`).\n\
+other binary stream that supports a `.read()` method, e.g. `io.BytesIO`).\n\
 Each read byte will add eight bits to the bitarray.  When `n` is omitted\n\
 or negative, reads and extends all data until EOF.\n\
 When `n` is non-negative but exceeds the available data, `EOFError` is\n\
@@ -1673,7 +1688,7 @@ bitarray_tofile(bitarrayobject *self, PyObject *f)
         Py_ssize_t size = Py_MIN(nbytes - offset, BLOCKSIZE);
 
         assert(size >= 0 && offset + size <= nbytes);
-        /* basically: f.write(memoryview(self)[offset:offset + size] */
+        /* basically: f.write(memoryview(self)[offset:offset + size]) */
         ret = PyObject_CallMethod(f, "write", "y#",
                                   self->ob_item + offset, size);
         if (ret == NULL)
@@ -1763,7 +1778,7 @@ PyDoc_STRVAR(unpack_doc,
 "unpack(zero=b'\\x00', one=b'\\x01') -> bytes\n\
 \n\
 Return bytes that contain one byte for each bit in the bitarray,\n\
-using specified mapping.");
+using the specified mapping.");
 
 
 static PyObject *
@@ -3167,7 +3182,7 @@ PyDoc_STRVAR(complete_doc,
 "complete() -> bool\n\
 \n\
 Return whether tree is complete.  That is, whether or not all\n\
-nodes have both children (unless they are symbols nodes).");
+nodes have both children (unless they are symbol nodes).");
 
 
 static PyObject *
@@ -3332,7 +3347,7 @@ decodeiter_next(decodeiterobject *it)
     PyObject *symbol;
 
     symbol = binode_traverse(it->tree, it->self, &(it->index));
-    if (symbol == NULL)  /* stop iteration OR error occured */
+    if (symbol == NULL)  /* stop iteration OR error occurred */
         return NULL;
     Py_INCREF(symbol);
     return symbol;
@@ -3723,9 +3738,9 @@ newbitarray_from_bytes(PyTypeObject *type, PyObject *buffer, int endian)
 }
 
 /* As of bitarray version 2.9.0, "bitarray(nbits)" will initialize all items
-   to 0 (previously, the buffer was be uninitialized).
+   to 0 (previously, the buffer was uninitialized).
    However, for speed, one might want to create an uninitialized bitarray.
-   In 2.9.1, we added the ability to created uninitialized bitarrays again,
+   In 2.9.1, we added the ability to create uninitialized bitarrays again,
    using "bitarray(nbits, endian, Ellipsis)".
 */
 static PyObject *
@@ -4003,7 +4018,7 @@ Optional keyword arguments:\n\
 \n\
 `endian`: Specifies the bit-endianness of the created bitarray object.\n\
 Allowed values are `big` and `little` (the default is `big`).\n\
-The bit-endianness effects the buffer representation of the bitarray.\n\
+The bit-endianness affects the buffer representation of the bitarray.\n\
 \n\
 `buffer`: Any object which exposes a buffer.  When provided, `initializer`\n\
 cannot be present (or has to be `None`).  The imported buffer may be\n\
@@ -4203,7 +4218,7 @@ sysinfo(PyObject *module, PyObject *args)
 PyDoc_STRVAR(sysinfo_doc,
 "_sysinfo(key) -> int\n\
 \n\
-Return system and compile specific information given a key.");
+Return system- and compile-specific information given a key.");
 
 
 static PyMethodDef module_functions[] = {

{bitarray-3.8.1 → bitarray-3.8.2}/bitarray/_util.c

@@ -31,7 +31,7 @@ ensure_bitarray(PyObject *obj)
 
 /* Return new bitarray of length 'nbits', endianness given by the PyObject
    'endian' (which may be Py_None).
-   Unless -1, 'c' is placed into all characters of buffer. */
+   Unless -1, 'c' is written to all bytes of the buffer. */
 static bitarrayobject *
 new_bitarray(Py_ssize_t nbits, PyObject *endian, int c)
 {
@@ -494,7 +494,7 @@ correspond_all(PyObject *module, PyObject *args)
         v = zlw(b);
         not_u = ~u;
         not_v = ~v;
-        /* for nff we need to substract the number of unused 1 bits */
+        /* for nff we need to subtract the number of unused 1 bits */
         nff += popcnt_64(not_u & not_v) - (64 - rbits);
         nft += popcnt_64(not_u & v);
         ntf += popcnt_64(u & not_v);
@@ -552,7 +552,7 @@ byteswap(PyObject *module, PyObject *args)
 
     if (n < 0)
         return PyErr_Format(PyExc_ValueError,
-                            "positive int expect, got %zd", n);
+                            "positive int expected, got %zd", n);
 
     if (PyObject_GetBuffer(buffer, &view, PyBUF_SIMPLE | PyBUF_WRITABLE) < 0)
         return NULL;
@@ -839,7 +839,7 @@ static const char base64_alphabet[] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 /* Given the length of the base m in [1..6] and a character c, return
-   its index in the base 2**m alphabet , or -1 if when c is not included.
+   its index in the base 2**m alphabet, or -1 if c is not included.
    Note: i >> m is true when i is not in range(0, 2**m) */
 static int
 digit_to_int(int m, char c)
@@ -981,7 +981,8 @@ PyDoc_STRVAR(ba2base_doc,
 \n\
 Return a string containing the base `n` ASCII representation of\n\
 the bitarray.  Allowed values for `n` are 2, 4, 8, 16, 32 and 64.\n\
-The bitarray has to be multiple of length 1, 2, 3, 4, 5 or 6 respectively.\n\
+The bitarray has to have a length divisible by 1, 2, 3, 4, 5 or 6\n\
+respectively.\n\
 For `n=32` the RFC 4648 Base32 alphabet is used, and for `n=64` the\n\
 standard base 64 alphabet is used.\n\
 When grouped, the string `sep` is inserted between groups\n\
@@ -1200,7 +1201,7 @@ byte_length(Py_ssize_t i)
      * The last element rts[NSEG(self)] is always the total count.
        Here: rts[NSEG(self)] = rts[4] = 12
 
-     * The last segment may be partial.  In that case, its size it given
+     * The last segment may be partial.  In that case, its size is given
        by nbits % 256.  Here: nbits % 256 = 987 % 256 = 219
 
    As each segment (at large) covers 256 bits (32 bytes), and each element
@@ -1284,7 +1285,7 @@ module_sc_rts(PyObject *module, PyObject *obj)
 
       a.count(1, 8 * offset, 8 * offset + (1 << (8 * n)))
 
-   The offset must be divisible by SEGSIZE, as this functions makes use of
+   The offset must be divisible by SEGSIZE, as this function makes use of
    running totals, stored in rts[].
    Here, and in the following, 'offset' is in units of bytes. */
 static Py_ssize_t
@@ -1301,7 +1302,7 @@ sc_count(bitarrayobject *a, Py_ssize_t *rts, Py_ssize_t offset, int n)
 /* Write a raw block, and return number of bytes copied.
    Note that the encoded block size is the return value + 1 (the head byte).
 
-   The header byte is in range(0x01, 0xa0).
+   The head byte is in range(0x01, 0xa0).
      * range(0x01, 0x20) number of raw bytes
      * range(0x20, 0xa0) number of 32-byte segments */
 static int
@@ -1341,7 +1342,6 @@ static void
 sc_write_indices(char *str, bitarrayobject *a, Py_ssize_t *rts,
                  Py_ssize_t offset, int n, int k)
 {
-    const char *str_stop = str + n * k;  /* stop position in buffer 'str' */
     const char *buff = a->ob_item + offset;
     Py_ssize_t m;
 
@@ -1370,12 +1370,13 @@ sc_write_indices(char *str, bitarrayobject *a, Py_ssize_t *rts,
                 if (buff[i] & BITMASK(a, j)) {
                     write_n(str, n, 8 * i + j);
                     str += n;
-                    if (--ni == 0) {
+                    if (--k == 0)
+                        /* we have encountered all indices in this block */
+                        return;
+
+                    if (--ni == 0)
                         /* we have encountered all indices in this segment */
-                        if (str == str_stop)
-                            return;
                         goto next_segment;
-                    }
                 }
             }
         }
@@ -1407,7 +1408,7 @@ sc_write_sparse(char *str, bitarrayobject *a, Py_ssize_t *rts,
         str[len++] = (char) (0xc0 + n);  /* block type */
         str[len++] = (char) k;           /* index count */
     }
-    if (k == 0)  /* no index bytes - sc_write_sparse() does not allow k = 0 */
+    if (k == 0)  /* no index bytes to write */
         return len;
 
     /* write block data - k indices, n bytes per index */
@@ -1423,7 +1424,7 @@ sc_write_sparse(char *str, bitarrayobject *a, Py_ssize_t *rts,
 
    - 32 index bytes take up as much space as a raw buffer of 32 bytes.
      Hence, if the bit count of the first 32 bytes of the bitarray buffer
-     is greater or equal to 32, we choose a raw block (type 0).
+     is greater than or equal to 32, we choose a raw block (type 0).
 
    - Arguably, n index bytes always take up as much space as n raw bytes.
      So what makes 32 special here?  A bitarray with a 32 byte buffer has
@@ -1459,7 +1460,7 @@ sc_write_sparse(char *str, bitarrayobject *a, Py_ssize_t *rts,
 
              header_size   +   (n + 1)  *  population
 
-         As n >= 1, the header_size will is always 2 bytes here.
+         As n >= 1, the header_size is always 2 bytes here.
 
    - As we only need to know which of these sizes is bigger, we can
      subtract (n * population) from both sizes.  Hence, the costs are:
@@ -1480,7 +1481,7 @@ sc_encode_block(char *str, Py_ssize_t *len,
     assert(nbytes > 0);
 
     count = (int) sc_count(a, rts, offset, 1);
-    /* the number of index bytes exceeds the number of raw bytes */
+    /* the number of index bytes is no smaller than the number of raw bytes */
     if (count >= Py_MIN(32, nbytes)) {           /* type 0 - raw bytes */
         int k = sc_write_raw(str + *len, a, rts, offset);
         *len += 1 + k;
@@ -1515,7 +1516,7 @@ sc_encode_block(char *str, Py_ssize_t *len,
     return BSI(n);
 }
 
-/* write header and return number or bytes written to buffer 'str' */
+/* write header and return number of bytes written to buffer 'str' */
 static int
 sc_encode_header(char *str, bitarrayobject *a)
 {
@@ -1565,7 +1566,7 @@ sc_encode(PyObject *module, PyObject *obj)
 
         /* Make sure we have enough memory in output buffer for next block.
            The largest block possible is a type 0 block with 128 segments.
-           Its size is: 1 head bytes + 128 * 32 raw bytes.
+           Its size is: 1 head byte + 128 * 32 raw bytes.
            Plus, we also may have the stop byte. */
         if (allocated < len + 1 + 128 * 32 + 1) {
             if (_PyBytes_Resize(&out, allocated + ALLOC_SIZE) < 0)
@@ -1597,7 +1598,7 @@ Use `sc_decode()` for decompressing (decoding).");
 
 
 /* read header from 'iter' and set 'endian' and 'nbits', return 0 on success
-   and -1 of failure (after setting exception) */
+   and -1 on failure (after setting exception) */
 static int
 sc_decode_header(PyObject *iter, int *endian, Py_ssize_t *nbits)
 {
@@ -1759,12 +1760,12 @@ untouched.  Use `sc_encode()` for compressing (encoding).");
    'padding' refers to the pad bits within the variable length format.
    This is not the same as the pad bits of the actual bitarray.
    For example, b'\x10' has padding = 1, and decodes to bitarray('000'),
-   which has 5 pad bits.  'padding' can take values to up 6.
+   which has 5 pad bits.  'padding' can take values up to 6.
  */
 #define LEN_PAD_BITS  3
 
 /* initial number of bits we allocate in vl_decode(), and amount by which
-   we increase our allocation by in vl_decode_core() if we run out */
+   we increase the allocation in vl_decode_core() */
 #define ALLOC_BITS  1024
 
 /* Consume 'iter' while extending bitarray 'a'.

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

@@ -4,7 +4,7 @@
 
    Author: Ilan Schnell
 */
-#define BITARRAY_VERSION  "3.8.1"
+#define BITARRAY_VERSION  "3.8.2"
 
 #ifdef STDC_HEADERS
 #  include <stddef.h>
@@ -64,7 +64,7 @@ typedef struct {
 /* number of pad bits */
 #define PADBITS(self)  ((8 - (self)->nbits % 8) % 8)
 
-/* number of bytes necessary to store given nunmber of bits */
+/* number of bytes necessary to store given number of bits */
 #define BYTES(bits)  (((bits) + 7) >> 3)
 
 /* we're not using bitmask_table here, as it is actually slower */
@@ -268,7 +268,7 @@ to_aligned(void *p)
     return (4 - r) % 4;
 }
 
-/* population count of n words starting from at uint64_t pointer w */
+/* 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)
 {
@@ -301,7 +301,7 @@ adjust_step_positive(Py_ssize_t slicelength,
     assert(*step != 1 || slicelength == 0 || *stop - *start == slicelength);
 }
 
-/* convert Python object to C int and set value at address -
+/* convert Python object to C int at address *vi -
    return 1 on success, 0 on failure (and set exception) */
 static inline int
 conv_pybit(PyObject *value, int *vi)

{bitarray-3.8.1 → bitarray-3.8.2}/bitarray/pythoncapi_compat.h

@@ -25,9 +25,6 @@ extern "C" {
 #if PY_VERSION_HEX < 0x030b00B4 && !defined(PYPY_VERSION)
 #  include "frameobject.h"        // PyFrameObject, PyFrame_GetBack()
 #endif
-#if PY_VERSION_HEX < 0x030C00A3
-#  include <structmember.h>       // T_SHORT, READONLY
-#endif
 
 
 #ifndef _Py_CAST
@@ -1428,6 +1425,11 @@ PyUnicodeWriter_WriteStr(PyUnicodeWriter *writer, PyObject *obj)
 static inline int
 PyUnicodeWriter_WriteRepr(PyUnicodeWriter *writer, PyObject *obj)
 {
+    if (obj == NULL) {
+        return _PyUnicodeWriter_WriteASCIIString((_PyUnicodeWriter*)writer,
+                                                 "<NULL>", 6);
+    }
+
     PyObject *str = PyObject_Repr(obj);
     if (str == NULL) {
         return -1;
@@ -1572,6 +1574,11 @@ static inline int PyLong_IsZero(PyObject *obj)
 
 // gh-124502 added PyUnicode_Equal() to Python 3.14.0a0
 #if PY_VERSION_HEX < 0x030E00A0
+
+#if PY_VERSION_HEX >= 0x030d0000 && !defined(PYPY_VERSION)
+PyAPI_FUNC(int) _PyUnicode_Equal(PyObject *str1, PyObject *str2);
+#endif
+
 static inline int PyUnicode_Equal(PyObject *str1, PyObject *str2)
 {
     if (!PyUnicode_Check(str1)) {
@@ -1586,8 +1593,6 @@ static inline int PyUnicode_Equal(PyObject *str1, PyObject *str2)
     }
 
 #if PY_VERSION_HEX >= 0x030d0000 && !defined(PYPY_VERSION)
-    PyAPI_FUNC(int) _PyUnicode_Equal(PyObject *str1, PyObject *str2);
-
     return _PyUnicode_Equal(str1, str2);
 #elif PY_VERSION_HEX >= 0x03060000 && !defined(PYPY_VERSION)
     return _PyUnicode_EQ(str1, str2);
@@ -1610,11 +1615,14 @@ static inline PyObject* PyBytes_Join(PyObject *sep, PyObject *iterable)
 
 
 #if PY_VERSION_HEX < 0x030E00A0
+
+#if PY_VERSION_HEX >= 0x03000000 && !defined(PYPY_VERSION)
+PyAPI_FUNC(Py_hash_t) _Py_HashBytes(const void *src, Py_ssize_t len);
+#endif
+
 static inline Py_hash_t Py_HashBuffer(const void *ptr, Py_ssize_t len)
 {
 #if PY_VERSION_HEX >= 0x03000000 && !defined(PYPY_VERSION)
-    PyAPI_FUNC(Py_hash_t) _Py_HashBytes(const void *src, Py_ssize_t len);
-
     return _Py_HashBytes(ptr, len);
 #else
     Py_hash_t hash;
@@ -1919,43 +1927,46 @@ PyLongWriter_Finish(PyLongWriter *writer)
 
 
 #if PY_VERSION_HEX < 0x030C00A3
-#  define Py_T_SHORT      T_SHORT
-#  define Py_T_INT        T_INT
-#  define Py_T_LONG       T_LONG
-#  define Py_T_FLOAT      T_FLOAT
-#  define Py_T_DOUBLE     T_DOUBLE
-#  define Py_T_STRING     T_STRING
-#  define _Py_T_OBJECT    T_OBJECT
-#  define Py_T_CHAR       T_CHAR
-#  define Py_T_BYTE       T_BYTE
-#  define Py_T_UBYTE      T_UBYTE
-#  define Py_T_USHORT     T_USHORT
-#  define Py_T_UINT       T_UINT
-#  define Py_T_ULONG      T_ULONG
-#  define Py_T_STRING_INPLACE  T_STRING_INPLACE
-#  define Py_T_BOOL       T_BOOL
-#  define Py_T_OBJECT_EX  T_OBJECT_EX
-#  define Py_T_LONGLONG   T_LONGLONG
-#  define Py_T_ULONGLONG  T_ULONGLONG
-#  define Py_T_PYSSIZET   T_PYSSIZET
+#  define Py_T_SHORT      0
+#  define Py_T_INT        1
+#  define Py_T_LONG       2
+#  define Py_T_FLOAT      3
+#  define Py_T_DOUBLE     4
+#  define Py_T_STRING     5
+#  define _Py_T_OBJECT    6
+#  define Py_T_CHAR       7
+#  define Py_T_BYTE       8
+#  define Py_T_UBYTE      9
+#  define Py_T_USHORT     10
+#  define Py_T_UINT       11
+#  define Py_T_ULONG      12
+#  define Py_T_STRING_INPLACE  13
+#  define Py_T_BOOL       14
+#  define Py_T_OBJECT_EX  16
+#  define Py_T_LONGLONG   17
+#  define Py_T_ULONGLONG  18
+#  define Py_T_PYSSIZET   19
 
 #  if PY_VERSION_HEX >= 0x03000000 && !defined(PYPY_VERSION)
-#    define _Py_T_NONE      T_NONE
+#    define _Py_T_NONE      20
 #  endif
 
-#  define Py_READONLY            READONLY
-#  define Py_AUDIT_READ          READ_RESTRICTED
-#  define _Py_WRITE_RESTRICTED   PY_WRITE_RESTRICTED
+#  define Py_READONLY            1
+#  define Py_AUDIT_READ          2
+#  define _Py_WRITE_RESTRICTED   4
 #endif
 
 
 // gh-127350 added Py_fopen() and Py_fclose() to Python 3.14a4
 #if PY_VERSION_HEX < 0x030E00A4
+
+#if 0x030400A2 <= PY_VERSION_HEX && !defined(PYPY_VERSION)
+PyAPI_FUNC(FILE*) _Py_fopen_obj(PyObject *path, const char *mode);
+#endif
+
 static inline FILE* Py_fopen(PyObject *path, const char *mode)
 {
 #if 0x030400A2 <= PY_VERSION_HEX && !defined(PYPY_VERSION)
-    PyAPI_FUNC(FILE*) _Py_fopen_obj(PyObject *path, const char *mode);
-
     return _Py_fopen_obj(path, mode);
 #else
     FILE *f;
@@ -1992,6 +2003,8 @@ static inline int Py_fclose(FILE *file)
 
 
 #if 0x03080000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x030E0000 && !defined(PYPY_VERSION)
+PyAPI_FUNC(const PyConfig*) _Py_GetConfig(void);
+
 static inline PyObject*
 PyConfig_Get(const char *name)
 {
@@ -2127,8 +2140,6 @@ PyConfig_Get(const char *name)
             return Py_NewRef(value);
         }
 
-        PyAPI_FUNC(const PyConfig*) _Py_GetConfig(void);
-
         const PyConfig *config = _Py_GetConfig();
         void *member = (char *)config + spec->offset;
         switch (spec->type) {
@@ -2231,6 +2242,81 @@ static inline int PyUnstable_Object_IsUniquelyReferenced(PyObject *obj)
 }
 #endif
 
+// gh-128926 added PyUnstable_TryIncRef() and PyUnstable_EnableTryIncRef() to
+// Python 3.14.0a5. Adapted from _Py_TryIncref() and _PyObject_SetMaybeWeakref().
+#if PY_VERSION_HEX < 0x030E00A5
+static inline int PyUnstable_TryIncRef(PyObject *op)
+{
+#ifndef Py_GIL_DISABLED
+    if (Py_REFCNT(op) > 0) {
+        Py_INCREF(op);
+        return 1;
+    }
+    return 0;
+#else
+    // _Py_TryIncrefFast()
+    uint32_t local = _Py_atomic_load_uint32_relaxed(&op->ob_ref_local);
+    local += 1;
+    if (local == 0) {
+        // immortal
+        return 1;
+    }
+    if (_Py_IsOwnedByCurrentThread(op)) {
+        _Py_INCREF_STAT_INC();
+        _Py_atomic_store_uint32_relaxed(&op->ob_ref_local, local);
+#ifdef Py_REF_DEBUG
+        _Py_INCREF_IncRefTotal();
+#endif
+        return 1;
+    }
+
+    // _Py_TryIncRefShared()
+    Py_ssize_t shared = _Py_atomic_load_ssize_relaxed(&op->ob_ref_shared);
+    for (;;) {
+        // If the shared refcount is zero and the object is either merged
+        // or may not have weak references, then we cannot incref it.
+        if (shared == 0 || shared == _Py_REF_MERGED) {
+            return 0;
+        }
+
+        if (_Py_atomic_compare_exchange_ssize(
+                &op->ob_ref_shared,
+                &shared,
+                shared + (1 << _Py_REF_SHARED_SHIFT))) {
+#ifdef Py_REF_DEBUG
+            _Py_INCREF_IncRefTotal();
+#endif
+            _Py_INCREF_STAT_INC();
+            return 1;
+        }
+    }
+#endif
+}
+
+static inline void PyUnstable_EnableTryIncRef(PyObject *op)
+{
+#ifdef Py_GIL_DISABLED
+    // _PyObject_SetMaybeWeakref()
+    if (_Py_IsImmortal(op)) {
+        return;
+    }
+    for (;;) {
+        Py_ssize_t shared = _Py_atomic_load_ssize_relaxed(&op->ob_ref_shared);
+        if ((shared & _Py_REF_SHARED_FLAG_MASK) != 0) {
+            // Nothing to do if it's in WEAKREFS, QUEUED, or MERGED states.
+            return;
+        }
+        if (_Py_atomic_compare_exchange_ssize(
+                &op->ob_ref_shared, &shared, shared | _Py_REF_MAYBE_WEAKREF)) {
+            return;
+        }
+    }
+#else
+    (void)op;  // unused argument
+#endif
+}
+#endif
+
 
 #if PY_VERSION_HEX < 0x030F0000
 static inline PyObject*
@@ -2587,6 +2673,40 @@ PyUnstable_Unicode_GET_CACHED_HASH(PyObject *op)
 }
 #endif
 
+#if 0x030D0000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x030F00A7 && !defined(PYPY_VERSION)
+// Immortal objects were implemented in Python 3.12, however there is no easy API
+// to make objects immortal until 3.14 which has _Py_SetImmortal(). Since
+// immortal objects are primarily needed for free-threading, this API is implemented
+// for 3.14 using _Py_SetImmortal() and uses private macros on 3.13.
+#if 0x030E0000 <= PY_VERSION_HEX
+PyAPI_FUNC(void) _Py_SetImmortal(PyObject *op);
+#endif
+
+static inline int
+PyUnstable_SetImmortal(PyObject *op)
+{
+    assert(op != NULL);
+    if (!PyUnstable_Object_IsUniquelyReferenced(op) || PyUnicode_Check(op)) {
+        return 0;
+    }
+#if 0x030E0000 <= PY_VERSION_HEX
+    _Py_SetImmortal(op);
+#else
+    // Python 3.13 doesn't export _Py_SetImmortal() function
+    if (PyObject_GC_IsTracked(op)) {
+        PyObject_GC_UnTrack(op);
+    }
+#ifdef Py_GIL_DISABLED
+    op->ob_tid = _Py_UNOWNED_TID;
+    op->ob_ref_local = _Py_IMMORTAL_REFCNT_LOCAL;
+    op->ob_ref_shared = 0;
+#else
+    op->ob_refcnt = _Py_IMMORTAL_REFCNT;
+#endif
+#endif
+    return 1;
+}
+#endif
 
 #ifdef __cplusplus
 }

{bitarray-3.8.1 → bitarray-3.8.2}/bitarray/util.py

@@ -179,13 +179,13 @@ class _Random:
             diff = a.count() - k
 
         randrange = random.randrange
-        if diff < 0:  # not enough bits 1 - increase count
+        if diff < 0:  # not enough 1 bits - increase count
             for _ in range(-diff):
                 i = randrange(n)
                 while a[i]:
                     i = randrange(n)
                 a[i] = 1
-        elif diff > 0:  # too many bits 1 - decrease count
+        elif diff > 0:  # too many 1 bits - decrease count
             for _ in range(diff):
                 i = randrange(n)
                 while not a[i]:

{bitarray-3.8.1 → bitarray-3.8.2}/bitarray.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitarray
-Version: 3.8.1
+Version: 3.8.2
 Summary: efficient arrays of booleans -- C extension
 Home-page: https://github.com/ilanschnell/bitarray
 Author: Ilan Schnell
@@ -11,7 +11,6 @@ Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: C
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
@@ -91,7 +90,7 @@ Once you have installed the package, you may want to test it:
 
     $ python -c 'import bitarray; bitarray.test()'
     bitarray is installed in: /Users/ilan/bitarray/bitarray
-    bitarray version: 3.8.1
+    bitarray version: 3.8.2
     sys.version: 3.13.5 (main, Jun 16 2025) [Clang 18.1.8]
     sys.prefix: /Users/ilan/miniforge
     pointer size: 64 bit
@@ -354,7 +353,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.8.1 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.8.2 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
 
 In the following, ``item`` and ``value`` are usually a single bit -
 an integer 0 or 1.
@@ -378,7 +377,7 @@ The bitarray object:
 
    ``endian``: Specifies the bit-endianness of the created bitarray object.
    Allowed values are ``big`` and ``little`` (the default is ``big``).
-   The bit-endianness effects the buffer representation of the bitarray.
+   The bit-endianness affects the buffer representation of the bitarray.
 
    ``buffer``: Any object which exposes a buffer.  When provided, ``initializer``
    cannot be present (or has to be ``None``).  The imported buffer may be
@@ -473,7 +472,7 @@ bitarray methods:
 
 
 ``extend(iterable, /)``
-   Append items from to the end of the bitarray.
+   Append items from iterable to the end of the bitarray.
    If ``iterable`` is a (Unicode) string, each ``0`` and ``1`` are appended as
    bits (ignoring whitespace and underscore).
 
@@ -504,7 +503,7 @@ bitarray methods:
 
 ``fromfile(f, n=-1, /)``
    Extend bitarray with up to ``n`` bytes read from file object ``f`` (or any
-   other binary stream what supports a ``.read()`` method, e.g. ``io.BytesIO``).
+   other binary stream that supports a ``.read()`` method, e.g. ``io.BytesIO``).
    Each read byte will add eight bits to the bitarray.  When ``n`` is omitted
    or negative, reads and extends all data until EOF.
    When ``n`` is non-negative but exceeds the available data, ``EOFError`` is
@@ -524,8 +523,9 @@ bitarray methods:
 
 
 ``invert(index=<all bits>, /)``
-   Invert all bits in bitarray (in-place).
-   When the optional ``index`` is given, only invert the single bit at ``index``.
+   Invert bits in-place.  When ``index`` is omitted, invert all bits.
+   When ``index`` is an integer, invert the single bit at index.
+   When ``index`` is a slice, invert the selected bits.
 
    New in version 1.5.3: optional index argument
 
@@ -608,7 +608,7 @@ bitarray methods:
 
 ``unpack(zero=b'\x00', one=b'\x01')`` -> bytes
    Return bytes that contain one byte for each bit in the bitarray,
-   using specified mapping.
+   using the specified mapping.
 
 
 bitarray data descriptors:
@@ -683,7 +683,8 @@ This sub-module was added in version 1.2.
 ``ba2base(n, bitarray, /, group=0, sep=' ')`` -> str
    Return a string containing the base ``n`` ASCII representation of
    the bitarray.  Allowed values for ``n`` are 2, 4, 8, 16, 32 and 64.
-   The bitarray has to be multiple of length 1, 2, 3, 4, 5 or 6 respectively.
+   The bitarray has to have a length divisible by 1, 2, 3, 4, 5 or 6
+   respectively.
    For ``n=32`` the RFC 4648 Base32 alphabet is used, and for ``n=64`` the
    standard base 64 alphabet is used.
    When grouped, the string ``sep`` is inserted between groups

{bitarray-3.8.1 → bitarray-3.8.2}/setup.py

@@ -3,10 +3,10 @@ import sys
 import platform
 
 
-if sys.version_info[:3] < (3, 6, 1):
+if sys.version_info[:3] < (3, 7):
     sys.exit("""\
 ****************************************************************************
-*   bitarray requires Python 3.6.1 or later.
+*   bitarray requires Python 3.7 or later.
 *   The last bitarray version supporting Python 2.7 is bitarray 2.9.3.
 ****************************************************************************
 """)
@@ -47,7 +47,6 @@ setup(
         "Operating System :: OS Independent",
         "Programming Language :: C",
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.6",
         "Programming Language :: Python :: 3.7",
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",