fastapi 0.112.2__py3-none-any.whl → 0.112.3__py3-none-any.whl

fastapi/__init__.py

@@ -1,6 +1,6 @@
 """FastAPI framework, high performance, easy to learn, fast to code, ready for production"""
 
-__version__ = "0.112.2"
+__version__ = "0.112.3"
 
 from starlette import status as status
 

fastapi/dependencies/models.py

@@ -1,58 +1,37 @@
-from typing import Any, Callable, List, Optional, Sequence
+from dataclasses import dataclass, field
+from typing import Any, Callable, List, Optional, Sequence, Tuple
 
 from fastapi._compat import ModelField
 from fastapi.security.base import SecurityBase
 
 
+@dataclass
 class SecurityRequirement:
-    def __init__(
-        self, security_scheme: SecurityBase, scopes: Optional[Sequence[str]] = None
-    ):
-        self.security_scheme = security_scheme
-        self.scopes = scopes
+    security_scheme: SecurityBase
+    scopes: Optional[Sequence[str]] = None
 
 
+@dataclass
 class Dependant:
-    def __init__(
-        self,
-        *,
-        path_params: Optional[List[ModelField]] = None,
-        query_params: Optional[List[ModelField]] = None,
-        header_params: Optional[List[ModelField]] = None,
-        cookie_params: Optional[List[ModelField]] = None,
-        body_params: Optional[List[ModelField]] = None,
-        dependencies: Optional[List["Dependant"]] = None,
-        security_schemes: Optional[List[SecurityRequirement]] = None,
-        name: Optional[str] = None,
-        call: Optional[Callable[..., Any]] = None,
-        request_param_name: Optional[str] = None,
-        websocket_param_name: Optional[str] = None,
-        http_connection_param_name: Optional[str] = None,
-        response_param_name: Optional[str] = None,
-        background_tasks_param_name: Optional[str] = None,
-        security_scopes_param_name: Optional[str] = None,
-        security_scopes: Optional[List[str]] = None,
-        use_cache: bool = True,
-        path: Optional[str] = None,
-    ) -> None:
-        self.path_params = path_params or []
-        self.query_params = query_params or []
-        self.header_params = header_params or []
-        self.cookie_params = cookie_params or []
-        self.body_params = body_params or []
-        self.dependencies = dependencies or []
-        self.security_requirements = security_schemes or []
-        self.request_param_name = request_param_name
-        self.websocket_param_name = websocket_param_name
-        self.http_connection_param_name = http_connection_param_name
-        self.response_param_name = response_param_name
-        self.background_tasks_param_name = background_tasks_param_name
-        self.security_scopes = security_scopes
-        self.security_scopes_param_name = security_scopes_param_name
-        self.name = name
-        self.call = call
-        self.use_cache = use_cache
-        # Store the path to be able to re-generate a dependable from it in overrides
-        self.path = path
-        # Save the cache key at creation to optimize performance
+    path_params: List[ModelField] = field(default_factory=list)
+    query_params: List[ModelField] = field(default_factory=list)
+    header_params: List[ModelField] = field(default_factory=list)
+    cookie_params: List[ModelField] = field(default_factory=list)
+    body_params: List[ModelField] = field(default_factory=list)
+    dependencies: List["Dependant"] = field(default_factory=list)
+    security_requirements: List[SecurityRequirement] = field(default_factory=list)
+    name: Optional[str] = None
+    call: Optional[Callable[..., Any]] = None
+    request_param_name: Optional[str] = None
+    websocket_param_name: Optional[str] = None
+    http_connection_param_name: Optional[str] = None
+    response_param_name: Optional[str] = None
+    background_tasks_param_name: Optional[str] = None
+    security_scopes_param_name: Optional[str] = None
+    security_scopes: Optional[List[str]] = None
+    use_cache: bool = True
+    path: Optional[str] = None
+    cache_key: Tuple[Optional[Callable[..., Any]], Tuple[str, ...]] = field(init=False)
+
+    def __post_init__(self) -> None:
         self.cache_key = (self.call, tuple(sorted(set(self.security_scopes or []))))

fastapi/dependencies/utils.py

@@ -1,6 +1,7 @@
 import inspect
 from contextlib import AsyncExitStack, contextmanager
 from copy import copy, deepcopy
+from dataclasses import dataclass
 from typing import (
     Any,
     Callable,
@@ -54,7 +55,7 @@ from fastapi.logger import logger
 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 create_response_field, get_path_param_names
+from fastapi.utils import create_model_field, get_path_param_names
 from pydantic.fields import FieldInfo
 from starlette.background import BackgroundTasks as StarletteBackgroundTasks
 from starlette.concurrency import run_in_threadpool
@@ -79,25 +80,23 @@ multipart_incorrect_install_error = (
 )
 
 
-def check_file_field(field: ModelField) -> None:
-    field_info = field.field_info
-    if isinstance(field_info, params.Form):
+def ensure_multipart_is_installed() -> None:
+    try:
+        # __version__ is available in both multiparts, and can be mocked
+        from multipart import __version__  # type: ignore
+
+        assert __version__
         try:
-            # __version__ is available in both multiparts, and can be mocked
-            from multipart import __version__  # type: ignore
-
-            assert __version__
-            try:
-                # parse_options_header is only available in the right multipart
-                from multipart.multipart import parse_options_header  # type: ignore
-
-                assert parse_options_header
-            except ImportError:
-                logger.error(multipart_incorrect_install_error)
-                raise RuntimeError(multipart_incorrect_install_error) from None
+            # parse_options_header is only available in the right multipart
+            from multipart.multipart import parse_options_header  # type: ignore
+
+            assert parse_options_header
         except ImportError:
-            logger.error(multipart_not_installed_error)
-            raise RuntimeError(multipart_not_installed_error) from None
+            logger.error(multipart_incorrect_install_error)
+            raise RuntimeError(multipart_incorrect_install_error) from None
+    except ImportError:
+        logger.error(multipart_not_installed_error)
+        raise RuntimeError(multipart_not_installed_error) from None
 
 
 def get_param_sub_dependant(
@@ -175,7 +174,7 @@ def get_flat_dependant(
         header_params=dependant.header_params.copy(),
         cookie_params=dependant.cookie_params.copy(),
         body_params=dependant.body_params.copy(),
-        security_schemes=dependant.security_requirements.copy(),
+        security_requirements=dependant.security_requirements.copy(),
         use_cache=dependant.use_cache,
         path=dependant.path,
     )
@@ -258,16 +257,16 @@ def get_dependant(
     )
     for param_name, param in signature_params.items():
         is_path_param = param_name in path_param_names
-        type_annotation, depends, param_field = analyze_param(
+        param_details = analyze_param(
             param_name=param_name,
             annotation=param.annotation,
             value=param.default,
             is_path_param=is_path_param,
         )
-        if depends is not None:
+        if param_details.depends is not None:
             sub_dependant = get_param_sub_dependant(
                 param_name=param_name,
-                depends=depends,
+                depends=param_details.depends,
                 path=path,
                 security_scopes=security_scopes,
             )
@@ -275,18 +274,18 @@ def get_dependant(
             continue
         if add_non_field_param_to_dependency(
             param_name=param_name,
-            type_annotation=type_annotation,
+            type_annotation=param_details.type_annotation,
             dependant=dependant,
         ):
             assert (
-                param_field is None
+                param_details.field is None
             ), f"Cannot specify multiple FastAPI annotations for {param_name!r}"
             continue
-        assert param_field is not None
-        if is_body_param(param_field=param_field, is_path_param=is_path_param):
-            dependant.body_params.append(param_field)
+        assert param_details.field is not None
+        if is_body_param(param_field=param_details.field, is_path_param=is_path_param):
+            dependant.body_params.append(param_details.field)
         else:
-            add_param_to_fields(field=param_field, dependant=dependant)
+            add_param_to_fields(field=param_details.field, dependant=dependant)
     return dependant
 
 
@@ -314,13 +313,20 @@ def add_non_field_param_to_dependency(
     return None
 
 
+@dataclass
+class ParamDetails:
+    type_annotation: Any
+    depends: Optional[params.Depends]
+    field: Optional[ModelField]
+
+
 def analyze_param(
     *,
     param_name: str,
     annotation: Any,
     value: Any,
     is_path_param: bool,
-) -> Tuple[Any, Optional[params.Depends], Optional[ModelField]]:
+) -> ParamDetails:
     field_info = None
     depends = None
     type_annotation: Any = Any
@@ -328,6 +334,7 @@ def analyze_param(
     if annotation is not inspect.Signature.empty:
         use_annotation = annotation
         type_annotation = annotation
+    # Extract Annotated info
     if get_origin(use_annotation) is Annotated:
         annotated_args = get_args(annotation)
         type_annotation = annotated_args[0]
@@ -347,6 +354,7 @@ def analyze_param(
             )
         else:
             fastapi_annotation = None
+        # Set default for Annotated FieldInfo
         if isinstance(fastapi_annotation, FieldInfo):
             # Copy `field_info` because we mutate `field_info.default` below.
             field_info = copy_field_info(
@@ -361,9 +369,10 @@ def analyze_param(
                 field_info.default = value
             else:
                 field_info.default = Required
+        # Get Annotated Depends
         elif isinstance(fastapi_annotation, params.Depends):
             depends = fastapi_annotation
-
+    # Get Depends from default value
     if isinstance(value, params.Depends):
         assert depends is None, (
             "Cannot specify `Depends` in `Annotated` and default value"
@@ -374,6 +383,7 @@ def analyze_param(
             f" default value together for {param_name!r}"
         )
         depends = value
+    # Get FieldInfo from default value
     elif isinstance(value, FieldInfo):
         assert field_info is None, (
             "Cannot specify FastAPI annotations in `Annotated` and default value"
@@ -383,11 +393,13 @@ def analyze_param(
         if PYDANTIC_V2:
             field_info.annotation = type_annotation
 
+    # Get Depends from type annotation
     if depends is not None and depends.dependency is None:
         # Copy `depends` before mutating it
         depends = copy(depends)
         depends.dependency = type_annotation
 
+    # Handle non-param type annotations like Request
     if lenient_issubclass(
         type_annotation,
         (
@@ -403,6 +415,7 @@ def analyze_param(
         assert (
             field_info is None
         ), f"Cannot specify FastAPI annotation for type {type_annotation!r}"
+    # Handle default assignations, neither field_info nor depends was not found in Annotated nor default value
     elif field_info is None and depends is None:
         default_value = value if value is not inspect.Signature.empty else Required
         if is_path_param:
@@ -420,7 +433,9 @@ def analyze_param(
             field_info = params.Query(annotation=use_annotation, default=default_value)
 
     field = None
+    # It's a field_info, not a dependency
     if field_info is not None:
+        # Handle field_info.in_
         if is_path_param:
             assert isinstance(field_info, params.Path), (
                 f"Cannot use `{field_info.__class__.__name__}` for path param"
@@ -436,12 +451,14 @@ def analyze_param(
             field_info,
             param_name,
         )
+        if isinstance(field_info, params.Form):
+            ensure_multipart_is_installed()
         if not field_info.alias and getattr(field_info, "convert_underscores", None):
             alias = param_name.replace("_", "-")
         else:
             alias = field_info.alias or param_name
         field_info.alias = alias
-        field = create_response_field(
+        field = create_model_field(
             name=param_name,
             type_=use_annotation_from_field_info,
             default=field_info.default,
@@ -450,7 +467,7 @@ def analyze_param(
             field_info=field_info,
         )
 
-    return type_annotation, depends, field
+    return ParamDetails(type_annotation=type_annotation, depends=depends, field=field)
 
 
 def is_body_param(*, param_field: ModelField, is_path_param: bool) -> bool:
@@ -521,6 +538,15 @@ async def solve_generator(
     return await stack.enter_async_context(cm)
 
 
+@dataclass
+class SolvedDependency:
+    values: Dict[str, Any]
+    errors: List[Any]
+    background_tasks: Optional[StarletteBackgroundTasks]
+    response: Response
+    dependency_cache: Dict[Tuple[Callable[..., Any], Tuple[str]], Any]
+
+
 async def solve_dependencies(
     *,
     request: Union[Request, WebSocket],
@@ -531,13 +557,7 @@ async def solve_dependencies(
     dependency_overrides_provider: Optional[Any] = None,
     dependency_cache: Optional[Dict[Tuple[Callable[..., Any], Tuple[str]], Any]] = None,
     async_exit_stack: AsyncExitStack,
-) -> Tuple[
-    Dict[str, Any],
-    List[Any],
-    Optional[StarletteBackgroundTasks],
-    Response,
-    Dict[Tuple[Callable[..., Any], Tuple[str]], Any],
-]:
+) -> SolvedDependency:
     values: Dict[str, Any] = {}
     errors: List[Any] = []
     if response is None:
@@ -579,27 +599,21 @@ async def solve_dependencies(
             dependency_cache=dependency_cache,
             async_exit_stack=async_exit_stack,
         )
-        (
-            sub_values,
-            sub_errors,
-            background_tasks,
-            _,  # the subdependency returns the same response we have
-            sub_dependency_cache,
-        ) = solved_result
-        dependency_cache.update(sub_dependency_cache)
-        if sub_errors:
-            errors.extend(sub_errors)
+        background_tasks = solved_result.background_tasks
+        dependency_cache.update(solved_result.dependency_cache)
+        if solved_result.errors:
+            errors.extend(solved_result.errors)
             continue
         if sub_dependant.use_cache and sub_dependant.cache_key in dependency_cache:
             solved = dependency_cache[sub_dependant.cache_key]
         elif is_gen_callable(call) or is_async_gen_callable(call):
             solved = await solve_generator(
-                call=call, stack=async_exit_stack, sub_values=sub_values
+                call=call, stack=async_exit_stack, sub_values=solved_result.values
             )
         elif is_coroutine_callable(call):
-            solved = await call(**sub_values)
+            solved = await call(**solved_result.values)
         else:
-            solved = await run_in_threadpool(call, **sub_values)
+            solved = await run_in_threadpool(call, **solved_result.values)
         if sub_dependant.name is not None:
             values[sub_dependant.name] = solved
         if sub_dependant.cache_key not in dependency_cache:
@@ -646,7 +660,13 @@ async def solve_dependencies(
         values[dependant.security_scopes_param_name] = SecurityScopes(
             scopes=dependant.security_scopes
         )
-    return values, errors, background_tasks, response, dependency_cache
+    return SolvedDependency(
+        values=values,
+        errors=errors,
+        background_tasks=background_tasks,
+        response=response,
+        dependency_cache=dependency_cache,
+    )
 
 
 def request_params_to_args(
@@ -775,7 +795,6 @@ def get_body_field(*, dependant: Dependant, name: str) -> Optional[ModelField]:
     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:
-        check_file_field(first_param)
         return first_param
     # If one field requires to embed, all have to be embedded
     # in case a sub-dependency is evaluated with a single unique body field
@@ -807,12 +826,11 @@ def get_body_field(*, dependant: Dependant, name: str) -> Optional[ModelField]:
         ]
         if len(set(body_param_media_types)) == 1:
             BodyFieldInfo_kwargs["media_type"] = body_param_media_types[0]
-    final_field = create_response_field(
+    final_field = create_model_field(
         name="body",
         type_=BodyModel,
         required=required,
         alias="body",
         field_info=BodyFieldInfo(**BodyFieldInfo_kwargs),
     )
-    check_file_field(final_field)
     return final_field

fastapi/routing.py

@@ -49,7 +49,7 @@ from fastapi.exceptions import (
 from fastapi.types import DecoratedCallable, IncEx
 from fastapi.utils import (
     create_cloned_field,
-    create_response_field,
+    create_model_field,
     generate_unique_id,
     get_value_or_default,
     is_body_allowed_for_status_code,
@@ -292,26 +292,34 @@ def get_request_handler(
                     dependency_overrides_provider=dependency_overrides_provider,
                     async_exit_stack=async_exit_stack,
                 )
-                values, errors, background_tasks, sub_response, _ = solved_result
+                errors = solved_result.errors
                 if not errors:
                     raw_response = await run_endpoint_function(
-                        dependant=dependant, values=values, is_coroutine=is_coroutine
+                        dependant=dependant,
+                        values=solved_result.values,
+                        is_coroutine=is_coroutine,
                     )
                     if isinstance(raw_response, Response):
                         if raw_response.background is None:
-                            raw_response.background = background_tasks
+                            raw_response.background = solved_result.background_tasks
                         response = raw_response
                     else:
-                        response_args: Dict[str, Any] = {"background": background_tasks}
+                        response_args: Dict[str, Any] = {
+                            "background": solved_result.background_tasks
+                        }
                         # If status_code was set, use it, otherwise use the default from the
                         # response class, in the case of redirect it's 307
                         current_status_code = (
-                            status_code if status_code else sub_response.status_code
+                            status_code
+                            if status_code
+                            else solved_result.response.status_code
                         )
                         if current_status_code is not None:
                             response_args["status_code"] = current_status_code
-                        if sub_response.status_code:
-                            response_args["status_code"] = sub_response.status_code
+                        if solved_result.response.status_code:
+                            response_args["status_code"] = (
+                                solved_result.response.status_code
+                            )
                         content = await serialize_response(
                             field=response_field,
                             response_content=raw_response,
@@ -326,7 +334,7 @@ def get_request_handler(
                         response = actual_response_class(content, **response_args)
                         if not is_body_allowed_for_status_code(response.status_code):
                             response.body = b""
-                        response.headers.raw.extend(sub_response.headers.raw)
+                        response.headers.raw.extend(solved_result.response.headers.raw)
             if errors:
                 validation_error = RequestValidationError(
                     _normalize_errors(errors), body=body
@@ -360,11 +368,12 @@ def get_websocket_app(
                 dependency_overrides_provider=dependency_overrides_provider,
                 async_exit_stack=async_exit_stack,
             )
-            values, errors, _, _2, _3 = solved_result
-            if errors:
-                raise WebSocketRequestValidationError(_normalize_errors(errors))
+            if solved_result.errors:
+                raise WebSocketRequestValidationError(
+                    _normalize_errors(solved_result.errors)
+                )
             assert dependant.call is not None, "dependant.call must be a function"
-            await dependant.call(**values)
+            await dependant.call(**solved_result.values)
 
     return app
 
@@ -488,7 +497,7 @@ class APIRoute(routing.Route):
                 status_code
             ), f"Status code {status_code} must not have a response body"
             response_name = "Response_" + self.unique_id
-            self.response_field = create_response_field(
+            self.response_field = create_model_field(
                 name=response_name,
                 type_=self.response_model,
                 mode="serialization",
@@ -521,7 +530,7 @@ class APIRoute(routing.Route):
                     additional_status_code
                 ), f"Status code {additional_status_code} must not have a response body"
                 response_name = f"Response_{additional_status_code}_{self.unique_id}"
-                response_field = create_response_field(name=response_name, type_=model)
+                response_field = create_model_field(name=response_name, type_=model)
                 response_fields[additional_status_code] = response_field
         if response_fields:
             self.response_fields: Dict[Union[int, str], ModelField] = response_fields

fastapi/utils.py

@@ -60,9 +60,9 @@ def get_path_param_names(path: str) -> Set[str]:
     return set(re.findall("{(.*?)}", path))
 
 
-def create_response_field(
+def create_model_field(
     name: str,
-    type_: Type[Any],
+    type_: Any,
     class_validators: Optional[Dict[str, Validator]] = None,
     default: Optional[Any] = Undefined,
     required: Union[bool, UndefinedType] = Undefined,
@@ -71,9 +71,6 @@ def create_response_field(
     alias: Optional[str] = None,
     mode: Literal["validation", "serialization"] = "validation",
 ) -> ModelField:
-    """
-    Create a new response field. Raises if type_ is invalid.
-    """
     class_validators = class_validators or {}
     if PYDANTIC_V2:
         field_info = field_info or FieldInfo(
@@ -135,7 +132,7 @@ def create_cloned_field(
                 use_type.__fields__[f.name] = create_cloned_field(
                     f, cloned_types=cloned_types
                 )
-    new_field = create_response_field(name=field.name, type_=use_type)
+    new_field = create_model_field(name=field.name, type_=use_type)
     new_field.has_alias = field.has_alias  # type: ignore[attr-defined]
     new_field.alias = field.alias  # type: ignore[misc]
     new_field.class_validators = field.class_validators  # type: ignore[attr-defined]

{fastapi-0.112.2.dist-info → fastapi-0.112.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi
-Version: 0.112.2
+Version: 0.112.3
 Summary: FastAPI framework, high performance, easy to learn, fast to code, ready for production
 Author-Email: =?utf-8?q?Sebasti=C3=A1n_Ram=C3=ADrez?= <tiangolo@gmail.com>
 Classifier: Intended Audience :: Information Technology
@@ -115,9 +115,8 @@ The key features are:
 <a href="https://bump.sh/fastapi?utm_source=fastapi&utm_medium=referral&utm_campaign=sponsor" target="_blank" title="Automate FastAPI documentation generation with Bump.sh"><img src="https://fastapi.tiangolo.com/img/sponsors/bump-sh.svg"></a>
 <a href="https://github.com/scalar/scalar/?utm_source=fastapi&utm_medium=website&utm_campaign=main-badge" target="_blank" title="Scalar: Beautiful Open-Source API References from Swagger/OpenAPI files"><img src="https://fastapi.tiangolo.com/img/sponsors/scalar.svg"></a>
 <a href="https://www.propelauth.com/?utm_source=fastapi&utm_campaign=1223&utm_medium=mainbadge" target="_blank" title="Auth, user management and more for your B2B product"><img src="https://fastapi.tiangolo.com/img/sponsors/propelauth.png"></a>
-<a href="https://docs.withcoherence.com/configuration/frameworks/?utm_medium=advertising&utm_source=fastapi&utm_campaign=docs#fastapi-example" target="_blank" title="Coherence"><img src="https://fastapi.tiangolo.com/img/sponsors/coherence.png"></a>
+<a href="https://docs.withcoherence.com/coherence-templates/full-stack-template/#fastapi?utm_medium=advertising&utm_source=fastapi&utm_campaign=docs" target="_blank" title="Coherence"><img src="https://fastapi.tiangolo.com/img/sponsors/coherence.png"></a>
 <a href="https://www.mongodb.com/developer/languages/python/python-quickstart-fastapi/?utm_campaign=fastapi_framework&utm_source=fastapi_sponsorship&utm_medium=web_referral" target="_blank" title="Simplify Full Stack Development with FastAPI & MongoDB"><img src="https://fastapi.tiangolo.com/img/sponsors/mongodb.png"></a>
-<a href="https://konghq.com/products/kong-konnect?utm_medium=referral&utm_source=github&utm_campaign=platform&utm_content=fast-api" target="_blank" title="Kong Konnect - API management platform"><img src="https://fastapi.tiangolo.com/img/sponsors/kong.png"></a>
 <a href="https://zuplo.link/fastapi-gh" target="_blank" title="Zuplo: Scale, Protect, Document, and Monetize your FastAPI"><img src="https://fastapi.tiangolo.com/img/sponsors/zuplo.png"></a>
 <a href="https://fine.dev?ref=fastapibadge" target="_blank" title="Fine's AI FastAPI Workflow: Effortlessly Deploy and Integrate FastAPI into Your Project"><img src="https://fastapi.tiangolo.com/img/sponsors/fine.png"></a>
 <a href="https://liblab.com?utm_source=fastapi" target="_blank" title="liblab - Generate SDKs from FastAPI"><img src="https://fastapi.tiangolo.com/img/sponsors/liblab.png"></a>
@@ -457,7 +456,7 @@ Coming back to the previous code example, **FastAPI** will:
 * Check if there is an optional query parameter named `q` (as in `http://127.0.0.1:8000/items/foo?q=somequery`) for `GET` requests.
     * As the `q` parameter is declared with `= None`, it is optional.
     * Without the `None` it would be required (as is the body in the case with `PUT`).
-* For `PUT` requests to `/items/{item_id}`, Read the body as JSON:
+* For `PUT` requests to `/items/{item_id}`, read the body as JSON:
     * Check that it has a required attribute `name` that should be a `str`.
     * Check that it has a required attribute `price` that has to be a `float`.
     * Check that it has an optional attribute `is_offer`, that should be a `bool`, if present.

{fastapi-0.112.2.dist-info → fastapi-0.112.3.dist-info}/RECORD

@@ -1,8 +1,8 @@
-fastapi-0.112.2.dist-info/METADATA,sha256=bnN5StpCV0DjSg7dk8yiEBkSTr_hAjcMHoxYSv4LuIU,27528
-fastapi-0.112.2.dist-info/WHEEL,sha256=rSwsxJWe3vzyR5HCwjWXQruDgschpei4h_giTm0dJVE,90
-fastapi-0.112.2.dist-info/entry_points.txt,sha256=Nn2-rs4A5_lQZko2b9QqCKQx9Irx0agGbxq3QLgjBxQ,46
-fastapi-0.112.2.dist-info/licenses/LICENSE,sha256=Tsif_IFIW5f-xYSy1KlhAy7v_oNEU4lP2cEnSQbMdE4,1086
-fastapi/__init__.py,sha256=61dw7I6Jsj1RGSw6HG8Q3fNgxEuX7Y_QoG39NNJ81C8,1081
+fastapi-0.112.3.dist-info/METADATA,sha256=w1QfelBarqYSCtz6ly70TBP_VdihTpwEujW_K2sRg9E,27273
+fastapi-0.112.3.dist-info/WHEEL,sha256=rSwsxJWe3vzyR5HCwjWXQruDgschpei4h_giTm0dJVE,90
+fastapi-0.112.3.dist-info/entry_points.txt,sha256=Nn2-rs4A5_lQZko2b9QqCKQx9Irx0agGbxq3QLgjBxQ,46
+fastapi-0.112.3.dist-info/licenses/LICENSE,sha256=Tsif_IFIW5f-xYSy1KlhAy7v_oNEU4lP2cEnSQbMdE4,1086
+fastapi/__init__.py,sha256=o7tP2gKcsHMiiJNCKrN-GA3wqWjGR54B379fYdZ3_TA,1081
 fastapi/__main__.py,sha256=bKePXLdO4SsVSM6r9SVoLickJDcR2c0cTOxZRKq26YQ,37
 fastapi/_compat.py,sha256=OjE3FUZ0IPXqIJWKhoWKDNCHv4so-FQ-rfN8ngQZeFE,23134
 fastapi/applications.py,sha256=Ix-o9pQAWhEDf9J0Q1hZ0nBB1uP72c-Y3oiYzvrwqiM,176316
@@ -11,8 +11,8 @@ fastapi/cli.py,sha256=OYhZb0NR_deuT5ofyPF2NoNBzZDNOP8Salef2nk-HqA,418
 fastapi/concurrency.py,sha256=AYLnS4judDUmXsNRICtoKSP0prfYDcS8ehBtYW9JhQQ,1403
 fastapi/datastructures.py,sha256=b2PEz77XGq-u3Ur1Inwk0AGjOsQZO49yF9C7IPJ15cY,5766
 fastapi/dependencies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastapi/dependencies/models.py,sha256=-n-YCxzgVBkurQi49qOTooT71v_oeAhHJ-qQFonxh5o,2494
-fastapi/dependencies/utils.py,sha256=DBKj3z2oU1U3W89zTc3e6ej6V1Qy1tvx0V5ho_cYVIQ,30243
+fastapi/dependencies/models.py,sha256=Pjl6vx-4nZ5Tta9kJa3-RfQKkXtCpS09-FhMgs9eWNs,1507
+fastapi/dependencies/utils.py,sha256=2J36LBZMJTZ6jadjANaG-voTfzgs8JpROJCRtoLoSFA,30922
 fastapi/encoders.py,sha256=LvwYmFeOz4tVwvgBoC5rvZnbr7hZr73KGrU8O7zSptU,11068
 fastapi/exception_handlers.py,sha256=MBrIOA-ugjJDivIi4rSsUJBdTsjuzN76q4yh0q1COKw,1332
 fastapi/exceptions.py,sha256=taNixuFEXb67lI1bnX1ubq8y8TseJ4yoPlWjyP0fTzk,4969
@@ -33,7 +33,7 @@ fastapi/params.py,sha256=CWumi-CkfxWSg4I2KpPxIvQyKdeW_Lnct9reHnrTwW8,28199
 fastapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastapi/requests.py,sha256=zayepKFcienBllv3snmWI20Gk0oHNVLU4DDhqXBb4LU,142
 fastapi/responses.py,sha256=QNQQlwpKhQoIPZTTWkpc9d_QGeGZ_aVQPaDV3nQ8m7c,1761
-fastapi/routing.py,sha256=sUxTddjKa4IokZAOzv6fHTF0MbltBtJv_QRmh4-L_eA,175040
+fastapi/routing.py,sha256=e_H0k8q4HQl88mgi-Jdf-9hBfn2gTvDjixXrufDN3U0,175326
 fastapi/security/__init__.py,sha256=bO8pNmxqVRXUjfl2mOKiVZLn0FpBQ61VUYVjmppnbJw,881
 fastapi/security/api_key.py,sha256=_OqUUjEHG5_MT1IPAhXIGJRCPldTBdSww_DegFy_W8Y,9368
 fastapi/security/base.py,sha256=dl4pvbC-RxjfbWgPtCWd8MVU-7CB2SZ22rJDXVCXO6c,141
@@ -45,6 +45,6 @@ fastapi/staticfiles.py,sha256=iirGIt3sdY2QZXd36ijs3Cj-T0FuGFda3cd90kM9Ikw,69
 fastapi/templating.py,sha256=4zsuTWgcjcEainMJFAlW6-gnslm6AgOS1SiiDWfmQxk,76
 fastapi/testclient.py,sha256=nBvaAmX66YldReJNZXPOk1sfuo2Q6hs8bOvIaCep6LQ,66
 fastapi/types.py,sha256=nFb36sK3DSoqoyo7Miwy3meKK5UdFBgkAgLSzQlUVyI,383
-fastapi/utils.py,sha256=T1OYlJBw80LMtKhvU18J6XeTX4_MMPzIGPYcJqI5QVM,8037
+fastapi/utils.py,sha256=y8Bj5ttMaI9tS4D60OUgXqKnktBr99NdYUnHHV9LgoY,7948
 fastapi/websockets.py,sha256=419uncYObEKZG0YcrXscfQQYLSWoE10jqxVMetGdR98,222
-fastapi-0.112.2.dist-info/RECORD,,
+fastapi-0.112.3.dist-info/RECORD,,