Merge pull request #153 from eadwinCode/ninja_1_2_0_support

feat: Ninja  V1.2.0 Support

Author: eadwinCode

docs/tutorial/throttling.md

@@ -4,11 +4,11 @@ Throttling can be seen as a permission that determines if a request should be au
 It indicates a temporary state used to control the rate of requests that clients can make to an API.
 
 ```python
-from ninja_extra import NinjaExtraAPI, throttle
+from ninja_extra import NinjaExtraAPI
+from ninja_extra.throttling import UserRateThrottle, AnonRateThrottle
 api = NinjaExtraAPI()
 
-@api.get('/users')
-@throttle  # this will apply default throttle classes [UserRateThrottle, AnonRateThrottle]
+@api.get('/users', throttle=[AnonRateThrottle(), UserRateThrottle()])
 def my_throttled_endpoint(request):
     return 'foo'
 ```
@@ -23,7 +23,7 @@ constraints, which could be burst throttling rate or sustained throttling rates,
 for example, you might want to limit a user to a maximum of 60 requests per minute, and 1000 requests per day.
 
 ```python
-from ninja_extra import NinjaExtraAPI, throttle
+from ninja_extra import NinjaExtraAPI
 from ninja_extra.throttling import UserRateThrottle
 api = NinjaExtraAPI()
 
@@ -36,8 +36,7 @@ class User1000PerDayRateThrottle(UserRateThrottle):
     rate = "1000/day"
     scope = "days"
 
-@api.get('/users')
-@throttle(User60MinRateThrottle, User1000PerDayRateThrottle)
+@api.get('/users', throttle=[User60MinRateThrottle(), User1000PerDayRateThrottle()])
 def my_throttled_endpoint(request):
     return 'foo'
 
@@ -61,13 +60,12 @@ NINJA_EXTRA = {
 The rate descriptions used in `THROTTLE_RATES` may include `second`, `minute`, `hour` or `day` as the throttle period.
 
 ```python
-from ninja_extra import NinjaExtraAPI, throttle
+from ninja_extra import NinjaExtraAPI
 from ninja_extra.throttling import UserRateThrottle
 
 api = NinjaExtraAPI()
 
-@api.get('/users')
-@throttle(UserRateThrottle)
+@api.get('/users', throttle=UserRateThrottle())
 def my_throttled_endpoint(request):
     return 'foo'
 ```
@@ -162,17 +160,15 @@ NINJA_EXTRA = {
 
 ```python
 # api.py
-from ninja_extra import NinjaExtraAPI, throttle
+from ninja_extra import NinjaExtraAPI
 from ninja_extra.throttling import DynamicRateThrottle
 api = NinjaExtraAPI()
 
-@api.get('/users')
-@throttle(DynamicRateThrottle, scope='burst')
+@api.get('/users', throttle=DynamicRateThrottle(scope='burst'))
 def get_users(request):
     return 'foo'
 
-@api.get('/users/<int:id>')
-@throttle(DynamicRateThrottle, scope='sustained')
+@api.get('/users/<int:id>', throttle=DynamicRateThrottle(scope='sustained'))
 def get_user_by_id(request, id: int):
     return 'foo'
 ```
@@ -187,21 +183,15 @@ Here, we dynamically applied `sustained` rates and `burst` rates to `get_users`
 ```python
 # api.py
 from ninja_extra import (
-    NinjaExtraAPI, throttle, api_controller, ControllerBase,
+    NinjaExtraAPI, api_controller, ControllerBase,
     http_get
 )
 from ninja_extra.throttling import DynamicRateThrottle
 api = NinjaExtraAPI()
 
-@api_controller("/throttled-controller")
+@api_controller("/throttled-controller", throttle=[DynamicRateThrottle(scope="sustained")])
 class ThrottlingControllerSample(ControllerBase):
-    throttling_classes = [
-        DynamicRateThrottle,
-    ]
-    throttling_init_kwargs = dict(scope="sustained")
-
-    @http_get("/endpoint_1")
-    @throttle(DynamicRateThrottle, scope='burst')
+    @http_get("/endpoint_1", throttle=DynamicRateThrottle(scope="burst"))
     def endpoint_1(self, request):
         # this will override the generally throttling applied at the controller
         return "foo"
@@ -216,4 +206,4 @@ class ThrottlingControllerSample(ControllerBase):
 
 
 api.register_controllers(ThrottlingControllerSample)
-```
+```

ninja_extra/conf/settings.py

@@ -41,7 +41,12 @@ class Config:
     THROTTLE_RATES: Dict[str, Optional[str]] = Field(
         {"user": "1000/day", "anon": "100/day"}
     )
-    THROTTLE_CLASSES: List[Any] = []
+    THROTTLE_CLASSES: List[Any] = Field(
+        [
+            "ninja_extra.throttling.AnonRateThrottle",
+            "ninja_extra.throttling.UserRateThrottle",
+        ]
+    )
     NUM_PROXIES: Optional[int] = None
     INJECTOR_MODULES: List[Any] = []
     ORDERING_CLASS: Any = Field(

ninja_extra/constants.py

@@ -15,6 +15,7 @@
 TRACE = "TRACE"
 ROUTE_METHODS = [POST, PUT, PATCH, DELETE, GET, HEAD, OPTIONS, TRACE]
 THROTTLED_FUNCTION = "__throttled_endpoint__"
+THROTTLED_OBJECTS = "__throttled_objects__"
 ROUTE_FUNCTION = "__route_function__"
 
 ROUTE_CONTEXT_VAR: contextvars.ContextVar[t.Optional["RouteContext"]] = (

ninja_extra/controllers/base.py

@@ -26,12 +26,13 @@
 from django.urls import path as django_path
 from injector import inject, is_decorated_with_inject
 from ninja import NinjaAPI, Router
-from ninja.constants import NOT_SET
+from ninja.constants import NOT_SET, NOT_SET_TYPE
 from ninja.security.base import AuthBase
 from ninja.signature import is_async
+from ninja.throttling import BaseThrottle
 from ninja.utils import normalize_path
 
-from ninja_extra.constants import ROUTE_FUNCTION, THROTTLED_FUNCTION
+from ninja_extra.constants import ROUTE_FUNCTION, THROTTLED_FUNCTION, THROTTLED_OBJECTS
 from ninja_extra.exceptions import APIException, NotFound, PermissionDenied, bad_request
 from ninja_extra.helper import get_function_name
 from ninja_extra.operation import Operation, PathView
@@ -51,7 +52,6 @@
 
 if TYPE_CHECKING:  # pragma: no cover
     from ninja_extra import NinjaExtraAPI
-    from ninja_extra.throttling import BaseThrottle
 
     from .route.context import RouteContext
 
@@ -126,10 +126,10 @@ def some_method_name(self):
     throttling_classes: List[Type["BaseThrottle"]] = []
     throttling_init_kwargs: Optional[Dict[Any, Any]] = None
 
-    Ok = Ok
-    Id = Id
-    Detail = Detail
-    bad_request = bad_request
+    Ok = Ok  # TODO: remove soonest
+    Id = Id  # TODO: remove soonest
+    Detail = Detail  # TODO: remove soonest
+    bad_request = bad_request  # TODO: remove soonest
 
     @classmethod
     def get_api_controller(cls) -> "APIController":
@@ -294,6 +294,7 @@ def __init__(
         prefix: str,
         *,
         auth: Any = NOT_SET,
+        throttle: Union[BaseThrottle, List[BaseThrottle], NOT_SET_TYPE] = NOT_SET,
         tags: Union[Optional[List[str]], str] = None,
         permissions: Optional["PermissionType"] = None,
         auto_import: bool = True,
@@ -303,6 +304,7 @@ def __init__(
         self.auth: Optional[AuthBase] = auth
 
         self.tags = tags  # type: ignore
+        self.throttle = throttle
 
         self.auto_import: bool = auto_import  # set to false and it would be ignored when api.auto_discover is called
         # `controller_class` target class that the APIController wraps
@@ -348,8 +350,6 @@ def tags(self, value: Union[str, List[str], None]) -> None:
         self._tags = tag
 
     def __call__(self, cls: ControllerClassType) -> ControllerClassType:
-        from ninja_extra.throttling import throttle
-
         self.auto_import = getattr(cls, "auto_import", self.auto_import)
         if not issubclass(cls, ControllerBase):
             # We force the cls to inherit from `ControllerBase` by creating another type.
@@ -360,8 +360,15 @@ def __call__(self, cls: ControllerClassType) -> ControllerClassType:
         assert isinstance(
             cls.throttling_classes, (list, tuple)
         ), f"Controller[{cls.__name__}].throttling_class must be a list or tuple"
-        has_throttling_classes = len(cls.throttling_classes) > 0
-        throttling_init_kwargs = cls.throttling_init_kwargs or {}
+
+        throttling_objects: Union[BaseThrottle, List[BaseThrottle], NOT_SET_TYPE]
+        if cls.throttling_classes:
+            throttling_init_kwargs = cls.throttling_init_kwargs or {}
+            throttling_objects = [
+                item(**throttling_init_kwargs) for item in cls.throttling_classes
+            ]
+        else:
+            throttling_objects = self.throttle
 
         if not self.tags:
             tag = str(cls.__name__).lower().replace("controller", "")
@@ -386,10 +393,13 @@ def __call__(self, cls: ControllerClassType) -> ControllerClassType:
 
         for _, v in self._controller_class_route_functions.items():
             throttled_endpoint = v.as_view.__dict__.get(THROTTLED_FUNCTION)
-            if not throttled_endpoint and has_throttling_classes:
-                v.route.view_func = throttle(
-                    *cls.throttling_classes, **throttling_init_kwargs
-                )(v.route.view_func)
+
+            if throttled_endpoint or throttling_objects is not NOT_SET:
+                v.route.route_params.throttle = v.as_view.__dict__.get(
+                    THROTTLED_OBJECTS, lambda: throttling_objects
+                )()
+                setattr(v.route.view_func, THROTTLED_FUNCTION, True)
+
             self._add_operation_from_route_function(v)
 
         if not is_decorated_with_inject(cls.__init__):
@@ -463,6 +473,7 @@ def add_api_operation(
         view_func: Callable,
         *,
         auth: Any = NOT_SET,
+        throttle: Union[BaseThrottle, List[BaseThrottle], NOT_SET_TYPE] = NOT_SET,
         response: Any = NOT_SET,
         operation_id: Optional[str] = None,
         summary: Optional[str] = None,
@@ -504,13 +515,14 @@ def add_api_operation(
             url_name=url_name,
             include_in_schema=include_in_schema,
             openapi_extra=openapi_extra,
+            throttle=throttle,
         )
         return operation
 
 
 @overload
 def api_controller(
-    prefix_or_class: Type[T],
+    prefix_or_class: Union[ControllerClassType, Type[T]],
 ) -> Union[Type[ControllerBase], Type[T]]:  # pragma: no cover
     ...
 
@@ -519,16 +531,20 @@ def api_controller(
 def api_controller(
     prefix_or_class: str = "",
     auth: Any = NOT_SET,
+    throttle: Union[BaseThrottle, List[BaseThrottle], NOT_SET_TYPE] = NOT_SET,
     tags: Union[Optional[List[str]], str] = None,
     permissions: Optional["PermissionType"] = None,
     auto_import: bool = True,
-) -> Callable[[Type[T]], Union[Type[ControllerBase], Type[T]]]:  # pragma: no cover
+) -> Callable[
+    [Union[Type, Type[T]]], Union[Type[ControllerBase], Type[T]]
+]:  # pragma: no cover
     ...
 
 
 def api_controller(
-    prefix_or_class: Union[str, ControllerClassType] = "",
+    prefix_or_class: Union[str, Union[ControllerClassType, Type]] = "",
     auth: Any = NOT_SET,
+    throttle: Union[BaseThrottle, List[BaseThrottle], NOT_SET_TYPE] = NOT_SET,
     tags: Union[Optional[List[str]], str] = None,
     permissions: Optional["PermissionType"] = None,
     auto_import: bool = True,
@@ -540,6 +556,7 @@ def api_controller(
             tags=tags,
             permissions=permissions,
             auto_import=auto_import,
+            throttle=throttle,
         )(prefix_or_class)
 
     def _decorator(cls: ControllerClassType) -> ControllerClassType:
@@ -549,6 +566,7 @@ def _decorator(cls: ControllerClassType) -> ControllerClassType:
             tags=tags,
             permissions=permissions,
             auto_import=auto_import,
+            throttle=throttle,
         )(cls)
 
     return _decorator