From b40295fa54e3fd94c5e71341db4c1187843d656a Mon Sep 17 00:00:00 2001 From: Cristian Maureira-Fredes Date: Wed, 24 Jun 2020 22:32:11 +0200 Subject: [PATCH] Traducido library/contextlib Closes #420 --- dict | 9 ++ library/contextlib.po | 362 ++++++++++++++++++++++++++++++++++++++---- 2 files changed, 341 insertions(+), 30 deletions(-) diff --git a/dict b/dict index 695c08f8b6..b9d17c6c27 100644 --- a/dict +++ b/dict @@ -11,6 +11,7 @@ suprimidor escribibles heredable reintenta +reentrada malformados API ASCII @@ -174,6 +175,7 @@ Zip ab aleatoriamente aleatorizar +anidarlos append aproximarla argv @@ -496,6 +498,9 @@ redimensionable redimensionables redireccionamiento redondeándolo +reentrante +reentrantes +reentrantada ref refactorización refactorizados @@ -517,6 +522,8 @@ reordenar repr request reubicar +reutilizable +reutilizables root run s @@ -542,6 +549,7 @@ singleton singletons sintácticamente situ +síncrono sobreescriban sobreescribe sobreescriben @@ -633,6 +641,7 @@ permutación Gaussianas log von +with semiabierto Twister subprocesos diff --git a/library/contextlib.po b/library/contextlib.po index cee3d19be9..506434438b 100644 --- a/library/contextlib.po +++ b/library/contextlib.po @@ -1,30 +1,34 @@ # 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. +# 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/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: 2019-05-06 11:59-0400\n" -"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" -"Last-Translator: FULL NAME \n" +"PO-Revision-Date: 2020-06-24 22:27+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" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" +"Last-Translator: Cristián Maureira-Fredes \n" +"Language: es\n" +"X-Generator: Poedit 2.3\n" #: ../Doc/library/contextlib.rst:2 msgid "" ":mod:`!contextlib` --- Utilities for :keyword:`!with`\\ -statement contexts" msgstr "" +":mod:`!contextlib` --- Utilidades para declaraciones de contexto :keyword:`!" +"with`" #: ../Doc/library/contextlib.rst:7 msgid "**Source code:** :source:`Lib/contextlib.py`" -msgstr "" +msgstr "**Código fuente:** :source:`Lib/contextlib.py`" #: ../Doc/library/contextlib.rst:11 msgid "" @@ -32,14 +36,17 @@ msgid "" "`with` statement. For more information see also :ref:`typecontextmanager` " "and :ref:`context-managers`." msgstr "" +"Este módulo proporciona utilidades para tareas comunes que involucran la " +"declaración :keyword:`with`. Para obtener más información, consulte también :" +"ref:`typecontextmanager` y :ref:`context-managers`." #: ../Doc/library/contextlib.rst:17 msgid "Utilities" -msgstr "" +msgstr "Utilidades" #: ../Doc/library/contextlib.rst:19 msgid "Functions and classes provided:" -msgstr "" +msgstr "Funciones y clases proporcionadas:" #: ../Doc/library/contextlib.rst:23 msgid "" @@ -49,6 +56,12 @@ msgid "" "__exit__` is an abstract method which by default returns ``None``. See also " "the definition of :ref:`typecontextmanager`." msgstr "" +"Una :term:`clase base abstracta ` para clases que " +"implementan :meth:`object.__aenter__` y :meth:`object.__exit__`. Se " +"proporciona una implementación predeterminada para :meth:`object.__enter__` " +"que devuelve ``self`` mientras que :meth:`object.__exit__` es un método " +"abstracto que por defecto devuelve ``None``. Véase también la definición de :" +"ref:`typecontextmanager`." #: ../Doc/library/contextlib.rst:34 msgid "" @@ -58,6 +71,12 @@ msgid "" "__aexit__` is an abstract method which by default returns ``None``. See also " "the definition of :ref:`async-context-managers`." msgstr "" +"Una :term:`clase base abstracta ` para clases que " +"implementan :meth:`object.__aenter__` y :meth:`object.__aexit__`. Se " +"proporciona una implementación predeterminada para :meth:`object.__aenter__` " +"que devuelve ``self`` mientras que :meth:`object.__aexit__` es un método " +"abstracto que por defecto devuelve ``None``. Véase también la definición de :" +"ref:`async-context-managers`." #: ../Doc/library/contextlib.rst:46 msgid "" @@ -65,6 +84,10 @@ msgid "" "function for :keyword:`with` statement context managers, without needing to " "create a class or separate :meth:`__enter__` and :meth:`__exit__` methods." msgstr "" +"Esta función es :term:`decorador` que se puede usar para definir una función " +"de fábrica para gestores de contexto de declaración :keyword:`with`, sin " +"necesidad de crear una clase o separar :meth:`__enter__` y :meth:`__exit__` " +"métodos." #: ../Doc/library/contextlib.rst:50 msgid "" @@ -73,12 +96,18 @@ msgid "" "and doesn't implement a ``close()`` method for use with ``contextlib." "closing``" msgstr "" +"Si bien muchos objetos admiten de forma nativa el uso con declaraciones, a " +"veces es necesario administrar un recurso que no sea un administrador de " +"contexto por sí mismo y no implemente un método ``close()`` para usar con " +"``contextlib.close``" #: ../Doc/library/contextlib.rst:54 msgid "" "An abstract example would be the following to ensure correct resource " "management::" msgstr "" +"Un ejemplo abstracto sería el siguiente para garantizar la gestión correcta " +"de los recursos::" #: ../Doc/library/contextlib.rst:73 msgid "" @@ -86,6 +115,10 @@ msgid "" "called. This iterator must yield exactly one value, which will be bound to " "the targets in the :keyword:`with` statement's :keyword:`!as` clause, if any." msgstr "" +"La función que se está decorando debe devolver un iterador :term:`generador` " +"cuando se llama. Este iterador debe producir exactamente un valor, que " +"estará vinculado a los objetivos en la :keyword:`with` declaración de la " +"cláusula :keyword:`!as`, si existe." #: ../Doc/library/contextlib.rst:77 msgid "" @@ -102,6 +135,19 @@ msgid "" "handled, and execution will resume with the statement immediately following " "the :keyword:`!with` statement." msgstr "" +"En el punto donde el generador cede, se ejecuta el bloque anidado en la " +"palabra clave :keyword:`with`. El generador se reanuda luego de salir del " +"bloque. Si se produce una excepción no controlada en el bloque, se vuelve a " +"plantear dentro del generador en el punto donde se produjo el rendimiento. " +"Por lo tanto, puede usar una declaración :keyword:`try`...\\ :keyword:" +"`except`...\\ :keyword:`finally` para atrapar el error (si lo hay), o " +"asegurarse de que se realice una limpieza. Si una excepción queda atrapada " +"simplemente para registrarla o realizar alguna acción (en lugar de " +"suprimirla por completo), el generador debe volver a generar esa excepción. " +"De lo contrario, el administrador de contexto del generador indicará a la " +"palabra clave :keyword:`!with` que se ha manejado la excepción, y la " +"ejecución se reanudará con la declaración inmediatamente siguiente a la " +"palabra clave :keyword:`!with`." #: ../Doc/library/contextlib.rst:89 msgid "" @@ -113,16 +159,25 @@ msgid "" "that context managers support multiple invocations in order to be used as " "decorators)." msgstr "" +":func:`contextmanager` usa :class:`ContextDecorator` para que los gestores " +"de contexto que crea se puedan usar como decoradores, así como en " +"declaraciones :keyword:`with`. Cuando se usa como decorador, se crea " +"implícitamente una nueva instancia de generador en cada llamada de función " +"(esto permite que los gestores de contexto \"de-un-tiro\" creados por :func:" +"`contextmanager` cumplan el requisito de que los gestores de contexto " +"admitan múltiples invocaciones para ser utilizado como decoradores)." #: ../Doc/library/contextlib.rst:96 msgid "Use of :class:`ContextDecorator`." -msgstr "" +msgstr "Uso de :class:`ContextDecorator`." #: ../Doc/library/contextlib.rst:102 msgid "" "Similar to :func:`~contextlib.contextmanager`, but creates an :ref:" "`asynchronous context manager `." msgstr "" +"Similar a :func:`~contextlib.contextmanager`, pero crea un :ref:" +"`administrador de contexto asíncrono `." #: ../Doc/library/contextlib.rst:105 msgid "" @@ -132,26 +187,35 @@ msgid "" "`__aexit__` methods. It must be applied to an :term:`asynchronous generator` " "function." msgstr "" +"Esta función es :term:`decorador` que se puede utilizar para definir una " +"función de fábrica para gestores de contexto asíncrono de declaración :" +"keyword:`async with`, sin necesidad de crear una clase o separar :meth:" +"`__aenter__` y métodos :meth:`__aexit__`. Debe aplicarse a una función :term:" +"`asynchronous generator`." #: ../Doc/library/contextlib.rst:111 msgid "A simple example::" -msgstr "" +msgstr "Un ejemplo simple::" #: ../Doc/library/contextlib.rst:132 msgid "" "Return a context manager that closes *thing* upon completion of the block. " "This is basically equivalent to::" msgstr "" +"Devuelve un gestor de contexto que cierra *thing* al completar el bloque. " +"Esto es básicamente equivalente a::" #: ../Doc/library/contextlib.rst:144 msgid "And lets you write code like this::" -msgstr "" +msgstr "Y te permite escribir código como este::" #: ../Doc/library/contextlib.rst:153 msgid "" "without needing to explicitly close ``page``. Even if an error occurs, " "``page.close()`` will be called when the :keyword:`with` block is exited." msgstr "" +"sin necesidad de cerrar explícitamente la ``page``. Incluso si se produce un " +"error, se llamará a ``page.close()`` cuando salga el bloque :keyword:`with`." #: ../Doc/library/contextlib.rst:161 msgid "" @@ -159,10 +223,13 @@ msgid "" "otherwise does nothing. It is intended to be used as a stand-in for an " "optional context manager, for example::" msgstr "" +"Devuelve un gestor de contexto que devuelve *enter_result* de ``__enter__``, " +"pero de lo contrario no hace nada. Está destinado a ser utilizado como un " +"sustituto para un administrador de contexto opcional, por ejemplo:" #: ../Doc/library/contextlib.rst:175 msgid "An example using *enter_result*::" -msgstr "" +msgstr "Un ejemplo usando *enter_result*::" #: ../Doc/library/contextlib.rst:193 msgid "" @@ -170,6 +237,10 @@ msgid "" "they occur in the body of a with statement and then resumes execution with " "the first statement following the end of the with statement." msgstr "" +"Devuelva un administrador de contexto que suprima cualquiera de las " +"excepciones especificadas si se producen en el cuerpo de una instrucción " +"*with* y luego reanuda la ejecución con la primera instrucción que sigue al " +"final de la instrucción *with*." #: ../Doc/library/contextlib.rst:197 msgid "" @@ -178,31 +249,39 @@ msgid "" "silently continuing with program execution is known to be the right thing to " "do." msgstr "" +"Al igual que con cualquier otro mecanismo que suprima completamente las " +"excepciones, este administrador de contexto debe usarse solo para cubrir " +"errores muy específicos en los que se sabe que continuar silenciosamente con " +"la ejecución del programa es lo correcto." #: ../Doc/library/contextlib.rst:202 msgid "For example::" -msgstr "" +msgstr "Por ejemplo::" #: ../Doc/library/contextlib.rst:212 msgid "This code is equivalent to::" -msgstr "" +msgstr "Este código es equivalente a::" #: ../Doc/library/contextlib.rst:224 ../Doc/library/contextlib.rst:263 #: ../Doc/library/contextlib.rst:273 msgid "This context manager is :ref:`reentrant `." -msgstr "" +msgstr "Este gestor de contexto es :ref:`reentrant `." #: ../Doc/library/contextlib.rst:231 msgid "" "Context manager for temporarily redirecting :data:`sys.stdout` to another " "file or file-like object." msgstr "" +"Administrador de contexto para redirigir temporalmente :data:`sys.stdout` a " +"otro archivo u objeto similar a un archivo." #: ../Doc/library/contextlib.rst:234 msgid "" "This tool adds flexibility to existing functions or classes whose output is " "hardwired to stdout." msgstr "" +"Esta herramienta agrega flexibilidad a las funciones o clases existentes " +"cuya salida está programada para stdout." #: ../Doc/library/contextlib.rst:237 msgid "" @@ -210,16 +289,21 @@ msgid "" "You can capture that output in a string by redirecting the output to an :" "class:`io.StringIO` object::" msgstr "" +"Por ejemplo, la salida de :func:`help` normalmente se envía a *sys.stdout*. " +"Puede capturar esa salida en una cadena redirigiendo la salida a un objeto :" +"class:`io.StringIO`::" #: ../Doc/library/contextlib.rst:246 msgid "" "To send the output of :func:`help` to a file on disk, redirect the output to " "a regular file::" msgstr "" +"Para enviar la salida de :func:`help` a un archivo en el disco, redirija la " +"salida a un archivo normal::" #: ../Doc/library/contextlib.rst:253 msgid "To send the output of :func:`help` to *sys.stderr*::" -msgstr "" +msgstr "Para enviar la salida de :func:`help` a *sys.stderr*::" #: ../Doc/library/contextlib.rst:258 msgid "" @@ -228,17 +312,26 @@ msgid "" "applications. It also has no effect on the output of subprocesses. However, " "it is still a useful approach for many utility scripts." msgstr "" +"Tenga en cuenta que el efecto secundario global en :data:`sys.stdout` " +"significa que este administrador de contexto no es adecuado para su uso en " +"el código de la biblioteca y en la mayoría de las aplicaciones con " +"subprocesos. Tampoco tiene efecto en la salida de subprocesos. Sin embargo, " +"sigue siendo un enfoque útil para muchos scripts de utilidad." #: ../Doc/library/contextlib.rst:270 msgid "" "Similar to :func:`~contextlib.redirect_stdout` but redirecting :data:`sys." "stderr` to another file or file-like object." msgstr "" +"Similar a :func:`~contextlib.redirect_stdout` pero redirigiendo :data:`sys." +"stderr` a otro archivo u objeto similar a un archivo." #: ../Doc/library/contextlib.rst:280 msgid "" "A base class that enables a context manager to also be used as a decorator." msgstr "" +"Una clase base que permite que un administrador de contexto también se use " +"como decorador." #: ../Doc/library/contextlib.rst:282 msgid "" @@ -246,37 +339,49 @@ msgid "" "``__enter__`` and ``__exit__`` as normal. ``__exit__`` retains its optional " "exception handling even when used as a decorator." msgstr "" +"Los gestores de contexto que heredan de ``ContextDecorator`` tienen que " +"implementar ``__enter__`` y ``__exit__`` de manera normal. ``__exit__`` " +"conserva su manejo opcional de excepciones incluso cuando se usa como " +"decorador." #: ../Doc/library/contextlib.rst:286 msgid "" "``ContextDecorator`` is used by :func:`contextmanager`, so you get this " "functionality automatically." msgstr "" +"``ContextDecorator`` es utilizado por :func:`contextmanager`, por lo que " +"obtiene esta funcionalidad automáticamente." #: ../Doc/library/contextlib.rst:289 msgid "Example of ``ContextDecorator``::" -msgstr "" +msgstr "Ejemplo de ``ContextDecorator``::" #: ../Doc/library/contextlib.rst:318 msgid "" "This change is just syntactic sugar for any construct of the following form::" msgstr "" +"Este cambio es solo azúcar sintáctico para cualquier construcción de la " +"siguiente forma:" #: ../Doc/library/contextlib.rst:324 msgid "``ContextDecorator`` lets you instead write::" -msgstr "" +msgstr "``ContextDecorator`` le permite escribir en su lugar::" #: ../Doc/library/contextlib.rst:330 msgid "" "It makes it clear that the ``cm`` applies to the whole function, rather than " "just a piece of it (and saving an indentation level is nice, too)." msgstr "" +"Deja en claro que el ``cm`` se aplica a toda la función, en lugar de solo " +"una parte de ella (y guardar un nivel de sangría también es bueno)." #: ../Doc/library/contextlib.rst:333 msgid "" "Existing context managers that already have a base class can be extended by " "using ``ContextDecorator`` as a mixin class::" msgstr "" +"Los gestores de contexto existentes que ya tienen una clase base pueden " +"ampliarse utilizando ``ContextDecorator`` como una clase mezcla (*mixin*)::" #: ../Doc/library/contextlib.rst:346 msgid "" @@ -285,6 +390,10 @@ msgid "" "statements. If this is not the case, then the original construct with the " "explicit :keyword:`!with` statement inside the function should be used." msgstr "" +"Como la función decorada debe poder llamarse varias veces, el gestor de " +"contexto subyacente debe admitir el uso en múltiples declaraciones :keyword:" +"`with`. Si este no es el caso, se debe utilizar la construcción original con " +"la declaración explícita :keyword:`!with` dentro de la función." #: ../Doc/library/contextlib.rst:356 msgid "" @@ -292,12 +401,18 @@ msgid "" "combine other context managers and cleanup functions, especially those that " "are optional or otherwise driven by input data." msgstr "" +"Un gestor de contexto que está diseñado para facilitar la combinación " +"programática de otros gestores de contexto y funciones de limpieza, " +"especialmente aquellas que son opcionales o que de otro modo son impulsadas " +"por los datos de entrada." #: ../Doc/library/contextlib.rst:360 msgid "" "For example, a set of files may easily be handled in a single with statement " "as follows::" msgstr "" +"Por ejemplo, un conjunto de archivos puede manejarse fácilmente en una sola " +"declaración de la siguiente manera:" #: ../Doc/library/contextlib.rst:369 msgid "" @@ -306,6 +421,11 @@ msgid "" "at the end of a :keyword:`with` statement). Note that callbacks are *not* " "invoked implicitly when the context stack instance is garbage collected." msgstr "" +"Cada instancia mantiene una pila de devoluciones de llamada registradas que " +"se llaman en orden inverso cuando la instancia se cierra (ya sea explícita o " +"implícitamente al final de una: palabra clave: `con` instrucción). Tenga en " +"cuenta que las devoluciones de llamada *no* se invocan implícitamente cuando " +"la instancia de la pila de contexto se recolecta basura." #: ../Doc/library/contextlib.rst:374 msgid "" @@ -313,6 +433,9 @@ msgid "" "resources in their ``__init__`` method (such as file objects) can be handled " "correctly." msgstr "" +"Este modelo de pila se utiliza para que los administradores de contexto que " +"adquieren sus recursos en su método ``__init__`` (como los objetos de " +"archivo) se puedan manejar correctamente." #: ../Doc/library/contextlib.rst:378 msgid "" @@ -323,6 +446,13 @@ msgid "" "exception, then outer callbacks will be passed arguments based on that " "updated state." msgstr "" +"Dado que las devoluciones de llamada registradas se invocan en el orden " +"inverso del registro, esto termina comportándose como si se hubieran " +"utilizado múltiples instrucciones anidadas :keyword:`with` con el conjunto " +"registrado de devoluciones de llamada. Esto incluso se extiende al manejo de " +"excepciones: si una devolución de llamada interna suprime o reemplaza una " +"excepción, las devoluciones de llamada externas se pasarán argumentos " +"basados en ese estado actualizado." #: ../Doc/library/contextlib.rst:385 msgid "" @@ -331,6 +461,11 @@ msgid "" "foundation for higher level context managers that manipulate the exit stack " "in application specific ways." msgstr "" +"Esta es una API de nivel relativamente bajo que se ocupa de los detalles de " +"desenrollar correctamente la pila de devoluciones de llamada de salida. " +"Proporciona una base adecuada para administradores de contexto de nivel " +"superior que manipulan la pila de salida en formas específicas de la " +"aplicación." #: ../Doc/library/contextlib.rst:394 msgid "" @@ -338,16 +473,24 @@ msgid "" "callback stack. The return value is the result of the context manager's own :" "meth:`__enter__` method." msgstr "" +"Ingresa a un nuevo administrador de contexto y agrega su método :meth:" +"`__exit__` a la pila de devolución de llamada. El valor de retorno es el " +"resultado del método propio del administrador de contexto :meth:`__enter__`." #: ../Doc/library/contextlib.rst:398 msgid "" "These context managers may suppress exceptions just as they normally would " "if used directly as part of a :keyword:`with` statement." msgstr "" +"Estos administradores de contexto pueden suprimir excepciones tal como lo " +"harían normalmente si se usaran directamente como parte de una declaración :" +"keyword:`with`." #: ../Doc/library/contextlib.rst:403 msgid "Adds a context manager's :meth:`__exit__` method to the callback stack." msgstr "" +"Agrega un método de gestor de contexto :meth:`__exit__` a la pila de " +"devolución de llamada." #: ../Doc/library/contextlib.rst:405 msgid "" @@ -355,6 +498,9 @@ msgid "" "an :meth:`__enter__` implementation with a context manager's own :meth:" "`__exit__` method." msgstr "" +"Como ``__enter__`` *no* se invoca, este método se puede usar para cubrir " +"parte de una implementación :meth:`__enter__` con un método propio del " +"gestor de contexto :meth:`__exit__`." #: ../Doc/library/contextlib.rst:409 msgid "" @@ -362,36 +508,52 @@ msgid "" "a callback with the same signature as a context manager's :meth:`__exit__` " "method and adds it directly to the callback stack." msgstr "" +"Si se pasa un objeto que no es un administrador de contexto, este método " +"supone que es una devolución de llamada con la misma firma que el método :" +"meth:`__exit__` de un gestor de contexto y lo agrega directamente a la pila " +"de devolución de llamada." #: ../Doc/library/contextlib.rst:413 msgid "" "By returning true values, these callbacks can suppress exceptions the same " "way context manager :meth:`__exit__` methods can." msgstr "" +"Al devolver valores verdaderos, estas devoluciones de llamada pueden " +"suprimir excepciones de la misma manera que el gestor de contexto los " +"métodos :meth:`__exit__` pueden hacerlo." #: ../Doc/library/contextlib.rst:416 msgid "" "The passed in object is returned from the function, allowing this method to " "be used as a function decorator." msgstr "" +"El objeto pasado se devuelve desde la función, lo que permite que este " +"método se use como decorador de funciones." #: ../Doc/library/contextlib.rst:421 msgid "" "Accepts an arbitrary callback function and arguments and adds it to the " "callback stack." msgstr "" +"Acepta una función de devolución de llamada arbitraria y argumentos y la " +"agrega a la pila de devolución de llamada." #: ../Doc/library/contextlib.rst:424 msgid "" "Unlike the other methods, callbacks added this way cannot suppress " "exceptions (as they are never passed the exception details)." msgstr "" +"A diferencia de los otros métodos, las devoluciones de llamada agregadas de " +"esta manera no pueden suprimir excepciones (ya que nunca se pasan los " +"detalles de excepción)." #: ../Doc/library/contextlib.rst:427 msgid "" "The passed in callback is returned from the function, allowing this method " "to be used as a function decorator." msgstr "" +"La devolución de llamada pasada se devuelve desde la función, lo que permite " +"que este método se use como decorador de funciones." #: ../Doc/library/contextlib.rst:432 msgid "" @@ -400,12 +562,18 @@ msgid "" "now be invoked when the new stack is closed (either explicitly or implicitly " "at the end of a :keyword:`with` statement)." msgstr "" +"Transfiere la pila de devolución de llamada a una instancia fresca :class:" +"`ExitStack` y la devuelve. Esta operación no invoca devoluciones de llamada; " +"en cambio, ahora se invocarán cuando se cierre la nueva pila (ya sea " +"explícita o implícitamente al final de una instrucción :keyword:`with`)." #: ../Doc/library/contextlib.rst:437 msgid "" "For example, a group of files can be opened as an \"all or nothing\" " "operation as follows::" msgstr "" +"Por ejemplo, un grupo de archivos se puede abrir como una operación de " +"\"todo o nada\" de la siguiente manera:" #: ../Doc/library/contextlib.rst:451 msgid "" @@ -413,6 +581,11 @@ msgid "" "order of registration. For any context managers and exit callbacks " "registered, the arguments passed in will indicate that no exception occurred." msgstr "" +"Inmediatamente desenrolla la pila de devolución de llamada, invocando " +"devoluciones de llamada en el orden inverso de registro. Para los " +"administradores de contexto y las devoluciones de llamada de salida " +"registradas, los argumentos pasados indicarán que no se produjo ninguna " +"excepción." #: ../Doc/library/contextlib.rst:458 msgid "" @@ -420,49 +593,61 @@ msgid "" "class:`ExitStack`, that supports combining both synchronous and asynchronous " "context managers, as well as having coroutines for cleanup logic." msgstr "" +"Un :ref:`gestor de contexto asíncrono `, similar a :" +"class:`ExitStack`, que admite la combinación de gestores de contexto " +"síncrono y asíncrono, además de tener rutinas para la lógica de limpieza." #: ../Doc/library/contextlib.rst:463 msgid "" "The :meth:`close` method is not implemented, :meth:`aclose` must be used " "instead." msgstr "" +"El método :meth:`close` no está implementado, :meth:`aclose` debe usarse en " +"su lugar." #: ../Doc/library/contextlib.rst:468 msgid "" "Similar to :meth:`enter_context` but expects an asynchronous context manager." msgstr "" +"Similar a :meth:`enter_context` pero espera un administrador de contexto " +"asíncrono." #: ../Doc/library/contextlib.rst:473 msgid "" "Similar to :meth:`push` but expects either an asynchronous context manager " "or a coroutine function." msgstr "" +"Similar a :meth:`push` pero espera un gestor de contexto asíncrono o una " +"función de rutina." #: ../Doc/library/contextlib.rst:478 msgid "Similar to :meth:`callback` but expects a coroutine function." -msgstr "" +msgstr "Similar a :meth:`callback` pero espera una función de rutina." #: ../Doc/library/contextlib.rst:482 msgid "Similar to :meth:`close` but properly handles awaitables." msgstr "" +"Similar a :meth:`close` pero maneja adecuadamente los objetos de espera." #: ../Doc/library/contextlib.rst:484 msgid "Continuing the example for :func:`asynccontextmanager`::" -msgstr "" +msgstr "Continuando con el ejemplo para :func:`asynccontextmanager`::" #: ../Doc/library/contextlib.rst:496 msgid "Examples and Recipes" -msgstr "" +msgstr "Ejemplos y recetas" #: ../Doc/library/contextlib.rst:498 msgid "" "This section describes some examples and recipes for making effective use of " "the tools provided by :mod:`contextlib`." msgstr "" +"Esta sección describe algunos ejemplos y recetas para hacer un uso efectivo " +"de las herramientas proporcionadas por :mod:`contextlib`." #: ../Doc/library/contextlib.rst:503 msgid "Supporting a variable number of context managers" -msgstr "" +msgstr "Apoyando un número variable de gestores de contexto" #: ../Doc/library/contextlib.rst:505 msgid "" @@ -473,6 +658,13 @@ msgid "" "input (such as opening a user specified collection of files), or from some " "of the context managers being optional::" msgstr "" +"El caso de uso principal para :class:`ExitStack` es el que se proporciona en " +"la documentación de la clase: admite un número variable de gestores de " +"contexto y otras operaciones de limpieza en una sola :keyword:`with`. La " +"variabilidad puede provenir de la cantidad de gestores de contexto que " +"necesitan ser impulsados por la entrada del usuario (como abrir una " +"colección de archivos especificada por el usuario), o de que algunos de los " +"gestores de contexto sean opcionales:" #: ../Doc/library/contextlib.rst:520 msgid "" @@ -480,10 +672,13 @@ msgid "" "statements to manage arbitrary resources that don't natively support the " "context management protocol." msgstr "" +"Como se muestra, :class:`ExitStack` también hace que sea bastante fácil de " +"usar :keyword:`with` para administrar recursos arbitrarios que no admiten de " +"forma nativa el protocolo de gestión de contexto." #: ../Doc/library/contextlib.rst:526 msgid "Catching exceptions from ``__enter__`` methods" -msgstr "" +msgstr "Capturando excepciones de los métodos ``__enter__``" #: ../Doc/library/contextlib.rst:528 msgid "" @@ -493,6 +688,11 @@ msgid "" "By using :class:`ExitStack` the steps in the context management protocol can " "be separated slightly in order to allow this::" msgstr "" +"Ocasionalmente es deseable capturar excepciones de una implementación del " +"método ``__enter__``, *sin* capturar inadvertidamente excepciones del cuerpo " +"de la declaración :keyword:`with` o el método ``__exit__`` del gestor de " +"contexto. Al usar :class:`ExitStack`, los pasos en el protocolo de gestor de " +"contexto se pueden separar ligeramente para permitir esto::" #: ../Doc/library/contextlib.rst:543 msgid "" @@ -504,10 +704,18 @@ msgid "" "to handle various situations that can't be handled directly in a :keyword:" "`with` statement." msgstr "" +"Es probable que la necesidad de hacer esto indique que la API subyacente " +"debería proporcionar una interfaz de administración de recursos directa para " +"usar con :keyword:`tr`/:keyword:`except`/:keyword:`finally`, pero no todas " +"las API están bien diseñados en ese sentido. Cuando un administrador de " +"contexto es la única API de administración de recursos proporcionada, " +"entonces :class:`ExitStack` puede facilitar el manejo de diversas " +"situaciones que no se pueden manejar directamente en una declaración :" +"keyword:`with`." #: ../Doc/library/contextlib.rst:553 msgid "Cleaning up in an ``__enter__`` implementation" -msgstr "" +msgstr "Limpieza en una implementación ``__enter__``" #: ../Doc/library/contextlib.rst:555 msgid "" @@ -515,6 +723,9 @@ msgid "" "useful in cleaning up an already allocated resource if later steps in the :" "meth:`__enter__` implementation fail." msgstr "" +"Como se señala en la documentación de :meth:`ExitStack.push`, este método " +"puede ser útil para limpiar un recurso ya asignado si fallan los pasos " +"posteriores en :meth:`__enter__`." #: ../Doc/library/contextlib.rst:559 msgid "" @@ -522,10 +733,14 @@ msgid "" "acquisition and release functions, along with an optional validation " "function, and maps them to the context management protocol::" msgstr "" +"Aquí hay un ejemplo de cómo hacer esto para un administrador de contexto que " +"acepta funciones de adquisición y liberación de recursos, junto con una " +"función de validación opcional, y las asigna al protocolo de administración " +"de contexto::" #: ../Doc/library/contextlib.rst:599 msgid "Replacing any use of ``try-finally`` and flag variables" -msgstr "" +msgstr "Reemplazar cualquier uso de ``try-finally`` y marcar variables" #: ../Doc/library/contextlib.rst:601 msgid "" @@ -534,6 +749,10 @@ msgid "" "should be executed. In its simplest form (that can't already be handled just " "by using an ``except`` clause instead), it looks something like this::" msgstr "" +"Un patrón que a veces verá es una declaración de ``try-finally`` con una " +"variable de indicador para indicar si el cuerpo de la cláusula ``finally`` " +"debe ejecutarse o no. En su forma más simple (que ya no puede manejarse " +"simplemente usando una cláusula ``except`` en su lugar), se parece a esto::" #: ../Doc/library/contextlib.rst:615 msgid "" @@ -541,6 +760,10 @@ msgid "" "development and review, because the setup code and the cleanup code can end " "up being separated by arbitrarily long sections of code." msgstr "" +"Al igual que con cualquier código basado en la declaración ``try``, esto " +"puede causar problemas de desarrollo y revisión, porque el código de " +"configuración y el código de limpieza pueden terminar separados por " +"secciones de código arbitrariamente largas." #: ../Doc/library/contextlib.rst:619 msgid "" @@ -548,18 +771,25 @@ msgid "" "execution at the end of a ``with`` statement, and then later decide to skip " "executing that callback::" msgstr "" +":class:`ExitStack` hace posible registrar una devolución de llamada para su " +"ejecución al final de una instrucción ``with``, y luego decide omitir la " +"ejecución de esa devolución de llamada::" #: ../Doc/library/contextlib.rst:631 msgid "" "This allows the intended cleanup up behaviour to be made explicit up front, " "rather than requiring a separate flag variable." msgstr "" +"Esto permite que el comportamiento de limpieza previsto se haga explícito " +"por adelantado, en lugar de requerir una variable de indicador separada." #: ../Doc/library/contextlib.rst:634 msgid "" "If a particular application uses this pattern a lot, it can be simplified " "even further by means of a small helper class::" msgstr "" +"Si una aplicación particular usa mucho este patrón, puede simplificarse aún " +"más por medio de una pequeña clase auxiliar::" #: ../Doc/library/contextlib.rst:652 msgid "" @@ -567,6 +797,9 @@ msgid "" "function, then it is still possible to use the decorator form of :meth:" "`ExitStack.callback` to declare the resource cleanup in advance::" msgstr "" +"Si la limpieza del recurso no está bien agrupada en una función " +"independiente, entonces todavía es posible usar la forma decoradora de :meth:" +"`ExitStack.callback` para declarar la limpieza del recurso por adelantado::" #: ../Doc/library/contextlib.rst:667 msgid "" @@ -574,16 +807,22 @@ msgid "" "this way cannot take any parameters. Instead, any resources to be released " "must be accessed as closure variables." msgstr "" +"Debido a la forma en que funciona el protocolo decorador, una función de " +"devolución de llamada declarada de esta manera no puede tomar ningún " +"parámetro. En cambio, se debe acceder a los recursos que se liberarán como " +"variables de cierre." #: ../Doc/library/contextlib.rst:673 msgid "Using a context manager as a function decorator" -msgstr "" +msgstr "Usar un gestor de contexto como decorador de funciones" #: ../Doc/library/contextlib.rst:675 msgid "" ":class:`ContextDecorator` makes it possible to use a context manager in both " "an ordinary ``with`` statement and also as a function decorator." msgstr "" +":class:`ContextDecorator` hace posible usar un gestor de contexto tanto en " +"una instrucción ordinaria ``with`` como también como decorador de funciones." #: ../Doc/library/contextlib.rst:678 msgid "" @@ -593,14 +832,20 @@ msgid "" "task, inheriting from :class:`ContextDecorator` provides both capabilities " "in a single definition::" msgstr "" +"Por ejemplo, a veces es útil envolver funciones o grupos de declaraciones " +"con un registrador que puede rastrear la hora de entrada y la hora de " +"salida. En lugar de escribir tanto un decorador de funciones como un " +"administrador de contexto para la tarea, heredar de :class:" +"`ContextDecorator` proporciona ambas capacidades en una sola definición::" #: ../Doc/library/contextlib.rst:699 msgid "Instances of this class can be used as both a context manager::" msgstr "" +"Las instancias de esta clase se pueden usar como un gestor de contexto::" #: ../Doc/library/contextlib.rst:705 msgid "And also as a function decorator::" -msgstr "" +msgstr "Y también como decorador de funciones::" #: ../Doc/library/contextlib.rst:712 msgid "" @@ -609,20 +854,26 @@ msgid "" "`__enter__`. If that value is needed, then it is still necessary to use an " "explicit ``with`` statement." msgstr "" +"Tenga en cuenta que hay una limitación adicional cuando se usan " +"administradores de contexto como decoradores de funciones: no hay forma de " +"acceder al valor de retorno de :meth:`__enter__`. Si se necesita ese valor, " +"aún es necesario usar una declaración explícita ``with``." #: ../Doc/library/contextlib.rst:720 msgid ":pep:`343` - The \"with\" statement" -msgstr "" +msgstr ":pep:`343` - La declaración \"with\"" #: ../Doc/library/contextlib.rst:720 msgid "" "The specification, background, and examples for the Python :keyword:`with` " "statement." msgstr "" +"La especificación, antecedentes y ejemplos de la declaración de Python :" +"keyword:`with`." #: ../Doc/library/contextlib.rst:726 msgid "Single use, reusable and reentrant context managers" -msgstr "" +msgstr "Gestores de contexto de uso único, reutilizables y reentrantes" #: ../Doc/library/contextlib.rst:728 msgid "" @@ -631,6 +882,12 @@ msgid "" "managers must be created afresh each time they're used - attempting to use " "them a second time will trigger an exception or otherwise not work correctly." msgstr "" +"La mayoría de los gestores de contexto están escritos de una manera que " +"significa que solo se pueden usar de manera efectiva en una declaración :" +"keyword:`with` una vez. Estos administradores de contexto de un solo uso " +"deben crearse de nuevo cada vez que se usan; si intenta usarlos por segunda " +"vez, se activará una excepción o, de lo contrario, no funcionará " +"correctamente." #: ../Doc/library/contextlib.rst:734 msgid "" @@ -638,6 +895,10 @@ msgid "" "context managers directly in the header of the :keyword:`with` statement " "where they are used (as shown in all of the usage examples above)." msgstr "" +"Esta limitación común significa que generalmente es aconsejable crear " +"gestores de contexto directamente en el encabezado de la palabra clave :" +"keyword:`with` donde se usan (como se muestra en todos los ejemplos de uso " +"anteriores)." #: ../Doc/library/contextlib.rst:738 msgid "" @@ -645,6 +906,9 @@ msgid "" "first :keyword:`with` statement will close the file, preventing any further " "IO operations using that file object." msgstr "" +"Los archivos son un ejemplo de gestores de contexto de un solo uso, ya que " +"la primera :keyword:`with` cerrará el archivo, evitando cualquier otra " +"operación de E/S que use ese objeto de archivo." #: ../Doc/library/contextlib.rst:742 msgid "" @@ -652,10 +916,13 @@ msgid "" "context managers, and will complain about the underlying generator failing " "to yield if an attempt is made to use them a second time::" msgstr "" +"Los gestores de contexto creados usando :func:`contextmanager` también son " +"gestores de contexto de un solo uso, y se quejarán de la falla del generador " +"subyacente si se intenta usarlos por segunda vez::" #: ../Doc/library/contextlib.rst:770 msgid "Reentrant context managers" -msgstr "" +msgstr "Gestores contextuales reentrantes" #: ../Doc/library/contextlib.rst:772 msgid "" @@ -664,6 +931,10 @@ msgid "" "may also be used *inside* a :keyword:`!with` statement that is already using " "the same context manager." msgstr "" +"Los gestores de contexto más sofisticados pueden ser \"reentrantes\". Estos " +"administradores de contexto no solo se pueden usar en múltiples " +"declaraciones :keyword:`with`, sino que también se pueden usar *inside* a :" +"keyword:`!with` que ya está usando el mismo gestor de contexto." #: ../Doc/library/contextlib.rst:777 msgid "" @@ -671,6 +942,9 @@ msgid "" "are :func:`suppress` and :func:`redirect_stdout`. Here's a very simple " "example of reentrant use::" msgstr "" +":class:`threading.RLock` es un ejemplo de un administrador de contexto " +"reentrante, como son :func:`suppress` y :func:`redirect_stdout`. Aquí hay un " +"ejemplo muy simple de uso reentrante::" #: ../Doc/library/contextlib.rst:796 msgid "" @@ -678,6 +952,9 @@ msgid "" "functions calling each other and hence be far more complicated than this " "example." msgstr "" +"Es más probable que los ejemplos del mundo real de reentrada impliquen " +"múltiples funciones que se llaman entre sí y, por lo tanto, sean mucho más " +"complicadas que este ejemplo." #: ../Doc/library/contextlib.rst:800 msgid "" @@ -686,10 +963,14 @@ msgid "" "as it makes a global modification to the system state by binding :data:`sys." "stdout` to a different stream." msgstr "" +"Tenga en cuenta también que ser reentrante *no* es lo mismo que ser seguro " +"para subprocesos. :func:`redirect_stdout`, por ejemplo, definitivamente no " +"es seguro para subprocesos, ya que realiza una modificación global al estado " +"del sistema al vincular :data:`sys.stdout` a una secuencia diferente." #: ../Doc/library/contextlib.rst:809 msgid "Reusable context managers" -msgstr "" +msgstr "Gestores contextuales reutilizables" #: ../Doc/library/contextlib.rst:811 msgid "" @@ -700,6 +981,14 @@ msgid "" "will fail (or otherwise not work correctly) if the specific context manager " "instance has already been used in a containing with statement." msgstr "" +"Distintos de los administradores de contexto de uso único y reentrante son " +"los administradores de contexto \"reutilizables\" (o, para ser completamente " +"explícitos, los administradores de contexto \"reutilizables, pero no " +"reentrantes\", ya que los administradores de contexto reentrantes también " +"son reutilizables). Estos administradores de contexto admiten que se usen " +"varias veces, pero fallarán (o de lo contrario no funcionarán correctamente) " +"si la instancia específica del administrador de contexto ya se ha utilizado " +"en una declaración que contiene." #: ../Doc/library/contextlib.rst:818 msgid "" @@ -707,6 +996,9 @@ msgid "" "context manager (for a reentrant lock, it is necessary to use :class:" "`threading.RLock` instead)." msgstr "" +":class:`threading.Lock` es un ejemplo de un gestor de contexto reutilizable, " +"pero no reentrante (para un bloqueo reentrante, es necesario usar :class:" +"`threading.RLock` en su lugar)." #: ../Doc/library/contextlib.rst:822 msgid "" @@ -714,6 +1006,10 @@ msgid "" "`ExitStack`, as it invokes *all* currently registered callbacks when leaving " "any with statement, regardless of where those callbacks were added::" msgstr "" +"Otro ejemplo de un administrador de contexto reutilizable, pero no " +"reentrante es :class:`ExitStack`, ya que invoca *all* las devoluciones de " +"llamada registradas actualmente al dejar cualquier con declaración, " +"independientemente de dónde se agregaron esas devoluciones de llamada::" #: ../Doc/library/contextlib.rst:853 msgid "" @@ -722,9 +1018,15 @@ msgid "" "cause the stack to be cleared at the end of the innermost with statement, " "which is unlikely to be desirable behaviour." msgstr "" +"Como muestra el resultado del ejemplo, la reutilización de un solo objeto de " +"pila en múltiples con declaraciones funciona correctamente, pero intentar " +"anidarlos hará que la pila se borre al final de la declaración más interna, " +"lo que es poco probable que sea un comportamiento deseable." #: ../Doc/library/contextlib.rst:858 msgid "" "Using separate :class:`ExitStack` instances instead of reusing a single " "instance avoids that problem::" msgstr "" +"El uso de instancias separadas :class:`ExitStack` en lugar de reutilizar una " +"sola instancia evita ese problema::"