asyncio-sync.po

# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Maintained by the python-doc-es workteam.
# docs-es@python.org /
# https://mail.python.org/mailman3/lists/docs-es.python.org/
# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to
# get the list of volunteers
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-10-25 19:47+0200\n"
"PO-Revision-Date: 2023-02-18 23:53+0100\n"
"Last-Translator: Rodrigo Tobar <rtobarc@gmail.com>\n"
"Language-Team: python-doc-es\n"
"Language: es\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"Generated-By: Babel 2.10.3\n"
"X-Generator: Poedit 3.2.2\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:31
msgid ":class:`Barrier`"
msgstr ":class:`Barrier`"

#: ../Doc/library/asyncio-sync.rst:38
msgid "Lock"
msgstr "Lock"

#: ../Doc/library/asyncio-sync.rst:42
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:44
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:47
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:56 ../Doc/library/asyncio-sync.rst:199
#: ../Doc/library/asyncio-sync.rst:298
msgid "which is equivalent to::"
msgstr "lo que es equivalente a::"

#: ../Doc/library/asyncio-sync.rst:67 ../Doc/library/asyncio-sync.rst:112
#: ../Doc/library/asyncio-sync.rst:187 ../Doc/library/asyncio-sync.rst:286
#: ../Doc/library/asyncio-sync.rst:341
msgid "Removed the *loop* parameter."
msgstr "Eliminado el parámetro *loop*."

#: ../Doc/library/asyncio-sync.rst:72
msgid "Acquire the lock."
msgstr "Adquiere el cierre."

#: ../Doc/library/asyncio-sync.rst:74
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:77
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:81
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:86
msgid "Release the lock."
msgstr "Libera el cierre."

#: ../Doc/library/asyncio-sync.rst:88
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:90
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:94
msgid "Return ``True`` if the lock is *locked*."
msgstr "Retorna ``True`` si el cierre está *cerrado*."

#: ../Doc/library/asyncio-sync.rst:98
msgid "Event"
msgstr "Event"

#: ../Doc/library/asyncio-sync.rst:102
msgid "An event object.  Not thread-safe."
msgstr "Un objeto de eventos. No es seguro en hilos."

#: ../Doc/library/asyncio-sync.rst:104
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:107
msgid ""
"An Event object manages an internal flag that can be set to *true* with the :"
"meth:`~Event.set` method and reset to *false* with the :meth:`clear` "
"method.  The :meth:`~Event.wait` method blocks until the flag is set to "
"*true*.  The flag is set to *false* initially."
msgstr ""
"Un objeto Event administra una bandera interna que se puede establecer en "
"*true* con el método :meth:`~Event.set` y se restablece en *false* con el "
"método :meth:`clear`. El método :meth:`~Event.wait` se bloquea hasta que la "
"bandera se establece en *true*. El flag se establece en *false* inicialmente."

#: ../Doc/library/asyncio-sync.rst:117 ../Doc/library/asyncio-sync.rst:365
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:`~Event.set`."
msgstr ""
"Si el evento está configurado, retorna ``True`` inmediatamente. De lo "
"contrario, bloquea hasta que otra tarea llame a :meth:`~Event.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:`~Event.wait` will now block until the :meth:`~Event."
"set` method is called again."
msgstr ""
"Las tareas que esperan en :meth:`~Event.wait` ahora se bloquearán hasta que "
"se vuelva a llamar al método :meth:`~Event.set`."

#: ../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:190
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:212
msgid "Acquire the underlying lock."
msgstr "Adquiere el cierre (lock) subyacente."

#: ../Doc/library/asyncio-sync.rst:214
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:219
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:222 ../Doc/library/asyncio-sync.rst:237
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:228
msgid "Return ``True`` if the underlying lock is acquired."
msgstr "Retorna ``True`` si el cierre subyacente está adquirido."

#: ../Doc/library/asyncio-sync.rst:232
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:234
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:243
msgid "Release the underlying lock."
msgstr "Libera el cierre subyacente."

#: ../Doc/library/asyncio-sync.rst:245
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:250
msgid "Wait until notified."
msgstr "Espera hasta que se le notifique."

#: ../Doc/library/asyncio-sync.rst:252
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:255
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:262
msgid "Wait until a predicate becomes *true*."
msgstr "Espera hasta que un predicado se vuelva *verdadero*."

#: ../Doc/library/asyncio-sync.rst:264
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:270
msgid "Semaphore"
msgstr "Semaphore"

#: ../Doc/library/asyncio-sync.rst:274
msgid "A Semaphore object.  Not thread-safe."
msgstr "Un objeto Semaphore. No es seguro en hilos."

#: ../Doc/library/asyncio-sync.rst:276
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:282
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:289
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:311
msgid "Acquire a semaphore."
msgstr "Adquiere un semáforo."

#: ../Doc/library/asyncio-sync.rst:313
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:319
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:323
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:326
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:331
msgid "BoundedSemaphore"
msgstr "BoundedSemaphore"

#: ../Doc/library/asyncio-sync.rst:335
msgid "A bounded semaphore object.  Not thread-safe."
msgstr "Un objeto semáforo delimitado. No es seguro en hilos."

#: ../Doc/library/asyncio-sync.rst:337
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:346
msgid "Barrier"
msgstr "Barrera"

#: ../Doc/library/asyncio-sync.rst:350
msgid "A barrier object.  Not thread-safe."
msgstr "Un objeto barrera. No es seguro en hilos."

#: ../Doc/library/asyncio-sync.rst:352
msgid ""
"A barrier is a simple synchronization primitive that allows to block until "
"*parties* number of tasks are waiting on it. Tasks can wait on the :meth:"
"`~Barrier.wait` method and would be blocked until the specified number of "
"tasks end up waiting on :meth:`~Barrier.wait`. At that point all of the "
"waiting tasks would unblock simultaneously."
msgstr ""
"Una barrera es una primitiva de sincronización simple que permite bloquear "
"hasta que un número *parties* de tareas estén esperando en ella. Las tareas "
"pueden esperar en el método :meth:`~Barrier.wait` y se bloquearán hasta que "
"el número especificado de tareas termine esperando en :meth:`~Barrier.wait`. "
"En ese momento, todas las tareas en espera se desbloquearán simultáneamente."

#: ../Doc/library/asyncio-sync.rst:358
msgid ""
":keyword:`async with` can be used as an alternative to awaiting on :meth:"
"`~Barrier.wait`."
msgstr ""
":keyword:`async with` puede utilizarse como alternativa a esperar en :meth:"
"`~Barrier.wait`."

#: ../Doc/library/asyncio-sync.rst:361
msgid "The barrier can be reused any number of times."
msgstr "La barrera puede reutilizarse tantas veces como se desee."

#: ../Doc/library/asyncio-sync.rst:388
msgid "Result of this example is::"
msgstr "El resultado de este ejemplo es::"

#: ../Doc/library/asyncio-sync.rst:399
msgid ""
"Pass the barrier. When all the tasks party to the barrier have called this "
"function, they are all unblocked simultaneously."
msgstr ""
"Pasa la barrera. Cuando todas las tareas que forman parte de la barrera han "
"llamado a esta función, todas se desbloquean simultáneamente."

#: ../Doc/library/asyncio-sync.rst:402
msgid ""
"When a waiting or blocked task in the barrier is cancelled, this task exits "
"the barrier which stays in the same state. If the state of the barrier is "
"\"filling\", the number of waiting task decreases by 1."
msgstr ""
"Cuando se cancela una tarea en espera o bloqueada en la barrera, esta tarea "
"sale de la barrera que permanece en el mismo estado. Si el estado de la "
"barrera es \"filling\", el número de tareas en espera disminuye en 1."

#: ../Doc/library/asyncio-sync.rst:407
msgid ""
"The return value is an integer in the range of 0 to ``parties-1``, different "
"for each task. This can be used to select a task to do some special "
"housekeeping, e.g.::"
msgstr ""
"El valor de retorno es un entero en el rango de 0 a ``parties-1``, diferente "
"para cada tarea. Esto se puede utilizar para seleccionar una tarea para "
"hacer algún mantenimiento especial, por ejemplo::"

#: ../Doc/library/asyncio-sync.rst:417
msgid ""
"This method may raise a :class:`BrokenBarrierError` exception if the barrier "
"is broken or reset while a task is waiting. It could raise a :exc:"
"`CancelledError` if a task is cancelled."
msgstr ""
"Este método puede lanzar una excepción :class:`BrokenBarrierError` si la "
"barrera se rompe o se restablece mientras una tarea está en espera. Podría "
"lanzar una excepción :exc:`CancelledError` si se cancela una tarea."

#: ../Doc/library/asyncio-sync.rst:423
msgid ""
"Return the barrier to the default, empty state.  Any tasks waiting on it "
"will receive the :class:`BrokenBarrierError` exception."
msgstr ""
"Devuelve la barrera al estado vacío por defecto.  Cualquier tarea que espere "
"en ella recibirá la excepción :class:`BrokenBarrierError`."

#: ../Doc/library/asyncio-sync.rst:426
msgid ""
"If a barrier is broken it may be better to just leave it and create a new "
"one."
msgstr "Si se rompe una barrera, puede ser mejor dejarla y crear una nueva."

#: ../Doc/library/asyncio-sync.rst:430
msgid ""
"Put the barrier into a broken state.  This causes any active or future calls "
"to :meth:`wait` to fail with the :class:`BrokenBarrierError`. Use this for "
"example if one of the tasks needs to abort, to avoid infinite waiting tasks."
msgstr ""
"Pone la barrera en estado roto.  Esto hace que cualquier llamada activa o "
"futura a :meth:`wait` falle con el :class:`BrokenBarrierError`. Use esto por "
"ejemplo si una de las tareas necesita abortar, para evitar tareas en espera "
"infinita."

#: ../Doc/library/asyncio-sync.rst:437
msgid "The number of tasks required to pass the barrier."
msgstr "El número de tareas necesarias para pasar la barrera."

#: ../Doc/library/asyncio-sync.rst:441
msgid "The number of tasks currently waiting in the barrier while filling."
msgstr ""
"El número de tareas que esperan actualmente en la barrera mientras se llena."

#: ../Doc/library/asyncio-sync.rst:445
msgid "A boolean that is ``True`` if the barrier is in the broken state."
msgstr "Un booleano que es ``True`` si la barrera está en estado roto."

#: ../Doc/library/asyncio-sync.rst:450
msgid ""
"This exception, a subclass of :exc:`RuntimeError`, is raised when the :class:"
"`Barrier` object is reset or broken."
msgstr ""
"Esta excepción, una subclase de :exc:`RuntimeError`, se lanza cuando el "
"objeto :class:`Barrier` se reinicia o se rompe."

#: ../Doc/library/asyncio-sync.rst:458
msgid ""
"Acquiring a lock using ``await lock`` or ``yield from lock`` and/or :keyword:"
"`with` statement (``with await lock``, ``with (yield from lock)``) was "
"removed.  Use ``async with lock`` instead."
msgstr ""
"Adquirir un bloqueo usando ``await lock`` o ``yield from lock`` o una "
"declaración :keyword:`with` (``with await lock``, ``with (yield from "
"lock)``) se eliminó . En su lugar, use ``async with lock``."