concurrent.futures.po

# 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: 2023-11-04 23:12+0100\n"
"Last-Translator: Marcos Medrano <marcosmedrano0@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"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"Generated-By: Babel 2.13.0\n"
"X-Generator: Poedit 3.4\n"

#: ../Doc/library/concurrent.futures.rst:2
msgid ":mod:`concurrent.futures` --- Launching parallel tasks"
msgstr ":mod:`concurrent.futures` --- Lanzamiento de tareas paralelas"

#: ../Doc/library/concurrent.futures.rst:9
msgid ""
"**Source code:** :source:`Lib/concurrent/futures/thread.py` and :source:`Lib/"
"concurrent/futures/process.py`"
msgstr ""
"**Código fuente:** :source:`Lib/concurrent/futures/thread.py` y :source:`Lib/"
"concurrent/futures/process.py`"

#: ../Doc/library/concurrent.futures.rst:14
msgid ""
"The :mod:`concurrent.futures` module provides a high-level interface for "
"asynchronously executing callables."
msgstr ""
"El módulo :mod:`concurrent.futures` provee una interfaz de alto nivel para "
"ejecutar invocables de forma asincrónica."

#: ../Doc/library/concurrent.futures.rst:17
msgid ""
"The asynchronous execution can be performed with threads, using :class:"
"`ThreadPoolExecutor`, or separate processes, using :class:"
"`ProcessPoolExecutor`.  Both implement the same interface, which is defined "
"by the abstract :class:`Executor` class."
msgstr ""
"La ejecución asincrónica se puede realizar mediante hilos, usando :class:"
"`ThreadPoolExecutor`, o procesos independientes, mediante :class:"
"`ProcessPoolExecutor`. Ambos implementan la misma interfaz, que se encuentra "
"definida por la clase abstracta :class:`Executor`."

#: ../Doc/includes/wasm-notavail.rst:3
msgid ":ref:`Availability <availability>`: not Emscripten, not WASI."
msgstr ":ref:`Disponibilidad <availability>`: no Emscripten, no WASI."

#: ../Doc/includes/wasm-notavail.rst:5
msgid ""
"This module does not work or is not available on WebAssembly platforms "
"``wasm32-emscripten`` and ``wasm32-wasi``. See :ref:`wasm-availability` for "
"more information."
msgstr ""
"Este módulo no funciona o no está disponible en las plataformas WebAssembly "
"``wasm32-emscripten`` y ``wasm32-wasi``. Consulte :ref:`wasm-availability` "
"para obtener más información."

#: ../Doc/library/concurrent.futures.rst:25
msgid "Executor Objects"
msgstr "Objetos ejecutores"

#: ../Doc/library/concurrent.futures.rst:29
msgid ""
"An abstract class that provides methods to execute calls asynchronously.  It "
"should not be used directly, but through its concrete subclasses."
msgstr ""
"Una clase abstracta que proporciona métodos para ejecutar llamadas de forma "
"asincrónica. No debe ser utilizada directamente, sino a través de sus "
"subclases."

#: ../Doc/library/concurrent.futures.rst:34
msgid ""
"Schedules the callable, *fn*, to be executed as ``fn(*args, **kwargs)`` and "
"returns a :class:`Future` object representing the execution of the "
"callable. ::"
msgstr ""
"Programa la invocación de *fn*, que será ejecutada como ``fn(*args, "
"**kwargs)`` y retorna un objeto :class:`Future` que representa la ejecución "
"del invocable. ::"

#: ../Doc/library/concurrent.futures.rst:44
msgid "Similar to :func:`map(func, *iterables) <map>` except:"
msgstr "Similar a :func:`map(func, *iterables) <map>` excepto que:"

#: ../Doc/library/concurrent.futures.rst:46
msgid "the *iterables* are collected immediately rather than lazily;"
msgstr ""
"los *iterables* son recolectados inmediatamente, en lugar de perezosamente;"

#: ../Doc/library/concurrent.futures.rst:48
msgid ""
"*func* is executed asynchronously and several calls to *func* may be made "
"concurrently."
msgstr ""
"*func* se ejecuta de forma asincrónica y se pueden realizar varias llamadas "
"a *func* simultáneamente."

#: ../Doc/library/concurrent.futures.rst:51
msgid ""
"The returned iterator raises a :exc:`TimeoutError` if :meth:`~iterator."
"__next__` is called and the result isn't available after *timeout* seconds "
"from the original call to :meth:`Executor.map`. *timeout* can be an int or a "
"float.  If *timeout* is not specified or ``None``, there is no limit to the "
"wait time."
msgstr ""
"El iterador retornado lanza :exc:`TimeoutError` si :meth:`~iterator."
"__next__` es llamado y el resultado no está disponible luego de *timeout* "
"segundos luego de la llamada original a :meth:`Executor.map`. *timeout* "
"puede ser un int o un float. Si no se provee un *timeout* o es ``None``, no "
"hay limite de espera."

#: ../Doc/library/concurrent.futures.rst:57
msgid ""
"If a *func* call raises an exception, then that exception will be raised "
"when its value is retrieved from the iterator."
msgstr ""
"Si una llamada a *func* lanza una excepción, dicha excepción va a ser "
"lanzada cuando su valor sea retornado por el iterador."

#: ../Doc/library/concurrent.futures.rst:60
msgid ""
"When using :class:`ProcessPoolExecutor`, this method chops *iterables* into "
"a number of chunks which it submits to the pool as separate tasks.  The "
"(approximate) size of these chunks can be specified by setting *chunksize* "
"to a positive integer.  For very long iterables, using a large value for "
"*chunksize* can significantly improve performance compared to the default "
"size of 1.  With :class:`ThreadPoolExecutor`, *chunksize* has no effect."
msgstr ""
"Al usar :class:`ProcessPoolExecutor`, este método divide los *iterables* en "
"varios fragmentos que luego envía al grupo como tareas separadas. El tamaño "
"(aproximado) de estos fragmentos puede especificarse estableciendo "
"*chunksize* a un entero positivo. El uso de un valor grande para *chunksize* "
"puede mejorar significativamente el rendimiento en comparación con el tamaño "
"predeterminado de 1. Con :class:`ThreadPoolExecutor`, el *chunksize* no "
"tiene ningún efecto."

#: ../Doc/library/concurrent.futures.rst:68
msgid "Added the *chunksize* argument."
msgstr "Se agregó el argumento *chunksize*."

#: ../Doc/library/concurrent.futures.rst:73
msgid ""
"Signal the executor that it should free any resources that it is using when "
"the currently pending futures are done executing.  Calls to :meth:`Executor."
"submit` and :meth:`Executor.map` made after shutdown will raise :exc:"
"`RuntimeError`."
msgstr ""
"Indica al ejecutor que debe liberar todos los recursos que está utilizando "
"cuando los futuros actualmente pendientes de ejecución finalicen. Las "
"llamadas a :meth:`Executor.submit` y :meth:`Executor.map` realizadas después "
"del apagado lanzarán :exc:`RuntimeError`."

#: ../Doc/library/concurrent.futures.rst:78
msgid ""
"If *wait* is ``True`` then this method will not return until all the pending "
"futures are done executing and the resources associated with the executor "
"have been freed.  If *wait* is ``False`` then this method will return "
"immediately and the resources associated with the executor will be freed "
"when all pending futures are done executing.  Regardless of the value of "
"*wait*, the entire Python program will not exit until all pending futures "
"are done executing."
msgstr ""
"Si *wait* es ``True`` este método no retornará hasta que todos los futuros "
"pendientes hayan terminado su ejecución y los recursos asociados al ejecutor "
"hayan sido liberados.  Si *wait* es ``False``, este método retornará de "
"inmediato y los recursos asociados al ejecutor se liberarán cuando todos los "
"futuros asociados hayan finalizado su ejecución. Independientemente del "
"valor de *wait*, el programa Python entero no finalizará hasta que todos los "
"futuros pendientes hayan finalizado su ejecución."

#: ../Doc/library/concurrent.futures.rst:86
msgid ""
"If *cancel_futures* is ``True``, this method will cancel all pending futures "
"that the executor has not started running. Any futures that are completed or "
"running won't be cancelled, regardless of the value of *cancel_futures*."
msgstr ""
"Si *cancel_futures* es ``True``, este método cancelará todos los futuros "
"pendientes que el ejecutor no ha comenzado a ejecutar. Los futuros que se "
"completen o estén en ejecución no se cancelarán, independientemente del "
"valor de *cancel_futures*."

#: ../Doc/library/concurrent.futures.rst:91
msgid ""
"If both *cancel_futures* and *wait* are ``True``, all futures that the "
"executor has started running will be completed prior to this method "
"returning. The remaining futures are cancelled."
msgstr ""
"Si tanto *cancel_futures* como *wait* son ``True``, todos los futuros que el "
"ejecutor ha comenzado a ejecutar se completarán antes de que regrese este "
"método. Los futuros restantes se cancelan."

#: ../Doc/library/concurrent.futures.rst:95
msgid ""
"You can avoid having to call this method explicitly if you use the :keyword:"
"`with` statement, which will shutdown the :class:`Executor` (waiting as if :"
"meth:`Executor.shutdown` were called with *wait* set to ``True``)::"
msgstr ""
"Se puede evitar tener que llamar este método explícitamente si se usa la "
"sentencia :keyword:`with`, la cual apagará el :class:`Executor` (esperando "
"como si :meth:`Executor.shutdown` hubiera sido llamado con *wait* en "
"``True``)::"

#: ../Doc/library/concurrent.futures.rst:107
msgid "Added *cancel_futures*."
msgstr "Agregado *cancel_futures*."

#: ../Doc/library/concurrent.futures.rst:112
msgid "ThreadPoolExecutor"
msgstr "ThreadPoolExecutor"

#: ../Doc/library/concurrent.futures.rst:114
msgid ""
":class:`ThreadPoolExecutor` is an :class:`Executor` subclass that uses a "
"pool of threads to execute calls asynchronously."
msgstr ""
":class:`ThreadPoolExecutor` es una subclase de :class:`Executor` que usa un "
"grupo de hilos para ejecutar llamadas de forma asincrónica."

#: ../Doc/library/concurrent.futures.rst:117
msgid ""
"Deadlocks can occur when the callable associated with a :class:`Future` "
"waits on the results of another :class:`Future`.  For example::"
msgstr ""
"Pueden ocurrir bloqueos mutuos cuando la llamada asociada a un :class:"
"`Future` espera el resultado de otro :class:`Future`. Por ejemplo::"

#: ../Doc/library/concurrent.futures.rst:136
msgid "And::"
msgstr "Y::"

#: ../Doc/library/concurrent.futures.rst:150
msgid ""
"An :class:`Executor` subclass that uses a pool of at most *max_workers* "
"threads to execute calls asynchronously."
msgstr ""
"Subclase de :class:`Executor` que utiliza un grupo de hilos de *max_workers* "
"como máximo para ejecutar llamadas de forma asincrónica."

#: ../Doc/library/concurrent.futures.rst:153
msgid ""
"All threads enqueued to ``ThreadPoolExecutor`` will be joined before the "
"interpreter can exit. Note that the exit handler which does this is executed "
"*before* any exit handlers added using ``atexit``. This means exceptions in "
"the main thread must be caught and handled in order to signal threads to "
"exit gracefully. For this reason, it is recommended that "
"``ThreadPoolExecutor`` not be used for long-running tasks."
msgstr ""
"Todos los hilos que se hayan puesto en cola en ``ThreadPoolExecutor`` se "
"unirán antes de que el intérprete pueda salir. Tenga en cuenta que el "
"controlador de salida que hace esto se ejecuta *antes* de cualquier "
"controlador de salida añadido mediante ``atexit``. Esto significa que las "
"excepciones en el hilo principal deben ser capturadas y manejadas para "
"indicar a los hilos que salgan correctamente. Por esta razón, se recomienda "
"no utilizar ``ThreadPoolExecutor`` para tareas de larga duración."

#: ../Doc/library/concurrent.futures.rst:160
msgid ""
"*initializer* is an optional callable that is called at the start of each "
"worker thread; *initargs* is a tuple of arguments passed to the "
"initializer.  Should *initializer* raise an exception, all currently pending "
"jobs will raise a :exc:`~concurrent.futures.thread.BrokenThreadPool`, as "
"well as any attempt to submit more jobs to the pool."
msgstr ""
"*initializer* es un invocable opcional que es llamado al comienzo de cada "
"hilo de trabajo; *initargs* es una tupla de argumentos pasados al "
"inicializador.  Si el *initializer* lanza una excepción, todos los trabajos "
"actualmente pendientes lanzarán :exc:`~concurrent.futures.thread."
"BrokenThreadPool`, así como cualquier intento de enviar más trabajos al "
"grupo."

#: ../Doc/library/concurrent.futures.rst:166
msgid ""
"If *max_workers* is ``None`` or not given, it will default to the number of "
"processors on the machine, multiplied by ``5``, assuming that :class:"
"`ThreadPoolExecutor` is often used to overlap I/O instead of CPU work and "
"the number of workers should be higher than the number of workers for :class:"
"`ProcessPoolExecutor`."
msgstr ""
"Si *max_workers* es ``None`` o no es especificado, se tomará por defecto el "
"número de procesadores de la máquina, multiplicado por ``5``, asumiendo que :"
"class:`ThreadPoolExecutor` a menudo se utiliza para paralelizar E/S en lugar "
"de trabajo de CPU y que el numero de trabajadores debe ser mayor que el "
"número de trabajadores para :class:`ProcessPoolExecutor`."

#: ../Doc/library/concurrent.futures.rst:174
msgid ""
"The *thread_name_prefix* argument was added to allow users to control the :"
"class:`threading.Thread` names for worker threads created by the pool for "
"easier debugging."
msgstr ""
"El argumento *thread_name_prefix* fue añadido para permitir al usuario "
"controlar los nombres asignados a los :class:`threading.Thread` creados por "
"el grupo para facilitar la depuración del programa."

#: ../Doc/library/concurrent.futures.rst:179
#: ../Doc/library/concurrent.futures.rst:282
msgid "Added the *initializer* and *initargs* arguments."
msgstr "Se agregaron los argumentos *initializer* y *initargs*."

#: ../Doc/library/concurrent.futures.rst:182
msgid ""
"Default value of *max_workers* is changed to ``min(32, os.cpu_count() + "
"4)``. This default value preserves at least 5 workers for I/O bound tasks. "
"It utilizes at most 32 CPU cores for CPU bound tasks which release the GIL. "
"And it avoids using very large resources implicitly on many-core machines."
msgstr ""
"El valor predeterminado de *max_workers* fue reemplazado por ``min(32, os."
"cpu_count() + 4)``. Este valor predeterminado conserva al menos 5 "
"trabajadores para las tareas vinculadas de E/S. Utiliza como máximo 32 "
"núcleos de CPU para tareas vinculadas a la CPU que liberan el GIL. Y evita "
"utilizar recursos muy grandes implícitamente en máquinas de muchos núcleos."

#: ../Doc/library/concurrent.futures.rst:188
msgid ""
"ThreadPoolExecutor now reuses idle worker threads before starting "
"*max_workers* worker threads too."
msgstr ""
"ThreadPoolExecutor ahora también reutiliza hilos inactivos antes de crear "
"*max_workers* hilos de trabajo."

#: ../Doc/library/concurrent.futures.rst:195
msgid "ThreadPoolExecutor Example"
msgstr "Ejemplo de ThreadPoolExecutor"

#: ../Doc/library/concurrent.futures.rst:227
msgid "ProcessPoolExecutor"
msgstr "ProcessPoolExecutor"

#: ../Doc/library/concurrent.futures.rst:229
msgid ""
"The :class:`ProcessPoolExecutor` class is an :class:`Executor` subclass that "
"uses a pool of processes to execute calls asynchronously. :class:"
"`ProcessPoolExecutor` uses the :mod:`multiprocessing` module, which allows "
"it to side-step the :term:`Global Interpreter Lock <global interpreter "
"lock>` but also means that only picklable objects can be executed and "
"returned."
msgstr ""
"La clase :class:`ProcessPoolExecutor` es una subclase :class:`Executor` que "
"usa un grupo de procesos para ejecutar llamadas de forma asíncrona. :class:"
"`ProcessPoolExecutor` usa el módulo :mod:`multiprocessing`, que le permite "
"eludir el :term:`Global Interpreter Lock <global interpreter lock>` pero "
"también significa que solo los objetos seleccionables pueden ser ejecutados "
"y retornados."

#: ../Doc/library/concurrent.futures.rst:236
msgid ""
"The ``__main__`` module must be importable by worker subprocesses. This "
"means that :class:`ProcessPoolExecutor` will not work in the interactive "
"interpreter."
msgstr ""
"El módulo ``__main__`` debe ser importable por los subprocesos trabajadores. "
"Esto significa que :class:`ProcessPoolExecutor` no funcionará en el "
"intérprete interactivo."

#: ../Doc/library/concurrent.futures.rst:239
msgid ""
"Calling :class:`Executor` or :class:`Future` methods from a callable "
"submitted to a :class:`ProcessPoolExecutor` will result in deadlock."
msgstr ""
"Llamar a métodos de :class:`Executor` o :class:`Future` desde el invocable "
"enviado a :class:`ProcessPoolExecutor` resultará en bloqueos mutuos."

#: ../Doc/library/concurrent.futures.rst:244
msgid ""
"An :class:`Executor` subclass that executes calls asynchronously using a "
"pool of at most *max_workers* processes.  If *max_workers* is ``None`` or "
"not given, it will default to the number of processors on the machine. If "
"*max_workers* is less than or equal to ``0``, then a :exc:`ValueError` will "
"be raised. On Windows, *max_workers* must be less than or equal to ``61``. "
"If it is not then :exc:`ValueError` will be raised. If *max_workers* is "
"``None``, then the default chosen will be at most ``61``, even if more "
"processors are available. *mp_context* can be a :mod:`multiprocessing` "
"context or ``None``. It will be used to launch the workers. If *mp_context* "
"is ``None`` or not given, the default :mod:`multiprocessing` context is "
"used. See :ref:`multiprocessing-start-methods`."
msgstr ""
"Subclase de :class:`Executor` que ejecuta llamadas asincrónicas mediante un "
"grupo de, como máximo, *max_workers* procesos. Si *max_workers* es ``None`` "
"o no fue especificado, el número predeterminado será la cantidad de "
"procesadores de la máquina, Si *max_workers* es menor o igual a ``0``, la "
"excepción :exc:`ValueError` será lanzada. En Windows, *max_workers* debe ser "
"menor o igual a ``61``. Si no es así, la excepción :exc:`ValueError` será "
"lanzada. Si *max_workers* es ``None``, el número predeterminado será ``61`` "
"como máximo, aún si existen más procesadores disponibles. *mp_context* puede "
"ser un contexto de :mod:`multiprocessing` o ``None`` y será utilizado para "
"iniciar los trabajadores. Si *mp_context* es ``None`` o no es especificado, "
"se utilizará el contexto predeterminado de :mod:`multiprocessing`. Consulte :"
"ref:`multiprocessing-start-methods` para más información."

#: ../Doc/library/concurrent.futures.rst:258
msgid ""
"*initializer* is an optional callable that is called at the start of each "
"worker process; *initargs* is a tuple of arguments passed to the "
"initializer.  Should *initializer* raise an exception, all currently pending "
"jobs will raise a :exc:`~concurrent.futures.process.BrokenProcessPool`, as "
"well as any attempt to submit more jobs to the pool."
msgstr ""
"*initializer* es un invocable opcional que es llamado al comienzo de cada "
"proceso trabajador; *initargs* es una tupla de argumentos pasados al "
"inicializador. Si el *initializer* lanza una excepción, todos los trabajos "
"actualmente pendientes lanzarán :exc:`~concurrent.futures.thread."
"BrokenProcessPool`, así como cualquier intento de enviar más trabajos al "
"grupo."

#: ../Doc/library/concurrent.futures.rst:264
msgid ""
"*max_tasks_per_child* is an optional argument that specifies the maximum "
"number of tasks a single process can execute before it will exit and be "
"replaced with a fresh worker process. By default *max_tasks_per_child* is "
"``None`` which means worker processes will live as long as the pool. When a "
"max is specified, the \"spawn\" multiprocessing start method will be used by "
"default in absence of a *mp_context* parameter. This feature is incompatible "
"with the \"fork\" start method."
msgstr ""
"*max_tasks_per_child* es un argumento opcional que especifica el número "
"máximo de tareas que un único proceso puede ejecutar antes de salir y ser "
"reemplazado por un nuevo proceso de trabajo. Por defecto, "
"*max_tasks_per_child* es ``None``, lo que significa que los procesos de "
"trabajo vivirán tanto como el pool. Cuando se especifica un máximo, el "
"método de inicio de multiprocesamiento \"spawn\" se utilizará por defecto en "
"ausencia de un parámetro *mp_context*. Esta característica es incompatible "
"con el método de inicio \"fork\"."

#: ../Doc/library/concurrent.futures.rst:272
msgid ""
"When one of the worker processes terminates abruptly, a :exc:"
"`BrokenProcessPool` error is now raised.  Previously, behaviour was "
"undefined but operations on the executor or its futures would often freeze "
"or deadlock."
msgstr ""
"Cuando uno de los procesos finaliza abruptamente, se lanzará :exc:"
"`BrokenProcessPool`. Anteriormente, el comportamiento no estaba definido, "
"pero las operaciones en el ejecutor o sus futuros a menudo se detenían o "
"bloqueaban mutuamente."

#: ../Doc/library/concurrent.futures.rst:278
msgid ""
"The *mp_context* argument was added to allow users to control the "
"start_method for worker processes created by the pool."
msgstr ""
"El argumento *mp_context* se agregó para permitir a los usuarios controlar "
"el método de iniciación para procesos de trabajo creados en el grupo."

#: ../Doc/library/concurrent.futures.rst:285
msgid ""
"The default :mod:`multiprocessing` start method (see :ref:`multiprocessing-"
"start-methods`) will change away from *fork* in Python 3.14.  Code that "
"requires *fork* be used for their :class:`ProcessPoolExecutor` should "
"explicitly specify that by passing a ``mp_context=multiprocessing."
"get_context(\"fork\")`` parameter."
msgstr ""
"El método de inicio por defecto de :mod:`multiprocessing` (ver :ref:"
"`multiprocessing-start-methods`) dejará de ser *fork* en Python 3.14. El "
"código que requiera el uso de *fork* para su :class:`ProcessPoolExecutor` "
"debe especificarlo explícitamente pasando un parámetro "
"``mp_context=multiprocessing.get_context(\"fork\")``."

#: ../Doc/library/concurrent.futures.rst:292
msgid ""
"The *max_tasks_per_child* argument was added to allow users to control the "
"lifetime of workers in the pool."
msgstr ""
"El argumento *max_tasks_per_child* se agregó para permitir a los usuarios "
"controlar el tiempo de vida para procesos de trabajo creados en el grupo."

#: ../Doc/library/concurrent.futures.rst:296
msgid ""
"On POSIX systems, if your application has multiple threads and the :mod:"
"`multiprocessing` context uses the ``\"fork\"`` start method: The :func:`os."
"fork` function called internally to spawn workers may raise a :exc:"
"`DeprecationWarning`. Pass a *mp_context* configured to use a different "
"start method. See the :func:`os.fork` documentation for further explanation."
msgstr ""
"En sistemas POSIX, si su aplicación tiene múltiples hilos y el contexto :mod:"
"`multiprocessing` utiliza el método de inicio ``\"fork\"``: La función :func:"
"`os.fork` llamada internamente para generar trabajadores puede lanzar un "
"mensaje :exc:`DeprecationWarning`. Pase un *mp_context* configurado para "
"utilizar un método de inicio diferente. Consulte la documentación de :func:"
"`os.fork` para más información."

#: ../Doc/library/concurrent.futures.rst:307
msgid "ProcessPoolExecutor Example"
msgstr "Ejemplo de *ProcessPoolExecutor*"

#: ../Doc/library/concurrent.futures.rst:345
msgid "Future Objects"
msgstr "Objetos futuro"

#: ../Doc/library/concurrent.futures.rst:347
msgid ""
"The :class:`Future` class encapsulates the asynchronous execution of a "
"callable. :class:`Future` instances are created by :meth:`Executor.submit`."
msgstr ""
"La clase :class:`Future` encapsula la ejecución asincrónica del invocable. "
"Las instancias de :class:`Future` son creadas por :meth:`Executor.submit`."

#: ../Doc/library/concurrent.futures.rst:352
msgid ""
"Encapsulates the asynchronous execution of a callable.  :class:`Future` "
"instances are created by :meth:`Executor.submit` and should not be created "
"directly except for testing."
msgstr ""
"Encapsula la ejecución asincrónica del invocable. Las instancias de :class:"
"`Future` son creadas por :meth:`Executor.submit` y no deberían ser creadas "
"directamente, excepto para pruebas."

#: ../Doc/library/concurrent.futures.rst:358
msgid ""
"Attempt to cancel the call.  If the call is currently being executed or "
"finished running and cannot be cancelled then the method will return "
"``False``, otherwise the call will be cancelled and the method will return "
"``True``."
msgstr ""
"Intenta cancelar la llamada.  Si el invocable está siendo ejecutado o ha "
"finalizado su ejecución y no puede ser cancelado el método retornará "
"``False``, de lo contrario la llamada será cancelada y el método retornará "
"``True``."

#: ../Doc/library/concurrent.futures.rst:365
msgid "Return ``True`` if the call was successfully cancelled."
msgstr "Retorna ``True`` si la llamada fue cancelada exitosamente."

#: ../Doc/library/concurrent.futures.rst:369
msgid ""
"Return ``True`` if the call is currently being executed and cannot be "
"cancelled."
msgstr ""
"Retorna ``True`` si la llamada está siendo ejecutada y no puede ser "
"cancelada."

#: ../Doc/library/concurrent.futures.rst:374
msgid ""
"Return ``True`` if the call was successfully cancelled or finished running."
msgstr ""
"Retorna ``True`` si la llamada fue cancelada exitosamente o terminó su "
"ejecución."

#: ../Doc/library/concurrent.futures.rst:379
msgid ""
"Return the value returned by the call. If the call hasn't yet completed then "
"this method will wait up to *timeout* seconds.  If the call hasn't completed "
"in *timeout* seconds, then a :exc:`TimeoutError` will be raised. *timeout* "
"can be an int or float.  If *timeout* is not specified or ``None``, there is "
"no limit to the wait time."
msgstr ""
"Retorna el valor retornado por la llamada. Si la llamada aún no se ha "
"completado, este método esperará hasta *timeout* segundos. Si la llamada no "
"se ha completado en *timeout* segundos, entonces se lanzará un :exc:"
"`TimeoutError`. *timeout* puede ser un int o un float. Si *timeout* no se "
"especifica o es ``None``, no hay límite para el tiempo de espera."

#: ../Doc/library/concurrent.futures.rst:386
#: ../Doc/library/concurrent.futures.rst:400
msgid ""
"If the future is cancelled before completing then :exc:`.CancelledError` "
"will be raised."
msgstr ""
"Si el futuro es cancelado antes de finalizar su ejecución, :exc:`."
"CancelledError` será lanzada."

#: ../Doc/library/concurrent.futures.rst:389
msgid ""
"If the call raised an exception, this method will raise the same exception."
msgstr ""
"Si la llamada lanzó una excepción, este método lanzará la misma excepción."

#: ../Doc/library/concurrent.futures.rst:393
msgid ""
"Return the exception raised by the call.  If the call hasn't yet completed "
"then this method will wait up to *timeout* seconds.  If the call hasn't "
"completed in *timeout* seconds, then a :exc:`TimeoutError` will be raised.  "
"*timeout* can be an int or float.  If *timeout* is not specified or "
"``None``, there is no limit to the wait time."
msgstr ""
"Retorna la excepción lanzada por la llamada. Si la llamada aún no se ha "
"completado, este método esperará hasta *timeout* segundos. Si la llamada no "
"se ha completado en *timeout* segundos, entonces se lanzará un :exc:"
"`TimeoutError`. *timeout* puede ser un int o un float. Si *timeout* no se "
"especifica o es ``None``, no hay límite para el tiempo de espera."

#: ../Doc/library/concurrent.futures.rst:403
msgid "If the call completed without raising, ``None`` is returned."
msgstr "Si la llamada es completada sin excepciones, se retornará ```None``."

#: ../Doc/library/concurrent.futures.rst:407
msgid ""
"Attaches the callable *fn* to the future.  *fn* will be called, with the "
"future as its only argument, when the future is cancelled or finishes "
"running."
msgstr ""
"Asocia el invocable *fn* al futuro. *fn* va a ser llamada, con el futuro "
"como su único argumento, cuando el futuro sea cancelado o finalice su "
"ejecución."

#: ../Doc/library/concurrent.futures.rst:411
msgid ""
"Added callables are called in the order that they were added and are always "
"called in a thread belonging to the process that added them.  If the "
"callable raises an :exc:`Exception` subclass, it will be logged and "
"ignored.  If the callable raises a :exc:`BaseException` subclass, the "
"behavior is undefined."
msgstr ""
"Los invocables agregados se llaman en el orden en que se agregaron y siempre "
"se llaman en un hilo que pertenece al proceso que los agregó. Si el "
"invocable genera una subclase :exc:`Exception`, se registrará y se ignorará. "
"Si el invocable genera una subclase :exc:`BaseException`, el comportamiento "
"no está definido."

#: ../Doc/library/concurrent.futures.rst:417
msgid ""
"If the future has already completed or been cancelled, *fn* will be called "
"immediately."
msgstr ""
"Si el futuro ya ha finalizado su ejecución o fue cancelado, *fn* retornará "
"inmediatamente."

#: ../Doc/library/concurrent.futures.rst:420
msgid ""
"The following :class:`Future` methods are meant for use in unit tests and :"
"class:`Executor` implementations."
msgstr ""
"Los siguientes métodos de :class:`Future` están pensados para ser usados en "
"pruebas unitarias e implementaciones de :class:`Executor`."

#: ../Doc/library/concurrent.futures.rst:425
msgid ""
"This method should only be called by :class:`Executor` implementations "
"before executing the work associated with the :class:`Future` and by unit "
"tests."
msgstr ""
"Este método sólo debe ser llamado en implementaciones de :class:`Executor` "
"antes de ejecutar el trabajo asociado al :class:`Future` y por las pruebas "
"unitarias."

#: ../Doc/library/concurrent.futures.rst:429
msgid ""
"If the method returns ``False`` then the :class:`Future` was cancelled, i."
"e. :meth:`Future.cancel` was called and returned ``True``.  Any threads "
"waiting on the :class:`Future` completing (i.e. through :func:`as_completed` "
"or :func:`wait`) will be woken up."
msgstr ""
"Si el método retorna ``False`` entonces el :class:`Future` fue cancelado, es "
"decir, :meth:`Future.cancel` fue llamado y retornó ``True``. Cualquier hilo "
"que esté esperando a que el :class:`Future` se complete (es decir, a través "
"de :func:`as_completed` o :func:`wait`) será despertado."

#: ../Doc/library/concurrent.futures.rst:434
msgid ""
"If the method returns ``True`` then the :class:`Future` was not cancelled "
"and has been put in the running state, i.e. calls to :meth:`Future.running` "
"will return ``True``."
msgstr ""
"Si el método retorna ``True`` entonces el :class:`Future` no se ha cancelado "
"y se ha puesto en estado de ejecución, es decir, las llamadas a :meth:"
"`Future.running`` retornarán ``True``."

#: ../Doc/library/concurrent.futures.rst:438
msgid ""
"This method can only be called once and cannot be called after :meth:`Future."
"set_result` or :meth:`Future.set_exception` have been called."
msgstr ""
"Este método solo puede ser llamado una sola vez y no puede ser llamado luego "
"de haber llamado a :meth:`Future.set_result` o a :meth:`Future."
"set_exception`."

#: ../Doc/library/concurrent.futures.rst:444
msgid ""
"Sets the result of the work associated with the :class:`Future` to *result*."
msgstr ""
"Establece *result* como el resultado del trabajo asociado al :class:`Future`."

#: ../Doc/library/concurrent.futures.rst:447
#: ../Doc/library/concurrent.futures.rst:460
msgid ""
"This method should only be used by :class:`Executor` implementations and "
"unit tests."
msgstr ""
"Este método solo debe ser usado por implementaciones de :class:`Executor` y "
"pruebas unitarias."

#: ../Doc/library/concurrent.futures.rst:450
#: ../Doc/library/concurrent.futures.rst:463
msgid ""
"This method raises :exc:`concurrent.futures.InvalidStateError` if the :class:"
"`Future` is already done."
msgstr ""
"Este método lanza :exc:`concurrent.futures.InvalidStateError` si :class:"
"`Future` ya ha finalizado su ejecución."

#: ../Doc/library/concurrent.futures.rst:457
msgid ""
"Sets the result of the work associated with the :class:`Future` to the :"
"class:`Exception` *exception*."
msgstr ""
"Establece *exception*, subclase de :class:`Exception`, como el resultado del "
"trabajo asociado al :class:`Future`."

#: ../Doc/library/concurrent.futures.rst:469
msgid "Module Functions"
msgstr "Funciones del módulo"

#: ../Doc/library/concurrent.futures.rst:473
msgid ""
"Wait for the :class:`Future` instances (possibly created by different :class:"
"`Executor` instances) given by *fs* to complete. Duplicate futures given to "
"*fs* are removed and will be returned only once. Returns a named 2-tuple of "
"sets.  The first set, named ``done``, contains the futures that completed "
"(finished or cancelled futures) before the wait completed.  The second set, "
"named ``not_done``, contains the futures that did not complete (pending or "
"running futures)."
msgstr ""
"Espera a que se completen las instancias :class:`Future` (posiblemente "
"creadas por diferentes instancias :class:`Executor`) dadas por *fs*. Los "
"futuros duplicados dados a *fs* se eliminan y sólo se devolverán una vez. "
"Retorna una tupla nombrada de 2 conjuntos. El primer conjunto, llamado "
"``done``, contiene los futuros que se han completado (futuros finalizados o "
"cancelados) antes de que se complete la espera. El segundo conjunto, llamado "
"``not_done``, contiene los futuros que no se completaron (futuros pendientes "
"o en ejecución)."

#: ../Doc/library/concurrent.futures.rst:481
msgid ""
"*timeout* can be used to control the maximum number of seconds to wait "
"before returning.  *timeout* can be an int or float.  If *timeout* is not "
"specified or ``None``, there is no limit to the wait time."
msgstr ""
"El argumento *timeout* puede ser usado para controlar la espera máxima en "
"segundos antes de retornar.  *timeout* puede ser un int o un float.  Si "
"*timeout* no es especificado o es ``None``, no hay limite en el tiempo de "
"espera."

#: ../Doc/library/concurrent.futures.rst:485
msgid ""
"*return_when* indicates when this function should return.  It must be one of "
"the following constants:"
msgstr ""
"*return_when* indica cuando debe retornar esta función.  Debe ser alguna de "
"las siguientes constantes:"

#: ../Doc/library/concurrent.futures.rst:491
msgid "Constant"
msgstr "Constante"

#: ../Doc/library/concurrent.futures.rst:491
msgid "Description"
msgstr "Descripción"

#: ../Doc/library/concurrent.futures.rst:493
msgid ":const:`FIRST_COMPLETED`"
msgstr ":const:`FIRST_COMPLETED`"

#: ../Doc/library/concurrent.futures.rst:493
msgid "The function will return when any future finishes or is cancelled."
msgstr "La función retornará cuando cualquier futuro finalice o sea cancelado."

#: ../Doc/library/concurrent.futures.rst:496
msgid ":const:`FIRST_EXCEPTION`"
msgstr ":const:`FIRST_EXCEPTION`"

#: ../Doc/library/concurrent.futures.rst:496
msgid ""
"The function will return when any future finishes by raising an exception.  "
"If no future raises an exception then it is equivalent to :const:"
"`ALL_COMPLETED`."
msgstr ""
"La función retornará cuando cualquier futuro finalice lanzando una "
"excepción. Si ningún futuro lanza una excepción, esta opción es equivalente "
"a :const:`ALL_COMPLETED`."

#: ../Doc/library/concurrent.futures.rst:502
msgid ":const:`ALL_COMPLETED`"
msgstr ":const:`ALL_COMPLETED`"

#: ../Doc/library/concurrent.futures.rst:502
msgid "The function will return when all futures finish or are cancelled."
msgstr ""
"La función retornará cuando todos los futuros finalicen o sean cancelados."

#: ../Doc/library/concurrent.futures.rst:508
msgid ""
"Returns an iterator over the :class:`Future` instances (possibly created by "
"different :class:`Executor` instances) given by *fs* that yields futures as "
"they complete (finished or cancelled futures). Any futures given by *fs* "
"that are duplicated will be returned once. Any futures that completed "
"before :func:`as_completed` is called will be yielded first.  The returned "
"iterator raises a :exc:`TimeoutError` if :meth:`~iterator.__next__` is "
"called and the result isn't available after *timeout* seconds from the "
"original call to :func:`as_completed`.  *timeout* can be an int or float. If "
"*timeout* is not specified or ``None``, there is no limit to the wait time."
msgstr ""
"Retorna un iterador sobre las instancias de :class:`Future` (posiblemente "
"creadas por distintas instancias de :class:`Executor`) dadas por *fs* que "
"produce futuros a medida que van finalizando (normalmente o cancelados). "
"Cualquier futuro dado por *fs* que esté duplicado será retornado una sola "
"vez. Los futuros que hayan finalizado antes de la llamada a :func:"
"`as_completed` serán entregados primero. El iterador retornado lanzará :exc:"
"`TimeoutError` si :meth:`~iterator.__next__` es llamado y el resultado no "
"está disponible luego de *timeout* segundos a partir de la llamada original "
"a :func:`as_completed`. *timeout* puede ser un int o un float. Si *timeout* "
"no es especificado o es ``None``, no hay límite en el tiempo de espera."

#: ../Doc/library/concurrent.futures.rst:522
msgid ":pep:`3148` -- futures - execute computations asynchronously"
msgstr ":pep:`3148` -- futuros - ejecutar cómputos asincrónicamente"

#: ../Doc/library/concurrent.futures.rst:522
msgid ""
"The proposal which described this feature for inclusion in the Python "
"standard library."
msgstr ""
"La propuesta que describe esta propuesta de inclusión en la biblioteca "
"estándar de Python."

#: ../Doc/library/concurrent.futures.rst:527
msgid "Exception classes"
msgstr "Clases de Excepciones"

#: ../Doc/library/concurrent.futures.rst:533
msgid "Raised when a future is cancelled."
msgstr "Lanzada cuando un futuro es cancelado."

#: ../Doc/library/concurrent.futures.rst:537
msgid ""
"A deprecated alias of :exc:`TimeoutError`, raised when a future operation "
"exceeds the given timeout."
msgstr ""
"Un alias obsoleto de :exc:`TimeoutError`, lanzado cuando una operación en un "
"futuro excede el tiempo de espera dado."

#: ../Doc/library/concurrent.futures.rst:542
msgid "This class was made an alias of :exc:`TimeoutError`."
msgstr "Esta clase se convirtió en un alias de :exc:`TimeoutError`."

#: ../Doc/library/concurrent.futures.rst:547
msgid ""
"Derived from :exc:`RuntimeError`, this exception class is raised when an "
"executor is broken for some reason, and cannot be used to submit or execute "
"new tasks."
msgstr ""
"Derivada de :exc:`RuntimeError`, esta excepción es lanzada cuando un "
"ejecutor se encuentra corrupto por algún motivo y no puede ser utilizado "
"para enviar o ejecutar nuevas tareas."

#: ../Doc/library/concurrent.futures.rst:555
msgid ""
"Raised when an operation is performed on a future that is not allowed in the "
"current state."
msgstr ""
"Lanzada cuando una operación es realizada sobre un futuro que no permite "
"dicha operación en el estado actual."

#: ../Doc/library/concurrent.futures.rst:564
msgid ""
"Derived from :exc:`~concurrent.futures.BrokenExecutor`, this exception class "
"is raised when one of the workers of a :class:`ThreadPoolExecutor` has "
"failed initializing."
msgstr ""
"Derivada de :exc:`~concurrent.futures.BrokenExecutor`, esta excepción es "
"lanzada cuando uno de los trabajadores de :class:`ThreadPoolExecutor` ha "
"fallado en su inicialización."

#: ../Doc/library/concurrent.futures.rst:574
msgid ""
"Derived from :exc:`~concurrent.futures.BrokenExecutor` (formerly :exc:"
"`RuntimeError`), this exception class is raised when one of the workers of "
"a :class:`ProcessPoolExecutor` has terminated in a non-clean fashion (for "
"example, if it was killed from the outside)."
msgstr ""
"Derivada de :exc:`~concurrent.futures.BrokenExecutor` (previamente :exc:"
"`RuntimeError`), esta excepción es lanzada cuando uno de los trabajadores "
"de :class:`ProcessPoolExecutor` ha finalizado de forma abrupta (por ejemplo, "
"al ser terminado desde afuera del proceso)."