usearch 2.9.2 → 2.10.0

package/javascript/lib.cpp

@@ -1,341 +0,0 @@
-/**
- *  @file javascript.cpp
- *  @author Ash Vardanian
- *  @brief JavaScript bindings for Unum USearch.
- *  @date 2023-04-26
- *
- *  @copyright Copyright (c) 2023
- *
- *  @see NodeJS docs: https://nodejs.org/api/addons.html#hello-world
- *
- */
-#include <new> // `std::bad_alloc`
-
-#define NAPI_CPP_EXCEPTIONS
-#include <napi.h>
-#include <node_api.h>
-
-#include <usearch/index_dense.hpp>
-
-using namespace unum::usearch;
-using namespace unum;
-
-class CompiledIndex : public Napi::ObjectWrap<CompiledIndex> {
-  public:
-    static Napi::Object Init(Napi::Env env, Napi::Object exports);
-    CompiledIndex(Napi::CallbackInfo const& ctx);
-
-  private:
-    Napi::Value GetDimensions(Napi::CallbackInfo const& ctx);
-    Napi::Value GetSize(Napi::CallbackInfo const& ctx);
-    Napi::Value GetCapacity(Napi::CallbackInfo const& ctx);
-    Napi::Value GetConnectivity(Napi::CallbackInfo const& ctx);
-
-    void Save(Napi::CallbackInfo const& ctx);
-    void Load(Napi::CallbackInfo const& ctx);
-    void View(Napi::CallbackInfo const& ctx);
-
-    void Add(Napi::CallbackInfo const& ctx);
-    Napi::Value Search(Napi::CallbackInfo const& ctx);
-    Napi::Value Remove(Napi::CallbackInfo const& ctx);
-    Napi::Value Contains(Napi::CallbackInfo const& ctx);
-    Napi::Value Count(Napi::CallbackInfo const& ctx);
-
-    std::unique_ptr<index_dense_t> native_;
-};
-
-Napi::Object CompiledIndex::Init(Napi::Env env, Napi::Object exports) {
-    Napi::Function func = DefineClass( //
-        env, "CompiledIndex",
-        {
-            InstanceMethod("dimensions", &CompiledIndex::GetDimensions),
-            InstanceMethod("size", &CompiledIndex::GetSize),
-            InstanceMethod("capacity", &CompiledIndex::GetCapacity),
-            InstanceMethod("connectivity", &CompiledIndex::GetConnectivity),
-            InstanceMethod("add", &CompiledIndex::Add),
-            InstanceMethod("search", &CompiledIndex::Search),
-            InstanceMethod("remove", &CompiledIndex::Remove),
-            InstanceMethod("contains", &CompiledIndex::Contains),
-            InstanceMethod("count", &CompiledIndex::Count),
-            InstanceMethod("save", &CompiledIndex::Save),
-            InstanceMethod("load", &CompiledIndex::Load),
-            InstanceMethod("view", &CompiledIndex::View),
-        });
-
-    Napi::FunctionReference* constructor = new Napi::FunctionReference();
-    *constructor = Napi::Persistent(func);
-    env.SetInstanceData(constructor);
-
-    exports.Set("CompiledIndex", func);
-    return exports;
-}
-
-std::size_t napi_argument_to_size(Napi::Value v) {
-    return static_cast<std::size_t>(v.As<Napi::Number>().DoubleValue());
-}
-
-CompiledIndex::CompiledIndex(Napi::CallbackInfo const& ctx) : Napi::ObjectWrap<CompiledIndex>(ctx) {
-
-    // Directly assign the parameters without checks
-    std::size_t dimensions = napi_argument_to_size(ctx[0]);
-    metric_kind_t metric_kind = metric_from_name(ctx[1].As<Napi::String>().Utf8Value().c_str());
-    scalar_kind_t quantization = scalar_kind_from_name(ctx[2].As<Napi::String>().Utf8Value().c_str());
-    std::size_t connectivity = napi_argument_to_size(ctx[3]);
-    std::size_t expansion_add = napi_argument_to_size(ctx[4]);
-    std::size_t expansion_search = napi_argument_to_size(ctx[5]);
-    bool multi = ctx[6].As<Napi::Boolean>().Value();
-
-    metric_punned_t metric(dimensions, metric_kind, quantization);
-    index_dense_config_t config(connectivity, expansion_add, expansion_search);
-    config.multi = multi;
-
-    native_.reset(new index_dense_t(index_dense_t::make(metric, config)));
-    if (!native_)
-        Napi::Error::New(ctx.Env(), "Out of memory!").ThrowAsJavaScriptException();
-}
-
-Napi::Value CompiledIndex::GetDimensions(Napi::CallbackInfo const& ctx) {
-    return Napi::Number::New(ctx.Env(), static_cast<std::uint64_t>(native_->dimensions()));
-}
-Napi::Value CompiledIndex::GetConnectivity(Napi::CallbackInfo const& ctx) {
-    return Napi::Number::New(ctx.Env(), static_cast<std::uint64_t>(native_->connectivity()));
-}
-Napi::Value CompiledIndex::GetSize(Napi::CallbackInfo const& ctx) {
-    return Napi::Number::New(ctx.Env(), static_cast<std::uint64_t>(native_->size()));
-}
-Napi::Value CompiledIndex::GetCapacity(Napi::CallbackInfo const& ctx) {
-    return Napi::Number::New(ctx.Env(), static_cast<std::uint64_t>(native_->capacity()));
-}
-
-void CompiledIndex::Save(Napi::CallbackInfo const& ctx) {
-    try {
-        std::string path = ctx[0].As<Napi::String>();
-        auto result = native_->save(path.c_str());
-        if (!result)
-            Napi::TypeError::New(ctx.Env(), result.error.release()).ThrowAsJavaScriptException();
-
-    } catch (...) {
-        Napi::TypeError::New(ctx.Env(), "Serialization failed").ThrowAsJavaScriptException();
-    }
-}
-
-void CompiledIndex::Load(Napi::CallbackInfo const& ctx) {
-    try {
-        std::string path = ctx[0].As<Napi::String>();
-        auto result = native_->load(path.c_str());
-        if (!result)
-            Napi::TypeError::New(ctx.Env(), result.error.release()).ThrowAsJavaScriptException();
-
-    } catch (...) {
-        Napi::TypeError::New(ctx.Env(), "Loading failed").ThrowAsJavaScriptException();
-    }
-}
-
-void CompiledIndex::View(Napi::CallbackInfo const& ctx) {
-
-    try {
-        std::string path = ctx[0].As<Napi::String>();
-        auto result = native_->view(path.c_str());
-        if (!result)
-            Napi::TypeError::New(ctx.Env(), result.error.release()).ThrowAsJavaScriptException();
-
-    } catch (...) {
-        Napi::TypeError::New(ctx.Env(), "Memory-mapping failed").ThrowAsJavaScriptException();
-    }
-}
-
-void CompiledIndex::Add(Napi::CallbackInfo const& ctx) {
-    // Extract keys and vectors from arguments
-    Napi::BigUint64Array keys = ctx[0].As<Napi::BigUint64Array>();
-    std::size_t tasks = keys.ElementLength();
-
-    // Ensure there is enough capacity
-    if (native_->size() + tasks >= native_->capacity())
-        native_->reserve(ceil2(native_->size() + tasks));
-
-    // Create an instance of the executor with the default number of threads
-    auto run_parallel = [&](auto vectors) {
-        executor_stl_t executor;
-        executor.fixed(tasks, [&](std::size_t /*thread_idx*/, std::size_t task_idx) {
-            native_->add(static_cast<default_key_t>(keys[task_idx]), vectors + task_idx * native_->dimensions());
-        });
-    };
-
-    Napi::TypedArray vectors = ctx[1].As<Napi::TypedArray>();
-    if (vectors.TypedArrayType() == napi_float32_array) {
-        run_parallel(vectors.As<Napi::Float32Array>().Data());
-    } else if (vectors.TypedArrayType() == napi_float64_array) {
-        run_parallel(vectors.As<Napi::Float64Array>().Data());
-    } else if (vectors.TypedArrayType() == napi_int8_array) {
-        run_parallel(vectors.As<Napi::Int8Array>().Data());
-    } else {
-        Napi::TypeError::New(ctx.Env(),
-                             "Unsupported TypedArray. Supported types are Float32Array, Float64Array, and Int8Array.")
-            .ThrowAsJavaScriptException();
-    }
-}
-
-Napi::Value CompiledIndex::Search(Napi::CallbackInfo const& ctx) {
-    Napi::Env env = ctx.Env();
-    Napi::TypedArray queries = ctx[0].As<Napi::TypedArray>();
-    std::size_t tasks = queries.ElementLength() / native_->dimensions();
-    std::size_t wanted = napi_argument_to_size(ctx[1]);
-
-    auto run_parallel = [&](auto vectors) -> Napi::Value {
-        Napi::Array result_js = Napi::Array::New(env, 3);
-        Napi::BigUint64Array matches_js = Napi::BigUint64Array::New(env, tasks * wanted);
-        Napi::Float32Array distances_js = Napi::Float32Array::New(env, tasks * wanted);
-        Napi::BigUint64Array counts_js = Napi::BigUint64Array::New(env, tasks);
-
-        auto matches_data = matches_js.Data();
-        auto distances_data = distances_js.Data();
-        auto counts_data = counts_js.Data();
-
-        try {
-            bool failed = false;
-            executor_stl_t executor;
-            executor.fixed(tasks, [&](std::size_t /*thread_idx*/, std::size_t task_idx) {
-                auto result = native_->search(vectors + task_idx * native_->dimensions(), wanted);
-                if (!result) {
-                    failed = true;
-                    Napi::TypeError::New(env, result.error.release()).ThrowAsJavaScriptException();
-                } else {
-                    counts_data[task_idx] = result.dump_to(matches_data + task_idx * native_->dimensions(),
-                                                           distances_data + task_idx * native_->dimensions());
-                }
-            });
-
-            if (failed)
-                return env.Null();
-
-        } catch (std::bad_alloc const&) {
-            Napi::TypeError::New(env, "Out of memory").ThrowAsJavaScriptException();
-            return env.Null();
-
-        } catch (...) {
-            Napi::TypeError::New(env, "Search failed").ThrowAsJavaScriptException();
-            return env.Null();
-        }
-
-        result_js.Set(0u, matches_js);
-        result_js.Set(1u, distances_js);
-        result_js.Set(2u, counts_js);
-        return result_js;
-    };
-
-    if (queries.TypedArrayType() == napi_float32_array) {
-        return run_parallel(queries.As<Napi::Float32Array>().Data());
-    } else if (queries.TypedArrayType() == napi_float64_array) {
-        return run_parallel(queries.As<Napi::Float64Array>().Data());
-    } else if (queries.TypedArrayType() == napi_int8_array) {
-        return run_parallel(queries.As<Napi::Int8Array>().Data());
-    } else {
-        Napi::TypeError::New(env,
-                             "Unsupported TypedArray. Supported types are Float32Array, Float64Array, and Int8Array.")
-            .ThrowAsJavaScriptException();
-        return env.Null();
-    }
-}
-
-Napi::Value CompiledIndex::Remove(Napi::CallbackInfo const& ctx) {
-    Napi::Env env = ctx.Env();
-    Napi::BigUint64Array keys = ctx[0].As<Napi::BigUint64Array>();
-    std::size_t length = keys.ElementLength();
-    Napi::Array result = Napi::Array::New(env, length);
-    for (std::size_t i = 0; i < length; ++i) {
-        result[i] = Napi::Number::New(env, native_->remove(static_cast<default_key_t>(keys[i])).completed);
-    }
-    return result;
-}
-
-Napi::Value CompiledIndex::Contains(Napi::CallbackInfo const& ctx) {
-    Napi::Env env = ctx.Env();
-    Napi::BigUint64Array keys = ctx[0].As<Napi::BigUint64Array>();
-    std::size_t length = keys.ElementLength();
-    Napi::Array result = Napi::Array::New(env, length);
-    for (std::size_t i = 0; i < length; ++i)
-        result[i] = Napi::Boolean::New(env, native_->contains(static_cast<default_key_t>(keys[i])));
-    return result;
-}
-
-Napi::Value CompiledIndex::Count(Napi::CallbackInfo const& ctx) {
-    Napi::Env env = ctx.Env();
-    Napi::BigUint64Array keys = ctx[0].As<Napi::BigUint64Array>();
-    std::size_t length = keys.ElementLength();
-    Napi::Array result = Napi::Array::New(env, length);
-    for (std::size_t i = 0; i < length; ++i)
-        result[i] = Napi::Boolean::New(env, native_->count(static_cast<default_key_t>(keys[i])));
-    return result;
-}
-
-Napi::Value exactSearch(Napi::CallbackInfo const& ctx) {
-    Napi::Env env = ctx.Env();
-
-    // Extracting parameters directly without additional type checks.
-    Napi::TypedArray dataset = ctx[0].As<Napi::TypedArray>();
-    Napi::ArrayBuffer datasetBuffer = dataset.ArrayBuffer();
-    Napi::TypedArray queries = ctx[1].As<Napi::TypedArray>();
-    Napi::ArrayBuffer queriesBuffer = queries.ArrayBuffer();
-    std::uint64_t dimensions = napi_argument_to_size(ctx[2]);
-    std::uint64_t wanted = napi_argument_to_size(ctx[3]);
-    metric_kind_t metric_kind = metric_from_name(ctx[4].As<Napi::String>().Utf8Value().c_str());
-
-    scalar_kind_t quantization;
-    std::size_t bytes_per_scalar;
-    switch (queries.TypedArrayType()) {
-    case napi_float64_array: quantization = scalar_kind_t::f64_k, bytes_per_scalar = 8; break;
-    case napi_int8_array: quantization = scalar_kind_t::i8_k, bytes_per_scalar = 1; break;
-    default: quantization = scalar_kind_t::f32_k, bytes_per_scalar = 4; break;
-    }
-
-    metric_punned_t metric(dimensions, metric_kind, quantization);
-    executor_default_t executor;
-    exact_search_t search;
-
-    // Performing the exact search.
-    std::size_t dataset_size = dataset.ElementLength() / dimensions;
-    std::size_t queries_size = queries.ElementLength() / dimensions;
-    auto results = search(                                     //
-        reinterpret_cast<byte_t const*>(datasetBuffer.Data()), //
-        dataset_size,                                          //
-        dimensions * bytes_per_scalar,                         //
-        reinterpret_cast<byte_t const*>(queriesBuffer.Data()), //
-        queries_size,                                          //
-        dimensions * bytes_per_scalar,                         //
-        wanted, metric, executor);
-
-    if (!results)
-        Napi::TypeError::New(env, "Out of memory").ThrowAsJavaScriptException();
-
-    // Constructing the result object
-    Napi::Array result_js = Napi::Array::New(env, 3);
-    Napi::BigUint64Array matches_js = Napi::BigUint64Array::New(env, queries_size * wanted);
-    Napi::Float32Array distances_js = Napi::Float32Array::New(env, queries_size * wanted);
-    Napi::BigUint64Array counts_js = Napi::BigUint64Array::New(env, queries_size);
-
-    auto matches_data = matches_js.Data();
-    auto distances_data = distances_js.Data();
-    auto counts_data = counts_js.Data();
-
-    // Export into JS buffers
-    for (std::size_t task_idx = 0; task_idx != queries_size; ++task_idx) {
-        auto result = results.at(task_idx);
-        counts_data[task_idx] = wanted;
-        for (std::size_t result_idx = 0; result_idx != wanted; ++result_idx) {
-            matches_data[task_idx * wanted + result_idx] = result[result_idx].offset;
-            distances_data[task_idx * wanted + result_idx] = result[result_idx].distance;
-        }
-    }
-
-    result_js.Set(0u, matches_js);
-    result_js.Set(1u, distances_js);
-    result_js.Set(2u, counts_js);
-    return result_js;
-}
-
-Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
-    exports.Set("exactSearch", Napi::Function::New(env, exactSearch));
-    return CompiledIndex::Init(env, exports);
-}
-
-NODE_API_MODULE(usearch, InitAll)

package/javascript/types/usearch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"usearch.d.ts","sourceRoot":"","sources":["../usearch.js"],"names":[],"mappings":"AAsIA;IAEI;;;;;;;;;;;OAWG;IACH;oBATkC,MAAM;gBAAU,UAAU;sBAAiC,UAAU;sBAAiC,MAAM;uBAAqB,MAAM;0BAAwB,MAAM;eAAa,OAAO;gBAChN,UAAU,iBACV,UAAU,iBACV,MAAM,kBACN,MAAM,qBACN,MAAM,UACN,OAAO,EAmCjB;IADG,oBAAwI;IAG5I;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,UAPW,MAAM,GAAC,MAAM,EAAE,GAAC,cAAc,WAE9B,YAAY,GAAC,YAAY,GAAC,SAAS,QAoB7C;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,gBANW,YAAY,GAAC,YAAY,GAAC,SAAS,GAAC,MAAM,MAAM,MAAM,CAAC,CAAC,KACxD,MAAM,GACL,OAAO,GAAC,YAAY,CAqB/B;IAED;;;;;;;;;OASG;IACH,eAJW,MAAM,GAAC,MAAM,EAAE,GAAC,cAAc,GAC7B,OAAO,GAAC,OAAO,EAAE,CAU5B;IAED;;;;;;OAMG;IACH,YAJW,MAAM,GAAC,MAAM,EAAE,GAAC,cAAc,GAC7B,MAAM,GAAC,MAAM,EAAE,CAU1B;IAED;;;;;;;;;OASG;IACH,aAJW,MAAM,GAAC,MAAM,EAAE,GAAC,cAAc,GAC7B,MAAM,GAAC,MAAM,EAAE,CAU1B;IAED;;;OAGG;IACH,cAFY,MAAM,CAEsC;IAExD;;;OAGG;IACH,gBAFY,MAAM,CAE0C;IAE5D;;;OAGG;IACH,QAFY,MAAM,CAE0B;IAE5C;;;OAGG;IACH,YAFY,MAAM,CAEkC;IAEpD;;;;OAIG;IACH,WAHW,MAAM,QAMhB;IAED;;;;OAIG;IACH,WAHW,MAAM,QAMhB;IAED;;;;OAIG;IACH,WAHW,MAAM,QAMhB;CACJ;;;;yBA5WS,MAAM;;;;;;;;;;;;;;;;;yBAmBN,MAAM;;;;;;;;;;AAYhB;;GAEG;AACH;IACI;;;;;OAKG;IACH,kBAHW,cAAc,aACd,YAAY,EAKtB;IAFG,qBAAgB;IAChB,wBAA0B;CAEjC;AAED;;GAEG;AACH;IACI;;;;;;;OAOG;IACH,kBALW,cAAc,aACd,YAAY,UACZ,cAAc,KACd,MAAM,EAOhB;IAJG,qBAAgB;IAChB,wBAA0B;IAC1B,uBAAoB;IACpB,UAAU;IAGd;;;;;OAKG;IACH,OAHW,MAAM,GACJ,OAAO,CAQnB;CACJ;AA+RD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qCA1BW,YAAY,GAAC,YAAY,GAAC,SAAS,GAAC,MAAM,MAAM,MAAM,CAAC,CAAC,WACxD,YAAY,GAAC,YAAY,GAAC,SAAS,GAAC,MAAM,MAAM,MAAM,CAAC,CAAC,cACxD,MAAM,SACN,MAAM,UACN,UAAU,GACT,OAAO,GAAC,YAAY,CA0D/B"}

package/javascript/usearch.test.js

@@ -1,74 +0,0 @@
-const test = require('node:test');
-const assert = require('node:assert');
-const usearch = require('./usearch.js');
-
-test('Single-entry operations', () => {
-    const index = new usearch.Index(2, 'l2sq');
-
-    assert.equal(index.connectivity(), 16, 'connectivity should be 16');
-    assert.equal(index.dimensions(), 2, 'dimensions should be 2');
-    assert.equal(index.size(), 0, 'initial size should be 0');
-
-    index.add(15n, new Float32Array([10, 20]));
-    index.add(16n, new Float32Array([10, 25]));
-
-    assert.equal(index.size(), 2, 'size after adding elements should be 2');
-    assert.equal(index.contains(15), true, 'entry must be present after insertion');
-
-    const results = index.search(new Float32Array([13, 14]), 2);
-
-    assert.deepEqual(results.keys, new BigUint64Array([15n, 16n]), 'keys should be 15 and 16');
-    assert.deepEqual(results.distances, new Float32Array([45, 130]), 'distances should be 45 and 130');
-});
-
-test('Batch operations', () => {
-    const indexBatch = new usearch.Index(2, 'l2sq');
-
-    const keys = [15n, 16n];
-    const vectors = [new Float32Array([10, 20]), new Float32Array([10, 25])];
-
-    indexBatch.add(keys, vectors);
-    assert.equal(indexBatch.size(), 2, 'size after adding batch should be 2');
-
-    const results = indexBatch.search(new Float32Array([13, 14]), 2);
-
-    assert.deepEqual(results.keys, new BigUint64Array([15n, 16n]), 'keys should be 15 and 16');
-    assert.deepEqual(results.distances, new Float32Array([45, 130]), 'distances should be 45 and 130');
-});
-
-test("Expected results", () => {
-    var index = new usearch.Index({
-        metric: "cos",
-        connectivity: 16,
-        dimensions: 3,
-    });
-    index.add(42n, new Float32Array([0.2, 0.6, 0.4]));
-    var results = index.search(new Float32Array([0.2, 0.6, 0.4]), 10);
-
-    assert.equal(index.size(), 1);
-    assert.deepEqual(results.keys, new BigUint64Array([42n]));
-    assert.deepEqual(results.distances, new Float32Array([0]));
-});
-
-
-
-test('Operations with invalid values', () => {
-    const indexBatch = new usearch.Index(2, 'l2sq');
-
-    const keys = [NaN, 16n];
-    const vectors = [new Float32Array([10, 30]), new Float32Array([1, 5])];
-
-    try {
-        indexBatch.add(keys, vectors);
-        throw new Error('indexBatch.add should have thrown an error.');
-    } catch (err) {
-        assert.equal(err.message, 'All keys must be integers or bigints.');
-    }
-
-    try {
-        indexBatch.search(NaN, 2);
-        throw new Error('indexBatch.search should have thrown an error.');
-    } catch (err) {
-        assert.equal(err.message, 'Vectors must be a TypedArray or an array of arrays.');
-    }
-});

package/package-ci.json

@@ -1,10 +0,0 @@
-{
-    "name": "usearch-ci",
-    "version": "1.0.0",
-    "devDependencies": {
-        "@semantic-release/exec": "^6.0.3",
-        "@semantic-release/git": "^10.0.1",
-        "conventional-changelog-eslint": "^3.0.9",
-        "semantic-release": "^21.1.2"
-    }
-}

package/pyproject.toml

@@ -1,51 +0,0 @@
-[build-system]
-requires = ["setuptools>=42", "wheel", "cmake>=3.22", "pybind11", "numpy"]
-build-backend = "setuptools.build_meta"
-
-[tool.pytest.ini_options]
-minversion = "6.0"
-addopts = ["-ra", "--showlocals", "--strict-markers", "--strict-config"]
-xfail_strict = true
-filterwarnings = ["error"]
-
-# Avoid running tests, as everything is happening in a super slow container
-# We have already run all the relavent Python tests in `prerelease.yml`
-#   test-requires = ["pytest", "numpy"]
-#   test-command = "pytest {project}/python/scripts"
-[tool.cibuildwheel]
-test-requires = []
-test-command = ""
-build-verbosity = 0
-skip = ["*musllinux*", "*i686*", "pp*", "cp36-*"]
-
-[tool.cibuildwheel.linux]
-before-build = [
-    "rm -rf {project}/CMakeCache.txt {project}/build {project}/build_debug {project}/CMakeFiles.txt {project}/_deps {project}/.pytest_cache",
-    "mkdir -p build/usearch",
-    "git submodule update --init --recursive",
-]
-manylinux-x86_64-image = "manylinux_2_28"
-manylinux-aarch64-image = "manylinux_2_28"
-
-archs = ["x86_64", "aarch64"]
-before-all = ["yum install -y glibc-devel wget python3-devel"]
-repair-wheel-command = "auditwheel repair --lib-sdir . -w {dest_dir} {wheel}"
-
-[tool.cibuildwheel.macos]
-before-build = [
-    "rm -rf {project}/CMakeCache.txt {project}/build {project}/build_debug {project}/CMakeFiles.txt {project}/_deps {project}/.pytest_cache",
-    "mkdir -p build/usearch",
-    "git submodule update --init --recursive",
-]
-archs = ["x86_64", "universal2", "arm64"]
-repair-wheel-command = "delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel}"
-
-
-[tool.cibuildwheel.windows]
-before-build = [
-    "rd /s /q {project}\\CMakeCache.txt {project}\\build {project}\\build_debug {project}\\CMakeFiles.txt {project}\\_deps {project}\\.pytest_cache || echo Done",
-    "md build\\usearch",
-    "git submodule update --init --recursive",
-]
-archs = ["x86", "AMD64"]
-skip = ["*win32*", "pp*", "cp36-*"]

package/setup.py

@@ -1,201 +0,0 @@
-import os
-import sys
-import subprocess
-from setuptools import setup
-
-from pybind11.setup_helpers import Pybind11Extension
-
-sources = ["python/lib.cpp"]
-compile_args = []
-link_args = []
-macros_args = []
-
-
-def get_bool_env(name: str, preference: bool) -> bool:
-    return os.environ.get(name, "1" if preference else "0") == "1"
-
-
-def get_bool_env_w_name(name: str, preference: bool) -> tuple:
-    return name, "1" if get_bool_env(name, preference) else "0"
-
-
-# Check the environment variables
-is_linux: bool = sys.platform == "linux"
-is_macos: bool = sys.platform == "darwin"
-is_windows: bool = sys.platform == "win32"
-
-
-is_gcc = False
-if is_linux:
-    cxx = os.environ.get("CXX")
-    if cxx:
-        try:
-            command = "where" if os.name == "nt" else "which"
-            full_path = subprocess.check_output([command, cxx], text=True).strip()
-            compiler_name = os.path.basename(full_path)
-            is_gcc = ("g++" in compiler_name) and ("clang++" not in compiler_name)
-        except subprocess.CalledProcessError:
-            pass
-
-
-prefer_simsimd: bool = is_linux or is_macos
-prefer_fp16lib: bool = True
-prefer_openmp: bool = is_linux and is_gcc
-
-use_simsimd: bool = get_bool_env("USEARCH_USE_SIMSIMD", prefer_simsimd)
-use_fp16lib: bool = get_bool_env("USEARCH_USE_FP16LIB", prefer_fp16lib)
-use_openmp: bool = get_bool_env("USEARCH_USE_OPENMP", prefer_openmp)
-
-
-# Common arguments for all platforms
-macros_args.append(("USEARCH_USE_OPENMP", "1" if use_openmp else "0"))
-macros_args.append(("USEARCH_USE_SIMSIMD", "1" if use_simsimd else "0"))
-macros_args.append(("USEARCH_USE_FP16LIB", "1" if use_fp16lib else "0"))
-
-if is_linux:
-    compile_args.append("-std=c++17")
-    compile_args.append("-O3")  # Maximize performance
-    compile_args.append("-ffast-math")  # Maximize floating-point performance
-    compile_args.append("-Wno-unknown-pragmas")
-    compile_args.append("-fdiagnostics-color=always")
-
-    # Simplify debugging, but the normal `-g` may make builds much longer!
-    compile_args.append("-g1")
-
-    if use_openmp:
-        compile_args.append("-fopenmp")
-        link_args.append("-lgomp")
-
-    if use_simsimd:
-        macros_args.extend(
-            [
-                get_bool_env_w_name("SIMSIMD_TARGET_X86_AVX512", True),
-                get_bool_env_w_name("SIMSIMD_TARGET_ARM_SVE", True),
-                get_bool_env_w_name("SIMSIMD_TARGET_X86_AVX2", True),
-                get_bool_env_w_name("SIMSIMD_TARGET_ARM_NEON", True),
-            ]
-        )
-
-if is_macos:
-    # MacOS 10.15 or higher is needed for `aligned_alloc` support.
-    # https://github.com/unum-cloud/usearch/actions/runs/4975434891/jobs/8902603392
-    compile_args.append("-mmacosx-version-min=10.15")
-    compile_args.append("-std=c++17")
-    compile_args.append("-O3")  # Maximize performance
-    compile_args.append("-ffast-math")  # Maximize floating-point performance
-    compile_args.append("-fcolor-diagnostics")
-    compile_args.append("-Wno-unknown-pragmas")
-
-    # Simplify debugging, but the normal `-g` may make builds much longer!
-    compile_args.append("-g1")
-
-    # Linking OpenMP requires additional preparation in CIBuildWheel.
-    # We must install `brew install llvm` ahead of time.
-    # import subprocess as cli
-    # llvm_base = cli.check_output(["brew", "--prefix", "llvm"]).strip().decode("utf-8")
-    # if len(llvm_base):
-    #     compile_args.append(f"-I{llvm_base}/include")
-    #     compile_args.append("-Xpreprocessor -fopenmp")
-    #     link_args.append(f"-L{llvm_base}/lib")
-    #     link_args.append("-lomp")
-    #     macros_args.append(("USEARCH_USE_OPENMP", "1"))
-
-    if use_simsimd:
-        macros_args.extend(
-            [
-                get_bool_env_w_name("SIMSIMD_TARGET_X86_AVX512", False),
-                get_bool_env_w_name("SIMSIMD_TARGET_ARM_SVE", False),
-                get_bool_env_w_name("SIMSIMD_TARGET_X86_AVX2", True),
-                get_bool_env_w_name("SIMSIMD_TARGET_ARM_NEON", True),
-            ]
-        )
-
-if is_windows:
-    compile_args.append("/std:c++17")
-    compile_args.append("/O2")
-    compile_args.append("/fp:fast")  # Enable fast math for MSVC
-    compile_args.append("/W1")  # Reduce warnings verbosity
-
-    # We don't actually want to use any SimSIMD stuff,
-    # as GCC attributes aren't compatible with MSVC
-    if use_simsimd:
-        macros_args.extend(
-            [
-                get_bool_env_w_name("SIMSIMD_TARGET_X86_AVX512", False),
-                get_bool_env_w_name("SIMSIMD_TARGET_ARM_SVE", False),
-                get_bool_env_w_name("SIMSIMD_TARGET_X86_AVX2", False),
-                get_bool_env_w_name("SIMSIMD_TARGET_ARM_NEON", False),
-            ]
-        )
-
-if is_linux or is_macos:
-    sources.append("sqlite/lib.cpp")
-    link_args.append("-lsqlite3")
-
-ext_modules = [
-    Pybind11Extension(
-        "usearch.compiled",
-        sources,
-        extra_compile_args=compile_args,
-        extra_link_args=link_args,
-        define_macros=macros_args,
-    ),
-]
-
-__version__ = open("VERSION", "r").read().strip()
-__lib_name__ = "usearch"
-
-this_directory = os.path.abspath(os.path.dirname(__file__))
-with open(os.path.join(this_directory, "README.md")) as f:
-    long_description = f.read()
-
-# Depending on the macros, adjust the include directories
-include_dirs = [
-    "include",
-    "python",
-    "stringzilla/include",
-]
-if use_simsimd:
-    include_dirs.append("simsimd/include")
-if use_fp16lib:
-    include_dirs.append("fp16/include")
-
-setup(
-    name=__lib_name__,
-    version=__version__,
-    packages=["usearch"],
-    package_dir={"usearch": "python/usearch"},
-    description="Smaller & Faster Single-File Vector Search Engine from Unum",
-    author="Ash Vardanian",
-    author_email="info@unum.cloud",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    license="Apache-2.0",
-    classifiers=[
-        "Development Status :: 5 - Production/Stable",
-        "Natural Language :: English",
-        "Intended Audience :: Developers",
-        "Intended Audience :: Information Technology",
-        "License :: OSI Approved :: Apache Software License",
-        "Programming Language :: C++",
-        "Programming Language :: Python :: 3 :: Only",
-        "Programming Language :: Python :: Implementation :: CPython",
-        "Programming Language :: Java",
-        "Programming Language :: JavaScript",
-        "Programming Language :: Objective C",
-        "Programming Language :: Rust",
-        "Programming Language :: Other",
-        "Operating System :: MacOS",
-        "Operating System :: Unix",
-        "Operating System :: Microsoft :: Windows",
-        "Topic :: System :: Clustering",
-        "Topic :: Database :: Database Engines/Servers",
-        "Topic :: Scientific/Engineering :: Artificial Intelligence",
-    ],
-    include_dirs=include_dirs,
-    ext_modules=ext_modules,
-    install_requires=[
-        "numpy",
-        "tqdm",
-    ],
-)