Added a more adaptive pagination response

Author: eadwinCode

.flake8

@@ -1,6 +1,6 @@
 [flake8]
 max-line-length = 88
-ignore = E203, E241, E501, W503
+ignore = E203, E241, E501, W503, F811
 exclude =
     .git,
     __pycache__

ninja_extra/generic.py

@@ -0,0 +1,32 @@
+from typing import Any, Dict, no_type_check
+
+
+class GenericModelMeta(type):
+    registry: Dict = {}
+
+    def __getitem__(self, wraps: Any) -> Any:
+        if (self, wraps) not in self.__class__.registry:
+            self.__class__.registry[self, wraps] = self().get_generic_type(wraps)
+        return self.__class__.registry[self, wraps]
+
+
+@no_type_check
+class GenericType(metaclass=GenericModelMeta):
+    """
+    Get a wrapper class that mimic python 3.8 generic support to python3.6, 3.7
+    Examples
+    --------
+    Create a Class to reference the generic model to be create:
+    >>> class ObjectA(GenericType):
+    >>>     def get_generic_type(self, wrap_type):
+    >>>         class ObjectAGeneric(self):
+    >>>             item: wrap_type
+    >>>         ObjectAGeneric.__name__ = (
+    >>>             f"{self.__class__.__name__}[{str(wrap_type.__name__).capitalize()}]"
+    >>>         )
+    >>>         return ObjectAGeneric
+
+    Usage:
+    >>> class Pass: ...
+    >>> object_generic_type  = ObjectA[Pass]
+    """

ninja_extra/operation.py

@@ -43,9 +43,10 @@ def _log_action(
             route_function: "RouteFunction" = (
                 self.view_func.get_route_function()  # type:ignore
             )
+            assert route_function.controller
             msg = (
                 f'"{request.method.upper() if request.method else "METHOD NOT FOUND"} - '
-                f'{route_function.controller.__class__.__name__}[{self.view_func.__name__}] {request.path}" '
+                f'{route_function.controller.__name__}[{self.view_func.__name__}] {request.path}" '
                 f"{duration if duration else str(ex)}"
             )
             logger(msg, **kwargs)

ninja_extra/pagination.py

@@ -1,9 +1,8 @@
 import inspect
 import logging
-import sys
 from collections import OrderedDict
 from functools import wraps
-from typing import TYPE_CHECKING, Any, Callable, Optional, Type, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, Optional, Type, Union, cast, overload
 
 from django.core.paginator import InvalidPage, Page, Paginator
 from django.db.models import QuerySet
@@ -17,7 +16,7 @@
 
 from ninja_extra.conf import settings
 from ninja_extra.exceptions import NotFound
-from ninja_extra.schemas import PaginatedResponseSchema, get_paginated_response_schema
+from ninja_extra.schemas import PaginatedResponseSchema
 from ninja_extra.urls import remove_query_param, replace_query_param
 
 logger = logging.getLogger()
@@ -31,6 +30,7 @@
     "PaginationBase",
     "LimitOffsetPagination",
     "paginate",
+    "PaginatedResponseSchema",
 ]
 
 
@@ -106,11 +106,9 @@ def get_paginated_response(self, *, base_url: str, page: Page) -> DictStrAny:
 
     @classmethod
     def get_response_schema(
-        cls, response_schema: Union[Schema, Type[Schema]]
-    ) -> Type[Schema]:
-        if sys.version_info >= (3, 8):
-            return PaginatedResponseSchema[response_schema]
-        return get_paginated_response_schema(response_schema)
+        cls, response_schema: Union[Schema, Type[Schema], Any]
+    ) -> Any:
+        return PaginatedResponseSchema[response_schema]
 
     def get_next_link(self, url: str, page: Page) -> Optional[str]:
         if not page.has_next():
@@ -136,7 +134,21 @@ def get_page_size(self, page_size: int) -> int:
         return self.page_size
 
 
-def paginate(func_or_pgn_class: Any = NOT_SET, **paginator_params: Any) -> Callable:
+@overload
+def paginate() -> Callable[..., Any]:
+    ...
+
+
+@overload
+def paginate(
+    func_or_pgn_class: Any = NOT_SET, **paginator_params: Any
+) -> Callable[..., Any]:
+    ...
+
+
+def paginate(
+    func_or_pgn_class: Any = NOT_SET, **paginator_params: Any
+) -> Callable[..., Any]:
     isfunction = inspect.isfunction(func_or_pgn_class)
     isnotset = func_or_pgn_class == NOT_SET
 
@@ -148,32 +160,31 @@ def paginate(func_or_pgn_class: Any = NOT_SET, **paginator_params: Any) -> Calla
     if not isnotset:
         pagination_class = func_or_pgn_class
 
-    def wrapper(func: Callable) -> Any:
+    def wrapper(func: Callable[..., Any]) -> Any:
         return _inject_pagination(func, pagination_class, **paginator_params)
 
     return wrapper
 
 
 def _inject_pagination(
-    func: Callable,
+    func: Callable[..., Any],
     paginator_class: Type[PaginationBase],
     **paginator_params: Any,
-) -> Callable:
-    func_modified = cast(Any, func)
-    func_modified.has_kwargs = True
-    if not has_kwargs(func_modified):
-        func_modified.has_kwargs = False
+) -> Callable[..., Any]:
+    func.has_kwargs = True  # type: ignore
+    if not has_kwargs(func):
+        func.has_kwargs = False  # type: ignore
         logger.debug(
-            f"function {func_modified.__name__} should have **kwargs if you want to use pagination parameters"
+            f"function {func.__name__} should have **kwargs if you want to use pagination parameters"
         )
 
     paginator: PaginationBase = paginator_class(**paginator_params)
     paginator_kwargs_name = "pagination"
 
-    @wraps(func_modified)
+    @wraps(func)
     def view_with_pagination(controller: "APIController", *args: Any, **kw: Any) -> Any:
         func_kwargs = dict(kw)
-        if not func_modified.has_kwargs:
+        if not func.has_kwargs:  # type: ignore
             func_kwargs.pop(paginator_kwargs_name)
 
         items = func(controller, *args, **func_kwargs)

ninja_extra/schemas/__init__.py

@@ -1,7 +1,3 @@
-from .response import (
-    PaginatedResponseSchema,
-    RouteParameter,
-    get_paginated_response_schema,
-)
+from .response import PaginatedResponseSchema, RouteParameter
 
-__all__ = ["PaginatedResponseSchema", "get_paginated_response_schema", "RouteParameter"]
+__all__ = ["PaginatedResponseSchema", "RouteParameter"]

ninja_extra/schemas/response.py

@@ -1,15 +1,15 @@
 import sys
-from typing import Any, Generic, List, Optional, Type, TypeVar, Union
+from typing import Any, Generic, List, Optional, Type, TypeVar
 
 from ninja import Schema
 from ninja.constants import NOT_SET
 from pydantic.generics import GenericModel
 from pydantic.main import BaseModel
 from pydantic.networks import AnyHttpUrl
 
-T = TypeVar("T")
+from ninja_extra.generic import GenericType
 
-PaginatedResponseSchema = None
+T = TypeVar("T")
 
 
 class BasePaginatedResponseSchema(Schema):
@@ -19,6 +19,17 @@ class BasePaginatedResponseSchema(Schema):
     results: List[Any]
 
 
+class PaginatedResponseSchema(GenericType):
+    def get_generic_type(self, wrap_type: Any) -> Type[BasePaginatedResponseSchema]:
+        class ListResponseSchema(BasePaginatedResponseSchema):
+            results: List[wrap_type]  # type: ignore
+
+        ListResponseSchema.__name__ = (
+            f"{self.__class__.__name__}[{str(wrap_type.__name__).capitalize()}]"
+        )
+        return ListResponseSchema
+
+
 if sys.version_info >= (3, 8):
 
     class PaginatedResponseSchema(
@@ -27,17 +38,6 @@ class PaginatedResponseSchema(
         results: List[T]
 
 
-def get_paginated_response_schema(
-    item_schema: Union[Schema, Type[Schema]],
-) -> Type[BasePaginatedResponseSchema]:
-    # fix for paginatedResponseSchema for python 3.6 and 3.7 which doesn't support generic typing
-    class ListResponseSchema(BasePaginatedResponseSchema):
-        results: List[item_schema]  # type: ignore
-
-    ListResponseSchema.__name__ = f"List{str(item_schema.__name__).capitalize()}"  # type: ignore
-    return ListResponseSchema
-
-
 class RouteParameter(BaseModel):
     path: str
     methods: List[str]