usearch 0.10.0 → 0.11.1

package/python/lib.cpp

@@ -169,7 +169,7 @@ static std::unique_ptr<hash_index_py_t> make_hash_index( //
     return std::unique_ptr<hash_index_py_t>(new hash_index_py_t(config, bits));
 }
 
-static void add_one_to_index(punned_py_t& index, label_t label, py::buffer vector, bool copy) {
+static void add_one_to_index(punned_py_t& index, label_t label, py::buffer vector, bool copy, std::size_t) {
 
     py::buffer_info vector_info = vector.request();
     if (vector_info.ndim != 1)
@@ -191,9 +191,9 @@ static void add_one_to_index(punned_py_t& index, label_t label, py::buffer vecto
         index.add(label, reinterpret_cast<f8_bits_t const*>(vector_data), config);
     else if (vector_info.format == "e")
         index.add(label, reinterpret_cast<f16_bits_t const*>(vector_data), config);
-    else if (vector_info.format == "f")
+    else if (vector_info.format == "f" || vector_info.format == "f4" || vector_info.format == "<f4")
         index.add(label, reinterpret_cast<float const*>(vector_data), config);
-    else if (vector_info.format == "d")
+    else if (vector_info.format == "d" || vector_info.format == "f8" || vector_info.format == "<f8")
         index.add(label, reinterpret_cast<double const*>(vector_data), config);
     else
         throw std::invalid_argument("Incompatible scalars in the vector!");
@@ -201,7 +201,10 @@ static void add_one_to_index(punned_py_t& index, label_t label, py::buffer vecto
 
 static void add_many_to_index(                                 //
     punned_py_t& index, py::buffer labels, py::buffer vectors, //
-    bool copy, std::size_t threads = 0) {
+    bool copy, std::size_t threads) {
+
+    if (index.config().max_threads_add < threads)
+        throw std::invalid_argument("Can't use that many threads!");
 
     py::buffer_info labels_info = labels.request();
     py::buffer_info vectors_info = vectors.request();
@@ -232,7 +235,7 @@ static void add_many_to_index(                                 //
 
     // https://docs.python.org/3/library/struct.html#format-characters
     if (vectors_info.format == "c" || vectors_info.format == "b")
-        multithreaded(index.config().concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+        multithreaded(threads, vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
             add_config_t config;
             config.store_vector = copy;
             config.thread = thread_idx;
@@ -242,7 +245,7 @@ static void add_many_to_index(                                 //
             index.add(label, vector, config);
         });
     else if (vectors_info.format == "e")
-        multithreaded(index.config().concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+        multithreaded(threads, vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
             add_config_t config;
             config.store_vector = copy;
             config.thread = thread_idx;
@@ -251,8 +254,8 @@ static void add_many_to_index(                                 //
                 reinterpret_cast<f16_bits_t const*>(vectors_data + task_idx * vectors_info.strides[0]);
             index.add(label, vector, config);
         });
-    else if (vectors_info.format == "f")
-        multithreaded(index.config().concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+    else if (vectors_info.format == "f" || vectors_info.format == "f4" || vectors_info.format == "<f4")
+        multithreaded(threads, vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
             add_config_t config;
             config.store_vector = copy;
             config.thread = thread_idx;
@@ -260,8 +263,8 @@ static void add_many_to_index(                                 //
             float const* vector = reinterpret_cast<float const*>(vectors_data + task_idx * vectors_info.strides[0]);
             index.add(label, vector, config);
         });
-    else if (vectors_info.format == "d")
-        multithreaded(index.config().concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+    else if (vectors_info.format == "d" || vectors_info.format == "f8" || vectors_info.format == "<f8")
+        multithreaded(threads, vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
             add_config_t config;
             config.store_vector = copy;
             config.thread = thread_idx;
@@ -299,11 +302,11 @@ static py::tuple search_one_in_index(punned_py_t& index, py::buffer vector, std:
         count = index //
                     .search(reinterpret_cast<f16_bits_t const*>(vector_data), wanted, config)
                     .dump_to(&labels_py1d(0), &distances_py1d(0));
-    else if (vector_info.format == "f")
+    else if (vector_info.format == "f" || vector_info.format == "f4" || vector_info.format == "<f4")
         count = index //
                     .search(reinterpret_cast<float const*>(vector_data), wanted, config)
                     .dump_to(&labels_py1d(0), &distances_py1d(0));
-    else if (vector_info.format == "d")
+    else if (vector_info.format == "d" || vector_info.format == "f8" || vector_info.format == "<f8")
         count = index //
                     .search(reinterpret_cast<double const*>(vector_data), wanted, config)
                     .dump_to(&labels_py1d(0), &distances_py1d(0));
@@ -329,11 +332,15 @@ static py::tuple search_one_in_index(punned_py_t& index, py::buffer vector, std:
  *      2. matrix of distances,
  *      3. array with match counts.
  */
-static py::tuple search_many_in_index(punned_py_t& index, py::buffer vectors, std::size_t wanted, bool exact) {
+static py::tuple search_many_in_index( //
+    punned_py_t& index, py::buffer vectors, std::size_t wanted, bool exact, std::size_t threads) {
 
     if (wanted == 0)
         return py::tuple(3);
 
+    if (index.config().max_threads_add < threads)
+        throw std::invalid_argument("Can't use that many threads!");
+
     py::buffer_info vectors_info = vectors.request();
     if (vectors_info.ndim == 1)
         return search_one_in_index(index, vectors, wanted, exact);
@@ -355,7 +362,7 @@ static py::tuple search_many_in_index(punned_py_t& index, py::buffer vectors, st
 
     // https://docs.python.org/3/library/struct.html#format-characters
     if (vectors_info.format == "c" || vectors_info.format == "b")
-        multithreaded(index.config().concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+        multithreaded(threads, vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
             search_config_t config;
             config.thread = thread_idx;
             config.exact = exact;
@@ -364,7 +371,7 @@ static py::tuple search_many_in_index(punned_py_t& index, py::buffer vectors, st
                 index.search(vector, wanted, config).dump_to(&labels_py2d(task_idx, 0), &distances_py2d(task_idx, 0)));
         });
     else if (vectors_info.format == "e")
-        multithreaded(index.config().concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+        multithreaded(threads, vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
             search_config_t config;
             config.thread = thread_idx;
             config.exact = exact;
@@ -372,8 +379,8 @@ static py::tuple search_many_in_index(punned_py_t& index, py::buffer vectors, st
             counts_py1d(task_idx) = static_cast<Py_ssize_t>(
                 index.search(vector, wanted, config).dump_to(&labels_py2d(task_idx, 0), &distances_py2d(task_idx, 0)));
         });
-    else if (vectors_info.format == "f")
-        multithreaded(index.config().concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+    else if (vectors_info.format == "f" || vectors_info.format == "f4" || vectors_info.format == "<f4")
+        multithreaded(threads, vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
             search_config_t config;
             config.thread = thread_idx;
             config.exact = exact;
@@ -381,8 +388,8 @@ static py::tuple search_many_in_index(punned_py_t& index, py::buffer vectors, st
             counts_py1d(task_idx) = static_cast<Py_ssize_t>(
                 index.search(vector, wanted, config).dump_to(&labels_py2d(task_idx, 0), &distances_py2d(task_idx, 0)));
         });
-    else if (vectors_info.format == "d")
-        multithreaded(index.config().concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+    else if (vectors_info.format == "d" || vectors_info.format == "f8" || vectors_info.format == "<f8")
+        multithreaded(threads, vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
             search_config_t config;
             config.thread = thread_idx;
             config.exact = exact;
@@ -407,7 +414,6 @@ template <typename index_at> void view_index(index_at& index, std::string const&
 template <typename index_at> void clear_index(index_at& index) { index.clear(); }
 template <typename index_at> std::size_t get_expansion_add(index_at const &index) { return index.config().expansion_add; }
 template <typename index_at> std::size_t get_expansion_search(index_at const &index) { return index.config().expansion_search; }
-
 // clang-format on
 
 template <typename element_at> bool has_duplicates(element_at const* begin, element_at const* end) {
@@ -476,8 +482,12 @@ void hash_buffer(hash_index_py_t& index, py::buffer vector) {
         throw std::invalid_argument("Array elements must be 16, 32, or 64 bit hashable integers!");
 }
 
-PYBIND11_MODULE(index, m) {
-    m.doc() = "Unum USearch Python bindings";
+PYBIND11_MODULE(compiled, m) {
+    m.doc() = "Smaller & Faster Single-File Vector Search Engine from Unum";
+
+    m.attr("DEFAULT_CONNECTIVITY") = py::int_(default_connectivity());
+    m.attr("DEFAULT_EXPANSION_ADD") = py::int_(default_expansion_add());
+    m.attr("DEFAULT_EXPANSION_SEARCH") = py::int_(default_expansion_search());
 
     auto i = py::class_<punned_py_t>(m, "Index");
 
@@ -508,14 +518,16 @@ PYBIND11_MODULE(index, m) {
         py::arg("label"),         //
         py::arg("vector"),        //
         py::kw_only(),            //
-        py::arg("copy") = true    //
+        py::arg("copy") = true,   //
+        py::arg("threads") = 0    //
     );
 
     i.def(                               //
         "search", &search_many_in_index, //
         py::arg("query"),                //
         py::arg("count") = 10,           //
-        py::arg("exact") = false         //
+        py::arg("exact") = false,        //
+        py::arg("threads") = 0           //
     );
 
     i.def("__len__", &punned_py_t::size);

package/python/scripts/bench.py

@@ -142,7 +142,7 @@ def main(
             expansion_add=expansion_add,
             expansion_search=expansion_search,
             connectivity=connectivity,
-            metric_pointer=inner_product_f32.address,
+            metric=inner_product_f32.address,
         )
         bench_usearch(index, vectors_mat, queries_mat, neighbors_mat)
 
@@ -153,7 +153,7 @@ def main(
             expansion_add=expansion_add,
             expansion_search=expansion_search,
             connectivity=connectivity,
-            metric_pointer=cos_f8.address,
+            metric=cos_f8.address,
         )
         bench_usearch(index, vectors_mat, queries_mat, neighbors_mat)
     except ImportError:

package/python/scripts/test.py

@@ -86,7 +86,7 @@ def test_user_defined_function(ndim: int, size: int):
             c += a_array[i] * b_array[i]
         return c
 
-    index = Index(ndim=ndim, metric_pointer=python_dot.address)
+    index = Index(ndim=ndim, metric=python_dot.address)
 
     vectors = np.random.uniform(
         0, 0.3, (size, index.ndim)).astype(np.float32)

package/python/usearch/client.py

@@ -1,8 +1,10 @@
-from typing import Union, Optional
+from typing import Union, Optional, List
 
 import numpy as np
 from ucall.client import Client
 
+from usearch.index import Matches
+
 
 def _vector_to_ascii(vector: np.ndarray) -> Optional[str]:
     if vector.dtype != np.int8 and vector.dtype != np.uint8 and vector.dtype != np.byte:
@@ -18,9 +20,6 @@ def _vector_to_ascii(vector: np.ndarray) -> Optional[str]:
     return ascii
 
 
-Triplet = tuple[np.ndarray, np.ndarray, np.ndarray]
-
-
 class IndexClient:
 
     def __init__(
@@ -53,8 +52,8 @@ class IndexClient:
         else:
             return self.add_many(labels, vectors)
 
-    def search_one(self, vector: np.ndarray, count: int) -> Triplet:
-        matches: list[dict] = []
+    def search_one(self, vector: np.ndarray, count: int) -> Matches:
+        matches: List[dict] = []
         vector = vector.flatten()
         ascii = _vector_to_ascii(vector)
         if ascii:
@@ -75,9 +74,9 @@ class IndexClient:
 
         return labels, distances, counts
 
-    def search_many(self, vectors: np.ndarray, count: int) -> Triplet:
+    def search_many(self, vectors: np.ndarray, count: int) -> Matches:
         batch_size: int = vectors.shape[0]
-        list_of_matches: list[list[dict]] = self.client.search_many(
+        list_of_matches: List[List[dict]] = self.client.search_many(
             vectors=vectors, count=count)
 
         labels = np.array((batch_size, count), dtype=np.uint32)
@@ -91,7 +90,7 @@ class IndexClient:
 
         return labels, distances, counts
 
-    def search(self, vectors: np.ndarray, count: int) -> Triplet:
+    def search(self, vectors: np.ndarray, count: int) -> Matches:
         if vectors.ndim == 1 or (vectors.ndim == 2 and vectors.shape[0] == 1):
             return self.search_one(vectors, count)
         else:

package/python/usearch/index.py

@@ -0,0 +1,306 @@
+# The purpose of this file is to provide Pythonic wrapper on top
+# the native precompiled CPython module. It improves compatibility
+# Python tooling, linters, and static analyzers. It also embeds JIT
+# into the primary `Index` class, connecting USearch with Numba.
+import os
+from math import sqrt
+from typing import Optional, Callable, Union, NamedTuple, List
+
+import numpy as np
+
+from usearch.compiled import Index as _CompiledIndex
+from usearch.compiled import SetsIndex as _CompiledSetsIndex
+from usearch.compiled import HashIndex as _CompiledHashIndex
+from usearch.compiled import DEFAULT_CONNECTIVITY, DEFAULT_EXPANSION_ADD, DEFAULT_EXPANSION_SEARCH
+
+SetsIndex = _CompiledSetsIndex
+HashIndex = _CompiledHashIndex
+
+
+class Matches(NamedTuple):
+    labels: np.ndarray
+    distances: np.ndarray
+    counts: np.ndarray
+
+
+def list_matches(results: Matches, row: int) -> List[dict]:
+
+    count = results[2][row]
+    labels = results[0][row, :count]
+    distances = results[1][row, :count]
+    return [
+        {'label': int(label), 'distance': float(distance)}
+        for label, distance in zip(labels, distances)
+    ]
+
+
+def jit_metric(ndim: int, metric_name: str, accuracy: str = 'f32') -> Callable:
+
+    try:
+        from numba import cfunc, types, carray
+    except ImportError:
+        raise ModuleNotFoundError(
+            'To use JIT install Numba with `pip install numba`.'
+            'Alternatively, reinstall usearch with `pip install usearch[jit]`')
+
+    # Showcases how to use Numba to JIT-compile similarity measures for USearch.
+    # https://numba.readthedocs.io/en/stable/reference/jit-compilation.html#c-callbacks
+
+    if accuracy == 'f32':
+        signature = types.float32(
+            types.CPointer(types.float32),
+            types.CPointer(types.float32),
+            types.size_t, types.size_t)
+
+        if metric_name == 'ip':
+
+            def numba_ip(a, b, _n, _m):
+                a_array = carray(a, ndim)
+                b_array = carray(b, ndim)
+                ab = 0.0
+                for i in range(ndim):
+                    ab += a_array[i] * b_array[i]
+                return ab
+
+            return cfunc(numba_ip, signature)
+
+        if metric_name == 'cos':
+
+            def numba_cos(a, b, _n, _m):
+                a_array = carray(a, ndim)
+                b_array = carray(b, ndim)
+                ab = 0.0
+                a_sq = 0.0
+                b_sq = 0.0
+                for i in range(ndim):
+                    ab += a_array[i] * b_array[i]
+                    a_sq += a_array[i] * a_array[i]
+                    b_sq += b_array[i] * b_array[i]
+                return ab / (sqrt(a_sq) * sqrt(b_sq))
+
+            return cfunc(numba_cos, signature)
+
+        if metric_name == 'l2sq':
+
+            def numba_l2sq(a, b, _n, _m):
+                a_array = carray(a, ndim)
+                b_array = carray(b, ndim)
+                ab_delta_sq = 0.0
+                for i in range(ndim):
+                    ab_delta_sq += (a_array[i] - b_array[i]) * \
+                        (a_array[i] - b_array[i])
+                return ab_delta_sq
+
+            return cfunc(numba_l2sq, signature)
+
+    return None
+
+
+class Index:
+    """Fast JIT-compiled index for equi-dimensional embeddings.
+
+    Vector labels must be integers.
+    Vectors must have the same number of dimensions within the index.
+    Supports Inner Product, Cosine Distance, Ln measures
+    like the Euclidean metric, as well as automatic downcasting
+    and quantization.
+    """
+
+    def __init__(
+        self,
+        ndim: int,
+        dtype: str = 'f32',
+        metric: Union[str, int] = 'ip',
+        jit: bool = False,
+
+        connectivity: int = DEFAULT_CONNECTIVITY,
+        expansion_add: int = DEFAULT_EXPANSION_ADD,
+        expansion_search: int = DEFAULT_EXPANSION_SEARCH,
+        tune: bool = False,
+
+        path: Optional[os.PathLike] = None,
+        view: bool = False,
+    ) -> None:
+        """Construct the index and compiles the functions, if requested (expensive).
+
+        :param ndim: Number of vector dimensions
+        :type ndim: int
+        :param dtype: Scalar type for vectors, defaults to 'f32'
+        :type dtype: str, optional
+            Example: you can use the `f16` index with `f32` vectors,
+            which will be automatically downcasted.
+
+        :param metric: Distance function, defaults to 'ip'
+        :type metric: Union[str, int], optional
+            Name of distance function, or the address of the
+            Numba `cfunc` JIT-compiled object.
+
+        :param jit: Enable Numba to JIT compile the metric, defaults to False
+        :type jit: bool, optional
+            This can result in up-to 3x performance difference on very large vectors
+            and very recent hardware, as the Python module is compiled with high
+            compatibility in mind and avoids very fancy assembly instructions.
+
+        :param connectivity: Connections per node in HNSW, defaults to None
+        :type connectivity: Optional[int], optional
+            Hyper-parameter for the number of Graph connections
+            per layer of HNSW. The original paper calls it "M".
+            Optional, but can't be changed after construction.
+
+        :param expansion_add: Traversal depth on insertions, defaults to None
+        :type expansion_add: Optional[int], optional
+            Hyper-parameter for the search depth when inserting new
+            vectors. The original paper calls it "efConstruction".
+            Can be changed afterwards, as the `.expansion_add`.
+
+        :param expansion_search: Traversal depth on queries, defaults to None
+        :type expansion_search: Optional[int], optional
+            Hyper-parameter for the search depth when querying 
+            nearest neighbors. The original paper calls it "ef".
+            Can be changed afterwards, as the `.expansion_search`.
+
+        :param tune: Automatically adjusts hyper-parameters, defaults to False
+        :type tune: bool, optional
+
+        :param path: Where to store the index, defaults to None
+        :type path: Optional[os.PathLike], optional
+        :param view: Are we simply viewing an immutable index, defaults to False
+        :type view: bool, optional
+        """
+        if jit:
+            assert isinstance(metric, str), 'Name the metric to JIT'
+            self._metric_name = metric
+            self._metric_jit = jit_metric(
+                ndim=ndim,
+                metric_name=metric,
+                dtype=dtype,
+            )
+            self._metric_pointer = self._metric_jit.address if \
+                self._metric_jit else 0
+
+        elif isinstance(metric, int):
+            self._metric_name = ''
+            self._metric_jit = None
+            self._metric_pointer = metric
+
+        else:
+            if metric is None:
+                metric = 'ip'
+            assert isinstance(metric, str)
+            self._metric_name = metric
+            self._metric_jit = None
+            self._metric_pointer = 0
+
+        self._compiled = _CompiledIndex(
+            ndim=ndim,
+            metric=self._metric_name,
+            metric_pointer=self._metric_pointer,
+            dtype=dtype,
+            connectivity=connectivity,
+            expansion_add=expansion_add,
+            expansion_search=expansion_search,
+            tune=tune,
+        )
+
+        self.path = path
+        if path and os.path.exists(path):
+            if view:
+                self._compiled.view(path)
+            else:
+                self._compiled.load(path)
+
+    def add(
+            self, labels, vectors, *,
+            copy: bool = True, threads: int = 0):
+        """Inserts one or move vectors into the index.
+
+        For maximal performance the `labels` and `vectors`
+        should conform to the Python's "buffer protocol" spec.
+
+        To index a single entry: 
+            labels: int, vectors: np.ndarray.
+        To index many entries: 
+            labels: np.ndarray, vectors: np.ndarray.
+
+        When working with extremely large indexes, you may want to
+        pass `copy=False`, if you can guarantee the lifetime of the
+        primary vectors store during the process of construction.
+
+        :param labels: Unique identifier for passed vectors.
+        :type labels: Buffer
+        :param vectors: Collection of vectors.
+        :type vectors: Buffer
+        :param copy: Should the index store a copy of vectors, defaults to True
+        :type copy: bool, optional
+        :param threads: Optimal number of cores to use, defaults to 0
+        :type threads: int, optional
+        """
+        if isinstance(labels, np.ndarray):
+            labels = labels.astype(np.longlong)
+        self._compiled.add(labels, vectors, copy=copy, threads=threads)
+
+    def search(
+            self, vectors, k: int = 10, *,
+            threads: int = 0, exact: bool = False) -> Matches:
+        tuple_ = self._compiled.search(
+            vectors, k,
+            exact=exact, threads=threads)
+        return Matches(*tuple_)
+
+    def __len__(self) -> int:
+        return len(self._compiled)
+
+    @property
+    def size(self) -> int:
+        return self._compiled.size
+
+    @property
+    def ndim(self) -> int:
+        return self._compiled.ndim
+
+    @property
+    def dtype(self) -> str:
+        return self._compiled.dtype
+
+    @property
+    def connectivity(self) -> int:
+        return self._compiled.connectivity
+
+    @property
+    def capacity(self) -> int:
+        return self._compiled.capacity
+
+    @property
+    def memory_usage(self) -> int:
+        return self._compiled.memory_usage
+
+    @property
+    def expansion_add(self) -> int:
+        return self._compiled.expansion_add
+
+    @property
+    def expansion_search(self) -> int:
+        return self._compiled.expansion_search
+
+    @expansion_add.setter
+    def change_expansion_add(self, v: int):
+        self._compiled.expansion_add = v
+
+    @expansion_search.setter
+    def change_expansion_search(self, v: int):
+        self._compiled.expansion_search = v
+
+    def save(self, path: os.PathLike):
+        self._compiled.save(path)
+
+    def load(self, path: os.PathLike):
+        self._compiled.load(path)
+
+    def view(self, path: os.PathLike):
+        self._compiled.view(path)
+
+    def clear(self):
+        self._compiled.clear()
+
+    def remove(self, label: int):
+        pass

package/python/usearch/server.py

@@ -4,20 +4,10 @@
 import os
 import argparse
 import numpy as np
+from typing import List
 
 from ucall.rich_posix import Server
-from usearch.index import Index
-
-Triplet = tuple[np.ndarray, np.ndarray, np.ndarray]
-
-
-def _results_to_json(results: Triplet, row: int) -> list[dict]:
-
-    count = results[2][row]
-    labels = results[0][row, :count]
-    distances = results[1][row, :count]
-    return [{'label': int(label), 'distance': float(distance)}
-            for label, distance in zip(labels, distances)]
+from usearch.index import Index, list_matches
 
 
 def _ascii_to_vector(string: str) -> np.ndarray:
@@ -78,16 +68,16 @@ def serve(
         index.add(labels, vectors, threads=threads)
 
     @server
-    def search_one(vector: np.ndarray, count: int) -> list[dict]:
+    def search_one(vector: np.ndarray, count: int) -> List[dict]:
         print('search', vector, count)
         vectors = vector.reshape(vector.shape[0], 1)
         results = index.search(vectors, count)
-        return _results_to_json(results, 0)
+        return list_matches(results, 0)
 
     @server
-    def search_many(vectors: np.ndarray, count: int) -> list[list[dict]]:
+    def search_many(vectors: np.ndarray, count: int) -> List[List[dict]]:
         results = index.search(vectors, count)
-        return [_results_to_json(results, i) for i in range(vectors.shape[0])]
+        return [list_matches(results, i) for i in range(vectors.shape[0])]
 
     @server
     def add_ascii(label: int, string: str):

package/robin-map/.codecov.yml

@@ -0,0 +1,5 @@
+comment: off
+coverage:
+  status:
+    project: off
+    patch: off