From be380a0460ef91c4d0a514e7be9d2465c0c08cde Mon Sep 17 00:00:00 2001 From: Maria Jose Molina Date: Mon, 29 Jun 2020 12:49:19 +0200 Subject: [PATCH 1/7] traducido library/multiprocessing.po closes #299 --- dict | 48 ++ library/multiprocessing.po | 1527 ++++++++++++++++++++++++++++++++---- 2 files changed, 1427 insertions(+), 148 deletions(-) diff --git a/dict b/dict index 965b536be8..45850a80f9 100644 --- a/dict +++ b/dict @@ -6,12 +6,19 @@ Adler Ahlstrom Alex Android +asincrónico +asincrónicos Associates +atómicamente +autenticación +autentificación Autocompletado Awk B +bidireccional BSD Boddie +booleano Brian Built C @@ -19,16 +26,24 @@ CPU Cameron Chapman Circus +clon Cocoa +comando +comandos Comos Compaq Cookbook Ctrl Cython +Desafortunadamente Distutils Distutils +dúplex +etc FLTK Fibonacci +finalización +finalizador Finder Flags Flying @@ -44,9 +59,12 @@ Hammond Hat Hat Henstridge +heredable +heredables Hewlett Hugunin I +Implementación Index Interesantemente Java @@ -113,6 +131,7 @@ Tkinter Tutorial Unicode Unix +unix Usenet VM WWW @@ -157,6 +176,8 @@ comilla command compilada computacionalmente +conectable +configúrelo consolelib corrutina corrutinas @@ -164,6 +185,7 @@ criptográficamente curses customización customizarlo +customizables códec datagramas debugueando @@ -178,7 +200,9 @@ descompresor deserialización deserializar desinstalador +deshabilitará desreferenciación +desreferenciar desreferenciarlas dict dinámicamente @@ -192,11 +216,13 @@ enrutamiento entendible enumerador env +escribible ésimo especificador estáticamente except exclude +explícitamente exponenciación exit f @@ -218,6 +244,7 @@ host i idiomáticas if +implementación implementadores import imports @@ -274,6 +301,7 @@ metadatos metadatos mezclarlos mini +miscelánea modularidad monoespaciada mortem @@ -282,6 +310,8 @@ multi multicast multihilo multilínea +multiproceso +multiprocesos multiprocesamiento mutex mxBase @@ -294,12 +324,14 @@ option or os pads +paralelizar parsea parseada parsear permitiéndole permutaciones personalizadamente +pid pip podés polimórfica @@ -313,9 +345,11 @@ post posteriori precompilado predeclarando +presumiblemente prompt prompts proxy +proxies pseudo py pyc @@ -329,7 +363,10 @@ recompilación recompilada recompilar recompilarse +recursión recursivamente +recursivo +recurrencia redefinido redefinidos redefinir @@ -361,13 +398,19 @@ search secuencialmente seguirle self +seleccionables semánticamente +semialeatorio +semialeatoria serializa +serializable +serializables serialización serializados serializar shell sincronización +sincronizaciones singleton sintácticamente situ @@ -393,6 +436,8 @@ submódulo submódulos subpaquete subpaquetes +subproceso +subprocesos subsecuencias subíndices sys @@ -417,6 +462,7 @@ txt uid unices unicode +unidireccional uninstall urllib vía @@ -433,4 +479,6 @@ xz ydel zipimporter zip +zombie +zombies zlib \ No newline at end of file diff --git a/library/multiprocessing.po b/library/multiprocessing.po index 2d43c0990f..2d2e6302a4 100644 --- a/library/multiprocessing.po +++ b/library/multiprocessing.po @@ -6,31 +6,33 @@ # Check https://github.com/PyCampES/python-docs-es/blob/3.8/TRANSLATORS to # get the list of volunteers # -#, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" -"Last-Translator: FULL NAME \n" +"PO-Revision-Date: 2020-06-28 22:50+0200\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" -"Content-Type: text/plain; charset=utf-8\n" +"Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 2.8.0\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" +"Last-Translator: \n" +"Language: es_ES\n" +"X-Generator: Poedit 2.3.1\n" #: ../Doc/library/multiprocessing.rst:2 msgid ":mod:`multiprocessing` --- Process-based parallelism" -msgstr "" +msgstr ":mod:`multiprocessing` ---Proceso-basado en paralelismo" #: ../Doc/library/multiprocessing.rst:7 msgid "**Source code:** :source:`Lib/multiprocessing/`" -msgstr "" +msgstr "**Source code:** :source:`Lib/multiprocessing/`" #: ../Doc/library/multiprocessing.rst:12 msgid "Introduction" -msgstr "" +msgstr "Introducción" #: ../Doc/library/multiprocessing.rst:14 msgid "" @@ -42,6 +44,14 @@ msgid "" "programmer to fully leverage multiple processors on a given machine. It " "runs on both Unix and Windows." msgstr "" +":mod:`multiprocessing` es un paquete que admite procesos de generación " +"(*spawning*) utilizando una API similar al módulo :mod:`threading`. El " +"paquete :mod:`multiprocessing` ofrece concurrencia tanto local como remota, " +"esquivando el término `:term:`Global Interpreter Lock` mediante el uso de " +"subprocesos en lugar de hilos (*threads*). Debido a esto, el módulo :mod:" +"`multiprocessing` le permite al programador aprovechar al máximo múltiples " +"procesadores en una máquina determinada. Se ejecuta tanto en Unix como en " +"Windows." #: ../Doc/library/multiprocessing.rst:22 msgid "" @@ -55,14 +65,23 @@ msgid "" "module. This basic example of data parallelism using :class:" "`~multiprocessing.pool.Pool`, ::" msgstr "" +"El módulo :mod:`multiprocessing` también introduce API que no tienen " +"análogos en el módulo :mod:`threading`. Un buen ejemplo de esto es el " +"objeto :class:`~multiprocessing.pool.Pool` que ofrece un medio conveniente " +"de paralelizar la ejecución de una función a través de múltiples valores de " +"entrada, distribuyendo los datos de entrada a través de procesos " +"(paralelismo de datos). El siguiente ejemplo demuestra la práctica común de " +"definir tales funciones en un módulo para que los procesos secundarios " +"puedan importar con éxito ese módulo. Este ejemplo básico de paralelismo de " +"datos usando :class:`~multiprocessing.pool.Pool`, ::" #: ../Doc/library/multiprocessing.rst:40 msgid "will print to standard output ::" -msgstr "" +msgstr "imprimirá la salida estándar ::" #: ../Doc/library/multiprocessing.rst:46 msgid "The :class:`Process` class" -msgstr "" +msgstr "La clase :class:`Process`" #: ../Doc/library/multiprocessing.rst:48 msgid "" @@ -71,31 +90,41 @@ msgid "" "`Process` follows the API of :class:`threading.Thread`. A trivial example " "of a multiprocess program is ::" msgstr "" +"En :mod:`multiprocessing`, los procesos se generan creando un objeto :class:" +"`Process` y luego llamando a su método :meth:`~Process.start` . :class:" +"`Process` sigue la API de :class:`threading.Thread`. Un ejemplo trivial de " +"un programa multiproceso es ::" #: ../Doc/library/multiprocessing.rst:63 msgid "" "To show the individual process IDs involved, here is an expanded example::" msgstr "" +"Para mostrar las IDs individuales involucradas en el proceso, aquí hay un " +"ejemplo ampliado::" #: ../Doc/library/multiprocessing.rst:84 msgid "" "For an explanation of why the ``if __name__ == '__main__'`` part is " "necessary, see :ref:`multiprocessing-programming`." msgstr "" +"Para obtener una explicación de por qué es necesaria la parte ``if __name__ " +"== ‘__main__’`` , consulte :ref:`multiprocessing-programming`." #: ../Doc/library/multiprocessing.rst:90 msgid "Contexts and start methods" -msgstr "" +msgstr "Contextos y métodos de inicio" #: ../Doc/library/multiprocessing.rst:94 msgid "" "Depending on the platform, :mod:`multiprocessing` supports three ways to " "start a process. These *start methods* are" msgstr "" +"Dependiendo de la plataforma, :mod:`multiprocessing` admite tres formas de " +"iniciar un proceso. Estos métodos de inicio *start methods* son" #: ../Doc/library/multiprocessing.rst:105 msgid "*spawn*" -msgstr "" +msgstr "Generación (*spawn*)" #: ../Doc/library/multiprocessing.rst:98 msgid "" @@ -106,14 +135,20 @@ msgid "" "Starting a process using this method is rather slow compared to using *fork* " "or *forkserver*." msgstr "" +"El proceso parental inicia un nuevo proceso de intérprete de Python. El " +"proceso hijo solo heredará los recursos necesarios para ejecutar los objetos " +"del método :meth:`~Process.run`. En particular, no se heredarán los " +"descriptores de archivo innecesarios y los identificadores del proceso " +"principal. Iniciar un proceso usando este método es bastante lento en " +"comparación con el uso de *fork* o *forkserver*." #: ../Doc/library/multiprocessing.rst:105 msgid "Available on Unix and Windows. The default on Windows and macOS." -msgstr "" +msgstr "Disponible en Unix y Windows. Por defecto en Windows y macOS." #: ../Doc/library/multiprocessing.rst:114 msgid "*fork*" -msgstr "" +msgstr "*fork*" #: ../Doc/library/multiprocessing.rst:108 msgid "" @@ -122,14 +157,19 @@ msgid "" "process. All resources of the parent are inherited by the child process. " "Note that safely forking a multithreaded process is problematic." msgstr "" +"El proceso parental usa :func:`os.fork` para bifurcar el intérprete de " +"Python. El proceso hijo, cuando comienza, es efectivamente idéntico al " +"proceso parental. Todos los recursos del proceso parental son heredados por " +"el proceso hijo. Tenga en cuenta que bifurcar (*forking*) de forma segura un " +"proceso multihilo es problemático." #: ../Doc/library/multiprocessing.rst:114 msgid "Available on Unix only. The default on Unix." -msgstr "" +msgstr "Disponible solo en Unix. Por defecto en Unix." #: ../Doc/library/multiprocessing.rst:125 msgid "*forkserver*" -msgstr "" +msgstr "*forkserver*" #: ../Doc/library/multiprocessing.rst:117 msgid "" @@ -139,12 +179,20 @@ msgid "" "process. The fork server process is single threaded so it is safe for it to " "use :func:`os.fork`. No unnecessary resources are inherited." msgstr "" +"Cuando el programa se inicia y selecciona el método de inicio *forkserver*, " +"se inicia un proceso de servidor. A partir de ese momento, cada vez que se " +"necesite un nuevo proceso, el proceso parental se conecta al servidor y " +"solicita que bifurque un nuevo proceso. El proceso del servidor *fork* es de " +"un solo hilo, por lo que es seguro usarlo :func:`os.fork`. No se heredan " +"recursos innecesarios." #: ../Doc/library/multiprocessing.rst:124 msgid "" "Available on Unix platforms which support passing file descriptors over Unix " "pipes." msgstr "" +"Disponible en plataformas Unix que admiten pasar descriptores de archivo a " +"través de tuberías (*pipes*) Unix." #: ../Doc/library/multiprocessing.rst:129 msgid "" @@ -152,13 +200,20 @@ msgid "" "method should be considered unsafe as it can lead to crashes of the " "subprocess. See :issue:`33725`." msgstr "" +"En macOS, el método de inicio *spawn* ahora es el predeterminado. El método " +"de inicio *fork* debe considerarse inseguro ya que puede provocar bloqueos " +"del subproceso. Consulte :issue:`33725`." #: ../Doc/library/multiprocessing.rst:133 msgid "" -"*spawn* added on all unix platforms, and *forkserver* added for some unix " +"*spawn* added on all Unix platforms, and *forkserver* added for some Unix " "platforms. Child processes no longer inherit all of the parents inheritable " "handles on Windows." msgstr "" +"*spawn* fue añadido en todas las plataformas Unix, y *forkserver* fue " +"agregado para algunas plataformas Unix. Los procesos hijos (*child " +"processes*) ya no heredan todos los identificadores heredables de los " +"procesos parentales en Windows." #: ../Doc/library/multiprocessing.rst:139 msgid "" @@ -174,17 +229,33 @@ msgid "" "a limited number of named semaphores, and shared memory segments occupy some " "space in the main memory.)" msgstr "" +"En Unix, los métodos de inicio *spawn* o *forkserver* también iniciarán un " +"proceso *resource tracker* que rastrea los recursos del sistema con nombre " +"no vinculados (como los nombrados semáforos o objetos :class:" +"`~multiprocessing.shared_memory.SharedMemory`) creado por procesos del " +"programa. Cuando todos los procesos han salido, el rastreador de recursos " +"desvincula cualquier objeto rastreado restante. Por lo general, no debería " +"haber ninguno, pero si un proceso fue eliminado por una señal, puede haber " +"algunos recursos “filtrados”. (Ni los semáforos filtrados ni los segmentos " +"de memoria compartida se desvincularán automáticamente hasta el próximo " +"reinicio. Esto es problemático para ambos objetos porque el sistema solo " +"permite un número limitado de semáforos con nombre, y los segmentos de " +"memoria compartida ocupan algo de espacio en la memoria principal)." #: ../Doc/library/multiprocessing.rst:152 msgid "" "To select a start method you use the :func:`set_start_method` in the ``if " "__name__ == '__main__'`` clause of the main module. For example::" msgstr "" +"Para seleccionar un método de inicio, utilice la función :func:" +"`set_start_method` en la cláusula ``if __name__ == '__main__'`` del módulo " +"principal. Por ejemplo::" #: ../Doc/library/multiprocessing.rst:169 msgid "" ":func:`set_start_method` should not be used more than once in the program." msgstr "" +":func:`set_start_method` no debería ser usada más de una vez en el programa." #: ../Doc/library/multiprocessing.rst:172 msgid "" @@ -192,6 +263,10 @@ msgid "" "Context objects have the same API as the multiprocessing module, and allow " "one to use multiple start methods in the same program. ::" msgstr "" +"Alternativamente, se puede usar :func:`get_context` para obtener un objeto " +"de contexto. Los objetos de contexto tienen la misma API que el módulo de " +"multiprocesamiento, y permiten utilizar múltiples métodos de inicio en el " +"mismo programa. ::" #: ../Doc/library/multiprocessing.rst:190 msgid "" @@ -200,12 +275,19 @@ msgid "" "*fork* context cannot be passed to processes started using the *spawn* or " "*forkserver* start methods." msgstr "" +"Tenga en cuenta que los objetos relacionados con un contexto pueden no ser " +"compatibles con procesos para un contexto diferente. En particular, los " +"*locks* creados con el contexto *fork* no se pueden pasar a los procesos " +"iniciados con los métodos de inicio *spawn* o *forkserver* ." #: ../Doc/library/multiprocessing.rst:195 msgid "" "A library which wants to use a particular start method should probably use :" "func:`get_context` to avoid interfering with the choice of the library user." msgstr "" +"Una biblioteca que quiera usar un método de inicio particular probablemente " +"debería usar :func:`get_context` para evitar interferir con la elección del " +"usuario de la biblioteca." #: ../Doc/library/multiprocessing.rst:201 msgid "" @@ -214,40 +296,51 @@ msgid "" "**PyInstaller** and **cx_Freeze**) on Unix. The ``'fork'`` start method does " "work." msgstr "" +"Los métodos de inicio ``’spawn’`` y ``’forkserver’`` actualmente no se " +"pueden usar con ejecutables “congelados”(*“frozen”*)(es decir, binarios " +"producidos por paquetes como **PyInstaller** y **cx_Freeze**) en Unix. El " +"método de inicio ``’fork’`` funciona." #: ../Doc/library/multiprocessing.rst:208 msgid "Exchanging objects between processes" -msgstr "" +msgstr "Intercambiando objetos entre procesos" #: ../Doc/library/multiprocessing.rst:210 msgid "" ":mod:`multiprocessing` supports two types of communication channel between " "processes:" msgstr "" +":mod:`multiprocessing` admite dos tipos de canales de comunicación entre " +"procesos:" #: ../Doc/library/multiprocessing.rst:213 msgid "**Queues**" -msgstr "" +msgstr "**Colas (*queues*)**" #: ../Doc/library/multiprocessing.rst:215 msgid "" "The :class:`Queue` class is a near clone of :class:`queue.Queue`. For " "example::" msgstr "" +"La clase :class:`Queue` es prácticamente un clon de :class:`queue.Queue`. " +"Por ejemplo::" #: ../Doc/library/multiprocessing.rst:230 msgid "Queues are thread and process safe." -msgstr "" +msgstr "Las colas (*queues*) son hilos y procesos seguro." #: ../Doc/library/multiprocessing.rst:232 msgid "**Pipes**" -msgstr "" +msgstr "**Tuberías (*tuberías*)**" #: ../Doc/library/multiprocessing.rst:234 msgid "" "The :func:`Pipe` function returns a pair of connection objects connected by " "a pipe which by default is duplex (two-way). For example::" msgstr "" +"La función :func:`Pipe` retorna un par de objetos de conexión conectados por " +"una tubería (*pipe*) que, por defecto, es un dúplex (bidireccional). Por " +"ejemplo::" #: ../Doc/library/multiprocessing.rst:250 msgid "" @@ -258,10 +351,17 @@ msgid "" "the *same* end of the pipe at the same time. Of course there is no risk of " "corruption from processes using different ends of the pipe at the same time." msgstr "" +"Los dos objetos de conexión retornados por :func:`Pipe` representan los dos " +"extremos de la tubería (*pipe*). Cada objeto de conexión tiene los métodos :" +"meth:`~Connection.send` y :meth:`~Connection.recv` (entre otros). Tenga en " +"cuenta que los datos en una tubería pueden corromperse si dos procesos (o " +"hilos) intentan leer o escribir en el *mismo* (*same*) extremo de la tubería " +"al mismo tiempo. Por supuesto, no hay riesgo de corrupción por procesos que " +"utilizan diferentes extremos de la tubería (*pipe*) al mismo tiempo." #: ../Doc/library/multiprocessing.rst:260 msgid "Synchronization between processes" -msgstr "" +msgstr "Sincronización entre procesos" #: ../Doc/library/multiprocessing.rst:262 msgid "" @@ -269,16 +369,22 @@ msgid "" "primitives from :mod:`threading`. For instance one can use a lock to ensure " "that only one process prints to standard output at a time::" msgstr "" +":mod:`multiprocessing` contiene equivalentes de todas las sincronizaciones " +"primitivas de :mod:`threading`. Por ejemplo, se puede usar un candado " +"(*lock*) para garantizar que solo un proceso se imprima a la salida estándar " +"a la vez::" #: ../Doc/library/multiprocessing.rst:281 msgid "" "Without using the lock output from the different processes is liable to get " "all mixed up." msgstr "" +"Sin usar el candado (*lock*) de salida de los diferentes procesos, es " +"probable que todo se mezcle." #: ../Doc/library/multiprocessing.rst:286 msgid "Sharing state between processes" -msgstr "" +msgstr "Compartiendo estado entre procesos" #: ../Doc/library/multiprocessing.rst:288 msgid "" @@ -286,27 +392,35 @@ msgid "" "avoid using shared state as far as possible. This is particularly true when " "using multiple processes." msgstr "" +"Como se mencionó anteriormente, cuando se realiza una programación " +"concurrente, generalmente es mejor evitar el uso del estado compartido en la " +"medida de lo posible. Esto es particularmente cierto cuando se utilizan " +"múltiples procesos." #: ../Doc/library/multiprocessing.rst:292 msgid "" "However, if you really do need to use some shared data then :mod:" "`multiprocessing` provides a couple of ways of doing so." msgstr "" +"Sin embargo, si usted realmente necesita usar algunos datos compartidos el :" +"mod:`multiprocessing` proporciona un par de maneras de hacerlo." #: ../Doc/library/multiprocessing.rst:295 msgid "**Shared memory**" -msgstr "" +msgstr "**Shared memory**" #: ../Doc/library/multiprocessing.rst:297 msgid "" "Data can be stored in a shared memory map using :class:`Value` or :class:" "`Array`. For example, the following code ::" msgstr "" +"Los datos se pueden almacenar en un mapa de memoria compartida usando :class:" +"`Value` o :class:`Array`. Por ejemplo, el siguiente código ::" #: ../Doc/library/multiprocessing.rst:318 #: ../Doc/library/multiprocessing.rst:364 msgid "will print ::" -msgstr "" +msgstr "imprimirá ::" #: ../Doc/library/multiprocessing.rst:323 msgid "" @@ -315,6 +429,10 @@ msgid "" "double precision float and ``'i'`` indicates a signed integer. These shared " "objects will be process and thread-safe." msgstr "" +"Los argumentos `` ‘d’ ‘’ y ``'i'``utilizados al crear `` num ‘’ y `` arr ‘’ " +"son códigos de tipo del tipo utilizado por: mod: `array` module:` `’ d’`` " +"indica un flotador de doble precisión y `` ‘i’`` indica un entero con signo. " +"Estos objetos compartidos serán seguros para procesos y subprocesos." #: ../Doc/library/multiprocessing.rst:328 msgid "" @@ -322,10 +440,13 @@ msgid "" "`multiprocessing.sharedctypes` module which supports the creation of " "arbitrary ctypes objects allocated from shared memory." msgstr "" +"Para una mayor flexibilidad en el uso de la memoria compartida, se puede " +"usar el módulo :mod:`multiprocessing.sharedctypes` que admite la creación " +"arbitraria de objetos *ctypes* asignados desde la memoria compartida." #: ../Doc/library/multiprocessing.rst:332 msgid "**Server process**" -msgstr "" +msgstr "**Proceso servidor (*Server process*)**" #: ../Doc/library/multiprocessing.rst:334 msgid "" @@ -333,6 +454,9 @@ msgid "" "holds Python objects and allows other processes to manipulate them using " "proxies." msgstr "" +"Un objeto de administrador retornado por :func:`Manager` controla un proceso " +"de servidor que contiene objetos de Python y permite que otros procesos los " +"manipulen usando *proxies*." #: ../Doc/library/multiprocessing.rst:338 msgid "" @@ -342,6 +466,11 @@ msgid "" "`Event`, :class:`Barrier`, :class:`Queue`, :class:`Value` and :class:" "`Array`. For example, ::" msgstr "" +"Un administrador retornado por :func:`Manager` soportará tipos de clases " +"como :class:`list`, :class:`dict`, :class:`~managers.Namespace`, :class:" +"`Lock`, :class:`RLock`, :class:`Semaphore`, :class:`BoundedSemaphore`, :" +"class:`Condition`, :class:`Event`, :class:`Barrier`, :class:`Queue`, :class:" +"`Value` y :class:`Array`. Por ejemplo, ::" #: ../Doc/library/multiprocessing.rst:369 msgid "" @@ -350,10 +479,15 @@ msgid "" "manager can be shared by processes on different computers over a network. " "They are, however, slower than using shared memory." msgstr "" +"Los administradores de procesos del servidor son más flexibles que el uso de " +"objetos de memoria compartida porque pueden hacerse para admitir tipos de " +"objetos arbitrarios. Por lo tanto, un solo administrador puede ser " +"compartido por procesos en diferentes ordenadores a través de una red. Sin " +"embargo, son más lentos que usar memoria compartida." #: ../Doc/library/multiprocessing.rst:376 msgid "Using a pool of workers" -msgstr "" +msgstr "Usando una piscina de trabajadores (*pool of workers*)" #: ../Doc/library/multiprocessing.rst:378 msgid "" @@ -361,16 +495,21 @@ msgid "" "processes. It has methods which allows tasks to be offloaded to the worker " "processes in a few different ways." msgstr "" +"La clase :class:`~multiprocessing.pool.Pool` representa procesos de piscina " +"de trabajadores (*pool of workers*). Tiene métodos que permiten que las " +"tareas se descarguen a los procesos de trabajo de diferentes maneras." #: ../Doc/library/multiprocessing.rst:382 msgid "For example::" -msgstr "" +msgstr "Por ejemplo::" #: ../Doc/library/multiprocessing.rst:426 msgid "" "Note that the methods of a pool should only ever be used by the process " "which created it." msgstr "" +"Tenga en cuenta que los métodos de una piscina (*pool*) solo deben ser " +"utilizados por el proceso que lo creó." #: ../Doc/library/multiprocessing.rst:431 msgid "" @@ -380,6 +519,11 @@ msgid "" "examples, such as the :class:`multiprocessing.pool.Pool` examples will not " "work in the interactive interpreter. For example::" msgstr "" +"La funcionalidad en este paquete requiere que los procesos hijos " +"(*children*) puedan importar el módulo ``__main__``. Esto está cubierto en :" +"ref:`multiprocessing-programming` sin embargo, vale la pena señalarlo aquí. " +"Esto significa que algunos ejemplos, como :class:`multiprocessing.pool.Pool` " +"no funcionarán en el intérprete interactivo. Por ejemplo::" #: ../Doc/library/multiprocessing.rst:454 msgid "" @@ -387,20 +531,25 @@ msgid "" "in a semi-random fashion, and then you may have to stop the parent process " "somehow.)" msgstr "" +"(Si intenta esto, en realidad generará tres trazas completas intercaladas de " +"forma semialeatoria, y luego tendrá que detener el proceso principal de " +"alguna manera)" #: ../Doc/library/multiprocessing.rst:460 msgid "Reference" -msgstr "" +msgstr "Referencia" #: ../Doc/library/multiprocessing.rst:462 msgid "" "The :mod:`multiprocessing` package mostly replicates the API of the :mod:" "`threading` module." msgstr "" +"El paquete :mod:`multiprocessing` mayoritariamente replica la API del " +"módulo :mod:`threading`." #: ../Doc/library/multiprocessing.rst:467 msgid ":class:`Process` and exceptions" -msgstr "" +msgstr ":class:`Process` y excepciones" #: ../Doc/library/multiprocessing.rst:472 msgid "" @@ -408,6 +557,9 @@ msgid "" "class:`Process` class has equivalents of all the methods of :class:" "`threading.Thread`." msgstr "" +"Los objetos de proceso representan la actividad que se ejecuta en un proceso " +"separado. La clase :class:`Process` tiene equivalentes para todos los " +"métodos :class:`threading.Thread`." #: ../Doc/library/multiprocessing.rst:476 msgid "" @@ -422,10 +574,21 @@ msgid "" "``False``. If ``None`` (the default), this flag will be inherited from the " "creating process." msgstr "" +"El constructor siempre debe llamarse con argumentos de palabras clave. " +"*group* siempre debe ser ``None`` ; existe únicamente por compatibilidad " +"con :class:`threading.Thread`. *target* es el objeto invocable a ser llamado " +"por el método :meth:`run()` . El valor predeterminado es ``None``, lo que " +"significa que nada es llamado. *name* es el nombre del proceso (consulte :" +"attr:`name` para más detalles). *args* es la tupla de argumento para la " +"invocación de destino. *kwargs* es un diccionario de argumentos de palabras " +"clave para la invocación de destino. Si se proporciona, el argumento " +"*daemon* solo de palabra clave establece el proceso :attr:`daemon` en " +"``True`` o ``False``. Si ``None`` (el valor predeterminado), este indicador " +"se heredará del proceso de creación." #: ../Doc/library/multiprocessing.rst:487 msgid "By default, no arguments are passed to *target*." -msgstr "" +msgstr "Por defecto, ningún argumento es pasado a *target*." #: ../Doc/library/multiprocessing.rst:489 msgid "" @@ -433,14 +596,17 @@ msgid "" "base class constructor (:meth:`Process.__init__`) before doing anything else " "to the process." msgstr "" +"Si una subclase anula al constructor, debe asegurarse de que invoca al " +"constructor de la clase base (:meth:`Process.__init__`) antes de hacer " +"cualquier otra cosa al proceso." #: ../Doc/library/multiprocessing.rst:493 msgid "Added the *daemon* argument." -msgstr "" +msgstr "Añadido el argumento *daemon*." #: ../Doc/library/multiprocessing.rst:498 msgid "Method representing the process's activity." -msgstr "" +msgstr "Método que representa la actividad del proceso." #: ../Doc/library/multiprocessing.rst:500 msgid "" @@ -449,16 +615,22 @@ msgid "" "argument, if any, with sequential and keyword arguments taken from the " "*args* and *kwargs* arguments, respectively." msgstr "" +"Puede anular este método en una subclase. El método estándar :meth:`run` " +"invoca el objeto invocable pasado al constructor del objeto como argumento " +"objetivo, si lo hay, con argumentos posicionares y de palabras clave tomados " +"de los argumentos *args* y *kwargs*, respectivamente." #: ../Doc/library/multiprocessing.rst:507 msgid "Start the process's activity." -msgstr "" +msgstr "Comienza la actividad del proceso." #: ../Doc/library/multiprocessing.rst:509 msgid "" "This must be called at most once per process object. It arranges for the " "object's :meth:`run` method to be invoked in a separate process." msgstr "" +"Esto debe llamarse como máximo una vez por objeto de proceso. Organiza la " +"invocación del método :meth:`run` del objeto en un proceso separado." #: ../Doc/library/multiprocessing.rst:514 msgid "" @@ -469,22 +641,34 @@ msgid "" "times out. Check the process's :attr:`exitcode` to determine if it " "terminated." msgstr "" +"Si el argumento opcional *timeout* es ``None`` (el valor predeterminado), el " +"método se bloquea hasta que el proceso cuyo método :meth:`join` se llama " +"termina. Si *timeout* es un número positivo, bloquea como máximo *timeout* " +"segundos. Tenga en cuenta que el método retorna ``None`` si su proceso " +"finaliza o si el método agota el tiempo de espera. Verifique el proceso :" +"attr:`exitcode` para determinar si terminó." #: ../Doc/library/multiprocessing.rst:521 msgid "A process can be joined many times." -msgstr "" +msgstr "Un proceso puede unirse muchas veces." #: ../Doc/library/multiprocessing.rst:523 msgid "" "A process cannot join itself because this would cause a deadlock. It is an " "error to attempt to join a process before it has been started." msgstr "" +"Un proceso no puede unirse a sí mismo porque esto provocaría un punto " +"muerto. Es un error intentar unirse a un proceso antes de que se haya " +"iniciado." #: ../Doc/library/multiprocessing.rst:528 msgid "" "The process's name. The name is a string used for identification purposes " "only. It has no semantics. Multiple processes may be given the same name." msgstr "" +"El nombre del proceso. El nombre es una cadena utilizada solo con fines de " +"identificación. No tiene semántica. Múltiples procesos pueden tener el mismo " +"nombre." #: ../Doc/library/multiprocessing.rst:532 msgid "" @@ -493,32 +677,42 @@ msgid "" "`2`:...:N\\ :sub:`k`' is constructed, where each N\\ :sub:`k` is the N-th " "child of its parent." msgstr "" +"El nombre inicial es establecido por el constructor. Si no se proporciona un " +"nombre explícito al constructor, se forma un nombre usando *'Process-N\\ :" +"sub:`1`:N\\ :sub:`2`:...:N\\ :sub:`k* se construye, donde cada *N\\ :sub:" +"`k`* es el *N-enésimo* hijo del parental." #: ../Doc/library/multiprocessing.rst:539 msgid "Return whether the process is alive." -msgstr "" +msgstr "Retorna si el proceso está vivo." #: ../Doc/library/multiprocessing.rst:541 msgid "" "Roughly, a process object is alive from the moment the :meth:`start` method " "returns until the child process terminates." msgstr "" +"Aproximadamente, un objeto de proceso está vivo desde el momento en que el " +"método :meth:`start` retorna hasta que finaliza el proceso hijo." #: ../Doc/library/multiprocessing.rst:546 msgid "" "The process's daemon flag, a Boolean value. This must be set before :meth:" "`start` is called." msgstr "" +"La bandera del proceso *daemon* , es un valor booleano. Esto debe " +"establecerse antes de que :meth:`start` sea llamado." #: ../Doc/library/multiprocessing.rst:549 msgid "The initial value is inherited from the creating process." -msgstr "" +msgstr "El valor inicial se hereda del proceso de creación." #: ../Doc/library/multiprocessing.rst:551 msgid "" "When a process exits, it attempts to terminate all of its daemonic child " "processes." msgstr "" +"Cuando un proceso sale, intenta terminar todos sus procesos demoníacos " +"(*daemonic*) hijos." #: ../Doc/library/multiprocessing.rst:554 msgid "" @@ -528,17 +722,27 @@ msgid "" "Unix daemons or services, they are normal processes that will be terminated " "(and not joined) if non-daemonic processes have exited." msgstr "" +"Tenga en cuenta que un proceso demoníaco (*daemonic*) no puede crear " +"procesos hijos. De lo contrario, un proceso demoníaco (*daemonic*) dejaría a " +"sus hijos huérfanos si se termina cuando finaliza su proceso parental. " +"Además, estos **no** son *daemons* o servicios de Unix, son procesos " +"normales qué finalizarán (y no se unirán) si los procesos no demoníacos han " +"salido." #: ../Doc/library/multiprocessing.rst:560 msgid "" "In addition to the :class:`threading.Thread` API, :class:`Process` objects " "also support the following attributes and methods:" msgstr "" +"Además de API :class:`threading.Thread`, los objetos :class:`Process` " +"también admiten los siguientes atributos y métodos:" #: ../Doc/library/multiprocessing.rst:565 msgid "" "Return the process ID. Before the process is spawned, this will be ``None``." msgstr "" +"Retorna el ID del proceso. Antes de que se genere el proceso, esto será " +"``None``." #: ../Doc/library/multiprocessing.rst:570 msgid "" @@ -546,16 +750,21 @@ msgid "" "terminated. A negative value *-N* indicates that the child was terminated " "by signal *N*." msgstr "" +"El código de salida del hijo. Esto será ``None`` si el proceso aún no ha " +"terminado. Un valor negativo *-N* indica que el hijo fue terminado por la " +"señal *N*." #: ../Doc/library/multiprocessing.rst:576 msgid "The process's authentication key (a byte string)." -msgstr "" +msgstr "La clave de autenticación del proceso (una cadena de bytes)." #: ../Doc/library/multiprocessing.rst:578 msgid "" "When :mod:`multiprocessing` is initialized the main process is assigned a " "random string using :func:`os.urandom`." msgstr "" +"Cuando el :mod:`multiprocessing` se inicializa el proceso principal se le " +"asigna una cadena aleatoria usando :func:`os.urandom`." #: ../Doc/library/multiprocessing.rst:581 msgid "" @@ -563,16 +772,21 @@ msgid "" "authentication key of its parent process, although this may be changed by " "setting :attr:`authkey` to another byte string." msgstr "" +"Cuando se crea un objeto :class:`Process`, este heredará la clave de " +"autenticación de su proceso parental, aunque esto puede cambiarse " +"configurando :attr:`authkey` a otra cadena de bytes." #: ../Doc/library/multiprocessing.rst:585 msgid "See :ref:`multiprocessing-auth-keys`." -msgstr "" +msgstr "Consulte :ref:`multiprocessing-auth-keys`." #: ../Doc/library/multiprocessing.rst:589 msgid "" "A numeric handle of a system object which will become \"ready\" when the " "process ends." msgstr "" +"Un identificador numérico de un objeto del sistema que estará \"listo\" " +"cuando finalice el proceso." #: ../Doc/library/multiprocessing.rst:592 msgid "" @@ -580,6 +794,9 @@ msgid "" "func:`multiprocessing.connection.wait`. Otherwise calling :meth:`join()` is " "simpler." msgstr "" +"Se puede usar este valor si desea esperar varios eventos a la vez usando :" +"func:`multiprocessing.connection.wait`. De lo contrario, llamar a :meth:" +"`join()` es más simple." #: ../Doc/library/multiprocessing.rst:596 msgid "" @@ -587,6 +804,10 @@ msgid "" "``WaitForMultipleObjects`` family of API calls. On Unix, this is a file " "descriptor usable with primitives from the :mod:`select` module." msgstr "" +"En Windows, este es un sistema operativo manejable con la familia de " +"llamadas API ``WaitForSingleObject`` y``WaitForMultipleObjects``. En Unix, " +"este es un descriptor de archivo utilizable con primitivas del módulo :mod:" +"`select`." #: ../Doc/library/multiprocessing.rst:604 msgid "" @@ -594,12 +815,17 @@ msgid "" "on Windows :c:func:`TerminateProcess` is used. Note that exit handlers and " "finally clauses, etc., will not be executed." msgstr "" +"Terminar el proceso. En Unix, esto se hace usando la señal ``SIGTERM``; en " +"Windows se utiliza :c:func:`TerminateProcess` . Tenga en cuenta que los " +"manejadores de salida y finalmente las cláusulas, etc., no se ejecutarán." #: ../Doc/library/multiprocessing.rst:608 msgid "" "Note that descendant processes of the process will *not* be terminated -- " "they will simply become orphaned." msgstr "" +"Tenga en cuenta que los procesos descendientes del proceso *no* finalizarán " +"-- simplemente quedarán huérfanos." #: ../Doc/library/multiprocessing.rst:613 msgid "" @@ -609,10 +835,17 @@ msgid "" "semaphore etc. then terminating it is liable to cause other processes to " "deadlock." msgstr "" +"Si este método se usa cuando el proceso asociado está usando una tubería " +"(*pipe*) o una cola(*queue*), entonces la tubería o la cola pueden " +"corromperse y pueden quedar inutilizables por otro proceso. Del mismo modo, " +"si el proceso ha adquirido un *lock* o un semáforo, etc., su finalización " +"puede provocar el bloqueo de otros procesos." #: ../Doc/library/multiprocessing.rst:621 msgid "Same as :meth:`terminate()` but using the ``SIGKILL`` signal on Unix." msgstr "" +"Siempre como :meth:`terminate()` pero utilizando la señal ``SIGKILL`` en " +"Unix." #: ../Doc/library/multiprocessing.rst:627 msgid "" @@ -621,6 +854,11 @@ msgid "" "running. Once :meth:`close` returns successfully, most other methods and " "attributes of the :class:`Process` object will raise :exc:`ValueError`." msgstr "" +"El cierre del objeto :class:`Process`, libera todos los recursos asociados a " +"él. :exc:`ValueError` se lanza si el proceso subyacente aún se está " +"ejecutando. Una vez :meth:`close` se retorna con éxito, la mayoría de los " +"otros métodos y atributos del objeto :class:`Process` lanzará :exc:" +"`ValueError`." #: ../Doc/library/multiprocessing.rst:635 msgid "" @@ -628,38 +866,46 @@ msgid "" "`terminate` and :attr:`exitcode` methods should only be called by the " "process that created the process object." msgstr "" +"Tenga en cuenta que los métodos :meth:`start`, :meth:`join`, :meth:" +"`is_alive`, :meth:`terminate` y :attr:`exitcode` deberían solo ser llamados " +"por el proceso que creó el objeto del proceso." #: ../Doc/library/multiprocessing.rst:639 msgid "Example usage of some of the methods of :class:`Process`:" -msgstr "" +msgstr "Ejemplo de uso de algunos métodos de la :class:`Process`:" #: ../Doc/library/multiprocessing.rst:660 msgid "The base class of all :mod:`multiprocessing` exceptions." -msgstr "" +msgstr "La clase base de todas las excepciones :mod:`multiprocessing`." #: ../Doc/library/multiprocessing.rst:664 msgid "" "Exception raised by :meth:`Connection.recv_bytes_into()` when the supplied " "buffer object is too small for the message read." msgstr "" +"La excepción :meth:`Connection.recv_bytes_into()` es lanzada cuando el " +"objeto de búfer suministrado es demasiado pequeño para el mensaje leído." #: ../Doc/library/multiprocessing.rst:667 msgid "" "If ``e`` is an instance of :exc:`BufferTooShort` then ``e.args[0]`` will " "give the message as a byte string." msgstr "" +"Si ``e`` es una instancia de :exc:`BufferTooShort` entonces ``e.args[0]`` " +"dará el mensaje como una cadena de *bytes*." #: ../Doc/library/multiprocessing.rst:672 msgid "Raised when there is an authentication error." -msgstr "" +msgstr "Lanzada cuando hay un error de autenticación." #: ../Doc/library/multiprocessing.rst:676 msgid "Raised by methods with a timeout when the timeout expires." msgstr "" +"Lanzada por métodos con un tiempo de espera (*timeout*) cuando este expira." #: ../Doc/library/multiprocessing.rst:679 msgid "Pipes and Queues" -msgstr "" +msgstr "Tuberías (*Pipes*) y Colas (*Queues*)" #: ../Doc/library/multiprocessing.rst:681 msgid "" @@ -667,12 +913,18 @@ msgid "" "communication between processes and avoids having to use any synchronization " "primitives like locks." msgstr "" +"Cuando se usan múltiples procesos, uno generalmente usa el paso de mensajes " +"para la comunicación entre procesos y evita tener que usar primitivas de " +"sincronización como *locks*." #: ../Doc/library/multiprocessing.rst:685 msgid "" "For passing messages one can use :func:`Pipe` (for a connection between two " "processes) or a queue (which allows multiple producers and consumers)." msgstr "" +"Para pasar mensajes se puede usar :func:`Pipe` (para una conexión entre dos " +"procesos) o una cola (*queue*)(que permite múltiples productores y " +"consumidores)." #: ../Doc/library/multiprocessing.rst:688 msgid "" @@ -683,6 +935,12 @@ msgid "" "meth:`~queue.Queue.join` methods introduced into Python 2.5's :class:`queue." "Queue` class." msgstr "" +"Los tipos :class:`Queue`, :class:`SimpleQueue` y :class:`JoinableQueue` son " +"colas multi-productor, multi-consumidor :abbr:`FIFO (first-in, first-out) " +"(primero en entrar, primero en salir) modeladas en :class:`queue.Queue` en " +"la biblioteca estándar. Se diferencian en que :class:`Queue` carece de :meth:" +"`~queue.Queue.task_done` y :meth:`~queue.Queue.join` métodos introducidos en " +"Python 2.5 :class:`queue.Queue` class." #: ../Doc/library/multiprocessing.rst:695 msgid "" @@ -691,12 +949,18 @@ msgid "" "semaphore used to count the number of unfinished tasks may eventually " "overflow, raising an exception." msgstr "" +"Si usa :class:`JoinableQueue`, entonces **debe** llamar a :meth:" +"`JoinableQueue.task_done` para cada tarea eliminada de la cola (*queue*) o " +"de lo contrario el semáforo utilizado para contar el número de tareas sin " +"terminar puede eventualmente desbordarse, lanzando un excepción." #: ../Doc/library/multiprocessing.rst:700 msgid "" "Note that one can also create a shared queue by using a manager object -- " "see :ref:`multiprocessing-managers`." msgstr "" +"Tenga en cuenta que también se puede crear una cola compartida mediante el " +"uso de un objeto de administrador; consulte :ref:`multiprocessing-managers`." #: ../Doc/library/multiprocessing.rst:705 msgid "" @@ -704,6 +968,10 @@ msgid "" "Full` exceptions to signal a timeout. They are not available in the :mod:" "`multiprocessing` namespace so you need to import them from :mod:`queue`." msgstr "" +":mod:`multiprocessing` utiliza las excepciones habituales :exc:`queue.Empty` " +"y :exc:`queue.Full` para indicar un tiempo de espera. No están disponibles " +"en el espacio de nombres :mod:`multiprocessing`, por lo que debe importarlos " +"desde :mod:`queue`." #: ../Doc/library/multiprocessing.rst:712 msgid "" @@ -713,6 +981,12 @@ msgid "" "practical difficulties -- if they really bother you then you can instead use " "a queue created with a :ref:`manager `." msgstr "" +"Cuando un objeto se coloca en una cola (*queue*), el objeto se serializa " +"(*pickled*) y luego un subproceso de fondo vacía los datos serializados a " +"una tubería (*pipe*) subyacente. Esto tiene algunas consecuencias que son un " +"poco sorprendentes, pero no deberían causar dificultades prácticas: si " +"realmente causan molestias, se puede usar una cola creada con un :ref:" +"`manager `." #: ../Doc/library/multiprocessing.rst:719 msgid "" @@ -720,6 +994,10 @@ msgid "" "delay before the queue's :meth:`~Queue.empty` method returns :const:`False` " "and :meth:`~Queue.get_nowait` can return without raising :exc:`queue.Empty`." msgstr "" +"Después de poner un objeto en una cola vacía, puede haber un retraso " +"infinitesimal antes de que el método de la cola :meth:`~Queue.empty` " +"retorne :const:`False` y :meth:`~Queue.get_nowait` puede retornar sin " +"lanzar :exc:`queue.Empty`." #: ../Doc/library/multiprocessing.rst:724 msgid "" @@ -728,6 +1006,10 @@ msgid "" "the same process will always be in the expected order with respect to each " "other." msgstr "" +"Si varios procesos están poniendo en cola objetos, es posible que los " +"objetos se reciban en el otro extremo fuera de orden. Sin embargo, los " +"objetos en cola por el mismo proceso siempre estarán en el orden esperado " +"entre sí." #: ../Doc/library/multiprocessing.rst:731 msgid "" @@ -736,6 +1018,10 @@ msgid "" "likely to become corrupted. This may cause any other process to get an " "exception when it tries to use the queue later on." msgstr "" +"Si se termina un proceso usando :meth:`Process.terminate` o :func:`os.kill` " +"mientras intenta usar una clase :class:`Queue`, es probable que los datos de " +"la cola(*queue*) se corrompan. Esto puede hacer que cualquier otro proceso " +"obtenga una excepción cuando intente usar la cola más adelante." #: ../Doc/library/multiprocessing.rst:738 msgid "" @@ -744,6 +1030,11 @@ msgid "" "cancel_join_thread>`), then that process will not terminate until all " "buffered items have been flushed to the pipe." msgstr "" +"Como se mencionó anteriormente, si un proceso hijo ha puesto elementos en " +"una cola (*queue*) (y no ha utilizado :meth:`JoinableQueue." +"cancel_join_thread `), entonces " +"ese proceso no terminará hasta que todos los elementos almacenados en búfer " +"hayan sido vaciados a la tubería (*pipe*)." #: ../Doc/library/multiprocessing.rst:743 msgid "" @@ -753,24 +1044,36 @@ msgid "" "parent process may hang on exit when it tries to join all its non-daemonic " "children." msgstr "" +"Esto significa que si intenta unirse a ese proceso, puede obtener un punto " +"muerto a menos que esté seguro de que todos los elementos que se han puesto " +"en la cola (*queue*) se han consumido. Del mismo modo, si el proceso hijo no " +"es *daemonic*, el proceso parental puede bloquearse en la salida cuando " +"intenta unir todos sus elementos hijos no *daemonic*." #: ../Doc/library/multiprocessing.rst:748 msgid "" "Note that a queue created using a manager does not have this issue. See :" "ref:`multiprocessing-programming`." msgstr "" +"Tenga en cuenta que una cola (*queue*) creada con un administrador no tiene " +"este problema. Consulte :ref:`multiprocessing-programming`." #: ../Doc/library/multiprocessing.rst:751 msgid "" "For an example of the usage of queues for interprocess communication see :" "ref:`multiprocessing-examples`." msgstr "" +"Para ver un ejemplo del uso de colas para la comunicación entre procesos, " +"consulte :ref:`multiprocessing-examples`." #: ../Doc/library/multiprocessing.rst:757 msgid "" "Returns a pair ``(conn1, conn2)`` of :class:`~multiprocessing.connection." "Connection` objects representing the ends of a pipe." msgstr "" +"Retorna un par de objetos *``(conn1, conn2)``* de la :class:" +"`~multiprocessing.connection.Connection` que representan los extremos de una " +"tubería (*pipe*)." #: ../Doc/library/multiprocessing.rst:761 msgid "" @@ -779,6 +1082,10 @@ msgid "" "used for receiving messages and ``conn2`` can only be used for sending " "messages." msgstr "" +"Si *duplex* es ``True`` (el valor predeterminado), entonces la tubería " +"(*pipe*) es bidireccional. Si *duplex* es ``False``, entonces la tubería es " +"unidireccional: ``conn1`` solo se puede usar para recibir mensajes y " +"``conn2`` solo se puede usar para enviar mensajes." #: ../Doc/library/multiprocessing.rst:769 msgid "" @@ -786,42 +1093,61 @@ msgid "" "semaphores. When a process first puts an item on the queue a feeder thread " "is started which transfers objects from a buffer into the pipe." msgstr "" +"Retorna un proceso de cola (*queue*) compartida implementado utilizando una " +"tubería (*pipe*) y algunos candados (*locks*) / semáforos (*semaphores*). " +"Cuando un proceso pone por primera vez un elemento en la cola, se inicia un " +"hilo alimentador que transfiere objetos desde un búfer a la tubería." #: ../Doc/library/multiprocessing.rst:773 msgid "" "The usual :exc:`queue.Empty` and :exc:`queue.Full` exceptions from the " "standard library's :mod:`queue` module are raised to signal timeouts." msgstr "" +"Las excepciones habituales :exc:`queue.Empty` y :exc:`queue.Full` del módulo " +"de la biblioteca estándar :mod:`queue` se generan para indicar tiempos de " +"espera." #: ../Doc/library/multiprocessing.rst:776 msgid "" ":class:`Queue` implements all the methods of :class:`queue.Queue` except " "for :meth:`~queue.Queue.task_done` and :meth:`~queue.Queue.join`." msgstr "" +"La :class:`Queue` implementa todos los métodos de la :class:`queue.Queue` " +"excepto por :meth:`~queue.Queue.task_done` y :meth:`~queue.Queue.join`." #: ../Doc/library/multiprocessing.rst:781 msgid "" "Return the approximate size of the queue. Because of multithreading/" "multiprocessing semantics, this number is not reliable." msgstr "" +"Retorna el tamaño aproximado de la cola (*queue*). Debido a la semántica " +"multiproceso/multiprocesamiento, este número no es confiable." #: ../Doc/library/multiprocessing.rst:784 msgid "" "Note that this may raise :exc:`NotImplementedError` on Unix platforms like " "Mac OS X where ``sem_getvalue()`` is not implemented." msgstr "" +"Tenga en cuenta que esto puede lanzar :exc:`NotImplementedError` en " +"plataformas Unix como Mac OS X donde ``sem_getvalue()`` no está implementado." #: ../Doc/library/multiprocessing.rst:789 msgid "" "Return ``True`` if the queue is empty, ``False`` otherwise. Because of " "multithreading/multiprocessing semantics, this is not reliable." msgstr "" +"Retorna ``True`` si la cola (*queue*) está vacía, de lo contrario retorna " +"``False`` . Debido a la semántica multiproceso/multiprocesamiento, esto no " +"es confiable." #: ../Doc/library/multiprocessing.rst:794 msgid "" "Return ``True`` if the queue is full, ``False`` otherwise. Because of " "multithreading/multiprocessing semantics, this is not reliable." msgstr "" +"Retorna ``True`` si la cola (*queue*) está llena, de lo contrario retorna " +"``False`` . Debido a la semántica multiproceso/multiprocesamiento, esto no " +"es confiable." #: ../Doc/library/multiprocessing.rst:799 msgid "" @@ -833,16 +1159,26 @@ msgid "" "an item on the queue if a free slot is immediately available, else raise " "the :exc:`queue.Full` exception (*timeout* is ignored in that case)." msgstr "" +"Pone *obj* en la cola. Si el argumento opcional *block* es ``True`` (el " +"valor predeterminado) y *timeout* es ``None`` (el valor predeterminado), se " +"bloquea si es necesario hasta que haya un espacio disponible. Si *timeout* " +"es un número positivo, bloquea a lo sumo *timeout* segundos y genera la " +"excepción :exc:`queue.Full` si no hay espacio libre disponible en ese " +"tiempo. De lo contrario (*block* es ``False``), y coloca un elemento en la " +"cola si hay un espacio libre disponible de inmediato, de lo contrario, " +"genera la excepción :exc:`queue.Full` (*timeout* se ignora en ese caso)." #: ../Doc/library/multiprocessing.rst:808 msgid "" "If the queue is closed, :exc:`ValueError` is raised instead of :exc:" "`AssertionError`." msgstr "" +"Si la cola (*queue*) está cerrada, :exc:`ValueError` se lanza en lugar de :" +"exc:`AssertionError`." #: ../Doc/library/multiprocessing.rst:814 msgid "Equivalent to ``put(obj, False)``." -msgstr "" +msgstr "Equivalente a ``put(obj, False)``." #: ../Doc/library/multiprocessing.rst:818 msgid "" @@ -854,22 +1190,36 @@ msgid "" "return an item if one is immediately available, else raise the :exc:`queue." "Empty` exception (*timeout* is ignored in that case)." msgstr "" +"Elimina y retorna un artículo de la cola (*queue*). Si un argumento opcional " +"*block* es ``True`` (el valor predeterminado) y el *timeout* es ``None`` (el " +"valor predeterminado), es bloqueado si es necesario hasta que un elemento " +"esté disponible. Si el *timeout* es un número positivo, bloquea a lo sumo " +"segundos y genera la excepción :exc:`queue.Empty` si no había ningún " +"elemento disponible dentro de ese tiempo. De lo contrario (el bloque es " +"``False``), retorna un elemento si hay uno disponible de inmediato, de lo " +"contrario, levante la excepción :exc:`queue.Empty` (*timeout* se ignora en " +"ese caso)." #: ../Doc/library/multiprocessing.rst:826 msgid "" "If the queue is closed, :exc:`ValueError` is raised instead of :exc:" "`OSError`." msgstr "" +"Si la cola está cerrada, se lanza :exc:`ValueError` en lugar de :exc:" +"`OSError`." #: ../Doc/library/multiprocessing.rst:832 msgid "Equivalent to ``get(False)``." -msgstr "" +msgstr "Equivalente a ``get(False)``." #: ../Doc/library/multiprocessing.rst:834 msgid "" ":class:`multiprocessing.Queue` has a few additional methods not found in :" "class:`queue.Queue`. These methods are usually unnecessary for most code:" msgstr "" +"La :class:`multiprocessing.Queue` tiene algunos métodos adicionales que no " +"se encuentran en :class:`queue.Queue`. Estos métodos suelen ser innecesarios " +"para la mayoría de los códigos:" #: ../Doc/library/multiprocessing.rst:840 msgid "" @@ -878,6 +1228,10 @@ msgid "" "data to the pipe. This is called automatically when the queue is garbage " "collected." msgstr "" +"Indica que el proceso actual no colocará más datos en esta cola (*queue*). " +"El subproceso en segundo plano se cerrará una vez que haya vaciado todos los " +"datos almacenados en la tubería (*pipe*). Esto se llama automáticamente " +"cuando la cola es recolectada por el recolector de basura." #: ../Doc/library/multiprocessing.rst:847 msgid "" @@ -885,6 +1239,10 @@ msgid "" "been called. It blocks until the background thread exits, ensuring that all " "data in the buffer has been flushed to the pipe." msgstr "" +"Unifica al hilo de fondo. Esto solo se puede usar después de que se ha " +"llamado a :meth:`close`. Esto se bloquea hasta que salga el hilo de fondo, " +"asegurando que todos los datos en el búfer se hayan vaciado a la tubería " +"(*pipe*)." #: ../Doc/library/multiprocessing.rst:851 msgid "" @@ -892,6 +1250,9 @@ msgid "" "attempt to join the queue's background thread. The process can call :meth:" "`cancel_join_thread` to make :meth:`join_thread` do nothing." msgstr "" +"Por defecto, si un proceso no es el creador de la cola (*queue*), al salir " +"intentará unirse al hilo de fondo de la cola. El proceso puede llamar a :" +"meth:`cancel_join_thread` para hacer que el :meth:`join_thread` no haga nada." #: ../Doc/library/multiprocessing.rst:857 msgid "" @@ -899,6 +1260,9 @@ msgid "" "background thread from being joined automatically when the process exits -- " "see :meth:`join_thread`." msgstr "" +"Evita que :meth:`join_thread` bloquee. En particular, esto evita que el " +"subproceso en segundo plano se una automáticamente cuando finaliza el " +"proceso; consulte :meth:`join_thread`." #: ../Doc/library/multiprocessing.rst:861 msgid "" @@ -908,6 +1272,11 @@ msgid "" "exit immediately without waiting to flush enqueued data to the underlying " "pipe, and you don't care about lost data." msgstr "" +"Un mejor nombre para este método podría ser ``allow_exit_without_flush()``. " +"Es probable que provoque la pérdida de datos en cola (*queue*), y es casi " +"seguro que no necesitará usarlos. Realmente solo está allí si necesita que " +"el proceso actual salga inmediatamente sin esperar a vaciar los datos en " +"cola en la tubería (*pipe*) subyacente, y no le importan los datos perdidos." #: ../Doc/library/multiprocessing.rst:870 msgid "" @@ -918,29 +1287,42 @@ msgid "" "information. The same holds true for any of the specialized queue types " "listed below." msgstr "" +"La funcionalidad de esta clase requiere una implementación de semáforo " +"compartido en funcionamiento en el sistema operativo que es huésped " +"(*host*). Sin uno, la funcionalidad en esta clase se deshabilitará, y los " +"intentos de instanciar a :class:`Queue` resultarán en :exc:`ImportError`. " +"Consulte :issue:`3770` para información adicional. Lo mismo es válido para " +"cualquiera de los tipos de cola especializados que se enumeran a " +"continuación." #: ../Doc/library/multiprocessing.rst:879 msgid "" "It is a simplified :class:`Queue` type, very close to a locked :class:`Pipe`." msgstr "" +"Es un tipo simplificado :class:`Queue`, muy similar a un *lock* de :class:" +"`Pipe`." #: ../Doc/library/multiprocessing.rst:883 msgid "Return ``True`` if the queue is empty, ``False`` otherwise." msgstr "" +"Retorna ``True`` si la cola (*queue*) está vacía, de otra manera retorna " +"``False``." #: ../Doc/library/multiprocessing.rst:887 msgid "Remove and return an item from the queue." -msgstr "" +msgstr "Eliminar y retornar un artículo de la cola (*queue*)." #: ../Doc/library/multiprocessing.rst:891 msgid "Put *item* into the queue." -msgstr "" +msgstr "Pone *item* en la cola." #: ../Doc/library/multiprocessing.rst:896 msgid "" ":class:`JoinableQueue`, a :class:`Queue` subclass, is a queue which " "additionally has :meth:`task_done` and :meth:`join` methods." msgstr "" +":class:`JoinableQueue`, una subclase :class:`Queue` , es una cola (*queue*) " +"que además tiene los métodos :meth:`task_done` y :meth:`join` ." #: ../Doc/library/multiprocessing.rst:901 msgid "" @@ -949,6 +1331,10 @@ msgid "" "call to :meth:`task_done` tells the queue that the processing on the task is " "complete." msgstr "" +"Indica que una tarea anteriormente en cola (*queue*) está completa. Usado " +"por los consumidores de la cola. Por cada :meth:`~Queue.get` utilizado para " +"recuperar una tarea, una llamada posterior a :meth:`task_done` le dice a la " +"cola que el procesamiento de la tarea se ha completado." #: ../Doc/library/multiprocessing.rst:906 msgid "" @@ -956,16 +1342,24 @@ msgid "" "all items have been processed (meaning that a :meth:`task_done` call was " "received for every item that had been :meth:`~Queue.put` into the queue)." msgstr "" +"Si un :meth:`~queue.Queue.join` se está bloqueando actualmente, se reanudará " +"cuando se hayan procesado todos los elementos (lo que significa que :meth:" +"`task_done` es llamado para cada elemento que había sido puesto en cola " +"(*queue*) por :meth:`~Queue.put` )." #: ../Doc/library/multiprocessing.rst:910 msgid "" "Raises a :exc:`ValueError` if called more times than there were items placed " "in the queue." msgstr "" +"Lanza un :exc:`ValueError` si es llamado más veces que elementos hay en una " +"cola." #: ../Doc/library/multiprocessing.rst:916 msgid "Block until all items in the queue have been gotten and processed." msgstr "" +"Se bloquea hasta que todos los elementos en una cola han sido recibidos y " +"procesados." #: ../Doc/library/multiprocessing.rst:918 msgid "" @@ -975,24 +1369,31 @@ msgid "" "the count of unfinished tasks drops to zero, :meth:`~queue.Queue.join` " "unblocks." msgstr "" +"El recuento de tareas no finalizadas aumenta cada vez que se agrega un " +"elemento a la cola. El recuento disminuye cada vez que un consumidor llama " +"a :meth:`task_done` para indicar que el artículo se recuperó y todo el " +"trabajo en él está completo. Cuando el recuento de tareas inacabadas cae a " +"cero, :meth:`~queue.Queue.join` se desbloquea." #: ../Doc/library/multiprocessing.rst:926 msgid "Miscellaneous" -msgstr "" +msgstr "Miscelánea" #: ../Doc/library/multiprocessing.rst:930 msgid "Return list of all live children of the current process." -msgstr "" +msgstr "Retorna una lista con todos los hijos del proceso actual." #: ../Doc/library/multiprocessing.rst:932 msgid "" "Calling this has the side effect of \"joining\" any processes which have " "already finished." msgstr "" +"Llamar a esto tiene el efecto secundario de \"unir\" cualquier proceso que " +"ya haya finalizado." #: ../Doc/library/multiprocessing.rst:937 msgid "Return the number of CPUs in the system." -msgstr "" +msgstr "Retorna el número de CPU en el sistema." #: ../Doc/library/multiprocessing.rst:939 msgid "" @@ -1000,23 +1401,27 @@ msgid "" "use. The number of usable CPUs can be obtained with ``len(os." "sched_getaffinity(0))``" msgstr "" +"Este número no es equivalente al número de CPU que puede utilizar el proceso " +"actual. El número de CPU utilizables se puede obtener con ``len(os." +"sched_getaffinity(0))``" #: ../Doc/library/multiprocessing.rst:943 msgid "May raise :exc:`NotImplementedError`." -msgstr "" +msgstr "Puedo lanzar :exc:`NotImplementedError`." #: ../Doc/library/multiprocessing.rst:946 msgid ":func:`os.cpu_count`" -msgstr "" +msgstr ":func:`os.cpu_count`" #: ../Doc/library/multiprocessing.rst:950 msgid "" "Return the :class:`Process` object corresponding to the current process." msgstr "" +"Retorna el objeto de la :class:`Process` correspondiente al proceso actual." #: ../Doc/library/multiprocessing.rst:952 msgid "An analogue of :func:`threading.current_thread`." -msgstr "" +msgstr "Un análogo de la :func:`threading.current_thread`." #: ../Doc/library/multiprocessing.rst:956 msgid "" @@ -1024,6 +1429,9 @@ msgid "" "the :func:`current_process`. For the main process, ``parent_process`` will " "be ``None``." msgstr "" +"Retorna el objeto de la :class:`Process` correspondiente al proceso parental " +"de :func:`current_process`. Para el proceso principal, ``parent_process` " +"será ``None``." #: ../Doc/library/multiprocessing.rst:964 msgid "" @@ -1031,18 +1439,25 @@ msgid "" "frozen to produce a Windows executable. (Has been tested with **py2exe**, " "**PyInstaller** and **cx_Freeze**.)" msgstr "" +"Agrega soporte para cuando un programa que utiliza :mod:`multiprocessing` se " +"haya congelado para producir un ejecutable de Windows. (Ha sido probado con " +"**py2exe**, **PyInstaller** y **cx_Freeze**.)" #: ../Doc/library/multiprocessing.rst:968 msgid "" "One needs to call this function straight after the ``if __name__ == " "'__main__'`` line of the main module. For example::" msgstr "" +"Es necesario llamar a esta función inmediatamente después de la línea " +"principal del módulo `if __name__ == '__main__'`` . Por ejemplo::" #: ../Doc/library/multiprocessing.rst:980 msgid "" "If the ``freeze_support()`` line is omitted then trying to run the frozen " "executable will raise :exc:`RuntimeError`." msgstr "" +"Si se omite la línea ``freeze_support()`` entonces se intenta comenzar el " +"ejecutable congelado que lanzará :exc:`RuntimeError`." #: ../Doc/library/multiprocessing.rst:983 msgid "" @@ -1051,6 +1466,10 @@ msgid "" "by the Python interpreter on Windows (the program has not been frozen), then " "``freeze_support()`` has no effect." msgstr "" +"La llamada de ``freeze_support()`` no tiene efecto cuando es invocada por " +"cualquier sistema operativo que no sea Windows. Además, si el módulo ha sido " +"ejecutado en un intérprete de Python en Windows (y el programa no se ha " +"congelado) entonces ``freeze_support()`` no tiene efecto." #: ../Doc/library/multiprocessing.rst:990 msgid "" @@ -1060,12 +1479,19 @@ msgid "" "``'fork'`` and ``'spawn'`` are always supported, with ``'fork'`` being the " "default." msgstr "" +"Retorna una lista de los métodos de inicio admitidos, el primero de los " +"cuales es el predeterminado. Los posibles métodos de inicio son ``'fork'``, " +"``'spawn'`` y ``'forkserver'``. En Windows solo está disponible ``'spawn'``. " +"En Unix, ``'fork'`` y ``'spawn'`` siempre son compatibles, siendo ``'fork'`` " +"el valor predeterminado." #: ../Doc/library/multiprocessing.rst:1000 msgid "" "Return a context object which has the same attributes as the :mod:" "`multiprocessing` module." msgstr "" +"Retorna un objeto de contexto que tiene los mismos atributos que el módulo :" +"mod:`multiprocessing`." #: ../Doc/library/multiprocessing.rst:1003 msgid "" @@ -1073,10 +1499,16 @@ msgid "" "*method* should be ``'fork'``, ``'spawn'``, ``'forkserver'``. :exc:" "`ValueError` is raised if the specified start method is not available." msgstr "" +"Si el método *method* es ``None`` entonces el contexto predeterminado es " +"retornado. Por lo contrario, *method* debería ser ``'fork'``, ``'spawn'``, " +"``'forkserver'``. Se lanza :exc:`ValueError` if el método de inicio no esta " +"disponible." #: ../Doc/library/multiprocessing.rst:1012 msgid "Return the name of start method used for starting processes." msgstr "" +"Retorna el nombre del método de inicio que es utilizado para iniciar " +"procesos." #: ../Doc/library/multiprocessing.rst:1014 msgid "" @@ -1084,6 +1516,10 @@ msgid "" "start method is fixed to the default and the name is returned. If the start " "method has not been fixed and *allow_none* is true then ``None`` is returned." msgstr "" +"Si el método de inicio no se ha solucionado y *allow_none* es falso, " +"entonces el método de inicio se fija al predeterminado y se retorna el " +"nombre. Si el método de inicio no se ha solucionado y *allow_none* es " +"verdadero, se retorna ``None``." #: ../Doc/library/multiprocessing.rst:1019 msgid "" @@ -1091,6 +1527,9 @@ msgid "" "``None``. ``'fork'`` is the default on Unix, while ``'spawn'`` is the " "default on Windows." msgstr "" +"El valor retornado puede ser ``'fork'``, ``'spawn'``, ``'forkserver'`` o " +"``None``. En Unix ``'fork'`` es el valor predeterminado mientras que " +"``'spawn'`` lo es en Windows." #: ../Doc/library/multiprocessing.rst:1027 msgid "" @@ -1098,26 +1537,35 @@ msgid "" "process. (By default :data:`sys.executable` is used). Embedders will " "probably need to do some thing like ::" msgstr "" +"Establece la ruta del intérprete de Python para usar cuando se inicia un " +"proceso secundario. (Por defecto se utiliza :data:`sys.executable`). Los " +"integradores probablemente necesiten hacer algo como ::" #: ../Doc/library/multiprocessing.rst:1033 msgid "before they can create child processes." -msgstr "" +msgstr "antes ellos pueden crear procesos hijos." #: ../Doc/library/multiprocessing.rst:1035 msgid "Now supported on Unix when the ``'spawn'`` start method is used." msgstr "" +"Ahora es compatible con Unix cuando se usa el método de inicio ``'spawn'``." #: ../Doc/library/multiprocessing.rst:1040 msgid "" "Set the method which should be used to start child processes. *method* can " "be ``'fork'``, ``'spawn'`` or ``'forkserver'``." msgstr "" +"Se establece el método que se debe usar para iniciar procesos secundarios. " +"*method* puede ser ``'fork'``, ``'spawn'`` o ``'forkserver'``." #: ../Doc/library/multiprocessing.rst:1043 msgid "" "Note that this should be called at most once, and it should be protected " "inside the ``if __name__ == '__main__'`` clause of the main module." msgstr "" +"Tenga en cuenta que esto debería llamarse como máximo una vez, y debería " +"protegerse dentro de la cláusula ``if __name__ == '__main__'`` del módulo " +"principal." #: ../Doc/library/multiprocessing.rst:1051 msgid "" @@ -1126,34 +1574,49 @@ msgid "" "func:`threading.setprofile`, :class:`threading.Timer`, or :class:`threading." "local`." msgstr "" +":mod:`multiprocessing` no contiene análogos de :func:`threading." +"active_count`, :func:`threading.enumerate`, :func:`threading.settrace`, :" +"func:`threading.setprofile`, :class:`threading.Timer`, o :class:`threading." +"local`." #: ../Doc/library/multiprocessing.rst:1058 msgid "Connection Objects" -msgstr "" +msgstr "Objetos de conexión *Connection Objects*" #: ../Doc/library/multiprocessing.rst:1062 msgid "" "Connection objects allow the sending and receiving of picklable objects or " "strings. They can be thought of as message oriented connected sockets." msgstr "" +"Los objetos de conexión permiten el envío y la recepción de objetos " +"serializables (*pickable*) o cadenas de caracteres seleccionables. Pueden " +"considerarse como sockets conectados orientados a mensajes." #: ../Doc/library/multiprocessing.rst:1065 msgid "" "Connection objects are usually created using :func:`Pipe ` -- see also :ref:`multiprocessing-listeners-clients`." msgstr "" +"Los objetos de conexión usualmente son creados usando :func:`Pipe " +"` -- ver también :ref:`multiprocessing-listeners-" +"clients`." #: ../Doc/library/multiprocessing.rst:1073 msgid "" "Send an object to the other end of the connection which should be read " "using :meth:`recv`." msgstr "" +"Envía un objeto al otro extremo de la conexión que debe leerse usando :meth:" +"`recv`." #: ../Doc/library/multiprocessing.rst:1076 msgid "" "The object must be picklable. Very large pickles (approximately 32 MiB+, " "though it depends on the OS) may raise a :exc:`ValueError` exception." msgstr "" +"El objeto debe ser serializable (*pickable*). Los serializados (*pickable*) " +"muy grandes (aproximadamente 32 *MiB+* , aunque depende del sistema " +"operativo) pueden generar una excepción :exc:`ValueError`." #: ../Doc/library/multiprocessing.rst:1081 msgid "" @@ -1161,22 +1624,27 @@ msgid "" "`send`. Blocks until there is something to receive. Raises :exc:`EOFError` " "if there is nothing left to receive and the other end was closed." msgstr "" +"Retorna un objeto enviado desde el otro extremo de la conexión usando :meth:" +"`send`. Se bloquea hasta que haya algo para recibir. Se lanza :exc:" +"`EOFError` si no queda nada por recibir y el otro extremo está cerrado." #: ../Doc/library/multiprocessing.rst:1088 msgid "Return the file descriptor or handle used by the connection." msgstr "" +"Retorna el descriptor de archivo o identificador utilizado por la conexión." #: ../Doc/library/multiprocessing.rst:1092 msgid "Close the connection." -msgstr "" +msgstr "Cierra la conexión." #: ../Doc/library/multiprocessing.rst:1094 msgid "This is called automatically when the connection is garbage collected." msgstr "" +"Esto se llama automáticamente cuando la conexión es basura recolectada." #: ../Doc/library/multiprocessing.rst:1098 msgid "Return whether there is any data available to be read." -msgstr "" +msgstr "Retorna si hay datos disponibles para leer." #: ../Doc/library/multiprocessing.rst:1100 msgid "" @@ -1184,16 +1652,23 @@ msgid "" "is a number then this specifies the maximum time in seconds to block. If " "*timeout* is ``None`` then an infinite timeout is used." msgstr "" +"Si no se especifica *timeout*, se retornará de inmediato. Si *timeout* es un " +"número, esto especifica el tiempo máximo en segundos para bloquear. Si " +"*timeout* es ``None``, se usa un tiempo de espera infinito." #: ../Doc/library/multiprocessing.rst:1104 msgid "" "Note that multiple connection objects may be polled at once by using :func:" "`multiprocessing.connection.wait`." msgstr "" +"Tenga en cuenta que se pueden sondear varios objetos de conexión a la vez " +"utilizando :func:`multiprocessing.connection.wait`." #: ../Doc/library/multiprocessing.rst:1109 msgid "Send byte data from a :term:`bytes-like object` as a complete message." msgstr "" +"Envía datos de *bytes* desde a :term:`bytes-like object` como un mensaje " +"completo." #: ../Doc/library/multiprocessing.rst:1111 msgid "" @@ -1202,6 +1677,10 @@ msgid "" "buffers (approximately 32 MiB+, though it depends on the OS) may raise a :" "exc:`ValueError` exception" msgstr "" +"Si se da *offset*, los datos se leen desde esa posición en *buffer*. Si se " +"da *size* entonces se leerán muchos *bytes* del búfer. Los *buffers* muy " +"grandes (aproximadamente *32 MiB+*, aunque depende del sistema operativo) " +"pueden generar una excepción :exc:`ValueError`" #: ../Doc/library/multiprocessing.rst:1118 msgid "" @@ -1210,18 +1689,26 @@ msgid "" "exc:`EOFError` if there is nothing left to receive and the other end has " "closed." msgstr "" +"Retorna un mensaje completo de datos de *bytes* enviados desde el otro " +"extremo de la conexión como una cadena de caracteres. Se bloquea hasta que " +"haya algo para recibir. Aumenta :exc:`EOFError` si no queda nada por recibir " +"y el otro extremo se ha cerrado." #: ../Doc/library/multiprocessing.rst:1123 msgid "" "If *maxlength* is specified and the message is longer than *maxlength* then :" "exc:`OSError` is raised and the connection will no longer be readable." msgstr "" +"Si se especifica *maxlength* y el mensaje es más largo que *maxlength*, " +"entonces se lanza un :exc:`OSError` y la conexión ya no será legible." #: ../Doc/library/multiprocessing.rst:1127 msgid "" "This function used to raise :exc:`IOError`, which is now an alias of :exc:" "`OSError`." msgstr "" +"Esta función solía lanzar un :exc:`IOError`, que ahora es un alias de :exc:" +"`OSError`." #: ../Doc/library/multiprocessing.rst:1134 msgid "" @@ -1230,6 +1717,10 @@ msgid "" "until there is something to receive. Raises :exc:`EOFError` if there is " "nothing left to receive and the other end was closed." msgstr "" +"Lee en *buffer* un mensaje completo de datos de *bytes* enviados desde el " +"otro extremo de la conexión y retorne el número de *bytes* en el mensaje. Se " +"bloquea hasta que haya algo para recibir. Si no queda nada por recibir y el " +"otro extremo está cerrándose se lanza :exc:`EOFError`." #: ../Doc/library/multiprocessing.rst:1140 msgid "" @@ -1237,6 +1728,10 @@ msgid "" "then the message will be written into the buffer from that position. Offset " "must be a non-negative integer less than the length of *buffer* (in bytes)." msgstr "" +"*buffer* debe ser un escribible :term:`bytes-like object`. Si se proporciona " +"*offset* el mensaje se escribirá en el búfer desde esa posición. La " +"compensación debe ser un número entero no negativo menor que la longitud de " +"*buffer* (en *bytes*)." #: ../Doc/library/multiprocessing.rst:1145 msgid "" @@ -1244,12 +1739,17 @@ msgid "" "and the complete message is available as ``e.args[0]`` where ``e`` is the " "exception instance." msgstr "" +"Si el búfer es demasiado corto, se genera una excepción :exc:" +"`BufferTooShort` y el mensaje completo está disponible como ``e.args [0]`` " +"donde ``e`` es la instancia de excepción." #: ../Doc/library/multiprocessing.rst:1149 msgid "" "Connection objects themselves can now be transferred between processes " "using :meth:`Connection.send` and :meth:`Connection.recv`." msgstr "" +"Los objetos de conexión ahora pueden transferirse entre procesos usando :" +"meth:`Connection.send` y :meth:`Connection.recv`." #: ../Doc/library/multiprocessing.rst:1153 msgid "" @@ -1257,10 +1757,14 @@ msgid "" "`typecontextmanager`. :meth:`~contextmanager.__enter__` returns the " "connection object, and :meth:`~contextmanager.__exit__` calls :meth:`close`." msgstr "" +"Los objetos de conexión ahora admiten el protocolo de administración de " +"contexto -- consulte :ref:`typecontextmanager`. :meth:`~contextmanager." +"__enter__` retorna el objeto de conexión, y :meth:`~contextmanager.__exit__` " +"llama a :meth:`close`." #: ../Doc/library/multiprocessing.rst:1158 msgid "For example:" -msgstr "" +msgstr "Por ejemplo:" #: ../Doc/library/multiprocessing.rst:1182 msgid "" @@ -1268,6 +1772,9 @@ msgid "" "receives, which can be a security risk unless you can trust the process " "which sent the message." msgstr "" +"El método :meth:`Connection.recv` desempaqueta automáticamente los datos que " +"recibe, lo que puede ser un riesgo de seguridad a menos que pueda confiar en " +"el proceso que envió el mensaje." #: ../Doc/library/multiprocessing.rst:1186 msgid "" @@ -1276,6 +1783,10 @@ msgid "" "methods after performing some sort of authentication. See :ref:" "`multiprocessing-auth-keys`." msgstr "" +"Por lo tanto, a menos que el objeto de conexión se haya producido usando :" +"func:`Pipe` solo debe usar los métodos :meth:`~Connection.recv` y :meth:" +"`~Connection.send` después de realizar algún tipo de autenticación. " +"Consulte :ref:`multiprocessing-auth-keys`." #: ../Doc/library/multiprocessing.rst:1193 msgid "" @@ -1283,10 +1794,14 @@ msgid "" "the data in the pipe is likely to become corrupted, because it may become " "impossible to be sure where the message boundaries lie." msgstr "" +"Si se mata un proceso mientras intenta leer o escribir en una tubería " +"(*pipe*), entonces es probable que los datos en la tubería se corrompan, " +"porque puede ser imposible estar seguro de dónde se encuentran los límites " +"del mensaje." #: ../Doc/library/multiprocessing.rst:1199 msgid "Synchronization primitives" -msgstr "" +msgstr "Sincronizaciones primitivas (*Synchronization primitives*)" #: ../Doc/library/multiprocessing.rst:1203 msgid "" @@ -1294,22 +1809,30 @@ msgid "" "program as they are in a multithreaded program. See the documentation for :" "mod:`threading` module." msgstr "" +"En general, las primitivas de sincronización no son tan necesarias en un " +"programa multiproceso como en un programa *multihilos* (*multithreaded*). " +"Consulte la documentación para :mod:`threading` ." #: ../Doc/library/multiprocessing.rst:1207 msgid "" "Note that one can also create synchronization primitives by using a manager " "object -- see :ref:`multiprocessing-managers`." msgstr "" +"Tenga en cuenta que también se pueden crear primitivas de sincronización " +"utilizando un objeto administrador -- consulte :ref:`multiprocessing-" +"managers`." #: ../Doc/library/multiprocessing.rst:1212 msgid "A barrier object: a clone of :class:`threading.Barrier`." -msgstr "" +msgstr "Un objeto de barrera: un clon de :class:`threading.Barrier`." #: ../Doc/library/multiprocessing.rst:1218 msgid "" "A bounded semaphore object: a close analog of :class:`threading." "BoundedSemaphore`." msgstr "" +"Un objeto semáforo (*semaphore object*) acotado: un análogo cercano de la :" +"class:`threading.BoundedSemaphore`." #: ../Doc/library/multiprocessing.rst:1221 #: ../Doc/library/multiprocessing.rst:1359 @@ -1317,31 +1840,39 @@ msgid "" "A solitary difference from its close analog exists: its ``acquire`` method's " "first argument is named *block*, as is consistent with :meth:`Lock.acquire`." msgstr "" +"Existe una diferencia solitaria de su análogo cercano: el primer argumento " +"de su método ``acquire`` es nombrado *block*, es consistente con :meth:`Lock." +"acquire`." #: ../Doc/library/multiprocessing.rst:1225 msgid "" "On Mac OS X, this is indistinguishable from :class:`Semaphore` because " "``sem_getvalue()`` is not implemented on that platform." msgstr "" +"En Mac OS X, esto no se puede distinguir de :class:`Semaphore` porque " +"``sem_getvalue()`` no está implementado en esa plataforma." #: ../Doc/library/multiprocessing.rst:1230 msgid "A condition variable: an alias for :class:`threading.Condition`." msgstr "" +"Una variable de condición: un alias para la :class:`threading.Condition`." #: ../Doc/library/multiprocessing.rst:1232 msgid "" "If *lock* is specified then it should be a :class:`Lock` or :class:`RLock` " "object from :mod:`multiprocessing`." msgstr "" +"Si se especifica *lock*, entonces debería ser una :class:`Lock` o :class:" +"`RLock` objeto de :mod:`multiprocessing`." #: ../Doc/library/multiprocessing.rst:1235 #: ../Doc/library/multiprocessing.rst:1769 msgid "The :meth:`~threading.Condition.wait_for` method was added." -msgstr "" +msgstr "El método :meth:`~threading.Condition.wait_for` fue a añadido." #: ../Doc/library/multiprocessing.rst:1240 msgid "A clone of :class:`threading.Event`." -msgstr "" +msgstr "Un clon de :class:`threading.Event`." #: ../Doc/library/multiprocessing.rst:1245 msgid "" @@ -1353,6 +1884,13 @@ msgid "" "`multiprocessing.Lock` as it applies to either processes or threads, except " "as noted." msgstr "" +"Un objeto candado no recursivo: un análogo cercano de :class:`threading." +"Lock` . Una vez que un proceso o subproceso ha adquirido un bloqueo, los " +"intentos posteriores de adquirirlo de cualquier proceso o subproceso se " +"bloquearán hasta que se libere; cualquier proceso o hilo puede liberarlo. " +"Los conceptos y comportamientos de :class:`threading.Lock` como se aplica a " +"los subprocesos se replican aquí en :class:`multiprocessing.Lock` como se " +"aplica a los procesos o subprocesos, excepto como se indica." #: ../Doc/library/multiprocessing.rst:1253 msgid "" @@ -1360,17 +1898,22 @@ msgid "" "instance of ``multiprocessing.synchronize.Lock`` initialized with a default " "context." msgstr "" +"Tenga en cuenta que :class:`Lock` es en realidad una función de fábrica que " +"retorna una instancia de ``multiprocessing.synchronize.Lock`` inicializada " +"con un contexto predeterminado." #: ../Doc/library/multiprocessing.rst:1257 msgid "" ":class:`Lock` supports the :term:`context manager` protocol and thus may be " "used in :keyword:`with` statements." msgstr "" +"La :class:`Lock` soporta el protocolo :term:`context manager` y, por lo " +"tanto, se puede usar en la declaración :keyword:`with` ." #: ../Doc/library/multiprocessing.rst:1262 #: ../Doc/library/multiprocessing.rst:1313 msgid "Acquire a lock, blocking or non-blocking." -msgstr "" +msgstr "Adquiriendo un candado (*lock*), bloqueante o no bloqueante." #: ../Doc/library/multiprocessing.rst:1264 msgid "" @@ -1379,6 +1922,11 @@ msgid "" "return ``True``. Note that the name of this first argument differs from " "that in :meth:`threading.Lock.acquire`." msgstr "" +"Con el argumento *block* establecido en ``True`` (el valor predeterminado), " +"la llamada al método se bloqueará hasta que el bloqueo esté en un estado " +"desbloqueado, luego configúrelo como bloqueado y retorne ``True``. Tenga en " +"cuenta que el nombre de este primer argumento difiere del que aparece en :" +"meth:`threading.Lock.acquire`." #: ../Doc/library/multiprocessing.rst:1269 msgid "" @@ -1386,6 +1934,10 @@ msgid "" "If the lock is currently in a locked state, return ``False``; otherwise set " "the lock to a locked state and return ``True``." msgstr "" +"Con el argumento *block* establecido en ``False``, la llamada al método no " +"se bloquea. Si el bloqueo está actualmente en un estado bloqueado, retorna " +"``False`` ; de lo contrario, configure el bloqueo en un estado bloqueado y " +"retorne ``True``." #: ../Doc/library/multiprocessing.rst:1273 msgid "" @@ -1400,18 +1952,35 @@ msgid "" "``False`` and is thus ignored. Returns ``True`` if the lock has been " "acquired or ``False`` if the timeout period has elapsed." msgstr "" +"Cuando se invoca con un valor positivo de punto flotante para *timeout*, " +"bloquea como máximo el número de segundos especificado por *timeout* siempre " +"que no se pueda obtener el bloqueo. Las invocaciones con un valor negativo " +"para *timeout* de cero. Las invocaciones con un valor *timeout* de ``None`` " +"(el valor predeterminado) establecen el período de tiempo de espera en " +"infinito. Tenga en cuenta que el tratamiento de valores negativos o ``None`` " +"para *timeout* difiere del comportamiento implementado en :meth:`threading." +"Lock.acquire`. El argumento *timeout* no tiene implicaciones prácticas si el " +"argumento *block* se establece en ``False`` y, por lo tanto, se ignora. " +"Retorna ``True`` si se ha adquirido el candado o ``False`` si ha " +"transcurrido el tiempo de espera." #: ../Doc/library/multiprocessing.rst:1288 msgid "" "Release a lock. This can be called from any process or thread, not only the " "process or thread which originally acquired the lock." msgstr "" +"Suelta un candado. Esto se puede llamar desde cualquier proceso o " +"subproceso, no solo desde el proceso o subproceso que originalmente adquirió " +"el candado." #: ../Doc/library/multiprocessing.rst:1291 msgid "" "Behavior is the same as in :meth:`threading.Lock.release` except that when " "invoked on an unlocked lock, a :exc:`ValueError` is raised." msgstr "" +"El comportamiento es el mismo que en :meth:`threading.Lock.release` excepto " +"que cuando se invoca en un bloqueo desbloqueado, se genera a :exc:" +"`ValueError`." #: ../Doc/library/multiprocessing.rst:1297 msgid "" @@ -1421,6 +1990,12 @@ msgid "" "thread may acquire it again without blocking; that process or thread must " "release it once for each time it has been acquired." msgstr "" +"Un objeto de candado recursivo: un análogo cercano a :class:`threading." +"RLock`. El proceso o el hilo que lo adquirió debe liberar un candado " +"recursivo. Una vez que un proceso o subproceso ha adquirido un candado " +"recursivo, el mismo proceso o subproceso puede volver a adquirirlo sin " +"bloquearlo; ese proceso o hilo debe liberarlo una vez por cada vez que se " +"haya adquirido." #: ../Doc/library/multiprocessing.rst:1303 msgid "" @@ -1428,12 +2003,17 @@ msgid "" "instance of ``multiprocessing.synchronize.RLock`` initialized with a default " "context." msgstr "" +"Tenga en cuenta que :class:`RLock` es en realidad una función de fábrica que " +"retorna una instancia de ``multiprocessing.synchronize.RLock`` inicializada " +"con un contexto predeterminado." #: ../Doc/library/multiprocessing.rst:1307 msgid "" ":class:`RLock` supports the :term:`context manager` protocol and thus may be " "used in :keyword:`with` statements." msgstr "" +"La :class:`RLock` admite el protocolo :term:`context manager` y, por lo " +"tanto, puede usarse en :keyword:`with`." #: ../Doc/library/multiprocessing.rst:1315 msgid "" @@ -1447,6 +2027,15 @@ msgid "" "of :meth:`threading.RLock.acquire`, starting with the name of the argument " "itself." msgstr "" +"Cuando se invoca con el argumento *block* establecido en ``True`` , bloquea " +"hasta que el candado esté en un estado desbloqueado (que no sea propiedad de " +"ningún proceso o subproceso) a menos que el candado o el subproceso actual " +"ya sea de su propiedad. El proceso o subproceso actual se apropia del " +"candado (si aún no lo tiene) y el nivel de recursión dentro de este aumenta " +"en uno, lo que da como resultado un valor de retorno de ``True``. Tenga en " +"cuenta que hay varias diferencias en el comportamiento de este primer " +"argumento en comparación con la implementación de :meth:`threading.RLock." +"acquire`, comenzando con el nombre del argumento en sí." #: ../Doc/library/multiprocessing.rst:1325 msgid "" @@ -1458,6 +2047,13 @@ msgid "" "thread takes ownership and the recursion level is incremented, resulting in " "a return value of ``True``." msgstr "" +"Cuando se invoca con el argumento *block* establecido en ``False``, no " +"bloquea. Si el candado ya ha sido adquirido (y por lo tanto es propiedad) de " +"otro proceso o subproceso, el proceso o subproceso actual no se apropia y el " +"nivel de recursión dentro del candado no cambia, lo que resulta en un valor " +"de retorno de ``False``. Si el candado está en un estado desbloqueado, el " +"proceso o subproceso actual toma posesión y el nivel de recurrencia se " +"incrementa, lo que resulta en un valor de retorno de ``True``." #: ../Doc/library/multiprocessing.rst:1333 msgid "" @@ -1465,6 +2061,10 @@ msgid "" "acquire`. Note that some of these behaviors of *timeout* differ from the " "implemented behaviors in :meth:`threading.RLock.acquire`." msgstr "" +"El uso y los comportamientos del argumento *timeout* son los mismos que en :" +"meth:`Lock.acquire`. Tenga en cuenta que algunos de estos comportamientos de " +"*timeout* difieren de los comportamientos implementados en :meth:`threading." +"RLock.acquire`." #: ../Doc/library/multiprocessing.rst:1340 msgid "" @@ -1475,6 +2075,13 @@ msgid "" "after the decrement the recursion level is still nonzero, the lock remains " "locked and owned by the calling process or thread." msgstr "" +"Libera un candado, disminuyendo el nivel de recursión. Si después del " +"decremento el nivel de recursión es cero, restablece el candado a " +"desbloqueado (que no sea propiedad de ningún proceso o subproceso) y si se " +"bloquean otros procesos o subprocesos esperando que el candado se " +"desbloquee, permite que continúe exactamente uno de ellos. Si después del " +"decremento el nivel de recursión sigue siendo distinto de cero, el candado " +"permanece bloqueado y pertenece al proceso de llamada o subproceso." #: ../Doc/library/multiprocessing.rst:1348 msgid "" @@ -1484,16 +2091,26 @@ msgid "" "state. Note that the type of exception raised in this situation differs " "from the implemented behavior in :meth:`threading.RLock.release`." msgstr "" +"Solo llame a este método cuando el proceso o subproceso de llamada sea el " +"propietario del candado. Se lanza un :exc:`AssertionError` si se llama a " +"este método mediante un proceso o subproceso que no sea el propietario o si " +"el candado está en un estado desbloqueado (sin propietario). Tenga en cuenta " +"que el tipo de excepción planteada en esta situación difiere del " +"comportamiento implementado en :meth:`threading.RLock.release`." #: ../Doc/library/multiprocessing.rst:1357 msgid "A semaphore object: a close analog of :class:`threading.Semaphore`." msgstr "" +"Un objeto semáforo: un análogo cercano de :class:`threading.Semaphore`." #: ../Doc/library/multiprocessing.rst:1364 msgid "" "On Mac OS X, ``sem_timedwait`` is unsupported, so calling ``acquire()`` with " "a timeout will emulate that function's behavior using a sleeping loop." msgstr "" +"En Mac OS X, ``sem_timedwait`` no es compatible, por lo que llamar a " +"``acquire()`` con un tiempo de espera emulará el comportamiento de esa " +"función utilizando un bucle inactivo." #: ../Doc/library/multiprocessing.rst:1369 msgid "" @@ -1503,12 +2120,19 @@ msgid "" "acquire` or :meth:`Condition.wait` then the call will be immediately " "interrupted and :exc:`KeyboardInterrupt` will be raised." msgstr "" +"Si la señal SIGINT generada por :kbd:`Ctrl-C` llega mientras el hilo " +"principal está bloqueado por una llamada a :meth:`BoundedSemaphore." +"acquire` , :meth:`Lock.acquire`, :meth:`RLock.acquire`, :meth:`Semaphore." +"acquire` , :meth:`Condition.acquire` o :meth:`Condition.wait`, la llamada " +"se interrumpirá inmediatamente y :exc:`KeyboardInterrupt` se lanzará." #: ../Doc/library/multiprocessing.rst:1375 msgid "" "This differs from the behaviour of :mod:`threading` where SIGINT will be " "ignored while the equivalent blocking calls are in progress." msgstr "" +"Esto difiere del comportamiento de :mod:`threading` donde SIGINT será " +"ignorado mientras las llamadas de candado equivalentes están en progreso." #: ../Doc/library/multiprocessing.rst:1380 msgid "" @@ -1518,16 +2142,23 @@ msgid "" "import it will result in an :exc:`ImportError`. See :issue:`3770` for " "additional information." msgstr "" +"Parte de la funcionalidad de este paquete requiere una implementación de " +"semáforo compartido que funcione en el sistema operativo. Sin uno, el " +"módulo :mod:`multiprocessing.synchronize` se desactivará, y los intentos de " +"importarlo darán como resultado :exc:`ImportError`. Consulte :issue:`3770`` " +"para información adicional." #: ../Doc/library/multiprocessing.rst:1388 msgid "Shared :mod:`ctypes` Objects" -msgstr "" +msgstr "Objetos compartidos :mod:`ctypes`" #: ../Doc/library/multiprocessing.rst:1390 msgid "" "It is possible to create shared objects using shared memory which can be " "inherited by child processes." msgstr "" +"Es posible crear objetos compartidos utilizando memoria compartida que puede " +"ser heredada por procesos secundarios." #: ../Doc/library/multiprocessing.rst:1395 msgid "" @@ -1535,6 +2166,10 @@ msgid "" "return value is actually a synchronized wrapper for the object. The object " "itself can be accessed via the *value* attribute of a :class:`Value`." msgstr "" +"Retorna un objeto :mod:`ctypes` asignado desde la memoria compartida. Por " +"defecto, el valor de retorno es en realidad un contenedor sincronizado para " +"el objeto. Se puede acceder al objeto en sí a través del atributo *value* de " +"la :class:`Value`." #: ../Doc/library/multiprocessing.rst:1399 #: ../Doc/library/multiprocessing.rst:1486 @@ -1543,6 +2178,9 @@ msgid "" "a ctypes type or a one character typecode of the kind used by the :mod:" "`array` module. *\\*args* is passed on to the constructor for the type." msgstr "" +"*typecode_or_type* determina el tipo del objeto retornado: es un tipo " +"*ctypes* o un código de tipo de un carácter del tipo utilizado por el " +"módulo :mod:`array`. *\\*args* se pasa al constructor para el tipo." #: ../Doc/library/multiprocessing.rst:1403 msgid "" @@ -1553,6 +2191,12 @@ msgid "" "be automatically protected by a lock, so it will not necessarily be " "\"process-safe\"." msgstr "" +"Si *lock* es ``True`` (el valor predeterminado), se crea un nuevo objeto de " +"candado recursivo para sincronizar el acceso al valor. Si *lock* es un " +"objeto :class:`Lock` o :class:`RLock`, se usará para sincronizar el acceso " +"al valor. Si *lock* es ``False``, entonces el acceso al objeto retornado no " +"estará protegido automáticamente por un candado, por lo que no será " +"necesariamente \"proceso-seguro\"." #: ../Doc/library/multiprocessing.rst:1410 msgid "" @@ -1560,24 +2204,32 @@ msgid "" "if, for instance, you want to atomically increment a shared value it is " "insufficient to just do ::" msgstr "" +"Operaciones como ``+ =`` que implican una lectura y escritura no son " +"atómicas. Entonces, si, por ejemplo, desea incrementar atómicamente un valor " +"compartido, es insuficiente simplemente hacer::" #: ../Doc/library/multiprocessing.rst:1416 msgid "" "Assuming the associated lock is recursive (which it is by default) you can " "instead do ::" msgstr "" +"Suponiendo que el candado asociado es recursivo (que es por defecto), puede " +"hacer ::" #: ../Doc/library/multiprocessing.rst:1422 #: ../Doc/library/multiprocessing.rst:1512 #: ../Doc/library/multiprocessing.rst:1527 msgid "Note that *lock* is a keyword-only argument." -msgstr "" +msgstr "Véase que *lock* es un argumento de solo una palabra clave." #: ../Doc/library/multiprocessing.rst:1426 msgid "" "Return a ctypes array allocated from shared memory. By default the return " "value is actually a synchronized wrapper for the array." msgstr "" +"Retorna una matriz *ctypes* asignada desde la memoria compartida. Por " +"defecto, el valor de retorno es en realidad un contenedor sincronizado para " +"la matriz." #: ../Doc/library/multiprocessing.rst:1429 msgid "" @@ -1588,6 +2240,13 @@ msgid "" "zeroed. Otherwise, *size_or_initializer* is a sequence which is used to " "initialize the array and whose length determines the length of the array." msgstr "" +"*typecode_or_type* determina el tipo de los elementos de la matriz " +"retornada: es un tipo de tipo *ctypes* o un código de tipo de un carácter " +"del tipo utilizado por el módulo :mod:`array`. Si *size_or_initializer* es " +"un número entero, entonces determina la longitud de la matriz, y la matriz " +"se pondrá a cero inicialmente. De lo contrario, *size_or_initializer* es una " +"secuencia que se utiliza para inicializar la matriz y cuya longitud " +"determina la longitud de la matriz." #: ../Doc/library/multiprocessing.rst:1436 msgid "" @@ -1598,20 +2257,29 @@ msgid "" "automatically protected by a lock, so it will not necessarily be \"process-" "safe\"." msgstr "" +"Si *lock* es ``True`` (el valor predeterminado), se crea un nuevo objeto de " +"bloqueo para sincronizar el acceso al valor. Si *lock* es un objeto :class:" +"`Lock` o :class:`RLock`, se usará para sincronizar el acceso al valor. Si " +"*lock* es ``False``, entonces el acceso al objeto retornado no estará " +"protegido automáticamente por un candado, por lo que no será necesariamente " +"\"proceso seguro\"." #: ../Doc/library/multiprocessing.rst:1443 msgid "Note that *lock* is a keyword only argument." -msgstr "" +msgstr "Véase que *lock* es un argumento de solo una palabra clave." #: ../Doc/library/multiprocessing.rst:1445 msgid "" "Note that an array of :data:`ctypes.c_char` has *value* and *raw* attributes " "which allow one to use it to store and retrieve strings." msgstr "" +"Tenga en cuenta que una matriz de :data:`ctypes.c_char` tiene atributos " +"*value* y *raw* que le permiten a uno usarlo para almacenar y recuperar " +"cadenas de caracteres." #: ../Doc/library/multiprocessing.rst:1450 msgid "The :mod:`multiprocessing.sharedctypes` module" -msgstr "" +msgstr "El módulo :mod:`multiprocessing.sharedctypes`" #: ../Doc/library/multiprocessing.rst:1455 msgid "" @@ -1619,6 +2287,9 @@ msgid "" "allocating :mod:`ctypes` objects from shared memory which can be inherited " "by child processes." msgstr "" +"El módulo :mod:`multiprocessing.sharedctypes` proporciona funciones para " +"asignar objetos :mod:`ctypes` de la memoria compartida que pueden ser " +"heredados por procesos secundarios." #: ../Doc/library/multiprocessing.rst:1461 msgid "" @@ -1628,10 +2299,15 @@ msgid "" "second process and trying to dereference the pointer from the second process " "may cause a crash." msgstr "" +"Aunque es posible almacenar un puntero en la memoria compartida, recuerde " +"que esto se referirá a una ubicación en el espacio de direcciones de un " +"proceso específico. Sin embargo, es muy probable que el puntero sea inválido " +"en el contexto de un segundo proceso y tratar de desreferenciar el puntero " +"del segundo proceso puede causar un bloqueo." #: ../Doc/library/multiprocessing.rst:1469 msgid "Return a ctypes array allocated from shared memory." -msgstr "" +msgstr "Retorna una matriz *ctypes* asignada desde la memoria compartida." #: ../Doc/library/multiprocessing.rst:1471 msgid "" @@ -1642,6 +2318,13 @@ msgid "" "zeroed. Otherwise *size_or_initializer* is a sequence which is used to " "initialize the array and whose length determines the length of the array." msgstr "" +"*typecode_or_type* determina el tipo de los elementos de la matriz " +"retornada: es un tipo de tipo *ctypes* o un código de tipo de un carácter " +"del tipo utilizado por el módulo :mod:`array`. Si *size_or_initializer* es " +"un entero, entonces determina la longitud de la matriz, y la matriz se " +"pondrá a cero inicialmente. De lo contrario, *size_or_initializer* es una " +"secuencia que se usa para inicializar la matriz y cuya longitud determina la " +"longitud de la matriz." #: ../Doc/library/multiprocessing.rst:1478 msgid "" @@ -1649,10 +2332,13 @@ msgid "" "func:`Array` instead to make sure that access is automatically synchronized " "using a lock." msgstr "" +"Tenga en cuenta que configurar y obtener un elemento es potencialmente no " +"atómico -- utiliza :func:`Array` en su lugar para asegurarse de que el " +"acceso se sincronice automáticamente mediante un candado." #: ../Doc/library/multiprocessing.rst:1484 msgid "Return a ctypes object allocated from shared memory." -msgstr "" +msgstr "Retorna un objeto *ctypes* asignado desde la memoria compartida." #: ../Doc/library/multiprocessing.rst:1490 msgid "" @@ -1660,6 +2346,9 @@ msgid "" "func:`Value` instead to make sure that access is automatically synchronized " "using a lock." msgstr "" +"Tenga en cuenta que configurar y obtener el valor es potencialmente no " +"atómico -- use :func:`Value` en su lugar para asegurarse de que el acceso se " +"sincronice automáticamente mediante un candado." #: ../Doc/library/multiprocessing.rst:1494 msgid "" @@ -1667,6 +2356,9 @@ msgid "" "attributes which allow one to use it to store and retrieve strings -- see " "documentation for :mod:`ctypes`." msgstr "" +"Tenga en cuenta que una matriz de :data:`ctypes.c_char` tiene atributos " +"``value`` y` `raw`` que le permiten a uno usarlo para almacenar y recuperar " +"cadenas; consulte la documentación para :mod:`ctypes`." #: ../Doc/library/multiprocessing.rst:1500 msgid "" @@ -1674,6 +2366,9 @@ msgid "" "process-safe synchronization wrapper may be returned instead of a raw ctypes " "array." msgstr "" +"Lo mismo que :func:`RawArray`, excepto que, dependiendo del valor de *lock*, " +"se puede devolver un contenedor de sincronización seguro para el proceso en " +"lugar de una matriz de tipos crudos." #: ../Doc/library/multiprocessing.rst:1504 #: ../Doc/library/multiprocessing.rst:1520 @@ -1685,6 +2380,12 @@ msgid "" "returned object will not be automatically protected by a lock, so it will " "not necessarily be \"process-safe\"." msgstr "" +"Si *lock* es ``True`` (el valor predeterminado), se crea un nuevo objeto " +"candado para sincronizar el acceso al valor. Si *lock* es un objeto :class: " +"`~multiprocessing.Lock` o :class:`~multiprocessing.RLock`, se utilizará para " +"sincronizar el acceso al valor. Si *lock* es `` False``, entonces el acceso " +"al objeto retornado no estará protegido automáticamente por un candado, por " +"lo que no será necesariamente \"seguro para el proceso\"." #: ../Doc/library/multiprocessing.rst:1516 msgid "" @@ -1692,12 +2393,17 @@ msgid "" "process-safe synchronization wrapper may be returned instead of a raw ctypes " "object." msgstr "" +"Lo mismo que :func:`RawValue` excepto que, dependiendo del valor de *lock*, " +"se puede devolver una envoltura de sincronización segura para el proceso en " +"lugar de un objeto *ctypes* sin procesar." #: ../Doc/library/multiprocessing.rst:1531 msgid "" "Return a ctypes object allocated from shared memory which is a copy of the " "ctypes object *obj*." msgstr "" +"Retorna un objeto *ctypes* asignado de la memoria compartida, que es una " +"copia del objeto *ctypes* *obj*." #: ../Doc/library/multiprocessing.rst:1536 msgid "" @@ -1705,6 +2411,9 @@ msgid "" "to synchronize access. If *lock* is ``None`` (the default) then a :class:" "`multiprocessing.RLock` object is created automatically." msgstr "" +"Retorna un objeto contenedor seguro para un objeto *ctypes* que usa *lock* " +"para sincronizar el acceso. Si *lock* es ``None`` (el valor predeterminado), " +"se crea automáticamente un objeto :class:`multiprocessing.RLock`." #: ../Doc/library/multiprocessing.rst:1540 msgid "" @@ -1712,16 +2421,22 @@ msgid "" "object it wraps: :meth:`get_obj` returns the wrapped object and :meth:" "`get_lock` returns the lock object used for synchronization." msgstr "" +"Un contenedor sincronizado tendrá dos métodos además de los del objeto que " +"envuelve: :meth:`get_obj` retorna el objeto envuelto y :meth:`get_lock` " +"retorna el objeto de bloqueo utilizado para la sincronización." #: ../Doc/library/multiprocessing.rst:1544 msgid "" "Note that accessing the ctypes object through the wrapper can be a lot " "slower than accessing the raw ctypes object." msgstr "" +"Tenga en cuenta que acceder al objeto *ctypes* a través del contenedor puede " +"ser mucho más lento que acceder al objeto *ctypes* sin formato." #: ../Doc/library/multiprocessing.rst:1547 msgid "Synchronized objects support the :term:`context manager` protocol." msgstr "" +"Los objetos sincronizados admiten el protocolo: :term:`context manager`." #: ../Doc/library/multiprocessing.rst:1551 msgid "" @@ -1729,76 +2444,81 @@ msgid "" "shared memory with the normal ctypes syntax. (In the table ``MyStruct`` is " "some subclass of :class:`ctypes.Structure`.)" msgstr "" +"La siguiente tabla compara la sintaxis para crear objetos *ctypes* " +"compartidos desde la memoria compartida con la sintaxis *ctypes* normal. (En " +"la tabla ``MyStruct`` hay alguna subclase de :class:`ctypes.Structure`.)" #: ../Doc/library/multiprocessing.rst:1556 msgid "ctypes" -msgstr "" +msgstr "*ctypes*" #: ../Doc/library/multiprocessing.rst:1556 msgid "sharedctypes using type" -msgstr "" +msgstr "*sharedctypes* usando *type*" #: ../Doc/library/multiprocessing.rst:1556 msgid "sharedctypes using typecode" -msgstr "" +msgstr "*sharedctypes* usando *typecode*" #: ../Doc/library/multiprocessing.rst:1558 msgid "c_double(2.4)" -msgstr "" +msgstr "*c_double(2.4)*" #: ../Doc/library/multiprocessing.rst:1558 msgid "RawValue(c_double, 2.4)" -msgstr "" +msgstr "*RawValue(c_double, 2.4)*" #: ../Doc/library/multiprocessing.rst:1558 msgid "RawValue('d', 2.4)" -msgstr "" +msgstr "*RawValue(‘d’, 2.4)*" #: ../Doc/library/multiprocessing.rst:1559 msgid "MyStruct(4, 6)" -msgstr "" +msgstr "*MyStruct(4, 6)*" #: ../Doc/library/multiprocessing.rst:1559 msgid "RawValue(MyStruct, 4, 6)" -msgstr "" +msgstr "*RawValue(MyStruct, 4, 6)*" #: ../Doc/library/multiprocessing.rst:1560 msgid "(c_short * 7)()" -msgstr "" +msgstr "*(c_short * 7)()*" #: ../Doc/library/multiprocessing.rst:1560 msgid "RawArray(c_short, 7)" -msgstr "" +msgstr "*RawArray(c_short, 7)*" #: ../Doc/library/multiprocessing.rst:1560 msgid "RawArray('h', 7)" -msgstr "" +msgstr "*RawArray(‘h’, 7)*" #: ../Doc/library/multiprocessing.rst:1561 msgid "(c_int * 3)(9, 2, 8)" -msgstr "" +msgstr "*(c_int * 3)(9, 2, 8)*" #: ../Doc/library/multiprocessing.rst:1561 msgid "RawArray(c_int, (9, 2, 8))" -msgstr "" +msgstr "*RawArray(c_int, (9, 2, 8))*" #: ../Doc/library/multiprocessing.rst:1561 msgid "RawArray('i', (9, 2, 8))" -msgstr "" +msgstr "*RawArray(‘i’, (9, 2, 8))*" #: ../Doc/library/multiprocessing.rst:1565 msgid "" "Below is an example where a number of ctypes objects are modified by a child " "process::" msgstr "" +"A continuación se muestra un ejemplo donde un número de objetos *ctypes* son " +"modificados por un proceso hijo::" #: ../Doc/library/multiprocessing.rst:1603 msgid "The results printed are ::" -msgstr "" +msgstr "Los resultados impresos son ::" #: ../Doc/library/multiprocessing.rst:1616 msgid "Managers" -msgstr "" +msgstr "Administradores (*Managers*)" #: ../Doc/library/multiprocessing.rst:1618 msgid "" @@ -1808,6 +2528,12 @@ msgid "" "*shared objects*. Other processes can access the shared objects by using " "proxies." msgstr "" +"Los administradores (*managers*) proporcionan una forma de crear datos que " +"se pueden compartir entre diferentes procesos, incluido el intercambio en " +"una red entre procesos que se ejecutan en diferentes máquinas. Un objeto " +"administrador controla un proceso de servidor que gestiona *shared objects* " +"(*objetos compartidos*). Otros procesos pueden acceder a los objetos " +"compartidos mediante el uso de servidores proxy." #: ../Doc/library/multiprocessing.rst:1626 msgid "" @@ -1816,6 +2542,11 @@ msgid "" "manager object corresponds to a spawned child process and has methods which " "will create shared objects and return corresponding proxies." msgstr "" +"Retorna un objeto iniciado :class:`~multiprocessing.managers.SyncManager` " +"que se puede usar para compartir objetos entre procesos. El objeto " +"administrador retornado corresponde a un proceso hijo generado y tiene " +"métodos que crearán objetos compartidos y devolverán los *proxies* " +"correspondientes." #: ../Doc/library/multiprocessing.rst:1634 msgid "" @@ -1823,10 +2554,13 @@ msgid "" "their parent process exits. The manager classes are defined in the :mod:" "`multiprocessing.managers` module:" msgstr "" +"Los procesos del administrador se cerrarán tan pronto como se recolecte la " +"basura o salga su proceso padre. Las clases de administrador se definen en " +"el módulo :mod:`multiprocessing.managers`:" #: ../Doc/library/multiprocessing.rst:1640 msgid "Create a BaseManager object." -msgstr "" +msgstr "Crear un objeto *BaseManager*." #: ../Doc/library/multiprocessing.rst:1642 msgid "" @@ -1834,12 +2568,17 @@ msgid "" "serve_forever()`` to ensure that the manager object refers to a started " "manager process." msgstr "" +"Una vez creado, debe llamar a :meth:`start` o ``get_server()." +"serve_forever()`` para asegurarse de que el objeto de administrador se " +"refiera a un proceso de administrador iniciado." #: ../Doc/library/multiprocessing.rst:1645 msgid "" "*address* is the address on which the manager process listens for new " "connections. If *address* is ``None`` then an arbitrary one is chosen." msgstr "" +"*address* es la dirección en la que el proceso del administrador escucha las " +"nuevas conexiones. Si *address* es ``None``, se elige una arbitrariamente." #: ../Doc/library/multiprocessing.rst:1648 msgid "" @@ -1848,12 +2587,19 @@ msgid "" "then ``current_process().authkey`` is used. Otherwise *authkey* is used and " "it must be a byte string." msgstr "" +"*authkey* es la clave de autenticación que se utilizará para verificar la " +"validez de las conexiones entrantes al proceso del servidor. Si *authkey* es " +"``None``, entonces se usa ``current_process().authkey``. De lo contrario, se " +"usa *authkey* y debe ser una cadena de *bytes*." #: ../Doc/library/multiprocessing.rst:1655 msgid "" "Start a subprocess to start the manager. If *initializer* is not ``None`` " "then the subprocess will call ``initializer(*initargs)`` when it starts." msgstr "" +"Se inicia un subproceso para iniciar el administrador. Si *initializer* no " +"es ``None``, entonces el subproceso llamará ``initializer(*initargs)`` " +"cuando se inicie." #: ../Doc/library/multiprocessing.rst:1660 msgid "" @@ -1861,36 +2607,48 @@ msgid "" "the control of the Manager. The :class:`Server` object supports the :meth:" "`serve_forever` method::" msgstr "" +"Retorna un objeto :class:`Server` que representa el servidor real bajo el " +"control del Administrador. El objeto :class:`Server` admite el método :meth:" +"`serve_forever` ::" #: ../Doc/library/multiprocessing.rst:1669 msgid ":class:`Server` additionally has an :attr:`address` attribute." -msgstr "" +msgstr ":class:`Server` tiene un atributo adicional :attr:`address`." #: ../Doc/library/multiprocessing.rst:1673 msgid "Connect a local manager object to a remote manager process::" msgstr "" +"Conecta un objeto de administrador (*manager*) local a un proceso de " +"administrador remoto::" #: ../Doc/library/multiprocessing.rst:1681 msgid "" "Stop the process used by the manager. This is only available if :meth:" "`start` has been used to start the server process." msgstr "" +"Detiene el proceso utilizado por el gerente (*manager*). Esto solo está " +"disponible si :meth:`start` se ha utilizado para iniciar el proceso del " +"servidor." #: ../Doc/library/multiprocessing.rst:1684 msgid "This can be called multiple times." -msgstr "" +msgstr "Esto se puede llamar múltiples veces." #: ../Doc/library/multiprocessing.rst:1688 msgid "" "A classmethod which can be used for registering a type or callable with the " "manager class." msgstr "" +"Un método de clase que puede usarse para registrar un tipo o invocarse con " +"la clase de administrador (*manager*)." #: ../Doc/library/multiprocessing.rst:1691 msgid "" "*typeid* is a \"type identifier\" which is used to identify a particular " "type of shared object. This must be a string." msgstr "" +"*typeid* es un \"identificador de tipo\" que se utiliza para identificar un " +"tipo particular de objeto compartido. Esto debe ser una cadena de caracteres." #: ../Doc/library/multiprocessing.rst:1694 msgid "" @@ -1899,6 +2657,10 @@ msgid "" "the :meth:`connect` method, or if the *create_method* argument is ``False`` " "then this can be left as ``None``." msgstr "" +"*callable* es un invocable utilizado para crear objetos para este " +"identificador de tipo. Si una instancia de administrador se conectará al " +"servidor utilizando el método :meth:`connect`, o si el argumento " +"*create_method* es ``False``, esto se puede dejar como ``None``." #: ../Doc/library/multiprocessing.rst:1700 msgid "" @@ -1906,6 +2668,9 @@ msgid "" "proxies for shared objects with this *typeid*. If ``None`` then a proxy " "class is created automatically." msgstr "" +"*proxytype* es una subclase de :class:`BaseProxy` que se usa para crear " +"*proxies* para objetos compartidos con este *typeid*. Si ``None``, se crea " +"automáticamente una clase *proxy*." #: ../Doc/library/multiprocessing.rst:1704 msgid "" @@ -1917,6 +2682,14 @@ msgid "" "\"public method\" means any attribute which has a :meth:`~object.__call__` " "method and whose name does not begin with ``'_'``.)" msgstr "" +"Se utiliza *exposed* para especificar una secuencia de nombres de métodos a " +"los que se debe permitir el acceso de los servidores proxy para este tipo de " +"identificación utilizando :meth:`BaseProxy._callmethod`. (Si *exposed* es " +"``None``, entonces :attr:`proxytype._exposed_` se usa en su lugar si " +"existe). En el caso de que no se especifique una lista expuesta, todos los " +"\"métodos públicos\" del objeto compartido serán accesibles . (Aquí un " +"\"método público\" significa cualquier atributo que tenga un método :meth:`~ " +"object .__ call__` y cuyo nombre no comience con` `'_'``.)" #: ../Doc/library/multiprocessing.rst:1713 msgid "" @@ -1927,6 +2700,13 @@ msgid "" "not a key of this mapping or if the mapping is ``None`` then the object " "returned by the method will be copied by value." msgstr "" +"El *method_to_typeid* es una asignación utilizada para especificar el tipo " +"de retorno de los métodos expuestos que deberían devolver un proxy. Asigna " +"nombres de métodos a cadenas typeid. (Si *method_to_typeid* es ``None`` " +"entonces :attr:`proxytype._method_to_typeid` se usa en su lugar si existe). " +"Si el nombre de un método no es una clave de esta asignación o si la " +"asignación es` `None`` entonces el objeto retornado por el método se copiará " +"por valor." #: ../Doc/library/multiprocessing.rst:1720 msgid "" @@ -1934,14 +2714,19 @@ msgid "" "*typeid* which can be used to tell the server process to create a new shared " "object and return a proxy for it. By default it is ``True``." msgstr "" +"*create_method* determina si un método debe crearse con el nombre *typeid* " +"que se puede usar para indicarle al proceso del servidor que cree un nuevo " +"objeto compartido y retornando un proxy para él. Por defecto es ``True``." #: ../Doc/library/multiprocessing.rst:1724 msgid ":class:`BaseManager` instances also have one read-only property:" msgstr "" +":class:`BaseManager` las instancias también tienen una propiedad de solo " +"lectura:" #: ../Doc/library/multiprocessing.rst:1728 msgid "The address used by the manager." -msgstr "" +msgstr "La dirección utilizada por el administrador." #: ../Doc/library/multiprocessing.rst:1730 msgid "" @@ -1950,12 +2735,19 @@ msgid "" "process (if it has not already started) and then returns the manager " "object. :meth:`~contextmanager.__exit__` calls :meth:`shutdown`." msgstr "" +"Los objetos de administrador admiten el protocolo de gestión de contexto; " +"consulte :ref:`typecontextmanager`. :meth:`~contextmanager.__ enter__` " +"inicia el proceso del servidor (si aún no se ha iniciado) y luego retorna el " +"objeto de administrador. :meth:`~contextmanager .__ exit__` llama :meth:" +"`shutdown`." #: ../Doc/library/multiprocessing.rst:1736 msgid "" "In previous versions :meth:`~contextmanager.__enter__` did not start the " "manager's server process if it was not already started." msgstr "" +"En versiones anteriores :meth:`~contextmanager.__ enter__` no iniciaba el " +"proceso del servidor del administrador si aún no se había iniciado." #: ../Doc/library/multiprocessing.rst:1741 msgid "" @@ -1963,6 +2755,9 @@ msgid "" "of processes. Objects of this type are returned by :func:`multiprocessing." "Manager`." msgstr "" +"Una subclase de :class:`BaseManager` que se puede utilizar para la " +"sincronización de procesos. Los objetos de este tipo son retornados por :" +"func:`multiprocessing.Manager`." #: ../Doc/library/multiprocessing.rst:1745 msgid "" @@ -1970,76 +2765,99 @@ msgid "" "number of commonly used data types to be synchronized across processes. This " "notably includes shared lists and dictionaries." msgstr "" +"Sus métodos crean y retornan :ref:`multiprocessing-proxy_objects` para " +"varios tipos de datos de uso común que se sincronizarán entre procesos. Esto " +"incluye notablemente listas compartidas y diccionarios." #: ../Doc/library/multiprocessing.rst:1751 msgid "" "Create a shared :class:`threading.Barrier` object and return a proxy for it." msgstr "" +":class:`threading.Barrier` crea un objeto compartido y retorna un *proxy* " +"para él." #: ../Doc/library/multiprocessing.rst:1758 msgid "" "Create a shared :class:`threading.BoundedSemaphore` object and return a " "proxy for it." msgstr "" +"Crea un objeto compartido :class:`threading.BoundedSemaphore` y retorna un " +"*proxy* para él." #: ../Doc/library/multiprocessing.rst:1763 msgid "" "Create a shared :class:`threading.Condition` object and return a proxy for " "it." msgstr "" +"Crea un objeto compartido :class:`threading.Condition` y retorna un *proxy* " +"para él." #: ../Doc/library/multiprocessing.rst:1766 msgid "" "If *lock* is supplied then it should be a proxy for a :class:`threading." "Lock` or :class:`threading.RLock` object." msgstr "" +"Si se proporciona *lock*, debería ser un *proxy* para un objeto :class:" +"`threading.Lock` o :class:`threading.RLock`." #: ../Doc/library/multiprocessing.rst:1774 msgid "" "Create a shared :class:`threading.Event` object and return a proxy for it." msgstr "" +"Crea un objeto compartido :class:`threading.Event` y retorna un *proxy* para " +"él." #: ../Doc/library/multiprocessing.rst:1778 msgid "" "Create a shared :class:`threading.Lock` object and return a proxy for it." msgstr "" +"Crea un objeto compartido :class:`threading.Lock` y retorna un *proxy* para " +"él." #: ../Doc/library/multiprocessing.rst:1782 msgid "Create a shared :class:`Namespace` object and return a proxy for it." msgstr "" +"Crea un objeto compartido :class:`Namespace` y retorna un *proxy* para él." #: ../Doc/library/multiprocessing.rst:1786 msgid "Create a shared :class:`queue.Queue` object and return a proxy for it." msgstr "" +"Crea un objeto compartido :class:`queue.Queue` y retorna un *proxy* para él." #: ../Doc/library/multiprocessing.rst:1790 msgid "" "Create a shared :class:`threading.RLock` object and return a proxy for it." msgstr "" +"Crea un objeto compartido :class:`threading.RLock` y retorna un *proxy* para " +"él." #: ../Doc/library/multiprocessing.rst:1794 msgid "" "Create a shared :class:`threading.Semaphore` object and return a proxy for " "it." msgstr "" +"Crea un objeto compartido :class:`threading.Semaphore` y retorna un proxy " +"para él." #: ../Doc/library/multiprocessing.rst:1799 msgid "Create an array and return a proxy for it." -msgstr "" +msgstr "Crea un arreglo y retorna un proxy para ello." #: ../Doc/library/multiprocessing.rst:1803 msgid "" "Create an object with a writable ``value`` attribute and return a proxy for " "it." msgstr "" +"Crea un objeto con un atributo de escritura ``value`` y retorna un proxy " +"para él." #: ../Doc/library/multiprocessing.rst:1810 msgid "Create a shared :class:`dict` object and return a proxy for it." -msgstr "" +msgstr "Crea un objeto compartido :class:`dict` y retorna un *proxy* para él." #: ../Doc/library/multiprocessing.rst:1815 msgid "Create a shared :class:`list` object and return a proxy for it." -msgstr "" +msgstr "Crea un objeto compartido :class:`list` y retorna un *proxy* para él." #: ../Doc/library/multiprocessing.rst:1817 msgid "" @@ -2047,16 +2865,22 @@ msgid "" "object such as a shared list can contain other shared objects which will all " "be managed and synchronized by the :class:`SyncManager`." msgstr "" +"Los objetos compartidos pueden anidarse. Por ejemplo, un objeto contenedor " +"compartido, como una lista compartida, puede contener otros objetos " +"compartidos que serán administrados y sincronizados por :class:`SyncManager`." #: ../Doc/library/multiprocessing.rst:1824 msgid "A type that can register with :class:`SyncManager`." -msgstr "" +msgstr "Un tipo que puede registrarse con :class:`SyncManager`." #: ../Doc/library/multiprocessing.rst:1826 msgid "" "A namespace object has no public methods, but does have writable attributes. " "Its representation shows the values of its attributes." msgstr "" +"Un objeto de espacio de nombres no tiene métodos públicos, pero tiene " +"atributos de escritura. Su representación muestra los valores de sus " +"atributos." #: ../Doc/library/multiprocessing.rst:1829 msgid "" @@ -2064,10 +2888,13 @@ msgid "" "with ``'_'`` will be an attribute of the proxy and not an attribute of the " "referent:" msgstr "" +"Sin embargo, cuando se usa un proxy para un objeto de espacio de nombres, un " +"atributo que comience con `` '_'`` será un atributo del *proxy* y no un " +"atributo del referente:" #: ../Doc/library/multiprocessing.rst:1845 msgid "Customized managers" -msgstr "" +msgstr "Administradores customizables (*Customized managers*)" #: ../Doc/library/multiprocessing.rst:1847 msgid "" @@ -2075,40 +2902,51 @@ msgid "" "and uses the :meth:`~BaseManager.register` classmethod to register new types " "or callables with the manager class. For example::" msgstr "" +"Para crear su propio administrador, uno crea una subclase de :class:" +"`BaseManager` y utiliza el método de clase :meth:`~BaseManager.register` " +"para registrar nuevos tipos o llamadas con la clase de administrador. Por " +"ejemplo::" #: ../Doc/library/multiprocessing.rst:1872 msgid "Using a remote manager" -msgstr "" +msgstr "Utilizando un administrador (*manager*) remoto" #: ../Doc/library/multiprocessing.rst:1874 msgid "" "It is possible to run a manager server on one machine and have clients use " "it from other machines (assuming that the firewalls involved allow it)." msgstr "" +"Es posible ejecutar un servidor administrador en una máquina y hacer que los " +"clientes lo usen desde otras máquinas (suponiendo que los *firewalls* " +"involucrados lo permitan)." #: ../Doc/library/multiprocessing.rst:1877 msgid "" "Running the following commands creates a server for a single shared queue " "which remote clients can access::" msgstr "" +"La ejecución de los siguientes comandos crea un servidor para una única cola " +"compartida a la que los clientes remotos pueden acceder::" #: ../Doc/library/multiprocessing.rst:1889 msgid "One client can access the server as follows::" -msgstr "" +msgstr "Un cliente puede tener accesos al servidor de la siguiente manera::" #: ../Doc/library/multiprocessing.rst:1899 msgid "Another client can also use it::" -msgstr "" +msgstr "Otro cliente puede también usarlo::" #: ../Doc/library/multiprocessing.rst:1910 msgid "" "Local processes can also access that queue, using the code from above on the " "client to access it remotely::" msgstr "" +"Los procesos locales también pueden acceder a esa cola (*queue*), utilizando " +"el código de arriba en el cliente para acceder de forma remota::" #: ../Doc/library/multiprocessing.rst:1935 msgid "Proxy Objects" -msgstr "" +msgstr "Objetos Proxy (*Proxy Objects*)" #: ../Doc/library/multiprocessing.rst:1937 msgid "" @@ -2116,6 +2954,10 @@ msgid "" "(presumably) in a different process. The shared object is said to be the " "*referent* of the proxy. Multiple proxy objects may have the same referent." msgstr "" +"Un proxy es un objeto que *se refiere* (*refers*) a un objeto compartido que " +"vive (presumiblemente) en un proceso diferente. Se dice que el objeto " +"compartido es el *referente* (*referent*) del *proxy*. Varios objetos " +"*proxy* pueden tener el mismo referente." #: ../Doc/library/multiprocessing.rst:1941 msgid "" @@ -2124,6 +2966,10 @@ msgid "" "available through the proxy). In this way, a proxy can be used just like " "its referent can:" msgstr "" +"Un objeto proxy tiene métodos que invocan los métodos correspondientes de su " +"referente (aunque no todos los métodos del referente estarán necesariamente " +"disponibles a través del proxy). De esta manera, un proxy se puede usar al " +"igual que su referente:" #: ../Doc/library/multiprocessing.rst:1959 msgid "" @@ -2131,6 +2977,9 @@ msgid "" "of the referent, whereas applying :func:`repr` will return the " "representation of the proxy." msgstr "" +"Tenga en cuenta que la aplicación :func:`str` a un proxy devolverá la " +"representación del referente, mientras que la aplicación :func:`repr` " +"devolverá la representación del proxy." #: ../Doc/library/multiprocessing.rst:1963 msgid "" @@ -2139,10 +2988,16 @@ msgid "" "`multiprocessing-proxy_objects`. This permits nesting of these managed " "lists, dicts, and other :ref:`multiprocessing-proxy_objects`:" msgstr "" +"Una característica importante de los objetos proxy es que son seleccionables " +"para que puedan pasarse entre procesos. Como tal, un referente puede " +"contener :ref:`multiprocessing-proxy_objects`. Esto permite anidar estas " +"listas administradas, dictados y otros :ref:`multiprocessing-proxy_objects`:" #: ../Doc/library/multiprocessing.rst:1979 msgid "Similarly, dict and list proxies may be nested inside one another::" msgstr "" +"Del mismo modo, los proxies *dict* y *list* pueden estar anidados uno dentro " +"del otro::" #: ../Doc/library/multiprocessing.rst:1992 msgid "" @@ -2154,6 +3009,14 @@ msgid "" "through the manager and so to effectively modify such an item, one could re-" "assign the modified value to the container proxy::" msgstr "" +"Si los objetos estándar (no proxy) :class:`list` or :class:`dict` están " +"contenidos en un referente, las modificaciones a esos valores mutables no se " +"propagarán a través del administrador porque el proxy no tiene forma de " +"saber cuándo los valores contenidos dentro son modificados. Sin embargo, " +"almacenar un valor en un proxy de contenedor (que desencadena un " +"``__setitem__`` en el objeto proxy) se propaga a través del administrador y, " +"por lo tanto, para modificar efectivamente dicho elemento, uno podría " +"reasignar el valor modificado al proxy de contenedor::" #: ../Doc/library/multiprocessing.rst:2011 msgid "" @@ -2161,38 +3024,45 @@ msgid "" "`multiprocessing-proxy_objects` for most use cases but also demonstrates a " "level of control over the synchronization." msgstr "" +"Este enfoque es quizás menos conveniente que emplear anidado :ref:" +"`multiprocessing-proxy_objects` para la mayoría de los casos de uso, pero " +"también demuestra un nivel de control sobre la sincronización." #: ../Doc/library/multiprocessing.rst:2017 msgid "" "The proxy types in :mod:`multiprocessing` do nothing to support comparisons " "by value. So, for instance, we have:" msgstr "" +"Los tipos de proxy en :mod:`multiprocessing` no hacen nada para admitir " +"comparaciones por valor. Entonces, por ejemplo, tenemos:" #: ../Doc/library/multiprocessing.rst:2025 msgid "" "One should just use a copy of the referent instead when making comparisons." msgstr "" +"En su lugar, se debe usar una copia del referente al hacer comparaciones." #: ../Doc/library/multiprocessing.rst:2029 msgid "Proxy objects are instances of subclasses of :class:`BaseProxy`." -msgstr "" +msgstr "Los objetos proxy son instancias de subclases de :class:`BaseProxy`." #: ../Doc/library/multiprocessing.rst:2033 msgid "Call and return the result of a method of the proxy's referent." -msgstr "" +msgstr "Llama y retorna el resultado de un método del referente del proxy." #: ../Doc/library/multiprocessing.rst:2035 msgid "" "If ``proxy`` is a proxy whose referent is ``obj`` then the expression ::" msgstr "" +"Si ``proxy`` es un proxy cuyo referente es ``obj`` entonces la expresión ::" #: ../Doc/library/multiprocessing.rst:2039 msgid "will evaluate the expression ::" -msgstr "" +msgstr "evaluará la expresión ::" #: ../Doc/library/multiprocessing.rst:2043 msgid "in the manager's process." -msgstr "" +msgstr "en el proceso del administrador." #: ../Doc/library/multiprocessing.rst:2045 msgid "" @@ -2200,6 +3070,9 @@ msgid "" "new shared object -- see documentation for the *method_to_typeid* argument " "of :meth:`BaseManager.register`." msgstr "" +"El valor retornado será una copia del resultado de la llamada o un proxy a " +"un nuevo objeto compartido; consulte la documentación del argumento " +"*method_to_typeid* de :meth:`BaseManager.register`." #: ../Doc/library/multiprocessing.rst:2049 msgid "" @@ -2208,58 +3081,73 @@ msgid "" "then this is converted into a :exc:`RemoteError` exception and is raised by :" "meth:`_callmethod`." msgstr "" +"Si la llamada genera una excepción, entonces se vuelve a generar :meth:" +"`_callmethod`. Si se genera alguna otra excepción en el proceso del " +"administrador, esto se convierte en una excepción :exc:`RemoteError` y se " +"genera mediante :meth:`_callmethod`." #: ../Doc/library/multiprocessing.rst:2054 msgid "" "Note in particular that an exception will be raised if *methodname* has not " "been *exposed*." msgstr "" +"Tenga en cuenta en particular que se generará una excepción si *methodname* " +"no ha sido *exposed*." #: ../Doc/library/multiprocessing.rst:2057 msgid "An example of the usage of :meth:`_callmethod`:" -msgstr "" +msgstr "Un ejemplo de uso de :meth:`_callmethod`:" #: ../Doc/library/multiprocessing.rst:2073 msgid "Return a copy of the referent." -msgstr "" +msgstr "Retorna una copia del referente." #: ../Doc/library/multiprocessing.rst:2075 msgid "If the referent is unpicklable then this will raise an exception." msgstr "" +"Si el referente no se puede deserializar (*unpicklable*), esto generará una " +"excepción." #: ../Doc/library/multiprocessing.rst:2079 msgid "Return a representation of the proxy object." -msgstr "" +msgstr "Retorna una representación de un objeto proxy." #: ../Doc/library/multiprocessing.rst:2083 msgid "Return the representation of the referent." -msgstr "" +msgstr "Retorna una representación del referente." #: ../Doc/library/multiprocessing.rst:2087 msgid "Cleanup" -msgstr "" +msgstr "Limpieza (*Cleanup*)" #: ../Doc/library/multiprocessing.rst:2089 msgid "" "A proxy object uses a weakref callback so that when it gets garbage " "collected it deregisters itself from the manager which owns its referent." msgstr "" +"Un objeto proxy utiliza una devolución de llamada (*callback*) de referencia " +"débil (*weakref*) para que cuando sea recolectado por el recolector de " +"basura se da de baja del administrador que posee su referente." #: ../Doc/library/multiprocessing.rst:2092 msgid "" "A shared object gets deleted from the manager process when there are no " "longer any proxies referring to it." msgstr "" +"Un objeto compartido se elimina del proceso del administrador cuando ya no " +"hay ningún proxy que se refiera a él." #: ../Doc/library/multiprocessing.rst:2097 msgid "Process Pools" -msgstr "" +msgstr "Piscinas de procesos (*Process Pools*)" #: ../Doc/library/multiprocessing.rst:2102 msgid "" "One can create a pool of processes which will carry out tasks submitted to " "it with the :class:`Pool` class." msgstr "" +"Se puede crear un grupo de procesos que llevarán a cabo las tareas que se le " +"presenten con la :class:`Pool` class." #: ../Doc/library/multiprocessing.rst:2107 msgid "" @@ -2267,18 +3155,26 @@ msgid "" "jobs can be submitted. It supports asynchronous results with timeouts and " "callbacks and has a parallel map implementation." msgstr "" +"Un objeto de grupo de procesos que controla un grupo de procesos de trabajo " +"a los que se pueden enviar trabajos. Admite resultados asincrónicos con " +"tiempos de espera y devoluciones de llamada y tiene una implementación de " +"mapa paralelo." #: ../Doc/library/multiprocessing.rst:2111 msgid "" "*processes* is the number of worker processes to use. If *processes* is " "``None`` then the number returned by :func:`os.cpu_count` is used." msgstr "" +"*processes* es el número de procesos de trabajo a utilizar. Si *processes* " +"es ``None`` , se utiliza el número retornado por :func:`os.cpu_count`." #: ../Doc/library/multiprocessing.rst:2114 msgid "" "If *initializer* is not ``None`` then each worker process will call " "``initializer(*initargs)`` when it starts." msgstr "" +"Si *initializer* no es ``None``, cada proceso de trabajo llamará " +"``initializer(*initargs)`` cuando se inicie." #: ../Doc/library/multiprocessing.rst:2117 msgid "" @@ -2287,6 +3183,11 @@ msgid "" "unused resources to be freed. The default *maxtasksperchild* is ``None``, " "which means worker processes will live as long as the pool." msgstr "" +"*maxtasksperchild* es el número de tareas que un proceso de trabajo puede " +"completar antes de salir y ser reemplazado por un proceso de trabajo nuevo, " +"para permitir que se liberen los recursos no utilizados. El valor " +"predeterminado *maxtasksperchild* es ``None`` , lo que significa que los " +"procesos de trabajo vivirán tanto tiempo como el grupo." #: ../Doc/library/multiprocessing.rst:2122 msgid "" @@ -2295,12 +3196,19 @@ msgid "" "`multiprocessing.Pool` or the :meth:`Pool` method of a context object. In " "both cases *context* is set appropriately." msgstr "" +"*context* se puede utilizar para especificar el contexto utilizado para " +"iniciar los procesos de trabajo. Por lo general, un grupo se crea utilizando " +"la función :func:`multiprocessing.Pool` o el método de un objeto de " +"contexto :meth:`Pool`. En ambos casos, *context* se establece de manera " +"adecuada." #: ../Doc/library/multiprocessing.rst:2128 msgid "" "Note that the methods of the pool object should only be called by the " "process which created the pool." msgstr "" +"Tenga en cuenta que los métodos del objeto de grupo solo deben ser invocados " +"por el proceso que creó el grupo." #: ../Doc/library/multiprocessing.rst:2132 msgid "" @@ -2309,6 +3217,11 @@ msgid "" "manager or by calling :meth:`close` and :meth:`terminate` manually. Failure " "to do this can lead to the process hanging on finalization." msgstr "" +"Los objetos :class:`multiprocessing.pool` tienen recursos internos que " +"necesitan ser administrados adecuadamente (como cualquier otro recurso) " +"utilizando el grupo como administrador de contexto o llamando a :meth:" +"`close` y :meth:`terminate` manualmente. De lo contrario, el proceso puede " +"demorarse en la finalización." #: ../Doc/library/multiprocessing.rst:2137 msgid "" @@ -2316,14 +3229,18 @@ msgid "" "pool as CPython does not assure that the finalizer of the pool will be " "called (see :meth:`object.__del__` for more information)." msgstr "" +"Tenga en cuenta que **not correct** (**no correcto**)confiar en el " +"recolector de basura para destruir el grupo ya que *CPython* no asegura que " +"se llamará al finalizador del grupo (consulte :meth:`object.__ del__` para " +"obtener más información)." #: ../Doc/library/multiprocessing.rst:2141 msgid "*maxtasksperchild*" -msgstr "" +msgstr "*maxtasksperchild*" #: ../Doc/library/multiprocessing.rst:2144 msgid "*context*" -msgstr "" +msgstr "*context*" #: ../Doc/library/multiprocessing.rst:2149 msgid "" @@ -2335,6 +3252,14 @@ msgid "" "one. The *maxtasksperchild* argument to the :class:`Pool` exposes this " "ability to the end user." msgstr "" +"Los procesos de los trabajadores dentro de una :class:`Pool` normalmente " +"viven durante la duración completa de la cola de trabajo de la piscina. Un " +"patrón frecuente que se encuentra en otros sistemas (como *Apache, mod_wsgi," +"* etc.) para liberar recursos en poder de los trabajadores es permitir que " +"un trabajador dentro de un grupo complete solo una cantidad determinada de " +"trabajo antes de salir, limpiarse y generar un nuevo proceso para reemplazar " +"el viejo. El argumento *maxtasksperchild* para :class:`Pool` expone esta " +"capacidad al usuario final." #: ../Doc/library/multiprocessing.rst:2159 msgid "" @@ -2343,10 +3268,15 @@ msgid "" "suited for performing work in parallel. Additionally, *func* is only " "executed in one of the workers of the pool." msgstr "" +"Llama a *func* con argumentos *args* y argumentos de palabras clave *kwds*. " +"Se bloquea hasta que el resultado esté listo. Dados estos bloques, :meth:" +"`apply_async` es más adecuado para realizar trabajos en paralelo. Además, " +"*func* solo se ejecuta en uno de los trabajadores de piscina." #: ../Doc/library/multiprocessing.rst:2166 msgid "A variant of the :meth:`apply` method which returns a result object." msgstr "" +"Una variante del método :meth:`apply` que retorna un objeto de resultado." #: ../Doc/library/multiprocessing.rst:2168 #: ../Doc/library/multiprocessing.rst:2198 @@ -2356,6 +3286,9 @@ msgid "" "that is unless the call failed, in which case the *error_callback* is " "applied instead." msgstr "" +"Si se especifica *callback*, debería ser un invocable que acepte un único " +"argumento. Cuando el resultado está listo, se le aplica *callback*, a menos " +"que la llamada falle, en cuyo caso se aplica *error_callback*." #: ../Doc/library/multiprocessing.rst:2173 #: ../Doc/library/multiprocessing.rst:2203 @@ -2364,6 +3297,9 @@ msgid "" "a single argument. If the target function fails, then the *error_callback* " "is called with the exception instance." msgstr "" +"Si se especifica *error_callback*, debería ser un invocable que acepte un " +"único argumento. Si la función de destino falla, se llama a *error_callback* " +"con la instancia de excepción." #: ../Doc/library/multiprocessing.rst:2177 #: ../Doc/library/multiprocessing.rst:2207 @@ -2371,6 +3307,8 @@ msgid "" "Callbacks should complete immediately since otherwise the thread which " "handles the results will get blocked." msgstr "" +"Las devoluciones de llamada deben completarse inmediatamente ya que de lo " +"contrario el hilo que maneja los resultados se bloqueará." #: ../Doc/library/multiprocessing.rst:2182 msgid "" @@ -2378,6 +3316,9 @@ msgid "" "one *iterable* argument though, for multiple iterables see :meth:`starmap`). " "It blocks until the result is ready." msgstr "" +"Un equivalente paralelo de la función incorporada :func:`map` (aunque solo " +"admite un argumento *iterable*, para varios iterables consulte :meth:" +"`starmap`). Bloquea hasta que el resultado esté listo." #: ../Doc/library/multiprocessing.rst:2186 msgid "" @@ -2385,6 +3326,9 @@ msgid "" "the process pool as separate tasks. The (approximate) size of these chunks " "can be specified by setting *chunksize* to a positive integer." msgstr "" +"Este método corta el iterable en varios trozos que envía al grupo de " +"procesos como tareas separadas. El tamaño (aproximado) de estos fragmentos " +"se puede especificar estableciendo *chunksize* en un entero positivo." #: ../Doc/library/multiprocessing.rst:2190 msgid "" @@ -2392,14 +3336,18 @@ msgid "" "using :meth:`imap` or :meth:`imap_unordered` with explicit *chunksize* " "option for better efficiency." msgstr "" +"Tenga en cuenta que puede causar un alto uso de memoria para iterables muy " +"largos. Considere usar :meth:`imap` o :meth:`imap_unordered` con la opción " +"explícita *chunksize* para una mejor eficiencia." #: ../Doc/library/multiprocessing.rst:2196 msgid "A variant of the :meth:`.map` method which returns a result object." msgstr "" +"Una variante del método :meth:`.map` que como resultado retorna un objeto." #: ../Doc/library/multiprocessing.rst:2212 msgid "A lazier version of :meth:`.map`." -msgstr "" +msgstr "Una versión más perezosa (*lazier*) de :meth:`.map`." #: ../Doc/library/multiprocessing.rst:2214 msgid "" @@ -2407,6 +3355,10 @@ msgid "" "method. For very long iterables using a large value for *chunksize* can " "make the job complete **much** faster than using the default value of ``1``." msgstr "" +"El argumento *chunksize* es el mismo que el utilizado por el método :meth:`." +"map`. Para iterables muy largos, usar un valor grande para *chunksize* puede " +"hacer que el trabajo se complete **much** (**mucho**) más rápido que usar el " +"valor predeterminado de ``1``." #: ../Doc/library/multiprocessing.rst:2219 msgid "" @@ -2415,6 +3367,10 @@ msgid "" "``next(timeout)`` will raise :exc:`multiprocessing.TimeoutError` if the " "result cannot be returned within *timeout* seconds." msgstr "" +"Además, si *chunksize* es ``1``, el método :meth:`!next` del iterador " +"retornado por el método :meth:`imap` tiene un parámetro opcional *timeout* :" +"``next (timeout)`` lanzará :exc:`multiprocessing.TimeoutError` si el " +"resultado no puede devolverse dentro de *timeout* segundos." #: ../Doc/library/multiprocessing.rst:2226 msgid "" @@ -2422,18 +3378,25 @@ msgid "" "returned iterator should be considered arbitrary. (Only when there is only " "one worker process is the order guaranteed to be \"correct\".)" msgstr "" +"Lo mismo que :meth:`imap` , excepto que el orden de los resultados del " +"iterador retornado debe considerarse arbitrario. (Solo cuando hay un solo " +"proceso de trabajo se garantiza que el orden sea “correcto”)." #: ../Doc/library/multiprocessing.rst:2232 msgid "" "Like :meth:`map` except that the elements of the *iterable* are expected to " "be iterables that are unpacked as arguments." msgstr "" +"Como :meth:`map` excepto que se espera que los elementos de *iterable* sean " +"iterables que se desempaquetan como argumentos." #: ../Doc/library/multiprocessing.rst:2235 msgid "" "Hence an *iterable* of ``[(1,2), (3, 4)]`` results in ``[func(1,2), " "func(3,4)]``." msgstr "" +"Por lo tanto, un *iterable* de ``[(1,2), (3, 4)]`` da como resultado " +"``[func(1,2), func(3,4)]``." #: ../Doc/library/multiprocessing.rst:2242 msgid "" @@ -2441,12 +3404,17 @@ msgid "" "*iterable* of iterables and calls *func* with the iterables unpacked. " "Returns a result object." msgstr "" +"Una combinación de :meth:`starmap` y :meth:`map_async` que itera sobre " +"*iterable* de iterables y llama a *func* con los iterables desempaquetados. " +"Como resultado se retorna un objeto." #: ../Doc/library/multiprocessing.rst:2250 msgid "" "Prevents any more tasks from being submitted to the pool. Once all the " "tasks have been completed the worker processes will exit." msgstr "" +"Impide que se envíen más tareas a la piscina (*pool*). Una vez que se hayan " +"completado todas las tareas, se cerrarán los procesos de trabajo." #: ../Doc/library/multiprocessing.rst:2255 msgid "" @@ -2454,12 +3422,17 @@ msgid "" "When the pool object is garbage collected :meth:`terminate` will be called " "immediately." msgstr "" +"Detiene los procesos de trabajo inmediatamente sin completar el trabajo " +"pendiente. Cuando el objeto del grupo es basura recolectada :meth:" +"`terminate` se llamará inmediatamente." #: ../Doc/library/multiprocessing.rst:2261 msgid "" "Wait for the worker processes to exit. One must call :meth:`close` or :meth:" "`terminate` before using :meth:`join`." msgstr "" +"Espera a que salgan los procesos de trabajo. Se debe llamar :meth:`close` o :" +"meth:`terminate` antes de usar :meth:`join`." #: ../Doc/library/multiprocessing.rst:2264 msgid "" @@ -2467,12 +3440,18 @@ msgid "" "`typecontextmanager`. :meth:`~contextmanager.__enter__` returns the pool " "object, and :meth:`~contextmanager.__exit__` calls :meth:`terminate`." msgstr "" +"Los objetos de piscina (*pool*) ahora admiten el protocolo de administración " +"de contexto; consulte :ref:`typecontextmanager`. :meth:`~contextmanager.__ " +"enter__` retorna el objeto de grupo, y :meth:`~ contextmanager.__ exit__` " +"llama :meth:`terminate`." #: ../Doc/library/multiprocessing.rst:2272 msgid "" "The class of the result returned by :meth:`Pool.apply_async` and :meth:`Pool." "map_async`." msgstr "" +"La clase del resultado retornado por :meth:`Pool.apply_async` y :meth:`Pool." +"map_async`." #: ../Doc/library/multiprocessing.rst:2277 msgid "" @@ -2481,40 +3460,53 @@ msgid "" "TimeoutError` is raised. If the remote call raised an exception then that " "exception will be reraised by :meth:`get`." msgstr "" +"Retorna el resultado cuando llegue. Si *timeout* no es ``None`` y el " +"resultado no llega dentro de *timeout* segundos, entonces se lanza :exc:" +"`multiprocessing.TimeoutError`. Si la llamada remota generó una excepción, " +"esa excepción se volverá a plantear mediante :meth:`get`." #: ../Doc/library/multiprocessing.rst:2284 msgid "Wait until the result is available or until *timeout* seconds pass." msgstr "" +"Espera hasta que el resultado esté disponible o hasta que pase *timeout* " +"segundos." #: ../Doc/library/multiprocessing.rst:2288 msgid "Return whether the call has completed." -msgstr "" +msgstr "Retorna si la llamada se ha completado." #: ../Doc/library/multiprocessing.rst:2292 msgid "" "Return whether the call completed without raising an exception. Will raise :" "exc:`ValueError` if the result is not ready." msgstr "" +"Retorna si la llamada se completó sin generar una excepción. Lanzará :exc:" +"`ValueError` si el resultado no está listo." #: ../Doc/library/multiprocessing.rst:2295 msgid "" "If the result is not ready, :exc:`ValueError` is raised instead of :exc:" "`AssertionError`." msgstr "" +"Si el resultado no está listo :exc:`ValueError` aparece en lugar de :exc:" +"`AssertionError`." #: ../Doc/library/multiprocessing.rst:2299 msgid "The following example demonstrates the use of a pool::" -msgstr "" +msgstr "El siguiente ejemplo demuestra el uso de una piscina(*pool*)::" #: ../Doc/library/multiprocessing.rst:2326 msgid "Listeners and Clients" -msgstr "" +msgstr "Oyentes y Clientes (*Listeners and Clients*)" #: ../Doc/library/multiprocessing.rst:2331 msgid "" "Usually message passing between processes is done using queues or by using :" "class:`~Connection` objects returned by :func:`~multiprocessing.Pipe`." msgstr "" +"Por lo general, el paso de mensajes entre procesos se realiza mediante colas " +"o mediante objetos :class:`~Connection` retornados por :func:" +"`~multiprocessing.Pipe`." #: ../Doc/library/multiprocessing.rst:2335 msgid "" @@ -2524,12 +3516,19 @@ msgid "" "*digest authentication* using the :mod:`hmac` module, and for polling " "multiple connections at the same time." msgstr "" +"Sin embargo, el módulo :mod:`multiprocessing.connection` permite cierta " +"flexibilidad adicional. Básicamente proporciona una API orientada a mensajes " +"de alto nivel para tratar con sockets o canalizaciones con nombre de " +"Windows. También tiene soporte para *digest authentication* usando el " +"módulo :mod:`hmac`, y para sondear múltiples conexiones al mismo tiempo." #: ../Doc/library/multiprocessing.rst:2344 msgid "" "Send a randomly generated message to the other end of the connection and " "wait for a reply." msgstr "" +"Envía un mensaje generado aleatoriamente al otro extremo de la conexión y " +"espera una respuesta." #: ../Doc/library/multiprocessing.rst:2347 msgid "" @@ -2537,24 +3536,34 @@ msgid "" "then a welcome message is sent to the other end of the connection. " "Otherwise :exc:`~multiprocessing.AuthenticationError` is raised." msgstr "" +"Si la respuesta coincide con el resumen del mensaje utilizando *authkey* " +"como clave, se envía un mensaje de bienvenida al otro extremo de la " +"conexión. De lo contrario se lanza :exc:`~multiprocessing." +"AuthenticationError`." #: ../Doc/library/multiprocessing.rst:2353 msgid "" "Receive a message, calculate the digest of the message using *authkey* as " "the key, and then send the digest back." msgstr "" +"Recibe un mensaje, calcula el resumen del mensaje usando *authkey* como la " +"clave y luego envía el resumen de vuelta." #: ../Doc/library/multiprocessing.rst:2356 msgid "" "If a welcome message is not received, then :exc:`~multiprocessing." "AuthenticationError` is raised." msgstr "" +"Si no se recibe un mensaje de bienvenida, se lanza :exc:`~multiprocessing." +"AuthenticationError`." #: ../Doc/library/multiprocessing.rst:2361 msgid "" "Attempt to set up a connection to the listener which is using address " "*address*, returning a :class:`~Connection`." msgstr "" +"Se intenta configurar una conexión con el oyente que utiliza la dirección " +"*address*, retornando :class:`~Connection`." #: ../Doc/library/multiprocessing.rst:2364 msgid "" @@ -2562,6 +3571,9 @@ msgid "" "generally be omitted since it can usually be inferred from the format of " "*address*. (See :ref:`multiprocessing-address-formats`)" msgstr "" +"El tipo de conexión está determinado por el argumento *family*, pero esto " +"generalmente se puede omitir ya que generalmente se puede inferir del " +"formato de *address*. (Consulte :ref:`multiprocessing-address-formats`)" #: ../Doc/library/multiprocessing.rst:2368 #: ../Doc/library/multiprocessing.rst:2403 @@ -2572,18 +3584,27 @@ msgid "" "AuthenticationError` is raised if authentication fails. See :ref:" "`multiprocessing-auth-keys`." msgstr "" +"Si se proporciona *authkey* y no *None*, debe ser una cadena de *bytes* y se " +"utilizará como clave secreta para un desafío de autenticación basado en " +"HMAC. No se realiza la autenticación si *authkey* es *None*. Si falla la " +"autenticación se lanza :exc:`~multiprocessing.AuthenticationError`. " +"Consulte :ref:`multiprocessing-auth-keys`." #: ../Doc/library/multiprocessing.rst:2376 msgid "" "A wrapper for a bound socket or Windows named pipe which is 'listening' for " "connections." msgstr "" +"Un contenedor para un *socket* vinculado o una tubería (*pipe*) con nombre " +"de Windows que está ‘escuchando’ las conexiones." #: ../Doc/library/multiprocessing.rst:2379 msgid "" "*address* is the address to be used by the bound socket or named pipe of the " "listener object." msgstr "" +"*address* es la dirección que utilizará el *socket* vinculado o la conocida " +"tubería (*pipe*) con nombre del objeto de escucha." #: ../Doc/library/multiprocessing.rst:2384 msgid "" @@ -2591,20 +3612,34 @@ msgid "" "end point on Windows. If you require a connectable end-point, you should use " "'127.0.0.1'." msgstr "" +"Si se usa una dirección de ‘0.0.0.0’ , la dirección no será un punto final " +"conectable en Windows. Si necesita un punto final conectable, debe usar " +"‘127.0.0.1’." #: ../Doc/library/multiprocessing.rst:2388 msgid "" "*family* is the type of socket (or named pipe) to use. This can be one of " -"the strings ``'AF_INET'`` (for a TCP socket), ``'AF_UNIX'`` (for a Unix " +"the strings ``'AF_INET'`` (for a TCP socket), ``'AF_Unix'`` (for a Unix " "domain socket) or ``'AF_PIPE'`` (for a Windows named pipe). Of these only " "the first is guaranteed to be available. If *family* is ``None`` then the " "family is inferred from the format of *address*. If *address* is also " "``None`` then a default is chosen. This default is the family which is " "assumed to be the fastest available. See :ref:`multiprocessing-address-" -"formats`. Note that if *family* is ``'AF_UNIX'`` and address is ``None`` " +"formats`. Note that if *family* is ``'AF_Unix'`` and address is ``None`` " "then the socket will be created in a private temporary directory created " "using :func:`tempfile.mkstemp`." msgstr "" +"*family* es el tipo de socket (o tubería con nombre) a utilizar. Esta puede " +"ser una de las cadenas de caracteres`` 'AF_INET'`` (para un socket TCP), ``' " +"AF_Unix'`` (para un socket de dominio Unix) o `` 'AF_PIPE'`` (para una " +"tubería con nombre de Windows) . De estos, solo el primero está garantizado " +"para estar disponible. Si *family* es ``None`` , *family* se deduce del " +"formato de *address*. Si *address* también es ``None`` , se elige un valor " +"predeterminado. Este valor predeterminado es *family* con la opción más " +"rápida disponible. Consulte :ref:`multiprocessing-address-format`. Tenga en " +"cuenta que si *family* es ``'AF_Unix'`` y la dirección es ``None``, el " +"*socket* se creará en un directorio temporal privado usando :func:`tempfile." +"mkstemp`." #: ../Doc/library/multiprocessing.rst:2399 msgid "" @@ -2612,6 +3647,9 @@ msgid "" "to the :meth:`~socket.socket.listen` method of the socket once it has been " "bound." msgstr "" +"Si el objeto de escucha utiliza un *socket*, entonces *backlog* (1 por " +"defecto) se pasa al método :meth:`~socket.socket.listen` del *socket* una " +"vez que se ha vinculado." #: ../Doc/library/multiprocessing.rst:2411 msgid "" @@ -2619,6 +3657,10 @@ msgid "" "and return a :class:`~Connection` object. If authentication is attempted and " "fails, then :exc:`~multiprocessing.AuthenticationError` is raised." msgstr "" +"Acepta una conexión en el *socket* vinculado o canalización con nombre del " +"objeto de escucha y retorne un objeto :class:`~Connection`. Si se intenta la " +"autenticación y falla, entonces se lanza una :exc:`~multiprocessing." +"AuthenticationError`." #: ../Doc/library/multiprocessing.rst:2418 msgid "" @@ -2626,20 +3668,26 @@ msgid "" "automatically when the listener is garbage collected. However it is " "advisable to call it explicitly." msgstr "" +"Cierra el socket vinculado o la tubería con nombre del objeto de escucha. " +"Esto se llama automáticamente cuando el oyente es recolectado por el " +"recolector de basura. Sin embargo, es aconsejable llamarlo explícitamente." #: ../Doc/library/multiprocessing.rst:2422 msgid "Listener objects have the following read-only properties:" msgstr "" +"Los objetos de escucha tienen las siguientes propiedades de solo lectura:" #: ../Doc/library/multiprocessing.rst:2426 msgid "The address which is being used by the Listener object." -msgstr "" +msgstr "La dirección que está utilizando el objeto *Listener*." #: ../Doc/library/multiprocessing.rst:2430 msgid "" "The address from which the last accepted connection came. If this is " "unavailable then it is ``None``." msgstr "" +"La dirección de donde vino la última conexión aceptada. Si esto no está " +"disponible, entonces es ``None``." #: ../Doc/library/multiprocessing.rst:2433 msgid "" @@ -2647,6 +3695,10 @@ msgid "" "`typecontextmanager`. :meth:`~contextmanager.__enter__` returns the " "listener object, and :meth:`~contextmanager.__exit__` calls :meth:`close`." msgstr "" +"Los objetos de escucha ahora admiten el protocolo de gestión de contexto -- " +"consulte :ref:`typecontextmanager`. El objeto *lISTENER* retorna :meth:" +"`~contextmanager.__enter__`, y :meth:`~contextmanager.__exit__` llama a :" +"meth:`close`." #: ../Doc/library/multiprocessing.rst:2440 msgid "" @@ -2656,31 +3708,42 @@ msgid "" "will block for an unlimited period. A negative timeout is equivalent to a " "zero timeout." msgstr "" +"Espera hasta que un objeto en *object_list* esté listo. Retorna la lista de " +"esos objetos en *object_list* que están listos. Si *timeout* es flotante, la " +"llamada se bloquea durante como máximo tantos segundos. Si *timeout* es " +"```None``, se bloqueará por un período ilimitado. Un tiempo de espera " +"negativo es equivalente a un tiempo de espera cero." #: ../Doc/library/multiprocessing.rst:2446 msgid "" "For both Unix and Windows, an object can appear in *object_list* if it is" msgstr "" +"Tanto para Unix como para Windows, un objeto puede aparecer en *object_list* " +"si este es" #: ../Doc/library/multiprocessing.rst:2449 msgid "a readable :class:`~multiprocessing.connection.Connection` object;" -msgstr "" +msgstr "un objeto legible de :class:`~multiprocessing.connection.Connection`;" #: ../Doc/library/multiprocessing.rst:2450 msgid "a connected and readable :class:`socket.socket` object; or" -msgstr "" +msgstr "un objeto conectado y legible de :class:`socket.socket`; o" #: ../Doc/library/multiprocessing.rst:2451 msgid "" "the :attr:`~multiprocessing.Process.sentinel` attribute of a :class:" "`~multiprocessing.Process` object." msgstr "" +"el atributo attr:`~multiprocessing.Process.sentinel` de un objeto :class:" +"`~multiprocessing.Process`." #: ../Doc/library/multiprocessing.rst:2454 msgid "" "A connection or socket object is ready when there is data available to be " "read from it, or the other end has been closed." msgstr "" +"Un objeto de conexión o *socket* está listo cuando hay datos disponibles " +"para leer, o el otro extremo se ha cerrado." #: ../Doc/library/multiprocessing.rst:2457 msgid "" @@ -2689,6 +3752,10 @@ msgid "" "`select.select` is interrupted by a signal, it can raise :exc:`OSError` with " "an error number of ``EINTR``, whereas :func:`wait` will not." msgstr "" +"**Unix**: ``wait(object_list, timeout)`` es casi equivalente a ``select." +"select(object_list, [], [], timeout)``. La diferencia es que si se " +"interrumpe :func:`select.select` por una señal, este lanza :exc:`OSError` " +"con un número de error ``EINTR``, a diferencia de :func:`wait`." #: ../Doc/library/multiprocessing.rst:2463 msgid "" @@ -2698,10 +3765,16 @@ msgid "" "meth:`fileno` method which returns a socket handle or pipe handle. (Note " "that pipe handles and socket handles are **not** waitable handles.)" msgstr "" +"**Windows**: Un elemento en *object_list* debe ser un identificador de " +"número entero que se pueda esperar (de acuerdo con la definición utilizada " +"por la documentación de la función *Win32* ``WaitForMultipleObjects()``) o " +"puede ser un objeto con un :meth:`fileno` Método que retorna un mango de " +"tubo o mango de tubería. (Tenga en cuenta que las manijas de las tuberías y " +"las manijas de los zócalos son **no** manijas aptas)" #: ../Doc/library/multiprocessing.rst:2473 msgid "**Examples**" -msgstr "" +msgstr "**Examples**" #: ../Doc/library/multiprocessing.rst:2475 msgid "" @@ -2709,38 +3782,49 @@ msgid "" "password'`` as an authentication key. It then waits for a connection and " "sends some data to the client::" msgstr "" +"El siguiente código de servidor crea un escucha que utiliza ``'secret " +"password'`` como clave de autenticación. Luego espera una conexión y envía " +"algunos datos al cliente::" #: ../Doc/library/multiprocessing.rst:2494 msgid "" "The following code connects to the server and receives some data from the " "server::" msgstr "" +"El siguiente código se conecta al servidor y recibe algunos datos del " +"servidor::" #: ../Doc/library/multiprocessing.rst:2511 msgid "" "The following code uses :func:`~multiprocessing.connection.wait` to wait for " "messages from multiple processes at once::" msgstr "" +"El siguiente código utiliza :func:`~multiprocessing.connection.wait` para " +"esperar mensajes de múltiples procesos a la vez::" #: ../Doc/library/multiprocessing.rst:2550 msgid "Address Formats" -msgstr "" +msgstr "Formatos de dirección (*Address formats*)" #: ../Doc/library/multiprocessing.rst:2552 msgid "" "An ``'AF_INET'`` address is a tuple of the form ``(hostname, port)`` where " "*hostname* is a string and *port* is an integer." msgstr "" +"Una dirección ``'AF_INET'`` es una tupla de la forma ``(hostname, port)`` " +"donde *hostname* es una cadena y *port* es un número entero." #: ../Doc/library/multiprocessing.rst:2555 msgid "" -"An ``'AF_UNIX'`` address is a string representing a filename on the " +"An ``'AF_Unix'`` address is a string representing a filename on the " "filesystem." msgstr "" +"Una dirección ``'AF_Unix'`` es una cadena que representa un nombre de " +"archivo en el sistema de archivos." #: ../Doc/library/multiprocessing.rst:2561 msgid "An ``'AF_PIPE'`` address is a string of the form" -msgstr "" +msgstr "Una dirección ``'AF_PIPE'`` es una cadena del formulario" #: ../Doc/library/multiprocessing.rst:2559 msgid "" @@ -2749,16 +3833,23 @@ msgid "" "use an address of the form :samp:`r'\\\\\\\\{ServerName}\\\\pipe\\" "\\{PipeName}'` instead." msgstr "" +":samp:`r'\\\\\\\\.\\\\pipe\\\\{PipeName}'`. Para usar :func:`Client` para " +"conectarse a una tubería (*pipe*) con nombre en un ordenador remoto llamada " +"*ServerName* uno debe usar una dirección del formulario :samp:`r'\\\\\\" +"\\{ServerName}\\\\pipe\\\\{PipeName}'`." #: ../Doc/library/multiprocessing.rst:2563 msgid "" "Note that any string beginning with two backslashes is assumed by default to " -"be an ``'AF_PIPE'`` address rather than an ``'AF_UNIX'`` address." +"be an ``'AF_PIPE'`` address rather than an ``'AF_Unix'`` address." msgstr "" +"Tenga en cuenta que cualquier cadena que comience con dos barras inclinadas " +"invertidas se asume por defecto como una dirección ``'AF_PIPE'`` en lugar de " +"una dirección ``'AF_Unix'``." #: ../Doc/library/multiprocessing.rst:2570 msgid "Authentication keys" -msgstr "" +msgstr "Llaves de autentificación" #: ../Doc/library/multiprocessing.rst:2572 msgid "" @@ -2767,6 +3858,11 @@ msgid "" "source is a security risk. Therefore :class:`Listener` and :func:`Client` " "use the :mod:`hmac` module to provide digest authentication." msgstr "" +"Cuando uno usa :meth:`Connection.recv `, los datos " +"recibidos se desbloquean automáticamente. Desafortunadamente, la eliminación " +"de datos de una fuente no confiable es un riesgo de seguridad. Por lo tanto :" +"class:`Listener` y :func:`Client` usan el módulo :mod:`hmac` para " +"proporcionar autenticación de resumen." #: ../Doc/library/multiprocessing.rst:2578 msgid "" @@ -2775,6 +3871,11 @@ msgid "" "the other knows the authentication key. (Demonstrating that both ends are " "using the same key does **not** involve sending the key over the connection.)" msgstr "" +"Una clave de autenticación es una cadena de bytes que se puede considerar " +"como una contraseña: una vez que se establece una conexión, ambos extremos " +"exigirán pruebas de que el otro conoce la clave de autenticación. (Demostrar " +"que ambos extremos están usando la misma clave **no** implica enviar la " +"clave a través de la conexión)." #: ../Doc/library/multiprocessing.rst:2584 msgid "" @@ -2786,16 +3887,25 @@ msgid "" "program will share a single authentication key which can be used when " "setting up connections between themselves." msgstr "" +"Si se solicita la autenticación pero no se especifica una clave de " +"autenticación, se utiliza el valor de retorno de ``current_process()." +"authkey`` (consulte :class:`~multiprocessing.Process` ). Este valor será " +"heredado automáticamente por cualquier objeto :class:`~ multiprocessing." +"Process` que crea el proceso actual. Esto significa que (por defecto) todos " +"los procesos de un programa multiproceso compartirán una única clave de " +"autenticación que se puede usar al configurar conexiones entre ellos." #: ../Doc/library/multiprocessing.rst:2592 msgid "" "Suitable authentication keys can also be generated by using :func:`os." "urandom`." msgstr "" +"Las claves de autenticación adecuadas también se pueden generar utilizando :" +"func:`os.urandom`." #: ../Doc/library/multiprocessing.rst:2596 msgid "Logging" -msgstr "" +msgstr "*Logging*" #: ../Doc/library/multiprocessing.rst:2598 msgid "" @@ -2804,12 +3914,18 @@ msgid "" "(depending on the handler type) for messages from different processes to get " "mixed up." msgstr "" +"Existe cierto soporte para el registro. Sin embargo, tenga en cuenta que el " +"paquete :mod:`logging` no utiliza bloqueos compartidos de proceso, por lo " +"que es posible (dependiendo del tipo de controlador) que los mensajes de " +"diferentes procesos se mezclen." #: ../Doc/library/multiprocessing.rst:2605 msgid "" "Returns the logger used by :mod:`multiprocessing`. If necessary, a new one " "will be created." msgstr "" +"retorna el registrador utilizado por :mod:`multiprocessing`. Si es " +"necesario, se creará uno nuevo." #: ../Doc/library/multiprocessing.rst:2608 msgid "" @@ -2817,6 +3933,9 @@ msgid "" "default handler. Messages sent to this logger will not by default propagate " "to the root logger." msgstr "" +"Cuando se creó por primera vez, el registrador tiene nivel :data:`logging." +"NOTSET` y no tiene un controlador predeterminado. Los mensajes enviados a " +"este registrador no se propagarán por defecto al registrador raíz." #: ../Doc/library/multiprocessing.rst:2612 msgid "" @@ -2824,6 +3943,9 @@ msgid "" "parent process's logger -- any other customization of the logger will not be " "inherited." msgstr "" +"Tenga en cuenta que en Windows los procesos hijos solo heredarán el nivel " +"del registrador del proceso parental -- no se heredará ninguna otra " +"personalización del registrador." #: ../Doc/library/multiprocessing.rst:2619 #, python-format @@ -2833,52 +3955,65 @@ msgid "" "output to :data:`sys.stderr` using format ``'[%(levelname)s/%(processName)s] " "%(message)s'``." msgstr "" +"Esta función realiza una llamada a :func:`get_logger` pero además de " +"devolver el registrador creado por *get_logger*, agrega un controlador que " +"envía la salida a :data:`sys.stderr` usando el formato ``'[%(levelname)s/" +"%(processName)s] %(message)s'``." #: ../Doc/library/multiprocessing.rst:2624 msgid "Below is an example session with logging turned on::" msgstr "" +"A continuación se muestra una sesión de ejemplo con el registro activado::" #: ../Doc/library/multiprocessing.rst:2639 msgid "For a full table of logging levels, see the :mod:`logging` module." msgstr "" +"Para obtener una tabla completa de niveles de registro, consulte el módulo :" +"mod:`logging`." #: ../Doc/library/multiprocessing.rst:2643 msgid "The :mod:`multiprocessing.dummy` module" -msgstr "" +msgstr "El módulo :mod:`multiprocessing.dummy`" #: ../Doc/library/multiprocessing.rst:2648 msgid "" ":mod:`multiprocessing.dummy` replicates the API of :mod:`multiprocessing` " "but is no more than a wrapper around the :mod:`threading` module." msgstr "" +"El :mod:`multiprocessing.dummy` replica la API de :mod:`multiprocessing` " +"pero no es más que un contenedor alrededor del módulo :mod:`threading`." #: ../Doc/library/multiprocessing.rst:2655 msgid "Programming guidelines" -msgstr "" +msgstr "Pautas de programación" #: ../Doc/library/multiprocessing.rst:2657 msgid "" "There are certain guidelines and idioms which should be adhered to when " "using :mod:`multiprocessing`." msgstr "" +"Hay ciertas pautas y expresiones idiomáticas que deben tenerse en cuenta al " +"usar :mod:`multiprocessing` ." #: ../Doc/library/multiprocessing.rst:2662 msgid "All start methods" -msgstr "" +msgstr "Todos los métodos de inicio" #: ../Doc/library/multiprocessing.rst:2664 msgid "The following applies to all start methods." -msgstr "" +msgstr "Lo siguiente se aplica a todos los métodos de inicio." #: ../Doc/library/multiprocessing.rst:2666 msgid "Avoid shared state" -msgstr "" +msgstr "Evita estado compartido" #: ../Doc/library/multiprocessing.rst:2668 msgid "" "As far as possible one should try to avoid shifting large amounts of data " "between processes." msgstr "" +"En la medida de lo posible, se debe tratar de evitar el desplazamiento de " +"grandes cantidades de datos entre procesos." #: ../Doc/library/multiprocessing.rst:2671 msgid "" @@ -2886,33 +4021,41 @@ msgid "" "between processes rather than using the lower level synchronization " "primitives." msgstr "" +"Probablemente sea mejor seguir usando colas (*queues*) o tuberías (*pipes*) " +"para la comunicación entre procesos en lugar de usar las primitivas de " +"sincronización de nivel inferior." #: ../Doc/library/multiprocessing.rst:2675 msgid "Picklability" -msgstr "" +msgstr "Serialización (*picklability*)" #: ../Doc/library/multiprocessing.rst:2677 msgid "Ensure that the arguments to the methods of proxies are picklable." msgstr "" +"Asegúrese que todos los argumentos de los métodos de *proxies* son " +"serializables (*pickable*)" #: ../Doc/library/multiprocessing.rst:2679 msgid "Thread safety of proxies" -msgstr "" +msgstr "Hilo seguro de *proxies*" #: ../Doc/library/multiprocessing.rst:2681 msgid "" "Do not use a proxy object from more than one thread unless you protect it " "with a lock." msgstr "" +"No usa un objeto proxy de más de un hilo a menos que lo proteja con un " +"candado (*lock*)." #: ../Doc/library/multiprocessing.rst:2684 msgid "" "(There is never a problem with different processes using the *same* proxy.)" msgstr "" +"(Nunca hay un problema con diferentes procesos que usan el *mismo* proxy.)" #: ../Doc/library/multiprocessing.rst:2686 msgid "Joining zombie processes" -msgstr "" +msgstr "Uniéndose a procesos zombies" #: ../Doc/library/multiprocessing.rst:2688 msgid "" @@ -2924,10 +4067,17 @@ msgid "" "join the process. Even so it is probably good practice to explicitly join " "all the processes that you start." msgstr "" +"En Unix, cuando un proceso finaliza pero no se ha unido, se convierte en un " +"zombie. Nunca debería haber muchos porque cada vez que se inicia un nuevo " +"proceso (o se llama :func:`~multiprocessing.active_children`) se unirán " +"todos los procesos completados que aún no se hayan unido. También llamando a " +"un proceso terminado :meth:`Process.is_alive ` se unirá al proceso. Aun así, probablemente sea una buena " +"práctica unir explícitamente todos los procesos que comience." #: ../Doc/library/multiprocessing.rst:2696 msgid "Better to inherit than pickle/unpickle" -msgstr "" +msgstr "Mejor heredar que serializar/deserializar (*pickle/unpickle*)" #: ../Doc/library/multiprocessing.rst:2698 msgid "" @@ -2938,10 +4088,17 @@ msgid "" "that a process which needs access to a shared resource created elsewhere can " "inherit it from an ancestor process." msgstr "" +"Cuando se usan los métodos de inicio *spawn* o *forkserver*, muchos tipos " +"de :mod:`multiprocesamiento` deben ser seleccionables para que los procesos " +"secundarios puedan usarlos. Sin embargo, generalmente se debe evitar enviar " +"objetos compartidos a otros procesos mediante tuberías o colas. En su lugar, " +"debe organizar el programa para que un proceso que necesita acceso a un " +"recurso compartido creado en otro lugar pueda heredarlo de un proceso " +"ancestro." #: ../Doc/library/multiprocessing.rst:2706 msgid "Avoid terminating processes" -msgstr "" +msgstr "Evita procesos de finalización" #: ../Doc/library/multiprocessing.rst:2708 msgid "" @@ -2950,6 +4107,11 @@ msgid "" "locks, semaphores, pipes and queues) currently being used by the process to " "become broken or unavailable to other processes." msgstr "" +"El uso del método :meth:`Process.terminate ` para detener un proceso puede causar que los recursos " +"compartidos (como candados *locks*, semáforos, tuberías *pipes* y colas " +"*queues*) que el proceso utiliza actualmente se rompan o no disponible para " +"otros procesos." #: ../Doc/library/multiprocessing.rst:2714 msgid "" @@ -2957,10 +4119,13 @@ msgid "" "terminate ` on processes which never use " "any shared resources." msgstr "" +"Por lo tanto, probablemente sea mejor considerar usar :meth:`Process." +"terminate ` en procesos que nunca usan " +"recursos compartidos." #: ../Doc/library/multiprocessing.rst:2718 msgid "Joining processes that use queues" -msgstr "" +msgstr "Unirse a procesos que usan colas" #: ../Doc/library/multiprocessing.rst:2720 msgid "" @@ -2970,6 +4135,12 @@ msgid "" "cancel_join_thread ` method of the " "queue to avoid this behaviour.)" msgstr "" +"Tenga en cuenta que un proceso que ha puesto elementos en una cola esperará " +"antes de finalizar hasta que todos los elementos almacenados en búfer sean " +"alimentados por el hilo \"alimentador\" a la tubería subyacente. (El proceso " +"secundario puede llamar al método :meth:`Queue.cancel_join_thread " +"` de la cola para evitar este " +"comportamiento)." #: ../Doc/library/multiprocessing.rst:2726 msgid "" @@ -2979,20 +4150,27 @@ msgid "" "put items on the queue will terminate. Remember also that non-daemonic " "processes will be joined automatically." msgstr "" +"Esto significa que siempre que use una cola debe asegurarse de que todos los " +"elementos que se hayan puesto en la cola se eliminarán antes de unirse al " +"proceso. De lo contrario, no puede estar seguro de que los procesos que han " +"puesto elementos en la cola finalizarán. Recuerde también que los procesos " +"no demoníacos se unirán automáticamente." #: ../Doc/library/multiprocessing.rst:2732 msgid "An example which will deadlock is the following::" -msgstr "" +msgstr "Un ejemplo que de bloqueo mutuo (*deadlock*) es el siguiente ::" #: ../Doc/library/multiprocessing.rst:2746 msgid "" "A fix here would be to swap the last two lines (or simply remove the ``p." "join()`` line)." msgstr "" +"Una solución aquí sería intercambiar las dos últimas líneas (o simplemente " +"eliminar la línea ``p.join()`` )." #: ../Doc/library/multiprocessing.rst:2749 msgid "Explicitly pass resources to child processes" -msgstr "" +msgstr "Se pasan recursos explícitamente a procesos hijos" #: ../Doc/library/multiprocessing.rst:2751 msgid "" @@ -3001,6 +4179,10 @@ msgid "" "However, it is better to pass the object as an argument to the constructor " "for the child process." msgstr "" +"En Unix que utiliza el método de inicio *fork*, un proceso secundario puede " +"hacer uso de un recurso compartido creado en un proceso primario utilizando " +"un recurso global. Sin embargo, es mejor pasar el objeto como argumento al " +"constructor para el proceso secundario." #: ../Doc/library/multiprocessing.rst:2756 msgid "" @@ -3010,28 +4192,36 @@ msgid "" "This might be important if some resource is freed when the object is garbage " "collected in the parent process." msgstr "" +"Además de hacer que el código (potencialmente) sea compatible con Windows y " +"los otros métodos de inicio, esto también garantiza que mientras el proceso " +"secundario siga vivo, el objeto no se recolectará en el proceso primario. " +"Esto podría ser importante si se libera algún recurso cuando el objeto es " +"basura recolectada en el proceso padre." #: ../Doc/library/multiprocessing.rst:2763 msgid "So for instance ::" -msgstr "" +msgstr "Entonces por ejemplo ::" #: ../Doc/library/multiprocessing.rst:2775 msgid "should be rewritten as ::" -msgstr "" +msgstr "debería ser reescrito como ::" #: ../Doc/library/multiprocessing.rst:2787 msgid "Beware of replacing :data:`sys.stdin` with a \"file like object\"" msgstr "" +"Tenga cuidado de reemplazar :data:`sys.stdin` con un *\"file like object\"*" #: ../Doc/library/multiprocessing.rst:2789 msgid ":mod:`multiprocessing` originally unconditionally called::" -msgstr "" +msgstr ":mod:`multiprocessing` original e incondicionalmente llamado::" #: ../Doc/library/multiprocessing.rst:2793 msgid "" "in the :meth:`multiprocessing.Process._bootstrap` method --- this resulted " "in issues with processes-in-processes. This has been changed to::" msgstr "" +"en el método :meth:`multiprocessing.Process._bootstrap` --- Esto dio lugar a " +"problemas con los procesos en proceso. Esto ha sido cambiado a::" #: ../Doc/library/multiprocessing.rst:2799 msgid "" @@ -3042,6 +4232,14 @@ msgid "" "`~io.IOBase.close()` on this file-like object, it could result in the same " "data being flushed to the object multiple times, resulting in corruption." msgstr "" +"Lo que resuelve el problema fundamental de los procesos que chocan entre sí " +"dando como resultado un error de descriptor de archivo incorrecto, pero " +"presenta un peligro potencial para las aplicaciones que reemplazan :func:" +"`sys.stdin` con un\" objeto similar a un archivo \"con almacenamiento en " +"búfer de salida. Este peligro es que si varios procesos invocan :meth:`~io." +"IOBase.close()` en este objeto similar a un archivo, podría ocasionar que " +"los mismos datos se vacíen al objeto varias veces, lo que provocaría " +"corrupción." #: ../Doc/library/multiprocessing.rst:2806 msgid "" @@ -3049,25 +4247,32 @@ msgid "" "it fork-safe by storing the pid whenever you append to the cache, and " "discarding the cache when the pid changes. For example::" msgstr "" +"Si escribe un objeto similar a un archivo e implementa su propio " +"almacenamiento en caché, puede hacer que sea seguro para la bifurcación " +"(*fork-safe*) almacenando el pid cada vez que se agrega al caché y " +"descartando el caché cuando cambia el pid. Por ejemplo::" #: ../Doc/library/multiprocessing.rst:2818 msgid "" "For more information, see :issue:`5155`, :issue:`5313` and :issue:`5331`" msgstr "" +"Para más información, consulte :issue:`5155`, :issue:`5313` y :issue:`5331`" #: ../Doc/library/multiprocessing.rst:2821 msgid "The *spawn* and *forkserver* start methods" -msgstr "" +msgstr "Los métodos de inicio *spawn* y *forkserver*" #: ../Doc/library/multiprocessing.rst:2823 msgid "" "There are a few extra restriction which don't apply to the *fork* start " "method." msgstr "" +"Hay algunas restricciones adicionales que no se aplican al método de inicio " +"*fork*." #: ../Doc/library/multiprocessing.rst:2826 msgid "More picklability" -msgstr "" +msgstr "Más serialización (*pickability*)" #: ../Doc/library/multiprocessing.rst:2828 msgid "" @@ -3076,10 +4281,15 @@ msgid "" "instances will be picklable when the :meth:`Process.start ` method is called." msgstr "" +"Asegúrese de que todos los argumentos para :meth:`Process.__init__` sean " +"serializables (*picklable*). Además, si la subclase es :class:" +"`~multiprocessing.Process` asegúrese de que las instancias serán " +"serializables cuando se llame al método :meth:`Process.start " +"`." #: ../Doc/library/multiprocessing.rst:2833 msgid "Global variables" -msgstr "" +msgstr "Variables globales" #: ../Doc/library/multiprocessing.rst:2835 msgid "" @@ -3088,16 +4298,22 @@ msgid "" "in the parent process at the time that :meth:`Process.start ` was called." msgstr "" +"Tenga en cuenta que si el código que se ejecuta en un proceso secundario " +"intenta acceder a una variable global, entonces el valor que ve (si lo hay) " +"puede no ser el mismo que el valor en el proceso primario en el momento en " +"que fue llamado :meth:`Process.start `." #: ../Doc/library/multiprocessing.rst:2840 msgid "" "However, global variables which are just module level constants cause no " "problems." msgstr "" +"Sin embargo, las variables globales que son solo constantes de nivel de " +"módulo no causan problemas." #: ../Doc/library/multiprocessing.rst:2843 msgid "Safe importing of main module" -msgstr "" +msgstr "Importando de manera segura el módulo principal" #: ../Doc/library/multiprocessing.rst:2845 msgid "" @@ -3105,51 +4321,66 @@ msgid "" "interpreter without causing unintended side effects (such a starting a new " "process)." msgstr "" +"Asegúrese de que un nuevo intérprete de Python pueda importar de forma " +"segura el módulo principal sin causar efectos secundarios no deseados (como " +"comenzar un nuevo proceso)." #: ../Doc/library/multiprocessing.rst:2849 msgid "" "For example, using the *spawn* or *forkserver* start method running the " "following module would fail with a :exc:`RuntimeError`::" msgstr "" +"Por ejemplo, usando el método de inicio *spawn* o *forkserver* ejecutando " +"este módulo fallaría produciendo :exc:`RuntimeError`::" #: ../Doc/library/multiprocessing.rst:2861 msgid "" "Instead one should protect the \"entry point\" of the program by using ``if " "__name__ == '__main__':`` as follows::" msgstr "" +"En su lugar, se debe proteger el \"punto de entrada\" (*\"entry point\"*) " +"del programa utilizando como sigue ``if __name__ == '__main__':`` ::" #: ../Doc/library/multiprocessing.rst:2875 msgid "" "(The ``freeze_support()`` line can be omitted if the program will be run " "normally instead of frozen.)" msgstr "" +"(La línea ``freeze_support()`` puede omitirse si el programa se ejecuta " +"normalmente en lugar de congelarse)." #: ../Doc/library/multiprocessing.rst:2878 msgid "" "This allows the newly spawned Python interpreter to safely import the module " "and then run the module's ``foo()`` function." msgstr "" +"Esto permite que el intérprete de Python recién generado importe de forma " +"segura el módulo y luego ejecute la función del módulo ``foo()``." #: ../Doc/library/multiprocessing.rst:2881 msgid "" "Similar restrictions apply if a pool or manager is created in the main " "module." msgstr "" +"Se aplican restricciones similares si se crea un grupo o administrador en el " +"módulo principal." #: ../Doc/library/multiprocessing.rst:2888 msgid "Examples" -msgstr "" +msgstr "Ejemplos" #: ../Doc/library/multiprocessing.rst:2890 msgid "Demonstration of how to create and use customized managers and proxies:" -msgstr "" +msgstr "Demostración de cómo crear y usar gerentes y proxies personalizados:" #: ../Doc/library/multiprocessing.rst:2896 msgid "Using :class:`~multiprocessing.pool.Pool`:" -msgstr "" +msgstr "Usando :class:`~multiprocessing.pool.Pool`:" #: ../Doc/library/multiprocessing.rst:2902 msgid "" "An example showing how to use queues to feed tasks to a collection of worker " "processes and collect the results:" msgstr "" +"Un ejemplo que muestra cómo usar las colas para alimentar tareas a una " +"colección de procesos de trabajo y recopilar los resultados:" From 9834fd192a07d0e7ec182d09ac3c0151afe59696 Mon Sep 17 00:00:00 2001 From: Maria Jose Molina Date: Mon, 29 Jun 2020 13:26:42 +0200 Subject: [PATCH 2/7] Arreglando palabras pendientes --- library/multiprocessing.po | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/library/multiprocessing.po b/library/multiprocessing.po index 2d2e6302a4..af292624d0 100644 --- a/library/multiprocessing.po +++ b/library/multiprocessing.po @@ -805,7 +805,7 @@ msgid "" "descriptor usable with primitives from the :mod:`select` module." msgstr "" "En Windows, este es un sistema operativo manejable con la familia de " -"llamadas API ``WaitForSingleObject`` y``WaitForMultipleObjects``. En Unix, " +"llamadas API ``WaitForSingleObject`` y ``WaitForMultipleObjects``. En Unix, " "este es un descriptor de archivo utilizable con primitivas del módulo :mod:" "`select`." @@ -2220,7 +2220,7 @@ msgstr "" #: ../Doc/library/multiprocessing.rst:1512 #: ../Doc/library/multiprocessing.rst:1527 msgid "Note that *lock* is a keyword-only argument." -msgstr "Véase que *lock* es un argumento de solo una palabra clave." +msgstr "Véase que *lock* es un argumento de solo una palabra clave." #: ../Doc/library/multiprocessing.rst:1426 msgid "" @@ -2702,7 +2702,7 @@ msgid "" msgstr "" "El *method_to_typeid* es una asignación utilizada para especificar el tipo " "de retorno de los métodos expuestos que deberían devolver un proxy. Asigna " -"nombres de métodos a cadenas typeid. (Si *method_to_typeid* es ``None`` " +"nombres de métodos a cadenas *typeid*. (Si *method_to_typeid* es ``None`` " "entonces :attr:`proxytype._method_to_typeid` se usa en su lugar si existe). " "Si el nombre de un método no es una clave de esta asignación o si la " "asignación es` `None`` entonces el objeto retornado por el método se copiará " From cab59c0767861abd4e3bd725c9c67c14faa7db6f Mon Sep 17 00:00:00 2001 From: Maria Jose Molina Contreras <32220621+mjmolina@users.noreply.github.com> Date: Mon, 29 Jun 2020 21:06:03 +0200 Subject: [PATCH 3/7] Apply suggestions from code review MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Cristián Maureira-Fredes --- library/multiprocessing.po | 170 ++++++++++++++++++------------------- 1 file changed, 85 insertions(+), 85 deletions(-) diff --git a/library/multiprocessing.po b/library/multiprocessing.po index af292624d0..1698de0641 100644 --- a/library/multiprocessing.po +++ b/library/multiprocessing.po @@ -24,11 +24,11 @@ msgstr "" #: ../Doc/library/multiprocessing.rst:2 msgid ":mod:`multiprocessing` --- Process-based parallelism" -msgstr ":mod:`multiprocessing` ---Proceso-basado en paralelismo" +msgstr ":mod:`multiprocessing` --- Proceso basado en paralelismo" #: ../Doc/library/multiprocessing.rst:7 msgid "**Source code:** :source:`Lib/multiprocessing/`" -msgstr "**Source code:** :source:`Lib/multiprocessing/`" +msgstr "**Código fuente:** :source:`Lib/multiprocessing/`" #: ../Doc/library/multiprocessing.rst:12 msgid "Introduction" @@ -108,7 +108,7 @@ msgid "" "necessary, see :ref:`multiprocessing-programming`." msgstr "" "Para obtener una explicación de por qué es necesaria la parte ``if __name__ " -"== ‘__main__’`` , consulte :ref:`multiprocessing-programming`." +"== '__main__'`` , consulte :ref:`multiprocessing-programming`." #: ../Doc/library/multiprocessing.rst:90 msgid "Contexts and start methods" @@ -206,7 +206,7 @@ msgstr "" #: ../Doc/library/multiprocessing.rst:133 msgid "" -"*spawn* added on all Unix platforms, and *forkserver* added for some Unix " +"*spawn* added on all unix platforms, and *forkserver* added for some unix " "platforms. Child processes no longer inherit all of the parents inheritable " "handles on Windows." msgstr "" @@ -296,10 +296,10 @@ msgid "" "**PyInstaller** and **cx_Freeze**) on Unix. The ``'fork'`` start method does " "work." msgstr "" -"Los métodos de inicio ``’spawn’`` y ``’forkserver’`` actualmente no se " -"pueden usar con ejecutables “congelados”(*“frozen”*)(es decir, binarios " +"Los métodos de inicio ``'spawn'`` y ``'forkserver'`` actualmente no se " +"pueden usar con ejecutables \"congelados\" (*frozen*)(es decir, binarios " "producidos por paquetes como **PyInstaller** y **cx_Freeze**) en Unix. El " -"método de inicio ``’fork’`` funciona." +"método de inicio ``'fork'`` funciona." #: ../Doc/library/multiprocessing.rst:208 msgid "Exchanging objects between processes" @@ -331,7 +331,7 @@ msgstr "Las colas (*queues*) son hilos y procesos seguro." #: ../Doc/library/multiprocessing.rst:232 msgid "**Pipes**" -msgstr "**Tuberías (*tuberías*)**" +msgstr "**Tuberías (*Pipes*)**" #: ../Doc/library/multiprocessing.rst:234 msgid "" @@ -407,7 +407,7 @@ msgstr "" #: ../Doc/library/multiprocessing.rst:295 msgid "**Shared memory**" -msgstr "**Shared memory**" +msgstr "**Memoria compartida**" #: ../Doc/library/multiprocessing.rst:297 msgid "" @@ -429,9 +429,9 @@ msgid "" "double precision float and ``'i'`` indicates a signed integer. These shared " "objects will be process and thread-safe." msgstr "" -"Los argumentos `` ‘d’ ‘’ y ``'i'``utilizados al crear `` num ‘’ y `` arr ‘’ " -"son códigos de tipo del tipo utilizado por: mod: `array` module:` `’ d’`` " -"indica un flotador de doble precisión y `` ‘i’`` indica un entero con signo. " +"Los argumentos ``'d'`` y ``'i'``utilizados al crear ``num`` y ``arr`` " +"son códigos de tipo del tipo utilizado por :mod:`array` module: ``'d'`` " +"indica un flotador de doble precisión y ``'i'`` indica un entero con signo. " "Estos objetos compartidos serán seguros para procesos y subprocesos." #: ../Doc/library/multiprocessing.rst:328 @@ -456,7 +456,7 @@ msgid "" msgstr "" "Un objeto de administrador retornado por :func:`Manager` controla un proceso " "de servidor que contiene objetos de Python y permite que otros procesos los " -"manipulen usando *proxies*." +"manipulen usando proxies." #: ../Doc/library/multiprocessing.rst:338 msgid "" @@ -575,7 +575,7 @@ msgid "" "creating process." msgstr "" "El constructor siempre debe llamarse con argumentos de palabras clave. " -"*group* siempre debe ser ``None`` ; existe únicamente por compatibilidad " +"*group* siempre debe ser ``None``; existe únicamente por compatibilidad " "con :class:`threading.Thread`. *target* es el objeto invocable a ser llamado " "por el método :meth:`run()` . El valor predeterminado es ``None``, lo que " "significa que nada es llamado. *name* es el nombre del proceso (consulte :" @@ -679,7 +679,7 @@ msgid "" msgstr "" "El nombre inicial es establecido por el constructor. Si no se proporciona un " "nombre explícito al constructor, se forma un nombre usando *'Process-N\\ :" -"sub:`1`:N\\ :sub:`2`:...:N\\ :sub:`k* se construye, donde cada *N\\ :sub:" +"sub:`1`:N\\ :sub:`2`:...:N\\ :sub:`k`'* se construye, donde cada *N\\ :sub:" "`k`* es el *N-enésimo* hijo del parental." #: ../Doc/library/multiprocessing.rst:539 @@ -960,7 +960,7 @@ msgid "" "see :ref:`multiprocessing-managers`." msgstr "" "Tenga en cuenta que también se puede crear una cola compartida mediante el " -"uso de un objeto de administrador; consulte :ref:`multiprocessing-managers`." +"uso de un objeto de administrador -- consulte :ref:`multiprocessing-managers`." #: ../Doc/library/multiprocessing.rst:705 msgid "" @@ -1094,7 +1094,7 @@ msgid "" "is started which transfers objects from a buffer into the pipe." msgstr "" "Retorna un proceso de cola (*queue*) compartida implementado utilizando una " -"tubería (*pipe*) y algunos candados (*locks*) / semáforos (*semaphores*). " +"tubería (*pipe*) y algunos candados/semáforos (*locks/semaphores*). " "Cuando un proceso pone por primera vez un elemento en la cola, se inicia un " "hilo alimentador que transfiere objetos desde un búfer a la tubería." @@ -1322,7 +1322,7 @@ msgid "" "additionally has :meth:`task_done` and :meth:`join` methods." msgstr "" ":class:`JoinableQueue`, una subclase :class:`Queue` , es una cola (*queue*) " -"que además tiene los métodos :meth:`task_done` y :meth:`join` ." +"que además tiene los métodos :meth:`task_done` y :meth:`join`." #: ../Doc/library/multiprocessing.rst:901 msgid "" @@ -1345,7 +1345,7 @@ msgstr "" "Si un :meth:`~queue.Queue.join` se está bloqueando actualmente, se reanudará " "cuando se hayan procesado todos los elementos (lo que significa que :meth:" "`task_done` es llamado para cada elemento que había sido puesto en cola " -"(*queue*) por :meth:`~Queue.put` )." +"(*queue*) por :meth:`~Queue.put`)." #: ../Doc/library/multiprocessing.rst:910 msgid "" @@ -1388,7 +1388,7 @@ msgid "" "Calling this has the side effect of \"joining\" any processes which have " "already finished." msgstr "" -"Llamar a esto tiene el efecto secundario de \"unir\" cualquier proceso que " +"Llamar a esto tiene el efecto secundario de \"unir\" (*joining*) cualquier proceso que " "ya haya finalizado." #: ../Doc/library/multiprocessing.rst:937 @@ -1740,7 +1740,7 @@ msgid "" "exception instance." msgstr "" "Si el búfer es demasiado corto, se genera una excepción :exc:" -"`BufferTooShort` y el mensaje completo está disponible como ``e.args [0]`` " +"`BufferTooShort` y el mensaje completo está disponible como ``e.args[0]`` " "donde ``e`` es la instancia de excepción." #: ../Doc/library/multiprocessing.rst:1149 @@ -1801,7 +1801,7 @@ msgstr "" #: ../Doc/library/multiprocessing.rst:1199 msgid "Synchronization primitives" -msgstr "Sincronizaciones primitivas (*Synchronization primitives*)" +msgstr "Primitivas de sincronización (*Synchronization primitives*)" #: ../Doc/library/multiprocessing.rst:1203 msgid "" @@ -1908,7 +1908,7 @@ msgid "" "used in :keyword:`with` statements." msgstr "" "La :class:`Lock` soporta el protocolo :term:`context manager` y, por lo " -"tanto, se puede usar en la declaración :keyword:`with` ." +"tanto, se puede usar en la declaración :keyword:`with`." #: ../Doc/library/multiprocessing.rst:1262 #: ../Doc/library/multiprocessing.rst:1313 @@ -1936,7 +1936,7 @@ msgid "" msgstr "" "Con el argumento *block* establecido en ``False``, la llamada al método no " "se bloquea. Si el bloqueo está actualmente en un estado bloqueado, retorna " -"``False`` ; de lo contrario, configure el bloqueo en un estado bloqueado y " +"``False``; de lo contrario, configure el bloqueo en un estado bloqueado y " "retorne ``True``." #: ../Doc/library/multiprocessing.rst:1273 @@ -2122,8 +2122,8 @@ msgid "" msgstr "" "Si la señal SIGINT generada por :kbd:`Ctrl-C` llega mientras el hilo " "principal está bloqueado por una llamada a :meth:`BoundedSemaphore." -"acquire` , :meth:`Lock.acquire`, :meth:`RLock.acquire`, :meth:`Semaphore." -"acquire` , :meth:`Condition.acquire` o :meth:`Condition.wait`, la llamada " +"acquire`, :meth:`Lock.acquire`, :meth:`RLock.acquire`, :meth:`Semaphore." +"acquire`, :meth:`Condition.acquire` o :meth:`Condition.wait`, la llamada " "se interrumpirá inmediatamente y :exc:`KeyboardInterrupt` se lanzará." #: ../Doc/library/multiprocessing.rst:1375 @@ -2145,7 +2145,7 @@ msgstr "" "Parte de la funcionalidad de este paquete requiere una implementación de " "semáforo compartido que funcione en el sistema operativo. Sin uno, el " "módulo :mod:`multiprocessing.synchronize` se desactivará, y los intentos de " -"importarlo darán como resultado :exc:`ImportError`. Consulte :issue:`3770`` " +"importarlo darán como resultado :exc:`ImportError`. Consulte :issue:`3770` " "para información adicional." #: ../Doc/library/multiprocessing.rst:1388 @@ -2204,7 +2204,7 @@ msgid "" "if, for instance, you want to atomically increment a shared value it is " "insufficient to just do ::" msgstr "" -"Operaciones como ``+ =`` que implican una lectura y escritura no son " +"Operaciones como ``+=`` que implican una lectura y escritura no son " "atómicas. Entonces, si, por ejemplo, desea incrementar atómicamente un valor " "compartido, es insuficiente simplemente hacer::" @@ -2229,7 +2229,7 @@ msgid "" msgstr "" "Retorna una matriz *ctypes* asignada desde la memoria compartida. Por " "defecto, el valor de retorno es en realidad un contenedor sincronizado para " -"la matriz." +"el arreglo." #: ../Doc/library/multiprocessing.rst:1429 msgid "" @@ -2324,7 +2324,7 @@ msgstr "" "un entero, entonces determina la longitud de la matriz, y la matriz se " "pondrá a cero inicialmente. De lo contrario, *size_or_initializer* es una " "secuencia que se usa para inicializar la matriz y cuya longitud determina la " -"longitud de la matriz." +"longitud del arreglo." #: ../Doc/library/multiprocessing.rst:1478 msgid "" @@ -2358,7 +2358,7 @@ msgid "" msgstr "" "Tenga en cuenta que una matriz de :data:`ctypes.c_char` tiene atributos " "``value`` y` `raw`` que le permiten a uno usarlo para almacenar y recuperar " -"cadenas; consulte la documentación para :mod:`ctypes`." +"cadenas de caracteres -- consulte la documentación para :mod:`ctypes`." #: ../Doc/library/multiprocessing.rst:1500 msgid "" @@ -2368,7 +2368,7 @@ msgid "" msgstr "" "Lo mismo que :func:`RawArray`, excepto que, dependiendo del valor de *lock*, " "se puede devolver un contenedor de sincronización seguro para el proceso en " -"lugar de una matriz de tipos crudos." +"lugar de un arreglo de tipos crudos." #: ../Doc/library/multiprocessing.rst:1504 #: ../Doc/library/multiprocessing.rst:1520 @@ -2470,7 +2470,7 @@ msgstr "*RawValue(c_double, 2.4)*" #: ../Doc/library/multiprocessing.rst:1558 msgid "RawValue('d', 2.4)" -msgstr "*RawValue(‘d’, 2.4)*" +msgstr "*RawValue('d', 2.4)*" #: ../Doc/library/multiprocessing.rst:1559 msgid "MyStruct(4, 6)" @@ -2502,7 +2502,7 @@ msgstr "*RawArray(c_int, (9, 2, 8))*" #: ../Doc/library/multiprocessing.rst:1561 msgid "RawArray('i', (9, 2, 8))" -msgstr "*RawArray(‘i’, (9, 2, 8))*" +msgstr "*RawArray('i', (9, 2, 8))*" #: ../Doc/library/multiprocessing.rst:1565 msgid "" @@ -2545,7 +2545,7 @@ msgstr "" "Retorna un objeto iniciado :class:`~multiprocessing.managers.SyncManager` " "que se puede usar para compartir objetos entre procesos. El objeto " "administrador retornado corresponde a un proceso hijo generado y tiene " -"métodos que crearán objetos compartidos y devolverán los *proxies* " +"métodos que crearán objetos compartidos y devolverán los proxies " "correspondientes." #: ../Doc/library/multiprocessing.rst:1634 @@ -2609,7 +2609,7 @@ msgid "" msgstr "" "Retorna un objeto :class:`Server` que representa el servidor real bajo el " "control del Administrador. El objeto :class:`Server` admite el método :meth:" -"`serve_forever` ::" +"`serve_forever`::" #: ../Doc/library/multiprocessing.rst:1669 msgid ":class:`Server` additionally has an :attr:`address` attribute." @@ -2670,7 +2670,7 @@ msgid "" msgstr "" "*proxytype* es una subclase de :class:`BaseProxy` que se usa para crear " "*proxies* para objetos compartidos con este *typeid*. Si ``None``, se crea " -"automáticamente una clase *proxy*." +"automáticamente una clase proxy." #: ../Doc/library/multiprocessing.rst:1704 msgid "" @@ -2688,8 +2688,8 @@ msgstr "" "``None``, entonces :attr:`proxytype._exposed_` se usa en su lugar si " "existe). En el caso de que no se especifique una lista expuesta, todos los " "\"métodos públicos\" del objeto compartido serán accesibles . (Aquí un " -"\"método público\" significa cualquier atributo que tenga un método :meth:`~ " -"object .__ call__` y cuyo nombre no comience con` `'_'``.)" +"\"método público\" significa cualquier atributo que tenga un método :meth:`~" +"object.__call__` y cuyo nombre no comience con ``'_'``.)" #: ../Doc/library/multiprocessing.rst:1713 msgid "" @@ -2705,7 +2705,7 @@ msgstr "" "nombres de métodos a cadenas *typeid*. (Si *method_to_typeid* es ``None`` " "entonces :attr:`proxytype._method_to_typeid` se usa en su lugar si existe). " "Si el nombre de un método no es una clave de esta asignación o si la " -"asignación es` `None`` entonces el objeto retornado por el método se copiará " +"asignación es ``None`` entonces el objeto retornado por el método se copiará " "por valor." #: ../Doc/library/multiprocessing.rst:1720 @@ -2736,9 +2736,9 @@ msgid "" "object. :meth:`~contextmanager.__exit__` calls :meth:`shutdown`." msgstr "" "Los objetos de administrador admiten el protocolo de gestión de contexto; " -"consulte :ref:`typecontextmanager`. :meth:`~contextmanager.__ enter__` " +"consulte :ref:`typecontextmanager`. :meth:`~contextmanager.__enter__` " "inicia el proceso del servidor (si aún no se ha iniciado) y luego retorna el " -"objeto de administrador. :meth:`~contextmanager .__ exit__` llama :meth:" +"objeto de administrador. :meth:`~contextmanager .__exit__` llama :meth:" "`shutdown`." #: ../Doc/library/multiprocessing.rst:1736 @@ -2746,7 +2746,7 @@ msgid "" "In previous versions :meth:`~contextmanager.__enter__` did not start the " "manager's server process if it was not already started." msgstr "" -"En versiones anteriores :meth:`~contextmanager.__ enter__` no iniciaba el " +"En versiones anteriores :meth:`~contextmanager.__enter__` no iniciaba el " "proceso del servidor del administrador si aún no se había iniciado." #: ../Doc/library/multiprocessing.rst:1741 @@ -2773,7 +2773,7 @@ msgstr "" msgid "" "Create a shared :class:`threading.Barrier` object and return a proxy for it." msgstr "" -":class:`threading.Barrier` crea un objeto compartido y retorna un *proxy* " +":class:`threading.Barrier` crea un objeto compartido y retorna un proxy " "para él." #: ../Doc/library/multiprocessing.rst:1758 @@ -2782,14 +2782,14 @@ msgid "" "proxy for it." msgstr "" "Crea un objeto compartido :class:`threading.BoundedSemaphore` y retorna un " -"*proxy* para él." +"proxy para él." #: ../Doc/library/multiprocessing.rst:1763 msgid "" "Create a shared :class:`threading.Condition` object and return a proxy for " "it." msgstr "" -"Crea un objeto compartido :class:`threading.Condition` y retorna un *proxy* " +"Crea un objeto compartido :class:`threading.Condition` y retorna un proxy " "para él." #: ../Doc/library/multiprocessing.rst:1766 @@ -2797,38 +2797,38 @@ msgid "" "If *lock* is supplied then it should be a proxy for a :class:`threading." "Lock` or :class:`threading.RLock` object." msgstr "" -"Si se proporciona *lock*, debería ser un *proxy* para un objeto :class:" +"Si se proporciona *lock*, debería ser un proxy para un objeto :class:" "`threading.Lock` o :class:`threading.RLock`." #: ../Doc/library/multiprocessing.rst:1774 msgid "" "Create a shared :class:`threading.Event` object and return a proxy for it." msgstr "" -"Crea un objeto compartido :class:`threading.Event` y retorna un *proxy* para " +"Crea un objeto compartido :class:`threading.Event` y retorna un proxy para " "él." #: ../Doc/library/multiprocessing.rst:1778 msgid "" "Create a shared :class:`threading.Lock` object and return a proxy for it." msgstr "" -"Crea un objeto compartido :class:`threading.Lock` y retorna un *proxy* para " +"Crea un objeto compartido :class:`threading.Lock` y retorna un proxy para " "él." #: ../Doc/library/multiprocessing.rst:1782 msgid "Create a shared :class:`Namespace` object and return a proxy for it." msgstr "" -"Crea un objeto compartido :class:`Namespace` y retorna un *proxy* para él." +"Crea un objeto compartido :class:`Namespace` y retorna un proxy para él." #: ../Doc/library/multiprocessing.rst:1786 msgid "Create a shared :class:`queue.Queue` object and return a proxy for it." msgstr "" -"Crea un objeto compartido :class:`queue.Queue` y retorna un *proxy* para él." +"Crea un objeto compartido :class:`queue.Queue` y retorna un proxy para él." #: ../Doc/library/multiprocessing.rst:1790 msgid "" "Create a shared :class:`threading.RLock` object and return a proxy for it." msgstr "" -"Crea un objeto compartido :class:`threading.RLock` y retorna un *proxy* para " +"Crea un objeto compartido :class:`threading.RLock` y retorna un proxy para " "él." #: ../Doc/library/multiprocessing.rst:1794 @@ -2853,11 +2853,11 @@ msgstr "" #: ../Doc/library/multiprocessing.rst:1810 msgid "Create a shared :class:`dict` object and return a proxy for it." -msgstr "Crea un objeto compartido :class:`dict` y retorna un *proxy* para él." +msgstr "Crea un objeto compartido :class:`dict` y retorna un proxy para él." #: ../Doc/library/multiprocessing.rst:1815 msgid "Create a shared :class:`list` object and return a proxy for it." -msgstr "Crea un objeto compartido :class:`list` y retorna un *proxy* para él." +msgstr "Crea un objeto compartido :class:`list` y retorna un proxy para él." #: ../Doc/library/multiprocessing.rst:1817 msgid "" @@ -2889,7 +2889,7 @@ msgid "" "referent:" msgstr "" "Sin embargo, cuando se usa un proxy para un objeto de espacio de nombres, un " -"atributo que comience con `` '_'`` será un atributo del *proxy* y no un " +"atributo que comience con ``'_'`` será un atributo del proxy y no un " "atributo del referente:" #: ../Doc/library/multiprocessing.rst:1845 @@ -2909,7 +2909,7 @@ msgstr "" #: ../Doc/library/multiprocessing.rst:1872 msgid "Using a remote manager" -msgstr "Utilizando un administrador (*manager*) remoto" +msgstr "Utilizando un administrador remoto" #: ../Doc/library/multiprocessing.rst:1874 msgid "" @@ -2917,7 +2917,7 @@ msgid "" "it from other machines (assuming that the firewalls involved allow it)." msgstr "" "Es posible ejecutar un servidor administrador en una máquina y hacer que los " -"clientes lo usen desde otras máquinas (suponiendo que los *firewalls* " +"clientes lo usen desde otras máquinas (suponiendo que los cortafuegos " "involucrados lo permitan)." #: ../Doc/library/multiprocessing.rst:1877 @@ -2954,10 +2954,10 @@ msgid "" "(presumably) in a different process. The shared object is said to be the " "*referent* of the proxy. Multiple proxy objects may have the same referent." msgstr "" -"Un proxy es un objeto que *se refiere* (*refers*) a un objeto compartido que " +"Un proxy es un objeto que *se refiere* a un objeto compartido que " "vive (presumiblemente) en un proceso diferente. Se dice que el objeto " -"compartido es el *referente* (*referent*) del *proxy*. Varios objetos " -"*proxy* pueden tener el mismo referente." +"compartido es el *referente* del proxy. Varios objetos " +"proxy pueden tener el mismo referente." #: ../Doc/library/multiprocessing.rst:1941 msgid "" @@ -2979,7 +2979,7 @@ msgid "" msgstr "" "Tenga en cuenta que la aplicación :func:`str` a un proxy devolverá la " "representación del referente, mientras que la aplicación :func:`repr` " -"devolverá la representación del proxy." +"retornará la representación del proxy." #: ../Doc/library/multiprocessing.rst:1963 msgid "" @@ -3186,7 +3186,7 @@ msgstr "" "*maxtasksperchild* es el número de tareas que un proceso de trabajo puede " "completar antes de salir y ser reemplazado por un proceso de trabajo nuevo, " "para permitir que se liberen los recursos no utilizados. El valor " -"predeterminado *maxtasksperchild* es ``None`` , lo que significa que los " +"predeterminado *maxtasksperchild* es ``None``, lo que significa que los " "procesos de trabajo vivirán tanto tiempo como el grupo." #: ../Doc/library/multiprocessing.rst:2122 @@ -3229,9 +3229,9 @@ msgid "" "pool as CPython does not assure that the finalizer of the pool will be " "called (see :meth:`object.__del__` for more information)." msgstr "" -"Tenga en cuenta que **not correct** (**no correcto**)confiar en el " +"Tenga en cuenta que **no es correcto** confiar en el " "recolector de basura para destruir el grupo ya que *CPython* no asegura que " -"se llamará al finalizador del grupo (consulte :meth:`object.__ del__` para " +"se llamará al finalizador del grupo (consulte :meth:`object.__del__` para " "obtener más información)." #: ../Doc/library/multiprocessing.rst:2141 @@ -3378,9 +3378,9 @@ msgid "" "returned iterator should be considered arbitrary. (Only when there is only " "one worker process is the order guaranteed to be \"correct\".)" msgstr "" -"Lo mismo que :meth:`imap` , excepto que el orden de los resultados del " +"Lo mismo que :meth:`imap`, excepto que el orden de los resultados del " "iterador retornado debe considerarse arbitrario. (Solo cuando hay un solo " -"proceso de trabajo se garantiza que el orden sea “correcto”)." +"proceso de trabajo se garantiza que el orden sea \"correcto\")." #: ../Doc/library/multiprocessing.rst:2232 msgid "" @@ -3596,7 +3596,7 @@ msgid "" "connections." msgstr "" "Un contenedor para un *socket* vinculado o una tubería (*pipe*) con nombre " -"de Windows que está ‘escuchando’ las conexiones." +"de Windows que está 'escuchando' las conexiones." #: ../Doc/library/multiprocessing.rst:2379 msgid "" @@ -3612,32 +3612,32 @@ msgid "" "end point on Windows. If you require a connectable end-point, you should use " "'127.0.0.1'." msgstr "" -"Si se usa una dirección de ‘0.0.0.0’ , la dirección no será un punto final " +"Si se usa una dirección de '0.0.0.0' , la dirección no será un punto final " "conectable en Windows. Si necesita un punto final conectable, debe usar " -"‘127.0.0.1’." +"'127.0.0.1'." #: ../Doc/library/multiprocessing.rst:2388 msgid "" "*family* is the type of socket (or named pipe) to use. This can be one of " -"the strings ``'AF_INET'`` (for a TCP socket), ``'AF_Unix'`` (for a Unix " +"the strings ``'AF_INET'`` (for a TCP socket), ``'AF_UNIX'`` (for a Unix " "domain socket) or ``'AF_PIPE'`` (for a Windows named pipe). Of these only " "the first is guaranteed to be available. If *family* is ``None`` then the " "family is inferred from the format of *address*. If *address* is also " "``None`` then a default is chosen. This default is the family which is " "assumed to be the fastest available. See :ref:`multiprocessing-address-" -"formats`. Note that if *family* is ``'AF_Unix'`` and address is ``None`` " +"formats`. Note that if *family* is ``'AF_UNIX'`` and address is ``None`` " "then the socket will be created in a private temporary directory created " "using :func:`tempfile.mkstemp`." msgstr "" "*family* es el tipo de socket (o tubería con nombre) a utilizar. Esta puede " -"ser una de las cadenas de caracteres`` 'AF_INET'`` (para un socket TCP), ``' " -"AF_Unix'`` (para un socket de dominio Unix) o `` 'AF_PIPE'`` (para una " +"ser una de las cadenas de caracteres ``'AF_INET'`` (para un socket TCP), ``' " +"AF_UNIX'`` (para un socket de dominio Unix) o ``'AF_PIPE'`` (para una " "tubería con nombre de Windows) . De estos, solo el primero está garantizado " "para estar disponible. Si *family* es ``None`` , *family* se deduce del " "formato de *address*. Si *address* también es ``None`` , se elige un valor " "predeterminado. Este valor predeterminado es *family* con la opción más " "rápida disponible. Consulte :ref:`multiprocessing-address-format`. Tenga en " -"cuenta que si *family* es ``'AF_Unix'`` y la dirección es ``None``, el " +"cuenta que si *family* es ``'AF_UNIX'`` y la dirección es ``None``, el " "*socket* se creará en un directorio temporal privado usando :func:`tempfile." "mkstemp`." @@ -3768,13 +3768,13 @@ msgstr "" "**Windows**: Un elemento en *object_list* debe ser un identificador de " "número entero que se pueda esperar (de acuerdo con la definición utilizada " "por la documentación de la función *Win32* ``WaitForMultipleObjects()``) o " -"puede ser un objeto con un :meth:`fileno` Método que retorna un mango de " -"tubo o mango de tubería. (Tenga en cuenta que las manijas de las tuberías y " +"puede ser un objeto con un :meth:`fileno` Método que retorna un manejador de " +"tubo o manejador de tubería. (Tenga en cuenta que las manijas de las tuberías y " "las manijas de los zócalos son **no** manijas aptas)" #: ../Doc/library/multiprocessing.rst:2473 msgid "**Examples**" -msgstr "**Examples**" +msgstr "**Ejemplos**" #: ../Doc/library/multiprocessing.rst:2475 msgid "" @@ -3812,7 +3812,7 @@ msgid "" "*hostname* is a string and *port* is an integer." msgstr "" "Una dirección ``'AF_INET'`` es una tupla de la forma ``(hostname, port)`` " -"donde *hostname* es una cadena y *port* es un número entero." +"donde *hostname* es una cadena de caracteres y *port* es un número entero." #: ../Doc/library/multiprocessing.rst:2555 msgid "" @@ -3915,7 +3915,7 @@ msgid "" "mixed up." msgstr "" "Existe cierto soporte para el registro. Sin embargo, tenga en cuenta que el " -"paquete :mod:`logging` no utiliza bloqueos compartidos de proceso, por lo " +"paquete :mod:`logging` no utiliza candados compartidos de proceso, por lo " "que es posible (dependiendo del tipo de controlador) que los mensajes de " "diferentes procesos se mezclen." @@ -3924,7 +3924,7 @@ msgid "" "Returns the logger used by :mod:`multiprocessing`. If necessary, a new one " "will be created." msgstr "" -"retorna el registrador utilizado por :mod:`multiprocessing`. Si es " +"Retorna el registrador utilizado por :mod:`multiprocessing`. Si es " "necesario, se creará uno nuevo." #: ../Doc/library/multiprocessing.rst:2608 @@ -4037,7 +4037,7 @@ msgstr "" #: ../Doc/library/multiprocessing.rst:2679 msgid "Thread safety of proxies" -msgstr "Hilo seguro de *proxies*" +msgstr "Seguridad de hilos de *proxies*" #: ../Doc/library/multiprocessing.rst:2681 msgid "" @@ -4109,8 +4109,8 @@ msgid "" msgstr "" "El uso del método :meth:`Process.terminate ` para detener un proceso puede causar que los recursos " -"compartidos (como candados *locks*, semáforos, tuberías *pipes* y colas " -"*queues*) que el proceso utiliza actualmente se rompan o no disponible para " +"compartidos (como candados, semáforos, tuberías y colas" +") que el proceso utiliza actualmente se rompan o no disponible para " "otros procesos." #: ../Doc/library/multiprocessing.rst:2714 @@ -4166,7 +4166,7 @@ msgid "" "join()`` line)." msgstr "" "Una solución aquí sería intercambiar las dos últimas líneas (o simplemente " -"eliminar la línea ``p.join()`` )." +"eliminar la línea ``p.join()``)." #: ../Doc/library/multiprocessing.rst:2749 msgid "Explicitly pass resources to child processes" @@ -4235,7 +4235,7 @@ msgstr "" "Lo que resuelve el problema fundamental de los procesos que chocan entre sí " "dando como resultado un error de descriptor de archivo incorrecto, pero " "presenta un peligro potencial para las aplicaciones que reemplazan :func:" -"`sys.stdin` con un\" objeto similar a un archivo \"con almacenamiento en " +"`sys.stdin` con un \"objeto similar a un archivo\" con almacenamiento en " "búfer de salida. Este peligro es que si varios procesos invocan :meth:`~io." "IOBase.close()` en este objeto similar a un archivo, podría ocasionar que " "los mismos datos se vacíen al objeto varias veces, lo que provocaría " From 34c403205e17d7e2b4d361b3d2288b10feaa49a5 Mon Sep 17 00:00:00 2001 From: Maria Jose Molina Date: Mon, 29 Jun 2020 21:46:26 +0200 Subject: [PATCH 4/7] Aplicando powrap a library/multiprocessing --- library/multiprocessing.po | 74 +++++++++++++++++++------------------- 1 file changed, 36 insertions(+), 38 deletions(-) diff --git a/library/multiprocessing.po b/library/multiprocessing.po index 1698de0641..246e03ec53 100644 --- a/library/multiprocessing.po +++ b/library/multiprocessing.po @@ -429,10 +429,10 @@ msgid "" "double precision float and ``'i'`` indicates a signed integer. These shared " "objects will be process and thread-safe." msgstr "" -"Los argumentos ``'d'`` y ``'i'``utilizados al crear ``num`` y ``arr`` " -"son códigos de tipo del tipo utilizado por :mod:`array` module: ``'d'`` " -"indica un flotador de doble precisión y ``'i'`` indica un entero con signo. " -"Estos objetos compartidos serán seguros para procesos y subprocesos." +"Los argumentos ``'d'`` y ``'i'``utilizados al crear ``num`` y ``arr`` son " +"códigos de tipo del tipo utilizado por :mod:`array` module: ``'d'`` indica " +"un flotador de doble precisión y ``'i'`` indica un entero con signo. Estos " +"objetos compartidos serán seguros para procesos y subprocesos." #: ../Doc/library/multiprocessing.rst:328 msgid "" @@ -575,9 +575,9 @@ msgid "" "creating process." msgstr "" "El constructor siempre debe llamarse con argumentos de palabras clave. " -"*group* siempre debe ser ``None``; existe únicamente por compatibilidad " -"con :class:`threading.Thread`. *target* es el objeto invocable a ser llamado " -"por el método :meth:`run()` . El valor predeterminado es ``None``, lo que " +"*group* siempre debe ser ``None``; existe únicamente por compatibilidad con :" +"class:`threading.Thread`. *target* es el objeto invocable a ser llamado por " +"el método :meth:`run()` . El valor predeterminado es ``None``, lo que " "significa que nada es llamado. *name* es el nombre del proceso (consulte :" "attr:`name` para más detalles). *args* es la tupla de argumento para la " "invocación de destino. *kwargs* es un diccionario de argumentos de palabras " @@ -960,7 +960,8 @@ msgid "" "see :ref:`multiprocessing-managers`." msgstr "" "Tenga en cuenta que también se puede crear una cola compartida mediante el " -"uso de un objeto de administrador -- consulte :ref:`multiprocessing-managers`." +"uso de un objeto de administrador -- consulte :ref:`multiprocessing-" +"managers`." #: ../Doc/library/multiprocessing.rst:705 msgid "" @@ -1094,9 +1095,9 @@ msgid "" "is started which transfers objects from a buffer into the pipe." msgstr "" "Retorna un proceso de cola (*queue*) compartida implementado utilizando una " -"tubería (*pipe*) y algunos candados/semáforos (*locks/semaphores*). " -"Cuando un proceso pone por primera vez un elemento en la cola, se inicia un " -"hilo alimentador que transfiere objetos desde un búfer a la tubería." +"tubería (*pipe*) y algunos candados/semáforos (*locks/semaphores*). Cuando " +"un proceso pone por primera vez un elemento en la cola, se inicia un hilo " +"alimentador que transfiere objetos desde un búfer a la tubería." #: ../Doc/library/multiprocessing.rst:773 msgid "" @@ -1388,8 +1389,8 @@ msgid "" "Calling this has the side effect of \"joining\" any processes which have " "already finished." msgstr "" -"Llamar a esto tiene el efecto secundario de \"unir\" (*joining*) cualquier proceso que " -"ya haya finalizado." +"Llamar a esto tiene el efecto secundario de \"unir\" (*joining*) cualquier " +"proceso que ya haya finalizado." #: ../Doc/library/multiprocessing.rst:937 msgid "Return the number of CPUs in the system." @@ -2123,8 +2124,8 @@ msgstr "" "Si la señal SIGINT generada por :kbd:`Ctrl-C` llega mientras el hilo " "principal está bloqueado por una llamada a :meth:`BoundedSemaphore." "acquire`, :meth:`Lock.acquire`, :meth:`RLock.acquire`, :meth:`Semaphore." -"acquire`, :meth:`Condition.acquire` o :meth:`Condition.wait`, la llamada " -"se interrumpirá inmediatamente y :exc:`KeyboardInterrupt` se lanzará." +"acquire`, :meth:`Condition.acquire` o :meth:`Condition.wait`, la llamada se " +"interrumpirá inmediatamente y :exc:`KeyboardInterrupt` se lanzará." #: ../Doc/library/multiprocessing.rst:1375 msgid "" @@ -2688,8 +2689,8 @@ msgstr "" "``None``, entonces :attr:`proxytype._exposed_` se usa en su lugar si " "existe). En el caso de que no se especifique una lista expuesta, todos los " "\"métodos públicos\" del objeto compartido serán accesibles . (Aquí un " -"\"método público\" significa cualquier atributo que tenga un método :meth:`~" -"object.__call__` y cuyo nombre no comience con ``'_'``.)" +"\"método público\" significa cualquier atributo que tenga un método :meth:" +"`~object.__call__` y cuyo nombre no comience con ``'_'``.)" #: ../Doc/library/multiprocessing.rst:1713 msgid "" @@ -2736,10 +2737,9 @@ msgid "" "object. :meth:`~contextmanager.__exit__` calls :meth:`shutdown`." msgstr "" "Los objetos de administrador admiten el protocolo de gestión de contexto; " -"consulte :ref:`typecontextmanager`. :meth:`~contextmanager.__enter__` " -"inicia el proceso del servidor (si aún no se ha iniciado) y luego retorna el " -"objeto de administrador. :meth:`~contextmanager .__exit__` llama :meth:" -"`shutdown`." +"consulte :ref:`typecontextmanager`. :meth:`~contextmanager.__enter__` inicia " +"el proceso del servidor (si aún no se ha iniciado) y luego retorna el objeto " +"de administrador. :meth:`~contextmanager .__exit__` llama :meth:`shutdown`." #: ../Doc/library/multiprocessing.rst:1736 msgid "" @@ -2773,8 +2773,8 @@ msgstr "" msgid "" "Create a shared :class:`threading.Barrier` object and return a proxy for it." msgstr "" -":class:`threading.Barrier` crea un objeto compartido y retorna un proxy " -"para él." +":class:`threading.Barrier` crea un objeto compartido y retorna un proxy para " +"él." #: ../Doc/library/multiprocessing.rst:1758 msgid "" @@ -2811,8 +2811,7 @@ msgstr "" msgid "" "Create a shared :class:`threading.Lock` object and return a proxy for it." msgstr "" -"Crea un objeto compartido :class:`threading.Lock` y retorna un proxy para " -"él." +"Crea un objeto compartido :class:`threading.Lock` y retorna un proxy para él." #: ../Doc/library/multiprocessing.rst:1782 msgid "Create a shared :class:`Namespace` object and return a proxy for it." @@ -2954,10 +2953,10 @@ msgid "" "(presumably) in a different process. The shared object is said to be the " "*referent* of the proxy. Multiple proxy objects may have the same referent." msgstr "" -"Un proxy es un objeto que *se refiere* a un objeto compartido que " -"vive (presumiblemente) en un proceso diferente. Se dice que el objeto " -"compartido es el *referente* del proxy. Varios objetos " -"proxy pueden tener el mismo referente." +"Un proxy es un objeto que *se refiere* a un objeto compartido que vive " +"(presumiblemente) en un proceso diferente. Se dice que el objeto compartido " +"es el *referente* del proxy. Varios objetos proxy pueden tener el mismo " +"referente." #: ../Doc/library/multiprocessing.rst:1941 msgid "" @@ -3229,10 +3228,10 @@ msgid "" "pool as CPython does not assure that the finalizer of the pool will be " "called (see :meth:`object.__del__` for more information)." msgstr "" -"Tenga en cuenta que **no es correcto** confiar en el " -"recolector de basura para destruir el grupo ya que *CPython* no asegura que " -"se llamará al finalizador del grupo (consulte :meth:`object.__del__` para " -"obtener más información)." +"Tenga en cuenta que **no es correcto** confiar en el recolector de basura " +"para destruir el grupo ya que *CPython* no asegura que se llamará al " +"finalizador del grupo (consulte :meth:`object.__del__` para obtener más " +"información)." #: ../Doc/library/multiprocessing.rst:2141 msgid "*maxtasksperchild*" @@ -3769,8 +3768,8 @@ msgstr "" "número entero que se pueda esperar (de acuerdo con la definición utilizada " "por la documentación de la función *Win32* ``WaitForMultipleObjects()``) o " "puede ser un objeto con un :meth:`fileno` Método que retorna un manejador de " -"tubo o manejador de tubería. (Tenga en cuenta que las manijas de las tuberías y " -"las manijas de los zócalos son **no** manijas aptas)" +"tubo o manejador de tubería. (Tenga en cuenta que las manijas de las " +"tuberías y las manijas de los zócalos son **no** manijas aptas)" #: ../Doc/library/multiprocessing.rst:2473 msgid "**Examples**" @@ -4109,9 +4108,8 @@ msgid "" msgstr "" "El uso del método :meth:`Process.terminate ` para detener un proceso puede causar que los recursos " -"compartidos (como candados, semáforos, tuberías y colas" -") que el proceso utiliza actualmente se rompan o no disponible para " -"otros procesos." +"compartidos (como candados, semáforos, tuberías y colas) que el proceso " +"utiliza actualmente se rompan o no disponible para otros procesos." #: ../Doc/library/multiprocessing.rst:2714 msgid "" From 96cabe97d65213b9ccb01ed35c9b4574e90e5bcf Mon Sep 17 00:00:00 2001 From: Maria Jose Molina Contreras <32220621+mjmolina@users.noreply.github.com> Date: Sat, 4 Jul 2020 21:41:11 +0200 Subject: [PATCH 5/7] Apply suggestions from code review MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Héctor Canto --- library/multiprocessing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/multiprocessing.po b/library/multiprocessing.po index 246e03ec53..a78c41bd2a 100644 --- a/library/multiprocessing.po +++ b/library/multiprocessing.po @@ -24,7 +24,7 @@ msgstr "" #: ../Doc/library/multiprocessing.rst:2 msgid ":mod:`multiprocessing` --- Process-based parallelism" -msgstr ":mod:`multiprocessing` --- Proceso basado en paralelismo" +msgstr ":mod:`multiprocessing` --- Paralelismo basado en procesos" #: ../Doc/library/multiprocessing.rst:7 msgid "**Source code:** :source:`Lib/multiprocessing/`" From c9aab3e6d5ad08a782a39a74f1d921a5275accef Mon Sep 17 00:00:00 2001 From: Maria Jose Molina Contreras <32220621+mjmolina@users.noreply.github.com> Date: Sat, 4 Jul 2020 22:02:41 +0200 Subject: [PATCH 6/7] Apply suggestions from code review MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Cristián Maureira-Fredes --- dict | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/dict b/dict index 537db531ba..a5f507eca0 100644 --- a/dict +++ b/dict @@ -742,4 +742,6 @@ random gaussiana Pareto Weibull -Reproducibilidad \ No newline at end of file +Reproducibilidad +offset +setuptools From 473b36085fcc170c26dc0d15f1b8425344c91b13 Mon Sep 17 00:00:00 2001 From: Maria Jose Molina Contreras <32220621+mjmolina@users.noreply.github.com> Date: Mon, 13 Jul 2020 14:21:16 +0200 Subject: [PATCH 7/7] Apply suggestions from code review MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Cristián Maureira-Fredes --- library/multiprocessing.po | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/library/multiprocessing.po b/library/multiprocessing.po index a78c41bd2a..df773980b7 100644 --- a/library/multiprocessing.po +++ b/library/multiprocessing.po @@ -296,8 +296,8 @@ msgid "" "**PyInstaller** and **cx_Freeze**) on Unix. The ``'fork'`` start method does " "work." msgstr "" -"Los métodos de inicio ``'spawn'`` y ``'forkserver'`` actualmente no se " -"pueden usar con ejecutables \"congelados\" (*frozen*)(es decir, binarios " +"Los métodos de inicio ``'spawn'`` y ``'forkserver'`` actualmente no pueden " +"ser usados con ejecutables \"congelados\" (*frozen*)(es decir, binarios " "producidos por paquetes como **PyInstaller** y **cx_Freeze**) en Unix. El " "método de inicio ``'fork'`` funciona."