package="okhttp.okhttp3">

  <uses-permission android:name="android.permission.INTERNET"/>

  <application>
    <provider
      android:name="androidx.startup.InitializationProvider"
      android:authorities="${applicationId}.androidx-startup"
      android:exported="false"
      tools:node="merge">
      <meta-data android:name="okhttp3.internal.platform.PlatformInitializer"

In many cases your application could need some external settings or configurations, for example secret keys, database credentials, credentials for email services, etc.

Most of these settings are variable (can change), like database URLs. And many could be sensitive, like secrets.

For this reason it's common to provide them in environment variables that are read by the application.

/// tip

# Debugging { #debugging }

You can connect the debugger in your editor, for example with Visual Studio Code or PyCharm.

## Call `uvicorn` { #call-uvicorn }

In your FastAPI application, import and run `uvicorn` directly:

{* ../../docs_src/debugging/tutorial001_py310.py hl[1,15] *}

### About `__name__ == "__main__"` { #about-name-main }

     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Waiting for application startup.
     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Application startup complete.
```

</div>

/// tip

For production you would use `fastapi run` instead of `fastapi dev`. 🚀

///

            warnings:
            - "warning1"
            - "warning2"
            headers:
              Content-Type: "application/vnd.elasticsearch+json;compatible-with=7"
              Accept: "application/vnd.elasticsearch+json;compatible-with=7"
            allowed_warnings:
            - "added allowed warning"
            allowed_warnings_regex:

### Java
```java
MockResponse response = new MockResponse.Builder()
    .addHeader("Content-Type", "application/json; charset=utf-8")
    .addHeader("Cache-Control", "no-cache")
    .body("{}")
    .build();
```

### Kotlin
```kotlin
val response = MockResponse.Builder()
  .addHeader("Content-Type", "application/json; charset=utf-8")
  .addHeader("Cache-Control", "no-cache")
  .body("{}")
  .build()
```

You can add middleware to **FastAPI** applications.

A "middleware" is a function that works with every **request** before it is processed by any specific *path operation*. And also with every **response** before returning it.

* It takes each **request** that comes to your application.
* It can then do something to that **request** or run any needed code.
* Then it passes the **request** to be processed by the rest of the application (by some *path operation*).

                                "content": {"application/json": {"schema": {}}},
                            },
                            "422": {
                                "description": "Validation Error",
                                "content": {
                                    "application/json": {
                                        "schema": {

You can use any template engine you want with **FastAPI**.

A common choice is Jinja2, the same one used by Flask and other tools.

There are utilities to configure it easily that you can use directly in your **FastAPI** application (provided by Starlette).

## Install dependencies { #install-dependencies }

Make sure you create a [virtual environment](../virtual-environments.md), activate it, and install `jinja2`:

<div class="termy">

///

## Separating tests { #separating-tests }

In a real application, you probably would have your tests in a different file.

And your **FastAPI** application might also be composed of several files/modules, etc.