```Python hl_lines="15"
    {!> ../../../docs_src/body_nested_models/tutorial008.py!}
    ```

## Editor support everywhere

And you get editor support everywhere.

Even for items inside of lists:

<img src="/img/tutorial/body-nested-models/image01.png">

You couldn't get this kind of editor support if you were working directly with `dict` instead of Pydantic models.

编写带有类型标注的标准 Python：

```Python
from datetime import date

from pydantic import BaseModel

# Declare a variable as a str
# and get editor support inside the function
def main(user_id: str):
    return user_id


# A Pydantic model
class User(BaseModel):
    id: int
    name: str
    joined: date
```

可以像这样来使用：

```Python

👆 ✍ 🐩 🐍 ⏮️ 🆎:

```Python
from datetime import date

from pydantic import BaseModel

# Declare a variable as a str
# and get editor support inside the function
def main(user_id: str):
    return user_id


# A Pydantic model
class User(BaseModel):
    id: int
    name: str
    joined: date
```

👈 💪 ⤴️ ⚙️ 💖:

```Python

!!! check "A inspiré **FastAPI** à"
Hug a inspiré certaines parties d'APIStar, et était l'un des outils que je trouvais les plus prometteurs, à côté d'APIStar.

    Hug a contribué à inspirer **FastAPI** pour utiliser les type hints Python
    pour déclarer les paramètres, et pour générer automatiquement un schéma définissant l'API.

The `TestClient` does some magic inside to call the asynchronous FastAPI application in your normal `def` test functions, using standard pytest. But that magic doesn't work anymore when we're using it inside asynchronous functions. By running our tests asynchronously, we can no longer use the `TestClient` inside our test functions.

But you can also declare the `Response` that you want to be used, in the *path operation decorator*.

The contents that you return from your *path operation function* will be put inside of that `Response`.

    return burgers
```

### More technical details

You might have noticed that `await` can only be used inside of functions defined with `async def`.

But at the same time, functions defined with `async def` have to be "awaited". So, functions with `async def` can only be called inside of functions defined with `async def` too.

So, about the egg and the chicken, how do you call the first `async` function?

```Python hl_lines="1  4  7-9"
{!../../../docs_src/extending_openapi/tutorial001.py!}
```

### Generate the OpenAPI schema

Then, use the same utility function to generate the OpenAPI schema, inside a `custom_openapi()` function:

```Python hl_lines="2  15-21"
{!../../../docs_src/extending_openapi/tutorial001.py!}
```

### Modify the OpenAPI schema

    !!! tip
        Prefer to use the `Annotated` version if possible.

    ```Python hl_lines="1  2  12-16"
    {!> ../../../docs_src/extra_data_types/tutorial001.py!}
    ```

Note that the parameters inside the function have their natural data type, and you can, for example, perform normal date manipulations, like:

=== "Python 3.10+"

    ```Python hl_lines="18-19"

```

To set a value used in the current "context" (e.g. for the current request) use:

```Python
some_var.set("new value")
```

To get a value anywhere inside of the context (e.g. in any part handling the current request) use:

```Python
some_var.get()
```

### Set context variables in the `async` dependency `reset_db_state()`