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

mongo_aggro/expressions/comparison.py

@@ -0,0 +1,161 @@
+"""Comparison 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 EqExpr(ExpressionBase):
+    """
+    $eq expression operator - tests equality.
+
+    Example:
+        >>> EqExpr(left=F("status"), right="active").model_dump()
+        {"$eq": ["$status", "active"]}
+    """
+
+    left: Any
+    right: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $eq expression."""
+        return {
+            "$eq": [serialize_value(self.left), serialize_value(self.right)]
+        }
+
+
+class NeExpr(ExpressionBase):
+    """
+    $ne expression operator - tests inequality.
+
+    Example:
+        >>> NeExpr(left=F("status"), right="deleted").model_dump()
+        {"$ne": ["$status", "deleted"]}
+    """
+
+    left: Any
+    right: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $ne expression."""
+        return {
+            "$ne": [serialize_value(self.left), serialize_value(self.right)]
+        }
+
+
+class GtExpr(ExpressionBase):
+    """
+    $gt expression operator - tests greater than.
+
+    Example:
+        >>> GtExpr(left=F("age"), right=18).model_dump()
+        {"$gt": ["$age", 18]}
+    """
+
+    left: Any
+    right: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $gt expression."""
+        return {
+            "$gt": [serialize_value(self.left), serialize_value(self.right)]
+        }
+
+
+class GteExpr(ExpressionBase):
+    """
+    $gte expression operator - tests greater than or equal.
+
+    Example:
+        >>> GteExpr(left=F("age"), right=18).model_dump()
+        {"$gte": ["$age", 18]}
+    """
+
+    left: Any
+    right: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $gte expression."""
+        return {
+            "$gte": [serialize_value(self.left), serialize_value(self.right)]
+        }
+
+
+class LtExpr(ExpressionBase):
+    """
+    $lt expression operator - tests less than.
+
+    Example:
+        >>> LtExpr(left=F("age"), right=65).model_dump()
+        {"$lt": ["$age", 65]}
+    """
+
+    left: Any
+    right: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $lt expression."""
+        return {
+            "$lt": [serialize_value(self.left), serialize_value(self.right)]
+        }
+
+
+class LteExpr(ExpressionBase):
+    """
+    $lte expression operator - tests less than or equal.
+
+    Example:
+        >>> LteExpr(left=F("age"), right=65).model_dump()
+        {"$lte": ["$age", 65]}
+    """
+
+    left: Any
+    right: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $lte expression."""
+        return {
+            "$lte": [serialize_value(self.left), serialize_value(self.right)]
+        }
+
+
+class CmpExpr(ExpressionBase):
+    """
+    $cmp expression operator - compares two values.
+
+    Returns -1 if first < second, 0 if equal, 1 if first > second.
+
+    Example:
+        >>> CmpExpr(left=F("a"), right=F("b")).model_dump()
+        {"$cmp": ["$a", "$b"]}
+    """
+
+    left: Any
+    right: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $cmp expression."""
+        return {
+            "$cmp": [serialize_value(self.left), serialize_value(self.right)]
+        }
+
+
+__all__ = [
+    "EqExpr",
+    "NeExpr",
+    "GtExpr",
+    "GteExpr",
+    "LtExpr",
+    "LteExpr",
+    "CmpExpr",
+]

mongo_aggro/expressions/conditional.py

@@ -0,0 +1,117 @@
+"""Conditional expression operators for MongoDB aggregation."""
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, model_serializer
+
+from mongo_aggro.base import serialize_value
+from mongo_aggro.expressions.base import ExpressionBase
+
+
+class CondExpr(ExpressionBase):
+    """
+    $cond expression operator - ternary conditional.
+
+    Example:
+        >>> CondExpr(
+        ...     if_=GtExpr(left=F("qty"), right=100),
+        ...     then="bulk",
+        ...     else_="retail"
+        ... ).model_dump()
+        {"$cond": {"if": {"$gt": ["$qty", 100]}, "then": "bulk", "else": "retail"}}
+    """
+
+    if_: Any
+    then: Any
+    else_: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $cond expression."""
+        return {
+            "$cond": {
+                "if": serialize_value(self.if_),
+                "then": serialize_value(self.then),
+                "else": serialize_value(self.else_),
+            }
+        }
+
+
+class IfNullExpr(ExpressionBase):
+    """
+    $ifNull expression operator - null coalescing.
+
+    Example:
+        >>> IfNullExpr(input=F("name"), replacement="Unknown").model_dump()
+        {"$ifNull": ["$name", "Unknown"]}
+    """
+
+    input: Any
+    replacement: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $ifNull expression."""
+        return {
+            "$ifNull": [
+                serialize_value(self.input),
+                serialize_value(self.replacement),
+            ]
+        }
+
+
+class SwitchBranch(BaseModel):
+    """A single branch in a $switch expression."""
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        extra="forbid",
+    )
+
+    case: Any
+    then: Any
+
+
+class SwitchExpr(ExpressionBase):
+    """
+    $switch expression operator - multi-branch conditional.
+
+    Example:
+        >>> SwitchExpr(
+        ...     branches=[
+        ...         SwitchBranch(case=EqExpr(left=F("status"), right="A"), then=1),
+        ...         SwitchBranch(case=EqExpr(left=F("status"), right="B"), then=2),
+        ...     ],
+        ...     default=0
+        ... ).model_dump()
+        {"$switch": {"branches": [...], "default": 0}}
+    """
+
+    branches: list[SwitchBranch]
+    default: Any = None
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $switch expression."""
+        result: dict[str, Any] = {
+            "$switch": {
+                "branches": [
+                    {
+                        "case": serialize_value(b.case),
+                        "then": serialize_value(b.then),
+                    }
+                    for b in self.branches
+                ]
+            }
+        }
+        if self.default is not None:
+            result["$switch"]["default"] = serialize_value(self.default)
+        return result
+
+
+__all__ = [
+    "CondExpr",
+    "IfNullExpr",
+    "SwitchBranch",
+    "SwitchExpr",
+]