Add files using upload-large-folder tool

lib/python3.11/site-packages/_yaml/__init__.py

@@ -0,0 +1,33 @@
+# This is a stub package designed to roughly emulate the _yaml
+# extension module, which previously existed as a standalone module
+# and has been moved into the `yaml` package namespace.
+# It does not perfectly mimic its old counterpart, but should get
+# close enough for anyone who's relying on it even when they shouldn't.
+import yaml
+
+# in some circumstances, the yaml module we imoprted may be from a different version, so we need
+# to tread carefully when poking at it here (it may not have the attributes we expect)
+if not getattr(yaml, '__with_libyaml__', False):
+    from sys import version_info
+
+    exc = ModuleNotFoundError if version_info >= (3, 6) else ImportError
+    raise exc("No module named '_yaml'")
+else:
+    from yaml._yaml import *
+    import warnings
+    warnings.warn(
+        'The _yaml extension module is now located at yaml._yaml'
+        ' and its location is subject to change.  To use the'
+        ' LibYAML-based parser and emitter, import from `yaml`:'
+        ' `from yaml import CLoader as Loader, CDumper as Dumper`.',
+        DeprecationWarning
+    )
+    del warnings
+    # Don't `del yaml` here because yaml is actually an existing
+    # namespace member of _yaml.
+
+__name__ = '_yaml'
+# If the module is top-level (i.e. not a part of any specific package)
+# then the attribute should be set to ''.
+# https://docs.python.org/3.8/library/types.html
+__package__ = ''

lib/python3.11/site-packages/einops-0.8.2.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

lib/python3.11/site-packages/einops-0.8.2.dist-info/METADATA

@@ -0,0 +1,394 @@
+Metadata-Version: 2.4
+Name: einops
+Version: 0.8.2
+Summary: A new flavour of deep learning operations
+Project-URL: Homepage, https://github.com/arogozhnikov/einops
+Author: Alex Rogozhnikov
+License: MIT
+License-File: LICENSE
+Keywords: deep learning,einops,machine learning,neural networks,scientific computations,tensor manipulation
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+
+<!--
+<a href='http://arogozhnikov.github.io/images/einops/einops_video.mp4' >
+<div align="center">
+  <img src="http://arogozhnikov.github.io/images/einops/einops_video.gif" alt="einops package examples" />
+  <br>
+  <small><a href='http://arogozhnikov.github.io/images/einops/einops_video.mp4'>This video in high quality (mp4)</a></small>
+  <br><br>
+</div>
+</a>
+-->
+
+<!-- this link magically rendered as video on github readme, unfortunately not in docs -->
+
+https://user-images.githubusercontent.com/6318811/177030658-66f0eb5d-e136-44d8-99c9-86ae298ead5b.mp4
+
+
+
+
+# einops 
+[![Run tests](https://github.com/arogozhnikov/einops/actions/workflows/run_tests.yml/badge.svg)](https://github.com/arogozhnikov/einops/actions/workflows/run_tests.yml)
+[![PyPI version](https://badge.fury.io/py/einops.svg)](https://badge.fury.io/py/einops)
+[![Documentation](https://img.shields.io/badge/documentation-link-blue.svg)](https://einops.rocks/)
+![Supported python versions](https://raw.githubusercontent.com/arogozhnikov/einops/main/docs/resources/python_badge.svg)
+
+
+Flexible and powerful tensor operations for readable and reliable code. <br />
+Supports numpy, pytorch, tensorflow, jax, and [others](#supported-frameworks).
+
+## Recent updates:
+
+- 0.8.0: tinygrad backend added, small fixes
+- 0.7.0: no-hassle `torch.compile`, support of [array api standard](https://data-apis.org/array-api/latest/API_specification/index.html) and more
+- 10'000🎉: github reports that more than 10k project use einops
+- einops 0.6.1: paddle backend added
+- einops 0.6 introduces [packing and unpacking](https://github.com/arogozhnikov/einops/blob/main/docs/4-pack-and-unpack.ipynb)
+- einops 0.5: einsum is now a part of einops
+- [Einops paper](https://openreview.net/pdf?id=oapKSVM2bcj) is accepted for oral presentation at ICLR 2022 (yes, it worth reading).
+  Talk recordings are [available](https://iclr.cc/virtual/2022/oral/6603)
+
+
+<details markdown="1">
+<summary>Previous updates</summary>
+- flax and oneflow backend added
+- torch.jit.script is supported for pytorch layers
+- powerful EinMix added to einops. [Einmix tutorial notebook](https://github.com/arogozhnikov/einops/blob/main/docs/3-einmix-layer.ipynb) 
+</details>
+
+<!--<div align="center">
+  <img src="http://arogozhnikov.github.io/images/einops/einops_logo_350x350.png" 
+  alt="einops package logo" width="250" height="250" />
+  <br><br>
+</div> -->
+
+
+## Tweets 
+
+> In case you need convincing arguments for setting aside time to learn about einsum and einops...
+[Tim Rocktäschel](https://twitter.com/_rockt/status/1230818967205425152)
+
+> Writing better code with PyTorch and einops 👌
+[Andrej Karpathy](https://twitter.com/karpathy/status/1290826075916779520)
+
+> Slowly but surely, einops is seeping in to every nook and cranny of my code. If you find yourself shuffling around bazillion dimensional tensors, this might change your life
+[Nasim Rahaman](https://twitter.com/nasim_rahaman/status/1216022614755463169)
+
+[More testimonials](https://einops.rocks/pages/testimonials/)
+
+
+## Contents
+
+- [Installation](#Installation)
+- [Documentation](https://einops.rocks/)
+- [Tutorial](#Tutorials)
+- [API micro-reference](#API)
+- [Why use einops](#Why-use-einops-notation)
+- [Supported frameworks](#Supported-frameworks)
+- [Citing](#Citing)
+- [Repository](https://github.com/arogozhnikov/einops) and [discussions](https://github.com/arogozhnikov/einops/discussions)
+
+## Installation  <a name="Installation"></a>
+
+Plain and simple:
+```bash
+pip install einops
+```
+
+(`uv pip install einops` works as well)
+
+## Tutorials <a name="Tutorials"></a>
+
+Tutorials are the most convenient way to see `einops` in action
+
+- part 1: [einops fundamentals](https://github.com/arogozhnikov/einops/blob/main/docs/1-einops-basics.ipynb)
+- part 2: [einops for deep learning](https://github.com/arogozhnikov/einops/blob/main/docs/2-einops-for-deep-learning.ipynb)
+- part 3: [packing and unpacking](https://github.com/arogozhnikov/einops/blob/main/docs/4-pack-and-unpack.ipynb)
+- part 4: [improve pytorch code with einops](http://einops.rocks/pytorch-examples.html)
+
+Kapil Sachdeva recorded a small [intro to einops](https://www.youtube.com/watch?v=xGy75Pjsqzo).
+
+## API <a name="API"></a>
+
+`einops` has a minimalistic yet powerful API.
+
+Three core operations provided ([einops tutorial](https://github.com/arogozhnikov/einops/blob/main/docs/)
+shows those cover stacking, reshape, transposition, squeeze/unsqueeze, repeat, tile, concatenate, view and numerous reductions)
+
+```python
+from einops import rearrange, reduce, repeat
+# rearrange elements according to the pattern
+output_tensor = rearrange(input_tensor, 't b c -> b c t')
+# combine rearrangement and reduction
+output_tensor = reduce(input_tensor, 'b c (h h2) (w w2) -> b h w c', 'mean', h2=2, w2=2)
+# copy along a new axis
+output_tensor = repeat(input_tensor, 'h w -> h w c', c=3)
+```
+
+Later additions to the family are `pack` and `unpack` functions (better than stack/split/concatenate):
+
+```python
+from einops import pack, unpack
+# pack and unpack allow reversibly 'packing' multiple tensors into one.
+# Packed tensors may be of different dimensionality:
+packed,  ps = pack([class_token_bc, image_tokens_bhwc, text_tokens_btc], 'b * c')
+class_emb_bc, image_emb_bhwc, text_emb_btc = unpack(transformer(packed), ps, 'b * c')
+```
+
+Finally, einops provides einsum with a support of multi-lettered names:
+
+```python
+from einops import einsum, pack, unpack
+# einsum is like ... einsum, generic and flexible dot-product
+# but 1) axes can be multi-lettered  2) pattern goes last 3) works with multiple frameworks
+C = einsum(A, B, 'b t1 head c, b t2 head c -> b head t1 t2')
+```
+
+### EinMix
+
+`EinMix` is a generic linear layer, perfect for MLP Mixers and similar architectures.
+
+### Layers
+
+Einops provides layers (`einops` keeps a separate version for each framework) that reflect corresponding functions
+
+```python
+from einops.layers.torch      import Rearrange, Reduce
+from einops.layers.tensorflow import Rearrange, Reduce
+from einops.layers.flax       import Rearrange, Reduce
+from einops.layers.paddle     import Rearrange, Reduce
+```
+
+<details markdown="1">
+<summary>Example of using layers within a pytorch model</summary>
+Example given for pytorch, but code in other frameworks is almost identical
+
+```python 
+from torch.nn import Sequential, Conv2d, MaxPool2d, Linear, ReLU
+from einops.layers.torch import Rearrange
+
+model = Sequential(
+    ...,
+    Conv2d(6, 16, kernel_size=5),
+    MaxPool2d(kernel_size=2),
+    # flattening without need to write forward
+    Rearrange('b c h w -> b (c h w)'),
+    Linear(16*5*5, 120),
+    ReLU(),
+    Linear(120, 10),
+)
+```
+
+No more flatten needed!
+
+Additionally, torch layers as those are script-able and compile-able.
+Operations [are torch.compile-able](https://github.com/arogozhnikov/einops/wiki/Using-torch.compile-with-einops),
+ but not script-able due to limitations of torch.jit.script.
+</details>
+
+
+
+
+## Naming <a name="Naming"></a>
+
+`einops` stands for Einstein-Inspired Notation for operations 
+(though "Einstein operations" is more attractive and easier to remember).
+
+Notation was loosely inspired by Einstein summation (in particular by `numpy.einsum` operation).
+
+## Why use `einops` notation?! <a name="Why-use-einops-notation"></a>
+
+
+### Semantic information (being verbose in expectations)
+
+```python
+y = x.view(x.shape[0], -1)
+y = rearrange(x, 'b c h w -> b (c h w)')
+```
+While these two lines are doing the same job in *some* context,
+the second one provides information about the input and output.
+In other words, `einops` focuses on interface: *what is the input and output*, not *how* the output is computed.
+
+The next operation looks similar:
+
+```python
+y = rearrange(x, 'time c h w -> time (c h w)')
+```
+but it gives the reader a hint:
+this is not an independent batch of images we are processing,
+but rather a sequence (video).
+
+Semantic information makes the code easier to read and maintain.
+
+### Convenient checks
+
+Reconsider the same example:
+
+```python
+y = x.view(x.shape[0], -1) # x: (batch, 256, 19, 19)
+y = rearrange(x, 'b c h w -> b (c h w)')
+```
+The second line checks that the input has four dimensions,
+but you can also specify particular dimensions.
+That's opposed to just writing comments about shapes since comments don't prevent mistakes,
+not tested, and without code review tend to be outdated
+```python
+y = x.view(x.shape[0], -1) # x: (batch, 256, 19, 19)
+y = rearrange(x, 'b c h w -> b (c h w)', c=256, h=19, w=19)
+```
+
+### Result is strictly determined
+
+Below we have at least two ways to define the depth-to-space operation
+```python
+# depth-to-space
+rearrange(x, 'b c (h h2) (w w2) -> b (c h2 w2) h w', h2=2, w2=2)
+rearrange(x, 'b c (h h2) (w w2) -> b (h2 w2 c) h w', h2=2, w2=2)
+```
+There are at least four more ways to do it. Which one is used by the framework?
+
+These details are ignored, since *usually* it makes no difference,
+but it can make a big difference (e.g. if you use grouped convolutions in the next stage),
+and you'd like to specify this in your code.
+
+
+### Uniformity
+
+```python
+reduce(x, 'b c (x dx) -> b c x', 'max', dx=2)
+reduce(x, 'b c (x dx) (y dy) -> b c x y', 'max', dx=2, dy=3)
+reduce(x, 'b c (x dx) (y dy) (z dz) -> b c x y z', 'max', dx=2, dy=3, dz=4)
+```
+These examples demonstrated that we don't use separate operations for 1d/2d/3d pooling,
+those are all defined in a uniform way.
+
+Space-to-depth and depth-to space are defined in many frameworks but how about width-to-height? Here you go:
+
+```python
+rearrange(x, 'b c h (w w2) -> b c (h w2) w', w2=2)
+```
+
+
+### Framework independent behavior
+
+Even simple functions are defined differently by different frameworks
+
+```python
+y = x.flatten() # or flatten(x)
+```
+
+Suppose `x`'s shape was `(3, 4, 5)`, then `y` has shape ...
+
+- numpy, pytorch, cupy, chainer, jax: `(60,)`
+- keras, tensorflow.layers, gluon: `(3, 20)`
+
+`einops` works the same way in all frameworks.
+
+
+### Independence of framework terminology
+
+Example: `tile` vs `repeat` causes lots of confusion. To copy image along width:
+```python
+np.tile(image, (1, 2))    # in numpy
+image.repeat(1, 2)        # pytorch's repeat ~ numpy's tile
+```
+
+With einops you don't need to decipher which axis was repeated:
+```python
+repeat(image, 'h w -> h (tile w)', tile=2)  # in numpy
+repeat(image, 'h w -> h (tile w)', tile=2)  # in pytorch
+repeat(image, 'h w -> h (tile w)', tile=2)  # in tf
+repeat(image, 'h w -> h (tile w)', tile=2)  # in jax
+repeat(image, 'h w -> h (tile w)', tile=2)  # in cupy
+... (etc.)
+```
+
+[Testimonials](https://einops.rocks/pages/testimonials/) provide users' perspective on the same question.
+
+
+## Supported frameworks <a name="Supported-frameworks"></a>
+
+Einops works with ...
+
+- [numpy](http://www.numpy.org/)
+- [pytorch](https://pytorch.org/)
+- [tensorflow](https://www.tensorflow.org/)
+- [jax](https://github.com/google/jax)
+- [cupy](https://github.com/cupy/cupy)
+- [flax](https://github.com/google/flax) (community)
+- [paddle](https://github.com/PaddlePaddle/Paddle) (community)
+- [oneflow](https://github.com/Oneflow-Inc/oneflow) (community)
+- [tinygrad](https://github.com/tinygrad/tinygrad) (community)
+- [pytensor](https://github.com/pymc-devs/pytensor) (community)
+
+
+
+```python
+from einops import rearrange  
+=> from einops.array_api import rearrange
+```
+
+But actually it is even better: einops can be used with *any* framework that supports
+[Python array API standard](https://data-apis.org/array-api/latest/API_specification/index.html),
+to name a few:
+
+- numpy >= 2.0
+- [MLX](https://github.com/ml-explore/mlx)  # yes, einops works with apple's framework
+- [pydata/sparse](https://github.com/pydata/sparse) >= 0.15 # and works with sparse tensors
+- [cubed](https://github.com/cubed-dev/cubed) # and with distributed tensors too
+- [quantco/ndonnx](https://github.com/Quantco/ndonnx)
+- jax
+- cupy
+- dask is supported via [array-api-compat](https://github.com/data-apis/array-api-compat)
+
+
+## Development
+
+Devcontainer is provided, this environment can be used locally, or on your server,
+or within github codespaces. 
+To start with devcontainers in vs code, clone repo, and click 'Reopen in Devcontainer'. 
+
+Starting from einops 0.8.1, einops distributes tests as a part of package.
+
+```bash
+# pip install einops pytest
+python -m einops.tests.run_tests numpy pytorch jax --pip-install
+```
+
+`numpy pytorch jax` is an _example_, any subset of testable frameworks can be provided.
+Every framework is tested against numpy, so it is a requirement for tests.
+
+Specifying `--pip-install` will install requirements in current virtualenv,
+and should be omitted if dependencies are installed locally.
+
+To build/test docs:
+
+```bash
+hatch run docs:serve  # Serving on http://localhost:8000/
+```
+
+
+## Citing einops <a name="Citing"></a>
+
+Please use the following bibtex record
+
+```text
+@inproceedings{
+    rogozhnikov2022einops,
+    title={Einops: Clear and Reliable Tensor Manipulations with Einstein-like Notation},
+    author={Alex Rogozhnikov},
+    booktitle={International Conference on Learning Representations},
+    year={2022},
+    url={https://openreview.net/forum?id=oapKSVM2bcj}
+}
+```
+
+
+## Supported python versions
+
+`einops` works with python 3.9 or later.

lib/python3.11/site-packages/einops-0.8.2.dist-info/RECORD

@@ -0,0 +1,58 @@
+einops-0.8.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+einops-0.8.2.dist-info/METADATA,sha256=C9ZdsENoikT0opYIwculIcky9_928ji72GlEHhUBJlM,13724
+einops-0.8.2.dist-info/RECORD,,
+einops-0.8.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+einops-0.8.2.dist-info/licenses/LICENSE,sha256=MNmENkKW9R_67K1LAe4SfpUlDFBokY1LZvyWIGcj5DQ,1073
+einops/__init__.py,sha256=MwPcYWGHKsJE0Uxlhf7YMv_Sf6vu9W9Y98hy1mRM6zk,438
+einops/__pycache__/__init__.cpython-311.pyc,,
+einops/__pycache__/_backends.cpython-311.pyc,,
+einops/__pycache__/_torch_specific.cpython-311.pyc,,
+einops/__pycache__/array_api.cpython-311.pyc,,
+einops/__pycache__/einops.cpython-311.pyc,,
+einops/__pycache__/packing.cpython-311.pyc,,
+einops/__pycache__/parsing.cpython-311.pyc,,
+einops/_backends.py,sha256=v4snGd66fVWeK0M8e3lNJ9j7_qmd8RMRyJVUTQB5slc,22528
+einops/_torch_specific.py,sha256=QXgLFLDIgDa_Iqtv5gcucEeD3LHALYHJhaXRKgC5f4A,4329
+einops/array_api.py,sha256=7mQ-4yhlWtqmtvcTZyI-pmDOSDbk3qpSCExl4-Vm1-o,5236
+einops/einops.py,sha256=vmx5IWde_ePuzrPDLZZVw_-0Qsare1k8YRRaKt5ZL-8,38079
+einops/experimental/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+einops/experimental/__pycache__/__init__.cpython-311.pyc,,
+einops/experimental/__pycache__/indexing.cpython-311.pyc,,
+einops/experimental/indexing.py,sha256=yFFflW3-kV6_5PPJU7_jOJsJBCWCWlE4dGlu9gwSPXo,121
+einops/layers/__init__.py,sha256=jijwEY07Yr3rBx8N5zwZ-5qfbl-KX2BcRDK8NJFDaWA,3705
+einops/layers/__pycache__/__init__.cpython-311.pyc,,
+einops/layers/__pycache__/_einmix.cpython-311.pyc,,
+einops/layers/__pycache__/flax.cpython-311.pyc,,
+einops/layers/__pycache__/keras.cpython-311.pyc,,
+einops/layers/__pycache__/oneflow.cpython-311.pyc,,
+einops/layers/__pycache__/paddle.cpython-311.pyc,,
+einops/layers/__pycache__/tensorflow.cpython-311.pyc,,
+einops/layers/__pycache__/torch.cpython-311.pyc,,
+einops/layers/_einmix.py,sha256=MQr6rymfMw-nzFmhvaLCcee0o7Ai8a1lmluxndWDAjU,11075
+einops/layers/flax.py,sha256=Hk7L31wR2BHL63950-0hy3ivw4rc8NkgGW9jn1AKs-8,2518
+einops/layers/keras.py,sha256=jxD9ZgYLWsKMkCIwojbBNSrY6c1pfXYhE2AMZa0pNXA,217
+einops/layers/oneflow.py,sha256=djcKEZRJrWvxTuSsO4jJVZojieKiDPdUpP4SOpg_zTM,1864
+einops/layers/paddle.py,sha256=YCHffUB4ha7wG-xEOeR9XcTPl48Kr57k_nBEx-J6FVA,1907
+einops/layers/tensorflow.py,sha256=MjGApMbkb_gwAdGya7uGfPZ7olyETsRzbwymfJHii9E,3322
+einops/layers/torch.py,sha256=BV-PzjoijGU9RGea1HCFuIMx4yccicz767M0jJDIH6U,2405
+einops/packing.py,sha256=EZeGLgMRD78hB-0e80ubXvWHukh0_O_wJCf0Hbbdylo,7660
+einops/parsing.py,sha256=vNPYcAs54-KLX1RtbkypGpsSpujzVkj_dQkZlUinLYw,6805
+einops/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+einops/tests/__init__.py,sha256=CpSdrOGBSspTwuG6cAsYMGAwkTq0VuIBrehM7K-SYwU,3531
+einops/tests/__pycache__/__init__.cpython-311.pyc,,
+einops/tests/__pycache__/run_tests.cpython-311.pyc,,
+einops/tests/__pycache__/test_einsum.cpython-311.pyc,,
+einops/tests/__pycache__/test_examples.cpython-311.pyc,,
+einops/tests/__pycache__/test_layers.cpython-311.pyc,,
+einops/tests/__pycache__/test_ops.cpython-311.pyc,,
+einops/tests/__pycache__/test_other.cpython-311.pyc,,
+einops/tests/__pycache__/test_packing.cpython-311.pyc,,
+einops/tests/__pycache__/test_parsing.cpython-311.pyc,,
+einops/tests/run_tests.py,sha256=efJ2apHPOw1BKNIv5qZSNjHpgjSv0rJ4v9hbPbE7yNE,3072
+einops/tests/test_einsum.py,sha256=Nycwg4a-4_Vz7l5f7mj2KIQ7QVs8P2SQIy1rnDcMOG8,11022
+einops/tests/test_examples.py,sha256=6VVkHgov6hpEyoUGbMzFvRfoWTdP1Wr8RPji7G4pPlw,11510
+einops/tests/test_layers.py,sha256=m8RqmBojvVMgr_ET6mhcGpbfYPasg60jUYux7ZlXhSM,18667
+einops/tests/test_ops.py,sha256=4nxEGJWrmEG6cctYHGYuVVdEs5nUN9ziH7ukQYar44M,26884
+einops/tests/test_other.py,sha256=vkWSJr7sn-COewksivTPaLe-GAmzLt7IEZF9TMnt360,13521
+einops/tests/test_packing.py,sha256=AIBNiy8RftTj8dLv1AdNijkTXfrjCOTSw43fuD6Pfjc,10408
+einops/tests/test_parsing.py,sha256=-YAJeJlhDb3U6xYIDRrtm6p4MSNWogeH6l3-np1wUCA,4389

lib/python3.11/site-packages/einops-0.8.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

lib/python3.11/site-packages/einops-0.8.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Alex Rogozhnikov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lib/python3.11/site-packages/fastapi/.agents/skills/fastapi/SKILL.md

@@ -0,0 +1,436 @@
+---
+name: fastapi
+description: FastAPI best practices and conventions. Use when working with FastAPI APIs and Pydantic models for them. Keeps FastAPI code clean and up to date with the latest features and patterns, updated with new versions. Write new code or refactor and update old code.
+---
+
+# FastAPI
+
+Official FastAPI skill to write code with best practices, keeping up to date with new versions and features.
+
+## Use the `fastapi` CLI
+
+Run the development server on localhost with reload:
+
+```bash
+fastapi dev
+```
+
+
+Run the production server:
+
+```bash
+fastapi run
+```
+
+### Add an entrypoint in `pyproject.toml`
+
+FastAPI CLI will read the entrypoint in `pyproject.toml` to know where the FastAPI app is declared.
+
+```toml
+[tool.fastapi]
+entrypoint = "my_app.main:app"
+```
+
+### Use `fastapi` with a path
+
+When adding the entrypoint to `pyproject.toml` is not possible, or the user explicitly asks not to, or it's running an independent small app, you can pass the app file path to the `fastapi` command:
+
+```bash
+fastapi dev my_app/main.py
+```
+
+Prefer to set the entrypoint in `pyproject.toml` when possible.
+
+## Use `Annotated`
+
+Always prefer the `Annotated` style for parameter and dependency declarations.
+
+It keeps the function signatures working in other contexts, respects the types, allows reusability.
+
+### In Parameter Declarations
+
+Use `Annotated` for parameter declarations, including `Path`, `Query`, `Header`, etc.:
+
+```python
+from typing import Annotated
+
+from fastapi import FastAPI, Path, Query
+
+app = FastAPI()
+
+
+@app.get("/items/{item_id}")
+async def read_item(
+    item_id: Annotated[int, Path(ge=1, description="The item ID")],
+    q: Annotated[str | None, Query(max_length=50)] = None,
+):
+    return {"message": "Hello World"}
+```
+
+instead of:
+
+```python
+# DO NOT DO THIS
+@app.get("/items/{item_id}")
+async def read_item(
+    item_id: int = Path(ge=1, description="The item ID"),
+    q: str | None = Query(default=None, max_length=50),
+):
+    return {"message": "Hello World"}
+```
+
+### For Dependencies
+
+Use `Annotated` for dependencies with `Depends()`.
+
+Unless asked not to, create a new type alias for the dependency to allow re-using it.
+
+```python
+from typing import Annotated
+
+from fastapi import Depends, FastAPI
+
+app = FastAPI()
+
+
+def get_current_user():
+    return {"username": "johndoe"}
+
+
+CurrentUserDep = Annotated[dict, Depends(get_current_user)]
+
+
+@app.get("/items/")
+async def read_item(current_user: CurrentUserDep):
+    return {"message": "Hello World"}
+```
+
+instead of:
+
+```python
+# DO NOT DO THIS
+@app.get("/items/")
+async def read_item(current_user: dict = Depends(get_current_user)):
+    return {"message": "Hello World"}
+```
+
+## Do not use Ellipsis for *path operations* or Pydantic models
+
+Do not use `...` as a default value for required parameters, it's not needed and not recommended.
+
+Do this, without Ellipsis (`...`):
+
+```python
+from typing import Annotated
+
+from fastapi import FastAPI, Query
+from pydantic import BaseModel, Field
+
+
+class Item(BaseModel):
+    name: str
+    description: str | None = None
+    price: float = Field(gt=0)
+
+
+app = FastAPI()
+
+
+@app.post("/items/")
+async def create_item(item: Item, project_id: Annotated[int, Query()]): ...
+```
+
+instead of this:
+
+```python
+# DO NOT DO THIS
+class Item(BaseModel):
+    name: str = ...
+    description: str | None = None
+    price: float = Field(..., gt=0)
+
+
+app = FastAPI()
+
+
+@app.post("/items/")
+async def create_item(item: Item, project_id: Annotated[int, Query(...)]): ...
+```
+
+## Return Type or Response Model
+
+When possible, include a return type. It will be used to validate, filter, document, and serialize the response.
+
+```python
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+    name: str
+    description: str | None = None
+
+
+@app.get("/items/me")
+async def get_item() -> Item:
+    return Item(name="Plumbus", description="All-purpose home device")
+```
+
+**Important**: Return types or response models are what filter data ensuring no sensitive information is exposed. And they are used to serialize data with Pydantic (in Rust), this is the main idea that can increase response performance.
+
+The return type doesn't have to be a Pydantic model, it could be a different type, like a list of integers, or a dict, etc.
+
+### When to use `response_model` instead
+
+If the return type is not the same as the type that you want to use to validate, filter, or serialize, use the `response_model` parameter on the decorator instead.
+
+```python
+from typing import Any
+
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+    name: str
+    description: str | None = None
+
+
+@app.get("/items/me", response_model=Item)
+async def get_item() -> Any:
+    return {"name": "Foo", "description": "A very nice Item"}
+```
+
+This can be particularly useful when filtering data to expose only the public fields and avoid exposing sensitive information.
+
+```python
+from typing import Any
+
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+app = FastAPI()
+
+
+class InternalItem(BaseModel):
+    name: str
+    description: str | None = None
+    secret_key: str
+
+
+class Item(BaseModel):
+    name: str
+    description: str | None = None
+
+
+@app.get("/items/me", response_model=Item)
+async def get_item() -> Any:
+    item = InternalItem(
+        name="Foo", description="A very nice Item", secret_key="supersecret"
+    )
+    return item
+```
+
+## Performance
+
+Do not use `ORJSONResponse` or `UJSONResponse`, they are deprecated.
+
+Instead, declare a return type or response model. Pydantic will handle the data serialization on the Rust side.
+
+## Including Routers
+
+When declaring routers, prefer to add router level parameters like prefix, tags, etc. to the router itself, instead of in `include_router()`.
+
+Do this:
+
+```python
+from fastapi import APIRouter, FastAPI
+
+app = FastAPI()
+
+router = APIRouter(prefix="/items", tags=["items"])
+
+
+@router.get("/")
+async def list_items():
+    return []
+
+
+# In main.py
+app.include_router(router)
+```
+
+instead of this:
+
+```python
+# DO NOT DO THIS
+from fastapi import APIRouter, FastAPI
+
+app = FastAPI()
+
+router = APIRouter()
+
+
+@router.get("/")
+async def list_items():
+    return []
+
+
+# In main.py
+app.include_router(router, prefix="/items", tags=["items"])
+```
+
+There could be exceptions, but try to follow this convention.
+
+Apply shared dependencies at the router level via `dependencies=[Depends(...)]`.
+
+## Dependency Injection
+
+See [the dependency injection reference](references/dependencies.md) for detailed patterns including `yield` with `scope`, and class dependencies.
+
+Use dependencies when the logic can't be declared in Pydantic validation, depends on external resources, needs cleanup (with `yield`), or is shared across endpoints.
+
+Apply shared dependencies at the router level via `dependencies=[Depends(...)]`.
+
+## Async vs Sync *path operations*
+
+Use `async` *path operations* only when fully certain that the logic called inside is compatible with async and await (it's called with `await`) or that doesn't block.
+
+```python
+from fastapi import FastAPI
+
+app = FastAPI()
+
+
+# Use async def when calling async code
+@app.get("/async-items/")
+async def read_async_items():
+    data = await some_async_library.fetch_items()
+    return data
+
+
+# Use plain def when calling blocking/sync code or when in doubt
+@app.get("/items/")
+def read_items():
+    data = some_blocking_library.fetch_items()
+    return data
+```
+
+In case of doubt, or by default, use regular `def` functions, those will be run in a threadpool so they don't block the event loop.
+
+The same rules apply to dependencies.
+
+Make sure blocking code is not run inside of `async` functions. The logic will work, but will damage the performance heavily.
+
+When needing to mix blocking and async code, see Asyncer in [the other tools reference](references/other-tools.md).
+
+## Streaming (JSON Lines, SSE, bytes)
+
+See [the streaming reference](references/streaming.md) for JSON Lines, Server-Sent Events (`EventSourceResponse`, `ServerSentEvent`), and byte streaming (`StreamingResponse`) patterns.
+
+## Tooling
+
+See [the other tools reference](references/other-tools.md) for details on uv, Ruff, ty for package management, linting, type checking, formatting, etc.
+
+## Other Libraries
+
+See [the other tools reference](references/other-tools.md) for details on other libraries:
+
+* Asyncer for handling async and await, concurrency, mixing async and blocking code, prefer it over AnyIO or asyncio.
+* SQLModel for working with SQL databases, prefer it over SQLAlchemy.
+* HTTPX for interacting with HTTP (other APIs), prefer it over Requests.
+
+## Do not use Pydantic RootModels
+
+Do not use Pydantic `RootModel`, instead use regular type annotations with `Annotated` and Pydantic validation utilities.
+
+For example, for a list with validations you could do:
+
+```python
+from typing import Annotated
+
+from fastapi import Body, FastAPI
+from pydantic import Field
+
+app = FastAPI()
+
+
+@app.post("/items/")
+async def create_items(items: Annotated[list[int], Field(min_length=1), Body()]):
+    return items
+```
+
+instead of:
+
+```python
+# DO NOT DO THIS
+from typing import Annotated
+
+from fastapi import FastAPI
+from pydantic import Field, RootModel
+
+app = FastAPI()
+
+
+class ItemList(RootModel[Annotated[list[int], Field(min_length=1)]]):
+    pass
+
+
+@app.post("/items/")
+async def create_items(items: ItemList):
+    return items
+
+```
+
+FastAPI supports these type annotations and will create a Pydantic `TypeAdapter` for them, so that types can work as normally and there's no need for the custom logic and types in RootModels.
+
+## Use one HTTP operation per function
+
+Don't mix HTTP operations in a single function, having one function per HTTP operation helps separate concerns and organize the code.
+
+Do this:
+
+```python
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+    name: str
+
+
+@app.get("/items/")
+async def list_items():
+    return []
+
+
+@app.post("/items/")
+async def create_item(item: Item):
+    return item
+```
+
+instead of this:
+
+```python
+# DO NOT DO THIS
+from fastapi import FastAPI, Request
+from pydantic import BaseModel
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+    name: str
+
+
+@app.api_route("/items/", methods=["GET", "POST"])
+async def handle_items(request: Request):
+    if request.method == "GET":
+        return []
+```

lib/python3.11/site-packages/fastapi/.agents/skills/fastapi/references/dependencies.md

@@ -0,0 +1,142 @@
+# Dependency Injection
+
+Use dependencies when:
+
+* They can't be declared in Pydantic validation and require additional logic
+* The logic depends on external resources or could block in any other way
+* Other dependencies need their results (it's a sub-dependency)
+* The logic can be shared by multiple endpoints to do things like error early, authentication, etc.
+* They need to handle cleanup (e.g., DB sessions, file handles), using dependencies with `yield`
+* Their logic needs input data from the request, like headers, query parameters, etc.
+
+## Dependencies with `yield` and `scope`
+
+When using dependencies with `yield`, they can have a `scope` that defines when the exit code is run.
+
+Use the default scope `"request"` to run the exit code after the response is sent back.
+
+```python
+from typing import Annotated
+
+from fastapi import Depends, FastAPI
+
+app = FastAPI()
+
+
+def get_db():
+    db = DBSession()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+DBDep = Annotated[DBSession, Depends(get_db)]
+
+
+@app.get("/items/")
+async def read_items(db: DBDep):
+    return db.query(Item).all()
+```
+
+Use the scope `"function"` when they should run the exit code after the response data is generated but before the response is sent back to the client.
+
+```python
+from typing import Annotated
+
+from fastapi import Depends, FastAPI
+
+app = FastAPI()
+
+
+def get_username():
+    try:
+        yield "Rick"
+    finally:
+        print("Cleanup up before response is sent")
+
+UserNameDep = Annotated[str, Depends(get_username, scope="function")]
+
+@app.get("/users/me")
+def get_user_me(username: UserNameDep):
+    return username
+```
+
+## Class Dependencies
+
+Avoid creating class dependencies when possible.
+
+If a class is needed, instead create a regular function dependency that returns a class instance.
+
+Do this:
+
+```python
+from dataclasses import dataclass
+from typing import Annotated
+
+from fastapi import Depends, FastAPI
+
+app = FastAPI()
+
+
+@dataclass
+class DatabasePaginator:
+    offset: int = 0
+    limit: int = 100
+    q: str | None = None
+
+    def get_page(self) -> dict:
+        # Simulate a page of data
+        return {
+            "offset": self.offset,
+            "limit": self.limit,
+            "q": self.q,
+            "items": [],
+        }
+
+
+def get_db_paginator(
+    offset: int = 0, limit: int = 100, q: str | None = None
+) -> DatabasePaginator:
+    return DatabasePaginator(offset=offset, limit=limit, q=q)
+
+
+PaginatorDep = Annotated[DatabasePaginator, Depends(get_db_paginator)]
+
+
+@app.get("/items/")
+async def read_items(paginator: PaginatorDep):
+    return paginator.get_page()
+```
+
+instead of this:
+
+```python
+# DO NOT DO THIS
+from typing import Annotated
+
+from fastapi import Depends, FastAPI
+
+app = FastAPI()
+
+
+class DatabasePaginator:
+    def __init__(self, offset: int = 0, limit: int = 100, q: str | None = None):
+        self.offset = offset
+        self.limit = limit
+        self.q = q
+
+    def get_page(self) -> dict:
+        # Simulate a page of data
+        return {
+            "offset": self.offset,
+            "limit": self.limit,
+            "q": self.q,
+            "items": [],
+        }
+
+
+@app.get("/items/")
+async def read_items(paginator: Annotated[DatabasePaginator, Depends()]):
+    return paginator.get_page()
+```

lib/python3.11/site-packages/fastapi/.agents/skills/fastapi/references/other-tools.md

@@ -0,0 +1,76 @@
+# Other Tools
+
+## uv
+
+If uv is available, use it to manage dependencies.
+
+## Ruff
+
+If Ruff is available, use it to lint and format the code. Consider enabling the FastAPI rules.
+
+## ty
+
+If ty is available, use it to check types.
+
+## Asyncer
+
+When needing to run blocking code inside of async functions, or async code inside of blocking functions, suggest using Asyncer.
+
+Prefer it over AnyIO or asyncio.
+
+Install:
+
+```bash
+uv add asyncer
+```
+
+Run blocking sync code inside of async with `asyncify()`:
+
+```python
+from asyncer import asyncify
+from fastapi import FastAPI
+
+app = FastAPI()
+
+
+def do_blocking_work(name: str) -> str:
+    # Some blocking I/O operation
+    return f"Hello {name}"
+
+
+@app.get("/items/")
+async def read_items():
+    result = await asyncify(do_blocking_work)(name="World")
+    return {"message": result}
+```
+
+And run async code inside of blocking sync code with `syncify()`:
+
+```python
+from asyncer import syncify
+from fastapi import FastAPI
+
+app = FastAPI()
+
+
+async def do_async_work(name: str) -> str:
+    return f"Hello {name}"
+
+
+@app.get("/items/")
+def read_items():
+    result = syncify(do_async_work)(name="World")
+    return {"message": result}
+```
+
+## SQLModel for SQL databases
+
+When working with SQL databases, prefer using SQLModel as it is integrated with Pydantic and will allow declaring data validation with the same models.
+
+Prefer it over SQLAlchemy.
+
+## HTTPX
+
+Use HTTPX for handling HTTP communication (e.g. with other APIs). It support sync and async usage.
+
+Prefer it over Requests.

lib/python3.11/site-packages/fastapi/.agents/skills/fastapi/references/streaming.md

@@ -0,0 +1,105 @@
+# Streaming
+
+## Stream JSON Lines
+
+To stream JSON Lines, declare the return type and use `yield` to return the data.
+
+```python
+@app.get("/items/stream")
+async def stream_items() -> AsyncIterable[Item]:
+    for item in items:
+        yield item
+```
+
+## Server-Sent Events (SSE)
+
+To stream Server-Sent Events, use `response_class=EventSourceResponse` and `yield` items from the endpoint.
+
+Plain objects are automatically JSON-serialized as `data:` fields, declare the return type so the serialization is done by Pydantic:
+
+```python
+from collections.abc import AsyncIterable
+
+from fastapi import FastAPI
+from fastapi.sse import EventSourceResponse
+from pydantic import BaseModel
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+    name: str
+    price: float
+
+
+@app.get("/items/stream", response_class=EventSourceResponse)
+async def stream_items() -> AsyncIterable[Item]:
+    yield Item(name="Plumbus", price=32.99)
+    yield Item(name="Portal Gun", price=999.99)
+```
+
+For full control over SSE fields (`event`, `id`, `retry`, `comment`), yield `ServerSentEvent` instances:
+
+```python
+from collections.abc import AsyncIterable
+
+from fastapi import FastAPI
+from fastapi.sse import EventSourceResponse, ServerSentEvent
+
+app = FastAPI()
+
+
+@app.get("/events", response_class=EventSourceResponse)
+async def stream_events() -> AsyncIterable[ServerSentEvent]:
+    yield ServerSentEvent(data={"status": "started"}, event="status", id="1")
+    yield ServerSentEvent(data={"progress": 50}, event="progress", id="2")
+```
+
+Use `raw_data` instead of `data` to send pre-formatted strings without JSON encoding:
+
+```python
+yield ServerSentEvent(raw_data="plain text line", event="log")
+```
+
+## Stream bytes
+
+To stream bytes, declare a `response_class=` of `StreamingResponse` or a sub-class, and use `yield` to return the data.
+
+```python
+from fastapi import FastAPI
+from fastapi.responses import StreamingResponse
+from app.utils import read_image
+
+app = FastAPI()
+
+
+class PNGStreamingResponse(StreamingResponse):
+    media_type = "image/png"
+
+@app.get("/image", response_class=PNGStreamingResponse)
+def stream_image_no_async_no_annotation():
+    with read_image() as image_file:
+        yield from image_file
+```
+
+prefer this over returning a `StreamingResponse` directly:
+
+```python
+# DO NOT DO THIS
+
+import anyio
+from fastapi import FastAPI
+from fastapi.responses import StreamingResponse
+from app.utils import read_image
+
+app = FastAPI()
+
+
+class PNGStreamingResponse(StreamingResponse):
+    media_type = "image/png"
+
+
+@app.get("/")
+async def main():
+    return PNGStreamingResponse(read_image())
+```

lib/python3.11/site-packages/fastapi/__init__.py

@@ -0,0 +1,25 @@
+"""FastAPI framework, high performance, easy to learn, fast to code, ready for production"""
+
+__version__ = "0.136.3"
+
+from starlette import status as status
+
+from .applications import FastAPI as FastAPI
+from .background import BackgroundTasks as BackgroundTasks
+from .datastructures import UploadFile as UploadFile
+from .exceptions import HTTPException as HTTPException
+from .exceptions import WebSocketException as WebSocketException
+from .param_functions import Body as Body
+from .param_functions import Cookie as Cookie
+from .param_functions import Depends as Depends
+from .param_functions import File as File
+from .param_functions import Form as Form
+from .param_functions import Header as Header
+from .param_functions import Path as Path
+from .param_functions import Query as Query
+from .param_functions import Security as Security
+from .requests import Request as Request
+from .responses import Response as Response
+from .routing import APIRouter as APIRouter
+from .websockets import WebSocket as WebSocket
+from .websockets import WebSocketDisconnect as WebSocketDisconnect

lib/python3.11/site-packages/fastapi/__main__.py

@@ -0,0 +1,3 @@
+from fastapi.cli import main
+
+main()

lib/python3.11/site-packages/fastapi/_compat/__init__.py

@@ -0,0 +1,40 @@
+from .shared import PYDANTIC_VERSION_MINOR_TUPLE as PYDANTIC_VERSION_MINOR_TUPLE
+from .shared import annotation_is_pydantic_v1 as annotation_is_pydantic_v1
+from .shared import field_annotation_is_scalar as field_annotation_is_scalar
+from .shared import (
+    field_annotation_is_scalar_sequence as field_annotation_is_scalar_sequence,
+)
+from .shared import field_annotation_is_sequence as field_annotation_is_sequence
+from .shared import (
+    is_bytes_or_nonable_bytes_annotation as is_bytes_or_nonable_bytes_annotation,
+)
+from .shared import is_bytes_sequence_annotation as is_bytes_sequence_annotation
+from .shared import is_pydantic_v1_model_instance as is_pydantic_v1_model_instance
+from .shared import (
+    is_uploadfile_or_nonable_uploadfile_annotation as is_uploadfile_or_nonable_uploadfile_annotation,
+)
+from .shared import (
+    is_uploadfile_sequence_annotation as is_uploadfile_sequence_annotation,
+)
+from .shared import lenient_issubclass as lenient_issubclass
+from .shared import sequence_types as sequence_types
+from .shared import value_is_sequence as value_is_sequence
+from .v2 import ModelField as ModelField
+from .v2 import PydanticSchemaGenerationError as PydanticSchemaGenerationError
+from .v2 import RequiredParam as RequiredParam
+from .v2 import Undefined as Undefined
+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 evaluate_forwardref as evaluate_forwardref
+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 .v2 import get_missing_field_error as get_missing_field_error
+from .v2 import get_model_name_map as get_model_name_map
+from .v2 import get_schema_from_model_field as get_schema_from_model_field
+from .v2 import is_scalar_field as is_scalar_field
+from .v2 import serialize_sequence_value as serialize_sequence_value
+from .v2 import (
+    with_info_plain_validator_function as with_info_plain_validator_function,
+)

lib/python3.11/site-packages/fastapi/_compat/shared.py

@@ -0,0 +1,214 @@
+import types
+import typing
+import warnings
+from collections import deque
+from collections.abc import Mapping, Sequence
+from dataclasses import is_dataclass
+from typing import (
+    Annotated,
+    Any,
+    TypeGuard,
+    TypeVar,
+    Union,
+    get_args,
+    get_origin,
+)
+
+from fastapi.types import UnionType
+from pydantic import BaseModel
+from pydantic.version import VERSION as PYDANTIC_VERSION
+from starlette.datastructures import UploadFile
+
+_T = TypeVar("_T")
+
+# Copy from Pydantic: pydantic/_internal/_typing_extra.py
+WithArgsTypes: tuple[Any, ...] = (
+    typing._GenericAlias,  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
+    types.GenericAlias,
+    types.UnionType,
+)  # pyright: ignore[reportAttributeAccessIssue]
+
+PYDANTIC_VERSION_MINOR_TUPLE = tuple(int(x) for x in PYDANTIC_VERSION.split(".")[:2])
+
+
+sequence_annotation_to_type = {
+    Sequence: list,
+    list: list,
+    tuple: tuple,
+    set: set,
+    frozenset: frozenset,
+    deque: deque,
+}
+
+sequence_types: tuple[type[Any], ...] = tuple(sequence_annotation_to_type.keys())
+
+
+# Copy of Pydantic: pydantic/_internal/_utils.py with added TypeGuard
+def lenient_issubclass(
+    cls: Any, class_or_tuple: type[_T] | tuple[type[_T], ...] | None
+) -> TypeGuard[type[_T]]:
+    try:
+        return isinstance(cls, type) and issubclass(cls, class_or_tuple)  # type: ignore[arg-type]  # ty: ignore[invalid-argument-type]
+    except TypeError:  # pragma: no cover
+        if isinstance(cls, WithArgsTypes):
+            return False
+        raise  # pragma: no cover
+
+
+def _annotation_is_sequence(annotation: type[Any] | None) -> bool:
+    if lenient_issubclass(annotation, (str, bytes)):
+        return False
+    return lenient_issubclass(annotation, sequence_types)
+
+
+def field_annotation_is_sequence(annotation: type[Any] | None) -> bool:
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        for arg in get_args(annotation):
+            if field_annotation_is_sequence(arg):
+                return True
+        return False
+    return _annotation_is_sequence(annotation) or _annotation_is_sequence(
+        get_origin(annotation)
+    )
+
+
+def value_is_sequence(value: Any) -> bool:
+    return isinstance(value, sequence_types) and not isinstance(value, (str, bytes))
+
+
+def _annotation_is_complex(annotation: type[Any] | None) -> bool:
+    return (
+        lenient_issubclass(annotation, (BaseModel, Mapping, UploadFile))
+        or _annotation_is_sequence(annotation)
+        or is_dataclass(annotation)
+    )
+
+
+def field_annotation_is_complex(annotation: type[Any] | None) -> bool:
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        return any(field_annotation_is_complex(arg) for arg in get_args(annotation))
+
+    if origin is Annotated:
+        return field_annotation_is_complex(get_args(annotation)[0])
+
+    return (
+        _annotation_is_complex(annotation)
+        or _annotation_is_complex(origin)
+        or hasattr(origin, "__pydantic_core_schema__")
+        or hasattr(origin, "__get_pydantic_core_schema__")
+    )
+
+
+def field_annotation_is_scalar(annotation: Any) -> bool:
+    # handle Ellipsis here to make tuple[int, ...] work nicely
+    return annotation is Ellipsis or not field_annotation_is_complex(annotation)
+
+
+def field_annotation_is_scalar_sequence(annotation: type[Any] | None) -> bool:
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        at_least_one_scalar_sequence = False
+        for arg in get_args(annotation):
+            if field_annotation_is_scalar_sequence(arg):
+                at_least_one_scalar_sequence = True
+                continue
+            elif not field_annotation_is_scalar(arg):
+                return False
+        return at_least_one_scalar_sequence
+    return field_annotation_is_sequence(annotation) and all(
+        field_annotation_is_scalar(sub_annotation)
+        for sub_annotation in get_args(annotation)
+    )
+
+
+def is_bytes_or_nonable_bytes_annotation(annotation: Any) -> bool:
+    if lenient_issubclass(annotation, bytes):
+        return True
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        for arg in get_args(annotation):
+            if lenient_issubclass(arg, bytes):
+                return True
+    return False
+
+
+def is_uploadfile_or_nonable_uploadfile_annotation(annotation: Any) -> bool:
+    if lenient_issubclass(annotation, UploadFile):
+        return True
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        for arg in get_args(annotation):
+            if lenient_issubclass(arg, UploadFile):
+                return True
+    return False
+
+
+def is_bytes_sequence_annotation(annotation: Any) -> bool:
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        at_least_one = False
+        for arg in get_args(annotation):
+            if is_bytes_sequence_annotation(arg):
+                at_least_one = True
+                continue
+        return at_least_one
+    return field_annotation_is_sequence(annotation) and all(
+        is_bytes_or_nonable_bytes_annotation(sub_annotation)
+        for sub_annotation in get_args(annotation)
+    )
+
+
+def is_uploadfile_sequence_annotation(annotation: Any) -> bool:
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        at_least_one = False
+        for arg in get_args(annotation):
+            if is_uploadfile_sequence_annotation(arg):
+                at_least_one = True
+                continue
+        return at_least_one
+    return field_annotation_is_sequence(annotation) and all(
+        is_uploadfile_or_nonable_uploadfile_annotation(sub_annotation)
+        for sub_annotation in get_args(annotation)
+    )
+
+
+def is_pydantic_v1_model_instance(obj: Any) -> bool:
+    # TODO: remove this function once the required version of Pydantic fully
+    # removes pydantic.v1
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", UserWarning)
+            from pydantic import v1
+    except ImportError:  # pragma: no cover
+        return False
+    return isinstance(obj, v1.BaseModel)
+
+
+def is_pydantic_v1_model_class(cls: Any) -> bool:
+    # TODO: remove this function once the required version of Pydantic fully
+    # removes pydantic.v1
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", UserWarning)
+            from pydantic import v1
+    except ImportError:  # pragma: no cover
+        return False
+    return lenient_issubclass(cls, v1.BaseModel)
+
+
+def annotation_is_pydantic_v1(annotation: Any) -> bool:
+    if is_pydantic_v1_model_class(annotation):
+        return True
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        for arg in get_args(annotation):
+            if is_pydantic_v1_model_class(arg):
+                return True
+    if field_annotation_is_sequence(annotation):
+        for sub_annotation in get_args(annotation):
+            if annotation_is_pydantic_v1(sub_annotation):
+                return True
+    return False

lib/python3.11/site-packages/fastapi/_compat/v2.py

@@ -0,0 +1,493 @@
+import re
+import warnings
+from collections.abc import Sequence
+from copy import copy
+from dataclasses import dataclass, is_dataclass
+from enum import Enum
+from functools import lru_cache
+from typing import (
+    Annotated,
+    Any,
+    Literal,
+    Union,
+    cast,
+    get_args,
+    get_origin,
+)
+
+from fastapi._compat import lenient_issubclass, shared
+from fastapi.openapi.constants import REF_TEMPLATE
+from fastapi.types import IncEx, ModelNameMap, UnionType
+from pydantic import BaseModel, ConfigDict, Field, TypeAdapter, create_model
+from pydantic import PydanticSchemaGenerationError as PydanticSchemaGenerationError
+from pydantic import PydanticUndefinedAnnotation as PydanticUndefinedAnnotation
+from pydantic import ValidationError as ValidationError
+from pydantic._internal import _typing_extra as _pydantic_typing_extra
+from pydantic._internal._schema_generation_shared import (  # type: ignore[attr-defined]
+    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
+from pydantic_core import CoreSchema as CoreSchema
+from pydantic_core import PydanticUndefined
+from pydantic_core import Url as Url
+from pydantic_core.core_schema import (
+    with_info_plain_validator_function as with_info_plain_validator_function,
+)
+
+RequiredParam = PydanticUndefined
+Undefined = PydanticUndefined
+
+
+def evaluate_forwardref(
+    value: Any,
+    globalns: dict[str, Any] | None = None,
+    localns: dict[str, Any] | None = None,
+) -> Any:
+    # eval_type_lenient has been deprecated since Pydantic v2.10.0b1 (PR #10530)
+    try_eval_type = getattr(_pydantic_typing_extra, "try_eval_type", None)
+    if try_eval_type is not None:
+        return try_eval_type(value, globalns, localns)[0]
+    return _pydantic_typing_extra.eval_type_lenient(  # ty: ignore[deprecated]
+        value, globalns, localns
+    )
+
+
+class GenerateJsonSchema(_GenerateJsonSchema):
+    # TODO: remove when this is merged (or equivalent): https://github.com/pydantic/pydantic/pull/12841
+    # and dropping support for any version of Pydantic before that one (so, in a very long time)
+    def bytes_schema(self, schema: CoreSchema) -> JsonSchemaValue:
+        json_schema = {"type": "string", "contentMediaType": "application/octet-stream"}
+        bytes_mode = (
+            self._config.ser_json_bytes
+            if self.mode == "serialization"
+            else self._config.val_json_bytes
+        )
+        if bytes_mode == "base64":
+            json_schema["contentEncoding"] = "base64"
+        self.update_with_validations(json_schema, schema, self.ValidationsMapping.bytes)
+        return json_schema
+
+
+# TODO: remove when dropping support for Pydantic < v2.12.3
+_Attrs = {
+    "default": ...,
+    "default_factory": None,
+    "alias": None,
+    "alias_priority": None,
+    "validation_alias": None,
+    "serialization_alias": None,
+    "title": None,
+    "field_title_generator": None,
+    "description": None,
+    "examples": None,
+    "exclude": None,
+    "exclude_if": None,
+    "discriminator": None,
+    "deprecated": None,
+    "json_schema_extra": None,
+    "frozen": None,
+    "validate_default": None,
+    "repr": True,
+    "init": None,
+    "init_var": None,
+    "kw_only": None,
+}
+
+
+# TODO: remove when dropping support for Pydantic < v2.12.3
+def asdict(field_info: FieldInfo) -> dict[str, Any]:
+    attributes = {}
+    for attr in _Attrs:
+        value = getattr(field_info, attr, Undefined)
+        if value is not Undefined:
+            attributes[attr] = value
+    return {
+        "annotation": field_info.annotation,
+        "metadata": field_info.metadata,
+        "attributes": attributes,
+    }
+
+
+@dataclass
+class ModelField:
+    field_info: FieldInfo
+    name: str
+    mode: Literal["validation", "serialization"] = "validation"
+    config: ConfigDict | None = None
+
+    @property
+    def alias(self) -> str:
+        a = self.field_info.alias
+        return a if a is not None else self.name
+
+    @property
+    def validation_alias(self) -> str | None:
+        va = self.field_info.validation_alias
+        if isinstance(va, str) and va:
+            return va
+        return None
+
+    @property
+    def serialization_alias(self) -> str | None:
+        sa = self.field_info.serialization_alias
+        return sa or None
+
+    @property
+    def default(self) -> Any:
+        return self.get_default()
+
+    def __post_init__(self) -> None:
+        with warnings.catch_warnings():
+            # Pydantic >= 2.12.0 warns about field specific metadata that is unused
+            # (e.g. `TypeAdapter(Annotated[int, Field(alias='b')])`). In some cases, we
+            # end up building the type adapter from a model field annotation so we
+            # need to ignore the warning:
+            if shared.PYDANTIC_VERSION_MINOR_TUPLE >= (2, 12):
+                from pydantic.warnings import UnsupportedFieldAttributeWarning
+
+                warnings.simplefilter(
+                    "ignore", category=UnsupportedFieldAttributeWarning
+                )
+            # TODO: remove after setting the min Pydantic to v2.12.3
+            # that adds asdict(), and use self.field_info.asdict() instead
+            field_dict = asdict(self.field_info)
+            annotated_args = (
+                field_dict["annotation"],
+                *field_dict["metadata"],
+                # this FieldInfo needs to be created again so that it doesn't include
+                # the old field info metadata and only the rest of the attributes
+                Field(**field_dict["attributes"]),
+            )
+            self._type_adapter: TypeAdapter[Any] = TypeAdapter(
+                Annotated[annotated_args],  # ty: ignore[invalid-type-form]
+                config=self.config,
+            )
+
+    def get_default(self) -> Any:
+        if self.field_info.is_required():
+            return Undefined
+        return self.field_info.get_default(call_default_factory=True)
+
+    def validate(
+        self,
+        value: Any,
+        values: dict[str, Any] = {},  # noqa: B006
+        *,
+        loc: tuple[int | str, ...] = (),
+    ) -> tuple[Any, list[dict[str, Any]]]:
+        try:
+            return (
+                self._type_adapter.validate_python(value, from_attributes=True),
+                [],
+            )
+        except ValidationError as exc:
+            return None, _regenerate_error_with_loc(
+                errors=exc.errors(include_url=False), loc_prefix=loc
+            )
+
+    def serialize(
+        self,
+        value: Any,
+        *,
+        mode: Literal["json", "python"] = "json",
+        include: IncEx | None = None,
+        exclude: IncEx | None = None,
+        by_alias: bool = True,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+    ) -> Any:
+        # What calls this code passes a value that already called
+        # self._type_adapter.validate_python(value)
+        return self._type_adapter.dump_python(
+            value,
+            mode=mode,
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+        )
+
+    def serialize_json(
+        self,
+        value: Any,
+        *,
+        include: IncEx | None = None,
+        exclude: IncEx | None = None,
+        by_alias: bool = True,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+    ) -> bytes:
+        # What calls this code passes a value that already called
+        # self._type_adapter.validate_python(value)
+        # This uses Pydantic's dump_json() which serializes directly to JSON
+        # bytes in one pass (via Rust), avoiding the intermediate Python dict
+        # step of dump_python(mode="json") + json.dumps().
+        return self._type_adapter.dump_json(
+            value,
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+        )
+
+    def __hash__(self) -> int:
+        # Each ModelField is unique for our purposes, to allow making a dict from
+        # ModelField to its JSON Schema.
+        return id(self)
+
+
+def _has_computed_fields(field: ModelField) -> bool:
+    computed_fields = field._type_adapter.core_schema.get("schema", {}).get(
+        "computed_fields", []
+    )
+    return len(computed_fields) > 0
+
+
+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]:
+    override_mode: Literal["validation"] | None = (
+        None
+        if (separate_input_output_schemas or _has_computed_fields(field))
+        else "validation"
+    )
+    field_alias = (
+        (field.validation_alias or field.alias)
+        if field.mode == "validation"
+        else (field.serialization_alias or field.alias)
+    )
+
+    # This expects that GenerateJsonSchema was already used to generate the definitions
+    json_schema = field_mapping[(field, override_mode or field.mode)]
+    if "$ref" not in json_schema:
+        # TODO remove when deprecating Pydantic v1
+        # Ref: https://github.com/pydantic/pydantic/blob/d61792cc42c80b13b23e3ffa74bc37ec7c77f7d1/pydantic/schema.py#L207
+        json_schema["title"] = field.field_info.title or field_alias.title().replace(
+            "_", " "
+        )
+    return json_schema
+
+
+def get_definitions(
+    *,
+    fields: Sequence[ModelField],
+    model_name_map: ModelNameMap,
+    separate_input_output_schemas: bool = True,
+) -> tuple[
+    dict[tuple[ModelField, Literal["validation", "serialization"]], JsonSchemaValue],
+    dict[str, dict[str, Any]],
+]:
+    schema_generator = GenerateJsonSchema(ref_template=REF_TEMPLATE)
+    validation_fields = [field for field in fields if field.mode == "validation"]
+    serialization_fields = [field for field in fields if field.mode == "serialization"]
+    flat_validation_models = get_flat_models_from_fields(
+        validation_fields, known_models=set()
+    )
+    flat_serialization_models = get_flat_models_from_fields(
+        serialization_fields, known_models=set()
+    )
+    flat_validation_model_fields = [
+        ModelField(
+            field_info=FieldInfo(annotation=model),
+            name=model.__name__,
+            mode="validation",
+        )
+        for model in flat_validation_models
+    ]
+    flat_serialization_model_fields = [
+        ModelField(
+            field_info=FieldInfo(annotation=model),
+            name=model.__name__,
+            mode="serialization",
+        )
+        for model in flat_serialization_models
+    ]
+    flat_model_fields = flat_validation_model_fields + flat_serialization_model_fields
+    input_types = {f.field_info.annotation for f in fields}
+    unique_flat_model_fields = {
+        f for f in flat_model_fields if f.field_info.annotation not in input_types
+    }
+    inputs = [
+        (
+            field,
+            (
+                field.mode
+                if (separate_input_output_schemas or _has_computed_fields(field))
+                else "validation"
+            ),
+            field._type_adapter.core_schema,
+        )
+        for field in list(fields) + list(unique_flat_model_fields)
+    ]
+    field_mapping, definitions = schema_generator.generate_definitions(inputs=inputs)
+    for item_def in cast(dict[str, dict[str, Any]], definitions).values():
+        if "description" in item_def:
+            item_description = cast(str, item_def["description"]).split("\f")[0]
+            item_def["description"] = item_description
+    # definitions: dict[DefsRef, dict[str, Any]]
+    # but mypy complains about general str in other places that are not declared as
+    # DefsRef, although DefsRef is just str:
+    # DefsRef = NewType('DefsRef', str)
+    # So, a cast to simplify the types here
+    return field_mapping, cast(dict[str, dict[str, Any]], definitions)
+
+
+def is_scalar_field(field: ModelField) -> bool:
+    from fastapi import params
+
+    return shared.field_annotation_is_scalar(
+        field.field_info.annotation
+    ) and not isinstance(field.field_info, params.Body)
+
+
+def copy_field_info(*, field_info: FieldInfo, annotation: Any) -> FieldInfo:
+    cls = type(field_info)
+    merged_field_info = cls.from_annotation(annotation)
+    new_field_info = copy(field_info)
+    new_field_info.metadata = merged_field_info.metadata
+    new_field_info.annotation = merged_field_info.annotation
+    return new_field_info
+
+
+def serialize_sequence_value(*, field: ModelField, value: Any) -> Sequence[Any]:
+    origin_type = get_origin(field.field_info.annotation) or field.field_info.annotation
+    if origin_type is Union or origin_type is UnionType:  # Handle optional sequences
+        union_args = get_args(field.field_info.annotation)
+        for union_arg in union_args:
+            if union_arg is type(None):
+                continue
+            origin_type = get_origin(union_arg) or union_arg
+            break
+    assert issubclass(origin_type, shared.sequence_types)  # type: ignore[arg-type]  # ty: ignore[invalid-argument-type]
+    return shared.sequence_annotation_to_type[origin_type](value)  # type: ignore[no-any-return,index]  # ty: ignore[invalid-return-type]
+
+
+def get_missing_field_error(loc: tuple[int | str, ...]) -> dict[str, Any]:
+    error = ValidationError.from_exception_data(
+        "Field required", [{"type": "missing", "loc": loc, "input": {}}]
+    ).errors(include_url=False)[0]
+    error["input"] = None
+    return error  # type: ignore[return-value]  # ty: ignore[invalid-return-type]
+
+
+def create_body_model(
+    *, fields: Sequence[ModelField], model_name: str
+) -> type[BaseModel]:
+    field_params = {f.name: (f.field_info.annotation, f.field_info) for f in fields}
+    BodyModel: type[BaseModel] = create_model(model_name, **field_params)  # type: ignore[call-overload]  # ty: ignore[no-matching-overload]
+    return BodyModel
+
+
+def get_model_fields(model: type[BaseModel]) -> list[ModelField]:
+    model_fields: list[ModelField] = []
+    for name, field_info in model.model_fields.items():
+        type_ = field_info.annotation
+        if lenient_issubclass(type_, (BaseModel, dict)) or is_dataclass(type_):
+            model_config = None
+        else:
+            model_config = model.model_config
+        model_fields.append(
+            ModelField(
+                field_info=field_info,
+                name=name,
+                config=model_config,
+            )
+        )
+    return model_fields
+
+
+@lru_cache
+def get_cached_model_fields(model: type[BaseModel]) -> list[ModelField]:
+    return get_model_fields(model)
+
+
+# Duplicate of several schema functions from Pydantic v1 to make them compatible with
+# Pydantic v2 and allow mixing the models
+
+TypeModelOrEnum = type["BaseModel"] | type[Enum]
+TypeModelSet = set[TypeModelOrEnum]
+
+
+def normalize_name(name: str) -> str:
+    return re.sub(r"[^a-zA-Z0-9.\-_]", "_", name)
+
+
+def get_model_name_map(unique_models: TypeModelSet) -> dict[TypeModelOrEnum, str]:
+    name_model_map = {}
+    for model in unique_models:
+        model_name = normalize_name(model.__name__)
+        name_model_map[model_name] = model
+    return {v: k for k, v in name_model_map.items()}
+
+
+def get_flat_models_from_model(
+    model: type["BaseModel"], known_models: TypeModelSet | None = None
+) -> TypeModelSet:
+    known_models = known_models or set()
+    fields = get_model_fields(model)
+    get_flat_models_from_fields(fields, known_models=known_models)
+    return known_models
+
+
+def get_flat_models_from_annotation(
+    annotation: Any, known_models: TypeModelSet
+) -> TypeModelSet:
+    origin = get_origin(annotation)
+    if origin is not None:
+        for arg in get_args(annotation):
+            if lenient_issubclass(arg, (BaseModel, Enum)):
+                if arg not in known_models:
+                    known_models.add(arg)  # type: ignore[arg-type]
+                    if lenient_issubclass(arg, BaseModel):
+                        get_flat_models_from_model(arg, known_models=known_models)
+            else:
+                get_flat_models_from_annotation(arg, known_models=known_models)
+    return known_models
+
+
+def get_flat_models_from_field(
+    field: ModelField, known_models: TypeModelSet
+) -> TypeModelSet:
+    field_type = field.field_info.annotation
+    if lenient_issubclass(field_type, BaseModel):
+        if field_type in known_models:
+            return known_models
+        known_models.add(field_type)
+        get_flat_models_from_model(field_type, known_models=known_models)
+    elif lenient_issubclass(field_type, Enum):
+        known_models.add(field_type)
+    else:
+        get_flat_models_from_annotation(field_type, known_models=known_models)
+    return known_models
+
+
+def get_flat_models_from_fields(
+    fields: Sequence[ModelField], known_models: TypeModelSet
+) -> TypeModelSet:
+    for field in fields:
+        get_flat_models_from_field(field, known_models=known_models)
+    return known_models
+
+
+def _regenerate_error_with_loc(
+    *, errors: Sequence[Any], loc_prefix: tuple[str | int, ...]
+) -> list[dict[str, Any]]:
+    updated_loc_errors: list[Any] = [
+        {**err, "loc": loc_prefix + err.get("loc", ())} for err in errors
+    ]
+
+    return updated_loc_errors

lib/python3.11/site-packages/fastapi/background.py

@@ -0,0 +1,61 @@
+from collections.abc import Callable
+from typing import Annotated, Any
+
+from annotated_doc import Doc
+from starlette.background import BackgroundTasks as StarletteBackgroundTasks
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+
+
+class BackgroundTasks(StarletteBackgroundTasks):
+    """
+    A collection of background tasks that will be called after a response has been
+    sent to the client.
+
+    Read more about it in the
+    [FastAPI docs for Background Tasks](https://fastapi.tiangolo.com/tutorial/background-tasks/).
+
+    ## Example
+
+    ```python
+    from fastapi import BackgroundTasks, FastAPI
+
+    app = FastAPI()
+
+
+    def write_notification(email: str, message=""):
+        with open("log.txt", mode="w") as email_file:
+            content = f"notification for {email}: {message}"
+            email_file.write(content)
+
+
+    @app.post("/send-notification/{email}")
+    async def send_notification(email: str, background_tasks: BackgroundTasks):
+        background_tasks.add_task(write_notification, email, message="some notification")
+        return {"message": "Notification sent in the background"}
+    ```
+    """
+
+    def add_task(
+        self,
+        func: Annotated[
+            Callable[P, Any],
+            Doc(
+                """
+                The function to call after the response is sent.
+
+                It can be a regular `def` function or an `async def` function.
+                """
+            ),
+        ],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> None:
+        """
+        Add a function to be called in the background after the response is sent.
+
+        Read more about it in the
+        [FastAPI docs for Background Tasks](https://fastapi.tiangolo.com/tutorial/background-tasks/).
+        """
+        return super().add_task(func, *args, **kwargs)

lib/python3.11/site-packages/fastapi/cli.py

@@ -0,0 +1,13 @@
+try:
+    from fastapi_cli.cli import main as cli_main
+
+except ImportError:  # pragma: no cover
+    cli_main = None  # type: ignore
+
+
+def main() -> None:
+    if not cli_main:  # type: ignore[truthy-function]
+        message = 'To use the fastapi command, please install "fastapi[standard]":\n\n\tpip install "fastapi[standard]"\n'
+        print(message)
+        raise RuntimeError(message)  # noqa: B904
+    cli_main()

lib/python3.11/site-packages/fastapi/concurrency.py

@@ -0,0 +1,41 @@
+from collections.abc import AsyncGenerator
+from contextlib import AbstractContextManager
+from contextlib import asynccontextmanager as asynccontextmanager
+from typing import TypeVar
+
+import anyio.to_thread
+from anyio import CapacityLimiter
+from starlette.concurrency import iterate_in_threadpool as iterate_in_threadpool  # noqa
+from starlette.concurrency import run_in_threadpool as run_in_threadpool  # noqa
+from starlette.concurrency import (  # noqa
+    run_until_first_complete as run_until_first_complete,
+)
+
+_T = TypeVar("_T")
+
+
+@asynccontextmanager
+async def contextmanager_in_threadpool(
+    cm: AbstractContextManager[_T],
+) -> AsyncGenerator[_T, None]:
+    # blocking __exit__ from running waiting on a free thread
+    # can create race conditions/deadlocks if the context manager itself
+    # has its own internal pool (e.g. a database connection pool)
+    # to avoid this we let __exit__ run without a capacity limit
+    # since we're creating a new limiter for each call, any non-zero limit
+    # works (1 is arbitrary)
+    exit_limiter = CapacityLimiter(1)
+    try:
+        yield await run_in_threadpool(cm.__enter__)
+    except Exception as e:
+        ok = bool(
+            await anyio.to_thread.run_sync(
+                cm.__exit__, type(e), e, e.__traceback__, limiter=exit_limiter
+            )
+        )
+        if not ok:
+            raise e
+    else:
+        await anyio.to_thread.run_sync(
+            cm.__exit__, None, None, None, limiter=exit_limiter
+        )

lib/python3.11/site-packages/fastapi/datastructures.py

@@ -0,0 +1,186 @@
+from collections.abc import Callable, Mapping
+from typing import (
+    Annotated,
+    Any,
+    BinaryIO,
+    TypeVar,
+    cast,
+)
+
+from annotated_doc import Doc
+from pydantic import GetJsonSchemaHandler
+from starlette.datastructures import URL as URL  # noqa: F401
+from starlette.datastructures import Address as Address  # noqa: F401
+from starlette.datastructures import FormData as FormData  # noqa: F401
+from starlette.datastructures import Headers as Headers  # noqa: F401
+from starlette.datastructures import QueryParams as QueryParams  # noqa: F401
+from starlette.datastructures import State as State  # noqa: F401
+from starlette.datastructures import UploadFile as StarletteUploadFile
+
+
+class UploadFile(StarletteUploadFile):
+    """
+    A file uploaded in a request.
+
+    Define it as a *path operation function* (or dependency) parameter.
+
+    If you are using a regular `def` function, you can use the `upload_file.file`
+    attribute to access the raw standard Python file (blocking, not async), useful and
+    needed for non-async code.
+
+    Read more about it in the
+    [FastAPI docs for Request Files](https://fastapi.tiangolo.com/tutorial/request-files/).
+
+    ## Example
+
+    ```python
+    from typing import Annotated
+
+    from fastapi import FastAPI, File, UploadFile
+
+    app = FastAPI()
+
+
+    @app.post("/files/")
+    async def create_file(file: Annotated[bytes, File()]):
+        return {"file_size": len(file)}
+
+
+    @app.post("/uploadfile/")
+    async def create_upload_file(file: UploadFile):
+        return {"filename": file.filename}
+    ```
+    """
+
+    file: Annotated[
+        BinaryIO,
+        Doc("The standard Python file object (non-async)."),
+    ]
+    filename: Annotated[str | None, Doc("The original file name.")]
+    size: Annotated[int | None, Doc("The size of the file in bytes.")]
+    headers: Annotated[Headers, Doc("The headers of the request.")]
+    content_type: Annotated[
+        str | None, Doc("The content type of the request, from the headers.")
+    ]
+
+    async def write(
+        self,
+        data: Annotated[
+            bytes,
+            Doc(
+                """
+                The bytes to write to the file.
+                """
+            ),
+        ],
+    ) -> None:
+        """
+        Write some bytes to the file.
+
+        You normally wouldn't use this from a file you read in a request.
+
+        To be awaitable, compatible with async, this is run in threadpool.
+        """
+        return await super().write(data)
+
+    async def read(
+        self,
+        size: Annotated[
+            int,
+            Doc(
+                """
+                The number of bytes to read from the file.
+                """
+            ),
+        ] = -1,
+    ) -> bytes:
+        """
+        Read some bytes from the file.
+
+        To be awaitable, compatible with async, this is run in threadpool.
+        """
+        return await super().read(size)
+
+    async def seek(
+        self,
+        offset: Annotated[
+            int,
+            Doc(
+                """
+                The position in bytes to seek to in the file.
+                """
+            ),
+        ],
+    ) -> None:
+        """
+        Move to a position in the file.
+
+        Any next read or write will be done from that position.
+
+        To be awaitable, compatible with async, this is run in threadpool.
+        """
+        return await super().seek(offset)
+
+    async def close(self) -> None:
+        """
+        Close the file.
+
+        To be awaitable, compatible with async, this is run in threadpool.
+        """
+        return await super().close()
+
+    @classmethod
+    def _validate(cls, __input_value: Any, _: Any) -> "UploadFile":
+        if not isinstance(__input_value, StarletteUploadFile):
+            raise ValueError(f"Expected UploadFile, received: {type(__input_value)}")
+        return cast(UploadFile, __input_value)
+
+    @classmethod
+    def __get_pydantic_json_schema__(
+        cls, core_schema: Mapping[str, Any], handler: GetJsonSchemaHandler
+    ) -> dict[str, Any]:
+        return {"type": "string", "contentMediaType": "application/octet-stream"}
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source: type[Any], handler: Callable[[Any], Mapping[str, Any]]
+    ) -> Mapping[str, Any]:
+        from ._compat.v2 import with_info_plain_validator_function
+
+        return with_info_plain_validator_function(cls._validate)
+
+
+class DefaultPlaceholder:
+    """
+    You shouldn't use this class directly.
+
+    It's used internally to recognize when a default value has been overwritten, even
+    if the overridden default value was truthy.
+    """
+
+    def __init__(self, value: Any):
+        self.value = value
+
+    def __bool__(self) -> bool:
+        return bool(self.value)
+
+    def __eq__(self, o: object) -> bool:
+        return isinstance(o, DefaultPlaceholder) and o.value == self.value
+
+
+DefaultType = TypeVar("DefaultType")
+
+
+def Default(value: DefaultType) -> DefaultType:
+    """
+    You shouldn't use this function directly.
+
+    It's used internally to recognize when a default value has been overwritten, even
+    if the overridden default value was truthy.
+    """
+    return DefaultPlaceholder(value)  # type: ignore
+
+
+# Sentinel for "parameter not provided" in Param/FieldInfo.
+# Typed as None to satisfy ty
+_Unset = Default(None)

lib/python3.11/site-packages/fastapi/dependencies/models.py

@@ -0,0 +1,193 @@
+import inspect
+import sys
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from functools import cached_property, partial
+from typing import Any, Literal
+
+from fastapi._compat import ModelField
+from fastapi.security.base import SecurityBase
+from fastapi.types import DependencyCacheKey
+
+if sys.version_info >= (3, 13):  # pragma: no cover
+    from inspect import iscoroutinefunction
+else:  # pragma: no cover
+    from asyncio import iscoroutinefunction
+
+
+def _unwrapped_call(call: Callable[..., Any] | None) -> Any:
+    if call is None:
+        return call  # pragma: no cover
+    unwrapped = inspect.unwrap(_impartial(call))
+    return unwrapped
+
+
+def _impartial(func: Callable[..., Any]) -> Callable[..., Any]:
+    while isinstance(func, partial):
+        func = func.func
+    return func
+
+
+@dataclass
+class Dependant:
+    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)
+    name: str | None = None
+    call: Callable[..., Any] | None = None
+    request_param_name: str | None = None
+    websocket_param_name: str | None = None
+    http_connection_param_name: str | None = None
+    response_param_name: str | None = None
+    background_tasks_param_name: str | None = None
+    security_scopes_param_name: str | None = None
+    own_oauth_scopes: list[str] | None = None
+    parent_oauth_scopes: list[str] | None = None
+    use_cache: bool = True
+    path: str | None = None
+    scope: Literal["function", "request"] | None = None
+
+    @cached_property
+    def oauth_scopes(self) -> list[str]:
+        scopes = self.parent_oauth_scopes.copy() if self.parent_oauth_scopes else []
+        # This doesn't use a set to preserve order, just in case
+        for scope in self.own_oauth_scopes or []:
+            if scope not in scopes:
+                scopes.append(scope)
+        return scopes
+
+    @cached_property
+    def cache_key(self) -> DependencyCacheKey:
+        scopes_for_cache = (
+            tuple(sorted(set(self.oauth_scopes or []))) if self._uses_scopes else ()
+        )
+        return (
+            self.call,
+            scopes_for_cache,
+            self.computed_scope or "",
+        )
+
+    @cached_property
+    def _uses_scopes(self) -> bool:
+        if self.own_oauth_scopes:
+            return True
+        if self.security_scopes_param_name is not None:
+            return True
+        if self._is_security_scheme:
+            return True
+        for sub_dep in self.dependencies:
+            if sub_dep._uses_scopes:
+                return True
+        return False
+
+    @cached_property
+    def _is_security_scheme(self) -> bool:
+        if self.call is None:
+            return False  # pragma: no cover
+        unwrapped = _unwrapped_call(self.call)
+        return isinstance(unwrapped, SecurityBase)
+
+    # Mainly to get the type of SecurityBase, but it's the same self.call
+    @cached_property
+    def _security_scheme(self) -> SecurityBase:
+        unwrapped = _unwrapped_call(self.call)
+        assert isinstance(unwrapped, SecurityBase)
+        return unwrapped
+
+    @cached_property
+    def _security_dependencies(self) -> list["Dependant"]:
+        security_deps = [dep for dep in self.dependencies if dep._is_security_scheme]
+        return security_deps
+
+    @cached_property
+    def is_gen_callable(self) -> bool:
+        if self.call is None:
+            return False  # pragma: no cover
+        if inspect.isgeneratorfunction(
+            _impartial(self.call)
+        ) or inspect.isgeneratorfunction(_unwrapped_call(self.call)):
+            return True
+        if inspect.isclass(_unwrapped_call(self.call)):
+            return False
+        dunder_call = getattr(_impartial(self.call), "__call__", None)  # noqa: B004
+        if dunder_call is None:
+            return False  # pragma: no cover
+        if inspect.isgeneratorfunction(
+            _impartial(dunder_call)
+        ) or inspect.isgeneratorfunction(_unwrapped_call(dunder_call)):
+            return True
+        dunder_unwrapped_call = getattr(_unwrapped_call(self.call), "__call__", None)  # noqa: B004
+        if dunder_unwrapped_call is None:
+            return False  # pragma: no cover
+        if inspect.isgeneratorfunction(
+            _impartial(dunder_unwrapped_call)
+        ) or inspect.isgeneratorfunction(_unwrapped_call(dunder_unwrapped_call)):
+            return True
+        return False
+
+    @cached_property
+    def is_async_gen_callable(self) -> bool:
+        if self.call is None:
+            return False  # pragma: no cover
+        if inspect.isasyncgenfunction(
+            _impartial(self.call)
+        ) or inspect.isasyncgenfunction(_unwrapped_call(self.call)):
+            return True
+        if inspect.isclass(_unwrapped_call(self.call)):
+            return False
+        dunder_call = getattr(_impartial(self.call), "__call__", None)  # noqa: B004
+        if dunder_call is None:
+            return False  # pragma: no cover
+        if inspect.isasyncgenfunction(
+            _impartial(dunder_call)
+        ) or inspect.isasyncgenfunction(_unwrapped_call(dunder_call)):
+            return True
+        dunder_unwrapped_call = getattr(_unwrapped_call(self.call), "__call__", None)  # noqa: B004
+        if dunder_unwrapped_call is None:
+            return False  # pragma: no cover
+        if inspect.isasyncgenfunction(
+            _impartial(dunder_unwrapped_call)
+        ) or inspect.isasyncgenfunction(_unwrapped_call(dunder_unwrapped_call)):
+            return True
+        return False
+
+    @cached_property
+    def is_coroutine_callable(self) -> bool:
+        if self.call is None:
+            return False  # pragma: no cover
+        if inspect.isroutine(_impartial(self.call)) and iscoroutinefunction(
+            _impartial(self.call)
+        ):
+            return True
+        if inspect.isroutine(_unwrapped_call(self.call)) and iscoroutinefunction(
+            _unwrapped_call(self.call)
+        ):
+            return True
+        if inspect.isclass(_unwrapped_call(self.call)):
+            return False
+        dunder_call = getattr(_impartial(self.call), "__call__", None)  # noqa: B004
+        if dunder_call is None:
+            return False  # pragma: no cover
+        if iscoroutinefunction(_impartial(dunder_call)) or iscoroutinefunction(
+            _unwrapped_call(dunder_call)
+        ):
+            return True
+        dunder_unwrapped_call = getattr(_unwrapped_call(self.call), "__call__", None)  # noqa: B004
+        if dunder_unwrapped_call is None:
+            return False  # pragma: no cover
+        if iscoroutinefunction(
+            _impartial(dunder_unwrapped_call)
+        ) or iscoroutinefunction(_unwrapped_call(dunder_unwrapped_call)):
+            return True
+        return False
+
+    @cached_property
+    def computed_scope(self) -> str | None:
+        if self.scope:
+            return self.scope
+        if self.is_gen_callable or self.is_async_gen_callable:
+            return "request"
+        return None

lib/python3.11/site-packages/fastapi/dependencies/utils.py

@@ -0,0 +1,1061 @@
+import dataclasses
+import inspect
+import sys
+from collections.abc import (
+    AsyncGenerator,
+    AsyncIterable,
+    AsyncIterator,
+    Callable,
+    Generator,
+    Iterable,
+    Iterator,
+    Mapping,
+    Sequence,
+)
+from contextlib import AsyncExitStack, contextmanager
+from copy import copy, deepcopy
+from dataclasses import dataclass
+from typing import (
+    Annotated,
+    Any,
+    ForwardRef,
+    Literal,
+    Union,
+    cast,
+    get_args,
+    get_origin,
+)
+
+from fastapi import params
+from fastapi._compat import (
+    ModelField,
+    RequiredParam,
+    Undefined,
+    copy_field_info,
+    create_body_model,
+    evaluate_forwardref,
+    field_annotation_is_scalar,
+    field_annotation_is_scalar_sequence,
+    field_annotation_is_sequence,
+    get_cached_model_fields,
+    get_missing_field_error,
+    is_bytes_or_nonable_bytes_annotation,
+    is_bytes_sequence_annotation,
+    is_scalar_field,
+    is_uploadfile_or_nonable_uploadfile_annotation,
+    is_uploadfile_sequence_annotation,
+    lenient_issubclass,
+    sequence_types,
+    serialize_sequence_value,
+    value_is_sequence,
+)
+from fastapi.background import BackgroundTasks
+from fastapi.concurrency import (
+    asynccontextmanager,
+    contextmanager_in_threadpool,
+)
+from fastapi.dependencies.models import Dependant
+from fastapi.exceptions import DependencyScopeError
+from fastapi.logger import logger
+from fastapi.security.oauth2 import SecurityScopes
+from fastapi.types import DependencyCacheKey
+from fastapi.utils import create_model_field, get_path_param_names
+from pydantic import BaseModel, Json
+from pydantic.fields import FieldInfo
+from starlette.background import BackgroundTasks as StarletteBackgroundTasks
+from starlette.concurrency import run_in_threadpool
+from starlette.datastructures import (
+    FormData,
+    Headers,
+    ImmutableMultiDict,
+    QueryParams,
+    UploadFile,
+)
+from starlette.requests import HTTPConnection, Request
+from starlette.responses import Response
+from starlette.websockets import WebSocket
+from typing_inspection.typing_objects import is_typealiastype
+
+multipart_not_installed_error = (
+    'Form data requires "python-multipart" to be installed. \n'
+    'You can install "python-multipart" with: \n\n'
+    "pip install python-multipart\n"
+)
+multipart_incorrect_install_error = (
+    'Form data requires "python-multipart" to be installed. '
+    'It seems you installed "multipart" instead. \n'
+    'You can remove "multipart" with: \n\n'
+    "pip uninstall multipart\n\n"
+    'And then install "python-multipart" with: \n\n'
+    "pip install python-multipart\n"
+)
+
+
+def ensure_multipart_is_installed() -> None:
+    try:
+        from python_multipart import __version__
+
+        # Import an attribute that can be mocked/deleted in testing
+        assert __version__ > "0.0.12"
+    except (ImportError, AssertionError):
+        try:
+            # __version__ is available in both multiparts, and can be mocked
+            from multipart import (  # type: ignore[no-redef,import-untyped]
+                __version__,
+            )
+
+            assert __version__
+            try:
+                # parse_options_header is only available in the right multipart
+                from multipart.multipart import (  # type: ignore[import-untyped]
+                    parse_options_header,
+                )
+
+                assert parse_options_header
+            except ImportError:
+                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_parameterless_sub_dependant(*, depends: params.Depends, path: str) -> Dependant:
+    assert callable(depends.dependency), (
+        "A parameter-less dependency must have a callable dependency"
+    )
+    own_oauth_scopes: list[str] = []
+    if isinstance(depends, params.Security) and depends.scopes:
+        own_oauth_scopes.extend(depends.scopes)
+    return get_dependant(
+        path=path,
+        call=depends.dependency,
+        scope=depends.scope,
+        own_oauth_scopes=own_oauth_scopes,
+    )
+
+
+def get_flat_dependant(
+    dependant: Dependant,
+    *,
+    skip_repeats: bool = False,
+    visited: list[DependencyCacheKey] | None = None,
+    parent_oauth_scopes: list[str] | None = None,
+) -> Dependant:
+    if visited is None:
+        visited = []
+    visited.append(dependant.cache_key)
+    use_parent_oauth_scopes = (parent_oauth_scopes or []) + (
+        dependant.oauth_scopes or []
+    )
+
+    flat_dependant = Dependant(
+        path_params=dependant.path_params.copy(),
+        query_params=dependant.query_params.copy(),
+        header_params=dependant.header_params.copy(),
+        cookie_params=dependant.cookie_params.copy(),
+        body_params=dependant.body_params.copy(),
+        name=dependant.name,
+        call=dependant.call,
+        request_param_name=dependant.request_param_name,
+        websocket_param_name=dependant.websocket_param_name,
+        http_connection_param_name=dependant.http_connection_param_name,
+        response_param_name=dependant.response_param_name,
+        background_tasks_param_name=dependant.background_tasks_param_name,
+        security_scopes_param_name=dependant.security_scopes_param_name,
+        own_oauth_scopes=dependant.own_oauth_scopes,
+        parent_oauth_scopes=use_parent_oauth_scopes,
+        use_cache=dependant.use_cache,
+        path=dependant.path,
+        scope=dependant.scope,
+    )
+    for sub_dependant in dependant.dependencies:
+        if skip_repeats and sub_dependant.cache_key in visited:
+            continue
+        flat_sub = get_flat_dependant(
+            sub_dependant,
+            skip_repeats=skip_repeats,
+            visited=visited,
+            parent_oauth_scopes=flat_dependant.oauth_scopes,
+        )
+        flat_dependant.dependencies.append(flat_sub)
+        flat_dependant.path_params.extend(flat_sub.path_params)
+        flat_dependant.query_params.extend(flat_sub.query_params)
+        flat_dependant.header_params.extend(flat_sub.header_params)
+        flat_dependant.cookie_params.extend(flat_sub.cookie_params)
+        flat_dependant.body_params.extend(flat_sub.body_params)
+        flat_dependant.dependencies.extend(flat_sub.dependencies)
+
+    return flat_dependant
+
+
+def _get_flat_fields_from_params(fields: list[ModelField]) -> list[ModelField]:
+    if not fields:
+        return fields
+    first_field = fields[0]
+    if len(fields) == 1 and lenient_issubclass(
+        first_field.field_info.annotation, BaseModel
+    ):
+        fields_to_extract = get_cached_model_fields(first_field.field_info.annotation)
+        return fields_to_extract
+    return fields
+
+
+def get_flat_params(dependant: Dependant) -> list[ModelField]:
+    flat_dependant = get_flat_dependant(dependant, skip_repeats=True)
+    path_params = _get_flat_fields_from_params(flat_dependant.path_params)
+    query_params = _get_flat_fields_from_params(flat_dependant.query_params)
+    header_params = _get_flat_fields_from_params(flat_dependant.header_params)
+    cookie_params = _get_flat_fields_from_params(flat_dependant.cookie_params)
+    return path_params + query_params + header_params + cookie_params
+
+
+def _get_signature(call: Callable[..., Any]) -> inspect.Signature:
+    try:
+        signature = inspect.signature(call, eval_str=True)
+    except NameError:
+        # Handle type annotations with if TYPE_CHECKING, not used by FastAPI
+        # e.g. dependency return types
+        if sys.version_info >= (3, 14):
+            from annotationlib import Format
+
+            signature = inspect.signature(call, annotation_format=Format.FORWARDREF)
+        else:
+            signature = inspect.signature(call)
+    return signature
+
+
+def get_typed_signature(call: Callable[..., Any]) -> inspect.Signature:
+    signature = _get_signature(call)
+    unwrapped = inspect.unwrap(call)
+    globalns = getattr(unwrapped, "__globals__", {})
+    typed_params = [
+        inspect.Parameter(
+            name=param.name,
+            kind=param.kind,
+            default=param.default,
+            annotation=get_typed_annotation(param.annotation, globalns),
+        )
+        for param in signature.parameters.values()
+    ]
+    typed_signature = inspect.Signature(typed_params)
+    return typed_signature
+
+
+def get_typed_annotation(annotation: Any, globalns: dict[str, Any]) -> Any:
+    if isinstance(annotation, str):
+        annotation = ForwardRef(annotation)
+        annotation = evaluate_forwardref(annotation, globalns, globalns)
+        if annotation is type(None):
+            return None
+    return annotation
+
+
+def get_typed_return_annotation(call: Callable[..., Any]) -> Any:
+    signature = _get_signature(call)
+    unwrapped = inspect.unwrap(call)
+    annotation = signature.return_annotation
+
+    if annotation is inspect.Signature.empty:
+        return None
+
+    globalns = getattr(unwrapped, "__globals__", {})
+    return get_typed_annotation(annotation, globalns)
+
+
+_STREAM_ORIGINS = {
+    AsyncIterable,
+    AsyncIterator,
+    AsyncGenerator,
+    Iterable,
+    Iterator,
+    Generator,
+}
+
+
+def get_stream_item_type(annotation: Any) -> Any | None:
+    origin = get_origin(annotation)
+    if origin is not None and origin in _STREAM_ORIGINS:
+        type_args = get_args(annotation)
+        if type_args:
+            return type_args[0]
+        return Any
+    return None
+
+
+def get_dependant(
+    *,
+    path: str,
+    call: Callable[..., Any],
+    name: str | None = None,
+    own_oauth_scopes: list[str] | None = None,
+    parent_oauth_scopes: list[str] | None = None,
+    use_cache: bool = True,
+    scope: Literal["function", "request"] | None = None,
+) -> Dependant:
+    dependant = Dependant(
+        call=call,
+        name=name,
+        path=path,
+        use_cache=use_cache,
+        scope=scope,
+        own_oauth_scopes=own_oauth_scopes,
+        parent_oauth_scopes=parent_oauth_scopes,
+    )
+    current_scopes = (parent_oauth_scopes or []) + (own_oauth_scopes or [])
+    path_param_names = get_path_param_names(path)
+    endpoint_signature = get_typed_signature(call)
+    signature_params = endpoint_signature.parameters
+    for param_name, param in signature_params.items():
+        is_path_param = param_name in path_param_names
+        param_details = analyze_param(
+            param_name=param_name,
+            annotation=param.annotation,
+            value=param.default,
+            is_path_param=is_path_param,
+        )
+        if param_details.depends is not None:
+            assert param_details.depends.dependency
+            if (
+                (dependant.is_gen_callable or dependant.is_async_gen_callable)
+                and dependant.computed_scope == "request"
+                and param_details.depends.scope == "function"
+            ):
+                assert dependant.call
+                call_name = getattr(dependant.call, "__name__", "<unnamed_callable>")
+                raise DependencyScopeError(
+                    f'The dependency "{call_name}" has a scope of '
+                    '"request", it cannot depend on dependencies with scope "function".'
+                )
+            sub_own_oauth_scopes: list[str] = []
+            if isinstance(param_details.depends, params.Security):
+                if param_details.depends.scopes:
+                    sub_own_oauth_scopes = list(param_details.depends.scopes)
+            sub_dependant = get_dependant(
+                path=path,
+                call=param_details.depends.dependency,
+                name=param_name,
+                own_oauth_scopes=sub_own_oauth_scopes,
+                parent_oauth_scopes=current_scopes,
+                use_cache=param_details.depends.use_cache,
+                scope=param_details.depends.scope,
+            )
+            dependant.dependencies.append(sub_dependant)
+            continue
+        if add_non_field_param_to_dependency(
+            param_name=param_name,
+            type_annotation=param_details.type_annotation,
+            dependant=dependant,
+        ):
+            assert param_details.field is None, (
+                f"Cannot specify multiple FastAPI annotations for {param_name!r}"
+            )
+            continue
+        assert param_details.field is not None
+        if isinstance(param_details.field.field_info, params.Body):
+            dependant.body_params.append(param_details.field)
+        else:
+            add_param_to_fields(field=param_details.field, dependant=dependant)
+    return dependant
+
+
+def add_non_field_param_to_dependency(
+    *, param_name: str, type_annotation: Any, dependant: Dependant
+) -> bool | None:
+    if lenient_issubclass(type_annotation, Request):
+        dependant.request_param_name = param_name
+        return True
+    elif lenient_issubclass(type_annotation, WebSocket):
+        dependant.websocket_param_name = param_name
+        return True
+    elif lenient_issubclass(type_annotation, HTTPConnection):
+        dependant.http_connection_param_name = param_name
+        return True
+    elif lenient_issubclass(type_annotation, Response):
+        dependant.response_param_name = param_name
+        return True
+    elif lenient_issubclass(type_annotation, StarletteBackgroundTasks):
+        dependant.background_tasks_param_name = param_name
+        return True
+    elif lenient_issubclass(type_annotation, SecurityScopes):
+        dependant.security_scopes_param_name = param_name
+        return True
+    return None
+
+
+@dataclass
+class ParamDetails:
+    type_annotation: Any
+    depends: params.Depends | None
+    field: ModelField | None
+
+
+def analyze_param(
+    *,
+    param_name: str,
+    annotation: Any,
+    value: Any,
+    is_path_param: bool,
+) -> ParamDetails:
+    field_info = None
+    depends = None
+    type_annotation: Any = Any
+    use_annotation: Any = Any
+    if is_typealiastype(annotation):
+        # unpack in case PEP 695 type syntax is used
+        annotation = annotation.__value__
+    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]
+        fastapi_annotations = [
+            arg
+            for arg in annotated_args[1:]
+            if isinstance(arg, (FieldInfo, params.Depends))
+        ]
+        fastapi_specific_annotations = [
+            arg
+            for arg in fastapi_annotations
+            if isinstance(
+                arg,
+                (
+                    params.Param,
+                    params.Body,
+                    params.Depends,
+                ),
+            )
+        ]
+        if fastapi_specific_annotations:
+            fastapi_annotation: FieldInfo | params.Depends | None = (
+                fastapi_specific_annotations[-1]
+            )
+        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(
+                field_info=fastapi_annotation,
+                annotation=use_annotation,
+            )
+            assert (
+                field_info.default == Undefined or field_info.default == RequiredParam
+            ), (
+                f"`{field_info.__class__.__name__}` default value cannot be set in"
+                f" `Annotated` for {param_name!r}. Set the default value with `=` instead."
+            )
+            if value is not inspect.Signature.empty:
+                assert not is_path_param, "Path parameters cannot have default values"
+                field_info.default = value
+            else:
+                field_info.default = RequiredParam
+        # 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"
+            f" together for {param_name!r}"
+        )
+        assert field_info is None, (
+            "Cannot specify a FastAPI annotation in `Annotated` and `Depends` as a"
+            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"
+            f" together for {param_name!r}"
+        )
+        field_info = value
+        if isinstance(field_info, FieldInfo):
+            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 = dataclasses.replace(depends, dependency=type_annotation)
+
+    # Handle non-param type annotations like Request
+    # Only apply special handling when there's no explicit Depends - if there's a Depends,
+    # the dependency will be called and its return value used instead of the special injection
+    if depends is None and lenient_issubclass(
+        type_annotation,
+        (
+            Request,
+            WebSocket,
+            HTTPConnection,
+            Response,
+            StarletteBackgroundTasks,
+            SecurityScopes,
+        ),
+    ):
+        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 RequiredParam
+        if is_path_param:
+            # We might check here that `default_value is RequiredParam`, but the fact is that the same
+            # parameter might sometimes be a path parameter and sometimes not. See
+            # `tests/test_infer_param_optionality.py` for an example.
+            field_info = params.Path(annotation=use_annotation)
+        elif is_uploadfile_or_nonable_uploadfile_annotation(
+            type_annotation
+        ) or is_uploadfile_sequence_annotation(type_annotation):
+            field_info = params.File(annotation=use_annotation, default=default_value)
+        elif not field_annotation_is_scalar(annotation=type_annotation):
+            field_info = params.Body(annotation=use_annotation, default=default_value)
+        else:
+            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"
+                f" {param_name!r}"
+            )
+        elif (
+            isinstance(field_info, params.Param)
+            and getattr(field_info, "in_", None) is None
+        ):
+            field_info.in_ = params.ParamTypes.query
+        use_annotation_from_field_info = use_annotation
+        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_model_field(
+            name=param_name,
+            type_=use_annotation_from_field_info,
+            default=field_info.default,
+            alias=alias,
+            field_info=field_info,
+        )
+        if is_path_param:
+            assert is_scalar_field(field=field), (
+                "Path params must be of one of the supported types"
+            )
+        elif isinstance(field_info, params.Query):
+            assert (
+                is_scalar_field(field)
+                or field_annotation_is_scalar_sequence(field.field_info.annotation)
+                or lenient_issubclass(field.field_info.annotation, BaseModel)
+            ), f"Query parameter {param_name!r} must be one of the supported types"
+
+    return ParamDetails(type_annotation=type_annotation, depends=depends, field=field)
+
+
+def add_param_to_fields(*, field: ModelField, dependant: Dependant) -> None:
+    field_info = field.field_info
+    field_info_in = getattr(field_info, "in_", None)
+    if field_info_in == params.ParamTypes.path:
+        dependant.path_params.append(field)
+    elif field_info_in == params.ParamTypes.query:
+        dependant.query_params.append(field)
+    elif field_info_in == params.ParamTypes.header:
+        dependant.header_params.append(field)
+    else:
+        assert field_info_in == params.ParamTypes.cookie, (
+            f"non-body parameters must be in path, query, header or cookie: {field.name}"
+        )
+        dependant.cookie_params.append(field)
+
+
+async def _solve_generator(
+    *, dependant: Dependant, stack: AsyncExitStack, sub_values: dict[str, Any]
+) -> Any:
+    assert dependant.call
+    if dependant.is_async_gen_callable:
+        cm = asynccontextmanager(dependant.call)(**sub_values)
+    elif dependant.is_gen_callable:
+        cm = contextmanager_in_threadpool(contextmanager(dependant.call)(**sub_values))
+    return await stack.enter_async_context(cm)
+
+
+@dataclass
+class SolvedDependency:
+    values: dict[str, Any]
+    errors: list[Any]
+    background_tasks: StarletteBackgroundTasks | None
+    response: Response
+    dependency_cache: dict[DependencyCacheKey, Any]
+
+
+async def solve_dependencies(
+    *,
+    request: Request | WebSocket,
+    dependant: Dependant,
+    body: dict[str, Any] | FormData | bytes | None = None,
+    background_tasks: StarletteBackgroundTasks | None = None,
+    response: Response | None = None,
+    dependency_overrides_provider: Any | None = None,
+    dependency_cache: dict[DependencyCacheKey, Any] | None = None,
+    # TODO: remove this parameter later, no longer used, not removing it yet as some
+    # people might be monkey patching this function (although that's not supported)
+    async_exit_stack: AsyncExitStack,
+    embed_body_fields: bool,
+) -> SolvedDependency:
+    request_astack = request.scope.get("fastapi_inner_astack")
+    assert isinstance(request_astack, AsyncExitStack), (
+        "fastapi_inner_astack not found in request scope"
+    )
+    function_astack = request.scope.get("fastapi_function_astack")
+    assert isinstance(function_astack, AsyncExitStack), (
+        "fastapi_function_astack not found in request scope"
+    )
+    values: dict[str, Any] = {}
+    errors: list[Any] = []
+    if response is None:
+        response = Response()
+        del response.headers["content-length"]
+        response.status_code = None  # type: ignore
+    if dependency_cache is None:
+        dependency_cache = {}
+    for sub_dependant in dependant.dependencies:
+        sub_dependant.call = cast(Callable[..., Any], sub_dependant.call)
+        call = sub_dependant.call
+        use_sub_dependant = sub_dependant
+        if (
+            dependency_overrides_provider
+            and dependency_overrides_provider.dependency_overrides
+        ):
+            original_call = sub_dependant.call
+            call = getattr(
+                dependency_overrides_provider, "dependency_overrides", {}
+            ).get(original_call, original_call)
+            use_path: str = sub_dependant.path  # type: ignore
+            use_sub_dependant = get_dependant(
+                path=use_path,
+                call=call,
+                name=sub_dependant.name,
+                parent_oauth_scopes=sub_dependant.oauth_scopes,
+                scope=sub_dependant.scope,
+            )
+
+        solved_result = await solve_dependencies(
+            request=request,
+            dependant=use_sub_dependant,
+            body=body,
+            background_tasks=background_tasks,
+            response=response,
+            dependency_overrides_provider=dependency_overrides_provider,
+            dependency_cache=dependency_cache,
+            async_exit_stack=async_exit_stack,
+            embed_body_fields=embed_body_fields,
+        )
+        background_tasks = solved_result.background_tasks
+        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 (
+            use_sub_dependant.is_gen_callable or use_sub_dependant.is_async_gen_callable
+        ):
+            use_astack = request_astack
+            if sub_dependant.scope == "function":
+                use_astack = function_astack
+            solved = await _solve_generator(
+                dependant=use_sub_dependant,
+                stack=use_astack,
+                sub_values=solved_result.values,
+            )
+        elif use_sub_dependant.is_coroutine_callable:
+            solved = await call(**solved_result.values)
+        else:
+            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:
+            dependency_cache[sub_dependant.cache_key] = solved
+    path_values, path_errors = request_params_to_args(
+        dependant.path_params, request.path_params
+    )
+    query_values, query_errors = request_params_to_args(
+        dependant.query_params, request.query_params
+    )
+    header_values, header_errors = request_params_to_args(
+        dependant.header_params, request.headers
+    )
+    cookie_values, cookie_errors = request_params_to_args(
+        dependant.cookie_params, request.cookies
+    )
+    values.update(path_values)
+    values.update(query_values)
+    values.update(header_values)
+    values.update(cookie_values)
+    errors += path_errors + query_errors + header_errors + cookie_errors
+    if dependant.body_params:
+        (
+            body_values,
+            body_errors,
+        ) = await request_body_to_args(  # body_params checked above
+            body_fields=dependant.body_params,
+            received_body=body,
+            embed_body_fields=embed_body_fields,
+        )
+        values.update(body_values)
+        errors.extend(body_errors)
+    if dependant.http_connection_param_name:
+        values[dependant.http_connection_param_name] = request
+    if dependant.request_param_name and isinstance(request, Request):
+        values[dependant.request_param_name] = request
+    elif dependant.websocket_param_name and isinstance(request, WebSocket):
+        values[dependant.websocket_param_name] = request
+    if dependant.background_tasks_param_name:
+        if background_tasks is None:
+            background_tasks = BackgroundTasks()
+        values[dependant.background_tasks_param_name] = background_tasks
+    if dependant.response_param_name:
+        values[dependant.response_param_name] = response
+    if dependant.security_scopes_param_name:
+        values[dependant.security_scopes_param_name] = SecurityScopes(
+            scopes=dependant.oauth_scopes
+        )
+    return SolvedDependency(
+        values=values,
+        errors=errors,
+        background_tasks=background_tasks,
+        response=response,
+        dependency_cache=dependency_cache,
+    )
+
+
+def _validate_value_with_model_field(
+    *, field: ModelField, value: Any, values: dict[str, Any], loc: tuple[str, ...]
+) -> tuple[Any, list[Any]]:
+    if value is None:
+        if field.field_info.is_required():
+            return None, [get_missing_field_error(loc=loc)]
+        else:
+            return deepcopy(field.default), []
+    return field.validate(value, values, loc=loc)
+
+
+def _is_json_field(field: ModelField) -> bool:
+    return any(type(item) is Json for item in field.field_info.metadata)
+
+
+def _get_multidict_value(
+    field: ModelField, values: Mapping[str, Any], alias: str | None = None
+) -> Any:
+    alias = alias or get_validation_alias(field)
+    if (
+        (not _is_json_field(field))
+        and field_annotation_is_sequence(field.field_info.annotation)
+        and isinstance(values, (ImmutableMultiDict, Headers))
+    ):
+        value = values.getlist(alias)
+    else:
+        value = values.get(alias, None)
+    if (
+        value is None
+        or (
+            isinstance(field.field_info, params.Form)
+            and isinstance(value, str)  # For type checks
+            and value == ""
+        )
+        or (
+            field_annotation_is_sequence(field.field_info.annotation)
+            and len(value) == 0
+        )
+    ):
+        if field.field_info.is_required():
+            return
+        else:
+            return deepcopy(field.default)
+    return value
+
+
+def request_params_to_args(
+    fields: Sequence[ModelField],
+    received_params: Mapping[str, Any] | QueryParams | Headers,
+) -> tuple[dict[str, Any], list[Any]]:
+    values: dict[str, Any] = {}
+    errors: list[dict[str, Any]] = []
+
+    if not fields:
+        return values, errors
+
+    first_field = fields[0]
+    fields_to_extract = fields
+    single_not_embedded_field = False
+    default_convert_underscores = True
+    if len(fields) == 1 and lenient_issubclass(
+        first_field.field_info.annotation, BaseModel
+    ):
+        fields_to_extract = get_cached_model_fields(first_field.field_info.annotation)
+        single_not_embedded_field = True
+        # If headers are in a Pydantic model, the way to disable convert_underscores
+        # would be with Header(convert_underscores=False) at the Pydantic model level
+        default_convert_underscores = getattr(
+            first_field.field_info, "convert_underscores", True
+        )
+
+    params_to_process: dict[str, Any] = {}
+
+    processed_keys = set()
+
+    for field in fields_to_extract:
+        alias = None
+        if isinstance(received_params, Headers):
+            # Handle fields extracted from a Pydantic Model for a header, each field
+            # doesn't have a FieldInfo of type Header with the default convert_underscores=True
+            convert_underscores = getattr(
+                field.field_info, "convert_underscores", default_convert_underscores
+            )
+            if convert_underscores:
+                alias = get_validation_alias(field)
+                if alias == field.name:
+                    alias = alias.replace("_", "-")
+        value = _get_multidict_value(field, received_params, alias=alias)
+        if value is not None:
+            params_to_process[get_validation_alias(field)] = value
+        processed_keys.add(alias or get_validation_alias(field))
+        # For headers with convert_underscores=True, mark both the converted
+        # header name and the original field alias as processed to avoid
+        # accepting the original alias as an extra header.
+        processed_keys.add(get_validation_alias(field))
+
+    for key in received_params.keys():
+        if key not in processed_keys:
+            if isinstance(received_params, (ImmutableMultiDict, Headers)):
+                value = received_params.getlist(key)
+                if isinstance(value, list) and (len(value) == 1):
+                    params_to_process[key] = value[0]
+                else:
+                    params_to_process[key] = value
+            else:
+                params_to_process[key] = received_params.get(key)
+
+    if single_not_embedded_field:
+        field_info = first_field.field_info
+        assert isinstance(field_info, params.Param), (
+            "Params must be subclasses of Param"
+        )
+        loc: tuple[str, ...] = (field_info.in_.value,)
+        v_, errors_ = _validate_value_with_model_field(
+            field=first_field, value=params_to_process, values=values, loc=loc
+        )
+        return {first_field.name: v_}, errors_
+
+    for field in fields:
+        value = _get_multidict_value(field, received_params)
+        field_info = field.field_info
+        assert isinstance(field_info, params.Param), (
+            "Params must be subclasses of Param"
+        )
+        loc = (field_info.in_.value, get_validation_alias(field))
+        v_, errors_ = _validate_value_with_model_field(
+            field=field, value=value, values=values, loc=loc
+        )
+        if errors_:
+            errors.extend(errors_)
+        else:
+            values[field.name] = v_
+    return values, errors
+
+
+def is_union_of_base_models(field_type: Any) -> bool:
+    """Check if field type is a Union where all members are BaseModel subclasses."""
+    from fastapi.types import UnionType
+
+    origin = get_origin(field_type)
+
+    # Check if it's a Union type (covers both typing.Union and types.UnionType in Python 3.10+)
+    if origin is not Union and origin is not UnionType:
+        return False
+
+    union_args = get_args(field_type)
+
+    for arg in union_args:
+        if not lenient_issubclass(arg, BaseModel):
+            return False
+
+    return True
+
+
+def _should_embed_body_fields(fields: list[ModelField]) -> bool:
+    if not fields:
+        return False
+    # More than one dependency could have the same field, it would show up as multiple
+    # fields but it's the same one, so count them by name
+    body_param_names_set = {field.name for field in fields}
+    # A top level field has to be a single field, not multiple
+    if len(body_param_names_set) > 1:
+        return True
+    first_field = fields[0]
+    # If it explicitly specifies it is embedded, it has to be embedded
+    if getattr(first_field.field_info, "embed", None):
+        return True
+    # If it's a Form (or File) field, it has to be a BaseModel (or a union of BaseModels) to be top level
+    # otherwise it has to be embedded, so that the key value pair can be extracted
+    if (
+        isinstance(first_field.field_info, params.Form)
+        and not lenient_issubclass(first_field.field_info.annotation, BaseModel)
+        and not is_union_of_base_models(first_field.field_info.annotation)
+    ):
+        return True
+    return False
+
+
+async def _extract_form_body(
+    body_fields: list[ModelField],
+    received_body: FormData,
+) -> dict[str, Any]:
+    values = {}
+
+    for field in body_fields:
+        value = _get_multidict_value(field, received_body)
+        field_info = field.field_info
+        if (
+            isinstance(field_info, params.File)
+            and is_bytes_or_nonable_bytes_annotation(field.field_info.annotation)
+            and isinstance(value, UploadFile)
+        ):
+            value = await value.read()
+        elif (
+            is_bytes_sequence_annotation(field.field_info.annotation)
+            and isinstance(field_info, params.File)
+            and value_is_sequence(value)
+        ):
+            # For types
+            assert isinstance(value, sequence_types)
+            results: list[bytes | str] = []
+            for sub_value in value:
+                results.append(await sub_value.read())
+            value = serialize_sequence_value(field=field, value=results)
+        if value is not None:
+            values[get_validation_alias(field)] = value
+    field_aliases = {get_validation_alias(field) for field in body_fields}
+    for key in received_body.keys():
+        if key not in field_aliases:
+            param_values = received_body.getlist(key)
+            if len(param_values) == 1:
+                values[key] = param_values[0]
+            else:
+                values[key] = param_values
+    return values
+
+
+async def request_body_to_args(
+    body_fields: list[ModelField],
+    received_body: dict[str, Any] | FormData | bytes | None,
+    embed_body_fields: bool,
+) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    values: dict[str, Any] = {}
+    errors: list[dict[str, Any]] = []
+    assert body_fields, "request_body_to_args() should be called with fields"
+    single_not_embedded_field = len(body_fields) == 1 and not embed_body_fields
+    first_field = body_fields[0]
+    body_to_process = received_body
+
+    fields_to_extract: list[ModelField] = body_fields
+
+    if (
+        single_not_embedded_field
+        and lenient_issubclass(first_field.field_info.annotation, BaseModel)
+        and isinstance(received_body, FormData)
+    ):
+        fields_to_extract = get_cached_model_fields(first_field.field_info.annotation)
+
+    if isinstance(received_body, FormData):
+        body_to_process = await _extract_form_body(fields_to_extract, received_body)
+
+    if single_not_embedded_field:
+        loc: tuple[str, ...] = ("body",)
+        v_, errors_ = _validate_value_with_model_field(
+            field=first_field, value=body_to_process, values=values, loc=loc
+        )
+        return {first_field.name: v_}, errors_
+    for field in body_fields:
+        loc = ("body", get_validation_alias(field))
+        value: Any | None = None
+        if body_to_process is not None and not isinstance(body_to_process, bytes):
+            try:
+                value = body_to_process.get(get_validation_alias(field))
+            # If the received body is a list, not a dict
+            except AttributeError:
+                errors.append(get_missing_field_error(loc))
+                continue
+        v_, errors_ = _validate_value_with_model_field(
+            field=field, value=value, values=values, loc=loc
+        )
+        if errors_:
+            errors.extend(errors_)
+        else:
+            values[field.name] = v_
+    return values, errors
+
+
+def get_body_field(
+    *, flat_dependant: Dependant, name: str, embed_body_fields: bool
+) -> ModelField | None:
+    """
+    Get a ModelField representing the request body for a path operation, combining
+    all body parameters into a single field if necessary.
+
+    Used to check if it's form data (with `isinstance(body_field, params.Form)`)
+    or JSON and to generate the JSON Schema for a request body.
+
+    This is **not** used to validate/parse the request body, that's done with each
+    individual body parameter.
+    """
+    if not flat_dependant.body_params:
+        return None
+    first_param = flat_dependant.body_params[0]
+    if not embed_body_fields:
+        return first_param
+    model_name = "Body_" + name
+    BodyModel = create_body_model(
+        fields=flat_dependant.body_params, model_name=model_name
+    )
+    required = any(
+        True for f in flat_dependant.body_params if f.field_info.is_required()
+    )
+    BodyFieldInfo_kwargs: dict[str, Any] = {
+        "annotation": BodyModel,
+        "alias": "body",
+    }
+    if not required:
+        BodyFieldInfo_kwargs["default"] = None
+    if any(isinstance(f.field_info, params.File) for f in flat_dependant.body_params):
+        BodyFieldInfo: type[params.Body] = params.File
+    elif any(isinstance(f.field_info, params.Form) for f in flat_dependant.body_params):
+        BodyFieldInfo = params.Form
+    else:
+        BodyFieldInfo = params.Body
+
+        body_param_media_types = [
+            f.field_info.media_type
+            for f in flat_dependant.body_params
+            if isinstance(f.field_info, params.Body)
+        ]
+        if len(set(body_param_media_types)) == 1:
+            BodyFieldInfo_kwargs["media_type"] = body_param_media_types[0]
+    final_field = create_model_field(
+        name="body",
+        type_=BodyModel,
+        alias="body",
+        field_info=BodyFieldInfo(**BodyFieldInfo_kwargs),
+    )
+    return final_field
+
+
+def get_validation_alias(field: ModelField) -> str:
+    va = getattr(field, "validation_alias", None)
+    return va or field.alias

lib/python3.11/site-packages/fastapi/encoders.py

@@ -0,0 +1,364 @@
+import dataclasses
+import datetime
+from collections import defaultdict, deque
+from collections.abc import Callable
+from decimal import Decimal
+from enum import Enum
+from ipaddress import (
+    IPv4Address,
+    IPv4Interface,
+    IPv4Network,
+    IPv6Address,
+    IPv6Interface,
+    IPv6Network,
+)
+from pathlib import Path, PurePath
+from re import Pattern
+from types import GeneratorType
+from typing import Annotated, Any
+from uuid import UUID
+
+from annotated_doc import Doc
+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
+
+from ._compat import (
+    Url,
+    is_pydantic_v1_model_instance,
+)
+
+try:
+    # pydantic.color.Color is deprecated since v2.0b3, but supporting for bwd-compat
+    from pydantic.color import Color  # ty: ignore[deprecated]
+except ImportError:  # pragma: no cover
+
+    class Color:  # type: ignore[no-redef]
+        pass
+
+
+try:
+    # Supporting the new Color format for newer versions of Pydantic
+    from pydantic_extra_types.color import Color as PyExtraColor
+except ImportError:  # pragma: no cover
+
+    class PyExtraColor:  # type: ignore[no-redef]
+        pass
+
+
+# Taken from Pydantic v1 as is
+def isoformat(o: datetime.date | datetime.time) -> str:
+    return o.isoformat()
+
+
+# Adapted from Pydantic v1
+# TODO: pv2 should this return strings instead?
+def decimal_encoder(dec_value: Decimal) -> int | float:
+    """
+    Encodes a Decimal as int if there's no exponent, otherwise float
+
+    This is useful when we use ConstrainedDecimal to represent Numeric(x,0)
+    where an integer (but not int typed) is used. Encoding this as a float
+    results in failed round-tripping between encode and parse.
+    Our Id type is a prime example of this.
+
+    >>> decimal_encoder(Decimal("1.0"))
+    1.0
+
+    >>> decimal_encoder(Decimal("1"))
+    1
+
+    >>> decimal_encoder(Decimal("NaN"))
+    nan
+    """
+    exponent = dec_value.as_tuple().exponent
+    if isinstance(exponent, int) and exponent >= 0:
+        return int(dec_value)
+    else:
+        return float(dec_value)
+
+
+ENCODERS_BY_TYPE: dict[type[Any], Callable[[Any], Any]] = {
+    bytes: lambda o: o.decode(),
+    Color: str,
+    PyExtraColor: str,
+    datetime.date: isoformat,
+    datetime.datetime: isoformat,
+    datetime.time: isoformat,
+    datetime.timedelta: lambda td: td.total_seconds(),
+    Decimal: decimal_encoder,
+    Enum: lambda o: o.value,
+    frozenset: list,
+    deque: list,
+    GeneratorType: list,
+    IPv4Address: str,
+    IPv4Interface: str,
+    IPv4Network: str,
+    IPv6Address: str,
+    IPv6Interface: str,
+    IPv6Network: str,
+    NameEmail: str,
+    Path: str,
+    Pattern: lambda o: o.pattern,
+    SecretBytes: str,
+    SecretStr: str,
+    set: list,
+    UUID: str,
+    Url: str,
+    AnyUrl: str,
+}
+
+
+def generate_encoders_by_class_tuples(
+    type_encoder_map: dict[Any, Callable[[Any], Any]],
+) -> dict[Callable[[Any], Any], tuple[Any, ...]]:
+    encoders_by_class_tuples: dict[Callable[[Any], Any], tuple[Any, ...]] = defaultdict(
+        tuple
+    )
+    for type_, encoder in type_encoder_map.items():
+        encoders_by_class_tuples[encoder] += (type_,)
+    return encoders_by_class_tuples
+
+
+encoders_by_class_tuples = generate_encoders_by_class_tuples(ENCODERS_BY_TYPE)
+
+
+def jsonable_encoder(
+    obj: Annotated[
+        Any,
+        Doc(
+            """
+            The input object to convert to JSON.
+            """
+        ),
+    ],
+    include: Annotated[
+        IncEx | None,
+        Doc(
+            """
+            Pydantic's `include` parameter, passed to Pydantic models to set the
+            fields to include.
+            """
+        ),
+    ] = None,
+    exclude: Annotated[
+        IncEx | None,
+        Doc(
+            """
+            Pydantic's `exclude` parameter, passed to Pydantic models to set the
+            fields to exclude.
+            """
+        ),
+    ] = None,
+    by_alias: Annotated[
+        bool,
+        Doc(
+            """
+            Pydantic's `by_alias` parameter, passed to Pydantic models to define if
+            the output should use the alias names (when provided) or the Python
+            attribute names. In an API, if you set an alias, it's probably because you
+            want to use it in the result, so you probably want to leave this set to
+            `True`.
+            """
+        ),
+    ] = True,
+    exclude_unset: Annotated[
+        bool,
+        Doc(
+            """
+            Pydantic's `exclude_unset` parameter, passed to Pydantic models to define
+            if it should exclude from the output the fields that were not explicitly
+            set (and that only had their default values).
+            """
+        ),
+    ] = False,
+    exclude_defaults: Annotated[
+        bool,
+        Doc(
+            """
+            Pydantic's `exclude_defaults` parameter, passed to Pydantic models to define
+            if it should exclude from the output the fields that had the same default
+            value, even when they were explicitly set.
+            """
+        ),
+    ] = False,
+    exclude_none: Annotated[
+        bool,
+        Doc(
+            """
+            Pydantic's `exclude_none` parameter, passed to Pydantic models to define
+            if it should exclude from the output any fields that have a `None` value.
+            """
+        ),
+    ] = False,
+    custom_encoder: Annotated[
+        dict[Any, Callable[[Any], Any]] | None,
+        Doc(
+            """
+            Pydantic's `custom_encoder` parameter, passed to Pydantic models to define
+            a custom encoder.
+            """
+        ),
+    ] = None,
+    sqlalchemy_safe: Annotated[
+        bool,
+        Doc(
+            """
+            Exclude from the output any fields that start with the name `_sa`.
+
+            This is mainly a hack for compatibility with SQLAlchemy objects, they
+            store internal SQLAlchemy-specific state in attributes named with `_sa`,
+            and those objects can't (and shouldn't be) serialized to JSON.
+            """
+        ),
+    ] = True,
+) -> Any:
+    """
+    Convert any object to something that can be encoded in JSON.
+
+    This is used internally by FastAPI to make sure anything you return can be
+    encoded as JSON before it is sent to the client.
+
+    You can also use it yourself, for example to convert objects before saving them
+    in a database that supports only JSON.
+
+    Read more about it in the
+    [FastAPI docs for JSON Compatible Encoder](https://fastapi.tiangolo.com/tutorial/encoder/).
+    """
+    custom_encoder = custom_encoder or {}
+    if custom_encoder:
+        if type(obj) in custom_encoder:
+            return custom_encoder[type(obj)](obj)
+        else:
+            for encoder_type, encoder_instance in custom_encoder.items():
+                if isinstance(obj, encoder_type):
+                    return encoder_instance(obj)
+    if include is not None and not isinstance(include, (set, dict)):
+        include = set(include)  # type: ignore[assignment]  # ty: ignore[invalid-assignment]
+    if exclude is not None and not isinstance(exclude, (set, dict)):
+        exclude = set(exclude)  # type: ignore[assignment]  # ty: ignore[invalid-assignment]
+    if isinstance(obj, BaseModel):
+        obj_dict = obj.model_dump(
+            mode="json",
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_none=exclude_none,
+            exclude_defaults=exclude_defaults,
+        )
+        return jsonable_encoder(
+            obj_dict,
+            exclude_none=exclude_none,
+            exclude_defaults=exclude_defaults,
+            sqlalchemy_safe=sqlalchemy_safe,
+        )
+    if dataclasses.is_dataclass(obj):
+        assert not isinstance(obj, type)
+        obj_dict = dataclasses.asdict(obj)
+        return jsonable_encoder(
+            obj_dict,
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+            custom_encoder=custom_encoder,
+            sqlalchemy_safe=sqlalchemy_safe,
+        )
+    if isinstance(obj, Enum):
+        return obj.value
+    if isinstance(obj, PurePath):
+        return str(obj)
+    if isinstance(obj, (str, int, float, type(None))):
+        return obj
+    if isinstance(obj, PydanticUndefinedType):
+        return None
+    if isinstance(obj, dict):
+        encoded_dict = {}
+        allowed_keys = set(obj.keys())
+        if include is not None:
+            allowed_keys &= set(include)
+        if exclude is not None:
+            allowed_keys -= set(exclude)
+        for key, value in obj.items():
+            if (
+                (
+                    not sqlalchemy_safe
+                    or (not isinstance(key, str))
+                    or (not key.startswith("_sa"))
+                )
+                and (value is not None or not exclude_none)
+                and key in allowed_keys
+            ):
+                encoded_key = jsonable_encoder(
+                    key,
+                    by_alias=by_alias,
+                    exclude_unset=exclude_unset,
+                    exclude_none=exclude_none,
+                    custom_encoder=custom_encoder,
+                    sqlalchemy_safe=sqlalchemy_safe,
+                )
+                encoded_value = jsonable_encoder(
+                    value,
+                    by_alias=by_alias,
+                    exclude_unset=exclude_unset,
+                    exclude_none=exclude_none,
+                    custom_encoder=custom_encoder,
+                    sqlalchemy_safe=sqlalchemy_safe,
+                )
+                encoded_dict[encoded_key] = encoded_value
+        return encoded_dict
+    if isinstance(obj, (list, set, frozenset, GeneratorType, tuple, deque)):
+        encoded_list = []
+        for item in obj:
+            encoded_list.append(
+                jsonable_encoder(
+                    item,
+                    include=include,
+                    exclude=exclude,
+                    by_alias=by_alias,
+                    exclude_unset=exclude_unset,
+                    exclude_defaults=exclude_defaults,
+                    exclude_none=exclude_none,
+                    custom_encoder=custom_encoder,
+                    sqlalchemy_safe=sqlalchemy_safe,
+                )
+            )
+        return encoded_list
+
+    if type(obj) in ENCODERS_BY_TYPE:
+        return ENCODERS_BY_TYPE[type(obj)](obj)
+    for encoder, classes_tuple in encoders_by_class_tuples.items():
+        if isinstance(obj, classes_tuple):
+            return encoder(obj)
+    if is_pydantic_v1_model_instance(obj):
+        raise PydanticV1NotSupportedError(
+            "pydantic.v1 models are no longer supported by FastAPI."
+            f" Please update the model {obj!r}."
+        )
+    try:
+        data = dict(obj)
+    except Exception as e:
+        errors: list[Exception] = []
+        errors.append(e)
+        try:
+            data = vars(obj)
+        except Exception as e:
+            errors.append(e)
+            raise ValueError(errors) from e
+    return jsonable_encoder(
+        data,
+        include=include,
+        exclude=exclude,
+        by_alias=by_alias,
+        exclude_unset=exclude_unset,
+        exclude_defaults=exclude_defaults,
+        exclude_none=exclude_none,
+        custom_encoder=custom_encoder,
+        sqlalchemy_safe=sqlalchemy_safe,
+    )

lib/python3.11/site-packages/fastapi/exception_handlers.py

@@ -0,0 +1,34 @@
+from fastapi.encoders import jsonable_encoder
+from fastapi.exceptions import RequestValidationError, WebSocketRequestValidationError
+from fastapi.utils import is_body_allowed_for_status_code
+from fastapi.websockets import WebSocket
+from starlette.exceptions import HTTPException
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+from starlette.status import WS_1008_POLICY_VIOLATION
+
+
+async def http_exception_handler(request: Request, exc: HTTPException) -> Response:
+    headers = getattr(exc, "headers", None)
+    if not is_body_allowed_for_status_code(exc.status_code):
+        return Response(status_code=exc.status_code, headers=headers)
+    return JSONResponse(
+        {"detail": exc.detail}, status_code=exc.status_code, headers=headers
+    )
+
+
+async def request_validation_exception_handler(
+    request: Request, exc: RequestValidationError
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=422,
+        content={"detail": jsonable_encoder(exc.errors())},
+    )
+
+
+async def websocket_request_validation_exception_handler(
+    websocket: WebSocket, exc: WebSocketRequestValidationError
+) -> None:
+    await websocket.close(
+        code=WS_1008_POLICY_VIOLATION, reason=jsonable_encoder(exc.errors())
+    )

lib/python3.11/site-packages/fastapi/exceptions.py

@@ -0,0 +1,256 @@
+from collections.abc import Mapping, Sequence
+from typing import Annotated, Any, TypedDict
+
+from annotated_doc import Doc
+from pydantic import BaseModel, create_model
+from starlette.exceptions import HTTPException as StarletteHTTPException
+from starlette.exceptions import WebSocketException as StarletteWebSocketException
+
+
+class EndpointContext(TypedDict, total=False):
+    function: str
+    path: str
+    file: str
+    line: int
+
+
+class HTTPException(StarletteHTTPException):
+    """
+    An HTTP exception you can raise in your own code to show errors to the client.
+
+    This is for client errors, invalid authentication, invalid data, etc. Not for server
+    errors in your code.
+
+    Read more about it in the
+    [FastAPI docs for Handling Errors](https://fastapi.tiangolo.com/tutorial/handling-errors/).
+
+    ## Example
+
+    ```python
+    from fastapi import FastAPI, HTTPException
+
+    app = FastAPI()
+
+    items = {"foo": "The Foo Wrestlers"}
+
+
+    @app.get("/items/{item_id}")
+    async def read_item(item_id: str):
+        if item_id not in items:
+            raise HTTPException(status_code=404, detail="Item not found")
+        return {"item": items[item_id]}
+    ```
+    """
+
+    def __init__(
+        self,
+        status_code: Annotated[
+            int,
+            Doc(
+                """
+                HTTP status code to send to the client.
+
+                Read more about it in the
+                [FastAPI docs for Handling Errors](https://fastapi.tiangolo.com/tutorial/handling-errors/#use-httpexception)
+                """
+            ),
+        ],
+        detail: Annotated[
+            Any,
+            Doc(
+                """
+                Any data to be sent to the client in the `detail` key of the JSON
+                response.
+
+                Read more about it in the
+                [FastAPI docs for Handling Errors](https://fastapi.tiangolo.com/tutorial/handling-errors/#use-httpexception)
+                """
+            ),
+        ] = None,
+        headers: Annotated[
+            Mapping[str, str] | None,
+            Doc(
+                """
+                Any headers to send to the client in the response.
+
+                Read more about it in the
+                [FastAPI docs for Handling Errors](https://fastapi.tiangolo.com/tutorial/handling-errors/#add-custom-headers)
+
+                """
+            ),
+        ] = None,
+    ) -> None:
+        super().__init__(status_code=status_code, detail=detail, headers=headers)
+
+
+class WebSocketException(StarletteWebSocketException):
+    """
+    A WebSocket exception you can raise in your own code to show errors to the client.
+
+    This is for client errors, invalid authentication, invalid data, etc. Not for server
+    errors in your code.
+
+    Read more about it in the
+    [FastAPI docs for WebSockets](https://fastapi.tiangolo.com/advanced/websockets/).
+
+    ## Example
+
+    ```python
+    from typing import Annotated
+
+    from fastapi import (
+        Cookie,
+        FastAPI,
+        WebSocket,
+        WebSocketException,
+        status,
+    )
+
+    app = FastAPI()
+
+    @app.websocket("/items/{item_id}/ws")
+    async def websocket_endpoint(
+        *,
+        websocket: WebSocket,
+        session: Annotated[str | None, Cookie()] = None,
+        item_id: str,
+    ):
+        if session is None:
+            raise WebSocketException(code=status.WS_1008_POLICY_VIOLATION)
+        await websocket.accept()
+        while True:
+            data = await websocket.receive_text()
+            await websocket.send_text(f"Session cookie is: {session}")
+            await websocket.send_text(f"Message text was: {data}, for item ID: {item_id}")
+    ```
+    """
+
+    def __init__(
+        self,
+        code: Annotated[
+            int,
+            Doc(
+                """
+                A closing code from the
+                [valid codes defined in the specification](https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.1).
+                """
+            ),
+        ],
+        reason: Annotated[
+            str | None,
+            Doc(
+                """
+                The reason to close the WebSocket connection.
+
+                It is UTF-8-encoded data. The interpretation of the reason is up to the
+                application, it is not specified by the WebSocket specification.
+
+                It could contain text that could be human-readable or interpretable
+                by the client code, etc.
+                """
+            ),
+        ] = None,
+    ) -> None:
+        super().__init__(code=code, reason=reason)
+
+
+RequestErrorModel: type[BaseModel] = create_model("Request")
+WebSocketErrorModel: type[BaseModel] = create_model("WebSocket")
+
+
+class FastAPIError(RuntimeError):
+    """
+    A generic, FastAPI-specific error.
+    """
+
+
+class DependencyScopeError(FastAPIError):
+    """
+    A dependency declared that it depends on another dependency with an invalid
+    (narrower) scope.
+    """
+
+
+class ValidationException(Exception):
+    def __init__(
+        self,
+        errors: Sequence[Any],
+        *,
+        endpoint_ctx: EndpointContext | None = None,
+    ) -> None:
+        self._errors = errors
+        self.endpoint_ctx = endpoint_ctx
+
+        ctx = endpoint_ctx or {}
+        self.endpoint_function = ctx.get("function")
+        self.endpoint_path = ctx.get("path")
+        self.endpoint_file = ctx.get("file")
+        self.endpoint_line = ctx.get("line")
+
+    def errors(self) -> Sequence[Any]:
+        return self._errors
+
+    def _format_endpoint_context(self) -> str:
+        if not (self.endpoint_file and self.endpoint_line and self.endpoint_function):
+            if self.endpoint_path:
+                return f"\n  Endpoint: {self.endpoint_path}"
+            return ""
+
+        context = f'\n  File "{self.endpoint_file}", line {self.endpoint_line}, in {self.endpoint_function}'
+        if self.endpoint_path:
+            context += f"\n    {self.endpoint_path}"
+        return context
+
+    def __str__(self) -> str:
+        message = f"{len(self._errors)} validation error{'s' if len(self._errors) != 1 else ''}:\n"
+        for err in self._errors:
+            message += f"  {err}\n"
+        message += self._format_endpoint_context()
+        return message.rstrip()
+
+
+class RequestValidationError(ValidationException):
+    def __init__(
+        self,
+        errors: Sequence[Any],
+        *,
+        body: Any = None,
+        endpoint_ctx: EndpointContext | None = None,
+    ) -> None:
+        super().__init__(errors, endpoint_ctx=endpoint_ctx)
+        self.body = body
+
+
+class WebSocketRequestValidationError(ValidationException):
+    def __init__(
+        self,
+        errors: Sequence[Any],
+        *,
+        endpoint_ctx: EndpointContext | None = None,
+    ) -> None:
+        super().__init__(errors, endpoint_ctx=endpoint_ctx)
+
+
+class ResponseValidationError(ValidationException):
+    def __init__(
+        self,
+        errors: Sequence[Any],
+        *,
+        body: Any = None,
+        endpoint_ctx: EndpointContext | None = None,
+    ) -> None:
+        super().__init__(errors, endpoint_ctx=endpoint_ctx)
+        self.body = body
+
+
+class PydanticV1NotSupportedError(FastAPIError):
+    """
+    A pydantic.v1 model is used, which is no longer supported.
+    """
+
+
+class FastAPIDeprecationWarning(UserWarning):
+    """
+    A custom deprecation warning as DeprecationWarning is ignored
+    Ref: https://sethmlarson.dev/deprecations-via-warnings-dont-work-for-python-libraries
+    """

lib/python3.11/site-packages/fastapi/logger.py

@@ -0,0 +1,3 @@
+import logging
+
+logger = logging.getLogger("fastapi")

lib/python3.11/site-packages/fastapi/middleware/__init__.py

@@ -0,0 +1 @@
+from starlette.middleware import Middleware as Middleware

lib/python3.11/site-packages/fastapi/middleware/asyncexitstack.py

@@ -0,0 +1,18 @@
+from contextlib import AsyncExitStack
+
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+
+# Used mainly to close files after the request is done, dependencies are closed
+# in their own AsyncExitStack
+class AsyncExitStackMiddleware:
+    def __init__(
+        self, app: ASGIApp, context_name: str = "fastapi_middleware_astack"
+    ) -> None:
+        self.app = app
+        self.context_name = context_name
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        async with AsyncExitStack() as stack:
+            scope[self.context_name] = stack
+            await self.app(scope, receive, send)

lib/python3.11/site-packages/fastapi/param_functions.py

@@ -0,0 +1,2460 @@
+from collections.abc import Callable, Sequence
+from typing import Annotated, Any, Literal
+
+from annotated_doc import Doc
+from fastapi import params
+from fastapi._compat import Undefined
+from fastapi.datastructures import _Unset
+from fastapi.openapi.models import Example
+from pydantic import AliasChoices, AliasPath
+from typing_extensions import deprecated
+
+
+def Path(  # noqa: N802
+    default: Annotated[
+        Any,
+        Doc(
+            """
+            Default value if the parameter field is not set.
+
+            This doesn't affect `Path` parameters as the value is always required.
+            The parameter is available only for compatibility.
+            """
+        ),
+    ] = ...,
+    *,
+    default_factory: Annotated[
+        Callable[[], Any] | None,
+        Doc(
+            """
+            A callable to generate the default value.
+
+            This doesn't affect `Path` parameters as the value is always required.
+            The parameter is available only for compatibility.
+            """
+        ),
+    ] = _Unset,
+    alias: Annotated[
+        str | None,
+        Doc(
+            """
+            An alternative name for the parameter field.
+
+            This will be used to extract the data and for the generated OpenAPI.
+            It is particularly useful when you can't use the name you want because it
+            is a Python reserved keyword or similar.
+            """
+        ),
+    ] = None,
+    alias_priority: Annotated[
+        int | None,
+        Doc(
+            """
+            Priority of the alias. This affects whether an alias generator is used.
+            """
+        ),
+    ] = _Unset,
+    validation_alias: Annotated[
+        str | AliasPath | AliasChoices | None,
+        Doc(
+            """
+            'Whitelist' validation step. The parameter field will be the single one
+            allowed by the alias or set of aliases defined.
+            """
+        ),
+    ] = None,
+    serialization_alias: Annotated[
+        str | None,
+        Doc(
+            """
+            'Blacklist' validation step. The vanilla parameter field will be the
+            single one of the alias' or set of aliases' fields and all the other
+            fields will be ignored at serialization time.
+            """
+        ),
+    ] = None,
+    title: Annotated[
+        str | None,
+        Doc(
+            """
+            Human-readable title.
+
+            Read more about it in the
+            [FastAPI docs for Path Parameters and Numeric Validations](https://fastapi.tiangolo.com/tutorial/path-params-numeric-validations/#declare-metadata)
+            """
+        ),
+    ] = None,
+    description: Annotated[
+        str | None,
+        Doc(
+            """
+            Human-readable description.
+            """
+        ),
+    ] = None,
+    gt: Annotated[
+        float | None,
+        Doc(
+            """
+            Greater than. If set, value must be greater than this. Only applicable to
+            numbers.
+
+            Read more about it in the
+            [FastAPI docs about Path parameters numeric validations](https://fastapi.tiangolo.com/tutorial/path-params-numeric-validations/#number-validations-greater-than-and-less-than-or-equal)
+            """
+        ),
+    ] = None,
+    ge: Annotated[
+        float | None,
+        Doc(
+            """
+            Greater than or equal. If set, value must be greater than or equal to
+            this. Only applicable to numbers.
+
+            Read more about it in the
+            [FastAPI docs about Path parameters numeric validations](https://fastapi.tiangolo.com/tutorial/path-params-numeric-validations/#number-validations-greater-than-and-less-than-or-equal)
+            """
+        ),
+    ] = None,
+    lt: Annotated[
+        float | None,
+        Doc(
+            """
+            Less than. If set, value must be less than this. Only applicable to numbers.
+
+            Read more about it in the
+            [FastAPI docs about Path parameters numeric validations](https://fastapi.tiangolo.com/tutorial/path-params-numeric-validations/#number-validations-greater-than-and-less-than-or-equal)
+            """
+        ),
+    ] = None,
+    le: Annotated[
+        float | None,
+        Doc(
+            """
+            Less than or equal. If set, value must be less than or equal to this.
+            Only applicable to numbers.
+
+            Read more about it in the
+            [FastAPI docs about Path parameters numeric validations](https://fastapi.tiangolo.com/tutorial/path-params-numeric-validations/#number-validations-greater-than-and-less-than-or-equal)
+            """
+        ),
+    ] = None,
+    min_length: Annotated[
+        int | None,
+        Doc(
+            """
+            Minimum length for strings.
+            """
+        ),
+    ] = None,
+    max_length: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum length for strings.
+            """
+        ),
+    ] = None,
+    pattern: Annotated[
+        str | None,
+        Doc(
+            """
+            RegEx pattern for strings.
+            """
+        ),
+    ] = None,
+    regex: Annotated[
+        str | None,
+        Doc(
+            """
+            RegEx pattern for strings.
+            """
+        ),
+        deprecated(
+            "Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead."
+        ),
+    ] = None,
+    discriminator: Annotated[
+        str | None,
+        Doc(
+            """
+            Parameter field name for discriminating the type in a tagged union.
+            """
+        ),
+    ] = None,
+    strict: Annotated[
+        bool | None,
+        Doc(
+            """
+            If `True`, strict validation is applied to the field.
+            """
+        ),
+    ] = _Unset,
+    multiple_of: Annotated[
+        float | None,
+        Doc(
+            """
+            Value must be a multiple of this. Only applicable to numbers.
+            """
+        ),
+    ] = _Unset,
+    allow_inf_nan: Annotated[
+        bool | None,
+        Doc(
+            """
+            Allow `inf`, `-inf`, `nan`. Only applicable to numbers.
+            """
+        ),
+    ] = _Unset,
+    max_digits: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum number of digits allowed for decimal values.
+            """
+        ),
+    ] = _Unset,
+    decimal_places: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum number of decimal places allowed for decimal values.
+            """
+        ),
+    ] = _Unset,
+    examples: Annotated[
+        list[Any] | None,
+        Doc(
+            """
+            Example values for this field.
+
+            Read more about it in the
+            [FastAPI docs for Declare Request Example Data](https://fastapi.tiangolo.com/tutorial/schema-extra-example/)
+            """
+        ),
+    ] = None,
+    example: Annotated[
+        Any | None,
+        deprecated(
+            "Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, "
+            "although still supported. Use examples instead."
+        ),
+    ] = _Unset,
+    openapi_examples: Annotated[
+        dict[str, Example] | None,
+        Doc(
+            """
+            OpenAPI-specific examples.
+
+            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
+
+            Swagger UI (that provides the `/docs` interface) has better support for the
+            OpenAPI-specific examples than the JSON Schema `examples`, that's the main
+            use case for this.
+
+            Read more about it in the
+            [FastAPI docs for Declare Request Example Data](https://fastapi.tiangolo.com/tutorial/schema-extra-example/#using-the-openapi_examples-parameter).
+            """
+        ),
+    ] = None,
+    deprecated: Annotated[
+        deprecated | str | bool | None,
+        Doc(
+            """
+            Mark this parameter field as deprecated.
+
+            It will affect the generated OpenAPI (e.g. visible at `/docs`).
+            """
+        ),
+    ] = None,
+    include_in_schema: Annotated[
+        bool,
+        Doc(
+            """
+            To include (or not) this parameter field in the generated OpenAPI.
+            You probably don't need it, but it's available.
+
+            This affects the generated OpenAPI (e.g. visible at `/docs`).
+            """
+        ),
+    ] = True,
+    json_schema_extra: Annotated[
+        dict[str, Any] | None,
+        Doc(
+            """
+            Any additional JSON schema data.
+            """
+        ),
+    ] = None,
+    **extra: Annotated[
+        Any,
+        Doc(
+            """
+            Include extra fields used by the JSON Schema.
+            """
+        ),
+        deprecated(
+            """
+            The `extra` kwargs is deprecated. Use `json_schema_extra` instead.
+            """
+        ),
+    ],
+) -> Any:
+    """
+    Declare a path parameter for a *path operation*.
+
+    Read more about it in the
+    [FastAPI docs for Path Parameters and Numeric Validations](https://fastapi.tiangolo.com/tutorial/path-params-numeric-validations/).
+
+    ```python
+    from typing import Annotated
+
+    from fastapi import FastAPI, Path
+
+    app = FastAPI()
+
+
+    @app.get("/items/{item_id}")
+    async def read_items(
+        item_id: Annotated[int, Path(title="The ID of the item to get")],
+    ):
+        return {"item_id": item_id}
+    ```
+    """
+    return params.Path(
+        default=default,
+        default_factory=default_factory,
+        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,
+        example=example,
+        examples=examples,
+        openapi_examples=openapi_examples,
+        deprecated=deprecated,
+        include_in_schema=include_in_schema,
+        json_schema_extra=json_schema_extra,
+        **extra,
+    )
+
+
+def Query(  # noqa: N802
+    default: Annotated[
+        Any,
+        Doc(
+            """
+            Default value if the parameter field is not set.
+
+            Read more about it in the
+            [FastAPI docs about Query parameters](https://fastapi.tiangolo.com/tutorial/query-params-str-validations/#alternative-old-query-as-the-default-value)
+            """
+        ),
+    ] = Undefined,
+    *,
+    default_factory: Annotated[
+        Callable[[], Any] | None,
+        Doc(
+            """
+            A callable to generate the default value.
+
+            This doesn't affect `Path` parameters as the value is always required.
+            The parameter is available only for compatibility.
+            """
+        ),
+    ] = _Unset,
+    alias: Annotated[
+        str | None,
+        Doc(
+            """
+            An alternative name for the parameter field.
+
+            This will be used to extract the data and for the generated OpenAPI.
+            It is particularly useful when you can't use the name you want because it
+            is a Python reserved keyword or similar.
+
+            Read more about it in the
+            [FastAPI docs about Query parameters](https://fastapi.tiangolo.com/tutorial/query-params-str-validations/#alias-parameters)
+            """
+        ),
+    ] = None,
+    alias_priority: Annotated[
+        int | None,
+        Doc(
+            """
+            Priority of the alias. This affects whether an alias generator is used.
+            """
+        ),
+    ] = _Unset,
+    validation_alias: Annotated[
+        str | AliasPath | AliasChoices | None,
+        Doc(
+            """
+            'Whitelist' validation step. The parameter field will be the single one
+            allowed by the alias or set of aliases defined.
+            """
+        ),
+    ] = None,
+    serialization_alias: Annotated[
+        str | None,
+        Doc(
+            """
+            'Blacklist' validation step. The vanilla parameter field will be the
+            single one of the alias' or set of aliases' fields and all the other
+            fields will be ignored at serialization time.
+            """
+        ),
+    ] = None,
+    title: Annotated[
+        str | None,
+        Doc(
+            """
+            Human-readable title.
+
+            Read more about it in the
+            [FastAPI docs about Query parameters](https://fastapi.tiangolo.com/tutorial/query-params-str-validations/#declare-more-metadata)
+            """
+        ),
+    ] = None,
+    description: Annotated[
+        str | None,
+        Doc(
+            """
+            Human-readable description.
+
+            Read more about it in the
+            [FastAPI docs about Query parameters](https://fastapi.tiangolo.com/tutorial/query-params-str-validations/#declare-more-metadata)
+            """
+        ),
+    ] = None,
+    gt: Annotated[
+        float | None,
+        Doc(
+            """
+            Greater than. If set, value must be greater than this. Only applicable to
+            numbers.
+
+            Read more about it in the
+            [FastAPI docs about Path parameters numeric validations](https://fastapi.tiangolo.com/tutorial/path-params-numeric-validations/#number-validations-greater-than-and-less-than-or-equal)
+            """
+        ),
+    ] = None,
+    ge: Annotated[
+        float | None,
+        Doc(
+            """
+            Greater than or equal. If set, value must be greater than or equal to
+            this. Only applicable to numbers.
+
+            Read more about it in the
+            [FastAPI docs about Path parameters numeric validations](https://fastapi.tiangolo.com/tutorial/path-params-numeric-validations/#number-validations-greater-than-and-less-than-or-equal)
+            """
+        ),
+    ] = None,
+    lt: Annotated[
+        float | None,
+        Doc(
+            """
+            Less than. If set, value must be less than this. Only applicable to numbers.
+
+            Read more about it in the
+            [FastAPI docs about Path parameters numeric validations](https://fastapi.tiangolo.com/tutorial/path-params-numeric-validations/#number-validations-greater-than-and-less-than-or-equal)
+            """
+        ),
+    ] = None,
+    le: Annotated[
+        float | None,
+        Doc(
+            """
+            Less than or equal. If set, value must be less than or equal to this.
+            Only applicable to numbers.
+
+            Read more about it in the
+            [FastAPI docs about Path parameters numeric validations](https://fastapi.tiangolo.com/tutorial/path-params-numeric-validations/#number-validations-greater-than-and-less-than-or-equal)
+            """
+        ),
+    ] = None,
+    min_length: Annotated[
+        int | None,
+        Doc(
+            """
+            Minimum length for strings.
+
+            Read more about it in the
+            [FastAPI docs about Query parameters](https://fastapi.tiangolo.com/tutorial/query-params-str-validations/)
+            """
+        ),
+    ] = None,
+    max_length: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum length for strings.
+
+            Read more about it in the
+            [FastAPI docs about Query parameters](https://fastapi.tiangolo.com/tutorial/query-params-str-validations/)
+            """
+        ),
+    ] = None,
+    pattern: Annotated[
+        str | None,
+        Doc(
+            """
+            RegEx pattern for strings.
+
+            Read more about it in the
+            [FastAPI docs about Query parameters](https://fastapi.tiangolo.com/tutorial/query-params-str-validations/#add-regular-expressions
+            """
+        ),
+    ] = None,
+    regex: Annotated[
+        str | None,
+        Doc(
+            """
+            RegEx pattern for strings.
+            """
+        ),
+        deprecated(
+            "Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead."
+        ),
+    ] = None,
+    discriminator: Annotated[
+        str | None,
+        Doc(
+            """
+            Parameter field name for discriminating the type in a tagged union.
+            """
+        ),
+    ] = None,
+    strict: Annotated[
+        bool | None,
+        Doc(
+            """
+            If `True`, strict validation is applied to the field.
+            """
+        ),
+    ] = _Unset,
+    multiple_of: Annotated[
+        float | None,
+        Doc(
+            """
+            Value must be a multiple of this. Only applicable to numbers.
+            """
+        ),
+    ] = _Unset,
+    allow_inf_nan: Annotated[
+        bool | None,
+        Doc(
+            """
+            Allow `inf`, `-inf`, `nan`. Only applicable to numbers.
+            """
+        ),
+    ] = _Unset,
+    max_digits: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum number of digits allowed for decimal values.
+            """
+        ),
+    ] = _Unset,
+    decimal_places: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum number of decimal places allowed for decimal values.
+            """
+        ),
+    ] = _Unset,
+    examples: Annotated[
+        list[Any] | None,
+        Doc(
+            """
+            Example values for this field.
+
+            Read more about it in the
+            [FastAPI docs for Declare Request Example Data](https://fastapi.tiangolo.com/tutorial/schema-extra-example/)
+            """
+        ),
+    ] = None,
+    example: Annotated[
+        Any | None,
+        deprecated(
+            "Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, "
+            "although still supported. Use examples instead."
+        ),
+    ] = _Unset,
+    openapi_examples: Annotated[
+        dict[str, Example] | None,
+        Doc(
+            """
+            OpenAPI-specific examples.
+
+            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
+
+            Swagger UI (that provides the `/docs` interface) has better support for the
+            OpenAPI-specific examples than the JSON Schema `examples`, that's the main
+            use case for this.
+
+            Read more about it in the
+            [FastAPI docs for Declare Request Example Data](https://fastapi.tiangolo.com/tutorial/schema-extra-example/#using-the-openapi_examples-parameter).
+            """
+        ),
+    ] = None,
+    deprecated: Annotated[
+        deprecated | str | bool | None,
+        Doc(
+            """
+            Mark this parameter field as deprecated.
+
+            It will affect the generated OpenAPI (e.g. visible at `/docs`).
+
+            Read more about it in the
+            [FastAPI docs about Query parameters](https://fastapi.tiangolo.com/tutorial/query-params-str-validations/#deprecating-parameters)
+            """
+        ),
+    ] = None,
+    include_in_schema: Annotated[
+        bool,
+        Doc(
+            """
+            To include (or not) this parameter field in the generated OpenAPI.
+            You probably don't need it, but it's available.
+
+            This affects the generated OpenAPI (e.g. visible at `/docs`).
+
+            Read more about it in the
+            [FastAPI docs about Query parameters](https://fastapi.tiangolo.com/tutorial/query-params-str-validations/#exclude-parameters-from-openapi
+            """
+        ),
+    ] = True,
+    json_schema_extra: Annotated[
+        dict[str, Any] | None,
+        Doc(
+            """
+            Any additional JSON schema data.
+            """
+        ),
+    ] = None,
+    **extra: Annotated[
+        Any,
+        Doc(
+            """
+            Include extra fields used by the JSON Schema.
+            """
+        ),
+        deprecated(
+            """
+            The `extra` kwargs is deprecated. Use `json_schema_extra` instead.
+            """
+        ),
+    ],
+) -> Any:
+    return params.Query(
+        default=default,
+        default_factory=default_factory,
+        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,
+        example=example,
+        examples=examples,
+        openapi_examples=openapi_examples,
+        deprecated=deprecated,
+        include_in_schema=include_in_schema,
+        json_schema_extra=json_schema_extra,
+        **extra,
+    )
+
+
+def Header(  # noqa: N802
+    default: Annotated[
+        Any,
+        Doc(
+            """
+            Default value if the parameter field is not set.
+            """
+        ),
+    ] = Undefined,
+    *,
+    default_factory: Annotated[
+        Callable[[], Any] | None,
+        Doc(
+            """
+            A callable to generate the default value.
+
+            This doesn't affect `Path` parameters as the value is always required.
+            The parameter is available only for compatibility.
+            """
+        ),
+    ] = _Unset,
+    alias: Annotated[
+        str | None,
+        Doc(
+            """
+            An alternative name for the parameter field.
+
+            This will be used to extract the data and for the generated OpenAPI.
+            It is particularly useful when you can't use the name you want because it
+            is a Python reserved keyword or similar.
+            """
+        ),
+    ] = None,
+    alias_priority: Annotated[
+        int | None,
+        Doc(
+            """
+            Priority of the alias. This affects whether an alias generator is used.
+            """
+        ),
+    ] = _Unset,
+    validation_alias: Annotated[
+        str | AliasPath | AliasChoices | None,
+        Doc(
+            """
+            'Whitelist' validation step. The parameter field will be the single one
+            allowed by the alias or set of aliases defined.
+            """
+        ),
+    ] = None,
+    serialization_alias: Annotated[
+        str | None,
+        Doc(
+            """
+            'Blacklist' validation step. The vanilla parameter field will be the
+            single one of the alias' or set of aliases' fields and all the other
+            fields will be ignored at serialization time.
+            """
+        ),
+    ] = None,
+    convert_underscores: Annotated[
+        bool,
+        Doc(
+            """
+            Automatically convert underscores to hyphens in the parameter field name.
+
+            Read more about it in the
+            [FastAPI docs for Header Parameters](https://fastapi.tiangolo.com/tutorial/header-params/#automatic-conversion)
+            """
+        ),
+    ] = True,
+    title: Annotated[
+        str | None,
+        Doc(
+            """
+            Human-readable title.
+            """
+        ),
+    ] = None,
+    description: Annotated[
+        str | None,
+        Doc(
+            """
+            Human-readable description.
+            """
+        ),
+    ] = None,
+    gt: Annotated[
+        float | None,
+        Doc(
+            """
+            Greater than. If set, value must be greater than this. Only applicable to
+            numbers.
+            """
+        ),
+    ] = None,
+    ge: Annotated[
+        float | None,
+        Doc(
+            """
+            Greater than or equal. If set, value must be greater than or equal to
+            this. Only applicable to numbers.
+            """
+        ),
+    ] = None,
+    lt: Annotated[
+        float | None,
+        Doc(
+            """
+            Less than. If set, value must be less than this. Only applicable to numbers.
+            """
+        ),
+    ] = None,
+    le: Annotated[
+        float | None,
+        Doc(
+            """
+            Less than or equal. If set, value must be less than or equal to this.
+            Only applicable to numbers.
+            """
+        ),
+    ] = None,
+    min_length: Annotated[
+        int | None,
+        Doc(
+            """
+            Minimum length for strings.
+            """
+        ),
+    ] = None,
+    max_length: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum length for strings.
+            """
+        ),
+    ] = None,
+    pattern: Annotated[
+        str | None,
+        Doc(
+            """
+            RegEx pattern for strings.
+            """
+        ),
+    ] = None,
+    regex: Annotated[
+        str | None,
+        Doc(
+            """
+            RegEx pattern for strings.
+            """
+        ),
+        deprecated(
+            "Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead."
+        ),
+    ] = None,
+    discriminator: Annotated[
+        str | None,
+        Doc(
+            """
+            Parameter field name for discriminating the type in a tagged union.
+            """
+        ),
+    ] = None,
+    strict: Annotated[
+        bool | None,
+        Doc(
+            """
+            If `True`, strict validation is applied to the field.
+            """
+        ),
+    ] = _Unset,
+    multiple_of: Annotated[
+        float | None,
+        Doc(
+            """
+            Value must be a multiple of this. Only applicable to numbers.
+            """
+        ),
+    ] = _Unset,
+    allow_inf_nan: Annotated[
+        bool | None,
+        Doc(
+            """
+            Allow `inf`, `-inf`, `nan`. Only applicable to numbers.
+            """
+        ),
+    ] = _Unset,
+    max_digits: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum number of digits allowed for decimal values.
+            """
+        ),
+    ] = _Unset,
+    decimal_places: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum number of decimal places allowed for decimal values.
+            """
+        ),
+    ] = _Unset,
+    examples: Annotated[
+        list[Any] | None,
+        Doc(
+            """
+            Example values for this field.
+
+            Read more about it in the
+            [FastAPI docs for Declare Request Example Data](https://fastapi.tiangolo.com/tutorial/schema-extra-example/)
+            """
+        ),
+    ] = None,
+    example: Annotated[
+        Any | None,
+        deprecated(
+            "Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, "
+            "although still supported. Use examples instead."
+        ),
+    ] = _Unset,
+    openapi_examples: Annotated[
+        dict[str, Example] | None,
+        Doc(
+            """
+            OpenAPI-specific examples.
+
+            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
+
+            Swagger UI (that provides the `/docs` interface) has better support for the
+            OpenAPI-specific examples than the JSON Schema `examples`, that's the main
+            use case for this.
+
+            Read more about it in the
+            [FastAPI docs for Declare Request Example Data](https://fastapi.tiangolo.com/tutorial/schema-extra-example/#using-the-openapi_examples-parameter).
+            """
+        ),
+    ] = None,
+    deprecated: Annotated[
+        deprecated | str | bool | None,
+        Doc(
+            """
+            Mark this parameter field as deprecated.
+
+            It will affect the generated OpenAPI (e.g. visible at `/docs`).
+            """
+        ),
+    ] = None,
+    include_in_schema: Annotated[
+        bool,
+        Doc(
+            """
+            To include (or not) this parameter field in the generated OpenAPI.
+            You probably don't need it, but it's available.
+
+            This affects the generated OpenAPI (e.g. visible at `/docs`).
+            """
+        ),
+    ] = True,
+    json_schema_extra: Annotated[
+        dict[str, Any] | None,
+        Doc(
+            """
+            Any additional JSON schema data.
+            """
+        ),
+    ] = None,
+    **extra: Annotated[
+        Any,
+        Doc(
+            """
+            Include extra fields used by the JSON Schema.
+            """
+        ),
+        deprecated(
+            """
+            The `extra` kwargs is deprecated. Use `json_schema_extra` instead.
+            """
+        ),
+    ],
+) -> Any:
+    return params.Header(
+        default=default,
+        default_factory=default_factory,
+        alias=alias,
+        alias_priority=alias_priority,
+        validation_alias=validation_alias,
+        serialization_alias=serialization_alias,
+        convert_underscores=convert_underscores,
+        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,
+        example=example,
+        examples=examples,
+        openapi_examples=openapi_examples,
+        deprecated=deprecated,
+        include_in_schema=include_in_schema,
+        json_schema_extra=json_schema_extra,
+        **extra,
+    )
+
+
+def Cookie(  # noqa: N802
+    default: Annotated[
+        Any,
+        Doc(
+            """
+            Default value if the parameter field is not set.
+            """
+        ),
+    ] = Undefined,
+    *,
+    default_factory: Annotated[
+        Callable[[], Any] | None,
+        Doc(
+            """
+            A callable to generate the default value.
+
+            This doesn't affect `Path` parameters as the value is always required.
+            The parameter is available only for compatibility.
+            """
+        ),
+    ] = _Unset,
+    alias: Annotated[
+        str | None,
+        Doc(
+            """
+            An alternative name for the parameter field.
+
+            This will be used to extract the data and for the generated OpenAPI.
+            It is particularly useful when you can't use the name you want because it
+            is a Python reserved keyword or similar.
+            """
+        ),
+    ] = None,
+    alias_priority: Annotated[
+        int | None,
+        Doc(
+            """
+            Priority of the alias. This affects whether an alias generator is used.
+            """
+        ),
+    ] = _Unset,
+    validation_alias: Annotated[
+        str | AliasPath | AliasChoices | None,
+        Doc(
+            """
+            'Whitelist' validation step. The parameter field will be the single one
+            allowed by the alias or set of aliases defined.
+            """
+        ),
+    ] = None,
+    serialization_alias: Annotated[
+        str | None,
+        Doc(
+            """
+            'Blacklist' validation step. The vanilla parameter field will be the
+            single one of the alias' or set of aliases' fields and all the other
+            fields will be ignored at serialization time.
+            """
+        ),
+    ] = None,
+    title: Annotated[
+        str | None,
+        Doc(
+            """
+            Human-readable title.
+            """
+        ),
+    ] = None,
+    description: Annotated[
+        str | None,
+        Doc(
+            """
+            Human-readable description.
+            """
+        ),
+    ] = None,
+    gt: Annotated[
+        float | None,
+        Doc(
+            """
+            Greater than. If set, value must be greater than this. Only applicable to
+            numbers.
+            """
+        ),
+    ] = None,
+    ge: Annotated[
+        float | None,
+        Doc(
+            """
+            Greater than or equal. If set, value must be greater than or equal to
+            this. Only applicable to numbers.
+            """
+        ),
+    ] = None,
+    lt: Annotated[
+        float | None,
+        Doc(
+            """
+            Less than. If set, value must be less than this. Only applicable to numbers.
+            """
+        ),
+    ] = None,
+    le: Annotated[
+        float | None,
+        Doc(
+            """
+            Less than or equal. If set, value must be less than or equal to this.
+            Only applicable to numbers.
+            """
+        ),
+    ] = None,
+    min_length: Annotated[
+        int | None,
+        Doc(
+            """
+            Minimum length for strings.
+            """
+        ),
+    ] = None,
+    max_length: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum length for strings.
+            """
+        ),
+    ] = None,
+    pattern: Annotated[
+        str | None,
+        Doc(
+            """
+            RegEx pattern for strings.
+            """
+        ),
+    ] = None,
+    regex: Annotated[
+        str | None,
+        Doc(
+            """
+            RegEx pattern for strings.
+            """
+        ),
+        deprecated(
+            "Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead."
+        ),
+    ] = None,
+    discriminator: Annotated[
+        str | None,
+        Doc(
+            """
+            Parameter field name for discriminating the type in a tagged union.
+            """
+        ),
+    ] = None,
+    strict: Annotated[
+        bool | None,
+        Doc(
+            """
+            If `True`, strict validation is applied to the field.
+            """
+        ),
+    ] = _Unset,
+    multiple_of: Annotated[
+        float | None,
+        Doc(
+            """
+            Value must be a multiple of this. Only applicable to numbers.
+            """
+        ),
+    ] = _Unset,
+    allow_inf_nan: Annotated[
+        bool | None,
+        Doc(
+            """
+            Allow `inf`, `-inf`, `nan`. Only applicable to numbers.
+            """
+        ),
+    ] = _Unset,
+    max_digits: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum number of digits allowed for decimal values.
+            """
+        ),
+    ] = _Unset,
+    decimal_places: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum number of decimal places allowed for decimal values.
+            """
+        ),
+    ] = _Unset,
+    examples: Annotated[
+        list[Any] | None,
+        Doc(
+            """
+            Example values for this field.
+
+            Read more about it in the
+            [FastAPI docs for Declare Request Example Data](https://fastapi.tiangolo.com/tutorial/schema-extra-example/)
+            """
+        ),
+    ] = None,
+    example: Annotated[
+        Any | None,
+        deprecated(
+            "Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, "
+            "although still supported. Use examples instead."
+        ),
+    ] = _Unset,
+    openapi_examples: Annotated[
+        dict[str, Example] | None,
+        Doc(
+            """
+            OpenAPI-specific examples.
+
+            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
+
+            Swagger UI (that provides the `/docs` interface) has better support for the
+            OpenAPI-specific examples than the JSON Schema `examples`, that's the main
+            use case for this.
+
+            Read more about it in the
+            [FastAPI docs for Declare Request Example Data](https://fastapi.tiangolo.com/tutorial/schema-extra-example/#using-the-openapi_examples-parameter).
+            """
+        ),
+    ] = None,
+    deprecated: Annotated[
+        deprecated | str | bool | None,
+        Doc(
+            """
+            Mark this parameter field as deprecated.
+
+            It will affect the generated OpenAPI (e.g. visible at `/docs`).
+            """
+        ),
+    ] = None,
+    include_in_schema: Annotated[
+        bool,
+        Doc(
+            """
+            To include (or not) this parameter field in the generated OpenAPI.
+            You probably don't need it, but it's available.
+
+            This affects the generated OpenAPI (e.g. visible at `/docs`).
+            """
+        ),
+    ] = True,
+    json_schema_extra: Annotated[
+        dict[str, Any] | None,
+        Doc(
+            """
+            Any additional JSON schema data.
+            """
+        ),
+    ] = None,
+    **extra: Annotated[
+        Any,
+        Doc(
+            """
+            Include extra fields used by the JSON Schema.
+            """
+        ),
+        deprecated(
+            """
+            The `extra` kwargs is deprecated. Use `json_schema_extra` instead.
+            """
+        ),
+    ],
+) -> Any:
+    return params.Cookie(
+        default=default,
+        default_factory=default_factory,
+        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,
+        example=example,
+        examples=examples,
+        openapi_examples=openapi_examples,
+        deprecated=deprecated,
+        include_in_schema=include_in_schema,
+        json_schema_extra=json_schema_extra,
+        **extra,
+    )
+
+
+def Body(  # noqa: N802
+    default: Annotated[
+        Any,
+        Doc(
+            """
+            Default value if the parameter field is not set.
+            """
+        ),
+    ] = Undefined,
+    *,
+    default_factory: Annotated[
+        Callable[[], Any] | None,
+        Doc(
+            """
+            A callable to generate the default value.
+
+            This doesn't affect `Path` parameters as the value is always required.
+            The parameter is available only for compatibility.
+            """
+        ),
+    ] = _Unset,
+    embed: Annotated[
+        bool | None,
+        Doc(
+            """
+            When `embed` is `True`, the parameter will be expected in a JSON body as a
+            key instead of being the JSON body itself.
+
+            This happens automatically when more than one `Body` parameter is declared.
+
+            Read more about it in the
+            [FastAPI docs for Body - Multiple Parameters](https://fastapi.tiangolo.com/tutorial/body-multiple-params/#embed-a-single-body-parameter).
+            """
+        ),
+    ] = None,
+    media_type: Annotated[
+        str,
+        Doc(
+            """
+            The media type of this parameter field. Changing it would affect the
+            generated OpenAPI, but currently it doesn't affect the parsing of the data.
+            """
+        ),
+    ] = "application/json",
+    alias: Annotated[
+        str | None,
+        Doc(
+            """
+            An alternative name for the parameter field.
+
+            This will be used to extract the data and for the generated OpenAPI.
+            It is particularly useful when you can't use the name you want because it
+            is a Python reserved keyword or similar.
+            """
+        ),
+    ] = None,
+    alias_priority: Annotated[
+        int | None,
+        Doc(
+            """
+            Priority of the alias. This affects whether an alias generator is used.
+            """
+        ),
+    ] = _Unset,
+    validation_alias: Annotated[
+        str | AliasPath | AliasChoices | None,
+        Doc(
+            """
+            'Whitelist' validation step. The parameter field will be the single one
+            allowed by the alias or set of aliases defined.
+            """
+        ),
+    ] = None,
+    serialization_alias: Annotated[
+        str | None,
+        Doc(
+            """
+            'Blacklist' validation step. The vanilla parameter field will be the
+            single one of the alias' or set of aliases' fields and all the other
+            fields will be ignored at serialization time.
+            """
+        ),
+    ] = None,
+    title: Annotated[
+        str | None,
+        Doc(
+            """
+            Human-readable title.
+            """
+        ),
+    ] = None,
+    description: Annotated[
+        str | None,
+        Doc(
+            """
+            Human-readable description.
+            """
+        ),
+    ] = None,
+    gt: Annotated[
+        float | None,
+        Doc(
+            """
+            Greater than. If set, value must be greater than this. Only applicable to
+            numbers.
+            """
+        ),
+    ] = None,
+    ge: Annotated[
+        float | None,
+        Doc(
+            """
+            Greater than or equal. If set, value must be greater than or equal to
+            this. Only applicable to numbers.
+            """
+        ),
+    ] = None,
+    lt: Annotated[
+        float | None,
+        Doc(
+            """
+            Less than. If set, value must be less than this. Only applicable to numbers.
+            """
+        ),
+    ] = None,
+    le: Annotated[
+        float | None,
+        Doc(
+            """
+            Less than or equal. If set, value must be less than or equal to this.
+            Only applicable to numbers.
+            """
+        ),
+    ] = None,
+    min_length: Annotated[
+        int | None,
+        Doc(
+            """
+            Minimum length for strings.
+            """
+        ),
+    ] = None,
+    max_length: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum length for strings.
+            """
+        ),
+    ] = None,
+    pattern: Annotated[
+        str | None,
+        Doc(
+            """
+            RegEx pattern for strings.
+            """
+        ),
+    ] = None,
+    regex: Annotated[
+        str | None,
+        Doc(
+            """
+            RegEx pattern for strings.
+            """
+        ),
+        deprecated(
+            "Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead."
+        ),
+    ] = None,
+    discriminator: Annotated[
+        str | None,
+        Doc(
+            """
+            Parameter field name for discriminating the type in a tagged union.
+            """
+        ),
+    ] = None,
+    strict: Annotated[
+        bool | None,
+        Doc(
+            """
+            If `True`, strict validation is applied to the field.
+            """
+        ),
+    ] = _Unset,
+    multiple_of: Annotated[
+        float | None,
+        Doc(
+            """
+            Value must be a multiple of this. Only applicable to numbers.
+            """
+        ),
+    ] = _Unset,
+    allow_inf_nan: Annotated[
+        bool | None,
+        Doc(
+            """
+            Allow `inf`, `-inf`, `nan`. Only applicable to numbers.
+            """
+        ),
+    ] = _Unset,
+    max_digits: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum number of digits allowed for decimal values.
+            """
+        ),
+    ] = _Unset,
+    decimal_places: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum number of decimal places allowed for decimal values.
+            """
+        ),
+    ] = _Unset,
+    examples: Annotated[
+        list[Any] | None,
+        Doc(
+            """
+            Example values for this field.
+
+            Read more about it in the
+            [FastAPI docs for Declare Request Example Data](https://fastapi.tiangolo.com/tutorial/schema-extra-example/)
+            """
+        ),
+    ] = None,
+    example: Annotated[
+        Any | None,
+        deprecated(
+            "Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, "
+            "although still supported. Use examples instead."
+        ),
+    ] = _Unset,
+    openapi_examples: Annotated[
+        dict[str, Example] | None,
+        Doc(
+            """
+            OpenAPI-specific examples.
+
+            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
+
+            Swagger UI (that provides the `/docs` interface) has better support for the
+            OpenAPI-specific examples than the JSON Schema `examples`, that's the main
+            use case for this.
+
+            Read more about it in the
+            [FastAPI docs for Declare Request Example Data](https://fastapi.tiangolo.com/tutorial/schema-extra-example/#using-the-openapi_examples-parameter).
+            """
+        ),
+    ] = None,
+    deprecated: Annotated[
+        deprecated | str | bool | None,
+        Doc(
+            """
+            Mark this parameter field as deprecated.
+
+            It will affect the generated OpenAPI (e.g. visible at `/docs`).
+            """
+        ),
+    ] = None,
+    include_in_schema: Annotated[
+        bool,
+        Doc(
+            """
+            To include (or not) this parameter field in the generated OpenAPI.
+            You probably don't need it, but it's available.
+
+            This affects the generated OpenAPI (e.g. visible at `/docs`).
+            """
+        ),
+    ] = True,
+    json_schema_extra: Annotated[
+        dict[str, Any] | None,
+        Doc(
+            """
+            Any additional JSON schema data.
+            """
+        ),
+    ] = None,
+    **extra: Annotated[
+        Any,
+        Doc(
+            """
+            Include extra fields used by the JSON Schema.
+            """
+        ),
+        deprecated(
+            """
+            The `extra` kwargs is deprecated. Use `json_schema_extra` instead.
+            """
+        ),
+    ],
+) -> Any:
+    return params.Body(
+        default=default,
+        default_factory=default_factory,
+        embed=embed,
+        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,
+        example=example,
+        examples=examples,
+        openapi_examples=openapi_examples,
+        deprecated=deprecated,
+        include_in_schema=include_in_schema,
+        json_schema_extra=json_schema_extra,
+        **extra,
+    )
+
+
+def Form(  # noqa: N802
+    default: Annotated[
+        Any,
+        Doc(
+            """
+            Default value if the parameter field is not set.
+            """
+        ),
+    ] = Undefined,
+    *,
+    default_factory: Annotated[
+        Callable[[], Any] | None,
+        Doc(
+            """
+            A callable to generate the default value.
+
+            This doesn't affect `Path` parameters as the value is always required.
+            The parameter is available only for compatibility.
+            """
+        ),
+    ] = _Unset,
+    media_type: Annotated[
+        str,
+        Doc(
+            """
+            The media type of this parameter field. Changing it would affect the
+            generated OpenAPI, but currently it doesn't affect the parsing of the data.
+            """
+        ),
+    ] = "application/x-www-form-urlencoded",
+    alias: Annotated[
+        str | None,
+        Doc(
+            """
+            An alternative name for the parameter field.
+
+            This will be used to extract the data and for the generated OpenAPI.
+            It is particularly useful when you can't use the name you want because it
+            is a Python reserved keyword or similar.
+            """
+        ),
+    ] = None,
+    alias_priority: Annotated[
+        int | None,
+        Doc(
+            """
+            Priority of the alias. This affects whether an alias generator is used.
+            """
+        ),
+    ] = _Unset,
+    validation_alias: Annotated[
+        str | AliasPath | AliasChoices | None,
+        Doc(
+            """
+            'Whitelist' validation step. The parameter field will be the single one
+            allowed by the alias or set of aliases defined.
+            """
+        ),
+    ] = None,
+    serialization_alias: Annotated[
+        str | None,
+        Doc(
+            """
+            'Blacklist' validation step. The vanilla parameter field will be the
+            single one of the alias' or set of aliases' fields and all the other
+            fields will be ignored at serialization time.
+            """
+        ),
+    ] = None,
+    title: Annotated[
+        str | None,
+        Doc(
+            """
+            Human-readable title.
+            """
+        ),
+    ] = None,
+    description: Annotated[
+        str | None,
+        Doc(
+            """
+            Human-readable description.
+            """
+        ),
+    ] = None,
+    gt: Annotated[
+        float | None,
+        Doc(
+            """
+            Greater than. If set, value must be greater than this. Only applicable to
+            numbers.
+            """
+        ),
+    ] = None,
+    ge: Annotated[
+        float | None,
+        Doc(
+            """
+            Greater than or equal. If set, value must be greater than or equal to
+            this. Only applicable to numbers.
+            """
+        ),
+    ] = None,
+    lt: Annotated[
+        float | None,
+        Doc(
+            """
+            Less than. If set, value must be less than this. Only applicable to numbers.
+            """
+        ),
+    ] = None,
+    le: Annotated[
+        float | None,
+        Doc(
+            """
+            Less than or equal. If set, value must be less than or equal to this.
+            Only applicable to numbers.
+            """
+        ),
+    ] = None,
+    min_length: Annotated[
+        int | None,
+        Doc(
+            """
+            Minimum length for strings.
+            """
+        ),
+    ] = None,
+    max_length: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum length for strings.
+            """
+        ),
+    ] = None,
+    pattern: Annotated[
+        str | None,
+        Doc(
+            """
+            RegEx pattern for strings.
+            """
+        ),
+    ] = None,
+    regex: Annotated[
+        str | None,
+        Doc(
+            """
+            RegEx pattern for strings.
+            """
+        ),
+        deprecated(
+            "Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead."
+        ),
+    ] = None,
+    discriminator: Annotated[
+        str | None,
+        Doc(
+            """
+            Parameter field name for discriminating the type in a tagged union.
+            """
+        ),
+    ] = None,
+    strict: Annotated[
+        bool | None,
+        Doc(
+            """
+            If `True`, strict validation is applied to the field.
+            """
+        ),
+    ] = _Unset,
+    multiple_of: Annotated[
+        float | None,
+        Doc(
+            """
+            Value must be a multiple of this. Only applicable to numbers.
+            """
+        ),
+    ] = _Unset,
+    allow_inf_nan: Annotated[
+        bool | None,
+        Doc(
+            """
+            Allow `inf`, `-inf`, `nan`. Only applicable to numbers.
+            """
+        ),
+    ] = _Unset,
+    max_digits: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum number of digits allowed for decimal values.
+            """
+        ),
+    ] = _Unset,
+    decimal_places: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum number of decimal places allowed for decimal values.
+            """
+        ),
+    ] = _Unset,
+    examples: Annotated[
+        list[Any] | None,
+        Doc(
+            """
+            Example values for this field.
+
+            Read more about it in the
+            [FastAPI docs for Declare Request Example Data](https://fastapi.tiangolo.com/tutorial/schema-extra-example/)
+            """
+        ),
+    ] = None,
+    example: Annotated[
+        Any | None,
+        deprecated(
+            "Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, "
+            "although still supported. Use examples instead."
+        ),
+    ] = _Unset,
+    openapi_examples: Annotated[
+        dict[str, Example] | None,
+        Doc(
+            """
+            OpenAPI-specific examples.
+
+            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
+
+            Swagger UI (that provides the `/docs` interface) has better support for the
+            OpenAPI-specific examples than the JSON Schema `examples`, that's the main
+            use case for this.
+
+            Read more about it in the
+            [FastAPI docs for Declare Request Example Data](https://fastapi.tiangolo.com/tutorial/schema-extra-example/#using-the-openapi_examples-parameter).
+            """
+        ),
+    ] = None,
+    deprecated: Annotated[
+        deprecated | str | bool | None,
+        Doc(
+            """
+            Mark this parameter field as deprecated.
+
+            It will affect the generated OpenAPI (e.g. visible at `/docs`).
+            """
+        ),
+    ] = None,
+    include_in_schema: Annotated[
+        bool,
+        Doc(
+            """
+            To include (or not) this parameter field in the generated OpenAPI.
+            You probably don't need it, but it's available.
+
+            This affects the generated OpenAPI (e.g. visible at `/docs`).
+            """
+        ),
+    ] = True,
+    json_schema_extra: Annotated[
+        dict[str, Any] | None,
+        Doc(
+            """
+            Any additional JSON schema data.
+            """
+        ),
+    ] = None,
+    **extra: Annotated[
+        Any,
+        Doc(
+            """
+            Include extra fields used by the JSON Schema.
+            """
+        ),
+        deprecated(
+            """
+            The `extra` kwargs is deprecated. Use `json_schema_extra` instead.
+            """
+        ),
+    ],
+) -> Any:
+    return params.Form(
+        default=default,
+        default_factory=default_factory,
+        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,
+        example=example,
+        examples=examples,
+        openapi_examples=openapi_examples,
+        deprecated=deprecated,
+        include_in_schema=include_in_schema,
+        json_schema_extra=json_schema_extra,
+        **extra,
+    )
+
+
+def File(  # noqa: N802
+    default: Annotated[
+        Any,
+        Doc(
+            """
+            Default value if the parameter field is not set.
+            """
+        ),
+    ] = Undefined,
+    *,
+    default_factory: Annotated[
+        Callable[[], Any] | None,
+        Doc(
+            """
+            A callable to generate the default value.
+
+            This doesn't affect `Path` parameters as the value is always required.
+            The parameter is available only for compatibility.
+            """
+        ),
+    ] = _Unset,
+    media_type: Annotated[
+        str,
+        Doc(
+            """
+            The media type of this parameter field. Changing it would affect the
+            generated OpenAPI, but currently it doesn't affect the parsing of the data.
+            """
+        ),
+    ] = "multipart/form-data",
+    alias: Annotated[
+        str | None,
+        Doc(
+            """
+            An alternative name for the parameter field.
+
+            This will be used to extract the data and for the generated OpenAPI.
+            It is particularly useful when you can't use the name you want because it
+            is a Python reserved keyword or similar.
+            """
+        ),
+    ] = None,
+    alias_priority: Annotated[
+        int | None,
+        Doc(
+            """
+            Priority of the alias. This affects whether an alias generator is used.
+            """
+        ),
+    ] = _Unset,
+    validation_alias: Annotated[
+        str | AliasPath | AliasChoices | None,
+        Doc(
+            """
+            'Whitelist' validation step. The parameter field will be the single one
+            allowed by the alias or set of aliases defined.
+            """
+        ),
+    ] = None,
+    serialization_alias: Annotated[
+        str | None,
+        Doc(
+            """
+            'Blacklist' validation step. The vanilla parameter field will be the
+            single one of the alias' or set of aliases' fields and all the other
+            fields will be ignored at serialization time.
+            """
+        ),
+    ] = None,
+    title: Annotated[
+        str | None,
+        Doc(
+            """
+            Human-readable title.
+            """
+        ),
+    ] = None,
+    description: Annotated[
+        str | None,
+        Doc(
+            """
+            Human-readable description.
+            """
+        ),
+    ] = None,
+    gt: Annotated[
+        float | None,
+        Doc(
+            """
+            Greater than. If set, value must be greater than this. Only applicable to
+            numbers.
+            """
+        ),
+    ] = None,
+    ge: Annotated[
+        float | None,
+        Doc(
+            """
+            Greater than or equal. If set, value must be greater than or equal to
+            this. Only applicable to numbers.
+            """
+        ),
+    ] = None,
+    lt: Annotated[
+        float | None,
+        Doc(
+            """
+            Less than. If set, value must be less than this. Only applicable to numbers.
+            """
+        ),
+    ] = None,
+    le: Annotated[
+        float | None,
+        Doc(
+            """
+            Less than or equal. If set, value must be less than or equal to this.
+            Only applicable to numbers.
+            """
+        ),
+    ] = None,
+    min_length: Annotated[
+        int | None,
+        Doc(
+            """
+            Minimum length for strings.
+            """
+        ),
+    ] = None,
+    max_length: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum length for strings.
+            """
+        ),
+    ] = None,
+    pattern: Annotated[
+        str | None,
+        Doc(
+            """
+            RegEx pattern for strings.
+            """
+        ),
+    ] = None,
+    regex: Annotated[
+        str | None,
+        Doc(
+            """
+            RegEx pattern for strings.
+            """
+        ),
+        deprecated(
+            "Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead."
+        ),
+    ] = None,
+    discriminator: Annotated[
+        str | None,
+        Doc(
+            """
+            Parameter field name for discriminating the type in a tagged union.
+            """
+        ),
+    ] = None,
+    strict: Annotated[
+        bool | None,
+        Doc(
+            """
+            If `True`, strict validation is applied to the field.
+            """
+        ),
+    ] = _Unset,
+    multiple_of: Annotated[
+        float | None,
+        Doc(
+            """
+            Value must be a multiple of this. Only applicable to numbers.
+            """
+        ),
+    ] = _Unset,
+    allow_inf_nan: Annotated[
+        bool | None,
+        Doc(
+            """
+            Allow `inf`, `-inf`, `nan`. Only applicable to numbers.
+            """
+        ),
+    ] = _Unset,
+    max_digits: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum number of digits allowed for decimal values.
+            """
+        ),
+    ] = _Unset,
+    decimal_places: Annotated[
+        int | None,
+        Doc(
+            """
+            Maximum number of decimal places allowed for decimal values.
+            """
+        ),
+    ] = _Unset,
+    examples: Annotated[
+        list[Any] | None,
+        Doc(
+            """
+            Example values for this field.
+
+            Read more about it in the
+            [FastAPI docs for Declare Request Example Data](https://fastapi.tiangolo.com/tutorial/schema-extra-example/)
+            """
+        ),
+    ] = None,
+    example: Annotated[
+        Any | None,
+        deprecated(
+            "Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, "
+            "although still supported. Use examples instead."
+        ),
+    ] = _Unset,
+    openapi_examples: Annotated[
+        dict[str, Example] | None,
+        Doc(
+            """
+            OpenAPI-specific examples.
+
+            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
+
+            Swagger UI (that provides the `/docs` interface) has better support for the
+            OpenAPI-specific examples than the JSON Schema `examples`, that's the main
+            use case for this.
+
+            Read more about it in the
+            [FastAPI docs for Declare Request Example Data](https://fastapi.tiangolo.com/tutorial/schema-extra-example/#using-the-openapi_examples-parameter).
+            """
+        ),
+    ] = None,
+    deprecated: Annotated[
+        deprecated | str | bool | None,
+        Doc(
+            """
+            Mark this parameter field as deprecated.
+
+            It will affect the generated OpenAPI (e.g. visible at `/docs`).
+            """
+        ),
+    ] = None,
+    include_in_schema: Annotated[
+        bool,
+        Doc(
+            """
+            To include (or not) this parameter field in the generated OpenAPI.
+            You probably don't need it, but it's available.
+
+            This affects the generated OpenAPI (e.g. visible at `/docs`).
+            """
+        ),
+    ] = True,
+    json_schema_extra: Annotated[
+        dict[str, Any] | None,
+        Doc(
+            """
+            Any additional JSON schema data.
+            """
+        ),
+    ] = None,
+    **extra: Annotated[
+        Any,
+        Doc(
+            """
+            Include extra fields used by the JSON Schema.
+            """
+        ),
+        deprecated(
+            """
+            The `extra` kwargs is deprecated. Use `json_schema_extra` instead.
+            """
+        ),
+    ],
+) -> Any:
+    return params.File(
+        default=default,
+        default_factory=default_factory,
+        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,
+        example=example,
+        examples=examples,
+        openapi_examples=openapi_examples,
+        deprecated=deprecated,
+        include_in_schema=include_in_schema,
+        json_schema_extra=json_schema_extra,
+        **extra,
+    )
+
+
+def Depends(  # noqa: N802
+    dependency: Annotated[
+        Callable[..., Any] | None,
+        Doc(
+            """
+            A "dependable" callable (like a function).
+
+            Don't call it directly, FastAPI will call it for you, just pass the object
+            directly.
+
+            Read more about it in the
+            [FastAPI docs for Dependencies](https://fastapi.tiangolo.com/tutorial/dependencies/)
+            """
+        ),
+    ] = None,
+    *,
+    use_cache: Annotated[
+        bool,
+        Doc(
+            """
+            By default, after a dependency is called the first time in a request, if
+            the dependency is declared again for the rest of the request (for example
+            if the dependency is needed by several dependencies), the value will be
+            re-used for the rest of the request.
+
+            Set `use_cache` to `False` to disable this behavior and ensure the
+            dependency is called again (if declared more than once) in the same request.
+
+            Read more about it in the
+            [FastAPI docs about sub-dependencies](https://fastapi.tiangolo.com/tutorial/dependencies/sub-dependencies/#using-the-same-dependency-multiple-times)
+            """
+        ),
+    ] = True,
+    scope: Annotated[
+        Literal["function", "request"] | None,
+        Doc(
+            """
+            Mainly for dependencies with `yield`, define when the dependency function
+            should start (the code before `yield`) and when it should end (the code
+            after `yield`).
+
+            * `"function"`: start the dependency before the *path operation function*
+                that handles the request, end the dependency after the *path operation
+                function* ends, but **before** the response is sent back to the client.
+                So, the dependency function will be executed **around** the *path operation
+                **function***.
+            * `"request"`: start the dependency before the *path operation function*
+                that handles the request (similar to when using `"function"`), but end
+                **after** the response is sent back to the client. So, the dependency
+                function will be executed **around** the **request** and response cycle.
+
+            Read more about it in the
+            [FastAPI docs for FastAPI Dependencies with yield](https://fastapi.tiangolo.com/tutorial/dependencies/dependencies-with-yield/#early-exit-and-scope)
+            """
+        ),
+    ] = None,
+) -> Any:
+    """
+    Declare a FastAPI dependency.
+
+    It takes a single "dependable" callable (like a function).
+
+    Don't call it directly, FastAPI will call it for you.
+
+    Read more about it in the
+    [FastAPI docs for Dependencies](https://fastapi.tiangolo.com/tutorial/dependencies/).
+
+    **Example**
+
+    ```python
+    from typing import Annotated
+
+    from fastapi import Depends, FastAPI
+
+    app = FastAPI()
+
+
+    async def common_parameters(q: str | None = None, skip: int = 0, limit: int = 100):
+        return {"q": q, "skip": skip, "limit": limit}
+
+
+    @app.get("/items/")
+    async def read_items(commons: Annotated[dict, Depends(common_parameters)]):
+        return commons
+    ```
+    """
+    return params.Depends(dependency=dependency, use_cache=use_cache, scope=scope)
+
+
+def Security(  # noqa: N802
+    dependency: Annotated[
+        Callable[..., Any] | None,
+        Doc(
+            """
+            A "dependable" callable (like a function).
+
+            Don't call it directly, FastAPI will call it for you, just pass the object
+            directly.
+
+            Read more about it in the
+            [FastAPI docs for Dependencies](https://fastapi.tiangolo.com/tutorial/dependencies/)
+            """
+        ),
+    ] = None,
+    *,
+    scopes: Annotated[
+        Sequence[str] | None,
+        Doc(
+            """
+            OAuth2 scopes required for the *path operation* that uses this Security
+            dependency.
+
+            The term "scope" comes from the OAuth2 specification, it seems to be
+            intentionally vague and interpretable. It normally refers to permissions,
+            in cases to roles.
+
+            These scopes are integrated with OpenAPI (and the API docs at `/docs`).
+            So they are visible in the OpenAPI specification.
+
+            Read more about it in the
+            [FastAPI docs about OAuth2 scopes](https://fastapi.tiangolo.com/advanced/security/oauth2-scopes/)
+            """
+        ),
+    ] = None,
+    use_cache: Annotated[
+        bool,
+        Doc(
+            """
+            By default, after a dependency is called the first time in a request, if
+            the dependency is declared again for the rest of the request (for example
+            if the dependency is needed by several dependencies), the value will be
+            re-used for the rest of the request.
+
+            Set `use_cache` to `False` to disable this behavior and ensure the
+            dependency is called again (if declared more than once) in the same request.
+
+            Read more about it in the
+            [FastAPI docs about sub-dependencies](https://fastapi.tiangolo.com/tutorial/dependencies/sub-dependencies/#using-the-same-dependency-multiple-times)
+            """
+        ),
+    ] = True,
+) -> Any:
+    """
+    Declare a FastAPI Security dependency.
+
+    The only difference with a regular dependency is that it can declare OAuth2
+    scopes that will be integrated with OpenAPI and the automatic UI docs (by default
+    at `/docs`).
+
+    It takes a single "dependable" callable (like a function).
+
+    Don't call it directly, FastAPI will call it for you.
+
+    Read more about it in the
+    [FastAPI docs for Security](https://fastapi.tiangolo.com/tutorial/security/) and
+    in the
+    [FastAPI docs for OAuth2 scopes](https://fastapi.tiangolo.com/advanced/security/oauth2-scopes/).
+
+    **Example**
+
+    ```python
+    from typing import Annotated
+
+    from fastapi import Security, FastAPI
+
+    from .db import User
+    from .security import get_current_active_user
+
+    app = FastAPI()
+
+    @app.get("/users/me/items/")
+    async def read_own_items(
+        current_user: Annotated[User, Security(get_current_active_user, scopes=["items"])]
+    ):
+        return [{"item_id": "Foo", "owner": current_user.username}]
+    ```
+    """
+    return params.Security(dependency=dependency, scopes=scopes, use_cache=use_cache)

lib/python3.11/site-packages/fastapi/params.py

@@ -0,0 +1,754 @@
+import warnings
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from enum import Enum
+from typing import Annotated, Any, Literal
+
+from fastapi.exceptions import FastAPIDeprecationWarning
+from fastapi.openapi.models import Example
+from pydantic import AliasChoices, AliasPath
+from pydantic.fields import FieldInfo
+from typing_extensions import deprecated
+
+from ._compat import (
+    Undefined,
+)
+from .datastructures import _Unset
+
+
+class ParamTypes(Enum):
+    query = "query"
+    header = "header"
+    path = "path"
+    cookie = "cookie"
+
+
+class Param(FieldInfo):  # type: ignore[misc]  # ty: ignore[subclass-of-final-class]
+    in_: ParamTypes
+
+    def __init__(
+        self,
+        default: Any = Undefined,
+        *,
+        default_factory: Callable[[], Any] | None = _Unset,
+        annotation: Any | None = None,
+        alias: str | None = None,
+        alias_priority: int | None = _Unset,
+        validation_alias: str | AliasPath | AliasChoices | None = None,
+        serialization_alias: str | None = None,
+        title: str | None = None,
+        description: str | None = None,
+        gt: float | None = None,
+        ge: float | None = None,
+        lt: float | None = None,
+        le: float | None = None,
+        min_length: int | None = None,
+        max_length: int | None = None,
+        pattern: str | None = None,
+        regex: Annotated[
+            str | None,
+            deprecated(
+                "Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead."
+            ),
+        ] = None,
+        discriminator: str | None = None,
+        strict: bool | None = _Unset,
+        multiple_of: float | None = _Unset,
+        allow_inf_nan: bool | None = _Unset,
+        max_digits: int | None = _Unset,
+        decimal_places: int | None = _Unset,
+        examples: list[Any] | None = None,
+        example: Annotated[
+            Any | None,
+            deprecated(
+                "Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, "
+                "although still supported. Use examples instead."
+            ),
+        ] = _Unset,
+        openapi_examples: dict[str, Example] | None = None,
+        deprecated: deprecated | str | bool | None = None,
+        include_in_schema: bool = True,
+        json_schema_extra: dict[str, Any] | None = None,
+        **extra: Any,
+    ):
+        if example is not _Unset:
+            warnings.warn(
+                "`example` has been deprecated, please use `examples` instead",
+                category=FastAPIDeprecationWarning,
+                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=FastAPIDeprecationWarning,
+                stacklevel=4,
+            )
+        current_json_schema_extra = json_schema_extra or extra
+        kwargs["deprecated"] = deprecated
+
+        if serialization_alias in (_Unset, None) and isinstance(alias, str):
+            serialization_alias = alias
+        if validation_alias in (_Unset, None):
+            validation_alias = alias
+        kwargs.update(
+            {
+                "annotation": annotation,
+                "alias_priority": alias_priority,
+                "validation_alias": validation_alias,
+                "serialization_alias": serialization_alias,
+                "strict": strict,
+                "json_schema_extra": current_json_schema_extra,
+            }
+        )
+        kwargs["pattern"] = pattern or regex
+
+        use_kwargs = {k: v for k, v in kwargs.items() if v is not _Unset}
+
+        super().__init__(**use_kwargs)  # ty: ignore[invalid-argument-type]
+
+    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: Callable[[], Any] | None = _Unset,
+        annotation: Any | None = None,
+        alias: str | None = None,
+        alias_priority: int | None = _Unset,
+        validation_alias: str | AliasPath | AliasChoices | None = None,
+        serialization_alias: str | None = None,
+        title: str | None = None,
+        description: str | None = None,
+        gt: float | None = None,
+        ge: float | None = None,
+        lt: float | None = None,
+        le: float | None = None,
+        min_length: int | None = None,
+        max_length: int | None = None,
+        pattern: str | None = None,
+        regex: Annotated[
+            str | None,
+            deprecated(
+                "Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead."
+            ),
+        ] = None,
+        discriminator: str | None = None,
+        strict: bool | None = _Unset,
+        multiple_of: float | None = _Unset,
+        allow_inf_nan: bool | None = _Unset,
+        max_digits: int | None = _Unset,
+        decimal_places: int | None = _Unset,
+        examples: list[Any] | None = None,
+        example: Annotated[
+            Any | None,
+            deprecated(
+                "Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, "
+                "although still supported. Use examples instead."
+            ),
+        ] = _Unset,
+        openapi_examples: dict[str, Example] | None = None,
+        deprecated: deprecated | str | bool | None = None,
+        include_in_schema: bool = True,
+        json_schema_extra: 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: Callable[[], Any] | None = _Unset,
+        annotation: Any | None = None,
+        alias: str | None = None,
+        alias_priority: int | None = _Unset,
+        validation_alias: str | AliasPath | AliasChoices | None = None,
+        serialization_alias: str | None = None,
+        title: str | None = None,
+        description: str | None = None,
+        gt: float | None = None,
+        ge: float | None = None,
+        lt: float | None = None,
+        le: float | None = None,
+        min_length: int | None = None,
+        max_length: int | None = None,
+        pattern: str | None = None,
+        regex: Annotated[
+            str | None,
+            deprecated(
+                "Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead."
+            ),
+        ] = None,
+        discriminator: str | None = None,
+        strict: bool | None = _Unset,
+        multiple_of: float | None = _Unset,
+        allow_inf_nan: bool | None = _Unset,
+        max_digits: int | None = _Unset,
+        decimal_places: int | None = _Unset,
+        examples: list[Any] | None = None,
+        example: Annotated[
+            Any | None,
+            deprecated(
+                "Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, "
+                "although still supported. Use examples instead."
+            ),
+        ] = _Unset,
+        openapi_examples: dict[str, Example] | None = None,
+        deprecated: deprecated | str | bool | None = None,
+        include_in_schema: bool = True,
+        json_schema_extra: 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: Callable[[], Any] | None = _Unset,
+        annotation: Any | None = None,
+        alias: str | None = None,
+        alias_priority: int | None = _Unset,
+        validation_alias: str | AliasPath | AliasChoices | None = None,
+        serialization_alias: str | None = None,
+        convert_underscores: bool = True,
+        title: str | None = None,
+        description: str | None = None,
+        gt: float | None = None,
+        ge: float | None = None,
+        lt: float | None = None,
+        le: float | None = None,
+        min_length: int | None = None,
+        max_length: int | None = None,
+        pattern: str | None = None,
+        regex: Annotated[
+            str | None,
+            deprecated(
+                "Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead."
+            ),
+        ] = None,
+        discriminator: str | None = None,
+        strict: bool | None = _Unset,
+        multiple_of: float | None = _Unset,
+        allow_inf_nan: bool | None = _Unset,
+        max_digits: int | None = _Unset,
+        decimal_places: int | None = _Unset,
+        examples: list[Any] | None = None,
+        example: Annotated[
+            Any | None,
+            deprecated(
+                "Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, "
+                "although still supported. Use examples instead."
+            ),
+        ] = _Unset,
+        openapi_examples: dict[str, Example] | None = None,
+        deprecated: deprecated | str | bool | None = None,
+        include_in_schema: bool = True,
+        json_schema_extra: 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: Callable[[], Any] | None = _Unset,
+        annotation: Any | None = None,
+        alias: str | None = None,
+        alias_priority: int | None = _Unset,
+        validation_alias: str | AliasPath | AliasChoices | None = None,
+        serialization_alias: str | None = None,
+        title: str | None = None,
+        description: str | None = None,
+        gt: float | None = None,
+        ge: float | None = None,
+        lt: float | None = None,
+        le: float | None = None,
+        min_length: int | None = None,
+        max_length: int | None = None,
+        pattern: str | None = None,
+        regex: Annotated[
+            str | None,
+            deprecated(
+                "Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead."
+            ),
+        ] = None,
+        discriminator: str | None = None,
+        strict: bool | None = _Unset,
+        multiple_of: float | None = _Unset,
+        allow_inf_nan: bool | None = _Unset,
+        max_digits: int | None = _Unset,
+        decimal_places: int | None = _Unset,
+        examples: list[Any] | None = None,
+        example: Annotated[
+            Any | None,
+            deprecated(
+                "Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, "
+                "although still supported. Use examples instead."
+            ),
+        ] = _Unset,
+        openapi_examples: dict[str, Example] | None = None,
+        deprecated: deprecated | str | bool | None = None,
+        include_in_schema: bool = True,
+        json_schema_extra: 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]  # ty: ignore[subclass-of-final-class]
+    def __init__(
+        self,
+        default: Any = Undefined,
+        *,
+        default_factory: Callable[[], Any] | None = _Unset,
+        annotation: Any | None = None,
+        embed: bool | None = None,
+        media_type: str = "application/json",
+        alias: str | None = None,
+        alias_priority: int | None = _Unset,
+        validation_alias: str | AliasPath | AliasChoices | None = None,
+        serialization_alias: str | None = None,
+        title: str | None = None,
+        description: str | None = None,
+        gt: float | None = None,
+        ge: float | None = None,
+        lt: float | None = None,
+        le: float | None = None,
+        min_length: int | None = None,
+        max_length: int | None = None,
+        pattern: str | None = None,
+        regex: Annotated[
+            str | None,
+            deprecated(
+                "Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead."
+            ),
+        ] = None,
+        discriminator: str | None = None,
+        strict: bool | None = _Unset,
+        multiple_of: float | None = _Unset,
+        allow_inf_nan: bool | None = _Unset,
+        max_digits: int | None = _Unset,
+        decimal_places: int | None = _Unset,
+        examples: list[Any] | None = None,
+        example: Annotated[
+            Any | None,
+            deprecated(
+                "Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, "
+                "although still supported. Use examples instead."
+            ),
+        ] = _Unset,
+        openapi_examples: dict[str, Example] | None = None,
+        deprecated: deprecated | str | bool | None = None,
+        include_in_schema: bool = True,
+        json_schema_extra: 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=FastAPIDeprecationWarning,
+                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=FastAPIDeprecationWarning,
+                stacklevel=4,
+            )
+        current_json_schema_extra = json_schema_extra or extra
+        kwargs["deprecated"] = deprecated
+        if serialization_alias in (_Unset, None) and isinstance(alias, str):
+            serialization_alias = alias
+        if validation_alias in (_Unset, None):
+            validation_alias = alias
+        kwargs.update(
+            {
+                "annotation": annotation,
+                "alias_priority": alias_priority,
+                "validation_alias": validation_alias,
+                "serialization_alias": serialization_alias,
+                "strict": strict,
+                "json_schema_extra": current_json_schema_extra,
+            }
+        )
+        kwargs["pattern"] = pattern or regex
+
+        use_kwargs = {k: v for k, v in kwargs.items() if v is not _Unset}
+
+        super().__init__(**use_kwargs)  # ty: ignore[invalid-argument-type]
+
+    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: Callable[[], Any] | None = _Unset,
+        annotation: Any | None = None,
+        media_type: str = "application/x-www-form-urlencoded",
+        alias: str | None = None,
+        alias_priority: int | None = _Unset,
+        validation_alias: str | AliasPath | AliasChoices | None = None,
+        serialization_alias: str | None = None,
+        title: str | None = None,
+        description: str | None = None,
+        gt: float | None = None,
+        ge: float | None = None,
+        lt: float | None = None,
+        le: float | None = None,
+        min_length: int | None = None,
+        max_length: int | None = None,
+        pattern: str | None = None,
+        regex: Annotated[
+            str | None,
+            deprecated(
+                "Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead."
+            ),
+        ] = None,
+        discriminator: str | None = None,
+        strict: bool | None = _Unset,
+        multiple_of: float | None = _Unset,
+        allow_inf_nan: bool | None = _Unset,
+        max_digits: int | None = _Unset,
+        decimal_places: int | None = _Unset,
+        examples: list[Any] | None = None,
+        example: Annotated[
+            Any | None,
+            deprecated(
+                "Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, "
+                "although still supported. Use examples instead."
+            ),
+        ] = _Unset,
+        openapi_examples: dict[str, Example] | None = None,
+        deprecated: deprecated | str | bool | None = None,
+        include_in_schema: bool = True,
+        json_schema_extra: 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: Callable[[], Any] | None = _Unset,
+        annotation: Any | None = None,
+        media_type: str = "multipart/form-data",
+        alias: str | None = None,
+        alias_priority: int | None = _Unset,
+        validation_alias: str | AliasPath | AliasChoices | None = None,
+        serialization_alias: str | None = None,
+        title: str | None = None,
+        description: str | None = None,
+        gt: float | None = None,
+        ge: float | None = None,
+        lt: float | None = None,
+        le: float | None = None,
+        min_length: int | None = None,
+        max_length: int | None = None,
+        pattern: str | None = None,
+        regex: Annotated[
+            str | None,
+            deprecated(
+                "Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead."
+            ),
+        ] = None,
+        discriminator: str | None = None,
+        strict: bool | None = _Unset,
+        multiple_of: float | None = _Unset,
+        allow_inf_nan: bool | None = _Unset,
+        max_digits: int | None = _Unset,
+        decimal_places: int | None = _Unset,
+        examples: list[Any] | None = None,
+        example: Annotated[
+            Any | None,
+            deprecated(
+                "Deprecated in OpenAPI 3.1.0 that now uses JSON Schema 2020-12, "
+                "although still supported. Use examples instead."
+            ),
+        ] = _Unset,
+        openapi_examples: dict[str, Example] | None = None,
+        deprecated: deprecated | str | bool | None = None,
+        include_in_schema: bool = True,
+        json_schema_extra: 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,
+        )
+
+
+@dataclass(frozen=True)
+class Depends:
+    dependency: Callable[..., Any] | None = None
+    use_cache: bool = True
+    scope: Literal["function", "request"] | None = None
+
+
+@dataclass(frozen=True)
+class Security(Depends):
+    scopes: Sequence[str] | None = None

lib/python3.11/site-packages/fastapi/requests.py

@@ -0,0 +1,2 @@
+from starlette.requests import HTTPConnection as HTTPConnection  # noqa: F401
+from starlette.requests import Request as Request  # noqa: F401

lib/python3.11/site-packages/fastapi/responses.py

@@ -0,0 +1,98 @@
+import importlib
+from typing import Any, Protocol, cast
+
+from fastapi.exceptions import FastAPIDeprecationWarning
+from fastapi.sse import EventSourceResponse as EventSourceResponse  # noqa
+from starlette.responses import FileResponse as FileResponse  # noqa
+from starlette.responses import HTMLResponse as HTMLResponse  # noqa
+from starlette.responses import JSONResponse as JSONResponse  # noqa
+from starlette.responses import PlainTextResponse as PlainTextResponse  # noqa
+from starlette.responses import RedirectResponse as RedirectResponse  # noqa
+from starlette.responses import Response as Response  # noqa
+from starlette.responses import StreamingResponse as StreamingResponse  # noqa
+from typing_extensions import deprecated
+
+
+class _UjsonModule(Protocol):
+    def dumps(self, __obj: Any, *, ensure_ascii: bool = ...) -> str: ...
+
+
+class _OrjsonModule(Protocol):
+    OPT_NON_STR_KEYS: int
+    OPT_SERIALIZE_NUMPY: int
+
+    def dumps(self, __obj: Any, *, option: int = ...) -> bytes: ...
+
+
+try:
+    ujson = cast(_UjsonModule, importlib.import_module("ujson"))
+except ModuleNotFoundError:  # pragma: nocover
+    ujson = None  # type: ignore[assignment]
+
+
+try:
+    orjson = cast(_OrjsonModule, importlib.import_module("orjson"))
+except ModuleNotFoundError:  # pragma: nocover
+    orjson = None  # type: ignore[assignment]
+
+
+@deprecated(
+    "UJSONResponse is deprecated, FastAPI now serializes data directly to JSON "
+    "bytes via Pydantic when a return type or response model is set, which is "
+    "faster and doesn't need a custom response class. Read more in the FastAPI "
+    "docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model "
+    "and https://fastapi.tiangolo.com/tutorial/response-model/",
+    category=FastAPIDeprecationWarning,
+    stacklevel=2,
+)
+class UJSONResponse(JSONResponse):
+    """JSON response using the ujson library to serialize data to JSON.
+
+    **Deprecated**: `UJSONResponse` is deprecated. FastAPI now serializes data
+    directly to JSON bytes via Pydantic when a return type or response model is
+    set, which is faster and doesn't need a custom response class.
+
+    Read more in the
+    [FastAPI docs for Custom Response](https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model)
+    and the
+    [FastAPI docs for Response Model](https://fastapi.tiangolo.com/tutorial/response-model/).
+
+    **Note**: `ujson` is not included with FastAPI and must be installed
+    separately, e.g. `pip install ujson`.
+    """
+
+    def render(self, content: Any) -> bytes:
+        assert ujson is not None, "ujson must be installed to use UJSONResponse"
+        return ujson.dumps(content, ensure_ascii=False).encode("utf-8")
+
+
+@deprecated(
+    "ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON "
+    "bytes via Pydantic when a return type or response model is set, which is "
+    "faster and doesn't need a custom response class. Read more in the FastAPI "
+    "docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model "
+    "and https://fastapi.tiangolo.com/tutorial/response-model/",
+    category=FastAPIDeprecationWarning,
+    stacklevel=2,
+)
+class ORJSONResponse(JSONResponse):
+    """JSON response using the orjson library to serialize data to JSON.
+
+    **Deprecated**: `ORJSONResponse` is deprecated. FastAPI now serializes data
+    directly to JSON bytes via Pydantic when a return type or response model is
+    set, which is faster and doesn't need a custom response class.
+
+    Read more in the
+    [FastAPI docs for Custom Response](https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model)
+    and the
+    [FastAPI docs for Response Model](https://fastapi.tiangolo.com/tutorial/response-model/).
+
+    **Note**: `orjson` is not included with FastAPI and must be installed
+    separately, e.g. `pip install orjson`.
+    """
+
+    def render(self, content: Any) -> bytes:
+        assert orjson is not None, "orjson must be installed to use ORJSONResponse"
+        return orjson.dumps(
+            content, option=orjson.OPT_NON_STR_KEYS | orjson.OPT_SERIALIZE_NUMPY
+        )

lib/python3.11/site-packages/fastapi/sse.py

@@ -0,0 +1,235 @@
+from typing import Annotated, Any
+
+from annotated_doc import Doc
+from pydantic import AfterValidator, BaseModel, Field, model_validator
+from starlette.responses import StreamingResponse
+
+# Canonical SSE event schema matching the OpenAPI 3.2 spec
+# (Section 4.14.4 "Special Considerations for Server-Sent Events")
+_SSE_EVENT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "data": {"type": "string"},
+        "event": {"type": "string"},
+        "id": {"type": "string"},
+        "retry": {"type": "integer", "minimum": 0},
+    },
+}
+
+
+class EventSourceResponse(StreamingResponse):
+    """Streaming response with `text/event-stream` media type.
+
+    Use as `response_class=EventSourceResponse` on a *path operation* that uses `yield`
+    to enable Server Sent Events (SSE) responses.
+
+    Works with **any HTTP method** (`GET`, `POST`, etc.), which makes it compatible
+    with protocols like MCP that stream SSE over `POST`.
+
+    The actual encoding logic lives in the FastAPI routing layer. This class
+    serves mainly as a marker and sets the correct `Content-Type`.
+    """
+
+    media_type = "text/event-stream"
+
+
+def _check_single_line(v: str | None, field_name: str) -> str | None:
+    if v is not None and ("\r" in v or "\n" in v):
+        raise ValueError(f"SSE '{field_name}' must be a single line")
+    return v
+
+
+def _check_event_single_line(v: str | None) -> str | None:
+    return _check_single_line(v, "event")
+
+
+def _check_id_valid(v: str | None) -> str | None:
+    if v is not None and "\0" in v:
+        raise ValueError("SSE 'id' must not contain null characters")
+    return _check_single_line(v, "id")
+
+
+class ServerSentEvent(BaseModel):
+    """Represents a single Server-Sent Event.
+
+    When `yield`ed from a *path operation function* that uses
+    `response_class=EventSourceResponse`, each `ServerSentEvent` is encoded
+    into the [SSE wire format](https://html.spec.whatwg.org/multipage/server-sent-events.html#parsing-an-event-stream)
+    (`text/event-stream`).
+
+    If you yield a plain object (dict, Pydantic model, etc.) instead, it is
+    automatically JSON-encoded and sent as the `data:` field.
+
+    All `data` values **including plain strings** are JSON-serialized.
+
+    For example, `data="hello"` produces `data: "hello"` on the wire (with
+    quotes).
+    """
+
+    data: Annotated[
+        Any,
+        Doc(
+            """
+            The event payload.
+
+            Can be any JSON-serializable value: a Pydantic model, dict, list,
+            string, number, etc. It is **always** serialized to JSON: strings
+            are quoted (`"hello"` becomes `data: "hello"` on the wire).
+
+            Mutually exclusive with `raw_data`.
+            """
+        ),
+    ] = None
+    raw_data: Annotated[
+        str | None,
+        Doc(
+            """
+            Raw string to send as the `data:` field **without** JSON encoding.
+
+            Use this when you need to send pre-formatted text, HTML fragments,
+            CSV lines, or any non-JSON payload. The string is placed directly
+            into the `data:` field as-is.
+
+            Mutually exclusive with `data`.
+            """
+        ),
+    ] = None
+    event: Annotated[
+        str | None,
+        AfterValidator(_check_event_single_line),
+        Doc(
+            """
+            Optional event type name.
+
+            Maps to `addEventListener(event, ...)` on the browser. When omitted,
+            the browser dispatches on the generic `message` event. Must be a
+            single line.
+            """
+        ),
+    ] = None
+    id: Annotated[
+        str | None,
+        AfterValidator(_check_id_valid),
+        Doc(
+            """
+            Optional event ID.
+
+            The browser sends this value back as the `Last-Event-ID` header on
+            automatic reconnection. **Must be a single line** and must not contain
+            null (`\\0`) characters.
+            """
+        ),
+    ] = None
+    retry: Annotated[
+        int | None,
+        Field(ge=0),
+        Doc(
+            """
+            Optional reconnection time in **milliseconds**.
+
+            Tells the browser how long to wait before reconnecting after the
+            connection is lost. Must be a non-negative integer.
+            """
+        ),
+    ] = None
+    comment: Annotated[
+        str | None,
+        Doc(
+            """
+            Optional comment line(s).
+
+            Comment lines start with `:` in the SSE wire format and are ignored by
+            `EventSource` clients. Useful for keep-alive pings to prevent
+            proxy/load-balancer timeouts.
+            """
+        ),
+    ] = None
+
+    @model_validator(mode="after")
+    def _check_data_exclusive(self) -> "ServerSentEvent":
+        if self.data is not None and self.raw_data is not None:
+            raise ValueError(
+                "Cannot set both 'data' and 'raw_data' on the same "
+                "ServerSentEvent. Use 'data' for JSON-serialized payloads "
+                "or 'raw_data' for pre-formatted strings."
+            )
+        return self
+
+
+def format_sse_event(
+    *,
+    data_str: Annotated[
+        str | None,
+        Doc(
+            """
+            Pre-serialized data string to use as the `data:` field.
+            """
+        ),
+    ] = None,
+    event: Annotated[
+        str | None,
+        Doc(
+            """
+            Optional event type name (`event:` field).
+            """
+        ),
+    ] = None,
+    id: Annotated[
+        str | None,
+        Doc(
+            """
+            Optional event ID (`id:` field).
+            """
+        ),
+    ] = None,
+    retry: Annotated[
+        int | None,
+        Doc(
+            """
+            Optional reconnection time in milliseconds (`retry:` field).
+            """
+        ),
+    ] = None,
+    comment: Annotated[
+        str | None,
+        Doc(
+            """
+            Optional comment line(s) (`:` prefix).
+            """
+        ),
+    ] = None,
+) -> bytes:
+    """Build SSE wire-format bytes from **pre-serialized** data.
+
+    The result always ends with `\n\n` (the event terminator).
+    """
+    lines: list[str] = []
+
+    if comment is not None:
+        for line in comment.splitlines():
+            lines.append(f": {line}")
+
+    if event is not None:
+        lines.append(f"event: {event}")
+
+    if data_str is not None:
+        for line in data_str.splitlines():
+            lines.append(f"data: {line}")
+
+    if id is not None:
+        lines.append(f"id: {id}")
+
+    if retry is not None:
+        lines.append(f"retry: {retry}")
+
+    lines.append("")
+    lines.append("")
+    return "\n".join(lines).encode("utf-8")
+
+
+# Keep-alive comment, per the SSE spec recommendation
+KEEPALIVE_COMMENT = b": ping\n\n"
+
+# Seconds between keep-alive pings when a generator is idle.
+# Private but importable so tests can monkeypatch it.
+_PING_INTERVAL: float = 15.0

lib/python3.11/site-packages/fastapi/staticfiles.py

@@ -0,0 +1 @@
+from starlette.staticfiles import StaticFiles as StaticFiles  # noqa

lib/python3.11/site-packages/fastapi/templating.py

@@ -0,0 +1 @@
+from starlette.templating import Jinja2Templates as Jinja2Templates  # noqa

lib/python3.11/site-packages/fastapi/testclient.py

@@ -0,0 +1 @@
+from starlette.testclient import TestClient as TestClient  # noqa

lib/python3.11/site-packages/fastapi/types.py

@@ -0,0 +1,12 @@
+import types
+from collections.abc import Callable
+from enum import Enum
+from typing import Any, TypeVar, Union
+
+from pydantic import BaseModel
+from pydantic.main import IncEx as IncEx
+
+DecoratedCallable = TypeVar("DecoratedCallable", bound=Callable[..., Any])
+UnionType = getattr(types, "UnionType", Union)
+ModelNameMap = dict[type[BaseModel] | type[Enum], str]
+DependencyCacheKey = tuple[Callable[..., Any] | None, tuple[str, ...], str]

lib/python3.11/site-packages/fastapi/utils.py

@@ -0,0 +1,136 @@
+import re
+import warnings
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Literal,
+)
+
+import fastapi
+from fastapi._compat import (
+    ModelField,
+    PydanticSchemaGenerationError,
+    Undefined,
+    annotation_is_pydantic_v1,
+)
+from fastapi.datastructures import DefaultPlaceholder, DefaultType
+from fastapi.exceptions import FastAPIDeprecationWarning, PydanticV1NotSupportedError
+from pydantic.fields import FieldInfo
+
+from ._compat import v2
+
+if TYPE_CHECKING:  # pragma: nocover
+    from .routing import APIRoute
+
+
+def is_body_allowed_for_status_code(status_code: int | str | None) -> bool:
+    if status_code is None:
+        return True
+    # Ref: https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#patterned-fields-1
+    if status_code in {
+        "default",
+        "1XX",
+        "2XX",
+        "3XX",
+        "4XX",
+        "5XX",
+    }:
+        return True
+    current_status_code = int(status_code)
+    return not (current_status_code < 200 or current_status_code in {204, 205, 304})
+
+
+def get_path_param_names(path: str) -> set[str]:
+    return set(re.findall("{(.*?)}", path))
+
+
+_invalid_args_message = (
+    "Invalid args for response field! Hint: "
+    "check that {type_} is a valid Pydantic field type. "
+    "If you are using a return type annotation that is not a valid Pydantic "
+    "field (e.g. Union[Response, dict, None]) you can disable generating the "
+    "response model from the type annotation with the path operation decorator "
+    "parameter response_model=None. Read more: "
+    "https://fastapi.tiangolo.com/tutorial/response-model/"
+)
+
+
+def create_model_field(
+    name: str,
+    type_: Any,
+    default: Any | None = Undefined,
+    field_info: FieldInfo | None = None,
+    alias: str | None = None,
+    mode: Literal["validation", "serialization"] = "validation",
+) -> ModelField:
+    if annotation_is_pydantic_v1(type_):
+        raise PydanticV1NotSupportedError(
+            "pydantic.v1 models are no longer supported by FastAPI."
+            f" Please update the response model {type_!r}."
+        )
+    field_info = field_info or FieldInfo(annotation=type_, default=default, alias=alias)
+    try:
+        return v2.ModelField(mode=mode, name=name, field_info=field_info)
+    except PydanticSchemaGenerationError:
+        raise fastapi.exceptions.FastAPIError(
+            _invalid_args_message.format(type_=type_)
+        ) from None
+
+
+def generate_operation_id_for_path(
+    *, name: str, path: str, method: str
+) -> str:  # pragma: nocover
+    warnings.warn(
+        message="fastapi.utils.generate_operation_id_for_path() was deprecated, "
+        "it is not used internally, and will be removed soon",
+        category=FastAPIDeprecationWarning,
+        stacklevel=2,
+    )
+    operation_id = f"{name}{path}"
+    operation_id = re.sub(r"\W", "_", operation_id)
+    operation_id = f"{operation_id}_{method.lower()}"
+    return operation_id
+
+
+def generate_unique_id(route: "APIRoute") -> str:
+    operation_id = f"{route.name}{route.path_format}"
+    operation_id = re.sub(r"\W", "_", operation_id)
+    assert route.methods
+    operation_id = f"{operation_id}_{list(route.methods)[0].lower()}"
+    return operation_id
+
+
+def deep_dict_update(main_dict: dict[Any, Any], update_dict: dict[Any, Any]) -> None:
+    for key, value in update_dict.items():
+        if (
+            key in main_dict
+            and isinstance(main_dict[key], dict)
+            and isinstance(value, dict)
+        ):
+            deep_dict_update(main_dict[key], value)
+        elif (
+            key in main_dict
+            and isinstance(main_dict[key], list)
+            and isinstance(update_dict[key], list)
+        ):
+            main_dict[key] = main_dict[key] + update_dict[key]
+        else:
+            main_dict[key] = value
+
+
+def get_value_or_default(
+    first_item: DefaultPlaceholder | DefaultType,
+    *extra_items: DefaultPlaceholder | DefaultType,
+) -> DefaultPlaceholder | DefaultType:
+    """
+    Pass items or `DefaultPlaceholder`s by descending priority.
+
+    The first one to _not_ be a `DefaultPlaceholder` will be returned.
+
+    Otherwise, the first item (a `DefaultPlaceholder`) will be returned.
+    """
+    items = (first_item,) + extra_items
+    for item in items:
+        if not isinstance(item, DefaultPlaceholder):
+            return item
+    return first_item