add pagination method, add tests, update api docs, bump version, add release info

ormar/__init__.py

@@ -65,7 +65,7 @@ class UndefinedType:  # pragma no cover
 
 Undefined = UndefinedType()
 
-__version__ = "0.8.0"
+__version__ = "0.8.1"
 __all__ = [
     "Integer",
     "BigInteger",

ormar/queryset/queryset.py

@@ -592,6 +592,37 @@ class QuerySet:
         )
         return await self.database.execute(expr)
 
+    def paginate(self, page: int, page_size: int = 20) -> "QuerySet":
+        """
+        You can paginate the result which is a combination of offset and limit clauses.
+        Limit is set to page size and offset is set to (page-1) * page_size.
+
+        :param page_size: numbers of items per page
+        :type page_size: int
+        :param page: page number
+        :type page: int
+        :return: QuerySet
+        :rtype: QuerySet
+        """
+        if page < 1 or page_size < 1:
+            raise QueryDefinitionError("Page size and page have to be greater than 0.")
+
+        limit_count = page_size
+        query_offset = (page - 1) * page_size
+        return self.__class__(
+            model_cls=self.model,
+            filter_clauses=self.filter_clauses,
+            exclude_clauses=self.exclude_clauses,
+            select_related=self._select_related,
+            limit_count=limit_count,
+            offset=query_offset,
+            columns=self._columns,
+            exclude_columns=self._exclude_columns,
+            order_bys=self.order_bys,
+            prefetch_related=self._prefetch_related,
+            limit_raw_sql=self.limit_sql_raw,
+        )
+
     def limit(self, limit_count: int, limit_raw_sql: bool = None) -> "QuerySet":
         """
         You can limit the results to desired number of parent models.

ormar/relations/querysetproxy.py

@@ -415,6 +415,23 @@ class QuerysetProxy(ormar.QuerySetProtocol):
         queryset = self.queryset.prefetch_related(related)
         return self.__class__(relation=self.relation, type_=self.type_, qryset=queryset)
 
+    def paginate(self, page: int, page_size: int = 20) -> "QuerysetProxy":
+        """
+        You can paginate the result which is a combination of offset and limit clauses.
+        Limit is set to page size and offset is set to (page-1) * page_size.
+
+        Actual call delegated to QuerySet.
+
+        :param page_size: numbers of items per page
+        :type page_size: int
+        :param page: page number
+        :type page: int
+        :return: QuerySet
+        :rtype: QuerySet
+        """
+        queryset = self.queryset.paginate(page=page, page_size=page_size)
+        return self.__class__(relation=self.relation, type_=self.type_, qryset=queryset)
+
     def limit(self, limit_count: int) -> "QuerysetProxy":
         """
         You can limit the results to desired number of parent models.