Hello community,
here is the log from the commit of package python-bitarray for openSUSE:Factory
checked in at 2020-07-08 19:12:54
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-bitarray (Old)
and /work/SRC/openSUSE:Factory/.python-bitarray.new.3060 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-bitarray"
Wed Jul 8 19:12:54 2020 rev:2 rq:819132 version:1.3.0
Changes:
--------
--- /work/SRC/openSUSE:Factory/python-bitarray/python-bitarray.changes
2020-03-25 23:46:56.312065083 +0100
+++
/work/SRC/openSUSE:Factory/.python-bitarray.new.3060/python-bitarray.changes
2020-07-08 19:13:14.523160390 +0200
@@ -1,0 +2,20 @@
+Mon Jul 6 18:40:25 UTC 2020 - Martin Hauke <[email protected]>
+
+- Update to version 1.3.0
+ * add `bitarray.util.make_endian()`
+ * `util.ba2hex()` and `util.hex2ba()` now also support
+ little-endian
+ * add `bitarray.get_default_endian()`
+ * made first argument of initializer a positional-only parameter
+ * remove `.fromstring()` and `.tostring()` methods, these have
+ been deprecated 8 years ago, since version 0.4.0
+ * add `__all__` in `bitarray/__init__.py`
+ * drop Python 3.3 and 3.4 support
+- Update to version 1.2.2
+ * `util.ba2hex` now always return a string object (instead of
+ bytes object for Python 3), see issue #94
+ * `util.hex2ba` allows a unicode object as input on Python 2
+ * Determine 64-bitness of interpreter in a cross-platform
+ fashion #91, in order to better support PyPy
+
+-------------------------------------------------------------------
Old:
----
bitarray-1.2.1.tar.gz
New:
----
bitarray-1.3.0.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-bitarray.spec ++++++
--- /var/tmp/diff_new_pack.9hroe8/_old 2020-07-08 19:13:16.951168767 +0200
+++ /var/tmp/diff_new_pack.9hroe8/_new 2020-07-08 19:13:16.955168781 +0200
@@ -18,7 +18,7 @@
%{?!python_module:%define python_module() python-%{**} python3-%{**}}
Name: python-bitarray
-Version: 1.2.1
+Version: 1.3.0
Release: 0
Summary: Efficient Arrays of Booleans
License: Python-2.0
++++++ bitarray-1.2.1.tar.gz -> bitarray-1.3.0.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/bitarray-1.2.1/CHANGE_LOG
new/bitarray-1.3.0/CHANGE_LOG
--- old/bitarray-1.2.1/CHANGE_LOG 2020-01-06 21:09:39.000000000 +0100
+++ new/bitarray-1.3.0/CHANGE_LOG 2020-07-06 05:39:41.000000000 +0200
@@ -1,3 +1,24 @@
+2020-07-06 1.3.0:
+-------------------
+ * add `bitarray.util.make_endian()`
+ * `util.ba2hex()` and `util.hex2ba()` now also support little-endian
+ * add `bitarray.get_default_endian()`
+ * made first argument of initializer a positional-only parameter
+ * remove `.fromstring()` and `.tostring()` methods, these have been
+ deprecated 8 years ago, since version 0.4.0
+ * add `__all__` in `bitarray/__init__.py`
+ * drop Python 3.3 and 3.4 support
+
+
+2020-05-18 1.2.2:
+-------------------
+ * `util.ba2hex` now always return a string object (instead of bytes object
+ for Python 3), see issue #94
+ * `util.hex2ba` allows a unicode object as input on Python 2
+ * Determine 64-bitness of interpreter in a cross-platform fashion #91,
+ in order to better support PyPy
+
+
2020-01-06 1.2.1:
-------------------
* simplify markdown of readme so PyPI renders better
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/bitarray-1.2.1/Makefile new/bitarray-1.3.0/Makefile
--- old/bitarray-1.2.1/Makefile 2020-01-06 21:09:39.000000000 +0100
+++ new/bitarray-1.3.0/Makefile 2020-07-06 05:39:41.000000000 +0200
@@ -1,3 +1,5 @@
+PYTHON=python
+
bitarray/_bitarray.so: bitarray/_bitarray.c
$(PYTHON) setup.py build_ext --inplace
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/bitarray-1.2.1/README.md new/bitarray-1.3.0/README.md
--- old/bitarray-1.2.1/README.md 2020-01-06 21:09:39.000000000 +0100
+++ new/bitarray-1.3.0/README.md 2020-07-06 05:39:41.000000000 +0200
@@ -36,8 +36,8 @@
Bitarray can be installed from source:
- $ tar xzf bitarray-1.2.1.tar.gz
- $ cd bitarray-1.2.1
+ $ tar xzf bitarray-1.3.0.tar.gz
+ $ cd bitarray-1.3.0
$ python setup.py install
On Unix systems, the latter command may have to be executed with root
@@ -46,7 +46,7 @@
$ python -c 'import bitarray; bitarray.test()'
bitarray is installed in: /usr/local/lib/python2.7/site-packages/bitarray
- bitarray version: 1.2.1
+ bitarray version: 1.3.0
3.7.4 (r271:86832, Dec 29 2018) [GCC 4.2.1 (SUSE Linux)]
.........................................................................
.........................................................................
@@ -286,12 +286,11 @@
The bitarray object:
--------------------
-`bitarray(initial=0, /, endian='big')`
+`bitarray(initializer=0, /, endian='big')` -> bitarray
Return a new bitarray object whose items are bits initialized from
the optional initial object, and endianness.
-If no initial object is provided, an empty bitarray (length zero) is created.
-The initial object may be of the following types:
+The initializer may be of the following types:
`int`: Create a bitarray of given integer length. The initial values are
arbitrary. If you want all values to be set, use the .setall() method.
@@ -399,12 +398,6 @@
read until EOF is reached.
-`fromstring(str)`
-
-Append from a string, interpreting the string as machine values.
-Deprecated since version 0.4.0, use `.frombytes()` instead.
-
-
`index(value, start=0, stop=<end of array>, /)` -> int
Return index of the first occurrence of `bool(value)` in the bitarray.
@@ -521,14 +514,6 @@
use the extend method.
-`tostring()` -> str
-
-Return the string representing (machine values) of the bitarray.
-When the length of the bitarray is not a multiple of 8, the few remaining
-bits (1..7) are set to 0.
-Deprecated since version 0.4.0, use `.tobytes()` instead.
-
-
`unpack(zero=b'\x00', one=b'\xff')` -> bytes
Return bytes containing one character for each bit in the bitarray,
@@ -538,7 +523,7 @@
The frozenbitarray object:
--------------------------
-`frozenbitarray(initial=0, /, endian='big')`
+`frozenbitarray(initializer=0, /, endian='big')` -> frozenbitarray
Return a frozenbitarray object, which is initialized the same way a bitarray
object is initialized. A frozenbitarray is immutable and hashable.
@@ -554,25 +539,35 @@
Run self-test, and return unittest.runner.TextTestResult object.
-`bitdiff(a, b, /)` -> int
+`bits2bytes(n, /)` -> int
-Return the difference between two bitarrays a and b.
-This is function does the same as (a ^ b).count(), but is more memory
-efficient, as no intermediate bitarray object gets created.
-Deprecated since version 1.2.0, use `bitarray.util.count_xor()` instead.
+Return the number of bytes necessary to store n bits.
-`bits2bytes(n, /)` -> int
+`get_default_endian()` -> string
-Return the number of bytes necessary to store n bits.
+Return the default endianness for new bitarray objects being created.
+Under normal circumstances, the return value is `big`.
Functions defined in bitarray.util:
-----------------------------------
-`zeros(length, /, endian='big')` -> bitarray
+`zeros(length, /, endian=None)` -> bitarray
+
+Create a bitarray of length, with all values 0, and optional
+endianness, which may be 'big', 'lillte'.
+
-Create a bitarray of length, with all values 0.
+`make_endian(bitarray, endian, /)` -> bitarray
+
+When the endianness of the given bitarray is different from `endian`,
+return a new bitarray, with endianness `endian` and the same elements
+as the original bitarray, i.e. even though the binary representation of the
+new bitarray will be different, the returned bitarray will equal the original
+one.
+Otherwise (endianness is already `endian`) the original bitarray is returned
+unchanged.
`rindex(bitarray, value=True, /)` -> int
@@ -621,11 +616,11 @@
`ba2hex(bitarray, /)` -> hexstr
-Return a bytes object containing with hexadecimal representation of
+Return a string containing with hexadecimal representation of
the bitarray (which has to be multiple of 4 in length).
-`hex2ba(hexstr, /)` -> bitarray
+`hex2ba(hexstr, /, endian=None)` -> bitarray
Bitarray of hexadecimal representation.
hexstr may contain any number of hex digits (upper or lower case).
@@ -637,7 +632,7 @@
The bit-endianness of the bitarray is respected.
-`int2ba(int, /, length=None, endian='big')` -> bitarray
+`int2ba(int, /, length=None, endian=None)` -> bitarray
Convert the given integer into a bitarray (with given endianness,
and no leading (big-endian) / trailing (little-endian) zeros).
@@ -646,7 +641,7 @@
within length bits.
-`huffman_code(dict, /, endian='big')` -> dict
+`huffman_code(dict, /, endian=None)` -> dict
Given a frequency map, a dictionary mapping symbols to thier frequency,
calculate the Huffman code, i.e. a dict mapping those symbols to
@@ -657,6 +652,27 @@
Change log
----------
+*1.3.0* (2020-07-06):
+
+ * add `bitarray.util.make_endian()`
+ * `util.ba2hex()` and `util.hex2ba()` now also support little-endian
+ * add `bitarray.get_default_endian()`
+ * made first argument of initializer a positional-only parameter
+ * remove `.fromstring()` and `.tostring()` methods, these have been
+ deprecated 8 years ago, since version 0.4.0
+ * add `__all__` in `bitarray/__init__.py`
+ * drop Python 3.3 and 3.4 support
+
+
+*1.2.2* (2020-05-18):
+
+ * `util.ba2hex` now always return a string object (instead of bytes object
+ for Python 3), see issue #94
+ * `util.hex2ba` allows a unicode object as input on Python 2
+ * Determine 64-bitness of interpreter in a cross-platform fashion #91,
+ in order to better support PyPy
+
+
*1.2.1* (2020-01-06):
* simplify markdown of readme so PyPI renders better
@@ -664,32 +680,5 @@
they cannot be imported)
-*1.2.0* (2019-12-06):
-
- * add bitarray.util module which provides useful utility functions
- * deprecate `bitarray.bitdiff` in favor of `bitarray.util.count_xor`
- * use markdown for documentation
- * fix bug in .count() on 32bit systems in special cases when array size
- is 2^29 bits or larger
- * simplified tests by using bytes syntax
- * update smallints and sieve example to use new utility module
- * simplified mandel example to use numba
- * use file context managers in tests
-
-
-*1.1.0* (2019-11-07):
-
- * add frozenbitarray object
- * add optional start and stop parameters to .count() method
- * add official Python 3.8 support
- * optimize setrange() C-function by using memset
- * fix issue #74, bitarray is hashable on Python 2
- * fix issue #68, `unittest.TestCase.assert_` deprecated
- * improved test suite - tests should run in about 1 second
- * update documentation to use positional-only syntax in docstrings
- * update readme to pass Python 3 doctest
- * add utils module to examples
-
-
Please find the complete change log
<a
href="https://github.com/ilanschnell/bitarray/blob/master/CHANGE_LOG";>here</a>.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/bitarray-1.2.1/bitarray/__init__.py
new/bitarray-1.3.0/bitarray/__init__.py
--- old/bitarray-1.2.1/bitarray/__init__.py 2020-01-06 21:09:39.000000000
+0100
+++ new/bitarray-1.3.0/bitarray/__init__.py 2020-07-06 05:39:41.000000000
+0200
@@ -4,22 +4,25 @@
Please find a description of this package at:
- http://pypi.python.org/pypi/bitarray/
+ https://github.com/ilanschnell/bitarray
Author: Ilan Schnell
"""
-from bitarray._bitarray import _bitarray, bitdiff, bits2bytes, _sysinfo
+from bitarray._bitarray import (_bitarray, bitdiff, bits2bytes, _sysinfo,
+ get_default_endian, _set_default_endian)
-__version__ = '1.2.1'
+
+__version__ = '1.3.0'
+
+__all__ = ['bitarray', 'frozenbitarray']
class bitarray(_bitarray):
- """bitarray(initial=0, /, endian='big')
+ """bitarray(initializer=0, /, endian='big') -> bitarray
Return a new bitarray object whose items are bits initialized from
the optional initial object, and endianness.
-If no initial object is provided, an empty bitarray (length zero) is created.
-The initial object may be of the following types:
+The initializer may be of the following types:
`int`: Create a bitarray of given integer length. The initial values are
arbitrary. If you want all values to be set, use the .setall() method.
@@ -40,25 +43,9 @@
machine representation of the bitarray, i.e. when using the methods: tofile,
fromfile, tobytes, frombytes."""
- def fromstring(self, string):
- """fromstring(str)
-
-Append from a string, interpreting the string as machine values.
-Deprecated since version 0.4.0, use `.frombytes()` instead."""
- return self.frombytes(string.encode())
-
- def tostring(self):
- """tostring() -> str
-
-Return the string representing (machine values) of the bitarray.
-When the length of the bitarray is not a multiple of 8, the few remaining
-bits (1..7) are set to 0.
-Deprecated since version 0.4.0, use `.tobytes()` instead."""
- return self.tobytes().decode()
-
class frozenbitarray(_bitarray):
- """frozenbitarray(initial=0, /, endian='big')
+ """frozenbitarray(initializer=0, /, endian='big') -> frozenbitarray
Return a frozenbitarray object, which is initialized the same way a bitarray
object is initialized. A frozenbitarray is immutable and hashable.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/bitarray-1.2.1/bitarray/_bitarray.c
new/bitarray-1.3.0/bitarray/_bitarray.c
--- old/bitarray-1.2.1/bitarray/_bitarray.c 2020-01-06 21:09:39.000000000
+0100
+++ new/bitarray-1.3.0/bitarray/_bitarray.c 2020-07-06 05:39:41.000000000
+0200
@@ -1,5 +1,5 @@
/*
- Copyright (c) 2008 - 2019, Ilan Schnell
+ Copyright (c) 2008 - 2020, Ilan Schnell
bitarray is published under the PSF license.
This file is the C part of the bitarray package.
@@ -36,7 +36,7 @@
typedef long long int idx_t;
/* throughout: 0 = little endian 1 = big endian */
-#define DEFAULT_ENDIAN 1
+static int default_endian = 1;
/* Unlike the normal convention, ob_size is the byte count, not the number
of elements. The reason for doing this is that we can use our own
@@ -54,7 +54,9 @@
static PyTypeObject Bitarraytype;
-#define bitarray_Check(obj) PyObject_TypeCheck(obj, &Bitarraytype)
+#define ENDIAN_STR(ba) (((ba)->endian) ? "big" : "little")
+
+#define bitarray_Check(obj) PyObject_TypeCheck((obj), &Bitarraytype)
#define BITS(bytes) ((idx_t) (bytes) << 3)
@@ -290,6 +292,7 @@
res++;
}
assert(res < 8);
+ assert(n == self->nbits + res);
return res;
}
@@ -425,8 +428,7 @@
}
}
-
-static int bitcount_lookup[256] = {
+static unsigned char bitcount_lookup[256] = {
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
@@ -587,21 +589,20 @@
static int
extend_bitarray(bitarrayobject *self, bitarrayobject *other)
{
- idx_t n_sum;
- idx_t n_other_bits;
+ idx_t self_bits, other_bits;
if (other->nbits == 0)
return 0;
- /* Note that other may be self. Thus we take the size before we resize,
- ensuring we only copy the right parts of the array. */
- n_other_bits = other->nbits;
- n_sum = self->nbits + other->nbits;
+ /* We have to store the sizes before we resize.
+ Since other may be self, we also need to store other->nbits. */
+ self_bits = self->nbits;
+ other_bits = other->nbits;
- if (resize(self, n_sum) < 0)
+ if (resize(self, self_bits + other_bits) < 0)
return -1;
- copy_n(self, n_sum - n_other_bits, other, 0, n_other_bits);
+ copy_n(self, self_bits, other, 0, other_bits);
return 0;
}
@@ -781,17 +782,17 @@
return ret;
}
-/* --------- helper functions NOT involving bitarrayobjects ------------ */
-
-#define ENDIAN_STR(ba) (((ba)->endian) ? "big" : "little")
+/* --------- helper functions not involving bitarrayobjects ------------ */
#ifdef IS_PY3K
#define IS_INDEX(x) (PyLong_Check(x) || PyIndex_Check(x))
#define IS_INT_OR_BOOL(x) (PyBool_Check(x) || PyLong_Check(x))
+#define Py_CSTRING PyUnicode_FromString
#else /* Py 2 */
#define IS_INDEX(x) (PyInt_Check(x) || PyLong_Check(x) || PyIndex_Check(x))
#define IS_INT_OR_BOOL(x) (PyBool_Check(x) || PyInt_Check(x) || \
PyLong_Check(x))
+#define Py_CSTRING PyString_FromString
#endif
/* given an PyLong (which must be 0 or 1), or a PyBool, return 0 or 1,
@@ -1163,11 +1164,7 @@
static PyObject *
bitarray_endian(bitarrayobject *self)
{
-#ifdef IS_PY3K
- return PyUnicode_FromString(ENDIAN_STR(self));
-#else
- return PyString_FromString(ENDIAN_STR(self));
-#endif
+ return Py_CSTRING(ENDIAN_STR(self));
}
PyDoc_STRVAR(endian_doc,
@@ -2740,6 +2737,27 @@
};
+/* Given a string, return an integer representing the endianness.
+ If the string is invalid, set a Python exception and return -1. */
+static int
+endian_from_string(const char* string)
+{
+ assert(default_endian == 0 || default_endian == 1);
+
+ if (string == NULL)
+ return default_endian;
+
+ if (strcmp(string, "little") == 0)
+ return 0;
+
+ if (strcmp(string, "big") == 0)
+ return 1;
+
+ PyErr_SetString(PyExc_ValueError, "endian must be 'little' or 'big'");
+ return -1;
+}
+
+
static PyObject *
bitarray_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
@@ -2747,26 +2765,15 @@
PyObject *initial = NULL;
char *endian_str = NULL;
int endian;
- static char *kwlist[] = {"initial", "endian", NULL};
+ static char *kwlist[] = {"", "endian", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds,
"|Os:bitarray", kwlist, &initial, &endian_str))
return NULL;
- if (endian_str == NULL) {
- endian = DEFAULT_ENDIAN; /* use default value */
- }
- else if (strcmp(endian_str, "little") == 0) {
- endian = 0;
- }
- else if (strcmp(endian_str, "big") == 0) {
- endian = 1;
- }
- else {
- PyErr_SetString(PyExc_ValueError,
- "endian must be 'little' or 'big'");
+ endian = endian_from_string(endian_str);
+ if (endian < 0)
return NULL;
- }
/* no arg or None */
if (initial == NULL || initial == Py_None)
@@ -3096,6 +3103,12 @@
#endif /* WITH_BUFFER */
+PyDoc_STRVAR(bitarraytype_doc,
+"_bitarray(initializer=0, /, endian='big') -> bitarray\n\
+\n\
+Return a new bitarray object.\n\
+");
+
/************************** Bitarray Type *******************************/
static PyTypeObject Bitarraytype = {
@@ -3133,7 +3146,7 @@
| Py_TPFLAGS_HAVE_NEWBUFFER
#endif
, /* tp_flags */
- 0, /* tp_doc */
+ bitarraytype_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
richcompare, /* tp_richcompare */
@@ -3223,6 +3236,44 @@
static PyObject *
+get_default_endian(PyObject *self)
+{
+ return Py_CSTRING(default_endian ? "big" : "little");
+}
+
+PyDoc_STRVAR(get_default_endian_doc,
+"get_default_endian() -> string\n\
+\n\
+Return the default endianness for new bitarray objects being created.\n\
+Under normal circumstances, the return value is `big`.");
+
+
+static PyObject *
+set_default_endian(PyObject *self, PyObject *args)
+{
+ char *endian_str;
+ int tmp;
+
+ 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. */
+ tmp = endian_from_string(endian_str);
+ if (tmp < 0)
+ return NULL;
+ default_endian = tmp;
+
+ 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.");
+
+
+static PyObject *
sysinfo(void)
{
return Py_BuildValue("iiiiL",
@@ -3251,6 +3302,10 @@
static PyMethodDef module_functions[] = {
{"bitdiff", (PyCFunction) bitdiff, METH_VARARGS, bitdiff_doc },
{"bits2bytes", (PyCFunction) bits2bytes, METH_O, bits2bytes_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_NOARGS, sysinfo_doc },
{NULL, NULL} /* sentinel */
};
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/bitarray-1.2.1/bitarray/_util.c
new/bitarray-1.3.0/bitarray/_util.c
--- old/bitarray-1.2.1/bitarray/_util.c 2020-01-06 21:09:39.000000000 +0100
+++ new/bitarray-1.3.0/bitarray/_util.c 2020-07-06 05:39:41.000000000 +0200
@@ -89,7 +89,7 @@
setbit(self, i, 0);
}
-static int bitcount_lookup[256] = {
+static unsigned char bitcount_lookup[256] = {
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/bitarray-1.2.1/bitarray/test_bitarray.py
new/bitarray-1.3.0/bitarray/test_bitarray.py
--- old/bitarray-1.2.1/bitarray/test_bitarray.py 2020-01-06
21:09:39.000000000 +0100
+++ new/bitarray-1.3.0/bitarray/test_bitarray.py 2020-07-06
05:39:41.000000000 +0200
@@ -29,9 +29,9 @@
from cStringIO import StringIO
-from bitarray import (bitarray, frozenbitarray,
- bitdiff, bits2bytes, __version__)
-
+from bitarray import (bitarray, frozenbitarray, bitdiff, bits2bytes,
+ get_default_endian, _set_default_endian,
+ _sysinfo, __version__)
tests = []
@@ -39,7 +39,7 @@
class Util(object):
@staticmethod
- def randombitarrays(start=1):
+ def randombitarrays(start=0):
for n in list(range(start, 25)) + [randint(1000, 2000)]:
a = bitarray(endian=['little', 'big'][randint(0, 1)])
a.frombytes(os.urandom(bits2bytes(n)))
@@ -59,6 +59,12 @@
return randint(-length-5, length+5)
@staticmethod
+ def other_endian(endian):
+ t = {'little': 'big',
+ 'big': 'little'}
+ return t[endian]
+
+ @staticmethod
def slicelen(s, length):
assert isinstance(s, slice)
start, stop, step = s.indices(length)
@@ -92,6 +98,28 @@
class TestsModuleFunctions(unittest.TestCase, Util):
+ def test_default_endian(self):
+ self.assertRaises(TypeError, _set_default_endian, 0)
+ self.assertRaises(TypeError, _set_default_endian, 'little', 0)
+ self.assertRaises(ValueError, _set_default_endian, 'foo')
+ for default_endian in 'big', 'little', u'big', u'little':
+ _set_default_endian(default_endian)
+ a = bitarray()
+ self.assertEqual(a.endian(), default_endian)
+ a = bitarray('10111')
+ self.assertEqual(a.endian(), default_endian)
+
+ for endian in 'big', 'little':
+ a = bitarray(endian=endian)
+ self.assertEqual(a.endian(), endian)
+
+ # test get_default_endian()
+ self.assertEqual(get_default_endian(), default_endian)
+ # make sure that calling _set_default_endian wrong does not
+ # change the default endianness
+ self.assertRaises(ValueError, _set_default_endian, 'foobar')
+ self.assertEqual(get_default_endian(), default_endian)
+
def test_bitdiff(self):
a = bitarray('0011')
b = bitarray('0101')
@@ -148,34 +176,23 @@
self.assertEqual(a.tolist(), [])
self.check_obj(a)
- def test_endian1(self):
+ def test_endian(self):
a = bitarray(endian='little')
- a.fromstring('A')
+ a.frombytes(b'ABC')
self.assertEqual(a.endian(), 'little')
self.assertIsInstance(a.endian(), str)
self.check_obj(a)
b = bitarray(endian='big')
- b.fromstring('A')
+ b.frombytes(b'ABC')
self.assertEqual(b.endian(), 'big')
self.assertIsInstance(a.endian(), str)
self.check_obj(b)
- self.assertEqual(a.tostring(), b.tostring())
-
- def test_endian2(self):
- a = bitarray(endian='little')
- a.fromstring(' ')
- self.assertEqual(a.endian(), 'little')
- self.check_obj(a)
-
- b = bitarray(endian='big')
- b.fromstring(' ')
- self.assertEqual(b.endian(), 'big')
- self.check_obj(b)
-
- self.assertEqual(a.tostring(), b.tostring())
+ self.assertNotEqual(a, b)
+ self.assertEqual(a.tobytes(), b.tobytes())
+ def test_endian_wrong(self):
self.assertRaises(TypeError, bitarray.__new__, bitarray, endian=0)
self.assertRaises(ValueError, bitarray.__new__, bitarray, endian='')
self.assertRaises(ValueError, bitarray.__new__,
@@ -255,7 +272,7 @@
self.assertRaises(ValueError, bitarray.__new__, bitarray, '01012100')
- def test_rawbytes(self): # this representation is used for pickling
+ def test_rawbytes(self): # this representation is used for pickling
for s, r in [(b'\x00', ''), (b'\x07\xff', '1'), (b'\x03\xff', '11111'),
(b'\x01\x87\xda', '10000111' '1101101')]:
self.assertEqual(bitarray(s, endian='big'),
@@ -265,28 +282,56 @@
self.assertRaises(ValueError, bitarray.__new__,
bitarray, bytes(bytearray([i])))
- def test_bitarray(self):
+ def test_bitarray_simple(self):
for n in range(10):
a = bitarray(n)
b = bitarray(a)
self.assertFalse(a is b)
self.assertEQUAL(a, b)
- for end in ('little', 'big'):
- a = bitarray(endian=end)
- c = bitarray(a)
- self.assertEqual(c.endian(), end)
- c = bitarray(a, endian='little')
- self.assertEqual(c.endian(), 'little')
- c = bitarray(a, endian='big')
- self.assertEqual(c.endian(), 'big')
+ def test_bitarray_endian(self):
+ # Test creating a new bitarray with different endianness from an
+ # existing bitarray.
+ for endian in 'little', 'big':
+ a = bitarray(endian=endian)
+ b = bitarray(a)
+ self.assertFalse(a is b)
+ self.assertEQUAL(a, b)
+ endian2 = self.other_endian(endian)
+ c = bitarray(a, endian2)
+ self.assertEqual(c.endian(), endian2)
+ self.assertEqual(a, c) # but only because they are empty
+
+ # Even though the byte representation will be the same,
+ # the bitarrays are not equal.
+ a = bitarray('11001000' '11110000', endian)
+ self.assertEqual(len(a) % 8, 0)
+ c = bitarray(a, endian2)
+ # This is only equal because the size of the bitarray is a
+ # multiple of 8, and unused bits are not set (which changes
+ # the byte representation).
+ self.assertEqual(a.tobytes(), c.tobytes())
+ self.assertNotEqual(a.endian(), c.endian())
+ self.assertNotEqual(a, c)
+
+ def test_bitarray_endianness(self):
+ a = bitarray('11100001', endian='little')
+ b = bitarray(a, endian='big')
+ self.assertNotEqual(a, b)
+ self.assertEqual(a.tobytes(), b.tobytes())
+
+ b.bytereverse()
+ self.assertEqual(a, b)
+ self.assertNotEqual(a.tobytes(), b.tobytes())
+
+ c = bitarray('11100001', endian='big')
+ self.assertEqual(a, c)
def test_None(self):
self.assertEQUAL(bitarray(), bitarray(0))
self.assertEQUAL(bitarray(), bitarray(None))
-
def test_WrongArgs(self):
self.assertRaises(TypeError, bitarray.__new__, bitarray, 'A', 42, 69)
@@ -297,6 +342,9 @@
self.assertRaises(TypeError, bitarray.__new__, bitarray, 4+3j)
self.assertRaises(TypeError, bitarray.__new__, bitarray, '', 0, 42)
+ # test second (endian) argument
+ self.assertRaises(TypeError, bitarray.__new__, bitarray, 0, None)
+ self.assertRaises(TypeError, bitarray.__new__, bitarray, 0, 0)
self.assertRaises(ValueError, bitarray.__new__, bitarray, 0, 'foo')
@@ -514,7 +562,7 @@
a = bitarray('1111')
a[1:3] = bitarray('0000')
self.assertEqual(a, bitarray('100001'))
- a[:] = bitarray('010') # replace all values
+ a[:] = bitarray('010') # replace all values
self.assertEqual(a, bitarray('010'))
def test_setslice_to_bool(self):
@@ -547,7 +595,7 @@
self.assertRaises(ValueError, a.__setitem__, slice(None, None, 2), 3)
self.assertRaises(ValueError, a.__setitem__, slice(None, 2, None), -1)
- def test_sieve(self): # Sieve of Eratosthenes
+ def test_sieve(self): # Sieve of Eratosthenes
a = bitarray(50)
a.setall(1)
for i in range(2, 8):
@@ -667,7 +715,7 @@
def __getitem__(self, i):
return bitarray.__getitem__(self, i - self.offset)
- for a in self.randombitarrays(start=1):
+ for a in self.randombitarrays(start=0):
b = ExaggeratingBitarray(a, 1234)
for i in range(len(a)):
self.assertEqual(a[i], b[i+1234])
@@ -735,7 +783,7 @@
self.assertEQUAL(a, b)
def test_overflow(self):
- if tuple.__itemsize__ == 8:
+ if _sysinfo()[0] == 8:
return
self.assertRaises(OverflowError, bitarray.__new__,
@@ -986,7 +1034,7 @@
self.assertEQUAL(a & b, bitarray('10001'))
b = bitarray('1001')
- self.assertRaises(ValueError, a.__and__, b) # not same length
+ self.assertRaises(ValueError, a.__and__, b) # not same length
self.assertRaises(TypeError, a.__and__, 42)
@@ -1274,9 +1322,9 @@
b.append(1)
self.assertTrue(a is b)
self.check_obj(b)
- self.assertEQUAL(b, bitarray(aa+[1], endian=a.endian()))
+ self.assertEQUAL(b, bitarray(aa + [1], endian=a.endian()))
b.append('')
- self.assertEQUAL(b, bitarray(aa+[1, 0], endian=a.endian()))
+ self.assertEQUAL(b, bitarray(aa + [1, 0], endian=a.endian()))
def test_insert(self):
@@ -1384,17 +1432,17 @@
i = randint(0, 1)
a.setall(i)
for unused in range(randint(1, 4)):
- a[randint(0, n-1)] = 1-i
+ a[randint(0, n - 1)] = 1 - i
aa = a.tolist()
for unused in range(100):
- start = randint(-50, n+50)
- stop = randint(-50, n+50)
+ start = randint(-50, n + 50)
+ stop = randint(-50, n + 50)
try:
- res1 = a.index(1-i, start, stop)
+ res1 = a.index(1 - i, start, stop)
except ValueError:
res1 = None
try:
- res2 = aa.index(1-i, start, stop)
+ res2 = aa.index(1 - i, start, stop)
except ValueError:
res2 = None
self.assertEqual(res1, res2)
@@ -1448,8 +1496,8 @@
def test_count6(self):
for a in self.randombitarrays():
s = a.to01()
- i = randint(-3, len(a)+1)
- j = randint(-3, len(a)+1)
+ i = randint(-3, len(a) + 1)
+ j = randint(-3, len(a) + 1)
self.assertEqual(a.count(1, i, j), s[i:j].count('1'))
self.assertEqual(a.count(0, i, j), s[i:j].count('0'))
@@ -1499,7 +1547,7 @@
def test_search3(self):
a = bitarray('10010101110011111001011')
for s, res in [('011', [6, 11, 20]),
- ('111', [7, 12, 13, 14]), # note the overlap
+ ('111', [7, 12, 13, 14]), # note the overlap
('1011', [5, 19]),
('100', [0, 9, 16])]:
b = bitarray(s)
@@ -1665,7 +1713,7 @@
for a in self.randombitarrays():
self.assertRaises(IndexError, a.pop, len(a))
- self.assertRaises(IndexError, a.pop, -len(a)-1)
+ self.assertRaises(IndexError, a.pop, -len(a) - 1)
if len(a) == 0:
continue
aa = a.tolist()
@@ -1725,7 +1773,7 @@
# ---------------------------------------------------------------------------
-class StringTests(unittest.TestCase, Util):
+class BytesTests(unittest.TestCase, Util):
def randombytes(self):
for n in range(1, 20):
@@ -1831,7 +1879,7 @@
self.assertRaises(TypeError, a.pack, bitarray())
-tests.append(StringTests)
+tests.append(BytesTests)
# ---------------------------------------------------------------------------
@@ -1877,7 +1925,7 @@
def test_fromfile_wrong_args(self):
b = bitarray()
self.assertRaises(TypeError, b.fromfile)
- self.assertRaises(TypeError, b.fromfile, StringIO()) # file not open
+ self.assertRaises(TypeError, b.fromfile, StringIO()) # file not open
self.assertRaises(TypeError, b.fromfile, 42)
self.assertRaises(TypeError, b.fromfile, 'bar')
@@ -1932,33 +1980,33 @@
def test_fromfile_n(self):
a = bitarray()
- a.fromstring('ABCDEFGHIJ')
+ a.frombytes(b'ABCDEFGHIJ')
with open(self.tmpfname, 'wb') as fo:
a.tofile(fo)
b = bitarray()
with open(self.tmpfname, 'rb') as f:
- b.fromfile(f, 0); self.assertEqual(b.tostring(), '')
- b.fromfile(f, 1); self.assertEqual(b.tostring(), 'A')
+ b.fromfile(f, 0); self.assertEqual(b.tobytes(), b'')
+ b.fromfile(f, 1); self.assertEqual(b.tobytes(), b'A')
f.read(1)
b = bitarray()
- b.fromfile(f, 2); self.assertEqual(b.tostring(), 'CD')
- b.fromfile(f, 1); self.assertEqual(b.tostring(), 'CDE')
- b.fromfile(f, 0); self.assertEqual(b.tostring(), 'CDE')
- b.fromfile(f); self.assertEqual(b.tostring(), 'CDEFGHIJ')
- b.fromfile(f); self.assertEqual(b.tostring(), 'CDEFGHIJ')
+ b.fromfile(f, 2); self.assertEqual(b.tobytes(), b'CD')
+ b.fromfile(f, 1); self.assertEqual(b.tobytes(), b'CDE')
+ b.fromfile(f, 0); self.assertEqual(b.tobytes(), b'CDE')
+ b.fromfile(f); self.assertEqual(b.tobytes(), b'CDEFGHIJ')
+ b.fromfile(f); self.assertEqual(b.tobytes(), b'CDEFGHIJ')
b = bitarray()
with open(self.tmpfname, 'rb') as f:
- f.read(1);
+ f.read(1)
self.assertRaises(EOFError, b.fromfile, f, 10)
- self.assertEqual(b.tostring(), 'BCDEFGHIJ')
+ self.assertEqual(b.tobytes(), b'BCDEFGHIJ')
b = bitarray()
with open(self.tmpfname, 'rb') as f:
- b.fromfile(f);
- self.assertEqual(b.tostring(), 'ABCDEFGHIJ')
+ b.fromfile(f)
+ self.assertEqual(b.tobytes(), b'ABCDEFGHIJ')
self.assertRaises(EOFError, b.fromfile, f, 1)
@@ -1986,7 +2034,7 @@
self.assertEqual(len(s), a.buffer_info()[1])
for n in range(3):
- a.fromstring(n * 'A')
+ a.frombytes(n * b'A')
self.assertRaises(TypeError, a.tofile)
self.assertRaises(TypeError, a.tofile, StringIO())
@@ -2288,7 +2336,7 @@
a[4003] = 0
self.assertEqual(a[3999:4009], bitarray('0111011110'))
v[301:304] = b'ABC'
- self.assertEqual(a[300 *8 : 305 * 8].tobytes(), b'\x00ABC\x00')
+ self.assertEqual(a[300 * 8 : 305 * 8].tobytes(), b'\x00ABC\x00')
if sys.version_info[:2] >= (2, 7):
tests.append(BufferInterfaceTests)
@@ -2353,7 +2401,7 @@
self.assertEqual(d[frozenbitarray('01')], 123)
self.assertEqual(d[frozenbitarray(b)], 345)
- def test_dictkey2(self): # taken sllightly modified from issue #74
+ def test_dictkey2(self): # taken slightly modified from issue #74
a1 = frozenbitarray([True, False])
a2 = frozenbitarray([False, False])
dct = {a1: "one", a2: "two"}
@@ -2378,8 +2426,9 @@
print('bitarray is installed in: %s' % os.path.dirname(__file__))
print('bitarray version: %s' % __version__)
- print('Python version: %s' % sys.version)
-
+ print('sys.version: %s' % sys.version)
+ print('sys.prefix: %s' % sys.prefix)
+ print('pointer size: %d bit' % (8 * _sysinfo()[0]))
suite = unittest.TestSuite()
for cls in tests:
for _ in range(repeat):
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/bitarray-1.2.1/bitarray/test_util.py
new/bitarray-1.3.0/bitarray/test_util.py
--- old/bitarray-1.2.1/bitarray/test_util.py 2020-01-06 21:09:39.000000000
+0100
+++ new/bitarray-1.3.0/bitarray/test_util.py 2020-07-06 05:39:41.000000000
+0200
@@ -11,13 +11,15 @@
except ImportError:
pass
-from bitarray import bitarray, frozenbitarray, bits2bytes
+from bitarray import bitarray, frozenbitarray, bits2bytes, _set_default_endian
from bitarray.test_bitarray import Util
-from bitarray.util import (zeros, rindex, strip, count_n,
+from bitarray.util import (zeros, make_endian, rindex, strip, count_n,
count_and, count_or, count_xor, subset,
ba2hex, hex2ba, ba2int, int2ba, huffman_code)
+if sys.version_info[0] == 3:
+ unicode = str
tests = []
@@ -25,38 +27,85 @@
class TestsZeros(unittest.TestCase):
- def test_init(self):
- a = zeros(0)
- self.assertEqual(a, bitarray(''))
- self.assertEqual(a.endian(), 'big')
- self.assertRaises(TypeError, zeros, 1.0)
- for n in range(100):
- a = zeros(n)
- self.assertEqual(a, bitarray(n * '0'))
- self.assertRaises(TypeError, zeros) # no argument
+ def test_1(self):
+ for default_endian in 'big', 'little':
+ _set_default_endian(default_endian)
+ a = zeros(0)
+ self.assertEqual(a, bitarray())
+ self.assertEqual(a.endian(), default_endian)
+
+ b = zeros(0, endian=None)
+ self.assertEqual(b.endian(), default_endian)
+
+ for n in range(100):
+ a = zeros(n)
+ self.assertEqual(a, bitarray(n * '0'))
+
+ for endian in 'big', 'little':
+ a = zeros(3, endian)
+ self.assertEqual(a, bitarray('000'))
+ self.assertEqual(a.endian(), endian)
- # wrong arguments
+ def test_wrong_args(self):
+ self.assertRaises(TypeError, zeros) # no argument
self.assertRaises(TypeError, zeros, '')
self.assertRaises(TypeError, zeros, bitarray())
self.assertRaises(TypeError, zeros, [])
+ self.assertRaises(TypeError, zeros, 1.0)
self.assertRaises(ValueError, zeros, -1)
self.assertRaises(TypeError, zeros, 0, 1) # endian not string
self.assertRaises(ValueError, zeros, 0, 'foo') # endian wrong string
- def test_endian(self):
- for endian in 'big', 'little':
- a = zeros(1, endian)
- self.assertEqual(a, bitarray('0'))
- self.assertEqual(a.endian(), endian)
- a = zeros(1, endian=endian)
- self.assertEqual(a, bitarray('0'))
- self.assertEqual(a.endian(), endian)
-
tests.append(TestsZeros)
# ---------------------------------------------------------------------------
+class TestsMakeEndian(unittest.TestCase, Util):
+
+ def test_simple(self):
+ a = bitarray('1110001', endian='big')
+ b = make_endian(a, 'big')
+ self.assertTrue(b is a)
+ c = make_endian(a, 'little')
+ self.assertTrue(c == a)
+ self.assertEqual(c.endian(), 'little')
+
+ # wrong arguments
+ self.assertRaises(TypeError, make_endian, '', 'big')
+ self.assertRaises(TypeError, make_endian, bitarray(), 1)
+ self.assertRaises(ValueError, make_endian, bitarray(), 'foo')
+
+ def test_empty(self):
+ a = bitarray(endian='little')
+ b = make_endian(a, 'big')
+ self.assertTrue(b == a)
+ self.assertEqual(len(b), 0)
+ self.assertEqual(b.endian(), 'big')
+
+ def test_from_frozen(self):
+ a = frozenbitarray('1101111', 'big')
+ b = make_endian(a, 'big')
+ self.assertTrue(b is a)
+ c = make_endian(a, 'little')
+ self.assertTrue(c == a)
+ self.assertEqual(c.endian(), 'little')
+
+ def test_random(self):
+ for a in self.randombitarrays():
+ aa = a.copy()
+ for endian in 'big', 'little':
+ b = make_endian(a, endian)
+ self.assertEqual(a, b)
+ self.assertEqual(b.endian(), endian)
+ if a.endian() == endian:
+ self.assertTrue(b is a)
+ self.assertEQUAL(a, aa)
+
+tests.append(TestsMakeEndian)
+
+# ---------------------------------------------------------------------------
+
class TestsHelpers(unittest.TestCase, Util):
def test_rindex(self):
@@ -122,13 +171,17 @@
self.assertEqual(rindex(a), a.index(1))
def test_strip1(self):
+ self.assertRaises(TypeError, strip, '0110')
self.assertRaises(TypeError, strip, bitarray(), 123)
self.assertRaises(ValueError, strip, bitarray(), 'up')
- for endian in 'big', 'little':
- a = bitarray('00010110000', endian)
- self.assertEQUAL(strip(a), bitarray('0001011', endian))
- self.assertEQUAL(strip(a, 'left'), bitarray('10110000', endian))
- self.assertEQUAL(strip(a, 'both'), bitarray('1011', endian))
+ 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')
+ self.assertEqual(strip(b, 'both'), bitarray('1011'))
for mode in 'left', 'right', 'both':
self.assertEqual(strip(bitarray('000'), mode), bitarray())
@@ -327,59 +380,79 @@
class TestsHexlify(unittest.TestCase, Util):
def test_ba2hex(self):
- self.assertEqual(ba2hex(bitarray(0, 'big')), b'')
- self.assertEqual(ba2hex(bitarray('1110', 'big')), b'e')
- self.assertEqual(ba2hex(bitarray('00000001', 'big')), b'01')
- self.assertEqual(ba2hex(bitarray('10000000', 'big')), b'80')
- self.assertEqual(ba2hex(frozenbitarray('11000111', 'big')), b'c7')
+ self.assertEqual(ba2hex(bitarray(0, 'big')), '')
+ self.assertEqual(ba2hex(bitarray('1110', 'big')), 'e')
+ self.assertEqual(ba2hex(bitarray('1110', 'little')), '7')
+ self.assertEqual(ba2hex(bitarray('00000001', 'big')), '01')
+ self.assertEqual(ba2hex(bitarray('10000000', 'big')), '80')
+ self.assertEqual(ba2hex(bitarray('00000001', 'little')), '08')
+ self.assertEqual(ba2hex(bitarray('10000000', 'little')), '10')
+ self.assertEqual(ba2hex(frozenbitarray('11000111', 'big')), 'c7')
# length not multiple of 4
self.assertRaises(ValueError, ba2hex, bitarray('10'))
- self.assertRaises(ValueError, ba2hex, bitarray(endian='little'))
self.assertRaises(TypeError, ba2hex, '101')
+ c = ba2hex(bitarray('1101', 'big'))
+ self.assertIsInstance(c, str)
+
for n in range(7):
a = bitarray(n * '1111', 'big')
b = a.copy()
- self.assertEqual(ba2hex(a), n * b'f')
+ self.assertEqual(ba2hex(a), n * 'f')
# ensure original object wasn't altered
self.assertEQUAL(a, b)
def test_hex2ba(self):
+ _set_default_endian('big')
self.assertEqual(hex2ba(''), bitarray())
- for c in 'e', 'E', b'e', b'E':
+ for c in 'e', 'E', b'e', b'E', unicode('e'), unicode('E'):
a = hex2ba(c)
self.assertEqual(a.to01(), '1110')
self.assertEqual(a.endian(), 'big')
self.assertEQUAL(hex2ba('01'), bitarray('00000001', 'big'))
+ self.assertEQUAL(hex2ba('08', 'little'),
+ bitarray('00000001', 'little'))
self.assertRaises(Exception, hex2ba, '01a7x89')
self.assertRaises(TypeError, hex2ba, 0)
def test_explicit(self):
- for h, bs in [(b'', ''),
- (b'0', '0000'),
- (b'a', '1010'),
- (b'f', '1111'),
- (b'1a', '00011010'),
- (b'2b', '00101011'),
- (b'4c1', '010011000001'),
- (b'a7d', '101001111101')]:
- a = bitarray(bs, 'big')
- self.assertEQUAL(hex2ba(h), a)
- self.assertEqual(ba2hex(a), h)
+ data = [ # little big little big
+ ('', '', ''),
+ ('0000', '0', '0'), ('0001', '8', '1'),
+ ('1000', '1', '8'), ('1001', '9', '9'),
+ ('0100', '2', '4'), ('0101', 'a', '5'),
+ ('1100', '3', 'c'), ('1101', 'b', 'd'),
+ ('0010', '4', '2'), ('0011', 'c', '3'),
+ ('1010', '5', 'a'), ('1011', 'd', 'b'),
+ ('0110', '6', '6'), ('0111', 'e', '7'),
+ ('1110', '7', 'e'), ('1111', 'f', 'f'),
+ ('10001100', '13', '8c'),
+ ('100011001110', '137', '8ce'),
+ ('1000110011101111', '137f', '8cef'),
+ ('10100111110111001001', '5eb39', 'a7dc9'),
+ ]
+ for bs, hex_le, hex_be in data:
+ a_be = bitarray(bs, 'big')
+ a_le = bitarray(bs, 'little')
+ self.assertEQUAL(hex2ba(hex_be, 'big'), a_be)
+ self.assertEQUAL(hex2ba(hex_le, 'little'), a_le)
+ self.assertEqual(ba2hex(a_be), hex_be)
+ self.assertEqual(ba2hex(a_le), hex_le)
def test_round_trip(self):
for i in range(100):
s = ''.join(choice(hexdigits) for _ in range(randint(0, 1000)))
- t = ba2hex(hex2ba(s))
- self.assertEqual(t.decode(), s.lower())
-
- def test_round_trip2(self):
- for a in self.randombitarrays():
- if len(a) % 4 or a.endian() != 'big':
- self.assertRaises(ValueError, ba2hex, a)
- continue
- b = hex2ba(ba2hex(a))
- self.assertEQUAL(b, a)
+ for default_endian in 'big', 'little':
+ _set_default_endian(default_endian)
+ a = hex2ba(s)
+ ida = id(a)
+ self.assertEqual(len(a) % 4, 0)
+ self.assertEqual(a.endian(), default_endian)
+ t = ba2hex(a)
+ self.assertEqual(t, s.lower())
+ b = hex2ba(t, default_endian)
+ self.assertEQUAL(a, b)
+ self.assertEqual(id(a), ida)
tests.append(TestsHexlify)
@@ -395,7 +468,7 @@
self.assertEqual(ba2int(frozenbitarray('11')), 3)
self.assertRaises(ValueError, ba2int, bitarray())
self.assertRaises(ValueError, ba2int, frozenbitarray())
- self.assertRaises(TypeError, ba2hex, '101')
+ self.assertRaises(TypeError, ba2int, '101')
a = bitarray('111')
b = a.copy()
self.assertEqual(ba2int(a), 7)
@@ -406,7 +479,7 @@
self.assertEqual(int2ba(0), bitarray('0'))
self.assertEqual(int2ba(1), bitarray('1'))
self.assertEqual(int2ba(5), bitarray('101'))
- self.assertEQUAL(int2ba(6), bitarray('110', 'big'))
+ self.assertEQUAL(int2ba(6, endian='big'), bitarray('110', 'big'))
self.assertEQUAL(int2ba(6, endian='little'),
bitarray('011', 'little'))
self.assertRaises(ValueError, int2ba, -1)
@@ -419,7 +492,8 @@
def test_int2ba_length(self):
self.assertRaises(TypeError, int2ba, 0, 1.0)
self.assertRaises(ValueError, int2ba, 0, 0)
- self.assertEqual(int2ba(5, length=6), bitarray('000101'))
+ self.assertEqual(int2ba(5, length=6, endian='big'),
+ bitarray('000101'))
self.assertRaises(OverflowError, int2ba, 3, 1)
for n in range(1, 100):
ab = int2ba(1, n, 'big')
@@ -445,6 +519,7 @@
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'),
@@ -452,6 +527,7 @@
ab = bitarray(sa, 'big')
al = bitarray(sa[::-1], 'little')
self.assertEQUAL(int2ba(i), ab)
+ self.assertEQUAL(int2ba(i, endian='big'), ab)
self.assertEQUAL(int2ba(i, endian='little'), al)
self.assertEqual(ba2int(ab), ba2int(al), i)
if i == 0 or i >= 512:
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/bitarray-1.2.1/bitarray/util.py
new/bitarray-1.3.0/bitarray/util.py
--- old/bitarray-1.2.1/bitarray/util.py 2020-01-06 21:09:39.000000000 +0100
+++ new/bitarray-1.3.0/bitarray/util.py 2020-07-06 05:39:41.000000000 +0200
@@ -1,4 +1,4 @@
-# Copyright (c) 2019, Ilan Schnell
+# Copyright (c) 2019 - 2020, Ilan Schnell
# bitarray is published under the PSF license.
#
# Author: Ilan Schnell
@@ -9,14 +9,14 @@
import heapq
import binascii
-from bitarray import bitarray, frozenbitarray, bits2bytes, _bitarray
+from bitarray import bitarray, bits2bytes, _bitarray, get_default_endian
from bitarray._util import (count_n, rindex,
count_and, count_or, count_xor, subset,
_set_babt)
-__all__ = ['zeros', 'rindex', 'strip', 'count_n',
+__all__ = ['zeros', 'make_endian', 'rindex', 'strip', 'count_n',
'count_and', 'count_or', 'count_xor', 'subset',
'ba2hex', 'hex2ba', 'ba2int', 'int2ba', 'huffman_code']
@@ -28,26 +28,56 @@
_is_py2 = bool(sys.version_info[0] == 2)
-def zeros(length, endian='big'):
- """zeros(length, /, endian='big') -> bitarray
+def zeros(length, endian=None):
+ """zeros(length, /, endian=None) -> bitarray
-Create a bitarray of length, with all values 0.
+Create a bitarray of length, with all values 0, and optional
+endianness, which may be 'big', 'lillte'.
"""
if not isinstance(length, (int, long) if _is_py2 else int):
raise TypeError("integer expected")
- a = bitarray(length, endian)
+ a = bitarray(length, endian or get_default_endian())
a.setall(0)
return a
+def make_endian(a, endian):
+ """make_endian(bitarray, endian, /) -> bitarray
+
+When the endianness of the given bitarray is different from `endian`,
+return a new bitarray, with endianness `endian` and the same elements
+as the original bitarray, i.e. even though the binary representation of the
+new bitarray will be different, the returned bitarray will equal the original
+one.
+Otherwise (endianness is already `endian`) the original bitarray is returned
+unchanged.
+"""
+ if not isinstance(a, _bitarray):
+ raise TypeError("bitarray expected")
+
+ if a.endian() == endian:
+ return a
+
+ b = bitarray(a, endian)
+ la = a.length()
+ if la == 0:
+ return b
+
+ b.bytereverse()
+ if la % 8:
+ p = 8 * (bits2bytes(la) - 1)
+ b[p:] = a[p:]
+ return b
+
+
def strip(a, mode='right'):
"""strip(bitarray, mode='right', /) -> bitarray
Strip zeros from left, right or both ends.
Allowed values for mode are the strings: `left`, `right`, `both`
"""
- if not isinstance(a, (bitarray, frozenbitarray)):
+ if not isinstance(a, _bitarray):
raise TypeError("bitarray expected")
if not isinstance(mode, str):
raise TypeError("string expected for mode")
@@ -71,46 +101,59 @@
return a[first:last + 1]
+# translate table which swaps the 4 highest with the 4 lowest bits"
+_swap_hilo_list = [16 * (i % 16) + (i // 16) for i in range(256)]
+if _is_py2:
+ _swap_hilo_bytes = b''.join(chr(i) for i in _swap_hilo_list)
+else:
+ _swap_hilo_bytes = bytes(_swap_hilo_list)
+
+
def ba2hex(a):
"""ba2hex(bitarray, /) -> hexstr
-Return a bytes object containing with hexadecimal representation of
+Return a string containing with hexadecimal representation of
the bitarray (which has to be multiple of 4 in length).
"""
- if not isinstance(a, (bitarray, frozenbitarray)):
+ if not isinstance(a, _bitarray):
raise TypeError("bitarray expected")
- if a.endian() != 'big':
- raise ValueError("big-endian bitarray expected")
+
la = a.length()
if la % 4:
raise ValueError("bitarray length not multiple of 4")
if la % 8:
# make sure we don't mutate the original argument
- a = a + bitarray(4, 'big')
- assert a.length() % 8 == 0
+ a = a + bitarray(4, a.endian())
- s = binascii.hexlify(a.tobytes())
+ b = a.tobytes()
+ if a.endian() == 'little':
+ b = b.translate(_swap_hilo_bytes)
+
+ s = binascii.hexlify(b)
if la % 8:
s = s[:-1]
- return s
+ return s if _is_py2 else s.decode()
-def hex2ba(s):
- """hex2ba(hexstr, /) -> bitarray
+def hex2ba(s, endian=None):
+ """hex2ba(hexstr, /, endian=None) -> bitarray
Bitarray of hexadecimal representation.
hexstr may contain any number of hex digits (upper or lower case).
"""
- if not isinstance(s, (str, bytes)):
- raise TypeError("string expected")
+ if not isinstance(s, (str, unicode if _is_py2 else bytes)):
+ raise TypeError("string expected, got: %r" % s)
ls = len(s)
if ls % 2:
s = s + ('0' if isinstance(s, str) else b'0')
- assert len(s) % 2 == 0
- a = bitarray(endian='big')
- a.frombytes(binascii.unhexlify(s))
+ a = bitarray(0, endian or get_default_endian())
+ b = binascii.unhexlify(s)
+ if a.endian() == 'little':
+ b = b.translate(_swap_hilo_bytes)
+ a.frombytes(b)
+
if ls % 2:
del a[-4:]
return a
@@ -122,7 +165,7 @@
Convert the given bitarray into an integer.
The bit-endianness of the bitarray is respected.
"""
- if not isinstance(a, (bitarray, frozenbitarray)):
+ if not isinstance(a, _bitarray):
raise TypeError("bitarray expected")
if not a:
raise ValueError("non-empty bitarray expected")
@@ -150,8 +193,8 @@
return int.from_bytes(b, byteorder=endian)
-def int2ba(i, length=None, endian='big'):
- """int2ba(int, /, length=None, endian='big') -> bitarray
+def int2ba(i, length=None, endian=None):
+ """int2ba(int, /, length=None, endian=None) -> bitarray
Convert the given integer into a bitarray (with given endianness,
and no leading (big-endian) / trailing (little-endian) zeros).
@@ -168,6 +211,8 @@
raise TypeError("integer expected for length")
if length <= 0:
raise ValueError("integer larger than 0 expected for length")
+ if endian is None:
+ endian = get_default_endian()
if not isinstance(endian, str):
raise TypeError("string expected for endian")
if endian not in ('big', 'little'):
@@ -175,7 +220,7 @@
if i == 0:
# there a special cases for 0 which we'd rather not deal with below
- return zeros(length or 1, endian=endian)
+ return zeros(length or 1, endian)
big_endian = bool(endian == 'big')
if _is_py2:
@@ -189,7 +234,7 @@
else: # py3
b = i.to_bytes(bits2bytes(i.bit_length()), byteorder=endian)
- a = bitarray(endian=endian)
+ a = bitarray(0, endian)
a.frombytes(b)
la = a.length()
if la == length:
@@ -215,8 +260,8 @@
return a
-def huffman_code(freq_map, endian='big'):
- """huffman_code(dict, /, endian='big') -> dict
+def huffman_code(freq_map, endian=None):
+ """huffman_code(dict, /, endian=None) -> dict
Given a frequency map, a dictionary mapping symbols to thier frequency,
calculate the Huffman code, i.e. a dict mapping those symbols to
@@ -263,7 +308,7 @@
result = {}
- def traverse(nd, prefix=bitarray(endian=endian)):
+ def traverse(nd, prefix=bitarray(0, endian or get_default_endian())):
if hasattr(nd, 'symbol'): # leaf
result[nd.symbol] = prefix
else: # parent, so traverse each of the children
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/bitarray-1.2.1/examples/huffman/huffman.py
new/bitarray-1.3.0/examples/huffman/huffman.py
--- old/bitarray-1.2.1/examples/huffman/huffman.py 2020-01-06
21:09:39.000000000 +0100
+++ new/bitarray-1.3.0/examples/huffman/huffman.py 2020-07-06
05:39:41.000000000 +0200
@@ -3,8 +3,8 @@
and codes.
Note:
- There is function for directly creating a Huffman code from a frequency
- map: bitarray.util.huffman_code()
+There is a function for directly creating a Huffman code from a frequency
+map: bitarray.util.huffman_code()
"""
from __future__ import print_function
from heapq import heappush, heappop
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/bitarray-1.2.1/setup.py new/bitarray-1.3.0/setup.py
--- old/bitarray-1.2.1/setup.py 2020-01-06 21:09:39.000000000 +0100
+++ new/bitarray-1.3.0/setup.py 2020-07-06 05:39:41.000000000 +0200
@@ -31,8 +31,6 @@
"Programming Language :: Python :: 2.6",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
- "Programming Language :: Python :: 3.3",
- "Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/bitarray-1.2.1/update_readme.py
new/bitarray-1.3.0/update_readme.py
--- old/bitarray-1.2.1/update_readme.py 2020-01-06 21:09:39.000000000 +0100
+++ new/bitarray-1.3.0/update_readme.py 2020-07-06 05:39:41.000000000 +0200
@@ -72,8 +72,8 @@
fo.write("Functions defined in the module:\n"
"--------------------------------\n\n")
write_doc('test')
- write_doc('bitdiff')
write_doc('bits2bytes')
+ write_doc('get_default_endian')
fo.write("Functions defined in bitarray.util:\n"
"-----------------------------------\n\n")
