TF_Operation* two = ScalarConst(2, graph, s);
  ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s);

  TF_Operation* plus2 = Add(a, two, graph, s, "plus2");
  ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s);

  TF_Operation* plusB = Add(plus2, b, graph, s, "plusB");
  ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s);

  // Setup a session and a partial run handle.  The partial run will allow

  }

  @Test
  fun removeUntilEmpty() {
    val tags =
      EmptyTags
        .plus(Integer::class, 5 as Integer)
        .plus(Boolean::class, true)
        .plus(String::class, "a")
        .plus(String::class, null)
        .plus(Integer::class, null)
        .plus(Boolean::class, null)
    assertThat(tags).isEqualTo(EmptyTags)
    assertThat(tags.toString()).isEqualTo("{}")
  }

  @Test

   * instance that does not have any mapping for [key].
   */
  abstract fun <T : Any> plus(
    key: KClass<T>,
    value: T?,
  ): Tags

  abstract operator fun <T : Any> get(key: KClass<T>): T?
}

/** An empty tags. This is always the tail of a [LinkedTags] chain. */
internal object EmptyTags : Tags() {
  override fun <T : Any> plus(
    key: KClass<T>,
    value: T?,
  ): Tags =
    when {

Il serait en fait plus courant d'utiliser Requests _à l'intérieur_ d'une application FastAPI.

Mais quand même, FastAPI s'est inspiré de Requests.

**Requests** est une bibliothèque pour _interagir_ avec les API (en tant que client), tandis que **FastAPI** est une bibliothèque pour _créer_ des API (en tant que serveur).

Ils sont, plus ou moins, aux extrémités opposées, se complétant l'un l'autre.

```

... et voyez comment votre éditeur complétera automatiquement les attributs et connaîtra leurs types :

![compatibilité IDE](https://fastapi.tiangolo.com/img/vscode-completion.png)

Pour un exemple plus complet comprenant plus de fonctionnalités, voir le <a href="https://fastapi.tiangolo.com/fr/tutorial/">Tutoriel - Guide utilisateur</a>.

**Spoiler alert** : le tutoriel - guide utilisateur inclut :

Dans le dernier sondage effectué auprès de développeurs python il était clair que <a href="https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features" class="external-link" target="_blank">la fonctionnalité la plus utilisée est "l’autocomplétion"</a>.

Tout le framework **FastAPI** a été conçu avec cela en tête. L'autocomplétion fonctionne partout.

Vous devrez rarement revenir à la documentation.

traitements aient lieu dans le même process (par exemple, pas besoin de partager la mémoire, les variables, etc.), il peut s'avérer profitable d'utiliser des outils plus importants tels que <a href="https://docs.celeryq.dev" class="external-link" target="_blank">Celery</a>.

Ces outils nécessitent généralement des configurations plus complexes ainsi qu'un gestionnaire de queue de message, comme RabbitMQ ou Redis, mais ils permettent d'exécuter des tâches d'arrière-plan dans différents process,...

"Opération" fait référence à une des "méthodes" HTTP.

Une de :

* `POST`
* `GET`
* `PUT`
* `DELETE`

...ou une des plus exotiques :

* `OPTIONS`
* `HEAD`
* `PATCH`
* `TRACE`

Dans le protocol HTTP, vous pouvez communiquer avec chaque chemin en utilisant une (ou plus) de ces "méthodes".

---

```

</div>

////

/// warning

N'oubliez pas de supprimer l'option `--reload` si vous l'utilisiez.

 L'option `--reload` consomme beaucoup plus de ressources, est plus instable, etc.

 Cela aide beaucoup pendant le **développement**, mais vous **ne devriez pas** l'utiliser en **production**.

///

## Hypercorn avec Trio

Starlette et **FastAPI** sont basés sur

Par exemple, il était clair que l'idéal était de se baser sur les annotations de type Python standard.

De plus, la meilleure approche était d'utiliser des normes déjà existantes.