72 expressions improvements

src/monggregate/base.py

@@ -32,15 +32,20 @@ def __new__(cls, *args, **kwargs):
 class BaseModel(pyd.BaseModel, ABC):
     """Mongreggate base class"""
 
+    def to_expression(self)->dict:
+        """Converts an instance of a class inheriting from BaseModel to an expression"""
+
+        return self.express(self)
+
     @classmethod
-    def resolve(cls, obj:Any)->dict|list[dict]:
+    def express(cls, obj:Any)->dict|list[dict]:
         """Resolves an expression encapsulated in an object from a class inheriting from BaseModel"""
 
-        return resolve(obj)
+        return express(obj)
 
     @property
     @abstractmethod
-    def statement(self)->dict:
+    def expression(self)->dict:
         """Stage statement absctract method"""
 
         # this is a lazy attribute
@@ -49,7 +54,7 @@ def statement(self)->dict:
     def __call__(self)->dict:
         """Makes an instance of any class inheriting from this class callable"""
 
-        return self.resolve(self.statement)
+        return self.express(self.expression)
 
     class Config(pyd.BaseConfig):
         """Base configuration for classes inheriting from this"""
@@ -65,25 +70,25 @@ def isbasemodel(instance:Any)->TypeGuard[BaseModel]:
 
     return isinstance(instance, BaseModel)
 
-def resolve(obj:Any)->dict|list[dict]:
+def express(obj:Any)->dict|list[dict]:
         """Resolves an expression encapsulated in an object from a class inheriting from BaseModel"""
 
         if isbasemodel(obj):
-            output:dict|list = obj.statement
+            output:dict|list = obj.expression
         elif isinstance(obj, list) and any(map(isbasemodel, obj)):
             output = []
             for element in obj:
                 if isinstance(element, BaseModel):
-                    output.append(element.statement)
+                    output.append(element.expression)
                 else:
                     output.append(element)
         elif isinstance(obj, dict):
             output = {}
             for key, value in obj.items():
                 if isinstance(value, BaseModel):
-                    output[key] = value.statement
+                    output[key] = value.expression
                 else:
-                    output[key] = resolve(value)
+                    output[key] = express(value)
         else:
             output = obj
 

src/monggregate/expressions.py

@@ -7,7 +7,7 @@
 
 # 3rd Party imports
 # ---------------------------
-from monggregate.base import BaseModel, pyd
+from monggregate.base import BaseModel
 
 # Local imports
 # ----------------------------
@@ -38,8 +38,8 @@ class Expression(BaseModel):
     content : Any
 
     @property
-    def statement(self)->Any:
-        return self.resolve(self.content)
+    def expression(self)->Any:
+        return self.express(self.content)
 
     #----------------------------------------------------
     # Expression Internal Methods
@@ -64,8 +64,8 @@ def field(cls, name:str)->Self:
     def variable(cls, name:str)->Self:
         """Creates a variable expression."""
 
-        while not variable.startswith("$$"):
-            variable = "$" + variable
+        while not name.startswith("$$"):
+            name = "$" + name
 
         return cls(content=Variable(name))
 
@@ -319,7 +319,7 @@ def __and__(self, other:Self)->Self:
         """
 
 
-        return self.__class__(content=boolean.And(expressions=[self, other]))
+        return self.__class__(content=boolean.And(operands=[self, other]))
 
 
     def __or__(self, other:Self)->Self:
@@ -330,7 +330,7 @@ def __or__(self, other:Self)->Self:
         """
 
 
-        return self.__class__(content=boolean.Or(expressions=[self, other]))
+        return self.__class__(content=boolean.Or(operands=[self, other]))
 
 
     def __invert__(self)->Self:
@@ -474,7 +474,7 @@ def concat(self, *args:Self)->Self:
         """Creates a $concat operator"""
 
 
-        return self.__class__(content=strings.Concat(expressions=[self, *args]))
+        return self.__class__(content=strings.Concat(operands=[self, *args]))
 
     def date_from_string(self)->Self:
         """Creates a $dateFromString operator"""

src/monggregate/operators/accumulators/avg.py

@@ -79,7 +79,7 @@ class Average(Accumulator):
 
     Attributes
     ----------
-    expression : Any valid expression
+    operand : Any valid expression
 
     Online MongoDB documentation:
     -----------------------------
@@ -105,17 +105,17 @@ class Average(Accumulator):
     expression : Any
 
     @property
-    def statement(self) -> dict:
+    def expression(self) -> dict:
 
-        return self.resolve({
+        return self.express({
             "$avg" : self.expression
         })
 
 Avg = Average
 
-def average(expression:Any)->Average:
+def average(operand:Any)->Average:
     """Returns a $avg operator"""
 
-    return Average(expression=expression)
+    return Average(expression=operand)
 
 avg = average

src/monggregate/operators/accumulators/count.py

@@ -66,13 +66,13 @@
 
     [Source](https://www.mongodb.com/docs/manual/reference/operator/aggregation/count-accumulator/#mongodb-group-grp.-count)
     """
 
 
 
     @property
-    def statement(self) -> dict:
+    def expression(self) -> dict:
 
-        return self.resolve({
+        return self.express({
             "$count" : {}
         })
 

src/monggregate/operators/accumulators/first.py

@@ -68,7 +68,7 @@
 
     Attributes
     ------------------------
-        - expression, Expression : Any valid expression
+        - operand, Any : Any valid expression
 
     Online MongoDB documentation:
     ------------------------------
@@ -88,13 +88,13 @@
     [Source](https://www.mongodb.com/docs/manual/reference/operator/aggregation/first/#mongodb-group-grp.-first)
     """
 
     expression : Any
 
 
     @property
-    def statement(self) -> dict:
+    def expression(self) -> dict:
 
-        return self.resolve({
+        return self.express({
             "$first" : self.expression
         })
 

src/monggregate/operators/accumulators/last.py

@@ -60,7 +60,7 @@
 
     Attributes
     ------------------------
-        - expression, Expression : Any valid expression
+        - operand, Any:Any valid expression
 
     Online MongoDB documentation
     ----------------------------
@@ -80,18 +80,18 @@
     [Source](https://www.mongodb.com/docs/manual/reference/operator/aggregation/last/#mongodb-group-grp.-last)
     """
 
     expression : Any
 
 
 
     @property
-    def statement(self) -> dict:
+    def expression(self) -> dict:
 
-        return self.resolve({
+        return self.express({
             "$last" : self.expression
         })
 
-def last(expression:Any)->Last:
+def last(operand:Any)->Last:
     """Returns a $last operator"""
 
-    return Last(expression=expression)
+    return Last(expression=operand)

src/monggregate/operators/accumulators/max.py

@@ -85,7 +85,7 @@
 
     Attributes
     ---------------------
-        - expression, Expression : Any valid expression
+        - operand, Any:Any valid expression
 
     Online MongoDB documentation
     ----------------------------
@@ -109,18 +109,18 @@
     [Source](https://www.mongodb.com/docs/manual/reference/operator/aggregation/max/#mongodb-group-grp.-max)
     """
 
     expression : Any
 
 
 
     @property
-    def statement(self) -> dict:
+    def expression(self) -> dict:
 
-        return self.resolve({
+        return self.express({
             "$max" : self.expression
         })
 
-def max(expression:Any)->Max:
+def max(operand:Any)->Max:
     """Returns a $last operator"""
 
-    return Max(expression=expression)
+    return Max(expression=operand)

src/monggregate/operators/accumulators/min.py

@@ -85,7 +85,7 @@
 
     Attributes
     ----------------------
-        - expression, Expression : Any valid expression
+        - operand, Any:Any valid expression
 
 
     Online MongoDB documentation
@@ -109,18 +109,18 @@
     [Source](https://www.mongodb.com/docs/manual/reference/operator/aggregation/min/#mongodb-group-grp.-min)
     """
 
     expression : Any
 
 
 
     @property
-    def statement(self) -> dict:
+    def expression(self) -> dict:
 
-        return self.resolve({
+        return self.express({
             "$min" : self.expression
         })
 
-def min(expression:Any)->Min:
+def min(operand:Any)->Min:
     """Returns a $min operator"""
 
-    return Min(expression=expression)
+    return Min(expression=operand)

src/monggregate/operators/accumulators/push.py

@@ -37,7 +37,7 @@
 
     Attributes
     -------------------
-        - expression, Expression : Any valid expression
+        - operand, Any:Any valid expression
 
     Online MongoDB documentation
     ----------------------------
@@ -52,18 +52,18 @@
     [Source](https://www.mongodb.com/docs/manual/reference/operator/aggregation/push/#mongodb-group-grp.-push)
     """
 
     expression : Any
 
 
 
     @property
-    def statement(self) -> dict:
+    def expression(self) -> dict:
 
-        return self.resolve({
+        return self.express({
             "$push" : self.expression
         })
 
-def push(expression:Any)->Push:
+def push(operand:Any)->Push:
     """Returns a $push operator"""
 
-    return Push(expression=expression)
+    return Push(expression=operand)

src/monggregate/operators/accumulators/sum.py

@@ -95,7 +95,7 @@
     Attributes
     -----------------------
         - operands, list[Expression] : Any valid list of expressions
-        - operand, Expression : Any valid expression
+        - operand, Any :Any valid expression
 
     Online MongoDB documentation
     ----------------------------
@@ -119,13 +119,13 @@
     [Source](https://www.mongodb.com/docs/manual/reference/operator/aggregation/sum/#mongodb-group-grp.-sum)
     """
 
     expression : Any
 
 
     @property
-    def statement(self) -> dict:
+    def expression(self) -> dict:
 
-        return self.resolve({
+        return self.express({
             "$sum" : self.expression
         })
 

src/monggregate/operators/arithmetic/add.py

@@ -50,17 +50,17 @@ class Add(ArithmeticOperator):
     """
 
 
-    expressions : list[Any]
+    operands : list[Any]
 
     @property
-    def statement(self) -> dict:
-        return self.resolve({
-            "$add" : self.expressions
+    def expression(self) -> dict:
+        return self.express({
+            "$add" : self.operands
         })
 
 def add(*args:Any)->Add:
     """Returns a $add operator"""
 
     return Add(
-        expressions=list(args)
+        operands=list(args)
     )

src/monggregate/operators/arithmetic/divide.py

@@ -52,13 +52,13 @@
     [Source](https://docs.mongodb.com/manual/reference/operator/aggregation/divide/#mongodb-expression-exp.-divide)
     """
 
 
     numerator : Any
     denominator : Any
 
     @property
-    def statement(self) -> dict:
-        return self.resolve({
+    def expression(self) -> dict:
+        return self.express({
             "$divide" : [self.numerator, self.denominator]
         })
 

src/monggregate/operators/arithmetic/multiply.py

@@ -49,17 +49,17 @@ class Multiply(ArithmeticOperator):
     """
 
 
-    expressions : list[Any]
+    operands : list[Any]
 
     @property
-    def statement(self) -> dict:
-        return self.resolve({
-            "$multiply" : self.expressions
+    def expression(self) -> dict:
+        return self.express({
+            "$multiply" : self.operands
         })
 
 def multiply(*args:Any)->Multiply:
     """Returns a $multiply operator"""
 
     return Multiply(
-        expressions=list(args)
+        operands=list(args)
     )

src/monggregate/operators/arithmetic/pow.py

@@ -68,13 +68,13 @@
     [Source](https://docs.mongodb.com/manual/reference/operator/aggregation/pow/#mongodb-expression-exp.-pow)
     """
 
 
     number : Any
     exponent : Any
 
     @property
-    def statement(self) -> dict:
-        return self.resolve({
+    def expression(self) -> dict:
+        return self.express({
             "$pow" : [self.number, self.exponent]
         })
 

src/monggregate/operators/arithmetic/subtract.py

@@ -73,8 +73,8 @@ class Subtract(ArithmeticOperator):
     right: Any
 
     @property
-    def statement(self) -> dict:
-        return self.resolve({
+    def expression(self) -> dict:
+        return self.express({
             "$substract" : [self.left, self.right]
         })