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

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

# Maintained by the python-doc-es workteam.

# docs-es@python.org /

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

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

# get the list of volunteers

#

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2020-05-05 12:54+0200\n"

"PO-Revision-Date: 2020-10-05 19:15+0200\n"

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

"MIME-Version: 1.0\n"

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

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

"Generated-By: Babel 2.8.0\n"

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

"Last-Translator: Francisco Jesús Sevilla García <fjsevilla.dev@gmail.com>\n"

"Language: es\n"

"X-Generator: Poedit 2.4.1\n"

#: ../Doc/library/asyncio-sync.rst:7

msgid "Synchronization Primitives"

msgstr "Primitivas de sincronización"

#: ../Doc/library/asyncio-sync.rst:9

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

msgstr "**Código fuente:** :source:`Lib/asyncio/locks.py`"

#: ../Doc/library/asyncio-sync.rst:13

msgid ""

"asyncio synchronization primitives are designed to be similar to those of "

"the :mod:`threading` module with two important caveats:"

msgstr ""

"Las primitivas de sincronización de asyncio están diseñadas para ser "

"similares a las del módulo :mod:`threading`, con dos importantes "

"advertencias:"

#: ../Doc/library/asyncio-sync.rst:16

msgid ""

"asyncio primitives are not thread-safe, therefore they should not be used "

"for OS thread synchronization (use :mod:`threading` for that);"

msgstr ""

"las primitivas de asyncio no son seguras en hilos, por lo tanto, no deben "

"ser usadas para la sincronización de hilos del sistema operativo (usa :mod:"

"`threading` para esto);"

#: ../Doc/library/asyncio-sync.rst:20

msgid ""

"methods of these synchronization primitives do not accept the *timeout* "

"argument; use the :func:`asyncio.wait_for` function to perform operations "

"with timeouts."

msgstr ""

"los métodos de estas primitivas de sincronización no aceptan el argumento "

"*timeout*. Usa la función :func:`asyncio.wait_for` para realizar operaciones "

"que involucren tiempos de espera."

#: ../Doc/library/asyncio-sync.rst:24

msgid "asyncio has the following basic synchronization primitives:"

msgstr "asyncio tiene las siguientes primitivas de sincronización básicas:"

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

msgid ":class:`Lock`"

msgstr ":class:`Lock`"

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

msgid ":class:`Event`"

msgstr ":class:`Event`"

#: ../Doc/library/asyncio-sync.rst:28

msgid ":class:`Condition`"

msgstr ":class:`Condition`"

#: ../Doc/library/asyncio-sync.rst:29

msgid ":class:`Semaphore`"

msgstr ":class:`Semaphore`"

#: ../Doc/library/asyncio-sync.rst:30

msgid ":class:`BoundedSemaphore`"

msgstr ":class:`BoundedSemaphore`"

#: ../Doc/library/asyncio-sync.rst:37

msgid "Lock"

msgstr "Lock"

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

msgid "Implements a mutex lock for asyncio tasks. Not thread-safe."

msgstr ""

"Implementa un cierre de exclusión mutua para tareas asyncio. No es seguro en "

"hilos."

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

msgid ""

"An asyncio lock can be used to guarantee exclusive access to a shared "

"resource."

msgstr ""

"Un cierre asyncio puede usarse para garantizar el acceso en exclusiva a un "

"recurso compartido."

#: ../Doc/library/asyncio-sync.rst:46

msgid "The preferred way to use a Lock is an :keyword:`async with` statement::"

msgstr ""

"La forma preferida de usar un Lock es mediante una declaración :keyword:"

"`async with`::"

#: ../Doc/library/asyncio-sync.rst:55 ../Doc/library/asyncio-sync.rst:200

#: ../Doc/library/asyncio-sync.rst:300

msgid "which is equivalent to::"

msgstr "lo que es equivalente a::"

#: ../Doc/library/asyncio-sync.rst:68 ../Doc/library/asyncio-sync.rst:114

#: ../Doc/library/asyncio-sync.rst:190 ../Doc/library/asyncio-sync.rst:290

#: ../Doc/library/asyncio-sync.rst:345

msgid "The *loop* parameter."

msgstr "El parámetro *loop*."

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

msgid "Acquire the lock."

msgstr "Adquiere el cierre."

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

msgid ""

"This method waits until the lock is *unlocked*, sets it to *locked* and "

"returns ``True``."

msgstr ""

"Este método espera hasta que el cierre está *abierto*, lo establece como "

"*cerrado* y retorna ``True``."

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

msgid ""

"When more than one coroutine is blocked in :meth:`acquire` waiting for the "

"lock to be unlocked, only one coroutine eventually proceeds."

msgstr ""

"Cuando más de una corrutina está bloqueada en :meth:`acquire`, esperando a "

"que el cierre se abra, solo una de las corrutinas proseguirá finalmente."

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

msgid ""

"Acquiring a lock is *fair*: the coroutine that proceeds will be the first "

"coroutine that started waiting on the lock."

msgstr ""

"Adquirir un cierre es *justo*: la corrutina que prosigue será la primera "

"corrutina que comenzó a esperarlo."

#: ../Doc/library/asyncio-sync.rst:85

msgid "Release the lock."

msgstr "Libera el cierre."

#: ../Doc/library/asyncio-sync.rst:87

msgid "When the lock is *locked*, reset it to *unlocked* and return."

msgstr ""

"Cuando el cierre está *cerrado*, lo restablece al estado *abierto* y retorna."

#: ../Doc/library/asyncio-sync.rst:89

msgid "If the lock is *unlocked*, a :exc:`RuntimeError` is raised."

msgstr ""

"Si el cierre está *abierto*, se lanza una excepción :exc:`RuntimeError`."

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

msgid "Return ``True`` if the lock is *locked*."

msgstr "Retorna ``True`` si el cierre está *cerrado*."

#: ../Doc/library/asyncio-sync.rst:97

msgid "Event"

msgstr "Event"

#: ../Doc/library/asyncio-sync.rst:101

msgid "An event object. Not thread-safe."

msgstr "Un objeto de eventos. No es seguro en hilos."

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

msgid ""

"An asyncio event can be used to notify multiple asyncio tasks that some "

"event has happened."

msgstr ""

"Un evento asyncio puede usarse para notificar a múltiples tareas asyncio que "

"ha ocurrido algún evento."

#: ../Doc/library/asyncio-sync.rst:106

msgid ""

"An Event object manages an internal flag that can be set to *true* with the :"

"meth:`set` method and reset to *false* with the :meth:`clear` method. The :"

"meth:`wait` method blocks until the flag is set to *true*. The flag is set "

"to *false* initially."

msgstr ""

"Un objeto Event gestiona un indicador interno que puede ser establecido en "

"*verdadero* mediante el método :meth:`set` y restaurado a *falso* con el "

"método :meth:`clear`. El método :meth:`wait` bloquea hasta que el indicador "

"es establecido en *verdadero*. De inicio, el indicador se establece en "

"*falso*."

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

msgid "Example::"

msgstr "Ejemplo:"

#: ../Doc/library/asyncio-sync.rst:142

msgid "Wait until the event is set."

msgstr "Espera hasta que se establezca el evento."

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

msgid ""

"If the event is set, return ``True`` immediately. Otherwise block until "

"another task calls :meth:`set`."

msgstr ""

"Si el evento está establecido, retorna ``True`` inmediatamente. En caso "

"contrario, bloquea hasta que alguna otra tarea invoca al método :meth:`set`."

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

msgid "Set the event."

msgstr "Establece el evento."

#: ../Doc/library/asyncio-sync.rst:151

msgid "All tasks waiting for event to be set will be immediately awakened."

msgstr ""

"Todas las tareas esperando a que el evento se establezca serán activadas "

"inmediatamente."

#: ../Doc/library/asyncio-sync.rst:156

msgid "Clear (unset) the event."

msgstr "Borra (restablece) el evento."

#: ../Doc/library/asyncio-sync.rst:158

msgid ""

"Tasks awaiting on :meth:`wait` will now block until the :meth:`set` method "

"is called again."

msgstr ""

"Las tareas pendientes en :meth:`wait` ahora se bloquearán hasta que se "

"vuelva a llamar al método :meth:`set` de nuevo."

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

msgid "Return ``True`` if the event is set."

msgstr "Retorna ``True`` si el evento está establecido."

#: ../Doc/library/asyncio-sync.rst:167

msgid "Condition"

msgstr "Condition"

#: ../Doc/library/asyncio-sync.rst:171

msgid "A Condition object. Not thread-safe."

msgstr "Un objeto Condition. No seguro en hilos."

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

msgid ""

"An asyncio condition primitive can be used by a task to wait for some event "

"to happen and then get exclusive access to a shared resource."

msgstr ""

"Una tarea puede usar una condición primitiva de asyncio para esperar a que "

"suceda algún evento y luego obtener acceso exclusivo a un recurso compartido."

#: ../Doc/library/asyncio-sync.rst:177

msgid ""

"In essence, a Condition object combines the functionality of an :class:"

"`Event` and a :class:`Lock`. It is possible to have multiple Condition "

"objects share one Lock, which allows coordinating exclusive access to a "

"shared resource between different tasks interested in particular states of "

"that shared resource."

msgstr ""

"En esencia, un objeto Condition combina la funcionalidad de un objeto :class:"

"`Event` y un objeto :class:`Lock`. Es posible tener múltiples objetos "

"Condition que compartan un mismo Lock, lo que permite coordinar el acceso "

"exclusivo a un recurso compartido entre diferentes tareas interesadas en "

"estados particulares de ese recurso compartido."

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

msgid ""

"The optional *lock* argument must be a :class:`Lock` object or ``None``. In "

"the latter case a new Lock object is created automatically."

msgstr ""

"El argumento opcional *lock* debe ser un objeto :class:`Lock` o ``None``. En "

"este último caso, se crea automáticamente un nuevo objeto Lock."

#: ../Doc/library/asyncio-sync.rst:191

msgid ""

"The preferred way to use a Condition is an :keyword:`async with` statement::"

msgstr ""

"La forma preferida de usar una condición es mediante una declaración :"

"keyword:`async with`::"

#: ../Doc/library/asyncio-sync.rst:213

msgid "Acquire the underlying lock."

msgstr "Adquiere el cierre (lock) subyacente."

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

msgid ""

"This method waits until the underlying lock is *unlocked*, sets it to "

"*locked* and returns ``True``."

msgstr ""

"Este método espera hasta que el cierre subyacente esté *abierto*, lo "

"establece en *cerrado* y retorna ``True``."

#: ../Doc/library/asyncio-sync.rst:220

msgid ""

"Wake up at most *n* tasks (1 by default) waiting on this condition. The "

"method is no-op if no tasks are waiting."

msgstr ""

"Despierta como máximo *n* tareas (1 por defecto) que estén esperando a esta "

"condición. El método no es operativo si no hay tareas esperando."

#: ../Doc/library/asyncio-sync.rst:223 ../Doc/library/asyncio-sync.rst:238

msgid ""

"The lock must be acquired before this method is called and released shortly "

"after. If called with an *unlocked* lock a :exc:`RuntimeError` error is "

"raised."

msgstr ""

"El cierre debe adquirirse antes de llamar a este método y liberarse poco "

"después. Si se llama con un cierre *abierto*, se lanza una excepción :exc:"

"`RuntimeError`."

#: ../Doc/library/asyncio-sync.rst:229

msgid "Return ``True`` if the underlying lock is acquired."

msgstr "Retorna ``True`` si el cierre subyacente está adquirido."

#: ../Doc/library/asyncio-sync.rst:233

msgid "Wake up all tasks waiting on this condition."

msgstr "Despierta todas las tareas que esperan a esta condición."

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

msgid "This method acts like :meth:`notify`, but wakes up all waiting tasks."

msgstr ""

"Este método actúa como :meth:`notify`, pero despierta todas las tareas en "

"espera."

#: ../Doc/library/asyncio-sync.rst:244

msgid "Release the underlying lock."

msgstr "Libera el cierre subyacente."

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

msgid "When invoked on an unlocked lock, a :exc:`RuntimeError` is raised."

msgstr ""

"Cuando se invoca en un cierre abierto, se lanza una excepción :exc:"

"`RuntimeError`."

#: ../Doc/library/asyncio-sync.rst:251

msgid "Wait until notified."

msgstr "Espera hasta que se le notifique."

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

msgid ""

"If the calling task has not acquired the lock when this method is called, a :"

"exc:`RuntimeError` is raised."

msgstr ""

"Si la tarea que llama no ha adquirido el cierre cuando se llama a este "

"método, se lanza una excepción :exc:`RuntimeError`."

#: ../Doc/library/asyncio-sync.rst:256

msgid ""

"This method releases the underlying lock, and then blocks until it is "

"awakened by a :meth:`notify` or :meth:`notify_all` call. Once awakened, the "

"Condition re-acquires its lock and this method returns ``True``."

msgstr ""

"Este método libera el cierre subyacente y luego se bloquea hasta que lo "

"despierte una llamada :meth:`notify` o :meth:`notify_all`. Una vez "

"despertado, la condición vuelve a adquirir su cierre y este método "

"retorna``True``."

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

msgid "Wait until a predicate becomes *true*."

msgstr "Espera hasta que un predicado se vuelva *verdadero*."

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

msgid ""

"The predicate must be a callable which result will be interpreted as a "

"boolean value. The final value is the return value."

msgstr ""

"El predicado debe ser un objeto invocable cuyo resultado se interpretará "

"como un valor booleano. El valor final es el valor de retorno."

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

msgid "Semaphore"

msgstr "Semaphore"

#: ../Doc/library/asyncio-sync.rst:275

msgid "A Semaphore object. Not thread-safe."

msgstr "Un objeto Semaphore. No es seguro en hilos."

#: ../Doc/library/asyncio-sync.rst:277

msgid ""

"A semaphore manages an internal counter which is decremented by each :meth:"

"`acquire` call and incremented by each :meth:`release` call. The counter can "

"never go below zero; when :meth:`acquire` finds that it is zero, it blocks, "

"waiting until some task calls :meth:`release`."

msgstr ""

"Un semáforo gestiona un contador interno que se reduce en cada llamada al "

"método :meth:`acquire` y se incrementa en cada llamada al método :meth:"

"`release`. El contador nunca puede bajar de cero, cuando :meth:`acquire` "

"encuentra que es cero, se bloquea, esperando hasta que alguna tarea llame a :"

"meth:`release`."

#: ../Doc/library/asyncio-sync.rst:283

msgid ""

"The optional *value* argument gives the initial value for the internal "

"counter (``1`` by default). If the given value is less than ``0`` a :exc:"

"`ValueError` is raised."

msgstr ""

"El argumento opcional *value* proporciona el valor inicial para el contador "

"interno (``1`` por defecto). Si el valor dado es menor que ``0`` se lanza "

"una excepción :exc:`ValueError`."

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

msgid ""

"The preferred way to use a Semaphore is an :keyword:`async with` statement::"

msgstr ""

"La forma preferida de utilizar un semáforo es mediante una declaración :"

"keyword:`async with`::"

#: ../Doc/library/asyncio-sync.rst:313

msgid "Acquire a semaphore."

msgstr "Adquiere un semáforo."

#: ../Doc/library/asyncio-sync.rst:315

msgid ""

"If the internal counter is greater than zero, decrement it by one and return "

"``True`` immediately. If it is zero, wait until a :meth:`release` is called "

"and return ``True``."

msgstr ""

"Si el contador interno es mayor que cero, lo reduce en uno y retorna "

"``True`` inmediatamente. Si es cero, espera hasta que se llame al método :"

"meth:`release` y retorna ``True``."

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

msgid "Returns ``True`` if semaphore can not be acquired immediately."

msgstr "Retorna ``True`` si el semáforo no se puede adquirir de inmediato."

#: ../Doc/library/asyncio-sync.rst:325

msgid ""

"Release a semaphore, incrementing the internal counter by one. Can wake up a "

"task waiting to acquire the semaphore."

msgstr ""

"Libera un semáforo, incrementando el contador interno en uno. Puede "

"despertar una tarea que esté a la espera para adquirir el semáforo."

#: ../Doc/library/asyncio-sync.rst:328

msgid ""

"Unlike :class:`BoundedSemaphore`, :class:`Semaphore` allows making more "

"``release()`` calls than ``acquire()`` calls."

msgstr ""

"A diferencia de :class:`BoundedSemaphore`, :class:`Semaphore` permite hacer "

"más llamadas ``release()`` que llamadas ``acquire()``."

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

msgid "BoundedSemaphore"

msgstr "BoundedSemaphore"

#: ../Doc/library/asyncio-sync.rst:337

msgid "A bounded semaphore object. Not thread-safe."

msgstr "Un objeto semáforo delimitado. No es seguro en hilos."

#: ../Doc/library/asyncio-sync.rst:339

msgid ""

"Bounded Semaphore is a version of :class:`Semaphore` that raises a :exc:"

"`ValueError` in :meth:`~Semaphore.release` if it increases the internal "

"counter above the initial *value*."

msgstr ""

"BoundedSemaphore es una versión de la clase :class:`Semaphore` que lanza una "

"excepción :exc:`ValueError` en :meth:`~Semaphore.release` si aumenta el "

"contador interno por encima del *valor* inicial."

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

msgid ""

"Acquiring a lock using ``await lock`` or ``yield from lock`` and/or :keyword:"

"`with` statement (``with await lock``, ``with (yield from lock)``) is "

"deprecated. Use ``async with lock`` instead."

msgstr ""

"Adquirir un bloqueo usando ``await lock`` o ``yield from lock`` y/o la "

"declaración :keyword:`with` (``with await lock``, ``with (yield from "

"lock)``) está obsoleto. En su lugar, se debe usar ``async with lock``."