add 4 new relation signales, add 4 new aggr methods, wip to cleanup

ormar/relations/querysetproxy.py

@@ -12,6 +12,8 @@ from typing import (  # noqa: I100, I201
     cast,
 )
 
+from sqlalchemy.engine import ResultProxy
+
 import ormar
 from ormar.exceptions import ModelPersistenceError, QueryDefinitionError
 
@@ -116,6 +118,7 @@ class QuerysetProxy:
         :type child: Model
         """
         model_cls = self.relation.through
+        # TODO: Add support for pk with default not only autoincrement id
         owner_column = self.related_field.default_target_field_name()  # type: ignore
         child_column = self.related_field.default_source_field_name()  # type: ignore
         rel_kwargs = {owner_column: self._owner.pk, child_column: child.pk}
@@ -185,6 +188,52 @@ class QuerysetProxy:
         """
         return await self.queryset.count()
 
+    async def max(  # noqa: A003
+        self, columns: Union[str, List[str]]
+    ) -> Union[Any, ResultProxy]:
+        """
+        Returns max value of columns for rows matching the given criteria
+        (applied with `filter` and `exclude` if set before).
+
+        :return: max value of column(s)
+        :rtype: Any
+        """
+        return await self.queryset.max(columns=columns)
+
+    async def min(  # noqa: A003
+        self, columns: Union[str, List[str]]
+    ) -> Union[Any, ResultProxy]:
+        """
+        Returns min value of columns for rows matching the given criteria
+        (applied with `filter` and `exclude` if set before).
+
+        :return: min value of column(s)
+        :rtype: Any
+        """
+        return await self.queryset.min(columns=columns)
+
+    async def sum(  # noqa: A003
+        self, columns: Union[str, List[str]]
+    ) -> Union[Any, ResultProxy]:
+        """
+        Returns sum value of columns for rows matching the given criteria
+        (applied with `filter` and `exclude` if set before).
+
+        :return: sum value of columns
+        :rtype: int
+        """
+        return await self.queryset.sum(columns=columns)
+
+    async def avg(self, columns: Union[str, List[str]]) -> Union[Any, ResultProxy]:
+        """
+        Returns avg value of columns for rows matching the given criteria
+        (applied with `filter` and `exclude` if set before).
+
+        :return: avg value of columns
+        :rtype: Union[int, float, List]
+        """
+        return await self.queryset.avg(columns=columns)
+
     async def clear(self, keep_reversed: bool = True) -> int:
         """
         Removes all related models from given relation.

ormar/relations/relation_proxy.py

@@ -152,6 +152,12 @@ class RelationProxy(list):
                 f"Object {self._owner.get_name()} has no "
                 f"{item.get_name()} with given primary key!"
             )
+        await self._owner.signals.pre_relation_remove.send(
+            sender=self._owner.__class__,
+            instance=self._owner,
+            child=item,
+            relation_name=self.field_name,
+        )
         super().remove(item)
         relation_name = self.related_field_name
         relation = item._orm._get(relation_name)
@@ -169,6 +175,12 @@ class RelationProxy(list):
                 await item.update()
             else:
                 await item.delete()
+        await self._owner.signals.post_relation_remove.send(
+            sender=self._owner.__class__,
+            instance=self._owner,
+            child=item,
+            relation_name=self.field_name,
+        )
 
     async def add(self, item: "Model", **kwargs: Any) -> None:
         """
@@ -182,6 +194,13 @@ class RelationProxy(list):
         :type item: Model
         """
         relation_name = self.related_field_name
+        await self._owner.signals.pre_relation_add.send(
+            sender=self._owner.__class__,
+            instance=self._owner,
+            child=item,
+            relation_name=self.field_name,
+            passed_kwargs=kwargs,
+        )
         self._check_if_model_saved()
         if self.type_ == ormar.RelationType.MULTIPLE:
             await self.queryset_proxy.create_through_instance(item, **kwargs)
@@ -189,3 +208,10 @@ class RelationProxy(list):
         else:
             setattr(item, relation_name, self._owner)
             await item.update()
+        await self._owner.signals.post_relation_add.send(
+            sender=self._owner.__class__,
+            instance=self._owner,
+            child=item,
+            relation_name=self.field_name,
+            passed_kwargs=kwargs,
+        )