Por ejemplo, digamos que estás utilizando la versión `0.112.0` en tu aplicación.

Si usas un archivo `requirements.txt` podrías especificar la versión con:

```txt
fastapi[standard]==0.112.0
```

eso significaría que usarías exactamente la versión `0.112.0`.

O también podrías fijarla con:

* <a href="https://stackshare.io/pypi-fastapi" class="external-link" target="_blank">Di que usas **FastAPI** en StackShare</a>.

## Ayuda a otros con preguntas en GitHub { #help-others-with-questions-in-github }

Puedes intentar ayudar a otros con sus preguntas en:

Para declarar un **request** body, usas modelos de <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> con todo su poder y beneficios.

/// info | Información

Pero FastAPI (en realidad Starlette) proporciona una forma más simple de hacerlo que asegura que los middlewares internos manejen errores del servidor y los controladores de excepciones personalizadas funcionen correctamente.

Para eso, usas `app.add_middleware()` (como en el ejemplo para CORS).

```Python
from fastapi import FastAPI
from unicorn import UnicornMiddleware

app = FastAPI()

app.add_middleware(UnicornMiddleware, some_config="rainbow")

///

## Argumentos adicionales en `Field` { #field-additional-arguments }

Cuando usas `Field()` con modelos de Pydantic, también puedes declarar `examples` adicionales:

{* ../../docs_src/schema_extra_example/tutorial002_py310.py hl[2,8:11] *}

## `examples` en JSON Schema - OpenAPI { #examples-in-json-schema-openapi }

Cuando usas cualquiera de:

* `Path()`
* `Query()`
* `Header()`
* `Cookie()`
* `Body()`

/// tip | Consejo

Prefiere usar la versión `Annotated` si es posible.

///

```Python
commons: CommonQueryParams = Depends()
```

////

Declaras la dependencia como el tipo del parámetro, y usas `Depends()` sin ningún parámetro, en lugar de tener que escribir la clase completa *otra vez* dentro de `Depends(CommonQueryParams)`.

El mismo ejemplo se vería entonces así:

			if wg != nil {
				wg.Done()
			}
			// Clean up and de-register the subscriber
			ps.Lock()
			defer ps.Unlock()
			var remainTypes Mask
			for i, s := range ps.subs {
				if s == sub {
					ps.subs = append(ps.subs[:i], ps.subs[i+1:]...)
				} else {
					remainTypes.Merge(s.types)
				}
			}
			atomic.StoreUint64(&ps.types, uint64(remainTypes))
			atomic.AddInt32(&ps.numSubscribers, -1)
		}()

Sin embargo, si usas el comando `pip install fastapi`, el paquete `python-multipart` no se incluye por defecto.

{* ../../docs_src/dependencies/tutorial008_an_py39.py hl[18:19,26:27] *}

Da mesma forma, você pode ter algumas dependências com `yield` e outras com `return` e ter uma relação de dependência entre algumas das duas.

E você poderia ter uma única dependência que precisa de diversas outras dependências com `yield`, etc.

Você pode ter qualquer combinação de dependências que você quiser.

Você também pode usá-lo para gerar código automaticamente para clientes que se comunicam com sua API. Por exemplo, aplicativos front-end, móveis ou IoT.

### Faça o deploy da sua aplicação (opcional) { #deploy-your-app-optional }