### Internal

* ⬆ Bump dorny/paths-filter from 3 to 4. PR [#15106](https://github.com/fastapi/fastapi/pull/15106) by [@dependabot[bot]](https://github.com/apps/dependabot).

* ⬆ Bump cairosvg from 2.8.2 to 2.9.0. PR [#15108](https://github.com/fastapi/fastapi/pull/15108) by [@dependabot[bot]](https://github.com/apps/dependabot).

* ⬆ Bump pyjwt from 2.11.0 to 2.12.0. PR [#15110](https://github.com/fastapi/fastapi/pull/15110) by [@dependabot[bot]](https://github.com/apps/dependabot).

from .v2 import Url as Url

from .v2 import copy_field_info as copy_field_info

from .v2 import create_body_model as create_body_model

from .v2 import get_cached_model_fields as get_cached_model_fields

from .v2 import get_definitions as get_definitions

from .v2 import get_flat_models_from_fields as get_flat_models_from_fields

from pydantic import PydanticSchemaGenerationError as PydanticSchemaGenerationError

from pydantic import PydanticUndefinedAnnotation as PydanticUndefinedAnnotation

from pydantic import ValidationError as ValidationError

GetJsonSchemaHandler as GetJsonSchemaHandler,

)

from pydantic.fields import FieldInfo as FieldInfo

from pydantic.json_schema import GenerateJsonSchema as _GenerateJsonSchema

from pydantic.json_schema import JsonSchemaValue as JsonSchemaValue

RequiredParam = PydanticUndefined

Undefined = PydanticUndefined

class GenerateJsonSchema(_GenerateJsonSchema):

Field(**field_dict["attributes"]),

)

self._type_adapter: TypeAdapter[Any] = TypeAdapter(

config=self.config,

)

for arg in get_args(annotation):

if lenient_issubclass(arg, (BaseModel, Enum)):

if arg not in known_models:

if lenient_issubclass(arg, BaseModel):

get_flat_models_from_model(arg, known_models=known_models)

else:

from collections.abc import Awaitable, Callable, Coroutine, Sequence

from enum import Enum

from annotated_doc import Doc

from fastapi import routing

self.exception_handlers.setdefault(

RequestValidationError, request_validation_exception_handler

)

self.exception_handlers.setdefault(

WebSocketRequestValidationError,

self.user_middleware: list[Middleware] = (

[] if middleware is None else list(middleware)

exception_handlers[key] = value

middleware = (

+ self.user_middleware

+ [

Middleware(

),

# Add FastAPI-specific AsyncExitStackMiddleware for closing files.

# Before this was also used for closing dependencies with yield but

# user middlewares, the same context is used.

# This is currently not needed, only for closing files, but used to be

# important when dependencies with yield were closed here.

]

)

def middleware(

self,

def decorator(func: DecoratedCallable) -> DecoratedCallable:

return func

return decorator

def main() -> None:

message = 'To use the fastapi command, please install "fastapi[standard]":\n\n\tpip install "fastapi[standard]"\n'

print(message)

raise RuntimeError(message) # noqa: B904

return DefaultPlaceholder(value) # type: ignore

Undefined,

copy_field_info,

create_body_model,

field_annotation_is_scalar,

field_annotation_is_scalar_sequence,

field_annotation_is_sequence,

except (ImportError, AssertionError):

try:

# __version__ is available in both multiparts, and can be mocked

assert __version__

try:

# parse_options_header is only available in the right multipart

parse_options_header,

)

def get_typed_annotation(annotation: Any, globalns: dict[str, Any]) -> Any:

if isinstance(annotation, str):

annotation = ForwardRef(annotation)

if annotation is type(None):

return None

return annotation

and param_details.depends.scope == "function"

):

assert dependant.call

raise DependencyScopeError(

'"request", it cannot depend on dependencies with scope "function".'

)

sub_own_oauth_scopes: list[str] = []

*,

request: Request | WebSocket,

dependant: Dependant,

background_tasks: StarletteBackgroundTasks | None = None,

response: Response | None = None,

dependency_overrides_provider: Any | None = None,

if response is None:

response = Response()

del response.headers["content-length"]

if dependency_cache is None:

dependency_cache = {}

for sub_dependant in dependant.dependencies:

for key in received_params.keys():

if key not in processed_keys:

value = received_params.getlist(key)

if isinstance(value, list) and (len(value) == 1):

params_to_process[key] = value[0]

async def request_body_to_args(

body_fields: list[ModelField],

embed_body_fields: bool,

) -> tuple[dict[str, Any], list[dict[str, Any]]]:

values: dict[str, Any] = {}

for field in body_fields:

loc = ("body", get_validation_alias(field))

value: Any | None = None

try:

value = body_to_process.get(get_validation_alias(field))

# If the received body is a list, not a dict

from fastapi.exceptions import PydanticV1NotSupportedError

from fastapi.types import IncEx

from pydantic import BaseModel

from pydantic.networks import AnyUrl, NameEmail

from pydantic.types import SecretBytes, SecretStr

from pydantic_core import PydanticUndefinedType

ENCODERS_BY_TYPE: dict[type[Any], Callable[[Any], Any]] = {

bytes: lambda o: o.decode(),

datetime.date: isoformat,

datetime.datetime: isoformat,

datetime.time: isoformat,

if isinstance(obj, encoder_type):

return encoder_instance(obj)

if include is not None and not isinstance(include, (set, dict)):

if exclude is not None and not isinstance(exclude, (set, dict)):

if isinstance(obj, BaseModel):

obj_dict = obj.model_dump(

mode="json",

from pydantic import EmailStr

except ImportError: # pragma: no cover

@classmethod

def __get_validators__(cls) -> Iterable[Callable[..., Any]]:

yield cls.validate