bitarray 3.7.0__tar.gz → 3.7.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitarray
-Version: 3.7.0
+Version: 3.7.2
 Summary: efficient arrays of booleans -- C extension
 Home-page: https://github.com/ilanschnell/bitarray
 Author: Ilan Schnell
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Utilities
 License-File: LICENSE
 Dynamic: author
@@ -76,7 +77,7 @@ Key features
 Installation
 ------------
 
-Python wheels are are available on PyPI for all mayor platforms and Python
+Python wheels are are available on PyPI for all major platforms and Python
 versions.  Which means you can simply:
 
 .. code-block:: shell-session
@@ -89,7 +90,7 @@ Once you have installed the package, you may want to test it:
 
     $ python -c 'import bitarray; bitarray.test()'
     bitarray is installed in: /Users/ilan/bitarray/bitarray
-    bitarray version: 3.7.0
+    bitarray version: 3.7.2
     sys.version: 3.13.5 (main, Jun 16 2025) [Clang 18.1.8]
     sys.prefix: /Users/ilan/miniforge
     pointer size: 64 bit
@@ -104,7 +105,7 @@ Once you have installed the package, you may want to test it:
     .........................................................................
     ................................................................
     ----------------------------------------------------------------------
-    Ran 599 tests in 0.166s
+    Ran 597 tests in 0.165s
 
     OK
 
@@ -256,85 +257,15 @@ shift (``>>``) always shifts towards higher indices.
 Bit-endianness
 --------------
 
-Unless explicitly converting to machine representation, i.e. initializing
-the buffer directly, using ``.tobytes()``, ``.frombytes()``, ``.tofile()``
-or ``.fromfile()``, as well as using ``memoryview()``, the bit-endianness
-will have no effect on any computation, and one can skip this section.
-
-Since bitarrays allows addressing individual bits, where the machine
-represents 8 bits in one byte, there are two obvious choices for this
-mapping: little-endian and big-endian.
-
-When dealing with the machine representation of bitarray objects, it is
-recommended to always explicitly specify the endianness.
-
-By default, bitarrays use big-endian representation:
-
-.. code-block:: python
-
-    >>> a = bitarray(b'A')
-    >>> a.endian
-    'big'
-    >>> a
-    bitarray('01000001')
-    >>> a[6] = 1
-    >>> a.tobytes()
-    b'C'
-
-Big-endian means that the most-significant bit comes first.
-Here, ``a[0]`` is the lowest address (index) and most significant bit,
-and ``a[7]`` is the highest address and least significant bit.
-
-When creating a new bitarray object, the endianness can always be
-specified explicitly:
-
-.. code-block:: python
-
-    >>> a = bitarray(b'A', endian='little')
-    >>> a
-    bitarray('10000010')
-    >>> a.endian
-    'little'
-
-Here, the low-bit comes first because little-endian means that increasing
-numeric significance corresponds to an increasing address.
-So ``a[0]`` is the lowest address and least significant bit,
-and ``a[7]`` is the highest address and most significant bit.
-
-The bit-endianness is a property of the bitarray object.
-The endianness cannot be changed once a bitarray object has been created.
-When comparing bitarray objects, the endianness (and hence the machine
-representation) is irrelevant; what matters is the mapping from indices
-to bits:
-
-.. code-block:: python
-
-    >>> bitarray('11001', endian='big') == bitarray('11001', endian='little')
-    True
-    >>> a = bitarray(b'\x01', endian='little')
-    >>> b = bitarray(b'\x80', endian='big')
-    >>> a == b
-    True
-    >>> a.tobytes() == b.tobytes()
-    False
-
-Bitwise operations (``|``, ``^``, ``&=``, ``|=``, ``^=``, ``~``) are
-implemented efficiently using the corresponding byte operations in C, i.e. the
-operators act on the machine representation of the bitarray objects.
-Therefore, it is not possible to perform bitwise operators on bitarrays
-with different endianness.
-
-As mentioned above, the endianness can not be changed once an object is
-created.  However, you can create a new bitarray with different endianness:
-
-.. code-block:: python
-
-    >>> a = bitarray('111000', endian='little')
-    >>> b = bitarray(a, endian='big')
-    >>> b
-    bitarray('111000')
-    >>> a == b
-    True
+For many purposes the bit-endianness is not of any relevance to the end user
+and can be regarded as an implementation detail of bitarray objects.
+However, there are use cases when the bit-endianness becomes important.
+These use cases involve explicitly reading and writing the bitarray buffer
+using ``.tobytes()``, ``.frombytes()``, ``.tofile()`` or ``.fromfile()``,
+importing and exporting buffers.  Also, a number of utility functions
+in ``bitarray.util`` will return different results depending on
+bit-endianness, such as ``ba2hex()`` or ``ba2int``.
+To better understand this topic, please read `bit-endianness <https://github.com/ilanschnell/bitarray/blob/master/doc/endianness.rst>`__.
 
 
 Buffer protocol
@@ -421,7 +352,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.7.0 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.7.2 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
 
 In the following, ``item`` and ``value`` are usually a single bit -
 an integer 0 or 1.
@@ -799,6 +730,11 @@ This sub-module was added in version 1.2.
    Also, ``a`` may be any object that exposes a writable buffer.
    Nothing about this function is specific to bitarray objects.
 
+   We should mention that Python's ``array.array`` object has a
+   method ``.byteswap()`` with similar functionality.  However, unlike
+   bitarray's ``util.byteswap()`` function, this method is limited to
+   swapping 2, 4, or 8 consecutive bytes.
+
    New in version 3.4
 
 
@@ -874,6 +810,10 @@ This sub-module was added in version 1.2.
    When ``odd=True``, only odd prime numbers are represented in the resulting
    bitarray ``a``, and ``a[i]`` corresponds to ``2*i+1`` being prime or not.
 
+   Apart from working with prime numbers, this function is useful for
+   testing, as it provides a simple way to create a well-defined bitarray
+   of any length.
+
    New in version 3.7
 
 
@@ -936,11 +876,7 @@ This sub-module was added in version 1.2.
    set to one.  Mathematically equivalent to setting (in a bitarray of
    length ``n``) all bits at indices ``random.sample(range(n), k)`` to one.
    The random bitarrays are reproducible when giving Python's ``random.seed()``
-   with a specific seed value.
-
-   This function requires Python 3.9 or higher, as it depends on the standard
-   library function ``random.randbytes()``.  Raises ``NotImplementedError``
-   when Python version is too low.
+   a specific seed value.
 
    New in version 3.6
 

{bitarray-3.7.0 → bitarray-3.7.2}/README.rst

@@ -44,7 +44,7 @@ Key features
 Installation
 ------------
 
-Python wheels are are available on PyPI for all mayor platforms and Python
+Python wheels are are available on PyPI for all major platforms and Python
 versions.  Which means you can simply:
 
 .. code-block:: shell-session
@@ -57,7 +57,7 @@ Once you have installed the package, you may want to test it:
 
     $ python -c 'import bitarray; bitarray.test()'
     bitarray is installed in: /Users/ilan/bitarray/bitarray
-    bitarray version: 3.7.0
+    bitarray version: 3.7.2
     sys.version: 3.13.5 (main, Jun 16 2025) [Clang 18.1.8]
     sys.prefix: /Users/ilan/miniforge
     pointer size: 64 bit
@@ -72,7 +72,7 @@ Once you have installed the package, you may want to test it:
     .........................................................................
     ................................................................
     ----------------------------------------------------------------------
-    Ran 599 tests in 0.166s
+    Ran 597 tests in 0.165s
 
     OK
 
@@ -224,85 +224,15 @@ shift (``>>``) always shifts towards higher indices.
 Bit-endianness
 --------------
 
-Unless explicitly converting to machine representation, i.e. initializing
-the buffer directly, using ``.tobytes()``, ``.frombytes()``, ``.tofile()``
-or ``.fromfile()``, as well as using ``memoryview()``, the bit-endianness
-will have no effect on any computation, and one can skip this section.
-
-Since bitarrays allows addressing individual bits, where the machine
-represents 8 bits in one byte, there are two obvious choices for this
-mapping: little-endian and big-endian.
-
-When dealing with the machine representation of bitarray objects, it is
-recommended to always explicitly specify the endianness.
-
-By default, bitarrays use big-endian representation:
-
-.. code-block:: python
-
-    >>> a = bitarray(b'A')
-    >>> a.endian
-    'big'
-    >>> a
-    bitarray('01000001')
-    >>> a[6] = 1
-    >>> a.tobytes()
-    b'C'
-
-Big-endian means that the most-significant bit comes first.
-Here, ``a[0]`` is the lowest address (index) and most significant bit,
-and ``a[7]`` is the highest address and least significant bit.
-
-When creating a new bitarray object, the endianness can always be
-specified explicitly:
-
-.. code-block:: python
-
-    >>> a = bitarray(b'A', endian='little')
-    >>> a
-    bitarray('10000010')
-    >>> a.endian
-    'little'
-
-Here, the low-bit comes first because little-endian means that increasing
-numeric significance corresponds to an increasing address.
-So ``a[0]`` is the lowest address and least significant bit,
-and ``a[7]`` is the highest address and most significant bit.
-
-The bit-endianness is a property of the bitarray object.
-The endianness cannot be changed once a bitarray object has been created.
-When comparing bitarray objects, the endianness (and hence the machine
-representation) is irrelevant; what matters is the mapping from indices
-to bits:
-
-.. code-block:: python
-
-    >>> bitarray('11001', endian='big') == bitarray('11001', endian='little')
-    True
-    >>> a = bitarray(b'\x01', endian='little')
-    >>> b = bitarray(b'\x80', endian='big')
-    >>> a == b
-    True
-    >>> a.tobytes() == b.tobytes()
-    False
-
-Bitwise operations (``|``, ``^``, ``&=``, ``|=``, ``^=``, ``~``) are
-implemented efficiently using the corresponding byte operations in C, i.e. the
-operators act on the machine representation of the bitarray objects.
-Therefore, it is not possible to perform bitwise operators on bitarrays
-with different endianness.
-
-As mentioned above, the endianness can not be changed once an object is
-created.  However, you can create a new bitarray with different endianness:
-
-.. code-block:: python
-
-    >>> a = bitarray('111000', endian='little')
-    >>> b = bitarray(a, endian='big')
-    >>> b
-    bitarray('111000')
-    >>> a == b
-    True
+For many purposes the bit-endianness is not of any relevance to the end user
+and can be regarded as an implementation detail of bitarray objects.
+However, there are use cases when the bit-endianness becomes important.
+These use cases involve explicitly reading and writing the bitarray buffer
+using ``.tobytes()``, ``.frombytes()``, ``.tofile()`` or ``.fromfile()``,
+importing and exporting buffers.  Also, a number of utility functions
+in ``bitarray.util`` will return different results depending on
+bit-endianness, such as ``ba2hex()`` or ``ba2int``.
+To better understand this topic, please read `bit-endianness <https://github.com/ilanschnell/bitarray/blob/master/doc/endianness.rst>`__.
 
 
 Buffer protocol
@@ -389,7 +319,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.7.0 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.7.2 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
 
 In the following, ``item`` and ``value`` are usually a single bit -
 an integer 0 or 1.
@@ -767,6 +697,11 @@ This sub-module was added in version 1.2.
    Also, ``a`` may be any object that exposes a writable buffer.
    Nothing about this function is specific to bitarray objects.
 
+   We should mention that Python's ``array.array`` object has a
+   method ``.byteswap()`` with similar functionality.  However, unlike
+   bitarray's ``util.byteswap()`` function, this method is limited to
+   swapping 2, 4, or 8 consecutive bytes.
+
    New in version 3.4
 
 
@@ -842,6 +777,10 @@ This sub-module was added in version 1.2.
    When ``odd=True``, only odd prime numbers are represented in the resulting
    bitarray ``a``, and ``a[i]`` corresponds to ``2*i+1`` being prime or not.
 
+   Apart from working with prime numbers, this function is useful for
+   testing, as it provides a simple way to create a well-defined bitarray
+   of any length.
+
    New in version 3.7
 
 
@@ -904,11 +843,7 @@ This sub-module was added in version 1.2.
    set to one.  Mathematically equivalent to setting (in a bitarray of
    length ``n``) all bits at indices ``random.sample(range(n), k)`` to one.
    The random bitarrays are reproducible when giving Python's ``random.seed()``
-   with a specific seed value.
-
-   This function requires Python 3.9 or higher, as it depends on the standard
-   library function ``random.randbytes()``.  Raises ``NotImplementedError``
-   when Python version is too low.
+   a specific seed value.
 
    New in version 3.6
 

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

@@ -9,14 +9,13 @@ Please find a description of this package at:
 
 Author: Ilan Schnell
 """
-from __future__ import absolute_import
 from collections import namedtuple
 
-from bitarray._bitarray import (bitarray, decodetree, _sysinfo,
-                                bits2bytes, _bitarray_reconstructor,
-                                get_default_endian, _set_default_endian,
-                                __version__)
-
+from bitarray._bitarray import (
+    bitarray, decodetree, bits2bytes, _bitarray_reconstructor,
+    get_default_endian, _set_default_endian, _sysinfo,
+    BITARRAY_VERSION as __version__
+)
 
 __all__ = ['bitarray', 'frozenbitarray', 'decodetree', 'bits2bytes']
 

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

@@ -117,6 +117,9 @@ class bitarray:
     def __delitem__(self,
                     i: Union[int, slice, bitarray, Sequence]) -> None: ...
 
+    def __buffer__(self, flags: int, /) -> memoryview: ...
+    def __release_buffer__(self, buffer: memoryview, /) -> None: ...
+
     def __add__(self, other: bitarray) -> bitarray: ...
     def __iadd__(self, other: bitarray) -> bitarray: ...
     def __mul__(self, n: int) -> bitarray: ...

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

@@ -1323,9 +1323,8 @@ bitarray_invert(bitarrayobject *self, PyObject *args)
             return NULL;
         }
         self->ob_item[i / 8] ^= BITMASK(self, i);
-        Py_RETURN_NONE;
     }
-    if (PySlice_Check(arg)) {
+    else if (PySlice_Check(arg)) {
         Py_ssize_t start, stop, step, slicelength;
 
         if (PySlice_GetIndicesEx(arg, self->nbits,
@@ -1333,15 +1332,15 @@ bitarray_invert(bitarrayobject *self, PyObject *args)
             return NULL;
         adjust_step_positive(slicelength, &start, &stop, &step);
         invert_range(self, start, stop, step);
-        Py_RETURN_NONE;
     }
-    if (arg == Py_None) {
+    else if (arg == Py_None) {
         invert_span(self, 0, self->nbits);
-        Py_RETURN_NONE;
     }
-
-    return PyErr_Format(PyExc_TypeError, "index expect, not '%s' object",
-                        Py_TYPE(arg)->tp_name);
+    else {
+        return PyErr_Format(PyExc_TypeError, "index expect, not '%s' object",
+                            Py_TYPE(arg)->tp_name);
+    }
+    Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(invert_doc,
@@ -3613,7 +3612,7 @@ endian_from_string(const char *str)
         return ENDIAN_BIG;
 
     PyErr_Format(PyExc_ValueError, "bit-endianness must be either "
-                                   "'little' or 'big', not '%s'", str);
+                 "'little' or 'big', not '%s'", str);
     return -1;
 }
 
@@ -4193,7 +4192,8 @@ sysinfo(PyObject *module, PyObject *args)
     R("DEBUG", 0);
 #endif
 
-    return PyErr_Format(PyExc_KeyError, "%s", key);
+    PyErr_SetString(PyExc_KeyError, key);
+    return NULL;
 #undef R
 }
 
@@ -4287,8 +4287,8 @@ PyInit__bitarray(void)
         return NULL;
     Py_SET_TYPE(&SearchIter_Type, &PyType_Type);
 
-    PyModule_AddObject(m, "__version__",
-                       PyUnicode_FromString(BITARRAY_VERSION));
+    if (PyModule_AddStringMacro(m, BITARRAY_VERSION) < 0)
+        return NULL;
 
     return m;
 }

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

@@ -837,7 +837,7 @@ static const char base64_alphabet[] =
 
 /* Given the length of the base m in [1..6] and a character c, return
    its index in the base 2**m alphabet , or -1 if when c is not included.
-   Note: i >> m checks if i is in range(0, 2**m) */
+   Note: i >> m is true when i is not in range(0, 2**m) */
 static int
 digit_to_int(int m, char c)
 {
@@ -2136,6 +2136,17 @@ module_cfw(PyObject *module, PyObject *args)  /* count_from_word() */
     return PyLong_FromSsize_t(count_from_word(a, i));
 }
 
+static PyObject *
+module_d2i(PyObject *module, PyObject *args)
+{
+    int m;
+    char c;
+
+    if (!PyArg_ParseTuple(args, "ic", &m, &c))
+        return NULL;
+    return PyLong_FromLong(digit_to_int(m, c));
+}
+
 static PyObject *
 module_read_n(PyObject *module, PyObject *args)
 {
@@ -2211,6 +2222,7 @@ static PyMethodDef module_functions[] = {
     {"_setup_table", (PyCFunction) module_setup_table, METH_O,       0},
     {"_zlw",         (PyCFunction) module_zlw,         METH_O,       0},
     {"_cfw",         (PyCFunction) module_cfw,         METH_VARARGS, 0},
+    {"_d2i",         (PyCFunction) module_d2i,         METH_VARARGS, 0},
     {"_read_n",      (PyCFunction) module_read_n,      METH_VARARGS, 0},
     {"_write_n",     (PyCFunction) module_write_n,     METH_VARARGS, 0},
     {"_sc_rts",      (PyCFunction) module_sc_rts,      METH_O,       0},
@@ -2242,7 +2254,8 @@ PyInit__util(void)
     Py_SET_TYPE(&CHDI_Type, &PyType_Type);
 
 #ifndef NDEBUG  /* expose segment size in debug mode for testing */
-    PyModule_AddObject(m, "_SEGSIZE", PyLong_FromSsize_t(SEGSIZE));
+    if (PyModule_AddIntConstant(m, "_SEGSIZE", SEGSIZE) < 0)
+        return NULL;
 #endif
 
     return m;

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

@@ -4,7 +4,7 @@
 
    Author: Ilan Schnell
 */
-#define BITARRAY_VERSION  "3.7.0"
+#define BITARRAY_VERSION  "3.7.2"
 
 #ifdef STDC_HEADERS
 #  include <stddef.h>
@@ -233,7 +233,7 @@ setup_table(char *table, char kop)
     for (k = 0; k < 256; k++) {
         char t = 0, j;
         for (j = 0; j < 8; j++) {
-            if (k & 1 << j)
+            if (k & 1 << j) {
                 /* j are the indices of active bits in k (little endian) */
                 switch (kop) {
                 case 'a': t += j;        break;  /* add active indices */
@@ -249,6 +249,7 @@ setup_table(char *table, char kop)
                 case 'r': t |= 128 >> j; break;  /* reverse bits */
                 default: Py_UNREACHABLE();
                 }
+            }
         }
         table[k] = t;
     }

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

@@ -1,10 +1,12 @@
+# Copyright (c) 2008 - 2025, Ilan Schnell; All Rights Reserved
+# bitarray is published under the PSF license.
+#
+# Author: Ilan Schnell
 """
 Tests for bitarray
 
 Author: Ilan Schnell
 """
-from __future__ import absolute_import
-
 import re
 import os
 import sys
@@ -13,7 +15,8 @@ import unittest
 import shutil
 import tempfile
 from io import BytesIO, UnsupportedOperation
-from random import choice, getrandbits, randrange, randint, shuffle
+from random import choice, choices, getrandbits, randrange, randint, shuffle
+from string import whitespace
 
 # imports needed inside tests
 import array
@@ -57,8 +60,6 @@ def urandom_2(n, endian="<RAND>"):
     del a[n:]
     return a
 
-WHITESPACE = ' \n\r\t\v'
-
 
 class Util(object):
 
@@ -400,10 +401,10 @@ class CreateObjectTests(unittest.TestCase, Util):
         self.assertRaises(ValueError, bitarray, '0\U00010348')  # UCS4
 
     def test_string01_whitespace(self):
-        a = bitarray(WHITESPACE)
+        a = bitarray(whitespace)
         self.assertEqual(a, bitarray())
 
-        for c in WHITESPACE:
+        for c in whitespace:
             a = bitarray(c + '1101110001')
             self.assertEqual(a, bitarray('1101110001'))
 
@@ -1406,7 +1407,7 @@ class GetSequenceIndexTests(unittest.TestCase, Util):
     def test_random(self):
         for a in self.randombitarrays():
             n = len(a)
-            lst = [randrange(n) for _ in range(n // 2)]
+            lst = choices(range(n), k=n//2)
             b = a[lst]
             self.assertEqual(b, bitarray(a[i] for i in lst))
             self.assertEqual(b.endian, a.endian)
@@ -1439,7 +1440,7 @@ class SetSequenceIndexTests(unittest.TestCase, Util):
     def test_bool_random(self):
         for a in self.randombitarrays():
             n = len(a)
-            lst = [randrange(n) for _ in range(n // 2)]
+            lst = choices(range(n), k=n//2)
             b = a.copy()
             v = getrandbits(1)
             a[lst] = v
@@ -1473,7 +1474,7 @@ class SetSequenceIndexTests(unittest.TestCase, Util):
     def test_bitarray_random(self):
         for a in self.randombitarrays():
             n = len(a)
-            lst = [randrange(n) for _ in range(n // 2)]
+            lst = choices(range(n), k=n//2)
             c = urandom_2(len(lst))
             b = a.copy()
 
@@ -1544,7 +1545,7 @@ class DelSequenceIndexTests(unittest.TestCase, Util):
     def test_random(self):
         for n in range(100):
             a = urandom_2(n)
-            lst = [randrange(n) for _ in range(randint(0, n))]
+            lst = choices(range(n), k=randint(0, n))
             b = a.copy()
             del a[lst]
             self.assertEqual(len(a), n - len(set(lst)))
@@ -2614,7 +2615,7 @@ class ExtendTests(unittest.TestCase, Util):
 
     def test_string01_whitespace(self):
         a = bitarray()
-        a.extend(WHITESPACE)
+        a.extend(whitespace)
         self.assertEqual(len(a), 0)
         a.extend('0 1\n0\r1\t0\v1_')
         self.assertEqual(a, bitarray('010101'))
@@ -3230,7 +3231,7 @@ class To01Tests(unittest.TestCase, Util):
     def test_sep(self):
         for a in self.randombitarrays():
             sep = "".join(chr(randint(32, 126))
-                              for _ in range(randrange(10)))
+                          for _ in range(randrange(10)))
             self.assertEqual(a.to01(1, sep), sep.join(str(v) for v in a))
 
         a = bitarray("11100111")
@@ -3442,7 +3443,7 @@ class CountTests(unittest.TestCase, Util):
     def test_sparse(self):
         n = 65536
         a = bitarray(n)
-        indices = set(randrange(n) for _ in range(256))
+        indices = set(choices(range(n), k=256))
         a[list(indices)] = 1
         self.assertEqual(a.count(1), len(indices))
         self.assertEqual(a.count(0), n - len(indices))
@@ -3633,7 +3634,7 @@ class IndexTests(unittest.TestCase, Util):
         for _ in range(500):
             n = randrange(1, 200)
             a = zeros(n)
-            plst = sorted(randrange(n) for _ in range(1, 10))
+            plst = sorted(choices(range(n), k=9))
             a[plst] = 1
             # test without start and stop
             self.assertEqual(a.find(1, right=0), plst[0])