aggify 0.2.9__tar.gz → 0.3.0__tar.gz

{aggify-0.2.9 → aggify-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aggify
-Version: 0.2.9
+Version: 0.3.0
 Summary: A MongoDB aggregation generator for Mongoengine
 Home-page: https://github.com/Aggify/aggify
 Author: SeYeD.Dev
@@ -181,4 +181,3 @@ In the sample usage above, you can see how Aggify simplifies the construction of
 allowing you to chain filters, lookups, and other operations to build complex queries.
 For more details and examples, please refer to the documentation and codebase.
 
-

{aggify-0.2.9 → aggify-0.3.0}/README.md

@@ -161,4 +161,3 @@ Mongoengine equivalent query:
 In the sample usage above, you can see how Aggify simplifies the construction of MongoDB aggregation pipelines by
 allowing you to chain filters, lookups, and other operations to build complex queries.
 For more details and examples, please refer to the documentation and codebase.
-

{aggify-0.2.9 → aggify-0.3.0}/aggify/aggify.py

@@ -1,7 +1,7 @@
 import functools
-from typing import Any, Dict, Type, Union, List, Callable, TypeVar
+from typing import Any, Dict, Type, Union, List, TypeVar, Callable
 
-from mongoengine import Document, EmbeddedDocument, fields
+from mongoengine import Document, EmbeddedDocument, fields as mongoengine_fields
 from mongoengine.base import TopLevelDocumentMetaclass
 
 from aggify.compiler import F, Match, Q, Operators, Cond  # noqa keep
@@ -85,25 +85,23 @@ class Aggify:
         """
 
         # Extract fields to keep and check if _id should be deleted
-        to_keep_values = ["id"]
-        delete_id = kwargs.get("id") == 0
+        to_keep_values = {"id"}
+        delete_id = kwargs.get("id") is not None
         projection = {}
 
         # Add missing fields to the base model
         for key, value in kwargs.items():
             if value == 1:
-                to_keep_values.append(key)
+                to_keep_values.add(key)
             elif key not in self.base_model._fields and isinstance(  # noqa
                 kwargs[key], (str, dict)
-            ):  # noqa
-                to_keep_values.append(key)
-                self.base_model._fields[key] = fields.IntField()  # noqa
+            ):
+                to_keep_values.add(key)
+                self.base_model._fields[key] = mongoengine_fields.IntField()  # noqa
             projection[get_db_field(self.base_model, key)] = value  # noqa
 
         # Remove fields from the base model, except the ones in to_keep_values and possibly _id
-        keys_for_deletion = set(self.base_model._fields.keys()) - set(  # noqa
-            to_keep_values
-        )  # noqa
+        keys_for_deletion = self.base_model._fields.keys() - to_keep_values  # noqa
         if delete_id:
             keys_for_deletion.add("id")
         for key in keys_for_deletion:
@@ -144,19 +142,18 @@ class Aggify:
         return self
 
     @last_out_stage_check
-    def add_fields(self, **_fields) -> "Aggify":  # noqa
-        """
-        Generates a MongoDB addFields pipeline stage.
+    def add_fields(self, **fields) -> "Aggify":  # noqa
+        """Generates a MongoDB addFields pipeline stage.
 
         Args:
-            _fields: A dictionary of field expressions and values.
+            fields: A dictionary of field expressions and values.
 
         Returns:
             A MongoDB add_fields pipeline stage.
         """
         add_fields_stage = {"$addFields": {}}
 
-        for field, expression in _fields.items():
+        for field, expression in fields.items():
             field = field.replace("__", ".")
             if isinstance(expression, str):
                 add_fields_stage["$addFields"][field] = {"$literal": expression}
@@ -169,7 +166,9 @@ class Aggify:
             else:
                 raise AggifyValueError([str, F, list], type(expression))
             # TODO: Should be checked if new field is embedded, create embedded field.
-            self.base_model._fields[field.replace("$", "")] = fields.IntField()  # noqa
+            self.base_model._fields[  # noqa
+                field.replace("$", "")
+            ] = mongoengine_fields.IntField()
 
         self.pipelines.append(add_fields_stage)
         return self
@@ -238,12 +237,8 @@ class Aggify:
         """
         Builds the pipelines list based on the query parameters.
         """
-        skip_list = []
 
         for key, value in query.items():
-            if key in skip_list:
-                continue
-
             # Split the key to access the field information.
             split_query = key.split("__")
 
@@ -257,8 +252,8 @@ class Aggify:
                 or "document_type_obj"
                 not in join_field.__dict__  # Check whether this field is a join field or not.
                 or issubclass(
-                    join_field.document_type, EmbeddedDocument  # noqa
-                )  # Check whether this field is embedded field or not
+                join_field.document_type, EmbeddedDocument  # noqa
+            )  # Check whether this field is embedded field or not
                 or len(split_query) == 1
                 or (len(split_query) == 2 and split_query[1] in Operators.ALL_OPERATORS)
             ):
@@ -276,7 +271,6 @@ class Aggify:
                 matches = []
                 for k, v in query.items():
                     if k.split("__")[0] == split_query[0]:
-                        skip_list.append(k)
                         _key = k.replace("__", ".", 1)
                         match = self.__match({_key: v}).get("$match")
                         if match != {}:
@@ -357,15 +351,6 @@ class Aggify:
         self.pipelines.append(unwind_stage)
         return self
 
-    def aggregate(self):
-        """
-        Returns the aggregated results.
-
-        Returns:
-            The aggregated results.
-        """
-        return self.base_model.objects.aggregate(*self.pipelines)  # type: ignore
-
     def annotate(
         self, annotate_name: str, accumulator: str, f: Union[Union[str, Dict], F, int]
     ) -> "Aggify":
@@ -389,31 +374,49 @@ class Aggify:
         """
 
         # Some of the accumulator fields might be false and should be checked.
+        # noinspection SpellCheckingInspection
         aggregation_mapping: Dict[str, Type] = {
-            "sum": (fields.FloatField(), "$sum"),
-            "avg": (fields.FloatField(), "$avg"),
-            "stdDevPop": (fields.FloatField(), "$stdDevPop"),
-            "stdDevSamp": (fields.FloatField(), "$stdDevSamp"),  # noqa
-            "push": (fields.ListField(), "$push"),
-            "addToSet": (fields.ListField(), "$addToSet"),
-            "count": (fields.IntField(), "$count"),
-            "first": (fields.EmbeddedDocumentField(fields.EmbeddedDocument), "$first"),
-            "last": (fields.EmbeddedDocumentField(fields.EmbeddedDocument), "$last"),
-            "max": (fields.DynamicField(), "$max"),
-            "accumulator": (fields.DynamicField(), "$accumulator"),
-            "min": (fields.DynamicField(), "$min"),
-            "median": (fields.DynamicField(), "$median"),
-            "mergeObjects": (fields.DictField(), "$mergeObjects"),
-            "top": (fields.EmbeddedDocumentField(fields.EmbeddedDocument), "$top"),
+            "sum": (mongoengine_fields.FloatField(), "$sum"),
+            "avg": (mongoengine_fields.FloatField(), "$avg"),
+            "stdDevPop": (mongoengine_fields.FloatField(), "$stdDevPop"),
+            "stdDevSamp": (mongoengine_fields.FloatField(), "$stdDevSamp"),
+            "push": (mongoengine_fields.ListField(), "$push"),
+            "addToSet": (mongoengine_fields.ListField(), "$addToSet"),
+            "count": (mongoengine_fields.IntField(), "$count"),
+            "first": (
+                mongoengine_fields.EmbeddedDocumentField(
+                    mongoengine_fields.EmbeddedDocument
+                ),
+                "$first",
+            ),
+            "last": (
+                mongoengine_fields.EmbeddedDocumentField(
+                    mongoengine_fields.EmbeddedDocument
+                ),
+                "$last",
+            ),
+            "max": (mongoengine_fields.DynamicField(), "$max"),
+            "accumulator": (mongoengine_fields.DynamicField(), "$accumulator"),
+            "min": (mongoengine_fields.DynamicField(), "$min"),
+            "median": (mongoengine_fields.DynamicField(), "$median"),
+            "mergeObjects": (mongoengine_fields.DictField(), "$mergeObjects"),
+            "top": (
+                mongoengine_fields.EmbeddedDocumentField(
+                    mongoengine_fields.EmbeddedDocument
+                ),
+                "$top",
+            ),
             "bottom": (
-                fields.EmbeddedDocumentField(fields.EmbeddedDocument),
+                mongoengine_fields.EmbeddedDocumentField(
+                    mongoengine_fields.EmbeddedDocument
+                ),
                 "$bottom",
             ),
-            "topN": (fields.ListField(), "$topN"),
-            "bottomN": (fields.ListField(), "$bottomN"),
-            "firstN": (fields.ListField(), "$firstN"),
-            "lastN": (fields.ListField(), "$lastN"),
-            "maxN": (fields.ListField(), "$maxN"),
+            "topN": (mongoengine_fields.ListField(), "$topN"),
+            "bottomN": (mongoengine_fields.ListField(), "$bottomN"),
+            "firstN": (mongoengine_fields.ListField(), "$firstN"),
+            "lastN": (mongoengine_fields.ListField(), "$lastN"),
+            "maxN": (mongoengine_fields.ListField(), "$maxN"),
         }
 
         try:
@@ -552,19 +555,23 @@ class Aggify:
         foreign_field: Union[str, None] = None,
     ) -> "Aggify":
         """
-        Generates a MongoDB lookup pipeline stage.
+            Generates a MongoDB lookup pipeline stage.
 
-        Args:
-            from_collection (Document): The document representing the collection to perform the lookup on.
-            as_name (str): The name of the new field to create.
-            query (list[Q] | Union[Q, None], optional): List of desired queries with Q function or a single query.
-            let (Union[List[str], None], optional): The local field(s) to join on. If provided,
-            localField and foreignField are not used.
-            local_field (Union[str, None], optional): The local field to join on when let not provided.
-            foreign_field (Union[str, None], optional): The foreign field to join on when let not provided.
+            Args:
+                from_collection (Document): The document representing the collection to perform the lookup on.
+                as_name (str): The name of the new field to create.
+                query (list[Q] | Union[Q, None], optional): List of desired queries with Q function or a single query.
+                let (Union[List[str], None], optional): The local field(s) to join on. If provided,
+                localField and foreignField are not used.
+                local_field (Union[str, None], optional): The local field to join on when `let` is not provided.
+                foreign_field (Union[str, None], optional): The foreign field to join on when `let` is not provided.
+                let (Union[List[str], None], optional): The local field(s) to join on. If provided,
+                localField and foreignField are not used.
+                local_field (Union[str, None], optional): The local field to join on when let not provided.
+                foreign_field (Union[str, None], optional): The foreign field to join on when let not provided.
 
-        Returns:
-            Aggify: An instance of the Aggify class representing a MongoDB lookup pipeline stage.
+            Returns:
+                Aggify: An instance of the Aggify class representing a MongoDB lookup pipeline stage.
         """
 
         lookup_stages = []
@@ -576,8 +583,6 @@ class Aggify:
                 expected_list=[["local_field", "foreign_field"], "let"]
             )
         elif not let:
-            if not (local_field and foreign_field):
-                raise InvalidArgument(expected_list=["local_field", "foreign_field"])
             lookup_stage = {
                 "$lookup": {
                     "from": from_collection_name,
@@ -632,7 +637,7 @@ class Aggify:
         return self
 
     @staticmethod
-    def get_model_field(model: CollectionType, field: str) -> fields:
+    def get_model_field(model: Type[Document], field: str) -> mongoengine_fields:
         """
         Get the field definition of a specified field in a MongoDB model.
 

{aggify-0.2.9 → aggify-0.3.0}/aggify/compiler.py

@@ -82,11 +82,6 @@ class Operators:
                 }
             else:
                 self.match_query[field] = {Operators.ALL_OPERATORS[operator]: value}
-        else:
-            # Default behavior
-            self.match_query[field] = {
-                Operators.ALL_OPERATORS.get(operator, operator): value
-            }
 
         return self.match_query
 
@@ -107,7 +102,7 @@ class Q:
         yield "$match", self.conditions
 
     def __or__(self, other):
-        if self.conditions.get("$or", None):
+        if self.conditions.get("$or"):
             self.conditions["$or"].append(dict(other)["$match"])
             combined_conditions = self.conditions
 
@@ -116,7 +111,7 @@ class Q:
         return Q(**combined_conditions)
 
     def __and__(self, other):
-        if self.conditions.get("$and", None):
+        if self.conditions.get("$and"):
             self.conditions["$and"].append(dict(other)["$match"])
             combined_conditions = self.conditions
         else:
@@ -138,7 +133,7 @@ class F:
     def to_dict(self):
         return self.field
 
-    def __add__(self, other):  # TODO: add type for 'other'
+    def __add__(self, other):
         if isinstance(other, F):
             other = other.field
 
@@ -248,7 +243,12 @@ class Match:
 
     @staticmethod
     def validate_operator(key: str):
-        operator = key.rsplit("__", 1)[1]
+        _op = key.rsplit("__", 1)
+        try:
+            operator = _op[1]
+        except IndexError:
+            raise InvalidOperator(str(_op)) from None
+
         if operator not in Operators.COMPARISON_OPERATORS:
             raise InvalidOperator(operator)
 
@@ -275,15 +275,15 @@ class Match:
     def compile(self, pipelines: list) -> Dict[str, Dict[str, list]]:
         match_query = {}
         for key, value in self.matches.items():
+            if isinstance(value, F):
+                if F.is_suitable_for_match(key) is False:
+                    raise InvalidOperator(key)
+
             if "__" not in key:
                 key = get_db_field(self.base_model, key)
                 match_query[key] = value
                 continue
 
-            if isinstance(value, F):
-                if F.is_suitable_for_match(key) is False:
-                    raise InvalidOperator(key)
-
             field, operator, *_ = key.split("__")
             if (
                 self.is_base_model_field(field)

{aggify-0.2.9 → aggify-0.3.0}/aggify/types.py

@@ -1,7 +1,6 @@
 from typing import Union, Dict, TypeVar, Callable
-from mongoengine import Document
 from bson import ObjectId
+from mongoengine import Document
 
 QueryParams = Union[int, None, str, bool, float, Dict, ObjectId]
-
 CollectionType = TypeVar("CollectionType", bound=Callable[..., Document])

{aggify-0.2.9 → aggify-0.3.0}/aggify/utilty.py

@@ -1,20 +1,8 @@
 from typing import Any, Union, List, Dict
 
 from mongoengine import Document
-
-from aggify.exceptions import MongoIndexError, InvalidField, AlreadyExistsField
 from aggify.types import CollectionType
-
-
-def int_to_slice(final_index: int) -> slice:
-    """
-    Converts an integer to a slice, assuming that the start index is 0.
-
-    Examples:
-        >>> int_to_slice(3)
-        slice(0, 2)
-    """
-    return slice(0, final_index)
+from aggify.exceptions import MongoIndexError, InvalidField, AlreadyExistsField
 
 
 def to_mongo_positive_index(index: Union[int, slice]) -> slice:

{aggify-0.2.9 → aggify-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "aggify"
-version = "0.2.9"
+version = "0.3.0"
 authors = ["SeYeD.Dev <me@seyed.dev>"]
 repository = "https://github.com/Aggify/aggify"
 documentation = "https://github.com/Aggify/aggify/docs"