Merge pull request #42 from VianneyMI/41-core-changes-to-package

41 core changes to package

monggregate/__init__.py

@@ -3,7 +3,7 @@
 from monggregate.pipeline import Pipeline
 from monggregate.expressions.expressions import Expression
 
-__version__ = "0.11.0"
+__version__ = "0.12.0"
 __author__ = "Vianney Mixtur"
 __contact__ = "prenom.nom@outlook.fr"
 __copyright__ = "Copyright © 2022 Vianney Mixtur"

monggregate/base.py

@@ -7,35 +7,17 @@
 
 # 3rd Party imports
 # ---------------------------
-from pydantic import BaseModel as PydanticBaseModel, BaseConfig, validator
+from pydantic import BaseModel as PydanticBaseModel, BaseConfig
+from humps import camelize
 
 class BaseModel(PydanticBaseModel, ABC):
     """Mongreggate base class"""
 
-    @validator("*", pre=True)
     @classmethod
-    def resolve(cls, expression:Any)->dict|list[dict]:
+    def resolve(cls, obj:Any)->dict|list[dict]:
         """Resolves an expression encapsulated in an object from a class inheriting from BaseModel"""
 
-        def isbasemodel(instance:Any)->bool:
-            """Returns true if instance is an instance of BaseModel"""
-
-            return isinstance(instance, BaseModel)
-
-        if isbasemodel(expression):
-            output:dict|list = expression.statement
-        elif isinstance(expression, list) and any(map(isbasemodel, expression)):
-            output = []
-            for element in expression:
-                if isinstance(element, BaseModel):
-                    output.append(element.statement)
-                else:
-                    output.append(element)
-        #elif isinstance(expression, dict): # Does this case really exist ?
-        else:
-            output = expression
-
-        return output
+        return resolve(obj)
 
     @property
     @abstractmethod
@@ -45,7 +27,6 @@ def statement(self)->dict:
         # this is a lazy attribute
         # what is currently in generate statement should go in here
 
-
     def __call__(self)->dict:
         """Makes an instance of any class inheriting from this class callable"""
 
@@ -56,3 +37,34 @@ class Config(BaseConfig):
 
         allow_population_by_field_name = True
         underscore_attrs_are_private = True
+        alias_generator = camelize
+
+
+def isbasemodel(instance:Any)->bool:
+    """Returns true if instance is an instance of BaseModel"""
+
+    return isinstance(instance, BaseModel)
+
+def resolve(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
+        elif isinstance(obj, list) and any(map(isbasemodel, obj)):
+            output = []
+            for element in obj:
+                if isinstance(element, BaseModel):
+                    output.append(element.statement)
+                else:
+                    output.append(element)
+        elif isinstance(obj, dict):
+            output = {}
+            for key, value in obj.items():
+                if isinstance(value, BaseModel):
+                    output[key] = value.statement
+                else:
+                    output[key] = resolve(value)
+        else:
+            output = obj
+
+        return output

monggregate/operators/accumulators/avg.py

@@ -89,9 +89,10 @@ class Average(Accumulator):
     @property
     def statement(self) -> dict:
 
-        return {
+        return self.resolve({
             "$avg" : self.expression
-        }
+        })
+
 Avg = Average
 
 def average(expression:Any)->dict:

monggregate/operators/accumulators/count.py

@@ -58,9 +58,9 @@ class Count(Accumulator):
     @property
     def statement(self) -> dict:
 
-        return {
+        return self.resolve({
             "$count" : {}
-        }
+        })
 
 def count()->dict:
     """Creates a $count statement"""

monggregate/operators/accumulators/first.py

@@ -77,9 +77,9 @@ class First(Accumulator):
     @property
     def statement(self) -> dict:
 
-        return {
+        return self.resolve({
             "$first" : self.expression
-        }
+        })
 
 def first(expression:Any)->dict:
     """Creates a push statement"""

monggregate/operators/accumulators/last.py

@@ -71,9 +71,9 @@ class Last(Accumulator):
     @property
     def statement(self) -> dict:
 
-        return {
+        return self.resolve({
             "$last" : self.expression
-        }
+        })
 
 def last(expression:Any)->dict:
     """Creates a push statement"""

monggregate/operators/accumulators/max.py

@@ -95,9 +95,9 @@ class Max(Accumulator):
     @property
     def statement(self) -> dict:
 
-        return {
+        return self.resolve({
             "$max" : self.expression
-        }
+        })
 
 def max(expression:Any)->dict: # pylint: disable=redefined-builtin
     """Creates a push statement"""

monggregate/operators/accumulators/min.py

@@ -95,9 +95,9 @@ class Min(Accumulator):
     @property
     def statement(self) -> dict:
 
-        return {
+        return self.resolve({
             "$min" : self.expression
-        }
+        })
 
 def min(expression:Any)->dict:
     """Creates a $min statement"""

monggregate/operators/accumulators/push.py

@@ -48,9 +48,9 @@ class Push(Accumulator):
     @property
     def statement(self) -> dict:
 
-        return {
+        return self.resolve({
             "$push" : self.expression
-        }
+        })
 
 def push(expression:Any)->dict:
     """Creates a push statement"""

monggregate/operators/accumulators/sum.py

@@ -104,9 +104,9 @@ class Sum(Accumulator):
     @property
     def statement(self) -> dict:
 
-        return {
+        return self.resolve({
             "$sum" : self.expression
-        }
+        })
 
 def sum(*args:Content)->dict: # pylint: disable=redefined-builtin
     """Creates a $sum statement"""

monggregate/operators/array/array_to_object.py

@@ -68,9 +68,9 @@ class ArrayToObject(ArrayOperator):
 
     @property
     def statement(self) -> dict:
-        return {
+        return self.resolve({
             "$arrayToObject" : self.expression
-        }
+        })
 
 def array_to_object(expression:Any)->dict:
     """Returns an $arrayToObject statement"""

monggregate/operators/array/filter.py

@@ -75,14 +75,14 @@ class Filter(ArrayOperator):
 
     @property
     def statement(self) -> dict:
-        return {
+        return self.resolve({
             "$filter":{
                "input" : self.expression,
                "cond" : self.query,
                "as" : self.let,
                "limit" : self.limit
             }
-        }
+        })
 
 def filter(expression:Any, let:str, query:Any, limit:int|None=None)->dict: # pylint: disable=redefined-builtin
     """Returns a $filter statement"""

monggregate/operators/array/first.py

@@ -112,9 +112,9 @@ class First(ArrayOnlyOperator):
 
     @property
     def statement(self) -> dict:
-        return {
+        return self.resolve({
             "$first":self.expression
-        }
+        })
 
 def first(array:Any)->dict:
     """Returns a $first statement"""

monggregate/operators/array/in_.py

@@ -50,9 +50,9 @@ class In(ArrayOperator):
 
     @property
     def statement(self) -> dict:
-        return {
+        return self.resolve({
             "$in":[self.left, self.right]
-        }
+        })
 
 def in_(left:Any, right:Any)->dict:
     """Returns a $maxN statement"""

monggregate/operators/array/is_array.py

@@ -40,9 +40,9 @@ class IsArray(ArrayOnlyOperator):
 
     @property
     def statement(self) -> dict:
-        return {
+        return self.resolve({
             "$isArray":self.expression
-        }
+        })
 
 def is_array(array:Any)->dict:
     """Returns a $isArray statement"""

monggregate/operators/array/last.py

@@ -116,9 +116,9 @@ class Last(ArrayOnlyOperator):
 
     @property
     def statement(self) -> dict:
-        return {
+        return self.resolve({
             "$last":self.expression
-        }
+        })
 
 def last(array:Any)->dict:
     """Returns a $last statement"""

monggregate/operators/array/max_n.py

@@ -65,12 +65,12 @@ class MaxN(ArrayOperator):
 
     @property
     def statement(self) -> dict:
-        return {
+        return self.resolve({
             "$maxN" : {
                 "n" : self.limit,
                 "input" : self.expression
             }
-        }
+        })
 
 def max_n(expression:Any, limit:Any=1)->dict:
     """Returns a $maxN statement"""

monggregate/operators/array/min_n.py

@@ -65,12 +65,12 @@ class MinN(ArrayOperator):
 
     @property
     def statement(self) -> dict:
-        return {
+        return self.resolve({
             "$minN" : {
                 "n" : self.limit,
                 "input" : self.expression
             }
-        }
+        })
 
 def min_n(expression:Any, limit:Any=1)->dict:
     """Returns a $minN statement"""

monggregate/operators/array/size.py

@@ -42,9 +42,9 @@ class Size(ArrayOnlyOperator):
 
     @property
     def statement(self) -> dict:
-        return {
+        return self.resolve({
             "$size":self.expression
-        }
+        })
 
 def size(array:Any)->dict:
     """Returns a $size statement"""

monggregate/operators/array/sort_array.py

@@ -101,12 +101,12 @@ class SortArray(ArrayOperator):
 
     @property
     def statement(self) -> dict:
-        return {
+        return self.resolve({
             "$sortArray":{
                 "input" : self.expression,
                 "sortBy" : self.by
             }
-        }
+        })
 
 def sort_array(expression:Any, sort_by:dict[str, Literal[1, -1]])->dict:
     """Returns a $first statement"""

monggregate/operators/boolean/and_.py

@@ -68,13 +68,14 @@ class And(BooleanOperator):
 
     @property
     def statement(self) -> dict:
-        return {
+        return self.resolve({
             "$and" : self.expressions
-        }
+        })
 
 def and_(*args:Any)->dict:
     """Returns an $and statement"""
 
     return And(
         expressions=list(args)
     ).statement
+

monggregate/operators/boolean/not_.py

@@ -43,9 +43,9 @@ class Not(BooleanOperator):
 
     @property
     def statement(self) -> dict:
-        return {
+        return self.resolve({
             "$not" : [self.expression]
-        }
+        })
 
 def not_(expression:Any)->dict:
     """Returns an $not statement"""

monggregate/operators/boolean/or_.py

@@ -44,9 +44,9 @@ class Or(BooleanOperator):
 
     @property
     def statement(self) -> dict:
-        return {
+        return self.resolve({
             "$or" : self.expressions
-        }
+        })
 
 def or_(*args:Any)->dict:
     """Returns an $or statement"""

monggregate/operators/comparison/cmp.py

@@ -44,9 +44,9 @@ class Compare(Comparator):
     @property
     def statement(self) -> dict:
 
-        return {
+        return self.resolve({
             "$cmp":[self.left, self.right]
-        }
+        })
 
 Cmp = Compare
 

monggregate/operators/comparison/eq.py

@@ -43,9 +43,9 @@ class Equal(Comparator):
     @property
     def statement(self) -> dict:
 
-        return {
+        return self.resolve({
             "$eq":[self.left, self.right]
-        }
+        })
 
 Eq = Equal
 

monggregate/operators/comparison/gt.py

@@ -41,9 +41,9 @@ class GreatherThan(Comparator):
     @property
     def statement(self) -> dict:
 
-        return {
+        return self.resolve({
             "$gt":[self.left, self.right]
-        }
+        })
 
 Gt = GreatherThan