From 1e0489fcee538534f08b081b143285c77d3a454f Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil Date: Sat, 4 Feb 2023 07:25:07 +0000 Subject: [PATCH] Howto/logging-cookbook (#24) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit utilisation de l'apostrophe typographique. compléments de traduction Co-authored-by: Christophe Nanteuil Reviewed-on: https://git.afpy.org/AFPy/python-docs-fr/pulls/24 Reviewed-by: Julien Palard Co-authored-by: Christophe Nanteuil Co-committed-by: Christophe Nanteuil --- howto/logging-cookbook.po | 632 +++++++++++++++++++++++++++----------- 1 file changed, 454 insertions(+), 178 deletions(-) diff --git a/howto/logging-cookbook.po b/howto/logging-cookbook.po index 59a6524c..83c633ef 100644 --- a/howto/logging-cookbook.po +++ b/howto/logging-cookbook.po @@ -6,14 +6,14 @@ msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-01-23 09:57+0100\n" -"PO-Revision-Date: 2022-11-14 15:35+0100\n" +"PO-Revision-Date: 2023-02-01 22:16+0100\n" "Last-Translator: \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 2.4.2\n" +"X-Generator: Poedit 3.2.1\n" #: howto/logging-cookbook.rst:5 msgid "Logging Cookbook" @@ -28,14 +28,15 @@ msgid "Vinay Sajip " msgstr "Vinay Sajip " #: howto/logging-cookbook.rst:9 -#, fuzzy msgid "" "This page contains a number of recipes related to logging, which have been " "found useful in the past. For links to tutorial and reference information, " "please see :ref:`cookbook-ref-links`." msgstr "" "Cette page contient des recettes relatives à la journalisation qui se sont " -"avérées utiles par le passé." +"avérées utiles par le passé. Pour des liens vers le tutoriel et des " +"informations de référence, consultez :ref:`ces autres ressources `." #: howto/logging-cookbook.rst:16 msgid "Using logging in multiple modules" @@ -53,9 +54,9 @@ msgid "" "module::" msgstr "" "Deux appels à ``logging.getLogger('unLogger')`` renvoient toujours une " -"référence vers le même objet de journalisation. C'est valable à l'intérieur " -"d'un module, mais aussi dans des modules différents pour autant que ce soit " -"le même processus de l'interpréteur Python. En plus, le code d'une " +"référence vers le même objet de journalisation. C’est valable à l’intérieur " +"d’un module, mais aussi dans des modules différents pour autant que ce soit " +"le même processus de l’interpréteur Python. En plus, le code d’une " "application peut définir et configurer une journalisation parente dans un " "module et créer (mais pas configurer) une journalisation fille dans un " "module séparé. Les appels à la journalisation fille passeront alors à la " @@ -71,29 +72,29 @@ msgstr "La sortie ressemble à ceci ::" #: howto/logging-cookbook.rst:102 msgid "Logging from multiple threads" -msgstr "Journalisation avec des fils d'exécution multiples" +msgstr "Journalisation avec des fils d’exécution multiples" #: howto/logging-cookbook.rst:104 msgid "" "Logging from multiple threads requires no special effort. The following " "example shows logging from the main (initial) thread and another thread::" msgstr "" -"La journalisation avec des fils d'exécution multiples ne requiert pas " -"d'effort particulier. L'exemple suivant montre comment journaliser depuis le " +"La journalisation avec des fils d’exécution multiples ne requiert pas " +"d’effort particulier. L’exemple suivant montre comment journaliser depuis le " "fil principal (c.-à-d. initial) et un autre fil ::" #: howto/logging-cookbook.rst:133 msgid "When run, the script should print something like the following:" -msgstr "À l'exécution, le script doit afficher quelque chose comme ça ::" +msgstr "À l’exécution, le script doit afficher quelque chose comme ça ::" #: howto/logging-cookbook.rst:155 msgid "" "This shows the logging output interspersed as one might expect. This " "approach works for more threads than shown here, of course." msgstr "" -"Les entrées de journalisation sont entrelacées, comme on pouvait s'y " +"Les entrées de journalisation sont entrelacées, comme on pouvait s’y " "attendre. Cette approche fonctionne aussi avec plus de fils que dans " -"l'exemple, bien sûr." +"l’exemple, bien sûr." #: howto/logging-cookbook.rst:159 msgid "Multiple handlers and formatters" @@ -111,14 +112,14 @@ msgid "" "example::" msgstr "" "Les gestionnaires de journalisation sont des objets Python ordinaires. La " -"méthode :meth:`~Logger.addHandler` n'est pas limitée, en nombre minimum ou " +"méthode :meth:`~Logger.addHandler` n’est pas limitée, en nombre minimum ou " "maximum, en gestionnaires que vous pouvez ajouter. Parfois, il peut être " "utile pour une application de journaliser tous les messages quels que soient " "leurs niveaux vers un fichier texte, tout en journalisant les erreurs (et " "plus grave) dans la console. Pour ce faire, configurez simplement les " "gestionnaires de manière adéquate. Les appels de journalisation dans le code " -"de l'application resteront les mêmes. Voici une légère modification de " -"l'exemple précédent dans une configuration au niveau du module ::" +"de l’application resteront les mêmes. Voici une légère modification de " +"l’exemple précédent dans une configuration au niveau du module ::" #: howto/logging-cookbook.rst:194 msgid "" @@ -126,9 +127,9 @@ msgid "" "All that changed was the addition and configuration of a new handler named " "*fh*." msgstr "" -"Notez que le code de « l'application » ignore la multiplicité des " -"gestionnaires. Les modifications consistent simplement en l'ajout et la " -"configuration d'un nouveau gestionnaire appelé *fh*." +"Notez que le code de « l’application » ignore la multiplicité des " +"gestionnaires. Les modifications consistent simplement en l’ajout et la " +"configuration d’un nouveau gestionnaire appelé *fh*." #: howto/logging-cookbook.rst:197 msgid "" @@ -143,11 +144,11 @@ msgid "" msgstr "" "La possibilité de créer de nouveaux gestionnaires avec des filtres sur un " "niveau de gravité supérieur ou inférieur peut être très utile lors de " -"l'écriture ou du test d'une application. Au lieu d'utiliser de nombreuses " +"l’écriture ou du test d’une application. Au lieu d’utiliser de nombreuses " "instructions ``print`` pour le débogage, utilisez ``logger.debug`` : " "contrairement aux instructions ``print``, que vous devrez supprimer ou " "commenter plus tard, les instructions ``logger.debug`` peuvent demeurer " -"telles quelles dans le code source et restent dormantes jusqu'à ce que vous " +"telles quelles dans le code source et restent dormantes jusqu’à ce que vous " "en ayez à nouveau besoin. À ce moment-là, il suffit de modifier le niveau de " "gravité de la journalisation ou du gestionnaire pour déboguer." @@ -183,7 +184,7 @@ msgid "" "As you can see, the DEBUG message only shows up in the file. The other " "messages are sent to both destinations." msgstr "" -"Comme vous pouvez le constater, le message DEBUG n'apparaît que dans le " +"Comme vous pouvez le constater, le message DEBUG n’apparaît que dans le " "fichier. Les autres messages sont envoyés vers les deux destinations." #: howto/logging-cookbook.rst:270 @@ -202,10 +203,16 @@ msgid "" "the directory exists and that you have the permissions to create and update " "files in it." msgstr "" +"Notez que le choix du nom de fichier journal ``/tmp/myapp.log`` ci-dessus " +"implique l'utilisation d'un emplacement standard pour les fichiers " +"temporaires sur les systèmes POSIX. Sous Windows, vous devrez peut-être " +"choisir un nom de répertoire différent pour le journal – assurez-vous " +"simplement que le répertoire existe et que vous disposez des autorisations " +"nécessaires pour créer et mettre à jour des fichiers dans celui-ci." #: howto/logging-cookbook.rst:282 msgid "Custom handling of levels" -msgstr "" +msgstr "Personnalisation du niveau de journalisation" #: howto/logging-cookbook.rst:284 msgid "" @@ -214,22 +221,36 @@ msgid "" "get processed by a handler. To do this, you need to use filters. Let's look " "at a scenario where you want to arrange things as follows:" msgstr "" +"Il peut arriver que vous souhaitiez que vos gestionnaires journalisent " +"légèrement différemment de la gestion standard des niveaux, où tous les " +"niveaux au-dessus d'un seuil sont traités par un gestionnaire. Pour ce " +"faire, vous devez utiliser des filtres. Examinons un scénario dans lequel " +"vous souhaitez organiser les choses comme suit :" +# énumération #: howto/logging-cookbook.rst:289 msgid "Send messages of severity ``INFO`` and ``WARNING`` to ``sys.stdout``" msgstr "" +"envoyer les messages de niveau ``INFO`` et ``WARNING`` à ``sys.stdout`` ;" +# énumération #: howto/logging-cookbook.rst:290 msgid "Send messages of severity ``ERROR`` and above to ``sys.stderr``" msgstr "" +"envoyer les messages de niveau ``ERROR`` et au-dessus à ``sys.stderr`` ;" +# énumération #: howto/logging-cookbook.rst:291 msgid "Send messages of severity ``DEBUG`` and above to file ``app.log``" msgstr "" +"envoyer les messages de niveau ``DEBUG`` et au-dessus vers le fichier ``app." +"log``." #: howto/logging-cookbook.rst:293 msgid "Suppose you configure logging with the following JSON:" msgstr "" +"Supposons que vous configurez la journalisation avec le contenu au format " +"JSON suivant :" #: howto/logging-cookbook.rst:335 msgid "" @@ -239,16 +260,26 @@ msgid "" "those messages and add it to the relevant handler. This can be configured by " "adding a ``filters`` section parallel to ``formatters`` and ``handlers``:" msgstr "" +"Cette configuration fait *presque* ce que nous voulons, sauf que ``sys." +"stdout`` affiche les messages de gravité ``ERROR`` et supérieurs ainsi que " +"les messages ``INFO`` et ``WARNING``. Pour éviter cela, nous pouvons " +"configurer un filtre qui exclut ces messages et l'ajouter au gestionnaire " +"approprié. Effectuons la configuration en ajoutant une section ``filters`` " +"parallèle à ``formatters`` et ``handlers`` :" #: howto/logging-cookbook.rst:350 msgid "and changing the section on the ``stdout`` handler to add it:" msgstr "" +"et en changeant la section du gestionnaire ``stdout`` pour ajouter le " +"filtre :" #: howto/logging-cookbook.rst:362 msgid "" "A filter is just a function, so we can define the ``filter_maker`` (a " "factory function) as follows:" msgstr "" +"Un filtre n'est qu'une fonction, nous pouvons donc définir un " +"``filter_maker`` (une fonction fabrique) comme suit :" #: howto/logging-cookbook.rst:375 msgid "" @@ -260,22 +291,32 @@ msgid "" "filter_maker`` in the filter configuration. You will need to change that if " "you define it in a different module." msgstr "" +"Elle convertit la chaîne transmise en argument vers un niveau numérique puis " +"renvoie une fonction qui ne renvoie ``True`` que si le niveau de " +"l'enregistrement transmis est inférieur ou égal au niveau spécifié. Notez " +"que dans cet exemple, nous avons défini ``filter_maker`` dans un script de " +"test ``main.py`` qui est exécuté depuis la ligne de commande, donc son " +"module est ``__main__`` – d'où le ``__main__.filter_maker`` dans la " +"configuration du filtre. Vous devez le changer si vous la définissez dans un " +"module différent." #: howto/logging-cookbook.rst:383 msgid "With the filter added, we can run ``main.py``, which in full is:" msgstr "" +"Avec le filtre, nous pouvons exécuter ``main.py`` dont voici la version " +"complète :" #: howto/logging-cookbook.rst:453 msgid "And after running it like this:" -msgstr "" +msgstr "Et après l'avoir exécuté comme ceci :" #: howto/logging-cookbook.rst:459 msgid "We can see the results are as expected:" -msgstr "" +msgstr "Nous obtenons le résultat attendu :" #: howto/logging-cookbook.rst:485 msgid "Configuration server example" -msgstr "Exemple d'un serveur de configuration" +msgstr "Exemple d’un serveur de configuration" #: howto/logging-cookbook.rst:487 msgid "Here is an example of a module using the logging configuration server::" @@ -289,7 +330,7 @@ msgid "" "server, properly preceded with the binary-encoded length, as the new logging " "configuration::" msgstr "" -"Et voici un script qui, à partir d'un nom de fichier, commence par envoyer " +"Et voici un script qui, à partir d’un nom de fichier, commence par envoyer " "la taille du fichier encodée en binaire (comme il se doit), puis envoie ce " "fichier au serveur pour définir la nouvelle configuration de " "journalisation ::" @@ -305,9 +346,9 @@ msgid "" "though of course it also occurs in other scenarios." msgstr "" "Parfois, il est nécessaire que les gestionnaires de journalisation fassent " -"leur travail sans bloquer le fil d'exécution qui émet des événements. C'est " +"leur travail sans bloquer le fil d’exécution qui émet des événements. C’est " "généralement le cas dans les applications Web, mais aussi bien sûr dans " -"d'autres scénarios." +"d’autres scénarios." #: howto/logging-cookbook.rst:551 msgid "" @@ -319,14 +360,14 @@ msgid "" "which is too slow (and this query can be deep in the socket library code, " "below the Python layer, and outside your control)." msgstr "" -"Un gestionnaire classiquement lent est le :class:`SMTPHandler` : l'envoi d'e-" +"Un gestionnaire classiquement lent est le :class:`SMTPHandler` : l’envoi d’e-" "mails peut prendre beaucoup de temps, pour un certain nombre de raisons " "indépendantes du développeur (par exemple, une infrastructure de messagerie " -"ou de réseau peu performante). Mais n'importe quel autre gestionnaire " -"utilisant le réseau ou presque peut aussi s'avérer bloquant : même une " +"ou de réseau peu performante). Mais n’importe quel autre gestionnaire " +"utilisant le réseau ou presque peut aussi s’avérer bloquant : même une " "simple opération :class:`SocketHandler` peut faire une requête DNS implicite " "et être ainsi très lente (cette requête peut être enfouie profondément dans " -"le code de la bibliothèque d'accès réseau, sous la couche Python, et hors de " +"le code de la bibliothèque d’accès réseau, sous la couche Python, et hors de " "votre contrôle)." #: howto/logging-cookbook.rst:559 @@ -344,14 +385,14 @@ msgid "" msgstr "" "Une solution consiste à utiliser une approche en deux parties. Pour la " "première partie, affectez un seul :class:`QueueHandler` à la journalisation " -"des fils d'exécution critiques pour les performances. Ils écrivent " -"simplement dans leur file d'attente, qui peut être dimensionnée à une " +"des fils d’exécution critiques pour les performances. Ils écrivent " +"simplement dans leur file d’attente, qui peut être dimensionnée à une " "capacité suffisamment grande ou initialisée sans limite supérieure en " -"taille. L'écriture dans la file d'attente est généralement acceptée " -"rapidement, mais nous vous conseillons quand même de prévoir d'intercepter " -"l'exception :exc:`queue.Full` par précaution dans votre code. Si vous " -"développez une bibliothèque avec des fils d'exécution critiques pour les " -"performances, documentez-le bien (avec une suggestion de n'affecter que des " +"taille. L’écriture dans la file d’attente est généralement acceptée " +"rapidement, mais nous vous conseillons quand même de prévoir d’intercepter " +"l’exception :exc:`queue.Full` par précaution dans votre code. Si vous " +"développez une bibliothèque avec des fils d’exécution critiques pour les " +"performances, documentez-le bien (avec une suggestion de n’affecter que des " "``QueueHandlers`` à votre journalisation) pour faciliter le travail des " "développeurs qui utilisent votre code." @@ -366,12 +407,12 @@ msgid "" "handlers for processing." msgstr "" "La deuxième partie de la solution est la classe :class:`QueueListener`, " -"conçue comme l'homologue de :class:`QueueHandler`. Un :class:`QueueListener` " -"est très simple : vous lui passez une file d'attente et des gestionnaires, " -"et il lance un fil d'exécution interne qui scrute la file d'attente pour " +"conçue comme l’homologue de :class:`QueueHandler`. Un :class:`QueueListener` " +"est très simple : vous lui passez une file d’attente et des gestionnaires, " +"et il lance un fil d’exécution interne qui scrute la file d’attente pour " "récupérer les événements envoyés par les ``QueueHandlers`` (ou toute autre " -"source de ``LogRecords``, d'ailleurs). Les ``LogRecords`` sont supprimés de " -"la file d'attente et transmis aux gestionnaires pour traitement." +"source de ``LogRecords``, d’ailleurs). Les ``LogRecords`` sont supprimés de " +"la file d’attente et transmis aux gestionnaires pour traitement." #: howto/logging-cookbook.rst:578 msgid "" @@ -381,21 +422,22 @@ msgid "" "handler classes, which would eat up one thread per handler for no particular " "benefit." msgstr "" -"L'avantage d'avoir une classe :class:`QueueListener` séparée est que vous " +"L’avantage d’avoir une classe :class:`QueueListener` séparée est que vous " "pouvez utiliser la même instance pour servir plusieurs ``QueueHandlers``. " "Cela consomme moins de ressources que des instances de gestionnaires " -"réparties chacune dans un fil d'exécution séparé." +"réparties chacune dans un fil d’exécution séparé." #: howto/logging-cookbook.rst:583 msgid "An example of using these two classes follows (imports omitted)::" msgstr "" -"Voici un exemple d'utilisation de ces deux classes (les importations sont " +"Voici un exemple d’utilisation de ces deux classes (les importations sont " "omises) ::" #: howto/logging-cookbook.rst:601 msgid "which, when run, will produce:" -msgstr "ce qui produit ceci à l'exécution :" +msgstr "ce qui produit ceci à l’exécution :" +# suit un : #: howto/logging-cookbook.rst:607 msgid "" "Although the earlier discussion wasn't specifically talking about async " @@ -406,7 +448,18 @@ msgid "" "application, to use the above approach for logging, so that any blocking " "code runs only in the ``QueueListener`` thread." msgstr "" +"bien que la discussion précédente n'aborde pas spécifiquement l'utilisation " +"de code asynchrone, mais concerne les gestionnaires de journalisation lents, " +"notez que lors de la journalisation à partir de code asynchrone, les " +"gestionnaires qui écrivent vers le réseau ou même dans des fichiers peuvent " +"entraîner des problèmes (blocage de la boucle d'événements) car une certaine " +"journalisation est faite à partir du code natif de :mod:`asyncio`. Il peut " +"être préférable, si un code asynchrone est utilisé dans une application, " +"d'utiliser l'approche ci-dessus pour la journalisation, de sorte que tout ce " +"qui utilise du code bloquant ne s'exécute que dans le thread " +"``QueueListener``." +# suit un : #: howto/logging-cookbook.rst:615 msgid "" "Prior to Python 3.5, the :class:`QueueListener` always passed every message " @@ -418,18 +471,18 @@ msgid "" "of each message with the handler's level, and only passes a message to a " "handler if it's appropriate to do so." msgstr "" -"Avant Python 3.5, la classe :class:`QueueListener` passait chaque message " -"reçu de la file d'attente à chaque gestionnaire avec lequel l'instance avait " +"avant Python 3.5, la classe :class:`QueueListener` passait chaque message " +"reçu de la file d’attente à chaque gestionnaire avec lequel l’instance avait " "été initialisée (on supposait que le filtrage de niveau était entièrement " -"effectué de l'autre côté, au niveau de l'alimentation de la file d'attente). " -"Depuis Python 3.5, le comportement peut être modifié en passant l'argument " +"effectué de l’autre côté, au niveau de l’alimentation de la file d’attente). " +"Depuis Python 3.5, le comportement peut être modifié en passant l’argument " "par mot-clé ``respect_handler_level=True`` au constructeur. Dans ce cas, la " "``QueueListener`` compare le niveau de chaque message avec le niveau défini " -"dans chaque gestionnaire et ne transmet le message que si c'est opportun." +"dans chaque gestionnaire et ne transmet le message que si c’est opportun." #: howto/logging-cookbook.rst:628 msgid "Sending and receiving logging events across a network" -msgstr "Envoi et réception d'événements de journalisation à travers le réseau" +msgstr "Envoi et réception d’événements de journalisation à travers le réseau" #: howto/logging-cookbook.rst:630 msgid "" @@ -439,8 +492,8 @@ msgid "" msgstr "" "Supposons que vous souhaitiez envoyer des événements de journalisation sur " "un réseau et les traiter à la réception. Une façon simple de faire est " -"d'attacher une instance :class:`SocketHandler` à la journalisation racine de " -"l'émetteur ::" +"d’attacher une instance :class:`SocketHandler` à la journalisation racine de " +"l’émetteur ::" #: howto/logging-cookbook.rst:658 msgid "" @@ -455,7 +508,7 @@ msgid "" "First run the server, and then the client. On the client side, nothing is " "printed on the console; on the server side, you should see something like:" msgstr "" -"Lancez d'abord le serveur, puis le client. Côté client, rien ne s'affiche " +"Lancez d’abord le serveur, puis le client. Côté client, rien ne s’affiche " "sur la console ; côté serveur, vous devez voir quelque chose comme ça :" #: howto/logging-cookbook.rst:758 @@ -469,16 +522,15 @@ msgstr "" "Notez que ``pickle`` introduit des problèmes de sécurité dans certains " "scénarios. Si vous êtes concerné, vous pouvez utiliser une sérialisation " "alternative en surchargeant la méthode :meth:`~handlers.SocketHandler." -"makePickle` par votre propre implémentation, ainsi qu'en adaptant le script " +"makePickle` par votre propre implémentation, ainsi qu’en adaptant le script " "ci-dessus pour utiliser votre sérialisation." #: howto/logging-cookbook.rst:766 msgid "Running a logging socket listener in production" msgstr "" -"Journalisation en production à l'aide d'un connecteur en écoute sur le réseau" +"Journalisation en production à l’aide d’un connecteur en écoute sur le réseau" #: howto/logging-cookbook.rst:770 -#, fuzzy msgid "" "To run a logging listener in production, you may need to use a process-" "management tool such as `Supervisor `_. `Here is a " @@ -486,84 +538,90 @@ msgid "" "the above functionality using Supervisor. It consists of the following files:" msgstr "" "Pour de la journalisation en production *via* un connecteur réseau en " -"écoute, il est probable que vous ayez besoin d'utiliser un outil de " +"écoute, il est probable que vous ayez besoin d’utiliser un outil de " "surveillance tel que `Supervisor `_. Vous trouverez " -"dans ce `Gist `_ des gabarits pour assurer cette " -"fonction avec *Supervisor* : vous aurez besoin de modifier les parties ``/" -"path/to/`` du *Gist* pour refléter les chemins réels que vous utilisez." +"dans ce `Gist `__ des gabarits pour assurer cette " +"fonction avec *Supervisor*. Il est composé des fichiers suivants :" #: howto/logging-cookbook.rst:777 msgid "File" -msgstr "" +msgstr "Fichier" #: howto/logging-cookbook.rst:777 msgid "Purpose" -msgstr "" +msgstr "Objectif" #: howto/logging-cookbook.rst:779 msgid ":file:`prepare.sh`" -msgstr "" +msgstr ":file:`prepare.sh`" #: howto/logging-cookbook.rst:779 msgid "A Bash script to prepare the environment for testing" -msgstr "" +msgstr "Script Bash pour préparer l'environnement de test" #: howto/logging-cookbook.rst:782 msgid ":file:`supervisor.conf`" -msgstr "" +msgstr ":file:`supervisor.conf`" #: howto/logging-cookbook.rst:782 msgid "" "The Supervisor configuration file, which has entries for the listener and a " "multi-process web application" msgstr "" +"Fichier de configuration de *Supervisor*, avec les entrées pour le " +"connecteur en écoute et l'application web multi-processus" #: howto/logging-cookbook.rst:786 msgid ":file:`ensure_app.sh`" -msgstr "" +msgstr ":file:`ensure_app.sh`" #: howto/logging-cookbook.rst:786 msgid "" "A Bash script to ensure that Supervisor is running with the above " "configuration" msgstr "" +"Script Bash pour s'assurer que *Supervisor* fonctionne bien avec la " +"configuration ci-dessus" #: howto/logging-cookbook.rst:789 msgid ":file:`log_listener.py`" -msgstr "" +msgstr ":file:`log_listener.py`" #: howto/logging-cookbook.rst:789 msgid "" "The socket listener program which receives log events and records them to a " "file" msgstr "" +"Programme en écoute sur le réseau qui reçoit les événements de " +"journalisation et les enregistre dans un fichier" #: howto/logging-cookbook.rst:792 msgid ":file:`main.py`" -msgstr "" +msgstr ":file:`main.py`" #: howto/logging-cookbook.rst:792 msgid "" "A simple web application which performs logging via a socket connected to " "the listener" -msgstr "" +msgstr "Application web simple qui journalise *via* un connecteur réseau" #: howto/logging-cookbook.rst:795 msgid ":file:`webapp.json`" -msgstr "" +msgstr ":file:`webapp.json`" #: howto/logging-cookbook.rst:795 msgid "A JSON configuration file for the web application" -msgstr "" +msgstr "Fichier JSON de configuration de l'application web" #: howto/logging-cookbook.rst:797 msgid ":file:`client.py`" -msgstr "" +msgstr ":file:`client.py`" #: howto/logging-cookbook.rst:797 msgid "A Python script to exercise the web application" msgstr "" +"Script Python qui interagit avec l'application web pour effectuer des appels " +"à la journalisation" #: howto/logging-cookbook.rst:800 msgid "" @@ -573,20 +631,30 @@ msgid "" "same log file without conflicting with one another --- they all go through " "the socket listener." msgstr "" +"L'application Web utilise `Gunicorn `_, qui est un " +"serveur d'applications Web populaire qui démarre plusieurs processus de " +"travail pour gérer les demandes. Cet exemple de configuration montre comment " +"les processus peuvent écrire dans le même fichier journal sans entrer en " +"conflit les uns avec les autres — ils passent tous par le connecteur en " +"écoute." #: howto/logging-cookbook.rst:805 msgid "To test these files, do the following in a POSIX environment:" msgstr "" +"Pour tester ces fichiers, suivez cette procédure dans un environnement " +"POSIX :" #: howto/logging-cookbook.rst:807 msgid "" "Download `the Gist `__ as a ZIP archive using the :" "guilabel:`Download ZIP` button." msgstr "" +"Téléchargez l'archive ZIP du `Gist `__ à l'aide du " +"bouton :guilabel:`Download ZIP`." #: howto/logging-cookbook.rst:810 msgid "Unzip the above files from the archive into a scratch directory." -msgstr "" +msgstr "Décompressez les fichiers de l'archive dans un répertoire de travail." #: howto/logging-cookbook.rst:812 msgid "" @@ -595,18 +663,27 @@ msgid "" "files, and a :file:`venv` subdirectory to contain a virtual environment into " "which ``bottle``, ``gunicorn`` and ``supervisor`` are installed." msgstr "" +"Dans le répertoire de travail, exécutez le script de préparation par ``bash " +"prepare.sh``. Cela crée un sous-répertoire :file:`run` pour contenir les " +"fichiers journaux et ceux relatifs à *Supervisor*, ainsi qu'un sous-" +"répertoire :file:`venv` pour contenir un environnement virtuel dans lequel " +"``bottle``, ``gunicorn`` et ``supervisor`` sont installés." #: howto/logging-cookbook.rst:817 msgid "" "Run ``bash ensure_app.sh`` to ensure that Supervisor is running with the " "above configuration." msgstr "" +"Exécutez ``bash ensure_app.sh`` pour vous assurer que *Supervisor* s'exécute " +"avec la configuration ci-dessus." #: howto/logging-cookbook.rst:820 msgid "" "Run ``venv/bin/python client.py`` to exercise the web application, which " "will lead to records being written to the log." msgstr "" +"Exécutez ``venv/bin/python client.py`` pour tester l'application Web, ce qui " +"entraîne l'écriture d'enregistrements dans le journal." #: howto/logging-cookbook.rst:823 msgid "" @@ -615,22 +692,32 @@ msgid "" "won't be in any particular order, since they have been handled concurrently " "by different worker processes in a non-deterministic way." msgstr "" +"Inspectez les fichiers journaux dans le sous-répertoire :file:`run`. Vous " +"devriez voir les lignes de journal les plus récentes dans les fichiers de " +"type :file:`app.log*`. Ils ne seront pas dans un ordre particulier, car ils " +"ont été traités par les différents processus de travail de manière non " +"déterministe." #: howto/logging-cookbook.rst:828 msgid "" "You can shut down the listener and the web application by running ``venv/bin/" "supervisorctl -c supervisor.conf shutdown``." msgstr "" +"Vous pouvez arrêter le connecteur en écoute et l'application Web en " +"exécutant ``venv/bin/supervisorctl -c supervisor.conf shutdown``." #: howto/logging-cookbook.rst:831 msgid "" "You may need to tweak the configuration files in the unlikely event that the " "configured ports clash with something else in your test environment." msgstr "" +"Vous devrez peut-être modifier les fichiers de configuration dans le cas peu " +"probable où les ports configurés entrent en conflit avec autre chose dans " +"votre environnement de test." #: howto/logging-cookbook.rst:837 msgid "Adding contextual information to your logging output" -msgstr "Ajout d'informations contextuelles dans la journalisation" +msgstr "Ajout d’informations contextuelles dans la journalisation" # #no-qa #: howto/logging-cookbook.rst:839 @@ -649,24 +736,24 @@ msgid "" "`Logger` instances becomes effectively unbounded." msgstr "" "Dans certains cas, vous pouvez souhaiter que la journalisation contienne des " -"informations contextuelles en plus des paramètres transmis à l'appel de " +"informations contextuelles en plus des paramètres transmis à l’appel de " "journalisation. Par exemple, dans une application réseau, il peut être " "souhaitable de consigner des informations spécifiques au client dans le " -"journal (par exemple, le nom d'utilisateur ou l'adresse IP du client " +"journal (par exemple, le nom d’utilisateur ou l’adresse IP du client " "distant). Bien que vous puissiez utiliser le paramètre *extra* pour y " -"parvenir, il n'est pas toujours pratique de transmettre les informations de " +"parvenir, il n’est pas toujours pratique de transmettre les informations de " "cette manière. Il peut être aussi tentant de créer des instances :class:" -"`Logger` connexion par connexion, mais ce n'est pas une bonne idée car ces " +"`Logger` connexion par connexion, mais ce n’est pas une bonne idée car ces " "instances :class:`Logger` ne sont pas éliminées par le ramasse-miettes. Même " -"si ce point n'est pas problématique en soi si la journalisation est " +"si ce point n’est pas problématique en soi si la journalisation est " "configurée avec plusieurs niveaux de granularité, cela peut devenir " -"difficile de gérer un nombre potentiellement illimité d'instances de :class:" +"difficile de gérer un nombre potentiellement illimité d’instances de :class:" "`Logger`." #: howto/logging-cookbook.rst:854 msgid "Using LoggerAdapters to impart contextual information" msgstr "" -"Utilisation d'adaptateurs de journalisation pour transmettre des " +"Utilisation d’adaptateurs de journalisation pour transmettre des " "informations contextuelles" #: howto/logging-cookbook.rst:856 @@ -685,7 +772,7 @@ msgstr "" "`Logger`, de sorte que vous pouvez appeler :meth:`debug`, :meth:`info`, :" "meth:`warning`, :meth:`error`, :meth:`exception`, :meth:`critical` et :meth:" "`log`. Ces méthodes ont les mêmes signatures que leurs homologues dans :" -"class:`Logger`, vous pouvez donc utiliser les deux types d'instances de " +"class:`Logger`, vous pouvez donc utiliser les deux types d’instances de " "manière interchangeable." #: howto/logging-cookbook.rst:864 @@ -700,11 +787,11 @@ msgid "" msgstr "" "Lorsque vous créez une instance de :class:`LoggerAdapter`, vous lui " "transmettez une instance de :class:`Logger` et un objet dictionnaire qui " -"contient vos informations contextuelles. Lorsque vous appelez l'une des " +"contient vos informations contextuelles. Lorsque vous appelez l’une des " "méthodes de journalisation sur une instance de :class:`LoggerAdapter`, elle " -"délègue l'appel à l'instance sous-jacente de :class:`Logger` transmise à son " -"constructeur et s'arrange pour intégrer les informations contextuelles dans " -"l'appel délégué. Voici un extrait du code de :class:`LoggerAdapter` ::" +"délègue l’appel à l’instance sous-jacente de :class:`Logger` transmise à son " +"constructeur et s’arrange pour intégrer les informations contextuelles dans " +"l’appel délégué. Voici un extrait du code de :class:`LoggerAdapter` ::" #: howto/logging-cookbook.rst:880 msgid "" @@ -720,13 +807,13 @@ msgid "" msgstr "" "Les informations contextuelles sont ajoutées dans la méthode :meth:" "`~LoggerAdapter.process` de :class:`LoggerAdapter`. On lui passe le message " -"et les arguments par mot-clé de l'appel de journalisation, et elle en " +"et les arguments par mot-clé de l’appel de journalisation, et elle en " "renvoie des versions (potentiellement) modifiées à utiliser pour la " -"journalisation sous-jacente. L'implémentation par défaut de cette méthode " -"laisse le message seul, mais insère une clé ``extra`` dans l'argument par " -"mot-clé dont la valeur est l'objet dictionnaire passé au constructeur. Bien " -"sûr, si vous avez passé un argument par mot-clé ``extra`` dans l'appel à " -"l'adaptateur, il est écrasé silencieusement." +"journalisation sous-jacente. L’implémentation par défaut de cette méthode " +"laisse le message seul, mais insère une clé ``extra`` dans l’argument par " +"mot-clé dont la valeur est l’objet dictionnaire passé au constructeur. Bien " +"sûr, si vous avez passé un argument par mot-clé ``extra`` dans l’appel à " +"l’adaptateur, il est écrasé silencieusement." #: howto/logging-cookbook.rst:889 msgid "" @@ -738,11 +825,11 @@ msgid "" "string, you just need to subclass :class:`LoggerAdapter` and override :meth:" "`~LoggerAdapter.process` to do what you need. Here is a simple example::" msgstr "" -"L'avantage d'utiliser ``extra`` est que les valeurs de l'objet dictionnaire " -"sont fusionnées dans le ``__dict__`` de l'instance :class:`LogRecord`, ce " -"qui vous permet d'utiliser des chaînes personnalisées avec vos instances :" -"class:`Formatter` qui connaissent les clés de l'objet dictionnaire. Si vous " -"avez besoin d'une méthode différente, par exemple si vous souhaitez ajouter " +"L’avantage d’utiliser ``extra`` est que les valeurs de l’objet dictionnaire " +"sont fusionnées dans le ``__dict__`` de l’instance :class:`LogRecord`, ce " +"qui vous permet d’utiliser des chaînes personnalisées avec vos instances :" +"class:`Formatter` qui connaissent les clés de l’objet dictionnaire. Si vous " +"avez besoin d’une méthode différente, par exemple si vous souhaitez ajouter " "des informations contextuelles avant ou après la chaîne de message, il vous " "suffit de surcharger :class:`LoggerAdapter` et de remplacer :meth:" "`~LoggerAdapter.process` pour faire ce dont vous avez besoin. Voici un " @@ -763,7 +850,7 @@ msgstr "" #: howto/logging-cookbook.rst:914 msgid "Using objects other than dicts to pass contextual information" msgstr "" -"Utilisation d'objets autres que les dictionnaires pour passer des " +"Utilisation d’objets autres que les dictionnaires pour passer des " "informations contextuelles" #: howto/logging-cookbook.rst:916 @@ -774,11 +861,11 @@ msgid "" "if you want to generate values dynamically (whereas the values in a dict " "would be constant)." msgstr "" -"Il n'est pas obligatoire de passer un dictionnaire réel à un :class:" -"`LoggerAdapter`, vous pouvez passer une instance d'une classe qui implémente " -"``__getitem__`` et ``__iter__`` pour qu'il ressemble à un dictionnaire du " -"point de vue de la journalisation. C'est utile si vous souhaitez générer des " -"valeurs de manière dynamique (alors que les valeurs d'un dictionnaire " +"Il n’est pas obligatoire de passer un dictionnaire réel à un :class:" +"`LoggerAdapter`, vous pouvez passer une instance d’une classe qui implémente " +"``__getitem__`` et ``__iter__`` pour qu’il ressemble à un dictionnaire du " +"point de vue de la journalisation. C’est utile si vous souhaitez générer des " +"valeurs de manière dynamique (alors que les valeurs d’un dictionnaire " "seraient constantes)." #: howto/logging-cookbook.rst:925 @@ -793,10 +880,10 @@ msgid "" "can then be output using a suitable format string, or if needed a custom :" "class:`Formatter`." msgstr "" -"Un :class:`Filter` défini par l'utilisateur peut aussi ajouter des " +"Un :class:`Filter` défini par l’utilisateur peut aussi ajouter des " "informations contextuelles à la journalisation. Les instances de ``Filter`` " "sont autorisées à modifier les ``LogRecords`` qui leur sont transmis, y " -"compris par l'ajout d'attributs supplémentaires qui peuvent ensuite être " +"compris par l’ajout d’attributs supplémentaires qui peuvent ensuite être " "intégrés à la journalisation en utilisant une chaîne de formatage appropriée " "ou, si nécessaire, un :class:`Formatter` personnalisé." @@ -812,18 +899,18 @@ msgid "" "an example script::" msgstr "" "Par exemple, dans une application Web, la requête en cours de traitement (ou " -"du moins ce qu'elle contient d'intéressant) peut être stockée dans une " -"variable locale au fil d'exécution (:class:`threading.local`), puis utilisée " +"du moins ce qu’elle contient d’intéressant) peut être stockée dans une " +"variable locale au fil d’exécution (:class:`threading.local`), puis utilisée " "dans un ``Filter`` pour ajouter, par exemple, des informations relatives à " -"la requête (par exemple, l'adresse IP distante et le nom de l'utilisateur) " -"au ``LogRecord``, en utilisant les noms d'attribut ``ip`` et ``user`` comme " -"dans l'exemple ``LoggerAdapter`` ci-dessus. Dans ce cas, la même chaîne de " +"la requête (par exemple, l’adresse IP distante et le nom de l’utilisateur) " +"au ``LogRecord``, en utilisant les noms d’attribut ``ip`` et ``user`` comme " +"dans l’exemple ``LoggerAdapter`` ci-dessus. Dans ce cas, la même chaîne de " "formatage peut être utilisée pour obtenir une sortie similaire à celle " "indiquée ci-dessus. Voici un exemple de script ::" #: howto/logging-cookbook.rst:978 msgid "which, when run, produces something like:" -msgstr "qui, à l'exécution, produit quelque chose comme ça ::" +msgstr "qui, à l’exécution, produit quelque chose comme ça ::" #: howto/logging-cookbook.rst:996 msgid "Use of ``contextvars``" @@ -873,7 +960,6 @@ msgid "" msgstr "" #: howto/logging-cookbook.rst:1218 -#, fuzzy msgid "Imparting contextual information in handlers" msgstr "Ajout d'informations contextuelles dans la journalisation" @@ -884,6 +970,11 @@ msgid "" "handlers, you can use a filter that returns a new :class:`~LogRecord` " "instead of modifying it in-place, as shown in the following script::" msgstr "" +"Chaque :class:`~Handler` possède sa propre chaîne de filtres. Si vous " +"souhaitez ajouter des informations contextuelles à un :class:`LogRecord` " +"sans impacter d'autres gestionnaires, vous pouvez utiliser un filtre qui " +"renvoie un nouveau :class:`~LogRecord` au lieu de le modifier sur place, " +"comme dans le script suivant ::" #: howto/logging-cookbook.rst:1247 msgid "Logging to a single file from multiple processes" @@ -904,20 +995,20 @@ msgid "" "includes a working socket receiver which can be used as a starting point for " "you to adapt in your own applications." msgstr "" -"La journalisation est fiable avec les programmes à fils d'exécution " -"multiples (thread-safe) : rien n'empêche plusieurs fils d'exécution de " -"journaliser dans le même fichier, du moment que ces fils d'exécution font " -"partie du même processus. En revanche, il n'existe aucun moyen standard de " -"sérialiser l'accès à un seul fichier sur plusieurs processus en Python. Si " +"La journalisation est fiable avec les programmes à fils d’exécution " +"multiples (*thread-safe*) : rien n’empêche plusieurs fils d’exécution de " +"journaliser dans le même fichier, du moment que ces fils d’exécution font " +"partie du même processus. En revanche, il n’existe aucun moyen standard de " +"sérialiser l’accès à un seul fichier sur plusieurs processus en Python. Si " "vous avez besoin de vous connecter à un seul fichier à partir de plusieurs " "processus, une façon de le faire est de faire en sorte que tous les " -"processus se connectent à un :class:`~handlers.SocketHandler`, et d'avoir un " +"processus se connectent à un :class:`~handlers.SocketHandler`, et d’avoir un " "processus séparé qui implémente un serveur qui lit à partir de ce connecteur " "et écrit les journaux dans le fichier (si vous préférez, vous pouvez dédier " -"un fil d'exécution dans l'un des processus existants pour exécuter cette " +"un fil d’exécution dans l’un des processus existants pour exécuter cette " "tâche). :ref:`Cette section ` documente cette approche plus " "en détail et inclut un connecteur en écoute réseau fonctionnel qui peut être " -"utilisé comme point de départ pour l'adapter à vos propres applications." +"utilisé comme point de départ pour l’adapter à vos propres applications." #: howto/logging-cookbook.rst:1262 msgid "" @@ -931,9 +1022,9 @@ msgid "" msgstr "" "Vous pouvez également écrire votre propre gestionnaire en utilisant la " "classe :class:`~multiprocessing.Lock` du module :mod:`multiprocessing` pour " -"sérialiser l'accès au fichier depuis vos processus. Les actuels :class:" -"`FileHandler` et sous-classes n'utilisent pas :mod:`multiprocessing` pour le " -"moment, même s'ils pourraient le faire à l'avenir. Notez qu'à l'heure " +"sérialiser l’accès au fichier depuis vos processus. Les actuels :class:" +"`FileHandler` et sous-classes n’utilisent pas :mod:`multiprocessing` pour le " +"moment, même s’ils pourraient le faire à l’avenir. Notez qu’à l’heure " "actuelle, le module :mod:`multiprocessing` ne fournit pas un verrouillage " "fonctionnel pour toutes les plates-formes (voir https://bugs.python.org/" "issue3770)." @@ -953,14 +1044,14 @@ msgid "" "requirements::" msgstr "" "Autrement, vous pouvez utiliser une ``Queue`` et un :class:`QueueHandler` " -"pour envoyer tous les événements de journalisation à l'un des processus de " -"votre application multi-processus. L'exemple de script suivant montre " -"comment procéder ; dans l'exemple, un processus d'écoute distinct écoute les " +"pour envoyer tous les événements de journalisation à l’un des processus de " +"votre application multi-processus. L’exemple de script suivant montre " +"comment procéder ; dans l’exemple, un processus d’écoute distinct écoute les " "événements envoyés par les autres processus et les journalise en fonction de " -"sa propre configuration de journalisation. Bien que l'exemple ne montre " -"qu'une seule façon de faire (par exemple, vous pouvez utiliser un fil " -"d'exécution d'écoute plutôt qu'un processus d'écoute séparé – " -"l'implémentation serait analogue), il permet des configurations de " +"sa propre configuration de journalisation. Bien que l’exemple ne montre " +"qu’une seule façon de faire (par exemple, vous pouvez utiliser un fil " +"d’exécution d’écoute plutôt qu’un processus d’écoute séparé – " +"l’implémentation serait analogue), il permet des configurations de " "journalisation complètement différentes pour celui qui écoute ainsi que pour " "les autres processus de votre application, et peut être utilisé comme base " "pour répondre à vos propres exigences ::" @@ -983,9 +1074,9 @@ msgid "" "appropriate destinations." msgstr "" "Cette variante montre comment appliquer la configuration pour des " -"enregistreurs particuliers - par exemple l'enregistreur ``foo`` a un " +"enregistreurs particuliers – par exemple l’enregistreur ``foo`` a un " "gestionnaire spécial qui stocke tous les événements du sous-système ``foo`` " -"dans un fichier ``mplog-foo.log``. C'est utilisé par le mécanisme de " +"dans un fichier ``mplog-foo.log``. C’est utilisé par le mécanisme de " "journalisation dans le processus principal (même si les événements de " "journalisation sont générés dans les processus de travail) pour diriger les " "messages vers les destinations appropriées." @@ -1001,7 +1092,7 @@ msgid "" "Instead of" msgstr "" "Si vous souhaitez utiliser :class:`concurrent.futures.ProcessPoolExecutor` " -"pour démarrer vos processus de travail, vous devez créer la file d'attente " +"pour démarrer vos processus de travail, vous devez créer la file d’attente " "légèrement différemment. À la place de" #: howto/logging-cookbook.rst:1500 @@ -1017,12 +1108,12 @@ msgstr "" #: howto/logging-cookbook.rst:1517 msgid "to this (remembering to first import :mod:`concurrent.futures`)::" msgstr "" -"par celle-ci (souvenez-vous d'importer au préalable :mod:`concurrent." +"par celle-ci (souvenez-vous d’importer au préalable :mod:`concurrent." "futures`) ::" #: howto/logging-cookbook.rst:1524 msgid "Deploying Web applications using Gunicorn and uWSGI" -msgstr "Déploiement d'applications Web avec *Gunicorn* et *uWSGI*" +msgstr "Déploiement d’applications Web avec *Gunicorn* et *uWSGI*" #: howto/logging-cookbook.rst:1526 msgid "" @@ -1035,15 +1126,15 @@ msgid "" "process management tool such as Supervisor - see `Running a logging socket " "listener in production`_ for more details." msgstr "" -"Lors du déploiement d'applications Web qui utilisent `Gunicorn `_ ou `uWSGI `_ " "(ou équivalent), plusieurs processus de travail sont créés pour traiter les " "requêtes des clients. Dans de tels environnements, évitez de créer des " "gestionnaires à fichiers directement dans votre application Web. Au lieu de " "cela, utilisez un :class:`SocketHandler` pour journaliser depuis " -"l'application Web vers gestionnaire réseau à l'écoute dans un processus " -"séparé. Cela peut être configuré à l'aide d'un outil de gestion de processus " -"tel que *Supervisor* (voir `Journalisation en production à l'aide d'un " +"l’application Web vers gestionnaire réseau à l’écoute dans un processus " +"séparé. Cela peut être configuré à l’aide d’un outil de gestion de processus " +"tel que *Supervisor* (voir `Journalisation en production à l’aide d’un " "connecteur en écoute sur le réseau`_ pour plus de détails)." #: howto/logging-cookbook.rst:1536 @@ -1059,12 +1150,12 @@ msgid "" "usage pattern, the logging package provides a :class:`~handlers." "RotatingFileHandler`::" msgstr "" -"Parfois, vous souhaitez laisser un fichier de journalisation grossir jusqu'à " +"Parfois, vous souhaitez laisser un fichier de journalisation grossir jusqu’à " "une certaine taille, puis ouvrir un nouveau fichier et vous y enregistrer " "les nouveaux événements. Vous souhaitez peut-être conserver un certain " "nombre de ces fichiers et, lorsque ce nombre de fichiers aura été créé, " "faire rouler les fichiers afin que le nombre de fichiers et la taille des " -"fichiers restent tous deux limités. Pour ce cas d'usage, :class:`~handlers." +"fichiers restent tous deux limités. Pour ce cas d’usage, :class:`~handlers." "RotatingFileHandler` est inclus dans le paquet de journalisation ::" #: howto/logging-cookbook.rst:1573 @@ -1073,7 +1164,7 @@ msgid "" "the application:" msgstr "" "Vous devez obtenir 6 fichiers séparés, chacun contenant une partie de " -"l'historique de journalisation de l'application :" +"l’historique de journalisation de l’application :" #: howto/logging-cookbook.rst:1585 msgid "" @@ -1083,7 +1174,7 @@ msgid "" "(``.1`` becomes ``.2``, etc.) and the ``.6`` file is erased." msgstr "" "Le fichier de journalisation actuel est toujours :file:" -"`logging_rotatingfile_example.out`, et chaque fois qu'il atteint la taille " +"`logging_rotatingfile_example.out`, et chaque fois qu’il atteint la taille " "limite, il est renommé avec le suffixe ``.1``. Chacun des fichiers de " "sauvegarde existants est renommé pour incrémenter le suffixe (``.1`` devient " "``.2``, etc.) et le fichier ``.6`` est effacé." @@ -1098,7 +1189,7 @@ msgstr "" #: howto/logging-cookbook.rst:1596 msgid "Use of alternative formatting styles" -msgstr "Utilisation d'autres styles de formatage" +msgstr "Utilisation d’autres styles de formatage" #: howto/logging-cookbook.rst:1598 msgid "" @@ -1110,7 +1201,7 @@ msgid "" msgstr "" "Lorsque la journalisation a été ajoutée à la bibliothèque standard Python, " "la seule façon de formater les messages avec un contenu variable était " -"d'utiliser la méthode de formatage avec « % ». Depuis, Python s'est enrichi " +"d’utiliser la méthode de formatage avec « % ». Depuis, Python s’est enrichi " "de deux nouvelles méthode de formatage : :class:`string.Template` (ajouté " "dans Python 2.4) et :meth:`str.format` (ajouté dans Python 2.6)." @@ -1171,10 +1262,10 @@ msgstr "" "clé ``exc_info`` indique que les informations de trace doivent être " "enregistrées, ou le paramètre par mot-clé ``extra`` indique des informations " "contextuelles supplémentaires à ajouter au journal). Vous ne pouvez donc pas " -"inclure dans les appels de journalisation à l'aide de la syntaxe :meth:`str." +"inclure dans les appels de journalisation à l’aide de la syntaxe :meth:`str." "format` ou :class:`string.Template`, car le paquet de journalisation utilise " "le formatage via « % » en interne pour fusionner la chaîne de format et les " -"arguments de variables. Il n'est pas possible de changer ça tout en " +"arguments de variables. Il n’est pas possible de changer ça tout en " "préservant la rétrocompatibilité puisque tous les appels de journalisation " "dans le code pré-existant utilisent des chaînes au format « % »." @@ -1186,7 +1277,7 @@ msgid "" "will call ``str()`` on that object to get the actual format string. Consider " "the following two classes::" msgstr "" -"Il existe cependant un moyen d'utiliser le formatage *via* « {} » et « $ » " +"Il existe cependant un moyen d’utiliser le formatage *via* « {} » et « $ » " "pour vos messages de journalisation. Rappelez-vous que, pour un message, " "vous pouvez utiliser un objet arbitraire comme chaîne de format de message, " "et que le package de journalisation appelle ``str()`` sur cet objet pour " @@ -1202,10 +1293,10 @@ msgid "" "__ (double underscore --- not to be confused with _, the single underscore " "used as a synonym/alias for :func:`gettext.gettext` or its brethren)." msgstr "" -"L'une ou l'autre peut être utilisée à la place d'une chaîne de format " +"L’une ou l’autre peut être utilisée à la place d’une chaîne de format " "\"%(message)s\" ou \"{message}\" ou \"$message\", afin de mettre en forme " "*via* « { } » ou « $ » la partie « message réel » qui apparaît dans la " -"sortie de journal formatée. Il est un peu lourd d'utiliser les noms de " +"sortie de journal formatée. Il est un peu lourd d’utiliser les noms de " "classe chaque fois que vous voulez journaliser quelque chose, mais ça " "devient acceptable si vous utilisez un alias tel que __ (double trait de " "soulignement — à ne pas confondre avec _, le trait de soulignement unique " @@ -1217,9 +1308,9 @@ msgid "" "copy and paste into your own code. They can be used as follows (assuming " "that they're declared in a module called ``wherever``):" msgstr "" -"Les classes ci-dessus ne sont pas incluses dans Python, bien qu'elles soient " +"Les classes ci-dessus ne sont pas incluses dans Python, bien qu’elles soient " "assez faciles à copier et coller dans votre propre code. Elles peuvent être " -"utilisées comme suit (en supposant qu'elles soient déclarées dans un module " +"utilisées comme suit (en supposant qu’elles soient déclarées dans un module " "appelé ``wherever``) :" #: howto/logging-cookbook.rst:1713 @@ -1242,14 +1333,14 @@ msgid "" "not just the format string. That's because the __ notation is just syntax " "sugar for a constructor call to one of the XXXMessage classes." msgstr "" -"Une chose à noter est qu'il n'y a pas de perte de performance significative " +"Une chose à noter est qu’il n’y a pas de perte de performance significative " "avec cette approche : le formatage réel ne se produit pas lorsque vous " -"effectuez l'appel de journalisation, mais lorsque (et si) le message " -"journalisé est réellement sur le point d'être écrit dans un journal par un " +"effectuez l’appel de journalisation, mais lorsque (et si) le message " +"journalisé est réellement sur le point d’être écrit dans un journal par un " "gestionnaire. Ainsi, la seule chose légèrement inhabituelle qui pourrait " "vous perturber est que les parenthèses entourent la chaîne de format et les " -"arguments, pas seulement la chaîne de format. C'est parce que la notation __ " -"n'est que du sucre syntaxique pour un appel de constructeur à l'une des " +"arguments, pas seulement la chaîne de format. C’est parce que la notation __ " +"n’est que du sucre syntaxique pour un appel de constructeur à l’une des " "classes ``XXXMessage``." #: howto/logging-cookbook.rst:1725 @@ -1258,7 +1349,7 @@ msgid "" "effect to the above, as in the following example::" msgstr "" "Si vous préférez, vous pouvez utiliser un :class:`LoggerAdapter` pour " -"obtenir un effet similaire à ce qui précède, comme dans l'exemple suivant ::" +"obtenir un effet similaire à ce qui précède, comme dans l’exemple suivant ::" #: howto/logging-cookbook.rst:1756 msgid "" @@ -1270,7 +1361,7 @@ msgstr "" #: howto/logging-cookbook.rst:1765 msgid "Customizing ``LogRecord``" -msgstr "" +msgstr "Personnalisation de ``LogRecord``" #: howto/logging-cookbook.rst:1767 msgid "" @@ -1282,12 +1373,22 @@ msgid "" "disabled). Before Python 3.2, there were only two places where this creation " "was done:" msgstr "" +"Chaque événement de journalisation est représenté par une instance :class:" +"`LogRecord`. Lorsqu’un événement est enregistré et non filtré en raison du " +"niveau d’un enregistreur, un :class:`LogRecord` est créé, rempli avec les " +"informations de l’événement, puis transmis aux gestionnaires de cet " +"enregistreur (et ses ancêtres, jusqu’à et y compris l’enregistreur où la " +"propagation vers le haut de la hiérarchie est désactivée). Avant Python 3.2, " +"il n’y avait que deux endroits où cette création était effectuée :" #: howto/logging-cookbook.rst:1774 msgid "" ":meth:`Logger.makeRecord`, which is called in the normal process of logging " "an event. This invoked :class:`LogRecord` directly to create an instance." msgstr "" +":meth:`Logger.makeRecord`, qui est appelée dans le processus normal de " +"journalisation d’un événement. Elle appelait :class:`LogRecord` directement " +"pour créer une instance." #: howto/logging-cookbook.rst:1777 msgid "" @@ -1297,12 +1398,20 @@ msgid "" "via a :class:`~handlers.SocketHandler`, or in JSON form via an :class:" "`~handlers.HTTPHandler`)." msgstr "" +":func:`makeLogRecord`, qui est appelée avec un dictionnaire contenant des " +"attributs à ajouter au *LogRecord*. Elle est généralement invoquée lorsqu’un " +"dictionnaire approprié a été reçu par le réseau (par exemple, sous forme de " +"*pickle* *via* un :class:`~handlers.SocketHandler`, ou sous format JSON " +"*via* un :class:`~handlers.HTTPHandler`)." #: howto/logging-cookbook.rst:1783 msgid "" "This has usually meant that if you need to do anything special with a :class:" "`LogRecord`, you've had to do one of the following." msgstr "" +"Cela signifiait généralement que, si vous deviez faire quelque chose de " +"spécial avec un :class:`LogRecord`, vous deviez faire l’une des choses " +"suivantes." #: howto/logging-cookbook.rst:1786 msgid "" @@ -1310,6 +1419,9 @@ msgid "" "makeRecord`, and set it using :func:`~logging.setLoggerClass` before any " "loggers that you care about are instantiated." msgstr "" +"Créer votre propre sous-classe :class:`Logger`, surchargeant :meth:`Logger." +"makeRecord`, et la personnaliser à l’aide de :func:`~logging.setLoggerClass` " +"avant que les enregistreurs qui vous intéressaient ne soient instanciés." #: howto/logging-cookbook.rst:1789 msgid "" @@ -1317,6 +1429,9 @@ msgid "" "special manipulation you need when its :meth:`~Filter.filter` method is " "called." msgstr "" +"Ajouter un :class:`Filter` à un enregistreur ou un gestionnaire, qui " +"effectuait la manipulation spéciale nécessaire dont vous aviez besoin " +"lorsque sa méthode :meth:`~Filter.filter` était appelée." #: howto/logging-cookbook.rst:1793 msgid "" @@ -1325,6 +1440,10 @@ msgid "" "attempt to set its own :class:`Logger` subclass, and the one which did this " "last would win." msgstr "" +"La première approche est un peu lourde dans le scénario où (disons) " +"plusieurs bibliothèques différentes veulent faire des choses différentes. " +"Chacun essaie de définir sa propre sous-classe :class:`Logger`, et celui qui " +"l’a fait en dernier gagne." #: howto/logging-cookbook.rst:1798 msgid "" @@ -1334,6 +1453,12 @@ msgid "" "to remember to do this every time they introduced a new logger (which they " "would do simply by adding new packages or modules and doing ::" msgstr "" +"La seconde approche fonctionne raisonnablement bien dans de nombreux cas, " +"mais ne vous permet pas, par exemple, d’utiliser une sous-classe spécialisée " +"de :class:`LogRecord`. Les développeurs de bibliothèques peuvent définir un " +"filtre approprié sur leurs enregistreurs, mais ils doivent se rappeler de le " +"faire chaque fois qu’ils introduisent un nouvel enregistreur (ce qu’ils font " +"simplement en ajoutant de nouveaux paquets ou modules et en écrivant ::" #: howto/logging-cookbook.rst:1806 msgid "" @@ -1344,6 +1469,13 @@ msgid "" "so output from that handler would not reflect the intentions of the library " "developer." msgstr "" +"au niveau des modules). C’est probablement trop de choses auxquelles penser. " +"Les développeurs pourraient également ajouter le filtre à un :class:" +"`~logging.NullHandler` attaché à leur enregistreur de niveau supérieur, mais " +"cela ne serait pas invoqué si un développeur d’application attachait un " +"gestionnaire à un enregistreur de bibliothèque de niveau inférieur — donc la " +"sortie de ce gestionnaire ne refléterait pas les intentions du développeur " +"de la bibliothèque." #: howto/logging-cookbook.rst:1812 msgid "" @@ -1354,6 +1486,13 @@ msgid "" "signature as the :class:`~logging.LogRecord` constructor, as :class:" "`LogRecord` is the default setting for the factory." msgstr "" +"Dans Python 3.2 et ultérieurs, la création de :class:`~logging.LogRecord` " +"est effectuée via une fabrique, que vous pouvez spécifier. La fabrique est " +"juste un appelable que vous pouvez définir avec :func:`~logging." +"setLogRecordFactory`, et interroger avec :func:`~logging." +"getLogRecordFactory`. La fabrique est invoquée avec la même signature que le " +"constructeur :class:`~logging.LogRecord`, car :class:`LogRecord` est le " +"paramètre par défaut de la fabrique." #: howto/logging-cookbook.rst:1819 msgid "" @@ -1362,6 +1501,10 @@ msgid "" "additional attributes to the record once created, using a pattern similar to " "this::" msgstr "" +"Cette approche permet à une fabrique personnalisée de contrôler tous les " +"aspects de la création d’un *LogRecord*. Par exemple, vous pouvez renvoyer " +"une sous-classe ou simplement ajouter des attributs supplémentaires à " +"l’enregistrement une fois créé, en utilisant un modèle similaire à celui-ci :" #: howto/logging-cookbook.rst:1832 msgid "" @@ -1372,10 +1515,18 @@ msgid "" "time overhead to all logging operations, and the technique should only be " "used when the use of a :class:`Filter` does not provide the desired result." msgstr "" +"Ce modèle permet à différentes bibliothèques d’enchaîner des fabriques, et " +"tant qu’elles n’écrasent pas les attributs des autres ou n’écrasent pas " +"involontairement les attributs fournis en standard, il ne devrait pas y " +"avoir de surprise. Cependant, il faut garder à l’esprit que chaque maillon " +"de la chaîne ajoute une surcharge d’exécution à toutes les opérations de " +"journalisation, et la technique ne doit être utilisée que lorsque " +"l’utilisation d’un :class:`Filter` ne permet pas d’obtenir le résultat " +"souhaité." #: howto/logging-cookbook.rst:1843 msgid "Subclassing QueueHandler - a ZeroMQ example" -msgstr "" +msgstr "Dérivation de *QueueHandler* – un exemple de *ZeroMQ*" #: howto/logging-cookbook.rst:1845 msgid "" @@ -1383,22 +1534,31 @@ msgid "" "of queues, for example a ZeroMQ 'publish' socket. In the example below,the " "socket is created separately and passed to the handler (as its 'queue')::" msgstr "" +"Vous pouvez utiliser une sous-classe :class:`QueueHandler` pour envoyer des " +"messages à d’autres types de files d’attente, par exemple un connecteur " +"*ZeroMQ publish*. Dans l’exemple ci-dessous, le connecteur est créé " +"séparément et transmis au gestionnaire (en tant que file d’attente) ::" #: howto/logging-cookbook.rst:1864 msgid "" "Of course there are other ways of organizing this, for example passing in " "the data needed by the handler to create the socket::" msgstr "" +"Bien sûr, il existe d’autres manières de faire, par exemple en transmettant " +"les données nécessaires au gestionnaire pour créer le connecteur ::" #: howto/logging-cookbook.rst:1882 msgid "Subclassing QueueListener - a ZeroMQ example" -msgstr "" +msgstr "Dérivation de *QueueListener* – un exemple de *ZeroMQ*" #: howto/logging-cookbook.rst:1884 msgid "" "You can also subclass :class:`QueueListener` to get messages from other " "kinds of queues, for example a ZeroMQ 'subscribe' socket. Here's an example::" msgstr "" +"Vous pouvez également dériver :class:`QueueListener` pour obtenir des " +"messages d’autres types de files d’attente, par exemple un connecteur " +"*ZeroMQ subscribe*. Voici un exemple ::" #: howto/logging-cookbook.rst:1903 howto/logging-cookbook.rst:3944 msgid "Module :mod:`logging`" @@ -1406,7 +1566,7 @@ msgstr "Module :mod:`logging`" #: howto/logging-cookbook.rst:1903 howto/logging-cookbook.rst:3944 msgid "API reference for the logging module." -msgstr "Référence d'API pour le module de journalisation." +msgstr "Référence de l’API du module de journalisation." #: howto/logging-cookbook.rst:1906 howto/logging-cookbook.rst:3947 msgid "Module :mod:`logging.config`" @@ -1414,7 +1574,7 @@ msgstr "Module :mod:`logging.config`" #: howto/logging-cookbook.rst:1906 howto/logging-cookbook.rst:3947 msgid "Configuration API for the logging module." -msgstr "API de configuration pour le module de journalisation." +msgstr "API pour la configuration du module de journalisation." #: howto/logging-cookbook.rst:1909 howto/logging-cookbook.rst:3950 msgid "Module :mod:`logging.handlers`" @@ -1427,14 +1587,18 @@ msgstr "Gestionnaires utiles inclus avec le module de journalisation." #: howto/logging-cookbook.rst:1911 msgid ":ref:`A basic logging tutorial `" msgstr "" +":ref:`Les bases de l’utilisation du module de journalisation `" #: howto/logging-cookbook.rst:1913 msgid ":ref:`A more advanced logging tutorial `" msgstr "" +":ref:`Utilisation avancée du module de journalisation `" #: howto/logging-cookbook.rst:1917 msgid "An example dictionary-based configuration" -msgstr "" +msgstr "Exemple de configuration basée sur un dictionnaire" #: howto/logging-cookbook.rst:1919 msgid "" @@ -1443,6 +1607,11 @@ msgid "" "stable/topics/logging/#configuring-logging>`_. This dictionary is passed to :" "func:`~config.dictConfig` to put the configuration into effect::" msgstr "" +"Vous trouverez ci-dessous un exemple de dictionnaire de configuration de " +"journalisation ­– il est tiré de la `documentation du projet Django `_. Ce " +"dictionnaire est passé à :func:`~config.dictConfig` pour activer la " +"configuration ::" #: howto/logging-cookbook.rst:1975 msgid "" @@ -1450,25 +1619,34 @@ msgid "" "section `_ of the Django documentation." msgstr "" +"Pour plus d’informations sur cette configuration, vous pouvez consulter la " +"`section correspondante `_ de la documentation de *Django*." #: howto/logging-cookbook.rst:1982 msgid "Using a rotator and namer to customize log rotation processing" msgstr "" +"Utilisation d’un rotateur et d’un nom pour personnaliser la rotation des " +"journaux" #: howto/logging-cookbook.rst:1984 msgid "" "An example of how you can define a namer and rotator is given in the " "following runnable script, which shows gzip compression of the log file::" msgstr "" +"L’extrait de code suivant fournit un exemple de la façon dont vous pouvez " +"définir un nom et un rotateur, avec la compression par *zlib* du journal ::" #: howto/logging-cookbook.rst:2015 msgid "" "After running this, you will see six new files, five of which are compressed:" msgstr "" +"Après l'avoir exécuté, vous verrez six nouveaux fichiers, dont cinq sont " +"compressés :" #: howto/logging-cookbook.rst:2028 msgid "A more elaborate multiprocessing example" -msgstr "" +msgstr "Exemple plus élaboré avec traitement en parallèle" #: howto/logging-cookbook.rst:2030 msgid "" @@ -1477,8 +1655,13 @@ msgid "" "simple, but serve to illustrate how more complex ones could be implemented " "in a real multiprocessing scenario." msgstr "" +"L’exemple suivant que nous allons étudier montre comment la journalisation " +"peut être utilisée, à l’aide de fichiers de configuration, pour un programme " +"effectuant des traitements parallèles. Les configurations sont assez " +"simples, mais servent à illustrer comment des configurations plus complexes " +"pourraient être implémentées dans un scénario multi-processus réel." -#: howto/logging-cookbook.rst:2035 +#: howto/logging-cookbook.rst:2014 msgid "" "In the example, the main process spawns a listener process and some worker " "processes. Each of the main process, the listener and the workers have three " @@ -1490,16 +1673,30 @@ msgid "" "purely illustrative, but you should be able to adapt this example to your " "own scenario." msgstr "" +"Dans l’exemple, le processus principal génère un processus d’écoute et des " +"processus de travail. Chacun des processus, le principal, l’auditeur " +"(*listener_process* dans l’exemple) et les processus de travail " +"(*worker_process* dans l’exemple) ont trois configurations distinctes (les " +"processus de travail partagent tous la même configuration). Nous pouvons " +"voir la journalisation dans le processus principal, comment les processus de " +"travail se connectent à un *QueueHandler* et comment l’auditeur implémente " +"un *QueueListener* avec une configuration de journalisation plus complexe, " +"et s’arrange pour envoyer les événements reçus *via* la file d’attente aux " +"gestionnaires spécifiés dans la configuration. Notez que ces configurations " +"sont purement illustratives, mais vous devriez pouvoir adapter cet exemple à " +"votre propre scénario." #: howto/logging-cookbook.rst:2045 msgid "" "Here's the script - the docstrings and the comments hopefully explain how it " "works::" msgstr "" +"Voici le script – les chaines de documentation et les commentaires " +"expliquent (en anglais), le principe de fonctionnement ::" #: howto/logging-cookbook.rst:2257 msgid "Inserting a BOM into messages sent to a SysLogHandler" -msgstr "" +msgstr "Insertion d’une *BOM* dans les messages envoyés à un *SysLogHandler*" #: howto/logging-cookbook.rst:2259 msgid "" @@ -1509,6 +1706,11 @@ msgid "" "encoded using UTF-8. (See the :rfc:`relevant section of the specification " "<5424#section-6>`.)" msgstr "" +"La :rfc:`5424` requiert qu’un message Unicode soit envoyé à un démon " +"*syslog* sous la forme d’un ensemble d’octets ayant la structure suivante : " +"un composant ASCII pur facultatif, suivi d’une marque d’ordre d’octet (*BOM* " +"pour *Byte Order Mark* en anglais) UTF-8, suivie de contenu Unicode UTF-8 " +"(voir la :rfc:`la spécification correspondante <5424#section-6>`)." #: howto/logging-cookbook.rst:2265 msgid "" @@ -1517,6 +1719,10 @@ msgid "" "incorrectly, with the BOM appearing at the beginning of the message and " "hence not allowing any pure-ASCII component to appear before it." msgstr "" +"Dans Python 3.1, du code a été ajouté à :class:`~logging.handlers." +"SysLogHandler` pour insérer une *BOM* dans le message mais, malheureusement, " +"il a été implémenté de manière incorrecte, la *BOM* apparaissant au début du " +"message et n’autorisant donc aucun composant ASCII pur à être placé devant." #: howto/logging-cookbook.rst:2271 msgid "" @@ -1526,18 +1732,28 @@ msgid "" "an optional pure-ASCII sequence before it and arbitrary Unicode after it, " "encoded using UTF-8, then you need to do the following:" msgstr "" +"Comme ce comportement est inadéquat, le code incorrect d’insertion de la " +"*BOM* a été supprimé de Python 3.2.4 et ultérieurs. Cependant, il n’est pas " +"remplacé et, si vous voulez produire des messages conformes :rfc:`5424` qui " +"incluent une *BOM*, une séquence facultative en ASCII pur avant et un " +"Unicode arbitraire après, encodé en UTF-8, alors vous devez appliquer ce qui " +"suit :" #: howto/logging-cookbook.rst:2277 msgid "" "Attach a :class:`~logging.Formatter` instance to your :class:`~logging." "handlers.SysLogHandler` instance, with a format string such as::" msgstr "" +"Adjoignez une instance :class:`~logging.Formatter` à votre instance :class:" +"`~logging.handlers.SysLogHandler`, avec une chaîne de format telle que ::" #: howto/logging-cookbook.rst:2283 msgid "" "The Unicode code point U+FEFF, when encoded using UTF-8, will be encoded as " "a UTF-8 BOM -- the byte-string ``b'\\xef\\xbb\\xbf'``." msgstr "" +"Le point de code Unicode U+FEFF, lorsqu’il est encodé en UTF-8, est encodé " +"comme une *BOM* UTF-8 – la chaîne d’octets ``b'\\xef\\xbb\\xbf'``." #: howto/logging-cookbook.rst:2286 msgid "" @@ -1545,6 +1761,9 @@ msgid "" "that the data that appears in there after substitution is always ASCII (that " "way, it will remain unchanged after UTF-8 encoding)." msgstr "" +"Remplacez la section ASCII par les caractères de votre choix, mais assurez-" +"vous que les données qui y apparaissent après la substitution sont toujours " +"ASCII (ainsi elles resteront inchangées après l’encodage UTF-8)." #: howto/logging-cookbook.rst:2290 msgid "" @@ -1552,6 +1771,10 @@ msgid "" "which appears there after substitution contains characters outside the ASCII " "range, that's fine -- it will be encoded using UTF-8." msgstr "" +"Remplacez la section Unicode par le contenu de votre choix ; si les données " +"qui y apparaissent après la substitution contiennent des caractères en " +"dehors de la plage ASCII, c’est pris en charge – elles seront encodées en " +"UTF-8." #: howto/logging-cookbook.rst:2294 msgid "" @@ -1561,10 +1784,15 @@ msgid "" "complain, but your messages will not be RFC 5424-compliant, and your syslog " "daemon may complain." msgstr "" +"Le message formaté *sera* encodé en UTF-8 par ``SysLogHandler``. Si vous " +"suivez les règles ci-dessus, vous devriez pouvoir produire des messages " +"conformes à la :rfc:`5424`. Si vous ne le faites pas, la journalisation ne " +"se plaindra peut-être pas, mais vos messages ne seront pas conformes à la " +"RFC 5424 et votre démon *syslog* est susceptible de se plaindre." #: howto/logging-cookbook.rst:2301 msgid "Implementing structured logging" -msgstr "" +msgstr "Journalisation structurée" #: howto/logging-cookbook.rst:2303 msgid "" @@ -1577,30 +1805,42 @@ msgid "" "following is a simple approach which uses JSON to serialise the event in a " "machine-parseable manner::" msgstr "" +"Bien que la plupart des messages de journalisation soient destinés à être " +"lus par des humains, et donc difficilement analysables par la machine, il " +"peut arriver que vous souhaitiez produire des messages dans un format " +"structuré dans le but d’être analysé par un programme (sans avoir besoin " +"d’expressions régulières complexes pour analyser le message du journal). " +"C’est simple à réaliser en utilisant le paquet de journalisation. Il existe " +"plusieurs façons d’y parvenir et voici une approche simple qui utilise JSON " +"pour sérialiser l’événement de manière à être analysable par une machine ::" #: howto/logging-cookbook.rst:2327 msgid "If the above script is run, it prints:" -msgstr "" +msgstr "Si vous lancez le script ci-dessus, il imprime :" #: howto/logging-cookbook.rst:2333 howto/logging-cookbook.rst:2375 msgid "" "Note that the order of items might be different according to the version of " "Python used." msgstr "" +"Notez que l’ordre des éléments peut être différent en fonction de la version " +"de Python utilisée." #: howto/logging-cookbook.rst:2336 msgid "" "If you need more specialised processing, you can use a custom JSON encoder, " "as in the following complete example::" msgstr "" +"Si vous avez besoin d’un traitement plus spécifique, vous pouvez utiliser un " +"encodeur JSON personnalisé, comme dans l’exemple complet suivant :" #: howto/logging-cookbook.rst:2369 msgid "When the above script is run, it prints:" -msgstr "" +msgstr "Quand vous exécutez le script ci-dessus, il imprime :" #: howto/logging-cookbook.rst:2384 msgid "Customizing handlers with :func:`dictConfig`" -msgstr "" +msgstr "Personnalisation des gestionnaires avec :func:`dictConfig`" #: howto/logging-cookbook.rst:2386 msgid "" @@ -1611,12 +1851,23 @@ msgid "" "the file handlers in the stdlib don't offer built-in support. You can " "customize handler creation using a plain function such as::" msgstr "" +"Il arrive de souhaiter personnaliser les gestionnaires de journalisation " +"d’une manière particulière et, en utilisant :func:`dictConfig`, vous pourrez " +"peut-être le faire sans avoir à dériver les classes mères. Par exemple, " +"supposons que vous souhaitiez définir le propriétaire d’un fichier journal. " +"Dans un environnement POSIX, cela se fait facilement en utilisant :func:" +"`shutil.chown`, mais les gestionnaires de fichiers de la bibliothèque " +"standard n’offrent pas cette gestion nativement. Vous pouvez personnaliser " +"la création du gestionnaire à l’aide d’une fonction simple telle que ::" #: howto/logging-cookbook.rst:2400 msgid "" "You can then specify, in a logging configuration passed to :func:" "`dictConfig`, that a logging handler be created by calling this function::" msgstr "" +"Vous pouvez ensuite spécifier, dans une configuration de journalisation " +"transmise à :func:`dictConfig`, qu’un gestionnaire de journalisation soit " +"créé en appelant cette fonction ::" #: howto/logging-cookbook.rst:2433 msgid "" @@ -1624,10 +1875,14 @@ msgid "" "group, just for the purposes of illustration. Putting it together into a " "working script, ``chowntest.py``::" msgstr "" +"Dans cet exemple, nous définissons le propriétaire à l’utilisateur et au " +"groupe ``pulse``, uniquement à des fins d’illustration. Rassemblons le tout " +"dans un script ``chowntest.py`` ::" #: howto/logging-cookbook.rst:2480 msgid "To run this, you will probably need to run as ``root``:" msgstr "" +"Pour l’exécuter, vous devrez probablement le faire en tant que ``root`` :" #: howto/logging-cookbook.rst:2490 msgid "" @@ -1637,16 +1892,25 @@ msgid "" "With pre-3.3 versions, you would need to implement the actual ownership " "change using e.g. :func:`os.chown`." msgstr "" +"Notez que cet exemple utilise Python 3.3 car c’est là que :func:`shutil." +"chown` fait son apparition. Cette approche devrait fonctionner avec " +"n’importe quelle version de Python prenant en charge :func:`dictConfig` – à " +"savoir, Python 2.7, 3.2 ou version ultérieure. Avec les versions antérieures " +"à la 3.3, vous devrez implémenter le changement de propriétaire réel en " +"utilisant par exemple :func:`os.chown`." #: howto/logging-cookbook.rst:2496 msgid "" "In practice, the handler-creating function may be in a utility module " "somewhere in your project. Instead of the line in the configuration::" msgstr "" +"En pratique, la fonction de création de gestionnaire peut être située dans " +"un module utilitaire ailleurs dans votre projet. Au lieu de cette ligne dans " +"la configuration ::" #: howto/logging-cookbook.rst:2501 msgid "you could use e.g.::" -msgstr "" +msgstr "vous pouvez écrire par exemple ::" #: howto/logging-cookbook.rst:2505 msgid "" @@ -1655,6 +1919,11 @@ msgid "" "__main__.owned_file_handler'`` should work. Here, the actual callable is " "resolved by :func:`dictConfig` from the ``ext://`` specification." msgstr "" +"où ``project.util`` peut être remplacé par le nom réel du paquet où réside " +"la fonction. Dans le script étudié ci-dessus, l’utilisation de ``'ext://" +"__main__.owned_file_handler'`` devrait fonctionner. Dans le cas présent, " +"l’appelable réel est résolu par :func:`dictConfig` à partir de la " +"spécification ``ext://``." #: howto/logging-cookbook.rst:2510 msgid "" @@ -1662,6 +1931,9 @@ msgid "" "types of file change - e.g. setting specific POSIX permission bits - in the " "same way, using :func:`os.chmod`." msgstr "" +"Nous espérons qu'à partir de cet exemple vous saurez implémenter d’autres " +"types de modification de fichier – par ex. définir des bits d’autorisation " +"POSIX spécifiques – de la même manière, en utilisant :func:`os.chmod`." #: howto/logging-cookbook.rst:2514 msgid "" @@ -1669,6 +1941,10 @@ msgid "" "than a :class:`~logging.FileHandler` - for example, one of the rotating file " "handlers, or a different type of handler altogether." msgstr "" +"Bien sûr, l’approche pourrait également être étendue à des types de " +"gestionnaires autres qu’un :class:`~logging.FileHandler` – par exemple, l’un " +"des gestionnaires à roulement de fichiers ou un autre type de gestionnaire " +"complètement différent." #: howto/logging-cookbook.rst:2524 msgid "Using particular formatting styles throughout your application"