# https://github.com/apache/lucene-solr/blob/master/lucene/analysis/common/src/resources/org/apache/lucene/analysis/snowball/french_stop.txt
au
aux
avec
ce
ces
dans
de
des
du
elle
en
et
eux
il
je
la
le
leur
lui
ma
mais
me
même
mes
moi
mon
ne
nos
notre
nous
on
ou
par
pas
pour
qu
que
qui
sa
se
ses
son
sur
ta
te
tes

### Casos de uso: serviço externo

Um exemplo pode ser que você possua um provedor de autenticação externo que você precisa chamar.

Você envia ao serviço um *token* e ele retorna um usuário autenticado.

Este provedor pode cobrar por requisição, e chamá-lo pode levar mais tempo do que se você tivesse um usuário fixo para os testes.

Y luego puedes establecer cookies en ese objeto de response *temporal*.

{* ../../docs_src/response_cookies/tutorial002.py hl[1, 8:9] *}

Y entonces puedes devolver cualquier objeto que necesites, como normalmente lo harías (un `dict`, un modelo de base de datos, etc).

Y si declaraste un `response_model`, todavía se utilizará para filtrar y convertir el objeto que devolviste.

Si no se proporciona, es `None` por defecto; aquí proporcionamos `"World"` como el valor por defecto para usar.

///

Luego podrías llamar a ese programa Python:

//// tab | Linux, macOS, Windows Bash

<div class="termy">

```console
// Aquí todavía no configuramos la env var
$ python main.py

Luego, cuando escribes ese nombre de usuario y contraseña, el navegador los envía automáticamente en el header.

## Simple HTTP Basic Auth

* Importa `HTTPBasic` y `HTTPBasicCredentials`.
* Crea un "esquema de `security`" usando `HTTPBasic`.
* Usa ese `security` con una dependencia en tu *path operation*.
* Devuelve un objeto de tipo `HTTPBasicCredentials`:

Así que vamos a usar ese mismo conocimiento para documentar cómo debería verse la *API externa*... creando la(s) *path operation(s)* que la API externa debería implementar (las que tu API va a llamar).

/// tip | Consejo

Cuando escribas el código para documentar un callback, podría ser útil imaginar que eres ese *desarrollador externo*. Y que actualmente estás implementando la *API externa*, no *tu API*.

/// info | Informação

`Form` é uma classe que herda diretamente de `Body`.

///

/// tip | Dica

Para declarar corpos de formulário, você precisa usar `Form` explicitamente, porque sem ele os parâmetros seriam interpretados como parâmetros de consulta ou parâmetros de corpo (JSON).

///

## Sobre "Campos de formulário"

```Python
{"id": id}
```

Por exemplo, dado um ID de valor `42`, aparecerá:

```html
Item ID: 42
```

### Argumentos do `url_for`

Você também pode usar `url_for()` dentro do template, ele recebe como argumentos os mesmos argumentos que seriam usados pela sua *path operation function*.

Logo, a seção com:

{% raw %}

```jinja
<a href="{{ url_for('read_item', id=id) }}">
```

{% endraw %}

### El response resultante

Si el cliente solicita `http://example.com/items/foo` (un `item_id` `"foo"`), ese cliente recibirá un código de estado HTTP de 200, y un response JSON de:

```JSON
{
  "item": "The Foo Wrestlers"
}
```

Pero si el cliente solicita `http://example.com/items/bar` (un `item_id` inexistente `"bar"`), ese cliente recibirá un código de estado HTTP de 404 (el error "no encontrado"), y un response JSON de:

```JSON

Você pode combinar *operações de rota* normais do FastAPI com GraphQL na mesma aplicação.

/// tip | Dica

**GraphQL** resolve alguns casos de uso muito específicos.

Ele tem **vantagens** e **desvantagens** quando comparado a **web APIs** comuns.

Certifique-se de avaliar se os **benefícios** para o seu caso de uso compensam as **desvantagens**. 🤓

///

## Bibliotecas GraphQL