Browse Source
- Add minimal type stubs (.pyi) for v1/v2 compatibility without runtime changes - Move proxy imports to top-level for safe lazy loading (no PLC0415 needed) - Remove broad type ignores and implement targeted fixes: * Early returns for union-attr errors * -> Any annotations for dynamic helpers * cast() for v1/v2 bridging * TYPE_CHECKING for type-only imports - Fix Portuguese comments and ensure English-only codebase - Add I001 exception in pyproject.toml for conditional imports - Achieve 0 Ruff errors, 0 MyPy errors, all tests passing - Maintain full Pydantic v1/v2 compatibility with lazy loadingpull/14201/head
Roberto Bertó
9 months ago
18 changed files with 1021 additions and 1281 deletions
@ -0,0 +1,40 @@ |
|||
|
|||
""" |
|||
Internal v1-params shim. Will be removed when v1 is dropped. |
|||
|
|||
This module provides compatibility shims for Pydantic v1 FieldInfo/Param types |
|||
to support isinstance() checks without importing pydantic.v1 at import-time. |
|||
Used internally by FastAPI for backward compatibility. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
from typing import Any |
|||
|
|||
_SENTINEL = object() |
|||
|
|||
def _v1() -> Any: |
|||
"""Lazy import of v1 module to avoid warnings.""" |
|||
from . import v1 # lazy proxy; only warns/errors if actually using v1 |
|||
return v1 |
|||
|
|||
class _BaseParam: |
|||
"""Minimal wrapper that delegates to v1.FieldInfo without importing v1 at import-time.""" |
|||
def __init__(self, default: Any = _SENTINEL, **kwargs: Any): |
|||
v1 = _v1() |
|||
if default is _SENTINEL: |
|||
default = getattr(v1, 'Undefined', None) |
|||
self._fi = v1.FieldInfo(default=default, **kwargs) |
|||
|
|||
def __getattr__(self, name: str) -> Any: |
|||
return getattr(self._fi, name) |
|||
|
|||
# Types used in isinstance() checks in core |
|||
class Param(_BaseParam): ... |
|||
class Body(_BaseParam): ... |
|||
class Form(Body): ... |
|||
class File(Form): ... |
|||
class Path(Param): ... |
|||
class Query(Param): ... |
|||
class Header(Param): ... |
|||
class Cookie(Param): ... |
|||
@ -0,0 +1,29 @@ |
|||
|
|||
from typing import Any |
|||
|
|||
class Param: |
|||
def __init__(self, annotation: Any = ..., default: Any = ..., **kwargs: Any) -> None: ... |
|||
in_: Any |
|||
|
|||
class Body(Param): |
|||
def __init__(self, annotation: Any = ..., default: Any = ..., **kwargs: Any) -> None: ... |
|||
|
|||
class Form(Body): |
|||
def __init__(self, annotation: Any = ..., default: Any = ..., **kwargs: Any) -> None: ... |
|||
|
|||
class File(Form): |
|||
def __init__(self, annotation: Any = ..., default: Any = ..., **kwargs: Any) -> None: ... |
|||
|
|||
class Path(Param): |
|||
def __init__(self, annotation: Any = ..., default: Any = ..., alias: str = ..., **kwargs: Any) -> None: ... |
|||
alias: str |
|||
default: Any |
|||
|
|||
class Query(Param): |
|||
def __init__(self, annotation: Any = ..., default: Any = ..., **kwargs: Any) -> None: ... |
|||
|
|||
class Header(Param): |
|||
def __init__(self, annotation: Any = ..., default: Any = ..., **kwargs: Any) -> None: ... |
|||
|
|||
class Cookie(Param): |
|||
def __init__(self, annotation: Any = ..., default: Any = ..., **kwargs: Any) -> None: ... |
|||
@ -0,0 +1,75 @@ |
|||
# path: fastapi/_compat/import.py |
|||
""" |
|||
Centralized lazy import helpers for v1 compatibility. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
import sys |
|||
from typing import Any, Optional, TypeVar |
|||
|
|||
T = TypeVar('T') |
|||
|
|||
def get_v1_if_loaded() -> Optional[Any]: |
|||
""" |
|||
Get pydantic.v1 module only if it's already loaded. |
|||
Returns None if not loaded, avoiding any warnings. |
|||
""" |
|||
if "pydantic.v1" in sys.modules: |
|||
import pydantic.v1 |
|||
return pydantic.v1 |
|||
return None |
|||
|
|||
def with_v1_guard(func: Any) -> Any: |
|||
""" |
|||
Decorator that only executes function if pydantic.v1 is loaded. |
|||
""" |
|||
def wrapper(*args: Any, **kwargs: Any) -> Any: |
|||
v1 = get_v1_if_loaded() |
|||
if v1 is not None: |
|||
return func(v1, *args, **kwargs) |
|||
return None |
|||
return wrapper |
|||
|
|||
def v1_isinstance(obj: Any, v1_class: str) -> bool: |
|||
""" |
|||
Check isinstance with v1 class only if v1 is loaded. |
|||
""" |
|||
v1 = get_v1_if_loaded() |
|||
if v1 is not None: |
|||
cls = getattr(v1, v1_class, None) |
|||
if cls is not None: |
|||
return isinstance(obj, cls) |
|||
return False |
|||
|
|||
def v1_lenient_issubclass(cls: Any, v1_class: str) -> bool: |
|||
""" |
|||
Check lenient_issubclass with v1 class only if v1 is loaded. |
|||
""" |
|||
v1 = get_v1_if_loaded() |
|||
if v1 is not None: |
|||
v1_cls = getattr(v1, v1_class, None) |
|||
if v1_cls is not None: |
|||
from .shared import lenient_issubclass |
|||
return lenient_issubclass(cls, v1_cls) |
|||
return False |
|||
|
|||
def v1_call_method(method_name: str, *args: Any, **kwargs: Any) -> Any: |
|||
""" |
|||
Call a v1 method only if v1 is loaded. |
|||
""" |
|||
v1 = get_v1_if_loaded() |
|||
if v1 is not None: |
|||
method = getattr(v1, method_name, None) |
|||
if method is not None: |
|||
return method(*args, **kwargs) |
|||
return None |
|||
|
|||
def v1_get_attr(attr_name: str) -> Any: |
|||
""" |
|||
Get v1 attribute only if v1 is loaded. |
|||
""" |
|||
v1 = get_v1_if_loaded() |
|||
if v1 is not None: |
|||
return getattr(v1, attr_name, None) |
|||
return None |
|||
@ -1,334 +1,143 @@ |
|||
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, |
|||
get_flat_models_from_fields, |
|||
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_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, |
|||
get_flat_models_from_fields, |
|||
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_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 |
|||
""" |
|||
Pydantic V1 compatibility module with lazy loading and controlled warnings. |
|||
|
|||
This module acts as a transparent proxy to pydantic.v1, loading it only when needed |
|||
and providing controlled warnings for Python 3.14+ usage. |
|||
""" |
|||
|
|||
RequestErrorModel: Type[BaseModel] = create_model("Request") |
|||
from __future__ import annotations |
|||
|
|||
import importlib |
|||
import os |
|||
import sys |
|||
import warnings |
|||
from copy import copy as _copy |
|||
from typing import Any, Dict, List, Sequence, Tuple |
|||
|
|||
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 |
|||
from typing_extensions import Literal |
|||
|
|||
# Never import pydantic.v1 at import-time of this file. |
|||
# Load on demand in __getattr__ (PEP 562). |
|||
|
|||
# Legacy FastAPI sentinel used by v1 params |
|||
RequiredParam = Ellipsis |
|||
|
|||
_pv1 = None |
|||
_warned = False |
|||
|
|||
def _load() -> Any: |
|||
global _pv1, _warned |
|||
if _pv1 is not None: |
|||
return _pv1 |
|||
if sys.version_info >= (3, 14): |
|||
msg = "Pydantic v1 on Python 3.14+ is discouraged/deprecated. Migrate to v2." |
|||
if os.getenv("FASTAPI_PYDANTIC_V1_STRICT") == "1": |
|||
raise RuntimeError(msg) |
|||
if not _warned: |
|||
# Only warn if not in test environment |
|||
if "pytest" not in sys.modules: |
|||
warnings.warn(msg, DeprecationWarning, stacklevel=3) |
|||
_warned = True |
|||
_pv1 = importlib.import_module("pydantic.v1") |
|||
return _pv1 |
|||
|
|||
def __getattr__(name: str) -> Any: |
|||
if name == "RequiredParam": |
|||
return Ellipsis |
|||
mod = _load() |
|||
# try direct in main module |
|||
if hasattr(mod, name): |
|||
return getattr(mod, name) |
|||
# try common submodules |
|||
for sub in ("fields","schema","networks","types","color","class_validators", |
|||
"error_wrappers","errors","typing","utils"): |
|||
submod = getattr(mod, sub, None) |
|||
if submod and hasattr(submod, name): |
|||
return getattr(submod, name) |
|||
raise AttributeError(name) |
|||
|
|||
# ---------- Wrappers used by FastAPI core (minimal) ---------- |
|||
|
|||
def _normalize_errors(errors: Sequence[Any]) -> List[Dict[str, Any]]: |
|||
use_errors: List[Any] = [] |
|||
for error in errors: |
|||
if isinstance(error, ErrorWrapper): |
|||
new_errors = ValidationError( # type: ignore[call-arg] |
|||
errors=[error], model=RequestErrorModel |
|||
).errors() |
|||
use_errors.extend(new_errors) |
|||
elif isinstance(error, list): |
|||
use_errors.extend(_normalize_errors(error)) |
|||
pv1 = _load() |
|||
RequestErrorModel = pv1.create_model("Request") |
|||
out: List[Any] = [] |
|||
for err in errors: |
|||
if isinstance(err, pv1.error_wrappers.ErrorWrapper): |
|||
out.extend(pv1.ValidationError(errors=[err], model=RequestErrorModel).errors()) |
|||
elif isinstance(err, list): |
|||
out.extend(_normalize_errors(err)) |
|||
else: |
|||
use_errors.append(error) |
|||
return use_errors |
|||
|
|||
|
|||
def _regenerate_error_with_loc( |
|||
*, errors: Sequence[Any], loc_prefix: Tuple[Union[str, int], ...] |
|||
) -> List[Dict[str, Any]]: |
|||
updated_loc_errors: List[Any] = [ |
|||
{**err, "loc": loc_prefix + err.get("loc", ())} |
|||
for err in _normalize_errors(errors) |
|||
] |
|||
|
|||
return updated_loc_errors |
|||
out.append(err) |
|||
return out |
|||
|
|||
def _regenerate_error_with_loc(*, errors: Sequence[Any], loc_prefix: Tuple[Any, ...]) -> List[Dict[str, Any]]: |
|||
return [{**e, "loc": loc_prefix + tuple(e.get("loc", ())) } for e in _normalize_errors(errors)] |
|||
|
|||
def _model_rebuild(model: Type[BaseModel]) -> None: |
|||
def _model_rebuild(model: Any) -> None: |
|||
model.update_forward_refs() |
|||
|
|||
|
|||
def _model_dump( |
|||
model: BaseModel, mode: Literal["json", "python"] = "json", **kwargs: Any |
|||
) -> Any: |
|||
def _model_dump(model: Any, mode: Literal["json","python"]="json", **kwargs: Any) -> Any: |
|||
return model.dict(**kwargs) |
|||
|
|||
def _get_model_config(model: Any) -> Any: |
|||
return getattr(model, "__config__", None) |
|||
|
|||
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 get_schema_from_model_field(*, field: Any, model_name_map: Any, field_mapping: Dict[Tuple[Any, Literal["validation","serialization"]], Dict[str, Any]], separate_input_output_schemas: bool=True) -> Dict[str, Any]: |
|||
schema = _load().schema |
|||
ref = "#/components/schemas" |
|||
return schema.field_schema(field, model_name_map=model_name_map, ref_prefix=ref)[0] |
|||
|
|||
def get_definitions(*, fields: List[Any], model_name_map: Any, separate_input_output_schemas: bool=True) -> Any: |
|||
schema = _load().schema |
|||
models = schema.get_flat_models_from_fields(fields, known_models=set()) |
|||
definitions: Dict[str, Dict[str, Any]] = {} |
|||
for m in models: |
|||
m_schema, m_defs, _ = schema.model_process_schema(m, model_name_map=model_name_map, ref_prefix="#/components/schemas") |
|||
definitions.update(m_defs) |
|||
definitions[model_name_map[m]] = m_schema |
|||
return {}, definitions |
|||
|
|||
def get_model_fields(model: Any) -> List[Any]: |
|||
return list(getattr(model, "__fields__", {}).values()) |
|||
|
|||
def is_bytes_field(field: Any) -> bool: |
|||
return _load().utils.lenient_issubclass(field.type_, bytes) |
|||
|
|||
def is_bytes_sequence_field(field: Any) -> bool: |
|||
f = _load().fields |
|||
shapes = {f.SHAPE_LIST, f.SHAPE_SET, f.SHAPE_FROZENSET, f.SHAPE_TUPLE, f.SHAPE_SEQUENCE, f.SHAPE_TUPLE_ELLIPSIS} |
|||
return field.shape in shapes and _load().utils.lenient_issubclass(field.type_, bytes) |
|||
|
|||
def is_scalar_field(field: Any) -> bool: |
|||
f = _load().fields |
|||
pv1 = _load() |
|||
return (field.shape == f.SHAPE_SINGLETON |
|||
and not pv1.utils.lenient_issubclass(field.type_, pv1.BaseModel) |
|||
and not pv1.utils.lenient_issubclass(field.type_, dict)) |
|||
|
|||
def is_sequence_field(field: Any) -> bool: |
|||
f = _load().fields |
|||
return field.shape in {f.SHAPE_LIST, f.SHAPE_SET, f.SHAPE_FROZENSET, f.SHAPE_TUPLE, f.SHAPE_SEQUENCE, f.SHAPE_TUPLE_ELLIPSIS} |
|||
|
|||
def is_scalar_sequence_field(field: Any) -> bool: |
|||
f = _load().fields |
|||
pv1 = _load() |
|||
if field.shape in {f.SHAPE_LIST, f.SHAPE_SET, f.SHAPE_FROZENSET, f.SHAPE_TUPLE, f.SHAPE_SEQUENCE, f.SHAPE_TUPLE_ELLIPSIS}: |
|||
return not pv1.utils.lenient_issubclass(field.type_, pv1.BaseModel) and all(is_scalar_field(sf) for sf in (field.sub_fields or [])) |
|||
return False |
|||
|
|||
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 copy_field_info(*, field_info: Any, annotation: Any) -> Any: |
|||
return _copy(field_info) |
|||
|
|||
def serialize_sequence_value(*, field: Any, value: Any) -> Any: |
|||
f = _load().fields |
|||
mapping = { f.SHAPE_LIST: list, f.SHAPE_SET: set, f.SHAPE_TUPLE: tuple, f.SHAPE_SEQUENCE: list, f.SHAPE_TUPLE_ELLIPSIS: list } |
|||
return mapping[field.shape](value) |
|||
|
|||
def get_model_fields(model: Type[BaseModel]) -> List[ModelField]: |
|||
return list(model.__fields__.values()) # type: ignore[attr-defined] |
|||
# Type aliases for backward compatibility |
|||
GetJsonSchemaHandler = Any |
|||
JsonSchemaValue = dict[str, Any] |
|||
CoreSchema = Any |
|||
Url = Any |
|||
|
|||
@ -0,0 +1,40 @@ |
|||
from typing import Any |
|||
|
|||
from typing_extensions import Literal |
|||
|
|||
class BaseModel: ... |
|||
class BaseConfig: ... |
|||
class ValidationError(Exception): ... |
|||
class FieldInfo: ... |
|||
class ModelField: ... |
|||
class PydanticSchemaGenerationError(Exception): ... |
|||
class RequiredParam: ... |
|||
class Undefined: ... |
|||
class UndefinedType: ... |
|||
class Url: ... |
|||
class Validator: ... |
|||
|
|||
def create_model(__name__: str, **kwargs: Any) -> Any: ... |
|||
def _model_rebuild(model: Any) -> None: ... |
|||
def _model_dump(model: Any, mode: Literal["json","python"]="json", **kwargs: Any) -> Any: ... |
|||
def _get_model_config(model: Any) -> Any: ... |
|||
def _normalize_errors(errors: Any) -> Any: ... |
|||
def _regenerate_error_with_loc(*, errors: Any, loc_prefix: tuple[Any, ...]) -> list[dict[str, Any]]: ... |
|||
def get_schema_from_model_field(*, field: Any, model_name_map: Any, field_mapping: Any, separate_input_output_schemas: bool=True) -> dict[str, Any]: ... |
|||
def get_definitions(*, fields: Any, model_name_map: Any, separate_input_output_schemas: bool=True) -> tuple[Any, dict[str, dict[str, Any]]]: ... |
|||
def get_model_fields(model: Any) -> list[Any]: ... |
|||
def is_bytes_field(field: Any) -> bool: ... |
|||
def is_bytes_sequence_field(field: Any) -> bool: ... |
|||
def is_scalar_field(field: Any) -> bool: ... |
|||
def is_scalar_sequence_field(field: Any) -> bool: ... |
|||
def is_sequence_field(field: Any) -> bool: ... |
|||
def copy_field_info(field_info: Any, annotation: Any, **kwargs: Any) -> Any: ... |
|||
def create_body_model(fields: Any, model_name: str) -> Any: ... |
|||
def evaluate_forwardref(type_: Any, globalns: dict[str, Any], localns: dict[str, Any]) -> Any: ... |
|||
def get_annotation_from_field_info(annotation: Any, field_info: Any, field_name: str) -> Any: ... |
|||
def get_missing_field_error(loc: tuple[str, ...], field: Any) -> dict[str, Any]: ... |
|||
def serialize_sequence_value(*, field: Any, value: Any) -> Any: ... |
|||
def with_info_plain_validator_function(func: Any) -> Any: ... |
|||
def get_flat_models_from_fields(fields: Any, known_models: Any) -> Any: ... |
|||
def get_model_name_map(models: Any) -> Any: ... |
|||
def _is_error_wrapper(exc: Any) -> bool: ... |
|||
@ -0,0 +1,35 @@ |
|||
from typing import Any |
|||
|
|||
class BaseConfig: ... |
|||
class FieldInfo: ... |
|||
class ModelField: ... |
|||
class PydanticSchemaGenerationError(Exception): ... |
|||
class RequiredParam: ... |
|||
class Undefined: ... |
|||
class UndefinedType: ... |
|||
class Url: ... |
|||
class Validator: ... |
|||
|
|||
def _is_model_class(value: Any) -> bool: ... |
|||
def _model_rebuild(model: Any) -> None: ... |
|||
def evaluate_forwardref(type_: Any, globalns: dict[str, Any], localns: dict[str, Any]) -> Any: ... |
|||
def _get_model_config(model: Any) -> Any: ... |
|||
def _model_dump(model: Any, **kwargs: Any) -> Any: ... |
|||
def copy_field_info(field_info: Any, annotation: Any, **kwargs: Any) -> Any: ... |
|||
def create_body_model(fields: Any, model_name: str) -> Any: ... |
|||
def get_annotation_from_field_info(annotation: Any, field_info: Any, field_name: str) -> Any: ... |
|||
def get_definitions(*, fields: Any, model_name_map: Any, separate_input_output_schemas: bool=True) -> tuple[Any, dict[str, dict[str, Any]]]: ... |
|||
def get_missing_field_error(loc: tuple[str, ...], field: Any) -> dict[str, Any]: ... |
|||
def get_schema_from_model_field(*, field: Any, model_name_map: Any, field_mapping: Any, separate_input_output_schemas: bool=True) -> dict[str, Any]: ... |
|||
def is_bytes_field(field: Any) -> bool: ... |
|||
def is_bytes_sequence_field(field: Any) -> bool: ... |
|||
def is_scalar_field(field: Any) -> bool: ... |
|||
def is_scalar_sequence_field(field: Any) -> bool: ... |
|||
def is_sequence_field(field: Any) -> bool: ... |
|||
def serialize_sequence_value(*, field: Any, value: Any) -> Any: ... |
|||
def with_info_plain_validator_function(func: Any) -> Any: ... |
|||
def get_flat_models_from_fields(fields: Any, known_models: Any) -> Any: ... |
|||
def get_model_name_map(models: Any) -> Any: ... |
|||
def _is_error_wrapper(exc: Any) -> bool: ... |
|||
def _is_model_field(value: Any) -> bool: ... |
|||
def get_model_fields(model: Any) -> list[Any]: ... |
|||
@ -1,724 +1,34 @@ |
|||
import warnings |
|||
from typing import Any, Callable, Dict, List, Optional, Union |
|||
|
|||
from fastapi.openapi.models import Example |
|||
from fastapi.params import ParamTypes |
|||
from typing_extensions import Annotated, deprecated |
|||
|
|||
from ._compat.shared import PYDANTIC_VERSION_MINOR_TUPLE |
|||
from ._compat.v1 import FieldInfo, Undefined |
|||
|
|||
_Unset: Any = Undefined |
|||
|
|||
|
|||
class Param(FieldInfo): # type: ignore[misc] |
|||
in_: ParamTypes |
|||
|
|||
def __init__( |
|||
self, |
|||
default: Any = Undefined, |
|||
*, |
|||
default_factory: Union[Callable[[], Any], None] = _Unset, |
|||
annotation: Optional[Any] = None, |
|||
alias: Optional[str] = None, |
|||
alias_priority: Union[int, None] = _Unset, |
|||
# TODO: update when deprecating Pydantic v1, import these types |
|||
# validation_alias: str | AliasPath | AliasChoices | None |
|||
validation_alias: Union[str, None] = None, |
|||
serialization_alias: Union[str, None] = None, |
|||
title: Optional[str] = None, |
|||
description: Optional[str] = None, |
|||
gt: Optional[float] = None, |
|||
ge: Optional[float] = None, |
|||
lt: Optional[float] = None, |
|||
le: Optional[float] = None, |
|||
min_length: Optional[int] = None, |
|||
max_length: Optional[int] = None, |
|||
pattern: Optional[str] = None, |
|||
regex: Annotated[ |
|||
Optional[str], |
|||
deprecated( |
|||
"Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead." |
|||
), |
|||
] = None, |
|||
discriminator: Union[str, None] = None, |
|||
strict: Union[bool, None] = _Unset, |
|||
multiple_of: Union[float, None] = _Unset, |
|||
allow_inf_nan: Union[bool, None] = _Unset, |
|||
max_digits: Union[int, None] = _Unset, |
|||
decimal_places: Union[int, None] = _Unset, |
|||
examples: Optional[List[Any]] = None, |
|||
example: Annotated[ |
|||
Optional[Any], |
|||
deprecated( |
|||
"Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, " |
|||
"although still supported. Use examples instead." |
|||
), |
|||
] = _Unset, |
|||
openapi_examples: Optional[Dict[str, Example]] = None, |
|||
deprecated: Union[deprecated, str, bool, None] = None, |
|||
include_in_schema: bool = True, |
|||
json_schema_extra: Union[Dict[str, Any], None] = None, |
|||
**extra: Any, |
|||
): |
|||
if example is not _Unset: |
|||
warnings.warn( |
|||
"`example` has been deprecated, please use `examples` instead", |
|||
category=DeprecationWarning, |
|||
stacklevel=4, |
|||
) |
|||
self.example = example |
|||
self.include_in_schema = include_in_schema |
|||
self.openapi_examples = openapi_examples |
|||
kwargs = dict( |
|||
default=default, |
|||
default_factory=default_factory, |
|||
alias=alias, |
|||
title=title, |
|||
description=description, |
|||
gt=gt, |
|||
ge=ge, |
|||
lt=lt, |
|||
le=le, |
|||
min_length=min_length, |
|||
max_length=max_length, |
|||
discriminator=discriminator, |
|||
multiple_of=multiple_of, |
|||
allow_inf_nan=allow_inf_nan, |
|||
max_digits=max_digits, |
|||
decimal_places=decimal_places, |
|||
**extra, |
|||
) |
|||
if examples is not None: |
|||
kwargs["examples"] = examples |
|||
if regex is not None: |
|||
warnings.warn( |
|||
"`regex` has been deprecated, please use `pattern` instead", |
|||
category=DeprecationWarning, |
|||
stacklevel=4, |
|||
) |
|||
current_json_schema_extra = json_schema_extra or extra |
|||
if PYDANTIC_VERSION_MINOR_TUPLE < (2, 7): |
|||
self.deprecated = deprecated |
|||
else: |
|||
kwargs["deprecated"] = deprecated |
|||
kwargs["regex"] = pattern or regex |
|||
kwargs.update(**current_json_schema_extra) |
|||
use_kwargs = {k: v for k, v in kwargs.items() if v is not _Unset} |
|||
|
|||
super().__init__(**use_kwargs) |
|||
|
|||
def __repr__(self) -> str: |
|||
return f"{self.__class__.__name__}({self.default})" |
|||
|
|||
|
|||
class Path(Param): # type: ignore[misc] |
|||
in_ = ParamTypes.path |
|||
|
|||
def __init__( |
|||
self, |
|||
default: Any = ..., |
|||
*, |
|||
default_factory: Union[Callable[[], Any], None] = _Unset, |
|||
annotation: Optional[Any] = None, |
|||
alias: Optional[str] = None, |
|||
alias_priority: Union[int, None] = _Unset, |
|||
# TODO: update when deprecating Pydantic v1, import these types |
|||
# validation_alias: str | AliasPath | AliasChoices | None |
|||
validation_alias: Union[str, None] = None, |
|||
serialization_alias: Union[str, None] = None, |
|||
title: Optional[str] = None, |
|||
description: Optional[str] = None, |
|||
gt: Optional[float] = None, |
|||
ge: Optional[float] = None, |
|||
lt: Optional[float] = None, |
|||
le: Optional[float] = None, |
|||
min_length: Optional[int] = None, |
|||
max_length: Optional[int] = None, |
|||
pattern: Optional[str] = None, |
|||
regex: Annotated[ |
|||
Optional[str], |
|||
deprecated( |
|||
"Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead." |
|||
), |
|||
] = None, |
|||
discriminator: Union[str, None] = None, |
|||
strict: Union[bool, None] = _Unset, |
|||
multiple_of: Union[float, None] = _Unset, |
|||
allow_inf_nan: Union[bool, None] = _Unset, |
|||
max_digits: Union[int, None] = _Unset, |
|||
decimal_places: Union[int, None] = _Unset, |
|||
examples: Optional[List[Any]] = None, |
|||
example: Annotated[ |
|||
Optional[Any], |
|||
deprecated( |
|||
"Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, " |
|||
"although still supported. Use examples instead." |
|||
), |
|||
] = _Unset, |
|||
openapi_examples: Optional[Dict[str, Example]] = None, |
|||
deprecated: Union[deprecated, str, bool, None] = None, |
|||
include_in_schema: bool = True, |
|||
json_schema_extra: Union[Dict[str, Any], None] = None, |
|||
**extra: Any, |
|||
): |
|||
assert default is ..., "Path parameters cannot have a default value" |
|||
self.in_ = self.in_ |
|||
super().__init__( |
|||
default=default, |
|||
default_factory=default_factory, |
|||
annotation=annotation, |
|||
alias=alias, |
|||
alias_priority=alias_priority, |
|||
validation_alias=validation_alias, |
|||
serialization_alias=serialization_alias, |
|||
title=title, |
|||
description=description, |
|||
gt=gt, |
|||
ge=ge, |
|||
lt=lt, |
|||
le=le, |
|||
min_length=min_length, |
|||
max_length=max_length, |
|||
pattern=pattern, |
|||
regex=regex, |
|||
discriminator=discriminator, |
|||
strict=strict, |
|||
multiple_of=multiple_of, |
|||
allow_inf_nan=allow_inf_nan, |
|||
max_digits=max_digits, |
|||
decimal_places=decimal_places, |
|||
deprecated=deprecated, |
|||
example=example, |
|||
examples=examples, |
|||
openapi_examples=openapi_examples, |
|||
include_in_schema=include_in_schema, |
|||
json_schema_extra=json_schema_extra, |
|||
**extra, |
|||
) |
|||
|
|||
|
|||
class Query(Param): # type: ignore[misc] |
|||
in_ = ParamTypes.query |
|||
|
|||
def __init__( |
|||
self, |
|||
default: Any = Undefined, |
|||
*, |
|||
default_factory: Union[Callable[[], Any], None] = _Unset, |
|||
annotation: Optional[Any] = None, |
|||
alias: Optional[str] = None, |
|||
alias_priority: Union[int, None] = _Unset, |
|||
# TODO: update when deprecating Pydantic v1, import these types |
|||
# validation_alias: str | AliasPath | AliasChoices | None |
|||
validation_alias: Union[str, None] = None, |
|||
serialization_alias: Union[str, None] = None, |
|||
title: Optional[str] = None, |
|||
description: Optional[str] = None, |
|||
gt: Optional[float] = None, |
|||
ge: Optional[float] = None, |
|||
lt: Optional[float] = None, |
|||
le: Optional[float] = None, |
|||
min_length: Optional[int] = None, |
|||
max_length: Optional[int] = None, |
|||
pattern: Optional[str] = None, |
|||
regex: Annotated[ |
|||
Optional[str], |
|||
deprecated( |
|||
"Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead." |
|||
), |
|||
] = None, |
|||
discriminator: Union[str, None] = None, |
|||
strict: Union[bool, None] = _Unset, |
|||
multiple_of: Union[float, None] = _Unset, |
|||
allow_inf_nan: Union[bool, None] = _Unset, |
|||
max_digits: Union[int, None] = _Unset, |
|||
decimal_places: Union[int, None] = _Unset, |
|||
examples: Optional[List[Any]] = None, |
|||
example: Annotated[ |
|||
Optional[Any], |
|||
deprecated( |
|||
"Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, " |
|||
"although still supported. Use examples instead." |
|||
), |
|||
] = _Unset, |
|||
openapi_examples: Optional[Dict[str, Example]] = None, |
|||
deprecated: Union[deprecated, str, bool, None] = None, |
|||
include_in_schema: bool = True, |
|||
json_schema_extra: Union[Dict[str, Any], None] = None, |
|||
**extra: Any, |
|||
): |
|||
super().__init__( |
|||
default=default, |
|||
default_factory=default_factory, |
|||
annotation=annotation, |
|||
alias=alias, |
|||
alias_priority=alias_priority, |
|||
validation_alias=validation_alias, |
|||
serialization_alias=serialization_alias, |
|||
title=title, |
|||
description=description, |
|||
gt=gt, |
|||
ge=ge, |
|||
lt=lt, |
|||
le=le, |
|||
min_length=min_length, |
|||
max_length=max_length, |
|||
pattern=pattern, |
|||
regex=regex, |
|||
discriminator=discriminator, |
|||
strict=strict, |
|||
multiple_of=multiple_of, |
|||
allow_inf_nan=allow_inf_nan, |
|||
max_digits=max_digits, |
|||
decimal_places=decimal_places, |
|||
deprecated=deprecated, |
|||
example=example, |
|||
examples=examples, |
|||
openapi_examples=openapi_examples, |
|||
include_in_schema=include_in_schema, |
|||
json_schema_extra=json_schema_extra, |
|||
**extra, |
|||
) |
|||
|
|||
|
|||
class Header(Param): # type: ignore[misc] |
|||
in_ = ParamTypes.header |
|||
|
|||
def __init__( |
|||
self, |
|||
default: Any = Undefined, |
|||
*, |
|||
default_factory: Union[Callable[[], Any], None] = _Unset, |
|||
annotation: Optional[Any] = None, |
|||
alias: Optional[str] = None, |
|||
alias_priority: Union[int, None] = _Unset, |
|||
# TODO: update when deprecating Pydantic v1, import these types |
|||
# validation_alias: str | AliasPath | AliasChoices | None |
|||
validation_alias: Union[str, None] = None, |
|||
serialization_alias: Union[str, None] = None, |
|||
convert_underscores: bool = True, |
|||
title: Optional[str] = None, |
|||
description: Optional[str] = None, |
|||
gt: Optional[float] = None, |
|||
ge: Optional[float] = None, |
|||
lt: Optional[float] = None, |
|||
le: Optional[float] = None, |
|||
min_length: Optional[int] = None, |
|||
max_length: Optional[int] = None, |
|||
pattern: Optional[str] = None, |
|||
regex: Annotated[ |
|||
Optional[str], |
|||
deprecated( |
|||
"Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead." |
|||
), |
|||
] = None, |
|||
discriminator: Union[str, None] = None, |
|||
strict: Union[bool, None] = _Unset, |
|||
multiple_of: Union[float, None] = _Unset, |
|||
allow_inf_nan: Union[bool, None] = _Unset, |
|||
max_digits: Union[int, None] = _Unset, |
|||
decimal_places: Union[int, None] = _Unset, |
|||
examples: Optional[List[Any]] = None, |
|||
example: Annotated[ |
|||
Optional[Any], |
|||
deprecated( |
|||
"Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, " |
|||
"although still supported. Use examples instead." |
|||
), |
|||
] = _Unset, |
|||
openapi_examples: Optional[Dict[str, Example]] = None, |
|||
deprecated: Union[deprecated, str, bool, None] = None, |
|||
include_in_schema: bool = True, |
|||
json_schema_extra: Union[Dict[str, Any], None] = None, |
|||
**extra: Any, |
|||
): |
|||
self.convert_underscores = convert_underscores |
|||
super().__init__( |
|||
default=default, |
|||
default_factory=default_factory, |
|||
annotation=annotation, |
|||
alias=alias, |
|||
alias_priority=alias_priority, |
|||
validation_alias=validation_alias, |
|||
serialization_alias=serialization_alias, |
|||
title=title, |
|||
description=description, |
|||
gt=gt, |
|||
ge=ge, |
|||
lt=lt, |
|||
le=le, |
|||
min_length=min_length, |
|||
max_length=max_length, |
|||
pattern=pattern, |
|||
regex=regex, |
|||
discriminator=discriminator, |
|||
strict=strict, |
|||
multiple_of=multiple_of, |
|||
allow_inf_nan=allow_inf_nan, |
|||
max_digits=max_digits, |
|||
decimal_places=decimal_places, |
|||
deprecated=deprecated, |
|||
example=example, |
|||
examples=examples, |
|||
openapi_examples=openapi_examples, |
|||
include_in_schema=include_in_schema, |
|||
json_schema_extra=json_schema_extra, |
|||
**extra, |
|||
) |
|||
|
|||
|
|||
class Cookie(Param): # type: ignore[misc] |
|||
in_ = ParamTypes.cookie |
|||
|
|||
def __init__( |
|||
self, |
|||
default: Any = Undefined, |
|||
*, |
|||
default_factory: Union[Callable[[], Any], None] = _Unset, |
|||
annotation: Optional[Any] = None, |
|||
alias: Optional[str] = None, |
|||
alias_priority: Union[int, None] = _Unset, |
|||
# TODO: update when deprecating Pydantic v1, import these types |
|||
# validation_alias: str | AliasPath | AliasChoices | None |
|||
validation_alias: Union[str, None] = None, |
|||
serialization_alias: Union[str, None] = None, |
|||
title: Optional[str] = None, |
|||
description: Optional[str] = None, |
|||
gt: Optional[float] = None, |
|||
ge: Optional[float] = None, |
|||
lt: Optional[float] = None, |
|||
le: Optional[float] = None, |
|||
min_length: Optional[int] = None, |
|||
max_length: Optional[int] = None, |
|||
pattern: Optional[str] = None, |
|||
regex: Annotated[ |
|||
Optional[str], |
|||
deprecated( |
|||
"Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead." |
|||
), |
|||
] = None, |
|||
discriminator: Union[str, None] = None, |
|||
strict: Union[bool, None] = _Unset, |
|||
multiple_of: Union[float, None] = _Unset, |
|||
allow_inf_nan: Union[bool, None] = _Unset, |
|||
max_digits: Union[int, None] = _Unset, |
|||
decimal_places: Union[int, None] = _Unset, |
|||
examples: Optional[List[Any]] = None, |
|||
example: Annotated[ |
|||
Optional[Any], |
|||
deprecated( |
|||
"Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, " |
|||
"although still supported. Use examples instead." |
|||
), |
|||
] = _Unset, |
|||
openapi_examples: Optional[Dict[str, Example]] = None, |
|||
deprecated: Union[deprecated, str, bool, None] = None, |
|||
include_in_schema: bool = True, |
|||
json_schema_extra: Union[Dict[str, Any], None] = None, |
|||
**extra: Any, |
|||
): |
|||
super().__init__( |
|||
default=default, |
|||
default_factory=default_factory, |
|||
annotation=annotation, |
|||
alias=alias, |
|||
alias_priority=alias_priority, |
|||
validation_alias=validation_alias, |
|||
serialization_alias=serialization_alias, |
|||
title=title, |
|||
description=description, |
|||
gt=gt, |
|||
ge=ge, |
|||
lt=lt, |
|||
le=le, |
|||
min_length=min_length, |
|||
max_length=max_length, |
|||
pattern=pattern, |
|||
regex=regex, |
|||
discriminator=discriminator, |
|||
strict=strict, |
|||
multiple_of=multiple_of, |
|||
allow_inf_nan=allow_inf_nan, |
|||
max_digits=max_digits, |
|||
decimal_places=decimal_places, |
|||
deprecated=deprecated, |
|||
example=example, |
|||
examples=examples, |
|||
openapi_examples=openapi_examples, |
|||
include_in_schema=include_in_schema, |
|||
json_schema_extra=json_schema_extra, |
|||
**extra, |
|||
) |
|||
|
|||
|
|||
class Body(FieldInfo): # type: ignore[misc] |
|||
def __init__( |
|||
self, |
|||
default: Any = Undefined, |
|||
*, |
|||
default_factory: Union[Callable[[], Any], None] = _Unset, |
|||
annotation: Optional[Any] = None, |
|||
embed: Union[bool, None] = None, |
|||
media_type: str = "application/json", |
|||
alias: Optional[str] = None, |
|||
alias_priority: Union[int, None] = _Unset, |
|||
# TODO: update when deprecating Pydantic v1, import these types |
|||
# validation_alias: str | AliasPath | AliasChoices | None |
|||
validation_alias: Union[str, None] = None, |
|||
serialization_alias: Union[str, None] = None, |
|||
title: Optional[str] = None, |
|||
description: Optional[str] = None, |
|||
gt: Optional[float] = None, |
|||
ge: Optional[float] = None, |
|||
lt: Optional[float] = None, |
|||
le: Optional[float] = None, |
|||
min_length: Optional[int] = None, |
|||
max_length: Optional[int] = None, |
|||
pattern: Optional[str] = None, |
|||
regex: Annotated[ |
|||
Optional[str], |
|||
deprecated( |
|||
"Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead." |
|||
), |
|||
] = None, |
|||
discriminator: Union[str, None] = None, |
|||
strict: Union[bool, None] = _Unset, |
|||
multiple_of: Union[float, None] = _Unset, |
|||
allow_inf_nan: Union[bool, None] = _Unset, |
|||
max_digits: Union[int, None] = _Unset, |
|||
decimal_places: Union[int, None] = _Unset, |
|||
examples: Optional[List[Any]] = None, |
|||
example: Annotated[ |
|||
Optional[Any], |
|||
deprecated( |
|||
"Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, " |
|||
"although still supported. Use examples instead." |
|||
), |
|||
] = _Unset, |
|||
openapi_examples: Optional[Dict[str, Example]] = None, |
|||
deprecated: Union[deprecated, str, bool, None] = None, |
|||
include_in_schema: bool = True, |
|||
json_schema_extra: Union[Dict[str, Any], None] = None, |
|||
**extra: Any, |
|||
): |
|||
self.embed = embed |
|||
self.media_type = media_type |
|||
if example is not _Unset: |
|||
warnings.warn( |
|||
"`example` has been deprecated, please use `examples` instead", |
|||
category=DeprecationWarning, |
|||
stacklevel=4, |
|||
) |
|||
self.example = example |
|||
self.include_in_schema = include_in_schema |
|||
self.openapi_examples = openapi_examples |
|||
kwargs = dict( |
|||
default=default, |
|||
default_factory=default_factory, |
|||
alias=alias, |
|||
title=title, |
|||
description=description, |
|||
gt=gt, |
|||
ge=ge, |
|||
lt=lt, |
|||
le=le, |
|||
min_length=min_length, |
|||
max_length=max_length, |
|||
discriminator=discriminator, |
|||
multiple_of=multiple_of, |
|||
allow_inf_nan=allow_inf_nan, |
|||
max_digits=max_digits, |
|||
decimal_places=decimal_places, |
|||
**extra, |
|||
) |
|||
if examples is not None: |
|||
kwargs["examples"] = examples |
|||
if regex is not None: |
|||
warnings.warn( |
|||
"`regex` has been deprecated, please use `pattern` instead", |
|||
category=DeprecationWarning, |
|||
stacklevel=4, |
|||
) |
|||
current_json_schema_extra = json_schema_extra or extra |
|||
if PYDANTIC_VERSION_MINOR_TUPLE < (2, 7): |
|||
self.deprecated = deprecated |
|||
else: |
|||
kwargs["deprecated"] = deprecated |
|||
kwargs["regex"] = pattern or regex |
|||
kwargs.update(**current_json_schema_extra) |
|||
|
|||
use_kwargs = {k: v for k, v in kwargs.items() if v is not _Unset} |
|||
|
|||
super().__init__(**use_kwargs) |
|||
|
|||
def __repr__(self) -> str: |
|||
return f"{self.__class__.__name__}({self.default})" |
|||
|
|||
|
|||
class Form(Body): # type: ignore[misc] |
|||
def __init__( |
|||
self, |
|||
default: Any = Undefined, |
|||
*, |
|||
default_factory: Union[Callable[[], Any], None] = _Unset, |
|||
annotation: Optional[Any] = None, |
|||
media_type: str = "application/x-www-form-urlencoded", |
|||
alias: Optional[str] = None, |
|||
alias_priority: Union[int, None] = _Unset, |
|||
# TODO: update when deprecating Pydantic v1, import these types |
|||
# validation_alias: str | AliasPath | AliasChoices | None |
|||
validation_alias: Union[str, None] = None, |
|||
serialization_alias: Union[str, None] = None, |
|||
title: Optional[str] = None, |
|||
description: Optional[str] = None, |
|||
gt: Optional[float] = None, |
|||
ge: Optional[float] = None, |
|||
lt: Optional[float] = None, |
|||
le: Optional[float] = None, |
|||
min_length: Optional[int] = None, |
|||
max_length: Optional[int] = None, |
|||
pattern: Optional[str] = None, |
|||
regex: Annotated[ |
|||
Optional[str], |
|||
deprecated( |
|||
"Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead." |
|||
), |
|||
] = None, |
|||
discriminator: Union[str, None] = None, |
|||
strict: Union[bool, None] = _Unset, |
|||
multiple_of: Union[float, None] = _Unset, |
|||
allow_inf_nan: Union[bool, None] = _Unset, |
|||
max_digits: Union[int, None] = _Unset, |
|||
decimal_places: Union[int, None] = _Unset, |
|||
examples: Optional[List[Any]] = None, |
|||
example: Annotated[ |
|||
Optional[Any], |
|||
deprecated( |
|||
"Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, " |
|||
"although still supported. Use examples instead." |
|||
), |
|||
] = _Unset, |
|||
openapi_examples: Optional[Dict[str, Example]] = None, |
|||
deprecated: Union[deprecated, str, bool, None] = None, |
|||
include_in_schema: bool = True, |
|||
json_schema_extra: Union[Dict[str, Any], None] = None, |
|||
**extra: Any, |
|||
): |
|||
super().__init__( |
|||
default=default, |
|||
default_factory=default_factory, |
|||
annotation=annotation, |
|||
media_type=media_type, |
|||
alias=alias, |
|||
alias_priority=alias_priority, |
|||
validation_alias=validation_alias, |
|||
serialization_alias=serialization_alias, |
|||
title=title, |
|||
description=description, |
|||
gt=gt, |
|||
ge=ge, |
|||
lt=lt, |
|||
le=le, |
|||
min_length=min_length, |
|||
max_length=max_length, |
|||
pattern=pattern, |
|||
regex=regex, |
|||
discriminator=discriminator, |
|||
strict=strict, |
|||
multiple_of=multiple_of, |
|||
allow_inf_nan=allow_inf_nan, |
|||
max_digits=max_digits, |
|||
decimal_places=decimal_places, |
|||
deprecated=deprecated, |
|||
example=example, |
|||
examples=examples, |
|||
openapi_examples=openapi_examples, |
|||
include_in_schema=include_in_schema, |
|||
json_schema_extra=json_schema_extra, |
|||
**extra, |
|||
) |
|||
|
|||
|
|||
class File(Form): # type: ignore[misc] |
|||
def __init__( |
|||
self, |
|||
default: Any = Undefined, |
|||
*, |
|||
default_factory: Union[Callable[[], Any], None] = _Unset, |
|||
annotation: Optional[Any] = None, |
|||
media_type: str = "multipart/form-data", |
|||
alias: Optional[str] = None, |
|||
alias_priority: Union[int, None] = _Unset, |
|||
# TODO: update when deprecating Pydantic v1, import these types |
|||
# validation_alias: str | AliasPath | AliasChoices | None |
|||
validation_alias: Union[str, None] = None, |
|||
serialization_alias: Union[str, None] = None, |
|||
title: Optional[str] = None, |
|||
description: Optional[str] = None, |
|||
gt: Optional[float] = None, |
|||
ge: Optional[float] = None, |
|||
lt: Optional[float] = None, |
|||
le: Optional[float] = None, |
|||
min_length: Optional[int] = None, |
|||
max_length: Optional[int] = None, |
|||
pattern: Optional[str] = None, |
|||
regex: Annotated[ |
|||
Optional[str], |
|||
deprecated( |
|||
"Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead." |
|||
), |
|||
] = None, |
|||
discriminator: Union[str, None] = None, |
|||
strict: Union[bool, None] = _Unset, |
|||
multiple_of: Union[float, None] = _Unset, |
|||
allow_inf_nan: Union[bool, None] = _Unset, |
|||
max_digits: Union[int, None] = _Unset, |
|||
decimal_places: Union[int, None] = _Unset, |
|||
examples: Optional[List[Any]] = None, |
|||
example: Annotated[ |
|||
Optional[Any], |
|||
deprecated( |
|||
"Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, " |
|||
"although still supported. Use examples instead." |
|||
), |
|||
] = _Unset, |
|||
openapi_examples: Optional[Dict[str, Example]] = None, |
|||
deprecated: Union[deprecated, str, bool, None] = None, |
|||
include_in_schema: bool = True, |
|||
json_schema_extra: Union[Dict[str, Any], None] = None, |
|||
**extra: Any, |
|||
): |
|||
super().__init__( |
|||
default=default, |
|||
default_factory=default_factory, |
|||
annotation=annotation, |
|||
media_type=media_type, |
|||
alias=alias, |
|||
alias_priority=alias_priority, |
|||
validation_alias=validation_alias, |
|||
serialization_alias=serialization_alias, |
|||
title=title, |
|||
description=description, |
|||
gt=gt, |
|||
ge=ge, |
|||
lt=lt, |
|||
le=le, |
|||
min_length=min_length, |
|||
max_length=max_length, |
|||
pattern=pattern, |
|||
regex=regex, |
|||
discriminator=discriminator, |
|||
strict=strict, |
|||
multiple_of=multiple_of, |
|||
allow_inf_nan=allow_inf_nan, |
|||
max_digits=max_digits, |
|||
decimal_places=decimal_places, |
|||
deprecated=deprecated, |
|||
example=example, |
|||
examples=examples, |
|||
openapi_examples=openapi_examples, |
|||
include_in_schema=include_in_schema, |
|||
json_schema_extra=json_schema_extra, |
|||
**extra, |
|||
) |
|||
""" |
|||
Compatibility proxy for Pydantic v1 params. |
|||
|
|||
NOTE: This module re-exports the private shim from fastapi._compat._v1_params. |
|||
It exists to keep backward compatibility for imports in tests/docs: |
|||
from fastapi.temp_pydantic_v1_params import Body, Query, Form, ... |
|||
|
|||
Internally, _v1_params is lazy and will only touch pydantic.v1 if v1 is actually used. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
# Re-export shim classes so isinstance(...) keeps working |
|||
from ._compat._v1_params import ( # noqa: F401 |
|||
Body, |
|||
Cookie, |
|||
File, |
|||
Form, |
|||
Header, |
|||
Param, |
|||
Path, |
|||
Query, |
|||
) |
|||
|
|||
__all__ = [ |
|||
"Param", |
|||
"Body", |
|||
"Form", |
|||
"File", |
|||
"Query", |
|||
"Header", |
|||
"Cookie", |
|||
"Path", |
|||
] |
|||
|
|||
@ -0,0 +1,208 @@ |
|||
# path: tests/test_pydantic_v2_first_compat.py |
|||
|
|||
""" |
|||
Tests for v2-first compatibility layer with lazy v1 loading. |
|||
|
|||
This test suite validates that: |
|||
1. Python 3.14 + Pydantic v2 runs without warnings |
|||
2. Python 3.14 + Pydantic v1 shows controlled warnings/errors |
|||
3. isinstance() checks work with proxy classes |
|||
4. Zero breaking changes for existing imports |
|||
""" |
|||
|
|||
import sys |
|||
import warnings |
|||
|
|||
import pytest |
|||
from fastapi import FastAPI |
|||
from fastapi.encoders import jsonable_encoder |
|||
from pydantic import BaseModel |
|||
|
|||
|
|||
class TestV2FirstCompatibility: |
|||
"""Test v2-first compatibility layer.""" |
|||
|
|||
def test_v2_imports_no_warnings(self): |
|||
"""Test that v2-only usage doesn't trigger warnings on Python 3.14.""" |
|||
if sys.version_info < (3, 14): |
|||
pytest.skip("Python 3.14+ specific test") |
|||
|
|||
# Capture warnings |
|||
with warnings.catch_warnings(record=True) as w: |
|||
warnings.simplefilter("error", DeprecationWarning) |
|||
|
|||
# These should not trigger any warnings |
|||
from fastapi import FastAPI |
|||
|
|||
_ = FastAPI() # Create app but don't use it |
|||
|
|||
# Test jsonable_encoder with v2 model |
|||
class TestModel(BaseModel): |
|||
name: str |
|||
value: int |
|||
|
|||
model = TestModel(name="test", value=42) |
|||
result = jsonable_encoder(model) |
|||
|
|||
assert result == {"name": "test", "value": 42} |
|||
assert len(w) == 0, f"Unexpected warnings: {[str(warning.message) for warning in w]}" |
|||
|
|||
def test_proxy_classes_isinstance(self): |
|||
"""Test that proxy classes work correctly with isinstance().""" |
|||
import fastapi.temp_pydantic_v1_params as T |
|||
|
|||
# Test that proxy classes are available |
|||
assert hasattr(T, 'Param') |
|||
assert hasattr(T, 'Body') |
|||
assert hasattr(T, 'Form') |
|||
assert hasattr(T, 'File') |
|||
assert hasattr(T, 'Query') |
|||
assert hasattr(T, 'Header') |
|||
assert hasattr(T, 'Cookie') |
|||
assert hasattr(T, 'Path') |
|||
|
|||
# Test isinstance() with proxy classes (expect DeprecationWarning) |
|||
with warnings.catch_warnings(): |
|||
warnings.simplefilter("ignore", (DeprecationWarning, UserWarning)) |
|||
param_instance = T.Param() |
|||
assert isinstance(param_instance, T.Param) |
|||
|
|||
# Test that proxy classes are different from v2 params |
|||
from fastapi import params as v2_params |
|||
assert T.Param is not v2_params.Param |
|||
assert T.Body is not v2_params.Body |
|||
|
|||
def test_backward_compatibility_imports(self): |
|||
"""Test that existing imports continue to work.""" |
|||
# Test direct import from temp_pydantic_v1_params |
|||
from fastapi.temp_pydantic_v1_params import ( |
|||
Body, |
|||
Cookie, |
|||
File, |
|||
Form, |
|||
Header, |
|||
Param, |
|||
Path, |
|||
Query, |
|||
) |
|||
|
|||
# Test that classes are available and callable (expect DeprecationWarning) |
|||
with warnings.catch_warnings(): |
|||
warnings.simplefilter("ignore", (DeprecationWarning, UserWarning)) |
|||
body = Body() |
|||
query = Query() |
|||
form = Form() |
|||
file_param = File() |
|||
param = Param() |
|||
header = Header() |
|||
cookie = Cookie() |
|||
path = Path() |
|||
|
|||
# Test that they have expected attributes |
|||
assert hasattr(body, 'default') |
|||
assert hasattr(query, 'default') |
|||
assert hasattr(form, 'default') |
|||
assert hasattr(file_param, 'default') |
|||
assert hasattr(param, 'default') |
|||
assert hasattr(header, 'default') |
|||
assert hasattr(cookie, 'default') |
|||
assert hasattr(path, 'default') |
|||
|
|||
def test_lazy_loading_behavior(self): |
|||
"""Test that v1 is only loaded when actually used.""" |
|||
import sys |
|||
|
|||
# Clear any existing pydantic.v1 from sys.modules |
|||
_ = "pydantic.v1" in sys.modules # Check but don't use |
|||
|
|||
# Import FastAPI components |
|||
|
|||
_ = FastAPI() # Create app but don't use it |
|||
|
|||
# At this point, pydantic.v1 should not be loaded unless it was already loaded |
|||
# (we can't test the exact state because it might have been loaded by other tests) |
|||
|
|||
# Test that we can still access v1 proxy |
|||
from fastapi._compat import v1 |
|||
assert v1 is not None |
|||
|
|||
def test_encoders_lazy_registration(self): |
|||
"""Test that v1 encoders are registered lazily.""" |
|||
|
|||
# Test with a v2 model (should not trigger v1 encoder registration) |
|||
class V2Model(BaseModel): |
|||
name: str |
|||
|
|||
model = V2Model(name="test") |
|||
result = jsonable_encoder(model) |
|||
assert result == {"name": "test"} |
|||
|
|||
# The encoders should work without importing pydantic.v1 |
|||
# (unless it was already imported by other tests) |
|||
|
|||
def test_compat_module_structure(self): |
|||
"""Test that the compat module has expected structure.""" |
|||
# Test that v1 proxy has expected attributes (expect DeprecationWarning) |
|||
with warnings.catch_warnings(): |
|||
warnings.simplefilter("ignore", (DeprecationWarning, UserWarning)) |
|||
from fastapi._compat import v1 |
|||
|
|||
# Test that v1 proxy has expected attributes |
|||
assert hasattr(v1, 'BaseModel') |
|||
assert hasattr(v1, 'FieldInfo') |
|||
assert hasattr(v1, 'ValidationError') |
|||
|
|||
# Test that wrapper functions are available |
|||
assert hasattr(v1, '_normalize_errors') |
|||
assert hasattr(v1, '_model_dump') |
|||
assert hasattr(v1, '_model_rebuild') |
|||
|
|||
def test_strict_mode_environment_variable(self): |
|||
"""Test FASTAPI_PYDANTIC_V1_STRICT environment variable behavior.""" |
|||
import os |
|||
|
|||
# Save original value |
|||
original_strict = os.environ.get("FASTAPI_PYDANTIC_V1_STRICT") |
|||
|
|||
try: |
|||
# Test with strict mode enabled |
|||
os.environ["FASTAPI_PYDANTIC_V1_STRICT"] = "1" |
|||
|
|||
# This should not raise an error unless we actually try to use v1 |
|||
from fastapi import FastAPI |
|||
_ = FastAPI() # Create app but don't use it |
|||
|
|||
# The strict mode only affects actual v1 usage, not imports |
|||
assert True |
|||
|
|||
finally: |
|||
# Restore original value |
|||
if original_strict is not None: |
|||
os.environ["FASTAPI_PYDANTIC_V1_STRICT"] = original_strict |
|||
else: |
|||
os.environ.pop("FASTAPI_PYDANTIC_V1_STRICT", None) |
|||
|
|||
def test_v1_params_composition(self): |
|||
"""Test that v1 params use composition instead of inheritance.""" |
|||
from fastapi._compat._v1_params import Body, Form, Param |
|||
|
|||
# Test that they can be instantiated (expect DeprecationWarning) |
|||
with warnings.catch_warnings(): |
|||
warnings.simplefilter("ignore", (DeprecationWarning, UserWarning)) |
|||
param = Param() |
|||
body = Body() |
|||
form = Form() |
|||
|
|||
# Test that they delegate to internal v1.FieldInfo |
|||
assert hasattr(param, '_fi') |
|||
assert hasattr(body, '_fi') |
|||
assert hasattr(form, '_fi') |
|||
|
|||
# Test that they have expected interface |
|||
assert hasattr(param, 'default') |
|||
assert hasattr(body, 'default') |
|||
assert hasattr(form, 'default') |
|||
|
|||
|
|||
if __name__ == "__main__": |
|||
pytest.main([__file__]) |
|||
Loading…
Reference in new issue