# Contributing guidelines

## Pull Request Checklist

Before sending your pull requests, make sure you do the following:

-   Read the [contributing guidelines](CONTRIBUTING.md).
-   Read the [Code of Conduct](CODE_OF_CONDUCT.md).
-   Ensure you have signed the
    [Contributor License Agreement (CLA)](https://cla.developers.google.com/).
-   Check if your changes are consistent with the

For large responses, returning a `Response` directly is much faster than returning a dictionary.

This is because by default, FastAPI will inspect every item inside and make sure it is serializable as JSON, using the same [JSON Compatible Encoder](../tutorial/encoder.md){.internal-link target=_blank} explained in the tutorial. This is what allows you to return **arbitrary objects**, for example database models.

      Request.Builder()
        .url(server.url("/"))
        .build()
    val response = client.newCall(request).execute()
    assertThat("b").isEqualTo(response.body.string())
  }

  /** Make sure interceptors can interact with the OkHttp client.  */
  @Test
  fun interceptorMakesAnUnrelatedRequest() {
    server.enqueue(MockResponse.Builder().body("a").build()) // Fetched by interceptor.

   * connect, and it sets up a same-connection retry with [ErrorCode.REFUSED_STREAM].
   *
   * https://github.com/square/okhttp/pull/7190
   */
  @Test
  fun preferCallConnectionOverDeferredConnection() {
    // Make sure we have enough connection options to permit retries.
    dnsResults =
      listOf(
        localhostIpv4,
        localhostIpv6,
        TestUtil.UNREACHABLE_ADDRESS_IPV4.address,
      )

 * * `Response.body().bytes()`
 * * `Response.body().string()`
 *
 * There is no benefit to invoking multiple `close()` methods for the same response body.
 *
 * For synchronous calls, the easiest way to make sure a response body is closed is with a `try`
 * block. With this structure the compiler inserts an implicit `finally` clause that calls
 * [close()][Response.close] for you.
 *
 * ```java
 * Call call = client.newCall(request);

And we return the scopes as part of the JWT token.

!!! danger
    For simplicity, here we are just adding the scopes received directly to the token.

    But in your application, for security, you should make sure you only add the scopes that the user is actually able to have, or the ones you have predefined.

=== "Python 3.10+"

    ```Python hl_lines="155"
    {!> ../../../docs_src/security/tutorial005_an_py310.py!}
    ```

rootdir: /home/user/code/superawesome-cli/app
plugins: forked-1.1.3, xdist-1.31.0, cov-2.8.1
collected 6 items

---> 100%

test_main.py <span style="color: green; white-space: pre;">......                            [100%]</span>

<span style="color: green;">================= 1 passed in 0.03s =================</span>
```

```Python hl_lines="24"
{!../../../docs_src/sql_databases_peewee/sql_app/database.py!}
```

!!! tip
    Make sure you overwrite `db._state` *after* creating `db`.

!!! tip
    You would do the same for any other Peewee database, including `PostgresqlDatabase`, `MySQLDatabase`, etc.

## Create the database models

                )
        }
        skipConditionally(buildType)
    }
}

fun BuildStep.onlyRunOnGitHubMergeQueueBranch() {
    conditions {
        matches("teamcity.build.branch", "(pre-test/.*)|(gh-readonly-queue/.*)")
    }
}

fun BuildStep.skipConditionally(buildType: BuildType? = null) {
    // we need to run CompileALl unconditionally because of artifact dependency

    ```

!!! tip
    By the spec, you should return a JSON with an `access_token` and a `token_type`, the same as in this example.

    This is something that you have to do yourself in your code, and make sure you use those JSON keys.

    It's almost the only thing that you have to remember to do correctly yourself, to be compliant with the specifications.

    For the rest, **FastAPI** handles it for you.