mgqpy 0.8.0__py3-none-any.whl

mgqpy/__init__.py

@@ -0,0 +1,177 @@
+# Terminology
+#
+# Query refers to the document that is passed to the compiler / mongodb find that holds
+#   the query conditions (can be multiple),
+#   e.g. { "fruits.type": { "$eq": "berry", "$ne": "aggregate" }, "fruits": { "$size": 3 }}
+#
+# Cond (conditions) refers to a single path-expression pair,
+#   e.g. { "fruits.type": { "$eq": "berry", "$ne": "aggregate" }
+#
+# Path refers to dot-separated fields,
+#   e.g. "fruits.type"
+#
+# Exp (expression) refers to the object that holds operator and value pairs (can be multiple),
+#   e.g. { "$eq": "berry", "$ne": "aggregate" }
+#
+# Op (operator) refers to the logical operator that is matched against the value,
+#   e.g. "$eq"
+#
+# Ov (operator value) refers to the value that you are matching against in
+#   the context of a single operator e.g. "berry"
+#
+# Doc refers to the object that is passed to the compiled filter function
+
+from typing import List
+
+from .operators.and_or_nor import _match_and, _match_or, _match_nor, _validate_query_ops
+from .operators.all import _match_all, _validate_all
+from .operators.elem_match import _match_elem_match
+from .operators.eq_ne_not import _match_eq, _match_ne, _match_not
+from .operators.gt import _match_gt
+from .operators.gte import _match_gte
+from .operators.in_nin import _match_in, _match_nin, _validate_in_nin
+from .operators.lt import _match_lt
+from .operators.lte import _match_lte
+from .operators.mod import _match_mod, _validate_mod
+from .operators.regex import _match_regex
+from .operators.size import _match_size, _validate_size
+
+cond_ops = {
+    "$eq",
+    "$gt",
+    "$gte",
+    "$in",
+    "$lt",
+    "$lte",
+    "$ne",
+    "$nin",
+    "$not",
+    "$regex",
+    "$options",
+    "$mod",
+    "$all",
+    "$elemMatch",
+    "$size",
+}
+
+query_ops = {
+    "$and",
+    "$or",
+    "$nor",
+}
+
+
+class Query:
+    def __init__(self, query):
+        self._query = query
+        pass
+
+    def test(self, doc) -> bool:
+        return _match_cond(self._query, doc)
+
+    def validate(self):
+        _validate(self._query)
+        return self
+
+
+def _match_cond(query, doc):
+    results: List[bool] = []
+
+    for path in query:
+        if isinstance(path, str) and path in query_ops:
+            if path == "$and":
+                results.append(_match_and(doc, path, query["$and"]))
+            if path == "$or":
+                results.append(_match_or(doc, path, query["$or"]))
+            if path == "$nor":
+                results.append(_match_nor(doc, path, query["$nor"]))
+        else:
+            exp_or_ov = query[path]
+            is_all_exp = _check_all_exp(exp_or_ov)
+            path_parts = path.split(".")
+
+            if is_all_exp:
+                exp = exp_or_ov
+                if "$eq" in exp:
+                    results.append(_match_eq(doc, path_parts, exp["$eq"]))
+                if "$ne" in exp:
+                    results.append(_match_ne(doc, path_parts, exp["$ne"]))
+                if "$gt" in exp:
+                    results.append(_match_gt(doc, path_parts, exp["$gt"]))
+                if "$gte" in exp:
+                    results.append(_match_gte(doc, path_parts, exp["$gte"]))
+                if "$lt" in exp:
+                    results.append(_match_lt(doc, path_parts, exp["$lt"]))
+                if "$lte" in exp:
+                    results.append(_match_lte(doc, path_parts, exp["$lte"]))
+                if "$in" in exp:
+                    results.append(_match_in(doc, path_parts, exp["$in"]))
+                if "$nin" in exp:
+                    results.append(_match_nin(doc, path_parts, exp["$nin"]))
+                if "$not" in exp:
+                    results.append(_match_not(doc, path, exp["$not"]))
+                if "$regex" in exp:
+                    ov = {
+                        "$regex": exp["$regex"],
+                        "$options": exp.get("$options", ""),
+                    }
+                    results.append(_match_regex(doc, path_parts, ov))
+                if "$mod" in exp:
+                    results.append(_match_mod(doc, path_parts, exp["$mod"]))
+                if "$all" in exp:
+                    results.append(_match_all(doc, path_parts, exp["$all"]))
+                if "$elemMatch" in exp:
+                    results.append(
+                        _match_elem_match(doc, path_parts, exp["$elemMatch"])
+                    )
+                if "$size" in exp:
+                    results.append(_match_size(doc, path_parts, exp["$size"]))
+            else:
+                ov = exp_or_ov
+                results.append(_match_eq(doc, path_parts, ov))
+
+    return all(results)
+
+
+def _validate(query) -> bool:
+    if not isinstance(query, dict):
+        raise TypeError("query must be a dict")
+
+    for path in query:
+        if isinstance(path, str) and path in query_ops:
+            if path == "$and":
+                if not _validate_query_ops(query["$and"]):
+                    raise TypeError("$and operator value must be a list")
+            if path == "$or":
+                if not _validate_query_ops(query["$or"]):
+                    raise TypeError("$or operator value must be a list")
+            if path == "$nor":
+                if not _validate_query_ops(query["$nor"]):
+                    raise TypeError("$nor operator value must be a list")
+            for cond in query[path]:
+                _validate(cond)
+        else:
+            exp_or_ov = query[path]
+            is_all_exp = _check_all_exp(exp_or_ov)
+            if is_all_exp:
+                exp = exp_or_ov
+                if "$in" in exp and not _validate_in_nin(exp["$in"]):
+                    raise TypeError("$in operator value must be a list")
+                if "$nin" in exp and not _validate_in_nin(exp["$nin"]):
+                    raise TypeError("$nin operator value must be a list")
+                if "$all" in exp and not _validate_all(exp["$all"]):
+                    raise TypeError("$all operator value must be a list")
+                if "$mod" in exp and not _validate_mod(exp["$mod"]):
+                    raise TypeError("$mod operator value must be a list of 2 numbers")
+                if "$size" in exp and not _validate_size(exp["$size"]):
+                    raise TypeError("$size operator value must be a number")
+
+    return True
+
+
+def _check_all_exp(exp_or_ov):
+    return (
+        exp_or_ov
+        and isinstance(exp_or_ov, dict)
+        and all(key in cond_ops for key in exp_or_ov.keys())
+    )

mgqpy/operators/all.py

@@ -0,0 +1,52 @@
+from typing import List
+
+import mgqpy
+
+
+def _match_all(doc, path: List[str], ov) -> bool:
+    if not _validate_all(ov):
+        return False
+
+    if len(ov) == 0:
+        return False
+
+    if _is_all_elem_match(ov):
+        elem_match_query = {"$and": [{".".join(path): o} for o in ov]}
+        return mgqpy._match_cond(elem_match_query, doc)
+
+    if len(path) == 0:
+        if not isinstance(doc, list):
+            return False
+
+        return all([o in doc or o == doc for o in ov])
+
+    key = path[0]
+    rest = path[1:]
+
+    if isinstance(doc, dict) and key in doc:
+        return _match_all(doc[key], rest, ov)
+
+    if isinstance(doc, list) and key.isdigit():
+        idx = int(key)
+        if idx < len(doc):
+            return _match_all(doc[idx], rest, ov)
+
+    if isinstance(doc, list):
+        return any([_match_all(d, path, ov) for d in doc])
+
+    return False
+
+
+# $all can be a list of values, or only $elemMatch if $ expression is in a list of dicts
+def _validate_all(ov) -> bool:
+    is_list = isinstance(ov, list)
+    if is_list:
+        if len(ov) == 0:
+            return True
+        if isinstance(ov[0], dict) and any(k.startswith("$") for k in ov[0].keys()):
+            return _is_all_elem_match(ov)
+    return is_list
+
+
+def _is_all_elem_match(ov) -> bool:
+    return all(isinstance(o, dict) and "$elemMatch" in o for o in ov)

mgqpy/operators/and_or_nor.py

@@ -0,0 +1,31 @@
+import mgqpy
+
+
+def _match_and(doc, path: str, ov) -> bool:
+    if not _validate_query_ops(ov):
+        return False
+
+    return all(mgqpy._match_cond(cond, doc) for cond in ov)
+
+
+def _match_or(doc, path: str, ov) -> bool:
+    if not _validate_query_ops(ov):
+        return False
+
+    return any(mgqpy._match_cond(cond, doc) for cond in ov)
+
+
+def _match_nor(doc, path: str, ov) -> bool:
+    if not _validate_query_ops(ov):
+        return False
+
+    return not any(mgqpy._match_cond(cond, doc) for cond in ov)
+
+
+def _validate_query_ops(ov) -> bool:
+    """
+    Validate query op is given a list (shallow).
+    Recursion is done by _validate and _match_cond.
+    """
+
+    return isinstance(ov, list)

mgqpy/operators/elem_match.py

@@ -0,0 +1,31 @@
+import mgqpy
+
+
+from typing import List
+
+
+def _match_elem_match(doc, path: List[str], ov) -> bool:
+    if len(path) == 0:
+        if not isinstance(doc, list):
+            return False
+
+        if any(mgqpy._match_cond(ov, d) for d in doc):
+            return True
+
+        return False
+
+    key = path[0]
+    rest = path[1:]
+
+    if isinstance(doc, dict) and key in doc:
+        return _match_elem_match(doc[key], rest, ov)
+
+    if isinstance(doc, list) and key.isdigit():
+        idx = int(key)
+        if idx < len(doc):
+            return _match_elem_match(doc[idx], rest, ov)
+
+    if isinstance(doc, list):
+        return any([_match_elem_match(d, path, ov) for d in doc])
+
+    return False

mgqpy/operators/eq_ne_not.py

@@ -0,0 +1,45 @@
+import re
+from typing import List
+
+from mgqpy.utils import coerce
+
+import mgqpy
+
+
+def _match_eq(doc, path: List[str], ov) -> bool:
+    if len(path) == 0:
+        if isinstance(doc, list) and any([_match_eq(d, path, ov) for d in doc]):
+            return True
+
+        if isinstance(ov, re.Pattern) and isinstance(doc, str):
+            return bool(ov.search(doc))
+
+        doc, ov = coerce(doc, ov)
+        return doc == ov
+
+    key = path[0]
+    rest = path[1:]
+
+    if isinstance(doc, dict) and key in doc:
+        return _match_eq(doc[key], rest, ov)
+
+    if isinstance(doc, list) and key.isdigit():
+        idx = int(key)
+        if idx < len(doc):
+            return _match_eq(doc[idx], rest, ov)
+
+    if isinstance(doc, list):
+        return any([_match_eq(d, path, ov) for d in doc])
+
+    if ov is None:
+        return True
+
+    return False
+
+
+def _match_ne(doc, path: List[str], ov) -> bool:
+    return not _match_eq(doc, path, ov)
+
+
+def _match_not(doc, path, ov):
+    return not mgqpy._match_cond({path: ov}, doc)

mgqpy/operators/gt.py

@@ -0,0 +1,56 @@
+import operator
+from itertools import zip_longest
+from numbers import Number
+from typing import List
+
+from mgqpy.utils import coerce
+
+
+def _match_gt(doc, path: List[str], ov) -> bool:
+    if len(path) == 0:
+        if isinstance(doc, list) and any([_match_gt(d, path, ov) for d in doc]):
+            return True
+
+        if isinstance(doc, list) and isinstance(ov, list):
+            if doc > ov:
+                return True
+
+        if isinstance(doc, dict) and isinstance(ov, dict):
+            keys = zip_longest(doc.keys(), ov.keys())
+            for doc_key, ov_key in keys:
+                if doc_key is None:
+                    return False
+                if ov_key is None:
+                    return True
+                if doc_key != ov_key:
+                    return doc_key > ov_key
+                if doc_key == ov_key:
+                    if doc[doc_key] > ov[ov_key]:
+                        return True
+                    if doc[doc_key] < ov[ov_key]:
+                        return False
+            return False
+
+        try:
+            doc, ov = coerce(doc, ov)
+            return operator.gt(doc, ov)
+        except Exception:
+            pass
+
+        return False
+
+    key = path[0]
+    rest = path[1:]
+
+    if isinstance(doc, dict) and key in doc:
+        return _match_gt(doc[key], rest, ov)
+
+    if isinstance(doc, list) and key.isdigit():
+        idx = int(key)
+        if idx < len(doc):
+            return _match_gt(doc[idx], rest, ov)
+
+    if isinstance(doc, list):
+        return any([_match_gt(d, path, ov) for d in doc])
+
+    return False

mgqpy/operators/gte.py

@@ -0,0 +1,65 @@
+import operator
+from itertools import zip_longest
+from numbers import Number
+from typing import List
+
+from mgqpy.utils import coerce
+
+
+def _match_gte(doc, path: List[str], ov) -> bool:
+    if len(path) == 0:
+        if isinstance(doc, list) and any([_match_gte(d, path, ov) for d in doc]):
+            return True
+
+        if isinstance(doc, list) and isinstance(ov, list):
+            if doc >= ov:
+                return True
+
+        if isinstance(doc, dict) and isinstance(ov, dict):
+            if not doc and not ov:
+                return True
+
+            keys = zip_longest(doc.keys(), ov.keys())
+            for doc_key, ov_key in keys:
+                if doc_key is None:
+                    return False
+                if ov_key is None:
+                    return True
+                if doc_key != ov_key:
+                    return doc_key > ov_key
+                if doc_key == ov_key:
+                    if doc[doc_key] > ov[ov_key]:
+                        return True
+                    if doc[doc_key] < ov[ov_key]:
+                        return False
+            return True
+
+        if doc is None and ov is None:
+            return True
+
+        try:
+            doc, ov = coerce(doc, ov)
+            return operator.ge(doc, ov)
+        except Exception:
+            pass
+
+        return False
+
+    key = path[0]
+    rest = path[1:]
+
+    if isinstance(doc, dict) and key in doc:
+        return _match_gte(doc[key], rest, ov)
+
+    if isinstance(doc, list) and key.isdigit():
+        idx = int(key)
+        if idx < len(doc):
+            return _match_gte(doc[idx], rest, ov)
+
+    if isinstance(doc, list):
+        return any([_match_gte(d, path, ov) for d in doc])
+
+    if ov is None:
+        return True
+
+    return False

mgqpy/operators/in_nin.py

@@ -0,0 +1,45 @@
+from mgqpy.operators.eq_ne_not import _match_eq
+
+
+from typing import List
+
+
+def _match_in(doc, path: List[str], ov) -> bool:
+    if not _validate_in_nin(ov):
+        return False
+
+    if len(path) == 0:
+        if isinstance(doc, list) and any([_match_in(d, path, ov) for d in doc]):
+            return True
+
+        return any([_match_eq(doc, path, o) for o in ov])
+
+    key = path[0]
+    rest = path[1:]
+
+    if isinstance(doc, dict) and key in doc:
+        return _match_in(doc[key], rest, ov)
+
+    if isinstance(doc, list) and key.isdigit():
+        idx = int(key)
+        if idx < len(doc):
+            return _match_in(doc[idx], rest, ov)
+
+    if isinstance(doc, list):
+        return any([_match_in(d, path, ov) for d in doc])
+
+    if None in ov:
+        return True
+
+    return False
+
+
+def _match_nin(doc, path: List[str], ov) -> bool:
+    if not _validate_in_nin(ov):
+        return False
+
+    return not _match_in(doc, path, ov)
+
+
+def _validate_in_nin(ov):
+    return isinstance(ov, list)

mgqpy/operators/lt.py

@@ -0,0 +1,59 @@
+import operator
+from itertools import zip_longest
+from numbers import Number
+from typing import List
+
+from mgqpy.utils import coerce
+
+
+def _match_lt(doc, path: List[str], ov) -> bool:
+    if len(path) == 0:
+        if isinstance(doc, list) and any([_match_lt(d, path, ov) for d in doc]):
+            return True
+
+        if isinstance(doc, list) and isinstance(ov, list):
+            if doc < ov:
+                return True
+
+        if isinstance(doc, dict) and isinstance(ov, dict):
+            if not doc and not ov:
+                return False
+
+            keys = zip_longest(doc.keys(), ov.keys())
+            for doc_key, ov_key in keys:
+                if doc_key is None:
+                    return True
+                if ov_key is None:
+                    return False
+                if doc_key != ov_key:
+                    return doc_key < ov_key
+                if doc_key == ov_key:
+                    if doc[doc_key] > ov[ov_key]:
+                        return False
+                    if doc[doc_key] < ov[ov_key]:
+                        return True
+            return False
+
+        try:
+            doc, ov = coerce(doc, ov)
+            return operator.lt(doc, ov)
+        except Exception:
+            pass
+
+        return False
+
+    key = path[0]
+    rest = path[1:]
+
+    if isinstance(doc, dict) and key in doc:
+        return _match_lt(doc[key], rest, ov)
+
+    if isinstance(doc, list) and key.isdigit():
+        idx = int(key)
+        if idx < len(doc):
+            return _match_lt(doc[idx], rest, ov)
+
+    if isinstance(doc, list):
+        return any([_match_lt(d, path, ov) for d in doc])
+
+    return False

mgqpy/operators/lte.py

@@ -0,0 +1,65 @@
+import operator
+from itertools import zip_longest
+from numbers import Number
+from typing import List
+
+from mgqpy.utils import coerce
+
+
+def _match_lte(doc, path: List[str], ov) -> bool:
+    if len(path) == 0:
+        if isinstance(doc, list) and any([_match_lte(d, path, ov) for d in doc]):
+            return True
+
+        if isinstance(doc, list) and isinstance(ov, list):
+            if doc <= ov:
+                return True
+
+        if isinstance(doc, dict) and isinstance(ov, dict):
+            if not doc and not ov:
+                return True
+
+            keys = zip_longest(doc.keys(), ov.keys())
+            for doc_key, ov_key in keys:
+                if doc_key is None:
+                    return True
+                if ov_key is None:
+                    return False
+                if doc_key != ov_key:
+                    return doc_key < ov_key
+                if doc_key == ov_key:
+                    if doc[doc_key] < ov[ov_key]:
+                        return True
+                    if doc[doc_key] > ov[ov_key]:
+                        return False
+            return True
+
+        if doc is None and ov is None:
+            return True
+
+        try:
+            doc, ov = coerce(doc, ov)
+            return operator.le(doc, ov)
+        except Exception:
+            pass
+
+        return False
+
+    key = path[0]
+    rest = path[1:]
+
+    if isinstance(doc, dict) and key in doc:
+        return _match_lte(doc[key], rest, ov)
+
+    if isinstance(doc, list) and key.isdigit():
+        idx = int(key)
+        if idx < len(doc):
+            return _match_lte(doc[idx], rest, ov)
+
+    if isinstance(doc, list):
+        return any([_match_lte(d, path, ov) for d in doc])
+
+    if ov is None:
+        return True
+
+    return False

mgqpy/operators/mod.py

@@ -0,0 +1,46 @@
+import math
+from numbers import Number
+from typing import List
+
+
+def _match_mod(doc, path: List[str], ov) -> bool:
+    if not _validate_mod(ov):
+        return False
+
+    if len(path) == 0:
+        if isinstance(doc, list) and any([_match_mod(d, path, ov) for d in doc]):
+            return True
+
+        if not isinstance(doc, Number):
+            return False
+
+        divisor = math.floor(ov[0])
+        expected_remainer = math.floor(ov[1])
+        doc_remainer = math.floor(doc % divisor)
+
+        return doc_remainer == expected_remainer
+
+    key = path[0]
+    rest = path[1:]
+
+    if isinstance(doc, dict) and key in doc:
+        return _match_mod(doc[key], rest, ov)
+
+    if isinstance(doc, list) and key.isdigit():
+        idx = int(key)
+        if idx < len(doc):
+            return _match_mod(doc[idx], rest, ov)
+
+    if isinstance(doc, list):
+        return any([_match_mod(d, path, ov) for d in doc])
+
+    return False
+
+
+def _validate_mod(ov):
+    return (
+        isinstance(ov, list)
+        and len(ov) == 2
+        and isinstance(ov[0], Number)
+        and isinstance(ov[1], Number)
+    )

mgqpy/operators/regex.py

@@ -0,0 +1,44 @@
+import re
+from typing import List
+
+
+def _match_regex(doc, path: List[str], ov) -> bool:
+    if len(path) == 0:
+        if isinstance(doc, list) and any([_match_regex(d, path, ov) for d in doc]):
+            return True
+
+        if not isinstance(doc, str):
+            return False
+
+        flags = re.NOFLAG
+        if "i" in ov["$options"]:
+            flags = flags | re.IGNORECASE
+        if "m" in ov["$options"]:
+            flags = flags | re.MULTILINE
+        if "s" in ov["$options"]:
+            flags = flags | re.DOTALL
+        if "x" in ov["$options"]:
+            flags = flags | re.VERBOSE
+
+        matcher = re.compile(ov["$regex"], flags)
+
+        if matcher.search(doc):
+            return True
+
+        return False
+
+    key = path[0]
+    rest = path[1:]
+
+    if isinstance(doc, dict) and key in doc:
+        return _match_regex(doc[key], rest, ov)
+
+    if isinstance(doc, list) and key.isdigit():
+        idx = int(key)
+        if idx < len(doc):
+            return _match_regex(doc[idx], rest, ov)
+
+    if isinstance(doc, list):
+        return any([_match_regex(d, path, ov) for d in doc])
+
+    return False

mgqpy/operators/size.py

@@ -0,0 +1,36 @@
+from numbers import Number
+from typing import List
+
+
+def _match_size(doc, path: List[str], ov) -> bool:
+    if not _validate_size(ov):
+        return False
+
+    if len(path) == 0:
+        if not isinstance(doc, list):
+            return False
+
+        if len(doc) == int(ov):
+            return True
+
+        return False
+
+    key = path[0]
+    rest = path[1:]
+
+    if isinstance(doc, dict) and key in doc:
+        return _match_size(doc[key], rest, ov)
+
+    if isinstance(doc, list) and key.isdigit():
+        idx = int(key)
+        if idx < len(doc):
+            return _match_size(doc[idx], rest, ov)
+
+    if isinstance(doc, list):
+        return any([_match_size(d, path, ov) for d in doc])
+
+    return False
+
+
+def _validate_size(ov) -> bool:
+    return isinstance(ov, Number)

mgqpy/utils.py

@@ -0,0 +1,89 @@
+"""Utility helpers for mgqpy."""
+
+import datetime
+import decimal
+import uuid
+from typing import Any, Sequence
+
+
+def coerce(a: Any, b: Any) -> tuple[Any, Any]:
+    """Make *a* and *b* directly comparable by aligning their types.
+
+    The coercion rules are intentionally conservative - we only convert
+    where the *intent* is unambiguous (e.g. ISO-8601 date strings).  The
+    function never raises: if conversion fails we fall back to the
+    original values so the caller can attempt a normal comparison.
+    """
+
+    match (a, b):
+        # one is date/datetime, other is str
+        case (datetime.datetime() as dt, str()):
+            return dt, _try_date(b, datetime.datetime, tzinfo=dt.tzinfo)
+        case (datetime.date() as d, str()):
+            return d, _try_date(b, datetime.date)
+        case (str(), datetime.datetime() as dt):
+            return _try_date(a, datetime.datetime, tzinfo=dt.tzinfo), dt
+        case (str(), datetime.date() as d):
+            return _try_date(a, datetime.date), d
+
+        # one is decimal
+        case (decimal.Decimal(), _):
+            return a, _try_decimal(b)
+        case (_, decimal.Decimal()):
+            return _try_decimal(a), b
+
+        # one is uuid
+        case (uuid.UUID(), _):
+            return a, _try_uuid(b)
+        case (_, uuid.UUID()):
+            return _try_uuid(a), b
+
+        # default return original values
+        case _:
+            return a, b
+
+
+# Datetime ↔︎ ISO 8601 string
+def _try_date(s: str, target, *, tzinfo: datetime.tzinfo | None = None):
+    """Attempt to convert *val* to target date or datetime"""
+    try:
+        if target is datetime.date:
+            return datetime.date.fromisoformat(s)
+        dt = datetime.datetime.fromisoformat(s)
+        if tzinfo is not None and dt.tzinfo is None:
+            return dt.replace(tzinfo=tzinfo)
+        return dt
+    except ValueError:
+        # Not a valid ISO format – leave as string so normal
+        # comparison semantics apply (and tests expecting a failure
+        # still pass).
+        return s
+
+
+# UUID ↔︎ string
+def _try_uuid(val: object):
+    """Attempt to convert *val* to UUID"""
+    if isinstance(val, uuid.UUID):
+        return val
+    if isinstance(val, str):
+        try:
+            return uuid.UUID(val)
+        except ValueError:
+            return val
+    return val
+
+
+# Decimal ↔︎ number / numeric-string
+def _try_decimal(val: object):
+    """Attempt to convert *val* to Decimal"""
+    if isinstance(val, decimal.Decimal):
+        return val
+    if isinstance(val, (int, float, str)) and not isinstance(val, bool):
+        try:
+            return decimal.Decimal(str(val))
+        except (decimal.InvalidOperation, ValueError):
+            pass
+    return val
+
+
+__all__: Sequence[str] = ("coerce",)

mgqpy-0.8.0.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.3
+Name: mgqpy
+Version: 0.8.0
+Summary: mongo query as a predicate function
+Author: Chiawei Ong
+Author-email: Chiawei Ong <ongchiawei@gmail.com>
+License: MIT License
+         
+         Copyright (c) 2024 Chiawei Ong
+         
+         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.
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Project-URL: Home, https://github.com/weiliddat/mgqpy
+Description-Content-Type: text/markdown
+
+# mgqpy
+
+[![codecov](https://codecov.io/gh/weiliddat/mgqpy/graph/badge.svg?token=CuQS0w5IkL)](https://codecov.io/gh/weiliddat/mgqpy)
+![PyPI - Version](https://img.shields.io/pypi/v/mgqpy)
+
+[MongoDB query](https://www.mongodb.com/docs/manual/reference/operator/query/) as a predicate function
+
+This aims to be consistent with how MongoDB's matches documents. This includes traversal across nested dicts and lists, None and field-presence/absence handling.
+
+## Installation
+
+```sh
+pip install mgqpy
+```
+
+## Usage
+
+Test if an input satisfies a query.
+
+Invalid queries (e.g. using $and without a list) will automatically return False.
+
+Use the `validate` method to raise errors if there's a problem with the query.
+
+```python
+from mgqpy import Query
+
+predicate = Query({"foo.bar": {"$gt": 1}})
+
+inputs = [
+    {"foo": [{"bar": [1, 2]}]},
+    {"foo": {"bar": 1}},
+    {"foo": {"bar": 2}},
+    {"foo": None},
+]
+
+filtered = filter(predicate.test, inputs)
+
+assert list(filtered) == [
+    {"foo": [{"bar": [1, 2]}]},
+    {"foo": {"bar": 2}},
+]
+```
+
+Use `validate` to validate queries given.
+
+```python
+predicate = Query({"foo": {"$in": 1}})
+
+try:
+    predicate.validate()
+except TypeError as e:
+    # ...
+```
+
+`validate` returns the `Query` instance so you can chain `test` if you wish to validate and test against an input in one go.
+
+```python
+input = {"foo": 1}
+
+predicate.validate().test(input)
+```
+
+## Supported operators
+
+Comparison query operators
+
+- [x] \$eq
+- [x] \$eq (implicit), e.g. `{"foo": None}`
+- [x] \$ne
+- [x] \$gt
+- [x] \$gte
+- [x] \$lt
+- [x] \$lte
+- [x] \$in
+- [x] \$nin
+
+Logical query operators
+
+- [x] \$and
+- [x] \$and (implicit), e.g. `{"foo": 1, "bar": "baz"}`
+- [x] \$or
+- [x] \$not
+- [x] \$nor
+
+Evaluation query operators
+
+- [x] \$regex
+- [x] \$regex (implicit), e.g. `{"foo": re.compile('^bar')}`
+- [x] \$mod
+
+Array query operators
+
+- [x] \$all
+- [x] \$elemMatch
+- [x] \$size

mgqpy-0.8.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+mgqpy/__init__.py,sha256=eouUh0LAX-EMCqwTpb6n-6qP9Qs3XhTQx25Hzog5h1Q,6402
+mgqpy/operators/all.py,sha256=KyllXvvaP30lVL0NwHNPp4IwPytjgVn_nfQEcYLpJ_c,1350
+mgqpy/operators/and_or_nor.py,sha256=jMLG1cxBOHwToKWxD2eROUY1LjuJ4SrQWscVfWiiXfA,697
+mgqpy/operators/elem_match.py,sha256=HjMi4zurci0jp3j4h6XrrGZv_K028PavCQ2j_uvMhSo,695
+mgqpy/operators/eq_ne_not.py,sha256=4EGFnd7_cANOarzXrD_QOFUkURDbj-7ZFz05GWeSrtc,1023
+mgqpy/operators/gt.py,sha256=QXF5dnRzw-6XwgMSr0Nfk8Ll5vxab75bYFu2VJ0f6sA,1576
+mgqpy/operators/gte.py,sha256=HFzHZhlceJnxiOvq_-Aw_I-vvYFdRggtJf11t9gdVfw,1749
+mgqpy/operators/in_nin.py,sha256=mEI1VKW88sWhzKfEsq7WyR5IHfYrWXhEtM1laHZFb1o,999
+mgqpy/operators/lt.py,sha256=zTLq2FAL89UrnUs8tqqlqSxqlCKfXB8HSiqq7YNTgIM,1641
+mgqpy/operators/lte.py,sha256=GqUnmncH6nsF6g_yGODrK5zoU2MY2Rl-h2byJmzcg6U,1749
+mgqpy/operators/mod.py,sha256=ULy9slBK0WtHBLytsGWmJmpYBg0AXZ407Lqdhm4UdV8,1106
+mgqpy/operators/regex.py,sha256=LrtW3g2DNHYVHBX81WyaJwf5EbERGeZzReIfo6Yk278,1129
+mgqpy/operators/size.py,sha256=TinEpCQ5WuVXiYXKMpQjV_3B9S4PTuEiulcvb6qDSf8,781
+mgqpy/utils.py,sha256=C555omp9WRipT1ZSTLoMP87dl6QHtuuUD1H1gDxycDM,2775
+mgqpy-0.8.0.dist-info/WHEEL,sha256=RRVLqVugUmFOqBedBFAmA4bsgFcROUBiSUKlERi0Hcg,79
+mgqpy-0.8.0.dist-info/METADATA,sha256=KZwMLxSAGYJmxHIXVQwDwI5Cd3p79Jz7bkQ_DXCuq2M,3484
+mgqpy-0.8.0.dist-info/RECORD,,

mgqpy-0.8.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.21
+Root-Is-Purelib: true
+Tag: py3-none-any