# 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: 2022-01-25 13:19+0100\n"

"PO-Revision-Date: 2021-08-07 17:05+0200\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.9.1\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/library/concurrent.futures.rst:24

msgid "Executor Objects"

msgstr "Objetos Ejecutores"

#: ../Doc/library/concurrent.futures.rst:28

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:33

#, fuzzy

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:43

msgid "Similar to :func:`map(func, *iterables) <map>` except:"

msgstr "Similar a :func:`map(func, *iterables) <map>` excepto que:"

#: ../Doc/library/concurrent.futures.rst:45

msgid "the *iterables* are collected immediately rather than lazily;"

msgstr ""

"los *iterables* son recolectados inmediatamente, en lugar de perezosamente;"

#: ../Doc/library/concurrent.futures.rst:47

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:50

msgid ""

"The returned iterator raises a :exc:`concurrent.futures.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:`concurrent.futures.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:56

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:59

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:67

msgid "Added the *chunksize* argument."

msgstr "Se agregó el argumento *chunksize*."

#: ../Doc/library/concurrent.futures.rst:72

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:77

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:85

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:90

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:94

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:106

msgid "Added *cancel_futures*."

msgstr "Agregado *cancel_futures*."

#: ../Doc/library/concurrent.futures.rst:111

msgid "ThreadPoolExecutor"

msgstr "ThreadPoolExecutor"

#: ../Doc/library/concurrent.futures.rst:113

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:116

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:135

msgid "And::"

msgstr "Y::"

#: ../Doc/library/concurrent.futures.rst:149

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:152

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:158

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:166

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:171

#: ../Doc/library/concurrent.futures.rst:265

msgid "Added the *initializer* and *initargs* arguments."

msgstr "Se agregaron los argumentos *initializer* y *initargs*."

#: ../Doc/library/concurrent.futures.rst:174

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:180

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:187

msgid "ThreadPoolExecutor Example"

msgstr "Ejemplo de ThreadPoolExecutor"

#: ../Doc/library/concurrent.futures.rst:219

msgid "ProcessPoolExecutor"

msgstr "ProcessPoolExecutor"

#: ../Doc/library/concurrent.futures.rst:221

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:228

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:231

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:236

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 multiprocessing context or "

"None. It will be used to launch the workers. If *mp_context* is ``None`` or "

"not given, the default multiprocessing context is used."

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 multiprocesamiento o ``None`` y será utilizado para "

"iniciar los trabajadores. Si *mp_context* es ``None`` o no es especificado, "

"se utilizará el contexto predeterminado de multiprocesamiento."

#: ../Doc/library/concurrent.futures.rst:249

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:255

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:261

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:271

msgid "ProcessPoolExecutor Example"

msgstr "Ejemplo de *ProcessPoolExecutor*"

#: ../Doc/library/concurrent.futures.rst:309

msgid "Future Objects"

msgstr "Objetos Futuro"

#: ../Doc/library/concurrent.futures.rst:311

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:316

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:322

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:329

msgid "Return ``True`` if the call was successfully cancelled."

msgstr "Retorna ``True`` si la llamada fue cancelada exitosamente."

#: ../Doc/library/concurrent.futures.rst:333

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:338

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:343

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:`concurrent.futures.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 ha "

"finalizado, el método esperará un total de *timeout* segundos. Si la llamada "

"no ha finalizado luego de *timeout* segundos, :exc:`concurrent.futures."

"TimeoutError` será lanzada. *timeout* puede ser un int o un float. Si "

"*timeout* es ``None`` o no fue especificado, no hay limite de espera."

#: ../Doc/library/concurrent.futures.rst:350

#: ../Doc/library/concurrent.futures.rst:364

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:353

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:357

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:`concurrent.futures."

"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 ha "

"finalizado, el método esperará un máximo de *timeout* segundos. Si la "

"llamada aún no ha finalizado luego de *timeout* segundos, entonces :exc:"

"`concurrent.futures.TimeoutError` será lanzada. *timeout* puede ser un int o "

"un float. Si *timeout* es ``None`` o no es especificado, no hay limite en el "

"tiempo de espera."

#: ../Doc/library/concurrent.futures.rst:367

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:371

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:375

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:381

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:384

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:389

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:393

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 :class:`Future` fue cancelado. i.e. :"

"meth:`Future.cancel` fue llamado y retornó `True`. Todos los hilos esperando "

"la finalización del :class:`Future` (i.e. a través de :func:`as_completed` "

"o :func:`wait`) serán despertados."

#: ../Doc/library/concurrent.futures.rst:398

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 fue cancelado "

"y ha sido colocado en estado de ejecución, i.e. las llamadas a :meth:`Future."

"running` retornarán `True`."

#: ../Doc/library/concurrent.futures.rst:402

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:408

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:411

#: ../Doc/library/concurrent.futures.rst:424

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:414

#: ../Doc/library/concurrent.futures.rst:427

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:421

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:433

msgid "Module Functions"

msgstr "Funciones del Módulo"

#: ../Doc/library/concurrent.futures.rst:437

#, fuzzy

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 la finalización de las instancias de :class:`Future` (posiblemente "

"creadas por distintas instancias de :class:`Executor`) dadas por *fs*. "

"Retorna una tupla nombrada de 2 conjuntos. El primer conjunto, llamado "

"``done``, contiene los futuros que finalizaron su ejecución (producto de su "

"finalización normal o su cancelación) antes del tiempo de espera "

"especificado. El segundo conjunto, llamado ``not_done``, contiene los "

"futuros que no finalizaron su ejecución (pueden estar pendientes o "

"ejecutándose en ese momento)."

#: ../Doc/library/concurrent.futures.rst:445

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:449

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:455

msgid "Constant"

msgstr "Constante"

#: ../Doc/library/concurrent.futures.rst:455

msgid "Description"

msgstr "Descripción"

#: ../Doc/library/concurrent.futures.rst:457

msgid ":const:`FIRST_COMPLETED`"

msgstr ":const:`FIRST_COMPLETED`"

#: ../Doc/library/concurrent.futures.rst:457

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:460

msgid ":const:`FIRST_EXCEPTION`"

msgstr ":const:`FIRST_EXCEPTION`"

#: ../Doc/library/concurrent.futures.rst:460

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:466

msgid ":const:`ALL_COMPLETED`"

msgstr ":const:`ALL_COMPLETED`"

#: ../Doc/library/concurrent.futures.rst:466

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:472

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:`concurrent.futures.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:"

"`concurrent.futures.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 limite en el "

"tiempo de espera."

#: ../Doc/library/concurrent.futures.rst:486

msgid ":pep:`3148` -- futures - execute computations asynchronously"

msgstr ":pep:`3148` -- futuros - ejecutar cómputos asincrónicamente"

#: ../Doc/library/concurrent.futures.rst:486

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:491

msgid "Exception classes"

msgstr "Clases de Excepciones"

#: ../Doc/library/concurrent.futures.rst:497

msgid "Raised when a future is cancelled."

msgstr "Lanzada cuando un futuro es cancelado."

#: ../Doc/library/concurrent.futures.rst:501

msgid "Raised when a future operation exceeds the given timeout."

msgstr "Lanzada cuando un futuro excede el tiempo de espera máximo."

#: ../Doc/library/concurrent.futures.rst:505

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:513

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:522

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:532

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)."