Pero puedes configurar explícitamente la app a usar.

## Configura el `entrypoint` de la app en `pyproject.toml` { #configure-the-app-entrypoint-in-pyproject-toml }

Puedes configurar dónde está tu app en un archivo `pyproject.toml` así:

```toml
[tool.fastapi]
entrypoint = "main:app"
```

Ese `entrypoint` le dirá al comando `fastapi` que debe importar la app así:

```python

change unified the key-management aspect within MinIO.

The unified KMS-based approach has several advantages:

- Key management is now centralized. There is one way to change or rotate encryption keys.
   There used to be two different mechanisms - one for regular S3 objects and one for IAM data.
- Reduced server startup time. For IAM encryption with the root credentials, MinIO had

Le *chemin d’accès* lui-même déclare également un scope, « items », il sera donc aussi présent dans la liste `security_scopes.scopes` passée à `get_current_user`.

Voici à quoi ressemble la hiérarchie des dépendances et des scopes :

* Le *chemin d’accès* `read_own_items` a :

* There's also a good chance that the pull request is not actually needed because the problem can be solved in a **different way**. Then you can suggest or ask about that.

### Don't worry about style { #dont-worry-about-style }

* Don't worry too much about things like commit message styles, I will squash and merge customizing the commit manually.

pkg net/rpc, method (*Server) ServeRequest(ServerCodec) error
pkg net/rpc, method (ServerError) Error() string
pkg net/rpc, type Call struct
pkg net/rpc, type Call struct, Args interface{}
pkg net/rpc, type Call struct, Done chan *Call
pkg net/rpc, type Call struct, Error error
pkg net/rpc, type Call struct, Reply interface{}
pkg net/rpc, type Call struct, ServiceMethod string
pkg net/rpc, type Client struct

Y también tendrá ambas responses en la documentación, una para `404` y otra para `403`.

///

## El `FastAPI` principal { #the-main-fastapi }

Ahora, veamos el módulo en `app/main.py`.

Aquí es donde importas y usas la clase `FastAPI`.

Este será el archivo principal en tu aplicación que conecta todo.

Y como la mayor parte de tu lógica ahora vivirá en su propio módulo específico, el archivo principal será bastante simple.

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

///

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

////

**FastAPI** proporciona un atajo para estos casos, en donde la dependencia es *específicamente* una clase que **FastAPI** "llamará" para crear una instance de la clase misma.

Para esos casos específicos, puedes hacer lo siguiente:

En lugar de escribir:

{* ../../docs_src/path_params_numeric_validations/tutorial001_an_py310.py hl[10] *}

/// note | Nota

Un parámetro de path siempre es requerido ya que tiene que formar parte del path. Incluso si lo declaras con `None` o le asignas un valor por defecto, no afectará en nada, siempre será requerido.

///

## Ordena los parámetros como necesites { #order-the-parameters-as-you-need }

/// tip | Consejo

Esto será especialmente útil cuando lo uses en una **gran code base** donde uses **las mismas dependencias** una y otra vez en **muchas *path operations***.

## Usar `async` o no usar `async` { #to-async-or-not-to-async }

                                fields.add(new ListField(currentField));
                            } else if (Collection.class.isAssignableFrom(type)) {
                                throw new RuntimeException("We dont interpolate into collections, use a list instead");
                            } else if (Map.class.isAssignableFrom(type)) {
                                fields.add(new MapField(currentField));