bitarray 3.8.0__tar.gz → 3.8.2__tar.gz

{bitarray-3.8.0 → bitarray-3.8.2}/LICENSE

@@ -11,7 +11,7 @@ license to reproduce, analyze, test, perform and/or display publicly,
 prepare derivative works, distribute, and otherwise use bitarray
 alone or in any derivative version, provided, however, that Ilan Schnell's
 License Agreement and Ilan Schnell's notice of copyright, i.e., "Copyright (c)
-2008 - 2025 Ilan Schnell; All Rights Reserved" are retained in bitarray
+2008 - 2026 Ilan Schnell; All Rights Reserved" are retained in bitarray
 alone or in any derivative version prepared by Licensee.
 
 3. In the event Licensee prepares a derivative work that is based on

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitarray
-Version: 3.8.0
+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.0
+    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
@@ -107,7 +106,7 @@ Once you have installed the package, you may want to test it:
     .........................................................................
     ................................................................
     ----------------------------------------------------------------------
-    Ran 595 tests in 0.165s
+    Ran 598 tests in 0.165s
 
     OK
 
@@ -354,7 +353,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.8.0 -- `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.0 → 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.0
+    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
@@ -73,7 +73,7 @@ Once you have installed the package, you may want to test it:
     .........................................................................
     ................................................................
     ----------------------------------------------------------------------
-    Ran 595 tests in 0.165s
+    Ran 598 tests in 0.165s
 
     OK
 
@@ -320,7 +320,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.8.0 -- `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.0 → bitarray-3.8.2}/bitarray/__init__.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2008 - 2025, Ilan Schnell; All Rights Reserved
+# Copyright (c) 2008 - 2026, Ilan Schnell; All Rights Reserved
 """
 This package defines an object type which can efficiently represent
 a bitarray.  Bitarrays are sequence types and behave very much like lists.

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

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 - 2025, Ilan Schnell; All Rights Reserved
+# Copyright (c) 2021 - 2026, Ilan Schnell; All Rights Reserved
 #
 # This stub, as well as util.pyi, are tested with Python 3.10 and mypy 1.11.2
 

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

@@ -1,5 +1,5 @@
 /*
-   Copyright (c) 2008 - 2025, Ilan Schnell; All Rights Reserved
+   Copyright (c) 2008 - 2026, Ilan Schnell; All Rights Reserved
    bitarray is published under the PSF license.
 
    This file is the C part of the bitarray package.
@@ -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,33 +97,21 @@ 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);
     self->ob_item = PyMem_Realloc(self->ob_item, new_allocated);
     if (self->ob_item == NULL) {
+        Py_SET_SIZE(self, 0);
+        self->allocated = 0;
+        self->nbits = 0;
         PyErr_NoMemory();
         return -1;
     }
@@ -200,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
@@ -1028,7 +1044,7 @@ bitarray_buffer_info(bitarrayobject *self)
     readonly = PyBool_FromLong(self->readonly);
     imported = PyBool_FromLong(self->buffer ? 1 : 0);
     if (address == NULL || readonly == NULL || imported == NULL)
-        return NULL;
+        goto error;
 
     args = Py_BuildValue("OnsnnOOi",
                          address,
@@ -1039,12 +1055,21 @@ bitarray_buffer_info(bitarrayobject *self)
                          readonly,
                          imported,
                          self->ob_exports);
+    if (args == NULL)
+        goto error;
+
     Py_DECREF(address);
     Py_DECREF(readonly);
     Py_DECREF(imported);
     res = PyObject_CallObject(info, args);
     Py_DECREF(args);
     return res;
+
+ error:
+    Py_XDECREF(address);
+    Py_XDECREF(readonly);
+    Py_XDECREF(imported);
+    return NULL;
 }
 
 PyDoc_STRVAR(buffer_info_doc,
@@ -1182,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).");
 
@@ -1334,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;
@@ -1343,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 *
@@ -1545,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;
 
@@ -1600,7 +1627,7 @@ extend_fread(bitarrayobject *self, PyObject *f, Py_ssize_t n)
     ret = bitarray_frombytes(self, bytes);
     Py_DECREF(bytes);
     if (ret == NULL)
-        res = -1;
+        return -1;
     Py_DECREF(ret);
     return res;
 }
@@ -1642,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\
@@ -1661,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)
@@ -1751,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 *
@@ -2844,8 +2871,9 @@ bitarray_encode(bitarrayobject *self, PyObject *args)
 
     /* extend self with the bitarrays from codedict */
     while ((symbol = PyIter_Next(iter))) {
-        value = PyDict_GetItem(codedict, symbol);
-        Py_DECREF(symbol);
+        if (PyDict_GetItemRef(codedict, symbol, &value) < 0)
+            goto error;
+
         if (value == NULL) {
             PyErr_Format(PyExc_ValueError,
                          "symbol not defined in prefix code: %A", symbol);
@@ -2854,6 +2882,9 @@ bitarray_encode(bitarrayobject *self, PyObject *args)
         if (check_value(value) < 0 ||
                 extend_bitarray(self, (bitarrayobject *) value) < 0)
             goto error;
+
+        Py_DECREF(symbol);
+        Py_DECREF(value);
     }
     Py_DECREF(iter);
     if (PyErr_Occurred())       /* from PyIter_Next() */
@@ -2862,6 +2893,8 @@ bitarray_encode(bitarrayobject *self, PyObject *args)
 
  error:
     Py_DECREF(iter);
+    Py_DECREF(symbol);
+    Py_XDECREF(value);
     return NULL;
 }
 
@@ -3023,8 +3056,10 @@ binode_to_dict(binode *nd, PyObject *dict, bitarrayobject *prefix)
 
         if ((t = bitarray_cp(prefix)) == NULL)
             return -1;
-        if (resize(t, t->nbits + 1) < 0)
+        if (resize(t, t->nbits + 1) < 0) {
+            Py_DECREF(t);
             return -1;
+        }
         setbit(t, t->nbits - 1, k);
         ret = binode_to_dict(nd->child[k], dict, t);
         Py_DECREF(t);
@@ -3147,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 *
@@ -3312,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;
@@ -3321,12 +3356,12 @@ decodeiter_next(decodeiterobject *it)
 static void
 decodeiter_dealloc(decodeiterobject *it)
 {
+    PyObject_GC_UnTrack(it);
     if (it->decodetree)
         Py_DECREF(it->decodetree);
     else       /* when decodeiter was created from dict - free tree */
         binode_delete(it->tree);
 
-    PyObject_GC_UnTrack(it);
     Py_DECREF(it->self);
     PyObject_GC_Del(it);
 }
@@ -3466,6 +3501,7 @@ static int
 searchiter_traverse(searchiterobject *it, visitproc visit, void *arg)
 {
     Py_VISIT(it->self);
+    Py_VISIT(it->sub);
     return 0;
 }
 
@@ -3702,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 *
@@ -3982,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\
@@ -4044,7 +4080,8 @@ bits2bytes(PyObject *module, PyObject *n)
         return PyErr_Format(PyExc_TypeError, "'int' object expected, "
                             "got '%s'", Py_TYPE(n)->tp_name);
 
-    zero = PyLong_FromLong(0);
+    if ((zero = PyLong_FromLong(0)) == NULL)
+        return NULL;
     cmp_res = PyObject_RichCompareBool(n, zero, Py_LT);
     Py_DECREF(zero);
     if (cmp_res < 0)
@@ -4054,13 +4091,17 @@ bits2bytes(PyObject *module, PyObject *n)
         return NULL;
     }
 
-    seven = PyLong_FromLong(7);
+    if ((seven = PyLong_FromLong(7)) == NULL)
+        return NULL;
     a = PyNumber_Add(n, seven);          /* a = n + 7 */
     Py_DECREF(seven);
     if (a == NULL)
         return NULL;
 
-    eight = PyLong_FromLong(8);
+    if ((eight = PyLong_FromLong(8)) == NULL) {
+        Py_DECREF(a);
+        return NULL;
+    }
     b = PyNumber_FloorDivide(a, eight);  /* b = a // 8 */
     Py_DECREF(eight);
     Py_DECREF(a);
@@ -4177,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[] = {