* <p>This interface is now a legacy type. Use {@code java.util.function.Predicate} (or the
 * appropriate primitive specialization such as {@code IntPredicate}) instead whenever possible.
 * Otherwise, at least reduce <i>explicit</i> dependencies on this type by using lambda expressions
 * or method references instead of classes, leaving your code easier to migrate in the future.
 *

  - [Changes by Kind](#changes-by-kind)
    - [Feature](#feature)
    - [Bug or Regression](#bug-or-regression)
    - [Other (Cleanup or Flake)](#other-cleanup-or-flake)
  - [Dependencies](#dependencies)
    - [Added](#added)
    - [Changed](#changed)
    - [Removed](#removed)
- [v1.28.14](#v12814)
  - [Downloads for v1.28.14](#downloads-for-v12814)
    - [Source Code](#source-code-1)

Pour en savoir plus, consultez la section [Benchmarks](https://fastapi.tiangolo.com/fr/benchmarks/).

## Dépendances { #dependencies }

FastAPI dépend de Pydantic et Starlette.

### Dépendances `standard` { #standard-dependencies }

Lorsque vous installez FastAPI avec `pip install "fastapi[standard]"`, il inclut le groupe `standard` de dépendances optionnelles :

Utilisées par Pydantic :

    keep all of your OkHttp artifacts on the same version, even if they're declared via transitive
    dependencies. You can even omit versions when declaring other OkHttp dependencies.

    ```kotlin
    dependencies {
       api(platform("com.squareup.okhttp3:okhttp-bom:4.4.0"))
       api("com.squareup.okhttp3:okhttp")              // No version!

This is a simple guide to get you started and teach you how everything works **underneath**.

There are many **alternatives** to managing virtual environments, package dependencies (requirements), projects.

Once you are ready and want to use a tool to **manage the entire project**, packages dependencies, virtual environments, etc. I would suggest you try [uv](https://github.com/astral-sh/uv).

`uv` can do a lot of things, it can:

 * <p>This interface is now a legacy type. Use {@code java.util.function.Function} (or the
 * appropriate primitive specialization such as {@code ToIntFunction}) instead whenever possible.
 * Otherwise, at least reduce <i>explicit</i> dependencies on this type by using lambda expressions
 * or method references instead of classes, leaving your code easier to migrate in the future.
 *

            Charsets.ISO_8859_1, "\n"
        )
    }

    private
    fun findLatest(name: String, notation: String, dest: Properties) {
        val libDependencies = arrayOf(project.dependencies.create(notation))
        @Suppress("SpreadOperator")
        val templateVersionConfiguration = project.configurations.detachedConfiguration(*libDependencies)

                    "Maven Upgrade " + CLIReportingUtils.showVersionMinimal());
            context.addInHeader("Tool for upgrading Maven projects and dependencies.");
            context.addInHeader("This tool is part of Apache Maven 4 distribution.");
            context.addInHeader("");

            context.terminal.handle(

Il existe des utilitaires pour le configurer facilement que vous pouvez utiliser directement dans votre application **FastAPI** (fournis par Starlette).

## Installer les dépendances { #install-dependencies }

Vous devez créer un [environnement virtuel](../virtual-environments.md), l'activer, puis installer `jinja2` :

<div class="termy">

```console
$ pip install jinja2

---> 100%
```

</div>

    assert resp.status_code == 200
    assert resp.json() == {"status": "ok"}
    assert resp.headers.get("X-Direct") == "set"


def test_response_dependency_chain():
    """Response dependency should work in a chain of dependencies."""
    app = FastAPI()

    def first_modifier(response: Response) -> Response:
        response.headers["X-First"] = "1"
        return response

    def second_modifier(