bitarray 3.7.2__tar.gz → 3.8.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitarray
-Version: 3.7.2
+Version: 3.8.0
 Summary: efficient arrays of booleans -- C extension
 Home-page: https://github.com/ilanschnell/bitarray
 Author: Ilan Schnell
@@ -20,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Free Threading :: 1 - Unstable
 Classifier: Topic :: Utilities
 License-File: LICENSE
 Dynamic: author
@@ -90,7 +91,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.7.2
+    bitarray version: 3.8.0
     sys.version: 3.13.5 (main, Jun 16 2025) [Clang 18.1.8]
     sys.prefix: /Users/ilan/miniforge
     pointer size: 64 bit
@@ -99,13 +100,14 @@ Once you have installed the package, you may want to test it:
     HAVE_BUILTIN_BSWAP64: 1
     default bit-endianness: big
     machine byte-order: little
+    Py_GIL_DISABLED: 0
     Py_DEBUG: 0
     DEBUG: 0
     .........................................................................
     .........................................................................
     ................................................................
     ----------------------------------------------------------------------
-    Ran 597 tests in 0.165s
+    Ran 595 tests in 0.165s
 
     OK
 
@@ -352,7 +354,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.7.2 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.8.0 -- `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.
@@ -588,6 +590,7 @@ bitarray methods:
 
 ``tobytes()`` -> bytes
    Return the bitarray buffer (pad bits are set to zero).
+   ``a.tobytes()`` is equivalent to ``bytes(a)``
 
 
 ``tofile(f, /)``
@@ -658,8 +661,6 @@ Functions defined in the `bitarray` module:
 
 ``get_default_endian()`` -> str
    Return the default bit-endianness for new bitarray objects being created.
-   Unless ``_set_default_endian('little')`` was called, the default
-   bit-endianness is ``big``.
 
    New in version 1.3
 

{bitarray-3.7.2 → bitarray-3.8.0}/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.7.2
+    bitarray version: 3.8.0
     sys.version: 3.13.5 (main, Jun 16 2025) [Clang 18.1.8]
     sys.prefix: /Users/ilan/miniforge
     pointer size: 64 bit
@@ -66,13 +66,14 @@ Once you have installed the package, you may want to test it:
     HAVE_BUILTIN_BSWAP64: 1
     default bit-endianness: big
     machine byte-order: little
+    Py_GIL_DISABLED: 0
     Py_DEBUG: 0
     DEBUG: 0
     .........................................................................
     .........................................................................
     ................................................................
     ----------------------------------------------------------------------
-    Ran 597 tests in 0.165s
+    Ran 595 tests in 0.165s
 
     OK
 
@@ -319,7 +320,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.7.2 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.8.0 -- `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.
@@ -555,6 +556,7 @@ bitarray methods:
 
 ``tobytes()`` -> bytes
    Return the bitarray buffer (pad bits are set to zero).
+   ``a.tobytes()`` is equivalent to ``bytes(a)``
 
 
 ``tofile(f, /)``
@@ -625,8 +627,6 @@ Functions defined in the `bitarray` module:
 
 ``get_default_endian()`` -> str
    Return the default bit-endianness for new bitarray objects being created.
-   Unless ``_set_default_endian('little')`` was called, the default
-   bit-endianness is ``big``.
 
    New in version 1.3
 

{bitarray-3.7.2 → bitarray-3.8.0}/bitarray/__init__.py

@@ -13,8 +13,7 @@ from collections import namedtuple
 
 from bitarray._bitarray import (
     bitarray, decodetree, bits2bytes, _bitarray_reconstructor,
-    get_default_endian, _set_default_endian, _sysinfo,
-    BITARRAY_VERSION as __version__
+    get_default_endian, _sysinfo, BITARRAY_VERSION as __version__
 )
 
 __all__ = ['bitarray', 'frozenbitarray', 'decodetree', 'bits2bytes']

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

@@ -162,7 +162,6 @@ __version__: str
 def bits2bytes(n: int) -> int: ...
 def get_default_endian() -> str: ...
 def test(verbosity: int = ...) -> TextTestResult: ...
-def _set_default_endian(endian: str) -> None: ...
 def _sysinfo(key: str) -> int: ...
 def _bitarray_reconstructor(cls: type,
                             buffer: bytes,

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

@@ -16,9 +16,6 @@
 /* size used when reading / writing blocks from files (in bytes) */
 #define BLOCKSIZE  65536
 
-/* default bit-endianness */
-static int default_endian = ENDIAN_BIG;
-
 /* translation table - setup during module initialization */
 static char reverse_trans[256];
 
@@ -1576,7 +1573,8 @@ bitarray_tobytes(bitarrayobject *self)
 PyDoc_STRVAR(tobytes_doc,
 "tobytes() -> bytes\n\
 \n\
-Return the bitarray buffer (pad bits are set to zero).");
+Return the bitarray buffer (pad bits are set to zero).\n\
+`a.tobytes()` is equivalent to `bytes(a)`");
 
 
 /* Extend self with bytes from f.read(n).  Return number of bytes actually
@@ -3116,7 +3114,7 @@ decodetree_todict(decodetreeobject *self)
     if ((dict = PyDict_New()) == NULL)
         return NULL;
 
-    prefix = newbitarrayobject(&Bitarray_Type, 0, default_endian);
+    prefix = newbitarrayobject(&Bitarray_Type, 0, ENDIAN_DEFAULT);
     if (prefix == NULL)
         goto error;
 
@@ -3565,6 +3563,8 @@ static PyMethodDef bitarray_methods[] = {
      to01_doc},
     {"tobytes",      (PyCFunction) bitarray_tobytes,     METH_NOARGS,
      tobytes_doc},
+    {"__bytes__",    (PyCFunction) bitarray_tobytes,     METH_NOARGS,
+     tobytes_doc},
     {"tofile",       (PyCFunction) bitarray_tofile,      METH_O,
      tofile_doc},
     {"tolist",       (PyCFunction) bitarray_tolist,      METH_NOARGS,
@@ -3600,10 +3600,8 @@ static PyMethodDef bitarray_methods[] = {
 static int
 endian_from_string(const char *str)
 {
-    assert(default_endian == ENDIAN_LITTLE || default_endian == ENDIAN_BIG);
-
     if (str == NULL)
-        return default_endian;
+        return ENDIAN_DEFAULT;
 
     if (strcmp(str, "little") == 0)
         return ENDIAN_LITTLE;
@@ -4126,39 +4124,13 @@ reconstructor(PyObject *module, PyObject *args)
 static PyObject *
 get_default_endian(PyObject *module)
 {
-    return PyUnicode_FromString(ENDIAN_STR(default_endian));
+    return PyUnicode_FromString(ENDIAN_STR(ENDIAN_DEFAULT));
 }
 
 PyDoc_STRVAR(get_default_endian_doc,
 "get_default_endian() -> str\n\
 \n\
-Return the default bit-endianness for new bitarray objects being created.\n\
-Unless `_set_default_endian('little')` was called, the default\n\
-bit-endianness is `big`.");
-
-
-static PyObject *
-set_default_endian(PyObject *module, PyObject *args)
-{
-    char *endian_str;
-    int t;
-
-    if (!PyArg_ParseTuple(args, "s:_set_default_endian", &endian_str))
-        return NULL;
-
-    /* As endian_from_string() might return -1, we have to store its value
-       in a temporary variable before setting default_endian. */
-    if ((t = endian_from_string(endian_str)) < 0)
-        return NULL;
-    default_endian = t;
-
-    Py_RETURN_NONE;
-}
-
-PyDoc_STRVAR(set_default_endian_doc,
-"_set_default_endian(endian, /)\n\
-\n\
-Set the default bit-endianness for new bitarray objects being created.");
+Return the default bit-endianness for new bitarray objects being created.");
 
 
 static PyObject *
@@ -4181,6 +4153,11 @@ sysinfo(PyObject *module, PyObject *args)
     R("PY_LITTLE_ENDIAN", PY_LITTLE_ENDIAN);
     R("PY_BIG_ENDIAN", PY_BIG_ENDIAN);
     R("HAVE_BUILTIN_BSWAP64", HAVE_BUILTIN_BSWAP64);
+#ifdef Py_GIL_DISABLED   /* Python configured using --disable-gil */
+    R("Py_GIL_DISABLED", 1);
+#else
+    R("Py_GIL_DISABLED", 0);
+#endif
 #ifdef Py_DEBUG          /* Python configured using --with-pydebug  */
     R("Py_DEBUG", 1);
 #else
@@ -4211,8 +4188,6 @@ static PyMethodDef module_functions[] = {
      reduce_doc},
     {"get_default_endian",  (PyCFunction) get_default_endian, METH_NOARGS,
      get_default_endian_doc},
-    {"_set_default_endian", (PyCFunction) set_default_endian, METH_VARARGS,
-     set_default_endian_doc},
     {"_sysinfo",            (PyCFunction) sysinfo,            METH_VARARGS,
      sysinfo_doc},
     {NULL,                  NULL}  /* sentinel */
@@ -4260,6 +4235,10 @@ PyInit__bitarray(void)
     if ((m = PyModule_Create(&moduledef)) == NULL)
         return NULL;
 
+#ifdef Py_GIL_DISABLED
+    PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
+#endif
+
     if (PyType_Ready(&Bitarray_Type) < 0)
         return NULL;
     Py_SET_TYPE(&Bitarray_Type, &PyType_Type);

{bitarray-3.7.2 → bitarray-3.8.0}/bitarray/_util.c

@@ -2249,6 +2249,10 @@ PyInit__util(void)
     if ((m = PyModule_Create(&moduledef)) == NULL)
         return NULL;
 
+#ifdef Py_GIL_DISABLED
+    PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
+#endif
+
     if (PyType_Ready(&CHDI_Type) < 0)
         return NULL;
     Py_SET_TYPE(&CHDI_Type, &PyType_Type);

{bitarray-3.7.2 → bitarray-3.8.0}/bitarray/bitarray.h

@@ -4,7 +4,7 @@
 
    Author: Ilan Schnell
 */
-#define BITARRAY_VERSION  "3.7.2"
+#define BITARRAY_VERSION  "3.8.0"
 
 #ifdef STDC_HEADERS
 #  include <stddef.h>
@@ -52,6 +52,8 @@ typedef struct {
 /* --- bit-endianness --- */
 #define ENDIAN_LITTLE  0
 #define ENDIAN_BIG     1
+/* default bit-endianness */
+#define ENDIAN_DEFAULT  ENDIAN_BIG
 
 #define IS_LE(self)  ((self)->endian == ENDIAN_LITTLE)
 #define IS_BE(self)  ((self)->endian == ENDIAN_BIG)

{bitarray-3.7.2 → bitarray-3.8.0}/bitarray/pythoncapi_compat.h

@@ -1456,6 +1456,18 @@ PyUnicodeWriter_WriteUTF8(PyUnicodeWriter *writer,
     return res;
 }
 
+static inline int
+PyUnicodeWriter_WriteASCII(PyUnicodeWriter *writer,
+                           const char *str, Py_ssize_t size)
+{
+    if (size < 0) {
+        size = (Py_ssize_t)strlen(str);
+    }
+
+    return _PyUnicodeWriter_WriteASCIIString((_PyUnicodeWriter*)writer,
+                                             str, size);
+}
+
 static inline int
 PyUnicodeWriter_WriteWideChar(PyUnicodeWriter *writer,
                               const wchar_t *str, Py_ssize_t size)
@@ -1479,7 +1491,8 @@ PyUnicodeWriter_WriteSubstring(PyUnicodeWriter *writer, PyObject *str,
                                Py_ssize_t start, Py_ssize_t end)
 {
     if (!PyUnicode_Check(str)) {
-        PyErr_Format(PyExc_TypeError, "expect str, not %T", str);
+        PyErr_Format(PyExc_TypeError, "expect str, not %s",
+                     Py_TYPE(str)->tp_name);
         return -1;
     }
     if (start < 0 || start > end) {
@@ -1978,7 +1991,7 @@ static inline int Py_fclose(FILE *file)
 #endif
 
 
-#if 0x03090000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x030E0000 && !defined(PYPY_VERSION)
+#if 0x03080000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x030E0000 && !defined(PYPY_VERSION)
 static inline PyObject*
 PyConfig_Get(const char *name)
 {
@@ -2019,7 +2032,9 @@ PyConfig_Get(const char *name)
         PYTHONCAPI_COMPAT_SPEC(module_search_paths, WSTR_LIST, "path"),
         PYTHONCAPI_COMPAT_SPEC(optimization_level, UINT, _Py_NULL),
         PYTHONCAPI_COMPAT_SPEC(parser_debug, BOOL, _Py_NULL),
+#if 0x03090000 <= PY_VERSION_HEX
         PYTHONCAPI_COMPAT_SPEC(platlibdir, WSTR, "platlibdir"),
+#endif
         PYTHONCAPI_COMPAT_SPEC(prefix, WSTR_OPT, "prefix"),
         PYTHONCAPI_COMPAT_SPEC(pycache_prefix, WSTR_OPT, "pycache_prefix"),
         PYTHONCAPI_COMPAT_SPEC(quiet, BOOL, _Py_NULL),
@@ -2198,6 +2213,380 @@ PyConfig_GetInt(const char *name, int *value)
 }
 #endif  // PY_VERSION_HEX > 0x03090000 && !defined(PYPY_VERSION)
 
+// gh-133144 added PyUnstable_Object_IsUniquelyReferenced() to Python 3.14.0b1.
+// Adapted from  _PyObject_IsUniquelyReferenced() implementation.
+#if PY_VERSION_HEX < 0x030E00B0
+static inline int PyUnstable_Object_IsUniquelyReferenced(PyObject *obj)
+{
+#if !defined(Py_GIL_DISABLED)
+    return Py_REFCNT(obj) == 1;
+#else
+    // NOTE: the entire ob_ref_shared field must be zero, including flags, to
+    // ensure that other threads cannot concurrently create new references to
+    // this object.
+    return (_Py_IsOwnedByCurrentThread(obj) &&
+            _Py_atomic_load_uint32_relaxed(&obj->ob_ref_local) == 1 &&
+            _Py_atomic_load_ssize_relaxed(&obj->ob_ref_shared) == 0);
+#endif
+}
+#endif
+
+
+#if PY_VERSION_HEX < 0x030F0000
+static inline PyObject*
+PySys_GetAttrString(const char *name)
+{
+#if PY_VERSION_HEX >= 0x03000000
+    PyObject *value = Py_XNewRef(PySys_GetObject(name));
+#else
+    PyObject *value = Py_XNewRef(PySys_GetObject((char*)name));
+#endif
+    if (value != NULL) {
+        return value;
+    }
+    if (!PyErr_Occurred()) {
+        PyErr_Format(PyExc_RuntimeError, "lost sys.%s", name);
+    }
+    return NULL;
+}
+
+static inline PyObject*
+PySys_GetAttr(PyObject *name)
+{
+#if PY_VERSION_HEX >= 0x03000000
+    const char *name_str = PyUnicode_AsUTF8(name);
+#else
+    const char *name_str = PyString_AsString(name);
+#endif
+    if (name_str == NULL) {
+        return NULL;
+    }
+
+    return PySys_GetAttrString(name_str);
+}
+
+static inline int
+PySys_GetOptionalAttrString(const char *name, PyObject **value)
+{
+#if PY_VERSION_HEX >= 0x03000000
+    *value = Py_XNewRef(PySys_GetObject(name));
+#else
+    *value = Py_XNewRef(PySys_GetObject((char*)name));
+#endif
+    if (*value != NULL) {
+        return 1;
+    }
+    return 0;
+}
+
+static inline int
+PySys_GetOptionalAttr(PyObject *name, PyObject **value)
+{
+#if PY_VERSION_HEX >= 0x03000000
+    const char *name_str = PyUnicode_AsUTF8(name);
+#else
+    const char *name_str = PyString_AsString(name);
+#endif
+    if (name_str == NULL) {
+        *value = NULL;
+        return -1;
+    }
+
+    return PySys_GetOptionalAttrString(name_str, value);
+}
+#endif  // PY_VERSION_HEX < 0x030F00A1
+
+
+#if PY_VERSION_HEX < 0x030F00A1
+typedef struct PyBytesWriter {
+    char small_buffer[256];
+    PyObject *obj;
+    Py_ssize_t size;
+} PyBytesWriter;
+
+static inline Py_ssize_t
+_PyBytesWriter_GetAllocated(PyBytesWriter *writer)
+{
+    if (writer->obj == NULL) {
+        return sizeof(writer->small_buffer);
+    }
+    else {
+        return PyBytes_GET_SIZE(writer->obj);
+    }
+}
+
+
+static inline int
+_PyBytesWriter_Resize_impl(PyBytesWriter *writer, Py_ssize_t size,
+                           int resize)
+{
+    int overallocate = resize;
+    assert(size >= 0);
+
+    if (size <= _PyBytesWriter_GetAllocated(writer)) {
+        return 0;
+    }
+
+    if (overallocate) {
+#ifdef MS_WINDOWS
+        /* On Windows, overallocate by 50% is the best factor */
+        if (size <= (PY_SSIZE_T_MAX - size / 2)) {
+            size += size / 2;
+        }
+#else
+        /* On Linux, overallocate by 25% is the best factor */
+        if (size <= (PY_SSIZE_T_MAX - size / 4)) {
+            size += size / 4;
+        }
+#endif
+    }
+
+    if (writer->obj != NULL) {
+        if (_PyBytes_Resize(&writer->obj, size)) {
+            return -1;
+        }
+        assert(writer->obj != NULL);
+    }
+    else {
+        writer->obj = PyBytes_FromStringAndSize(NULL, size);
+        if (writer->obj == NULL) {
+            return -1;
+        }
+
+        if (resize) {
+            assert((size_t)size > sizeof(writer->small_buffer));
+            memcpy(PyBytes_AS_STRING(writer->obj),
+                   writer->small_buffer,
+                   sizeof(writer->small_buffer));
+        }
+    }
+    return 0;
+}
+
+static inline void*
+PyBytesWriter_GetData(PyBytesWriter *writer)
+{
+    if (writer->obj == NULL) {
+        return writer->small_buffer;
+    }
+    else {
+        return PyBytes_AS_STRING(writer->obj);
+    }
+}
+
+static inline Py_ssize_t
+PyBytesWriter_GetSize(PyBytesWriter *writer)
+{
+    return writer->size;
+}
+
+static inline void
+PyBytesWriter_Discard(PyBytesWriter *writer)
+{
+    if (writer == NULL) {
+        return;
+    }
+
+    Py_XDECREF(writer->obj);
+    PyMem_Free(writer);
+}
+
+static inline PyBytesWriter*
+PyBytesWriter_Create(Py_ssize_t size)
+{
+    if (size < 0) {
+        PyErr_SetString(PyExc_ValueError, "size must be >= 0");
+        return NULL;
+    }
+
+    PyBytesWriter *writer = (PyBytesWriter*)PyMem_Malloc(sizeof(PyBytesWriter));
+    if (writer == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+
+    writer->obj = NULL;
+    writer->size = 0;
+
+    if (size >= 1) {
+        if (_PyBytesWriter_Resize_impl(writer, size, 0) < 0) {
+            PyBytesWriter_Discard(writer);
+            return NULL;
+        }
+        writer->size = size;
+    }
+    return writer;
+}
+
+static inline PyObject*
+PyBytesWriter_FinishWithSize(PyBytesWriter *writer, Py_ssize_t size)
+{
+    PyObject *result;
+    if (size == 0) {
+        result = PyBytes_FromStringAndSize("", 0);
+    }
+    else if (writer->obj != NULL) {
+        if (size != PyBytes_GET_SIZE(writer->obj)) {
+            if (_PyBytes_Resize(&writer->obj, size)) {
+                goto error;
+            }
+        }
+        result = writer->obj;
+        writer->obj = NULL;
+    }
+    else {
+        result = PyBytes_FromStringAndSize(writer->small_buffer, size);
+    }
+    PyBytesWriter_Discard(writer);
+    return result;
+
+error:
+    PyBytesWriter_Discard(writer);
+    return NULL;
+}
+
+static inline PyObject*
+PyBytesWriter_Finish(PyBytesWriter *writer)
+{
+    return PyBytesWriter_FinishWithSize(writer, writer->size);
+}
+
+static inline PyObject*
+PyBytesWriter_FinishWithPointer(PyBytesWriter *writer, void *buf)
+{
+    Py_ssize_t size = (char*)buf - (char*)PyBytesWriter_GetData(writer);
+    if (size < 0 || size > _PyBytesWriter_GetAllocated(writer)) {
+        PyBytesWriter_Discard(writer);
+        PyErr_SetString(PyExc_ValueError, "invalid end pointer");
+        return NULL;
+    }
+
+    return PyBytesWriter_FinishWithSize(writer, size);
+}
+
+static inline int
+PyBytesWriter_Resize(PyBytesWriter *writer, Py_ssize_t size)
+{
+    if (size < 0) {
+        PyErr_SetString(PyExc_ValueError, "size must be >= 0");
+        return -1;
+    }
+    if (_PyBytesWriter_Resize_impl(writer, size, 1) < 0) {
+        return -1;
+    }
+    writer->size = size;
+    return 0;
+}
+
+static inline int
+PyBytesWriter_Grow(PyBytesWriter *writer, Py_ssize_t size)
+{
+    if (size < 0 && writer->size + size < 0) {
+        PyErr_SetString(PyExc_ValueError, "invalid size");
+        return -1;
+    }
+    if (size > PY_SSIZE_T_MAX - writer->size) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    size = writer->size + size;
+
+    if (_PyBytesWriter_Resize_impl(writer, size, 1) < 0) {
+        return -1;
+    }
+    writer->size = size;
+    return 0;
+}
+
+static inline void*
+PyBytesWriter_GrowAndUpdatePointer(PyBytesWriter *writer,
+                                   Py_ssize_t size, void *buf)
+{
+    Py_ssize_t pos = (char*)buf - (char*)PyBytesWriter_GetData(writer);
+    if (PyBytesWriter_Grow(writer, size) < 0) {
+        return NULL;
+    }
+    return (char*)PyBytesWriter_GetData(writer) + pos;
+}
+
+static inline int
+PyBytesWriter_WriteBytes(PyBytesWriter *writer,
+                         const void *bytes, Py_ssize_t size)
+{
+    if (size < 0) {
+        size_t len = strlen((const char*)bytes);
+        if (len > (size_t)PY_SSIZE_T_MAX) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        size = (Py_ssize_t)len;
+    }
+
+    Py_ssize_t pos = writer->size;
+    if (PyBytesWriter_Grow(writer, size) < 0) {
+        return -1;
+    }
+    char *buf = (char*)PyBytesWriter_GetData(writer);
+    memcpy(buf + pos, bytes, (size_t)size);
+    return 0;
+}
+
+static inline int
+PyBytesWriter_Format(PyBytesWriter *writer, const char *format, ...)
+                     Py_GCC_ATTRIBUTE((format(printf, 2, 3)));
+
+static inline int
+PyBytesWriter_Format(PyBytesWriter *writer, const char *format, ...)
+{
+    va_list vargs;
+    va_start(vargs, format);
+    PyObject *str = PyBytes_FromFormatV(format, vargs);
+    va_end(vargs);
+
+    if (str == NULL) {
+        return -1;
+    }
+    int res = PyBytesWriter_WriteBytes(writer,
+                                       PyBytes_AS_STRING(str),
+                                       PyBytes_GET_SIZE(str));
+    Py_DECREF(str);
+    return res;
+}
+#endif  // PY_VERSION_HEX < 0x030F00A1
+
+
+#if PY_VERSION_HEX < 0x030F00A1
+static inline PyObject*
+PyTuple_FromArray(PyObject *const *array, Py_ssize_t size)
+{
+    PyObject *tuple = PyTuple_New(size);
+    if (tuple == NULL) {
+        return NULL;
+    }
+    for (Py_ssize_t i=0; i < size; i++) {
+        PyObject *item = array[i];
+        PyTuple_SET_ITEM(tuple, i, Py_NewRef(item));
+    }
+    return tuple;
+}
+#endif
+
+
+#if PY_VERSION_HEX < 0x030F00A1
+static inline Py_hash_t
+PyUnstable_Unicode_GET_CACHED_HASH(PyObject *op)
+{
+#ifdef PYPY_VERSION
+    (void)op;  // unused argument
+    return -1;
+#elif PY_VERSION_HEX >= 0x03000000
+    return ((PyASCIIObject*)op)->hash;
+#else
+    return ((PyUnicodeObject*)op)->hash;
+#endif
+}
+#endif
+
 
 #ifdef __cplusplus
 }

{bitarray-3.7.2 → bitarray-3.8.0}/bitarray/test_bitarray.py

@@ -33,7 +33,7 @@ is_pypy = bool(platform.python_implementation() == 'PyPy')
 
 
 from bitarray import (bitarray, frozenbitarray, bits2bytes, decodetree,
-                      get_default_endian, _set_default_endian,
+                      get_default_endian,
                       _bitarray_reconstructor, _sysinfo as sysinfo,
                       BufferInfo, __version__)
 
@@ -152,11 +152,20 @@ class ModuleFunctionsTests(unittest.TestCase):
 
     def test_sysinfo(self):
         for key in ["void*", "size_t", "bitarrayobject", "decodetreeobject",
-                    "binode", "HAVE_BUILTIN_BSWAP64", "PY_LITTLE_ENDIAN",
-                    "PY_BIG_ENDIAN", "Py_DEBUG", "DEBUG"]:
+                    "binode", "HAVE_BUILTIN_BSWAP64",
+                    "PY_LITTLE_ENDIAN", "PY_BIG_ENDIAN",
+                    "Py_GIL_DISABLED", "Py_DEBUG", "DEBUG"]:
             res = sysinfo(key)
             self.assertEqual(type(res), int)
 
+    @skipIf(sys.version_info[:2] < (3, 14))
+    def test_gil_disabled(self):
+        self.assertEqual(sysinfo("Py_GIL_DISABLED"),
+                         "free-threading" in sys.version)
+        # see if GIL is actually disabled in free-threading build
+        if sysinfo("Py_GIL_DISABLED"):
+            self.assertFalse(sys._is_gil_enabled())
+
     def test_sysinfo_errors(self):
         self.assertRaises(TypeError, sysinfo)
         self.assertRaises(TypeError, sysinfo, b"void*")
@@ -175,36 +184,12 @@ class ModuleFunctionsTests(unittest.TestCase):
         self.assertEqual(sys.byteorder == "big",
                          sysinfo("PY_BIG_ENDIAN"))
 
-    def test_set_default_endian(self):
-        for default_endian in 'big', 'little':
-            _set_default_endian(default_endian)
-            a = bitarray()
-            self.assertEqual(a.endian, default_endian)
-            for x in None, 0, 64, '10111', [1, 0]:
-                a = bitarray(x)
-                self.assertEqual(a.endian, default_endian)
-
-            for endian in 'big', 'little', None:
-                a = bitarray(endian=endian)
-                self.assertEqual(a.endian,
-                                 default_endian if endian is None else endian)
-
-            # make sure that wrong calling _set_default_endian() does not
-            # change the default endianness
-            self.assertRaises(ValueError, _set_default_endian, 'foobar')
-            self.assertEqual(bitarray().endian, default_endian)
-
-    def test_set_default_endian_errors(self):
-        self.assertRaises(TypeError, _set_default_endian, 0)
-        self.assertRaises(TypeError, _set_default_endian, 'little', 0)
-        self.assertRaises(ValueError, _set_default_endian, 'foo')
-
     def test_get_default_endian(self):
-        for default_endian in 'big', 'little':
-            _set_default_endian(default_endian)
-            endian = get_default_endian()
-            self.assertEqual(endian, default_endian)
-            self.assertEqual(type(endian), str)
+        endian = get_default_endian()
+        self.assertTrue(endian in ('little', 'big'))
+        self.assertEqual(type(endian), str)
+        a = bitarray()
+        self.assertEqual(a.endian, endian)
 
     def test_get_default_endian_errors(self):
         # takes no arguments
@@ -257,16 +242,6 @@ class CreateObjectTests(unittest.TestCase, Util):
         self.assertNotEqual(a, b)
         self.assertEqual(a.tobytes(), b.tobytes())
 
-    def test_endian_default(self):
-        _set_default_endian('big')
-        a_big = bitarray()
-        _set_default_endian('little')
-        a_little = bitarray()
-        _set_default_endian('big')
-
-        self.assertEqual(a_big.endian, 'big')
-        self.assertEqual(a_little.endian, 'little')
-
     def test_endian_wrong(self):
         self.assertRaises(TypeError, bitarray, endian=0)
         self.assertRaises(ValueError, bitarray, endian='')
@@ -283,10 +258,9 @@ class CreateObjectTests(unittest.TestCase, Util):
             a = bitarray(buffer=b'', endian=endian)
             self.assertEQUAL(a, bitarray(0, endian))
 
-            _set_default_endian(endian)
-            a = bitarray(buffer=b'A')
-            self.assertEqual(a.endian, endian)
-            self.assertEqual(len(a), 8)
+        a = bitarray(buffer=b'A')
+        self.assertEqual(a.endian, "big")
+        self.assertEqual(len(a), 8)
 
     def test_buffer_readonly(self):
         a = bitarray(buffer=b'\xf0', endian='little')
@@ -538,6 +512,13 @@ class ToObjectsTests(unittest.TestCase, Util):
             self.assertEqual(bytes(a), a.tobytes())
             self.assertEqual(bytearray(a), a.tobytes())
 
+    def test_bytes_bytearray_pad(self):
+        for endian, res in ("little", b"\x01"), ("big", b"\x80"):
+            a = bitarray("1", endian)
+            self.assertEqual(a.tobytes(), res)
+            a = bitarray("1", endian)
+            self.assertEqual(bytes(a), res)
+
     def test_set(self):
         for a in self.randombitarrays():
             self.assertEqual(set(a), set(a.tolist()))
@@ -2423,7 +2404,6 @@ class NumberTests(unittest.TestCase, Util):
 
     @skipIf(is_pypy)
     def test_imported(self):
-        _set_default_endian("big")
         a = bytearray([0xf0, 0x01, 0x02, 0x0f])
         b = bitarray(buffer=a)
         self.assertFalse(b.readonly)
@@ -2937,20 +2917,18 @@ class SortTests(unittest.TestCase, Util):
 class PackTests(unittest.TestCase, Util):
 
     def test_pack_simple(self):
-        for endian in 'little', 'big':
-            _set_default_endian(endian)
-            a = bitarray()
-            a.pack(bytes())
-            self.assertEQUAL(a, bitarray())
-            a.pack(b'\x00')
-            self.assertEQUAL(a, bitarray('0'))
-            a.pack(b'\xff')
-            self.assertEQUAL(a, bitarray('01'))
-            a.pack(b'\x01\x00\x7a')
-            self.assertEQUAL(a, bitarray('01101'))
-            a.pack(bytearray([0x01, 0x00, 0xff, 0xa7]))
-            self.assertEQUAL(a, bitarray('01101 1011'))
-            self.check_obj(a)
+        a = bitarray()
+        a.pack(bytes())
+        self.assertEQUAL(a, bitarray())
+        a.pack(b'\x00')
+        self.assertEQUAL(a, bitarray('0'))
+        a.pack(b'\xff')
+        self.assertEQUAL(a, bitarray('01'))
+        a.pack(b'\x01\x00\x7a')
+        self.assertEQUAL(a, bitarray('01101'))
+        a.pack(bytearray([0x01, 0x00, 0xff, 0xa7]))
+        self.assertEQUAL(a, bitarray('01101 1011'))
+        self.check_obj(a)
 
     def test_pack_types(self):
         a = bitarray()
@@ -5174,17 +5152,19 @@ class FrozenbitarrayTests(unittest.TestCase, Util):
 def run(verbosity=1):
     import bitarray.test_util
 
-    default_endian = get_default_endian()
     print('bitarray is installed in: %s' % os.path.dirname(__file__))
     print('bitarray version: %s' % __version__)
     print('sys.version: %s' % sys.version)
     print('sys.prefix: %s' % sys.prefix)
+    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' % default_endian)
+    print('default bit-endianness: %s' % get_default_endian())
     print('machine byte-order: %s' % sys.byteorder)
+    print('Py_GIL_DISABLED: %s' % sysinfo("Py_GIL_DISABLED"))
     print('Py_DEBUG: %s' % sysinfo("Py_DEBUG"))
     print('DEBUG: %s' % sysinfo("DEBUG"))
     loader = unittest.TestLoader()
@@ -5194,7 +5174,6 @@ def run(verbosity=1):
 
     runner = unittest.TextTestRunner(verbosity=verbosity)
     result = runner.run(suite)
-    _set_default_endian(default_endian)
     return result
 
 if __name__ == '__main__':

{bitarray-3.7.2 → bitarray-3.8.0}/bitarray/test_util.py

@@ -24,7 +24,7 @@ from string import hexdigits, whitespace
 from collections import Counter
 
 from bitarray import (bitarray, frozenbitarray, decodetree, bits2bytes,
-                      _set_default_endian)
+                      get_default_endian)
 from bitarray.test_bitarray import Util, skipIf, is_pypy, urandom_2, PTRSIZE
 
 from bitarray.util import (
@@ -46,12 +46,10 @@ class ZerosOnesTests(unittest.TestCase):
 
     def test_basic(self):
         for _ in range(50):
-            default_endian = choice(['little', 'big'])
-            _set_default_endian(default_endian)
             a = choice([zeros(0), zeros(0, None), zeros(0, endian=None),
                         ones(0), ones(0, None), ones(0, endian=None)])
             self.assertEqual(a, bitarray())
-            self.assertEqual(a.endian, default_endian)
+            self.assertEqual(a.endian, get_default_endian())
             self.assertEqual(type(a), bitarray)
 
             endian = choice(['little', 'big', None])
@@ -59,11 +57,11 @@ class ZerosOnesTests(unittest.TestCase):
 
             a = choice([zeros(n, endian), zeros(n, endian=endian)])
             self.assertEqual(a.to01(), n * "0")
-            self.assertEqual(a.endian, endian or default_endian)
+            self.assertEqual(a.endian, endian or get_default_endian())
 
             b = choice([ones(n, endian), ones(n, endian=endian)])
             self.assertEqual(b.to01(), n * "1")
-            self.assertEqual(b.endian, endian or default_endian)
+            self.assertEqual(b.endian, endian or get_default_endian())
 
     def test_errors(self):
         for f in zeros, ones:
@@ -86,18 +84,16 @@ class URandomTests(unittest.TestCase):
 
     def test_basic(self):
         for _ in range(20):
-            default_endian = choice(['little', 'big'])
-            _set_default_endian(default_endian)
             a = choice([urandom(0), urandom(0, endian=None)])
             self.assertEqual(a, bitarray())
-            self.assertEqual(a.endian, default_endian)
+            self.assertEqual(a.endian, get_default_endian())
 
             endian = choice(['little', 'big', None])
             n = randrange(100)
 
             a = choice([urandom(n, endian), urandom(n, endian=endian)])
             self.assertEqual(len(a), n)
-            self.assertEqual(a.endian, endian or default_endian)
+            self.assertEqual(a.endian, endian or get_default_endian())
             self.assertEqual(type(a), bitarray)
 
     def test_errors(self):
@@ -122,8 +118,6 @@ class Random_K_Tests(unittest.TestCase):
 
     def test_basic(self):
         for _ in range(250):
-            default_endian = choice(['little', 'big'])
-            _set_default_endian(default_endian)
             endian = choice(['little', 'big', None])
             n = randrange(120)
             k = randint(0, n)
@@ -131,7 +125,7 @@ class Random_K_Tests(unittest.TestCase):
             self.assertTrue(type(a), bitarray)
             self.assertEqual(len(a), n)
             self.assertEqual(a.count(), k)
-            self.assertEqual(a.endian, endian or default_endian)
+            self.assertEqual(a.endian, endian or get_default_endian())
 
     def test_inputs_and_edge_cases(self):
         R = random_k
@@ -210,7 +204,6 @@ class Random_K_Tests(unittest.TestCase):
         # We ensure that after setting a seed value, random_k() will
         # always return the same random bitarrays.  However, we do not ensure
         # that these results will not change in future versions of bitarray.
-        _set_default_endian("little")
         a = []
         for val in 654321, 654322, 654321, 654322:
             seed(val)
@@ -289,15 +282,13 @@ class Random_P_Tests(unittest.TestCase):
 
     def test_basic(self):
         for _ in range(250):
-            default_endian = choice(['little', 'big'])
-            _set_default_endian(default_endian)
             endian = choice(['little', 'big', None])
             n = randrange(120)
             p = choice([0.0, 0.0001, 0.2, 0.5, 0.9, 1.0])
             a = random_p(n, p, endian)
             self.assertTrue(type(a), bitarray)
             self.assertEqual(len(a), n)
-            self.assertEqual(a.endian, endian or default_endian)
+            self.assertEqual(a.endian, endian or get_default_endian())
 
     def test_inputs_and_edge_cases(self):
         R = random_p
@@ -347,7 +338,6 @@ class Random_P_Tests(unittest.TestCase):
         # We ensure that after setting a seed value, random_p() will always
         # return the same random bitarrays.  However, we do not ensure that
         # these results will not change in future versions of bitarray.
-        _set_default_endian("little")
         a = []
         for val in 123456, 123457, 123456, 123457:
             seed(val)
@@ -391,13 +381,11 @@ class PrimeTests(unittest.TestCase):
 
     def test_explitcit(self):
         for n in range(230):
-            default_endian = choice(['little', 'big'])
-            _set_default_endian(default_endian)
             endian = choice(["little", "big", None])
             odd = getrandbits(1)
             a = gen_primes(n, endian, odd)
             self.assertEqual(len(a), n)
-            self.assertEqual(a.endian, endian or default_endian)
+            self.assertEqual(a.endian, endian or get_default_endian())
             if odd:
                 lst = [2] + [2 * i + 1 for i in a.search(1)]
             else:
@@ -530,16 +518,15 @@ class StripTests(unittest.TestCase, Util):
         self.assertRaises(TypeError, strip, '0110')
         self.assertRaises(TypeError, strip, bitarray(), 123)
         self.assertRaises(ValueError, strip, bitarray(), 'up')
-        for default_endian in 'big', 'little':
-            _set_default_endian(default_endian)
-            a = bitarray('00010110000')
-            self.assertEQUAL(strip(a), bitarray('0001011'))
-            self.assertEQUAL(strip(a, 'left'), bitarray('10110000'))
-            self.assertEQUAL(strip(a, 'both'), bitarray('1011'))
-            b = frozenbitarray('00010110000')
-            c = strip(b, 'both')
-            self.assertEqual(c, bitarray('1011'))
-            self.assertEqual(type(c), frozenbitarray)
+
+        a = bitarray('00010110000')
+        self.assertEQUAL(strip(a), bitarray('0001011'))
+        self.assertEQUAL(strip(a, 'left'), bitarray('10110000'))
+        self.assertEQUAL(strip(a, 'both'), bitarray('1011'))
+        b = frozenbitarray('00010110000')
+        c = strip(b, 'both')
+        self.assertEqual(c, bitarray('1011'))
+        self.assertEqual(type(c), frozenbitarray)
 
     def test_zeros_ones(self):
         for _ in range(50):
@@ -1412,7 +1399,6 @@ class HexlifyTests(unittest.TestCase, Util):
         self.assertRaises(ValueError, ba2hex, a, 2, " \0")
 
     def test_hex2ba_whitespace(self):
-        _set_default_endian('big')
         self.assertEqual(hex2ba("F1 FA %s f3 c0" % whitespace),
                          bitarray("11110001 11111010 11110011 11000000"))
         self.assertEQUAL(hex2ba(b' a F ', 'big'),
@@ -1441,13 +1427,11 @@ class HexlifyTests(unittest.TestCase, Util):
 
     def test_random(self):
         for _ in range(100):
-            default_endian = self.random_endian()
-            _set_default_endian(default_endian)
             endian = choice(["little", "big", None])
             a = urandom_2(4 * randrange(100), endian)
             s = ba2hex(a, group=randrange(10), sep=choice(whitespace))
             b = hex2ba(s, endian)
-            self.assertEqual(b.endian, endian or default_endian)
+            self.assertEqual(b.endian, endian or get_default_endian())
             self.assertEqual(a, b)
             self.check_obj(b)
 
@@ -1978,14 +1962,11 @@ class VLFTests(unittest.TestCase, Util):
                 (b'\xb5\xa7\x18', '0101 0100111 0011'),
                 (b'\x95\xb7\x1c', '0101 0110111 001110'),
         ]:
-            default_endian = self.random_endian()
-            _set_default_endian(default_endian)
-
             a = bitarray(s)
             self.assertEqual(vl_encode(a), blob)
             c = vl_decode(blob)
             self.assertEqual(c, a)
-            self.assertEqual(c.endian, default_endian)
+            self.assertEqual(c.endian, get_default_endian())
 
             for endian in 'big', 'little', None:
                 a = bitarray(s, endian)
@@ -1995,7 +1976,7 @@ class VLFTests(unittest.TestCase, Util):
 
                 c = vl_decode(blob, endian)
                 self.assertEqual(c, a)
-                self.assertEqual(c.endian, endian or default_endian)
+                self.assertEqual(c.endian, endian or get_default_endian())
 
     def test_encode_types(self):
         s = "0011 01"
@@ -2264,7 +2245,6 @@ class IntegerizationTests(unittest.TestCase, Util):
                              bitarray(n * '1'))
 
     def test_explicit(self):
-        _set_default_endian('big')
         for i, sa in [( 0,     '0'),    (1,         '1'),
                       ( 2,    '10'),    (3,        '11'),
                       (25, '11001'),  (265, '100001001'),

{bitarray-3.7.2 → bitarray-3.8.0}/bitarray.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitarray
-Version: 3.7.2
+Version: 3.8.0
 Summary: efficient arrays of booleans -- C extension
 Home-page: https://github.com/ilanschnell/bitarray
 Author: Ilan Schnell
@@ -20,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Free Threading :: 1 - Unstable
 Classifier: Topic :: Utilities
 License-File: LICENSE
 Dynamic: author
@@ -90,7 +91,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.7.2
+    bitarray version: 3.8.0
     sys.version: 3.13.5 (main, Jun 16 2025) [Clang 18.1.8]
     sys.prefix: /Users/ilan/miniforge
     pointer size: 64 bit
@@ -99,13 +100,14 @@ Once you have installed the package, you may want to test it:
     HAVE_BUILTIN_BSWAP64: 1
     default bit-endianness: big
     machine byte-order: little
+    Py_GIL_DISABLED: 0
     Py_DEBUG: 0
     DEBUG: 0
     .........................................................................
     .........................................................................
     ................................................................
     ----------------------------------------------------------------------
-    Ran 597 tests in 0.165s
+    Ran 595 tests in 0.165s
 
     OK
 
@@ -352,7 +354,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.7.2 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.8.0 -- `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.
@@ -588,6 +590,7 @@ bitarray methods:
 
 ``tobytes()`` -> bytes
    Return the bitarray buffer (pad bits are set to zero).
+   ``a.tobytes()`` is equivalent to ``bytes(a)``
 
 
 ``tofile(f, /)``
@@ -658,8 +661,6 @@ Functions defined in the `bitarray` module:
 
 ``get_default_endian()`` -> str
    Return the default bit-endianness for new bitarray objects being created.
-   Unless ``_set_default_endian('little')`` was called, the default
-   bit-endianness is ``big``.
 
    New in version 1.3
 

{bitarray-3.7.2 → bitarray-3.8.0}/setup.py

@@ -56,6 +56,7 @@ setup(
         "Programming Language :: Python :: 3.12",
         "Programming Language :: Python :: 3.13",
         "Programming Language :: Python :: 3.14",
+        "Programming Language :: Python :: Free Threading :: 1 - Unstable",
         "Topic :: Utilities",
     ],
     description = "efficient arrays of booleans -- C extension",