🌐 Update translations for pt (add-missing) (#15157)

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

docs/pt/docs/tutorial/server-sent-events.md

@@ -0,0 +1,120 @@
+# Eventos Enviados pelo Servidor (SSE) { #server-sent-events-sse }
+
+Você pode transmitir dados para o cliente usando Server-Sent Events (SSE).
+
+Isso é semelhante a [Stream de JSON Lines](stream-json-lines.md), mas usa o formato `text/event-stream`, que é suportado nativamente pelos navegadores com a [`EventSource` API](https://developer.mozilla.org/en-US/docs/Web/API/EventSource).
+
+/// info | Informação
+
+Adicionado no FastAPI 0.135.0.
+
+///
+
+## O que são Server-Sent Events? { #what-are-server-sent-events }
+
+SSE é um padrão para transmitir dados do servidor para o cliente via HTTP.
+
+Cada evento é um pequeno bloco de texto com “campos” como `data`, `event`, `id` e `retry`, separados por linhas em branco.
+
+Fica assim:
+
+```
+data: {"name": "Portal Gun", "price": 999.99}
+
+data: {"name": "Plumbus", "price": 32.99}
+
+```
+
+SSE é comumente usado para streaming de chat de IA, notificações em tempo real, logs e observabilidade, e outros casos em que o servidor envia atualizações para o cliente.
+
+/// tip | Dica
+
+Se você quiser transmitir dados binários, por exemplo vídeo ou áudio, veja o guia avançado: [Stream de Dados](../advanced/stream-data.md).
+
+///
+
+## Transmitir SSE com FastAPI { #stream-sse-with-fastapi }
+
+Para transmitir SSE com FastAPI, use `yield` na sua função de operação de rota e defina `response_class=EventSourceResponse`.
+
+Importe `EventSourceResponse` de `fastapi.sse`:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[4,22] *}
+
+Cada item produzido é codificado como JSON e enviado no campo `data:` de um evento SSE.
+
+Se você declarar o tipo de retorno como `AsyncIterable[Item]`, o FastAPI o usará para validar, documentar e serializar os dados com o Pydantic.
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[10:12,23] *}
+
+/// tip | Dica
+
+Como o Pydantic fará a serialização no lado em **Rust**, você terá um desempenho muito maior do que se não declarar um tipo de retorno.
+
+///
+
+### *Funções de operação de rota* não assíncronas { #non-async-path-operation-functions }
+
+Você também pode usar funções `def` normais (sem `async`) e usar `yield` da mesma forma.
+
+O FastAPI garantirá a execução correta para não bloquear o event loop.
+
+Como, neste caso, a função não é assíncrona, o tipo de retorno adequado seria `Iterable[Item]`:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[28:31] hl[29] *}
+
+### Sem tipo de retorno { #no-return-type }
+
+Você também pode omitir o tipo de retorno. O FastAPI usará o [`jsonable_encoder`](./encoder.md) para converter os dados e enviá-los.
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[34:37] hl[35] *}
+
+## `ServerSentEvent` { #serversentevent }
+
+Se você precisar definir campos de SSE como `event`, `id`, `retry` ou `comment`, você pode produzir objetos `ServerSentEvent` em vez de dados simples.
+
+Importe `ServerSentEvent` de `fastapi.sse`:
+
+{* ../../docs_src/server_sent_events/tutorial002_py310.py hl[4,26] *}
+
+O campo `data` é sempre codificado como JSON. Você pode passar qualquer valor que possa ser serializado como JSON, incluindo modelos do Pydantic.
+
+## Dados brutos { #raw-data }
+
+Se você precisar enviar dados sem codificação JSON, use `raw_data` em vez de `data`.
+
+Isto é útil para enviar texto pré-formatado, linhas de log ou valores <dfn title="um valor usado para indicar uma condição ou estado especial">"sentinela"</dfn> especiais como `[DONE]`.
+
+{* ../../docs_src/server_sent_events/tutorial003_py310.py hl[17] *}
+
+/// note | Nota
+
+`data` e `raw_data` são mutuamente exclusivos. Você só pode definir um deles em cada `ServerSentEvent`.
+
+///
+
+## Retomando com `Last-Event-ID` { #resuming-with-last-event-id }
+
+Quando um navegador se reconecta após uma queda na conexão, ele envia o último `id` recebido no cabeçalho `Last-Event-ID`.
+
+Você pode lê-lo como um parâmetro de cabeçalho e usá-lo para retomar o stream de onde o cliente parou:
+
+{* ../../docs_src/server_sent_events/tutorial004_py310.py hl[25,27,31] *}
+
+## SSE com POST { #sse-with-post }
+
+SSE funciona com qualquer método HTTP, não apenas `GET`.
+
+Isso é útil para protocolos como o [MCP](https://modelcontextprotocol.io) que fazem stream de SSE via `POST`:
+
+{* ../../docs_src/server_sent_events/tutorial005_py310.py hl[14] *}
+
+## Detalhes Técnicos { #technical-details }
+
+O FastAPI implementa algumas boas práticas de SSE prontas para uso.
+
+- Enviar um comentário de keep alive `ping` a cada 15 segundos quando não houver mensagens, para evitar que alguns proxies fechem a conexão, como sugerido na [especificação HTML: Server-Sent Events](https://html.spec.whatwg.org/multipage/server-sent-events.html#authoring-notes).
+- Definir o cabeçalho `Cache-Control: no-cache` para evitar o cache do stream.
+- Definir o cabeçalho especial `X-Accel-Buffering: no` para evitar buffering em alguns proxies como o Nginx.
+
+Você não precisa fazer nada, isso funciona automaticamente. 🤓

docs/pt/docs/tutorial/stream-json-lines.md

@@ -0,0 +1,111 @@
+# Stream de JSON Lines { #stream-json-lines }
+
+Você pode ter uma sequência de dados que deseja enviar em um "**Stream**"; é possível fazer isso com **JSON Lines**.
+
+/// info | Informação
+
+Adicionado no FastAPI 0.134.0.
+
+///
+
+## O que é um Stream? { #what-is-a-stream }
+
+"**Streaming**" de dados significa que sua aplicação começará a enviar itens ao cliente sem esperar que toda a sequência esteja pronta.
+
+Assim, ela envia o primeiro item, o cliente o recebe e começa a processá-lo, enquanto você ainda pode estar produzindo o próximo item.
+
+```mermaid
+sequenceDiagram
+    participant App
+    participant Client
+
+    App->>App: Produce Item 1
+    App->>Client: Send Item 1
+    App->>App: Produce Item 2
+    Client->>Client: Process Item 1
+    App->>Client: Send Item 2
+    App->>App: Produce Item 3
+    Client->>Client: Process Item 2
+    App->>Client: Send Item 3
+    Client->>Client: Process Item 3
+    Note over App: Keeps producing...
+    Note over Client: Keeps consuming...
+```
+
+Pode até ser um Stream infinito, em que você continua enviando dados.
+
+## JSON Lines { #json-lines }
+
+Nesses casos, é comum enviar "**JSON Lines**", um formato em que você envia um objeto JSON por linha.
+
+Uma response teria um tipo de conteúdo `application/jsonl` (em vez de `application/json`) e o corpo seria algo como:
+
+```json
+{"name": "Plumbus", "description": "A multi-purpose household device."}
+{"name": "Portal Gun", "description": "A portal opening device."}
+{"name": "Meeseeks Box", "description": "A box that summons a Meeseeks."}
+```
+
+É muito semelhante a um array JSON (equivalente a uma list do Python), mas em vez de estar envolto em `[]` e ter `,` entre os itens, há **um objeto JSON por linha**, separados por um caractere de nova linha.
+
+/// info | Informação
+
+O ponto importante é que sua aplicação poderá produzir cada linha em sequência, enquanto o cliente consome as anteriores.
+
+///
+
+/// note | Detalhes Técnicos
+
+Como cada objeto JSON será separado por uma nova linha, eles não podem conter caracteres de nova linha literais em seu conteúdo, mas podem conter novas linhas com escape (`\n`), o que faz parte do padrão JSON.
+
+Mas, normalmente, você não precisará se preocupar com isso, é feito automaticamente, continue lendo. 🤓
+
+///
+
+## Casos de uso { #use-cases }
+
+Você pode usar isso para transmitir dados de um serviço de **IA LLM**, de **logs** ou **telemetria**, ou de outros tipos de dados que possam ser estruturados em itens **JSON**.
+
+/// tip | Dica
+
+Se você quiser transmitir dados binários, por exemplo vídeo ou áudio, confira o guia avançado: [Stream Data](../advanced/stream-data.md).
+
+///
+
+## Stream de JSON Lines com FastAPI { #stream-json-lines-with-fastapi }
+
+Para transmitir JSON Lines com FastAPI, em vez de usar `return` na sua *função de operação de rota*, use `yield` para produzir cada item em sequência.
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[1:24] hl[24] *}
+
+Se cada item JSON que você quer enviar de volta for do tipo `Item` (um modelo Pydantic) e a função for assíncrona, você pode declarar o tipo de retorno como `AsyncIterable[Item]`:
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[1:24] hl[9:11,22] *}
+
+Se você declarar o tipo de retorno, o FastAPI o usará para **validar** os dados, **documentá-los** no OpenAPI, **filtrá-los** e **serializá-los** usando o Pydantic.
+
+/// tip | Dica
+
+Como o Pydantic fará a serialização no lado em **Rust**, você terá uma **performance** muito maior do que se não declarar um tipo de retorno.
+
+///
+
+### Funções de operação de rota não assíncronas { #non-async-path-operation-functions }
+
+Você também pode usar funções `def` normais (sem `async`) e usar `yield` da mesma forma.
+
+O FastAPI garantirá que sejam executadas corretamente para não bloquear o event loop.
+
+Como, neste caso, a função não é assíncrona, o tipo de retorno adequado seria `Iterable[Item]`:
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[27:30] hl[28] *}
+
+### Sem tipo de retorno { #no-return-type }
+
+Você também pode omitir o tipo de retorno. O FastAPI então usará o [`jsonable_encoder`](./encoder.md) para converter os dados em algo que possa ser serializado para JSON e depois enviá-los como JSON Lines.
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[33:36] hl[34] *}
+
+## Eventos enviados pelo servidor (SSE) { #server-sent-events-sse }
+
+O FastAPI também tem suporte de primeira classe a Server-Sent Events (SSE), que são bastante semelhantes, mas com alguns detalhes extras. Você pode aprender sobre eles no próximo capítulo: [Eventos enviados pelo servidor (SSE)](server-sent-events.md). 🤓