fix everything?

ormar/queryset/actions/order_action.py

@@ -20,7 +20,7 @@ class OrderAction(QueryAction):
     """
 
     def __init__(
-            self, order_str: str, model_cls: Type["Model"], alias: str = None
+        self, order_str: str, model_cls: Type["Model"], alias: str = None
     ) -> None:
         self.direction: str = ""
         super().__init__(query_str=order_str, model_cls=model_cls)
@@ -46,9 +46,16 @@ class OrderAction(QueryAction):
         prefix = f"{self.table_prefix}_" if self.table_prefix else ""
         return f"{prefix}{self.table}" f".{self.field_alias}"
 
-    def get_min_or_max(self):
+    def get_min_or_max(self) -> sqlalchemy.sql.expression.TextClause:
+        """
+        Used in limit sub queries where you need to use aggregated functions
+        in order to order by columns not included in group by.
+
+        :return: min or max function to order
+        :rtype: sqlalchemy.sql.elements.TextClause
+        """
         prefix = f"{self.table_prefix}_" if self.table_prefix else ""
-        if self.direction == '':
+        if self.direction == "":
             return text(f"min({prefix}{self.table}" f".{self.field_alias})")
         else:
             return text(f"max({prefix}{self.table}" f".{self.field_alias}) desc")

ormar/queryset/query.py

@@ -18,16 +18,16 @@ if TYPE_CHECKING:  # pragma no cover
 
 class Query:
     def __init__(  # noqa CFQ002
-            self,
-            model_cls: Type["Model"],
-            filter_clauses: List[FilterAction],
-            exclude_clauses: List[FilterAction],
-            select_related: List,
-            limit_count: Optional[int],
-            offset: Optional[int],
-            excludable: "ExcludableItems",
-            order_bys: Optional[List["OrderAction"]],
-            limit_raw_sql: bool,
+        self,
+        model_cls: Type["Model"],
+        filter_clauses: List[FilterAction],
+        exclude_clauses: List[FilterAction],
+        select_related: List,
+        limit_count: Optional[int],
+        offset: Optional[int],
+        excludable: "ExcludableItems",
+        order_bys: Optional[List["OrderAction"]],
+        limit_raw_sql: bool,
     ) -> None:
         self.query_offset = offset
         self.limit_count = limit_count
@@ -153,9 +153,10 @@ class Query:
         return expr
 
     def _build_pagination_condition(
-            self
+        self,
     ) -> Tuple[
-        sqlalchemy.sql.expression.TextClause, sqlalchemy.sql.expression.TextClause]:
+        sqlalchemy.sql.expression.TextClause, sqlalchemy.sql.expression.TextClause
+    ]:
         """
         In order to apply limit and offset on main table in join only
         (otherwise you can get only partially constructed main model
@@ -183,10 +184,9 @@ class Query:
         limit_qry = sqlalchemy.sql.select([qry_text])
         limit_qry = limit_qry.select_from(self.select_from)
         limit_qry = FilterQuery(filter_clauses=self.filter_clauses).apply(limit_qry)
-        limit_qry = FilterQuery(filter_clauses=self.exclude_clauses,
-                                exclude=True).apply(
-            limit_qry
-        )
+        limit_qry = FilterQuery(
+            filter_clauses=self.exclude_clauses, exclude=True
+        ).apply(limit_qry)
         limit_qry = limit_qry.group_by(qry_text)
         for order_by in maxes.values():
             limit_qry = limit_qry.order_by(order_by)
@@ -194,11 +194,12 @@ class Query:
         limit_qry = OffsetQuery(query_offset=self.query_offset).apply(limit_qry)
         limit_qry = limit_qry.alias("limit_query")
         on_clause = sqlalchemy.text(
-            f"limit_query.{pk_alias}={self.table.name}.{pk_alias}")
+            f"limit_query.{pk_alias}={self.table.name}.{pk_alias}"
+        )
         return limit_qry, on_clause
 
     def _apply_expression_modifiers(
-            self, expr: sqlalchemy.sql.select
+        self, expr: sqlalchemy.sql.select
     ) -> sqlalchemy.sql.select:
         """
         Receives the select query (might be join) and applies:

ormar/queryset/queryset.py

@@ -281,7 +281,7 @@ class QuerySet:
             limit_raw_sql=self.limit_sql_raw,
         )
         exp = qry.build_select_expression()
-        print("\n", exp.compile(compile_kwargs={"literal_binds": True}))
+        # print("\n", exp.compile(compile_kwargs={"literal_binds": True}))
         return exp
 
     def filter(  # noqa: A003