Merge pull request #148 from python-ellar/pydanticV2_support

Pydantic v2 migration

Author: eadwinCode

.github/workflows/test_full.yml

@@ -37,8 +37,6 @@ jobs:
         run: pip install flit
       - name: Install Dependencies
         run: flit install --symlink
-      - name: Black
-        run: black --check ellar tests examples
       - name: Ruff Linting Check
         run: ruff check ellar tests examples
       - name: mypy

Makefile

@@ -19,12 +19,11 @@ install-full: ## Install dependencies
 	pre-commit install -f
 
 lint:fmt ## Run code linters
-	black --check ellar tests examples
 	ruff check ellar tests examples
 	mypy ellar
 
 fmt format:clean ## Run code formatters
-	black ellar tests examples
+	ruff format ellar tests examples
 	ruff check --fix ellar tests examples
 
 test:clean ## Run tests

ellar/app/context.py

@@ -4,6 +4,7 @@
 from types import TracebackType
 
 from ellar.common.constants import ELLAR_CONFIG_MODULE
+from ellar.common.logger import logger
 from ellar.common.utils.functional import SimpleLazyObject, empty
 from ellar.core import Config
 from ellar.di import EllarInjector
@@ -95,10 +96,10 @@ def _get_application_config() -> Config:
     if app_context is empty:
         config_module = os.environ.get(ELLAR_CONFIG_MODULE)
         if not config_module:
-            raise RuntimeError(
+            logger.warning(
                 "You are trying to access app config outside app context "
                 "and %s is not specified. This may cause differences in config "
-                "values when the app." % (ELLAR_CONFIG_MODULE,)
+                "values with the app" % (ELLAR_CONFIG_MODULE,)
             )
         return Config(config_module=config_module)
 

ellar/auth/handlers/schemes/base.py

@@ -103,8 +103,7 @@ def openapi_security_scheme(
     ) -> t.Dict:
         assert cls.openapi_in, "openapi_in is required"
         return {
-            cls.openapi_name
-            or cls.__name__: {
+            cls.openapi_name or cls.__name__: {
                 "type": "apiKey",
                 "description": cls.openapi_description,
                 "in": cls.openapi_in,
@@ -153,8 +152,7 @@ def openapi_security_scheme(
     ) -> t.Dict:
         assert cls.scheme, "openapi_scheme is required"
         return {
-            cls.openapi_name
-            or cls.__name__: {
+            cls.openapi_name or cls.__name__: {
                 "type": "http",
                 "description": cls.openapi_description,
                 "scheme": cls.scheme,

ellar/auth/session/options.py

@@ -1,7 +1,7 @@
 import sys
 import typing as t
 
-from pydantic import BaseModel
+from ellar.pydantic import BaseModel
 
 if sys.version_info >= (3, 8):  # pragma: no cover
     from typing import Literal

ellar/cache/schema.py

@@ -1,28 +1,25 @@
 import typing as t
 
 from ellar.cache import BaseCacheBackend
-from pydantic import BaseModel, validator
+from ellar.pydantic import BaseModel, as_pydantic_validator, field_validator
 
 
+@as_pydantic_validator("__validate_input__", schema={"type": "object"})
 class TBaseCacheBackend:
     @classmethod
-    def __get_validators__(
-        cls: t.Type["TBaseCacheBackend"],
-    ) -> t.Iterable[t.Callable[..., t.Any]]:
-        yield cls.validate
+    def __validate_input__(
+        cls: t.Type["TBaseCacheBackend"], __input: t.Any, _: t.Any
+    ) -> t.Any:
+        if isinstance(__input, BaseCacheBackend):
+            return __input
 
-    @classmethod
-    def validate(cls: t.Type["TBaseCacheBackend"], v: t.Any) -> t.Any:
-        if isinstance(v, BaseCacheBackend):
-            return v
-
-        raise ValueError(f"Expected BaseCacheBackend, received: {type(v)}")
+        raise ValueError(f"Expected BaseCacheBackend, received: {type(__input)}")
 
 
 class CacheModuleSchemaSetup(BaseModel):
     CACHES: t.Dict[str, TBaseCacheBackend] = {}
 
-    @validator("CACHES", pre=True)
+    @field_validator("CACHES", mode="before")
     def pre_cache_validate(cls, value: t.Dict) -> t.Any:
         if value and not value.get("default"):
             raise ValueError("CACHES configuration must have a 'default' key")

ellar/common/__init__.py

@@ -96,7 +96,7 @@
     trace,
     ws_route,
 )
-from .serializer import DataclassSerializer, Serializer, serialize_object
+from .serializer import Serializer, serialize_object
 from .templating import TemplateResponse, render_template, render_template_string
 
 __all__ = [
@@ -108,7 +108,6 @@
     "EllarTyper",
     "GlobalGuard",
     "Serializer",
-    "DataclassSerializer",
     "WebSocketException",
     "APIException",
     "AuthenticationFailed",

ellar/common/compatible/__init__.py

@@ -1,10 +1,8 @@
 from .cache_properties import cached_property
 from .dict import AttributeDict, AttributeDictAccessMixin
-from .emails import EmailStr
 
 __all__ = [
     "cached_property",
-    "EmailStr",
     "AttributeDictAccessMixin",
     "AttributeDict",
 ]

ellar/common/constants.py

@@ -5,13 +5,6 @@
 
 from ellar.common.types import TMessage
 from ellar.di import AnnotationToValue
-from pydantic.fields import (
-    SHAPE_LIST,
-    SHAPE_SEQUENCE,
-    SHAPE_SET,
-    SHAPE_TUPLE,
-    SHAPE_TUPLE_ELLIPSIS,
-)
 
 POST = "POST"
 PUT = "PUT"
@@ -81,21 +74,8 @@ class CONTROLLER_METADATA(metaclass=AnnotationToValue):
     INCLUDE_IN_SCHEMA: str
 
 
-sequence_shapes = {
-    SHAPE_LIST,
-    SHAPE_SET,
-    SHAPE_TUPLE,
-    SHAPE_SEQUENCE,
-    SHAPE_TUPLE_ELLIPSIS,
-}
 sequence_types = (list, set, tuple)
-sequence_shape_to_type = {
-    SHAPE_LIST: list,
-    SHAPE_SET: set,
-    SHAPE_TUPLE: tuple,
-    SHAPE_SEQUENCE: list,
-    SHAPE_TUPLE_ELLIPSIS: list,
-}
+
 primitive_types = (int, float, bool, str)
 METHODS_WITH_BODY = {"GET", "HEAD", "POST", "PUT", "DELETE", "PATCH"}
 STATUS_CODES_WITH_NO_BODY = {100, 101, 102, 103, 204, 304}

ellar/common/converters.py

@@ -1,7 +1,7 @@
 import typing as t
 from abc import ABC, abstractmethod
 
-from pydantic.typing import get_args, get_origin
+from typing_extensions import get_args, get_origin
 
 _origin_maps = {
     list: t.List,

ellar/common/datastructures.py

@@ -1,5 +1,6 @@
 import typing as t
 
+from ellar.pydantic import as_pydantic_validator
 from starlette.datastructures import (
     URL as URL,
 )
@@ -38,6 +39,9 @@
 ]
 
 
+@as_pydantic_validator(
+    "__validate_input__", schema={"type": "string", "format": "binary"}
+)
 class UploadFile(StarletteUploadFile):
     """
     A file uploaded in a request.
@@ -76,17 +80,12 @@ async def create_upload_file(file: UploadFile):
     ]
 
     @classmethod
-    def __modify_schema__(cls, field_schema: t.Dict[str, t.Any]) -> None:
-        field_schema.update({"type": "string", "format": "binary"})
-
-    @classmethod
-    def __get_validators__(
-        cls: t.Type["UploadFile"],
-    ) -> t.Iterable[t.Callable[..., t.Any]]:
-        yield cls.validate
-
-    @classmethod
-    def validate(cls: t.Type["UploadFile"], v: t.Any) -> t.Any:
-        if not isinstance(v, StarletteUploadFile):
-            raise ValueError(f"Expected UploadFile, received: {type(v)}")
-        return cls(v.file, size=v.size, filename=v.filename, headers=v.headers)
+    def __validate_input__(cls, __input_value: t.Any, _: t.Any) -> "UploadFile":
+        if not isinstance(__input_value, StarletteUploadFile):
+            raise ValueError(f"Expected UploadFile, received: {type(__input_value)}")
+        return cls(
+            __input_value.file,
+            size=__input_value.size,
+            filename=__input_value.filename,
+            headers=__input_value.headers,
+        )

ellar/common/decorators/exception.py

@@ -1,7 +1,7 @@
 import typing as t
 
 from ellar.common.constants import EXCEPTION_HANDLERS_KEY
-from pydantic import BaseModel
+from ellar.pydantic import BaseModel
 
 
 class ValidateExceptionHandler(BaseModel):

ellar/common/decorators/serializer.py

@@ -14,7 +14,6 @@ def serializer_filter(
         t.Union[t.Set[t.Union[int, str]], t.Mapping[t.Union[int, str], t.Any]]
     ] = None,
     by_alias: bool = True,
-    skip_defaults: t.Optional[bool] = None,
     exclude_unset: bool = False,
     exclude_defaults: bool = False,
     exclude_none: bool = False,
@@ -26,7 +25,6 @@ def serializer_filter(
     :param include:
     :param exclude:
     :param by_alias:
-    :param skip_defaults:
     :param exclude_unset:
     :param exclude_defaults:
     :param exclude_none:
@@ -39,7 +37,6 @@ def serializer_filter(
             include=include,
             exclude=exclude,
             by_alias=by_alias,
-            skip_defaults=skip_defaults,
             exclude_unset=exclude_unset,
             exclude_defaults=exclude_defaults,
             exclude_none=exclude_none,

ellar/common/exceptions/callable_exceptions.py

@@ -66,7 +66,7 @@ async def catch(
     ) -> t.Union[Response, t.Any]:
         args = tuple(list(self.func_args) + [ctx, exc])
         if self.is_async:
-            return await self.callable_exception_handler(*args)  # type:ignore
+            return await self.callable_exception_handler(*args)  # type:ignore[misc]
         return await run_in_threadpool(self.callable_exception_handler, *args)
 
     def __eq__(self, other: t.Any) -> bool:

ellar/common/exceptions/handlers.py

@@ -76,5 +76,5 @@ async def catch(
         config = ctx.get_app().config
         return config.DEFAULT_JSON_CLASS(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            content={"detail": serialize_object(exc.errors())},
+            content={"detail": exc.errors()},
         )

ellar/common/exceptions/validation.py

@@ -1,17 +1,25 @@
 import typing as t
 
-from pydantic import BaseModel, ValidationError, create_model
-from pydantic.error_wrappers import ErrorList
+from ellar.common.serializer import serialize_object
+from ellar.pydantic import BaseModel, create_model
 
 RequestErrorModel: t.Type[BaseModel] = create_model("Request")
 WebSocketErrorModel: t.Type[BaseModel] = create_model("WebSocket")
 
 
-class RequestValidationError(ValidationError):
-    def __init__(self, errors: t.Sequence[ErrorList]) -> None:
-        super().__init__(errors, RequestErrorModel)
+class ValidationException(Exception):
+    def __init__(self, errors: t.Sequence[t.Any]) -> None:
+        self._errors = errors
 
+    def errors(self) -> t.Sequence[t.Any]:
+        return serialize_object(self._errors)  # type:ignore[no-any-return]
 
-class WebSocketRequestValidationError(ValidationError):
-    def __init__(self, errors: t.Sequence[ErrorList]) -> None:
-        super().__init__(errors, WebSocketErrorModel)
+
+class RequestValidationError(ValidationException):
+    def __init__(self, errors: t.Sequence[t.Any], *, body: t.Any = None) -> None:
+        super().__init__(errors)
+        self.body = body
+
+
+class WebSocketRequestValidationError(ValidationException):
+    pass

ellar/common/interfaces/exceptions.py

@@ -1,21 +1,16 @@
 import typing as t
 from abc import ABC, abstractmethod
 
+from ellar.pydantic import as_pydantic_validator
 from starlette.responses import Response
 
 from .context import IHostContext
 
 
+@as_pydantic_validator("__validate_input__", schema={"type": "object"})
 class IExceptionHandler(ABC, t.Iterable):
     @classmethod
-    def __get_validators__(
-        cls: t.Type["IExceptionHandler"],
-    ) -> t.Iterable[t.Callable[..., t.Any]]:
-        # for Pydantic Model Validation
-        yield cls.__validate
-
-    @classmethod
-    def __validate(cls, v: t.Any) -> t.Any:
+    def __validate_input__(cls, v: t.Any, _: t.Any) -> t.Any:
         if not isinstance(v, cls):
             raise ValueError(f"Expected IExceptionHandler object, received: {type(v)}")
         return v

ellar/common/interfaces/middleware.py

@@ -1,16 +1,12 @@
 import typing as t
 
+from ellar.pydantic import as_pydantic_validator
 
-class IEllarMiddleware:
-    @classmethod
-    def __get_validators__(
-        cls: t.Type["IEllarMiddleware"],
-    ) -> t.Iterable[t.Callable[..., t.Any]]:
-        # for Pydantic Model Validation
-        yield cls.__validate
 
+@as_pydantic_validator("__validate_input__", schema={"type": "object"})
+class IEllarMiddleware:
     @classmethod
-    def __validate(cls, v: t.Any) -> t.Any:
+    def __validate_input__(cls, v: t.Any, _: t.Any) -> t.Any:
         if not isinstance(v, cls):
             raise ValueError(f"Expected EllarMiddleware object, received: {type(v)}")
         return v  # pragma: no cover

ellar/common/interfaces/response_model.py

@@ -1,7 +1,7 @@
 import typing as t
 from abc import ABC, abstractmethod
 
-from pydantic.fields import ModelField
+from ellar.pydantic import ModelField
 from starlette.responses import Response
 
 from .context import IExecutionContext

ellar/common/interfaces/versioning.py

@@ -2,6 +2,7 @@
 from abc import ABC, abstractmethod
 
 from ellar.common.types import TScope
+from ellar.pydantic import as_pydantic_validator
 
 
 class IAPIVersioningResolver(ABC):
@@ -10,20 +11,14 @@ def can_activate(self, route_versions: t.Set[t.Union[int, float, str]]) -> bool:
         """Validate Version routes"""
 
 
+@as_pydantic_validator("__validate_input__", schema={"type": "object"})
 class IAPIVersioning(ABC):
     @abstractmethod
     def get_version_resolver(self, scope: TScope) -> IAPIVersioningResolver:
         """Retrieve Version Resolver"""
 
     @classmethod
-    def __get_validators__(
-        cls: t.Type["IAPIVersioning"],
-    ) -> t.Iterable[t.Callable[..., t.Any]]:
-        # for Pydantic Model Validation
-        yield cls.__validate
-
-    @classmethod
-    def __validate(cls, v: t.Any) -> t.Any:
+    def __validate_input__(cls, v: t.Any, _: t.Any) -> t.Any:
         if not isinstance(v, cls):
             raise ValueError(f"Expected BaseAPIVersioning, received: {type(v)}")
         return v