usearch 2.7.3 → 2.7.6

package/simsimd/python/lib.c

@@ -1,110 +1,491 @@
 /**
- *  @file python.c
- *  @author Ash Vardanian
- *  @date 2023-01-30
- *  @copyright Copyright (c) 2023
- *
- *  @brief Pure CPython bindings for SimSIMD.
+ *  @brief      Pure CPython bindings for SimSIMD.
+ *  @file       lib.c
+ *  @author     Ash Vardanian
+ *  @date       January 1, 2023
+ *  @copyright  Copyright (c) 2023
  */
-#define SIMSIMD_TARGET_ARM_NEON 1
-#define SIMSIMD_TARGET_X86_AVX2 1
 #if __linux__
+#define SIMSIMD_TARGET_ARM_NEON 1
 #define SIMSIMD_TARGET_ARM_SVE 1
+#define SIMSIMD_TARGET_X86_AVX2 1
 #define SIMSIMD_TARGET_X86_AVX512 1
+#include <omp.h>
+#elif defined(_MSC_VER)
+#define SIMSIMD_TARGET_ARM_NEON 0
+#define SIMSIMD_TARGET_ARM_SVE 0
+#define SIMSIMD_TARGET_X86_AVX2 0
+#define SIMSIMD_TARGET_X86_AVX512 0
+#elif defined(__APPLE__)
+#define SIMSIMD_TARGET_ARM_NEON 1
+#define SIMSIMD_TARGET_ARM_SVE 0
+#define SIMSIMD_TARGET_X86_AVX2 1
+#define SIMSIMD_TARGET_X86_AVX512 0
 #endif
 
+#define SIMSIMD_RSQRT simsimd_approximate_inverse_square_root
+#define SIMSIMD_LOG simsimd_approximate_log
 #include "simsimd/simsimd.h"
-#include "simsimd/simsimd_chem.h"
 
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
+#include <numpy/arrayobject.h>
+
+typedef struct parsed_vector_or_matrix_t {
+    char* start;
+    size_t dimensions;
+    size_t count;
+    size_t stride;
+    int is_flat;
+    simsimd_datatype_t datatype;
+} parsed_vector_or_matrix_t;
 
-static void pseudo_destroy(PyObject* obj) { (void)obj; }
+/// @brief  Global variable that caches the CPU capabilities, and is computed just onc, when the module is loaded.
+simsimd_capability_t static_capabilities = simsimd_cap_serial_k;
 
-PyObject* distance(void* func) { return PyCapsule_New(func, NULL, pseudo_destroy); }
+int same_string(char const* a, char const* b) { return strcmp(a, b) == 0; }
 
-static PyObject* to_int(PyObject* self, PyObject* args) {
-    PyObject* capsule;
-    if (!PyArg_ParseTuple(args, "O", &capsule)) {
+simsimd_datatype_t numpy_string_to_datatype(char const* name) {
+    // https://docs.python.org/3/library/struct.html#format-characters
+    if (same_string(name, "f") || same_string(name, "<f") || same_string(name, "f4") || same_string(name, "<f4"))
+        return simsimd_datatype_f32_k;
+    else if (same_string(name, "e") || same_string(name, "<e") || same_string(name, "f2") || same_string(name, "<f2"))
+        return simsimd_datatype_f16_k;
+    else if (same_string(name, "b") || same_string(name, "<b") || same_string(name, "i1") || same_string(name, "|i1"))
+        return simsimd_datatype_i8_k;
+    else if (same_string(name, "B") || same_string(name, "<B") || same_string(name, "u1") || same_string(name, "|u1"))
+        return simsimd_datatype_b8_k;
+    else if (same_string(name, "d") || same_string(name, "<d") || same_string(name, "i8") || same_string(name, "<i8"))
+        return simsimd_datatype_f64_k;
+    else
+        return simsimd_datatype_unknown_k;
+}
+
+simsimd_datatype_t python_string_to_datatype(char const* name) {
+    if (same_string(name, "f") || same_string(name, "f32"))
+        return simsimd_datatype_f32_k;
+    else if (same_string(name, "h") || same_string(name, "f16"))
+        return simsimd_datatype_f16_k;
+    else if (same_string(name, "c") || same_string(name, "i8"))
+        return simsimd_datatype_i8_k;
+    else if (same_string(name, "b") || same_string(name, "b8"))
+        return simsimd_datatype_b8_k;
+    else if (same_string(name, "d") || same_string(name, "f64"))
+        return simsimd_datatype_f64_k;
+    else
+        return simsimd_datatype_unknown_k;
+}
+
+simsimd_metric_kind_t python_string_to_metric_kind(char const* name) {
+    if (same_string(name, "sqeuclidean"))
+        return simsimd_metric_sqeuclidean_k;
+    else if (same_string(name, "inner"))
+        return simsimd_metric_inner_k;
+    else if (same_string(name, "cosine"))
+        return simsimd_metric_cosine_k;
+    else if (same_string(name, "hamming"))
+        return simsimd_metric_hamming_k;
+    else if (same_string(name, "jaccard"))
+        return simsimd_metric_jaccard_k;
+    else if (same_string(name, "kullbackleibler") || same_string(name, "kl"))
+        return simsimd_metric_kl_k;
+    else if (same_string(name, "jensenshannon") || same_string(name, "js"))
+        return simsimd_metric_js_k;
+    else if (same_string(name, "jaccard"))
+        return simsimd_metric_jaccard_k;
+    else
+        return simsimd_metric_unknown_k;
+}
+
+static PyObject* api_get_capabilities(PyObject* self) {
+    simsimd_capability_t caps = static_capabilities;
+    PyObject* cap_dict = PyDict_New();
+    if (!cap_dict)
         return NULL;
+
+#define ADD_CAP(name) PyDict_SetItemString(cap_dict, #name, PyBool_FromLong(caps& simsimd_cap_##name##_k))
+
+    ADD_CAP(serial);
+    ADD_CAP(arm_neon);
+    ADD_CAP(arm_sve);
+    ADD_CAP(arm_sve2);
+    ADD_CAP(x86_avx2);
+    ADD_CAP(x86_avx512);
+    ADD_CAP(x86_avx2fp16);
+    ADD_CAP(x86_avx512fp16);
+    ADD_CAP(x86_avx512vpopcntdq);
+
+#undef ADD_CAP
+
+    return cap_dict;
+}
+
+int parse_tensor(PyObject* tensor, Py_buffer* buffer, parsed_vector_or_matrix_t* parsed) {
+    if (PyObject_GetBuffer(tensor, buffer, PyBUF_STRIDES | PyBUF_FORMAT) != 0) {
+        PyErr_SetString(PyExc_TypeError, "arguments must support buffer protocol");
+        return -1;
+    }
+    parsed->start = buffer->buf;
+    parsed->datatype = numpy_string_to_datatype(buffer->format);
+    if (buffer->ndim == 1) {
+        if (buffer->strides[0] > buffer->itemsize) {
+            PyErr_SetString(PyExc_ValueError, "input vectors must be contiguous");
+            PyBuffer_Release(buffer);
+            return -1;
+        }
+        parsed->is_flat = 1;
+        parsed->dimensions = buffer->shape[0];
+        parsed->count = 1;
+        parsed->stride = 0;
+    } else if (buffer->ndim == 2) {
+        if (buffer->strides[1] > buffer->itemsize) {
+            PyErr_SetString(PyExc_ValueError, "input vectors must be contiguous");
+            PyBuffer_Release(buffer);
+            return -1;
+        }
+        parsed->is_flat = 0;
+        parsed->dimensions = buffer->shape[1];
+        parsed->count = buffer->shape[0];
+        parsed->stride = buffer->strides[0];
+    } else {
+        PyErr_SetString(PyExc_ValueError, "input tensors must be 1D or 2D");
+        PyBuffer_Release(buffer);
+        return -1;
     }
+    return 0;
+}
 
-    if (!PyCapsule_IsValid(capsule, NULL)) {
-        PyErr_SetString(PyExc_ValueError, "Object is not a valid capsule");
+static PyObject* impl_metric(simsimd_metric_kind_t metric_kind, PyObject* const* args, Py_ssize_t nargs) {
+    if (nargs != 2) {
+        PyErr_SetString(PyExc_TypeError, "function expects exactly 2 arguments");
         return NULL;
     }
 
-    void* pointer = PyCapsule_GetPointer(capsule, NULL);
+    PyObject* output = NULL;
+    PyObject* input_tensor_a = args[0];
+    PyObject* input_tensor_b = args[1];
+    Py_buffer buffer_a, buffer_b;
+    parsed_vector_or_matrix_t parsed_a, parsed_b;
+    if (parse_tensor(input_tensor_a, &buffer_a, &parsed_a) != 0 ||
+        parse_tensor(input_tensor_b, &buffer_b, &parsed_b) != 0) {
+        return NULL; // Error already set by parse_tensor
+    }
 
-    return PyLong_FromVoidPtr(pointer);
-}
+    // Check dimensions
+    if (parsed_a.dimensions != parsed_b.dimensions) {
+        PyErr_SetString(PyExc_ValueError, "vector dimensions don't match");
+        goto cleanup;
+    }
+    if (parsed_a.count == 0 || parsed_b.count == 0) {
+        PyErr_SetString(PyExc_ValueError, "collections can't be empty");
+        goto cleanup;
+    }
+    if (parsed_a.count > 1 && parsed_b.count > 1 && parsed_a.count != parsed_b.count) {
+        PyErr_SetString(PyExc_ValueError, "collections must have the same number of elements or just one element");
+        goto cleanup;
+    }
 
-static PyMethodDef simsimd_methods[] = {
-    {"to_int", (PyCFunction)to_int, METH_VARARGS, "Converts CPython capsule to `int`"},
-    {NULL, NULL, 0, NULL} /* Sentinel */
-};
+    // Check data types
+    if (parsed_a.datatype != parsed_b.datatype && parsed_a.datatype != simsimd_datatype_unknown_k &&
+        parsed_b.datatype != simsimd_datatype_unknown_k) {
+        PyErr_SetString(PyExc_ValueError, "input tensors must have matching and supported datatypes");
+        goto cleanup;
+    }
 
-static PyModuleDef simsimd_module = {
-    PyModuleDef_HEAD_INIT,
-    .m_name = "SimSIMD",
-    .m_doc = "SIMD-accelerated similarity measures for x86 and Arm: AVX2, AVX512, NEON, SVE",
-    .m_size = -1,
-    .m_methods = simsimd_methods,
-};
+    simsimd_metric_punned_t metric = NULL;
+    simsimd_capability_t capability = simsimd_cap_serial_k;
+    simsimd_datatype_t datatype = parsed_a.datatype;
+    simsimd_find_metric_punned(metric_kind, datatype, static_capabilities, simsimd_cap_any_k, &metric, &capability);
+    if (!metric) {
+        PyErr_SetString(PyExc_ValueError, "unsupported metric and datatype combination");
+        goto cleanup;
+    }
 
-PyMODINIT_FUNC PyInit_simsimd(void) {
-    PyObject* m = PyModule_Create(&simsimd_module);
-    if (m == NULL)
-        return NULL;
+    // If the distance is computed between two vectors, rather than matrices, return a scalar
+    if (parsed_a.is_flat && parsed_b.is_flat) {
+        output = PyFloat_FromDouble(metric(parsed_a.start, parsed_b.start, parsed_a.dimensions, parsed_b.dimensions));
+    } else {
 
-    PyModule_AddObject(m, "tanimoto_b1x8_naive", distance(&simsimd_tanimoto_b1x8_naive));
+        // In some batch requests we may be computing the distance from multiple vectors to one,
+        // so the stride must be set to zero avoid illegal memory access
+        if (parsed_a.count == 1)
+            parsed_a.stride = 0;
+        if (parsed_b.count == 1)
+            parsed_b.stride = 0;
 
-    // Specialized:
-    PyModule_AddObject(m, "tanimoto_maccs_naive", distance(&simsimd_tanimoto_maccs_naive));
-    PyModule_AddObject(m, "tanimoto_conditional_naive", distance(&simsimd_tanimoto_conditional_naive));
+        size_t count_max = parsed_a.count > parsed_b.count ? parsed_a.count : parsed_b.count;
 
-#if SIMSIMD_TARGET_ARM
-    PyModule_AddObject(m, "dot_f32x4_neon", distance(&simsimd_dot_f32x4_neon));
-    PyModule_AddObject(m, "cos_f16x4_neon", distance(&simsimd_cos_f16x4_neon));
-    PyModule_AddObject(m, "cos_i8x16_neon", distance(&simsimd_cos_i8x16_neon));
-    PyModule_AddObject(m, "cos_f32x4_neon", distance(&simsimd_cos_f32x4_neon));
+        // Compute the distances
+        float* distances = malloc(count_max * sizeof(float));
+        for (size_t i = 0; i < count_max; ++i)
+            distances[i] = metric(                    //
+                parsed_a.start + i * parsed_a.stride, //
+                parsed_b.start + i * parsed_b.stride, //
+                parsed_a.dimensions,                  //
+                parsed_b.dimensions);
 
-    // Specialized:
-    PyModule_AddObject(m, "tanimoto_maccs_neon", distance(&simsimd_tanimoto_maccs_neon));
+        // Create a new PyArray object for the output
+        npy_intp dims[1] = {count_max};
+        PyArray_Descr* descr = PyArray_DescrFromType(NPY_FLOAT32);
+        PyArrayObject* output_array = (PyArrayObject*)PyArray_NewFromDescr( //
+            &PyArray_Type, descr, 1, dims, NULL, distances, NPY_ARRAY_OWNDATA | NPY_ARRAY_C_CONTIGUOUS, NULL);
 
-#if SIMSIMD_TARGET_ARM_SVE
-    PyModule_AddObject(m, "dot_f32_sve", distance(&simsimd_dot_f32_sve));
-    PyModule_AddObject(m, "cos_f32_sve", distance(&simsimd_cos_f32_sve));
-    PyModule_AddObject(m, "cos_f16_sve", distance(&simsimd_cos_f16_sve));
-    PyModule_AddObject(m, "l2sq_f32_sve", distance(&simsimd_l2sq_f32_sve));
-    PyModule_AddObject(m, "l2sq_f16_sve", distance(&simsimd_l2sq_f16_sve));
-    PyModule_AddObject(m, "hamming_b1x8_sve", distance(&simsimd_hamming_b1x8_sve));
-    PyModule_AddObject(m, "hamming_b1x128_sve", distance(&simsimd_hamming_b1x128_sve));
+        if (!output_array) {
+            free(distances);
+            goto cleanup;
+        }
 
-    // Specialized:
-    PyModule_AddObject(m, "tanimoto_maccs_sve", distance(&simsimd_tanimoto_maccs_sve));
-#endif
-#endif
+        output = output_array;
+    }
 
-#if SIMSIMD_TARGET_X86
-    PyModule_AddObject(m, "dot_f32x4_avx2", distance(&simsimd_dot_f32x4_avx2));
-    PyModule_AddObject(m, "cos_f32x4_avx2", distance(&simsimd_cos_f32x4_avx2));
-    PyModule_AddObject(m, "l2sq_f32x4_avx2", distance(&simsimd_l2sq_f32x4_avx2));
-    PyModule_AddObject(m, "dot_f16x8_avx2", distance(&simsimd_dot_f16x8_avx2));
-    PyModule_AddObject(m, "cos_f16x8_avx2", distance(&simsimd_cos_f16x8_avx2));
-    PyModule_AddObject(m, "l2sq_f16x8_avx2", distance(&simsimd_l2sq_f16x8_avx2));
+cleanup:
+    PyBuffer_Release(&buffer_a);
+    PyBuffer_Release(&buffer_b);
+    return output;
+}
 
-#if SIMSIMD_TARGET_X86_AVX512
-    PyModule_AddObject(m, "dot_f16x16_avx512", distance(&simsimd_dot_f16x16_avx512));
-    PyModule_AddObject(m, "cos_f16x16_avx512", distance(&simsimd_cos_f16x16_avx512));
-    PyModule_AddObject(m, "l2sq_f16x16_avx512", distance(&simsimd_l2sq_f16x16_avx512));
+static PyObject* impl_cdist(                            //
+    PyObject* input_tensor_a, PyObject* input_tensor_b, //
+    simsimd_metric_kind_t metric_kind, size_t threads) {
 
-    PyModule_AddObject(m, "hamming_b1x128_avx512", distance(&simsimd_hamming_b1x128_avx512));
+    PyObject* output = NULL;
+    Py_buffer buffer_a, buffer_b;
+    parsed_vector_or_matrix_t parsed_a, parsed_b;
+    if (parse_tensor(input_tensor_a, &buffer_a, &parsed_a) != 0 ||
+        parse_tensor(input_tensor_b, &buffer_b, &parsed_b) != 0) {
+        return NULL; // Error already set by parse_tensor
+    }
+
+    // Check dimensions
+    if (parsed_a.dimensions != parsed_b.dimensions) {
+        PyErr_SetString(PyExc_ValueError, "vector dimensions don't match");
+        goto cleanup;
+    }
+    if (parsed_a.count == 0 || parsed_b.count == 0) {
+        PyErr_SetString(PyExc_ValueError, "collections can't be empty");
+        goto cleanup;
+    }
 
-    // Specialized:
-    PyModule_AddObject(m, "tanimoto_maccs_avx512", distance(&simsimd_tanimoto_maccs_avx512));
+    // Check data types
+    if (parsed_a.datatype != parsed_b.datatype && parsed_a.datatype != simsimd_datatype_unknown_k &&
+        parsed_b.datatype != simsimd_datatype_unknown_k) {
+        PyErr_SetString(PyExc_ValueError, "input tensors must have matching and supported datatypes");
+        goto cleanup;
+    }
+
+    simsimd_metric_punned_t metric = NULL;
+    simsimd_capability_t capability = simsimd_cap_serial_k;
+    simsimd_datatype_t datatype = parsed_a.datatype;
+    simsimd_find_metric_punned(metric_kind, datatype, static_capabilities, simsimd_cap_any_k, &metric, &capability);
+    if (!metric) {
+        PyErr_SetString(PyExc_ValueError, "unsupported metric and datatype combination");
+        goto cleanup;
+    }
+
+    // If the distance is computed between two vectors, rather than matrices, return a scalar
+    if (parsed_a.is_flat && parsed_b.is_flat) {
+        output = PyFloat_FromDouble(metric(parsed_a.start, parsed_b.start, parsed_a.dimensions, parsed_b.dimensions));
+    } else {
+
+#ifdef __linux__
+#ifdef _OPENMP
+        if (threads == 0)
+            threads = omp_get_num_procs();
+        omp_set_num_threads(threads);
 #endif
 #endif
+        // Compute the distances
+        float* distances = malloc(parsed_a.count * parsed_b.count * sizeof(float));
+#pragma omp parallel for collapse(2)
+        for (size_t i = 0; i < parsed_a.count; ++i)
+            for (size_t j = 0; j < parsed_b.count; ++j)
+                distances[i * parsed_b.count + j] = metric( //
+                    parsed_a.start + i * parsed_a.stride,   //
+                    parsed_b.start + j * parsed_b.stride,   //
+                    parsed_a.dimensions,                    //
+                    parsed_b.dimensions);
+
+        // Create a new PyArray object for the output
+        npy_intp dims[2] = {parsed_a.count, parsed_b.count};
+        PyArray_Descr* descr = PyArray_DescrFromType(NPY_FLOAT32);
+        PyArrayObject* output_array = (PyArrayObject*)PyArray_NewFromDescr( //
+            &PyArray_Type, descr, 2, dims, NULL, distances, NPY_ARRAY_OWNDATA | NPY_ARRAY_C_CONTIGUOUS, NULL);
+
+        if (!output_array) {
+            free(distances);
+            goto cleanup;
+        }
+
+        output = output_array;
+    }
+
+cleanup:
+    PyBuffer_Release(&buffer_a);
+    PyBuffer_Release(&buffer_b);
+    return output;
+}
+
+static PyObject* impl_pointer(simsimd_metric_kind_t metric_kind, PyObject* args) {
+    char const* type_name = PyUnicode_AsUTF8(PyTuple_GetItem(args, 0));
+    if (!type_name) {
+        PyErr_SetString(PyExc_ValueError, "Invalid type name");
+        return NULL;
+    }
+
+    simsimd_datatype_t datatype = python_string_to_datatype(type_name);
+    if (!type_name) {
+        PyErr_SetString(PyExc_ValueError, "Unsupported type");
+        return NULL;
+    }
+
+    simsimd_metric_punned_t metric = NULL;
+    simsimd_capability_t capability = simsimd_cap_serial_k;
+    simsimd_find_metric_punned(metric_kind, datatype, static_capabilities, simsimd_cap_any_k, &metric, &capability);
+    if (metric == NULL) {
+        PyErr_SetString(PyExc_ValueError, "No such metric");
+        return NULL;
+    }
+
+    return PyLong_FromUnsignedLongLong((unsigned long long)metric);
+}
+
+static PyObject* api_cdist(PyObject* self, PyObject* args, PyObject* kwargs) {
+    PyObject *input_tensor_a, *input_tensor_b;
+    PyObject* metric_obj = NULL;
+    PyObject* threads_obj = NULL;
+
+    if (!PyTuple_Check(args) || PyTuple_Size(args) < 2) {
+        PyErr_SetString(PyExc_TypeError, "function expects at least 2 positional arguments");
+        return NULL;
+    }
+
+    input_tensor_a = PyTuple_GetItem(args, 0);
+    input_tensor_b = PyTuple_GetItem(args, 1);
+    if (PyTuple_Size(args) > 2)
+        metric_obj = PyTuple_GetItem(args, 2);
+    if (PyTuple_Size(args) > 3)
+        threads_obj = PyTuple_GetItem(args, 3);
+
+    // Checking for named arguments in kwargs
+    if (kwargs) {
+        if (!metric_obj) {
+            metric_obj = PyDict_GetItemString(kwargs, "metric");
+        } else if (PyDict_GetItemString(kwargs, "metric")) {
+            PyErr_SetString(PyExc_TypeError, "Duplicate argument for 'metric'");
+            return NULL;
+        }
+
+        if (!threads_obj) {
+            threads_obj = PyDict_GetItemString(kwargs, "threads");
+        } else if (PyDict_GetItemString(kwargs, "threads")) {
+            PyErr_SetString(PyExc_TypeError, "Duplicate argument for 'threads'");
+            return NULL;
+        }
+    }
+
+    // Process the PyObject values
+    simsimd_metric_kind_t metric_kind = simsimd_metric_l2sq_k;
+    if (metric_obj) {
+        char const* metric_str = PyUnicode_AsUTF8(metric_obj);
+        if (!metric_str && PyErr_Occurred()) {
+            PyErr_SetString(PyExc_TypeError, "Expected 'metric' to be a string");
+            return NULL;
+        }
+        metric_kind = python_string_to_metric_kind(metric_str);
+        if (metric_kind == simsimd_metric_unknown_k) {
+            PyErr_SetString(PyExc_ValueError, "Unsupported metric");
+            return NULL;
+        }
+    }
+
+    size_t threads = 1;
+    if (threads_obj)
+        threads = PyLong_AsSize_t(threads_obj);
+    if (PyErr_Occurred()) {
+        PyErr_SetString(PyExc_TypeError, "Expected 'threads' to be an unsigned integer");
+        return NULL;
+    }
+
+    return impl_cdist(input_tensor_a, input_tensor_b, metric_kind, threads);
+}
+
+static PyObject* api_l2sq_pointer(PyObject* self, PyObject* args) { return impl_pointer(simsimd_metric_l2sq_k, args); }
+static PyObject* api_cos_pointer(PyObject* self, PyObject* args) { return impl_pointer(simsimd_metric_cos_k, args); }
+static PyObject* api_ip_pointer(PyObject* self, PyObject* args) { return impl_pointer(simsimd_metric_ip_k, args); }
+static PyObject* api_kl_pointer(PyObject* self, PyObject* args) { return impl_pointer(simsimd_metric_kl_k, args); }
+static PyObject* api_js_pointer(PyObject* self, PyObject* args) { return impl_pointer(simsimd_metric_js_k, args); }
+static PyObject* api_hamming_pointer(PyObject* self, PyObject* args) {
+    return impl_pointer(simsimd_metric_hamming_k, args);
+}
+static PyObject* api_jaccard_pointer(PyObject* self, PyObject* args) {
+    return impl_pointer(simsimd_metric_jaccard_k, args);
+}
+
+static PyObject* api_l2sq(PyObject* self, PyObject* const* args, Py_ssize_t nargs) {
+    return impl_metric(simsimd_metric_l2sq_k, args, nargs);
+}
+static PyObject* api_cos(PyObject* self, PyObject* const* args, Py_ssize_t nargs) {
+    return impl_metric(simsimd_metric_cos_k, args, nargs);
+}
+static PyObject* api_ip(PyObject* self, PyObject* const* args, Py_ssize_t nargs) {
+    return impl_metric(simsimd_metric_ip_k, args, nargs);
+}
+static PyObject* api_kl(PyObject* self, PyObject* const* args, Py_ssize_t nargs) {
+    return impl_metric(simsimd_metric_kl_k, args, nargs);
+}
+static PyObject* api_js(PyObject* self, PyObject* const* args, Py_ssize_t nargs) {
+    return impl_metric(simsimd_metric_js_k, args, nargs);
+}
+static PyObject* api_hamming(PyObject* self, PyObject* const* args, Py_ssize_t nargs) {
+    return impl_metric(simsimd_metric_hamming_k, args, nargs);
+}
+static PyObject* api_jaccard(PyObject* self, PyObject* const* args, Py_ssize_t nargs) {
+    return impl_metric(simsimd_metric_jaccard_k, args, nargs);
+}
+
+static PyMethodDef simsimd_methods[] = {
+    // Introspecting library and hardware capabilities
+    {"get_capabilities", api_get_capabilities, METH_NOARGS, "Get hardware capabilities"},
+
+    // NumPy and SciPy compatible interfaces (two matrix or vector arguments)
+    {"sqeuclidean", api_l2sq, METH_FASTCALL, "L2sq (Sq. Euclidean) distances between a pair of matrices"},
+    {"cosine", api_cos, METH_FASTCALL, "Cosine (Angular) distances between a pair of matrices"},
+    {"inner", api_ip, METH_FASTCALL, "Inner (Dot) Product distances between a pair of matrices"},
+    {"hamming", api_hamming, METH_FASTCALL, "Hamming distances between a pair of matrices"},
+    {"jaccard", api_jaccard, METH_FASTCALL, "Jaccard (Bitwise Tanimoto) distances between a pair of matrices"},
+    {"kullbackleibler", api_kl, METH_FASTCALL, "Kullback-Leibler divergence between probability distributions"},
+    {"jensenshannon", api_js, METH_FASTCALL, "Jensen-Shannon divergence between probability distributions"},
+
+    // Conventional `cdist` and `pdist` insterfaces with third string argument, and optional `threads` arg
+    {"cdist", api_cdist, METH_VARARGS | METH_KEYWORDS,
+     "Compute distance between each pair of the two collections of inputs"},
+
+    // Exposing underlying API for USearch
+    {"pointer_to_sqeuclidean", api_l2sq_pointer, METH_VARARGS, "L2sq (Sq. Euclidean) function pointer as `int`"},
+    {"pointer_to_cosine", api_cos_pointer, METH_VARARGS, "Cosine (Angular) function pointer as `int`"},
+    {"pointer_to_inner", api_ip_pointer, METH_VARARGS, "Inner (Dot) Product function pointer as `int`"},
+    {"pointer_to_kullbackleibler", api_ip_pointer, METH_VARARGS, "Kullback-Leibler function pointer as `int`"},
+    {"pointer_to_jensenshannon", api_ip_pointer, METH_VARARGS, "Jensen-Shannon function pointer as `int`"},
+
+    // Sentinel
+    {NULL, NULL, 0, NULL}};
+
+static PyModuleDef simsimd_module = {
+    PyModuleDef_HEAD_INIT,
+    .m_name = "SimSIMD",
+    .m_doc = "Vector Similarity Functions 3x-200x Faster than SciPy and NumPy",
+    .m_size = -1,
+    .m_methods = simsimd_methods,
+};
+
+PyMODINIT_FUNC PyInit_simsimd(void) {
+    _import_array();
+    PyObject* module = PyModule_Create(&simsimd_module);
+
+    // Open the VERSION file to add the `simsimd.__version__` attribute
+    if (module)
+        PyModule_AddStringConstant(module, "__version__", "2.1.1");
 
-    return m;
+    static_capabilities = simsimd_capabilities();
+    return module;
 }