bsonsearch 2.1.2__cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl

bsonsearch/__init__.py

@@ -0,0 +1,191 @@
+"""
+wrapper for bsonsearch
+"""
+
+from .matcher_module import Matcher, Document, Utils
+
+
+try:
+    import yara
+    import io
+    import bson
+
+    def YARA_DICT(compiled_rule):
+        compiled_binary_rule = io.BytesIO()
+        compiled_rule.save(file=compiled_binary_rule)
+        return {"$yara":bson.Binary(compiled_binary_rule.getvalue())}
+
+    def YARA_LOAD(fn):
+        compiled_rule = yara.load(fn)
+        return YARA_DICT(compiled_rule)
+
+    def YARA_COMPILE(fn):
+        compiled_rule = yara.compile(fn)
+        return YARA_DICT(compiled_rule)
+
+    def YARA_COMPILE_STR(source):
+        compiled_rule = yara.compile(source=source)
+        return YARA_DICT(compiled_rule)
+
+    def YARA_SOURCE_STR(source):
+        assert isinstance(source, bytes)
+        return {"$yara": {"source": source}}
+
+except ImportError:
+    yara = None
+
+
+try:
+    import discodb
+    import bson
+    DISCO_VALUE_ONLY = "$valueonly"
+    DISCO_KEY_EXISTS = "$keyexists"
+    DISCO_VALUE_IS = "$valueis"
+    DISCO_CNF_QUERY = "$Q"
+    DISCO_DDB_FILE = "$ddb"
+
+    def DISCO_VALUE_IS_CONFIG(**kwargs):
+        spec = {
+            kwargs["ns"]: {
+                "$module": {
+                    "name": "disco",
+                    "config": {
+                        DISCO_VALUE_IS: kwargs['value'],
+                        DISCO_DDB_FILE: kwargs["ddb"]
+                    }
+                }
+            }
+        }
+        return spec
+
+    def DISCO_VALUE_ONLY_CONFIG(**kwargs):
+        spec = {
+            kwargs["ns"]: {
+                "$module": {
+                    "name": "disco",
+                    "config": {
+                        DISCO_VALUE_ONLY: kwargs['value'],
+                        DISCO_DDB_FILE: kwargs["ddb"]
+                    }
+                }
+            }
+        }
+        return spec
+
+    def DISCO_KEY_EXISTS_CONFIG(**kwargs):
+        spec = {
+            kwargs["ns"]: {
+                "$module": {
+                    "name": "disco",
+                    "config": {
+                        DISCO_KEY_EXISTS: 0,
+                        DISCO_DDB_FILE: kwargs["ddb"]
+                    }
+                }
+            }
+        }
+        return spec
+
+
+    def DISCO_QUERY_CONFIG(**kwargs):
+        config = bson.son.SON()
+        config['$ddb'] = kwargs["ddb"]
+        config[DISCO_CNF_QUERY] = discodb.Q.parse(kwargs["cnf"]).deploy()
+        config['precache'] = kwargs.get("precache", False)
+        spec = {
+            kwargs["ns"]: {
+                "$module": {
+                    "name": "disco",
+                    "config": config
+                }
+            }
+        }
+        return spec
+
+    def DISCODB_CNF_TO_DICT(cnf_string):
+        return discodb.Q.parse(cnf_string).deploy()
+except ImportError:
+    discodb = None
+
+
+try:
+    import IPy
+    import struct
+    from bson.binary import Binary
+    def pack_ip(ip_string):
+        '''
+
+        :param ip_string: String representation of ipv4 or ipv6 address ("127.0.0.1" or "::1"
+        :return: Binary encapsulated and packed 16 byte integer
+        '''
+        ip = IPy.IP(ip_string)
+        ip_int = ip.int()
+        ip_bin = Binary(struct.pack(">QQ", ip_int/(2**64), ip_int%(2**64)), 0x80+ip.version())
+        return ip_bin
+
+    def ip_inrange_query(namespace, ip_string, netmask):
+        """
+        builds the $inIPRange
+        :param namespace:
+        :param ip_string:
+        :param netmask:
+        :return:
+        """
+        assert namespace
+        ip_bin = pack_ip(ip_string)
+        nm_bin = pack_ip(netmask)
+        assert ip_bin.subtype == nm_bin.subtype
+        return {namespace: {"$inIPrange": [ip_bin, nm_bin]}}
+
+    def ip_inrangeset_query(namespace, list_of_ip_netmask_tuples):
+        """
+
+        :param namespace:
+        :param list_of_ip_netmask_tuples: [(ip1,mask1), (ip2,mask2)...]
+        :return:dict
+        """
+        setlist = []
+        assert namespace
+        for ip_string, netmask in list_of_ip_netmask_tuples:
+            ip_bin = pack_ip(ip_string)
+            nm_bin = pack_ip(netmask)
+            setlist.append([ip_bin, nm_bin])
+        assert ip_bin.subtype == nm_bin.subtype
+        return {namespace: {"$inIPrangeset": setlist}}
+except ImportError:
+    pack_ip = None
+
+
+
+# list_of_tuples = unroll("", [], highly_embedded_dict)
+def unroll(current_key, output_map, entry, keys_to_append=None):
+    """
+
+    :param current_key:
+    :param output_map:
+    :param entry:
+    :param keys_to_append:
+    :return:
+    """
+    def unroll_dict(current_key, output_map, entry, keys_to_append=None):
+        for key, value in entry.items():
+            unroll(".".join([current_key, key]).lstrip("."),
+                   output_map,
+                   value,
+                   keys_to_append=keys_to_append)
+
+    def unroll_list(current_key, output_map, entry, keys_to_append=None):
+        for item in entry:
+            unroll(current_key,
+                   output_map,
+                   item,
+                   keys_to_append=keys_to_append)
+
+    if isinstance(entry, dict):
+        unroll_dict(current_key, output_map, entry, keys_to_append=keys_to_append)
+    elif isinstance(entry, list):
+        unroll_list(current_key, output_map, entry, keys_to_append=keys_to_append)
+    else:  # not iterable
+        if not keys_to_append or current_key in keys_to_append:
+            output_map.append((current_key, entry))
+    return output_map

bsonsearch/matcher_ext/matcher_module.c

@@ -0,0 +1,551 @@
+#define WITH_MODULES
+
+//The modules we know to be enabled from the build
+#define WITH_DUKJS
+#define WITH_DISCO
+#define WITH_MATH
+
+#define WITH_UTILS
+#define WITH_PROJECTION
+#define ALLOW_FILESYSTEM
+#define WITH_CONDITIONAL
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include "bsoncompare.h"
+#include "mongoc-matcher-private.h"
+#include "matcher-module-duk.h"
+
+typedef struct {
+    PyObject_HEAD
+    Py_ssize_t value;
+} Utils;
+
+typedef struct {
+    PyObject_HEAD
+    mongoc_matcher_t *matcher;
+    const char *json;
+    Py_ssize_t value;
+} Matcher;
+
+typedef struct {
+    PyObject_HEAD
+    bson_t  *document;
+    const char *json;
+    Py_ssize_t value;
+} Document;
+
+
+// ---- UTILS FUNCTIONS ----
+static PyObject *
+Utils_startup(Utils *self, PyObject *args, PyObject *kwds)
+{
+    int result = bsonsearch_startup();
+    return PyLong_FromLong(result);
+}
+
+static PyObject *
+Utils_shutdown(Utils *self, PyObject *args, PyObject *kwds)
+{
+    int result = bsonsearch_shutdown();
+    return PyLong_FromLong(result);
+}
+
+static PyObject *
+Utils_regex_destroy(Utils *self, PyObject *args, PyObject *kwds)
+{
+    int result = regex_destroy();
+    return PyLong_FromLong(result);
+}
+
+static PyObject *
+Utils_to_bson(Utils *self, PyObject *args, PyObject *kwds)
+{
+    const char * json = NULL;
+    Py_ssize_t json_len;
+    if (!PyArg_ParseTuple(args, "s#", &json, &json_len)) {
+        return NULL;
+    }
+    bson_t  *bson_object = generate_doc_from_json((const uint8_t*)json, json_len);
+    const uint8_t *doc_bson = bson_get_data(bson_object);
+
+    PyObject * result =  Py_BuildValue("y#", doc_bson, bson_object->len);
+    bson_destroy(bson_object);
+    bson_free((void *)doc_bson);
+
+    return result;
+}
+
+static PyObject *
+Utils_haversine_distance(Utils *self, PyObject *args, PyObject *kwds)
+{
+    double lon1;
+    double lat1;
+    double lon2;
+    double lat2;
+    if (!PyArg_ParseTuple(args, "dddd", &lon1, &lat1, &lon2, &lat2)) {
+        return NULL; // Error occurred, exception already set
+    }
+    double result = bsonsearch_haversine_distance(
+        lon1, lat1, lon2, lat2
+    );
+    return PyFloat_FromDouble(result);
+}
+
+
+static PyObject *
+Utils_haversine_distance_degrees(Utils *self, PyObject *args, PyObject *kwds)
+{
+    double lon1;
+    double lat1;
+    double lon2;
+    double lat2;
+    if (!PyArg_ParseTuple(args, "dddd", &lon1, &lat1, &lon2, &lat2)) {
+        return NULL; // Error occurred, exception already set
+    }
+    double result = bsonsearch_haversine_distance_degrees(
+        lon1, lat1, lon2, lat2
+    );
+    return PyFloat_FromDouble(result);
+}
+
+static PyObject *
+Utils_crossarc_degrees(Utils *self, PyObject *args, PyObject *kwds)
+{
+    double lon1;
+    double lat1;
+    double lon2;
+    double lat2;
+    double lon3;
+    double lat3;
+    if (!PyArg_ParseTuple(args, "dddddd", &lon1, &lat1, &lon2, &lat2, &lon3, &lat3)) {
+        return NULL; // Error occurred, exception already set
+    }
+    double result = bsonsearch_get_crossarc_degrees(
+        lon1, lat1, lon2, lat2, lon3, lat3
+    );
+    return PyFloat_FromDouble(result);
+}
+
+static PyObject *
+Utils_get_value(Utils *self, PyObject *Py_UNUSED(ignored))
+{
+    return PyLong_FromLong(self->value);
+}
+
+// Method definitions for Matcher
+static PyMethodDef Utils_methods[] = {
+    {"get_value", (PyCFunction)Utils_get_value, METH_NOARGS, "Return the value of the Document instance."},
+    {"regex_destroy", (PyCFunction)Utils_regex_destroy, METH_VARARGS, "Frees internal regex cache"},
+    {"startup", (PyCFunction)Utils_startup, METH_VARARGS, "Prep the module internally"},
+    {"shutdown", (PyCFunction)Utils_shutdown, METH_VARARGS, "Cleanup the module internally"},
+    {"to_bson", (PyCFunction)Utils_to_bson, METH_VARARGS, "convert a json document to bson document"},
+    {"haversine_distance", (PyCFunction)Utils_haversine_distance, METH_VARARGS, "Haversine distance using radians"},
+    {"haversine_distance_degrees", (PyCFunction)Utils_haversine_distance_degrees, METH_VARARGS, "Haversine distance using degrees"},
+    {"crossarc_degrees", (PyCFunction)Utils_crossarc_degrees, METH_VARARGS, "Crossarc"},
+    {NULL}  /* Sentinel */
+};
+
+// Matcher_new: Constructor (allocates and initializes the C struct)
+static PyObject *
+Utils_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    Utils *self;
+    self = (Utils *)type->tp_alloc(type, 0);
+    if (self != NULL) {
+        self->value = 0; // Default value
+    }
+    return (PyObject *)self;
+}
+
+// Matcher_init: Initializer (sets instance attributes)
+static int
+Utils_init(Utils *self, PyObject *args, PyObject *kwds)
+{
+    return 0;
+}
+
+// Matcher_dealloc: Destructor (frees resources)
+static void
+Utils_dealloc(Document *self)
+{
+    Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+
+// 6. Create the PyTypeObject
+static PyTypeObject UtilsClassType = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    .tp_name = "bsonsearch.matcher_module.Utils",
+    .tp_doc = "matchermodule",
+    .tp_basicsize = sizeof(Utils),
+    .tp_itemsize = 0,
+    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+    .tp_new = Utils_new, // Use the custom tp_new
+    .tp_init = (initproc)Utils_init,
+    .tp_dealloc = (destructor)Utils_dealloc,
+    .tp_methods = Utils_methods,
+};
+
+//  ----  Document FUNCTIONS ----
+
+static PyObject *
+Document_get_value(Document *self, PyObject *Py_UNUSED(ignored))
+{
+    return PyLong_FromLong(self->value);
+}
+
+static PyObject *
+Document_as_bson(Document *self, PyObject *Py_UNUSED(ignored))
+{
+    const uint8_t *doc_bson = bson_get_data(self->document);
+    PyObject * result =  Py_BuildValue("y#", doc_bson, self->document->len);
+    return result;
+}
+
+static PyObject *
+Document_as_json(Document *self, PyObject *Py_UNUSED(ignored))
+{
+    Py_ssize_t len;
+    char * str = bson_as_legacy_extended_json(self->document, &len);
+    PyObject * result =  Py_BuildValue("s#", str, len);
+    bson_free(str);
+    return result;
+}
+
+static PyObject *
+Document_as_canonical_json(Document *self, PyObject *Py_UNUSED(ignored))
+{
+    Py_ssize_t len;
+    char * str = bson_as_canonical_extended_json(self->document, &len);
+    PyObject * result =  Py_BuildValue("s#", str, len);
+    bson_free(str);
+    return result;
+}
+
+// Method definitions for Matcher
+static PyMethodDef Document_methods[] = {
+    {"get_value", (PyCFunction)Document_get_value, METH_NOARGS, "Return the value of the Document instance."},
+    {"as_bson", (PyCFunction)Document_as_bson, METH_NOARGS, "Return the BSON bytes"},
+    {"as_json", (PyCFunction)Document_as_json, METH_NOARGS, "Return the JSON string"},
+    {"as_canonical_json", (PyCFunction)Document_as_canonical_json, METH_NOARGS, "Return the canonical JSON string"},
+    {NULL}  /* Sentinel */
+};
+
+// Matcher_new: Constructor (allocates and initializes the C struct)
+static PyObject *
+Document_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    Document *self;
+    self = (Document *)type->tp_alloc(type, 0);
+    if (self != NULL) {
+        self->value = 0; // Default value
+    }
+    return (PyObject *)self;
+}
+
+// Matcher_init: Initializer (sets instance attributes)
+static int
+Document_init(Document *self, PyObject *args, PyObject *kwds)
+{
+    PyObject* input_obj;
+    if (!PyArg_ParseTuple(args, "O", &input_obj)) {
+        return 0; // Error handling done by PyArg_ParseTuple
+    }
+    if (PyUnicode_Check(input_obj)) {
+        char* buffer = PyUnicode_AsUTF8AndSize(input_obj, &self->value);
+        if (buffer == NULL) {
+            PyErr_SetString(PyExc_TypeError, "Expected a JSON string");
+            return -1; // Error
+        }
+        self->document = generate_doc_from_json((const uint8_t *)buffer, (uint32_t)self->value);
+        if (self->document == NULL) {
+            PyErr_SetString(PyExc_TypeError, "Expected valid JSON string");
+            return -1;
+        }
+
+    } else if (PyBytes_Check(input_obj)) {
+        Py_ssize_t length;
+        char* buffer = NULL;
+        PyBytes_AsStringAndSize(input_obj, &buffer, &length);
+        self->document = bson_new_from_data((const uint8_t*)buffer, (uint32_t)length);
+        if (self->document == NULL) {
+            PyErr_SetString(PyExc_TypeError, "Expected a valid BSON document");
+            return -1;
+        }
+    } else {
+        PyErr_SetString(PyExc_TypeError, "Expected string or bytes");
+        return -1;
+    }
+
+    return 0;
+}
+
+// Matcher_dealloc: Destructor (frees resources)
+static void
+Document_dealloc(Document *self)
+{
+    doc_destroy(self->document);
+    Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+
+// 6. Create the PyTypeObject
+static PyTypeObject DocumentClassType = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    .tp_name = "bsonsearch.matcher_module.Document",
+    .tp_doc = "matchermodule",
+    .tp_basicsize = sizeof(Matcher),
+    .tp_itemsize = 0,
+    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+    .tp_new = Document_new, // Use the custom tp_new
+    .tp_init = (initproc)Document_init,
+    .tp_dealloc = (destructor)Document_dealloc,
+    .tp_methods = Document_methods,
+};
+
+
+
+
+//  ----  MATCHER FUNCTIONS ----
+static PyObject *
+Matcher_get_value(Matcher *self, PyObject *Py_UNUSED(ignored))
+{
+    return PyLong_FromLong(self->value);
+}
+
+static PyObject *
+Matcher_match_json(Matcher *self, PyObject *args, PyObject *kwds)
+{
+    const char *c_string_ptr;
+    Py_ssize_t c_string_len;
+    if (!PyArg_ParseTuple(args, "s#", &c_string_ptr, &c_string_len)) {
+        return NULL;
+    }
+    bson_t *doc = generate_doc_from_json((const uint8_t*)c_string_ptr, c_string_len);
+    if (!doc) {
+        return NULL;
+    }
+    long result = matcher_compare_doc(self->matcher, doc);
+    doc_destroy(doc);
+    return PyBool_FromLong(result);
+}
+
+static PyObject *
+Matcher_match_doc(Matcher *self, PyObject *args, PyObject *kwds)
+{
+    PyObject *my_obj;
+    if (!PyArg_ParseTuple(args, "O!", &DocumentClassType, &my_obj)) {
+        return NULL; // PyArg_ParseTuple handles the error
+    }
+    Document *document = (Document *)my_obj;
+    long result = matcher_compare_doc(self->matcher, document->document);
+    return PyBool_FromLong(result);
+}
+
+static PyObject *
+Matcher_project_json(Matcher *self, PyObject *args, PyObject *kwds)
+{
+    PyObject *my_obj;
+    if (!PyArg_ParseTuple(args, "O!", &DocumentClassType, &my_obj)) {
+        return NULL; // PyArg_ParseTuple handles the error
+    }
+    Document *document = (Document *)my_obj;
+    char *result = bsonsearch_project_json(self->matcher, document->document);
+    PyObject *returnable =  Py_BuildValue("s", result);
+    bson_free(result);
+    return returnable;
+}
+
+static PyObject *
+Matcher_project_canonical_json(Matcher *self, PyObject *args, PyObject *kwds)
+{
+    PyObject *my_obj;
+    if (!PyArg_ParseTuple(args, "O!", &DocumentClassType, &my_obj)) {
+        return NULL; // PyArg_ParseTuple handles the error
+    }
+    Document *document = (Document *)my_obj;
+    char *result = bsonsearch_project_canonical_json(self->matcher, document->document);
+    PyObject *returnable =  Py_BuildValue("s", result);
+    bson_free(result);
+    return returnable;
+}
+
+static PyObject *
+Matcher_project_bson(Matcher *self, PyObject *args, PyObject *kwds)
+{
+    PyObject *my_obj;
+    if (!PyArg_ParseTuple(args, "O!", &DocumentClassType, &my_obj)) {
+        return NULL; // PyArg_ParseTuple handles the error
+    }
+    Document *document = (Document *)my_obj;
+    bson_t *projected = bsonsearch_project_bson(self->matcher, document->document);
+    const uint8_t *doc_bson = bson_get_data(projected);
+    PyObject *returnable =  Py_BuildValue("y#", doc_bson, projected->len);
+    bson_destroy(projected);
+    return returnable;
+}
+
+static PyObject *
+Matcher_as_bson(Matcher *self, PyObject *Py_UNUSED(ignored))
+{
+    const uint8_t *doc_bson = bson_get_data(&self->matcher->query);
+    PyObject * result =  Py_BuildValue("y#", doc_bson, self->matcher->query.len);
+    return result;
+}
+
+static PyObject *
+Matcher_as_json(Matcher *self, PyObject *Py_UNUSED(ignored))
+{
+    Py_ssize_t len;
+    char * str = bson_as_legacy_extended_json(&self->matcher->query, &len);
+    PyObject * result =  Py_BuildValue("s#", str, len);
+    bson_free(str);
+    return result;
+}
+
+static PyObject *
+Matcher_as_canonical_json(Matcher *self, PyObject *Py_UNUSED(ignored))
+{
+    Py_ssize_t len;
+    char * str = bson_as_canonical_extended_json(&self->matcher->query, &len);
+    PyObject * result =  Py_BuildValue("s#", str, len);
+    bson_free(str);
+    return result;
+}
+
+// Method definitions for Matcher
+static PyMethodDef Matcher_methods[] = {
+    {"get_value", (PyCFunction)Matcher_get_value, METH_NOARGS, "Return the value of the Matcher instance."},
+    {"as_bson", (PyCFunction)Matcher_as_bson, METH_NOARGS, "gets the BSON representation of the matcher."},
+    {"as_json", (PyCFunction)Matcher_as_json, METH_NOARGS, "gets the JSON representation of the matcher."},
+    {"as_canonical_json", (PyCFunction)Matcher_as_canonical_json, METH_NOARGS, "gets the canonical JSON representation of the matcher."},
+    {"match_json", (PyCFunction)Matcher_match_json, METH_VARARGS, "Returns whether the doc matches the spec"},
+    {"match_doc", (PyCFunction)Matcher_match_doc, METH_VARARGS, "Returns whether the doc matches the spec"},
+    {"project_json", (PyCFunction)Matcher_project_json, METH_VARARGS, "projects data into a json document"},
+    {"project_canonical_json", (PyCFunction)Matcher_project_canonical_json, METH_VARARGS, "projects data into a canonical json document"},
+    {"project_bson", (PyCFunction)Matcher_project_bson, METH_VARARGS, "projects data into a bson document"},
+    {NULL}  /* Sentinel */
+};
+
+// Matcher_new: Constructor (allocates and initializes the C struct)
+static PyObject *
+Matcher_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    Matcher *self;
+    self = (Matcher *)type->tp_alloc(type, 0);
+    if (self != NULL) {
+        self->value = 0; // Default value
+    }
+    return (PyObject *)self;
+}
+
+// Matcher_init: Initializer (sets instance attributes)
+static int
+Matcher_init(Matcher *self, PyObject *args, PyObject *kwds)
+{
+    PyObject* input_obj;
+    if (!PyArg_ParseTuple(args, "O", &input_obj)) {
+        return 0; // Error handling done by PyArg_ParseTuple
+    }
+    if (PyUnicode_Check(input_obj)) {
+        self->json = PyUnicode_AsUTF8AndSize(input_obj, &self->value);
+        if (self->json == NULL) {
+            PyErr_SetString(PyExc_TypeError, "Expected a JSON string");
+            return 0; // Error
+        }
+        self->matcher = generate_matcher_from_json((const uint8_t *)self->json, (uint32_t)self->value);
+        if (self->matcher == NULL) {
+            return -2;
+        }
+    } else if (PyBytes_Check(input_obj)) {
+        Py_ssize_t length;
+        char* buffer = NULL;
+        PyBytes_AsStringAndSize(input_obj, &buffer, &length);
+        self->matcher = generate_matcher((const uint8_t*)buffer, (uint32_t)length);
+        if (self->matcher == NULL) {
+            PyErr_SetString(PyExc_TypeError, "Expected a valid BSON document");
+            return 0;
+        }
+    } else {
+        PyErr_SetString(PyExc_TypeError, "Expected string or bytes");
+        return -1;
+    }
+    return 0;
+}
+
+// Matcher_dealloc: Destructor (frees resources)
+static void
+Matcher_dealloc(Matcher *self)
+{
+    matcher_destroy(self->matcher);
+    Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+
+// 6. Create the PyTypeObject
+static PyTypeObject MatcherClassType = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    .tp_name = "bsonsearch.matcher_module.Matcher",
+    .tp_doc = "matchermodule",
+    .tp_basicsize = sizeof(Matcher),
+    .tp_itemsize = 0,
+    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+    .tp_new = Matcher_new, // Use the custom tp_new
+    .tp_init = (initproc)Matcher_init,
+    .tp_dealloc = (destructor)Matcher_dealloc,
+    .tp_methods = Matcher_methods,
+};
+
+
+
+//  ----  Module FUNCTIONS  (unlikely to need editing below here) ----
+
+
+static struct PyModuleDef matcher_module_def = {
+    PyModuleDef_HEAD_INIT,
+    .m_name = "bsonsearch.matcher_module",
+    .m_doc = "The module.",
+    .m_size = -1
+};
+
+
+// Module initialization function
+PyMODINIT_FUNC
+PyInit_matcher_module(void)
+{
+    PyObject *m;
+
+    if (PyType_Ready(&MatcherClassType) < 0)
+        return NULL;
+
+    if (PyType_Ready(&DocumentClassType) < 0)
+        return NULL;
+
+    if (PyType_Ready(&UtilsClassType) < 0)
+        return NULL;
+
+    m = PyModule_Create(&matcher_module_def);
+    if (m == NULL)
+        return NULL;
+
+    Py_INCREF(&MatcherClassType);
+    if (PyModule_AddObject(m, "Matcher", (PyObject *)&MatcherClassType) < 0) {
+        Py_DECREF(&MatcherClassType);
+        Py_DECREF(m);
+        return NULL;
+    }
+    Py_INCREF(&DocumentClassType);
+    if (PyModule_AddObject(m, "Document", (PyObject *)&DocumentClassType) < 0) {
+        Py_DECREF(&DocumentClassType);
+        Py_DECREF(m);
+        return NULL;
+    }
+    Py_INCREF(&UtilsClassType);
+    if (PyModule_AddObject(m, "Utils", (PyObject *)&UtilsClassType) < 0) {
+        Py_DECREF(&UtilsClassType);
+        Py_DECREF(m);
+        return NULL;
+    }
+    return m;
+}

bsonsearch-2.1.2.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: bsonsearch
+Version: 2.1.2
+Summary: compare BSON/JSON documents locally
+Author: Dan Bauman
+Maintainer: Dan Bauman
+Requires-Python: >=3.11
+License-File: LICENSE
+Dynamic: license-file

bsonsearch-2.1.2.dist-info/RECORD

@@ -0,0 +1,14 @@
+bsonsearch/__init__.py,sha256=HwyXH3os6-2kCbVKL3SUUgz_p38bAaBFpERzgPHzzcc,5376
+bsonsearch/matcher_module.cpython-314-x86_64-linux-gnu.so,sha256=nuXhMIBjtnLaB1_GrEPzD7t3gjVPS-fO17Mum5GCpmI,71097
+bsonsearch/matcher_ext/matcher_module.c,sha256=j9qCKULhmS7uPzdgl8IjKPhi2dsGQnvhULKcCs3VSfM,16944
+bsonsearch.libs/libbson2-bf0e8588.so.2.1.2,sha256=Z3djfzeEB-URJSzWaSh7RuCSPPXFcBm_9DJk6npT78c,742785
+bsonsearch.libs/libbsonsearch-f7a0a394.so,sha256=Wp8aN-dhDI1OMkQvnQ2RIR4ljzV7s3HkS3eJBewHaBQ,127713
+bsonsearch.libs/libcmph-3f220d00.so.0.0.0,sha256=nBfFpgHtvvtyFciqyTFjhc5OXgxtB9N_p8K3TuL1utA,568601
+bsonsearch.libs/libdiscodb-1a6a5160.so,sha256=ANqdJZ6uoMEjAcQ7sils5VJYvgMbj6kX2Q9qWZZDkFw,63377
+bsonsearch.libs/libduktape-9faedf1e.so.207.20700,sha256=BqFn2Au4nQQ9Yx7Os_wGgBVINMdJNa-ZpQdK0XtRNro,351937
+bsonsearch.libs/libpcre-3dcc71ac.so.1.2.13,sha256=2o02DZLn3toKuZuBxw89YeR1AFuXTg4OXN0ysoI75AA,2065633
+bsonsearch-2.1.2.dist-info/METADATA,sha256=Q0gu93DeoPesbpLa-sHUNiTBlDK4zh26QUAQJssrL8g,209
+bsonsearch-2.1.2.dist-info/WHEEL,sha256=DMni2HWXXG4oat8Y6bAVuu-xlkB-grHQiqsTu-lLHls,190
+bsonsearch-2.1.2.dist-info/top_level.txt,sha256=yKvan_PZbgnwFJu7aiO90uulDgZEUkdIbqdARreIdAU,11
+bsonsearch-2.1.2.dist-info/RECORD,,
+bsonsearch-2.1.2.dist-info/licenses/LICENSE,sha256=Kn6aS7NZYk5QKVM90hlXPEC32aK9Z4ioFCkLvdGlKP4,1081

bsonsearch-2.1.2.dist-info/WHEEL

@@ -0,0 +1,7 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp314-cp314-manylinux_2_17_x86_64
+Tag: cp314-cp314-manylinux2014_x86_64
+Tag: cp314-cp314-manylinux_2_28_x86_64
+

bsonsearch-2.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2016 Dan Bauman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bsonsearch-2.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+bsonsearch