Merge pull request #243 from eadwinCode/pydantic_v1_drop

fix: Dropped Pydantic V1

Author: eadwinCode

docs/dependency-injection/index.md

@@ -35,7 +35,7 @@ Let's create a more practical example with a Todo application that demonstrates
 from typing import List, Optional
 from datetime import datetime
 from pydantic import BaseModel
-from injector import inject, singleton
+from injector import inject
 
 # Data Models
 class TodoItem(BaseModel):

docs/route_context.md

@@ -77,9 +77,9 @@ You can access the `RouteContext` during schema validation using the `service_re
 
 ```python
 from ninja_extra import service_resolver
-from ninja_extra.controllers import RouteContext
+from ninja_extra.context import RouteContext
 from ninja import ModelSchema
-from pydantic import validator
+from pydantic import field_validator
 from django.urls import reverse
 
 class UserProfileSchema(ModelSchema):
@@ -89,7 +89,7 @@ class UserProfileSchema(ModelSchema):
         model = UserProfile
         model_fields = ["avatar_url", "bio"]
 
-    @validator("avatar_url")
+    @field_validator("avatar_url", mode="before")
     def make_absolute_url(cls, value):
         # Get RouteContext to access request
         context: RouteContext = service_resolver(RouteContext)

docs/settings.md

@@ -21,7 +21,7 @@ NINJA_EXTRA = {
     'NUM_PROXIES': None,
     'ORDERING_CLASS':"ninja_extra.ordering.Ordering",
     'SEARCHING_CLASS':"ninja_extra.searching.Searching",
-    'ROUTE_CONTEXT_CLASS':"ninja_extra.controllers.RouteContext",
+    'ROUTE_CONTEXT_CLASS':"ninja_extra.context.RouteContext",
 }
 ```
 
@@ -74,6 +74,6 @@ default: `ninja_extra.searching.Searching`
 # `ROUTE_CONTEXT_CLASS`
 
 It defines the default `RouteContext` class that will be instantiated during request processing.
-default: `ninja_extra.controllers.RouteContext`
+default: `ninja_extra.context.RouteContext`
 
 See [Route Context](route_context.md) for more details.

ninja_extra/apps.py

@@ -1,10 +1,10 @@
-from typing import Any, cast
+import typing as t
 
 from django.apps import AppConfig, apps
 from django.utils.translation import gettext_lazy as _
 from injector import Injector, Module
 
-from ninja_extra.conf import settings
+from ninja_extra.lazy import settings_lazy
 from ninja_extra.modules import NinjaExtraModule
 from ninja_extra.shortcuts import fail_silently
 
@@ -23,15 +23,15 @@ def ready(self) -> None:
         django_injector_app = fail_silently(
             apps.get_app_config, app_label="django_injector"
         )
-        app = cast(Any, django_injector_app)
+        app = t.cast(t.Any, django_injector_app)
         if app:  # pragma: no cover
             app.ready()
             self.injector = app.injector
             self.injector.binder.install(self.ninja_extra_module)
         self.register_injector_modules()
 
     def register_injector_modules(self) -> None:  # pragma: no cover
-        for module in settings.INJECTOR_MODULES:
+        for module in settings_lazy().INJECTOR_MODULES:
             if isinstance(module, type) and issubclass(module, Module):
                 module = module()
             self.injector.binder.install(module)

ninja_extra/conf/__init__.py

@@ -1,3 +1,3 @@
-from .settings import settings
+from .package_settings import settings
 
 __all__ = ["settings"]

ninja_extra/conf/decorator.py

@@ -0,0 +1,52 @@
+import typing as t
+
+from django.utils.module_loading import import_string
+from pydantic import GetCoreSchemaHandler, GetJsonSchemaHandler
+from pydantic.json_schema import JsonSchemaValue
+from pydantic_core.core_schema import CoreSchema, with_info_plain_validator_function
+
+from ninja_extra.shortcuts import fail_silently
+
+
+class AllowTypeOfSource:
+    def __init__(
+        self,
+        schema: t.Optional[t.Dict[str, t.Any]] = None,
+        validator: t.Optional[t.Callable[..., bool]] = None,
+        error_message: t.Optional[t.Callable[..., str]] = None,
+    ) -> None:
+        self._schema = schema
+        self.validator = validator
+        self.error_message = error_message
+
+    def __get_pydantic_core_schema__(
+        self,
+        source: t.Type[t.Any],
+        handler: GetCoreSchemaHandler,
+    ) -> CoreSchema:
+        def validate(value: t.Any, *args: t.Any) -> t.Any:
+            if isinstance(value, str):
+                try_import_value = fail_silently(import_string, value)
+                if try_import_value is not None:
+                    value = try_import_value
+
+            if (self.validator and not self.validator(source, value)) or (
+                not self.validator and not isinstance(value, source)
+            ):
+                self._handle_error(source, value)
+            return value
+
+        return with_info_plain_validator_function(validate)
+
+    def _handle_error(self, source: t.Any, value: t.Any) -> None:
+        error_message = (
+            f"Expected an instance of {source}, got an instance of {type(value)}"
+            if self.error_message is None
+            else self.error_message(source, value)
+        )
+        raise ValueError(error_message)
+
+    def __get_pydantic_json_schema__(
+        self, core_schema: CoreSchema, handler: GetJsonSchemaHandler
+    ) -> JsonSchemaValue:  # pragma: no cover
+        return self._schema  # type:ignore[return-value]

ninja_extra/conf/package_settings.py

@@ -0,0 +1,101 @@
+from typing import Any, Dict, List, Optional
+
+from django.conf import settings as django_settings
+from django.core.signals import setting_changed
+from ninja.pagination import PaginationBase
+from ninja.throttling import BaseThrottle
+from pydantic import BaseModel, Field
+from typing_extensions import Annotated
+
+from ninja_extra.conf.decorator import AllowTypeOfSource
+from ninja_extra.interfaces.ordering import OrderingBase
+from ninja_extra.interfaces.route_context import RouteContextBase
+from ninja_extra.interfaces.searching import SearchingBase
+
+_GenericModelValidator = AllowTypeOfSource(
+    validator=lambda source, value: isinstance(value, type)
+    and issubclass(value, source),
+    error_message=lambda source,
+    value: f"Expected type of {source.__name__}, received: {type(value)}",
+)
+PaginationClassHandlerType = Annotated[PaginationBase, _GenericModelValidator]
+ThrottlingClassHandlerType = Annotated[BaseThrottle, _GenericModelValidator]
+SearchingClassHandlerType = Annotated[SearchingBase, _GenericModelValidator]
+OrderingClassHandlerType = Annotated[OrderingBase, _GenericModelValidator]
+RouteContextHandlerType = Annotated[RouteContextBase, _GenericModelValidator]
+
+_InjectorModuleValidator = AllowTypeOfSource(
+    validator=lambda source, value: value is not None,
+    error_message=lambda source,
+    value: f"Expected PaginationBase object, received: {type(value)}",
+)
+InjectorModuleHandlerType = Annotated[Any, _InjectorModuleValidator]
+
+
+class UserDefinedSettingsMapper:
+    def __init__(self, data: dict) -> None:
+        self.__dict__ = data
+
+
+NinjaEXTRA_SETTINGS_DEFAULTS = {
+    "INJECTOR_MODULES": [],
+    "PAGINATION_CLASS": "ninja.pagination.LimitOffsetPagination",
+    "THROTTLE_CLASSES": [
+        "ninja_extra.throttling.AnonRateThrottle",
+        "ninja_extra.throttling.UserRateThrottle",
+    ],
+    "THROTTLE_RATES": {"user": None, "anon": None},
+    "ORDERING_CLASS": "ninja_extra.ordering.Ordering",
+    "SEARCHING_CLASS": "ninja_extra.searching.Searching",
+    "ROUTE_CONTEXT_CLASS": "ninja_extra.context.RouteContext",
+}
+
+USER_SETTINGS = UserDefinedSettingsMapper(
+    getattr(django_settings, "NINJA_EXTRA", NinjaEXTRA_SETTINGS_DEFAULTS)
+)
+
+
+class NinjaExtraSettings(BaseModel):
+    class Config:
+        from_attributes = True
+        validate_assignment = True
+
+    PAGINATION_CLASS: PaginationClassHandlerType = Field(  # type: ignore[assignment]
+        "ninja.pagination.LimitOffsetPagination",
+    )
+    PAGINATION_PER_PAGE: int = Field(100)
+    THROTTLE_RATES: Dict[str, Optional[str]] = Field(
+        {"user": "1000/day", "anon": "100/day"}
+    )
+    THROTTLE_CLASSES: List[ThrottlingClassHandlerType] = Field(
+        [
+            "ninja_extra.throttling.AnonRateThrottle",  # type: ignore[list-item]
+            "ninja_extra.throttling.UserRateThrottle",  # type: ignore[list-item]
+        ]
+    )
+    NUM_PROXIES: Optional[int] = None
+    INJECTOR_MODULES: List[InjectorModuleHandlerType] = []
+    ORDERING_CLASS: OrderingClassHandlerType = Field(  # type: ignore[assignment]
+        "ninja_extra.ordering.Ordering",
+    )
+    SEARCHING_CLASS: SearchingClassHandlerType = Field(  # type: ignore[assignment]
+        "ninja_extra.searching.Searching",
+    )
+    ROUTE_CONTEXT_CLASS: RouteContextHandlerType = Field(  # type: ignore[assignment]
+        "ninja_extra.context.RouteContext",
+    )
+
+
+settings = NinjaExtraSettings.model_validate(USER_SETTINGS)
+
+
+def reload_settings(*args: Any, **kwargs: Any) -> None:  # pragma: no cover
+    global settings
+
+    setting, value = kwargs["setting"], kwargs["value"]
+
+    if setting == "NINJA_EXTRA":
+        settings = NinjaExtraSettings.model_validate(UserDefinedSettingsMapper(value))
+
+
+setting_changed.connect(reload_settings)  # pragma: no cover

ninja_extra/conf/settings.py

@@ -2,7 +2,7 @@
 import typing as t
 
 if t.TYPE_CHECKING:  # pragma: no cover
-    from ninja_extra.controllers.route.context import RouteContext
+    from ninja_extra.context import RouteContext
 
 
 POST = "POST"