Up to [cvs.NetBSD.org] / pkgsrc / devel / py-bitarray
Request diff between arbitrary revisions
Keyword substitution: kv
Default branch: MAIN
py-bitarray: updated to 3.11.0 3.11.0 * add run-length codec: `util.rl_encode()` and `util.rl_decode()` * add `util.sc_stat()` * add [Comparison of bitarray codecs](codecs.rst) documentation * optimize sparse block selection for trailing zeros * preserve bitarrays when buffer reallocation fails * consistent input validation for large `util.sum_indices()` inputs * improve sparse-compression and debug-mode tests, including new tests for slice adjustment `adjust_slice()` * move private `sysinfo()` and `ssqi()` out of the top-level namespace
py-bitarray: updated to 3.8.2 3.8.2: * clarity/wording improvements throughout project * add `new_allocation()` to simplify `resize()` * drop Python 3.6 support
py-bitarray: updated to 3.8.1 3.8.1 * fixed critial findings in C Extension Analysis Report * add tests, in particular `devel/test_capi.py`
py-bitarray: updated to 3.8.0 3.8.0 * add experimental support for free-threaded builds (GIL disabled) * remove `_set_default_endian()` * add `.__bytes__()`
py-bitarray: updated to 3.3.2 3.3.2: * fix off-by-one-error in check for length of count argument in `util.canonical_decode()` * simplify `util.int2ba()` * add tests * add [masked indexing example](../examples/masked.py) * add [tricks example](../examples/tricks.py)
py-bitarray: updated to 3.3.1 3.3.1 * remove `License` classifier in favor of a SPDX license expression * reorganize and cleanup many tests 3.3.0: * add optional `group` and `sep` arguments' to `.to01()` as well as `util.ba2hex()` and `util.ba2base()` * ignore whitespace in `util.base2ba()` and `util.hex2ba()` * check for embedded nul characters when extending (and initializing) bitarray from string * improve testing * add [double precision floating point number example](../examples/double.py)
py-bitarray: updated to 3.0.0 3.0.0 * see [Bitarray 3 transition](bitarray3.rst) * 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
lang/python and a number of python packages: re-do atomic64.mk issue. Evidently, python 3.13 brought in the need to support 64-bit atomics. This means that python extension packages built with C needs to use mk/atomic64.mk to make -latomic available on the required 32-bit ports. Sadly, there is no reliable way to detect in the .mk files whether the package is using C (or C++), so this change adds an unconditional include of mk/atomic64.mk when the python version is equal to or larger than 3.13 for packages using egg.mk or wheel.mk. This undoes the individual package Makefile inclusions of mk/atomic64.mk that I've added over the last few days.
devel/py-bitarray: use atomic64.mk to fix build on macppc w/python3.13.
py-*: remove unused tool dependency py-setuptools includes the py-wheel functionality nowadays
py-bitarray: updated to 2.9.3 2.9.3: * add official Python 3.13 support * update cibuildwheel to 2.21.3 * minor simplifications * fix some typos
py-bitarray: updated to 2.9.2 2024-01-01 2.9.2: ------------------- * 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) 2023-12-23 2.9.1: ------------------- * avoid buffer being unnecessarily initialized with 0s in several functions of the `bitarray.util` module * fix `.count()` type hint in pyi-file * improve testing 2023-12-17 2.9.0: ------------------- * deprecate support for Python 2 - Python 2.7 support will be removed in bitarray version 3.0, * `bitarray(n)` for integer initializer `n` will always return a bitarray of length `n` with all items initialized to `0` * allow sub-bitarray in `.count()` * 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
py-bitarray: update to 2.8.5.
2023-12-09 2.8.5:
-------------------
* 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
py-bitarray: updated to 2.8.4 2.8.4 (2023-12-04): simplify copy_n() (remove special cases) add word shift example C program, and simplify shift_r8() improve documentation and testing add roadmap
py-bitarray: updated to 2.8.3 2.8.3: * ensure readonly attribute is set correctly when creating new objects, * optimize sparse bitarray compression for raw block type * improve hash functions in Bloom filter example
py-bitarray: updated to 2.8.2 2.8.2: * 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, * `util.sc_encode()`: avoid writing empty blocks at end of compressed stream, ie. skip encoding when total population count is reached
py-bitarray: updated to 2.8.1 2.8.1: * use reconstructor function for pickling * simplify implementation of `.reverse()`
py-bitarray: updated to 2.8.0 2.8.0: * allow [integer sequence indexing](indexing.rst) by list of indices * add [masked indexing](indexing.rst) by bitarray masks * improve `.bytereverse()` docstring
py-bitarray: updated to 2.7.6 2.7.6 remove caching hash value
py-bitarray: updated to 2.7.5 2.7.5: * fix for pypy3.9-v7.3.11 * enable building wheels for PyPy
py-bitarray: updated to 2.7.4 2.7.4: * register `bitarray` as `abc.MutableSequence` * cibuildwheel: update macOS version to 11 from unsupported 10.15, see https://github.com/actions/runner-images/issues/5583 * improve documentation regarding type when indexing single bitarray items
py-bitarray: updated to 2.7.3 2.7.3: * fix popcount64 name conflict on NetBSD * even though PyPy is not actively supported, allow running tests for PyPy 3.7 and 3.8 * 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 * improve testing
py-bitarray: fix previous, and make 'test' target work. All tests pass. Bump PKGREVISION.
py-bitarray: fix build on NetBSD This defines its own popcount. Reported upstream at https://github.com/ilanschnell/bitarray/issues/189
py-bitarray: updated to 2.7.2 2.7.2: * speedup all count functionality by using `__builtin_popcountll` when available * add `popcount64()` to `bitarray.h` - we assume now that `uint64_t` is always available * improve testing 2.7.1: * optimize `util.sc_encode()`
py-bitarray: updated to 2.7.0 2.7.0: ------------------- * add `util.sc_encode()` and `util.sc_decode()` for [compression of sparse bitarrays](sparse_compression.rst) * 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](../examples/distance.py) example: dice, hamming, jaccard, kulczynski1, rogerstanimoto, russellrao, sokalmichener, sokalsneath, yule * add example [sparse bitarray](../examples/sparse) implementations
py-bitarray: updated to 2.6.2 2.6.2: * optimize `richcompare()` for opposite endianness * improve some docstrings add tests
py-bitarray: updated to 2.6.1 2.6.1: * add documentation on shift operators * fix typo in iterable initializer description * optimize `richcompare()`
py-bitarray: updated to 2.6.0 2.6.0: * add data descriptions: `.nbytes`, `.padbits`, `.readonly` * allow optional `endian` argument to be `None` when creating bitarrays * fix type annotation for `canonical_decode()` * frozenbitarray's padbits are now guaranteed to be zero * add tests
py-bitarray: updated to 2.5.1 2.5.1: * optimize `.reverse()` * allow negative (byte) indices in `.bytereverse()`
py-bitarray: updated to 2.5.0 2.5.0: * add calculating of canonical Huffman codes `util.canonical_huffman()` and decoding thereof `util.canonical_decode()` * allow creating "Huffman codes" from frequency maps with a single symbol in `util.huffman_code()` and `util.canonical_huffman()` * allow bytes-like argument in `.frombytes()` and `.pack()` - previously, the arguments were limited to the `bytes` object * allow bytes-like arguments in `util.deserialize()` * add official [pyodide](https://pyodide.org/) support * add [DEFLATE decompression](../examples/puff/) 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, * add `skipIF` decorator for skipping tests * add tests
py-bitarray: updated to 2.4.1 2.4.1: * improve `resize()` * optimize `copy_n()` by avoiding loops * `.bytereverse()` no longer sets unused bits to zero 2.4.0: * enable building wheels for multiple platforms and Python versions using pypa/cibuildwheel * use setuptools instead of distutils in `setup.py` * add missing type hinting for `.count()` step argument
py-bitarray: updated to 2.3.7 2.3.7: * add optional step argument to `.count()` method * add tests
py-bitarray: updated to 2.3.6 2.3.6: * add optional value parameter to `util.count_n()` * 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
py-bitarray: updated to 2.3.5 2.3.5: * Fixed bug for big-endian systems (such as IBM s390) * Pass `zip_safe=False` to `setup()`
py-bitarray: convert to egg.mk
py-bitarray: updated to 2.3.4 2021-09-12 2.3.4: ------------------- * 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 2021-09-05 2.3.3: ------------------- * improve some error messages * add tests 2021-08-23 2.3.2: ------------------- * fix slice assignment for shared buffer with offset case * add tests (including internal debug mode tests for `buffers_overlap()`) 2021-08-20 2.3.1: ------------------- * fix special shared buffer copy case * add and improve tests
py-bitarray: updated to 2.3.0
2.3.0:
* add optional `buffer` argument to `bitarray()` to import the buffer of
another object
* 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](../examples/mmapped-file.py) example
* ignore underscore (`_`) in string input, e.g. `bitarray('1100_0111')`
* add missing type hinting for new `.bytereverse()` arguments
* fix `.extend()` type annotations
* avoid `.reverse()` using temporary memory
* make `.unpack()`, `util.serialize()`, `util.vl_encode()`
and `.__reduce__()` more memory efficient
* add and improve tests
2.2.5:
* 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](../examples/copy_n.py) works internally
* add documentation
* add tests
py-bitarray: updated to 2.2.4 2.2.4: * use shift operations to speedup all unaligned copy operations * expose functionality to Python level only in debug mode for testing * add and improve tests 2.2.3: * speedup `repeat()` * speedup shift operations * optimize slice assignment with negative step, e.g.: `a[::-1] = 1` * add tests 2.2.2: * speedup slice assignment * speedup bitwise operations * 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
py-bitarray: updated to 2.2.1 2.2.1: * improve documentation * speedup `vl_encode()` * `bitarray.h`: make `getbit()` always an (inline) function * add assertions in C code
py-bitarray: updated to 2.2.0 2.2.0: * add `bitarray.util.vl_encode()` and `bitarray.util.vl_decode()` which uses a [variable length bitarray format](variable_length.rst)
py-bitarray: updated to 2.1.2 2.1.2: * support type hinting for all Python 3 versions (that bitarray supports, 3.5 and higher currently) * add explicit endianness to two tests
py-bitarray: updated to 2.1.1 2.1.1: * add type hinting (see PEP 484, 561) using stub (`.pyi`) files * add tests
py-bitarray: updated to 2.1.0 2021-05-05 2.1.0: ------------------- * add `.find()` method * `.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](../examples/lexico.py) * add tests 2021-04-19 2.0.1: ------------------- * update documentation * improve some error messages 2021-04-14 2.0.0: ------------------- * require more specific objects, int (0 or 1) or bool * items are always returned as int 0 or 1 * 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 * fix frozenbitarray being mutable by `<<=` and `>>=` * support sequence protocol in `.extend()` (and bitarray creation) * improve OverflowError messages from `util.int2ba()` * add [hexadecimal example](../examples/hexadecimal.py) 2021-04-10 1.9.2: ------------------- * update pythoncapi_compat: Fix support with PyPy 3.7 * update readme 2021-04-05 1.9.1: ------------------- * switch documentation from markdown to reStructuredText * add tests
py-bitarray: updated to 1.9.0
2021-04-03 1.9.0:
-------------------
* add shift operations (`<<`, `>>`, `<<=`, `>>=`)
* add `bitarray.util.ba2base()` and `bitarray.util.base2ba()`,
see last paragraph in [Bitarray representations](examples/represent.rst)
* documentation and tests
2021-03-31 1.8.2:
-------------------
* fix crash caused by unsupported types in binary operations
* speedup initializing or extending a bitarray from another with different
bit endianness
* add formatting options to `bitarray.util.pprint()`
* add documentation on [bitarray representations](examples/represent.rst)
* add and improve tests (all 291 tests run in less than half a second on
a modern machine)
2021-03-25 1.8.1:
-------------------
* moved implementation of and `hex2ba()` and `ba2hex()` to C-level
py-bitarray: updated to 1.8.0
1.8.0:
* 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 example showing how to jsonize bitarrays
* add tests
py-bitarray: updated to 1.7.1
2021-03-12 1.7.1:
-------------------
* 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
2021-02-27 1.7.0:
-------------------
* add `bitarray.util.urandom()`
* raise TypeError when trying to extend bitarrays from bytes on Python 3,
ie. `bitarray(b'011')` and `.extend(b'110')`. (Deprecated since 1.4.1)
py-bitarray: added version 1.6.3 This module provides an object type which efficiently represents an array of booleans. Bitarrays are sequence types and behave very much like usual lists. Eight bits are represented by one byte in a contiguous block of memory. The user can select between two representations: little-endian and big-endian. All of the functionality is implemented in C. Methods for accessing the machine representation are provided. This can be useful when bit level access to binary files is required, such as portable bitmap image files (.pbm). Also, when dealing with compressed data which uses variable bit length encoding, you may find this module useful.