# Code below omitted 👇
    ```

    <details>
    <summary>👀 Full file preview</summary>

    ```Python
    {!> ../../../docs_src/separate_openapi_schemas/tutorial001_py310.py!}
    ```

    </details>

=== "Python 3.9+"

    ```Python hl_lines="16"
    {!> ../../../docs_src/separate_openapi_schemas/tutorial001_py39.py[ln:1-17]!}

    # Code below omitted 👇
    ```

    <details>

## Environment Variables

!!! tip
    If you already know what "environment variables" are and how to use them, feel free to skip to the next section below.

## Dependencies with `yield`, `HTTPException`, `except` and Background Tasks

!!! warning
    You most probably don't need these technical details, you can skip this section and continue below.

    These details are useful mainly if you were using a version of FastAPI prior to 0.106.0 and used resources from dependencies with `yield` in background tasks.

To understand more about it, see the section <a href="https://fastapi.tiangolo.com/benchmarks/" class="internal-link" target="_blank">Benchmarks</a>.

            ] = fastapi_specific_annotations[-1]
        else:
            fastapi_annotation = None
        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 is Undefined or field_info.default is Required, (

It will have a property `scopes` with a list containing all the scopes required by itself and all the dependencies that use this as a sub-dependency. That means, all the "dependants"... this might sound confusing, it is explained again later below.

The `security_scopes` object (of class `SecurityScopes`) also provides a `scope_str` attribute with a single string, containing those scopes separated by spaces (we are going to use it).

    else_: Optional["SchemaOrBool"] = Field(default=None, alias="else")
    dependentSchemas: Optional[Dict[str, "SchemaOrBool"]] = None
    prefixItems: Optional[List["SchemaOrBool"]] = None
    # TODO: uncomment and remove below when deprecating Pydantic v1
    # It generales a list of schemas for tuples, before prefixItems was available
    # items: Optional["SchemaOrBool"] = None
    items: Optional[Union["SchemaOrBool", List["SchemaOrBool"]]] = None

When creating a **FastAPI** class instance or an `APIRouter` you can specify which response class to use by default.

The parameter that defines this is `default_response_class`.

In the example below, **FastAPI** will use `ORJSONResponse` by default, in all *path operations*, instead of `JSONResponse`.

```Python hl_lines="2  4"
{!../../../docs_src/custom_response/tutorial010.py!}
```

!!! tip

## Technical Details

Modern versions of Python have support for **"asynchronous code"** using something called **"coroutines"**, with **`async` and `await`** syntax.

Let's see that phrase by parts in the sections below:

* **Asynchronous Code**
* **`async` and `await`**
* **Coroutines**

## Asynchronous Code

This will easily let you test that your app with Peewee and FastAPI is behaving correctly with all the stuff about threads.

If you want to check how Peewee would break your app if used without modification, go the `sql_app/database.py` file and comment the line:

```Python
# db._state = PeeweeConnectionState()
```