# 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: 2021-03-19 11:16+0100\n"

"PO-Revision-Date: 2020-09-22 17:54+0000\n"

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

"Language: es\n"

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

"Plural-Forms: nplurals=2; plural=(n != 1)\n"

"MIME-Version: 1.0\n"

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

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

"Generated-By: Babel 2.8.0\n"

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

msgid "Event Loop"

msgstr "Bucle de eventos"

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

msgid ""

"**Source code:** :source:`Lib/asyncio/events.py`, :source:`Lib/asyncio/"

"base_events.py`"

msgstr ""

"**Código fuente:** :source:`Lib/asyncio/events.py`, :source:`Lib/asyncio/"

"base_events.py`"

#: ../Doc/library/asyncio-eventloop.rst:14

msgid "Preface"

msgstr "Prólogo"

#: ../Doc/library/asyncio-eventloop.rst:15

msgid ""

"The event loop is the core of every asyncio application. Event loops run "

"asynchronous tasks and callbacks, perform network IO operations, and run "

"subprocesses."

msgstr ""

"El bucle de eventos es el núcleo de cada aplicación asyncio. Los bucles de "

"eventos ejecutan tareas asíncronas y llamadas de retorno, realizan "

"operaciones de E/S de red y ejecutan subprocesos."

#: ../Doc/library/asyncio-eventloop.rst:19

msgid ""

"Application developers should typically use the high-level asyncio "

"functions, such as :func:`asyncio.run`, and should rarely need to reference "

"the loop object or call its methods. This section is intended mostly for "

"authors of lower-level code, libraries, and frameworks, who need finer "

"control over the event loop behavior."

msgstr ""

"Los desarrolladores de aplicaciones normalmente deberían usar las funciones "

"asyncio de alto nivel, como: :func:`asyncio.run`, y rara vez deberían "

"necesitar hacer referencia al objeto de bucle o llamar a sus métodos. Esta "

"sección esta dirigida principalmente a autores de código de nivel inferior, "

"bibliotecas y frameworks, quienes necesitan un control mas preciso sobre el "

"comportamiento del bucle de eventos."

#: ../Doc/library/asyncio-eventloop.rst:26

msgid "Obtaining the Event Loop"

msgstr "Obtención del bucle de eventos"

#: ../Doc/library/asyncio-eventloop.rst:27

msgid ""

"The following low-level functions can be used to get, set, or create an "

"event loop:"

msgstr ""

"Las siguientes funciones de bajo nivel se pueden utilizar para obtener, "

"establecer o crear un bucle de eventos:"

#: ../Doc/library/asyncio-eventloop.rst:32

msgid "Return the running event loop in the current OS thread."

msgstr ""

"Retorna el bucle de eventos en ejecución en el hilo del sistema operativo "

"actual."

#: ../Doc/library/asyncio-eventloop.rst:34

msgid ""

"If there is no running event loop a :exc:`RuntimeError` is raised. This "

"function can only be called from a coroutine or a callback."

msgstr ""

"Si no hay un bucle de eventos en ejecución, se levanta un :exc:"

"`RuntimeError`. Esta función únicamente puede ser llamada desde una "

"corrutina o una llamada de retorno."

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

msgid "Get the current event loop."

msgstr "Obtiene bucle de eventos actual."

#: ../Doc/library/asyncio-eventloop.rst:43

msgid ""

"If there is no current event loop set in the current OS thread, the OS "

"thread is main, and :func:`set_event_loop` has not yet been called, asyncio "

"will create a new event loop and set it as the current one."

msgstr ""

"Si no hay un bucle de eventos actual establecido en el hilo actual del "

"sistema operativo, el hilo del sistema operativo es el principal, y :func:"

"`set_event_loop` aún no ha sido llamado, asyncio creará un nuevo bucle de "

"eventos y lo establecerá como el actual."

#: ../Doc/library/asyncio-eventloop.rst:48

msgid ""

"Because this function has rather complex behavior (especially when custom "

"event loop policies are in use), using the :func:`get_running_loop` function "

"is preferred to :func:`get_event_loop` in coroutines and callbacks."

msgstr ""

"Dado que esta función tiene un comportamiento bastante complejo "

"(especialmente cuando están en uso las políticas de bucle de eventos "

"personalizadas), usar la función :func:`get_running_loop` es preferible "

"antes que :func:`get_event_loop` en corrutinas y llamadas de retorno."

#: ../Doc/library/asyncio-eventloop.rst:53

msgid ""

"Consider also using the :func:`asyncio.run` function instead of using lower "

"level functions to manually create and close an event loop."

msgstr ""

"Considere también usar la función :func:`asyncio.run` en lugar de usar "

"funciones de bajo nivel para crear y cerrar manualmente un bucle de eventos."

#: ../Doc/library/asyncio-eventloop.rst:58

msgid "Set *loop* as a current event loop for the current OS thread."

msgstr ""

"Establece *loop* como el bucle de eventos actual para el hilo actual del "

"sistema operativo."

#: ../Doc/library/asyncio-eventloop.rst:62

msgid "Create a new event loop object."

msgstr "Crea un nuevo objeto de bucle de eventos."

#: ../Doc/library/asyncio-eventloop.rst:64

msgid ""

"Note that the behaviour of :func:`get_event_loop`, :func:`set_event_loop`, "

"and :func:`new_event_loop` functions can be altered by :ref:`setting a "

"custom event loop policy <asyncio-policies>`."

msgstr ""

"Tenga en cuenta que el comportamiento de las funciones :func:"

"`get_event_loop`, :func:`set_event_loop`, y :func:`new_event_loop` puede ser "

"modificado mediante :ref:`estableciendo una política de bucle de eventos "

"personalizada <asyncio-policies>`."

#: ../Doc/library/asyncio-eventloop.rst:70

msgid "Contents"

msgstr "Contenidos"

#: ../Doc/library/asyncio-eventloop.rst:71

msgid "This documentation page contains the following sections:"

msgstr "Esta página de documentación contiene las siguientes secciones:"

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

msgid ""

"The `Event Loop Methods`_ section is the reference documentation of the "

"event loop APIs;"

msgstr ""

"La sección `Métodos del bucle de eventos`_ es la documentación de referencia "

"de las APIs del bucle de eventos;"

#: ../Doc/library/asyncio-eventloop.rst:76

msgid ""

"The `Callback Handles`_ section documents the :class:`Handle` and :class:"

"`TimerHandle` instances which are returned from scheduling methods such as :"

"meth:`loop.call_soon` and :meth:`loop.call_later`;"

msgstr ""

"La sección `Callback Handles`_ documenta las instancias :class:`Handle` y :"

"class:`TimerHandle` las cuales son retornadas por métodos planificados como :"

"meth:`loop.call_soon` y :meth:`loop.call_later`;"

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

msgid ""

"The `Server Objects`_ section documents types returned from event loop "

"methods like :meth:`loop.create_server`;"

msgstr ""

"La sección `Objetos del servidor`_ documenta tipos retornados por los "

"métodos del bucle de eventos como :meth:`loop.create_server`;"

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

msgid ""

"The `Event Loop Implementations`_ section documents the :class:"

"`SelectorEventLoop` and :class:`ProactorEventLoop` classes;"

msgstr ""

"La sección `Implementaciones de bucle de eventos`_ documenta las clases :"

"class:`SelectorEventLoop` y :class:`ProactorEventLoop`;"

#: ../Doc/library/asyncio-eventloop.rst:86

msgid ""

"The `Examples`_ section showcases how to work with some event loop APIs."

msgstr ""

"La sección `Ejemplos`_ muestra como trabajar con algunas APIs de bucle de "

"eventos."

#: ../Doc/library/asyncio-eventloop.rst:93

msgid "Event Loop Methods"

msgstr "Métodos del bucle de eventos"

#: ../Doc/library/asyncio-eventloop.rst:95

msgid "Event loops have **low-level** APIs for the following:"

msgstr "Los bucles de eventos tienen APIs de **bajo nivel** para lo siguiente:"

#: ../Doc/library/asyncio-eventloop.rst:103

msgid "Running and stopping the loop"

msgstr "Iniciar y para el bucle"

#: ../Doc/library/asyncio-eventloop.rst:107

msgid "Run until the *future* (an instance of :class:`Future`) has completed."

msgstr ""

"Se ejecuta hasta que *future* (una instancia de :class:`Future`) se haya "

"completado."

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

msgid ""

"If the argument is a :ref:`coroutine object <coroutine>` it is implicitly "

"scheduled to run as a :class:`asyncio.Task`."

msgstr ""

"Si el argumento es un :ref:`objeto corrutina <coroutine>` está "

"implícitamente planificado para ejecutarse como una :class:`asyncio.Task`."

#: ../Doc/library/asyncio-eventloop.rst:113

msgid "Return the Future's result or raise its exception."

msgstr "Retorna el resultado del Futuro o genera una excepción."

#: ../Doc/library/asyncio-eventloop.rst:117

msgid "Run the event loop until :meth:`stop` is called."

msgstr "Ejecuta el bucle de eventos hasta que :meth:`stop` es llamado."

#: ../Doc/library/asyncio-eventloop.rst:119

msgid ""

"If :meth:`stop` is called before :meth:`run_forever()` is called, the loop "

"will poll the I/O selector once with a timeout of zero, run all callbacks "

"scheduled in response to I/O events (and those that were already scheduled), "

"and then exit."

msgstr ""

"Si :meth:`stop` es llamado antes que :meth:`run_forever()`, el bucle va a "

"sondear el selector de E/S una sola vez con un plazo de ejecución de cero, "

"ejecuta todas las llamadas planificadas como respuesta a eventos E/S (y "

"aquellas que ya hayan sido planificados), y entonces termina."

#: ../Doc/library/asyncio-eventloop.rst:124

msgid ""

"If :meth:`stop` is called while :meth:`run_forever` is running, the loop "

"will run the current batch of callbacks and then exit. Note that new "

"callbacks scheduled by callbacks will not run in this case; instead, they "

"will run the next time :meth:`run_forever` or :meth:`run_until_complete` is "

"called."

msgstr ""

"Si :meth:`stop` es llamado mientras :meth:`run_forever` se está ejecutando, "

"el loop ejecutará el lote actual de llamadas y después finalizará. Tenga en "

"cuenta que llamadas planificadas por otras llamadas no se ejecutarán en este "

"caso; en su lugar, ellas correrán la próxima vez que :meth:`run_forever` o :"

"meth:`run_until_complete` sean llamados."

#: ../Doc/library/asyncio-eventloop.rst:132

msgid "Stop the event loop."

msgstr "Detener el bucle de eventos."

#: ../Doc/library/asyncio-eventloop.rst:136

msgid "Return ``True`` if the event loop is currently running."

msgstr "Retorna ``True`` si el bucle de eventos esta en ejecución actualmente."

#: ../Doc/library/asyncio-eventloop.rst:140

msgid "Return ``True`` if the event loop was closed."

msgstr "Retorna ``True`` si el bucle de eventos se cerró."

#: ../Doc/library/asyncio-eventloop.rst:144

msgid "Close the event loop."

msgstr "Cierra el bucle de eventos."

#: ../Doc/library/asyncio-eventloop.rst:146

msgid ""

"The loop must not be running when this function is called. Any pending "

"callbacks will be discarded."

msgstr ""

"El bucle no debe estar en ejecución cuando se llama a esta función. "

"Cualquier llamada de retorno pendiente será descartada."

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

msgid ""

"This method clears all queues and shuts down the executor, but does not wait "

"for the executor to finish."

msgstr ""

"Este método limpia todas las colas y apaga el ejecutor, pero no espera a que "

"el ejecutor termine."

#: ../Doc/library/asyncio-eventloop.rst:152

msgid ""

"This method is idempotent and irreversible. No other methods should be "

"called after the event loop is closed."

msgstr ""

"Este método es idempotente e irreversible. No se debe llamar ningún otro "

"método después que el bucle de eventos es cerrado."

#: ../Doc/library/asyncio-eventloop.rst:157

msgid ""

"Schedule all currently open :term:`asynchronous generator` objects to close "

"with an :meth:`~agen.aclose()` call. After calling this method, the event "

"loop will issue a warning if a new asynchronous generator is iterated. This "

"should be used to reliably finalize all scheduled asynchronous generators."

msgstr ""

"Programa todos los objetos :term:`asynchronous generator` abiertos "

"actualmente para cerrarlos con una llamada :meth:`~agen.aclose()`. Después "

"de llamar este método, el bucle de eventos emitirá una advertencia si un "

"nuevo generador asíncrono es iterado. Esto debe ser usado para finalizar de "

"manera confiable todos los generadores asíncronos planificados."

#: ../Doc/library/asyncio-eventloop.rst:163

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

msgid ""

"Note that there is no need to call this function when :func:`asyncio.run` is "

"used."

msgstr ""

"Tenga en cuenta que no hay necesidad de llamar esta función cuando :func:"

"`asyncio.run` es utilizado."

#: ../Doc/library/asyncio-eventloop.rst:166

#: ../Doc/library/asyncio-eventloop.rst:1074

#: ../Doc/library/asyncio-eventloop.rst:1456

msgid "Example::"

msgstr "Ejemplo::"

#: ../Doc/library/asyncio-eventloop.rst:178

msgid ""

"Schedule the closure of the default executor and wait for it to join all of "

"the threads in the :class:`ThreadPoolExecutor`. After calling this method, "

"a :exc:`RuntimeError` will be raised if :meth:`loop.run_in_executor` is "

"called while using the default executor."

msgstr ""

#: ../Doc/library/asyncio-eventloop.rst:190

msgid "Scheduling callbacks"

msgstr "Programación de llamadas de retorno"

#: ../Doc/library/asyncio-eventloop.rst:194

#, fuzzy

msgid ""

"Schedule the *callback* :term:`callback` to be called with *args* arguments "

"at the next iteration of the event loop."

msgstr ""

"Planifica un *callback* para ser ejecutada con los argumentos *args* en la "

"próxima iteración del bucle de eventos."

#: ../Doc/library/asyncio-eventloop.rst:197

msgid ""

"Callbacks are called in the order in which they are registered. Each "

"callback will be called exactly once."

msgstr ""

"Llamadas que son ejecutadas en el orden en el que fueron registradas. Cada "

"llamada será ejecutada exactamente una sola vez."

#: ../Doc/library/asyncio-eventloop.rst:200

#: ../Doc/library/asyncio-eventloop.rst:263

msgid ""

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

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

"context is used when no *context* is provided."

msgstr ""

"Un argumento *context* opcional y solo de palabra clave que permite "

"especificar una clase :class:`contextvars.Context` personalizada en la cual "

"*callback* será ejecutada. Cuando no se provee *context* el contexto actual "

"es utilizado."

#: ../Doc/library/asyncio-eventloop.rst:204

msgid ""

"An instance of :class:`asyncio.Handle` is returned, which can be used later "

"to cancel the callback."

msgstr ""

"Una instancia de :class:`asyncio.Handle` es retornada, que puede ser "

"utilizada después para cancelar la llamada."

#: ../Doc/library/asyncio-eventloop.rst:207

msgid "This method is not thread-safe."

msgstr "Este método no es seguro para subprocesos."

#: ../Doc/library/asyncio-eventloop.rst:211

msgid ""

"A thread-safe variant of :meth:`call_soon`. Must be used to schedule "

"callbacks *from another thread*."

msgstr ""

"Una variante de :meth:`call_soon` que es segura para subprocesos. Debe ser "

"usada en llamadas planificadas *desde otro hilo*."

#: ../Doc/library/asyncio-eventloop.rst:214

msgid ""

"See the :ref:`concurrency and multithreading <asyncio-multithreading>` "

"section of the documentation."

msgstr ""

"Vea sección :ref:`concurrencia y multiproceso <asyncio-multithreading>` de "

"la documentación."

#: ../Doc/library/asyncio-eventloop.rst:217

#: ../Doc/library/asyncio-eventloop.rst:267

#: ../Doc/library/asyncio-eventloop.rst:287

msgid ""

"The *context* keyword-only parameter was added. See :pep:`567` for more "

"details."

msgstr ""

"Fue agregado el parámetro solo de palabra clave *context*. Vea :pep:`567` "

"para mas detalles."

#: ../Doc/library/asyncio-eventloop.rst:225

msgid ""

"Most :mod:`asyncio` scheduling functions don't allow passing keyword "

"arguments. To do that, use :func:`functools.partial`::"

msgstr ""

"La mayoría de las funciones planificadas de :mod:`asyncio` no permiten pasar "

"argumentos de palabra clave. Para hacer eso utilice :func:`functools."

"partial`::"

#: ../Doc/library/asyncio-eventloop.rst:232

msgid ""

"Using partial objects is usually more convenient than using lambdas, as "

"asyncio can render partial objects better in debug and error messages."

msgstr ""

"El uso de objetos parciales es usualmente mas conveniente que utilizar "

"lambdas, ya que asyncio puede renderizar mejor objetos parciales en mensajes "

"de depuración y error."

#: ../Doc/library/asyncio-eventloop.rst:240

msgid "Scheduling delayed callbacks"

msgstr "Planificando llamadas retardadas"

#: ../Doc/library/asyncio-eventloop.rst:242

msgid ""

"Event loop provides mechanisms to schedule callback functions to be called "

"at some point in the future. Event loop uses monotonic clocks to track time."

msgstr ""

"El bucle de eventos provee mecanismos para planificar funciones de llamadas "

"que serán ejecutadas en algún punto en el futuro. El bucle de eventos usa "

"relojes monotónicos para seguir el tiempo."

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

msgid ""

"Schedule *callback* to be called after the given *delay* number of seconds "

"(can be either an int or a float)."

msgstr ""

"Planifica *callback* para ser ejecutada luego de *delay* número de segundos "

"(puede ser tanto un entero como un flotante)."

#: ../Doc/library/asyncio-eventloop.rst:252

#: ../Doc/library/asyncio-eventloop.rst:284

msgid ""

"An instance of :class:`asyncio.TimerHandle` is returned which can be used to "

"cancel the callback."

msgstr ""

"Una instancia de :class:`asyncio.TimerHandle` es retornada, la que puede ser "

"utilizada para cancelar la ejecución."

#: ../Doc/library/asyncio-eventloop.rst:255

msgid ""

"*callback* will be called exactly once. If two callbacks are scheduled for "

"exactly the same time, the order in which they are called is undefined."

msgstr ""

"*callback* será ejecutada exactamente una sola vez. Si dos llamadas son "

"planificadas para el mismo momento exacto, el orden en el que son ejecutadas "

"es indefinido."

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

msgid ""

"The optional positional *args* will be passed to the callback when it is "

"called. If you want the callback to be called with keyword arguments use :"

"func:`functools.partial`."

msgstr ""

"El argumento posicional opcional *args* será pasado a la llamada cuando esta "

"sea ejecutada. Si quieres que la llamada sea ejecutada con argumentos de "

"palabra clave usa :func:`functools.partial`."

#: ../Doc/library/asyncio-eventloop.rst:271

msgid ""

"In Python 3.7 and earlier with the default event loop implementation, the "

"*delay* could not exceed one day. This has been fixed in Python 3.8."

msgstr ""

"En Python 3.7 y versiones anteriores con la implementación del bucle de "

"eventos predeterminada, el *delay* no puede exceder un día. Esto fue "

"arreglado en Python 3.8."

#: ../Doc/library/asyncio-eventloop.rst:278

msgid ""

"Schedule *callback* to be called at the given absolute timestamp *when* (an "

"int or a float), using the same time reference as :meth:`loop.time`."

msgstr ""

"Planifica *callback* para ser ejecutada en una marca de tiempo absoluta "

"*when* (un entero o un flotante), usando la misma referencia de tiempo que :"

"meth:`loop.time`."

#: ../Doc/library/asyncio-eventloop.rst:282

msgid "This method's behavior is the same as :meth:`call_later`."

msgstr "El comportamiento de este método es el mismo que :meth:`call_later`."

#: ../Doc/library/asyncio-eventloop.rst:291

msgid ""

"In Python 3.7 and earlier with the default event loop implementation, the "

"difference between *when* and the current time could not exceed one day. "

"This has been fixed in Python 3.8."

msgstr ""

"En Python 3.7 y versiones anteriores con la implementación del bucle de "

"eventos predeterminada, la diferencia entre *when* y el tiempo actual no "

"puede exceder un día. Esto fue arreglado en Python 3.8."

#: ../Doc/library/asyncio-eventloop.rst:298

msgid ""

"Return the current time, as a :class:`float` value, according to the event "

"loop's internal monotonic clock."

msgstr ""

"Retorna el tiempo actual, como un :class:`float`, de acuerdo al reloj "

"monotónico interno del bucle de evento."

#: ../Doc/library/asyncio-eventloop.rst:302

msgid ""

"In Python 3.7 and earlier timeouts (relative *delay* or absolute *when*) "

"should not exceed one day. This has been fixed in Python 3.8."

msgstr ""

"En Python 3.7 y versiones anteriores los tiempos de espera (*delay* relativo "

"o *when* absoluto) no deben exceder un día. Esto fue arreglado en Python 3.8."

#: ../Doc/library/asyncio-eventloop.rst:308

msgid "The :func:`asyncio.sleep` function."

msgstr "La función :func:`asyncio.sleep`."

#: ../Doc/library/asyncio-eventloop.rst:312

msgid "Creating Futures and Tasks"

msgstr "Creando Futuros y Tareas"

#: ../Doc/library/asyncio-eventloop.rst:316

msgid "Create an :class:`asyncio.Future` object attached to the event loop."

msgstr "Crea un objeto :class:`asyncio.Future` adjunto al bucle de eventos."

#: ../Doc/library/asyncio-eventloop.rst:318

msgid ""

"This is the preferred way to create Futures in asyncio. This lets third-"

"party event loops provide alternative implementations of the Future object "

"(with better performance or instrumentation)."

msgstr ""

"Esta es la manera preferida de crear Futures en asyncio. Esto permite que "

"bucles de eventos de terceros provean implementaciones alternativas del "

"objeto Future (con mejor rendimiento o instrumentación)."

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

msgid ""

"Schedule the execution of a :ref:`coroutine`. Return a :class:`Task` object."

msgstr ""

"Planifica la ejecución de una :ref:`Coroutine`. Retorna un objeto :class:"

"`Task`."

#: ../Doc/library/asyncio-eventloop.rst:329

msgid ""

"Third-party event loops can use their own subclass of :class:`Task` for "

"interoperability. In this case, the result type is a subclass of :class:"

"`Task`."

msgstr ""

"Bucles de eventos de terceros pueden usar sus propias subclases de :class:"

"`Task` por interoperabilidad. En este caso, el tipo de resultado es una "

"subclase de :class:`Task`."

#: ../Doc/library/asyncio-eventloop.rst:333

msgid ""

"If the *name* argument is provided and not ``None``, it is set as the name "

"of the task using :meth:`Task.set_name`."

msgstr ""

"Si el argumento *name* es provisto y no ``None``, se establece como el "

"nombre de la tarea usando :meth:`Task.set_name`."

#: ../Doc/library/asyncio-eventloop.rst:336

msgid "Added the ``name`` parameter."

msgstr "Agregado el parámetro ``name``."

#: ../Doc/library/asyncio-eventloop.rst:341

msgid "Set a task factory that will be used by :meth:`loop.create_task`."

msgstr ""

"Establece una fábrica de tareas que será utilizada por :meth:`loop."

"create_task`."

#: ../Doc/library/asyncio-eventloop.rst:344

msgid ""

"If *factory* is ``None`` the default task factory will be set. Otherwise, "

"*factory* must be a *callable* with the signature matching ``(loop, coro)``, "

"where *loop* is a reference to the active event loop, and *coro* is a "

"coroutine object. The callable must return a :class:`asyncio.Future`-"

"compatible object."

msgstr ""

"Si *factory* es ``None`` se establecerá la fábrica de tareas por defecto. En "

"cualquier otro caso, *factory* debe ser un *callable* con la misma firma "

"``(loop, coro)``, donde *loop* es una referencia al bucle de eventos activo "

"y *coro* es un objeto de corrutina. El ejecutable debe retornar una objeto :"

"class:`asyncio.Future` compatible."

#: ../Doc/library/asyncio-eventloop.rst:352

msgid "Return a task factory or ``None`` if the default one is in use."

msgstr ""

"Retorna una fábrica de tareas o ``None`` si la predefinida está en uso."

#: ../Doc/library/asyncio-eventloop.rst:356

msgid "Opening network connections"

msgstr "Abriendo conexiones de red"

#: ../Doc/library/asyncio-eventloop.rst:365

msgid ""

"Open a streaming transport connection to a given address specified by *host* "

"and *port*."

msgstr ""

"Abre una conexión de transmisión de transporte a una dirección especificada "

"por *host* y *port*."

#: ../Doc/library/asyncio-eventloop.rst:368

msgid ""

"The socket family can be either :py:data:`~socket.AF_INET` or :py:data:"

"`~socket.AF_INET6` depending on *host* (or the *family* argument, if "

"provided)."

msgstr ""

"La familia de sockets puede ser tanto :py:data:`~socket.AF_INET` como :py:"

"data:`~socket.AF_INET6` dependiendo de *host* (o del argumento *family* si "

"es que fue provisto)."

#: ../Doc/library/asyncio-eventloop.rst:372

msgid "The socket type will be :py:data:`~socket.SOCK_STREAM`."

msgstr "El tipo de socket será :py:data:`~socket.SOCK_STREAM`."

#: ../Doc/library/asyncio-eventloop.rst:374

#: ../Doc/library/asyncio-eventloop.rst:990

#: ../Doc/library/asyncio-eventloop.rst:1006

msgid ""

"*protocol_factory* must be a callable returning an :ref:`asyncio protocol "

"<asyncio-protocol>` implementation."

msgstr ""

"*protocol_factory* debe ser un ejecutable que retorna una implementación "

"del :ref:`asyncio protocol <asyncio-protocol>`."

#: ../Doc/library/asyncio-eventloop.rst:377

msgid ""

"This method will try to establish the connection in the background. When "

"successful, it returns a ``(transport, protocol)`` pair."

msgstr ""

"Este método tratará de establecer la conexión en un segundo plano. Cuando es "

"exitosa, retorna un par ``(transport, protocol)``."

#: ../Doc/library/asyncio-eventloop.rst:380

msgid "The chronological synopsis of the underlying operation is as follows:"

msgstr "La sinopsis cronológica de las operaciones subyacentes es como sigue:"

#: ../Doc/library/asyncio-eventloop.rst:382

msgid ""

"The connection is established and a :ref:`transport <asyncio-transport>` is "

"created for it."

msgstr ""

"La conexión es establecida y un :ref:`transporte <asyncio-transport>` es "

"creado para ello."

#: ../Doc/library/asyncio-eventloop.rst:385

msgid ""

"*protocol_factory* is called without arguments and is expected to return a :"

"ref:`protocol <asyncio-protocol>` instance."

msgstr ""

"*protocol_factory* es llamado sin argumentos y se espera que retorne una "

"instancia de :ref:`protocol <asyncio-protocol>`."

#: ../Doc/library/asyncio-eventloop.rst:388

msgid ""

"The protocol instance is coupled with the transport by calling its :meth:"

"`~BaseProtocol.connection_made` method."

msgstr ""

"La instancia del protocolo se acopla con el transporte mediante el llamado "

"de su método :meth:`~BaseProtocol.connection_made`."

#: ../Doc/library/asyncio-eventloop.rst:391

msgid "A ``(transport, protocol)`` tuple is returned on success."

msgstr ""

"Una tupla ``(transport, protocol)`` es retornada cuando se tiene éxito."

#: ../Doc/library/asyncio-eventloop.rst:393

msgid ""

"The created transport is an implementation-dependent bidirectional stream."

msgstr ""

"El transporte creado es una transmisión (*stream*) bidireccional que depende "

"de la implementación."

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

#: ../Doc/library/asyncio-eventloop.rst:518

msgid "Other arguments:"

msgstr "Otros argumentos:"

#: ../Doc/library/asyncio-eventloop.rst:398

msgid ""

"*ssl*: if given and not false, a SSL/TLS transport is created (by default a "

"plain TCP transport is created). If *ssl* is a :class:`ssl.SSLContext` "

"object, this context is used to create the transport; if *ssl* is :const:"

"`True`, a default context returned from :func:`ssl.create_default_context` "

"is used."

msgstr ""

"*ssl*: si se provee y no es falso, un transporte SSL/TLS es creado (de "

"manera predeterminada se crea un transporte TCP plano). Si *ssl* es un "

"objeto :class:`ssl.SSLContext`, este contexto es utilizado para crear el "

"transporte; si *ssl* es :const:`True`, se utiliza un contexto predeterminado "

"retornado por :func:`ssl.create_default_context`."

#: ../Doc/library/asyncio-eventloop.rst:404

msgid ":ref:`SSL/TLS security considerations <ssl-security>`"

msgstr ":ref:`Consideraciones de seguridad SSL/TLS <ssl-security>`"

#: ../Doc/library/asyncio-eventloop.rst:406

msgid ""

"*server_hostname* sets or overrides the hostname that the target server's "

"certificate will be matched against. Should only be passed if *ssl* is not "

"``None``. By default the value of the *host* argument is used. If *host* "

"is empty, there is no default and you must pass a value for "

"*server_hostname*. If *server_hostname* is an empty string, hostname "

"matching is disabled (which is a serious security risk, allowing for "

"potential man-in-the-middle attacks)."

msgstr ""

"*server_hostname* establece o reemplaza el nombre de servidor (*hostname*) "

"contra el cual el certificado del servidor de destino será comparado. Sólo "

"debería ser pasado si *ssl* no es ``None``. De manera predeterminada es "

"usado el valor del argumento *host*. Si *host* está vacío, no hay valor "

"predeterminado y debes pasar un valor para *server_hostname*. Si "

"*server_hostname* es una cadena vacía, la comparación de nombres de "

"servidores es deshabilitada (lo que es un riesgo de seguridad serio, "

"permitiendo potenciales ataques de hombre-en-el-medio, *man-in-the-middle "

"attacks*)."

#: ../Doc/library/asyncio-eventloop.rst:414

msgid ""

"*family*, *proto*, *flags* are the optional address family, protocol and "

"flags to be passed through to getaddrinfo() for *host* resolution. If given, "

"these should all be integers from the corresponding :mod:`socket` module "

"constants."

msgstr ""

"*family*, *proto*, *flags* son dirección de familia, protocolo y banderas "

"opcionales que serán pasadas a través de `getaddrinfo()` para la resolución "

"de *host*. Si están dados, todos ellos deberían ser enteros de las "

"constantes del módulo :mod:`socket` correspondiente."

#: ../Doc/library/asyncio-eventloop.rst:419

#, fuzzy

msgid ""

"*happy_eyeballs_delay*, if given, enables Happy Eyeballs for this "

"connection. It should be a floating-point number representing the amount of "

"time in seconds to wait for a connection attempt to complete, before "

"starting the next attempt in parallel. This is the \"Connection Attempt Delay"

"\" as defined in :rfc:`8305`. A sensible default value recommended by the "

"RFC is ``0.25`` (250 milliseconds)."

msgstr ""

"*happy_eyeballs_delay*, si es provisto, habilita Globos Oculares Felices "

"(*Happy Eyeballs*) para esta conexión. Debería ser un número con coma "

"flotante representando la cantidad de tiempo en segundos a esperar para que "

"un intento de conexión se complete, antes de empezar el próximo intento en "

"paralelo. Este es el retraso de intento de conexión (*Connection Attempt "

"Delay*) como es definido en :rfc:`8305`. Un valor predefinido sensible que "

"es recomendado por el RFC es ``0.25`` (250 milisegundos)."

#: ../Doc/library/asyncio-eventloop.rst:427

msgid ""

"*interleave* controls address reordering when a host name resolves to "

"multiple IP addresses. If ``0`` or unspecified, no reordering is done, and "

"addresses are tried in the order returned by :meth:`getaddrinfo`. If a "

"positive integer is specified, the addresses are interleaved by address "

"family, and the given integer is interpreted as \"First Address Family Count"

"\" as defined in :rfc:`8305`. The default is ``0`` if *happy_eyeballs_delay* "

"is not specified, and ``1`` if it is."

msgstr ""

"*interleave* controla reordenamientos de dirección cuando un nombre de "

"servidor resuelve a múltiples direcciones IP. Si es ``0`` o no es "

"especificado, no se hace ningún reordenamiento, y las direcciones son "

"intentadas en el orden retornado por :meth:`getaddrinfo`. Si un entero "

"positivo es especificado, las direcciones son intercaladas por dirección de "

"familia, y el entero dado es interpretado como \"Número de familias de la "

"primera dirección\" (*First Address Family Count*) como es definida en :rfc:"

"`8305`. El valor predefinido es ``0`` si *happy_eyeballs_delay* no es "

"especificado, y ``1`` si lo es."

#: ../Doc/library/asyncio-eventloop.rst:436

msgid ""

"*sock*, if given, should be an existing, already connected :class:`socket."

"socket` object to be used by the transport. If *sock* is given, none of "

"*host*, *port*, *family*, *proto*, *flags*, *happy_eyeballs_delay*, "

"*interleave* and *local_addr* should be specified."

msgstr ""

"*sock*, si está dado, debe ser un objeto :class:`socket.socket` existente y "

"ya conectado, que será utilizado por el transporte. Si *sock* es dado, "

"ningún *host*, *port*, *family*, *proto*, *flags*, *happy_eyeballs_delay*, "

"*interleave* o *local_addr* deben ser especificados."

#: ../Doc/library/asyncio-eventloop.rst:442

msgid ""

"*local_addr*, if given, is a ``(local_host, local_port)`` tuple used to bind "

"the socket to locally. The *local_host* and *local_port* are looked up "

"using ``getaddrinfo()``, similarly to *host* and *port*."

msgstr ""

"*local_addr*, si está dado, es una tupla ``(local_host, local_port)``usada "

"para enlazar el socket localmente. Los *local_host* y *local_port* son "

"buscados usando ``getaddrinfo()``, de manera similar que con *host* y "

"*puerto*."

#: ../Doc/library/asyncio-eventloop.rst:446

#: ../Doc/library/asyncio-eventloop.rst:799

msgid ""

"*ssl_handshake_timeout* is (for a TLS connection) the time in seconds to "

"wait for the TLS handshake to complete before aborting the connection. "

"``60.0`` seconds if ``None`` (default)."

msgstr ""

"*ssl_handshake_timeout* es (para una conexión TLS) el tiempo en segundos a "

"esperar que se complete el apretón de manos (*handshake*) TLS antes de "

"abortar la conexión. ``60.0`` segundos si es ``None`` (predefinido)."

#: ../Doc/library/asyncio-eventloop.rst:452

msgid "Added the *happy_eyeballs_delay* and *interleave* parameters."

msgstr "Agregados los parámetros *happy_eyeballs_delay* y *interleave*."

#: ../Doc/library/asyncio-eventloop.rst:454

msgid ""

"Happy Eyeballs Algorithm: Success with Dual-Stack Hosts. When a server's "

"IPv4 path and protocol are working, but the server's IPv6 path and protocol "

"are not working, a dual-stack client application experiences significant "

"connection delay compared to an IPv4-only client. This is undesirable "

"because it causes the dual- stack client to have a worse user experience. "

"This document specifies requirements for algorithms that reduce this user-"

"visible delay and provides an algorithm."

msgstr ""

"Algoritmo de Globos Oculares Felices (*Happy Eyeballs*): Éxito con "

"Servidores de Doble-Pila (Dual-Stack Hosts). Cuando la ruta IPv4 y el "

"protocolo de un servidor están funcionando, pero la ruta IPv6 y el protocolo "

"no están funcionando, una aplicación del cliente de doble-pila experimenta "

"una demora de conexión significante en comparación con un cliente sólo de "

"IPv4. Esto no es deseable porque causa que el cliente de doble-pila tenga "

"la peor experiencia de usuario. Este documento especifica requerimientos "

"para algoritmos que reducen esta demora visible por el usuario, y provee un "

"algoritmo."

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

msgid "For more information: https://tools.ietf.org/html/rfc6555"

msgstr "Para mas información: https://tools.ietf.org/html/rfc6555"

#: ../Doc/library/asyncio-eventloop.rst:467

#: ../Doc/library/asyncio-eventloop.rst:584

#: ../Doc/library/asyncio-eventloop.rst:737

msgid "The *ssl_handshake_timeout* parameter."

msgstr "El parámetro *ssl_handshake_timeout*."

#: ../Doc/library/asyncio-eventloop.rst:471

#: ../Doc/library/asyncio-eventloop.rst:667

msgid ""

"The socket option :py:data:`~socket.TCP_NODELAY` is set by default for all "

"TCP connections."

msgstr ""

"La opción del socket :py:data:`~socket.TCP_NODELAY` es establecida de manera "

"predeterminada para todas las conexiones TCP."

#: ../Doc/library/asyncio-eventloop.rst:476

#: ../Doc/library/asyncio-eventloop.rst:672

msgid "Added support for SSL/TLS in :class:`ProactorEventLoop`."

msgstr "Agregado el soporte para SSL/TLS en :class:`ProactorEventLoop`."

#: ../Doc/library/asyncio-eventloop.rst:480

msgid ""

"The :func:`open_connection` function is a high-level alternative API. It "

"returns a pair of (:class:`StreamReader`, :class:`StreamWriter`) that can be "

"used directly in async/await code."

msgstr ""

"La función :func:`open_connection` es una API alternativa de alto nivel. "

"Retorna un par de (:class:`StreamReader`, :class:`StreamWriter`) que puede "

"ser usado directamente en código async/await."

#: ../Doc/library/asyncio-eventloop.rst:491

msgid ""

"The parameter *reuse_address* is no longer supported, as using :py:data:"

"`~sockets.SO_REUSEADDR` poses a significant security concern for UDP. "

"Explicitly passing ``reuse_address=True`` will raise an exception."

msgstr ""

"El parámetro *reuse_address* ya no es soportado, como utiliza :py:data:"

"`~sockets.SO_REUSEADDR` plantea un problema de seguridad importante para "

"UDP. Pasando explícitamente ``reuse_address=True`` lanzará una excepción."

#: ../Doc/library/asyncio-eventloop.rst:495

msgid ""

"When multiple processes with differing UIDs assign sockets to an identical "

"UDP socket address with ``SO_REUSEADDR``, incoming packets can become "

"randomly distributed among the sockets."

msgstr ""

"Cuando múltiples procesos con UIDs diferentes asignan sockets a una misma "

"dirección socket UDP con ``SO_REUSEADDR``, los paquetes entrantes pueden "

"distribuirse aleatoriamente entre los sockets."

#: ../Doc/library/asyncio-eventloop.rst:499

msgid ""

"For supported platforms, *reuse_port* can be used as a replacement for "

"similar functionality. With *reuse_port*, :py:data:`~sockets.SO_REUSEPORT` "

"is used instead, which specifically prevents processes with differing UIDs "

"from assigning sockets to the same socket address."

msgstr ""

"Para plataformas soportadas, *reuse_port* puede ser utilizado como un "

"reemplazo para funcionalidades similares. Con *reuse_port*, :py:data:"

"`~sockets.SO_REUSEPORT` es usado en su lugar, que específicamente previene "

"que procesos con distintos UIDs asignen sockets a la misma dirección de "

"socket."

#: ../Doc/library/asyncio-eventloop.rst:505

msgid "Create a datagram connection."

msgstr "Crea un datagrama de conexión."

#: ../Doc/library/asyncio-eventloop.rst:507

msgid ""

"The socket family can be either :py:data:`~socket.AF_INET`, :py:data:"

"`~socket.AF_INET6`, or :py:data:`~socket.AF_UNIX`, depending on *host* (or "

"the *family* argument, if provided)."

msgstr ""

"La familia de socket puede ser tanto :py:data:`~socket.AF_INET`, :py:data:"

"`~socket.AF_INET6`, como :py:data:`~socket.AF_UNIX`, dependiendo de *host* "

"(o del argumento *family*, si fue provisto)."

#: ../Doc/library/asyncio-eventloop.rst:511

msgid "The socket type will be :py:data:`~socket.SOCK_DGRAM`."

msgstr "El tipo de socket será :py:data:`~socket.SOCK_DGRAM`."

#: ../Doc/library/asyncio-eventloop.rst:513

#: ../Doc/library/asyncio-eventloop.rst:609

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

msgid ""

"*protocol_factory* must be a callable returning a :ref:`protocol <asyncio-"

"protocol>` implementation."

msgstr ""

"*protocol_factory* debe ser un ejecutable que retorne una implementación de :"

"ref:`protocol <asyncio-protocol>`."

#: ../Doc/library/asyncio-eventloop.rst:516

#: ../Doc/library/asyncio-eventloop.rst:570

msgid "A tuple of ``(transport, protocol)`` is returned on success."

msgstr ""

"Una tupla de ``(transport, protocol)`` es retornada cuando se tiene éxito."

#: ../Doc/library/asyncio-eventloop.rst:520

msgid ""

"*local_addr*, if given, is a ``(local_host, local_port)`` tuple used to bind "

"the socket to locally. The *local_host* and *local_port* are looked up "

"using :meth:`getaddrinfo`."

msgstr ""

"*local_addr*, si está dado, es una tupla ``(local_host, local_port)`` usada "

"para enlazar el socket localmente. Los *local_host* y *local_port* son "

"buscados utilizando :meth:`getaddrinfo`."

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

msgid ""

"*remote_addr*, if given, is a ``(remote_host, remote_port)`` tuple used to "

"connect the socket to a remote address. The *remote_host* and *remote_port* "

"are looked up using :meth:`getaddrinfo`."

msgstr ""

"*remote_addr*, si está dado, es una tupla ``(remote_host, remote_port)`` "

"utilizada para conectar el socket a una dirección remota. Los *remote_host* "

"y *remote_port* son buscados utilizando :meth:`getaddrinfo`."

#: ../Doc/library/asyncio-eventloop.rst:528

msgid ""

"*family*, *proto*, *flags* are the optional address family, protocol and "

"flags to be passed through to :meth:`getaddrinfo` for *host* resolution. If "

"given, these should all be integers from the corresponding :mod:`socket` "

"module constants."

msgstr ""

"*family*, *proto*, *flags* son direcciones de familia, protocolo y banderas "

"opcionales que serán pasadas a través de :meth:`getaddrinfo` para la "

"resolución de *host*. Si está dado, estos deben ser todos enteros de las "

"constantes del módulo :mod:`socket` correspondiente."

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

msgid ""

"*reuse_port* tells the kernel to allow this endpoint to be bound to the same "

"port as other existing endpoints are bound to, so long as they all set this "

"flag when being created. This option is not supported on Windows and some "

"Unixes. If the :py:data:`~socket.SO_REUSEPORT` constant is not defined then "

"this capability is unsupported."

msgstr ""

"*reuse_port* dice al kernel que habilite este punto de conexión para ser "

"unido al mismo puerto de la misma forma que otros puntos de conexión "

"existentes también están unidos, siempre y cuando todos ellos establezcan "

"esta bandera al ser creados. Esta opción no es soportada en Windows y "

"algunos sistemas Unix. Si la constante :py:data:`~socket.SO_REUSEPORT` no "

"está definida entonces esta funcionalidad no es soportada."

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

msgid ""

"*allow_broadcast* tells the kernel to allow this endpoint to send messages "

"to the broadcast address."

msgstr ""

"*allow_broadcast* dice al kernel que habilite este punto de conexión para "

"enviar mensajes a la dirección de transmisión (*broadcast*)."

#: ../Doc/library/asyncio-eventloop.rst:542

msgid ""

"*sock* can optionally be specified in order to use a preexisting, already "

"connected, :class:`socket.socket` object to be used by the transport. If "

"specified, *local_addr* and *remote_addr* should be omitted (must be :const:"

"`None`)."

msgstr ""

"*sock* puede opcionalmente ser especificado para usar un objeto :class:"

"`socket.socket` preexistente y ya conectado que será utilizado por el "

"transporte. Si están especificados, *local_addr* y *remote_addr* deben ser "

"omitidos (tienen que ser :const:`None`)."

#: ../Doc/library/asyncio-eventloop.rst:547

msgid ""

"See :ref:`UDP echo client protocol <asyncio-udp-echo-client-protocol>` and :"

"ref:`UDP echo server protocol <asyncio-udp-echo-server-protocol>` examples."