{!> ../../../docs_src/path_operation_configuration/tutorial003_py310.py!}
    ```

## 📛 ⚪️➡️ #️⃣

📛 😑 📏 &amp; 📔 💗 ⏸, 👆 💪 📣 *➡ 🛠️* 📛 🔢 <abbr title="a multi-line string as the first expression inside a function (not assigned to any variable) used for documentation"> #️⃣ </abbr> &amp; **FastAPI** 🔜 ✍ ⚫️ ⚪️➡️ 📤.

And then, when using the dependency in a *path operation function*, we declare it with the type `Session` we imported directly from SQLAlchemy.

This will then give us better editor support inside the *path operation function*, because the editor will know that the `db` parameter is of type `Session`:

=== "Python 3.9+"

    ```Python hl_lines="22  30  36  45  51"

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

And will be also used in the API docs inside each *path operation* that needs them:

<img src="/img/tutorial/body/image02.png">

## Editor support

In your editor, inside your function you will get type hints and completion everywhere (this wouldn't happen if you received a `dict` instead of a Pydantic model):

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

you can also declare a group of `examples` with additional information that will be added to their **JSON Schemas** inside of **OpenAPI**.

### `Body` with `examples`

Here we pass `examples` containing one example of the data expected in `Body()`:

=== "Python 3.10+"

    ```Python hl_lines="22-29"

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

You declare the dependency as the type of the parameter, and you use `Depends()` without any parameter, instead of having to write the full class *again* inside of `Depends(CommonQueryParams)`.

The same example would then look like:

=== "Python 3.10+"

    ```Python hl_lines="19"
    {!> ../../../docs_src/dependencies/tutorial004_an_py310.py!}
    ```

# Additional Status Codes

By default, **FastAPI** will return the responses using a `JSONResponse`, putting the content you return from your *path operation* inside of that `JSONResponse`.

It will use the default status code or the one you set in your *path operation*.

## Additional status codes

This won't happen if you import that module (file).

So, if you have another file `importer.py` with:

```Python
from myapp import app

# Some more code
```

in that case, the automatically created variable inside of `myapp.py` will not have the variable `__name__` with a value of `"__main__"`.

So, the line:

```Python
    uvicorn.run(app, host="0.0.0.0", port=8000)
```

will not be executed.

!!! info

Here we define the config `env_file` inside of your Pydantic `Settings` class, and set the value to the filename with the dotenv file we want to use.

### Creating the `Settings` only once with `lru_cache`

5. Copy the `./app` directory inside the `/code` directory.

    As this has all the code which is what **changes most frequently** the Docker **cache** won't be used for this or any **following steps** easily.

And as the write operation doesn't use `async` and `await`, we define the function with normal `def`:

```Python hl_lines="6-9"
{!../../../docs_src/background_tasks/tutorial001.py!}
```

## Add the background task

Inside of your *path operation function*, pass your task function to the *background tasks* object with the method `.add_task()`:

```Python hl_lines="14"
{!../../../docs_src/background_tasks/tutorial001.py!}
```