asyncio-subprocess.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Raphael Mendon&ccedil;a, 2021
# Claudio Rogerio Carvalho Filho <excriptbrasil@gmail.com>, 2021
# Vinicius Gubiani Ferreira <vini.g.fer@gmail.com>, 2021
# i17obot <i17obot@rougeth.com>, 2021
# Adorilson Bezerra <adorilson@gmail.com>, 2024
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-03-14 14:17+0000\n"
"PO-Revision-Date: 2021-06-28 00:55+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2025\n"
"Language-Team: Portuguese (Brazil) (https://app.transifex.com/python-doc/"
"teams/5390/pt_BR/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: pt_BR\n"
"Plural-Forms: nplurals=3; plural=(n == 0 || n == 1) ? 0 : n != 0 && n % "
"1000000 == 0 ? 1 : 2;\n"

#: ../../library/asyncio-subprocess.rst:7
msgid "Subprocesses"
msgstr "Subprocessos"

#: ../../library/asyncio-subprocess.rst:9
msgid ""
"**Source code:** :source:`Lib/asyncio/subprocess.py`, :source:`Lib/asyncio/"
"base_subprocess.py`"
msgstr ""
"**C&oacute;digo-fonte:** :source:`Lib/asyncio/subprocess.py`, :source:`Lib/asyncio/"
"base_subprocess.py`"

#: ../../library/asyncio-subprocess.rst:14
msgid ""
"This section describes high-level async/await asyncio APIs to create and "
"manage subprocesses."
msgstr ""
"Esta se&ccedil;&atilde;o descreve APIs async/await asyncio de alto n&iacute;vel para criar e "
"gerenciar subprocessos."

#: ../../library/asyncio-subprocess.rst:19
msgid ""
"Here's an example of how asyncio can run a shell command and obtain its "
"result::"
msgstr ""
"Aqui est&aacute; um exemplo de como asyncio pode executar um comando shell e obter "
"o seu resultado::"

#: ../../library/asyncio-subprocess.rst:22
msgid ""
"import asyncio\n"
"\n"
"async def run(cmd):\n"
"    proc = await asyncio.create_subprocess_shell(\n"
"        cmd,\n"
"        stdout=asyncio.subprocess.PIPE,\n"
"        stderr=asyncio.subprocess.PIPE)\n"
"\n"
"    stdout, stderr = await proc.communicate()\n"
"\n"
"    print(f'[{cmd!r} exited with {proc.returncode}]')\n"
"    if stdout:\n"
"        print(f'[stdout]\\n{stdout.decode()}')\n"
"    if stderr:\n"
"        print(f'[stderr]\\n{stderr.decode()}')\n"
"\n"
"asyncio.run(run('ls /zzz'))"
msgstr ""
"import asyncio\n"
"\n"
"async def run(cmd):\n"
"    proc = await asyncio.create_subprocess_shell(\n"
"        cmd,\n"
"        stdout=asyncio.subprocess.PIPE,\n"
"        stderr=asyncio.subprocess.PIPE)\n"
"\n"
"    stdout, stderr = await proc.communicate()\n"
"\n"
"    print(f'[{cmd!r} exited with {proc.returncode}]')\n"
"    if stdout:\n"
"        print(f'[stdout]\\n{stdout.decode()}')\n"
"    if stderr:\n"
"        print(f'[stderr]\\n{stderr.decode()}')\n"
"\n"
"asyncio.run(run('ls /zzz'))"

#: ../../library/asyncio-subprocess.rst:40
msgid "will print::"
msgstr "ir&aacute; exibir::"

#: ../../library/asyncio-subprocess.rst:42
msgid ""
"['ls /zzz' exited with 1]\n"
"[stderr]\n"
"ls: /zzz: No such file or directory"
msgstr ""
"['ls /zzz' exited with 1]\n"
"[stderr]\n"
"ls: /zzz: No such file or directory"

#: ../../library/asyncio-subprocess.rst:46
msgid ""
"Because all asyncio subprocess functions are asynchronous and asyncio "
"provides many tools to work with such functions, it is easy to execute and "
"monitor multiple subprocesses in parallel.  It is indeed trivial to modify "
"the above example to run several commands simultaneously::"
msgstr ""
"Devido ao fato que todas as fun&ccedil;&otilde;es de subprocessos asyncio s&atilde;o ass&iacute;ncronas "
"e asyncio fornece muitas ferramentas para trabalhar com tais fun&ccedil;&otilde;es, &eacute; "
"f&aacute;cil executar e monitorar m&uacute;ltiplos subprocessos em paralelo. &Eacute; na verdade "
"trivial modificar o exemplo acima para executar diversos comandos "
"simultaneamente::"

#: ../../library/asyncio-subprocess.rst:51
msgid ""
"async def main():\n"
"    await asyncio.gather(\n"
"        run('ls /zzz'),\n"
"        run('sleep 1; echo \"hello\"'))\n"
"\n"
"asyncio.run(main())"
msgstr ""
"async def main():\n"
"    await asyncio.gather(\n"
"        run('ls /zzz'),\n"
"        run('sleep 1; echo \"hello\"'))\n"
"\n"
"asyncio.run(main())"

#: ../../library/asyncio-subprocess.rst:58
msgid "See also the `Examples`_ subsection."
msgstr "Veja tamb&eacute;m a subse&ccedil;&atilde;o `Exemplos`_."

#: ../../library/asyncio-subprocess.rst:62
msgid "Creating Subprocesses"
msgstr "Criando subprocessos"

#: ../../library/asyncio-subprocess.rst:68
msgid "Create a subprocess."
msgstr "Cria um subprocesso."

#: ../../library/asyncio-subprocess.rst:70
#: ../../library/asyncio-subprocess.rst:89
msgid ""
"The *limit* argument sets the buffer limit for :class:`StreamReader` "
"wrappers for :attr:`~asyncio.subprocess.Process.stdout` and :attr:`~asyncio."
"subprocess.Process.stderr` (if :const:`subprocess.PIPE` is passed to "
"*stdout* and *stderr* arguments)."
msgstr ""
"O argumento *limit* define o limite do buffer para os inv&oacute;lucros :class:"
"`StreamReader` para :attr:`~asyncio.subprocess.Process.stdout` e :attr:"
"`~asyncio.subprocess.Process.stderr` (se :const:`subprocess.PIPE` for "
"passado para os argumentos *stdout* e *stderr*)."

#: ../../library/asyncio-subprocess.rst:74
#: ../../library/asyncio-subprocess.rst:93
msgid "Return a :class:`~asyncio.subprocess.Process` instance."
msgstr "Retorna uma inst&acirc;ncia de :class:`~asyncio.subprocess.Process`."

#: ../../library/asyncio-subprocess.rst:76
msgid ""
"See the documentation of :meth:`loop.subprocess_exec` for other parameters."
msgstr ""
"Veja a documenta&ccedil;&atilde;o de :meth:`loop.subprocess_exec` para outros par&acirc;metros."

#: ../../library/asyncio-subprocess.rst:79
#: ../../library/asyncio-subprocess.rst:107
msgid "Removed the *loop* parameter."
msgstr "Removido o par&acirc;metro *loop*."

#: ../../library/asyncio-subprocess.rst:87
msgid "Run the *cmd* shell command."
msgstr "Executa o comando *cmd* no shell."

#: ../../library/asyncio-subprocess.rst:95
msgid ""
"See the documentation of :meth:`loop.subprocess_shell` for other parameters."
msgstr ""
"Veja a documenta&ccedil;&atilde;o de :meth:`loop.subprocess_shell` para outros par&acirc;metros."

#: ../../library/asyncio-subprocess.rst:100
msgid ""
"It is the application's responsibility to ensure that all whitespace and "
"special characters are quoted appropriately to avoid `shell injection "
"<https://en.wikipedia.org/wiki/Shell_injection#Shell_injection>`_ "
"vulnerabilities. The :func:`shlex.quote` function can be used to properly "
"escape whitespace and special shell characters in strings that are going to "
"be used to construct shell commands."
msgstr ""
"&Eacute; responsabilidade da aplica&ccedil;&atilde;o garantir que todos os espa&ccedil;os em branco e "
"caracteres especiais tenham aspas apropriadamente para evitar "
"vulnerabilidades de `inje&ccedil;&atilde;o de shell <https://en.wikipedia.org/wiki/"
"Shell_injection#Shell_injection>`_. A fun&ccedil;&atilde;o :func:`shlex.quote` pode ser "
"usada para escapar espa&ccedil;os em branco e caracteres especiais de shell "
"apropriadamente em strings que ser&atilde;o usadas para construir comandos shell."

#: ../../library/asyncio-subprocess.rst:112
msgid ""
"Subprocesses are available for Windows if a :class:`ProactorEventLoop` is "
"used. See :ref:`Subprocess Support on Windows <asyncio-windows-subprocess>` "
"for details."
msgstr ""
"Subprocessos est&atilde;o dispon&iacute;veis para Windows se uma :class:"
"`ProactorEventLoop` for usada. Veja :ref:`Suporte para subprocesso para "
"Windows <asyncio-windows-subprocess>` para detalhes."

#: ../../library/asyncio-subprocess.rst:118
msgid ""
"asyncio also has the following *low-level* APIs to work with subprocesses: :"
"meth:`loop.subprocess_exec`, :meth:`loop.subprocess_shell`, :meth:`loop."
"connect_read_pipe`, :meth:`loop.connect_write_pipe`, as well as the :ref:"
"`Subprocess Transports <asyncio-subprocess-transports>` and :ref:`Subprocess "
"Protocols <asyncio-subprocess-protocols>`."
msgstr ""
"asyncio tamb&eacute;m tem as seguintes APIs *de baixo n&iacute;vel* para trabalhar com "
"subprocessos: :meth:`loop.subprocess_exec`, :meth:`loop.subprocess_shell`, :"
"meth:`loop.connect_read_pipe`, :meth:`loop.connect_write_pipe`, assim como "
"os :ref:`Transportes de Subprocesso <asyncio-subprocess-transports>` e :ref:"
"`Protocolos de Subprocesso <asyncio-subprocess-protocols>`."

#: ../../library/asyncio-subprocess.rst:126
msgid "Constants"
msgstr "Constantes"

#: ../../library/asyncio-subprocess.rst:131
msgid "Can be passed to the *stdin*, *stdout* or *stderr* parameters."
msgstr "Pode ser passado para os par&acirc;metros *stdin*, *stdout* ou *stderr*."

#: ../../library/asyncio-subprocess.rst:133
msgid ""
"If *PIPE* is passed to *stdin* argument, the :attr:`Process.stdin <asyncio."
"subprocess.Process.stdin>` attribute will point to a :class:`~asyncio."
"StreamWriter` instance."
msgstr ""
"Se *PIPE* for passado para o argumento *stdin*, o atributo :attr:`Process."
"stdin <asyncio.subprocess.Process.stdin>` ir&aacute; apontar para uma inst&acirc;ncia :"
"class:`~asyncio.StreamWriter`."

#: ../../library/asyncio-subprocess.rst:137
msgid ""
"If *PIPE* is passed to *stdout* or *stderr* arguments, the :attr:`Process."
"stdout <asyncio.subprocess.Process.stdout>` and :attr:`Process.stderr "
"<asyncio.subprocess.Process.stderr>` attributes will point to :class:"
"`~asyncio.StreamReader` instances."
msgstr ""
"Se *PIPE* for passado para os argumentos *stdout* ou *stderr*, os atributos :"
"attr:`Process.stdout <asyncio.subprocess.Process.stdout>` e :attr:`Process."
"stderr <asyncio.subprocess.Process.stderr>` ir&atilde;o apontar para inst&acirc;ncias :"
"class:`~asyncio.StreamReader`."

#: ../../library/asyncio-subprocess.rst:145
msgid ""
"Special value that can be used as the *stderr* argument and indicates that "
"standard error should be redirected into standard output."
msgstr ""
"Valor especial que pode ser usado como o argumento *stderr* e indica que a "
"sa&iacute;da de erro padr&atilde;o deve ser redirecionada para a sa&iacute;da padr&atilde;o."

#: ../../library/asyncio-subprocess.rst:151
msgid ""
"Special value that can be used as the *stdin*, *stdout* or *stderr* argument "
"to process creation functions.  It indicates that the special file :data:`os."
"devnull` will be used for the corresponding subprocess stream."
msgstr ""
"Valor especial que pode ser usado como argumento *stdin*, *stdout* ou "
"*stderr* para fun&ccedil;&otilde;es de cria&ccedil;&atilde;o de processos. Ele indica que o arquivo "
"especial :data:`os.devnull` ser&aacute; usado para o fluxo de subprocesso "
"correspondente."

#: ../../library/asyncio-subprocess.rst:157
msgid "Interacting with Subprocesses"
msgstr "Interagindo com subprocessos"

#: ../../library/asyncio-subprocess.rst:159
msgid ""
"Both :func:`create_subprocess_exec` and :func:`create_subprocess_shell` "
"functions return instances of the *Process* class.  *Process* is a high-"
"level wrapper that allows communicating with subprocesses and watching for "
"their completion."
msgstr ""
"Ambas as fun&ccedil;&otilde;es :func:`create_subprocess_exec` e :func:"
"`create_subprocess_shell` retornam inst&acirc;ncias da classe *Process*. *Process* "
"&eacute; um inv&oacute;lucro de alto n&iacute;vel que permite a comunica&ccedil;&atilde;o com subprocessos e "
"observar eles serem completados."

#: ../../library/asyncio-subprocess.rst:167
msgid ""
"An object that wraps OS processes created by the :func:`~asyncio."
"create_subprocess_exec` and :func:`~asyncio.create_subprocess_shell` "
"functions."
msgstr ""
"Um objeto que envolve processos do sistema operacional criados pelas "
"fun&ccedil;&otilde;es :func:`~asyncio.create_subprocess_exec` e :func:`~asyncio."
"create_subprocess_shell`."

#: ../../library/asyncio-subprocess.rst:171
msgid ""
"This class is designed to have a similar API to the :class:`subprocess."
"Popen` class, but there are some notable differences:"
msgstr ""
"Esta classe &eacute; projetada para ter uma API similar a classe :class:`subprocess."
"Popen`, mas existem algumas diferen&ccedil;as not&aacute;veis:"

#: ../../library/asyncio-subprocess.rst:175
msgid ""
"unlike Popen, Process instances do not have an equivalent to the :meth:"
"`~subprocess.Popen.poll` method;"
msgstr ""
"ao contr&aacute;rio de Popen, inst&acirc;ncias de Process n&atilde;o t&ecirc;m um equivalente ao "
"m&eacute;todo :meth:`~subprocess.Popen.poll`;"

#: ../../library/asyncio-subprocess.rst:178
msgid ""
"the :meth:`~asyncio.subprocess.Process.communicate` and :meth:`~asyncio."
"subprocess.Process.wait` methods don't have a *timeout* parameter: use the :"
"func:`~asyncio.wait_for` function;"
msgstr ""
"os m&eacute;todos :meth:`~asyncio.subprocess.Process.communicate` e :meth:`~asyncio."
"subprocess.Process.wait` n&atilde;o t&ecirc;m um par&acirc;metro *timeout*: utilize a fun&ccedil;&atilde;o :"
"func:`~ascyncio.wait_for`;"

#: ../../library/asyncio-subprocess.rst:182
msgid ""
"the :meth:`Process.wait() <asyncio.subprocess.Process.wait>` method is "
"asynchronous, whereas :meth:`subprocess.Popen.wait` method is implemented as "
"a blocking busy loop;"
msgstr ""
"o m&eacute;todo :meth:`Process.wait() <asyncio.subprocess.Process.wait>` &eacute; "
"ass&iacute;ncrono, enquanto que o m&eacute;todo :meth:`subprocess.Popen.wait` &eacute; "
"implementado como um la&ccedil;o bloqueante para indicar que est&aacute; ocupado;"

#: ../../library/asyncio-subprocess.rst:186
msgid "the *universal_newlines* parameter is not supported."
msgstr "o par&acirc;metro *universal_newlines* n&atilde;o &eacute; suportado."

#: ../../library/asyncio-subprocess.rst:188
msgid "This class is :ref:`not thread safe <asyncio-multithreading>`."
msgstr "Esta classe :ref:`n&atilde;o &eacute; segura para thread <asyncio-multithreading>`."

#: ../../library/asyncio-subprocess.rst:190
msgid ""
"See also the :ref:`Subprocess and Threads <asyncio-subprocess-threads>` "
"section."
msgstr ""
"Veja tamb&eacute;m a se&ccedil;&atilde;o :ref:`Subprocesso e Threads <asyncio-subprocess-"
"threads>`."

#: ../../library/asyncio-subprocess.rst:196
msgid "Wait for the child process to terminate."
msgstr "Aguarda o processo filho encerrar."

#: ../../library/asyncio-subprocess.rst:198
msgid "Set and return the :attr:`returncode` attribute."
msgstr "Define e retorna o atributo :attr:`returncode`."

#: ../../library/asyncio-subprocess.rst:202
msgid ""
"This method can deadlock when using ``stdout=PIPE`` or ``stderr=PIPE`` and "
"the child process generates so much output that it blocks waiting for the OS "
"pipe buffer to accept more data. Use the :meth:`communicate` method when "
"using pipes to avoid this condition."
msgstr ""
"Este m&eacute;todo pode entrar em deadlock ao usar ``stdout=PIPE`` ou "
"``stderr=PIPE`` e o processo filho gera tantas sa&iacute;das que ele bloqueia a "
"espera pelo encadeamento de buffer do sistema operacional para aceitar mais "
"dados. Use o m&eacute;todo :meth:`communicate` ao usar encadeamentos para evitar "
"essa condi&ccedil;&atilde;o."

#: ../../library/asyncio-subprocess.rst:211
msgid "Interact with process:"
msgstr "Interage com processo:"

#: ../../library/asyncio-subprocess.rst:213
msgid "send data to *stdin* (if *input* is not ``None``);"
msgstr "envia dados para *stdin* (se *input* for diferente de ``None``);"

#: ../../library/asyncio-subprocess.rst:214
msgid "closes *stdin*;"
msgstr "fecha *stdin*;"

#: ../../library/asyncio-subprocess.rst:215
msgid "read data from *stdout* and *stderr*, until EOF is reached;"
msgstr ""
"l&ecirc; dados a partir de *stdout* e *stderr*, at&eacute; que EOF (fim do arquivo) seja "
"atingido;"

#: ../../library/asyncio-subprocess.rst:216
msgid "wait for process to terminate."
msgstr "aguarda o processo encerrar."

#: ../../library/asyncio-subprocess.rst:218
msgid ""
"The optional *input* argument is the data (:class:`bytes` object) that will "
"be sent to the child process."
msgstr ""
"O argumento opcional *input* &eacute; a informa&ccedil;&atilde;o (objeto :class:`bytes`) que ser&aacute; "
"enviada para o processo filho."

#: ../../library/asyncio-subprocess.rst:221
msgid "Return a tuple ``(stdout_data, stderr_data)``."
msgstr "Retorna uma tupla ``(stdout_data, stderr_data)``."

#: ../../library/asyncio-subprocess.rst:223
msgid ""
"If either :exc:`BrokenPipeError` or :exc:`ConnectionResetError` exception is "
"raised when writing *input* into *stdin*, the exception is ignored.  This "
"condition occurs when the process exits before all data are written into "
"*stdin*."
msgstr ""
"Se qualquer exce&ccedil;&atilde;o :exc:`BrokenPipeError` ou :exc:`ConnectionResetError` "
"for levantada ao escrever *input* em *stdin*, a exce&ccedil;&atilde;o &eacute; ignorada. Esta "
"condi&ccedil;&atilde;o ocorre quando o processo encerra antes de todos os dados serem "
"escritos em *stdin*."

#: ../../library/asyncio-subprocess.rst:228
msgid ""
"If it is desired to send data to the process' *stdin*, the process needs to "
"be created with ``stdin=PIPE``.  Similarly, to get anything other than "
"``None`` in the result tuple, the process has to be created with "
"``stdout=PIPE`` and/or ``stderr=PIPE`` arguments."
msgstr ""
"Se for desejado enviar dados para o *stdin* do processo, o mesmo precisa ser "
"criado com ``stdin=PIPE``. De forma similar, para obter qualquer coisa al&eacute;m "
"de ``None`` na tupla resultante, o processo precisa ser criado com os "
"argumentos ``stdout=PIPE`` e/ou ``stderr=PIPE``."

#: ../../library/asyncio-subprocess.rst:234
msgid ""
"Note, that the data read is buffered in memory, so do not use this method if "
"the data size is large or unlimited."
msgstr ""
"Perceba que, os dados lidos s&atilde;o armazenados em um buffer na mem&oacute;ria, ent&atilde;o "
"n&atilde;o use este m&eacute;todo se o tamanho dos dados &eacute; grande ou ilimitado."

#: ../../library/asyncio-subprocess.rst:239
msgid "*stdin* gets closed when ``input=None`` too."
msgstr "*stdin* &eacute; fechado quando ``input=None`` &eacute; tamb&eacute;m."

#: ../../library/asyncio-subprocess.rst:243
msgid "Sends the signal *signal* to the child process."
msgstr "Envia o sinal *signal* para o processo filho."

#: ../../library/asyncio-subprocess.rst:247
msgid ""
"On Windows, :py:const:`~signal.SIGTERM` is an alias for :meth:`terminate`. "
"``CTRL_C_EVENT`` and ``CTRL_BREAK_EVENT`` can be sent to processes started "
"with a *creationflags* parameter which includes ``CREATE_NEW_PROCESS_GROUP``."
msgstr ""
"No Windows, :py:const:`~signal.SIGTERM` &eacute; um apelido para :meth:`terminate`. "
"``CTRL_C_EVENT`` e ``CTRL_BREAK_EVENT`` podem ser enviados para processos "
"iniciados com um par&acirc;metro *creationflags*, o qual inclui "
"``CREATE_NEW_PROCESS_GROUP``."

#: ../../library/asyncio-subprocess.rst:254
msgid "Stop the child process."
msgstr "Interrompe o processo filho."

#: ../../library/asyncio-subprocess.rst:256
msgid ""
"On POSIX systems this method sends :py:const:`~signal.SIGTERM` to the child "
"process."
msgstr ""
"Em sistemas POSIX este m&eacute;todo envia :py:const:`~signal.SIGTERM` para o "
"processo filho."

#: ../../library/asyncio-subprocess.rst:259
msgid ""
"On Windows the Win32 API function :c:func:`!TerminateProcess` is called to "
"stop the child process."
msgstr ""
"No Windows a fun&ccedil;&atilde;o :c:func:`!TerminateProcess` da API Win32 &eacute; chamada para "
"interromper o processo filho."

#: ../../library/asyncio-subprocess.rst:264
msgid "Kill the child process."
msgstr "Mata o processo filho."

#: ../../library/asyncio-subprocess.rst:266
msgid ""
"On POSIX systems this method sends :py:data:`~signal.SIGKILL` to the child "
"process."
msgstr ""
"Em sistemas POSIX este m&eacute;todo envia :py:data:`~signal.SIGKILL` para o "
"processo filho."

#: ../../library/asyncio-subprocess.rst:269
msgid "On Windows this method is an alias for :meth:`terminate`."
msgstr "No Windows, este m&eacute;todo &eacute; um atalho para :meth:`terminate`."

#: ../../library/asyncio-subprocess.rst:273
msgid ""
"Standard input stream (:class:`~asyncio.StreamWriter`) or ``None`` if the "
"process was created with ``stdin=None``."
msgstr ""
"Fluxo de entrada padr&atilde;o (:class:`~asyncio.StreamWriter`) ou ``None`` se o "
"processo foi criado com ``stdin=None``."

#: ../../library/asyncio-subprocess.rst:278
msgid ""
"Standard output stream (:class:`~asyncio.StreamReader`) or ``None`` if the "
"process was created with ``stdout=None``."
msgstr ""
"Fluxo de sa&iacute;da padr&atilde;o (:class:`~asyncio.StreamReader`) ou ``None`` se o "
"processo foi criado com ``stdout=None``."

#: ../../library/asyncio-subprocess.rst:283
msgid ""
"Standard error stream (:class:`~asyncio.StreamReader`) or ``None`` if the "
"process was created with ``stderr=None``."
msgstr ""
"Erro de fluxo padr&atilde;o (:class:`~asyncio.StreamReader`) ou ``None`` se o "
"processo foi criado com ``stderr=None``."

#: ../../library/asyncio-subprocess.rst:288
msgid ""
"Use the :meth:`communicate` method rather than :attr:`process.stdin.write() "
"<stdin>`, :attr:`await process.stdout.read() <stdout>` or :attr:`await "
"process.stderr.read() <stderr>`. This avoids deadlocks due to streams "
"pausing reading or writing and blocking the child process."
msgstr ""
"Use o m&eacute;todo :meth:`communicate` ao inv&eacute;s de :attr:`process.stdin.write() "
"<stdin>`, :attr:`await process.stdout.read() <stdout>` ou :attr:`await "
"process.stderr.read() <stderr>`. Isso evita deadlocks devido a fluxos "
"pausando a leitura ou escrita, e bloqueando o processo filho."

#: ../../library/asyncio-subprocess.rst:297
msgid "Process identification number (PID)."
msgstr "N&uacute;mero de identifica&ccedil;&atilde;o do processo (PID)."

#: ../../library/asyncio-subprocess.rst:299
msgid ""
"Note that for processes created by the :func:`~asyncio."
"create_subprocess_shell` function, this attribute is the PID of the spawned "
"shell."
msgstr ""
"Perceba que para processos criados pela fun&ccedil;&atilde;o :func:`~asyncio."
"create_subprocess_shell`, este atributo &eacute; o PID do console gerado."

#: ../../library/asyncio-subprocess.rst:304
msgid "Return code of the process when it exits."
msgstr "Retorna o c&oacute;digo do processo quando o mesmo terminar."

#: ../../library/asyncio-subprocess.rst:306
msgid "A ``None`` value indicates that the process has not terminated yet."
msgstr "Um valor ``None`` indica que o processo ainda n&atilde;o terminou."

#: ../../library/asyncio-subprocess.rst:308
msgid ""
"A negative value ``-N`` indicates that the child was terminated by signal "
"``N`` (POSIX only)."
msgstr ""
"Um valor negativo ``-N`` indica que o filho foi terminado pelo sinal ``N`` "
"(POSIX apenas)."

#: ../../library/asyncio-subprocess.rst:315
msgid "Subprocess and Threads"
msgstr "Subprocesso e Threads"

#: ../../library/asyncio-subprocess.rst:317
msgid ""
"Standard asyncio event loop supports running subprocesses from different "
"threads by default."
msgstr ""
"La&ccedil;o de eventos padr&atilde;o do asyncio suporta a execu&ccedil;&atilde;o de subprocessos a "
"partir de diferentes threads por padr&atilde;o."

#: ../../library/asyncio-subprocess.rst:320
msgid ""
"On Windows subprocesses are provided by :class:`ProactorEventLoop` only "
"(default), :class:`SelectorEventLoop` has no subprocess support."
msgstr ""
"No Windows, subprocessos s&atilde;o fornecidos pela classe :class:"
"`ProactorEventLoop` apenas (por padr&atilde;o), a classe :class:`SelectorEventLoop` "
"n&atilde;o tem suporte a subprocesso."

#: ../../library/asyncio-subprocess.rst:323
msgid ""
"On UNIX *child watchers* are used for subprocess finish waiting, see :ref:"
"`asyncio-watchers` for more info."
msgstr ""
"Em sistemas UNIX, *monitores de filhos* s&atilde;o usados para aguardar o "
"encerramento de subprocesso, veja :ref:`asyncio-watchers` para mais "
"informa&ccedil;&otilde;es."

#: ../../library/asyncio-subprocess.rst:329
msgid ""
"UNIX switched to use :class:`ThreadedChildWatcher` for spawning subprocesses "
"from different threads without any limitation."
msgstr ""
"UNIX mudou para usar :class:`ThreadedChildWatcher` para gerar subprocessos a "
"partir de diferentes threads sem qualquer limita&ccedil;&atilde;o."

#: ../../library/asyncio-subprocess.rst:332
msgid ""
"Spawning a subprocess with *inactive* current child watcher raises :exc:"
"`RuntimeError`."
msgstr ""
"Gerar um subprocesso com um monitor *inativo* para o filho atual, levanta :"
"exc:`RuntimeError`."

#: ../../library/asyncio-subprocess.rst:335
msgid ""
"Note that alternative event loop implementations might have own limitations; "
"please refer to their documentation."
msgstr ""
"Perceba que implementa&ccedil;&otilde;es alternativas do la&ccedil;o de eventos podem ter "
"limita&ccedil;&otilde;es pr&oacute;prias; por favor, verifique a sua documenta&ccedil;&atilde;o."

#: ../../library/asyncio-subprocess.rst:340
msgid ""
"The :ref:`Concurrency and multithreading in asyncio <asyncio-"
"multithreading>` section."
msgstr ""
"A se&ccedil;&atilde;o :ref:`Concorr&ecirc;ncia e multithreading em asyncio <asyncio-"
"multithreading>`."

#: ../../library/asyncio-subprocess.rst:345
msgid "Examples"
msgstr "Exemplos"

#: ../../library/asyncio-subprocess.rst:347
msgid ""
"An example using the :class:`~asyncio.subprocess.Process` class to control a "
"subprocess and the :class:`StreamReader` class to read from its standard "
"output."
msgstr ""
"Um exemplo de uso da classe :class:`~asyncio.subprocess.Process` para "
"controlar um subprocesso e a classe :class:`StreamReader` para ler a partir "
"da sua sa&iacute;da padr&atilde;o."

#: ../../library/asyncio-subprocess.rst:353
msgid ""
"The subprocess is created by the :func:`create_subprocess_exec` function::"
msgstr "O subprocesso &eacute; criado pela fun&ccedil;&atilde;o :func:`create_subprocess_exec`::"

#: ../../library/asyncio-subprocess.rst:356
msgid ""
"import asyncio\n"
"import sys\n"
"\n"
"async def get_date():\n"
"    code = 'import datetime; print(datetime.datetime.now())'\n"
"\n"
"    # Create the subprocess; redirect the standard output\n"
"    # into a pipe.\n"
"    proc = await asyncio.create_subprocess_exec(\n"
"        sys.executable, '-c', code,\n"
"        stdout=asyncio.subprocess.PIPE)\n"
"\n"
"    # Read one line of output.\n"
"    data = await proc.stdout.readline()\n"
"    line = data.decode('ascii').rstrip()\n"
"\n"
"    # Wait for the subprocess exit.\n"
"    await proc.wait()\n"
"    return line\n"
"\n"
"date = asyncio.run(get_date())\n"
"print(f\"Current date: {date}\")"
msgstr ""
"import asyncio\n"
"import sys\n"
"\n"
"async def get_date():\n"
"    code = 'import datetime; print(datetime.datetime.now())'\n"
"\n"
"    # Cria um subprocesso; redireciona a sa&iacute;da padr&atilde;o\n"
"    # para o encadeamento.\n"
"    proc = await asyncio.create_subprocess_exec(\n"
"        sys.executable, '-c', code,\n"
"        stdout=asyncio.subprocess.PIPE)\n"
"\n"
"    # L&ecirc; uma linha da sa&iacute;da.\n"
"    data = await proc.stdout.readline()\n"
"    line = data.decode('ascii').rstrip()\n"
"\n"
"    # Espera o subprocesso sair.\n"
"    await proc.wait()\n"
"    return line\n"
"\n"
"date = asyncio.run(get_date())\n"
"print(f\"Current date: {date}\")"

#: ../../library/asyncio-subprocess.rst:380
msgid ""
"See also the :ref:`same example <asyncio_example_subprocess_proto>` written "
"using low-level APIs."
msgstr ""
"Veja tamb&eacute;m o :ref:`mesmo exemplo <asyncio_example_subprocess_proto>` "
"escrito usando APIs de baixo n&iacute;vel."