Merge pull request #5 from eadwinCode/feat/Async-Support

Async support on Pagination and Route Authentication

Author: eadwinCode

.github/workflows/test_full.yml

@@ -23,7 +23,7 @@ jobs:
       - name: Install core
         run: pip install "Django${{ matrix.django-version }}" pydantic
       - name: Install tests
-        run: pip install pytest pytest-asyncio pytest-django injector django-ninja
+        run: pip install pytest pytest-asyncio pytest-django injector django-ninja asgiref
       - name: Test
         run: pytest
   codestyle:

ninja_extra/__init__.py

@@ -15,6 +15,7 @@
 from ninja_extra.controllers.route import route
 from ninja_extra.dependency_resolver import get_injector, service_resolver
 from ninja_extra.main import NinjaExtraAPI
+from ninja_extra.router import Router
 
 default_app_config = "ninja_extra.apps.NinjaExtraConfig"
 
@@ -36,4 +37,5 @@
     "get_injector",
     "service_resolver",
     "lazy",
+    "Router",
 ]

ninja_extra/controllers/base.py

@@ -11,6 +11,7 @@
     Iterator,
     List,
     Optional,
+    Sequence,
     Tuple,
     Type,
     Union,
@@ -25,10 +26,12 @@
 from ninja import NinjaAPI, Router
 from ninja.constants import NOT_SET
 from ninja.security.base import AuthBase
+from ninja.signature import is_async
 from ninja.utils import normalize_path
 
 from ninja_extra.exceptions import APIException, NotFound, PermissionDenied, bad_request
-from ninja_extra.operation import Operation, PathView
+from ninja_extra.helper import get_function_name
+from ninja_extra.operation import ControllerPathView, Operation
 from ninja_extra.permissions import AllowAny, BasePermission
 from ninja_extra.shortcuts import (
     fail_silently,
@@ -39,7 +42,7 @@
 
 from .registry import ControllerRegistry
 from .response import Detail, Id, Ok
-from .route.route_functions import RouteFunction
+from .route.route_functions import AsyncRouteFunction, RouteFunction
 
 if TYPE_CHECKING:
     from ninja_extra import NinjaExtraAPI  # pragma: no cover
@@ -256,7 +259,7 @@ def __init__(
         # `controller_class` target class that the APIController wraps
         self._controller_class: Optional[Type["ControllerBase"]] = None
         # `_path_operations` a converted dict of APIController route function used by Django-Ninja library
-        self._path_operations: Dict[str, PathView] = dict()
+        self._path_operations: Dict[str, ControllerPathView] = dict()
         # `permission_classes` a collection of BasePermission Types
         # a fallback if route functions has no permissions definition
         self.permission_classes: PermissionType = permissions or [AllowAny]  # type: ignore
@@ -268,6 +271,15 @@ def __init__(
         if re.search(self._PATH_PARAMETER_COMPONENT_RE, prefix):
             self._prefix_has_route_param = True
 
+        self.has_auth_async = False
+        if auth is not NOT_SET:
+            auth_callbacks = isinstance(auth, Sequence) and auth or [auth]
+            for _auth in auth_callbacks:
+                _call_back = _auth if inspect.isfunction(_auth) else _auth.__call__
+                if is_async(_call_back):
+                    self.has_auth_async = True
+                    break
+
     @property
     def controller_class(self) -> Type["ControllerBase"]:
         assert self._controller_class, "Controller Class is not available"
@@ -310,7 +322,7 @@ def __call__(self, cls: Type) -> Type["ControllerBase"]:
         return cls
 
     @property
-    def path_operations(self) -> Dict[str, PathView]:
+    def path_operations(self) -> Dict[str, ControllerPathView]:
         return self._path_operations
 
     def set_api_instance(self, api: "NinjaExtraAPI") -> None:
@@ -346,7 +358,20 @@ def __str__(self) -> str:  # pragma: no cover
     def add_operation_from_route_function(self, route_function: RouteFunction) -> None:
         # converts route functions to Operation model
         route_function.route.route_params.operation_id = f"{str(uuid.uuid4())[:8]}_controller_{route_function.route.view_func.__name__}"
-        self.add_api_operation(
+
+        if (
+            self.auth
+            and self.has_auth_async
+            and not isinstance(route_function, AsyncRouteFunction)
+        ):
+            raise Exception(
+                f"You are using a Controller level Asynchronous Authentication Class, "
+                f"All controller endpoint must be `async`.\n"
+                f"Controller={self.controller_class.__name__}, "
+                f"endpoint={get_function_name(route_function.route.view_func)}"
+            )
+
+        route_function.operation = self.add_api_operation(  # type: ignore
             view_func=route_function.as_view, **route_function.route.route_params.dict()
         )
 
@@ -375,7 +400,7 @@ def add_api_operation(
         if self._prefix_has_route_param:
             path = normalize_path("/".join([i for i in (self.prefix, path) if i]))
         if path not in self._path_operations:
-            path_view = PathView()
+            path_view = ControllerPathView()
             self._path_operations[path] = path_view
         else:
             path_view = self._path_operations[path]

ninja_extra/controllers/route/__init__.py

@@ -459,8 +459,7 @@ def __init__(
 
         _response = response
         if (
-            inspect.isclass(response)
-            and issubclass(response, ControllerResponse)  # type:ignore
+            inspect.isclass(response) and issubclass(response, ControllerResponse)
         ) or isinstance(response, ControllerResponse):
             response = cast(ControllerResponse, response)
             _response = {response.status_code: response.get_schema()}

ninja_extra/controllers/route/route_functions.py

@@ -11,6 +11,8 @@
 from .context import RouteContext
 
 if TYPE_CHECKING:
+    from ninja_extra.operation import ControllerOperation
+
     from ...controllers.base import APIController, ControllerBase
     from ...controllers.route import Route
 
@@ -28,6 +30,7 @@ def __init__(
         self, route: "Route", api_controller: Optional["APIController"] = None
     ):
         self.route = route
+        self.operation: Optional["ControllerOperation"] = None
         self.has_request_param = False
         self.api_controller = api_controller
         self.as_view = wraps(route.view_func)(self.get_view_function())

ninja_extra/helper.py

@@ -0,0 +1,8 @@
+import inspect
+from typing import Any
+
+
+def get_function_name(func_class: Any) -> str:
+    if inspect.isfunction(func_class) or inspect.isclass(func_class):
+        return str(func_class.__name__)
+    return str(func_class.__class__.__name__)

ninja_extra/main.py

@@ -10,7 +10,7 @@
 from ninja.parser import Parser
 from ninja.renderers import BaseRenderer
 
-from ninja_extra import exceptions
+from ninja_extra import exceptions, router
 from ninja_extra.controllers.base import APIController, ControllerBase
 from ninja_extra.controllers.registry import ControllerRegistry
 
@@ -49,6 +49,9 @@ def __init__(
         )
         self.app_name = app_name
         self.exception_handler(exceptions.APIException)(self.api_exception_handler)
+        self._routers: List[Tuple[str, router.Router]] = []  # type: ignore
+        self.default_router = router.Router()
+        self.add_router("", self.default_router)
 
     def api_exception_handler(
         self, request: HttpRequest, exc: exceptions.APIException

ninja_extra/operation.py

@@ -1,3 +1,4 @@
+import inspect
 import time
 from contextlib import contextmanager
 from typing import (
@@ -8,7 +9,9 @@
     List,
     Optional,
     Sequence,
+    Type,
     Union,
+    cast,
 )
 
 from django.http import HttpRequest
@@ -21,8 +24,11 @@
     PathView as NinjaPathView,
 )
 from ninja.signature import is_async
+from ninja.types import TCallable
+from ninja.utils import check_csrf
 
 from ninja_extra.exceptions import APIException
+from ninja_extra.helper import get_function_name
 from ninja_extra.logger import request_logger
 from ninja_extra.signals import route_context_finished, route_context_started
 
@@ -35,12 +41,41 @@
 
 class Operation(NinjaOperation):
     def __init__(
-        self, *args: Any, url_name: Optional[str] = None, **kwargs: Any
+        self,
+        path: str,
+        methods: List[str],
+        view_func: Callable,
+        *,
+        url_name: Optional[str] = None,
+        **kwargs: Any,
     ) -> None:
-        super().__init__(*args, **kwargs)
+        self.is_coroutine = is_async(view_func)
         self.url_name = url_name
+        super().__init__(path, methods, view_func, **kwargs)
         self.signature = ViewSignature(self.path, self.view_func)
 
+    def _set_auth(
+        self, auth: Optional[Union[Sequence[Callable], Callable, object]]
+    ) -> None:
+        if auth is not None and auth is not NOT_SET:
+            self.auth_callbacks = isinstance(auth, Sequence) and auth or [auth]
+            for callback in self.auth_callbacks:
+                _call_back = (
+                    callback if inspect.isfunction(callback) else callback.__call__  # type: ignore
+                )
+
+                if not getattr(callback, "is_coroutine", None):
+                    setattr(callback, "is_coroutine", is_async(_call_back))
+
+                if is_async(_call_back) and not self.is_coroutine:
+                    raise Exception(
+                        f"Could apply auth=`{get_function_name(callback)}` "
+                        f"to view_func=`{get_function_name(self.view_func)}`.\n"
+                        f"N:B - {get_function_name(callback)} can only be used on Asynchronous view functions"
+                    )
+
+
+class ControllerOperation(Operation):
     def _log_action(
         self,
         logger: Callable[..., Any],
@@ -90,10 +125,8 @@ def _prep_run(self, request: HttpRequest, **kw: Any) -> Iterator:
             context = self.get_execution_context(request, **kw)
             # send route_context_started signal
             route_context_started.send(RouteContext, route_context=context)
-            values = self._get_values(request, kw)
-            context.kwargs = values
 
-            yield values, context
+            yield context
             self._log_action(
                 request_logger.info,
                 request=request,
@@ -115,15 +148,16 @@ def _prep_run(self, request: HttpRequest, **kw: Any) -> Iterator:
             route_context_finished.send(RouteContext, route_context=None)
 
     def run(self, request: HttpRequest, **kw: Any) -> HttpResponseBase:
-        error = super(Operation, self)._run_checks(request)
+        error = self._run_checks(request)
         if error:
             return error
         try:
             with self._prep_run(request, **kw) as ctx:
-                values, context = ctx
-                result = self.view_func(context=context, **values)
+                values = self._get_values(request, kw)
+                ctx.kwargs = values
+                result = self.view_func(context=ctx, **values)
                 _processed_results = self._result_to_response(request, result)
-            return _processed_results
+                return _processed_results
         except Exception as e:
             if isinstance(e, TypeError) and "required positional argument" in str(e):
                 msg = "Did you fail to use functools.wraps() in a decorator?"
@@ -133,16 +167,73 @@ def run(self, request: HttpRequest, **kw: Any) -> HttpResponseBase:
 
 
 class AsyncOperation(Operation, NinjaAsyncOperation):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        from asgiref.sync import sync_to_async
+
+        self._get_values = cast(Callable, sync_to_async(super()._get_values))  # type: ignore
+        self._result_to_response = cast(  # type: ignore
+            Callable,
+            sync_to_async(super()._result_to_response),
+        )
+
+    async def _run_checks(self, request: HttpRequest) -> Optional[HttpResponse]:  # type: ignore
+        """Runs security checks for each operation"""
+        # auth:
+        if self.auth_callbacks:
+            error = await self._run_authentication(request)
+            if error:
+                return error
+
+        # csrf:
+        if self.api.csrf:
+            error = check_csrf(request, self.view_func)
+            if error:
+                return error
+
+        return None
+
+    async def _run_authentication(self, request: HttpRequest) -> Optional[HttpResponse]:  # type: ignore
+        for callback in self.auth_callbacks:
+            try:
+                is_coroutine = getattr(callback, "is_coroutine", False)
+                if is_coroutine:
+                    result = await callback(request)
+                else:
+                    result = callback(request)
+            except Exception as exc:
+                return self.api.on_exception(request, exc)
+
+            if result:
+                request.auth = result  # type: ignore
+                return None
+        return self.api.create_response(request, {"detail": "Unauthorized"}, status=401)
+
     async def run(self, request: HttpRequest, **kw: Any) -> HttpResponseBase:  # type: ignore
-        error = self._run_checks(request)
+        error = await self._run_checks(request)
+        if error:
+            return error
+        try:
+            values = await self._get_values(request, kw)  # type: ignore
+            result = await self.view_func(request, **values)
+            _processed_results = await self._result_to_response(request, result)  # type: ignore
+            return cast(HttpResponseBase, _processed_results)
+        except Exception as e:
+            return self.api.on_exception(request, e)
+
+
+class AsyncControllerOperation(AsyncOperation, ControllerOperation):
+    async def run(self, request: HttpRequest, **kw: Any) -> HttpResponseBase:  # type: ignore
+        error = await self._run_checks(request)
         if error:
             return error
         try:
             with self._prep_run(request, **kw) as ctx:
-                values, context = ctx
-                result = await self.view_func(context=context, **values)
-                _processed_results = self._result_to_response(request, result)
-            return _processed_results
+                values = await self._get_values(request, kw)  # type: ignore
+                ctx.kwargs = values
+                result = await self.view_func(context=ctx, **values)
+                _processed_results = await self._result_to_response(request, result)  # type: ignore
+                return cast(HttpResponseBase, _processed_results)
         except Exception as e:
             return self.api.on_exception(request, e)
 
@@ -176,12 +267,7 @@ def add_operation(
     ) -> Operation:
         if url_name:
             self.url_name = url_name
-
-        operation_class = Operation
-        if is_async(view_func):
-            self.is_async = True
-            operation_class = AsyncOperation
-
+        operation_class = self.get_operation_class(view_func)
         operation = operation_class(
             path,
             methods,
@@ -203,3 +289,23 @@ def add_operation(
 
         self.operations.append(operation)
         return operation
+
+    def get_operation_class(
+        self, view_func: TCallable
+    ) -> Type[Union[Operation, AsyncOperation]]:
+        operation_class = Operation
+        if is_async(view_func):
+            self.is_async = True
+            operation_class = AsyncOperation
+        return operation_class
+
+
+class ControllerPathView(PathView):
+    def get_operation_class(
+        self, view_func: TCallable
+    ) -> Type[Union[Operation, AsyncOperation]]:
+        operation_class = ControllerOperation
+        if is_async(view_func):
+            self.is_async = True
+            operation_class = AsyncControllerOperation
+        return operation_class