logging.po

# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Maintained by the python-doc-es workteam.
# docs-es@python.org /
# https://mail.python.org/mailman3/lists/docs-es.python.org/
# Check https://github.com/PyCampES/python-docs-es/blob/3.8/TRANSLATORS to
# get the list of volunteers
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-05-05 12:54+0200\n"
"PO-Revision-Date: 2021-01-01 21:49-0300\n"
"Last-Translator: \n"
"Language-Team: python-doc-es\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.8.0\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"Language: es\n"
"X-Generator: Poedit 2.4.2\n"

#: ../Doc/library/logging.rst:2
msgid ":mod:`logging` --- Logging facility for Python"
msgstr ":mod:`logging` --- Instalación de logging para Python"

#: ../Doc/library/logging.rst:10
msgid "**Source code:** :source:`Lib/logging/__init__.py`"
msgstr "**Source code:** :source:`Lib/logging/__init__.py`"

#: ../Doc/library/logging.rst:16
msgid ""
"This page contains the API reference information. For tutorial information "
"and discussion of more advanced topics, see"
msgstr ""
"Esta página contiene la información de referencia de la API. Para "
"información sobre tutorial y discusión de temas más avanzados, ver"

#: ../Doc/library/logging.rst:19
msgid ":ref:`Basic Tutorial <logging-basic-tutorial>`"
msgstr ":ref:`Tutorial básico <logging-basic-tutorial>`"

#: ../Doc/library/logging.rst:20
msgid ":ref:`Advanced Tutorial <logging-advanced-tutorial>`"
msgstr ":ref:`Tutorial avanzado <logging-advanced-tutorial>`"

#: ../Doc/library/logging.rst:21
msgid ":ref:`Logging Cookbook <logging-cookbook>`"
msgstr ":ref:`Libro de recetas de Logging <logging-cookbook>`"

#: ../Doc/library/logging.rst:25
msgid ""
"This module defines functions and classes which implement a flexible event "
"logging system for applications and libraries."
msgstr ""
"Este módulo define funciones y clases que implementan un sistema flexible de "
"logging de eventos para aplicaciones y bibliotecas."

#: ../Doc/library/logging.rst:28
msgid ""
"The key benefit of having the logging API provided by a standard library "
"module is that all Python modules can participate in logging, so your "
"application log can include your own messages integrated with messages from "
"third-party modules."
msgstr ""
"El beneficio clave de tener la API de logging proporcionada por un módulo de "
"la biblioteca estándar es que todos los módulos de Python pueden participar "
"en el logging, por lo que el registro de su aplicación puede incluir sus "
"propios mensajes integrados con mensajes de módulos de terceros."

#: ../Doc/library/logging.rst:33
msgid ""
"The module provides a lot of functionality and flexibility.  If you are "
"unfamiliar with logging, the best way to get to grips with it is to see the "
"tutorials (see the links on the right)."
msgstr ""
"El módulo proporciona mucha funcionalidad y flexibilidad. Si no está "
"familiarizado con logging, la mejor manera de familiarizarse con él es ver "
"los tutoriales (ver los enlaces a la derecha)."

#: ../Doc/library/logging.rst:37
msgid ""
"The basic classes defined by the module, together with their functions, are "
"listed below."
msgstr ""
"Las clases básicas definidas por el módulo, junto con sus funciones, se "
"enumeran a continuación."

#: ../Doc/library/logging.rst:40
msgid "Loggers expose the interface that application code directly uses."
msgstr ""
"Los loggers exponen la interfaz que el código de la aplicación usa "
"directamente."

#: ../Doc/library/logging.rst:41
msgid ""
"Handlers send the log records (created by loggers) to the appropriate "
"destination."
msgstr ""
"Los gestores envían los registros (creados por los loggers) al destino "
"apropiado."

#: ../Doc/library/logging.rst:43
msgid ""
"Filters provide a finer grained facility for determining which log records "
"to output."
msgstr ""
"Los filtros proporcionan una facilidad de ajuste preciso para determinar que "
"registros generar."

#: ../Doc/library/logging.rst:45
msgid "Formatters specify the layout of log records in the final output."
msgstr ""
"Los formateadores especifican el diseño de los registros en el resultado "
"final."

#: ../Doc/library/logging.rst:51
msgid "Logger Objects"
msgstr "Objetos Logger"

#: ../Doc/library/logging.rst:53
msgid ""
"Loggers have the following attributes and methods.  Note that Loggers should "
"*NEVER* be instantiated directly, but always through the module-level "
"function ``logging.getLogger(name)``.  Multiple calls to :func:`getLogger` "
"with the same name will always return a reference to the same Logger object."
msgstr ""
"Los loggers tienen los siguientes atributos y métodos. Tenga en cuenta que "
"los loggers *NUNCA* deben ser instanciados directamente, siempre a través de "
"la función de nivel de módulo ``logging.getLogger(name)``. Múltiples "
"llamadas a :func:`getLogger` con el mismo nombre siempre retornarán una "
"referencia al mismo objeto Logger."

#: ../Doc/library/logging.rst:58
msgid ""
"The ``name`` is potentially a period-separated hierarchical value, like "
"``foo.bar.baz`` (though it could also be just plain ``foo``, for example). "
"Loggers that are further down in the hierarchical list are children of "
"loggers higher up in the list.  For example, given a logger with a name of "
"``foo``, loggers with names of ``foo.bar``, ``foo.bar.baz``, and ``foo.bam`` "
"are all descendants of ``foo``.  The logger name hierarchy is analogous to "
"the Python package hierarchy, and identical to it if you organise your "
"loggers on a per-module basis using the recommended construction ``logging."
"getLogger(__name__)``.  That's because in a module, ``__name__`` is the "
"module's name in the Python package namespace."
msgstr ""
"El ``name`` es potencialmente un valor jerárquico separado por puntos, como "
"``foo.bar.baz`` (aunque también podría ser simplemente ```foo``, por "
"ejemplo). Los loggers que están más abajo en la lista jerárquica son hijos "
"de los loggers que están más arriba en la lista. Por ejemplo, dado un logger "
"con el nombre de ``foo``, los logger con los nombres de ``foo.bar``, ``foo."
"bar.baz`` y ``foo.bam`` son descendientes de ``foo``. La jerarquía del "
"nombre del logger es análoga a la jerarquía del paquete Python e idéntica si "
"organiza los logger por módulo utilizando la construcción recomendada "
"``logging.getLogger(__name__)``. Debido que en un módulo, ``__name__`` es el "
"nombre del módulo en el espacio de nombres del paquete Python."

#: ../Doc/library/logging.rst:74
msgid ""
"If this attribute evaluates to true, events logged to this logger will be "
"passed to the handlers of higher level (ancestor) loggers, in addition to "
"any handlers attached to this logger. Messages are passed directly to the "
"ancestor loggers' handlers - neither the level nor filters of the ancestor "
"loggers in question are considered."
msgstr ""
"Si este atributo se evalúa como verdadero, los eventos registrados en este "
"logger se pasarán a los gestores de los loggers de nivel superior "
"(ancestro), además de los gestores asociados a este logger. Los mensajes se "
"pasan directamente a los gestores de los loggers ancestrales; no se "
"consideran ni el nivel ni los filtros de los loggers ancestrales en cuestión."

#: ../Doc/library/logging.rst:80
msgid ""
"If this evaluates to false, logging messages are not passed to the handlers "
"of ancestor loggers."
msgstr ""
"Si esto se evalúa como falso, los mensajes de registro no se pasan a los "
"gestores de los logger ancestrales."

#: ../Doc/library/logging.rst:83
msgid "The constructor sets this attribute to ``True``."
msgstr "El constructor establece este atributo en ``True``."

#: ../Doc/library/logging.rst:85
msgid ""
"If you attach a handler to a logger *and* one or more of its ancestors, it "
"may emit the same record multiple times. In general, you should not need to "
"attach a handler to more than one logger - if you just attach it to the "
"appropriate logger which is highest in the logger hierarchy, then it will "
"see all events logged by all descendant loggers, provided that their "
"propagate setting is left set to ``True``. A common scenario is to attach "
"handlers only to the root logger, and to let propagation take care of the "
"rest."
msgstr ""
"Si adjunta un controlador a un logger *y* uno o más de sus ancestros, puede "
"emitir el mismo registro varias veces. En general, no debería necesitar "
"adjuntar un gestor a más de un logger; si solo lo adjunta al logger "
"apropiado que está más arriba en la jerarquía del logger, verá todos los "
"eventos registrados por todos los logger descendientes, siempre que la "
"configuración de propagación sea ``True``. Un escenario común es adjuntar "
"gestores solo al logger raíz y dejar que la propagación se encargue del "
"resto."

#: ../Doc/library/logging.rst:96
msgid ""
"Sets the threshold for this logger to *level*. Logging messages which are "
"less severe than *level* will be ignored; logging messages which have "
"severity *level* or higher will be emitted by whichever handler or handlers "
"service this logger, unless a handler's level has been set to a higher "
"severity level than *level*."
msgstr ""
"Establece el umbral para este logger en *level*. Los mensajes de logging que "
"son menos severos que *level* serán ignorados; los mensajes de logging que "
"tengan un nivel de severidad *level* o superior serán emitidos por cualquier "
"gestor o gestores que atiendan este logger, a menos que el nivel de un "
"gestor haya sido configurado en un nivel de severidad más alto que *level*."

#: ../Doc/library/logging.rst:101
msgid ""
"When a logger is created, the level is set to :const:`NOTSET` (which causes "
"all messages to be processed when the logger is the root logger, or "
"delegation to the parent when the logger is a non-root logger). Note that "
"the root logger is created with level :const:`WARNING`."
msgstr ""
"Cuando se crea un logger, el nivel se establece en :const:`NOTSET` (que hace "
"que todos los mensajes se procesen cuando el logger es el logger raíz, o la "
"delegación al padre cuando el logger no es un logger raíz). Tenga en cuenta "
"que el logger raíz se crea con el nivel :const:`WARNING`."

#: ../Doc/library/logging.rst:106
msgid ""
"The term 'delegation to the parent' means that if a logger has a level of "
"NOTSET, its chain of ancestor loggers is traversed until either an ancestor "
"with a level other than NOTSET is found, or the root is reached."
msgstr ""
"El término 'delegación al padre' significa que si un logger tiene un nivel "
"de NOTSET, su cadena de logger ancestrales se atraviesa hasta que se "
"encuentra un ancestro con un nivel diferente a NOTSET o se alcanza la raíz."

#: ../Doc/library/logging.rst:110
msgid ""
"If an ancestor is found with a level other than NOTSET, then that ancestor's "
"level is treated as the effective level of the logger where the ancestor "
"search began, and is used to determine how a logging event is handled."
msgstr ""
"Si se encuentra un antepasado con un nivel distinto de NOTSET, entonces el "
"nivel de ese antepasado se trata como el nivel efectivo del logger donde "
"comenzó la búsqueda de antepasados, y se utiliza para determinar cómo se "
"maneja un evento de registro."

#: ../Doc/library/logging.rst:114
msgid ""
"If the root is reached, and it has a level of NOTSET, then all messages will "
"be processed. Otherwise, the root's level will be used as the effective "
"level."
msgstr ""
"Si se alcanza la raíz y tiene un nivel de NOTSET, se procesarán todos los "
"mensajes. De lo contrario, el nivel de la raíz se utilizará como el nivel "
"efectivo."

#: ../Doc/library/logging.rst:117 ../Doc/library/logging.rst:426
msgid "See :ref:`levels` for a list of levels."
msgstr "Ver :ref:`levels` para obtener una lista de niveles."

#: ../Doc/library/logging.rst:119
msgid ""
"The *level* parameter now accepts a string representation of the level such "
"as 'INFO' as an alternative to the integer constants such as :const:`INFO`. "
"Note, however, that levels are internally stored as integers, and methods "
"such as e.g. :meth:`getEffectiveLevel` and :meth:`isEnabledFor` will return/"
"expect to be passed integers."
msgstr ""
"El parámetro *level* ahora acepta una representación de cadena del nivel "
"como 'INFO' como alternativa a las constantes de enteros como :const:`INFO`. "
"Sin embargo, tenga en cuenta que los niveles se almacenan internamente como "
"e.j. :meth:`getEffectiveLevel` y :meth:`isEnabledFor` retornará/esperará que "
"se pasen enteros."

#: ../Doc/library/logging.rst:129
msgid ""
"Indicates if a message of severity *level* would be processed by this "
"logger. This method checks first the module-level level set by ``logging."
"disable(level)`` and then the logger's effective level as determined by :"
"meth:`getEffectiveLevel`."
msgstr ""
"Indica si este logger procesará un mensaje de gravedad *level*. Este método "
"verifica primero el nivel de nivel de módulo establecido por ``logging."
"disable(level)`` y luego el nivel efectivo del logger según lo determinado "
"por :meth:`getEffectiveLevel`."

#: ../Doc/library/logging.rst:137
msgid ""
"Indicates the effective level for this logger. If a value other than :const:"
"`NOTSET` has been set using :meth:`setLevel`, it is returned. Otherwise, the "
"hierarchy is traversed towards the root until a value other than :const:"
"`NOTSET` is found, and that value is returned. The value returned is an "
"integer, typically one of :const:`logging.DEBUG`, :const:`logging.INFO` etc."
msgstr ""
"Indica el nivel efectivo para este logger. Si se ha establecido un valor "
"distinto de :const:`NOTSET` utilizando :meth:`setLevel`, se retorna. De lo "
"contrario, la jerarquía se atraviesa hacia la raíz hasta que se encuentre un "
"valor que no sea :const:`NOTSET` y se retorna ese valor. El valor retornado "
"es un entero, típicamente uno de :const:`logging.DEBUG`, :const:`logging."
"INFO` etc."

#: ../Doc/library/logging.rst:147
msgid ""
"Returns a logger which is a descendant to this logger, as determined by the "
"suffix. Thus, ``logging.getLogger('abc').getChild('def.ghi')`` would return "
"the same logger as would be returned by ``logging.getLogger('abc.def."
"ghi')``. This is a convenience method, useful when the parent logger is "
"named using e.g. ``__name__`` rather than a literal string."
msgstr ""
"Retorna un logger que es descendiente de este logger, según lo determinado "
"por el sufijo. Por lo tanto, ``logging.getLogger('abc').getChild('def."
"ghi')`` retornaría el mismo logger que retornaría ``logging.getLogger('abc."
"def.ghi')``. Este es un método convenientemente útil cuando el logger "
"principal se nombra usando e.j. ``__name__`` en lugar de una cadena literal."

#: ../Doc/library/logging.rst:158
#, python-format
msgid ""
"Logs a message with level :const:`DEBUG` on this logger. The *msg* is the "
"message format string, and the *args* are the arguments which are merged "
"into *msg* using the string formatting operator. (Note that this means that "
"you can use keywords in the format string, together with a single dictionary "
"argument.) No % formatting operation is performed on *msg* when no *args* "
"are supplied."
msgstr ""
"Registra un mensaje con el nivel :const:`DEBUG` en este logger. El *msg* es "
"la cadena de formato del mensaje, y los *args* son los argumentos que se "
"fusionan en *msg* utilizando el operador de formato de cadena. (Tenga en "
"cuenta que esto significa que puede usar palabras clave en la cadena de "
"formato, junto con un solo argumento de diccionario). No se realiza ninguna "
"operación de formateo % en *msg* cuando no se suministran *args*."

#: ../Doc/library/logging.rst:164
msgid ""
"There are four keyword arguments in *kwargs* which are inspected: "
"*exc_info*, *stack_info*, *stacklevel* and *extra*."
msgstr ""
"Hay cuatro argumentos de palabras clave *kwargs* que se inspeccionan: "
"*exc_info*, *stack_info*, *stacklevel* y *extra*."

#: ../Doc/library/logging.rst:167
msgid ""
"If *exc_info* does not evaluate as false, it causes exception information to "
"be added to the logging message. If an exception tuple (in the format "
"returned by :func:`sys.exc_info`) or an exception instance is provided, it "
"is used; otherwise, :func:`sys.exc_info` is called to get the exception "
"information."
msgstr ""
"Si *exc_info* no se evalúa como falso, hace que se agregue información de "
"excepción al mensaje de registro. Si se proporciona una tupla de excepción "
"(en el formato retornado por :func:`sys.exc_info`) o se proporciona una "
"instancia de excepción, se utiliza; de lo contrario, se llama a :func:`sys."
"exc_info` para obtener la información de excepción."

#: ../Doc/library/logging.rst:172 ../Doc/library/logging.rst:966
msgid ""
"The second optional keyword argument is *stack_info*, which defaults to "
"``False``. If true, stack information is added to the logging message, "
"including the actual logging call. Note that this is not the same stack "
"information as that displayed through specifying *exc_info*: The former is "
"stack frames from the bottom of the stack up to the logging call in the "
"current thread, whereas the latter is information about stack frames which "
"have been unwound, following an exception, while searching for exception "
"handlers."
msgstr ""
"El segundo argumento opcional con la palabra clave *stack_info*, que por "
"defecto es ``False``. Si es verdadero, la información de la pila agregara el "
"mensaje de registro, incluida la actual llamada del registro. Tenga en "
"cuenta que esta no es la misma información de la pila que se muestra al "
"especificar *exc_info*: la primera son los cuadros de la pila desde la parte "
"inferior de la pila hasta la llamada de registro en el hilo actual, mientras "
"que la segunda es la información sobre los cuadros de la pila que se han "
"desenrollado, siguiendo una excepción, mientras busca gestores de excepción."

#: ../Doc/library/logging.rst:181 ../Doc/library/logging.rst:975
msgid ""
"You can specify *stack_info* independently of *exc_info*, e.g. to just show "
"how you got to a certain point in your code, even when no exceptions were "
"raised. The stack frames are printed following a header line which says:"
msgstr ""
"Puede especificar *stack_info* independientemente de *exc_info*, por ejemplo "
"solo para mostrar cómo llegaste a cierto punto en tu código, incluso cuando "
"no se lanzaron excepciones. Los marcos de la pila se imprimen siguiendo una "
"línea de encabezado que dice:"

#: ../Doc/library/logging.rst:189 ../Doc/library/logging.rst:983
msgid ""
"This mimics the ``Traceback (most recent call last):`` which is used when "
"displaying exception frames."
msgstr ""
"Esto imita el ``Traceback (most recent call last):`` que se usa cuando se "
"muestran marcos de excepción."

#: ../Doc/library/logging.rst:192
msgid ""
"The third optional keyword argument is *stacklevel*, which defaults to "
"``1``. If greater than 1, the corresponding number of stack frames are "
"skipped when computing the line number and function name set in the :class:"
"`LogRecord` created for the logging event. This can be used in logging "
"helpers so that the function name, filename and line number recorded are not "
"the information for the helper function/method, but rather its caller. The "
"name of this parameter mirrors the equivalent one in the :mod:`warnings` "
"module."
msgstr ""
"El tercer argumento opcional con la palabra clave *stacklevel*, que por "
"defecto es ``1``. Si es mayor que 1, se omite el número correspondiente de "
"cuadros de pila al calcular el número de línea y el nombre de la función "
"establecidos en :class:`LogRecord` creado para el evento de registro. Esto "
"se puede utilizar en el registro de ayudantes para que el nombre de la "
"función, el nombre de archivo y el número de línea registrados no sean la "
"información para la función/método auxiliar, sino más bien su llamador. El "
"nombre de este parámetro refleja el equivalente en el modulo :mod:`warnings`."

#: ../Doc/library/logging.rst:200
msgid ""
"The fourth keyword argument is *extra* which can be used to pass a "
"dictionary which is used to populate the __dict__ of the :class:`LogRecord` "
"created for the logging event with user-defined attributes. These custom "
"attributes can then be used as you like. For example, they could be "
"incorporated into logged messages. For example::"
msgstr ""
"El cuarto argumento de palabra clave es *extra*, que se puede usar para "
"pasar un diccionario que se usa para completar el __dict__ de :class:"
"`LogRecord` creado para el evento de registro con atributos definidos por el "
"usuario. Estos atributos personalizados se pueden usar a su gusto. Podrían "
"incorporarse en mensajes registrados. Por ejemplo::"

#: ../Doc/library/logging.rst:212
msgid "would print something like"
msgstr "imprimiría algo como"

#: ../Doc/library/logging.rst:218 ../Doc/library/logging.rst:1003
msgid ""
"The keys in the dictionary passed in *extra* should not clash with the keys "
"used by the logging system. (See the :class:`Formatter` documentation for "
"more information on which keys are used by the logging system.)"
msgstr ""
"Las claves en el diccionario pasado *extra* no deben entrar en conflicto con "
"las claves utilizadas por el sistema de registro. (Ver la documentación de :"
"class:`Formatter` para obtener más información sobre qué claves utiliza el "
"sistema de registro)."

#: ../Doc/library/logging.rst:222
msgid ""
"If you choose to use these attributes in logged messages, you need to "
"exercise some care. In the above example, for instance, the :class:"
"`Formatter` has been set up with a format string which expects 'clientip' "
"and 'user' in the attribute dictionary of the :class:`LogRecord`. If these "
"are missing, the message will not be logged because a string formatting "
"exception will occur. So in this case, you always need to pass the *extra* "
"dictionary with these keys."
msgstr ""
"Si elige usar estos atributos en los mensajes registrados, debe tener "
"cuidado. En el ejemplo anterior, se ha configurado :class:`Formatter` con "
"una cadena de formato que espera *clientip* y 'usuario' en el diccionario de "
"atributos de :class:`LogRecord`. Si faltan, el mensaje no se registrará "
"porque se producirá una excepción de formato de cadena. En este caso, "
"siempre debe pasar el diccionario *extra* con estas teclas."

#: ../Doc/library/logging.rst:229 ../Doc/library/logging.rst:1014
msgid ""
"While this might be annoying, this feature is intended for use in "
"specialized circumstances, such as multi-threaded servers where the same "
"code executes in many contexts, and interesting conditions which arise are "
"dependent on this context (such as remote client IP address and "
"authenticated user name, in the above example). In such circumstances, it is "
"likely that specialized :class:`Formatter`\\ s would be used with "
"particular :class:`Handler`\\ s."
msgstr ""
"Si bien esto puede ser molesto, esta función está diseñada para su uso en "
"circunstancias especializadas, como servidores de subprocesos múltiples "
"donde el mismo código se ejecuta en muchos contextos, y las condiciones "
"interesantes que surgen dependen de este contexto (como la dirección IP del "
"cliente remoto y autenticado nombre de usuario, en el ejemplo anterior). En "
"tales circunstancias, es probable que se especialice :class:`Formatter`\\ s "
"con particular :class:`Handler`\\ s."

#: ../Doc/library/logging.rst:236 ../Doc/library/logging.rst:1021
msgid "The *stack_info* parameter was added."
msgstr "Se agregó el parámetro *stack_info*."

#: ../Doc/library/logging.rst:239
msgid "The *exc_info* parameter can now accept exception instances."
msgstr "El parámetro *exc_info* ahora puede aceptar instancias de excepción."

#: ../Doc/library/logging.rst:242
msgid "The *stacklevel* parameter was added."
msgstr "Se agregó el parámetro *stacklevel*."

#: ../Doc/library/logging.rst:248
msgid ""
"Logs a message with level :const:`INFO` on this logger. The arguments are "
"interpreted as for :meth:`debug`."
msgstr ""
"Registra un mensaje con el nivel :const:`INFO` en este logger. Los "
"argumentos se interpretan como :meth:`debug`."

#: ../Doc/library/logging.rst:254
msgid ""
"Logs a message with level :const:`WARNING` on this logger. The arguments are "
"interpreted as for :meth:`debug`."
msgstr ""
"Registra un mensaje con el nivel :const:`WARNING` en este logger. Los "
"argumentos se interpretan como :meth:`debug`."

#: ../Doc/library/logging.rst:257
msgid ""
"There is an obsolete method ``warn`` which is functionally identical to "
"``warning``. As ``warn`` is deprecated, please do not use it - use "
"``warning`` instead."
msgstr ""
"Hay un método obsoleto ``warn`` que es funcionalmente idéntico a "
"``warning``. Como ``warn`` está en desuso, no lo use, use ``warning`` en su "
"lugar."

#: ../Doc/library/logging.rst:263
msgid ""
"Logs a message with level :const:`ERROR` on this logger. The arguments are "
"interpreted as for :meth:`debug`."
msgstr ""
"Registra un mensaje con nivel :const:`ERROR` en este logger. Los argumentos "
"se interpretan como :meth:`debug`."

#: ../Doc/library/logging.rst:269
msgid ""
"Logs a message with level :const:`CRITICAL` on this logger. The arguments "
"are interpreted as for :meth:`debug`."
msgstr ""
"Registra un mensaje con el nivel :const:`CRITICAL` en este logger. Los "
"argumentos se interpretan como :meth:`debug`."

#: ../Doc/library/logging.rst:275
msgid ""
"Logs a message with integer level *level* on this logger. The other "
"arguments are interpreted as for :meth:`debug`."
msgstr ""
"Registra un mensaje con nivel entero *level* en este logger. Los otros "
"argumentos se interpretan como :meth:`debug`."

#: ../Doc/library/logging.rst:281
msgid ""
"Logs a message with level :const:`ERROR` on this logger. The arguments are "
"interpreted as for :meth:`debug`. Exception info is added to the logging "
"message. This method should only be called from an exception handler."
msgstr ""
"Registra un mensaje con nivel :const:`ERROR` en este logger. Los argumentos "
"se interpretan como :meth:`debug`. La información de excepción se agrega al "
"mensaje de registro. Este método solo debe llamarse desde un gestor de "
"excepciones."

#: ../Doc/library/logging.rst:288
msgid "Adds the specified filter *filter* to this logger."
msgstr "Agrega el filtro *filter* especificado a este logger."

#: ../Doc/library/logging.rst:293
msgid "Removes the specified filter *filter* from this logger."
msgstr "Elimina el filtro *filter* especificado de este logger."

#: ../Doc/library/logging.rst:298
msgid ""
"Apply this logger's filters to the record and return ``True`` if the record "
"is to be processed. The filters are consulted in turn, until one of them "
"returns a false value. If none of them return a false value, the record will "
"be processed (passed to handlers). If one returns a false value, no further "
"processing of the record occurs."
msgstr ""
"Aplique los filtros de este logger al registro y retorna ``True`` si se va a "
"procesar el registro. Los filtros se consultan a su vez, hasta que uno de "
"ellos retorna un valor falso. Si ninguno de ellos retorna un valor falso, el "
"registro será procesado (pasado a los gestores). Si se retorna un valor "
"falso, no se produce más procesamiento del registro."

#: ../Doc/library/logging.rst:307
msgid "Adds the specified handler *hdlr* to this logger."
msgstr "Agrega el gestor especificado *hdlr* a este logger."

#: ../Doc/library/logging.rst:312
msgid "Removes the specified handler *hdlr* from this logger."
msgstr "Elimina el gestor especificado *hdlr* de este logger."

#: ../Doc/library/logging.rst:317
msgid ""
"Finds the caller's source filename and line number. Returns the filename, "
"line number, function name and stack information as a 4-element tuple. The "
"stack information is returned as ``None`` unless *stack_info* is ``True``."
msgstr ""
"Encuentra el nombre de archivo de origen de la invoca y el número de línea. "
"Retorna el nombre del archivo, el número de línea, el nombre de la función y "
"la información de la pila como una tupla de 4 elementos. La información de "
"la pila se retorna como ``None`` a menos que *stack_info* sea ``True``."

#: ../Doc/library/logging.rst:321
msgid ""
"The *stacklevel* parameter is passed from code calling the :meth:`debug` and "
"other APIs. If greater than 1, the excess is used to skip stack frames "
"before determining the values to be returned. This will generally be useful "
"when calling logging APIs from helper/wrapper code, so that the information "
"in the event log refers not to the helper/wrapper code, but to the code that "
"calls it."
msgstr ""
"El parámetro *stacklevel* se pasa del código que llama a :meth:`debug` y "
"otras API. Si es mayor que 1, el exceso se utiliza para omitir los cuadros "
"de la pila antes de determinar los valores que se retornarán. Esto "
"generalmente será útil al llamar a las API de registro desde un *helper/"
"wrapper*, de modo que la información en el registro de eventos no se refiera "
"al *helper/wrapper*, sino al código que lo llama."

#: ../Doc/library/logging.rst:331
msgid ""
"Handles a record by passing it to all handlers associated with this logger "
"and its ancestors (until a false value of *propagate* is found). This method "
"is used for unpickled records received from a socket, as well as those "
"created locally. Logger-level filtering is applied using :meth:`~Logger."
"filter`."
msgstr ""
"Gestiona un registro pasándolo a todos los gestores asociados con este "
"logger y sus antepasados (hasta que se encuentre un valor falso de "
"*propagar*). Este método se utiliza para registros no empaquetados recibidos "
"de un socket, así como para aquellos creados localmente. El filtrado a nivel "
"de logger se aplica usando :meth:`~Logger.filter`."

#: ../Doc/library/logging.rst:339
msgid ""
"This is a factory method which can be overridden in subclasses to create "
"specialized :class:`LogRecord` instances."
msgstr ""
"Este es un método *factory* que se puede sobreescribir en subclases para "
"crear instancias especializadas :class:`LogRecord`."

#: ../Doc/library/logging.rst:344
msgid ""
"Checks to see if this logger has any handlers configured. This is done by "
"looking for handlers in this logger and its parents in the logger hierarchy. "
"Returns ``True`` if a handler was found, else ``False``. The method stops "
"searching up the hierarchy whenever a logger with the 'propagate' attribute "
"set to false is found - that will be the last logger which is checked for "
"the existence of handlers."
msgstr ""
"Comprueba si este logger tiene algún controlador configurado. Esto se hace "
"buscando gestores en este logger y sus padres en la jerarquía del logger. "
"Retorna ``True`` si se encontró un gestor, de lo contrario, ``False`` . El "
"método deja de buscar en la jerarquía cada vez que se encuentra un logger "
"con el atributo *propagate* establecido en falso: ese será el último logger "
"que verificará la existencia de gestores."

#: ../Doc/library/logging.rst:353
msgid "Loggers can now be pickled and unpickled."
msgstr ""
"Los logger ahora se pueden serializar y deserializar (*pickled and "
"unpickled*)."

#: ../Doc/library/logging.rst:359
msgid "Logging Levels"
msgstr "Niveles de logging"

#: ../Doc/library/logging.rst:361
msgid ""
"The numeric values of logging levels are given in the following table. These "
"are primarily of interest if you want to define your own levels, and need "
"them to have specific values relative to the predefined levels. If you "
"define a level with the same numeric value, it overwrites the predefined "
"value; the predefined name is lost."
msgstr ""
"Los valores numéricos de los niveles de logging se dan en la siguiente "
"tabla. Estos son principalmente de interés si desea definir sus propios "
"niveles y necesita que tengan valores específicos en relación con los "
"niveles predefinidos. Si define un nivel con el mismo valor numérico, "
"sobrescribe el valor predefinido; se pierde el nombre predefinido."

#: ../Doc/library/logging.rst:368
msgid "Level"
msgstr "Nivel"

#: ../Doc/library/logging.rst:368
msgid "Numeric value"
msgstr "Valor numérico"

#: ../Doc/library/logging.rst:370
msgid "``CRITICAL``"
msgstr "``CRITICAL``"

#: ../Doc/library/logging.rst:370
msgid "50"
msgstr "50"

#: ../Doc/library/logging.rst:372
msgid "``ERROR``"
msgstr "``ERROR``"

#: ../Doc/library/logging.rst:372
msgid "40"
msgstr "40"

#: ../Doc/library/logging.rst:374
msgid "``WARNING``"
msgstr "``WARNING``"

#: ../Doc/library/logging.rst:374
msgid "30"
msgstr "30"

#: ../Doc/library/logging.rst:376
msgid "``INFO``"
msgstr "``INFO``"

#: ../Doc/library/logging.rst:376
msgid "20"
msgstr "20"

#: ../Doc/library/logging.rst:378
msgid "``DEBUG``"
msgstr "``DEBUG``"

#: ../Doc/library/logging.rst:378
msgid "10"
msgstr "10"

#: ../Doc/library/logging.rst:380
msgid "``NOTSET``"
msgstr "``NOTSET``"

#: ../Doc/library/logging.rst:380
msgid "0"
msgstr "0"

#: ../Doc/library/logging.rst:387
msgid "Handler Objects"
msgstr "Gestor de objetos"

#: ../Doc/library/logging.rst:389
msgid ""
"Handlers have the following attributes and methods. Note that :class:"
"`Handler` is never instantiated directly; this class acts as a base for more "
"useful subclasses. However, the :meth:`__init__` method in subclasses needs "
"to call :meth:`Handler.__init__`."
msgstr ""
"Los gestores tienen los siguientes atributos y métodos. Tenga en cuenta que :"
"class:`Handler` nunca se instancia directamente; Esta clase actúa como base "
"para subclases más útiles. Sin embargo, el método :meth:`__init__` en las "
"subclases debe llamar a :meth:`Handler.__init__`."

#: ../Doc/library/logging.rst:398
msgid ""
"Initializes the :class:`Handler` instance by setting its level, setting the "
"list of filters to the empty list and creating a lock (using :meth:"
"`createLock`) for serializing access to an I/O mechanism."
msgstr ""
"Inicializa la instancia :class:`Handler` estableciendo su nivel, "
"configurando la lista de filtros en la lista vacía y creando un bloqueo "
"(usando :meth:`createLock`) para serializar el acceso a un mecanismo de E/S."

#: ../Doc/library/logging.rst:405
msgid ""
"Initializes a thread lock which can be used to serialize access to "
"underlying I/O functionality which may not be threadsafe."
msgstr ""
"Inicializa un bloqueo de subprocesos que se puede utilizar para serializar "
"el acceso a la funcionalidad de E/S subyacente que puede no ser segura para "
"subprocesos."

#: ../Doc/library/logging.rst:411
msgid "Acquires the thread lock created with :meth:`createLock`."
msgstr "Adquiere el bloqueo de hilo creado con :meth:`createLock`."

#: ../Doc/library/logging.rst:416
msgid "Releases the thread lock acquired with :meth:`acquire`."
msgstr "Libera el bloqueo de hilo adquirido con :meth:`acquire`."

#: ../Doc/library/logging.rst:421
msgid ""
"Sets the threshold for this handler to *level*. Logging messages which are "
"less severe than *level* will be ignored. When a handler is created, the "
"level is set to :const:`NOTSET` (which causes all messages to be processed)."
msgstr ""
"Establece el umbral para este gestor en *level*. Los mensajes de registro "
"que son menos severos que *level* serán ignorados. Cuando se crea un "
"controlador, el nivel se establece en :const:`NOTSET` (lo que hace que se "
"procesen todos los mensajes)."

#: ../Doc/library/logging.rst:428
msgid ""
"The *level* parameter now accepts a string representation of the level such "
"as 'INFO' as an alternative to the integer constants such as :const:`INFO`."
msgstr ""
"El parámetro *level* ahora acepta una representación de cadena del nivel "
"como 'INFO' como alternativa a las constantes de enteros como :const:`INFO`."

#: ../Doc/library/logging.rst:436
msgid "Sets the :class:`Formatter` for this handler to *fmt*."
msgstr "Establece :class:`Formatter` para este controlador en *fmt*."

#: ../Doc/library/logging.rst:441
msgid "Adds the specified filter *filter* to this handler."
msgstr "Agrega el filtro *filter* especificado a este gestor."

#: ../Doc/library/logging.rst:446
msgid "Removes the specified filter *filter* from this handler."
msgstr "Elimina el filtro especificado *filter* de este gestor."

#: ../Doc/library/logging.rst:451
msgid ""
"Apply this handler's filters to the record and return ``True`` if the record "
"is to be processed. The filters are consulted in turn, until one of them "
"returns a false value. If none of them return a false value, the record will "
"be emitted. If one returns a false value, the handler will not emit the "
"record."
msgstr ""
"Aplique los filtros de este gestor al registro y retorna ``True`` si se va a "
"procesar el registro. Los filtros se consultan a su vez, hasta que uno de "
"ellos retorna un valor falso. Si ninguno de ellos retorna un valor falso, se "
"emitirá el registro. Si uno retorna un valor falso, el controlador no "
"emitirá el registro."

#: ../Doc/library/logging.rst:460
msgid ""
"Ensure all logging output has been flushed. This version does nothing and is "
"intended to be implemented by subclasses."
msgstr ""
"Asegúrese de que toda la salida de logging se haya vaciado. Esta versión no "
"hace nada y está destinada a ser implementada por subclases."

#: ../Doc/library/logging.rst:466
msgid ""
"Tidy up any resources used by the handler. This version does no output but "
"removes the handler from an internal list of handlers which is closed when :"
"func:`shutdown` is called. Subclasses should ensure that this gets called "
"from overridden :meth:`close` methods."
msgstr ""
"Poner en orden los recursos utilizados por el gestor. Esta versión no genera "
"salida, pero elimina el controlador de una lista interna de gestores que se "
"cierra cuando se llama a :func:`shutdown`. Las subclases deben garantizar "
"que esto se llame desde métodos :meth:`close` sobreescritos."

#: ../Doc/library/logging.rst:474
msgid ""
"Conditionally emits the specified logging record, depending on filters which "
"may have been added to the handler. Wraps the actual emission of the record "
"with acquisition/release of the I/O thread lock."
msgstr ""
"Emite condicionalmente el registro especifico, según los filtros que se "
"hayan agregado al controlador. Envuelve la actual emisión del registro con "
"*acquisition/release* del hilo de bloqueo E/S."

#: ../Doc/library/logging.rst:481
msgid ""
"This method should be called from handlers when an exception is encountered "
"during an :meth:`emit` call. If the module-level attribute "
"``raiseExceptions`` is ``False``, exceptions get silently ignored. This is "
"what is mostly wanted for a logging system - most users will not care about "
"errors in the logging system, they are more interested in application "
"errors. You could, however, replace this with a custom handler if you wish. "
"The specified record is the one which was being processed when the exception "
"occurred. (The default value of ``raiseExceptions`` is ``True``, as that is "
"more useful during development)."
msgstr ""
"Este método debe llamarse desde los gestores cuando se encuentra una "
"excepción durante una llamada a :meth:`emit`. Si el atributo de nivel de "
"módulo ``raiseExceptions`` es `` False``, las excepciones se ignoran "
"silenciosamente. Esto es lo que más se necesita para un sistema de registro: "
"a la mayoría de los usuarios no les importan los errores en el sistema de "
"registro, están más interesados en los errores de la aplicación. Sin "
"embargo, puede reemplazar esto con un gestor personalizado si lo desea. El "
"registro especificado es el que se estaba procesando cuando se produjo la "
"excepción. (El valor predeterminado de ``raiseExceptions`` es `` True``, ya "
"que es más útil durante el desarrollo)."

#: ../Doc/library/logging.rst:494
msgid ""
"Do formatting for a record - if a formatter is set, use it. Otherwise, use "
"the default formatter for the module."
msgstr ""
"Formato para un registro - si se configura un formateador, úselo. De lo "
"contrario, use el formateador predeterminado para el módulo."

#: ../Doc/library/logging.rst:500
msgid ""
"Do whatever it takes to actually log the specified logging record. This "
"version is intended to be implemented by subclasses and so raises a :exc:"
"`NotImplementedError`."
msgstr ""
"Haga lo que sea necesario para registrar de forma especifica el registro. "
"Esta versión está destinada a ser implementada por subclases y, por lo "
"tanto, lanza un :exc:`NotImplementedError`."

#: ../Doc/library/logging.rst:504
msgid ""
"For a list of handlers included as standard, see :mod:`logging.handlers`."
msgstr ""
"Para obtener una lista de gestores incluidos como estándar, consulte :mod:"
"`logging.handlers`."

#: ../Doc/library/logging.rst:509
msgid "Formatter Objects"
msgstr "Objetos formateadores"

#: ../Doc/library/logging.rst:513
#, python-format
msgid ""
":class:`Formatter` objects have the following attributes and methods. They "
"are responsible for converting a :class:`LogRecord` to (usually) a string "
"which can be interpreted by either a human or an external system. The base :"
"class:`Formatter` allows a formatting string to be specified. If none is "
"supplied, the default value of ``'%(message)s'`` is used, which just "
"includes the message in the logging call. To have additional items of "
"information in the formatted output (such as a timestamp), keep reading."
msgstr ""
":class:`Formatter` tiene los siguientes atributos y métodos. Son "
"responsables de convertir una :class:`LogRecord` a (generalmente) una cadena "
"que puede ser interpretada por un sistema humano o externo. La base :class:"
"`Formatter` permite especificar una cadena de formato. Si no se proporciona "
"ninguno, se utiliza el valor predeterminado de ``'%(message)s'``, que solo "
"incluye el mensaje en la llamada de registro. Para tener elementos de "
"información adicionales en la salida formateada (como una marca de tiempo), "
"siga leyendo."

#: ../Doc/library/logging.rst:521
#, python-format
msgid ""
"A Formatter can be initialized with a format string which makes use of "
"knowledge of the :class:`LogRecord` attributes - such as the default value "
"mentioned above making use of the fact that the user's message and arguments "
"are pre-formatted into a :class:`LogRecord`'s *message* attribute.  This "
"format string contains standard Python %-style mapping keys. See section :"
"ref:`old-string-formatting` for more information on string formatting."
msgstr ""
"Un formateador se puede inicializar con una cadena de formato que utiliza el "
"conocimiento de los atributos :class:`LogRecord`, como el valor "
"predeterminado mencionado anteriormente, haciendo uso del hecho de que el "
"mensaje y los argumentos del usuario están formateados previamente en :class:"
"`LogRecord`'s con *message* como atributo. Esta cadena de formato contiene "
"claves de mapeo de Python %-style estándar. Ver la sección :ref:`old-string-"
"formatting` para obtener más información sobre el formato de cadenas."

#: ../Doc/library/logging.rst:528
msgid ""
"The useful mapping keys in a :class:`LogRecord` are given in the section on :"
"ref:`logrecord-attributes`."
msgstr ""
"Las claves de mapeo útiles en a :class:`LogRecord` se dan en la sección "
"sobre :ref:`logrecord-attributes`."

#: ../Doc/library/logging.rst:534
#, python-format
msgid ""
"Returns a new instance of the :class:`Formatter` class.  The instance is "
"initialized with a format string for the message as a whole, as well as a "
"format string for the date/time portion of a message.  If no *fmt* is "
"specified, ``'%(message)s'`` is used.  If no *datefmt* is specified, a "
"format is used which is described in the :meth:`formatTime` documentation."
msgstr ""
"Retorna una nueva instancia de :class:`Formatter`. La instancia se "
"inicializa con una cadena de formato para el mensaje en su conjunto, así "
"como una cadena de formato para la porción fecha/hora de un mensaje. Si no "
"se especifica *fmt*, se utiliza ``'%(message)s'``. Si no se especifica "
"*datefmt*, se utiliza un formato que se describe en la documentación :meth:"
"`formatTime`."

#: ../Doc/library/logging.rst:540
#, python-format
msgid ""
"The *style* parameter can be one of '%', '{' or '$' and determines how the "
"format string will be merged with its data: using one of %-formatting, :meth:"
"`str.format` or :class:`string.Template`. This only applies to the format "
"string *fmt* (e.g. ``'%(message)s'`` or ``{message}``), not to the actual "
"log messages passed to ``Logger.debug`` etc; see :ref:`formatting-styles` "
"for more information on using {- and $-formatting for log messages."
msgstr ""
"El parámetro *style* puede ser uno de '%', '{'' o '$' y determina cómo se "
"fusionará la cadena de formato con sus datos: usando uno de %-formatting, :"
"meth:`str.format` o :class:`string.Template`. Esto solo aplica al formato de "
"cadenas de caracteres *fmt* (e.j. ``'%(message)s'`` o ``{message}``), no al "
"mensaje pasado actualmente al ``Logger.debug`` etc; ver :ref:`formatting-"
"styles` para más información sobre usar {- y formateado-$ para mensajes de "
"log."

#: ../Doc/library/logging.rst:548
msgid "The *style* parameter was added."
msgstr "Se agregó el parámetro *style*."

#: ../Doc/library/logging.rst:551
#, python-format
msgid ""
"The *validate* parameter was added. Incorrect or mismatched style and fmt "
"will raise a ``ValueError``. For example: ``logging.Formatter('%(asctime)s - "
"%(message)s', style='{')``."
msgstr ""
"Se agregó el parámetro *validate*. Si el estilo es incorrecto o no "
"coincidente, *fmt* lanzará un ``ValueError``. Por ejemplo: ``logging."
"Formatter('%(asctime)s - %(message)s', style='{')``."

#: ../Doc/library/logging.rst:558
msgid ""
"The record's attribute dictionary is used as the operand to a string "
"formatting operation. Returns the resulting string. Before formatting the "
"dictionary, a couple of preparatory steps are carried out. The *message* "
"attribute of the record is computed using *msg* % *args*. If the formatting "
"string contains ``'(asctime)'``, :meth:`formatTime` is called to format the "
"event time. If there is exception information, it is formatted using :meth:"
"`formatException` and appended to the message. Note that the formatted "
"exception information is cached in attribute *exc_text*. This is useful "
"because the exception information can be pickled and sent across the wire, "
"but you should be careful if you have more than one :class:`Formatter` "
"subclass which customizes the formatting of exception information. In this "
"case, you will have to clear the cached value after a formatter has done its "
"formatting, so that the next formatter to handle the event doesn't use the "
"cached value but recalculates it afresh."
msgstr ""
"El diccionario de atributos del registro se usa como el operando de una "
"operación para formateo de cadenas. Retorna la cadena resultante. Antes de "
"formatear el diccionario, se llevan a cabo un par de pasos preparatorios. El "
"atributo *message* del registro se calcula usando *msg* % *args*. Si el "
"formato de la cadena contiene ``'(asctime)'``, :meth:`formatTime` es llamado "
"para dar formato al evento. Si hay información sobre la excepción, se "
"formatea usando :meth:`formatException` y se adjunta al mensaje. Tenga en "
"cuenta que la información de excepción formateada se almacena en caché en el "
"atributo *exc_text*. Esto es útil porque la información de excepción se "
"puede *pickled* y propagarse en el cable, pero debe tener cuidado si tiene "
"más de una subclase :class:`Formatter` que personaliza el formato de la "
"información de la excepción. En este caso, tendrá que borrar el valor "
"almacenado en caché después de que un formateador haya terminado su "
"formateo, para que el siguiente formateador que maneje el evento no use el "
"valor almacenado en caché sino que lo recalcule."

#: ../Doc/library/logging.rst:574
msgid ""
"If stack information is available, it's appended after the exception "
"information, using :meth:`formatStack` to transform it if necessary."
msgstr ""
"Si la información de la pila está disponible, se agrega después de la "
"información de la excepción, usando :meth:`formatStack` para transformarla "
"si es necesario."

#: ../Doc/library/logging.rst:580
#, python-format
msgid ""
"This method should be called from :meth:`format` by a formatter which wants "
"to make use of a formatted time. This method can be overridden in formatters "
"to provide for any specific requirement, but the basic behavior is as "
"follows: if *datefmt* (a string) is specified, it is used with :func:`time."
"strftime` to format the creation time of the record. Otherwise, the format "
"'%Y-%m-%d %H:%M:%S,uuu' is used, where the uuu part is a millisecond value "
"and the other letters are as per the :func:`time.strftime` documentation.  "
"An example time in this format is ``2003-01-23 00:29:50,411``.  The "
"resulting string is returned."
msgstr ""
"Este método debe ser llamado desde :meth:`format` por un formateador que "
"espera un tiempo formateado . Este método se puede reemplazar en "
"formateadores para proporcionar cualquier requisito específico, pero el "
"comportamiento básico es el siguiente: if *datefmt* (una cadena), se usa "
"con :func:`time.strftime` para formatear el tiempo de creación del registro "
"De lo contrario, se utiliza el formato '%Y-%m-%d %H:%M:%S,uuu', donde la "
"parte *uuu* es un valor de milisegundos y las otras letras son :func:`time."
"strftime` . Un ejemplo de tiempo en este formato es ``2003-01-23 "
"00:29:50,411``. Se retorna la cadena resultante."

#: ../Doc/library/logging.rst:590
msgid ""
"This function uses a user-configurable function to convert the creation time "
"to a tuple. By default, :func:`time.localtime` is used; to change this for a "
"particular formatter instance, set the ``converter`` attribute to a function "
"with the same signature as :func:`time.localtime` or :func:`time.gmtime`. To "
"change it for all formatters, for example if you want all logging times to "
"be shown in GMT, set the ``converter`` attribute in the ``Formatter`` class."
msgstr ""
"Esta función utiliza una función configurable por el usuario para convertir "
"el tiempo de creación en una tupla. Por defecto, se utiliza :func:`time."
"localtime`; Para cambiar esto para una instancia de formateador particular, "
"se agrega el atributo ``converter`` en una función con igual firma como :"
"func:`time.localtime` o :func:`time.gmtime`. Para cambiarlo en todos los "
"formateadores, por ejemplo, si desea que todos los tiempos de registro se "
"muestren en GMT, agregue el atributo ``converter`` en la clase ``Formatter``."

#: ../Doc/library/logging.rst:598
#, python-format
msgid ""
"Previously, the default format was hard-coded as in this example: "
"``2010-09-06 22:38:15,292`` where the part before the comma is handled by a "
"strptime format string (``'%Y-%m-%d %H:%M:%S'``), and the part after the "
"comma is a millisecond value. Because strptime does not have a format "
"placeholder for milliseconds, the millisecond value is appended using "
"another format string, ``'%s,%03d'`` --- and both of these format strings "
"have been hardcoded into this method. With the change, these strings are "
"defined as class-level attributes which can be overridden at the instance "
"level when desired. The names of the attributes are ``default_time_format`` "
"(for the strptime format string) and ``default_msec_format`` (for appending "
"the millisecond value)."
msgstr ""
"Anteriormente, el formato predeterminado estaba codificado como en este "
"ejemplo: ``2010-09-06 22:38:15,292`` donde la parte anterior a la coma es "
"manejada por una cadena de formato strptime (``'%Y-%m-%d %H:%M:%S'``), y la "
"parte después de la coma es un valor de milisegundos. Debido a que strptime "
"no tiene una posición de formato para milisegundos, el valor de milisegundos "
"se agrega usando otra cadena de formato, ``'%s,%03d'``--- ambas cadenas de "
"formato se han codificado en este método. Con el cambio, estas cadenas se "
"definen como atributos de nivel de clase que pueden *overridden* a nivel de "
"instancia cuando se desee. Los nombres de los atributos son "
"``default_time_format`` (para una cadena de formato strptime) y "
"``default_msec_format`` (para agregar el valor de milisegundos)."

#: ../Doc/library/logging.rst:611
msgid "The ``default_msec_format`` can be ``None``."
msgstr ""

#: ../Doc/library/logging.rst:616
msgid ""
"Formats the specified exception information (a standard exception tuple as "
"returned by :func:`sys.exc_info`) as a string. This default implementation "
"just uses :func:`traceback.print_exception`. The resulting string is "
"returned."
msgstr ""
"Formatea la información de una excepción especificada (una excepción como "
"una tupla estándar es retornada por :func:`sys.exc_info`) como una cadena. "
"Esta implementación predeterminada solo usa :func:`traceback."
"print_exception`. La cadena resultantes retornada."

#: ../Doc/library/logging.rst:623
msgid ""
"Formats the specified stack information (a string as returned by :func:"
"`traceback.print_stack`, but with the last newline removed) as a string. "
"This default implementation just returns the input value."
msgstr ""
"Formatea la información de una pila especificada (una cadena es retornada "
"por :func:`traceback.print_stack`, pero con la ultima línea removida) como "
"una cadena. Esta implementación predeterminada solo retorna el valor de "
"entrada."

#: ../Doc/library/logging.rst:630
msgid "Filter Objects"
msgstr "Filtro de Objetos"

#: ../Doc/library/logging.rst:632
msgid ""
"``Filters`` can be used by ``Handlers`` and ``Loggers`` for more "
"sophisticated filtering than is provided by levels. The base filter class "
"only allows events which are below a certain point in the logger hierarchy. "
"For example, a filter initialized with 'A.B' will allow events logged by "
"loggers 'A.B', 'A.B.C', 'A.B.C.D', 'A.B.D' etc. but not 'A.BB', 'B.A.B' etc. "
"If initialized with the empty string, all events are passed."
msgstr ""
"Los ``Manejadores`` y los ``Registradores`` pueden usar los ``Filtros`` para "
"un filtrado más sofisticado que el proporcionado por los niveles. La clase "
"de filtro base solo permite eventos que están por debajo de cierto punto en "
"la jerarquía del logger. Por ejemplo, un filtro inicializado con 'A.B' "
"permitirá los eventos registrados por los logger 'A.B', 'A.B.C', 'A.B.C.D', "
"'A.B.D' etc., pero no 'A.BB', 'B.A.B', etc. Si se inicializa con una cadena "
"vacía, se pasan todos los eventos."

#: ../Doc/library/logging.rst:642
msgid ""
"Returns an instance of the :class:`Filter` class. If *name* is specified, it "
"names a logger which, together with its children, will have its events "
"allowed through the filter. If *name* is the empty string, allows every "
"event."
msgstr ""
"Retorna una instancia de la clase :class:`Filter`. Si se especifica *name*, "
"nombra un logger que, junto con sus hijos, tendrá sus eventos permitidos a "
"través del filtro. Si *name* es una cadena vacía, permite todos los eventos."

#: ../Doc/library/logging.rst:649
msgid ""
"Is the specified record to be logged? Returns zero for no, nonzero for yes. "
"If deemed appropriate, the record may be modified in-place by this method."
msgstr ""
"¿Se apuntará el registro especificado? Retorna cero para no, distinto de "
"cero para sí. Si se considera apropiado, el registro puede modificarse in "
"situ mediante este método."

#: ../Doc/library/logging.rst:653
msgid ""
"Note that filters attached to handlers are consulted before an event is "
"emitted by the handler, whereas filters attached to loggers are consulted "
"whenever an event is logged (using :meth:`debug`, :meth:`info`, etc.), "
"before sending an event to handlers. This means that events which have been "
"generated by descendant loggers will not be filtered by a logger's filter "
"setting, unless the filter has also been applied to those descendant loggers."
msgstr ""
"Tenga en cuenta que los filtros adjuntos a los gestores se consultan antes "
"de que el gestor emita un evento, mientras que los filtros adjuntos a los "
"loggers se consultan cada vez que se registra un evento (usando :meth:"
"`debug`, :meth:`info`, etc.), antes de enviar un evento a los gestores. Esto "
"significa que los eventos que han sido generados por loggers descendientes "
"no serán filtrados por la configuración del filtro del logger, a menos que "
"el filtro también se haya aplicado a esos loggers descendientes."

#: ../Doc/library/logging.rst:660
msgid ""
"You don't actually need to subclass ``Filter``: you can pass any instance "
"which has a ``filter`` method with the same semantics."
msgstr ""
"En realidad, no se necesita la subclase ``Filtro``: se puede pasar cualquier "
"instancia que tenga un método de ``filter`` con la misma semántica."

#: ../Doc/library/logging.rst:663
msgid ""
"You don't need to create specialized ``Filter`` classes, or use other "
"classes with a ``filter`` method: you can use a function (or other callable) "
"as a filter. The filtering logic will check to see if the filter object has "
"a ``filter`` attribute: if it does, it's assumed to be a ``Filter`` and its :"
"meth:`~Filter.filter` method is called. Otherwise, it's assumed to be a "
"callable and called with the record as the single parameter. The returned "
"value should conform to that returned by :meth:`~Filter.filter`."
msgstr ""
"No es necesario crear clases especializadas de ``Filter`` ni usar otras "
"clases con un método ``filter``: puede usar una función (u otra invocable) "
"como filtro. La lógica de filtrado verificará si el objeto de filtro tiene "
"un atributo ``filter``: si lo tiene, se asume que es un ``Filter`` y se "
"llama a su método :meth:`~Filter.filter`. De lo contrario, se supone que es "
"invocable y se llama con el registro como único parámetro. El valor "
"retornado debe ajustarse al retornado por :meth:`~Filter.filter`."

#: ../Doc/library/logging.rst:673
msgid ""
"Although filters are used primarily to filter records based on more "
"sophisticated criteria than levels, they get to see every record which is "
"processed by the handler or logger they're attached to: this can be useful "
"if you want to do things like counting how many records were processed by a "
"particular logger or handler, or adding, changing or removing attributes in "
"the :class:`LogRecord` being processed. Obviously changing the LogRecord "
"needs to be done with some care, but it does allow the injection of "
"contextual information into logs (see :ref:`filters-contextual`)."
msgstr ""
"Aunque los filtros se utilizan principalmente para filtrar registros basados ​​"
"en criterios más sofisticados que los niveles, son capaces de ver cada "
"registro que es procesado por el gestor o logger al que están adjuntos: esto "
"puede ser útil si desea hacer cosas como contar cuántos registros fueron "
"procesados por un logger o gestor en particular, o agregando, cambiando o "
"quitando atributos en :class:`LogRecord` que se está procesando. Obviamente, "
"el cambio de LogRecord debe hacerse con cierto cuidado, pero permite la "
"inyección de información contextual en los registros (ver :ref:`filters-"
"contextual`)."

#: ../Doc/library/logging.rst:685
msgid "LogRecord Objects"
msgstr "Objetos LogRecord"

#: ../Doc/library/logging.rst:687
msgid ""
":class:`LogRecord` instances are created automatically by the :class:"
"`Logger` every time something is logged, and can be created manually via :"
"func:`makeLogRecord` (for example, from a pickled event received over the "
"wire)."
msgstr ""
"Las instancias :class:`LogRecord` son creadas automáticamente por :class:"
"`Logger` cada vez que se registra algo, y se pueden crear manualmente a "
"través de :func:`makeLogRecord` (por ejemplo, a partir de un evento "
"serializado (*pickled*) recibido en la transmisión)."

#: ../Doc/library/logging.rst:695
msgid "Contains all the information pertinent to the event being logged."
msgstr "Contiene toda la información pertinente al evento que se registra."

#: ../Doc/library/logging.rst:697
msgid ""
"The primary information is passed in :attr:`msg` and :attr:`args`, which are "
"combined using ``msg % args`` to create the :attr:`message` field of the "
"record."
msgstr ""
"La información principal se pasa en :attr:`msg` y :attr:`args`, que se "
"combinan usando ``msg % args`` para crear el campo :attr:`message` del "
"registro."

#: ../Doc/library/logging.rst
msgid "Parameters"
msgstr "Parámetros"

#: ../Doc/library/logging.rst:701
msgid ""
"The name of the logger used to log the event represented by this LogRecord. "
"Note that this name will always have this value, even though it may be "
"emitted by a handler attached to a different (ancestor) logger."
msgstr ""
"El nombre del logger utilizado para registrar el evento representado por "
"este LogRecord. Tenga en cuenta que este nombre siempre tendrá este valor, "
"aunque puede ser emitido por un gestor adjunto a un logger diferente "
"(ancestro)."

#: ../Doc/library/logging.rst:705
msgid ""
"The numeric level of the logging event (one of DEBUG, INFO etc.) Note that "
"this is converted to *two* attributes of the LogRecord: ``levelno`` for the "
"numeric value and ``levelname`` for the corresponding level name."
msgstr ""
"El nivel numérico del evento logging (uno de DEBUG, INFO, etc.) Tenga en "
"cuenta que esto se convierte en *dos* atributos de LogRecord:``levelno`` "
"para el valor numérico y ``levelname`` para el nombre del nivel "
"correspondiente ."

#: ../Doc/library/logging.rst:709
msgid "The full pathname of the source file where the logging call was made."
msgstr ""
"El nombre de ruta completo del archivo de origen donde se realizó la llamada "
"logging."

#: ../Doc/library/logging.rst:711
msgid "The line number in the source file where the logging call was made."
msgstr ""
"El número de línea en el archivo de origen donde se realizó la llamada "
"logging."

#: ../Doc/library/logging.rst:713
msgid ""
"The event description message, possibly a format string with placeholders "
"for variable data."
msgstr ""
"El mensaje de descripción del evento, posiblemente una cadena de formato con "
"marcadores de posición para datos variables."

#: ../Doc/library/logging.rst:715
msgid ""
"Variable data to merge into the *msg* argument to obtain the event "
"description."
msgstr ""
"Datos variables para fusionar en el argumento *msg* para obtener la "
"descripción del evento."

#: ../Doc/library/logging.rst:717
msgid ""
"An exception tuple with the current exception information, or ``None`` if no "
"exception information is available."
msgstr ""
"Una tupla de excepción con la información de excepción actual, o ``None`` si "
"no hay información de excepción disponible."

#: ../Doc/library/logging.rst:719
msgid ""
"The name of the function or method from which the logging call was invoked."
msgstr ""
"El nombre de la función o método desde el que se invocó la llamada de "
"logging."

#: ../Doc/library/logging.rst:721
msgid ""
"A text string representing stack information from the base of the stack in "
"the current thread, up to the logging call."
msgstr ""
"Una cadena de texto que representa la información de la pila desde la base "
"de la pila en el hilo actual, hasta la llamada de logging."

#: ../Doc/library/logging.rst:726
msgid ""
"Returns the message for this :class:`LogRecord` instance after merging any "
"user-supplied arguments with the message. If the user-supplied message "
"argument to the logging call is not a string, :func:`str` is called on it to "
"convert it to a string. This allows use of user-defined classes as messages, "
"whose ``__str__`` method can return the actual format string to be used."
msgstr ""
"Retorna el mensaje para la instancia :class:`LogRecord` después de fusionar "
"cualquier argumento proporcionado por el usuario con el mensaje. Si el "
"argumento del mensaje proporcionado por el usuario para la llamada de "
"logging no es una cadena de caracteres, se invoca :func:`str` para "
"convertirlo en una cadena. Esto permite el uso de clases definidas por el "
"usuario como mensajes, cuyo método ``__str__`` puede retornar la cadena de "
"formato real que se utilizará."

#: ../Doc/library/logging.rst:733
msgid ""
"The creation of a :class:`LogRecord` has been made more configurable by "
"providing a factory which is used to create the record. The factory can be "
"set using :func:`getLogRecordFactory` and :func:`setLogRecordFactory` (see "
"this for the factory's signature)."
msgstr ""
"La creación de :class:`LogRecord` se ha hecho más configurable al "
"proporcionar una fábrica que se utiliza para crear el registro. La fábrica "
"se puede configurar usando :func:`getLogRecordFactory` y :func:"
"`setLogRecordFactory` (ver esto para la firma de la fábrica)."

#: ../Doc/library/logging.rst:739
msgid ""
"This functionality can be used to inject your own values into a :class:"
"`LogRecord` at creation time. You can use the following pattern::"
msgstr ""
"Esta funcionalidad se puede utilizar para inyectar sus propios valores en :"
"class:`LogRecord` en el momento de la creación. Puede utilizar el siguiente "
"patrón::"

#: ../Doc/library/logging.rst:751
msgid ""
"With this pattern, multiple factories could be chained, and as long as they "
"don't overwrite each other's attributes or unintentionally overwrite the "
"standard attributes listed above, there should be no surprises."
msgstr ""
"Con este patrón, se podrían encadenar varias fábricas y, siempre que no "
"sobrescriban los atributos de las demás o se sobrescriban involuntariamente "
"los atributos estándar enumerados anteriormente, no debería haber sorpresas."

#: ../Doc/library/logging.rst:760
msgid "LogRecord attributes"
msgstr "Atributos LogRecord"

#: ../Doc/library/logging.rst:762
#, python-format
msgid ""
"The LogRecord has a number of attributes, most of which are derived from the "
"parameters to the constructor. (Note that the names do not always correspond "
"exactly between the LogRecord constructor parameters and the LogRecord "
"attributes.) These attributes can be used to merge data from the record into "
"the format string. The following table lists (in alphabetical order) the "
"attribute names, their meanings and the corresponding placeholder in a "
"%-style format string."
msgstr ""
"LogRecord tiene varios atributos, la mayoría de los cuales se derivan de los "
"parámetros del constructor. (Tenga en cuenta que los nombres no siempre se "
"corresponden exactamente entre los parámetros del constructor de LogRecord y "
"los atributos de LogRecord). Estos atributos se pueden usar para combinar "
"datos del registro en la cadena de formato. La siguiente tabla enumera (en "
"orden alfabético) los nombres de los atributos, sus significados y el "
"marcador de posición correspondiente en una cadena de formato %."

#: ../Doc/library/logging.rst:770
msgid ""
"If you are using {}-formatting (:func:`str.format`), you can use ``{attrname}"
"`` as the placeholder in the format string. If you are using $-formatting (:"
"class:`string.Template`), use the form ``${attrname}``. In both cases, of "
"course, replace ``attrname`` with the actual attribute name you want to use."
msgstr ""
"Si utilizas formato-{} (:func:`str.format`), puedes usar ``{attrname}`` como "
"marcador de posición en la cadena de caracteres de formato. Si está "
"utilizando formato-$ (:class:`string.Template`), use la forma ``${attrname}"
"``. En ambos casos, por supuesto, reemplace` `attrname`` con el nombre de "
"atributo real que desea utilizar."

#: ../Doc/library/logging.rst:776
msgid ""
"In the case of {}-formatting, you can specify formatting flags by placing "
"them after the attribute name, separated from it with a colon. For example: "
"a placeholder of ``{msecs:03d}`` would format a millisecond value of ``4`` "
"as ``004``. Refer to the :meth:`str.format` documentation for full details "
"on the options available to you."
msgstr ""
"En el caso del formato-{}, puede especificar *flags* de formato colocándolos "
"después del nombre del atributo, separados con dos puntos. Por ejemplo: un "
"marcador de posición de ``{msecs:03d}`` formateará un valor de milisegundos "
"de ``4`` como ``004``. Consulte la documentación :meth:`str.format` para "
"obtener detalles completos sobre las opciones disponibles."

#: ../Doc/library/logging.rst:783
msgid "Attribute name"
msgstr "Nombre del atributo"

#: ../Doc/library/logging.rst:783 ../Doc/library/logging.rst:1168
msgid "Format"
msgstr "Formato"

#: ../Doc/library/logging.rst:783 ../Doc/library/logging.rst:1168
msgid "Description"
msgstr "Descripción"

#: ../Doc/library/logging.rst ../Doc/library/logging.rst:785
msgid "args"
msgstr "args"

#: ../Doc/library/logging.rst:785 ../Doc/library/logging.rst:799
#: ../Doc/library/logging.rst:827 ../Doc/library/logging.rst:845
msgid "You shouldn't need to format this yourself."
msgstr "No debería necesitar formatear esto usted mismo."

#: ../Doc/library/logging.rst:785
msgid ""
"The tuple of arguments merged into ``msg`` to produce ``message``, or a dict "
"whose values are used for the merge (when there is only one argument, and it "
"is a dictionary)."
msgstr ""
"La tupla de argumentos se fusionó en ``msg`` para producir un ``messsage``, "
"o un dict cuyos valores se utilizan para la fusión (cuando solo hay un "
"argumento y es un diccionario)."

#: ../Doc/library/logging.rst:790
msgid "asctime"
msgstr "asctime"

#: ../Doc/library/logging.rst:790
#, python-format
msgid "``%(asctime)s``"
msgstr "``%(asctime)s``"

#: ../Doc/library/logging.rst:790
msgid ""
"Human-readable time when the :class:`LogRecord` was created.  By default "
"this is of the form '2003-07-08 16:49:45,896' (the numbers after the comma "
"are millisecond portion of the time)."
msgstr ""
"Fecha y Hora en formato legible por humanos cuando se creó :class:"
"`LogRecord`. De forma predeterminada, tiene el formato '2003-07-08 16: 49: "
"45,896' (los números después de la coma son milisegundos)."

#: ../Doc/library/logging.rst:796
msgid "created"
msgstr "created"

#: ../Doc/library/logging.rst:796
#, python-format
msgid "``%(created)f``"
msgstr "``%(created)f``"

#: ../Doc/library/logging.rst:796
msgid ""
"Time when the :class:`LogRecord` was created (as returned by :func:`time."
"time`)."
msgstr ""
"Tiempo en que se creó :class:`LogRecord` (según lo retornado por :func:`time."
"time`)."

#: ../Doc/library/logging.rst ../Doc/library/logging.rst:799
msgid "exc_info"
msgstr "exc_info"

#: ../Doc/library/logging.rst:799
msgid ""
"Exception tuple (à la ``sys.exc_info``) or, if no exception has occurred, "
"``None``."
msgstr ""
"Tupla de excepción (al modo ``sys.exc_info``) o, si no se ha producido "
"ninguna excepción, ``None``."

#: ../Doc/library/logging.rst:802
msgid "filename"
msgstr "filename"

#: ../Doc/library/logging.rst:802
#, python-format
msgid "``%(filename)s``"
msgstr "``%(filename)s``"

#: ../Doc/library/logging.rst:802
msgid "Filename portion of ``pathname``."
msgstr "Parte del nombre de archivo de ``pathname``."

#: ../Doc/library/logging.rst:804
msgid "funcName"
msgstr "funcName"

#: ../Doc/library/logging.rst:804
#, python-format
msgid "``%(funcName)s``"
msgstr "``%(funcName)s``"

#: ../Doc/library/logging.rst:804
msgid "Name of function containing the logging call."
msgstr "Nombre de la función que contiene la llamada de logging."

#: ../Doc/library/logging.rst:806
msgid "levelname"
msgstr "levelname"

#: ../Doc/library/logging.rst:806
#, python-format
msgid "``%(levelname)s``"
msgstr "``%(levelname)s``"

#: ../Doc/library/logging.rst:806
msgid ""
"Text logging level for the message (``'DEBUG'``, ``'INFO'``, ``'WARNING'``, "
"``'ERROR'``, ``'CRITICAL'``)."
msgstr ""
"Texto de nivel de logging para el mensaje (``'DEBUG'``, ``'INFO'``, "
"``'WARNING'``, ``'ERROR'``, ``'CRITICAL'``)."

#: ../Doc/library/logging.rst:810
msgid "levelno"
msgstr "levelno"

#: ../Doc/library/logging.rst:810
#, python-format
msgid "``%(levelno)s``"
msgstr "``%(levelno)s``"

#: ../Doc/library/logging.rst:810
msgid ""
"Numeric logging level for the message (:const:`DEBUG`, :const:`INFO`, :const:"
"`WARNING`, :const:`ERROR`, :const:`CRITICAL`)."
msgstr ""
"Número de nivel de logging para el mensaje (:const:`DEBUG`, :const:`INFO`, :"
"const:`WARNING`, :const:`ERROR`, :const:`CRITICAL`)."

#: ../Doc/library/logging.rst:815
msgid "lineno"
msgstr "lineno"

#: ../Doc/library/logging.rst:815
#, python-format
msgid "``%(lineno)d``"
msgstr "``%(lineno)d``"

#: ../Doc/library/logging.rst:815
msgid "Source line number where the logging call was issued (if available)."
msgstr ""
"Número de línea original donde se emitió la llamada de logging (si está "
"disponible)."

#: ../Doc/library/logging.rst:818
msgid "message"
msgstr "message"

#: ../Doc/library/logging.rst:818
#, python-format
msgid "``%(message)s``"
msgstr "``%(message)s``"

#: ../Doc/library/logging.rst:818
msgid ""
"The logged message, computed as ``msg % args``. This is set when :meth:"
"`Formatter.format` is invoked."
msgstr ""
"El mensaje registrado, computado como ``msg % args``. Esto se establece "
"cuando se invoca :meth:`Formatter.format`."

#: ../Doc/library/logging.rst:822
msgid "module"
msgstr "module"

#: ../Doc/library/logging.rst:822
#, python-format
msgid "``%(module)s``"
msgstr "``%(module)s``"

#: ../Doc/library/logging.rst:822
msgid "Module (name portion of ``filename``)."
msgstr "Módulo (parte del nombre de ``filename``)."

#: ../Doc/library/logging.rst:824
msgid "msecs"
msgstr "msecs"

#: ../Doc/library/logging.rst:824
#, python-format
msgid "``%(msecs)d``"
msgstr "``%(msecs)d``"

#: ../Doc/library/logging.rst:824
msgid ""
"Millisecond portion of the time when the :class:`LogRecord` was created."
msgstr "Porción de milisegundos del tiempo en que se creó :class:`LogRecord`."

#: ../Doc/library/logging.rst ../Doc/library/logging.rst:827
msgid "msg"
msgstr "msg"

#: ../Doc/library/logging.rst:827
msgid ""
"The format string passed in the original logging call. Merged with ``args`` "
"to produce ``message``, or an arbitrary object (see :ref:`arbitrary-object-"
"messages`)."
msgstr ""
"La cadena de caracteres de formato pasada en la llamada logging original. Se "
"fusionó con ``args`` para producir un ``message``, o un objeto arbitrario "
"(ver :ref:`arbitrary-object-messages`)."

#: ../Doc/library/logging.rst ../Doc/library/logging.rst:832
msgid "name"
msgstr "name"

#: ../Doc/library/logging.rst:832
#, python-format
msgid "``%(name)s``"
msgstr "``%(name)s``"

#: ../Doc/library/logging.rst:832
msgid "Name of the logger used to log the call."
msgstr "Nombre del logger usado para registrar la llamada."

#: ../Doc/library/logging.rst:834
msgid "pathname"
msgstr "pathname"

#: ../Doc/library/logging.rst:834
#, python-format
msgid "``%(pathname)s``"
msgstr "``%(pathname)s``"

#: ../Doc/library/logging.rst:834
msgid ""
"Full pathname of the source file where the logging call was issued (if "
"available)."
msgstr ""
"Nombre de ruta completo del archivo de origen donde se emitió la llamada de "
"logging (si está disponible)."

#: ../Doc/library/logging.rst:837
msgid "process"
msgstr "process"

#: ../Doc/library/logging.rst:837
#, python-format
msgid "``%(process)d``"
msgstr "``%(process)d``"

#: ../Doc/library/logging.rst:837
msgid "Process ID (if available)."
msgstr "ID de proceso (si está disponible)."

#: ../Doc/library/logging.rst:839
msgid "processName"
msgstr "processName"

#: ../Doc/library/logging.rst:839
#, python-format
msgid "``%(processName)s``"
msgstr "``%(processName)s``"

#: ../Doc/library/logging.rst:839
msgid "Process name (if available)."
msgstr "Nombre del proceso (si está disponible)."

#: ../Doc/library/logging.rst:841
msgid "relativeCreated"
msgstr "relativeCreated"

#: ../Doc/library/logging.rst:841
#, python-format
msgid "``%(relativeCreated)d``"
msgstr "``%(relativeCreated)d``"

#: ../Doc/library/logging.rst:841
msgid ""
"Time in milliseconds when the LogRecord was created, relative to the time "
"the logging module was loaded."
msgstr ""
"Tiempo en milisegundos cuando se creó el LogRecord, en relación con el "
"tiempo en que se cargó el módulo logging."

#: ../Doc/library/logging.rst:845
msgid "stack_info"
msgstr "stack_info"

#: ../Doc/library/logging.rst:845
msgid ""
"Stack frame information (where available) from the bottom of the stack in "
"the current thread, up to and including the stack frame of the logging call "
"which resulted in the creation of this record."
msgstr ""
"Apila la información del marco (si está disponible) desde la parte inferior "
"de la pila en el hilo actual hasta la llamada de registro que dio como "
"resultado la generación de este registro."

#: ../Doc/library/logging.rst:851
msgid "thread"
msgstr "thread"

#: ../Doc/library/logging.rst:851
#, python-format
msgid "``%(thread)d``"
msgstr "``%(thread)d``"

#: ../Doc/library/logging.rst:851
msgid "Thread ID (if available)."
msgstr "ID de hilo (si está disponible)."

#: ../Doc/library/logging.rst:853
msgid "threadName"
msgstr "threadName"

#: ../Doc/library/logging.rst:853
#, python-format
msgid "``%(threadName)s``"
msgstr "``%(threadName)s``"

#: ../Doc/library/logging.rst:853
msgid "Thread name (if available)."
msgstr "Nombre del hilo (si está disponible)."

#: ../Doc/library/logging.rst:856
msgid "*processName* was added."
msgstr "*processName* fue agregado."

#: ../Doc/library/logging.rst:863
msgid "LoggerAdapter Objects"
msgstr "Objetos LoggerAdapter"

#: ../Doc/library/logging.rst:865
msgid ""
":class:`LoggerAdapter` instances are used to conveniently pass contextual "
"information into logging calls. For a usage example, see the section on :ref:"
"`adding contextual information to your logging output <context-info>`."
msgstr ""
"Las instancias :class:`LoggerAdapter` se utilizan para pasar "
"convenientemente información contextual en las llamadas de logging. Para ver "
"un ejemplo de uso, consulte la sección sobre :ref:`agregar información "
"contextual a su salida de logging <context-info>`."

#: ../Doc/library/logging.rst:871
msgid ""
"Returns an instance of :class:`LoggerAdapter` initialized with an "
"underlying :class:`Logger` instance and a dict-like object."
msgstr ""
"Retorna una instancia de :class:`LoggerAdapter` inicializada con una "
"instancia subyacente :class:`Logger` y un objeto del tipo *dict*."

#: ../Doc/library/logging.rst:876
msgid ""
"Modifies the message and/or keyword arguments passed to a logging call in "
"order to insert contextual information. This implementation takes the object "
"passed as *extra* to the constructor and adds it to *kwargs* using key "
"'extra'. The return value is a (*msg*, *kwargs*) tuple which has the "
"(possibly modified) versions of the arguments passed in."
msgstr ""
"Modifica el mensaje y/o los argumentos de palabra clave pasados a una "
"llamada de logging para insertar información contextual. Esta implementación "
"toma el objeto pasado como *extra* al constructor y lo agrega a *kwargs* "
"usando la clave 'extra'. El valor de retorno es una tupla (*msg*, *kwargs*) "
"que tiene las versiones (posiblemente modificadas) de los argumentos pasados."

#: ../Doc/library/logging.rst:882
msgid ""
"In addition to the above, :class:`LoggerAdapter` supports the following "
"methods of :class:`Logger`: :meth:`~Logger.debug`, :meth:`~Logger.info`, :"
"meth:`~Logger.warning`, :meth:`~Logger.error`, :meth:`~Logger.exception`, :"
"meth:`~Logger.critical`, :meth:`~Logger.log`, :meth:`~Logger.isEnabledFor`, :"
"meth:`~Logger.getEffectiveLevel`, :meth:`~Logger.setLevel` and :meth:"
"`~Logger.hasHandlers`. These methods have the same signatures as their "
"counterparts in :class:`Logger`, so you can use the two types of instances "
"interchangeably."
msgstr ""
"Además de lo anterior, :class:`LoggerAdapter` admite los siguientes métodos "
"de :class:`Logger`: :meth:`~Logger.debug`, :meth:`~Logger.info`, :meth:"
"`~Logger.warning`, :meth:`~Logger.error`, :meth:`~Logger.exception`, :meth:"
"`~Logger.critical`, :meth:`~Logger.log`, :meth:`~Logger.isEnabledFor`, :meth:"
"`~Logger.getEffectiveLevel`, :meth:`~Logger.setLevel` y :meth:`~Logger."
"hasHandlers`. Estos métodos tienen las mismas firmas que sus contrapartes "
"en :class:`Logger`, por lo que puede usar los dos tipos de instancias "
"indistintamente."

#: ../Doc/library/logging.rst:891
msgid ""
"The :meth:`~Logger.isEnabledFor`, :meth:`~Logger.getEffectiveLevel`, :meth:"
"`~Logger.setLevel` and :meth:`~Logger.hasHandlers` methods were added to :"
"class:`LoggerAdapter`.  These methods delegate to the underlying logger."
msgstr ""
"Los métodos :meth:`~Logger.isEnabledFor`, :meth:`~Logger."
"getEffectiveLevel`, :meth:`~Logger.setLevel` y :meth:`~Logger.hasHandlers` "
"se agregaron a :class:`LoggerAdapter` . Estos métodos se delegan al logger "
"subyacente."

#: ../Doc/library/logging.rst:898
msgid "Thread Safety"
msgstr "Seguridad del hilo"

#: ../Doc/library/logging.rst:900
msgid ""
"The logging module is intended to be thread-safe without any special work "
"needing to be done by its clients. It achieves this though using threading "
"locks; there is one lock to serialize access to the module's shared data, "
"and each handler also creates a lock to serialize access to its underlying I/"
"O."
msgstr ""
"El módulo logging está diseñado para ser seguro para subprocesos sin que sus "
"clientes tengan que realizar ningún trabajo especial. Lo logra mediante el "
"uso de bloqueos de hilos; hay un bloqueo para serializar el acceso a los "
"datos compartidos del módulo, y cada gestor también crea un bloqueo para "
"serializar el acceso a su E/S subyacente."

#: ../Doc/library/logging.rst:905
msgid ""
"If you are implementing asynchronous signal handlers using the :mod:`signal` "
"module, you may not be able to use logging from within such handlers. This "
"is because lock implementations in the :mod:`threading` module are not "
"always re-entrant, and so cannot be invoked from such signal handlers."
msgstr ""
"Si está implementando gestores de señales asíncronos usando el módulo :mod:"
"`signal`, es posible que no pueda usar logging desde dichos gestores. Esto "
"se debe a que las implementaciones de bloqueo en el módulo :mod:`threading` "
"no siempre son reentrantes y, por lo tanto, no se pueden invocar desde "
"dichos gestores de señales."

#: ../Doc/library/logging.rst:912
msgid "Module-Level Functions"
msgstr "Funciones a nivel de módulo"

#: ../Doc/library/logging.rst:914
msgid ""
"In addition to the classes described above, there are a number of module-"
"level functions."
msgstr ""
"Además de las clases descritas anteriormente, hay una serie de funciones a "
"nivel de módulo."

#: ../Doc/library/logging.rst:920
msgid ""
"Return a logger with the specified name or, if name is ``None``, return a "
"logger which is the root logger of the hierarchy. If specified, the name is "
"typically a dot-separated hierarchical name like *'a'*, *'a.b'* or *'a.b.c."
"d'*. Choice of these names is entirely up to the developer who is using "
"logging."
msgstr ""
"Retorna un logger con el nombre especificado o, si el nombre es ``None``, "
"retorna un logger que es el logger principal de la jerarquía. Si se "
"especifica, el nombre suele ser un nombre jerárquico separado por puntos "
"como *'a'*, *'a.b'* or *'a.b.c.d'*. La elección de estos nombres depende "
"totalmente del desarrollador que utiliza logging."

#: ../Doc/library/logging.rst:925
msgid ""
"All calls to this function with a given name return the same logger "
"instance. This means that logger instances never need to be passed between "
"different parts of an application."
msgstr ""
"Todas las llamadas a esta función con un nombre dado retornan la misma "
"instancia de logger. Esto significa que las instancias del logger nunca "
"necesitan pasar entre diferentes partes de una aplicación."

#: ../Doc/library/logging.rst:932
msgid ""
"Return either the standard :class:`Logger` class, or the last class passed "
"to :func:`setLoggerClass`. This function may be called from within a new "
"class definition, to ensure that installing a customized :class:`Logger` "
"class will not undo customizations already applied by other code. For "
"example::"
msgstr ""
"Retorna ya sea la clase estándar :class:`Logger`, o la última clase pasada "
"a :func:`setLoggerClass`. Esta función se puede llamar desde una nueva "
"definición de clase, para garantizar que la instalación de una clase "
"personalizada :class:`Logger` no deshaga las *customizaciones* ya aplicadas "
"por otro código. Por ejemplo::"

#: ../Doc/library/logging.rst:943
msgid "Return a callable which is used to create a :class:`LogRecord`."
msgstr "Retorna un invocable que se usa para crear una :class:`LogRecord`."

#: ../Doc/library/logging.rst:945
msgid ""
"This function has been provided, along with :func:`setLogRecordFactory`, to "
"allow developers more control over how the :class:`LogRecord` representing a "
"logging event is constructed."
msgstr ""
"Esta función se ha proporcionado, junto con :func:`setLogRecordFactory`, "
"para permitir a los desarrolladores un mayor control sobre cómo :class:"
"`LogRecord` representa un evento logging construido."

#: ../Doc/library/logging.rst:950
msgid ""
"See :func:`setLogRecordFactory` for more information about the how the "
"factory is called."
msgstr ""
"Consulte :func:`setLogRecordFactory` para obtener más información sobre cómo "
"se llama a la fábrica."

#: ../Doc/library/logging.rst:955
msgid ""
"Logs a message with level :const:`DEBUG` on the root logger. The *msg* is "
"the message format string, and the *args* are the arguments which are merged "
"into *msg* using the string formatting operator. (Note that this means that "
"you can use keywords in the format string, together with a single dictionary "
"argument.)"
msgstr ""
"Registra un mensaje con el nivel :const:`DEBUG` en el logger raíz. *msg * es "
"la cadena de carácteres de formato del mensaje y *args* son los argumentos "
"que se fusionan en *msg* usando el operador de formato de cadena. (Tenga en "
"cuenta que esto significa que puede utilizar palabras clave en la cadena de "
"formato, junto con un único argumento de diccionario)."

#: ../Doc/library/logging.rst:960
msgid ""
"There are three keyword arguments in *kwargs* which are inspected: "
"*exc_info* which, if it does not evaluate as false, causes exception "
"information to be added to the logging message. If an exception tuple (in "
"the format returned by :func:`sys.exc_info`) or an exception instance is "
"provided, it is used; otherwise, :func:`sys.exc_info` is called to get the "
"exception information."
msgstr ""
"Hay tres argumentos de palabras clave en *kwargs* que se inspeccionan: "
"*exc_info* que, si no se evalúa como falso, hace que se agregue información "
"de excepción al mensaje de registro. Si se proporciona una tupla de "
"excepción (en el formato retornado por :func:`sys.exc_info`) o una instancia "
"de excepción, se utiliza; de lo contrario, se llama a :func:`sys.exc_info` "
"para obtener la información de la excepción."

#: ../Doc/library/logging.rst:986
msgid ""
"The third optional keyword argument is *extra* which can be used to pass a "
"dictionary which is used to populate the __dict__ of the LogRecord created "
"for the logging event with user-defined attributes. These custom attributes "
"can then be used as you like. For example, they could be incorporated into "
"logged messages. For example::"
msgstr ""
"El tercer argumento de palabra clave opcional es *extra* que se puede usar "
"para pasar un diccionario que se usa para completar el __dict__ de LogRecord "
"creado para el evento de registro con atributos definidos por el usuario. "
"Estos atributos personalizados se pueden utilizar como desee. Por ejemplo, "
"podrían incorporarse a mensajes registrados. Por ejemplo::"

#: ../Doc/library/logging.rst:997
msgid "would print something like:"
msgstr "imprimiría algo como:"

#: ../Doc/library/logging.rst:1007
msgid ""
"If you choose to use these attributes in logged messages, you need to "
"exercise some care. In the above example, for instance, the :class:"
"`Formatter` has been set up with a format string which expects 'clientip' "
"and 'user' in the attribute dictionary of the LogRecord. If these are "
"missing, the message will not be logged because a string formatting "
"exception will occur. So in this case, you always need to pass the *extra* "
"dictionary with these keys."
msgstr ""
"Si opta por utilizar estos atributos en los mensajes registrados, debemos "
"tener cuidado. En el caso anterior, por ejemplo, :class:`Formatter` se ha "
"configurado con una cadena de caracteres de formato que espera 'clientip' y "
"'user' en el diccionario de atributos de LogRecord. Si faltan, el mensaje no "
"se registrará porque se producirá una excepción de formato de cadena. "
"Entonces, en este caso, siempre debe pasar el diccionario *extra* con estas "
"claves."

#: ../Doc/library/logging.rst:1026
msgid ""
"Logs a message with level :const:`INFO` on the root logger. The arguments "
"are interpreted as for :func:`debug`."
msgstr ""
"Registra un mensaje con nivel :const:`INFO` en el logger raíz. Los "
"argumentos se interpretan como :func:`debug`."

#: ../Doc/library/logging.rst:1032
msgid ""
"Logs a message with level :const:`WARNING` on the root logger. The arguments "
"are interpreted as for :func:`debug`."
msgstr ""
"Registra un mensaje con nivel :const:`WARNING` en el logger raíz. Los "
"argumentos se interpretan como :func:`debug`."

#: ../Doc/library/logging.rst:1035
msgid ""
"There is an obsolete function ``warn`` which is functionally identical to "
"``warning``. As ``warn`` is deprecated, please do not use it - use "
"``warning`` instead."
msgstr ""
"Hay una función obsoleta `warn`` que es funcionalmente idéntica a "
"``warning``. Como ``warn`` está deprecado, por favor no lo use, use "
"``warning`` en su lugar."

#: ../Doc/library/logging.rst:1042
msgid ""
"Logs a message with level :const:`ERROR` on the root logger. The arguments "
"are interpreted as for :func:`debug`."
msgstr ""
"Registra un mensaje con nivel :const:`ERROR` en el logger raíz. Los "
"argumentos se interpretan como :func:`debug`."

#: ../Doc/library/logging.rst:1048
msgid ""
"Logs a message with level :const:`CRITICAL` on the root logger. The "
"arguments are interpreted as for :func:`debug`."
msgstr ""
"Registra un mensaje con nivel :const:`CRITICAL` en el logger raíz. Los "
"argumentos se interpretan como :func:`debug`."

#: ../Doc/library/logging.rst:1054
msgid ""
"Logs a message with level :const:`ERROR` on the root logger. The arguments "
"are interpreted as for :func:`debug`. Exception info is added to the logging "
"message. This function should only be called from an exception handler."
msgstr ""
"Registra un mensaje con nivel :const:`ERROR` en el logger raíz. Los "
"argumentos se interpretan como :func:`debug`. Se agrega información de "
"excepción al mensaje de logging. Esta función solo se debe llamar desde un "
"gestor de excepciones."

#: ../Doc/library/logging.rst:1060
msgid ""
"Logs a message with level *level* on the root logger. The other arguments "
"are interpreted as for :func:`debug`."
msgstr ""
"Registra un mensaje con nivel *level* en el logger raíz. Los argumentos "
"restantes se interpretan como :func:`debug`."

#: ../Doc/library/logging.rst:1063
msgid ""
"The above module-level convenience functions, which delegate to the root "
"logger, call :func:`basicConfig` to ensure that at least one handler is "
"available. Because of this, they should *not* be used in threads, in "
"versions of Python earlier than 2.7.1 and 3.2, unless at least one handler "
"has been added to the root logger *before* the threads are started. In "
"earlier versions of Python, due to a thread safety shortcoming in :func:"
"`basicConfig`, this can (under rare circumstances) lead to handlers being "
"added multiple times to the root logger, which can in turn lead to multiple "
"messages for the same event."
msgstr ""
"Las funciones de nivel de módulo anteriores, que delegan en el logger raíz, "
"llaman a :func:`basicConfig` para asegurarse de que haya al menos un gestor "
"disponible. Debido a esto, *no* deben usarse en subprocesos, en versiones de "
"Python anteriores a la 2.7.1 y 3.2, a menos que se haya agregado al menos un "
"gestor al logger raíz *antes* de que se inicien los subprocesos. En "
"versiones anteriores de Python, debido a una deficiencia de seguridad de "
"subprocesos en :func:`basicConfig`, esto puede (en raras circunstancias) "
"llevar a que se agreguen gestores varias veces al logger raíz, lo que a su "
"vez puede generar múltiples mensajes para el mismo evento."

#: ../Doc/library/logging.rst:1075
msgid ""
"Provides an overriding level *level* for all loggers which takes precedence "
"over the logger's own level. When the need arises to temporarily throttle "
"logging output down across the whole application, this function can be "
"useful. Its effect is to disable all logging calls of severity *level* and "
"below, so that if you call it with a value of INFO, then all INFO and DEBUG "
"events would be discarded, whereas those of severity WARNING and above would "
"be processed according to the logger's effective level. If ``logging."
"disable(logging.NOTSET)`` is called, it effectively removes this overriding "
"level, so that logging output again depends on the effective levels of "
"individual loggers."
msgstr ""
"Proporciona un nivel superior de *level* para todos los loggers que tienen "
"prioridad sobre el propio nivel del logger. Cuando surge la necesidad de "
"reducir temporalmente la salida de logging en toda la aplicación, esta "
"función puede resultar útil. Su efecto es deshabilitar todas las llamadas de "
"gravedad *level* e inferior, de modo que si lo llaman con un valor de INFO, "
"todos los eventos INFO y DEBUG se descartarán, mientras que los de gravedad "
"WARNING y superiores se procesarán de acuerdo con el nivel efectivo del "
"logger. Si se llama a ``logging.disable(logging.NOTSET)`` , elimina "
"efectivamente este nivel primordial, de modo que la salida del registro "
"depende nuevamente de los niveles efectivos de los loggers individuales."

#: ../Doc/library/logging.rst:1086
msgid ""
"Note that if you have defined any custom logging level higher than "
"``CRITICAL`` (this is not recommended), you won't be able to rely on the "
"default value for the *level* parameter, but will have to explicitly supply "
"a suitable value."
msgstr ""
"Tenga en cuenta que si ha definido un nivel de logging personalizado "
"superior a ``CRITICAL`` (esto no es recomendado), no podrá confiar en el "
"valor predeterminado para el parámetro *level*, pero tendrá que proporcionar "
"explícitamente un valor adecuado."

#: ../Doc/library/logging.rst:1091
msgid ""
"The *level* parameter was defaulted to level ``CRITICAL``. See :issue:"
"`28524` for more information about this change."
msgstr ""
"El parámetro *level* se estableció por defecto en el nivel ``CRITICAL``. "
"Consulte el Issue #28524 para obtener más información sobre este cambio."

#: ../Doc/library/logging.rst:1097
msgid ""
"Associates level *level* with text *levelName* in an internal dictionary, "
"which is used to map numeric levels to a textual representation, for example "
"when a :class:`Formatter` formats a message. This function can also be used "
"to define your own levels. The only constraints are that all levels used "
"must be registered using this function, levels should be positive integers "
"and they should increase in increasing order of severity."
msgstr ""
"Asocia nivel *level* con el texto *levelName* en un diccionario interno, que "
"se utiliza para asignar niveles numéricos a una representación textual, por "
"ejemplo, cuando :class:`Formatter` formatea un mensaje. Esta función también "
"se puede utilizar para definir sus propios niveles. Las únicas restricciones "
"son que todos los niveles utilizados deben registrarse utilizando esta "
"función, los niveles deben ser números enteros positivos y deben aumentar en "
"orden creciente de severidad."

#: ../Doc/library/logging.rst:1104
msgid ""
"If you are thinking of defining your own levels, please see the section on :"
"ref:`custom-levels`."
msgstr ""
"Si está pensando en definir sus propios niveles, consulte la sección sobre :"
"ref:`custom-levels`."

#: ../Doc/library/logging.rst:1109
msgid "Returns the textual or numeric representation of logging level *level*."
msgstr ""

#: ../Doc/library/logging.rst:1111
msgid ""
"If *level* is one of the predefined levels :const:`CRITICAL`, :const:"
"`ERROR`, :const:`WARNING`, :const:`INFO` or :const:`DEBUG` then you get the "
"corresponding string. If you have associated levels with names using :func:"
"`addLevelName` then the name you have associated with *level* is returned. "
"If a numeric value corresponding to one of the defined levels is passed in, "
"the corresponding string representation is returned."
msgstr ""

#: ../Doc/library/logging.rst:1118
msgid ""
"The *level* parameter also accepts a string representation of the level such "
"as 'INFO'. In such cases, this functions returns the corresponding numeric "
"value of the level."
msgstr ""

#: ../Doc/library/logging.rst:1122
#, python-format
msgid ""
"If no matching numeric or string value is passed in, the string 'Level %s' "
"% level is returned."
msgstr ""

#: ../Doc/library/logging.rst:1125
#, python-format
msgid ""
"Levels are internally integers (as they need to be compared in the logging "
"logic). This function is used to convert between an integer level and the "
"level name displayed in the formatted log output by means of the ``"
"%(levelname)s`` format specifier (see :ref:`logrecord-attributes`), and vice "
"versa."
msgstr ""
"Los niveles internamente son números enteros (ya que deben compararse en la "
"lógica de logging). Esta función se utiliza para convertir entre un nivel "
"entero y el nombre del nivel que se muestra en la salida de logging "
"formateado mediante el especificador de formato ``%(levelname)s`` (ver :ref:"
"`logrecord-attributes`)."

#: ../Doc/library/logging.rst:1131
msgid ""
"In Python versions earlier than 3.4, this function could also be passed a "
"text level, and would return the corresponding numeric value of the level. "
"This undocumented behaviour was considered a mistake, and was removed in "
"Python 3.4, but reinstated in 3.4.2 due to retain backward compatibility."
msgstr ""
"En las versiones de Python anteriores a la 3.4, esta función también podría "
"pasar un nivel de texto y retornaría el valor numérico correspondiente del "
"nivel. Este comportamiento indocumentado se consideró un error y se eliminó "
"en Python 3.4, pero se restableció en 3.4.2 debido a que conserva la "
"compatibilidad con versiones anteriores."

#: ../Doc/library/logging.rst:1139
msgid ""
"Creates and returns a new :class:`LogRecord` instance whose attributes are "
"defined by *attrdict*. This function is useful for taking a pickled :class:"
"`LogRecord` attribute dictionary, sent over a socket, and reconstituting it "
"as a :class:`LogRecord` instance at the receiving end."
msgstr ""
"Crea y retorna una nueva instancia :class:`LogRecord` cuyos atributos están "
"definidos por *attrdict*. Esta función es útil para tomar un diccionario de "
"atributos serializado (*pickled*) :class:`LogRecord`, enviado a través de un "
"socket, y reconstituido como una instancia :class:`LogRecord` en el extremo "
"receptor."

#: ../Doc/library/logging.rst:1147
msgid ""
"Does basic configuration for the logging system by creating a :class:"
"`StreamHandler` with a default :class:`Formatter` and adding it to the root "
"logger. The functions :func:`debug`, :func:`info`, :func:`warning`, :func:"
"`error` and :func:`critical` will call :func:`basicConfig` automatically if "
"no handlers are defined for the root logger."
msgstr ""
"Realiza una configuración básica para el sistema de logging creando una :"
"class:`StreamHandler` con un :class:`Formatter` predeterminado y agregándolo "
"al logger raíz. Las funciones :func:`debug`, :func:`info`, :func:`warning`, :"
"func:`error` y :func:`critical` llamarán :func:`basicConfig` automáticamente "
"si no se definen gestores para el logger raíz."

#: ../Doc/library/logging.rst:1153
msgid ""
"This function does nothing if the root logger already has handlers "
"configured, unless the keyword argument *force* is set to ``True``."
msgstr ""
"Esta función no hace nada si el logger raíz ya tiene gestores configurados, "
"a menos que el argumento de palabra clave *force* esté establecido como "
"``True``."

#: ../Doc/library/logging.rst:1156
msgid ""
"This function should be called from the main thread before other threads are "
"started. In versions of Python prior to 2.7.1 and 3.2, if this function is "
"called from multiple threads, it is possible (in rare circumstances) that a "
"handler will be added to the root logger more than once, leading to "
"unexpected results such as messages being duplicated in the log."
msgstr ""
"Esta función debe llamarse desde el hilo principal antes de que se inicien "
"otros hilos. En las versiones de Python anteriores a 2.7.1 y 3.2, si se "
"llama a esta función desde varios subprocesos, es posible (en raras "
"circunstancias) que se agregue un gestor al logger raíz más de una vez, lo "
"que genera resultados inesperados como mensajes duplicados en el registro."

#: ../Doc/library/logging.rst:1163
msgid "The following keyword arguments are supported."
msgstr "Se admiten los siguientes argumentos de palabras clave."

#: ../Doc/library/logging.rst:1170
msgid "*filename*"
msgstr "*filename*"

#: ../Doc/library/logging.rst:1170
msgid ""
"Specifies that a FileHandler be created, using the specified filename, "
"rather than a StreamHandler."
msgstr ""
"Especifica que se cree un *FileHandler*, utilizando el nombre de archivo "
"especificado, en lugar de *StreamHandler*."

#: ../Doc/library/logging.rst:1174
msgid "*filemode*"
msgstr "*filemode*"

#: ../Doc/library/logging.rst:1174
msgid ""
"If *filename* is specified, open the file in this :ref:`mode <filemodes>`. "
"Defaults to ``'a'``."
msgstr ""
"Si se especifica *filename*, abre el archivo en :ref:`mode <filemodes>`. Por "
"defecto es ``'a'``."

#: ../Doc/library/logging.rst:1178
msgid "*format*"
msgstr "*format*"

#: ../Doc/library/logging.rst:1178
msgid ""
"Use the specified format string for the handler. Defaults to attributes "
"``levelname``, ``name`` and ``message`` separated by colons."
msgstr ""
"Utiliza la cadena de caracteres de formato especificada para el gestor.Los "
"atributos por defecto son ``levelname``, ``name`` y ``message`` separado por "
"dos puntos."

#: ../Doc/library/logging.rst:1183
msgid "*datefmt*"
msgstr "*datefmt*"

#: ../Doc/library/logging.rst:1183
msgid ""
"Use the specified date/time format, as accepted by :func:`time.strftime`."
msgstr ""
"Utiliza el formato de fecha/hora especificado, aceptado por :func:`time."
"strftime`."

#: ../Doc/library/logging.rst:1186
msgid "*style*"
msgstr "*style*"

#: ../Doc/library/logging.rst:1186
msgid ""
"If *format* is specified, use this style for the format string. One of "
"``'%'``, ``'{'`` or ``'$'`` for :ref:`printf-style <old-string-"
"formatting>`, :meth:`str.format` or :class:`string.Template` respectively. "
"Defaults to ``'%'``."
msgstr ""
"Si *format* es especificado, utilice este estilo para la cadena de "
"caracteres de formato. Uno de ``'%'``, ``'{'`` o ``'$'`` para :ref:`printf-"
"style <old-string-formatting>`, :meth:`str.format` o :class:`string."
"Template` respectivamente. El valor predeterminado es ``'%'``."

#: ../Doc/library/logging.rst:1194
msgid "*level*"
msgstr "*level*"

#: ../Doc/library/logging.rst:1194
msgid "Set the root logger level to the specified :ref:`level <levels>`."
msgstr ""
"Establece el nivel del logger raíz en el :ref:`level <levels>` especificado."

#: ../Doc/library/logging.rst:1197
msgid "*stream*"
msgstr "*stream*"

#: ../Doc/library/logging.rst:1197
msgid ""
"Use the specified stream to initialize the StreamHandler. Note that this "
"argument is incompatible with *filename* - if both are present, a "
"``ValueError`` is raised."
msgstr ""
"Utiliza la secuencia especificada para inicializar StreamHandler. Tenga en "
"cuenta que este argumento es incompatible con *filename*; si ambos están "
"presentes, se lanza un ``ValueError``."

#: ../Doc/library/logging.rst:1202
msgid "*handlers*"
msgstr "*handlers*"

#: ../Doc/library/logging.rst:1202
msgid ""
"If specified, this should be an iterable of already created handlers to add "
"to the root logger. Any handlers which don't already have a formatter set "
"will be assigned the default formatter created in this function. Note that "
"this argument is incompatible with *filename* or *stream* - if both are "
"present, a ``ValueError`` is raised."
msgstr ""
"Si se especifica, debe ser una iteración de los gestores ya creados para "
"agregar al logger raíz. A cualquier gestor que aún no tenga un formateador "
"configurado se le asignará el formateador predeterminado creado en esta "
"función. Tenga en cuenta que este argumento es incompatible con *filename* o "
"*stream*; si ambos están presentes, se lanza un ``ValueError``."

#: ../Doc/library/logging.rst:1211
msgid "*force*"
msgstr "*force*"

#: ../Doc/library/logging.rst:1211
msgid ""
"If this keyword argument is specified as true, any existing handlers "
"attached to the root logger are removed and closed, before carrying out the "
"configuration as specified by the other arguments."
msgstr ""
"Si este argumento de palabra clave se especifica como verdadero, los "
"gestores existentes adjuntos al logger raíz se eliminan y cierran antes de "
"llevar a cabo la configuración tal como se especifica en los otros "
"argumentos."

#: ../Doc/library/logging.rst:1217
msgid "*encoding*"
msgstr ""

#: ../Doc/library/logging.rst:1217
msgid ""
"If this keyword argument is specified along with *filename*, its value is "
"used when the FileHandler is created, and thus used when opening the output "
"file."
msgstr ""

#: ../Doc/library/logging.rst:1222
msgid "*errors*"
msgstr ""

#: ../Doc/library/logging.rst:1222
msgid ""
"If this keyword argument is specified along with *filename*, its value is "
"used when the FileHandler is created, and thus used when opening the output "
"file. If not specified, the value 'backslashreplace' is used. Note that if "
"``None`` is specified, it will be passed as such to func:`open`, which means "
"that it will be treated the same as passing 'errors'."
msgstr ""

#: ../Doc/library/logging.rst:1233
msgid "The *style* argument was added."
msgstr "Se agregó el argumento *style*."

#: ../Doc/library/logging.rst:1236
msgid ""
"The *handlers* argument was added. Additional checks were added to catch "
"situations where incompatible arguments are specified (e.g. *handlers* "
"together with *stream* or *filename*, or *stream* together with *filename*)."
msgstr ""
"Se agregó el argumento *handlers*. Se agregaron verificaciones adicionales "
"para detectar situaciones en las que se especifican argumentos incompatibles "
"(por ejemplo, *handlers* junto con *stream* o *filename*, o *stream* junto "
"con *filename*)."

#: ../Doc/library/logging.rst:1242
msgid "The *force* argument was added."
msgstr "Se agregó el argumento *force*."

#: ../Doc/library/logging.rst:1245
msgid "The *encoding* and *errors* arguments were added."
msgstr ""

#: ../Doc/library/logging.rst:1250
msgid ""
"Informs the logging system to perform an orderly shutdown by flushing and "
"closing all handlers. This should be called at application exit and no "
"further use of the logging system should be made after this call."
msgstr ""
"Informa al sistema de logging para realizar un apagado ordenado descargando "
"y cerrando todos los gestores. Esto se debe llamar al salir de la aplicación "
"y no se debe hacer ningún uso posterior del sistema de logging después de "
"esta llamada."

#: ../Doc/library/logging.rst:1254
msgid ""
"When the logging module is imported, it registers this function as an exit "
"handler (see :mod:`atexit`), so normally there's no need to do that manually."
msgstr ""
"Cuando se importa el módulo de logging, registra esta función como un gestor "
"de salida (ver :mod:`atexit`), por lo que normalmente no es necesario "
"hacerlo manualmente."

#: ../Doc/library/logging.rst:1261
msgid ""
"Tells the logging system to use the class *klass* when instantiating a "
"logger. The class should define :meth:`__init__` such that only a name "
"argument is required, and the :meth:`__init__` should call :meth:`Logger."
"__init__`. This function is typically called before any loggers are "
"instantiated by applications which need to use custom logger behavior. After "
"this call, as at any other time, do not instantiate loggers directly using "
"the subclass: continue to use the :func:`logging.getLogger` API to get your "
"loggers."
msgstr ""
"Le dice al sistema de logging que use la clase *klass* al crear una "
"instancia de un logger. La clase debe definir :meth:`__init__` tal que solo "
"se requiera un argumento de nombre, y :meth:`__init__` debe llamar :meth:"
"`Logger.__init__`. Por lo general, esta función se llama antes de cualquier "
"loggers sea instanciado por las aplicaciones que necesitan utilizar un "
"comportamiento de logger personalizado. Después de esta llamada, como en "
"cualquier otro momento, no cree instancias de loggers directamente usando la "
"subclase: continúe usando la API :func:`logging.getLogger` para obtener sus "
"loggers."

#: ../Doc/library/logging.rst:1272
msgid "Set a callable which is used to create a :class:`LogRecord`."
msgstr "Establece un invocable que se utiliza para crear :class:`LogRecord`."

#: ../Doc/library/logging.rst:1274
msgid "The factory callable to be used to instantiate a log record."
msgstr ""
"La fábrica invocable que se utilizará para crear una instancia de un "
"registro."

#: ../Doc/library/logging.rst:1276
msgid ""
"This function has been provided, along with :func:`getLogRecordFactory`, to "
"allow developers more control over how the :class:`LogRecord` representing a "
"logging event is constructed."
msgstr ""
"Esta función se ha proporcionado, junto con :func:`getLogRecordFactory`, "
"para permitir a los desarrolladores un mayor control sobre cómo se "
"construye :class:`LogRecord` que representa un evento de logging."

#: ../Doc/library/logging.rst:1281
msgid "The factory has the following signature:"
msgstr "La fábrica tiene la siguiente firma:"

#: ../Doc/library/logging.rst:1283
msgid ""
"``factory(name, level, fn, lno, msg, args, exc_info, func=None, sinfo=None, "
"**kwargs)``"
msgstr ""
"``factory(name, level, fn, lno, msg, args, exc_info, func=None, sinfo=None, "
"**kwargs)``"

#: ../Doc/library/logging.rst:1285
msgid "The logger name."
msgstr "El nombre del logger."

#: ../Doc/library/logging.rst
msgid "level"
msgstr "level"

#: ../Doc/library/logging.rst:1286
msgid "The logging level (numeric)."
msgstr "El nivel de logging (numérico)."

#: ../Doc/library/logging.rst
msgid "fn"
msgstr "fn"

#: ../Doc/library/logging.rst:1287
msgid "The full pathname of the file where the logging call was made."
msgstr ""
"El nombre de ruta completo del archivo donde se realizó la llamada de "
"logging."

#: ../Doc/library/logging.rst
msgid "lno"
msgstr "lno"

#: ../Doc/library/logging.rst:1288
msgid "The line number in the file where the logging call was made."
msgstr ""
"El número de línea en el archivo donde se realizó la llamada de logging."

#: ../Doc/library/logging.rst:1289
msgid "The logging message."
msgstr "El mensaje de logging."

#: ../Doc/library/logging.rst:1290
msgid "The arguments for the logging message."
msgstr "Los argumentos para el mensaje de logging."

#: ../Doc/library/logging.rst:1291
msgid "An exception tuple, or ``None``."
msgstr "Una tupla de excepción o ``None``."

#: ../Doc/library/logging.rst
msgid "func"
msgstr "func"

#: ../Doc/library/logging.rst:1292
msgid "The name of the function or method which invoked the logging call."
msgstr "El nombre de la función o método que invocó la llamada de logging."

#: ../Doc/library/logging.rst
msgid "sinfo"
msgstr "sinfo"

#: ../Doc/library/logging.rst:1294
msgid ""
"A stack traceback such as is provided by :func:`traceback.print_stack`, "
"showing the call hierarchy."
msgstr ""
"Un seguimiento de pila como el que proporciona :func:`traceback."
"print_stack`, que muestra la jerarquía de llamadas."

#: ../Doc/library/logging.rst
msgid "kwargs"
msgstr "kwargs"

#: ../Doc/library/logging.rst:1296
msgid "Additional keyword arguments."
msgstr "Argumentos de palabras clave adicionales."

#: ../Doc/library/logging.rst:1300
msgid "Module-Level Attributes"
msgstr "Atributos a nivel de módulo"

#: ../Doc/library/logging.rst:1304
msgid ""
"A \"handler of last resort\" is available through this attribute. This is a :"
"class:`StreamHandler` writing to ``sys.stderr`` with a level of ``WARNING``, "
"and is used to handle logging events in the absence of any logging "
"configuration. The end result is to just print the message to ``sys."
"stderr``. This replaces the earlier error message saying that \"no handlers "
"could be found for logger XYZ\". If you need the earlier behaviour for some "
"reason, ``lastResort`` can be set to ``None``."
msgstr ""
"Un \"gestor de último recurso\" está disponible a través de este atributo. "
"Esta es una :class:`StreamHandler` que escribe en``sys.stderr`` con un nivel "
"``WARNING``, y se usa para gestionar eventos de logging en ausencia de "
"cualquier configuración de logging. El resultado final es simplemente "
"imprimir el mensaje en ``sys.stderr``. Esto reemplaza el mensaje de error "
"anterior que decía que \"no se pudieron encontrar gestores para el logger XYZ"
"\". Si necesita el comportamiento anterior por alguna razón, ``lastResort`` "
"se puede configurar en ``None``."

#: ../Doc/library/logging.rst:1315
msgid "Integration with the warnings module"
msgstr "Integración con el módulo de advertencias"

#: ../Doc/library/logging.rst:1317
msgid ""
"The :func:`captureWarnings` function can be used to integrate :mod:`logging` "
"with the :mod:`warnings` module."
msgstr ""
"La función :func:`captureWarnings` se puede utilizar para integrar :mod:"
"`logging` con el módulo :mod:`warnings`."

#: ../Doc/library/logging.rst:1322
msgid ""
"This function is used to turn the capture of warnings by logging on and off."
msgstr ""
"Esta función se utiliza para activar y desactivar la captura de advertencias "
"(*warnings*)."

#: ../Doc/library/logging.rst:1325
msgid ""
"If *capture* is ``True``, warnings issued by the :mod:`warnings` module will "
"be redirected to the logging system. Specifically, a warning will be "
"formatted using :func:`warnings.formatwarning` and the resulting string "
"logged to a logger named ``'py.warnings'`` with a severity of :const:"
"`WARNING`."
msgstr ""
"Si *capture* es ``True``, las advertencias emitidas por el módulo :mod:"
"`warnings` serán redirigidas al sistema de logging. Específicamente, una "
"advertencia se formateará usando :func:`warnings.formatwarning` y la cadena "
"de caracteres resultante se registrará en un logger  llamado ``'py."
"warnings'`` con severidad :const:`WARNING`."

#: ../Doc/library/logging.rst:1330
msgid ""
"If *capture* is ``False``, the redirection of warnings to the logging system "
"will stop, and warnings will be redirected to their original destinations (i."
"e. those in effect before ``captureWarnings(True)`` was called)."
msgstr ""
"Si *capture* es ``False``, la redirección de advertencias al sistema de "
"logging se detendrá y las advertencias serán redirigidas a sus destinos "
"originales (es decir, aquellos en vigor antes de que se llamara a "
"``captureWarnings(True)``)."

#: ../Doc/library/logging.rst:1338
msgid "Module :mod:`logging.config`"
msgstr "Módulo :mod:`logging.config`"

#: ../Doc/library/logging.rst:1338
msgid "Configuration API for the logging module."
msgstr "API de configuración para el módulo logging."

#: ../Doc/library/logging.rst:1341
msgid "Module :mod:`logging.handlers`"
msgstr "Módulo :mod:`logging.handlers`"

#: ../Doc/library/logging.rst:1341
msgid "Useful handlers included with the logging module."
msgstr "Gestores útiles incluidos con el módulo logging."

#: ../Doc/library/logging.rst:1345
msgid ":pep:`282` - A Logging System"
msgstr ":pep:`282` - A Logging System"

#: ../Doc/library/logging.rst:1344
msgid ""
"The proposal which described this feature for inclusion in the Python "
"standard library."
msgstr ""
"La propuesta que describió esta característica para su inclusión en la "
"biblioteca estándar de Python."

#: ../Doc/library/logging.rst:1350
msgid ""
"`Original Python logging package <https://www.red-dove.com/python_logging."
"html>`_"
msgstr ""
"`Paquete logging original de Python <https://www.red-dove.com/python_logging."
"html>`_"

#: ../Doc/library/logging.rst:1348
msgid ""
"This is the original source for the :mod:`logging` package.  The version of "
"the package available from this site is suitable for use with Python 1.5.2, "
"2.1.x and 2.2.x, which do not include the :mod:`logging` package in the "
"standard library."
msgstr ""
"Esta es la fuente original del paquete :mod:`logging`. La versión del "
"paquete disponible en este sitio es adecuada para usar con Python 1.5.2, 2.1."
"xy 2.2.x, que no incluyen el paquete :mod:`logging` en la biblioteca "
"estándar."