Ele tem um recurso interessante e incomum: usando o mesmo framework, é possível criar APIs e também CLIs.

Como é baseado no padrão anterior para frameworks web Python síncronos (WSGI), ele não consegue lidar com Websockets e outras coisas, embora ainda tenha alta performance também.

/// info | Informação

Apenas tenha em mente que quando você ler "servidor" em geral, isso pode se referir a uma dessas duas coisas.

Quando se refere à máquina remota, é comum chamá-la de **servidor**, mas também de **máquina**, **VM** (máquina virtual), **nó**. Todos esses termos se referem a algum tipo de máquina remota, normalmente executando Linux, onde você executa programas.

## Instale o Programa Servidor { #install-the-server-program }

Se você usa um arquivo `requirements.txt`, você poderia especificar a versão com:

```txt
fastapi[standard]==0.112.0
```

isso significaria que você usaria exatamente a versão `0.112.0`.

Ou você também poderia fixá-la com:

```txt
fastapi[standard]>=0.112.0,<0.113.0
```

isso significaria que você usaria as versões `0.112.0` ou superiores, mas menores que `0.113.0`, por exemplo, a versão `0.112.2` ainda seria aceita.

    byte[] expectedBytes = new byte[size];
    byte[] bytes = newPreFilledByteArray(1024);

    // Setup
    File file = createTempFile();
    Files.write(bytes, file);

    Random random = new Random();
    random.nextBytes(expectedBytes);

    // Test
    MappedByteBuffer map = Files.map(file, MapMode.READ_WRITE);
    map.put(expectedBytes);

    // Verify

A especificação também afirma que o `username` e a `password` devem ser enviados como dados de formulário (portanto, não há JSON aqui).

### `scope` { #scope }

A especificação também diz que o cliente pode enviar outro campo de formulário "`scope`".

      }
    }
  }

  @GwtIncompatible // Too slow in GWT (~3min fully optimized)
  public void testDivideRemainderEuclideanProperty() {
    // Use a seed so that the test is deterministic:
    Random r = new Random(0L);
    for (int i = 0; i < 1000000; i++) {
      int dividend = r.nextInt();
      int divisor = r.nextInt();
      // Test that the Euclidean property is preserved:
      assertThat(
              dividend

     */
    public enum LoadBalancingStrategy {
        /** Round-robin distribution */
        ROUND_ROBIN,
        /** Least connections */
        LEAST_CONNECTIONS,
        /** Random selection */
        RANDOM,
        /** Failover only (use primary until failure) */
        FAILOVER_ONLY
    }

    /**
     * Represents a group of channels for a single session.
     */

  public void testRemovalNotification_get_basher() throws InterruptedException {
    int nTasks = 1000;
    int nThreads = 100;
    int getsPerTask = 1000;
    int nUniqueKeys = 10000;
    Random random = new Random(); // Randoms.insecureRandom();

    QueuingRemovalListener<String, String> removalListener = queuingRemovalListener();
    AtomicInteger computeCount = new AtomicInteger();

* para **saída**, ele será **obrigatório** (e possivelmente `None`, ou em termos de JSON, `null`)

### Modelo para Saída na Documentação { #model-for-output-in-docs }

Você pode verificar o modelo de saída na documentação também, **ambos** `name` e `description` são marcados como **obrigatórios** com um **asterisco vermelho**:

<div class="screenshot">
<img src="/img/tutorial/separate-openapi-schemas/image03.png">
</div>

O `root_path` é um mecanismo fornecido pela especificação ASGI (na qual o FastAPI é construído, através do Starlette).

O `root_path` é usado para lidar com esses casos específicos.

E também é usado internamente ao montar sub-aplicações.