Skip to content

Latest commit

 

History

History
856 lines (560 loc) · 30.6 KB

changelog.rst

File metadata and controls

856 lines (560 loc) · 30.6 KB
Raw

Change log

3.0.0 (2024-10-15):

  • see Bitarray 3 transition
  • remove Python 2.7 support
  • .decode() now returns iterator (equivalent to past .iterdecode())
  • .search() now returns iterator (equivalent to past .itersearch())
  • remove .iterdecode() and .itersearch()
  • remove util.rindex(), use .index(..., right=1) instead, deprecated since 2.9
  • remove util.make_endian(), use bitarray(..., endian=...) instead, deprecated since 2.9
  • remove hackish support for bitarray() handling unpickling, see detailed explaination in #207 - closes #206

2.9.3 (2024-10-10):

  • add official Python 3.13 support
  • update cibuildwheel to 2.21.3
  • minor simplifications
  • fix some typos

2.9.2 (2024-01-01):

  • optimize initialization from strings by not constantly resizing buffer
  • optimize util.hex2ba() and util.base2ba() by avoiding unnecessary copies
  • optimize util.base2ba() and util.ba2base() for n=16 (hexadecimal)

2.9.1 (2023-12-23):

  • avoid buffer being unnecessarily initialized with 0s in several functions of the bitarray.util module
  • fix .count() type hint in pyi-file
  • improve testing

2.9.0 (2023-12-17):

  • deprecate support for Python 2 - Python 2.7 support will be removed in bitarray version 3.0, see roadmap
  • bitarray(n) for integer initializer n will always return a bitarray of length n with all items initialized to 0, see #212
  • allow sub-bitarray in .count(), #212
  • add util.ones()
  • .find() and .index(): add keyword argument right for rightmost index
  • .itersearch(): add start and stop argument, and keyword argument right (for descending order - starting with rightmost match)
  • deprecate util.rindex() (will be removed in 3.0 release), use .index(..., right=True) instead
  • deprecate util.make_endian() (will be removed in 3.0 release), use bitarray(..., endian=...) instead

2.8.5 (2023-12-09):

  • speedup unaligned copies by always using word shifts (in combination with builtin byte swap 64 when available) when bit-endianness and machine byte-order are opposite
  • add HAVE_BUILTIN_BSWAP64 to header
  • avoid misaligned pointers when casting to (uint64_t *)
  • add tests

2.8.4 (2023-12-04):

2.8.3 (2023-11-11):

  • ensure readonly attribute is set correctly when creating new objects, see #211
  • optimize sparse bitarray compression for raw block type
  • improve hash functions in Bloom filter example

2.8.2 (2023-10-03):

  • update cibuildwheel to 2.16.1 in order to provide cp312 wheels on PyPI
  • improve error messages for masked assignment
  • simplify test collection
  • added pytest.ini to allow running pytest with no additional arguments, see #208
  • util.sc_encode(): avoid writing empty blocks at end of compressed stream, i.e. skip encoding when total population count is reached

2.8.1 (2023-08-06):

  • use reconstructor function for pickling, see #207
  • simplify implementation of .reverse()

2.8.0 (2023-07-22):

2.7.6 (2023-06-24):

  • remove caching hash value, fixes issue #201

2.7.5 (2023-06-10):

  • fix for pypy3.9-v7.3.11, #198 (fixes #188)
  • enable building wheels for PyPy

2.7.4 (2023-05-29):

  • register bitarray as abc.MutableSequence, see #196
  • cibuildwheel: update macOS version to 11 from unsupported 10.15, see actions/runner-images#5583
  • improve documentation regarding type when indexing single bitarray items, #192

2.7.3 (2023-02-20):

  • fix popcount64 name conflict on NetBSD, #189
  • even though PyPy is not actively supported, allow running tests for PyPy 3.7 and 3.8, see also #188
  • allow running python setup.py test
  • add official Python 3.12 support
  • simplify count functionality in util module
  • retire bitcount_lookup[256] table
  • improve util.count_n() error messages
  • avoid util module tests from being run more than once in each call to bitarray.test() when called multiple times in the same Python process, see #6e52e49a
  • improve testing

2.7.2 (2023-02-12):

  • speedup all count functionality by using __builtin_popcountll when available, see #187
  • add popcount64() to bitarray.h - we assume now that uint64_t is always available
  • improve testing

2.7.1 (2023-02-10):

  • optimize util.sc_encode()

2.7.0 (2023-02-05):

  • add util.sc_encode() and util.sc_decode() for compression of sparse bitarrays
  • add util.any_and()
  • add util.intervals()
  • move functionality of the following utility functions entirely to C: hex2ba(), base2ba(), deserialize(), vl_decode(), zeros()
  • improve error checking for unpickling
  • add distance metrics example: dice, hamming, jaccard, kulczynski1, rogerstanimoto, russellrao, sokalmichener, sokalsneath, yule
  • add example sparse bitarray implementations

2.6.2 (2023-01-01):

  • optimize richcompare() for opposite endianness
  • improve some docstrings add tests

2.6.1 (2022-12-18):

  • add documentation on shift operators, #181
  • fix typo in iterable initializer description, #179
  • optimize richcompare()

2.6.0 (2022-07-19):

  • add data descriptions: .nbytes, .padbits, .readonly
  • allow optional endian argument to be None when creating bitarrays
  • fix type annotation for canonical_decode(), #178
  • frozenbitarray's padbits are now guaranteed to be zero
  • add tests

2.5.1 (2022-05-10):

  • optimize .reverse(), see #177
  • allow negative (byte) indices in .bytereverse()

2.5.0 (2022-05-04):

  • add calculating of canonical Huffman codes util.canonical_huffman() and decoding thereof util.canonical_decode(), see #173
  • allow creating "Huffman codes" from frequency maps with a single symbol in util.huffman_code() and util.canonical_huffman(), see #172
  • allow bytes-like argument in .frombytes() and .pack() - previously, the arguments were limited to the bytes object, see #174
  • allow bytes-like arguments in util.deserialize()
  • add official pyodide support
  • add DEFLATE decompression example
  • optimize .bytereverse()
  • optimize delslice() for cases like del a[1:17:2] when a is large
  • fix examples/huffman/compress.py to handle files with 0 or 1 characters, see also #172
  • add skipIF decorator for skipping tests
  • add tests

2.4.1 (2022-03-29):

  • improve resize(), see #167
  • optimize copy_n() by avoiding loops, #171
  • .bytereverse() no longer sets unused pad bits to zero

2.4.0 (2022-03-01):

  • enable building wheels for multiple platforms and Python versions using pypa/cibuildwheel, see #165 and #170 (thanks Brian Thorne, @hardbyte)
  • use setuptools instead of distutils in setup.py, #168
  • add missing type hinting for .count() step argument

2.3.7 (2022-02-21):

  • add optional step argument to .count() method, see #162 and #163
  • add tests

2.3.6 (2022-02-07):

  • add optional value parameter to util.count_n(), see #154 and #161
  • determine machine endianness at build time when possible, by using the PY_LITTLE_ENDIAN macro, in order to optimize shift_r8()
  • add official Python 3.11 support

2.3.5 (2022-01-07):

  • Fixed bug for big-endian systems (such as IBM s390), see #159 and #160
  • Pass zip_safe=False to setup(), see #151

2.3.4 (2021-09-12):

  • Fix util.ba2int() for frozenbitarrays. A bug was introduced in 2.3.0 as .tobytes() no longer treats pad bits for read-only buffers as zero.
  • add tests

2.3.3 (2021-09-05):

  • improve some error messages
  • add tests

2.3.2 (2021-08-23):

  • fix slice assignment for shared buffer with offset case, see #3ba05687 and #73081e98
  • add tests (including internal debug mode tests for buffers_overlap())

2.3.1 (2021-08-20):

  • fix special shared buffer copy case, see #815c2a11
  • add and improve tests

2.3.0 (2021-08-15):

  • add optional buffer argument to bitarray() to import the buffer of another object, #141, #146, see also: buffer protocol
  • update .buffer_info() to include: a read-only flag, an imported buffer flag, and the number of buffer exports
  • add optional start and stop arguments to util.rindex()
  • add memory-mapped file example
  • ignore underscore (_) in string input, e.g. bitarray('1100_0111')
  • add missing type hinting for new .bytereverse() arguments
  • fix .extend() type annotations, #145
  • avoid .reverse() using temporary memory
  • make .unpack(), util.serialize(), util.vl_encode() and .__reduce__() more memory efficient
  • add and improve tests

2.2.5 (2021-08-07):

  • speedup find_bit() and find_last() using uint64 checking, this means a speedup for .find(), .index(), .search() and util.rindex()
  • add optional start and stop arguments to .bytereverse()
  • add example to illustrate how unaligned copying works internally
  • add documentation
  • add tests

2.2.4 (2021-07-29):

  • use shift operations to speedup all unaligned copy operations, #142
  • expose functionality to Python level only in debug mode for testing
  • add and improve tests

2.2.3 (2021-07-22):

  • speedup repeat(), #136
  • speedup shift operations, #139
  • optimize slice assignment with negative step, e.g.: a[::-1] = 1
  • add tests

2.2.2 (2021-07-16):

  • speedup slice assignment, see #132 and #135
  • speedup bitwise operations, #133
  • optimize getbit() and setbit() in bitarray.h
  • fix TypeError messages when bitarray or int (0, 1) are expected (bool is a subclass of int)
  • add and improve tests

2.2.1 (2021-07-06):

  • improve documentation
  • speedup vl_encode()
  • bitarray.h: make getbit() always an (inline) function
  • add assertions in C code

2.2.0 (2021-07-03):

2.1.3 (2021-06-15):

  • Fix building with MSVC / Bullseye, #129

2.1.2 (2021-06-13):

  • support type hinting for all Python 3 versions (that bitarray supports, 3.5 and higher currently), fixed #128
  • add explicit endianness to two tests, fixes #127

2.1.1 (2021-06-11):

  • add type hinting (see PEP 484, 561) using stub (.pyi) files
  • add tests

2.1.0 (2021-05-05):

  • add .find() method, see #122
  • .find(), .index(), .search() and .itersearch() now all except both (sub-) bitarray as well as bool items to be searched for
  • improve encode/decode error messages
  • add lexicographical permutations example
  • add tests

2.0.1 (2021-04-19):

  • update documentation
  • improve some error messages

2.0.0 (2021-04-14):

  • require more specific objects, int (0 or 1) or bool, see #119
  • items are always returned as int 0 or 1, #119
  • remove .length() method (deprecated since 1.5.1 - use len())
  • in .unpack() the one argument now defaults to 0x01 (was 0xff)
  • .tolist() now always returns a list of integers (0 or 1)
  • fix frozenbitarray hash function, see #121
  • fix frozenbitarray being mutable by <<= and >>=
  • support sequence protocol in .extend() (and bitarray creation)
  • improve OverflowError messages from util.int2ba()
  • add hexadecimal example

1.9.2 (2021-04-10):

  • update pythoncapi_compat: Fix support with PyPy 3.7, #120
  • update readme

1.9.1 (2021-04-05):

  • switch documentation from markdown to reStructuredText
  • add tests

1.9.0 (2021-04-03):

  • add shift operations (<<, >>, <<=, >>=), see #117
  • add bitarray.util.ba2base() and bitarray.util.base2ba(), see last paragraph in Bitarray representations
  • documentation and tests

1.8.2 (2021-03-31):

  • fix crash caused by unsupported types in binary operations, #116
  • speedup initializing or extending a bitarray from another with different bit-endianness
  • add formatting options to bitarray.util.pprint()
  • add documentation on bitarray representations
  • add and improve tests (all 291 tests run in less than half a second on a modern machine)

1.8.1 (2021-03-25):

  • moved implementation of and hex2ba() and ba2hex() to C-level
  • add bitarray.util.parity()

1.8.0 (2021-03-21):

  • add bitarray.util.serialize() and bitarray.util.deserialize()
  • allow whitespace (ignore space and \n\r\t\v) in input strings, e.g. bitarray('01 11') or a += '10 00'
  • add bitarray.util.pprint()
  • When initializing a bitarray from another with different bit-endianness, e.g. a = bitarray('110', 'little') and b = bitarray(a, 'big'), the buffer used to be simply copied, with consequence that a == b would result in False. This is fixed now, that is a == b will always evaluate to True.
  • add test for loading existing pickle file (created using bitarray 1.5.0)
  • add example showing how to jsonize bitarrays
  • add tests

1.7.1 (2021-03-12):

  • fix issue #114, raise TypeError when incorrect index is used during assignment, e.g. a[1.5] = 1
  • raise TypeError (not IndexError) when assigning slice to incorrect type, e.g. a[1:4] = 1.2
  • improve some docstrings and tests

1.7.0 (2021-02-27):

  • add bitarray.util.urandom()
  • raise TypeError when trying to extend bitarrays from bytes on Python 3, i.e. bitarray(b'011') and .extend(b'110'). (Deprecated since 1.4.1)

1.6.3 (2021-01-20):

  • add missing .h files to sdist tarball, #113

1.6.2 (2021-01-20):

  • use Py_SET_TYPE() and Py_SET_SIZE() for Python 3.10, #109
  • add official Python 3.10 support
  • fix slice assignment to same object, e.g. a[2::] = a or a[::-1] = a, #112
  • add bitarray.h, #110

1.6.1 (2020-11-05):

  • use PyType_Ready for all types: bitarray, bitarrayiterator, decodeiterator, decodetree, searchiterator

1.6.0 (2020-10-17):

  • add decodetree object, for speeding up consecutive calls to .decode() and .iterdecode(), in particular when dealing with large prefix codes, see #103
  • add optional parameter to .tolist() which changes the items in the returned list to integers (0 or 1), as opposed to Booleans
  • remove deprecated bitdiff(), which has been deprecated since version 1.2.0, use bitarray.util.count_xor() instead
  • drop Python 2.6 support
  • update license file, #104

1.5.3 (2020-08-24):

  • add optional index parameter to .index() to invert single bit
  • fix sys.getsizeof(bitarray) by adding .__sizeof__(), see issue #100

1.5.2 (2020-08-16):

  • add PyType_Ready usage, issue #66
  • speedup search() for bitarrays with length 1 in sparse bitarrays, see issue #67
  • add tests

1.5.1 (2020-08-10):

  • support signed integers in util.ba2int() and util.int2ba(), see issue #85
  • deprecate .length() in favor of len()

1.5.0 (2020-08-05):

  • Use Py_ssize_t for bitarray index. This means that on 32bit systems, the maximum number of elements in a bitarray is 2 GBits. We used to have a special 64bit index type for all architectures, but this prevented us from using Python's sequence, mapping and number methods, and made those method lookups slow.
  • speedup slice operations when step size = 1 (if alignment allows copying whole bytes)
  • Require equal endianness for operations: &, |, ^, &=, |=, ^=. This should have always been the case but was overlooked in the past.
  • raise TypeError when trying to create bitarray from boolean
  • This will be last release to still support Python 2.6 (which was retired in 2013). We do NOT plan to stop support for Python 2.7 anytime soon.

1.4.2 (2020-07-15):

  • add more tests
  • C-level:
    • simplify pack/unpack code
    • fix memory leak in ~ operation (bitarray_cpinvert)

1.4.1 (2020-07-14):

  • add official Python 3.9 support
  • improve many docstrings
  • add DeprecationWarning for bitdiff()
  • add DeprecationWarning when trying to extend bitarrays from bytes on Python 3 (bitarray(b'011') and .extend(b'110'))
  • C-level:
    • Rewrote .fromfile() and .tofile() implementation, such that now the same code is used for Python 2 and 3. The new implementation is more memory efficient on Python 3.
    • use memcmp() in richcompare() to shortcut EQ/NE, when comparing two very large bitarrays for equality the speedup can easily be 100x
    • simplify how unpacking is handled
  • add more tests

1.4.0 (2020-07-11):

  • add .clear() method (Python 3.3 added this method to lists)
  • avoid over-allocation when bitarray objects are initially created
  • raise BufferError when resizing bitarrays which is exporting buffers
  • add example to study the resize() function
  • improve some error messages
  • add more tests
  • raise NotImplementedError with (useful message) when trying to call the .fromstring() or .tostring() methods, which have been removed in the last release

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
  • make tests for bitarray.util required (instead of warning when 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 arguments 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

1.0.1 (2019-07-19):

  • fix readme to pass twine check

1.0.0 (2019-07-15):

  • fix bitarrays beings created from unicode in Python 2
  • use PyBytes_* in C code, treating the Py3k function names as default, which also removes all redefinitions of PyString_*
  • handle negative arguments of .index() method consistently with how they are treated for lists
  • add a few more comments to the C code
  • move imports outside tests: pickle, io, etc.
  • drop Python 2.5 support

0.9.3 (2019-05-20):

  • refactor resize() - only shrink allocated memory if new size falls lower than half the allocated size
  • improve error message when trying to initialize from float or complex

0.9.2 (2019-04-29):

  • fix to compile on Windows with VS 2015, issue #72

0.9.1 (2019-04-28):

  • fix types to actually be types, #29
  • check for ambiguous prefix codes when building binary tree for decoding
  • remove Python level methods: encode, decode, iterdecode (in favor of having these implemented on the C-level along with check_codedict)
  • fix self tests for Python 2.5 and 2.6
  • move all Huffman code related example code into examples/huffman
  • add code to generate graphviz .dot file of Huffman tree to examples

0.9.0 (2019-04-22):

  • more efficient decode and iterdecode by using C-level binary tree instead of a python one, #54
  • added buffer protocol support for Python 3, #55
  • fixed invalid pointer exceptions in pypy, #47
  • made all examples Py3k compatible
  • add gene sequence example
  • add official Python 3.7 support
  • drop Python 2.4, 3.1 and 3.2 support

0.8.3 (2018-07-06):

  • add exception to setup.py when README.rst cannot be opened

0.8.2 (2018-05-30):

  • add official Python 3.6 support (although it was already working)
  • fix description of fill(), #52
  • handle extending self correctly, #28
  • copy_n(): fast copy with memmove() fixed, #43
  • minor clarity/wording changes to README, #23

0.8.1 (2013-03-30):

  • fix issue #10, i.e. int(bitarray()) segfault
  • added tests for using a bitarray object as an argument to functions like int, long (on Python 2), float, list, tuple, dict

0.8.0 (2012-04-04):

  • add Python 2.4 support
  • add (module level) function bitdiff for calculating the difference between two bitarrays

0.7.0 (2012-02-15):

  • add iterdecode method (C level), which returns an iterator but is otherwise like the decode method
  • improve memory efficiency and speed of pickling large bitarray objects

0.6.0 (2012-02-06):

  • add buffer protocol to bitarray objects (Python 2.7 only)
  • allow slice assignment to 0 or 1, e.g. a[::3] = 0 (in addition to booleans)
  • moved implementation of itersearch method to C level (Lluis Pamies)
  • search, itersearch now only except bitarray objects, whereas __contains__ excepts either booleans or bitarrays
  • use a priority queue for Huffman tree example (thanks to Ushma Bhatt)
  • improve documentation

0.5.2 (2012-02-02):

  • fixed MSVC compile error on Python 3 (thanks to Chris Gohlke)
  • add missing start and stop optional parameters to index() method
  • add examples/compress.py

0.5.1 (2012-01-31):

  • update documentation to use tobytes and frombytes, rather than tostring and fromstring (which are now deprecated)
  • simplified how tests are run

0.5.0 (2012-01-23):

  • added itersearch method
  • added Bloom filter example
  • minor fixes in docstrings, added more tests

0.4.0 (2011-12-29):

  • porting to Python 3.x (Roland Puntaier)
  • introduced .tobytes() and .frombytes() (.tostring() and .fromstring() are now deprecated)
  • updated development status
  • added sieve prime number example
  • moved project to github: https://github.com/ilanschnell/bitarray

0.3.5 (2009-04-06):

  • fixed reference counts bugs
  • added possibility to slice assign to True or False, e.g. a[::3] = True will set every third element to True

0.3.4 (2009-01-15):

  • Made C code less ambiguous, such that the package compiles on Visual Studio, with all tests passing.

0.3.3 (2008-12-14):

  • Made changes to the C code to allow compilation with more compilers. Compiles on Visual Studio, although there are still a few tests failing.

0.3.2 (2008-10-19):

  • Added sequential search method.
  • The special method __contains__ now also takes advantage of the sequential search.

0.3.1 (2008-10-12):

  • Simplified state information for pickling. Argument for count is now optional, defaults to True. Fixed typos.

0.3.0 (2008-09-30):

  • Fixed a severe bug for 64-bit machines. Implemented all methods in C, improved tests.
  • Removed deprecated methods .from01() and .fromlist().

0.2.5 (2008-09-23):

  • Added section in README about prefix codes. Implemented _multiply method for faster __mul__ and __imul__. Fixed some typos.

0.2.4 (2008-09-22):

  • Implemented encode and decode method (in C) for variable-length prefix codes.
  • Added more examples, wrote README for the examples.
  • Added more tests, fixed some typos.

0.2.3 (2008-09-16):

  • Fixed a memory leak, implemented a number of methods in C. These include __getitem__, __setitem__, __delitem__, pop, remove, insert. The methods implemented on the Python level is very limit now.
  • Implemented bitwise operations.

0.2.2 (2008-09-09):

  • Rewrote parts of the README
  • Implemented memory efficient algorithm for the reverse method
  • Fixed typos, added a few tests, more C refactoring.

0.2.1 (2008-09-07):

  • Improved tests, in particular added checking for memory leaks.
  • Refactored many things on the C level.
  • Implemented a few more methods.

0.2.0 (2008-09-02):

  • Added bit-endianness property to the bitarray object
  • Added the examples to the release package.

0.1.0 (2008-08-17):

May 2008:

Wrote the initial code, and put it on my personal web-site: http://ilan.schnell-web.net/prog/