padronização: asyncio em monoespaço

Author: ramalho

online/cap07.adoc

@@ -357,7 +357,7 @@ Quando chamados, devolvem um gerador assíncrono para ser usado com `async for`.
 Funções geradoras, funções de corrotinas nativas e funções geradoras assíncronas são diferentes de outros invocáveis: os valores devolvidos por tais funções nunca são dados da aplicação, mas objetos que exigem processamento adicional, seja para produzir dados da aplicação, seja para realizar algum trabalho útil.
 Funções geradoras devolvem iteradores.
 Ambos são tratados no <<ch_generators>>.
-Funções de corrotinas nativas e funções geradoras assíncronas devolvem objetos que só funcionam com a ajuda de um framework de programação assíncrona, tal como _asyncio_.
+Funções de corrotinas nativas e funções geradoras assíncronas devolvem objetos que só funcionam com a ajuda de um framework de programação assíncrona, tal como `asyncio`.
 Elas são o assunto do <<ch_async>>.
 
 

online/cap15.adoc

@@ -878,20 +878,20 @@ include::../code/15-more-types/cast/tcp_echo.py[tags=CAST_USE]
 ----
 
 Usar `cast` nesse caso exigiu algumas horas para entender o problema e ler o
-código-fonte de  _asyncio_, para encontrar o tipo correto para _sockets_: a
+código-fonte de  `asyncio`, para encontrar o tipo correto para _sockets_: a
 classe `TransportSocket` do módulo não-documentado `asyncio.trsock`. Também
 precisei adicionar duas instruções `import` e mais uma linha de código para
 melhorar a legibilidade.footnote:[Na realidade, inicialmente coloquei um
 comentário `# type: ignore` às linhas com `+server.sockets[0]+` porque, após
 pesquisar um pouco, encontrei linhas similares na
 https://fpy.li/7g[documentação]
-do _asyncio_ e em um https://fpy.li/15-19[caso de teste], e aí comecei a
+do `asyncio` e em um https://fpy.li/15-19[caso de teste], e aí comecei a
 suspeitar que o problema não estava no meu código.] Mas agora o código está mais
 seguro.
 
 A leitora atenta pode ter notado que `sockets[0]` poderia gerar um `IndexError`
 se `sockets` estiver vazio.
-Entretanto, até onde entendo o _asyncio_, isso não pode acontecer no
+Entretanto, até onde entendo o `asyncio`, isso não pode acontecer no
 <<ex_tcp_mojifinder_main>> do <<ch_async>>, pois no momento em que leio o atributo `sockets`, o
 `server` já está pronto para aceitar conexões , portanto o atributo não estará
 vazio. E, de qualquer forma, `IndexError` ocorre durante a execução. O Mypy não
@@ -1892,7 +1892,7 @@ não precisa usar—exceto para escrever dicas de tipo. Tais classes não são
 documentadas, provavelmente porque são consideradas detalhes de implementação
 pelos autores dos pacotes. Aqui estão dois exemplos da biblioteca padrão.
 
-Tive que vasculhar a imensa documentação do _asyncio_, e depois navegar o
+Tive que vasculhar a imensa documentação do `asyncio`, e depois navegar o
 código-fonte de vários módulos daquele pacote para descobrir a classe
 não-documentada `TransportSocket` no módulo igualmente não documentado
 `asyncio.trsock` só para usar `cast()` no exemplo do `server.sockets`, na

online/cap17.adoc

@@ -2211,7 +2211,7 @@ diferenciá-las das novas "corrotinas nativas".
 Após o lançamento de Python 3.5, a tendência é usar "corrotina" como sinônimo de
 "corrotina nativa". Mas a PEP 342 não está descontinuada, e as corrotinas
 clássicas ainda funcionam como originalmente projetadas, apesar de não serem
-mais suportadas pela biblioteca _asyncio_.
+mais suportadas pela biblioteca `asyncio`.
 
 ====
 
@@ -2568,8 +2568,8 @@ Aquele texto inclui pseudo-código similar ao Python detalhando como `yield from
 ====
 
 Na prática, qualquer trabalho produtivo com corrotinas exige o apoio de um framework especializado.
-É isso que _asyncio_ oferecia para corrotinas clássicas lá atrás, no Python 3.3.
-Com o advento das corrotinas nativas no Python 3.5, os mantenedores de Python estão gradualmente eliminando o suporte a corrotinas clássicas no _asyncio_.
+É isso que `asyncio` oferecia para corrotinas clássicas lá atrás, no Python 3.3.
+Com o advento das corrotinas nativas no Python 3.5, os mantenedores de Python estão gradualmente eliminando o suporte a corrotinas clássicas no `asyncio`.
 Mas os mecanismos subjacentes são muito similares.
 A sintaxe `async def` torna as corrotinas nativas mais visíveis no código,
 um grande benefício por si só.

online/cap19.adoc

@@ -54,7 +54,7 @@ usando Python como sua linguagem primária—apesar das persistentes alegações
 === Novidades neste capítulo
 
 Este((("concurrency models", "significant changes to"))) capítulo é novo, escrito para a segunda edição do _Python Fluente_.
-Os exemplos com os caracteres giratórios na <<concurrent_hello_world>> antes estavam no capítulo sobre _asyncio_.
+Os exemplos com os caracteres giratórios na <<concurrent_hello_world>> antes estavam no capítulo sobre `asyncio`.
 Aqui eles foram revisados, e apresentam uma primeira ilustração das três abordagens de Python à concorrência: threads, processos e corrotinas nativas.
 
 O resto do conteúdo é novo, exceto por alguns parágrafos, que apareciam originalmente nos capítulos sobre `concurrent.futures` e `asyncio`.
@@ -170,7 +170,7 @@ Corrotina::
     Em Python, corrotinas clássicas são criadas a partir de funções geradoras, e corrotinas nativas são definidas com `async def`.
     A <<classic_coroutines_sec>> introduziu o conceito, e o <<ch_async>> trata do uso de corrotinas nativas.
     As corrotinas de Python normalmente rodam dentro de uma única thread, sob a supervisão de um laço de eventos (_event loop_), também na mesma thread.
-    Frameworks de programação assíncrona como _asyncio_, _Curio_, ou _Trio_ fornecem um laço de eventos e bibliotecas de apoio para E/S não-bloqueante baseado em corrotinas.
+    Frameworks de programação assíncrona como `asyncio`, _Curio_, ou _Trio_ fornecem um laço de eventos e bibliotecas de apoio para E/S não-bloqueante baseado em corrotinas.
     Corrotinas permitem _multitarefa cooperativa_:
     cada corrotina deve ceder explicitamente o controle com as palavras-chave `yield` ou `await`, para que outra possa continuar de forma concorrente (mas não em paralelo).
     Isso significa que qualquer código bloqueante em uma corrotina bloqueia a execução do laço de eventos e de todas as outras corrotinas—ao contrário da _multitarefa preemptiva_ suportada por processos e threads.
@@ -530,7 +530,7 @@ O pacote suporta multitarefa cooperativa através de corrotinas leves—chamadas
 e assim são mais fáceis de integrar a bases de código sequencial existentes.
 O https://fpy.li/19-15[SQL Alchemy 1.4 ORM] usa greenlets
 internamente para implementar sua nova
-https://fpy.li/19-16[API assíncrona] compatível com _asyncio_.
+https://fpy.li/19-16[API assíncrona] compatível com `asyncio`.
 
 A((("gevent library"))) biblioteca de programação de redes
 https://fpy.li/19-17[_gevent_] modifica, através de _monkey patches_, o módulo `socket` padrão de Python, tornando-o não-bloqueante, substituindo parte do código daquele módulo por greenlets.
@@ -595,7 +595,7 @@ ele já está agendado para rodar, mas uma instância de `Thread` precisa ser in
 Objetos `Task` oferecem o método `.cancel()`, que levantará um `CancelledError` na expressão `await` onde a corrotina está suspensa naquele momento.
 * A corrotina `supervisor` é acionada com `asyncio.run` na função `main`.
 
-Essa comparação ajuda a entender como a concorrência é orquestrada com _asyncio_,
+Essa comparação ajuda a entender como a concorrência é orquestrada com `asyncio`,
 em contraste com como isso é feito com o módulo `threading`, que pode ser mais familiar
 para quem já usou threads em qualquer linguagem.
 
@@ -1035,7 +1035,7 @@ stack, disparando efeitos colaterais custosos, como invalidar os caches da CPU e
 talvez até trocar páginas de memória. footnote:[Para saber mais, consulte
 https://fpy.li/ad["Troca de contexto"] na Wikipedia.]
 
-Os dois próximos capítulos tratam de mais temas ligados à programação concorrente em Python, usando a biblioteca de alto nível _concurrent.futures_ para gerenciar threads e processos (<<ch_executors>>) e a biblioteca _asyncio_ para programação assíncrona (<<ch_async>>).
+Os dois próximos capítulos tratam de mais temas ligados à programação concorrente em Python, usando a biblioteca de alto nível _concurrent.futures_ para gerenciar threads e processos (<<ch_executors>>) e a biblioteca `asyncio` para programação assíncrona (<<ch_async>>).
 
 As((("", startref="CMprocess19"))) demais seções nesse capítulo procuram responder à questão:
 
@@ -1131,7 +1131,7 @@ https://fpy.li/19-31[_Salt_],
 bem como bibliotecas como a
 https://fpy.li/19-32[_Fabric_].
 
-Há também um número crescente de bibliotecas para administração de sistemas que suportam corrotinas e _asyncio_.
+Há também um número crescente de bibliotecas para administração de sistemas que suportam corrotinas e `asyncio`.
 Em 2016, a https://fpy.li/19-33[equipe de Engenharia de Produção] do Facebook relatou:
 "Estamos cada vez mais confiantes no AsyncIO, introduzido no Python 3.4,
 e vendo ganhos de desempenho imensos conforme migramos as bases de código de Python 2."