From 464086a75ec1b08ea5c80b530fef79bd2052eb6f Mon Sep 17 00:00:00 2001 From: Guillaume Gay Date: Tue, 13 Nov 2018 14:13:06 +0100 Subject: [PATCH] howto/logging (#379) --- howto/logging.po | 441 +++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 403 insertions(+), 38 deletions(-) diff --git a/howto/logging.po b/howto/logging.po index 78c0e9f7..21c99a62 100644 --- a/howto/logging.po +++ b/howto/logging.po @@ -1,12 +1,11 @@ # Copyright (C) 2001-2018, Python Software Foundation # For licence information, see README file. -# msgid "" msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2018-06-28 15:29+0200\n" -"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"POT-Creation-Date: 2018-06-10 11:27+0200\n" +"PO-Revision-Date: 2018-11-12 23:09+0100\n" "Last-Translator: FULL NAME \n" "Language-Team: FRENCH \n" "Language: fr\n" @@ -16,7 +15,7 @@ msgstr "" #: ../Doc/howto/logging.rst:3 msgid "Logging HOWTO" -msgstr "" +msgstr "Tutoriel sur la journalisation" #: ../Doc/howto/logging.rst:0 msgid "Author" @@ -28,7 +27,7 @@ msgstr "" #: ../Doc/howto/logging.rst:12 msgid "Basic Logging Tutorial" -msgstr "" +msgstr "Les bases de l'utilisation du module `logging`" #: ../Doc/howto/logging.rst:14 msgid "" @@ -40,10 +39,19 @@ msgid "" "which the developer ascribes to the event; the importance can also be called " "the *level* or *severity*." msgstr "" +"La journalisation (*logging* en anglais) est une façon de suivre les " +"événements qui ont lieu durant le fonctionnement d'un logiciel. Le " +"développeur du logiciel ajoute des appels à l'outil de journalisation dans " +"son code pour indiquer que certains événements ont eu lieu. Un événement est " +"décrit par un message descriptif, qui peut éventuellement contenir des " +"données variables (c'est-à-dire qui peuvent être différentes pour chaque " +"occurrence de l'événement). Un événement a aussi une importance que la " +"développeur lui attribue ; cette importance peut aussi être appelée *niveau* " +"ou *sévérité*." #: ../Doc/howto/logging.rst:23 msgid "When to use logging" -msgstr "" +msgstr "Quand utiliser `logging`" #: ../Doc/howto/logging.rst:25 msgid "" @@ -52,19 +60,26 @@ msgid "" "func:`critical`. To determine when to use logging, see the table below, " "which states, for each of a set of common tasks, the best tool to use for it." msgstr "" +"Le module *logging* fournit un ensemble de fonctions de commodités pour une " +"utilisation simple du module. Ce sont les fonctions :func:`debug`, :func:" +"`info`, :func:`warning`, :func:`error` et :func:`critical`. Pour déterminer " +"quand employer la journalisation, voyez la table ci-dessous, qui vous " +"indique, pour chaque tâche parmi les plus communes, l'outil approprié." #: ../Doc/howto/logging.rst:31 msgid "Task you want to perform" -msgstr "" +msgstr "Tâche que vous souhaitez mener" #: ../Doc/howto/logging.rst:31 msgid "The best tool for the task" -msgstr "" +msgstr "Le meilleur outil pour cette tâche" #: ../Doc/howto/logging.rst:33 msgid "" "Display console output for ordinary usage of a command line script or program" msgstr "" +"Afficher la sortie console d'un script en ligne de commande ou d'un " +"programme lors de son utilisation ordinaire." #: ../Doc/howto/logging.rst:33 msgid ":func:`print`" @@ -75,48 +90,65 @@ msgid "" "Report events that occur during normal operation of a program (e.g. for " "status monitoring or fault investigation)" msgstr "" +"Rapporter des évènements qui ont lieu au cours du fonctionnement normal d'un " +"programme (par exemple pour suivre un statut ou examiner des " +"dysfonctionnements)" #: ../Doc/howto/logging.rst:37 msgid "" ":func:`logging.info` (or :func:`logging.debug` for very detailed output for " "diagnostic purposes)" msgstr "" +":func:`logging.info` (ou :func:`logging.debug` pour une sortie très " +"détaillée à visée diagnostique)" #: ../Doc/howto/logging.rst:42 msgid "Issue a warning regarding a particular runtime event" msgstr "" +"Émettre un avertissement (*warning* en anglais) en relation avec un " +"évènement particulier au cours du fonctionnement" #: ../Doc/howto/logging.rst:42 msgid "" ":func:`warnings.warn` in library code if the issue is avoidable and the " "client application should be modified to eliminate the warning" msgstr "" +":func:`warnings.warn` dans le code de la bibliothèque si le problème est " +"évitable et l'application cliente doit être modifiée pour éliminer ce " +"*warning*" #: ../Doc/howto/logging.rst:47 msgid "" ":func:`logging.warning` if there is nothing the client application can do " "about the situation, but the event should still be noted" msgstr "" +":func:`logging.warning` si l'application cliente ne peut rien faire pour " +"corriger la situation mais l'évènement devrait quand même être noté" #: ../Doc/howto/logging.rst:52 msgid "Report an error regarding a particular runtime event" msgstr "" +"Rapporter une erreur lors d'un évènement particulier en cours d'exécution" #: ../Doc/howto/logging.rst:52 msgid "Raise an exception" -msgstr "" +msgstr "Lever une exception" #: ../Doc/howto/logging.rst:55 msgid "" "Report suppression of an error without raising an exception (e.g. error " "handler in a long-running server process)" msgstr "" +"Rapporter la suppression d'une erreur sans lever d'exception (par exemple " +"pour la gestion d'erreur d'un processus de long terme sur un serveur)" #: ../Doc/howto/logging.rst:55 msgid "" ":func:`logging.error`, :func:`logging.exception` or :func:`logging.critical` " "as appropriate for the specific error and application domain" msgstr "" +":func:`logging.error`, :func:`logging.exception` ou :func:`logging." +"critical`, au mieux, selon l'erreur spécifique et le domaine d'application" #: ../Doc/howto/logging.rst:62 msgid "" @@ -124,14 +156,17 @@ msgid "" "they are used to track. The standard levels and their applicability are " "described below (in increasing order of severity):" msgstr "" +"Les fonctions de journalisation sont nommées d'après le niveau ou la " +"sévérité des évènements qu'elles suivent. Les niveaux standards et leurs " +"applications sont décrits ci-dessous (par ordre croissant de sévérité) :" #: ../Doc/howto/logging.rst:69 ../Doc/howto/logging.rst:846 msgid "Level" -msgstr "" +msgstr "Niveau" #: ../Doc/howto/logging.rst:69 msgid "When it's used" -msgstr "" +msgstr "Quand il est utilisé" #: ../Doc/howto/logging.rst:71 ../Doc/howto/logging.rst:856 msgid "``DEBUG``" @@ -141,6 +176,8 @@ msgstr "``DEBUG``" msgid "" "Detailed information, typically of interest only when diagnosing problems." msgstr "" +"Information détaillée, intéressante seulement lorsqu'on diagnostique un " +"problème." #: ../Doc/howto/logging.rst:74 ../Doc/howto/logging.rst:854 msgid "``INFO``" @@ -148,7 +185,7 @@ msgstr "``INFO``" #: ../Doc/howto/logging.rst:74 msgid "Confirmation that things are working as expected." -msgstr "" +msgstr "Confirmation que tout fonctionne comme prévu" #: ../Doc/howto/logging.rst:77 ../Doc/howto/logging.rst:852 msgid "``WARNING``" @@ -160,6 +197,9 @@ msgid "" "problem in the near future (e.g. 'disk space low'). The software is still " "working as expected." msgstr "" +"L'indication que quelque chose d'inattendu a eu lieu, ou de la possibilité " +"d'un problème dans un futur proche (par exemple « espace disque faible »). " +"Le logiciel fonctionne encore normalement." #: ../Doc/howto/logging.rst:82 ../Doc/howto/logging.rst:850 msgid "``ERROR``" @@ -170,6 +210,8 @@ msgid "" "Due to a more serious problem, the software has not been able to perform " "some function." msgstr "" +"Du fait d'un problème plus sérieux, le logiciel n'a pas été capable de " +"réaliser une tâche." #: ../Doc/howto/logging.rst:85 ../Doc/howto/logging.rst:848 msgid "``CRITICAL``" @@ -180,6 +222,8 @@ msgid "" "A serious error, indicating that the program itself may be unable to " "continue running." msgstr "" +"Une erreur sérieuse, indiquant que le programme lui-même pourrait être " +"incapable de continuer à fonctionner." #: ../Doc/howto/logging.rst:89 msgid "" @@ -187,6 +231,9 @@ msgid "" "and above will be tracked, unless the logging package is configured to do " "otherwise." msgstr "" +"Le niveau par défaut est ``WARNING``, ce qui signifie que seuls les " +"évènements de ce niveau et au dessus sont suivis, sauf si le paquet " +"*logging* est configuré pour faire autrement." #: ../Doc/howto/logging.rst:93 msgid "" @@ -194,18 +241,22 @@ msgid "" "of handling tracked events is to print them to the console. Another common " "way is to write them to a disk file." msgstr "" +"Les évènements suivis peuvent être gérés de différentes façons. La manière " +"la plus simple est de les afficher dans la console. Une autre méthode " +"commune est de les écrire dans un fichier." #: ../Doc/howto/logging.rst:101 msgid "A simple example" -msgstr "" +msgstr "Un exemple simple" #: ../Doc/howto/logging.rst:103 msgid "A very simple example is::" -msgstr "" +msgstr "Un exemple très simple est : ::" #: ../Doc/howto/logging.rst:109 msgid "If you type these lines into a script and run it, you'll see:" msgstr "" +"Si vous entrez ces lignes dans un script que vous exécutez, vous verrez :" #: ../Doc/howto/logging.rst:115 msgid "" @@ -216,10 +267,17 @@ msgid "" "explained later. The actual output can be formatted quite flexibly if you " "need that; formatting options will also be explained later." msgstr "" +"affiché dans la console. Le message ``INFO`` n'apparaît pas parce que le " +"niveau par défaut est ``WARNING``. Le message affiché inclut l'indication du " +"niveau et la description de l'évènement fournie dans l'appel à *logging*, i." +"e. « Watch out! ». Ne vous préoccupez pas de la partie « *root* » pour le " +"moment : nous détaillerons ce point plus bas. La sortie elle même peut être " +"formatée de multiples manières si besoin. Les options de formatage seront " +"aussi expliquées plus bas." #: ../Doc/howto/logging.rst:124 msgid "Logging to a file" -msgstr "" +msgstr "Enregistrer les évènements dans un fichier" #: ../Doc/howto/logging.rst:126 msgid "" @@ -228,12 +286,18 @@ msgid "" "Python interpreter, and don't just continue from the session described " "above::" msgstr "" +"Il est très commun d'enregistrer les évènements dans un fichier, c'est donc " +"ce que nous allons regarder maintenant. Il faut essayer ce qui suit avec un " +"interpréteur Python nouvellement démarré, ne poursuivez pas la session " +"commencée ci-dessus ::" #: ../Doc/howto/logging.rst:136 msgid "" "And now if we open the file and look at what we have, we should find the log " "messages:" msgstr "" +"Maintenant, si nous ouvrons le fichier et lisons ce qui s'y trouve, on " +"trouvera les messages de log :" #: ../Doc/howto/logging.rst:145 msgid "" @@ -241,17 +305,24 @@ msgid "" "threshold for tracking. In this case, because we set the threshold to " "``DEBUG``, all of the messages were printed." msgstr "" +"Cet exemple montre aussi comment on peut régler le niveau de journalisation " +"qui sert de seuil pour le suivi. Dans ce cas, comme nous avons réglé le " +"seuil à ``DEBUG``, tous les messages ont été écrits." #: ../Doc/howto/logging.rst:149 msgid "" "If you want to set the logging level from a command-line option such as:" msgstr "" +"Si vous souhaitez régler le niveau de *logging* à partir d'une option de la " +"ligne de commande comme :" #: ../Doc/howto/logging.rst:155 msgid "" "and you have the value of the parameter passed for ``--log`` in some " "variable *loglevel*, you can use::" msgstr "" +"et que vous passez ensuite la valeur du paramètre donné à l'option `--log` " +"dans une variable *loglevel*, vous pouvez utiliser : ::" #: ../Doc/howto/logging.rst:160 msgid "" @@ -259,6 +330,9 @@ msgid "" "argument. You may want to error check any user input value, perhaps as in " "the following example::" msgstr "" +"de manière à obtenir la valeur à passer à :func:`basicConfig` à travers " +"l'argument *level*. Vous pouvez vérifier que l'utilisateur n'a fait aucune " +"erreur pour la valeur de ce paramètre, comme dans l'exemple ci-dessous : ::" #: ../Doc/howto/logging.rst:172 msgid "" @@ -267,6 +341,10 @@ msgid "" "configuration facility, only the first call will actually do anything: " "subsequent calls are effectively no-ops." msgstr "" +"L'appel à :func:`basicConfig` doit être fait *avant* un appel à :func:" +"`debug`, :func:`info`, etc. Comme l'objectif est d'avoir un outil de " +"configuration simple et d'usage unique, seul le premier appel aura un effet, " +"les appels suivants ne font rien." #: ../Doc/howto/logging.rst:177 msgid "" @@ -275,26 +353,36 @@ msgid "" "afresh, not remembering the messages from earlier runs, you can specify the " "*filemode* argument, by changing the call in the above example to::" msgstr "" +"Si vous exécutez le script plusieurs fois, les messages des exécutions " +"successives sont ajoutés au fichier *example.log*. Si vous voulez que chaque " +"exécution reprenne un fichier vierge, sans conserver les messages des " +"exécutions précédentes, vous pouvez spécifier l'argument *filemode*, en " +"changeant l'appel à l'exemple précédent par ::" #: ../Doc/howto/logging.rst:184 msgid "" "The output will be the same as before, but the log file is no longer " "appended to, so the messages from earlier runs are lost." msgstr "" +"La sortie est identique à la précédente, mais le texte n'est plus ajouté au " +"fichier de log, donc les messages des exécutions précédentes sont perdus." #: ../Doc/howto/logging.rst:189 msgid "Logging from multiple modules" -msgstr "" +msgstr "Employer *logging* à partir de différents modules" #: ../Doc/howto/logging.rst:191 msgid "" "If your program consists of multiple modules, here's an example of how you " "could organize logging in it::" msgstr "" +"Si votre programme est composé de plusieurs modules, voici une façon " +"d'organiser\n" +"l'outil de journalisation : ::" #: ../Doc/howto/logging.rst:215 msgid "If you run *myapp.py*, you should see this in *myapp.log*:" -msgstr "" +msgstr "Si vous exécutez *myapp.py*, vous verrez ceci dans *myapp.log* :" #: ../Doc/howto/logging.rst:223 msgid "" @@ -306,20 +394,30 @@ msgid "" "to refer to the documentation beyond the tutorial level -- see :ref:`logging-" "advanced-tutorial`." msgstr "" +"ce qui est normalement ce à quoi vous vous attendiez. Vous pouvez " +"généraliser cela à plusieurs modules, en employant le motif de *mylib.py*. " +"Remarquez qu'avec cette méthode simple, vous ne pourrez pas savoir, en " +"lisant le fichier de log, *d'où* viennent les messages dans votre " +"application, sauf dans la description de l'évènement. Si vous voulez suivre " +"la localisation des messages, référerez vous à la documentation avancée :ref:" +"`logging-advanced-tutorial`." #: ../Doc/howto/logging.rst:233 msgid "Logging variable data" -msgstr "" +msgstr "Journalisation de données variables" #: ../Doc/howto/logging.rst:235 msgid "" "To log variable data, use a format string for the event description message " "and append the variable data as arguments. For example::" msgstr "" +"Pour enregistrer des données variables, utilisez une chaîne formatée dans le " +"message de description de l'évènement et ajoutez les données variables comme " +"argument. Par exemple : ::" #: ../Doc/howto/logging.rst:241 msgid "will display:" -msgstr "" +msgstr "affichera :" #: ../Doc/howto/logging.rst:247 msgid "" @@ -330,20 +428,29 @@ msgid "" "options *are* supported, but exploring them is outside the scope of this " "tutorial: see :ref:`formatting-styles` for more information." msgstr "" +"Comme vous pouvez le voir, l'inclusion des données variables dans le message " +"de description de l'évènement emploie le vieux style de formatage avec %. " +"C'est pour assurer la rétrocompatibilité : le module `logging` est antérieur " +"aux nouvelles options de formatage comme :meth:`str.format` ou :class:" +"`string.Template`. Ces nouvelles options de formatage *sont* gérées, mais " +"leur exploration sors du cadre de ce tutoriel, voyez :ref:`formatting-" +"styles` pour plus d'information." #: ../Doc/howto/logging.rst:256 msgid "Changing the format of displayed messages" -msgstr "" +msgstr "Modifier le format du message affiché" #: ../Doc/howto/logging.rst:258 msgid "" "To change the format which is used to display messages, you need to specify " "the format you want to use::" msgstr "" +"Pour changer le format utilisé pour afficher le message, vous devez préciser " +"le format que vous souhaitez employer : ::" #: ../Doc/howto/logging.rst:267 msgid "which would print:" -msgstr "" +msgstr "Ce qui affiche :" #: ../Doc/howto/logging.rst:275 msgid "" @@ -354,20 +461,29 @@ msgid "" "including variable data) and perhaps to display when the event occurred. " "This is described in the next section." msgstr "" +"Notez que le `root` qui apparaissait dans les exemples précédents a disparu. " +"Pour voir l'ensemble des éléments qui peuvent apparaître dans la chaîne de " +"format, référez-vous à la documentation pour :ref:`logrecord-attributes`. " +"Pour une utilisation simple, vous avez seulement besoin du *levelname* (la " +"sévérité), du *message* (la description de l'évènement, avec les données " +"variables) et peut-être du moment auquel l'évènement a eu lieu. Nous " +"décrivons ces points dans la prochaine section." #: ../Doc/howto/logging.rst:284 msgid "Displaying the date/time in messages" -msgstr "" +msgstr "Afficher l'horodatage dans les messages" #: ../Doc/howto/logging.rst:286 msgid "" "To display the date and time of an event, you would place '%(asctime)s' in " "your format string::" msgstr "" +"Pour afficher la date ou le temps d'un évènement, ajoutez `%(asctime)` dans " +"votre chaîne de formatage : ::" #: ../Doc/howto/logging.rst:293 msgid "which should print something like this:" -msgstr "" +msgstr "Ce qui affichera quelque chose comme :" #: ../Doc/howto/logging.rst:299 msgid "" @@ -375,20 +491,24 @@ msgid "" "rfc:`3339`. If you need more control over the formatting of the date/time, " "provide a *datefmt* argument to ``basicConfig``, as in this example::" msgstr "" +"Le format par défaut de l'horodatage (comme ci-dessus) est donné par la " +"norme ISO8601 ou :rfc:`3339`. Pour plus de contrôle sur le formatage de " +"l'horodatage, vous pouvez fournir à ``basicConfig`` un argument *datefmt*, " +"comme dans l'exemple suivant : ::" #: ../Doc/howto/logging.rst:307 msgid "which would display something like this:" -msgstr "" +msgstr "Ce qui affichera quelque chose comme :" #: ../Doc/howto/logging.rst:313 msgid "" "The format of the *datefmt* argument is the same as supported by :func:`time." "strftime`." -msgstr "" +msgstr "Le format de *datefmt* est le même que celui de :func:`time.strftime`." #: ../Doc/howto/logging.rst:318 msgid "Next Steps" -msgstr "" +msgstr "Étapes suivantes" #: ../Doc/howto/logging.rst:320 msgid "" @@ -398,15 +518,25 @@ msgid "" "time in reading the following sections. If you're ready for that, grab some " "of your favourite beverage and carry on." msgstr "" +"Nous concluons ainsi le tutoriel basique. Il devrait suffire à vous mettre " +"le pied à l'étrier pour utiliser `logging`. Le module `logging` a beaucoup " +"d'autre cordes à son arc, mais pour en profiter au maximum, vous devez " +"prendre le temps de lire les sections suivantes. Si vous êtes prêt, servez-" +"vous votre boisson préférée et poursuivons." #: ../Doc/howto/logging.rst:326 msgid "" "If your logging needs are simple, then use the above examples to incorporate " "logging into your own scripts, and if you run into problems or don't " "understand something, please post a question on the comp.lang.python Usenet " -"group (available at https://groups.google.com/forum/#!forum/comp.lang." -"python) and you should receive help before too long." +"group (available at https://groups.google.com/group/comp.lang.python) and " +"you should receive help before too long." msgstr "" +"Si vos besoins avec `logging` sont simples, vous pouvez incorporer les " +"exemples ci-dessus dans vos scripts. Si vous rencontrez des difficultés ou " +"s'il y a quelque chose que vous ne comprenez pas, vous pouvez poser une " +"question sur le groupe Usenet `comp.lang.python` (accessible à `https://" +"groups.google.com/group/comp.lang.python`_), on vous répondra rapidement." #: ../Doc/howto/logging.rst:332 msgid "" @@ -414,42 +544,58 @@ msgid "" "slightly more advanced/in-depth tutorial than the basic one above. After " "that, you can take a look at the :ref:`logging-cookbook`." msgstr "" +"Vous êtes encore là ? Vous pouvez lire les prochaines section, qui donnent " +"un peu plus de détails que l'introduction ci-dessus. Après ça, vous pouvez " +"jeter un œil à :ref:`logging-cookbook`." #: ../Doc/howto/logging.rst:340 msgid "Advanced Logging Tutorial" -msgstr "" +msgstr "Usage avancé de Logging" #: ../Doc/howto/logging.rst:342 msgid "" "The logging library takes a modular approach and offers several categories " "of components: loggers, handlers, filters, and formatters." msgstr "" +"La bibliothèque de journalisation adopte une approche modulaire et offre " +"différentes catégories de composants : *loggers*, *handlers*, *filters* et " +"*formatters*." #: ../Doc/howto/logging.rst:345 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." #: ../Doc/howto/logging.rst:346 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." #: ../Doc/howto/logging.rst:348 msgid "" "Filters provide a finer grained facility for determining which log records " "to output." msgstr "" +"Les filtres (*filters*) fournissent un moyen de choisir finement quelles " +"entrées de journal doivent être sorties." #: ../Doc/howto/logging.rst:350 msgid "Formatters specify the layout of log records in the final output." msgstr "" +"Les formateurs (*formatters*) spécifient la structure de l'entrée de journal " +"dans la sortie finale." #: ../Doc/howto/logging.rst:352 msgid "" "Log event information is passed between loggers, handlers, filters and " "formatters in a :class:`LogRecord` instance." msgstr "" +"L'information relative à un événement est passée entre *loggers*, *handlers* " +"et *formatters* dans une instance de la classe :class:`LogRecord`." #: ../Doc/howto/logging.rst:355 msgid "" @@ -461,18 +607,32 @@ msgid "" "want, and indicate the area of an application in which a logged message " "originates." msgstr "" +"La journalisation est réalisée en appelant les méthodes d'instance de la " +"classe :class:`Logger` (que l'on appelle ci-dessous :dfn:`loggers`). Chaque " +"instance a un nom, et sont organisées conceptuellement comme des hiérarchies " +"dans l'espace des noms, en utilisant un point comme séparateur. Par exemple, " +"un `logger` appelé `scan` est le parent des `loggers` `scan.text`, `scan." +"html` et `scan.pdf`. Les noms des `loggers` peuvent être ce que vous voulez " +"et indiquer le sous-domaine d'une application depuis lequel le message " +"enregistré a été émis." #: ../Doc/howto/logging.rst:362 msgid "" "A good convention to use when naming loggers is to use a module-level " "logger, in each module which uses logging, named as follows::" msgstr "" +"Une bonne convention lorsqu'on nomme les *loggers* est d'utiliser un " +"*logger* au niveau du module, dans chaque module qui emploie `logging`, " +"nommé de la façon suivante : ::" #: ../Doc/howto/logging.rst:367 msgid "" "This means that logger names track the package/module hierarchy, and it's " "intuitively obvious where events are logged just from the logger name." msgstr "" +"Cela signifie que le nom d'un `logger` se rapporte à la hiérarchie du paquet " +"et des modules, et il est évident où un événement à été enregistré " +"simplement en voyant le nom du `logger`." #: ../Doc/howto/logging.rst:370 msgid "" @@ -482,6 +642,12 @@ msgid "" "the root logger. The functions and the methods have the same signatures. The " "root logger's name is printed as 'root' in the logged output." msgstr "" +"La racine de la hiérarchie des `loggers` est appelée le *root logger*. " +"C'est le `logger` utilisé par les fonctions :func:`debug`, :func:`info`, :" +"func:`warning`, :func:`error` et :func:`critical`, qui appelle en fait les " +"méthodes du mêmes nom de l'objet *root logger*. Les fonctions et les " +"méthodes ont la même signature. Le nom du *root logger* est affiché comme « " +"`root` » dans la sortie." #: ../Doc/howto/logging.rst:376 msgid "" @@ -493,6 +659,15 @@ msgid "" "destination class if you have special requirements not met by any of the " "built-in handler classes." msgstr "" +"Il est bien sûr possible d'enregistrer des messages pour des destinations " +"différentes. Ce paquet permet d'écrire des entrées de journal dans des " +"fichiers, des ressources HTTP GET/POST, par courriel via SMTP, des *sockets* " +"génériques, des files d'attente, ou des mécanismes d'enregistrement " +"spécifiques au système d'exploitation, comme *syslog* ou le journal " +"d'événements de Windows NT. Les destinations sont servies par des classes :" +"dfn:`handler`. Vous pouvez créer votre propre classe de destination si vous " +"avez des besoins spéciaux qui ne sont couverts par aucune classe *handler* " +"prédéfinie." #: ../Doc/howto/logging.rst:383 msgid "" @@ -505,10 +680,21 @@ msgid "" "displayed message before delegating to the root logger to do the actual " "message output." msgstr "" +"Par défaut, aucune destination n'est prédéfinie pour les messages de " +"journalisation. Vous pouvez définir une destination (comme la console ou un " +"fichier) en utilisant :func:`basicConfig` comme dans les exemples donnés " +"dans le tutoriels. Si vous appelez les fonctions :func:`debug`, :func:" +"`info`, :func:`warning`, :func:`error` et :func:`critical`, celles-ci " +"vérifient si une destination a été définie ; si ce n'est pas le cas, la " +"destination est assignée à la console (``sys.stderr``) avec un format par " +"défaut pour le message affiché, avant d'être déléguée au *logger* racine, " +"qui sort le message." #: ../Doc/howto/logging.rst:391 msgid "The default format set by :func:`basicConfig` for messages is:" msgstr "" +"Le format par défaut des messages est défini par :func:`basicConfig` comme " +"suit : ::" #: ../Doc/howto/logging.rst:397 msgid "" @@ -516,20 +702,26 @@ msgid "" "the *format* keyword argument. For all options regarding how a format string " "is constructed, see :ref:`formatter-objects`." msgstr "" +"Vous pouvez modifier ce comportement en passant une chaîne de formatage à :" +"func:`basicConfig` par l'argument nommé *format*. Voyez :ref:`formatter-" +"objects` pour toutes les options de construction de cette chaîne de " +"formatage." #: ../Doc/howto/logging.rst:402 msgid "Logging Flow" -msgstr "" +msgstr "Flux du processus de journalisation" #: ../Doc/howto/logging.rst:404 msgid "" "The flow of log event information in loggers and handlers is illustrated in " "the following diagram." msgstr "" +"Le flux des informations associées à un évènement dans les `loggers` et les " +"`handlers` est illustré dans le diagramme suivant." #: ../Doc/howto/logging.rst:410 msgid "Loggers" -msgstr "" +msgstr "Loggers" #: ../Doc/howto/logging.rst:412 msgid "" @@ -540,16 +732,25 @@ msgid "" "Third, logger objects pass along relevant log messages to all interested log " "handlers." msgstr "" +"Les objets de classe :class:`Logger` ont un rôle triple. Premièrement, ils " +"exposent plusieurs méthodes au code de l'application, de manière à ce " +"qu'elle puisse enregistrer des messages en cours d'exécution. Deuxièmement, " +"les objets `logger` déterminent sur quel message agir selon leur sévérité (à " +"partir des filtres par défaut) ou selon les objets `filter` associés. " +"Troisièmement, les objets `logger` transmettent les messages pertinents à " +"tous les `handlers` concernés." #: ../Doc/howto/logging.rst:418 msgid "" "The most widely used methods on logger objects fall into two categories: " "configuration and message sending." msgstr "" +"Les méthodes des objets `logger` les plus utilisées appartiennent à deux " +"catégories : la configuration et l'envoi de messages." #: ../Doc/howto/logging.rst:421 msgid "These are the most common configuration methods:" -msgstr "" +msgstr "Voici les méthodes de configuration les plus communes :" #: ../Doc/howto/logging.rst:423 msgid "" @@ -559,6 +760,11 @@ msgid "" "INFO, the logger will handle only INFO, WARNING, ERROR, and CRITICAL " "messages and will ignore DEBUG messages." msgstr "" +":meth:`Logger.setLevel` spécifie le plus bas niveau de sévérité qu'un " +"`logger` traitera. Ainsi, `debug` est le niveau de sévérité défini par " +"défaut le plus bas, et `critical` le plus haut. Par exemple, si le niveau de " +"sévérité est INFO, le `logger` ne traite que les message de niveau INFO, " +"WARNING, ERROR et CRITICAL, et ignore les messages de niveau DEBUG." #: ../Doc/howto/logging.rst:429 msgid "" @@ -566,6 +772,9 @@ msgid "" "handler objects from the logger object. Handlers are covered in more detail " "in :ref:`handler-basic`." msgstr "" +":meth:`Logger.addHandler` et :meth:`Logger.removeHandler` ajoutent ou " +"enlèvent des objets `handlers` au `logger`. Les objets `handlers` sont " +"expliqués plus en détail dans :ref:`handler-basic`." #: ../Doc/howto/logging.rst:433 msgid "" @@ -573,17 +782,25 @@ msgid "" "filter objects from the logger object. Filters are covered in more detail " "in :ref:`filter`." msgstr "" +":meth:`Logger.addFilter` et :meth:`Logger.removeFilter` ajoutent ou enlèvent " +"des objets `filter` au `logger`. Les objets `filters` sont expliqués plus " +"en détail dans :ref:`filter`." #: ../Doc/howto/logging.rst:437 msgid "" "You don't need to always call these methods on every logger you create. See " "the last two paragraphs in this section." msgstr "" +"Comme nous l'expliquons aux deux derniers paragraphes de cette section, vous " +"n'avez pas besoin de faire appel à ces méthodes à chaque fois que vous créez " +"un `logger`." #: ../Doc/howto/logging.rst:440 msgid "" "With the logger object configured, the following methods create log messages:" msgstr "" +"Une fois que l'objet `logger` est correctement configuré, les méthodes " +"suivantes permettent de créer un message :" #: ../Doc/howto/logging.rst:442 msgid "" @@ -597,6 +814,16 @@ msgid "" "about a keyword of ``exc_info`` and use it to determine whether to log " "exception information." msgstr "" +"Les méthodes :meth:`Logger.debug`, :meth:`Logger.info`, :meth:`Logger." +"warning`, :meth:`Logger.error`, et :meth:`Logger.critical`créent des entrées " +"de journal avec un message et un niveau correspondant à leur nom. Le message " +"est en fait une chaîne de caractère qui peut contenir la syntaxe standard " +"de substitution de chaînes de caractères : ``%s``, ``%d``, ``%f``, etc. " +"L'argument suivant est une liste des objets correspondant aux champs à " +"substituer dans le message. En ce qui concerne ``**kwargs``, les méthodes de " +"`logging` ne tiennent compte que du mot clef ``exc_info`` et l'utilisent " +"pour déterminer s'il faut enregistrer les informations associées à une " +"exception." #: ../Doc/howto/logging.rst:452 msgid "" @@ -604,6 +831,10 @@ msgid "" "error`. The difference is that :meth:`Logger.exception` dumps a stack trace " "along with it. Call this method only from an exception handler." msgstr "" +":meth:`Logger.exception` crée un message similaire à :meth:`Logger.error`. " +"La différence est que :meth:`Logger.exception` ajoute la trace de la pile " +"d'exécution au message. On ne peut appeler cette méthode qu'à l'intérieur " +"d'un bloc de gestion d'exception." #: ../Doc/howto/logging.rst:456 msgid "" @@ -612,6 +843,11 @@ msgid "" "convenience methods listed above, but this is how to log at custom log " "levels." msgstr "" +":meth:`Logger.log` prend le niveau de sévérité comme argument explicite. " +"C'est un peu plus verbeux pour enregistrer des messages que d'utiliser les " +"méthodes plus pratiques décrites si dessus, mais c'est ce qui permet " +"d'enregistrer des messages pour des niveaux de sévérité définis par " +"l'utilisateur." #: ../Doc/howto/logging.rst:460 msgid "" @@ -624,6 +860,15 @@ msgid "" "loggers with names of ``foo.bar``, ``foo.bar.baz``, and ``foo.bam`` are all " "descendants of ``foo``." msgstr "" +":func:`getLogger` renvoie une référence à un objet `logger` du nom spécifié " +"si celui-ci est donné en argument. Dans le cas contraire, se sera le `logger " +"root`. Ces noms sont des structures hiérarchiques séparées par des points. " +"Des appels répétés à :func:`getLogger` avec le même nom renvoient une " +"référence au même objet `logger`. Les `loggers` qui sont plus bas dans cette " +"liste hiérarchique sont des enfants des `loggers` plus haut dans la liste. " +"Par exemple, si un `logger` a le nom ``foo``, les `loggers` avec les noms " +"``foo.bar``, ``foo.bar.baz``, et ``foo.bam`` sont tous des descendants de " +"``foo``." #: ../Doc/howto/logging.rst:468 msgid "" @@ -636,6 +881,14 @@ msgid "" "the logger is used to determine whether the event is passed to the logger's " "handlers." msgstr "" +"On associe aux `loggers` un concept de *niveau effectif*. Si aucun niveau " +"n'est explicitement défini pour un `logger`, c'est le niveau du parent qui " +"est utilisé comme niveau effectif. Si le parent n'a pas de niveau défini, " +"c'est celui de *son* parent qui est considéré, et ainsi de suite ; on " +"examine tous les ancêtres jusqu'à ce qu'un niveau explicite soit trouvé. Le " +"`logger root` a toujours un niveau explicite (``WARNING`` par défaut). Quand " +"le `logger` traite un événement, c'est ce niveau effectif qui est utilisé " +"pour déterminer si cet événement est transmis à ses `handlers`." #: ../Doc/howto/logging.rst:476 msgid "" @@ -646,10 +899,17 @@ msgid "" "needed. (You can, however, turn off propagation by setting the *propagate* " "attribute of a logger to ``False``.)" msgstr "" +"Les `loggers` fils font remonter leurs messages aux `handlers` associés à " +"leurs `loggers` ancêtres. De ce fait, il n'est pas nécessaire de définir et " +"configurer des `handlers` pour tous les `loggers` employés par une " +"application. Il suffit de configurer les `handlers` pour un `logger` de haut " +"niveau et de créer des `loggers` fils quand c'est nécessaire (on peut " +"cependant empêcher la propagation aux ancêtres des messages en donnant la " +"valeur ``False`` à l'attribut *propagate* d'un `logger`)." #: ../Doc/howto/logging.rst:487 msgid "Handlers" -msgstr "" +msgstr "Handlers" #: ../Doc/howto/logging.rst:489 msgid "" @@ -663,6 +923,16 @@ msgid "" "individual handlers where each handler is responsible for sending messages " "of a specific severity to a specific location." msgstr "" +"Les objets de type :class:`~logging.Handler` sont responsables de la " +"distribution des messages (selon leur niveau de sévérité) vers les " +"destinations spécifiées pour ce `handler`. Les objets :class:`Logger` " +"peuvent ajouter des objets `handler` à eux-mêmes en appelant :meth:`~Logger." +"addHandler`. Pour donner un exemple, une application peut envoyer tous les " +"messages dans un fichier journal, tous les messages de niveau `error` ou " +"supérieur vers la sortie standard, et tous les messages de niveau `critical` " +"vers une adresse de courriel. Dans ce scenario, nous avons besoin de trois " +"`handlers`, responsable chacun d'envoyer des messages d'une sévérité donnée " +"vers une destination donnée." #: ../Doc/howto/logging.rst:499 msgid "" @@ -670,6 +940,9 @@ msgid "" "handlers`); the tutorials use mainly :class:`StreamHandler` and :class:" "`FileHandler` in its examples." msgstr "" +"La bibliothèque standard inclut déjà un bon nombre de types d'`handlers` " +"(voir :ref:`useful-handlers`) ; le tutoriel utilise surtout :class:" +"`StreamHandler` et :class:`FileHandler` dans ses exemples." #: ../Doc/howto/logging.rst:503 msgid "" @@ -678,6 +951,10 @@ msgid "" "application developers who are using the built-in handler objects (that is, " "not creating custom handlers) are the following configuration methods:" msgstr "" +"Peu de méthodes des objets `handlers` sont intéressantes pour les " +"développeurs. Les seules méthodes intéressantes lorsqu'on utilise les objets " +"`handlers` natifs (c'est à dire si l'on ne crée pas d'`handler` " +"personnalisé) sont les méthodes de configuration suivantes : " #: ../Doc/howto/logging.rst:508 msgid "" @@ -688,18 +965,28 @@ msgid "" "level set in each handler determines which messages that handler will send " "on." msgstr "" +"La méthode :meth:`~Handler.setLevel`, comme celle des objets `logger` permet " +"de spécifier le plus bas niveau de sévérité qui sera distribué à la " +"destination appropriée. Pourquoi y a-t-il deux méthodes :func:`setLevel` ? " +"Le niveau défini dans le `logger` détermine quelle sévérité doit avoir un " +"message pour être transmis à ses `handlers`. Le niveau mis pour chaque " +"`handler` détermine quels messages seront envoyés aux destinations." #: ../Doc/howto/logging.rst:514 msgid "" ":meth:`~Handler.setFormatter` selects a Formatter object for this handler to " "use." msgstr "" +":meth:`~Handler.setFormatter` sélectionne l'objet `Formatter` utilisé par " +"cet `handler`." #: ../Doc/howto/logging.rst:517 msgid "" ":meth:`~Handler.addFilter` and :meth:`~Handler.removeFilter` respectively " "configure and deconfigure filter objects on handlers." msgstr "" +":meth:`~Handler.addFilter` et :meth:`~Handler.removeFilter` configurent et " +"respectivement dé-configurent des objets `filter` sur les `handlers`." #: ../Doc/howto/logging.rst:520 msgid "" @@ -708,10 +995,15 @@ msgid "" "the interface that all handlers should have and establishes some default " "behavior that child classes can use (or override)." msgstr "" +"Le code d'une application ne devrait ni instancier, ni utiliser d'instances " +"de la classe :class:`Handler`. La classe :class:`Handler` est plutôt d'une " +"classe de base qui défini l'interface que tous les `handlers` doivent avoir, " +"et établi les comportements par défaut que les classes filles peuvent " +"employer (ou redéfinir)." #: ../Doc/howto/logging.rst:527 msgid "Formatters" -msgstr "" +msgstr "Formatters" #: ../Doc/howto/logging.rst:529 msgid "" @@ -722,18 +1014,30 @@ msgid "" "takes three optional arguments -- a message format string, a date format " "string and a style indicator." msgstr "" +"Les objets `formatter` configurent l'ordre final, la structure et le contenu " +"du message. Contrairement à la classe de base :class:`logging.Handler`, le " +"code d'une application peut instancier un objet de classe `formatter`, même " +"si vous pouvez toujours sous-classer `formatter` si vous avez besoin d'un " +"comportement spécial dans votre application. Le constructeur a trois " +"arguments optionnels : une chaîne de formatage du message, un chaîne de " +"formatage de la date et un indicateur de style." #: ../Doc/howto/logging.rst:538 msgid "" "If there is no message format string, the default is to use the raw " "message. If there is no date format string, the default date format is:" msgstr "" +"S'il n'y a pas de chaîne de formatage, la chaîne brute est utilisée par " +"défaut. S'il n'y a pas de chaîne de formatage de date, le format de date par " +"défaut est :" #: ../Doc/howto/logging.rst:545 msgid "" "with the milliseconds tacked on at the end. The ``style`` is one of `%`, '{' " "or '$'. If one of these is not specified, then '%' will be used." msgstr "" +"avec les millisecondes en suffixe. Le ``style`` est `%`, `{` ou `$`. Si " +"aucun n'est spécifié, `%` sera utilisé." #: ../Doc/howto/logging.rst:548 msgid "" @@ -744,10 +1048,17 @@ msgid "" "arguments), while if the style is '$' then the message format string should " "conform to what is expected by :meth:`string.Template.substitute`." msgstr "" +"Si l'argument ``style`` est `%`, la chaîne de formatage utilise ``%()s`` comme style de substitution de chaîne de caractères ; les " +"clefs possibles sont documentées dans :ref:`logrecord-attributes`. Si le " +"style est `{`, le message de la chaîne de formatage est compatible avec :" +"meth:`str.format` (en employant des arguments à mots clefs). Enfin si le " +"style est `$` alors la chaîne de formatage du message doit être conforme à " +"ce qui est attendu de :meth:`string.Template.substitute`." #: ../Doc/howto/logging.rst:555 msgid "Added the ``style`` parameter." -msgstr "" +msgstr "Ajout du paramètre ``style``." #: ../Doc/howto/logging.rst:558 msgid "" @@ -755,6 +1066,9 @@ msgid "" "format, the severity of the message, and the contents of the message, in " "that order::" msgstr "" +"Le chaîne de formatage de message suivante enregistrera le temps dans un " +"format lisible par les humains, la sévérité du message et son contenu, dans " +"cet ordre ::" #: ../Doc/howto/logging.rst:564 msgid "" @@ -766,32 +1080,47 @@ msgid "" "want all logging times to be shown in GMT, set the ``converter`` attribute " "in the Formatter class (to ``time.gmtime`` for GMT display)." msgstr "" +"Les `formatters` emploient une fonction configurable par l'utilisateur pour " +"convertir le temps de création d'une entrée de journal en un tuple. Par " +"défaut, :func:`time.localtime` est employé ; pour changer cela pour une " +"instance particulière de `formatter`, assignez une fonction avec la même " +"signature que :func:`time.localtime` ou :func:`time.gmtime` à l'attribut " +"``converter`` de cette instance. Pour changer cela pour tous les " +"`formatters`, par exemple si vous voulez que tous votre horodatage soit " +"affiché en GMT, changez l'attribut ``converter`` de la classe ``Formatter`` " +"en ``time.gmtime``." #: ../Doc/howto/logging.rst:574 msgid "Configuring Logging" -msgstr "" +msgstr "Configuration de `Logging`" #: ../Doc/howto/logging.rst:578 msgid "Programmers can configure logging in three ways:" -msgstr "" +msgstr "On peut configurer `logging` de trois façons : " #: ../Doc/howto/logging.rst:580 msgid "" "Creating loggers, handlers, and formatters explicitly using Python code that " "calls the configuration methods listed above." msgstr "" +"Créer des `loggers`, `handlers` et `formatters` explicitement en utilisant " +"du code Python qui appelle les méthodes de configuration listées ci-dessus." #: ../Doc/howto/logging.rst:582 msgid "" "Creating a logging config file and reading it using the :func:`fileConfig` " "function." msgstr "" +"Créer un ficher de configuration de `logging` et le lire en employant la " +"fonction :func:`fileConfig`." #: ../Doc/howto/logging.rst:584 msgid "" "Creating a dictionary of configuration information and passing it to the :" "func:`dictConfig` function." msgstr "" +"Créer un dictionnaire d'informations de configuration et le passer à la " +"fonction :func:`dictConfig`." #: ../Doc/howto/logging.rst:587 msgid "" @@ -799,11 +1128,17 @@ msgid "" "config-api`. The following example configures a very simple logger, a " "console handler, and a simple formatter using Python code::" msgstr "" +"Pour la documentation de référence de ces deux dernières options, voyez :ref:" +"`logging-config-api`. L'exemple suivant configure un `logger` très simple, " +"un `handler` employant la console, et un `formatter` simple en utilisant du " +"code Python ::" #: ../Doc/howto/logging.rst:617 msgid "" "Running this module from the command line produces the following output:" msgstr "" +"L'exécution de ce module via la ligne de commande produit la sortie " +"suivante :" #: ../Doc/howto/logging.rst:628 msgid "" @@ -811,15 +1146,20 @@ msgid "" "identical to those in the example listed above, with the only difference " "being the names of the objects::" msgstr "" +"Le module Python suivant crée un *logger*, un *handler* et un *formatter* " +"identiques à ceux de l'exemple détaillé au dessus, au nom des objets " +"près : ::" #: ../Doc/howto/logging.rst:647 msgid "Here is the logging.conf file:" -msgstr "" +msgstr "Voici le fichier *logging.conf* :" #: ../Doc/howto/logging.rst:680 msgid "" "The output is nearly identical to that of the non-config-file-based example:" msgstr "" +"La sortie est presque identique à celle de l'exemple qui n'est pas basé sur " +"un fichier de configuration :" #: ../Doc/howto/logging.rst:691 msgid "" @@ -827,6 +1167,10 @@ msgid "" "Python code approach, mainly separation of configuration and code and the " "ability of noncoders to easily modify the logging properties." msgstr "" +"Vous pouvez constatez les avantages de l'approche par fichier de " +"configuration par rapport à celle du code Python, principalement la " +"séparation de la configuration et du code, et la possibilité pour une " +"personne qui ne code pas de modifier facilement les propriétés de `logging`." #: ../Doc/howto/logging.rst:695 msgid "" @@ -838,6 +1182,14 @@ msgid "" "Please refer to the reference documentation for more information, and " "specify ``False`` for this parameter if you wish." msgstr "" +"La fonction :func:`fileConfig` accepte un paramètre par défaut " +"``disable_existing_loggers``, qui vaut ``True`` par défaut pour des raisons " +"de compatibilité ascendante. Ce n'est pas forcément ce que vous souhaitez : " +"en effet, tout les *loggers* créés avant l'appel à :func:`fileConfig` seront " +"désactivés sauf si eux-mêmes (ou l'un de leurs ancêtres) sont explicitement " +"nommés dans le fichier de configuration. Veuillez vous rapporter à la " +"documentation pour plus de détails, et donner la valeur ``False`` à ce " +"paramètre si vous le souhaitez." #: ../Doc/howto/logging.rst:703 msgid "" @@ -847,6 +1199,12 @@ msgid "" "to the logger-disabling behaviour described above, which may not be what you " "want - in which case, provide the key explicitly with a value of ``False``." msgstr "" +"Le dictionnaire passé à :func:`dictConfig` peut aussi spécifier une valeur " +"Booléenne pour la clef ``disable_existing_loggers``. Si cette valeur n'est " +"pas donnée, elle est interprétée comme vraie par défaut. Cela conduit au " +"comportement de désactivation des *loggers* décrit ci-dessus, qui n'est pas " +"forcément celui que vous souhaitez ; dans ce cas, donnez explicitement la " +"valeur ``False`` à cette clef." #: ../Doc/howto/logging.rst:713 msgid "" @@ -858,6 +1216,13 @@ msgid "" "module ``mymodule``, where ``mypackage`` is available on the Python import " "path)." msgstr "" +"Notez que les noms de classe référencés dans le fichier de configuration " +"doivent être relatifs aux module `logging`, ou des valeurs absolues qui " +"peuvent être résolues à travers les mécanismes d'importation habituels. " +"Ainsi, on peut soit utiliser :class:`~logging.handlers.WatchedFileHandler` " +"(relativement au module `logging`) ou ``mypackage.mymodule.MyHandler`` (pour " +"une classe définie dans le paquet ``mypackage`` et le module ``mymodule``, " +"si ``mypackage`` est disponible dans les chemins d'importation de Python)." #: ../Doc/howto/logging.rst:721 msgid ""