fastapi 0.118.3__py3-none-any.whl → 0.119.1__py3-none-any.whl

fastapi/_compat/shared.py

@@ -0,0 +1,211 @@
+import sys
+import types
+import typing
+from collections import deque
+from dataclasses import is_dataclass
+from typing import (
+    Any,
+    Deque,
+    FrozenSet,
+    List,
+    Mapping,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    Union,
+)
+
+from fastapi._compat import may_v1
+from fastapi.types import UnionType
+from pydantic import BaseModel
+from pydantic.version import VERSION as PYDANTIC_VERSION
+from starlette.datastructures import UploadFile
+from typing_extensions import Annotated, get_args, get_origin
+
+# Copy from Pydantic v2, compatible with v1
+if sys.version_info < (3, 9):
+    # Pydantic no longer supports Python 3.8, this might be incorrect, but the code
+    # this is used for is also never reached in this codebase, as it's a copy of
+    # Pydantic's lenient_issubclass, just for compatibility with v1
+    # TODO: remove when dropping support for Python 3.8
+    WithArgsTypes: Tuple[Any, ...] = ()
+elif sys.version_info < (3, 10):
+    WithArgsTypes: tuple[Any, ...] = (typing._GenericAlias, types.GenericAlias)  # type: ignore[attr-defined]
+else:
+    WithArgsTypes: tuple[Any, ...] = (
+        typing._GenericAlias,  # type: ignore[attr-defined]
+        types.GenericAlias,
+        types.UnionType,
+    )  # pyright: ignore[reportAttributeAccessIssue]
+
+PYDANTIC_VERSION_MINOR_TUPLE = tuple(int(x) for x in PYDANTIC_VERSION.split(".")[:2])
+PYDANTIC_V2 = PYDANTIC_VERSION_MINOR_TUPLE[0] == 2
+
+
+sequence_annotation_to_type = {
+    Sequence: list,
+    List: list,
+    list: list,
+    Tuple: tuple,
+    tuple: tuple,
+    Set: set,
+    set: set,
+    FrozenSet: frozenset,
+    frozenset: frozenset,
+    Deque: deque,
+    deque: deque,
+}
+
+sequence_types = tuple(sequence_annotation_to_type.keys())
+
+Url: Type[Any]
+
+
+# Copy of Pydantic v2, compatible with v1
+def lenient_issubclass(
+    cls: Any, class_or_tuple: Union[Type[Any], Tuple[Type[Any], ...], None]
+) -> bool:
+    try:
+        return isinstance(cls, type) and issubclass(cls, class_or_tuple)  # type: ignore[arg-type]
+    except TypeError:  # pragma: no cover
+        if isinstance(cls, WithArgsTypes):
+            return False
+        raise  # pragma: no cover
+
+
+def _annotation_is_sequence(annotation: Union[Type[Any], None]) -> bool:
+    if lenient_issubclass(annotation, (str, bytes)):
+        return False
+    return lenient_issubclass(annotation, sequence_types)  # type: ignore[arg-type]
+
+
+def field_annotation_is_sequence(annotation: Union[Type[Any], None]) -> bool:
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        for arg in get_args(annotation):
+            if field_annotation_is_sequence(arg):
+                return True
+        return False
+    return _annotation_is_sequence(annotation) or _annotation_is_sequence(
+        get_origin(annotation)
+    )
+
+
+def value_is_sequence(value: Any) -> bool:
+    return isinstance(value, sequence_types) and not isinstance(value, (str, bytes))  # type: ignore[arg-type]
+
+
+def _annotation_is_complex(annotation: Union[Type[Any], None]) -> bool:
+    return (
+        lenient_issubclass(
+            annotation, (BaseModel, may_v1.BaseModel, Mapping, UploadFile)
+        )
+        or _annotation_is_sequence(annotation)
+        or is_dataclass(annotation)
+    )
+
+
+def field_annotation_is_complex(annotation: Union[Type[Any], None]) -> bool:
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        return any(field_annotation_is_complex(arg) for arg in get_args(annotation))
+
+    if origin is Annotated:
+        return field_annotation_is_complex(get_args(annotation)[0])
+
+    return (
+        _annotation_is_complex(annotation)
+        or _annotation_is_complex(origin)
+        or hasattr(origin, "__pydantic_core_schema__")
+        or hasattr(origin, "__get_pydantic_core_schema__")
+    )
+
+
+def field_annotation_is_scalar(annotation: Any) -> bool:
+    # handle Ellipsis here to make tuple[int, ...] work nicely
+    return annotation is Ellipsis or not field_annotation_is_complex(annotation)
+
+
+def field_annotation_is_scalar_sequence(annotation: Union[Type[Any], None]) -> bool:
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        at_least_one_scalar_sequence = False
+        for arg in get_args(annotation):
+            if field_annotation_is_scalar_sequence(arg):
+                at_least_one_scalar_sequence = True
+                continue
+            elif not field_annotation_is_scalar(arg):
+                return False
+        return at_least_one_scalar_sequence
+    return field_annotation_is_sequence(annotation) and all(
+        field_annotation_is_scalar(sub_annotation)
+        for sub_annotation in get_args(annotation)
+    )
+
+
+def is_bytes_or_nonable_bytes_annotation(annotation: Any) -> bool:
+    if lenient_issubclass(annotation, bytes):
+        return True
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        for arg in get_args(annotation):
+            if lenient_issubclass(arg, bytes):
+                return True
+    return False
+
+
+def is_uploadfile_or_nonable_uploadfile_annotation(annotation: Any) -> bool:
+    if lenient_issubclass(annotation, UploadFile):
+        return True
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        for arg in get_args(annotation):
+            if lenient_issubclass(arg, UploadFile):
+                return True
+    return False
+
+
+def is_bytes_sequence_annotation(annotation: Any) -> bool:
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        at_least_one = False
+        for arg in get_args(annotation):
+            if is_bytes_sequence_annotation(arg):
+                at_least_one = True
+                continue
+        return at_least_one
+    return field_annotation_is_sequence(annotation) and all(
+        is_bytes_or_nonable_bytes_annotation(sub_annotation)
+        for sub_annotation in get_args(annotation)
+    )
+
+
+def is_uploadfile_sequence_annotation(annotation: Any) -> bool:
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        at_least_one = False
+        for arg in get_args(annotation):
+            if is_uploadfile_sequence_annotation(arg):
+                at_least_one = True
+                continue
+        return at_least_one
+    return field_annotation_is_sequence(annotation) and all(
+        is_uploadfile_or_nonable_uploadfile_annotation(sub_annotation)
+        for sub_annotation in get_args(annotation)
+    )
+
+
+def annotation_is_pydantic_v1(annotation: Any) -> bool:
+    if lenient_issubclass(annotation, may_v1.BaseModel):
+        return True
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        for arg in get_args(annotation):
+            if lenient_issubclass(arg, may_v1.BaseModel):
+                return True
+    if field_annotation_is_sequence(annotation):
+        for sub_annotation in get_args(annotation):
+            if annotation_is_pydantic_v1(sub_annotation):
+                return True
+    return False

fastapi/_compat/v1.py

@@ -0,0 +1,312 @@
+from copy import copy
+from dataclasses import dataclass, is_dataclass
+from enum import Enum
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    Union,
+)
+
+from fastapi._compat import shared
+from fastapi.openapi.constants import REF_PREFIX as REF_PREFIX
+from fastapi.types import ModelNameMap
+from pydantic.version import VERSION as PYDANTIC_VERSION
+from typing_extensions import Literal
+
+PYDANTIC_VERSION_MINOR_TUPLE = tuple(int(x) for x in PYDANTIC_VERSION.split(".")[:2])
+PYDANTIC_V2 = PYDANTIC_VERSION_MINOR_TUPLE[0] == 2
+# Keeping old "Required" functionality from Pydantic V1, without
+# shadowing typing.Required.
+RequiredParam: Any = Ellipsis
+
+if not PYDANTIC_V2:
+    from pydantic import BaseConfig as BaseConfig
+    from pydantic import BaseModel as BaseModel
+    from pydantic import ValidationError as ValidationError
+    from pydantic import create_model as create_model
+    from pydantic.class_validators import Validator as Validator
+    from pydantic.color import Color as Color
+    from pydantic.error_wrappers import ErrorWrapper as ErrorWrapper
+    from pydantic.errors import MissingError
+    from pydantic.fields import (  # type: ignore[attr-defined]
+        SHAPE_FROZENSET,
+        SHAPE_LIST,
+        SHAPE_SEQUENCE,
+        SHAPE_SET,
+        SHAPE_SINGLETON,
+        SHAPE_TUPLE,
+        SHAPE_TUPLE_ELLIPSIS,
+    )
+    from pydantic.fields import FieldInfo as FieldInfo
+    from pydantic.fields import ModelField as ModelField  # type: ignore[attr-defined]
+    from pydantic.fields import Undefined as Undefined  # type: ignore[attr-defined]
+    from pydantic.fields import (  # type: ignore[attr-defined]
+        UndefinedType as UndefinedType,
+    )
+    from pydantic.networks import AnyUrl as AnyUrl
+    from pydantic.networks import NameEmail as NameEmail
+    from pydantic.schema import TypeModelSet as TypeModelSet
+    from pydantic.schema import (
+        field_schema,
+        model_process_schema,
+    )
+    from pydantic.schema import (
+        get_annotation_from_field_info as get_annotation_from_field_info,
+    )
+    from pydantic.schema import get_flat_models_from_field as get_flat_models_from_field
+    from pydantic.schema import (
+        get_flat_models_from_fields as get_flat_models_from_fields,
+    )
+    from pydantic.schema import get_model_name_map as get_model_name_map
+    from pydantic.types import SecretBytes as SecretBytes
+    from pydantic.types import SecretStr as SecretStr
+    from pydantic.typing import evaluate_forwardref as evaluate_forwardref
+    from pydantic.utils import lenient_issubclass as lenient_issubclass
+
+
+else:
+    from pydantic.v1 import BaseConfig as BaseConfig  # type: ignore[assignment]
+    from pydantic.v1 import BaseModel as BaseModel  # type: ignore[assignment]
+    from pydantic.v1 import (  # type: ignore[assignment]
+        ValidationError as ValidationError,
+    )
+    from pydantic.v1 import create_model as create_model  # type: ignore[no-redef]
+    from pydantic.v1.class_validators import Validator as Validator
+    from pydantic.v1.color import Color as Color  # type: ignore[assignment]
+    from pydantic.v1.error_wrappers import ErrorWrapper as ErrorWrapper
+    from pydantic.v1.errors import MissingError
+    from pydantic.v1.fields import (
+        SHAPE_FROZENSET,
+        SHAPE_LIST,
+        SHAPE_SEQUENCE,
+        SHAPE_SET,
+        SHAPE_SINGLETON,
+        SHAPE_TUPLE,
+        SHAPE_TUPLE_ELLIPSIS,
+    )
+    from pydantic.v1.fields import FieldInfo as FieldInfo  # type: ignore[assignment]
+    from pydantic.v1.fields import ModelField as ModelField
+    from pydantic.v1.fields import Undefined as Undefined
+    from pydantic.v1.fields import UndefinedType as UndefinedType
+    from pydantic.v1.networks import AnyUrl as AnyUrl
+    from pydantic.v1.networks import (  # type: ignore[assignment]
+        NameEmail as NameEmail,
+    )
+    from pydantic.v1.schema import TypeModelSet as TypeModelSet
+    from pydantic.v1.schema import (
+        field_schema,
+        model_process_schema,
+    )
+    from pydantic.v1.schema import (
+        get_annotation_from_field_info as get_annotation_from_field_info,
+    )
+    from pydantic.v1.schema import (
+        get_flat_models_from_field as get_flat_models_from_field,
+    )
+    from pydantic.v1.schema import (
+        get_flat_models_from_fields as get_flat_models_from_fields,
+    )
+    from pydantic.v1.schema import get_model_name_map as get_model_name_map
+    from pydantic.v1.types import (  # type: ignore[assignment]
+        SecretBytes as SecretBytes,
+    )
+    from pydantic.v1.types import (  # type: ignore[assignment]
+        SecretStr as SecretStr,
+    )
+    from pydantic.v1.typing import evaluate_forwardref as evaluate_forwardref
+    from pydantic.v1.utils import lenient_issubclass as lenient_issubclass
+
+
+GetJsonSchemaHandler = Any
+JsonSchemaValue = Dict[str, Any]
+CoreSchema = Any
+Url = AnyUrl
+
+sequence_shapes = {
+    SHAPE_LIST,
+    SHAPE_SET,
+    SHAPE_FROZENSET,
+    SHAPE_TUPLE,
+    SHAPE_SEQUENCE,
+    SHAPE_TUPLE_ELLIPSIS,
+}
+sequence_shape_to_type = {
+    SHAPE_LIST: list,
+    SHAPE_SET: set,
+    SHAPE_TUPLE: tuple,
+    SHAPE_SEQUENCE: list,
+    SHAPE_TUPLE_ELLIPSIS: list,
+}
+
+
+@dataclass
+class GenerateJsonSchema:
+    ref_template: str
+
+
+class PydanticSchemaGenerationError(Exception):
+    pass
+
+
+RequestErrorModel: Type[BaseModel] = create_model("Request")
+
+
+def with_info_plain_validator_function(
+    function: Callable[..., Any],
+    *,
+    ref: Union[str, None] = None,
+    metadata: Any = None,
+    serialization: Any = None,
+) -> Any:
+    return {}
+
+
+def get_model_definitions(
+    *,
+    flat_models: Set[Union[Type[BaseModel], Type[Enum]]],
+    model_name_map: Dict[Union[Type[BaseModel], Type[Enum]], str],
+) -> Dict[str, Any]:
+    definitions: Dict[str, Dict[str, Any]] = {}
+    for model in flat_models:
+        m_schema, m_definitions, m_nested_models = model_process_schema(
+            model, model_name_map=model_name_map, ref_prefix=REF_PREFIX
+        )
+        definitions.update(m_definitions)
+        model_name = model_name_map[model]
+        definitions[model_name] = m_schema
+    for m_schema in definitions.values():
+        if "description" in m_schema:
+            m_schema["description"] = m_schema["description"].split("\f")[0]
+    return definitions
+
+
+def is_pv1_scalar_field(field: ModelField) -> bool:
+    from fastapi import params
+
+    field_info = field.field_info
+    if not (
+        field.shape == SHAPE_SINGLETON
+        and not lenient_issubclass(field.type_, BaseModel)
+        and not lenient_issubclass(field.type_, dict)
+        and not shared.field_annotation_is_sequence(field.type_)
+        and not is_dataclass(field.type_)
+        and not isinstance(field_info, params.Body)
+    ):
+        return False
+    if field.sub_fields:
+        if not all(is_pv1_scalar_field(f) for f in field.sub_fields):
+            return False
+    return True
+
+
+def is_pv1_scalar_sequence_field(field: ModelField) -> bool:
+    if (field.shape in sequence_shapes) and not lenient_issubclass(
+        field.type_, BaseModel
+    ):
+        if field.sub_fields is not None:
+            for sub_field in field.sub_fields:
+                if not is_pv1_scalar_field(sub_field):
+                    return False
+        return True
+    if shared._annotation_is_sequence(field.type_):
+        return True
+    return False
+
+
+def _model_rebuild(model: Type[BaseModel]) -> None:
+    model.update_forward_refs()
+
+
+def _model_dump(
+    model: BaseModel, mode: Literal["json", "python"] = "json", **kwargs: Any
+) -> Any:
+    return model.dict(**kwargs)
+
+
+def _get_model_config(model: BaseModel) -> Any:
+    return model.__config__  # type: ignore[attr-defined]
+
+
+def get_schema_from_model_field(
+    *,
+    field: ModelField,
+    model_name_map: ModelNameMap,
+    field_mapping: Dict[
+        Tuple[ModelField, Literal["validation", "serialization"]], JsonSchemaValue
+    ],
+    separate_input_output_schemas: bool = True,
+) -> Dict[str, Any]:
+    return field_schema(  # type: ignore[no-any-return]
+        field, model_name_map=model_name_map, ref_prefix=REF_PREFIX
+    )[0]
+
+
+# def get_compat_model_name_map(fields: List[ModelField]) -> ModelNameMap:
+#     models = get_flat_models_from_fields(fields, known_models=set())
+#     return get_model_name_map(models)  # type: ignore[no-any-return]
+
+
+def get_definitions(
+    *,
+    fields: List[ModelField],
+    model_name_map: ModelNameMap,
+    separate_input_output_schemas: bool = True,
+) -> Tuple[
+    Dict[Tuple[ModelField, Literal["validation", "serialization"]], JsonSchemaValue],
+    Dict[str, Dict[str, Any]],
+]:
+    models = get_flat_models_from_fields(fields, known_models=set())
+    return {}, get_model_definitions(flat_models=models, model_name_map=model_name_map)
+
+
+def is_scalar_field(field: ModelField) -> bool:
+    return is_pv1_scalar_field(field)
+
+
+def is_sequence_field(field: ModelField) -> bool:
+    return field.shape in sequence_shapes or shared._annotation_is_sequence(field.type_)
+
+
+def is_scalar_sequence_field(field: ModelField) -> bool:
+    return is_pv1_scalar_sequence_field(field)
+
+
+def is_bytes_field(field: ModelField) -> bool:
+    return lenient_issubclass(field.type_, bytes)  # type: ignore[no-any-return]
+
+
+def is_bytes_sequence_field(field: ModelField) -> bool:
+    return field.shape in sequence_shapes and lenient_issubclass(field.type_, bytes)
+
+
+def copy_field_info(*, field_info: FieldInfo, annotation: Any) -> FieldInfo:
+    return copy(field_info)
+
+
+def serialize_sequence_value(*, field: ModelField, value: Any) -> Sequence[Any]:
+    return sequence_shape_to_type[field.shape](value)  # type: ignore[no-any-return]
+
+
+def get_missing_field_error(loc: Tuple[str, ...]) -> Dict[str, Any]:
+    missing_field_error = ErrorWrapper(MissingError(), loc=loc)
+    new_error = ValidationError([missing_field_error], RequestErrorModel)
+    return new_error.errors()[0]  # type: ignore[return-value]
+
+
+def create_body_model(
+    *, fields: Sequence[ModelField], model_name: str
+) -> Type[BaseModel]:
+    BodyModel = create_model(model_name)
+    for f in fields:
+        BodyModel.__fields__[f.name] = f  # type: ignore[index]
+    return BodyModel
+
+
+def get_model_fields(model: Type[BaseModel]) -> List[ModelField]:
+    return list(model.__fields__.values())  # type: ignore[attr-defined]