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

mongo_aggro/expressions/__init__.py

@@ -0,0 +1,396 @@
+"""MongoDB expression operators for aggregation pipelines.
+
+This package provides expression operators organized by category:
+- arithmetic: Math operators ($add, $subtract, $multiply, etc.)
+- array: Array manipulation ($size, $slice, $filter, $map, etc.)
+- bitwise: Bitwise operations ($bitAnd, $bitOr, $bitXor, $bitNot)
+- comparison: Comparisons ($eq, $ne, $gt, $gte, $lt, $lte, $cmp)
+- conditional: Conditionals ($cond, $ifNull, $switch)
+- date: Date operations ($dateAdd, $year, $month, etc.)
+- encrypted: Encrypted string operations
+- logical: Boolean logic ($and, $or, $not)
+- object: Object manipulation ($mergeObjects, $getField, etc.)
+- set: Set operations ($setUnion, $setIntersection, etc.)
+- size: Data size ($bsonSize, $binarySize)
+- string: String operations ($concat, $split, $toLower, etc.)
+- trigonometry: Trig functions ($sin, $cos, $tan, etc.)
+- type: Type conversion ($toString, $toInt, $type, etc.)
+- variable: Variables ($let, $literal, $rand)
+- window: Window functions ($rank, $shift, etc.)
+"""
+
+# Base classes
+# Arithmetic operators
+from mongo_aggro.expressions.arithmetic import (
+    AbsExpr,
+    AddExpr,
+    CeilExpr,
+    DivideExpr,
+    ExpExpr,
+    FloorExpr,
+    LnExpr,
+    Log10Expr,
+    LogExpr,
+    ModExpr,
+    MultiplyExpr,
+    PowExpr,
+    RoundExpr,
+    SqrtExpr,
+    SubtractExpr,
+    TruncExpr,
+)
+
+# Array operators
+from mongo_aggro.expressions.array import (
+    ArrayElemAtExpr,
+    ArraySizeExpr,
+    ConcatArraysExpr,
+    FilterExpr,
+    FirstNExpr,
+    InArrayExpr,
+    IndexOfArrayExpr,
+    IsArrayExpr,
+    LastNExpr,
+    MapExpr,
+    MaxNExpr,
+    MinNExpr,
+    RangeExpr,
+    ReduceExpr,
+    ReverseArrayExpr,
+    SliceExpr,
+    SortArrayExpr,
+)
+from mongo_aggro.expressions.base import ExpressionBase, F, Field
+
+# Bitwise operators
+from mongo_aggro.expressions.bitwise import (
+    BitAndExpr,
+    BitNotExpr,
+    BitOrExpr,
+    BitXorExpr,
+)
+
+# Comparison operators
+from mongo_aggro.expressions.comparison import (
+    CmpExpr,
+    EqExpr,
+    GteExpr,
+    GtExpr,
+    LteExpr,
+    LtExpr,
+    NeExpr,
+)
+
+# Conditional operators
+from mongo_aggro.expressions.conditional import (
+    CondExpr,
+    IfNullExpr,
+    SwitchBranch,
+    SwitchExpr,
+)
+
+# Date operators
+from mongo_aggro.expressions.date import (
+    DateAddExpr,
+    DateDiffExpr,
+    DateFromPartsExpr,
+    DateFromStringExpr,
+    DateSubtractExpr,
+    DateToPartsExpr,
+    DateToStringExpr,
+    DateTruncExpr,
+    DayOfMonthExpr,
+    DayOfWeekExpr,
+    DayOfYearExpr,
+    HourExpr,
+    IsoDayOfWeekExpr,
+    IsoWeekExpr,
+    IsoWeekYearExpr,
+    MillisecondExpr,
+    MinuteExpr,
+    MonthExpr,
+    SecondExpr,
+    ToDateExpr,
+    WeekExpr,
+    YearExpr,
+)
+
+# Encrypted string operators
+from mongo_aggro.expressions.encrypted import (
+    EncStrContainsExpr,
+    EncStrEndsWithExpr,
+    EncStrNormalizedEqExpr,
+    EncStrStartsWithExpr,
+)
+
+# Logical operators
+from mongo_aggro.expressions.logical import AndExpr, NotExpr, OrExpr
+
+# Object operators
+from mongo_aggro.expressions.object import (
+    ArrayToObjectExpr,
+    GetFieldExpr,
+    MergeObjectsExpr,
+    ObjectToArrayExpr,
+    SetFieldExpr,
+)
+
+# Set operators
+from mongo_aggro.expressions.set import (
+    AllElementsTrueExpr,
+    AnyElementTrueExpr,
+    SetDifferenceExpr,
+    SetEqualsExpr,
+    SetIntersectionExpr,
+    SetIsSubsetExpr,
+    SetUnionExpr,
+)
+
+# Size operators
+from mongo_aggro.expressions.size import BinarySizeExpr, BsonSizeExpr
+
+# String operators
+from mongo_aggro.expressions.string import (
+    ConcatExpr,
+    LTrimExpr,
+    RegexFindAllExpr,
+    RegexFindExpr,
+    RegexMatchExpr,
+    ReplaceAllExpr,
+    ReplaceOneExpr,
+    RTrimExpr,
+    SplitExpr,
+    StrCaseCmpExpr,
+    StrLenCPExpr,
+    SubstrCPExpr,
+    ToLowerExpr,
+    ToUpperExpr,
+    TrimExpr,
+)
+
+# Trigonometry operators
+from mongo_aggro.expressions.trigonometry import (
+    AcosExpr,
+    AcoshExpr,
+    AsinExpr,
+    AsinhExpr,
+    Atan2Expr,
+    AtanExpr,
+    AtanhExpr,
+    CosExpr,
+    CoshExpr,
+    DegreesToRadiansExpr,
+    RadiansToDegreesExpr,
+    SinExpr,
+    SinhExpr,
+    TanExpr,
+    TanhExpr,
+)
+
+# Type operators
+from mongo_aggro.expressions.type import (
+    ConvertExpr,
+    IsNumberExpr,
+    ToBoolExpr,
+    ToDecimalExpr,
+    ToDoubleExpr,
+    ToIntExpr,
+    ToLongExpr,
+    ToObjectIdExpr,
+    ToStringExpr,
+    TypeExpr,
+)
+
+# Variable operators
+from mongo_aggro.expressions.variable import LetExpr, LiteralExpr, RandExpr
+
+# Window operators
+from mongo_aggro.expressions.window import (
+    BottomExpr,
+    BottomNWindowExpr,
+    CovariancePopExpr,
+    CovarianceSampExpr,
+    DenseRankExpr,
+    DerivativeExpr,
+    DocumentNumberExpr,
+    ExpMovingAvgExpr,
+    IntegralExpr,
+    LinearFillExpr,
+    LocfExpr,
+    RankExpr,
+    ShiftExpr,
+    TopExpr,
+    TopNWindowExpr,
+)
+
+__all__ = [
+    # Base
+    "Field",
+    "F",
+    "ExpressionBase",
+    # Comparison
+    "EqExpr",
+    "NeExpr",
+    "GtExpr",
+    "GteExpr",
+    "LtExpr",
+    "LteExpr",
+    "CmpExpr",
+    # Logical
+    "AndExpr",
+    "OrExpr",
+    "NotExpr",
+    # Arithmetic
+    "AddExpr",
+    "SubtractExpr",
+    "MultiplyExpr",
+    "DivideExpr",
+    "AbsExpr",
+    "ModExpr",
+    "CeilExpr",
+    "FloorExpr",
+    "RoundExpr",
+    "TruncExpr",
+    "SqrtExpr",
+    "PowExpr",
+    "ExpExpr",
+    "LnExpr",
+    "Log10Expr",
+    "LogExpr",
+    # Conditional
+    "CondExpr",
+    "IfNullExpr",
+    "SwitchBranch",
+    "SwitchExpr",
+    # String
+    "ConcatExpr",
+    "SplitExpr",
+    "ToLowerExpr",
+    "ToUpperExpr",
+    "TrimExpr",
+    "LTrimExpr",
+    "RTrimExpr",
+    "ReplaceOneExpr",
+    "ReplaceAllExpr",
+    "RegexMatchExpr",
+    "RegexFindExpr",
+    "RegexFindAllExpr",
+    "SubstrCPExpr",
+    "StrLenCPExpr",
+    "StrCaseCmpExpr",
+    # Array
+    "ArraySizeExpr",
+    "SliceExpr",
+    "FilterExpr",
+    "MapExpr",
+    "ReduceExpr",
+    "ArrayElemAtExpr",
+    "ConcatArraysExpr",
+    "InArrayExpr",
+    "IndexOfArrayExpr",
+    "IsArrayExpr",
+    "ReverseArrayExpr",
+    "SortArrayExpr",
+    "RangeExpr",
+    "FirstNExpr",
+    "LastNExpr",
+    "MaxNExpr",
+    "MinNExpr",
+    # Date
+    "DateAddExpr",
+    "DateSubtractExpr",
+    "DateDiffExpr",
+    "DateToStringExpr",
+    "DateFromStringExpr",
+    "ToDateExpr",
+    "YearExpr",
+    "MonthExpr",
+    "DayOfMonthExpr",
+    "DayOfWeekExpr",
+    "DayOfYearExpr",
+    "HourExpr",
+    "MinuteExpr",
+    "SecondExpr",
+    "MillisecondExpr",
+    "WeekExpr",
+    "IsoWeekExpr",
+    "IsoWeekYearExpr",
+    "IsoDayOfWeekExpr",
+    "DateFromPartsExpr",
+    "DateToPartsExpr",
+    "DateTruncExpr",
+    # Type
+    "ToStringExpr",
+    "ToIntExpr",
+    "ToDoubleExpr",
+    "ToBoolExpr",
+    "ToObjectIdExpr",
+    "ToLongExpr",
+    "ToDecimalExpr",
+    "ConvertExpr",
+    "TypeExpr",
+    "IsNumberExpr",
+    # Set
+    "SetUnionExpr",
+    "SetIntersectionExpr",
+    "SetDifferenceExpr",
+    "SetEqualsExpr",
+    "SetIsSubsetExpr",
+    "AnyElementTrueExpr",
+    "AllElementsTrueExpr",
+    # Object
+    "MergeObjectsExpr",
+    "ObjectToArrayExpr",
+    "ArrayToObjectExpr",
+    "GetFieldExpr",
+    "SetFieldExpr",
+    # Variable
+    "LetExpr",
+    "LiteralExpr",
+    "RandExpr",
+    # Trigonometry
+    "SinExpr",
+    "CosExpr",
+    "TanExpr",
+    "AsinExpr",
+    "AcosExpr",
+    "AtanExpr",
+    "Atan2Expr",
+    "SinhExpr",
+    "CoshExpr",
+    "TanhExpr",
+    "AsinhExpr",
+    "AcoshExpr",
+    "AtanhExpr",
+    "DegreesToRadiansExpr",
+    "RadiansToDegreesExpr",
+    # Bitwise
+    "BitAndExpr",
+    "BitOrExpr",
+    "BitXorExpr",
+    "BitNotExpr",
+    # Size
+    "BsonSizeExpr",
+    "BinarySizeExpr",
+    # Window
+    "RankExpr",
+    "DenseRankExpr",
+    "DocumentNumberExpr",
+    "ShiftExpr",
+    "ExpMovingAvgExpr",
+    "DerivativeExpr",
+    "IntegralExpr",
+    "CovariancePopExpr",
+    "CovarianceSampExpr",
+    "LinearFillExpr",
+    "LocfExpr",
+    "TopExpr",
+    "BottomExpr",
+    "TopNWindowExpr",
+    "BottomNWindowExpr",
+    # Encrypted
+    "EncStrContainsExpr",
+    "EncStrStartsWithExpr",
+    "EncStrEndsWithExpr",
+    "EncStrNormalizedEqExpr",
+]

mongo_aggro/expressions/arithmetic.py

@@ -0,0 +1,329 @@
+"""Arithmetic 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 AddExpr(ExpressionBase):
+    """
+    $add expression operator - adds numbers or dates.
+
+    Example:
+        >>> AddExpr(operands=[F("price"), F("tax")]).model_dump()
+        {"$add": ["$price", "$tax"]}
+    """
+
+    operands: list[Any]
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $add expression."""
+        return {"$add": [serialize_value(o) for o in self.operands]}
+
+
+class SubtractExpr(ExpressionBase):
+    """
+    $subtract expression operator - subtracts two numbers or dates.
+
+    Example:
+        >>> SubtractExpr(left=F("total"), right=F("discount")).model_dump()
+        {"$subtract": ["$total", "$discount"]}
+    """
+
+    left: Any
+    right: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $subtract expression."""
+        return {
+            "$subtract": [
+                serialize_value(self.left),
+                serialize_value(self.right),
+            ]
+        }
+
+
+class MultiplyExpr(ExpressionBase):
+    """
+    $multiply expression operator - multiplies numbers.
+
+    Example:
+        >>> MultiplyExpr(operands=[F("price"), F("qty")]).model_dump()
+        {"$multiply": ["$price", "$qty"]}
+    """
+
+    operands: list[Any]
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $multiply expression."""
+        return {"$multiply": [serialize_value(o) for o in self.operands]}
+
+
+class DivideExpr(ExpressionBase):
+    """
+    $divide expression operator - divides two numbers.
+
+    Example:
+        >>> DivideExpr(dividend=F("total"), divisor=F("count")).model_dump()
+        {"$divide": ["$total", "$count"]}
+    """
+
+    dividend: Any
+    divisor: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $divide expression."""
+        return {
+            "$divide": [
+                serialize_value(self.dividend),
+                serialize_value(self.divisor),
+            ]
+        }
+
+
+class AbsExpr(ExpressionBase):
+    """
+    $abs expression operator - returns absolute value.
+
+    Example:
+        >>> AbsExpr(value=F("balance")).model_dump()
+        {"$abs": "$balance"}
+    """
+
+    value: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $abs expression."""
+        return {"$abs": serialize_value(self.value)}
+
+
+class ModExpr(ExpressionBase):
+    """
+    $mod expression operator - returns remainder of division.
+
+    Example:
+        >>> ModExpr(dividend=F("num"), divisor=2).model_dump()
+        {"$mod": ["$num", 2]}
+    """
+
+    dividend: Any
+    divisor: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $mod expression."""
+        return {
+            "$mod": [
+                serialize_value(self.dividend),
+                serialize_value(self.divisor),
+            ]
+        }
+
+
+class CeilExpr(ExpressionBase):
+    """
+    $ceil expression operator - rounds up to nearest integer.
+
+    Example:
+        >>> CeilExpr(input=F("value")).model_dump()
+        {"$ceil": "$value"}
+    """
+
+    input: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $ceil expression."""
+        return {"$ceil": serialize_value(self.input)}
+
+
+class FloorExpr(ExpressionBase):
+    """
+    $floor expression operator - rounds down to nearest integer.
+
+    Example:
+        >>> FloorExpr(input=F("value")).model_dump()
+        {"$floor": "$value"}
+    """
+
+    input: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $floor expression."""
+        return {"$floor": serialize_value(self.input)}
+
+
+class RoundExpr(ExpressionBase):
+    """
+    $round expression operator - rounds to specified decimal place.
+
+    Example:
+        >>> RoundExpr(input=F("value"), place=2).model_dump()
+        {"$round": ["$value", 2]}
+    """
+
+    input: Any
+    place: int = 0
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $round expression."""
+        return {"$round": [serialize_value(self.input), self.place]}
+
+
+class TruncExpr(ExpressionBase):
+    """
+    $trunc expression operator - truncates to specified decimal place.
+
+    Example:
+        >>> TruncExpr(input=F("value"), place=2).model_dump()
+        {"$trunc": ["$value", 2]}
+    """
+
+    input: Any
+    place: int = 0
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $trunc expression."""
+        return {"$trunc": [serialize_value(self.input), self.place]}
+
+
+class SqrtExpr(ExpressionBase):
+    """
+    $sqrt expression operator - calculates square root.
+
+    Example:
+        >>> SqrtExpr(input=F("value")).model_dump()
+        {"$sqrt": "$value"}
+    """
+
+    input: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $sqrt expression."""
+        return {"$sqrt": serialize_value(self.input)}
+
+
+class PowExpr(ExpressionBase):
+    """
+    $pow expression operator - raises number to exponent.
+
+    Example:
+        >>> PowExpr(base=F("value"), exponent=2).model_dump()
+        {"$pow": ["$value", 2]}
+    """
+
+    base: Any
+    exponent: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $pow expression."""
+        return {
+            "$pow": [
+                serialize_value(self.base),
+                serialize_value(self.exponent),
+            ]
+        }
+
+
+class ExpExpr(ExpressionBase):
+    """
+    $exp expression operator - raises e to the specified exponent.
+
+    Example:
+        >>> ExpExpr(input=F("value")).model_dump()
+        {"$exp": "$value"}
+    """
+
+    input: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $exp expression."""
+        return {"$exp": serialize_value(self.input)}
+
+
+class LnExpr(ExpressionBase):
+    """
+    $ln expression operator - calculates natural logarithm.
+
+    Example:
+        >>> LnExpr(input=F("value")).model_dump()
+        {"$ln": "$value"}
+    """
+
+    input: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $ln expression."""
+        return {"$ln": serialize_value(self.input)}
+
+
+class Log10Expr(ExpressionBase):
+    """
+    $log10 expression operator - calculates log base 10.
+
+    Example:
+        >>> Log10Expr(input=F("value")).model_dump()
+        {"$log10": "$value"}
+    """
+
+    input: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $log10 expression."""
+        return {"$log10": serialize_value(self.input)}
+
+
+class LogExpr(ExpressionBase):
+    """
+    $log expression operator - calculates log with specified base.
+
+    Example:
+        >>> LogExpr(input=F("value"), base=2).model_dump()
+        {"$log": ["$value", 2]}
+    """
+
+    input: Any
+    base: Any
+
+    @model_serializer
+    def serialize(self) -> dict[str, Any]:
+        """Serialize to MongoDB $log expression."""
+        return {
+            "$log": [serialize_value(self.input), serialize_value(self.base)]
+        }
+
+
+__all__ = [
+    "AddExpr",
+    "SubtractExpr",
+    "MultiplyExpr",
+    "DivideExpr",
+    "AbsExpr",
+    "ModExpr",
+    "CeilExpr",
+    "FloorExpr",
+    "RoundExpr",
+    "TruncExpr",
+    "SqrtExpr",
+    "PowExpr",
+    "ExpExpr",
+    "LnExpr",
+    "Log10Expr",
+    "LogExpr",
+]