🔧 Add Page.with_custom_options

Author: uriyyo

fastapi_pagination/bases.py

@@ -1,9 +1,22 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
+from collections import ChainMap
 from dataclasses import dataclass
-from typing import ClassVar, Generic, Sequence, Type, TypeVar
+from functools import wraps
+from typing import (
+    Any,
+    ClassVar,
+    Dict,
+    Generic,
+    Mapping,
+    Sequence,
+    Type,
+    TypeVar,
+    cast,
+)
 
+from pydantic import BaseModel, create_model
 from pydantic.generics import GenericModel
 from pydantic.types import conint
 
@@ -23,6 +36,19 @@ def to_raw_params(self) -> RawParams:
         pass  # pragma: no cover
 
 
+def _create_params(cls: Type[AbstractParams], fields: Dict[str, Any]) -> Mapping[str, Any]:
+    if not issubclass(cls, BaseModel):
+        raise ValueError(f"{cls.__name__} must be subclass of BaseModel")
+
+    incorrect = sorted(fields.keys() - cls.__fields__.keys())
+    if incorrect:
+        ending = "s" if len(incorrect) > 1 else ""
+        raise ValueError(f"Unknown field{ending} {', '.join(incorrect)}")
+
+    anns = ChainMap(*(obj.__dict__.get("__annotations__", {}) for obj in cls.mro()))
+    return {name: (anns[name], val) for name, val in fields.items()}
+
+
 class AbstractPage(GenericModel, Generic[T], ABC):
     __params_type__: ClassVar[Type[AbstractParams]]
 
@@ -31,6 +57,22 @@ class AbstractPage(GenericModel, Generic[T], ABC):
     def create(cls: Type[C], items: Sequence[T], total: int, params: AbstractParams) -> C:
         pass  # pragma: no cover
 
+    @classmethod
+    def with_custom_options(cls: C, **kwargs: Any) -> C:
+        params_cls = cast(Type[AbstractPage], cls).__params_type__
+
+        custom_params: Any = create_model(
+            params_cls.__name__,
+            __base__=params_cls,
+            **_create_params(params_cls, kwargs),
+        )
+
+        @wraps(cls, updated=())  # type: ignore
+        class CustomPage(cls[T], Generic[T]):  # type: ignore
+            __params_type__: ClassVar[Type[AbstractParams]] = custom_params
+
+        return cast(C, CustomPage)
+
     class Config:
         arbitrary_types_allowed = True
 

tests/test_bases.py

@@ -0,0 +1,39 @@
+from typing import Generic, TypeVar
+
+from pytest import raises
+
+from fastapi_pagination import Page
+from fastapi_pagination.bases import AbstractParams, RawParams
+
+T = TypeVar("T")
+
+
+def test_custom_page_invalid_params_cls():
+    class CustomParams(AbstractParams):
+        def to_raw_params(self) -> RawParams:
+            return RawParams(0, 0)
+
+    class CustomPage(Page[T], Generic[T]):
+        __params_type__ = CustomParams
+
+    with raises(ValueError, match="^CustomParams must be subclass of BaseModel$"):
+        CustomPage.with_custom_options(size=10)
+
+
+def test_custom_page_invalid_values():
+    with raises(ValueError, match="^Unknown field smth_wrong$"):
+        Page.with_custom_options(smth_wrong=100)
+
+    with raises(ValueError, match="^Unknown fields a, b, c"):
+        Page.with_custom_options(a=1, b=2, c=3)
+
+
+def test_custom_page():
+    page_cls = Page.with_custom_options()
+    assert page_cls.__params_type__().dict() == {"size": 50, "page": 0}
+
+    page_cls = Page.with_custom_options(size=100)
+    assert page_cls.__params_type__().dict() == {"size": 100, "page": 0}
+
+    page_cls = Page.with_custom_options(size=100, page=100)
+    assert page_cls.__params_type__().dict() == {"size": 100, "page": 100}