diff --git a/dictionaries/howto_logging-cookbook.txt b/dictionaries/howto_logging-cookbook.txt new file mode 100644 index 0000000000..470fb64e38 --- /dev/null +++ b/dictionaries/howto_logging-cookbook.txt @@ -0,0 +1,13 @@ +logger +loggings +loggers +pickle +binding +bindings +slot +QueueHandler +QueueListener +SysLogHandler +LogRecord +bindings +LoggerAdapters diff --git a/howto/logging-cookbook.po b/howto/logging-cookbook.po index 6b84aa1803..9ac36a807d 100644 --- a/howto/logging-cookbook.po +++ b/howto/logging-cookbook.po @@ -6,41 +6,45 @@ # Check https://github.com/python/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: 2021-03-19 11:16+0100\n" -"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" -"Last-Translator: FULL NAME \n" +"POT-Creation-Date: 2020-05-05 12:54+0200\n" +"PO-Revision-Date: 2020-11-27 01:14-0300\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: Carlos A. Crespo \n" +"Language: es\n" +"X-Generator: Poedit 2.4.1\n" #: ../Doc/howto/logging-cookbook.rst:5 msgid "Logging Cookbook" -msgstr "" +msgstr "Libro de recetas de Logging" #: ../Doc/howto/logging-cookbook.rst msgid "Author" -msgstr "" +msgstr "Autor" #: ../Doc/howto/logging-cookbook.rst:7 msgid "Vinay Sajip " -msgstr "" +msgstr "Vinay Sajip " #: ../Doc/howto/logging-cookbook.rst:9 msgid "" "This page contains a number of recipes related to logging, which have been " "found useful in the past." msgstr "" +"Esta página contiene un número de recetas sobre *logging*, que han sido " +"útiles en el pasado." #: ../Doc/howto/logging-cookbook.rst:15 msgid "Using logging in multiple modules" -msgstr "" +msgstr "Usar logging en múltiples módulos" #: ../Doc/howto/logging-cookbook.rst:17 msgid "" @@ -53,38 +57,52 @@ msgid "" "logger calls to the child will pass up to the parent. Here is a main " "module::" msgstr "" +"Múltiples llamadas a ``logging.getLogger('someLogger')`` devuelven una " +"referencia al mismo objeto logger. Esto es cierto no solo dentro del mismo " +"módulo, sino también en todos los módulos siempre que estén ejecutándose en " +"el mismo proceso del intérprete de Python. Es válido para las referencias al " +"mismo objeto. Además, el código de la aplicación puede definir y configurar " +"un logger primario en un módulo y crear (pero no configurar) un logger " +"secundario en un módulo separado, y todas las llamadas al secundario pasarán " +"al principal. A continuación un módulo principal::" +# Esto me confunde un poco. Cuando menciona módulo principal / auxiliar en los ejemplos, ¿se refiere a principal y secundario que está en el cuerpo del texto? ¿no convendría unificar? #: ../Doc/howto/logging-cookbook.rst:55 msgid "Here is the auxiliary module::" -msgstr "" +msgstr "Y aquí un módulo auxiliar::" #: ../Doc/howto/logging-cookbook.rst:75 msgid "The output looks like this:" -msgstr "" +msgstr "El resultado se ve así:" #: ../Doc/howto/logging-cookbook.rst:101 msgid "Logging from multiple threads" -msgstr "" +msgstr "Logging desde múltiples hilos" #: ../Doc/howto/logging-cookbook.rst:103 msgid "" "Logging from multiple threads requires no special effort. The following " "example shows logging from the main (initial) thread and another thread::" msgstr "" +"Realizar *logging* desde múltiples hilos (*threads*) no requiere ningún " +"esfuerzo especial. El siguiente ejemplo muestra el logging desde el hilo " +"principal (inicial) y otro hilo::" #: ../Doc/howto/logging-cookbook.rst:132 msgid "When run, the script should print something like the following:" -msgstr "" +msgstr "Cuando se ejecuta, el script debe imprimir algo como lo siguiente:" #: ../Doc/howto/logging-cookbook.rst:154 msgid "" "This shows the logging output interspersed as one might expect. This " "approach works for more threads than shown here, of course." msgstr "" +"Esto muestra la salida de logging intercalada como cabría esperar. Por " +"supuesto, este enfoque funciona para más hilos de lo que se muestran aquí." #: ../Doc/howto/logging-cookbook.rst:158 msgid "Multiple handlers and formatters" -msgstr "" +msgstr "Múltiples gestores y formateadores" #: ../Doc/howto/logging-cookbook.rst:160 msgid "" @@ -97,6 +115,15 @@ msgid "" "slight modification to the previous simple module-based configuration " "example::" msgstr "" +"Los *loggers* son simples objetos Python. El método :meth:`~Logger." +"addHandler` no tiene una cuota mínima o máxima para la cantidad de gestores " +"(*handlers*) que puede agregar. A veces será beneficioso para una aplicación " +"registrar todos los mensajes de todas las prioridades en un archivo de texto " +"mientras se registran simultáneamente los errores o más en la consola. Para " +"configurar esto, simplemente configure los gestores apropiados. Las llamadas " +"de logging en el código de la aplicación permanecerán sin cambios. Aquí hay " +"una ligera modificación al ejemplo de configuración simple anterior basado " +"en módulo::" #: ../Doc/howto/logging-cookbook.rst:193 msgid "" @@ -104,6 +131,9 @@ msgid "" "All that changed was the addition and configuration of a new handler named " "*fh*." msgstr "" +"Tenga en cuenta que el código de la 'aplicación' no se preocupa por los " +"gestores múltiples. Todo lo que cambió fue la adición y configuración de un " +"nuevo gestor llamado *fh*." #: ../Doc/howto/logging-cookbook.rst:196 msgid "" @@ -116,10 +146,18 @@ msgid "" "to happen is to modify the severity level of the logger and/or handler to " "debug." msgstr "" +"La capacidad de crear nuevos gestores con filtros de mayor o menor prioridad " +"puede ser muy útil al escribir y probar una aplicación. En lugar de usar " +"muchas declaraciones ``print`` para la depuración, use ``logger.debug``: a " +"diferencia de las declaraciones de impresión, que tendrá que eliminar o " +"comentar más tarde, las declaraciones de *logger.debug* pueden permanecer " +"intactas en el código fuente y permanecen inactivas hasta que las necesite " +"nuevamente. En ese momento, el único cambio que debe realizar es modificar " +"el nivel de prioridad del *logger* y/o gestor para depurar." #: ../Doc/howto/logging-cookbook.rst:207 msgid "Logging to multiple destinations" -msgstr "" +msgstr "Logging en múltiples destinos" #: ../Doc/howto/logging-cookbook.rst:209 msgid "" @@ -129,34 +167,46 @@ msgid "" "console. Let's also assume that the file should contain timestamps, but the " "console messages should not. Here's how you can achieve this::" msgstr "" +"Supongamos que desea que la consola y un archivo tengan diferentes formatos " +"de mensaje y salida de log para diferentes situaciones. Por ejemplo, desea " +"registrar mensajes con un nivel DEBUG y superiores en un archivo y enviar " +"mensajes con nivel INFO y superior a la consola. Además, suponga que desea " +"grabar una marca de tiempo en el archivo y no imprimirlo en la consola. " +"Puede lograr este comportamiento haciendo lo siguiente::" #: ../Doc/howto/logging-cookbook.rst:247 msgid "When you run this, on the console you will see" -msgstr "" +msgstr "Cuando ejecute esto, en la consola verá" #: ../Doc/howto/logging-cookbook.rst:256 msgid "and in the file you will see something like" -msgstr "" +msgstr "y en el archivo verá algo como" #: ../Doc/howto/logging-cookbook.rst:266 msgid "" "As you can see, the DEBUG message only shows up in the file. The other " "messages are sent to both destinations." msgstr "" +"Como se puede ver, el mensaje DEBUG sólo se muestra en el archivo. Los otros " +"mensajes se envían a los dos destinos." #: ../Doc/howto/logging-cookbook.rst:269 msgid "" "This example uses console and file handlers, but you can use any number and " "combination of handlers you choose." msgstr "" +"Este ejemplo usa gestores de consola y archivos, pero puede usar cualquier " +"número y combinación de los gestores que elija." #: ../Doc/howto/logging-cookbook.rst:274 msgid "Configuration server example" -msgstr "" +msgstr "Ejemplo de servidor de configuración" #: ../Doc/howto/logging-cookbook.rst:276 msgid "Here is an example of a module using the logging configuration server::" msgstr "" +"Aquí hay un ejemplo de un módulo que usa el servidor de configuración " +"logging::" #: ../Doc/howto/logging-cookbook.rst:307 msgid "" @@ -164,10 +214,13 @@ msgid "" "server, properly preceded with the binary-encoded length, as the new logging " "configuration::" msgstr "" +"Y aquí hay un script que toma un nombre de archivo y envía ese archivo al " +"servidor, precedido adecuadamente con la longitud codificada en binario, " +"como la nueva configuración de logging::" #: ../Doc/howto/logging-cookbook.rst:330 msgid "Dealing with handlers that block" -msgstr "" +msgstr "Tratar con gestores que bloquean" #: ../Doc/howto/logging-cookbook.rst:334 msgid "" @@ -175,7 +228,11 @@ msgid "" "blocking the thread you're logging from. This is common in Web applications, " "though of course it also occurs in other scenarios." msgstr "" +"A veces tiene que hacer que sus gestores de logging hagan su trabajo sin " +"bloquear el hilo desde el que está iniciando sesión. Esto es común en las " +"aplicaciones web, aunque, por supuesto, también ocurre en otros escenarios." +# -"under the hood": de bajo nivel? más técnicas? #: ../Doc/howto/logging-cookbook.rst:338 msgid "" "A common culprit which demonstrates sluggish behaviour is the :class:" @@ -186,6 +243,14 @@ msgid "" "which is too slow (and this query can be deep in the socket library code, " "below the Python layer, and outside your control)." msgstr "" +"Un responsable habitual que ejemplifica un comportamiento lento es la :class:" +"`SMTPHandler`: el envío de correos electrónicos puede llevar mucho tiempo, " +"por varias razones fuera del control del desarrollador (por ejemplo, una " +"infraestructura de red o correo de bajo rendimiento). Pero casi cualquier " +"controlador basado en red puede bloquear: incluso una operación :class:" +"`SocketHandler` puede estar haciendo a bajo nivel una consulta DNS que es " +"demasiado lenta (y esta consulta puede estar en el código de la biblioteca " +"de socket, debajo de la capa de Python, y fuera de su control)." #: ../Doc/howto/logging-cookbook.rst:346 msgid "" @@ -200,6 +265,17 @@ msgid "" "to attach only ``QueueHandlers`` to your loggers) for the benefit of other " "developers who will use your code." msgstr "" +"Una solución es utilizar un enfoque de dos partes. Para la primera parte, " +"adjunte solo una :class:`QueueHandler` a los loggers que se acceden desde " +"subprocesos críticos de rendimiento. Simplemente escriben en su cola, que " +"puede dimensionarse a una capacidad lo suficientemente grande o " +"inicializarse sin límite superior a su tamaño. La escritura en la cola " +"generalmente se aceptará rápidamente, aunque es probable que deba atrapar la " +"excepción :exc:`queue.Full` como precaución en su código. Si usted es un " +"desarrollador de bibliotecas que tiene subprocesos críticos de rendimiento " +"en su código, asegúrese de documentar esto (junto con una sugerencia de " +"adjuntar solo ``QueueHandlers`` a sus loggers) para el beneficio de otros " +"desarrolladores que usarán su código." #: ../Doc/howto/logging-cookbook.rst:357 msgid "" @@ -211,6 +287,12 @@ msgid "" "matter). The ``LogRecords`` are removed from the queue and passed to the " "handlers for processing." msgstr "" +"La segunda parte de la solución es :class:`QueueListener`, que fue designado " +"como la contraparte de :class:`QueueHandler`. Un :class:`QueueListener` es " +"muy simple: ha pasado una cola y algunos gestores, y activa un hilo interno " +"que escucha su cola para *LogRecords* enviados desde ``QueueHandlers`` (o " +"cualquier otra fuente de ``LogRecords``, para el caso). Los ``LogRecords`` " +"se eliminan de la cola y se pasan a los gestores para su procesamiento." #: ../Doc/howto/logging-cookbook.rst:365 msgid "" @@ -220,16 +302,24 @@ msgid "" "handler classes, which would eat up one thread per handler for no particular " "benefit." msgstr "" +"La ventaja de tener una clase separada :class:`QueueListener` es que puede " +"usar la misma instancia para dar servicio a múltiples ``QueueHandlers``. " +"Esto es más amigable con los recursos que, por ejemplo, tener versiones " +"enhebradas de las clases de gestores existentes, que consumirían un hilo por " +"gestor sin ningún beneficio particular." #: ../Doc/howto/logging-cookbook.rst:370 msgid "An example of using these two classes follows (imports omitted)::" msgstr "" +"Un ejemplo del uso de estas dos clases a continuación (se omiten *imports*)::" #: ../Doc/howto/logging-cookbook.rst:388 msgid "which, when run, will produce:" -msgstr "" +msgstr "que, cuando se ejecuta, producirá:" +# Está OK traducir "listener" por "oyente"?? #: ../Doc/howto/logging-cookbook.rst:394 +#, fuzzy msgid "" "Prior to Python 3.5, the :class:`QueueListener` always passed every message " "received from the queue to every handler it was initialized with. (This was " @@ -240,29 +330,48 @@ msgid "" "of each message with the handler's level, and only passes a message to a " "handler if it's appropriate to do so." msgstr "" +"Antes de Python 3.5, :class:`QueueListener` siempre pasaba cada mensaje " +"recibido de la cola a cada gestor con el que se inicializaba. (Esto se debió " +"a que se asumió que el filtrado de nivel se realizó en el otro lado, donde " +"se llena la cola). A partir de 3.5, este comportamiento se puede cambiar " +"pasando un argumento de palabra clave ``respect_handler_level=True`` al " +"constructor del oyente . Cuando se hace esto, el oyente compara el nivel de " +"cada mensaje con el nivel del controlador, y solo pasa un mensaje a un " +"controlador si es apropiado hacerlo." #: ../Doc/howto/logging-cookbook.rst:407 msgid "Sending and receiving logging events across a network" -msgstr "" +msgstr "Enviar y recibir eventos logging a través de una red" +# tengo dudas con "extremo final del envío" #: ../Doc/howto/logging-cookbook.rst:409 +#, fuzzy msgid "" "Let's say you want to send logging events across a network, and handle them " "at the receiving end. A simple way of doing this is attaching a :class:" "`SocketHandler` instance to the root logger at the sending end::" msgstr "" +"Supongamos que desea enviar eventos logging a través de una red y " +"gestionarlos en el extremo receptor. Una forma sencilla de hacer esto es " +"adjuntar una instancia de :class:`SocketHandler` al logger raíz en el " +"extremo final del envío::" #: ../Doc/howto/logging-cookbook.rst:437 msgid "" "At the receiving end, you can set up a receiver using the :mod:" "`socketserver` module. Here is a basic working example::" msgstr "" +"En el extremo receptor, puede configurar un receptor usando el módulo :mod:" +"`socketserver`. Aquí hay un ejemplo básico de trabajo:" #: ../Doc/howto/logging-cookbook.rst:525 msgid "" "First run the server, and then the client. On the client side, nothing is " "printed on the console; on the server side, you should see something like:" msgstr "" +"Primero ejecuta el servidor, y luego el cliente. Del lado del cliente, nada " +"se imprime en la consola; del lado del servidor, se debería ver algo como " +"esto:" #: ../Doc/howto/logging-cookbook.rst:537 msgid "" @@ -272,11 +381,17 @@ msgid "" "implementing your alternative there, as well as adapting the above script to " "use your alternative serialization." msgstr "" +"Tenga en cuenta que existen algunos problemas de seguridad con pickle en " +"algunos escenarios. Si estos le afectan, puede usar un esquema de " +"serialización alternativo anulando el método :meth:`~ handlers.SocketHandler." +"makePickle` e implementando su alternativa allí, así como adaptar el script " +"anterior para usar su serialización alternativa." #: ../Doc/howto/logging-cookbook.rst:547 msgid "Adding contextual information to your logging output" -msgstr "" +msgstr "Agregar información contextual a su salida de logging" +# no estoy seguro de la parte "se liberan de memoria via recolector de basura". En la wikipedia en español lo llaman así. "se liberan de memoria" es una agregado mío. #: ../Doc/howto/logging-cookbook.rst:549 msgid "" "Sometimes you want logging output to contain contextual information in " @@ -292,11 +407,25 @@ msgid "" "logging an application, it could be hard to manage if the number of :class:" "`Logger` instances becomes effectively unbounded." msgstr "" +"A veces, desea que la salida de logging contenga información contextual " +"además de los parámetros pasados a la llamada del logging. Por ejemplo, en " +"una aplicación en red, puede ser conveniente registrar información " +"específica del cliente en el logging (por ejemplo, el nombre de usuario del " +"cliente remoto o la dirección IP). Aunque puede usar el parámetro *extra* " +"para lograr esto, no siempre es conveniente pasar la información de esta " +"manera. Si bien puede resultar tentador crear instancias :class:`Logger` por " +"conexión, esta no es una buena idea porque estas instancias no se liberan de " +"memoria vía el recolector de basura (*garbage collector*). Si bien esto no " +"es un problema en la práctica, cuando el número de instancias de :class:" +"`Logger` depende del nivel de granularidad que desea usar para hacer el " +"logging de una aplicación, podría ser difícil de administrar si el número de " +"instancias :class:`Logger` se vuelven efectivamente ilimitadas." #: ../Doc/howto/logging-cookbook.rst:564 msgid "Using LoggerAdapters to impart contextual information" -msgstr "" +msgstr "Uso de LoggerAdapters para impartir información contextual" +# "signatures" por "características"? #: ../Doc/howto/logging-cookbook.rst:566 msgid "" "An easy way in which you can pass contextual information to be output along " @@ -307,8 +436,16 @@ msgid "" "signatures as their counterparts in :class:`Logger`, so you can use the two " "types of instances interchangeably." msgstr "" +"Una manera fácil de pasar información contextual para que se genere junto " +"con la información de eventos logging es usar la clase :class:" +"`LoggerAdapter`. Esta clase está diseñada para parecerse a :class:`Logger`, " +"de modo que pueda llamar :meth:`debug`, :meth:`info`, :meth:`warning`, :meth:" +"`error`, :meth:`excepción`, :meth:`critical` y :meth:`log`. Estos métodos " +"tienen las mismas signaturas que sus contrapartes en :class:`Logger`, por lo " +"que puede usar los dos tipos de instancias indistintamente." #: ../Doc/howto/logging-cookbook.rst:574 +#, fuzzy msgid "" "When you create an instance of :class:`LoggerAdapter`, you pass it a :class:" "`Logger` instance and a dict-like object which contains your contextual " @@ -318,6 +455,13 @@ msgid "" "contextual information in the delegated call. Here's a snippet from the code " "of :class:`LoggerAdapter`::" msgstr "" +"Cuando creas una instancia de :class:`LoggerAdapter`, le pasas una " +"instancia :class:`Logger` y un objeto tipo dict que contiene tu información " +"contextual. Cuando llamas a uno de los métodos logging en una instancia de :" +"class:`LoggerAdapter`, este último delega la llamada a la instancia " +"subyacente de :class:`Logger` pasada a su constructor, y se arregla para " +"pasar la información contextual en la llamada delegada . Aquí hay un " +"fragmento del código de :class:`LoggerAdapter`::" #: ../Doc/howto/logging-cookbook.rst:590 msgid "" @@ -331,6 +475,15 @@ msgid "" "had passed an 'extra' keyword argument in the call to the adapter, it will " "be silently overwritten." msgstr "" +"El método :meth:`~LoggerAdapter.process` de :class:`LoggerAdapter` es donde " +"la información contextual se agrega a la salida del logging. Se pasa el " +"mensaje y los argumentos de palabra clave de la llamada logging, y retorna " +"versiones (potencialmente) modificadas de estos para usar en la llamada al " +"logging subyacente. La implementación predeterminada de este método deja el " +"mensaje solo, pero inserta una clave 'extra' en el argumento de palabra " +"clave cuyo valor es el objeto tipo dict pasado al constructor. Por supuesto, " +"si ha pasado un argumento de palabra clave 'extra' en la llamada al " +"adaptador, se sobrescribirá silenciosamente." #: ../Doc/howto/logging-cookbook.rst:599 msgid "" @@ -342,20 +495,31 @@ msgid "" "string, you just need to subclass :class:`LoggerAdapter` and override :meth:" "`~LoggerAdapter.process` to do what you need. Here is a simple example::" msgstr "" +"La ventaja de usar 'extra' es que los valores en el objeto dict se combinan " +"en la instancia :class:`LogRecord` __dict__, lo que le permite usar cadenas " +"personalizadas con sus instancias :class:`Formatter` que conocen las claves " +"del objeto dict. Si necesita un método diferente, por ejemplo, si desea " +"anteponer o agregar la información contextual a la cadena del mensaje, solo " +"necesita la subclase :class:`LoggerAdapter` y anular :meth:`~LoggerAdapter." +"process` para hacer lo que necesita. Aquí hay un ejemplo simple:" #: ../Doc/howto/logging-cookbook.rst:615 msgid "which you can use like this::" -msgstr "" +msgstr "que puede usar así::" #: ../Doc/howto/logging-cookbook.rst:620 msgid "" "Then any events that you log to the adapter will have the value of " "``some_conn_id`` prepended to the log messages." msgstr "" +"Luego, cualquier evento que registre en el adaptador tendrá el valor de " +"``some_conn_id`` antepuesto a los mensajes de logging." #: ../Doc/howto/logging-cookbook.rst:624 msgid "Using objects other than dicts to pass contextual information" msgstr "" +"Usar objetos distintos a los diccionarios para transmitir información " +"contextual" #: ../Doc/howto/logging-cookbook.rst:626 msgid "" @@ -365,10 +529,15 @@ msgid "" "if you want to generate values dynamically (whereas the values in a dict " "would be constant)." msgstr "" +"No es necesario pasar un diccionario real a la :class:`LoggerAdapter` - " +"puedes pasar una instancia de una clase que implemente ``__getitem__`` y " +"``__iter__`` de modo que parezca un diccionario para el logging. Esto es " +"útil si quieres generar valores dinámicamente (mientras que los valores en " +"un diccionario son constantes)." #: ../Doc/howto/logging-cookbook.rst:635 msgid "Using Filters to impart contextual information" -msgstr "" +msgstr "Usar filtros para impartir información contextual" #: ../Doc/howto/logging-cookbook.rst:637 msgid "" @@ -378,6 +547,12 @@ msgid "" "can then be output using a suitable format string, or if needed a custom :" "class:`Formatter`." msgstr "" +"También puedes agregar información contextual a la salida del log utilizando " +"un :class:`Filter` definido por el usuario. Las instancias de ``Filter`` " +"pueden modificar los ``LogRecords`` que se les pasan, incluido el agregado " +"de atributos adicionales que luego se pueden generar utilizando cadena de " +"caracteres con el formato adecuado, o si es necesario, un :class:`Formatter` " +"personalizado." #: ../Doc/howto/logging-cookbook.rst:642 msgid "" @@ -390,15 +565,26 @@ msgid "" "format string can be used to get similar output to that shown above. Here's " "an example script::" msgstr "" +"Por ejemplo, en una aplicación web, la solicitud que se está procesando (o " +"al menos, las partes interesantes de la misma) se pueden almacenar en una " +"variable *threadlocal* (:class:`threading.local`) y luego se puede acceder a " +"ella desde ``Filter`` para agregar información de la solicitud, - digamos, " +"la dirección IP remota y el nombre de usuario-, al ``LogRecord``, usando los " +"nombres de atributo 'ip' y 'user' como en el ejemplo anterior de " +"``LoggerAdapter``. En ese caso, se puede usar el mismo formato de cadena de " +"caracteres para obtener un resultado similar al que se muestra arriba. Aquí " +"hay un script de ejemplo::" #: ../Doc/howto/logging-cookbook.rst:688 msgid "which, when run, produces something like:" -msgstr "" +msgstr "que cuando se ejecuta, produce algo como:" #: ../Doc/howto/logging-cookbook.rst:709 msgid "Logging to a single file from multiple processes" -msgstr "" +msgstr "Logging a un sólo archivo desde múltiples procesos" +# Traté de refrasear las primeras oraciones para que no sea super repetitivo. +# No tengo claro cómo es todo el tema de socket y si está bien traducido "socket server", "working socket". #: ../Doc/howto/logging-cookbook.rst:711 msgid "" "Although logging is thread-safe, and logging to a single file from multiple " @@ -414,6 +600,18 @@ msgid "" "includes a working socket receiver which can be used as a starting point for " "you to adapt in your own applications." msgstr "" +"Aunque logging es seguro para hilos, y el logging a un solo archivo desde " +"múltiples hilos en un solo proceso *es* compatible, el logging en un solo " +"archivo desde *múltiples procesos* *no* es compatible, porque no existe una " +"forma estándar de serializar el acceso a un solo archivo en múltiples " +"procesos en Python. Si necesita hacer esto último, una forma de abordarlo es " +"hacer que todos los procesos se registren en una :class:`~handlers." +"SocketHandler`, y tener un proceso separado que implemente un servidor de " +"socket que lee del socket y los loggings para archivar. (Si lo prefiere, " +"puede dedicar un hilo en uno de los procesos existentes para realizar esta " +"función.) :ref:`Esta sección ` documenta este enfoque con " +"más detalle e incluye un receptor socket que funciona que se puede utilizar " +"como punto de partida para que se adapte a sus propias aplicaciones." #: ../Doc/howto/logging-cookbook.rst:724 msgid "" @@ -425,6 +623,13 @@ msgid "" "`multiprocessing` module does not provide working lock functionality on all " "platforms (see https://bugs.python.org/issue3770)." msgstr "" +"También puedes escribir tu propio gestor que use la clase :class:" +"`~multiprocessing.Lock` del módulo :mod:`multiprocessing` para serializar el " +"acceso al archivo desde tus procesos. La existente :class:`FileHandler` y " +"las subclases no hacen uso de :mod:`multiprocessing` en la actualidad, " +"aunque pueden hacerlo en el futuro. Tenga en cuenta que, en la actualidad, " +"el módulo :mod:`multiprocessing` no proporciona la funcionalidad de bloqueo " +"de trabajo en todas las plataformas (ver https://bugs.python.org/issue3770)." #: ../Doc/howto/logging-cookbook.rst:734 msgid "" @@ -440,12 +645,25 @@ msgid "" "application, and can be used as the basis for code meeting your own specific " "requirements::" msgstr "" +"Alternativamente, puede usar una ``Queue`` y :class:`QueueHandler` para " +"enviar todos los logging a uno de los procesos en su aplicación multi-" +"proceso. El siguiente script de ejemplo demuestra cómo puede hacer esto; en " +"el ejemplo, un proceso de escucha independiente escucha los eventos enviados " +"por otros procesos y los registra de acuerdo con su propia configuración de " +"logging. Aunque el ejemplo solo demuestra una forma de hacerlo (por ejemplo, " +"es posible que desee utilizar un hilo de escucha en lugar de un proceso de " +"escucha separado; la implementación sería análoga), permite configuraciones " +"de logging completamente diferentes para el oyente y los otros procesos en " +"su aplicación. Y se puede utilizar como base para el código que cumpla con " +"sus propios requisitos específicos::" #: ../Doc/howto/logging-cookbook.rst:850 msgid "" "A variant of the above script keeps the logging in the main process, in a " "separate thread::" msgstr "" +"Una variante del script anterior mantiene el logging en el proceso " +"principal, en un hilo separado::" #: ../Doc/howto/logging-cookbook.rst:945 msgid "" @@ -456,10 +674,16 @@ msgid "" "events are generated in the worker processes) to direct the messages to the " "appropriate destinations." msgstr "" +"Esta variante muestra cómo puede, por ejemplo, aplicar la configuración para " +"logging particulares: el registrador ``foo`` tiene un gestor especial que " +"almacena todos los eventos en el subsistema ``foo`` en un archivo ``mplog-" +"foo.log``. Esto será utilizado por la maquinaria de logging en el proceso " +"principal (aunque los eventos logging se generen en los procesos de trabajo) " +"para dirigir los mensajes a los destinos apropiados." #: ../Doc/howto/logging-cookbook.rst:952 msgid "Using concurrent.futures.ProcessPoolExecutor" -msgstr "" +msgstr "Usando concurrent.futures.ProcessPoolExecutor" #: ../Doc/howto/logging-cookbook.rst:954 msgid "" @@ -467,22 +691,27 @@ msgid "" "your worker processes, you need to create the queue slightly differently. " "Instead of" msgstr "" +"Si desea utilizar :class:`concurrent.futures.ProcessPoolExecutor` para " +"iniciar sus procesos de trabajo, debe crear la cola de manera ligeramente " +"diferente. En vez de" #: ../Doc/howto/logging-cookbook.rst:962 msgid "you should use" -msgstr "" +msgstr "debería usar" +# No sé cómo traducir "worker creation". #: ../Doc/howto/logging-cookbook.rst:968 +#, fuzzy msgid "and you can then replace the worker creation from this::" -msgstr "" +msgstr "y entonces puedes reemplazar::" #: ../Doc/howto/logging-cookbook.rst:979 msgid "to this (remembering to first import :mod:`concurrent.futures`)::" -msgstr "" +msgstr "a esto (recuerda el primer *import* :mod:`concurrent.futures`)::" #: ../Doc/howto/logging-cookbook.rst:987 msgid "Using file rotation" -msgstr "" +msgstr "Usando rotación de archivos" #: ../Doc/howto/logging-cookbook.rst:992 msgid "" @@ -493,12 +722,20 @@ msgid "" "usage pattern, the logging package provides a :class:`~handlers." "RotatingFileHandler`::" msgstr "" +"A veces, se desea dejar que un archivo de log crezca hasta cierto tamaño y " +"luego abra un nuevo archivo e inicie sesión en él. Es posible que desee " +"conservar una cierta cantidad de estos archivos, y cuando se hayan creado " +"tantos archivos, rote los archivos para que la cantidad de archivos y el " +"tamaño de los archivos permanezcan limitados. Para este patrón de uso, el " +"paquete logging proporciona :class:`~handlers.RotatingFileHandler`::" #: ../Doc/howto/logging-cookbook.rst:1024 msgid "" "The result should be 6 separate files, each with part of the log history for " "the application:" msgstr "" +"El resultado debe ser 6 archivos separados, cada uno con parte del historial " +"de log de la aplicación:" #: ../Doc/howto/logging-cookbook.rst:1036 msgid "" @@ -507,19 +744,26 @@ msgid "" "``.1``. Each of the existing backup files is renamed to increment the suffix " "(``.1`` becomes ``.2``, etc.) and the ``.6`` file is erased." msgstr "" +"El archivo más actual siempre es :file:`logging_rotatingfile_example.out`, y " +"cada vez que alcanza el límite de tamaño, se le cambia el nombre con el " +"sufijo``.1``. Se cambia el nombre de cada uno de los archivos de respaldo " +"existentes para incrementar el sufijo (``.1`` se convierte en ``.2``, etc.) " +"y se borra el archivo ``.6``." #: ../Doc/howto/logging-cookbook.rst:1041 msgid "" "Obviously this example sets the log length much too small as an extreme " "example. You would want to set *maxBytes* to an appropriate value." msgstr "" +"Obviamente, este ejemplo establece la longitud del log demasiado pequeña " +"como un ejemplo extremo. Se querrá establecer *maxBytes* en un valor " +"apropiado." #: ../Doc/howto/logging-cookbook.rst:1047 msgid "Use of alternative formatting styles" -msgstr "" +msgstr "Uso de estilos de formato alternativos" #: ../Doc/howto/logging-cookbook.rst:1049 -#, python-format msgid "" "When logging was added to the Python standard library, the only way of " "formatting messages with variable content was to use the %-formatting " @@ -527,6 +771,11 @@ msgid "" "`string.Template` (added in Python 2.4) and :meth:`str.format` (added in " "Python 2.6)." msgstr "" +"Cuando se agregó logging a la biblioteca estándar de Python, la única forma " +"de formatear mensajes con contenido variable era usar el método de formateo " +"'%'. Desde entonces, Python ha ganado dos nuevos enfoques de formato: :class:" +"`string.Template` (agregado en Python 2.4) y :meth:`str.format` (agregado en " +"Python 2.6)." #: ../Doc/howto/logging-cookbook.rst:1055 msgid "" @@ -540,17 +789,30 @@ msgid "" "meth:`str.format` or :class:`string.Template`. Here's an example console " "session to show the possibilities:" msgstr "" +"Logging (a partir de la versión 3.2) proporciona un soporte mejorado para " +"estos dos estilos de formato adicionales. La clase :class:`Formatter` ha " +"sido mejorada para tomar un parámetro de palabra clave adicional llamado " +"``style``. El valor predeterminado es ``'%'``, pero otros valores posibles " +"son ``'{'`` y ``'$'``, que corresponden a los otros dos estilos de formato. " +"La compatibilidad con versiones anteriores se mantiene de forma " +"predeterminada (como era de esperar), pero al especificar explícitamente un " +"parámetro de estilo, tiene la capacidad de especificar cadenas de formato " +"que funcionan con :meth:`str.format` o :class:`string.Template`. Aquí hay " +"una sesión de consola de ejemplo para mostrar las posibilidades:" #: ../Doc/howto/logging-cookbook.rst:1089 -#, python-format msgid "" "Note that the formatting of logging messages for final output to logs is " "completely independent of how an individual logging message is constructed. " "That can still use %-formatting, as shown here::" msgstr "" +"Tenga en cuenta que el formato de logging para la salida final a los logs es " +"completamente independiente de cómo se construye un mensaje de logging " +"individual. Para eso todavía puede usar el formateo \"%\", como se muestra " +"aquí:" +# No entiendo este bloque en inglés ni en español :P #: ../Doc/howto/logging-cookbook.rst:1097 -#, python-format msgid "" "Logging calls (``logger.debug()``, ``logger.info()`` etc.) only take " "positional parameters for the actual logging message itself, with keyword " @@ -559,12 +821,25 @@ msgid "" "traceback information should be logged, or the ``extra`` keyword parameter " "to indicate additional contextual information to be added to the log). So " "you cannot directly make logging calls using :meth:`str.format` or :class:" -"`string.Template` syntax, because internally the logging package uses " -"%-formatting to merge the format string and the variable arguments. There " +"`string.Template` syntax, because internally the logging package uses %-" +"formatting to merge the format string and the variable arguments. There " "would be no changing this while preserving backward compatibility, since all " "logging calls which are out there in existing code will be using %-format " "strings." msgstr "" +"Las llamadas de Logging (``logger.debug()``, ``logger.info()``, etc.) solo " +"toman parámetros posicionales para el mensaje de logging real en sí, los " +"parámetros de palabras clave se usan solo para determinar opciones sobre " +"cómo gestionar la llamada propiamente a Logging (por ejemplo, el parámetro " +"de palabra clave ``exc_info`` para indicar que la información de rastreo " +"debe registrarse, o el parámetro de palabra clave ``extra`` para indicar " +"información contextual adicional que se agregará al log). Por lo tanto, no " +"puede realizar llamadas de logging directamente usando la sintaxis :meth:" +"`str.format` o :class:`string.Template`, porque internamente el paquete de " +"logging usa formato % para fusionar la cadena de formato y los argumentos de " +"las variables. No habría ningún cambio en esto mientras se conserva la " +"compatibilidad con versiones anteriores, ya que todas las llamadas de " +"logging que están en el código existente usarán cadenas de formato %." #: ../Doc/howto/logging-cookbook.rst:1110 msgid "" @@ -574,9 +849,14 @@ msgid "" "will call ``str()`` on that object to get the actual format string. Consider " "the following two classes::" msgstr "" +"Sin embargo, existe una forma en la que puede usar el formato {} - y $ - " +"para construir sus mensajes de log individuales. Recuerde que para un " +"mensaje puede usar un objeto arbitrario como una cadena de caracteres de " +"formato de mensaje, y que el paquete logging llamará a ``str()`` en ese " +"objeto para obtener la cadena de caracteres de formato real. Considere las " +"siguientes dos clases::" #: ../Doc/howto/logging-cookbook.rst:1134 -#, python-format msgid "" "Either of these can be used in place of a format string, to allow {}- or $-" "formatting to be used to build the actual \"message\" part which appears in " @@ -586,6 +866,14 @@ msgid "" "__ (double underscore --- not to be confused with _, the single underscore " "used as a synonym/alias for :func:`gettext.gettext` or its brethren)." msgstr "" +"Cualquiera de estos puede usarse en lugar de una cadena de formato, para " +"permitir que se use el formato {} - o $ - para construir la parte del " +"\"mensaje\" real que aparece en la salida del log en lugar de \"%(message)s" +"\" o \"{message}\" o \"$message\". Es un poco difícil de manejar usar los " +"nombres de las clases siempre que quieras registrar algo, pero es bastante " +"aceptable si usas un alias como __ (doble subrayado --- no confundir con _, " +"el subrayado simple usado como sinónimo/alias para :func:`gettext.gettext` o " +"sus hermanos)." #: ../Doc/howto/logging-cookbook.rst:1142 msgid "" @@ -593,6 +881,10 @@ msgid "" "copy and paste into your own code. They can be used as follows (assuming " "that they're declared in a module called ``wherever``):" msgstr "" +"Las clases anteriores no están incluidas en Python, aunque son bastante " +"fáciles de copiar y pegar en su propio código. Se pueden usar de la " +"siguiente manera (asumiendo que están declaradas en un módulo llamado " +"``wherever``):" #: ../Doc/howto/logging-cookbook.rst:1164 msgid "" @@ -600,6 +892,9 @@ msgid "" "you would of course use ``logger.debug()`` or similar to actually log using " "this approach." msgstr "" +"Si bien los ejemplos anteriores usan ``print()`` para mostrar cómo funciona " +"el formateo, por supuesto usaría ``logger.debug()`` o similar para realmente " +"registrar usando este enfoque." #: ../Doc/howto/logging-cookbook.rst:1168 msgid "" @@ -611,22 +906,34 @@ msgid "" "not just the format string. That's because the __ notation is just syntax " "sugar for a constructor call to one of the XXXMessage classes." msgstr "" +"Una cosa a tener en cuenta es que no paga una penalización de rendimiento " +"significativa con este enfoque: el formateo real no ocurre cuando realiza la " +"llamada a logging, sino cuando (y si) el mensaje registrado está a punto de " +"ser enviado a un log por un gestor. Entonces, lo único un poco inusual que " +"podría confundirte es que los paréntesis rodean la cadena de formato y los " +"argumentos, no solo la cadena de formato. Eso es porque la notación __ es " +"solo azúcar sintáctico para una llamada de constructor a una de las clases " +"XXXMessage." #: ../Doc/howto/logging-cookbook.rst:1176 msgid "" "If you prefer, you can use a :class:`LoggerAdapter` to achieve a similar " "effect to the above, as in the following example::" msgstr "" +"Si lo prefiere, puede usar :class:`LoggerAdapter` para lograr un efecto " +"similar al anterior, como en el siguiente ejemplo::" #: ../Doc/howto/logging-cookbook.rst:1207 msgid "" "The above script should log the message ``Hello, world!`` when run with " "Python 3.2 or later." msgstr "" +"El script anterior debería registrar el mensaje ``Hello, world!`` Cuando se " +"ejecuta con Python 3.2 o posterior." #: ../Doc/howto/logging-cookbook.rst:1216 msgid "Customizing ``LogRecord``" -msgstr "" +msgstr "Personalización de ``LogRecord``" #: ../Doc/howto/logging-cookbook.rst:1218 msgid "" @@ -638,12 +945,22 @@ msgid "" "disabled). Before Python 3.2, there were only two places where this creation " "was done:" msgstr "" +"Cada evento logging está representado por una instancia :class:`LogRecord`. " +"Cuando se registra un evento y no se filtra por el nivel de un registrador, " +"se crea :class:`LogRecord`, se llena con información sobre el evento y luego " +"se pasa a los gestores de ese registrador (y sus antepasados, hasta (e " +"incluyéndolo) el registrador donde se deshabilita una mayor propagación en " +"la jerarquía). Antes de Python 3.2, solo había dos lugares donde se " +"realizaba esta creación:" #: ../Doc/howto/logging-cookbook.rst:1225 msgid "" ":meth:`Logger.makeRecord`, which is called in the normal process of logging " "an event. This invoked :class:`LogRecord` directly to create an instance." msgstr "" +":meth:`Logger.makeRecord`, que se llama en el proceso normal de logging de " +"un evento. Esto invoca :class:`LogRecord` directamente para crear una " +"instancia." #: ../Doc/howto/logging-cookbook.rst:1228 msgid "" @@ -653,12 +970,19 @@ msgid "" "via a :class:`~handlers.SocketHandler`, or in JSON form via an :class:" "`~handlers.HTTPHandler`)." msgstr "" +":func:`makeLogRecord`, que se llama con un diccionario que contiene " +"atributos que se agregarán al *LogRecord*. Esto se suele invocar cuando se " +"ha recibido un diccionario adecuado a través de la red (por ejemplo, en " +"forma de *pickle* a través de :class:`~handlers.SocketHandler`, o en formato " +"JSON a través de :class:`~handlers.HTTPHandler`)." #: ../Doc/howto/logging-cookbook.rst:1234 msgid "" "This has usually meant that if you need to do anything special with a :class:" "`LogRecord`, you've had to do one of the following." msgstr "" +"Por lo general, esto significa que si necesita hacer algo especial con :" +"class:`LogRecord`, debe hacer una de las siguientes cosas." #: ../Doc/howto/logging-cookbook.rst:1237 msgid "" @@ -666,6 +990,9 @@ msgid "" "makeRecord`, and set it using :func:`~logging.setLoggerClass` before any " "loggers that you care about are instantiated." msgstr "" +"Cree su propia subclase :class:`Logger`, que anula :meth:`Logger." +"makeRecord`, y configúrelo usando :func:`~logging.setLoggerClass` antes de " +"que se creen instancias de los registradores que le interesan." #: ../Doc/howto/logging-cookbook.rst:1240 msgid "" @@ -673,6 +1000,9 @@ msgid "" "special manipulation you need when its :meth:`~Filter.filter` method is " "called." msgstr "" +"Agrega un :class:`Filter` a un registrador o gestor, que realiza la " +"manipulación especial necesaria que necesita cuando se llama a su método :" +"meth:`~Filter.filter`." #: ../Doc/howto/logging-cookbook.rst:1244 msgid "" @@ -681,6 +1011,10 @@ msgid "" "attempt to set its own :class:`Logger` subclass, and the one which did this " "last would win." msgstr "" +"El primer enfoque sería un poco difícil de manejar en el escenario en el que " +"(digamos) varias bibliotecas diferentes quisieran hacer cosas diferentes. " +"Cada uno intentaría establecer su propia subclase :class:`Logger`, y el que " +"hiciera esto último ganaría." #: ../Doc/howto/logging-cookbook.rst:1249 msgid "" @@ -690,6 +1024,12 @@ msgid "" "to remember to do this every time they introduced a new logger (which they " "would do simply by adding new packages or modules and doing ::" msgstr "" +"El segundo enfoque funciona razonablemente bien en muchos casos, pero no le " +"permite, por ejemplo, usar una subclase especializada de :class:`LogRecord`. " +"Los desarrolladores de bibliotecas pueden establecer un filtro adecuado en " +"sus registradores, pero tendrían que recordar hacerlo cada vez que " +"introduzcan un nuevo registrador (lo que harían simplemente agregando nuevos " +"paquetes o módulos y haciendo ::" #: ../Doc/howto/logging-cookbook.rst:1257 msgid "" @@ -700,8 +1040,15 @@ msgid "" "so output from that handler would not reflect the intentions of the library " "developer." msgstr "" +"a nivel de módulo). Probablemente sean demasiadas cosas en las que pensar. " +"Los desarrolladores también podrían agregar el filtro a :class:`~logging." +"NullHandler` adjunto a su registrador de nivel superior, pero esto no se " +"invocaría si un desarrollador de aplicaciones adjuntara un controlador a un " +"registrador de biblioteca de nivel inferior --- así que la salida de ese " +"gestor no reflejaría las intenciones del desarrollador de la biblioteca." #: ../Doc/howto/logging-cookbook.rst:1263 +#, fuzzy msgid "" "In Python 3.2 and later, :class:`~logging.LogRecord` creation is done " "through a factory, which you can specify. The factory is just a callable you " @@ -710,6 +1057,12 @@ msgid "" "signature as the :class:`~logging.LogRecord` constructor, as :class:" "`LogRecord` is the default setting for the factory." msgstr "" +"En Python 3.2 y posterior, la creación :class:`~logging.LogRecord` se " +"realiza a través de una fábrica, que puede especificar. La fábrica es solo " +"un invocable que puede configurar con :func:`~logging.setLogRecordFactory`, " +"e interrogar con :func:`~logging.getLogRecordFactory`. La fábrica se invoca " +"con la misma firma que el constructor :class:`~logging.LogRecord`, ya que :" +"class:`LogRecord` es la configuración predeterminada de la fábrica." #: ../Doc/howto/logging-cookbook.rst:1270 msgid "" @@ -718,6 +1071,10 @@ msgid "" "additional attributes to the record once created, using a pattern similar to " "this::" msgstr "" +"Este enfoque permite que una fábrica personalizada controle todos los " +"aspectos de la creación de *LogRecord*. Por ejemplo, podría devolver una " +"subclase, o simplemente agregar algunos atributos adicionales al registro " +"una vez creado, usando un patrón similar a este::" #: ../Doc/howto/logging-cookbook.rst:1283 msgid "" @@ -728,10 +1085,17 @@ msgid "" "time overhead to all logging operations, and the technique should only be " "used when the use of a :class:`Filter` does not provide the desired result." msgstr "" +"Este patrón permite que diferentes bibliotecas encadenen fábricas juntas, y " +"siempre que no sobrescriban los atributos de las demás o sobrescriban " +"involuntariamente los atributos proporcionados como estándar, no debería " +"haber sorpresas. Sin embargo, debe tenerse en cuenta que cada eslabón de la " +"cadena agrega una sobrecarga de tiempo de ejecución a todas las operaciones " +"de logging, y la técnica solo debe usarse cuando el uso de :class:`Filter` " +"no proporciona el resultado deseado." #: ../Doc/howto/logging-cookbook.rst:1294 msgid "Subclassing QueueHandler - a ZeroMQ example" -msgstr "" +msgstr "Subclasificación QueueHandler - un ejemplo de ZeroMQ" #: ../Doc/howto/logging-cookbook.rst:1296 msgid "" @@ -739,58 +1103,67 @@ msgid "" "of queues, for example a ZeroMQ 'publish' socket. In the example below,the " "socket is created separately and passed to the handler (as its 'queue')::" msgstr "" +"Puede usar una subclase :class:`QueueHandler` para enviar mensajes a otros " +"tipos de colas, por ejemplo, un socket de 'publicación' ZeroMQ. En el " +"siguiente ejemplo, el socket se crea por separado y se pasa al gestor (como " +"su 'cola')::" #: ../Doc/howto/logging-cookbook.rst:1315 msgid "" "Of course there are other ways of organizing this, for example passing in " "the data needed by the handler to create the socket::" msgstr "" +"Por supuesto, hay otras formas de organizar esto, por ejemplo, pasando los " +"datos que necesita el gestor para crear el socket::" #: ../Doc/howto/logging-cookbook.rst:1333 msgid "Subclassing QueueListener - a ZeroMQ example" -msgstr "" +msgstr "Subclasificación QueueListener - un ejemplo de ZeroMQ" #: ../Doc/howto/logging-cookbook.rst:1335 msgid "" "You can also subclass :class:`QueueListener` to get messages from other " "kinds of queues, for example a ZeroMQ 'subscribe' socket. Here's an example::" msgstr "" +"También puede subclasificar :class:`QueueListener` para obtener mensajes de " +"otros tipos de colas, por ejemplo, un socket de 'suscripción' de ZeroMQ. " +"Aquí tienes un ejemplo::" #: ../Doc/howto/logging-cookbook.rst:1354 msgid "Module :mod:`logging`" -msgstr "" +msgstr "Módulo :mod:`logging`" #: ../Doc/howto/logging-cookbook.rst:1354 msgid "API reference for the logging module." -msgstr "" +msgstr "Referencia de API para el módulo logging." #: ../Doc/howto/logging-cookbook.rst:1357 msgid "Module :mod:`logging.config`" -msgstr "" +msgstr "Módulo :mod:`logging.config`" #: ../Doc/howto/logging-cookbook.rst:1357 msgid "Configuration API for the logging module." -msgstr "" +msgstr "API de configuración para el módulo logging." #: ../Doc/howto/logging-cookbook.rst:1360 msgid "Module :mod:`logging.handlers`" -msgstr "" +msgstr "Módulo :mod:`logging.handlers`" #: ../Doc/howto/logging-cookbook.rst:1360 msgid "Useful handlers included with the logging module." -msgstr "" +msgstr "Gestores útiles incluidos con el módulo logging." #: ../Doc/howto/logging-cookbook.rst:1362 msgid ":ref:`A basic logging tutorial `" -msgstr "" +msgstr ":ref:`Un tutorial básico de logging `" #: ../Doc/howto/logging-cookbook.rst:1364 msgid ":ref:`A more advanced logging tutorial `" -msgstr "" +msgstr ":ref:`Un tutorial de logging más avanzado `" #: ../Doc/howto/logging-cookbook.rst:1368 msgid "An example dictionary-based configuration" -msgstr "" +msgstr "Una configuración de ejemplo basada en diccionario" #: ../Doc/howto/logging-cookbook.rst:1370 msgid "" @@ -799,6 +1172,11 @@ msgid "" "stable/topics/logging/#configuring-logging>`_. This dictionary is passed to :" "func:`~config.dictConfig` to put the configuration into effect::" msgstr "" +"A continuación se muestra un ejemplo de un diccionario de configuración de " +"logging, tomado de la `documentación del proyecto Django `_. Este " +"diccionario se pasa a :func:`~config.dictConfig` para poner en efecto la " +"configuración::" #: ../Doc/howto/logging-cookbook.rst:1426 msgid "" @@ -806,16 +1184,24 @@ msgid "" "section `_ of the Django documentation." msgstr "" +"Para obtener más información sobre esta configuración, puede ver la `sección " +"correspondiente `_ de la documentación de Django." #: ../Doc/howto/logging-cookbook.rst:1433 msgid "Using a rotator and namer to customize log rotation processing" msgstr "" +"Usar un rotador y un nombre para personalizar el procesamiento de rotación " +"de log" #: ../Doc/howto/logging-cookbook.rst:1435 msgid "" "An example of how you can define a namer and rotator is given in the " "following snippet, which shows zlib-based compression of the log file::" msgstr "" +"Un ejemplo de cómo puede definir un nombre y un rotador se da en el " +"siguiente fragmento, que muestra la compresión basada en zlib del archivo de " +"log::" #: ../Doc/howto/logging-cookbook.rst:1453 msgid "" @@ -823,10 +1209,13 @@ msgid "" "\"container\" such as you’d find in an actual gzip file. This snippet is " "just for illustration purposes." msgstr "" +"Estos no son archivos .gz \"verdaderos\", ya que son datos comprimidos sin " +"ningún \"contenedor\" como el que encontraría en un archivo gzip real. Este " +"fragmento es solo para fines ilustrativos." #: ../Doc/howto/logging-cookbook.rst:1458 msgid "A more elaborate multiprocessing example" -msgstr "" +msgstr "Un ejemplo de multiprocesamiento más elaborado" #: ../Doc/howto/logging-cookbook.rst:1460 msgid "" @@ -835,8 +1224,14 @@ msgid "" "simple, but serve to illustrate how more complex ones could be implemented " "in a real multiprocessing scenario." msgstr "" +"El siguiente ejemplo de trabajo muestra cómo logging se puede usar con " +"multiprocesamiento usando archivos de configuración. Las configuraciones son " +"bastante simples, pero sirven para ilustrar cómo se podrían implementar las " +"más complejas en un escenario real de multiprocesamiento." +# En algunas lineas anteriores me pasa lo mismo. No sé muy bien qué significa y cómo traducir "listener process" y "worker processes". Separé en varias oraciones para que sea más fluida la lectura. #: ../Doc/howto/logging-cookbook.rst:1465 +#, fuzzy msgid "" "In the example, the main process spawns a listener process and some worker " "processes. Each of the main process, the listener and the workers have three " @@ -848,16 +1243,28 @@ msgid "" "purely illustrative, but you should be able to adapt this example to your " "own scenario." msgstr "" +"En el ejemplo, el proceso principal genera un proceso de escucha y algunos " +"procesos de trabajo. Cada uno de los procesos principales, el oyente y los " +"de trabajo tienen tres configuraciones separadas (todos los de trabajo " +"comparten la misma configuración). Podemos ver el logging en el proceso " +"principal, cómo los de trabajo inician sesión en un QueueHandler y cómo el " +"oyente implementa un QueueListener. Este último con una configuración de " +"logging más compleja, organiza el envío de eventos recibidos a través de la " +"cola a los gestores especificados en la configuración. Tenga en cuenta que " +"estas configuraciones son puramente ilustrativas, pero usted debe ser capaz " +"de adaptar este ejemplo a su propio escenario." #: ../Doc/howto/logging-cookbook.rst:1475 msgid "" "Here's the script - the docstrings and the comments hopefully explain how it " "works::" msgstr "" +"Aquí está el script, el docstrings y los comentarios, esperemos, expliquen " +"cómo funciona::" #: ../Doc/howto/logging-cookbook.rst:1687 msgid "Inserting a BOM into messages sent to a SysLogHandler" -msgstr "" +msgstr "Insertar BOM en mensajes enviados a SysLogHandler" #: ../Doc/howto/logging-cookbook.rst:1689 msgid "" @@ -867,6 +1274,11 @@ msgid "" "encoded using UTF-8. (See the :rfc:`relevant section of the specification " "<5424#section-6>`.)" msgstr "" +":rfc:`5424` requiere que se envíe un mensaje Unicode a un demonio syslog " +"como un conjunto de bytes que tienen la siguiente estructura: un componente " +"opcional puro-ASCII, seguido de una Marca de Orden de Bytes UTF-8 (*BOM* por " +"sus siglas en inglés), seguida de codificado en Unicode usando UTF-8. (See " +"the :rfc:`relevant section of the specification <5424#section-6>`.)" #: ../Doc/howto/logging-cookbook.rst:1695 msgid "" @@ -875,6 +1287,10 @@ msgid "" "incorrectly, with the BOM appearing at the beginning of the message and " "hence not allowing any pure-ASCII component to appear before it." msgstr "" +"En Python 3.1, se agregó código a :class:`~logging.handlers.SysLogHandler` " +"para insertar BOM en el mensaje, pero desafortunadamente, se implementó " +"incorrectamente, BOM aparece al principio del mensaje y, por lo tanto, no " +"permite ningún componente ASCII puro para que aparezca antes." #: ../Doc/howto/logging-cookbook.rst:1701 msgid "" @@ -884,18 +1300,29 @@ msgid "" "an optional pure-ASCII sequence before it and arbitrary Unicode after it, " "encoded using UTF-8, then you need to do the following:" msgstr "" +"Como este comportamiento no funciona, el código de inserción BOM incorrecto " +"se elimina de Python 3.2.4 y versiones posteriores. Sin embargo, no se está " +"reemplazando, y si desea producir mensajes compatibles con :rfc:`5424` que " +"incluyan BOM, una secuencia opcional de ASCII puro antes y Unicode " +"arbitrario después, codificados usando UTF-8; entonces necesita hacer lo " +"siguiente:" #: ../Doc/howto/logging-cookbook.rst:1707 msgid "" "Attach a :class:`~logging.Formatter` instance to your :class:`~logging." "handlers.SysLogHandler` instance, with a format string such as::" msgstr "" +"Adjunte una instancia de :class:`~logging.Formatter` a su instancia :class:" +"`~logging.handlers.SysLogHandler`, con una cadena de caracteres de formato " +"como::" #: ../Doc/howto/logging-cookbook.rst:1713 msgid "" "The Unicode code point U+FEFF, when encoded using UTF-8, will be encoded as " "a UTF-8 BOM -- the byte-string ``b'\\xef\\xbb\\xbf'``." msgstr "" +"El punto de código Unicode U+ FEFF, cuando se codifica usando UTF-8, se " +"codificará como una BOM UTF-8, la cadena de bytes ``b'\\xef\\xbb\\xbf'``." #: ../Doc/howto/logging-cookbook.rst:1716 msgid "" @@ -903,6 +1330,10 @@ msgid "" "that the data that appears in there after substitution is always ASCII (that " "way, it will remain unchanged after UTF-8 encoding)." msgstr "" +"Reemplace la sección ASCII con los marcadores de posición que desee, pero " +"asegúrese de que los datos que aparecen allí después de la sustitución sean " +"siempre ASCII (de esa manera, permanecerán sin cambios después de la " +"codificación UTF-8)." #: ../Doc/howto/logging-cookbook.rst:1720 msgid "" @@ -910,6 +1341,9 @@ msgid "" "which appears there after substitution contains characters outside the ASCII " "range, that's fine -- it will be encoded using UTF-8." msgstr "" +"Reemplace la sección Unicode con los marcadores de posición que desee; si " +"los datos que aparecen allí después de la sustitución contienen caracteres " +"fuera del rango ASCII, está bien: se codificarán usando UTF-8." #: ../Doc/howto/logging-cookbook.rst:1724 msgid "" @@ -919,12 +1353,19 @@ msgid "" "complain, but your messages will not be RFC 5424-compliant, and your syslog " "daemon may complain." msgstr "" +"El mensaje formateado *se* codificará utilizando la codificación UTF-8 por " +"``SysLogHandler``. Si sigue las reglas anteriores, debería poder producir " +"mensajes compatibles con :rfc:`5424`. Si no lo hace, es posible que el " +"logging no se queje, pero sus mensajes no serán compatibles con RFC 5424 y " +"su demonio syslog puede quejarse." #: ../Doc/howto/logging-cookbook.rst:1731 msgid "Implementing structured logging" -msgstr "" +msgstr "Implementar logging estructurado" +# Me quedan dudas con la frase final: "analizable por computadora" #: ../Doc/howto/logging-cookbook.rst:1733 +#, fuzzy msgid "" "Although most logging messages are intended for reading by humans, and thus " "not readily machine-parseable, there might be circumstances where you want " @@ -935,10 +1376,18 @@ msgid "" "following is a simple approach which uses JSON to serialise the event in a " "machine-parseable manner::" msgstr "" +"Aunque la mayoría de los mensajes de logging están destinados a ser leídos " +"por humanos y, por lo tanto, no se pueden analizar fácilmente mediante una " +"máquina, puede haber circunstancias en las que desee generar mensajes en un " +"formato estructurado que *sea* capaz de ser analizado por un programa (sin " +"necesidad de expresiones regulares complejas para analizar el mensaje de " +"log). Esto es sencillo de lograr utilizando el paquete logging. Hay varias " +"formas de lograr esto, pero el siguiente es un enfoque simple que usa JSON " +"para serializar el evento de una manera analizable por computadora:" #: ../Doc/howto/logging-cookbook.rst:1757 msgid "If the above script is run, it prints:" -msgstr "" +msgstr "Si se ejecuta el script anterior, se imprime:" #: ../Doc/howto/logging-cookbook.rst:1763 #: ../Doc/howto/logging-cookbook.rst:1812 @@ -946,20 +1395,24 @@ msgid "" "Note that the order of items might be different according to the version of " "Python used." msgstr "" +"Tenga en cuenta que el orden de los elementos puede ser diferente según la " +"versión de Python utilizada." #: ../Doc/howto/logging-cookbook.rst:1766 msgid "" "If you need more specialised processing, you can use a custom JSON encoder, " "as in the following complete example::" msgstr "" +"Si necesita un procesamiento más especializado, puede utilizar un " +"codificador JSON personalizado, como en el siguiente ejemplo completo::" #: ../Doc/howto/logging-cookbook.rst:1806 msgid "When the above script is run, it prints:" -msgstr "" +msgstr "Cuando se ejecuta el script anterior, se imprime:" #: ../Doc/howto/logging-cookbook.rst:1821 msgid "Customizing handlers with :func:`dictConfig`" -msgstr "" +msgstr "Personalización de gestores con :func:`dictConfig`" #: ../Doc/howto/logging-cookbook.rst:1823 msgid "" @@ -970,12 +1423,21 @@ msgid "" "the file handlers in the stdlib don't offer built-in support. You can " "customize handler creation using a plain function such as::" msgstr "" +"Hay ocasiones en las que desea personalizar los gestores de logging de " +"formas particulares, y si usa :func:`dictConfig` puede hacerlo sin " +"subclases. Como ejemplo, considere que es posible que desee establecer la " +"propiedad de un archivo de log. En POSIX, esto se hace fácilmente usando :" +"func:`shutil.chown`, pero los gestores de archivos en stdlib no ofrecen " +"soporte integrado. Puede personalizar la creación de gestores usando una " +"función simple como::" #: ../Doc/howto/logging-cookbook.rst:1837 msgid "" "You can then specify, in a logging configuration passed to :func:" "`dictConfig`, that a logging handler be created by calling this function::" msgstr "" +"Luego puede especificar, en una configuración de logging pasada a :func:" +"`dictConfig`, que se cree un gestor de logging llamando a esta función::" #: ../Doc/howto/logging-cookbook.rst:1870 msgid "" @@ -983,10 +1445,14 @@ msgid "" "group, just for the purposes of illustration. Putting it together into a " "working script, ``chowntest.py``::" msgstr "" +"En este ejemplo, se establece la propiedad utilizando el usuario y el grupo " +"``pulse``, solo con fines ilustrativos. Poniéndolo junto en un script de " +"trabajo, ``chowntest.py``::" #: ../Doc/howto/logging-cookbook.rst:1917 msgid "To run this, you will probably need to run as ``root``:" msgstr "" +"Para ejecutar esto, probablemente se necesite ejecutarlo como ``root``:" #: ../Doc/howto/logging-cookbook.rst:1927 msgid "" @@ -996,16 +1462,24 @@ msgid "" "With pre-3.3 versions, you would need to implement the actual ownership " "change using e.g. :func:`os.chown`." msgstr "" +"Tenga en cuenta que este ejemplo usa Python 3.3 porque ahí es donde :func:" +"`shutil.chown` aparece. Este enfoque debería funcionar con cualquier versión " +"de Python que admita :func:`dictConfig`, es decir, Python 2.7, 3.2 o " +"posterior. Con las versiones anteriores a 3.3, necesitaría implementar el " +"cambio de propiedad real usando, por ejemplo, :func:`os.chown`." #: ../Doc/howto/logging-cookbook.rst:1933 msgid "" "In practice, the handler-creating function may be in a utility module " "somewhere in your project. Instead of the line in the configuration::" msgstr "" +"En la práctica, la función de creación de gestores puede estar en un módulo " +"de utilidad en algún lugar de su proyecto. En lugar de la línea en la " +"configuración::" #: ../Doc/howto/logging-cookbook.rst:1938 msgid "you could use e.g.::" -msgstr "" +msgstr "podrías usar, por ejemplo,::" #: ../Doc/howto/logging-cookbook.rst:1942 msgid "" @@ -1014,6 +1488,11 @@ msgid "" "__main__.owned_file_handler'`` should work. Here, the actual callable is " "resolved by :func:`dictConfig` from the ``ext://`` specification." msgstr "" +"donde ``project.util`` se puede reemplazar con el nombre real del paquete " +"donde reside la función. En el script de trabajo anterior, el uso de " +"``'ext://__main__.owned_file_handler'`` debería funcionar. Aquí, el " +"invocable real se resuelve mediante :func:`dictConfig` de la especificación " +"``ext://``." #: ../Doc/howto/logging-cookbook.rst:1947 msgid "" @@ -1021,6 +1500,9 @@ msgid "" "types of file change - e.g. setting specific POSIX permission bits - in the " "same way, using :func:`os.chmod`." msgstr "" +"Por furtuna, este ejemplo también indica el camino hacia cómo podría " +"implementar otros tipos de cambio de archivo, por ejemplo, configurando de " +"la misma manera bits de permisos POSIX específicos, usando :func:`os.chmod`." #: ../Doc/howto/logging-cookbook.rst:1951 msgid "" @@ -1028,10 +1510,13 @@ msgid "" "than a :class:`~logging.FileHandler` - for example, one of the rotating file " "handlers, or a different type of handler altogether." msgstr "" +"Por supuesto, el enfoque también podría extenderse a tipos de gestores " +"distintos a :class:`~logging.FileHandler` - por ejemplo, uno de los gestores " +"de archivos rotativos, o un tipo diferente por completo." #: ../Doc/howto/logging-cookbook.rst:1961 msgid "Using particular formatting styles throughout your application" -msgstr "" +msgstr "Usar estilos de formato particulares en toda su aplicación" #: ../Doc/howto/logging-cookbook.rst:1963 msgid "" @@ -1043,9 +1528,15 @@ msgid "" "to logs, and is completely orthogonal to how an individual logging message " "is constructed." msgstr "" +"En Python 3.2, :class:`~logging.Formatter` obtuvo un parámetro de palabra " +"clave ``estilo`` que, aunque por defecto era ``%`` para compatibilidad con " +"versiones anteriores, permitía la especificación de ``{`` o ``$`` para " +"permitir los enfoques de formato admitidos por :meth:`str.format` y :class:" +"`string.Template`. Tenga en cuenta que esto rige el formato de los mensajes " +"de logging para la salida final a los logging y es completamente ortogonal a " +"cómo se construye un mensaje de logging individual." #: ../Doc/howto/logging-cookbook.rst:1970 -#, python-format msgid "" "Logging calls (:meth:`~Logger.debug`, :meth:`~Logger.info` etc.) only take " "positional parameters for the actual logging message itself, with keyword " @@ -1059,15 +1550,31 @@ msgid "" "changing this while preserving backward compatibility, since all logging " "calls which are out there in existing code will be using %-format strings." msgstr "" +"Las llamadas de logging (:meth:`~Logger.debug`, :meth:`~Logger.info`, etc.) " +"solo toman parámetros posicionales para el mensaje logging real en sí, con " +"parámetros de palabras clave que se utilizan solo para determinar las " +"opciones sobre cómo manejar la llamada de logging (por ejemplo, el parámetro " +"de palabra clave ``exc_info`` para indicar que la información de rastreo " +"debe registrarse, o el parámetro de palabra clave ``extra`` para indicar " +"información contextual adicional que se agregará al log). Por lo tanto, no " +"puede realizar llamadas de logging directamente usando la sintaxis :meth:" +"`str.format` o :class:`string.Template`, porque internamente el paquete " +"logging usa formato % para fusionar la cadena de formato y los argumentos de " +"las variables. No se cambiaría esto mientras se conserve la compatibilidad " +"con versiones anteriores, ya que todas las llamadas de logging que están en " +"el código existente utilizarán cadenas de caracteres formato %." #: ../Doc/howto/logging-cookbook.rst:1982 -#, python-format msgid "" "There have been suggestions to associate format styles with specific " "loggers, but that approach also runs into backward compatibility problems " -"because any existing code could be using a given logger name and using " -"%-formatting." +"because any existing code could be using a given logger name and using %-" +"formatting." msgstr "" +"Ha habido sugerencias para asociar estilos de formato con *loggers* " +"específicos, pero ese enfoque también tiene problemas de compatibilidad con " +"versiones anteriores porque cualquier código existente podría estar usando " +"un nombre de *logger* dado y usando formato %." #: ../Doc/howto/logging-cookbook.rst:1986 msgid "" @@ -1076,13 +1583,16 @@ msgid "" "individual logging call. This opens up a couple of ways in which alternative " "formatting styles can be accommodated." msgstr "" +"Para que logging funcione de manera interoperable entre cualquier biblioteca " +"de terceros y su código, las decisiones sobre el formato deben tomarse a " +"nivel de la llamada de logging individual. Esto abre un par de formas en las " +"que se pueden acomodar estilos de formato alternativos." #: ../Doc/howto/logging-cookbook.rst:1993 msgid "Using LogRecord factories" -msgstr "" +msgstr "Uso de fábricas de LogRecord" #: ../Doc/howto/logging-cookbook.rst:1995 -#, python-format msgid "" "In Python 3.2, along with the :class:`~logging.Formatter` changes mentioned " "above, the logging package gained the ability to allow users to set their " @@ -1096,16 +1606,30 @@ msgid "" "code. Care should also be taken to call ``str(self.msg)``, just as the base " "implementation does." msgstr "" +"En Python 3.2, junto con los cambios de :class:`~logging.Formatter` " +"mencionados anteriormente, el paquete logging ganó la capacidad de permitir " +"a los usuarios establecer sus propias subclases :class:`LogRecord`, usando " +"la función :func:`setLogRecordFactory`. Puede usar esto para configurar su " +"propia subclase de :class:`LogRecord`, que hace lo correcto al anular el " +"método :meth:`~LogRecord.getMessage`. La implementación de la clase base de " +"este método es donde ocurre el formato ``msg % args`` y donde puede " +"sustituir su formato alternativo; sin embargo, debe tener cuidado de admitir " +"todos los estilos de formato y permitir formato % como predeterminado, para " +"garantizar la interoperabilidad con otro código. También se debe tener " +"cuidado de llamar a ``str(self.msg)``, tal como lo hace la implementación " +"base." #: ../Doc/howto/logging-cookbook.rst:2006 msgid "" "Refer to the reference documentation on :func:`setLogRecordFactory` and :" "class:`LogRecord` for more information." msgstr "" +"Consulte la documentación de referencia en :func:`setLogRecordFactory` y :" +"class:`LogRecord` para obtener más información." #: ../Doc/howto/logging-cookbook.rst:2011 msgid "Using custom message objects" -msgstr "" +msgstr "Usar objetos de mensaje personalizados" #: ../Doc/howto/logging-cookbook.rst:2013 msgid "" @@ -1116,9 +1640,15 @@ msgid "" "func:`str` on that object to get the actual format string. Consider the " "following two classes::" msgstr "" +"Existe otra forma, quizás más sencilla, de usar el formato {} - y $ - para " +"construir sus mensajes de log individuales. Al iniciar sesión, recuerde que " +"puede usar cualquier objeto como una cadena de caracteres de formato de " +"mensaje (:ref:`arbitrary-object-messages`) que al iniciar sesión puede usar " +"un objeto arbitrario como una cadena de formato de mensaje, y que el paquete " +"de logging llamará :func:`str` en ese objeto para obtener el cadena de " +"formato real. Considere las siguientes dos clases:" #: ../Doc/howto/logging-cookbook.rst:2038 -#, python-format msgid "" "Either of these can be used in place of a format string, to allow {}- or $-" "formatting to be used to build the actual \"message\" part which appears in " @@ -1128,16 +1658,25 @@ msgid "" "alias such as ``M`` or ``_`` for the message (or perhaps ``__``, if you are " "using ``_`` for localization)." msgstr "" +"Cualquiera de estos puede usarse en lugar de una cadena de formato, para " +"permitir que se use el formato {} - o $ - para construir la parte del " +"\"mensaje\" real que aparece en la salida del log formateado en lugar de " +"“%(message)s” or “{message}” or “$message”. Si le resulta un poco difícil de " +"manejar usar los nombres de las clases cada vez que desea registrar algo, " +"puede hacerlo más tolerable si usa un alias como ``M`` o ``_`` para el " +"mensaje (o quizás ``__``, si está utilizando``_`` para localización)." #: ../Doc/howto/logging-cookbook.rst:2046 msgid "" "Examples of this approach are given below. Firstly, formatting with :meth:" "`str.format`::" msgstr "" +"A continuación se dan ejemplos de este enfoque. En primer lugar, formatear " +"con :meth:`str.format`::" #: ../Doc/howto/logging-cookbook.rst:2060 msgid "Secondly, formatting with :class:`string.Template`::" -msgstr "" +msgstr "En segundo lugar, formatear con :class:`string.Template`::" #: ../Doc/howto/logging-cookbook.rst:2067 msgid "" @@ -1150,10 +1689,19 @@ msgid "" "sugar for a constructor call to one of the ``XXXMessage`` classes shown " "above." msgstr "" +"Una cosa a tener en cuenta es que no paga ninguna penalización significativa " +"del rendimiento con este enfoque: el formato real no se produce cuando se " +"realiza la llamada logging, sino cuando (y si) el mensaje registrado está " +"realmente a punto de ser salida a un log por un gestor. Así que lo único un " +"poco inusual con lo que podría tropezar es que los paréntesis van alrededor " +"de la cadena de caracteres de formato y los argumentos, no sólo la cadena de " +"formato. Esto se debe a que la notación __ es solo azúcar sintáctico para " +"una llamada de constructor a una de las clases ``XXXMessage`` mostradas " +"anteriormente." #: ../Doc/howto/logging-cookbook.rst:2081 msgid "Configuring filters with :func:`dictConfig`" -msgstr "" +msgstr "Configurar filtros con :func:`dictConfig`" #: ../Doc/howto/logging-cookbook.rst:2083 msgid "" @@ -1169,6 +1717,17 @@ msgid "" "callable which returns a :class:`~logging.Filter` instance). Here is a " "complete example::" msgstr "" +"*Puedes* configurar filtros usando :func:`~logging.config.dictConfig`, " +"aunque a primera vista es posible que no sea obvio cómo hacerlo (de ahí esta " +"receta). Dado que :class:`~logging.Filter` es la única clase de filtro " +"incluida en la biblioteca estándar, y es poco probable que satisfaga muchos " +"requisitos (solo está allí como clase base), normalmente necesitarás definir " +"tu propia subclase :class:`~logging.Filter` con un método :meth:`~logging." +"Filter.filter` sobreescrito. Para hacer esto, especifique la clave ``()`` en " +"el diccionario de configuración para el filtro, especificando un invocable " +"que se usará para crear el filtro (una clase es la más obvia, pero puede " +"proporcionar cualquier invocable que devuelva una instancia :class:`~logging." +"Filter`). Aquí hay un ejemplo completo:" #: ../Doc/howto/logging-cookbook.rst:2136 msgid "" @@ -1176,14 +1735,17 @@ msgid "" "constructs the instance, in the form of keyword parameters. When run, the " "above script will print:" msgstr "" +"Este ejemplo muestra cómo puede pasar datos de configuración al invocable " +"que construye la instancia, en forma de parámetros de palabras clave. Cuando " +"se ejecuta, se imprimirá el script anterior:" #: ../Doc/howto/logging-cookbook.rst:2144 msgid "which shows that the filter is working as configured." -msgstr "" +msgstr "que muestra que el filtro está funcionando según lo configurado." #: ../Doc/howto/logging-cookbook.rst:2146 msgid "A couple of extra points to note:" -msgstr "" +msgstr "Un par de puntos adicionales a tener en cuenta:" #: ../Doc/howto/logging-cookbook.rst:2148 msgid "" @@ -1194,6 +1756,12 @@ msgid "" "have used the text ``'ext://__main__.MyFilter'`` instead of ``MyFilter`` in " "the above example." msgstr "" +"Si no puede hacer referencia al invocable directamente en la configuración " +"(por ejemplo, si vive en un módulo diferente y no puede importarlo " +"directamente donde está el diccionario de configuración), puede usar el " +"formulario ``ext://...`` como se describe en :ref:`logging-config-dict-" +"externalobj`. Por ejemplo, podría haber usado el texto ``'ext://__main__." +"MyFilter'`` en lugar de ``MyFilter`` en el ejemplo anterior." #: ../Doc/howto/logging-cookbook.rst:2155 msgid "" @@ -1203,10 +1771,15 @@ msgid "" "configuration, and see the other cookbook recipe :ref:`custom-handlers` " "above." msgstr "" +"Además de los filtros, esta técnica también se puede utilizar para " +"configurar gestores y formateadores personalizados. Consultar :ref:`logging-" +"config-dict-userdef` para obtener más información sobre cómo logging admite " +"el uso de objetos definidos por el usuario en su configuración, y ver arriba " +"la otra receta :ref:`custom-handlers`." #: ../Doc/howto/logging-cookbook.rst:2164 msgid "Customized exception formatting" -msgstr "" +msgstr "Formato de excepción personalizado" #: ../Doc/howto/logging-cookbook.rst:2166 msgid "" @@ -1215,10 +1788,15 @@ msgid "" "even when exception information is present. You can do this with a custom " "formatter class, as shown in the following example::" msgstr "" +"Puede haber ocasiones en las que desee personalizar un formato de excepción; " +"por el bien del argumento, digamos que desea exactamente una línea por " +"evento registrado, incluso cuando la información de la excepción está " +"presente. Puede hacer esto con una clase de formateador personalizada, como " +"se muestra en el siguiente ejemplo::" #: ../Doc/howto/logging-cookbook.rst:2207 msgid "When run, this produces a file with exactly two lines:" -msgstr "" +msgstr "Cuando se ejecuta, esto produce un archivo con exactamente dos líneas:" #: ../Doc/howto/logging-cookbook.rst:2214 msgid "" @@ -1226,10 +1804,13 @@ msgid "" "information can be formatted to your liking. The :mod:`traceback` module may " "be helpful for more specialized needs." msgstr "" +"Si bien el tratamiento anterior es simplista, señala el camino hacia cómo se " +"puede formatear la información de excepción a su gusto. El módulo :mod:" +"`traceback` puede resultar útil para necesidades más especializadas." #: ../Doc/howto/logging-cookbook.rst:2221 msgid "Speaking logging messages" -msgstr "" +msgstr "Mensajes de logging hablantes" #: ../Doc/howto/logging-cookbook.rst:2223 msgid "" @@ -1247,12 +1828,29 @@ msgid "" "other handlers to be kept waiting. Here is a short example showing the " "approach, which assumes that the ``espeak`` TTS package is available::" msgstr "" +"Puede haber situaciones en las que sea deseable que los mensajes de logging " +"se presenten en un formato audible en lugar de visible. Esto es fácil de " +"hacer si tiene la funcionalidad de texto a voz (*TTS* por sus siglas en " +"inglés) disponible en su sistema, incluso si no tiene un *binding* Python. " +"La mayoría de los sistemas TTS tienen un programa de línea de comandos que " +"puede ejecutar, y esto puede invocarse desde un gestor usando :mod:" +"`subprocess`. Aquí se asume que los programas de línea de comando TTS no " +"esperarán interactuar con los usuarios o tardarán mucho en completarse, y " +"que la frecuencia de los mensajes registrados no será tan alta como para " +"inundar al usuario con mensajes, y que es aceptable que los mensajes se " +"reproducen uno a la vez en lugar de todos al mismo tiempo. La implementación " +"de ejemplo a continuación espera a que se pronuncie un mensaje antes de que " +"se procese el siguiente, y esto puede hacer que otros gestores se mantengan " +"esperando. Aquí hay un breve ejemplo que muestra el enfoque, que asume que " +"el paquete TTS ``espeak`` está disponible::" #: ../Doc/howto/logging-cookbook.rst:2265 msgid "" "When run, this script should say \"Hello\" and then \"Goodbye\" in a female " "voice." msgstr "" +"Cuando se ejecute, este script debería decir \"Hola\" y luego \"Adiós\" con " +"voz femenina." #: ../Doc/howto/logging-cookbook.rst:2267 msgid "" @@ -1260,10 +1858,13 @@ msgid "" "other systems altogether which can process messages via external programs " "run from a command line." msgstr "" +"El enfoque anterior puede, por supuesto, adaptarse a otros sistemas TTS e " +"incluso a otros sistemas que pueden procesar mensajes a través de programas " +"externos ejecutados desde una línea de comando." #: ../Doc/howto/logging-cookbook.rst:2275 msgid "Buffering logging messages and outputting them conditionally" -msgstr "" +msgstr "Almacenamiento en búfer de mensajes de logging y su salida condicional" #: ../Doc/howto/logging-cookbook.rst:2277 msgid "" @@ -1274,6 +1875,12 @@ msgid "" "collected debug information, but if there is an error, you want all the " "debug information to be output as well as the error." msgstr "" +"Puede haber situaciones en las que desee registrar mensajes en un área " +"temporal y solo mostrarlos si se produce una determinada condición. Por " +"ejemplo, es posible que desee comenzar a registrar eventos de depuración en " +"una función, y si la función se completa sin errores, no desea saturar el " +"log con la información de depuración recopilada; pero si hay un error, desea " +"toda la información de depuración información así como el error." #: ../Doc/howto/logging-cookbook.rst:2284 msgid "" @@ -1287,6 +1894,16 @@ msgid "" "specified threshold is seen. You can use this recipe with a more specialised " "subclass of ``MemoryHandler`` if you want custom flushing behavior." msgstr "" +"Aquí hay un ejemplo que muestra cómo puede hacer esto usando un decorador " +"para sus funciones donde desea que el logging se comporte de esta manera. " +"Hace uso de :class:`logging.handlers.MemoryHandler`, que permite el " +"almacenamiento en búfer de eventos registrados hasta que se produzca alguna " +"condición, momento en el que los eventos almacenados en búfer se ``flushed`` " +"y se pasan a otro gestor (el gestor ``target``) para su procesamiento. De " +"forma predeterminada, el ``MemoryHandler`` se vacía cuando su búfer se llena " +"o se ve un evento cuyo nivel es mayor o igual a un umbral especificado. " +"Puede usar esta receta con una subclase más especializada de " +"``MemoryHandler`` si desea un comportamiento de descarga personalizado." #: ../Doc/howto/logging-cookbook.rst:2294 msgid "" @@ -1296,6 +1913,12 @@ msgid "" "pass a parameter to ``foo`` which, if true, will log at ERROR and CRITICAL " "levels - otherwise, it only logs at DEBUG, INFO and WARNING levels." msgstr "" +"El script de ejemplo tiene una función simple, ``foo``, que recorre todos " +"los niveles de logging, escribiendo en ``sys.stderr`` para decir en qué " +"nivel está a punto de *loguear* y luego registrar un mensaje en ese nivel. " +"Puede pasar un parámetro a ``foo`` que, si es verdadero, se registrará en " +"los niveles ERROR y CRITICAL; de lo contrario, solo registrará en los " +"niveles DEBUG, INFO y WARNING." #: ../Doc/howto/logging-cookbook.rst:2300 msgid "" @@ -1308,14 +1931,23 @@ msgid "" "StreamHandler` which writes to ``sys.stderr``, ``logging.ERROR`` and ``100`` " "respectively." msgstr "" +"El script simplemente dispone decorar ``foo`` con un decorador que hará el " +"logging condicional que se requiere. El decorador toma un registrador como " +"parámetro y adjunta un gestor de memoria durante la duración de la llamada a " +"la función decorada. El decorador se puede parametrizar adicionalmente " +"utilizando un gestor *target*, un nivel en el que debe producirse el vaciado " +"y una capacidad para el búfer (número de registros almacenados en búfer). " +"Estos están predeterminados a :class:`~logging.StreamHandler` que escribe " +"en``sys.stderr``, ``logging.ERROR`` y ``100`` respectivamente." #: ../Doc/howto/logging-cookbook.rst:2308 msgid "Here's the script::" -msgstr "" +msgstr "Aquí está el script::" #: ../Doc/howto/logging-cookbook.rst:2371 msgid "When this script is run, the following output should be observed:" msgstr "" +"Cuando se ejecuta este script, se debe observar el siguiente resultado::" #: ../Doc/howto/logging-cookbook.rst:2401 msgid "" @@ -1323,20 +1955,25 @@ msgid "" "whose severity is ERROR or greater, but in that case, any previous events at " "lower severities are also logged." msgstr "" +"Como puede ver, la salida real de logging solo ocurre cuando se registra un " +"evento cuya gravedad es ERROR o mayor, pero en ese caso, también se registra " +"cualquier evento anterior con una gravedad menor." #: ../Doc/howto/logging-cookbook.rst:2405 msgid "You can of course use the conventional means of decoration::" -msgstr "" +msgstr "Por supuesto, puede utilizar las formas de decoración convencionales::" #: ../Doc/howto/logging-cookbook.rst:2415 msgid "Formatting times using UTC (GMT) via configuration" -msgstr "" +msgstr "Formateo de horas usando UTC (GMT) a través de la configuración" #: ../Doc/howto/logging-cookbook.rst:2417 msgid "" "Sometimes you want to format times using UTC, which can be done using a " "class such as `UTCFormatter`, shown below::" msgstr "" +"A veces desea formatear las horas usando UTC, lo que se puede hacer usando " +"una clase como `UTCFormatter`, como se muestra a continuación::" #: ../Doc/howto/logging-cookbook.rst:2426 msgid "" @@ -1345,20 +1982,26 @@ msgid "" "the :func:`~logging.config.dictConfig` API with an approach illustrated by " "the following complete example::" msgstr "" +"y luego puede usar el ``UTCFormatter`` en su código en lugar de :class:" +"`~logging.Formatter`. Si desea hacer eso a través de la configuración, puede " +"usar la API :func:`~logging.config.dictConfig` con un enfoque ilustrado por " +"el siguiente ejemplo completo::" #: ../Doc/howto/logging-cookbook.rst:2469 msgid "When this script is run, it should print something like:" -msgstr "" +msgstr "Cuando se ejecuta este script, debería imprimir algo como:" #: ../Doc/howto/logging-cookbook.rst:2476 msgid "" "showing how the time is formatted both as local time and UTC, one for each " "handler." msgstr "" +"mostrando cómo se formatea la hora como hora local y UTC, una para cada " +"gestor." #: ../Doc/howto/logging-cookbook.rst:2483 msgid "Using a context manager for selective logging" -msgstr "" +msgstr "Usar un administrador de contexto para logging selectivo" #: ../Doc/howto/logging-cookbook.rst:2485 msgid "" @@ -1369,6 +2012,13 @@ msgid "" "optionally change the logging level and add a logging handler purely in the " "scope of the context manager::" msgstr "" +"Hay ocasiones en las que sería útil cambiar temporalmente la configuración " +"de logging y revertir esto después de hacer algo. Para ello, un " +"administrador de contexto es la forma más obvia de guardar y restaurar el " +"contexto de logging. Aquí hay un ejemplo simple de un administrador de " +"contexto de este tipo, que le permite cambiar opcionalmente el nivel de " +"logging y agregar un gestor de logging exclusivamente en el alcance del " +"administrador de contexto::" #: ../Doc/howto/logging-cookbook.rst:2518 msgid "" @@ -1378,12 +2028,20 @@ msgid "" "from the block. You can also ask the manager to close the handler for you on " "block exit - you could do this if you don't need the handler any more." msgstr "" +"Si especifica un valor de nivel, el nivel del registrador se establece en " +"ese valor en el alcance del bloque *with* cubierto por el administrador de " +"contexto. Si especifica un gestor, se agrega al registrador al entrar al " +"bloque y se elimina al salir del bloque. También puede pedirle al " +"administrador que cierre el gestor por usted al salir del bloque si ya no lo " +"necesita." #: ../Doc/howto/logging-cookbook.rst:2524 msgid "" "To illustrate how it works, we can add the following block of code to the " "above::" msgstr "" +"Para ilustrar cómo funciona, podemos agregar el siguiente bloque de código " +"al anterior::" #: ../Doc/howto/logging-cookbook.rst:2542 msgid "" @@ -1397,26 +2055,42 @@ msgid "" "statement's completion, the status is as it was before so message #6 appears " "(like message #1) whereas message #7 doesn't (just like message #2)." msgstr "" +"Inicialmente configuramos el nivel del registrador en ``INFO``, por lo que " +"aparece el mensaje #1 y el mensaje #2 no. Luego cambiamos el nivel a " +"``DEBUG`` temporalmente en el siguiente bloque ``with``, y aparece el " +"mensaje #3. Una vez que se sale del bloque, el nivel del registrador se " +"restaura a ``INFO`` y, por lo tanto, el mensaje #4 no aparece. En el " +"siguiente bloque ``with``, configuramos el nivel en ``DEBUG`` nuevamente, " +"pero también agregamos un gestor que escribe en ``sys.stdout``. Por lo " +"tanto, el mensaje #5 aparece dos veces en la consola (una vez a través de " +"``stderr`` y una vez a través de ``stdout``). Después de la finalización de " +"la declaración ``with``, se vuelve al estado anterior, por lo que aparece el " +"mensaje #6 (como el mensaje #1) mientras que el mensaje #7 no (como el " +"mensaje #2)." #: ../Doc/howto/logging-cookbook.rst:2552 msgid "If we run the resulting script, the result is as follows:" -msgstr "" +msgstr "Si ejecutamos el script resultante, el resultado es el siguiente:" #: ../Doc/howto/logging-cookbook.rst:2563 msgid "" "If we run it again, but pipe ``stderr`` to ``/dev/null``, we see the " "following, which is the only message written to ``stdout``:" msgstr "" +"Si lo ejecutamos de nuevo, pero dirigimos ``stderr`` a ``/dev/null``, vemos " +"lo siguiente, que es el único mensaje escrito en ``stdout``:" #: ../Doc/howto/logging-cookbook.rst:2571 msgid "Once again, but piping ``stdout`` to ``/dev/null``, we get:" -msgstr "" +msgstr "Una vez más, pero canalizando ``stdout`` a ``/dev/null``, obtenemos:" #: ../Doc/howto/logging-cookbook.rst:2581 msgid "" "In this case, the message #5 printed to ``stdout`` doesn't appear, as " "expected." msgstr "" +"En este caso, el mensaje #5 impreso en ``stdout`` no aparece, como se " +"esperaba." #: ../Doc/howto/logging-cookbook.rst:2583 msgid "" @@ -1424,28 +2098,34 @@ msgid "" "attach logging filters temporarily. Note that the above code works in Python " "2 as well as Python 3." msgstr "" +"Por supuesto, el enfoque descrito aquí puede generalizarse, por ejemplo, " +"para adjuntar filtros de logging temporalmente. Tenga en cuenta que el " +"código anterior funciona tanto en Python 2 como en Python 3." #: ../Doc/howto/logging-cookbook.rst:2591 msgid "A CLI application starter template" -msgstr "" +msgstr "Una plantilla de inicio de aplicación CLI" #: ../Doc/howto/logging-cookbook.rst:2593 msgid "Here's an example which shows how you can:" -msgstr "" +msgstr "Aquí hay un ejemplo que muestra cómo puede:" #: ../Doc/howto/logging-cookbook.rst:2595 msgid "Use a logging level based on command-line arguments" msgstr "" +"Utilizar un nivel de logging basado en argumentos de la línea de comandos" #: ../Doc/howto/logging-cookbook.rst:2596 msgid "" "Dispatch to multiple subcommands in separate files, all logging at the same " "level in a consistent way" msgstr "" +"Enviar a varios subcomandos en archivos separados, todos registrando en el " +"mismo nivel de forma coherente" #: ../Doc/howto/logging-cookbook.rst:2598 msgid "Make use of simple, minimal configuration" -msgstr "" +msgstr "Utilizar una configuración mínima y sencilla" #: ../Doc/howto/logging-cookbook.rst:2600 msgid "" @@ -1457,52 +2137,70 @@ msgid "" "verbosity of the application via a command-line argument, defaulting to " "``logging.INFO``. Here's one way that ``app.py`` could be written::" msgstr "" +"Supongamos que tenemos una aplicación de línea de comandos cuyo trabajo es " +"detener, iniciar o reiniciar algunos servicios. Esto podría organizarse con " +"fines ilustrativos como un archivo ``app.py`` que es el script principal de " +"la aplicación, con comandos individuales implementados en ``start.py``, " +"``stop.py`` y ``restart.py``. Supongamos además que queremos controlar la " +"verbosidad de la aplicación a través de un argumento de línea de comandos, " +"por defecto en ``logging.INFO``. Aquí hay una forma en que se podría " +"escribir ``app.py``::" #: ../Doc/howto/logging-cookbook.rst:2649 msgid "" "And the ``start``, ``stop`` and ``restart`` commands can be implemented in " "separate modules, like so for starting::" msgstr "" +"Y los comandos ``start``, ``stop`` y ``reiniciar`` se pueden implementar en " +"módulos separados, como para iniciar::" #: ../Doc/howto/logging-cookbook.rst:2662 msgid "and thus for stopping::" -msgstr "" +msgstr "y así para detener::" #: ../Doc/howto/logging-cookbook.rst:2683 msgid "and similarly for restarting::" -msgstr "" +msgstr "y de manera similar para reiniciar::" #: ../Doc/howto/logging-cookbook.rst:2704 msgid "" "If we run this application with the default log level, we get output like " "this:" msgstr "" +"Si ejecutamos esta aplicación con el nivel de log predeterminado, obtenemos " +"un resultado como este:" #: ../Doc/howto/logging-cookbook.rst:2717 msgid "" "The first word is the logging level, and the second word is the module or " "package name of the place where the event was logged." msgstr "" +"La primera palabra es el nivel de logging y la segunda palabra es el nombre " +"del módulo o paquete del lugar donde se registró el evento." #: ../Doc/howto/logging-cookbook.rst:2720 msgid "" "If we change the logging level, then we can change the information sent to " "the log. For example, if we want more information:" msgstr "" +"Si cambiamos el nivel de logging, podemos cambiar la información enviada al " +"log. Por ejemplo, si queremos más información:" #: ../Doc/howto/logging-cookbook.rst:2737 msgid "And if we want less:" -msgstr "" +msgstr "Y si queremos menos:" #: ../Doc/howto/logging-cookbook.rst:2745 msgid "" "In this case, the commands don't print anything to the console, since " "nothing at ``WARNING`` level or above is logged by them." msgstr "" +"En este caso, los comandos no imprimen nada en la consola, ya que no " +"registran nada en el nivel de ``WARNING`` o superior." #: ../Doc/howto/logging-cookbook.rst:2751 msgid "A Qt GUI for logging" -msgstr "" +msgstr "Una GUI de Qt para logging" #: ../Doc/howto/logging-cookbook.rst:2753 msgid "" @@ -1511,6 +2209,11 @@ msgid "" "platform UI framework with Python bindings using `PySide2 `_ or `PyQt5 `_ libraries." msgstr "" +"Una pregunta que surge de vez en cuando es sobre cómo *loggear* en una " +"aplicación GUI. El *framework* `Qt ` _ es un *framework* " +"popular multiplataforma con bindings de Python que usan PySide2 `_ o librerías `PyQt5 `_ ." #: ../Doc/howto/logging-cookbook.rst:2759 msgid "" @@ -1521,6 +2224,14 @@ msgid "" "logging) as well as a worker thread doing work in the background (here, just " "logging messages at random levels with random short delays in between)." msgstr "" +"El siguiente ejemplo muestra cómo iniciar sesión en una GUI de Qt. Esto " +"introduce una clase simple ``QtHandler`` que toma un invocable, que debería " +"ser un slot en el hilo principal que realiza actualizaciones de la GUI. " +"También se crea un hilo de trabajo para mostrar cómo puede iniciar sesión en " +"la GUI tanto desde la propia interfaz de usuario (a través de un botón para " +"el logging manual) como desde un hilo de trabajo que trabaja en segundo " +"plano (aquí, simplemente registrando mensajes en niveles aleatorios con " +"aleatorio breves retrasos intermedios)." #: ../Doc/howto/logging-cookbook.rst:2766 msgid "" @@ -1528,6 +2239,10 @@ msgid "" "the :mod:`threading` module, as there are circumstances where one has to use " "``QThread``, which offers better integration with other ``Qt`` components." msgstr "" +"El hilo *worker* se implementa usando la clase ``QThread`` de Qt en lugar " +"del módulo :mod:`threading`, ya que hay circunstancias en las que uno tiene " +"que usar ``QThread``, que ofrece una mejor integración con otros componentes " +"``Qt``." #: ../Doc/howto/logging-cookbook.rst:2770 msgid "" @@ -1536,3 +2251,7 @@ msgid "" "Qt. Please refer to the comments in the code snippet for more detailed " "information." msgstr "" +"El código debería funcionar con versiones recientes de ``PySide2`` o " +"``PyQt5``. Debería poder adaptar el enfoque a versiones anteriores de Qt. " +"Consulte los comentarios en el fragmento de código para obtener información " +"más detallada."