fix: type hints

Author: sveneberth

src/viur/core/db/query.py

@@ -4,7 +4,6 @@
 import copy
 import functools
 import logging
-import operator
 import typing as t
 
 from .config import conf
@@ -15,12 +14,19 @@
     KEY_SPECIAL_PROPERTY,
     QueryDefinition,
     SortOrder,
+    TFilters,
+    TOrders,
 )
 from .utils import IsInTransaction
 
 if t.TYPE_CHECKING:
     from viur.core.skeleton import SkeletonInstance, SkelList
 
+TOrderHook = t.TypeVar("TOrderHook", bound=t.Callable[["Query", TOrders], TOrders])
+TFilterHook = t.TypeVar("TFilterHook", bound=t.Callable[
+    ["Query", str, DATASTORE_BASE_TYPES | list[DATASTORE_BASE_TYPES]], TFilters
+])
+
 
 def _entryMatchesQuery(entry: Entity, singleFilter: dict) -> bool:
     """
@@ -71,26 +77,19 @@ def __init__(self, kind: str, srcSkelClass: t.Union["SkeletonInstance", None] =
         :param srcSkelClass: If set, enables data-model depended queries (like relational queries) as well as the
             :meth:fetch method
         """
-        super(Query, self).__init__()
+        super().__init__()
         self.kind = kind
         self.srcSkel = srcSkelClass
         self.queries: t.Union[None, QueryDefinition, t.List[QueryDefinition]] = QueryDefinition(kind, {}, [])
-        cbSignature = t.Union[
-            None,
-            t.Callable[
-                [Query, str, t.Union[DATASTORE_BASE_TYPES, t.List[DATASTORE_BASE_TYPES]]],
-                t.Union[None, t.Tuple[str, t.Union[DATASTORE_BASE_TYPES, t.List[DATASTORE_BASE_TYPES]]]]
-            ]
-        ]
-        self._filterHook: cbSignature = None
-        self._orderHook: cbSignature = None
+        self._filterHook: TFilterHook | None = None
+        self._orderHook: TOrderHook | None = None
         # Sometimes, the default merge functionality from MultiQuery is not sufficient
         self._customMultiQueryMerge: t.Union[None, t.Callable[[Query, t.List[t.List[Entity]], int], t.List[Entity]]] \
             = None
         # Some (Multi-)Queries need a different amount of results per subQuery than actually returned
         self._calculateInternalMultiQueryLimit: t.Union[None, t.Callable[[Query, int], int]] = None
         # Allow carrying custom data along with the query.
-        # Currently only used by SpartialBone to record the guaranteed correctness
+        # Currently only used by SpatialBone to record the guaranteed correctness
         self.customQueryInfo = {}
         self.origKind = kind
         self._lastEntry = None
@@ -101,7 +100,7 @@ def __init__(self, kind: str, srcSkelClass: t.Union["SkeletonInstance", None] =
         #     if isinstance(accessLog, set):
         #         accessLog.add(kind)
 
-    def setFilterHook(self, hook: t.Callable) -> t.Optional[t.Callable]:
+    def setFilterHook(self, hook: TFilterHook) -> TFilterHook | None:
         """
         Installs *hook* as a callback function for new filters.
 
@@ -117,7 +116,7 @@ def setFilterHook(self, hook: t.Callable) -> t.Optional[t.Callable]:
         self._filterHook = hook
         return old
 
-    def setOrderHook(self, hook: t.Callable) -> t.Callable:
+    def setOrderHook(self, hook: TOrderHook) -> TOrderHook | None:
         """
         Installs *hook* as a callback function for new orderings.
 
@@ -278,7 +277,7 @@ def order(self, *orderings: t.Tuple[str, SortOrder]) -> t.Self:
 
         .. code-block:: python
 
-            query = Query( "Person" )
+            query = Query("Person")
             query.order(("bday" db.SortOrder.Ascending), ("age", db.SortOrder.Descending))
 
         sorts every Person in order of their birthday, starting with January 1.
@@ -307,7 +306,7 @@ def order(self, *orderings: t.Tuple[str, SortOrder]) -> t.Self:
 
 
         :param orderings: The properties to sort by, in sort order.
-            Each argument must be a (string, direction) 2-tuple.
+            Each argument must be a (name, direction) 2-tuple.
         :returns: Returns the query itself for chaining.
         """
         if self.queries is None:
@@ -326,8 +325,6 @@ def order(self, *orderings: t.Tuple[str, SortOrder]) -> t.Self:
 
             orders.append(order)
 
-        orderings = tuple(orders)
-
         if self._orderHook is not None:
             try:
                 orderings = self._orderHook(self, orderings)

src/viur/core/db/types.py

@@ -40,6 +40,8 @@ class SortOrder(enum.Enum):
     """Fetch A->Z, then flip the results (useful in pagination)"""
 
 
+
+
 class Key(Datastore_key):
     """
         The python representation of one datastore key. Unlike the original implementation, we don't store a
@@ -149,6 +151,10 @@ def __init__(
         assert not key or isinstance(key, Key), "Key must be a Key-Object (or None for an embedded entity)"
 
 
+TOrders :t.TypeAlias = list[tuple[str, SortOrder]]
+TFilters:t.TypeAlias = dict[str, DATASTORE_BASE_TYPES | list[DATASTORE_BASE_TYPES]]
+
+
 @dataclass
 class QueryDefinition:
     """
@@ -158,10 +164,10 @@ class QueryDefinition:
     kind: t.Optional[str]
     """The datastore kind to run the query on. Can be None for kindles queries."""
 
-    filters: dict[str, DATASTORE_BASE_TYPES | list[DATASTORE_BASE_TYPES]]
+    filters: TFilters
     """A dictionary of constrains to apply to the query."""
 
-    orders: t.Optional[list[tuple[str, SortOrder]]]
+    orders: t.Optional[TOrders]
     """The list of fields to sort the results by."""
 
     distinct: t.Optional[list[str]] = None