# Copyright (C) 2001-2020, Python Software Foundation

# This file is distributed under the same license as the Python package.

# Maintained by the python-doc-es workteam.

# docs-es@python.org /

# https://mail.python.org/mailman3/lists/docs-es.python.org/

# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to

# get the list of volunteers

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3.8\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2023-10-12 19:43+0200\n"

"PO-Revision-Date: 2021-08-04 13:41+0200\n"

"Last-Translator: Cristián Maureira-Fredes <cmaureirafredes@gmail.com>\n"

"Language-Team: python-doc-es\n"

"Language: es\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=utf-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Generated-By: Babel 2.13.0\n"

#: ../Doc/library/asyncio-task.rst:6

msgid "Coroutines and Tasks"

msgstr "Corrutinas y tareas"

#: ../Doc/library/asyncio-task.rst:8

msgid ""

"This section outlines high-level asyncio APIs to work with coroutines and "

"Tasks."

msgstr ""

"Esta sección describe las API de asyncio de alto nivel para trabajar con "

"corrutinas y tareas."

#: ../Doc/library/asyncio-task.rst:19 ../Doc/library/asyncio-task.rst:148

msgid "Coroutines"

msgstr "Corrutinas"

#: ../Doc/library/asyncio-task.rst:21

msgid "**Source code:** :source:`Lib/asyncio/coroutines.py`"

msgstr "**Source code:** :source:`Lib/asyncio/coroutines.py`"

#: ../Doc/library/asyncio-task.rst:25

msgid ""

":term:`Coroutines <coroutine>` declared with the async/await syntax is the "

"preferred way of writing asyncio applications. For example, the following "

"snippet of code prints \"hello\", waits 1 second, and then prints \"world\"::"

msgstr ""

":term:`Coroutines <coroutine>` declarado con la sintaxis async/await es la "

"forma preferida de escribir aplicaciones asyncio. Por ejemplo, el siguiente "

"fragmento de código imprime \"hola\", espera 1 segundo y luego imprime "

"\"mundo\"::"

#: ../Doc/library/asyncio-task.rst:41

msgid ""

"Note that simply calling a coroutine will not schedule it to be executed::"

msgstr ""

"Tenga en cuenta que simplemente llamando a una corrutina no programará para "

"que se ejecute::"

#: ../Doc/library/asyncio-task.rst:47

msgid "To actually run a coroutine, asyncio provides the following mechanisms:"

msgstr ""

"Para ejecutar realmente una corutina, asyncio proporciona los siguientes "

"mecanismos:"

#: ../Doc/library/asyncio-task.rst:49

msgid ""

"The :func:`asyncio.run` function to run the top-level entry point \"main()\" "

"function (see the above example.)"

msgstr ""

"La función :func:`asyncio.run` para ejecutar la función de punto de entrada "

"de nivel superior \"main()\" (consulte el ejemplo anterior.)"

#: ../Doc/library/asyncio-task.rst:52

msgid ""

"Awaiting on a coroutine. The following snippet of code will print \"hello\" "

"after waiting for 1 second, and then print \"world\" after waiting for "

"*another* 2 seconds::"

msgstr ""

"Esperando en una corrutina. El siguiente fragmento de código imprimirá "

"\"hola\" después de esperar 1 segundo y luego imprimirá \"mundo\" después de "

"esperar *otros* 2 segundos::"

#: ../Doc/library/asyncio-task.rst:73

msgid "Expected output::"

msgstr "Salida esperada::"

#: ../Doc/library/asyncio-task.rst:80

msgid ""

"The :func:`asyncio.create_task` function to run coroutines concurrently as "

"asyncio :class:`Tasks <Task>`."

msgstr ""

"La función :func:`asyncio.create_task` para ejecutar corrutinas "

"concurrentemente como asyncio :class:`Tasks <Task>`."

#: ../Doc/library/asyncio-task.rst:83

msgid ""

"Let's modify the above example and run two ``say_after`` coroutines "

"*concurrently*::"

msgstr ""

"Modifiquemos el ejemplo anterior y ejecutemos dos corrutinas ``say_after`` "

"*concurrentemente*::"

#: ../Doc/library/asyncio-task.rst:102

msgid ""

"Note that expected output now shows that the snippet runs 1 second faster "

"than before::"

msgstr ""

"Tenga en cuenta que la salida esperada ahora muestra que el fragmento de "

"código se ejecuta 1 segundo más rápido que antes::"

#: ../Doc/library/asyncio-task.rst:110

msgid ""

"The :class:`asyncio.TaskGroup` class provides a more modern alternative to :"

"func:`create_task`. Using this API, the last example becomes::"

msgstr ""

"La clase :class:`asyncio.TaskGroup` proporciona una alternativa más moderna "

"a :func:`create_task`. Usando esta API, el último ejemplo se convierte en:"

#: ../Doc/library/asyncio-task.rst:128

msgid "The timing and output should be the same as for the previous version."

msgstr ""

"El tiempo y la salida deben ser los mismos que para la versión anterior."

#: ../Doc/library/asyncio-task.rst:130

msgid ":class:`asyncio.TaskGroup`."

msgstr ":class:`asyncio.TaskGroup`."

#: ../Doc/library/asyncio-task.rst:137

msgid "Awaitables"

msgstr "Esperables"

#: ../Doc/library/asyncio-task.rst:139

msgid ""

"We say that an object is an **awaitable** object if it can be used in an :"

"keyword:`await` expression. Many asyncio APIs are designed to accept "

"awaitables."

msgstr ""

"Decimos que un objeto es un objeto **esperable** si se puede utilizar en una "

"expresión :keyword:`await`. Muchas API de asyncio están diseñadas para "

"aceptar los valores esperables."

#: ../Doc/library/asyncio-task.rst:143

msgid ""

"There are three main types of *awaitable* objects: **coroutines**, "

"**Tasks**, and **Futures**."

msgstr ""

"Hay tres tipos principales de objetos *esperables*: **corrutinas**, "

"**Tareas** y **Futures**."

#: ../Doc/library/asyncio-task.rst:149

msgid ""

"Python coroutines are *awaitables* and therefore can be awaited from other "

"coroutines::"

msgstr ""

"Las corrutinas de Python son *esperables* y por lo tanto se pueden esperar "

"de otras corrutinas::"

#: ../Doc/library/asyncio-task.rst:170

msgid ""

"In this documentation the term \"coroutine\" can be used for two closely "

"related concepts:"

msgstr ""

"En esta documentación se puede utilizar el término \"corrutina\" para dos "

"conceptos estrechamente relacionados:"

#: ../Doc/library/asyncio-task.rst:173

msgid "a *coroutine function*: an :keyword:`async def` function;"

msgstr "una *función corrutina*: una función :keyword:`async def`;"

#: ../Doc/library/asyncio-task.rst:175

msgid ""

"a *coroutine object*: an object returned by calling a *coroutine function*."

msgstr ""

"un *objeto corrutina*: un objeto retornado llamando a una *función "

"corrutina*."

#: ../Doc/library/asyncio-task.rst:180

msgid "Tasks"

msgstr "Tareas"

#: ../Doc/library/asyncio-task.rst:181

msgid "*Tasks* are used to schedule coroutines *concurrently*."

msgstr "*Las tareas* se utilizan para programar corrutinas *concurrentemente*."

#: ../Doc/library/asyncio-task.rst:183

msgid ""

"When a coroutine is wrapped into a *Task* with functions like :func:`asyncio."

"create_task` the coroutine is automatically scheduled to run soon::"

msgstr ""

"Cuando una corrutina se envuelve en una *Tarea* con funciones como :func:"

"`asyncio.create_task` la corrutina se programa automáticamente para "

"ejecutarse pronto::"

#: ../Doc/library/asyncio-task.rst:205

msgid "Futures"

msgstr "Futures"

#: ../Doc/library/asyncio-task.rst:206

msgid ""

"A :class:`Future` is a special **low-level** awaitable object that "

"represents an **eventual result** of an asynchronous operation."

msgstr ""

"Un :class:`Future` es un objeto esperable especial de **bajo-nivel** que "

"representa un **resultado eventual** de una operación asíncrona."

#: ../Doc/library/asyncio-task.rst:209

msgid ""

"When a Future object is *awaited* it means that the coroutine will wait "

"until the Future is resolved in some other place."

msgstr ""

"Cuando un objeto Future es *esperado* significa que la corrutina esperará "

"hasta que el Future se resuelva en algún otro lugar."

#: ../Doc/library/asyncio-task.rst:212

msgid ""

"Future objects in asyncio are needed to allow callback-based code to be used "

"with async/await."

msgstr ""

"Los objetos Future de asyncio son necesarios para permitir que el código "

"basado en retro llamada se use con async/await."

#: ../Doc/library/asyncio-task.rst:215

msgid ""

"Normally **there is no need** to create Future objects at the application "

"level code."

msgstr ""

"Normalmente , **no es necesario** crear objetos Future en el código de nivel "

"de aplicación."

#: ../Doc/library/asyncio-task.rst:218

msgid ""

"Future objects, sometimes exposed by libraries and some asyncio APIs, can be "

"awaited::"

msgstr ""

"Los objetos Future, a veces expuestos por bibliotecas y algunas API de "

"asyncio, pueden ser esperados::"

#: ../Doc/library/asyncio-task.rst:230

msgid ""

"A good example of a low-level function that returns a Future object is :meth:"

"`loop.run_in_executor`."

msgstr ""

"Un buen ejemplo de una función de bajo nivel que retorna un objeto Future "

"es :meth:`loop.run_in_executor`."

#: ../Doc/library/asyncio-task.rst:235

msgid "Creating Tasks"

msgstr "Creando Tareas"

#: ../Doc/library/asyncio-task.rst:237

msgid "**Source code:** :source:`Lib/asyncio/tasks.py`"

msgstr "**Source code:** :source:`Lib/asyncio/tasks.py`"

#: ../Doc/library/asyncio-task.rst:243

msgid ""

"Wrap the *coro* :ref:`coroutine <coroutine>` into a :class:`Task` and "

"schedule its execution. Return the Task object."

msgstr ""

"Envuelve una :ref:`coroutine <coroutine>` *coro* en una :class:`Task` y "

"programa su ejecución. Retorna el objeto Tarea."

#: ../Doc/library/asyncio-task.rst:246

msgid ""

"If *name* is not ``None``, it is set as the name of the task using :meth:"

"`Task.set_name`."

msgstr ""

"Si *name* no es ``None``, se establece como el nombre de la tarea mediante :"

"meth:`Task.set_name`."

#: ../Doc/library/asyncio-task.rst:249

msgid ""

"An optional keyword-only *context* argument allows specifying a custom :"

"class:`contextvars.Context` for the *coro* to run in. The current context "

"copy is created when no *context* is provided."

msgstr ""

"Un argumento *context* opcional de solo palabra clave permite especificar "

"un :class:`contextvars.Context` personalizado para que se ejecute el *coro*. "

"La copia de contexto actual se crea cuando no se proporciona *context*."

#: ../Doc/library/asyncio-task.rst:253

msgid ""

"The task is executed in the loop returned by :func:`get_running_loop`, :exc:"

"`RuntimeError` is raised if there is no running loop in current thread."

msgstr ""

"La tarea se ejecuta en el bucle retornado por :func:`get_running_loop`, :exc:"

"`RuntimeError` se genera si no hay ningún bucle en ejecución en el "

"subproceso actual."

#: ../Doc/library/asyncio-task.rst:259

msgid ""

":meth:`asyncio.TaskGroup.create_task` is a new alternative leveraging "

"structural concurrency; it allows for waiting for a group of related tasks "

"with strong safety guarantees."

msgstr ""

":meth:`asyncio.TaskGroup.create_task` es una alternativa más nueva que "

"permite una espera conveniente para un grupo de tareas relacionadas."

#: ../Doc/library/asyncio-task.rst:265

msgid ""

"Save a reference to the result of this function, to avoid a task "

"disappearing mid-execution. The event loop only keeps weak references to "

"tasks. A task that isn't referenced elsewhere may get garbage collected at "

"any time, even before it's done. For reliable \"fire-and-forget\" background "

"tasks, gather them in a collection::"

msgstr ""

"Guarde una referencia al resultado de esta función, para evitar que una "

"tarea desaparezca en medio de la ejecución. El bucle de eventos solo "

"mantiene referencias débiles a las tareas. Una tarea a la que no se hace "

"referencia en ningún otro lugar puede ser recolectada por el recolector de "

"basura en cualquier momento, incluso antes de que se complete. Para tareas "

"confiables en segundo plano, de tipo \"lanzar y olvidar\", reúnalas en una "

"colección:"

#: ../Doc/library/asyncio-task.rst:287 ../Doc/library/asyncio-task.rst:1076

msgid "Added the *name* parameter."

msgstr "Se ha añadido el parámetro *name*."

#: ../Doc/library/asyncio-task.rst:290 ../Doc/library/asyncio-task.rst:1083

msgid "Added the *context* parameter."

msgstr "Se ha añadido el parámetro *context*."

#: ../Doc/library/asyncio-task.rst:295

msgid "Task Cancellation"

msgstr "Cancelación de tareas"

#: ../Doc/library/asyncio-task.rst:297

msgid ""

"Tasks can easily and safely be cancelled. When a task is cancelled, :exc:"

"`asyncio.CancelledError` will be raised in the task at the next opportunity."

msgstr ""

"Las tareas se pueden cancelar de forma fácil y segura. Cuando se cancela una "

"tarea, se generará :exc:`asyncio.CancelledError` en la tarea en la próxima "

"oportunidad."

#: ../Doc/library/asyncio-task.rst:301

msgid ""

"It is recommended that coroutines use ``try/finally`` blocks to robustly "

"perform clean-up logic. In case :exc:`asyncio.CancelledError` is explicitly "

"caught, it should generally be propagated when clean-up is complete. :exc:"

"`asyncio.CancelledError` directly subclasses :exc:`BaseException` so most "

"code will not need to be aware of it."

msgstr ""

"Se recomienda que las corrutinas utilicen bloques ``try/finally`` para "

"realizar de forma sólida la lógica de limpieza. En caso de que :exc:`asyncio."

"CancelledError` se detecte explícitamente, generalmente debería propagarse "

"cuando se complete la limpieza. :exc:`asyncio.CancelledError` subclasifica "

"directamente a :exc:`BaseException`, por lo que la mayor parte del código no "

"necesitará tenerlo en cuenta."

#: ../Doc/library/asyncio-task.rst:307

msgid ""

"The asyncio components that enable structured concurrency, like :class:"

"`asyncio.TaskGroup` and :func:`asyncio.timeout`, are implemented using "

"cancellation internally and might misbehave if a coroutine swallows :exc:"

"`asyncio.CancelledError`. Similarly, user code should not generally call :"

"meth:`uncancel <asyncio.Task.uncancel>`. However, in cases when suppressing :"

"exc:`asyncio.CancelledError` is truly desired, it is necessary to also call "

"``uncancel()`` to completely remove the cancellation state."

msgstr ""

"Los componentes asyncio que permiten la simultaneidad estructurada, como :"

"class:`asyncio.TaskGroup` y :func:`asyncio.timeout`, se implementan mediante "

"cancelación internamente y podrían comportarse mal si una rutina traga :exc:"

"`asyncio.CancelledError`. De manera similar, el código de usuario "

"generalmente no debería llamar a :meth:`uncancel <asyncio.Task.uncancel>`. "

"Sin embargo, en los casos en los que realmente se desea suprimir :exc:"

"`asyncio.CancelledError`, es necesario llamar también a ``uncancel()`` para "

"eliminar completamente el estado de cancelación."

#: ../Doc/library/asyncio-task.rst:319

msgid "Task Groups"

msgstr "Grupos de tareas"

#: ../Doc/library/asyncio-task.rst:321

msgid ""

"Task groups combine a task creation API with a convenient and reliable way "

"to wait for all tasks in the group to finish."

msgstr ""

"Los grupos de tareas combinan una API de creación de tareas con una forma "

"conveniente y confiable de esperar a que finalicen todas las tareas del "

"grupo."

#: ../Doc/library/asyncio-task.rst:326

msgid ""

"An :ref:`asynchronous context manager <async-context-managers>` holding a "

"group of tasks. Tasks can be added to the group using :meth:`create_task`. "

"All tasks are awaited when the context manager exits."

msgstr ""

"Un :ref:`asynchronous context manager <async-context-managers>` que contiene "

"un grupo de tareas. Las tareas se pueden agregar al grupo usando :meth:"

"`create_task`. Se esperan todas las tareas cuando sale el administrador de "

"contexto."

#: ../Doc/library/asyncio-task.rst:335

msgid ""

"Create a task in this task group. The signature matches that of :func:"

"`asyncio.create_task`."

msgstr ""

"Cree una tarea en este grupo de tareas. La firma coincide con la de :func:"

"`asyncio.create_task`."

#: ../Doc/library/asyncio-task.rst:338 ../Doc/library/asyncio-task.rst:472

#: ../Doc/library/asyncio-task.rst:645 ../Doc/library/asyncio-task.rst:703

#: ../Doc/library/asyncio-task.rst:729 ../Doc/library/asyncio-task.rst:772

#: ../Doc/library/asyncio-task.rst:869

msgid "Example::"

msgstr "Ejemplo::"

#: ../Doc/library/asyncio-task.rst:346

msgid ""

"The ``async with`` statement will wait for all tasks in the group to finish. "

"While waiting, new tasks may still be added to the group (for example, by "

"passing ``tg`` into one of the coroutines and calling ``tg.create_task()`` "

"in that coroutine). Once the last task has finished and the ``async with`` "

"block is exited, no new tasks may be added to the group."

msgstr ""

"La instrucción ``async with`` esperará a que finalicen todas las tareas del "

"grupo. Mientras espera, aún se pueden agregar nuevas tareas al grupo (por "

"ejemplo, pasando ``tg`` a una de las corrutinas y llamando a ``tg."

"create_task()`` en esa corrutina). Una vez finalizada la última tarea y "

"salido del bloque ``async with``, no se podrán añadir nuevas tareas al grupo."

#: ../Doc/library/asyncio-task.rst:353

msgid ""

"The first time any of the tasks belonging to the group fails with an "

"exception other than :exc:`asyncio.CancelledError`, the remaining tasks in "

"the group are cancelled. No further tasks can then be added to the group. At "

"this point, if the body of the ``async with`` statement is still active (i."

"e., :meth:`~object.__aexit__` hasn't been called yet), the task directly "

"containing the ``async with`` statement is also cancelled. The resulting :"

"exc:`asyncio.CancelledError` will interrupt an ``await``, but it will not "

"bubble out of the containing ``async with`` statement."

msgstr ""

"La primera vez que alguna de las tareas pertenecientes al grupo falla con "

"una excepción que no sea :exc:`asyncio.CancelledError`, las tareas restantes "

"del grupo se cancelan. No se pueden añadir más tareas al grupo. En este "

"punto, si el cuerpo de la instrucción ``async with`` aún está activo (es "

"decir, aún no se ha llamado a :meth:`~object.__aexit__`), la tarea que "

"contiene directamente la instrucción ``async with`` también se cancela. El :"

"exc:`asyncio.CancelledError` resultante interrumpirá un ``await``, pero no "

"saldrá de la instrucción ``async with`` que lo contiene."

#: ../Doc/library/asyncio-task.rst:363

msgid ""

"Once all tasks have finished, if any tasks have failed with an exception "

"other than :exc:`asyncio.CancelledError`, those exceptions are combined in "

"an :exc:`ExceptionGroup` or :exc:`BaseExceptionGroup` (as appropriate; see "

"their documentation) which is then raised."

msgstr ""

"Una vez que todas las tareas han finalizado, si alguna tarea ha fallado con "

"una excepción que no sea :exc:`asyncio.CancelledError`, esas excepciones se "

"combinan en un :exc:`ExceptionGroup` o :exc:`BaseExceptionGroup` (según "

"corresponda; consulte su documentación) que luego se genera."

#: ../Doc/library/asyncio-task.rst:370

msgid ""

"Two base exceptions are treated specially: If any task fails with :exc:"

"`KeyboardInterrupt` or :exc:`SystemExit`, the task group still cancels the "

"remaining tasks and waits for them, but then the initial :exc:"

"`KeyboardInterrupt` or :exc:`SystemExit` is re-raised instead of :exc:"

"`ExceptionGroup` or :exc:`BaseExceptionGroup`."

msgstr ""

"Dos excepciones básicas se tratan de manera especial: si alguna tarea falla "

"con :exc:`KeyboardInterrupt` o :exc:`SystemExit`, el grupo de tareas aún "

"cancela las tareas restantes y las espera, pero luego se vuelve a generar "

"el :exc:`KeyboardInterrupt` o :exc:`SystemExit` inicial en lugar de :exc:"

"`ExceptionGroup` o :exc:`BaseExceptionGroup`."

#: ../Doc/library/asyncio-task.rst:376

msgid ""

"If the body of the ``async with`` statement exits with an exception (so :"

"meth:`~object.__aexit__` is called with an exception set), this is treated "

"the same as if one of the tasks failed: the remaining tasks are cancelled "

"and then waited for, and non-cancellation exceptions are grouped into an "

"exception group and raised. The exception passed into :meth:`~object."

"__aexit__`, unless it is :exc:`asyncio.CancelledError`, is also included in "

"the exception group. The same special case is made for :exc:"

"`KeyboardInterrupt` and :exc:`SystemExit` as in the previous paragraph."

msgstr ""

"Si el cuerpo de la instrucción ``async with`` finaliza con una excepción "

"(por lo que se llama a :meth:`~object.__aexit__` con un conjunto de "

"excepciones), esto se trata igual que si una de las tareas fallara: las "

"tareas restantes se cancelan y luego se esperan, y las excepciones de no "

"cancelación se agrupan en un grupo de excepción y se generan. La excepción "

"pasada a :meth:`~object.__aexit__`, a menos que sea :exc:`asyncio."

"CancelledError`, también se incluye en el grupo de excepciones. Se hace el "

"mismo caso especial para :exc:`KeyboardInterrupt` y :exc:`SystemExit` que en "

"el párrafo anterior."

#: ../Doc/library/asyncio-task.rst:390

msgid "Sleeping"

msgstr "Durmiendo"

#: ../Doc/library/asyncio-task.rst:394

msgid "Block for *delay* seconds."

msgstr "Bloquea por *delay* segundos."

#: ../Doc/library/asyncio-task.rst:396

msgid ""

"If *result* is provided, it is returned to the caller when the coroutine "

"completes."

msgstr ""

"Si se proporciona *result*, se retorna al autor de la llamada cuando se "

"completa la corrutina."

#: ../Doc/library/asyncio-task.rst:399

msgid ""

"``sleep()`` always suspends the current task, allowing other tasks to run."

msgstr ""

"``sleep()`` siempre suspende la tarea actual, permitiendo que se ejecuten "

"otras tareas."

#: ../Doc/library/asyncio-task.rst:402

msgid ""

"Setting the delay to 0 provides an optimized path to allow other tasks to "

"run. This can be used by long-running functions to avoid blocking the event "

"loop for the full duration of the function call."

msgstr ""

"Establecer el retraso en 0 proporciona una ruta optimizada para permitir que "

"se ejecuten otras tareas. Esto puede ser utilizado por funciones de "

"ejecución prolongada para evitar bloquear el bucle de eventos durante toda "

"la duración de la llamada a la función."

#: ../Doc/library/asyncio-task.rst:408

msgid ""

"Example of coroutine displaying the current date every second for 5 seconds::"

msgstr ""

"Ejemplo de una rutina que muestra la fecha actual cada segundo durante 5 "

"segundos::"

#: ../Doc/library/asyncio-task.rst:426 ../Doc/library/asyncio-task.rst:521

#: ../Doc/library/asyncio-task.rst:620 ../Doc/library/asyncio-task.rst:767

#: ../Doc/library/asyncio-task.rst:797 ../Doc/library/asyncio-task.rst:849

#: ../Doc/library/asyncio-task.rst:875

msgid "Removed the *loop* parameter."

msgstr "Se quitó el parámetro *loop*."

#: ../Doc/library/asyncio-task.rst:431

msgid "Running Tasks Concurrently"

msgstr "Ejecutando tareas concurrentemente"

#: ../Doc/library/asyncio-task.rst:435

msgid ""

"Run :ref:`awaitable objects <asyncio-awaitables>` in the *aws* sequence "

"*concurrently*."

msgstr ""

"Ejecute :ref:`objetos esperables <asyncio-awaitables>` en la secuencia *aws* "

"de forma *concurrently*."

#: ../Doc/library/asyncio-task.rst:438

msgid ""

"If any awaitable in *aws* is a coroutine, it is automatically scheduled as a "

"Task."

msgstr ""

"Si cualquier esperable en *aws* es una corrutina, se programa "

"automáticamente como una Tarea."

#: ../Doc/library/asyncio-task.rst:441

msgid ""

"If all awaitables are completed successfully, the result is an aggregate "

"list of returned values. The order of result values corresponds to the "

"order of awaitables in *aws*."

msgstr ""

"Si todos los esperables se completan correctamente, el resultado es una "

"lista agregada de valores retornados. El orden de los valores de resultado "

"corresponde al orden de esperables en *aws*."

#: ../Doc/library/asyncio-task.rst:445

msgid ""

"If *return_exceptions* is ``False`` (default), the first raised exception is "

"immediately propagated to the task that awaits on ``gather()``. Other "

"awaitables in the *aws* sequence **won't be cancelled** and will continue to "

"run."

msgstr ""

"Si *return_exceptions* es ``False`` (valor predeterminado), la primera "

"excepción provocada se propaga inmediatamente a la tarea que espera en "

"``gather()``. Otros esperables en la secuencia *aws* **no se cancelarán** y "

"continuarán ejecutándose."

#: ../Doc/library/asyncio-task.rst:450

msgid ""

"If *return_exceptions* is ``True``, exceptions are treated the same as "

"successful results, and aggregated in the result list."

msgstr ""

"Si *return_exceptions* es ``True``, las excepciones se tratan igual que los "

"resultados correctos y se agregan en la lista de resultados."

#: ../Doc/library/asyncio-task.rst:453

msgid ""

"If ``gather()`` is *cancelled*, all submitted awaitables (that have not "

"completed yet) are also *cancelled*."

msgstr ""

"Si ``gather()`` es *cancelado*, todos los esperables enviados (que aún no se "

"han completado) también se *cancelan*."

#: ../Doc/library/asyncio-task.rst:456

msgid ""

"If any Task or Future from the *aws* sequence is *cancelled*, it is treated "

"as if it raised :exc:`CancelledError` -- the ``gather()`` call is **not** "

"cancelled in this case. This is to prevent the cancellation of one "

"submitted Task/Future to cause other Tasks/Futures to be cancelled."

msgstr ""

"Si alguna Tarea o Future de la secuencia *aws* se *cancela*, se trata como "

"si se lanzara :exc:`CancelledError` -- la llamada ``gather()`` **no** se "

"cancela en este caso. Esto es para evitar la cancelación de una Tarea/Future "

"enviada para hacer que otras Tareas/Futures sean canceladas."

#: ../Doc/library/asyncio-task.rst:463

msgid ""

"A new alternative to create and run tasks concurrently and wait for their "

"completion is :class:`asyncio.TaskGroup`. *TaskGroup* provides stronger "

"safety guarantees than *gather* for scheduling a nesting of subtasks: if a "

"task (or a subtask, a task scheduled by a task) raises an exception, "

"*TaskGroup* will, while *gather* will not, cancel the remaining scheduled "

"tasks)."

msgstr ""

"Una forma más moderna de crear y ejecutar tareas simultáneamente y esperar a "

"que se completen es :class:`asyncio.TaskGroup`."

#: ../Doc/library/asyncio-task.rst:510

msgid ""

"If *return_exceptions* is False, cancelling gather() after it has been "

"marked done won't cancel any submitted awaitables. For instance, gather can "

"be marked done after propagating an exception to the caller, therefore, "

"calling ``gather.cancel()`` after catching an exception (raised by one of "

"the awaitables) from gather won't cancel any other awaitables."

msgstr ""

"Si *return_exceptions* es False, cancelar gather() después de que se haya "

"marcado como hecho no cancelará ninguna espera enviada. Por ejemplo, la "

"recopilación se puede marcar como hecha después de propagar una excepción a "

"la persona que llama, por lo tanto, llamar a ``gather.cancel()`` después de "

"detectar una excepción (generada por uno de los elementos pendientes) de "

"recopilación no cancelará ningún otro elemento pendiente."

#: ../Doc/library/asyncio-task.rst:517

msgid ""

"If the *gather* itself is cancelled, the cancellation is propagated "

"regardless of *return_exceptions*."

msgstr ""

"Si se cancela el propio *gather*, la cancelación se propaga "

"independientemente de *return_exceptions*."

#: ../Doc/library/asyncio-task.rst:524

msgid ""

"Deprecation warning is emitted if no positional arguments are provided or "

"not all positional arguments are Future-like objects and there is no running "

"event loop."

msgstr ""

"Se emite una advertencia de obsolescencia si no se proporcionan argumentos "

"posicionales o no todos los argumentos posicionales son objetos de tipo "

"Future y no hay un bucle de eventos en ejecución."

#: ../Doc/library/asyncio-task.rst:533

msgid "Eager Task Factory"

msgstr "Fábrica de tareas ansiosas"

#: ../Doc/library/asyncio-task.rst:537

msgid "A task factory for eager task execution."

msgstr "Una fábrica de tareas para una ejecución entusiasta de tareas."

#: ../Doc/library/asyncio-task.rst:539

msgid ""

"When using this factory (via :meth:`loop.set_task_factory(asyncio."

"eager_task_factory) <loop.set_task_factory>`), coroutines begin execution "

"synchronously during :class:`Task` construction. Tasks are only scheduled on "

"the event loop if they block. This can be a performance improvement as the "

"overhead of loop scheduling is avoided for coroutines that complete "

"synchronously."

msgstr ""

"Cuando se utiliza esta fábrica (a través de :meth:`loop."

"set_task_factory(asyncio.eager_task_factory) <loop.set_task_factory>`), las "

"corrutinas comienzan a ejecutarse sincrónicamente durante la construcción "

"de :class:`Task`. Las tareas sólo se programan en el bucle de eventos si se "

"bloquean. Esto puede suponer una mejora del rendimiento, ya que se evita la "

"sobrecarga de la programación del bucle para las corrutinas que se completan "

"sincrónicamente."

#: ../Doc/library/asyncio-task.rst:545

msgid ""

"A common example where this is beneficial is coroutines which employ caching "

"or memoization to avoid actual I/O when possible."

msgstr ""

"Un ejemplo común en el que esto resulta beneficioso son las rutinas que "

"emplean almacenamiento en caché o memorización para evitar E/S reales cuando "

"sea posible."

#: ../Doc/library/asyncio-task.rst:550

msgid ""

"Immediate execution of the coroutine is a semantic change. If the coroutine "

"returns or raises, the task is never scheduled to the event loop. If the "

"coroutine execution blocks, the task is scheduled to the event loop. This "

"change may introduce behavior changes to existing applications. For example, "

"the application's task execution order is likely to change."

msgstr ""

"La ejecución inmediata de la corrutina es un cambio semántico. Si la rutina "

"regresa o se activa, la tarea nunca se programa en el bucle de eventos. Si "

"la ejecución de la rutina se bloquea, la tarea se programa en el bucle de "

"eventos. Este cambio puede introducir cambios de comportamiento en las "

"aplicaciones existentes. Por ejemplo, es probable que cambie el orden de "

"ejecución de las tareas de la aplicación."

#: ../Doc/library/asyncio-task.rst:561

msgid ""

"Create an eager task factory, similar to :func:`eager_task_factory`, using "

"the provided *custom_task_constructor* when creating a new task instead of "

"the default :class:`Task`."

msgstr ""

"Cree una fábrica de tareas entusiastas, similar a :func:"

"`eager_task_factory`, utilizando el *custom_task_constructor* proporcionado "

"al crear una nueva tarea en lugar del :class:`Task` predeterminado."

#: ../Doc/library/asyncio-task.rst:565

msgid ""

"*custom_task_constructor* must be a *callable* with the signature matching "

"the signature of :class:`Task.__init__ <Task>`. The callable must return a :"

"class:`asyncio.Task`-compatible object."

msgstr ""

"*custom_task_constructor* debe ser un *callable* con la firma que coincida "

"con la firma de :class:`Task.__init__ <Task>`. El invocable debe devolver un "

"objeto compatible con :class:`asyncio.Task`."

#: ../Doc/library/asyncio-task.rst:569

msgid ""

"This function returns a *callable* intended to be used as a task factory of "

"an event loop via :meth:`loop.set_task_factory(factory) <loop."

"set_task_factory>`)."

msgstr ""

"Esta función devuelve un *callable* destinado a ser utilizado como fábrica "

"de tareas de un bucle de eventos a través de :meth:`loop."

"set_task_factory(factory) <loop.set_task_factory>`)."

#: ../Doc/library/asyncio-task.rst:576

msgid "Shielding From Cancellation"

msgstr "Protección contra cancelación"

#: ../Doc/library/asyncio-task.rst:580

msgid ""

"Protect an :ref:`awaitable object <asyncio-awaitables>` from being :meth:"

"`cancelled <Task.cancel>`."

msgstr ""

"Protege un :ref:`objeto esperable <asyncio-awaitables>` de ser :meth:"

"`cancelado <Task.cancel>`."

#: ../Doc/library/asyncio-task.rst:583 ../Doc/library/asyncio-task.rst:749

msgid "If *aw* is a coroutine it is automatically scheduled as a Task."

msgstr "Si *aw* es una corrutina, se programa automáticamente como una Tarea."

#: ../Doc/library/asyncio-task.rst:585

msgid "The statement::"

msgstr "La declaración::"

#: ../Doc/library/asyncio-task.rst:590

msgid "is equivalent to::"

msgstr "es equivalente a::"

#: ../Doc/library/asyncio-task.rst:594

msgid ""

"*except* that if the coroutine containing it is cancelled, the Task running "

"in ``something()`` is not cancelled. From the point of view of "

"``something()``, the cancellation did not happen. Although its caller is "

"still cancelled, so the \"await\" expression still raises a :exc:"

"`CancelledError`."

msgstr ""

"*excepto* que si la corrutina que lo contiene se cancela, la tarea que se "

"ejecuta en ``something()`` no se cancela. Desde el punto de vista de "

"``something()``, la cancelación no ocurrió. Aunque su invocador siga "

"cancelado, por lo que la expresión \"await\" sigue generando un :exc:"

"`CancelledError`."

#: ../Doc/library/asyncio-task.rst:600

msgid ""

"If ``something()`` is cancelled by other means (i.e. from within itself) "

"that would also cancel ``shield()``."

msgstr ""

"Si ``something()`` se cancela por otros medios (es decir, desde dentro de sí "

"mismo) eso también cancelaría ``shield()``."

#: ../Doc/library/asyncio-task.rst:603

msgid ""

"If it is desired to completely ignore cancellation (not recommended) the "

"``shield()`` function should be combined with a try/except clause, as "

"follows::"

msgstr ""

"Si se desea ignorar por completo la cancelación (no se recomienda) la "

"función ``shield()`` debe combinarse con una cláusula try/except, como se "

"indica a continuación::"

#: ../Doc/library/asyncio-task.rst:615

msgid ""

"Save a reference to tasks passed to this function, to avoid a task "

"disappearing mid-execution. The event loop only keeps weak references to "

"tasks. A task that isn't referenced elsewhere may get garbage collected at "

"any time, even before it's done."

msgstr ""

"Guarde una referencia a las tareas pasadas a esta función, para evitar que "

"una tarea desaparezca a mitad de la ejecución. El bucle de eventos solo "

"mantiene referencias débiles a las tareas. Una tarea a la que no se hace "

"referencia en ningún otro lugar puede ser recolectada por el recolector de "

"basura en cualquier momento, incluso antes de que se complete."

#: ../Doc/library/asyncio-task.rst:623

msgid ""

"Deprecation warning is emitted if *aw* is not Future-like object and there "

"is no running event loop."

msgstr ""

"Se emite una advertencia de obsolescencia si *aw* no es un objeto similares "

"a Futures y no hay un bucle de eventos en ejecución."

#: ../Doc/library/asyncio-task.rst:629

msgid "Timeouts"

msgstr "Tiempo agotado"

#: ../Doc/library/asyncio-task.rst:633

msgid ""

"Return an :ref:`asynchronous context manager <async-context-managers>` that "

"can be used to limit the amount of time spent waiting on something."

msgstr ""

"Un :ref:`asynchronous context manager <async-context-managers>` que se puede "

"usar para limitar la cantidad de tiempo que se pasa esperando algo."

#: ../Doc/library/asyncio-task.rst:637

msgid ""

"*delay* can either be ``None``, or a float/int number of seconds to wait. If "

"*delay* is ``None``, no time limit will be applied; this can be useful if "

"the delay is unknown when the context manager is created."

msgstr ""

"*delay* puede ser ``None`` o un número flotante/int de segundos de espera. "

"Si *delay* es ``None``, no se aplicará ningún límite de tiempo; esto puede "

"ser útil si se desconoce el retraso cuando se crea el administrador de "

"contexto."

#: ../Doc/library/asyncio-task.rst:642

msgid ""

"In either case, the context manager can be rescheduled after creation using :"

"meth:`Timeout.reschedule`."

msgstr ""

"En cualquier caso, el administrador de contexto se puede reprogramar después "

"de la creación mediante :meth:`Timeout.reschedule`."

#: ../Doc/library/asyncio-task.rst:651

msgid ""

"If ``long_running_task`` takes more than 10 seconds to complete, the context "

"manager will cancel the current task and handle the resulting :exc:`asyncio."

"CancelledError` internally, transforming it into a :exc:`TimeoutError` which "

"can be caught and handled."

msgstr ""

"Si ``long_running_task`` tarda más de 10 segundos en completarse, el "

"administrador de contexto cancelará la tarea actual y manejará internamente "

"el :exc:`asyncio.CancelledError` resultante, transformándolo en un :exc:"

"`asyncio.TimeoutError` que se puede capturar y manejar."

#: ../Doc/library/asyncio-task.rst:658

msgid ""

"The :func:`asyncio.timeout` context manager is what transforms the :exc:"

"`asyncio.CancelledError` into a :exc:`TimeoutError`, which means the :exc:"

"`TimeoutError` can only be caught *outside* of the context manager."

msgstr ""

"El administrador de contexto :func:`asyncio.timeout` es lo que transforma "

"el :exc:`asyncio.CancelledError` en un :exc:`asyncio.TimeoutError`, lo que "

"significa que el :exc:`asyncio.TimeoutError` solo puede capturarse *outside* "

"del administrador de contexto."

#: ../Doc/library/asyncio-task.rst:663

msgid "Example of catching :exc:`TimeoutError`::"

msgstr "Ejemplo de captura de :exc:`TimeoutError`::"

#: ../Doc/library/asyncio-task.rst:674

msgid ""

"The context manager produced by :func:`asyncio.timeout` can be rescheduled "

"to a different deadline and inspected."

msgstr ""

"El administrador de contexto producido por :func:`asyncio.timeout` puede "

"reprogramarse para una fecha límite diferente e inspeccionarse."

#: ../Doc/library/asyncio-task.rst:679

msgid ""

"An :ref:`asynchronous context manager <async-context-managers>` for "

"cancelling overdue coroutines."

msgstr ""

"Un :ref:`asynchronous context manager <async-context-managers>` para "

"cancelar corrutinas vencidas."

#: ../Doc/library/asyncio-task.rst:682

msgid ""

"``when`` should be an absolute time at which the context should time out, as "

"measured by the event loop's clock:"

msgstr ""

"``when`` debe ser un tiempo absoluto en el que el contexto debe expirar, "

"según lo medido por el reloj del bucle de eventos:"

#: ../Doc/library/asyncio-task.rst:685

msgid "If ``when`` is ``None``, the timeout will never trigger."

msgstr "Si ``when`` es ``None``, el tiempo de espera nunca se activará."

#: ../Doc/library/asyncio-task.rst:686

msgid ""

"If ``when < loop.time()``, the timeout will trigger on the next iteration of "

"the event loop."

msgstr ""

"Si ``when < loop.time()``, el tiempo de espera se activará en la próxima "

"iteración del bucle de eventos"

#: ../Doc/library/asyncio-task.rst:691

msgid ""

"Return the current deadline, or ``None`` if the current deadline is not set."

msgstr ""

"Retorna la fecha límite actual, o ``None`` si la fecha límite actual no está "

"establecida."

#: ../Doc/library/asyncio-task.rst:696

msgid "Reschedule the timeout."

msgstr "Reprogramar el tiempo de espera."

#: ../Doc/library/asyncio-task.rst:700

msgid "Return whether the context manager has exceeded its deadline (expired)."

msgstr ""

"Retorna si el administrador de contexto ha excedido su fecha límite "

"(caducada)."

#: ../Doc/library/asyncio-task.rst:720

msgid "Timeout context managers can be safely nested."

msgstr ""

"Los administradores de contexto de tiempo de espera se pueden anidar de "

"forma segura."

#: ../Doc/library/asyncio-task.rst:726

msgid ""

"Similar to :func:`asyncio.timeout`, except *when* is the absolute time to "

"stop waiting, or ``None``."

msgstr ""

"Similar a :func:`asyncio.timeout`, excepto que *when* es el tiempo absoluto "

"para dejar de esperar, o ``None``."

#: ../Doc/library/asyncio-task.rst:746

msgid ""

"Wait for the *aw* :ref:`awaitable <asyncio-awaitables>` to complete with a "

"timeout."

msgstr ""

"Espere a que el *aw* :ref:`esperable <asyncio-awaitables>` se complete con "

"un tiempo agotado."

#: ../Doc/library/asyncio-task.rst:751

msgid ""

"*timeout* can either be ``None`` or a float or int number of seconds to wait "

"for. If *timeout* is ``None``, block until the future completes."

msgstr ""

"*timeout* puede ser ``None`` o punto flotante o un número entero de segundos "

"a esperar. Si *timeout* es ``None``, se bloquea hasta que Future se completa."

#: ../Doc/library/asyncio-task.rst:755

msgid ""

"If a timeout occurs, it cancels the task and raises :exc:`TimeoutError`."

msgstr ""

"Si se agota el tiempo de espera, cancela la tarea y lanza :exc:"

"`TimeoutError`."

#: ../Doc/library/asyncio-task.rst:758

msgid ""

"To avoid the task :meth:`cancellation <Task.cancel>`, wrap it in :func:"

"`shield`."

msgstr ""

"Para evitar la :meth:`cancelación <Task.cancel>` de la tarea , envuélvala "

"en :func:`shield`."

#: ../Doc/library/asyncio-task.rst:761

msgid ""

"The function will wait until the future is actually cancelled, so the total "

"wait time may exceed the *timeout*. If an exception happens during "

"cancellation, it is propagated."

msgstr ""

"La función esperará hasta que se cancele el Future, por lo que el tiempo de "

"espera total puede exceder el *timeout*. Si ocurre una excepción durante la "

"cancelación, se propaga."

#: ../Doc/library/asyncio-task.rst:765

msgid "If the wait is cancelled, the future *aw* is also cancelled."

msgstr "Si se cancela la espera, el Future *aw* también se cancela."

#: ../Doc/library/asyncio-task.rst:792

msgid ""

"When *aw* is cancelled due to a timeout, ``wait_for`` waits for *aw* to be "

"cancelled. Previously, it raised :exc:`TimeoutError` immediately."

msgstr ""

"Cuando se cancela *aw* debido a un tiempo de espera, ``wait_for`` espera a "

"que se cancele *aw*. Anteriormente, lanzaba :exc:`TimeoutError` "

"inmediatamente."

#: ../Doc/library/asyncio-task.rst:802

msgid "Waiting Primitives"

msgstr "Esperando primitivas"

#: ../Doc/library/asyncio-task.rst:806

msgid ""

"Run :class:`~asyncio.Future` and :class:`~asyncio.Task` instances in the "

"*aws* iterable concurrently and block until the condition specified by "

"*return_when*."

msgstr ""

"Ejecuta instancias :class:`~asyncio.Future` y :class:`~asyncio.Task` en el "

"iterable *aws* simultáneamente y bloquea hasta la condición especificada por "