python-docs-fr/library/logging.po

# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-05-22 23:13+0200\n"
"PO-Revision-Date: 2022-10-18 12:29+0200\n"
"Last-Translator: Antoine Wecxsteen\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 2.3\n"

#: library/logging.rst:2
msgid ":mod:`logging` --- Logging facility for Python"
msgstr ":mod:`logging` — Fonctionnalités de journalisation pour Python"

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

#: library/logging.rst:16
msgid ""
"This page contains the API reference information. For tutorial information "
"and discussion of more advanced topics, see"
msgstr ""
"Cette page contient les informations de référence de l’API. Pour des "
"tutoriels et des discussions sur des sujets plus avancés, voir"

#: library/logging.rst:19
msgid ":ref:`Basic Tutorial <logging-basic-tutorial>`"
msgstr ":ref:`Tutoriel de découverte <logging-basic-tutorial>`"

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

#: library/logging.rst:21
msgid ":ref:`Logging Cookbook <logging-cookbook>`"
msgstr ":ref:`Recettes pour la journalisation <logging-cookbook>`"

#: library/logging.rst:25
msgid ""
"This module defines functions and classes which implement a flexible event "
"logging system for applications and libraries."
msgstr ""
"Ce module définit les fonctions et les classes qui mettent en œuvre un "
"système flexible d’enregistrement des événements pour les applications et "
"les bibliothèques."

#: 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 ""
"L'intérêt principal d'utiliser une API de journalisation fournie par un "
"module de bibliothèque standard réside dans le fait que tous les modules "
"Python peuvent participer à la journalisation, de sorte que le journal de "
"votre application peut inclure vos propres messages et ceux de modules tiers."

#: 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 ""
"Le module offre beaucoup de fonctionnalités et de flexibilité. Si vous "
"n’êtes pas familier de la journalisation, la meilleure façon de "
"l'appréhender est de consulter les tutoriels (voir les liens à droite)."

#: library/logging.rst:37
msgid ""
"The basic classes defined by the module, together with their functions, are "
"listed below."
msgstr ""
"Les classes élémentaires définies par le module, ainsi que leurs fonctions, "
"sont énumérées ci-dessous."

#: library/logging.rst:40
msgid "Loggers expose the interface that application code directly uses."
msgstr ""
"les enregistreurs (*loggers* en anglais) exposent l'interface que le code de "
"l'application utilise directement ;"

#: library/logging.rst:41
msgid ""
"Handlers send the log records (created by loggers) to the appropriate "
"destination."
msgstr ""
"les gestionnaires (*handlers*) envoient les entrées de journal (créées par "
"les *loggers*) vers les destinations voulues ;"

#: library/logging.rst:43
msgid ""
"Filters provide a finer grained facility for determining which log records "
"to output."
msgstr ""
"les filtres (*filters*) fournissent un moyen de choisir plus finement "
"quelles entrées de journal doivent être sorties ;"

#: library/logging.rst:45
msgid "Formatters specify the layout of log records in the final output."
msgstr ""
"les formateurs (*formatters*) définissent la structure de l'entrée de "
"journal dans la sortie finale."

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

#: 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 ""
"Les enregistreurs ont les attributs et les méthodes suivants. Notez que les "
"enregistreurs ne doivent *JAMAIS* être instanciés directement, mais toujours "
"par la fonction au niveau du module ``logging.getLogger(nom)``. Les appels "
"à :func:`getLogger` avec le même nom renvoient toujours une référence au "
"même objet enregistreur."

#: 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 ""
"``nom`` est une valeur avec un ou plusieurs niveaux de hiérarchie, séparés "
"par des points, comme ``truc.machin.bidule`` (bien qu’elle puisse aussi "
"valoir simplement ``truc``, par exemple). Les enregistreurs à droite dans la "
"liste hiérarchique sont les enfants des enregistreurs plus à gauche dans "
"cette liste. Par exemple, pour un enregistreur nommé ``truc``, les "
"enregistreurs portant les noms ``truc.machin``, ``truc.machin.bidule`` et "
"``truc.chose`` sont tous des enfants de ``truc``. La hiérarchie des noms "
"d’enregistreurs est analogue à la hiérarchie des paquets Python et est même "
"identique à celle-ci si vous organisez vos enregistreurs par module en "
"utilisant la construction recommandée ``logging.getLogger(__name__)``. C’est "
"ainsi parce que dans un module, ``__name__`` est le nom du module dans "
"l’espace de noms des paquets Python."

#: 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 cet attribut est évalué comme vrai, les événements enregistrés dans cet "
"enregistreur seront transmis aux gestionnaires des enregistreurs de niveau "
"supérieur (parents), en plus des gestionnaires attachés à l'enregistreur. "
"Les messages sont transmis directement aux gestionnaires des enregistreurs "
"parents — ni le niveau ni les filtres des enregistreurs parentaux en "
"question ne sont pris en compte."

#: library/logging.rst:80
msgid ""
"If this evaluates to false, logging messages are not passed to the handlers "
"of ancestor loggers."
msgstr ""
"S’il s’évalue comme faux, les messages de journalisation ne sont pas "
"transmis aux gestionnaires des enregistreurs parents."

#: library/logging.rst:83
msgid ""
"Spelling it out with an example: If the propagate attribute of the logger "
"named ``A.B.C`` evaluates to true, any event logged to ``A.B.C`` via a "
"method call such as ``logging.getLogger('A.B.C').error(...)`` will [subject "
"to passing that logger's level and filter settings] be passed in turn to any "
"handlers attached to loggers named ``A.B``, ``A`` and the root logger, after "
"first being passed to any handlers attached to ``A.B.C``. If any logger in "
"the chain ``A.B.C``, ``A.B``, ``A`` has its ``propagate`` attribute set to "
"false, then that is the last logger whose handlers are offered the event to "
"handle, and propagation stops at that point."
msgstr ""

#: library/logging.rst:92
msgid "The constructor sets this attribute to ``True``."
msgstr "Le constructeur fixe cet attribut à ``True``."

#: library/logging.rst:94
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 vous associez un gestionnaire à un enregistreur *et* à un ou plusieurs de "
"ses parents, il peut émettre le même enregistrement plusieurs fois. En "
"général, il est rare d'avoir besoin d'attacher un gestionnaire à plus d'un "
"enregistreur — si vous l'attachez simplement à l'enregistreur approprié le "
"plus haut possible dans la hiérarchie des enregistreurs, alors il voit tous "
"les événements enregistrés par tous les enregistreurs descendants, à "
"condition que leur paramètre de propagation soit laissé à ``True``. La "
"pratique la plus courante est de n'attacher les gestionnaires qu'à "
"l'enregistreur racine et à laisser la propagation s'occuper du reste."

#: library/logging.rst:105
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 ""
"Fixe le seuil de l'enregistreur au niveau *level*. Les messages de "
"journalisation qui sont moins graves que *level* sont ignorés ; les messages "
"qui ont une gravité égale à *level* ou plus élevée sont traités par le ou "
"les gestionnaires de l'enregistreur, à moins que le niveau d'un gestionnaire "
"n'ait été fixé à un niveau de gravité plus élevé que *level*."

#: library/logging.rst:110
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 ""
"Lorsqu'un enregistreur est créé, son niveau est fixé à :const:`NOTSET` (ce "
"qui entraîne le traitement de tous les messages lorsque l'enregistreur est "
"l'enregistreur racine, ou la délégation au parent lorsque l'enregistreur est "
"un enregistreur non racine). Notez que l'enregistreur racine est créé avec "
"le niveau :const:`WARNING`."

#: library/logging.rst:115
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 ""
"Le terme « délégation au parent » signifie que si un enregistreur a un "
"niveau de ``NOTSET``, sa chaîne d’enregistreurs parents est parcourue "
"jusqu'à ce qu'un parent ayant un niveau autre que ``NOTSET`` soit trouvé, ou "
"que la racine soit atteinte."

#: library/logging.rst:119
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 un parent est trouvé avec un niveau autre que NOTSET, alors le niveau de "
"ce parent est utilisé comme le niveau effectif de l'enregistreur d'où la "
"recherche du parent a commencé. Ce niveau est utilisé pour déterminer "
"comment un événement d'enregistrement est traité."

#: library/logging.rst:123
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 la racine est atteinte, et qu'elle a un niveau de NOTSET, alors tous les "
"messages sont traités. Sinon, le niveau de la racine est utilisé comme "
"niveau effectif."

#: library/logging.rst:435
msgid "See :ref:`levels` for a list of levels."
msgstr "Voir :ref:`levels` pour la liste des niveaux."

#: library/logging.rst:128
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 ""
"le paramètre *level* peut désormais être une chaîne de caractères "
"représentant le niveau de gravité (comme ``'INFO'``) en plus des constantes "
"entières (comme :const:`INFO`). Notez cependant que les niveaux sont stockés "
"en interne sous forme d'entiers, et que des méthodes telles que :meth:"
"`getEffectiveLevel` et :meth:`isEnabledFor` renvoient et s'attendent à "
"recevoir des entiers."

#: library/logging.rst:138
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 ""
"Indique si un message de gravité *level* est traitable par cet enregistreur. "
"Cette méthode vérifie d'abord le niveau de gravité du module défini par "
"``logging.disable(level)`` et ensuite le niveau effectif de l'enregistreur, "
"déterminé par :meth:`getEffectiveLevel`."

#: library/logging.rst:146
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 ""
"Indique le niveau effectif de l'enregistreur. Si une valeur autre que :const:"
"`NOTSET` a été définie en utilisant :meth:`setLevel`, elle est renvoyée. "
"Sinon, la hiérarchie est parcourue vers la racine jusqu'à ce qu'une valeur "
"autre que :const:`NOTSET` soit trouvée, et cette valeur est renvoyée. La "
"valeur renvoyée est un entier, par exemple :const:`logging.DEBUG`, :const:"
"`logging.INFO`, etc."

#: library/logging.rst:156
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 ""
"Renvoie un enregistreur enfant de l'enregistreur, déterminé par *suffix*. "
"Ainsi, ``logging.getLogger('abc').getChild('def.ghi')`` renvoie le même "
"enregistreur que ``logging.getLogger('abc.def.ghi')``. C'est une méthode "
"destinée à simplifier la vie du développeur. Elle est très utile quand "
"l’enregistreur parent est nommé en utilisant, par exemple, ``__name__`` "
"plutôt qu'une chaîne de caractères littérale."

#: library/logging.rst:167
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 ""
"Enregistre un message de niveau :const:`DEBUG` dans cet enregistreur. *msg* "
"est la chaîne du message qui sera formatée avec *args* en utilisant "
"l'opérateur de formatage. Cela signifie qu'il est possible de mettre des "
"mots-clé dans la chaîne et de passer un dictionnaire en argument. Si *args* "
"n'est pas fourni, aucun formatage « à la % » n'est appliqué."

#: library/logging.rst:173
msgid ""
"There are four keyword arguments in *kwargs* which are inspected: "
"*exc_info*, *stack_info*, *stacklevel* and *extra*."
msgstr ""
"Quatre mots-clés de *kwargs* sont analysés : *exc_info*, *stack_info*, "
"*stacklevel* et *extra*."

#: library/logging.rst:176
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 la valeur booléenne de *exc_info* est vraie, les informations des "
"exceptions sont ajoutées au message. Si *exc_info* est un *n*-uplet "
"d'exception (au format identique aux valeurs renvoyées par :func:`sys."
"exc_info`) ou une instance d'exception, sa valeur est utilisée. Dans le cas "
"contraire, les informations sur l'exception sont déterminées par un appel à :"
"func:`sys.exc_info`."

#: library/logging.rst:986
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 ""
"Le deuxième argument par mot-clé optionnel est *stack_info*, valant "
"``False`` par défaut. S'il est vrai, les informations de la pile d'appels "
"sont ajoutées à l'entrée de journal, en incluant aussi l'appel à la fonction "
"de journalisation. Ce ne sont pas les mêmes informations que celles "
"affichées en définissant *exc_info* : les premières représentent les appels "
"de fonctions successifs, du bas de la pile jusqu'à l'appel de la fonction de "
"journalisation dans le fil d'exécution actuel, alors que les secondes "
"portent des informations sur les appels successifs déclenchés par la levée "
"d'une exception et la recherche de gestionnaires pour cette exception."

#: library/logging.rst:995
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 ""
"Il est possible de définir *stack_info* indépendamment de *exc_info*, p. ex. "
"pour s'assurer que l'exécution a atteint un certain point dans le code, même "
"si aucune exception n'a été levée. La pile d'appels est alors affichée après "
"la ligne d'en-tête suivante :"

#: library/logging.rst:1003
msgid ""
"This mimics the ``Traceback (most recent call last):`` which is used when "
"displaying exception frames."
msgstr ""
"Elle imite la ligne ``Traceback (most recent call last):`` affichée avec la "
"pile d'appels d'une exception."

#: library/logging.rst:201
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 ""
"Le troisième argument par mot-clé optionnel est *stacklevel*, valant ``1`` "
"par défaut. S'il est supérieur à 1, il correspond au nombre d'entrées dans "
"la pile qui sont ignorées en déterminant le numéro de ligne et le nom de la "
"fonction dans la classe :class:`LogRecord` créée pour l'évènement de "
"journalisation. C'est utile pour les utilitaires de journalisation car cela "
"permet d'ignorer les informations (nom de fonction, fichier source et ligne) "
"de l'utilitaire et de ne traiter que celles de l'appelant. Le nom de ce "
"paramètre est le même que son équivalent dans le module :mod:`warnings`."

#: library/logging.rst:209
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 ""
"Le quatrième argument par mot-clé est *extra* qui permet de remplir le "
"dictionnaire *__dict__* du :class:`LogRecord` créé pour l'évènement de "
"journalisation, avec des attributs personnalisés. Ces attributs peuvent être "
"utilisés comme bon vous semble. Ils peuvent ainsi être incorporés aux "
"entrées de journalisation. Par exemple ::"

#: library/logging.rst:221
msgid "would print something like"
msgstr "affiche"

#: library/logging.rst:1023
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 ""
"Les clés du dictionnaire passé dans *extra* ne doivent pas être les mêmes "
"que les clés utilisées par le système de journalisation. Voir la "
"documentation de la classe :class:`Formatter` pour plus de précisions sur "
"les clés utilisées par le système de journalisation."

#: library/logging.rst:231
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 vous choisissez d'utiliser des attributs dans les messages à journaliser, "
"il faut être prudent. Ainsi, dans l'exemple précédent, le :class:`Formatter` "
"a été configuré avec une chaîne qui attend *clientip* et *user* dans le "
"dictionnaire d'attributs du :class:`LogRecord`. S'ils sont manquants, le "
"message n'est pas enregistré car une exception de formatage de chaîne est "
"levée. Il faut alors toujours passer un dictionnaire *extra* avec ces clés."

#: library/logging.rst:1034
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 ""
"Même si elle peut sembler gênante, cette fonctionnalité est nécessaire dans "
"certains cas, comme sur des serveurs à fils d'exécution multiples, où le "
"même code s'exécute dans des contextes différents et où les évènements "
"significatifs dépendent du contexte (comme l'adresse IP du client et le nom "
"d'utilisateur dans l'exemple précédent). Dans ces circonstances, il est "
"clair que les classes :class:`Formatter`\\ s spécialisées doivent être "
"utilisées avec des :class:`Handler`\\ s particuliers."

#: library/logging.rst:1041
msgid "The *stack_info* parameter was added."
msgstr "ajout du paramètre *stack_info*."

#: library/logging.rst:248
msgid "The *exc_info* parameter can now accept exception instances."
msgstr "le paramètre *exc_info* peut être une instance d'exception."

#: library/logging.rst:251
msgid "The *stacklevel* parameter was added."
msgstr "ajout du paramètre *stacklevel*."

#: library/logging.rst:257
msgid ""
"Logs a message with level :const:`INFO` on this logger. The arguments are "
"interpreted as for :meth:`debug`."
msgstr ""
"Enregistre un message avec le niveau de gravité :const:`INFO`. Les arguments "
"ont la même signification que pour :meth:`debug`."

#: library/logging.rst:263
msgid ""
"Logs a message with level :const:`WARNING` on this logger. The arguments are "
"interpreted as for :meth:`debug`."
msgstr ""
"Enregistre un message avec le niveau de gravité :const:`WARNING`. Les "
"arguments ont la même signification que pour :meth:`debug`."

#: library/logging.rst:266
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 ""
"Il existe une méthode obsolète ``warn`` qui est identique à ``warning``. "
"``warn`` n'est plus maintenue, prière de ne plus l'utiliser et de la "
"remplacer par ``warning``."

#: library/logging.rst:272
msgid ""
"Logs a message with level :const:`ERROR` on this logger. The arguments are "
"interpreted as for :meth:`debug`."
msgstr ""
"Enregistre un message avec le niveau de gravité :const:`ERROR`. Les "
"arguments ont la même signification que pour :meth:`debug`."

#: library/logging.rst:278
msgid ""
"Logs a message with level :const:`CRITICAL` on this logger. The arguments "
"are interpreted as for :meth:`debug`."
msgstr ""
"Enregistre un message avec le niveau de gravité :const:`CRITICAL`. Les "
"arguments ont la même signification que pour :meth:`debug`."

#: library/logging.rst:284
msgid ""
"Logs a message with integer level *level* on this logger. The other "
"arguments are interpreted as for :meth:`debug`."
msgstr ""
"Enregistre un message avec le niveau de gravité *level*. Les arguments ont "
"la même signification que pour :meth:`debug`."

#: library/logging.rst:290
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 ""
"Enregistre un message avec le niveau de gravité :const:`ERROR`. Les "
"arguments ont la même signification que pour :meth:`debug`. Des informations "
"sur l'exception sont ajoutées au message. Cette méthode doit être appelée "
"depuis un gestionnaire d'exceptions."

#: library/logging.rst:297
msgid "Adds the specified filter *filter* to this logger."
msgstr "Ajoute le filtre *filter* à l'enregistreur."

#: library/logging.rst:302
msgid "Removes the specified filter *filter* from this logger."
msgstr "Retire le filtre *filter* de cet enregistreur."

#: library/logging.rst:307
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 ""
"Applique les filtres associés à l'enregistreur et renvoie ``True`` si "
"l'entrée doit être traitée. Les filtres sont appliqués les uns après les "
"autres, jusqu'à ce que l'un renvoie faux. Si ce n'est pas le cas, le "
"traitement de l'entrée se poursuit (elle est alors passée aux "
"gestionnaires). Si l'un d'entre eux renvoie faux, le traitement de l'entrée "
"s'arrête."

#: library/logging.rst:316
msgid "Adds the specified handler *hdlr* to this logger."
msgstr "Ajoute le gestionnaire *hdlr* à l'enregistreur."

#: library/logging.rst:321
msgid "Removes the specified handler *hdlr* from this logger."
msgstr "Retire le gestionnaire *hdlr* de l'enregistreur."

#: library/logging.rst:326
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 ""
"Détermine le fichier source et la ligne de l'appelant. Renvoie un quadruplet "
"contenant le nom du fichier source, le numéro de ligne, le nom de la "
"fonction et la pile d'appels. La pile vaut ``None`` si *stack_info* n'est "
"pas ``True``."

#: library/logging.rst:330
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 ""
"Le paramètre *stacklevel* est passé par le code appelant :meth:`debug` "
"(entre autres). S'il est supérieur à 1, *n*-1 entrées de la pile sont "
"supprimées avant de renvoyer la pile. C'est pratique quand on appelle des "
"APIs de journalisation à travers du code d'encapsulation car cela permet de "
"retirer les informations sur ce code de l'entrée, tout en conservant celles "
"sur le code au-dessus du code d'encapsulation."

#: library/logging.rst:340
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 ""
"Traite une entrée en la passant à tous les gestionnaires de l'enregistreur "
"et à tous ses parents (jusqu'à ce qu'un *propagate* soit faux). C'est "
"pratique pour désérialiser les entrées reçues d'un connecteur et celles "
"créées localement. Du filtrage au niveau de l'enregistreur est appliqué en "
"appelant :meth:`~Logger.filter`."

#: library/logging.rst:348
msgid ""
"This is a factory method which can be overridden in subclasses to create "
"specialized :class:`LogRecord` instances."
msgstr ""
"Fabrique qui peut être redéfinie pour créer des instances de :class:"
"`LogRecord`."

#: library/logging.rst:353
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 ""
"Vérifie si l'enregistreur a des gestionnaires associés. Elle recherche les "
"gestionnaires de l'enregistreur et ceux de ses parents. Renvoie ``True`` si "
"au moins un gestionnaire a été trouvé et ``False`` sinon. Cette méthode "
"arrête de remonter la hiérarchie dès qu'un enregistreur avec l'attribut "
"*propagate* à faux est rencontré ­— cet enregistreur est alors le dernier "
"dans lequel la méthode cherche des gestionnaires."

#: library/logging.rst:362
msgid "Loggers can now be pickled and unpickled."
msgstr "les enregistreurs peuvent être sérialisés et désérialisés."

#: library/logging.rst:368
msgid "Logging Levels"
msgstr "Niveaux de journalisation"

#: library/logging.rst:370
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 ""
"Les valeurs numériques des niveaux de journalisation sont données dans le "
"tableau suivant. Celles-ci n'ont d'intérêt que si vous voulez définir vos "
"propres niveaux, avec des valeurs spécifiques par rapport aux niveaux "
"prédéfinis. Si vous définissez un niveau avec la même valeur numérique, il "
"écrase la valeur prédéfinie ; le nom prédéfini est perdu."

#: library/logging.rst:377
msgid "Level"
msgstr "Niveau"

#: library/logging.rst:377
msgid "Numeric value"
msgstr "Valeur numérique"

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

#: library/logging.rst:379
msgid "50"
msgstr "50"

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

#: library/logging.rst:381
msgid "40"
msgstr "40"

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

#: library/logging.rst:383
msgid "30"
msgstr "30"

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

#: library/logging.rst:385
msgid "20"
msgstr "20"

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

#: library/logging.rst:387
msgid "10"
msgstr "10"

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

#: library/logging.rst:389
msgid "0"
msgstr "0"

#: library/logging.rst:396
msgid "Handler Objects"
msgstr "Gestionnaires"

#: library/logging.rst:398
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 ""
"Les gestionnaires ont les attributs et méthodes suivants. :class:`Handler` "
"est une classe de base pour des sous-classes plus utiles et ne doit pas être "
"instanciée directement. Les méthodes :meth:`__init__` des sous-classes "
"doivent toutefois appeler :meth:`Handler.__init__`."

#: library/logging.rst:407
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 ""
"Initialise l'objet :class:`Handler` en définissant le niveau de gravité, en "
"initialisant la liste des filtres avec une liste vide et en créant un verrou "
"(avec :meth:`createLock`) pour sérialiser l'accès au mécanisme d'E-S."

#: library/logging.rst:414
msgid ""
"Initializes a thread lock which can be used to serialize access to "
"underlying I/O functionality which may not be threadsafe."
msgstr ""
"Instancie un verrou qui peut être utilisé pour sérialiser l'accès au système "
"d'E-S sous-jacent (qui peut ne pas être à fil d'exécution sécurisé)."

#: library/logging.rst:420
msgid "Acquires the thread lock created with :meth:`createLock`."
msgstr "Acquiert le verrou créé par :meth:`createLock`."

#: library/logging.rst:425
msgid "Releases the thread lock acquired with :meth:`acquire`."
msgstr "Relâche le verrou acquis par :meth:`acquire`."

#: library/logging.rst:430
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 ""
"Ajuste le seuil déclenchement du gestionnaire au niveau *level*. Les "
"messages de gravité moindre que *level* sont alors ignorés. Ce seuil est "
"fixé à :const:`NOTSET` lors de la création d'un gestionnaire (ce qui "
"signifie que tous les messages seront traités)."

#: library/logging.rst:437
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 ""
"le paramètre *level* peut être une chaîne de caractères, comme ``'INFO'``, "
"en plus d'une constante entière comme :const:`INFO`."

#: library/logging.rst:445
msgid "Sets the :class:`Formatter` for this handler to *fmt*."
msgstr "Définit le :class:`Formatter` du gestionnaire à *fmt*."

#: library/logging.rst:450
msgid "Adds the specified filter *filter* to this handler."
msgstr "Ajoute le filtre *filter* au gestionnaire."

#: library/logging.rst:455
msgid "Removes the specified filter *filter* from this handler."
msgstr "Retire le filtre *filter* du gestionnaire."

#: library/logging.rst:460
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 ""
"Applique les filtres du gestionnaire à *record* et renvoie ``True`` si "
"l'entrée doit être traitée. Les filtres sont appliqués l'un après l'autre, "
"jusqu'à ce que l'un renvoie faux. Si aucun d'entre eux ne renvoie faux, "
"l'entrée est enregistrée, sinon le gestionnaire ne traitera pas l'entrée."

#: library/logging.rst:469
msgid ""
"Ensure all logging output has been flushed. This version does nothing and is "
"intended to be implemented by subclasses."
msgstr ""
"Oblige toutes les entrées à être traitées. Cette fonction ne fait rien de "
"spécial et doit être redéfinie par les sous-classes."

#: library/logging.rst:475
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 ""
"Recycle toutes les ressources utilisées par le gestionnaire. Cette version "
"ne fait rien de particulier mais elle retire le gestionnaire de la liste "
"interne des gestionnaires à recycler à l'appel de :func:`shutdown`. Les sous-"
"classes doivent appeler cette méthode depuis leur surcharge de :meth:`close`."

#: library/logging.rst:483
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 ""
"Traite ou non *record* selon les filtres ajoutés au gestionnaire. Un verrou "
"sur l'E-S. est mis en place durant l'écriture effective."

#: library/logging.rst:490
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 ""
"Cette méthode est appelée quand une exception est levée lors d'un appel à :"
"meth:`emit`. Si l'attribut ``raiseExceptions`` du module est ``False``, les "
"exceptions sont ignorées. C'est en général le comportement attendu d'un "
"système de journalisation — la plupart des utilisateurs ne se préoccupent "
"pas des erreurs du système de journalisation même, seulement des erreurs de "
"l'application. Il est tout de même possible de redéfinir cette méthode ; "
"*record* est l'entrée qui était en train d'être traitée quand l'exception a "
"eu lieu. La valeur par défaut de ``raiseExceptions`` est ``True``, ce qui "
"est pratique lors du développement."

#: library/logging.rst:503
msgid ""
"Do formatting for a record - if a formatter is set, use it. Otherwise, use "
"the default formatter for the module."
msgstr ""
"Formate *record* avec le formateur défini. S'il n'y en a pas, le formateur "
"par défaut du module est utilisé."

#: library/logging.rst:509
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 ""
"Journalise *record* « pour de bon ». Cette version doit être redéfinie par "
"les sous-classes et lève donc une :exc:`NotImplementedError`."

#: library/logging.rst:513
msgid ""
"For a list of handlers included as standard, see :mod:`logging.handlers`."
msgstr ""
"Les gestionnaires de la bibliothèque standard sont répertoriés dans :mod:"
"`logging.handlers`."

#: library/logging.rst:518
msgid "Formatter Objects"
msgstr "Formateurs"

#: library/logging.rst:522
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 ""

#: library/logging.rst:530
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 ""

#: library/logging.rst:537
msgid ""
"The useful mapping keys in a :class:`LogRecord` are given in the section on :"
"ref:`logrecord-attributes`."
msgstr ""

#: library/logging.rst:543
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 ""

#: library/logging.rst:549
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 ""

#: library/logging.rst:557
msgid ""
"The *defaults* parameter can be a dictionary with default values to use in "
"custom fields. For example: ``logging.Formatter('%(ip)s %(message)s', "
"defaults={\"ip\": None})``"
msgstr ""

#: library/logging.rst:561
msgid "The *style* parameter was added."
msgstr "Ajout du paramètre *style*."

#: library/logging.rst:564
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 ""

#: library/logging.rst:569
msgid "The *defaults* parameter was added."
msgstr "Ajout du paramètre *defaults*."

#: library/logging.rst:574
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 (by setting the *exc_text* "
"attribute to ``None``) 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 ""

#: library/logging.rst:590
msgid ""
"If stack information is available, it's appended after the exception "
"information, using :meth:`formatStack` to transform it if necessary."
msgstr ""

#: library/logging.rst:596
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 ""

#: library/logging.rst:606
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 ""

#: library/logging.rst:614
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 ""

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

#: library/logging.rst:632
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 ""

#: library/logging.rst:639
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 ""

#: library/logging.rst:646
msgid "Filter Objects"
msgstr "Filtres"

#: library/logging.rst:648
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 ""

#: library/logging.rst:658
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 ""

#: library/logging.rst:665
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 ""

#: library/logging.rst:669
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 ""

#: library/logging.rst:676
msgid ""
"You don't actually need to subclass ``Filter``: you can pass any instance "
"which has a ``filter`` method with the same semantics."
msgstr ""

#: library/logging.rst:679
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 ""

#: library/logging.rst:689
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 ""

#: library/logging.rst:701
msgid "LogRecord Objects"
msgstr "Objets LogRecord"

#: library/logging.rst:703
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 ""

#: library/logging.rst:711
msgid "Contains all the information pertinent to the event being logged."
msgstr ""

#: library/logging.rst:713
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 ""

#: library/logging.rst:0
#, fuzzy
msgid "Parameters"
msgstr "Paramètres :"

#: library/logging.rst:717
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 ""

#: library/logging.rst:721
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 ""

#: library/logging.rst:725
msgid "The full pathname of the source file where the logging call was made."
msgstr ""

#: library/logging.rst:727
msgid "The line number in the source file where the logging call was made."
msgstr ""

#: library/logging.rst:729
msgid ""
"The event description message, possibly a format string with placeholders "
"for variable data."
msgstr ""

#: library/logging.rst:731
msgid ""
"Variable data to merge into the *msg* argument to obtain the event "
"description."
msgstr ""

#: library/logging.rst:733
msgid ""
"An exception tuple with the current exception information, or ``None`` if no "
"exception information is available."
msgstr ""

#: library/logging.rst:735
msgid ""
"The name of the function or method from which the logging call was invoked."
msgstr ""

#: library/logging.rst:737
msgid ""
"A text string representing stack information from the base of the stack in "
"the current thread, up to the logging call."
msgstr ""

#: library/logging.rst:742
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 ""

#: library/logging.rst:749
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 ""

#: library/logging.rst:755
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 ""

#: library/logging.rst:767
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 ""

#: library/logging.rst:776
msgid "LogRecord attributes"
msgstr ""

#: library/logging.rst:778
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 ""

#: library/logging.rst:786
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 ""

#: library/logging.rst:792
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 ""

#: library/logging.rst:799
msgid "Attribute name"
msgstr ""

#: library/logging.rst:1186
msgid "Format"
msgstr "Format"

#: library/logging.rst:1186
msgid "Description"
msgstr "Description"

#: library/logging.rst:0
msgid "args"
msgstr ""

#: library/logging.rst:815 library/logging.rst:861
msgid "You shouldn't need to format this yourself."
msgstr ""

#: library/logging.rst:801
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 ""

#: library/logging.rst:806
msgid "asctime"
msgstr ""

#: library/logging.rst:806
msgid "``%(asctime)s``"
msgstr "``%(asctime)s``"

#: library/logging.rst:806
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 ""

#: library/logging.rst:812
msgid "created"
msgstr "created"

#: library/logging.rst:812
msgid "``%(created)f``"
msgstr "``%(created)f``"

#: library/logging.rst:812
msgid ""
"Time when the :class:`LogRecord` was created (as returned by :func:`time."
"time`)."
msgstr ""

#: library/logging.rst:0
msgid "exc_info"
msgstr "exc_info"

#: library/logging.rst:815
msgid ""
"Exception tuple (à la ``sys.exc_info``) or, if no exception has occurred, "
"``None``."
msgstr ""

#: library/logging.rst:818
msgid "filename"
msgstr "filename"

#: library/logging.rst:818
msgid "``%(filename)s``"
msgstr "``%(filename)s``"

#: library/logging.rst:818
msgid "Filename portion of ``pathname``."
msgstr ""

#: library/logging.rst:820
msgid "funcName"
msgstr "funcName"

#: library/logging.rst:820
msgid "``%(funcName)s``"
msgstr "``%(funcName)s``"

#: library/logging.rst:820
msgid "Name of function containing the logging call."
msgstr ""

#: library/logging.rst:822
msgid "levelname"
msgstr "levelname"

#: library/logging.rst:822
msgid "``%(levelname)s``"
msgstr "``%(levelname)s``"

#: library/logging.rst:822
msgid ""
"Text logging level for the message (``'DEBUG'``, ``'INFO'``, ``'WARNING'``, "
"``'ERROR'``, ``'CRITICAL'``)."
msgstr ""

#: library/logging.rst:826
msgid "levelno"
msgstr ""

#: library/logging.rst:826
msgid "``%(levelno)s``"
msgstr "``%(levelno)s``"

#: library/logging.rst:826
msgid ""
"Numeric logging level for the message (:const:`DEBUG`, :const:`INFO`, :const:"
"`WARNING`, :const:`ERROR`, :const:`CRITICAL`)."
msgstr ""

#: library/logging.rst:831
msgid "lineno"
msgstr "lineno"

#: library/logging.rst:831
msgid "``%(lineno)d``"
msgstr "``%(lineno)d``"

#: library/logging.rst:831
msgid "Source line number where the logging call was issued (if available)."
msgstr ""

#: library/logging.rst:834
msgid "message"
msgstr "message"

#: library/logging.rst:834
msgid "``%(message)s``"
msgstr "``%(message)s``"

#: library/logging.rst:834
msgid ""
"The logged message, computed as ``msg % args``. This is set when :meth:"
"`Formatter.format` is invoked."
msgstr ""

#: library/logging.rst:838
msgid "module"
msgstr "module"

#: library/logging.rst:838
msgid "``%(module)s``"
msgstr "``%(module)s``"

#: library/logging.rst:838
msgid "Module (name portion of ``filename``)."
msgstr ""

#: library/logging.rst:840
msgid "msecs"
msgstr "msecs"

#: library/logging.rst:840
msgid "``%(msecs)d``"
msgstr "``%(msecs)d``"

#: library/logging.rst:840
msgid ""
"Millisecond portion of the time when the :class:`LogRecord` was created."
msgstr ""

#: library/logging.rst:0
msgid "msg"
msgstr ""

#: library/logging.rst:843
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 ""

#: library/logging.rst:0
msgid "name"
msgstr ""

#: library/logging.rst:848
msgid "``%(name)s``"
msgstr "``%(name)s``"

#: library/logging.rst:848
msgid "Name of the logger used to log the call."
msgstr ""

#: library/logging.rst:850
msgid "pathname"
msgstr "pathname"

#: library/logging.rst:850
msgid "``%(pathname)s``"
msgstr "``%(pathname)s``"

#: library/logging.rst:850
msgid ""
"Full pathname of the source file where the logging call was issued (if "
"available)."
msgstr ""

#: library/logging.rst:853
msgid "process"
msgstr "process"

#: library/logging.rst:853
msgid "``%(process)d``"
msgstr "``%(process)d``"

#: library/logging.rst:853
msgid "Process ID (if available)."
msgstr ""

#: library/logging.rst:855
msgid "processName"
msgstr "processName"

#: library/logging.rst:855
msgid "``%(processName)s``"
msgstr "``%(processName)s``"

#: library/logging.rst:855
msgid "Process name (if available)."
msgstr ""

#: library/logging.rst:857
msgid "relativeCreated"
msgstr "relativeCreated"

#: library/logging.rst:857
msgid "``%(relativeCreated)d``"
msgstr "``%(relativeCreated)d``"

#: library/logging.rst:857
msgid ""
"Time in milliseconds when the LogRecord was created, relative to the time "
"the logging module was loaded."
msgstr ""

#: library/logging.rst:861
msgid "stack_info"
msgstr ""

#: library/logging.rst:861
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 ""

#: library/logging.rst:867
msgid "thread"
msgstr ""

#: library/logging.rst:867
msgid "``%(thread)d``"
msgstr "``%(thread)d``"

#: library/logging.rst:867
msgid "Thread ID (if available)."
msgstr ""

#: library/logging.rst:869
msgid "threadName"
msgstr ""

#: library/logging.rst:869
msgid "``%(threadName)s``"
msgstr "``%(threadName)s``"

#: library/logging.rst:869
msgid "Thread name (if available)."
msgstr ""

#: library/logging.rst:872
msgid "*processName* was added."
msgstr ""

#: library/logging.rst:879
msgid "LoggerAdapter Objects"
msgstr ""

#: library/logging.rst:881
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 ""

#: library/logging.rst:887
msgid ""
"Returns an instance of :class:`LoggerAdapter` initialized with an "
"underlying :class:`Logger` instance and a dict-like object."
msgstr ""

#: library/logging.rst:892
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 ""

#: library/logging.rst:898
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 ""

#: library/logging.rst:907
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 ""

#: library/logging.rst:912
msgid ""
"Attribute :attr:`manager` and method :meth:`_log` were added, which delegate "
"to the underlying logger and allow adapters to be nested."
msgstr ""

#: library/logging.rst:918
msgid "Thread Safety"
msgstr ""

#: library/logging.rst:920
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 ""

#: library/logging.rst:925
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 ""

#: library/logging.rst:932
msgid "Module-Level Functions"
msgstr "Fonctions de niveau module"

#: library/logging.rst:934
msgid ""
"In addition to the classes described above, there are a number of module-"
"level functions."
msgstr ""

#: library/logging.rst:940
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 ""

#: library/logging.rst:945
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 ""

#: library/logging.rst:952
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 ""

#: library/logging.rst:963
msgid "Return a callable which is used to create a :class:`LogRecord`."
msgstr ""

#: library/logging.rst:965
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 ""

#: library/logging.rst:970
msgid ""
"See :func:`setLogRecordFactory` for more information about the how the "
"factory is called."
msgstr ""

#: library/logging.rst:975
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 ""

#: library/logging.rst:980
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 ""

#: library/logging.rst:1006
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 ""

#: library/logging.rst:1017
msgid "would print something like:"
msgstr ""

#: library/logging.rst:1027
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 ""

#: library/logging.rst:1046
msgid ""
"Logs a message with level :const:`INFO` on the root logger. The arguments "
"are interpreted as for :func:`debug`."
msgstr ""

#: library/logging.rst:1052
msgid ""
"Logs a message with level :const:`WARNING` on the root logger. The arguments "
"are interpreted as for :func:`debug`."
msgstr ""

#: library/logging.rst:1055
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 ""

#: library/logging.rst:1062
msgid ""
"Logs a message with level :const:`ERROR` on the root logger. The arguments "
"are interpreted as for :func:`debug`."
msgstr ""

#: library/logging.rst:1068
msgid ""
"Logs a message with level :const:`CRITICAL` on the root logger. The "
"arguments are interpreted as for :func:`debug`."
msgstr ""

#: library/logging.rst:1074
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 ""

#: library/logging.rst:1080
msgid ""
"Logs a message with level *level* on the root logger. The other arguments "
"are interpreted as for :func:`debug`."
msgstr ""

#: library/logging.rst:1085
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 ""

#: library/logging.rst:1096
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 ""

#: library/logging.rst:1101
msgid ""
"The *level* parameter was defaulted to level ``CRITICAL``. See :issue:"
"`28524` for more information about this change."
msgstr ""

#: library/logging.rst:1107
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 ""

#: library/logging.rst:1114
msgid ""
"If you are thinking of defining your own levels, please see the section on :"
"ref:`custom-levels`."
msgstr ""

#: library/logging.rst:1119
msgid ""
"Returns a mapping from level names to their corresponding logging levels. "
"For example, the string \"CRITICAL\" maps to :const:`CRITICAL`. The returned "
"mapping is copied from an internal mapping on each call to this function."
msgstr ""

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

#: library/logging.rst:1129
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 ""

#: library/logging.rst:1136
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 ""

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

#: library/logging.rst:1143
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 ""

#: library/logging.rst:1149
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 ""

#: library/logging.rst:1157
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 ""

#: library/logging.rst:1165
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 ""

#: library/logging.rst:1171
msgid ""
"This function does nothing if the root logger already has handlers "
"configured, unless the keyword argument *force* is set to ``True``."
msgstr ""

#: library/logging.rst:1174
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 ""

#: library/logging.rst:1181
msgid "The following keyword arguments are supported."
msgstr ""

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

#: library/logging.rst:1188
msgid ""
"Specifies that a :class:`FileHandler` be created, using the specified "
"filename, rather than a :class:`StreamHandler`."
msgstr ""

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

#: library/logging.rst:1192
msgid ""
"If *filename* is specified, open the file in this :ref:`mode <filemodes>`. "
"Defaults to ``'a'``."
msgstr ""

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

#: library/logging.rst:1196
msgid ""
"Use the specified format string for the handler. Defaults to attributes "
"``levelname``, ``name`` and ``message`` separated by colons."
msgstr ""

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

#: library/logging.rst:1201
msgid ""
"Use the specified date/time format, as accepted by :func:`time.strftime`."
msgstr ""

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

#: library/logging.rst:1204
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 ""

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

#: library/logging.rst:1212
msgid "Set the root logger level to the specified :ref:`level <levels>`."
msgstr ""

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

#: library/logging.rst:1215
msgid ""
"Use the specified stream to initialize the :class:`StreamHandler`. Note that "
"this argument is incompatible with *filename* - if both are present, a "
"``ValueError`` is raised."
msgstr ""

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

#: library/logging.rst:1221
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 ""

#: library/logging.rst:1230
#, fuzzy
msgid "*force*"
msgstr "*format*"

#: library/logging.rst:1230
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 ""

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

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

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

#: library/logging.rst:1241
msgid ""
"If this keyword argument is specified along with *filename*, its value is "
"used when the :class:`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 ""

#: library/logging.rst:1252
msgid "The *style* argument was added."
msgstr ""

#: library/logging.rst:1255
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 ""

#: library/logging.rst:1261
msgid "The *force* argument was added."
msgstr ""

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

#: library/logging.rst:1269
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 ""

#: library/logging.rst:1273
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 ""

#: library/logging.rst:1280
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 ""

#: library/logging.rst:1291
msgid "Set a callable which is used to create a :class:`LogRecord`."
msgstr ""

#: library/logging.rst:1293
msgid "The factory callable to be used to instantiate a log record."
msgstr ""

#: library/logging.rst:1295
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 ""

#: library/logging.rst:1300
msgid "The factory has the following signature:"
msgstr ""

#: library/logging.rst:1302
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)``"

#: library/logging.rst:1304
msgid "The logger name."
msgstr ""

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

#: library/logging.rst:1305
msgid "The logging level (numeric)."
msgstr ""

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

#: library/logging.rst:1306
msgid "The full pathname of the file where the logging call was made."
msgstr ""

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

#: library/logging.rst:1307
msgid "The line number in the file where the logging call was made."
msgstr ""

#: library/logging.rst:1308
msgid "The logging message."
msgstr ""

#: library/logging.rst:1309
msgid "The arguments for the logging message."
msgstr ""

#: library/logging.rst:1310
msgid "An exception tuple, or ``None``."
msgstr ""

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

#: library/logging.rst:1311
msgid "The name of the function or method which invoked the logging call."
msgstr ""

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

#: library/logging.rst:1313
msgid ""
"A stack traceback such as is provided by :func:`traceback.print_stack`, "
"showing the call hierarchy."
msgstr ""

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

#: library/logging.rst:1315
msgid "Additional keyword arguments."
msgstr ""

#: library/logging.rst:1319
msgid "Module-Level Attributes"
msgstr ""

#: library/logging.rst:1323
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 ""

#: library/logging.rst:1334
msgid "Integration with the warnings module"
msgstr ""

#: library/logging.rst:1336
msgid ""
"The :func:`captureWarnings` function can be used to integrate :mod:`logging` "
"with the :mod:`warnings` module."
msgstr ""

#: library/logging.rst:1341
msgid ""
"This function is used to turn the capture of warnings by logging on and off."
msgstr ""

#: library/logging.rst:1344
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 ""

#: library/logging.rst:1349
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 ""

#: library/logging.rst:1357
msgid "Module :mod:`logging.config`"
msgstr "Module :mod:`logging.config`"

#: library/logging.rst:1357
msgid "Configuration API for the logging module."
msgstr "API de configuration pour le module de journalisation."

#: library/logging.rst:1360
msgid "Module :mod:`logging.handlers`"
msgstr "Module :mod:`logging.handlers`"

#: library/logging.rst:1360
msgid "Useful handlers included with the logging module."
msgstr "Gestionnaires utiles inclus avec le module de journalisation."

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

#: library/logging.rst:1363
msgid ""
"The proposal which described this feature for inclusion in the Python "
"standard library."
msgstr ""

#: library/logging.rst:1369
msgid ""
"`Original Python logging package <https://old.red-dove.com/python_logging."
"html>`_"
msgstr ""

#: library/logging.rst:1367
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 ""