# 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: 2023-04-14 13:19+0200\n" "PO-Revision-Date: 2023-03-30 19:47+0200\n" "Last-Translator: Mathieu Dupuy\n" "Language-Team: FRENCH \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 3.2.2\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 `" msgstr ":ref:`Tutoriel de découverte `" #: library/logging.rst:20 msgid ":ref:`Advanced Tutorial `" msgstr ":ref:`Tutoriel avancé `" #: library/logging.rst:21 msgid ":ref:`Logging Cookbook `" msgstr ":ref:`Recettes pour la journalisation `" #: 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 simplest example:" msgstr "" #: library/logging.rst:41 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 view the " "tutorials (**see the links above and on the right**)." msgstr "" "Ce module offre de nombreuses fonctionnalités et une grande flexibilité. Si " "vous n'êtes pas familier avec la journalisation, la meilleure façon de " "l’appréhender est de consulter les tutoriels (**voir les liens ci-dessus et " "à droite**)." #: library/logging.rst:45 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:48 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:49 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:51 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:53 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:59 msgid "Logger Objects" msgstr "Enregistreurs" #: library/logging.rst:61 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:66 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:82 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:88 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:91 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:100 msgid "The constructor sets this attribute to ``True``." msgstr "Le constructeur fixe cet attribut à ``True``." #: library/logging.rst:102 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:113 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:118 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:123 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:127 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:131 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:447 msgid "See :ref:`levels` for a list of levels." msgstr "Voir :ref:`levels` pour la liste des niveaux." #: library/logging.rst:136 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:146 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:154 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:164 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:175 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:181 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:184 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:1067 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:1076 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:1084 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:209 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:217 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:229 msgid "would print something like" msgstr "affiche" #: library/logging.rst:235 msgid "" "The keys in the dictionary passed in *extra* should not clash with the keys " "used by the logging system. (See the section on :ref:`logrecord-attributes` " "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:239 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:1115 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:253 msgid "" "If no handler is attached to this logger (or any of its ancestors, taking " "into account the relevant :attr:`Logger.propagate` attributes), the message " "will be sent to the handler set on :attr:`lastResort`." msgstr "" #: library/logging.rst:1126 msgid "The *stack_info* parameter was added." msgstr "ajout du paramètre *stack_info*." #: library/logging.rst:260 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:263 msgid "The *stacklevel* parameter was added." msgstr "ajout du paramètre *stacklevel*." #: library/logging.rst:269 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:275 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:278 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:284 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:290 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:296 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:302 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:309 msgid "Adds the specified filter *filter* to this logger." msgstr "Ajoute le filtre *filter* à l'enregistreur." #: library/logging.rst:314 msgid "Removes the specified filter *filter* from this logger." msgstr "Retire le filtre *filter* de cet enregistreur." #: library/logging.rst:319 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:328 msgid "Adds the specified handler *hdlr* to this logger." msgstr "Ajoute le gestionnaire *hdlr* à l'enregistreur." #: library/logging.rst:333 msgid "Removes the specified handler *hdlr* from this logger." msgstr "Retire le gestionnaire *hdlr* de l'enregistreur." #: library/logging.rst:338 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:342 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:352 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:360 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:365 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:374 msgid "Loggers can now be pickled and unpickled." msgstr "les enregistreurs peuvent être sérialisés et désérialisés." #: library/logging.rst:380 msgid "Logging Levels" msgstr "Niveaux de journalisation" #: library/logging.rst:382 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:389 msgid "Level" msgstr "Niveau" #: library/logging.rst:389 msgid "Numeric value" msgstr "Valeur numérique" #: library/logging.rst:391 msgid "``CRITICAL``" msgstr "``CRITICAL``" #: library/logging.rst:391 msgid "50" msgstr "50" #: library/logging.rst:393 msgid "``ERROR``" msgstr "``ERROR``" #: library/logging.rst:393 msgid "40" msgstr "40" #: library/logging.rst:395 msgid "``WARNING``" msgstr "``WARNING``" #: library/logging.rst:395 msgid "30" msgstr "30" #: library/logging.rst:397 msgid "``INFO``" msgstr "``INFO``" #: library/logging.rst:397 msgid "20" msgstr "20" #: library/logging.rst:399 msgid "``DEBUG``" msgstr "``DEBUG``" #: library/logging.rst:399 msgid "10" msgstr "10" #: library/logging.rst:401 msgid "``NOTSET``" msgstr "``NOTSET``" #: library/logging.rst:401 msgid "0" msgstr "0" #: library/logging.rst:408 msgid "Handler Objects" msgstr "Gestionnaires" #: library/logging.rst:410 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:419 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:426 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:432 msgid "Acquires the thread lock created with :meth:`createLock`." msgstr "Acquiert le verrou créé par :meth:`createLock`." #: library/logging.rst:437 msgid "Releases the thread lock acquired with :meth:`acquire`." msgstr "Relâche le verrou acquis par :meth:`acquire`." #: library/logging.rst:442 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:449 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:457 msgid "Sets the :class:`Formatter` for this handler to *fmt*." msgstr "Définit le :class:`Formatter` du gestionnaire à *fmt*." #: library/logging.rst:462 msgid "Adds the specified filter *filter* to this handler." msgstr "Ajoute le filtre *filter* au gestionnaire." #: library/logging.rst:467 msgid "Removes the specified filter *filter* from this handler." msgstr "Retire le filtre *filter* du gestionnaire." #: library/logging.rst:472 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:481 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:487 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:495 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:502 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:515 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:521 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:525 msgid "" "This method is called after a handler-level lock is acquired, which is " "released after this method returns. When you override this method, note that " "you should be careful when calling anything that invokes other parts of the " "logging API which might do locking, because that might result in a deadlock. " "Specifically:" msgstr "" #: library/logging.rst:531 msgid "" "Logging configuration APIs acquire the module-level lock, and then " "individual handler-level locks as those handlers are configured." msgstr "" #: library/logging.rst:534 msgid "" "Many logging APIs lock the module-level lock. If such an API is called from " "this method, it could cause a deadlock if a configuration call is made on " "another thread, because that thread will try to acquire the module-level " "lock *before* the handler-level lock, whereas this thread tries to acquire " "the module-level lock *after* the handler-level lock (because in this " "method, the handler-level lock has already been acquired)." msgstr "" #: library/logging.rst:541 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:546 msgid "Formatter Objects" msgstr "Formateurs" #: library/logging.rst:550 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:558 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:565 msgid "" "The useful mapping keys in a :class:`LogRecord` are given in the section on :" "ref:`logrecord-attributes`." msgstr "" #: library/logging.rst:571 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:577 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:585 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:589 msgid "The *style* parameter was added." msgstr "Ajout du paramètre *style*." #: library/logging.rst:592 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:597 msgid "The *defaults* parameter was added." msgstr "Ajout du paramètre *defaults*." #: library/logging.rst:602 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:618 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:624 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:634 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:642 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:655 msgid "The ``default_msec_format`` can be ``None``." msgstr "" #: library/logging.rst:660 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:667 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:673 msgid "" "A base formatter class suitable for subclassing when you want to format a " "number of records. You can pass a :class:`Formatter` instance which you want " "to use to format each line (that corresponds to a single record). If not " "specified, the default formatter (which just outputs the event message) is " "used as the line formatter." msgstr "" #: library/logging.rst:681 msgid "" "Return a header for a list of *records*. The base implementation just " "returns the empty string. You will need to override this method if you want " "specific behaviour, e.g. to show the count of records, a title or a " "separator line." msgstr "" #: library/logging.rst:688 msgid "" "Return a footer for a list of *records*. The base implementation just " "returns the empty string. You will need to override this method if you want " "specific behaviour, e.g. to show the count of records or a separator line." msgstr "" #: library/logging.rst:695 msgid "" "Return formatted text for a list of *records*. The base implementation just " "returns the empty string if there are no records; otherwise, it returns the " "concatenation of the header, each record formatted with the line formatter, " "and the footer." msgstr "" #: library/logging.rst:703 msgid "Filter Objects" msgstr "Filtres" #: library/logging.rst:705 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:715 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:722 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:726 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:733 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:736 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:746 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:759 msgid "LogRecord Objects" msgstr "Objets LogRecord" #: library/logging.rst:761 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:769 msgid "Contains all the information pertinent to the event being logged." msgstr "" #: library/logging.rst:771 msgid "" "The primary information is passed in *msg* and *args*, which are combined " "using ``msg % args`` to create the :attr:`!message` attribute of the record." msgstr "" #: library/logging.rst:0 msgid "Parameters" msgstr "Paramètres" #: library/logging.rst:775 msgid "" "The name of the logger used to log the event represented by this :class:`!" "LogRecord`. Note that the logger name in the :class:`!LogRecord` will always " "have this value, even though it may be emitted by a handler attached to a " "different (ancestor) logger." msgstr "" #: library/logging.rst:783 msgid "" "The :ref:`numeric level ` of the logging event (such as ``10`` for " "``DEBUG``, ``20`` for ``INFO``, etc). Note that this is converted to *two* " "attributes of the LogRecord: :attr:`!levelno` for the numeric value and :" "attr:`!levelname` for the corresponding level name." msgstr "" #: library/logging.rst:790 msgid "" "The full string path of the source file where the logging call was made." msgstr "" #: library/logging.rst:794 msgid "The line number in the source file where the logging call was made." msgstr "" #: library/logging.rst:798 msgid "" "The event description message, which can be a %-format string with " "placeholders for variable data, or an arbitrary object (see :ref:`arbitrary-" "object-messages`)." msgstr "" #: library/logging.rst:803 msgid "" "Variable data to merge into the *msg* argument to obtain the event " "description." msgstr "" #: library/logging.rst:807 msgid "" "An exception tuple with the current exception information, as returned by :" "func:`sys.exc_info`, or ``None`` if no exception information is available." msgstr "" #: library/logging.rst:812 msgid "" "The name of the function or method from which the logging call was invoked." msgstr "" #: library/logging.rst:816 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:823 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:830 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:836 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:848 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:857 msgid "LogRecord attributes" msgstr "" #: library/logging.rst:859 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:867 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:873 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:880 msgid "Attribute name" msgstr "" #: library/logging.rst:1271 msgid "Format" msgstr "Format" #: library/logging.rst:1271 msgid "Description" msgstr "Description" #: library/logging.rst:882 msgid "args" msgstr "" #: library/logging.rst:896 library/logging.rst:942 msgid "You shouldn't need to format this yourself." msgstr "" #: library/logging.rst:882 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:887 msgid "asctime" msgstr "" #: library/logging.rst:887 msgid "``%(asctime)s``" msgstr "``%(asctime)s``" #: library/logging.rst:887 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:893 msgid "created" msgstr "created" #: library/logging.rst:893 msgid "``%(created)f``" msgstr "``%(created)f``" #: library/logging.rst:893 msgid "" "Time when the :class:`LogRecord` was created (as returned by :func:`time." "time`)." msgstr "" #: library/logging.rst:896 msgid "exc_info" msgstr "exc_info" #: library/logging.rst:896 msgid "" "Exception tuple (à la ``sys.exc_info``) or, if no exception has occurred, " "``None``." msgstr "" #: library/logging.rst:899 msgid "filename" msgstr "filename" #: library/logging.rst:899 msgid "``%(filename)s``" msgstr "``%(filename)s``" #: library/logging.rst:899 msgid "Filename portion of ``pathname``." msgstr "" #: library/logging.rst:901 msgid "funcName" msgstr "funcName" #: library/logging.rst:901 msgid "``%(funcName)s``" msgstr "``%(funcName)s``" #: library/logging.rst:901 msgid "Name of function containing the logging call." msgstr "" #: library/logging.rst:903 msgid "levelname" msgstr "levelname" #: library/logging.rst:903 msgid "``%(levelname)s``" msgstr "``%(levelname)s``" #: library/logging.rst:903 msgid "" "Text logging level for the message (``'DEBUG'``, ``'INFO'``, ``'WARNING'``, " "``'ERROR'``, ``'CRITICAL'``)." msgstr "" #: library/logging.rst:907 msgid "levelno" msgstr "" #: library/logging.rst:907 msgid "``%(levelno)s``" msgstr "``%(levelno)s``" #: library/logging.rst:907 msgid "" "Numeric logging level for the message (:const:`DEBUG`, :const:`INFO`, :const:" "`WARNING`, :const:`ERROR`, :const:`CRITICAL`)." msgstr "" #: library/logging.rst:912 msgid "lineno" msgstr "lineno" #: library/logging.rst:912 msgid "``%(lineno)d``" msgstr "``%(lineno)d``" #: library/logging.rst:912 msgid "Source line number where the logging call was issued (if available)." msgstr "" #: library/logging.rst:915 msgid "message" msgstr "message" #: library/logging.rst:915 msgid "``%(message)s``" msgstr "``%(message)s``" #: library/logging.rst:915 msgid "" "The logged message, computed as ``msg % args``. This is set when :meth:" "`Formatter.format` is invoked." msgstr "" #: library/logging.rst:919 msgid "module" msgstr "module" #: library/logging.rst:919 msgid "``%(module)s``" msgstr "``%(module)s``" #: library/logging.rst:919 msgid "Module (name portion of ``filename``)." msgstr "" #: library/logging.rst:921 msgid "msecs" msgstr "msecs" #: library/logging.rst:921 msgid "``%(msecs)d``" msgstr "``%(msecs)d``" #: library/logging.rst:921 msgid "" "Millisecond portion of the time when the :class:`LogRecord` was created." msgstr "" #: library/logging.rst:924 msgid "msg" msgstr "" #: library/logging.rst:924 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:929 msgid "name" msgstr "" #: library/logging.rst:929 msgid "``%(name)s``" msgstr "``%(name)s``" #: library/logging.rst:929 msgid "Name of the logger used to log the call." msgstr "" #: library/logging.rst:931 msgid "pathname" msgstr "pathname" #: library/logging.rst:931 msgid "``%(pathname)s``" msgstr "``%(pathname)s``" #: library/logging.rst:931 msgid "" "Full pathname of the source file where the logging call was issued (if " "available)." msgstr "" #: library/logging.rst:934 msgid "process" msgstr "process" #: library/logging.rst:934 msgid "``%(process)d``" msgstr "``%(process)d``" #: library/logging.rst:934 msgid "Process ID (if available)." msgstr "" #: library/logging.rst:936 msgid "processName" msgstr "processName" #: library/logging.rst:936 msgid "``%(processName)s``" msgstr "``%(processName)s``" #: library/logging.rst:936 msgid "Process name (if available)." msgstr "" #: library/logging.rst:938 msgid "relativeCreated" msgstr "relativeCreated" #: library/logging.rst:938 msgid "``%(relativeCreated)d``" msgstr "``%(relativeCreated)d``" #: library/logging.rst:938 msgid "" "Time in milliseconds when the LogRecord was created, relative to the time " "the logging module was loaded." msgstr "" #: library/logging.rst:942 msgid "stack_info" msgstr "" #: library/logging.rst:942 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:948 msgid "thread" msgstr "" #: library/logging.rst:948 msgid "``%(thread)d``" msgstr "``%(thread)d``" #: library/logging.rst:948 msgid "Thread ID (if available)." msgstr "" #: library/logging.rst:950 msgid "threadName" msgstr "" #: library/logging.rst:950 msgid "``%(threadName)s``" msgstr "``%(threadName)s``" #: library/logging.rst:950 msgid "Thread name (if available)." msgstr "" #: library/logging.rst:953 msgid "*processName* was added." msgstr "" #: library/logging.rst:960 msgid "LoggerAdapter Objects" msgstr "" #: library/logging.rst:962 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 `." msgstr "" #: library/logging.rst:968 msgid "" "Returns an instance of :class:`LoggerAdapter` initialized with an " "underlying :class:`Logger` instance and a dict-like object." msgstr "" #: library/logging.rst:973 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:979 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:988 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:993 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:999 msgid "Thread Safety" msgstr "" #: library/logging.rst:1001 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:1006 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:1013 msgid "Module-Level Functions" msgstr "Fonctions de niveau module" #: library/logging.rst:1015 msgid "" "In addition to the classes described above, there are a number of module-" "level functions." msgstr "" #: library/logging.rst:1021 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:1026 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:1033 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:1044 msgid "Return a callable which is used to create a :class:`LogRecord`." msgstr "" #: library/logging.rst:1046 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:1051 msgid "" "See :func:`setLogRecordFactory` for more information about the how the " "factory is called." msgstr "" #: library/logging.rst:1056 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:1061 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:1087 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:1098 msgid "would print something like:" msgstr "" #: library/logging.rst:1104 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:1108 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:1122 msgid "" "This function (as well as :func:`info`, :func:`warning`, :func:`error` and :" "func:`critical`) will call :func:`basicConfig` if the root logger doesn't " "have any handler attached." msgstr "" #: library/logging.rst:1131 msgid "" "Logs a message with level :const:`INFO` on the root logger. The arguments " "are interpreted as for :func:`debug`." msgstr "" #: library/logging.rst:1137 msgid "" "Logs a message with level :const:`WARNING` on the root logger. The arguments " "are interpreted as for :func:`debug`." msgstr "" #: library/logging.rst:1140 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:1147 msgid "" "Logs a message with level :const:`ERROR` on the root logger. The arguments " "are interpreted as for :func:`debug`." msgstr "" #: library/logging.rst:1153 msgid "" "Logs a message with level :const:`CRITICAL` on the root logger. The " "arguments are interpreted as for :func:`debug`." msgstr "" #: library/logging.rst:1159 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:1165 msgid "" "Logs a message with level *level* on the root logger. The other arguments " "are interpreted as for :func:`debug`." msgstr "" #: library/logging.rst:1170 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:1181 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:1186 msgid "" "The *level* parameter was defaulted to level ``CRITICAL``. See :issue:" "`28524` for more information about this change." msgstr "" #: library/logging.rst:1192 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:1199 msgid "" "If you are thinking of defining your own levels, please see the section on :" "ref:`custom-levels`." msgstr "" #: library/logging.rst:1204 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:1212 msgid "Returns the textual or numeric representation of logging level *level*." msgstr "" #: library/logging.rst:1214 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:1221 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:1225 msgid "" "If no matching numeric or string value is passed in, the string 'Level %s' % " "level is returned." msgstr "" #: library/logging.rst:1228 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:1234 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:1242 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:1250 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:1256 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:1259 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:1266 msgid "The following keyword arguments are supported." msgstr "" #: library/logging.rst:1273 msgid "*filename*" msgstr "*filename*" #: library/logging.rst:1273 msgid "" "Specifies that a :class:`FileHandler` be created, using the specified " "filename, rather than a :class:`StreamHandler`." msgstr "" #: library/logging.rst:1277 msgid "*filemode*" msgstr "*filemode*" #: library/logging.rst:1277 msgid "" "If *filename* is specified, open the file in this :ref:`mode `. " "Defaults to ``'a'``." msgstr "" #: library/logging.rst:1281 msgid "*format*" msgstr "*format*" #: library/logging.rst:1281 msgid "" "Use the specified format string for the handler. Defaults to attributes " "``levelname``, ``name`` and ``message`` separated by colons." msgstr "" #: library/logging.rst:1286 msgid "*datefmt*" msgstr "*datefmt*" #: library/logging.rst:1286 msgid "" "Use the specified date/time format, as accepted by :func:`time.strftime`." msgstr "" #: library/logging.rst:1289 msgid "*style*" msgstr "*style*" #: library/logging.rst:1289 msgid "" "If *format* is specified, use this style for the format string. One of " "``'%'``, ``'{'`` or ``'$'`` for :ref:`printf-style `, :meth:`str.format` or :class:`string.Template` respectively. " "Defaults to ``'%'``." msgstr "" #: library/logging.rst:1297 msgid "*level*" msgstr "*level*" #: library/logging.rst:1297 msgid "Set the root logger level to the specified :ref:`level `." msgstr "" #: library/logging.rst:1300 msgid "*stream*" msgstr "*stream*" #: library/logging.rst:1300 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:1306 msgid "*handlers*" msgstr "*handlers*" #: library/logging.rst:1306 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:1315 #, fuzzy msgid "*force*" msgstr "*format*" #: library/logging.rst:1315 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:1321 msgid "*encoding*" msgstr "" #: library/logging.rst:1321 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:1326 msgid "*errors*" msgstr "" #: library/logging.rst:1326 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:1337 msgid "The *style* argument was added." msgstr "" #: library/logging.rst:1340 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:1346 msgid "The *force* argument was added." msgstr "" #: library/logging.rst:1349 msgid "The *encoding* and *errors* arguments were added." msgstr "" #: library/logging.rst:1354 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:1358 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:1365 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:1376 msgid "Set a callable which is used to create a :class:`LogRecord`." msgstr "" #: library/logging.rst:1378 msgid "The factory callable to be used to instantiate a log record." msgstr "" #: library/logging.rst:1380 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:1385 msgid "The factory has the following signature:" msgstr "" #: library/logging.rst:1387 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:1389 msgid "The logger name." msgstr "" #: library/logging.rst:0 msgid "level" msgstr "level" #: library/logging.rst:1390 msgid "The logging level (numeric)." msgstr "" #: library/logging.rst:0 msgid "fn" msgstr "fn" #: library/logging.rst:1391 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:1392 msgid "The line number in the file where the logging call was made." msgstr "" #: library/logging.rst:1393 msgid "The logging message." msgstr "" #: library/logging.rst:1394 msgid "The arguments for the logging message." msgstr "" #: library/logging.rst:1395 msgid "An exception tuple, or ``None``." msgstr "" #: library/logging.rst:0 msgid "func" msgstr "func" #: library/logging.rst:1396 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:1398 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:1400 msgid "Additional keyword arguments." msgstr "" #: library/logging.rst:1404 msgid "Module-Level Attributes" msgstr "" #: library/logging.rst:1408 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:1419 msgid "Integration with the warnings module" msgstr "" #: library/logging.rst:1421 msgid "" "The :func:`captureWarnings` function can be used to integrate :mod:`logging` " "with the :mod:`warnings` module." msgstr "" #: library/logging.rst:1426 msgid "" "This function is used to turn the capture of warnings by logging on and off." msgstr "" #: library/logging.rst:1429 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:1434 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:1442 msgid "Module :mod:`logging.config`" msgstr "Module :mod:`logging.config`" #: library/logging.rst:1442 msgid "Configuration API for the logging module." msgstr "API de configuration pour le module de journalisation." #: library/logging.rst:1445 msgid "Module :mod:`logging.handlers`" msgstr "Module :mod:`logging.handlers`" #: library/logging.rst:1445 msgid "Useful handlers included with the logging module." msgstr "Gestionnaires utiles inclus avec le module de journalisation." #: library/logging.rst:1449 msgid ":pep:`282` - A Logging System" msgstr "" #: library/logging.rst:1448 msgid "" "The proposal which described this feature for inclusion in the Python " "standard library." msgstr "" #: library/logging.rst:1454 msgid "" "`Original Python logging package `_" msgstr "" #: library/logging.rst:1452 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 ""