mongo-aggro 0.1.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

mongo_aggro/expressions/encrypted.py

@@ -0,0 +1,116 @@
+"""Encrypted string expression operators for MongoDB aggregation."""
+
+from typing import Any
+
+from pydantic import model_serializer
+
+from mongo_aggro.base import serialize_value
+from mongo_aggro.expressions.base import ExpressionBase
+
+
+class EncStrContainsExpr(ExpressionBase):
+    """
+    $encStrContains expression - checks if encrypted string contains substring.
+
+    Used with Queryable Encryption for searching encrypted fields.
+
+    Example:
+        >>> EncStrContainsExpr(input=F("encryptedField"), substring="search").model_dump()
+        {"$encStrContains": {"input": "$encryptedField", "substring": "search"}}
+    """
+
+    input: Any
+    substring: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $encStrContains expression."""
+        return {
+            "$encStrContains": {
+                "input": serialize_value(self.input),
+                "substring": serialize_value(self.substring),
+            }
+        }
+
+
+class EncStrStartsWithExpr(ExpressionBase):
+    """
+    $encStrStartsWith expression - checks if encrypted string starts with prefix.
+
+    Used with Queryable Encryption for searching encrypted fields.
+
+    Example:
+        >>> EncStrStartsWithExpr(input=F("encryptedField"), prefix="abc").model_dump()
+        {"$encStrStartsWith": {"input": "$encryptedField", "prefix": "abc"}}
+    """
+
+    input: Any
+    prefix: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $encStrStartsWith expression."""
+        return {
+            "$encStrStartsWith": {
+                "input": serialize_value(self.input),
+                "prefix": serialize_value(self.prefix),
+            }
+        }
+
+
+class EncStrEndsWithExpr(ExpressionBase):
+    """
+    $encStrEndsWith expression - checks if encrypted string ends with suffix.
+
+    Used with Queryable Encryption for searching encrypted fields.
+
+    Example:
+        >>> EncStrEndsWithExpr(input=F("encryptedField"), suffix="xyz").model_dump()
+        {"$encStrEndsWith": {"input": "$encryptedField", "suffix": "xyz"}}
+    """
+
+    input: Any
+    suffix: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $encStrEndsWith expression."""
+        return {
+            "$encStrEndsWith": {
+                "input": serialize_value(self.input),
+                "suffix": serialize_value(self.suffix),
+            }
+        }
+
+
+class EncStrNormalizedEqExpr(ExpressionBase):
+    """
+    $encStrNormalizedEq expression - normalized equality for encrypted strings.
+
+    Used with Queryable Encryption for case-insensitive matching.
+
+    Example:
+        >>> EncStrNormalizedEqExpr(input=F("encryptedField"), value="test").model_dump()
+        {"$encStrNormalizedEq": {"input": "$encryptedField", "value": "test"}}
+    """
+
+    input: Any
+    value: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $encStrNormalizedEq expression."""
+        return {
+            "$encStrNormalizedEq": {
+                "input": serialize_value(self.input),
+                "value": serialize_value(self.value),
+            }
+        }
+
+
+__all__ = [
+    "EncStrContainsExpr",
+    "EncStrStartsWithExpr",
+    "EncStrEndsWithExpr",
+    "EncStrNormalizedEqExpr",
+]

mongo_aggro/expressions/logical.py

@@ -0,0 +1,72 @@
+"""Logical expression operators for MongoDB aggregation."""
+
+from typing import Any
+
+from pydantic import model_serializer
+
+from mongo_aggro.base import serialize_value
+from mongo_aggro.expressions.base import ExpressionBase
+
+
+class AndExpr(ExpressionBase):
+    """
+    $and expression operator - logical AND.
+
+    Example:
+        >>> AndExpr(conditions=[
+        ...     EqExpr(left=F("a"), right=1),
+        ...     GtExpr(left=F("b"), right=2)
+        ... ]).model_dump()
+        {"$and": [{"$eq": ["$a", 1]}, {"$gt": ["$b", 2]}]}
+    """
+
+    conditions: list[Any]
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $and expression."""
+        return {"$and": [serialize_value(c) for c in self.conditions]}
+
+
+class OrExpr(ExpressionBase):
+    """
+    $or expression operator - logical OR.
+
+    Example:
+        >>> OrExpr(conditions=[
+        ...     EqExpr(left=F("a"), right=1),
+        ...     EqExpr(left=F("a"), right=2)
+        ... ]).model_dump()
+        {"$or": [{"$eq": ["$a", 1]}, {"$eq": ["$a", 2]}]}
+    """
+
+    conditions: list[Any]
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $or expression."""
+        return {"$or": [serialize_value(c) for c in self.conditions]}
+
+
+class NotExpr(ExpressionBase):
+    """
+    $not expression operator - logical NOT.
+
+    Example:
+        >>> NotExpr(condition=EqExpr(left=F("a"), right=1)).model_dump()
+        {"$not": {"$eq": ["$a", 1]}}
+    """
+
+    condition: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $not expression."""
+        return {"$not": serialize_value(self.condition)}
+
+
+__all__ = [
+    "AndExpr",
+    "OrExpr",
+    "NotExpr",
+]

mongo_aggro/expressions/object.py

@@ -0,0 +1,122 @@
+"""Object expression operators for MongoDB aggregation."""
+
+from typing import Any
+
+from pydantic import model_serializer
+
+from mongo_aggro.base import serialize_value
+from mongo_aggro.expressions.base import ExpressionBase
+
+
+class MergeObjectsExpr(ExpressionBase):
+    """
+    $mergeObjects expression operator - merges documents into one.
+
+    Example:
+        >>> MergeObjectsExpr(objects=[F("defaults"), F("overrides")]).model_dump()
+        {"$mergeObjects": ["$defaults", "$overrides"]}
+    """
+
+    objects: list[Any]
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $mergeObjects expression."""
+        return {"$mergeObjects": [serialize_value(o) for o in self.objects]}
+
+
+class ObjectToArrayExpr(ExpressionBase):
+    """
+    $objectToArray expression operator - converts object to array of k/v pairs.
+
+    Example:
+        >>> ObjectToArrayExpr(input=F("doc")).model_dump()
+        {"$objectToArray": "$doc"}
+    """
+
+    input: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $objectToArray expression."""
+        return {"$objectToArray": serialize_value(self.input)}
+
+
+class ArrayToObjectExpr(ExpressionBase):
+    """
+    $arrayToObject expression operator - converts array of k/v pairs to object.
+
+    Example:
+        >>> ArrayToObjectExpr(input=F("pairs")).model_dump()
+        {"$arrayToObject": "$pairs"}
+    """
+
+    input: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $arrayToObject expression."""
+        return {"$arrayToObject": serialize_value(self.input)}
+
+
+class GetFieldExpr(ExpressionBase):
+    """
+    $getField expression operator - gets a field value by name.
+
+    Example:
+        >>> GetFieldExpr(field="status", input=F("doc")).model_dump()
+        {"$getField": {"field": "status", "input": "$doc"}}
+    """
+
+    field: Any
+    input: Any | None = None
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $getField expression."""
+        if self.input is None:
+            return {"$getField": serialize_value(self.field)}
+        return {
+            "$getField": {
+                "field": serialize_value(self.field),
+                "input": serialize_value(self.input),
+            }
+        }
+
+
+class SetFieldExpr(ExpressionBase):
+    """
+    $setField expression operator - sets or adds a field in a document.
+
+    Example:
+        >>> SetFieldExpr(
+        ...     field="status",
+        ...     input=F("doc"),
+        ...     value="active"
+        ... ).model_dump()
+        {"$setField": {"field": "status", "input": "$doc", "value": "active"}}
+    """
+
+    field: Any
+    input: Any
+    value: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $setField expression."""
+        return {
+            "$setField": {
+                "field": serialize_value(self.field),
+                "input": serialize_value(self.input),
+                "value": serialize_value(self.value),
+            }
+        }
+
+
+__all__ = [
+    "MergeObjectsExpr",
+    "ObjectToArrayExpr",
+    "ArrayToObjectExpr",
+    "GetFieldExpr",
+    "SetFieldExpr",
+]

mongo_aggro/expressions/set.py

@@ -0,0 +1,150 @@
+"""Set expression operators for MongoDB aggregation."""
+
+from typing import Any
+
+from pydantic import model_serializer
+
+from mongo_aggro.base import serialize_value
+from mongo_aggro.expressions.base import ExpressionBase
+
+
+class SetUnionExpr(ExpressionBase):
+    """
+    $setUnion expression operator - returns union of arrays (unique values).
+
+    Example:
+        >>> SetUnionExpr(arrays=[F("tags1"), F("tags2")]).model_dump()
+        {"$setUnion": ["$tags1", "$tags2"]}
+    """
+
+    arrays: list[Any]
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $setUnion expression."""
+        return {"$setUnion": [serialize_value(a) for a in self.arrays]}
+
+
+class SetIntersectionExpr(ExpressionBase):
+    """
+    $setIntersection expression operator - returns common elements.
+
+    Example:
+        >>> SetIntersectionExpr(arrays=[F("a"), F("b")]).model_dump()
+        {"$setIntersection": ["$a", "$b"]}
+    """
+
+    arrays: list[Any]
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $setIntersection expression."""
+        return {"$setIntersection": [serialize_value(a) for a in self.arrays]}
+
+
+class SetDifferenceExpr(ExpressionBase):
+    """
+    $setDifference expression operator - returns elements in first not in second.
+
+    Example:
+        >>> SetDifferenceExpr(first=F("all"), second=F("excluded")).model_dump()
+        {"$setDifference": ["$all", "$excluded"]}
+    """
+
+    first: Any
+    second: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $setDifference expression."""
+        return {
+            "$setDifference": [
+                serialize_value(self.first),
+                serialize_value(self.second),
+            ]
+        }
+
+
+class SetEqualsExpr(ExpressionBase):
+    """
+    $setEquals expression operator - checks if arrays have same elements.
+
+    Example:
+        >>> SetEqualsExpr(arrays=[F("a"), F("b")]).model_dump()
+        {"$setEquals": ["$a", "$b"]}
+    """
+
+    arrays: list[Any]
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $setEquals expression."""
+        return {"$setEquals": [serialize_value(a) for a in self.arrays]}
+
+
+class SetIsSubsetExpr(ExpressionBase):
+    """
+    $setIsSubset expression operator - checks if first is subset of second.
+
+    Example:
+        >>> SetIsSubsetExpr(first=F("small"), second=F("large")).model_dump()
+        {"$setIsSubset": ["$small", "$large"]}
+    """
+
+    first: Any
+    second: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $setIsSubset expression."""
+        return {
+            "$setIsSubset": [
+                serialize_value(self.first),
+                serialize_value(self.second),
+            ]
+        }
+
+
+class AnyElementTrueExpr(ExpressionBase):
+    """
+    $anyElementTrue expression operator - true if any array element is truthy.
+
+    Example:
+        >>> AnyElementTrueExpr(input=F("flags")).model_dump()
+        {"$anyElementTrue": "$flags"}
+    """
+
+    input: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $anyElementTrue expression."""
+        return {"$anyElementTrue": serialize_value(self.input)}
+
+
+class AllElementsTrueExpr(ExpressionBase):
+    """
+    $allElementsTrue expression operator - true if all array elements truthy.
+
+    Example:
+        >>> AllElementsTrueExpr(input=F("conditions")).model_dump()
+        {"$allElementsTrue": "$conditions"}
+    """
+
+    input: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $allElementsTrue expression."""
+        return {"$allElementsTrue": serialize_value(self.input)}
+
+
+__all__ = [
+    "SetUnionExpr",
+    "SetIntersectionExpr",
+    "SetDifferenceExpr",
+    "SetEqualsExpr",
+    "SetIsSubsetExpr",
+    "AnyElementTrueExpr",
+    "AllElementsTrueExpr",
+]

mongo_aggro/expressions/size.py

@@ -0,0 +1,48 @@
+"""Data size expression operators for MongoDB aggregation."""
+
+from typing import Any
+
+from pydantic import model_serializer
+
+from mongo_aggro.base import serialize_value
+from mongo_aggro.expressions.base import ExpressionBase
+
+
+class BsonSizeExpr(ExpressionBase):
+    """
+    $bsonSize expression operator - returns size of document in bytes.
+
+    Example:
+        >>> BsonSizeExpr(input=F("doc")).model_dump()
+        {"$bsonSize": "$doc"}
+    """
+
+    input: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $bsonSize expression."""
+        return {"$bsonSize": serialize_value(self.input)}
+
+
+class BinarySizeExpr(ExpressionBase):
+    """
+    $binarySize expression operator - returns size of string/binary in bytes.
+
+    Example:
+        >>> BinarySizeExpr(input=F("data")).model_dump()
+        {"$binarySize": "$data"}
+    """
+
+    input: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $binarySize expression."""
+        return {"$binarySize": serialize_value(self.input)}
+
+
+__all__ = [
+    "BsonSizeExpr",
+    "BinarySizeExpr",
+]