</div>

Cela signifie qu'il aura **toujours une valeur**, simplement, parfois la valeur pourra être `None` (ou `null` en JSON).

Cela signifie que les clients utilisant votre API n'ont pas à vérifier si la valeur existe ou non, ils peuvent **supposer que le champ sera toujours présent**, mais que, dans certains cas, il aura la valeur par défaut `None`.

Por causa disso, o próprio **FastAPI** fornece uma documentação alternativa da API (usando ReDoc), que você pode acessar em [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc):

<img src="/img/tutorial/path-params/image02.png">

        UnknownHostException exception = assertThrows(UnknownHostException.class, () -> {
            nameServiceClient.getNbtByName("NONEXISTENT-FAST-FAIL");
        }, "Should throw UnknownHostException for non-existent NetBIOS name");

        // Verify the exception message indicates name resolution failure
        assertTrue(exception.getMessage().contains("NONEXISTENT") || exception.getMessage().contains("unknown")

        } catch (org.codelibs.core.exception.ResourceNotFoundRuntimeException e) {
            // Expected behavior - method throws exception for non-existent files
            assertTrue(e.getMessage().contains("nonexistent.conf"));
        }

        // Test with multiple names - should also throw exception for non-existent files
        try {

et de le réparer, d'arrêter et de redémarrer le serveur de développement, _etc._

## Stratégies de déploiement { #deployment-strategies }

Il existe plusieurs façons de procéder, en fonction de votre cas d'utilisation spécifique et des outils que vous
utilisez.

Vous pouvez **déployer un serveur** vous-même en utilisant une combinaison d'outils, vous pouvez utiliser un **service

# Codificador Compatível com JSON { #json-compatible-encoder }

Existem alguns casos em que você pode precisar converter um tipo de dados (como um modelo Pydantic) para algo compatível com JSON (como um `dict`, `list`, etc).

Por exemplo, se você precisar armazená-lo em um banco de dados.

Para isso, **FastAPI** fornece uma função `jsonable_encoder()`.

## Usando a função `jsonable_encoder` { #using-the-jsonable-encoder }

```Python
with open("file.txt") as file:
    file.read()
```

Dans les versions récentes de Python, il existe aussi un **gestionnaire de contexte asynchrone**. Vous l'utiliseriez avec `async with` :

```Python
async with lifespan(app):
    await do_stuff()
```

   * of the queue is evicted to make room.
   *
   * @return {@code true} always
   */
  @Override
  @CanIgnoreReturnValue
  public boolean offer(E e) {
    return add(e);
  }

  /**
   * Adds the given element to this queue. If the queue is currently full, the element at the head
   * of the queue is evicted to make room.
   *
   * @return {@code true} always
   */

# Extendendo o OpenAPI { #extending-openapi }

Existem alguns casos em que pode ser necessário modificar o esquema OpenAPI gerado.

Nesta seção, você verá como fazer isso.

## O processo normal { #the-normal-process }

O processo normal (padrão) é o seguinte:

Uma aplicação (instância) do `FastAPI` possui um método `.openapi()` que deve retornar o esquema OpenAPI.

            }
        };

        try {
            emptyEnv.get("non.existent.property");
            fail("Should throw ConfigPropertyNotFoundException");
        } catch (ConfigPropertyNotFoundException e) {
            assertTrue(e.getMessage().contains("non.existent.property"));
        }

        try {
            emptyEnv.is("non.existent.boolean");
            fail("Should throw ConfigPropertyNotFoundException");