⬆ Require Pydantic > 1.0 (#1862)

* 🔥 Remove support for Pydantic < 1.0

* 🔥 Remove deprecated skip_defaults from jsonable_encoder and set default for exclude to None, as in Pydantic

* ♻️ Set default of response_model_exclude=None as in Pydantic

* ⬆️ Require Pydantic >=1.0.0 in requirements

Author: tiangolo

fastapi/applications.py

@@ -1,12 +1,7 @@
 from typing import Callable, List, Optional, Sequence
 
 from fastapi.security.base import SecurityBase
-
-try:
-    from pydantic.fields import ModelField
-except ImportError:  # pragma: nocover
-    # TODO: remove when removing support for Pydantic < 1.0.0
-    from pydantic.fields import Field as ModelField  # type: ignore
+from pydantic.fields import ModelField
 
 param_supported_types = (str, int, float, bool)
 

fastapi/dependencies/models.py

@@ -28,15 +28,23 @@
 from fastapi.security.base import SecurityBase
 from fastapi.security.oauth2 import OAuth2, SecurityScopes
 from fastapi.security.open_id_connect_url import OpenIdConnect
-from fastapi.utils import (
-    PYDANTIC_1,
-    create_response_field,
-    get_field_info,
-    get_path_param_names,
-)
-from pydantic import BaseConfig, BaseModel, create_model
+from fastapi.utils import create_response_field, get_path_param_names
+from pydantic import BaseModel, create_model
 from pydantic.error_wrappers import ErrorWrapper
 from pydantic.errors import MissingError
+from pydantic.fields import (
+    SHAPE_LIST,
+    SHAPE_SEQUENCE,
+    SHAPE_SET,
+    SHAPE_SINGLETON,
+    SHAPE_TUPLE,
+    SHAPE_TUPLE_ELLIPSIS,
+    FieldInfo,
+    ModelField,
+    Required,
+)
+from pydantic.schema import get_annotation_from_field_info
+from pydantic.typing import ForwardRef, evaluate_forwardref
 from pydantic.utils import lenient_issubclass
 from starlette.background import BackgroundTasks
 from starlette.concurrency import run_in_threadpool
@@ -45,41 +53,6 @@
 from starlette.responses import Response
 from starlette.websockets import WebSocket
 
-try:
-    from pydantic.fields import (
-        SHAPE_LIST,
-        SHAPE_SEQUENCE,
-        SHAPE_SET,
-        SHAPE_SINGLETON,
-        SHAPE_TUPLE,
-        SHAPE_TUPLE_ELLIPSIS,
-        FieldInfo,
-        ModelField,
-        Required,
-    )
-    from pydantic.schema import get_annotation_from_field_info
-    from pydantic.typing import ForwardRef, evaluate_forwardref
-except ImportError:  # pragma: nocover
-    # TODO: remove when removing support for Pydantic < 1.0.0
-    from pydantic import Schema as FieldInfo  # type: ignore
-    from pydantic.fields import Field as ModelField  # type: ignore
-    from pydantic.fields import Required, Shape  # type: ignore
-    from pydantic.schema import get_annotation_from_schema  # type: ignore
-    from pydantic.utils import ForwardRef, evaluate_forwardref  # type: ignore
-
-    SHAPE_LIST = Shape.LIST
-    SHAPE_SEQUENCE = Shape.SEQUENCE
-    SHAPE_SET = Shape.SET
-    SHAPE_SINGLETON = Shape.SINGLETON
-    SHAPE_TUPLE = Shape.TUPLE
-    SHAPE_TUPLE_ELLIPSIS = Shape.TUPLE_ELLIPS
-
-    def get_annotation_from_field_info(
-        annotation: Any, field_info: FieldInfo, field_name: str
-    ) -> Type[Any]:
-        return get_annotation_from_schema(annotation, field_info)
-
-
 sequence_shapes = {
     SHAPE_LIST,
     SHAPE_SET,
@@ -113,7 +86,7 @@ def get_annotation_from_field_info(
 
 
 def check_file_field(field: ModelField) -> None:
-    field_info = get_field_info(field)
+    field_info = field.field_info
     if isinstance(field_info, params.Form):
         try:
             # __version__ is available in both multiparts, and can be mocked
@@ -239,7 +212,7 @@ def get_flat_params(dependant: Dependant) -> List[ModelField]:
 
 
 def is_scalar_field(field: ModelField) -> bool:
-    field_info = get_field_info(field)
+    field_info = field.field_info
     if not (
         field.shape == SHAPE_SINGLETON
         and not lenient_issubclass(field.type_, BaseModel)
@@ -354,7 +327,7 @@ def get_dependant(
         ) and is_scalar_sequence_field(param_field):
             add_param_to_fields(field=param_field, dependant=dependant)
         else:
-            field_info = get_field_info(param_field)
+            field_info = param_field.field_info
             assert isinstance(
                 field_info, params.Body
             ), f"Param: {param_field.name} can only be a request body, using Body(...)"
@@ -430,16 +403,13 @@ def get_param_field(
     )
     field.required = required
     if not had_schema and not is_scalar_field(field=field):
-        if PYDANTIC_1:
-            field.field_info = params.Body(field_info.default)
-        else:
-            field.schema = params.Body(field_info.default)  # type: ignore  # pragma: nocover
+        field.field_info = params.Body(field_info.default)
 
     return field
 
 
 def add_param_to_fields(*, field: ModelField, dependant: Dependant) -> None:
-    field_info = cast(params.Param, get_field_info(field))
+    field_info = cast(params.Param, field.field_info)
     if field_info.in_ == params.ParamTypes.path:
         dependant.path_params.append(field)
     elif field_info.in_ == params.ParamTypes.query:
@@ -642,26 +612,17 @@ def request_params_to_args(
             value = received_params.getlist(field.alias) or field.default
         else:
             value = received_params.get(field.alias)
-        field_info = get_field_info(field)
+        field_info = field.field_info
         assert isinstance(
             field_info, params.Param
         ), "Params must be subclasses of Param"
         if value is None:
             if field.required:
-                if PYDANTIC_1:
-                    errors.append(
-                        ErrorWrapper(
-                            MissingError(), loc=(field_info.in_.value, field.alias)
-                        )
-                    )
-                else:  # pragma: nocover
-                    errors.append(
-                        ErrorWrapper(  # type: ignore
-                            MissingError(),
-                            loc=(field_info.in_.value, field.alias),
-                            config=BaseConfig,
-                        )
+                errors.append(
+                    ErrorWrapper(
+                        MissingError(), loc=(field_info.in_.value, field.alias)
                     )
+                )
             else:
                 values[field.name] = deepcopy(field.default)
             continue
@@ -685,7 +646,7 @@ async def request_body_to_args(
     errors = []
     if required_params:
         field = required_params[0]
-        field_info = get_field_info(field)
+        field_info = field.field_info
         embed = getattr(field_info, "embed", None)
         field_alias_omitted = len(required_params) == 1 and not embed
         if field_alias_omitted:
@@ -752,12 +713,7 @@ async def request_body_to_args(
 
 
 def get_missing_field_error(loc: Tuple[str, ...]) -> ErrorWrapper:
-    if PYDANTIC_1:
-        missing_field_error = ErrorWrapper(MissingError(), loc=loc)
-    else:  # pragma: no cover
-        missing_field_error = ErrorWrapper(  # type: ignore
-            MissingError(), loc=loc, config=BaseConfig,
-        )
+    missing_field_error = ErrorWrapper(MissingError(), loc=loc)
     return missing_field_error
 
 
@@ -775,7 +731,7 @@ def get_schema_compatible_field(*, field: ModelField) -> ModelField:
             default=field.default,
             required=field.required,
             alias=field.alias,
-            field_info=get_field_info(field),
+            field_info=field.field_info,
         )
     return out_field
 
@@ -785,7 +741,7 @@ def get_body_field(*, dependant: Dependant, name: str) -> Optional[ModelField]:
     if not flat_dependant.body_params:
         return None
     first_param = flat_dependant.body_params[0]
-    field_info = get_field_info(first_param)
+    field_info = first_param.field_info
     embed = getattr(field_info, "embed", None)
     body_param_names_set = {param.name for param in flat_dependant.body_params}
     if len(body_param_names_set) == 1 and not embed:
@@ -796,29 +752,25 @@ def get_body_field(*, dependant: Dependant, name: str) -> Optional[ModelField]:
     # in case a sub-dependency is evaluated with a single unique body field
     # That is combined (embedded) with other body fields
     for param in flat_dependant.body_params:
-        setattr(get_field_info(param), "embed", True)
+        setattr(param.field_info, "embed", True)
     model_name = "Body_" + name
     BodyModel = create_model(model_name)
     for f in flat_dependant.body_params:
         BodyModel.__fields__[f.name] = get_schema_compatible_field(field=f)
     required = any(True for f in flat_dependant.body_params if f.required)
 
     BodyFieldInfo_kwargs: Dict[str, Any] = dict(default=None)
-    if any(
-        isinstance(get_field_info(f), params.File) for f in flat_dependant.body_params
-    ):
+    if any(isinstance(f.field_info, params.File) for f in flat_dependant.body_params):
         BodyFieldInfo: Type[params.Body] = params.File
-    elif any(
-        isinstance(get_field_info(f), params.Form) for f in flat_dependant.body_params
-    ):
+    elif any(isinstance(f.field_info, params.Form) for f in flat_dependant.body_params):
         BodyFieldInfo = params.Form
     else:
         BodyFieldInfo = params.Body
 
         body_param_media_types = [
-            getattr(get_field_info(f), "media_type")
+            getattr(f.field_info, "media_type")
             for f in flat_dependant.body_params
-            if isinstance(get_field_info(f), params.Body)
+            if isinstance(f.field_info, params.Body)
         ]
         if len(set(body_param_media_types)) == 1:
             BodyFieldInfo_kwargs["media_type"] = body_param_media_types[0]

fastapi/dependencies/utils.py

@@ -4,8 +4,6 @@
 from types import GeneratorType
 from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
 
-from fastapi.logger import logger
-from fastapi.utils import PYDANTIC_1
 from pydantic import BaseModel
 from pydantic.json import ENCODERS_BY_TYPE
 
@@ -28,21 +26,14 @@ def generate_encoders_by_class_tuples(
 def jsonable_encoder(
     obj: Any,
     include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
-    exclude: Union[SetIntStr, DictIntStrAny] = set(),
+    exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
     by_alias: bool = True,
-    skip_defaults: Optional[bool] = None,
     exclude_unset: bool = False,
     exclude_defaults: bool = False,
     exclude_none: bool = False,
     custom_encoder: dict = {},
     sqlalchemy_safe: bool = True,
 ) -> Any:
-    if skip_defaults is not None:
-        logger.warning(  # pragma: nocover
-            "skip_defaults in jsonable_encoder has been deprecated in favor of "
-            "exclude_unset to keep in line with Pydantic v1, support for it will be "
-            "removed soon."
-        )
     if include is not None and not isinstance(include, set):
         include = set(include)
     if exclude is not None and not isinstance(exclude, set):
@@ -51,24 +42,14 @@ def jsonable_encoder(
         encoder = getattr(obj.__config__, "json_encoders", {})
         if custom_encoder:
             encoder.update(custom_encoder)
-        if PYDANTIC_1:
-            obj_dict = obj.dict(
-                include=include,
-                exclude=exclude,
-                by_alias=by_alias,
-                exclude_unset=bool(exclude_unset or skip_defaults),
-                exclude_none=exclude_none,
-                exclude_defaults=exclude_defaults,
-            )
-        else:  # pragma: nocover
-            if exclude_defaults:
-                raise ValueError("Cannot use exclude_defaults")
-            obj_dict = obj.dict(
-                include=include,
-                exclude=exclude,
-                by_alias=by_alias,
-                skip_defaults=bool(exclude_unset or skip_defaults),
-            )
+        obj_dict = obj.dict(
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_none=exclude_none,
+            exclude_defaults=exclude_defaults,
+        )
         if "__root__" in obj_dict:
             obj_dict = obj_dict["__root__"]
         return jsonable_encoder(
@@ -94,7 +75,7 @@ def jsonable_encoder(
                     or (not key.startswith("_sa"))
                 )
                 and (value is not None or not exclude_none)
-                and ((include and key in include) or key not in exclude)
+                and ((include and key in include) or not exclude or key not in exclude)
             ):
                 encoded_key = jsonable_encoder(
                     key,

fastapi/encoders.py

@@ -1,11 +1,8 @@
 from typing import Any, Dict, Optional, Sequence
 
-from fastapi.utils import PYDANTIC_1
 from pydantic import ValidationError, create_model
 from pydantic.error_wrappers import ErrorList
 from starlette.exceptions import HTTPException as StarletteHTTPException
-from starlette.requests import Request
-from starlette.websockets import WebSocket
 
 
 class HTTPException(StarletteHTTPException):
@@ -32,15 +29,9 @@ class FastAPIError(RuntimeError):
 class RequestValidationError(ValidationError):
     def __init__(self, errors: Sequence[ErrorList], *, body: Any = None) -> None:
         self.body = body
-        if PYDANTIC_1:
-            super().__init__(errors, RequestErrorModel)
-        else:
-            super().__init__(errors, Request)  # type: ignore  # pragma: nocover
+        super().__init__(errors, RequestErrorModel)
 
 
 class WebSocketRequestValidationError(ValidationError):
     def __init__(self, errors: Sequence[ErrorList]) -> None:
-        if PYDANTIC_1:
-            super().__init__(errors, WebSocketErrorModel)
-        else:
-            super().__init__(errors, WebSocket)  # type: ignore  # pragma: nocover
+        super().__init__(errors, WebSocketErrorModel)

fastapi/exceptions.py

@@ -2,24 +2,13 @@
 from typing import Any, Callable, Dict, Iterable, List, Optional, Union
 
 from fastapi.logger import logger
-from pydantic import BaseModel
-
-try:
-    from pydantic import AnyUrl, Field
-except ImportError:  # pragma: nocover
-    # TODO: remove when removing support for Pydantic < 1.0.0
-    from pydantic import Schema as Field  # type: ignore
-    from pydantic import UrlStr as AnyUrl  # type: ignore
+from pydantic import AnyUrl, BaseModel, Field
 
 try:
     import email_validator
 
     assert email_validator  # make autoflake ignore the unused import
-    try:
-        from pydantic import EmailStr
-    except ImportError:  # pragma: nocover
-        # TODO: remove when removing support for Pydantic < 1.0.0
-        from pydantic.types import EmailStr  # type: ignore
+    from pydantic import EmailStr
 except ImportError:  # pragma: no cover
 
     class EmailStr(str):  # type: ignore