From abfc2841897adc778e3cab09a35a178c66c3fece Mon Sep 17 00:00:00 2001 From: Antoine Rozo Date: Thu, 31 Oct 2019 17:26:17 +0100 Subject: [PATCH 01/12] Complete library/contextlib.po --- library/contextlib.po | 353 +++++++++++++++++++++++++++++++++++++++--- 1 file changed, 329 insertions(+), 24 deletions(-) diff --git a/library/contextlib.po b/library/contextlib.po index 13d2a9d0b..6d4f27f43 100644 --- a/library/contextlib.po +++ b/library/contextlib.po @@ -6,18 +6,21 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2018-12-21 09:48+0100\n" -"PO-Revision-Date: 2018-07-04 11:33+0200\n" -"Last-Translator: FULL NAME \n" +"PO-Revision-Date: 2019-11-01 17:18+0100\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" +"Last-Translator: \n" +"X-Generator: Poedit 2.2.1\n" #: ../Doc/library/contextlib.rst:2 msgid "" ":mod:`!contextlib` --- Utilities for :keyword:`!with`\\ -statement contexts" msgstr "" +":mod:`!contextlib` — Utilitaires pour les contextes et le mot-clé :keyword:`!" +"with`" #: ../Doc/library/contextlib.rst:7 msgid "**Source code:** :source:`Lib/contextlib.py`" @@ -29,6 +32,9 @@ msgid "" "`with` statement. For more information see also :ref:`typecontextmanager` " "and :ref:`context-managers`." msgstr "" +"Ce module fournit des utilitaires pour les tâches impliquant le mot-clé :" +"keyword:`with`. Pour plus d'informations voir aussi :ref:" +"`typecontextmanager` et :ref:`context-managers`." #: ../Doc/library/contextlib.rst:17 msgid "Utilities" @@ -36,7 +42,7 @@ msgstr "Utilitaires" #: ../Doc/library/contextlib.rst:19 msgid "Functions and classes provided:" -msgstr "" +msgstr "Fonctions et classes fournies :" #: ../Doc/library/contextlib.rst:23 msgid "" @@ -46,6 +52,12 @@ msgid "" "__exit__` is an abstract method which by default returns ``None``. See also " "the definition of :ref:`typecontextmanager`." msgstr "" +"Une :term:`abstract base class` pour les classes qui implémentent les " +"méthodes :meth:`object.__enter__` et :meth:`object.__exit__`. Une " +"implémentation par défaut de :meth:`object.__enter__` est fournie, qui " +"renvoie ``self``, et :meth:`object.__exit__` est une méthode abstraite qui " +"renvoie ``None`` par défaut. Voir aussi la définition de :ref:" +"`typecontextmanager`." #: ../Doc/library/contextlib.rst:34 msgid "" @@ -55,6 +67,12 @@ msgid "" "__aexit__` is an abstract method which by default returns ``None``. See also " "the definition of :ref:`async-context-managers`." msgstr "" +"Une :term:`abstract base class` pour les classes qui implémentent les " +"méthodes :meth:`object.__aenter__` et :meth:`object.__aexit__`. Une " +"implémentation par défaut de :meth:`object.__aenter__` est fournie, qui " +"renvoie ``self``, et :meth:`object.__aexit__` est une méthode abstraite qui " +"renvoie ``None`` par défaut. Voir aussi la définition de :ref:`async-context-" +"managers`." #: ../Doc/library/contextlib.rst:46 msgid "" @@ -62,6 +80,10 @@ msgid "" "function for :keyword:`with` statement context managers, without needing to " "create a class or separate :meth:`__enter__` and :meth:`__exit__` methods." msgstr "" +"Cette fonction est un :term:`decorator` qui peut être utilisé pour définir " +"une fonction fabriquant des gestionnaires de contexte à utiliser avec :" +"keyword:`with`, sans nécessiter de créer une classe ou des méthodes :meth:" +"`__enter__` et :meth:`__exit__` séparées." #: ../Doc/library/contextlib.rst:50 msgid "" @@ -70,12 +92,18 @@ msgid "" "and doesn't implement a ``close()`` method for use with ``contextlib." "closing``" msgstr "" +"Alors que de nombreux objets supportent nativement les instructions *with*, " +"on trouve parfois des ressources qui nécessitent d'être gérées mais ne sont " +"pas des gestionnaires de contextes, et qui n'implémentent pas de méthode " +"``close()``pour pouvoir être utilisées avec ``contextlib.closing``" #: ../Doc/library/contextlib.rst:54 msgid "" "An abstract example would be the following to ensure correct resource " "management::" msgstr "" +"L'exemple abstrait suivant présente comment assurer une gestion correcte des " +"ressources : ::" #: ../Doc/library/contextlib.rst:73 msgid "" @@ -83,6 +111,10 @@ msgid "" "called. This iterator must yield exactly one value, which will be bound to " "the targets in the :keyword:`with` statement's :keyword:`!as` clause, if any." msgstr "" +"La fonction à décorer doit renvoyer un :term:`generator`/itérateur quand " +"elle est appelée. Ce générateur ne doit produire exactement qu'une valeur, " +"qui sera récupérée dans le bloc :keyword:`with` à l'aide de la clause :" +"keyword:`!as` si précisée." #: ../Doc/library/contextlib.rst:77 msgid "" @@ -99,6 +131,18 @@ msgid "" "handled, and execution will resume with the statement immediately following " "the :keyword:`!with` statement." msgstr "" +"Au moment où le générateur produit une valeur, le bloc imbriqué sous le mot-" +"clé :keyword:`with` est exécuté. Le générateur est ensuite repris après la " +"sortie du bloc. Si une exception non gérée survient dans le bloc, elle est " +"relayée dans le générateur au niveau de l'instruction *yield*. Ainsi, vous " +"pouvez utiliser les instructions :keyword:`try`...\\ :keyword:`except`...\\ :" +"keyword:`finally` pour attraper l'erreur (s'il y a), ou vous assurer qu'un " +"nettoyage a bien lieu. Si une exception est attrapée dans l'unique but " +"d'être journalisée ou d'effectuer une action particulière (autre que " +"supprimer entièrement l'exception), le générateur se doit de la relayer. " +"Autrement le générateur gestionnaire de contexte doit indiquer à " +"l'instruction :keyword:`!with` que l'exception a été gérée, et l'exécution " +"reprendra sur l'instruction qui suit directement le bloc :keyword:`!with`." #: ../Doc/library/contextlib.rst:89 msgid "" @@ -110,16 +154,26 @@ msgid "" "that context managers support multiple invocations in order to be used as " "decorators)." msgstr "" +"Le décorateur :func:`contextmanager` utilise la classe :class:" +"`ContextDecorator` afin que les gestionnaires de contexte qu'il crée " +"puissent être utilisés aussi bien en tant que décorateurs qu'avec des " +"instructions :keyword:`with`. Quand utilisé comme décorateur, une nouvelle " +"instance du générateur est créée à chaque appel de la fonction (cela permet " +"aux gestionnaires de contexte à usage unique créés par :func:" +"`contextmanager` de remplir la condition de pouvoir être invoqués plusieurs " +"fois afin d'être utilisés comme décorateurs)." #: ../Doc/library/contextlib.rst:96 msgid "Use of :class:`ContextDecorator`." -msgstr "" +msgstr "Utilisation de la classe :class:`ContextDecorator`." #: ../Doc/library/contextlib.rst:102 msgid "" "Similar to :func:`~contextlib.contextmanager`, but creates an :ref:" "`asynchronous context manager `." msgstr "" +"Similaire à :func:`~contextlib.contextmanager`, mais crée un :ref:" +"`gestionnaire de contexte asynchrone `." #: ../Doc/library/contextlib.rst:105 msgid "" @@ -129,26 +183,35 @@ msgid "" "`__aexit__` methods. It must be applied to an :term:`asynchronous generator` " "function." msgstr "" +"Cette fonction est un :term:`decorator` qui peut être utilisé pour définir " +"une fonction fabriquant des gestionnaires de contexte asynchrones à utiliser " +"avec :keyword:`async with`, sans nécessiter de créer une classe ou des " +"méthodes :meth:`__aenter__` et :meth:`__aexit__` séparées. Le décorateur " +"doit appliqué à une fonction renvoyant un :term:`asynchronous generator`." #: ../Doc/library/contextlib.rst:111 msgid "A simple example::" -msgstr "Un exemple simple ::" +msgstr "Un exemple simple : ::" #: ../Doc/library/contextlib.rst:132 msgid "" "Return a context manager that closes *thing* upon completion of the block. " "This is basically equivalent to::" msgstr "" +"Renvoie un gestionnaire de contexte qui ferme *thing* à la fin du bloc. " +"C'est essentiellement équivalent à : ::" #: ../Doc/library/contextlib.rst:144 msgid "And lets you write code like this::" -msgstr "" +msgstr "Et cela vous permet d'écrire du code tel que : ::" #: ../Doc/library/contextlib.rst:153 msgid "" "without needing to explicitly close ``page``. Even if an error occurs, " "``page.close()`` will be called when the :keyword:`with` block is exited." msgstr "" +"sans besoin de fermer explicitement ``page``. Même si une erreur survient, " +"``page.close()`` sera appelée à la fermeture du bloc :keyword:`with`." #: ../Doc/library/contextlib.rst:161 msgid "" @@ -156,10 +219,13 @@ msgid "" "otherwise does nothing. It is intended to be used as a stand-in for an " "optional context manager, for example::" msgstr "" +"Renvoie un gestionnaire de contexte dont la méthode ``__enter__`` renvoie " +"*enter_result*, mais ne fait rien d'autre. L'idée est de l'utiliser comme " +"remplaçant pour un gestionnaire de contexte optionnel, par exemple : ::" #: ../Doc/library/contextlib.rst:175 msgid "An example using *enter_result*::" -msgstr "" +msgstr "Un exemple utilisant *enter_result* : ::" #: ../Doc/library/contextlib.rst:193 msgid "" @@ -167,6 +233,9 @@ msgid "" "they occur in the body of a with statement and then resumes execution with " "the first statement following the end of the with statement." msgstr "" +"Renvoie un gestionnaire de contexte qui supprime toutes les exceptions " +"spécifiées si elles surviennent dans le corps du bloc *with*, et reprend " +"l'exécution sur la première instruction qui suit la fin du bloc *with*." #: ../Doc/library/contextlib.rst:197 msgid "" @@ -175,31 +244,39 @@ msgid "" "silently continuing with program execution is known to be the right thing to " "do." msgstr "" +"Comme pour tous les mécanismes qui suppriment complètement les exceptions, " +"ce gestionnaire de contexte doit seulement être utilisé pour couvrir des cas " +"très spécifiques d'erreurs où il est certain que continuer silencieusement " +"l'exécution du programme est la bonne chose à faire." #: ../Doc/library/contextlib.rst:202 msgid "For example::" -msgstr "Par exemple ::" +msgstr "Par exemple : ::" #: ../Doc/library/contextlib.rst:212 msgid "This code is equivalent to::" -msgstr "Ce code est équivalent à ::" +msgstr "Ce code est équivalent à : ::" #: ../Doc/library/contextlib.rst:224 ../Doc/library/contextlib.rst:263 #: ../Doc/library/contextlib.rst:273 msgid "This context manager is :ref:`reentrant `." -msgstr "" +msgstr "Ce gestionnaire de contexte est :ref:`réentrant `." #: ../Doc/library/contextlib.rst:231 msgid "" "Context manager for temporarily redirecting :data:`sys.stdout` to another " "file or file-like object." msgstr "" +"Gestionnaire de contexte servant à rediriger temporairement :data:`sys." +"stdout` vers un autre fichier ou objet fichier-compatible." #: ../Doc/library/contextlib.rst:234 msgid "" "This tool adds flexibility to existing functions or classes whose output is " "hardwired to stdout." msgstr "" +"Cet outil ajoute une certaine flexibilité aux fonctions ou classes " +"existantes dans la sortie est envoyée vers la sortie standard." #: ../Doc/library/contextlib.rst:237 msgid "" @@ -207,16 +284,21 @@ msgid "" "You can capture that output in a string by redirecting the output to an :" "class:`io.StringIO` object::" msgstr "" +"Par exemple, la sortie de :func:`help` est normalement envoyée vers *sys." +"stdout*. Vous pouvez capturer cette sortie dans une chaîne de caractères en " +"la redirigeant vers un objet :class:`io.StringIO` : ::" #: ../Doc/library/contextlib.rst:246 msgid "" "To send the output of :func:`help` to a file on disk, redirect the output to " "a regular file::" msgstr "" +"Pour envoyer la sortie de :func:`help` vers un fichier sur le disque, " +"redirigez-la sur un fichier normal : ::" #: ../Doc/library/contextlib.rst:253 msgid "To send the output of :func:`help` to *sys.stderr*::" -msgstr "" +msgstr "Pour envoyer la sortie de :func:`help` sur *sys.stderr* : ::" #: ../Doc/library/contextlib.rst:258 msgid "" @@ -225,17 +307,27 @@ msgid "" "applications. It also has no effect on the output of subprocesses. However, " "it is still a useful approach for many utility scripts." msgstr "" +"Notez que l'effet de bord global sur :data:`sys.stdout` signifie que ce " +"gestionnaire de contexte ne sera pas adapté pour une utilisation dans le " +"code d'une bibliothèque et dans la plupart des applications à plusieurs fils " +"d'exécution. Aussi, cela n'a pas d'effet sur la sortie des sous-processus. " +"Cependant, cela reste une approche utile pour beaucoup de scripts " +"utilitaires." #: ../Doc/library/contextlib.rst:270 msgid "" "Similar to :func:`~contextlib.redirect_stdout` but redirecting :data:`sys." "stderr` to another file or file-like object." msgstr "" +"Similaire à :func:`~contextlib.redirect_stdout` mais redirige :data:`sys." +"stderr` vers un autre fichier ou objet fichier-compatible." #: ../Doc/library/contextlib.rst:280 msgid "" "A base class that enables a context manager to also be used as a decorator." msgstr "" +"Une classe mère qui permet à un gestionnaire de contexte d'être aussi " +"utilisé comme décorateur." #: ../Doc/library/contextlib.rst:282 msgid "" @@ -243,37 +335,50 @@ msgid "" "``__enter__`` and ``__exit__`` as normal. ``__exit__`` retains its optional " "exception handling even when used as a decorator." msgstr "" +"Les gestionnaires de contexte héritant de ``ContextDecorator`` doivent " +"implémenter ``__enter__`` et ``__exit__`` comme habituellement. ``__exit__`` " +"conserve sa gestion optionnelle des exceptions même lors de l'utilisation en " +"décorateur." #: ../Doc/library/contextlib.rst:286 msgid "" "``ContextDecorator`` is used by :func:`contextmanager`, so you get this " "functionality automatically." msgstr "" +"``ContextDecorator`` est utilisé par :func:`contextmanager`, donc vous " +"bénéficiez automatiquement de cette fonctionnalité." #: ../Doc/library/contextlib.rst:289 msgid "Example of ``ContextDecorator``::" -msgstr "" +msgstr "Exemple de ``ContextDecorator`` : ::" #: ../Doc/library/contextlib.rst:318 msgid "" "This change is just syntactic sugar for any construct of the following form::" msgstr "" +"Ce changement est simplement un sucre syntaxique pour les constructions de " +"la forme suivante : ::" #: ../Doc/library/contextlib.rst:324 msgid "``ContextDecorator`` lets you instead write::" -msgstr "" +msgstr "``ContextDecorator`` vous permet d'écrire à la place : ::" #: ../Doc/library/contextlib.rst:330 msgid "" "It makes it clear that the ``cm`` applies to the whole function, rather than " "just a piece of it (and saving an indentation level is nice, too)." msgstr "" +"Cela éclaircit le fait que ``cm`` s'applique à la fonction entière, et pas " +"juste à un morceau en particulier (et gagner un niveau d'indentation est " +"toujours sympa)." #: ../Doc/library/contextlib.rst:333 msgid "" "Existing context managers that already have a base class can be extended by " "using ``ContextDecorator`` as a mixin class::" msgstr "" +"Les gestionnaires de contexte existants qui ont déjà une classe mère peuvent " +"être étendus en utilisant ``ContextDecorator`` comme une *mixin* : ::" #: ../Doc/library/contextlib.rst:346 msgid "" @@ -282,6 +387,11 @@ msgid "" "statements. If this is not the case, then the original construct with the " "explicit :keyword:`!with` statement inside the function should be used." msgstr "" +"Comme la fonction décorée doit être capable d'être appelée plusieurs fois, " +"le gestionnaire de contexte sous-jacent doit permettre d'être utilisé dans " +"de multiples instructions :keyword:`with`. Si ce n'est pas le cas, alors la " +"construction d'origine avec de multiples instructions :keyword:`!with` au " +"sein de la fonction doit être utilisée." #: ../Doc/library/contextlib.rst:356 msgid "" @@ -289,12 +399,18 @@ msgid "" "combine other context managers and cleanup functions, especially those that " "are optional or otherwise driven by input data." msgstr "" +"Un gestionnaire de contexte qui est prévu pour simplifier le fait de " +"combiner programmatiquement d'autres gestionnaires de contexte et fonctions " +"de nettoyage, spécifiquement ceux qui sont optionnels ou pilotés par des " +"données d'entrée." #: ../Doc/library/contextlib.rst:360 msgid "" "For example, a set of files may easily be handled in a single with statement " "as follows::" msgstr "" +"Par exemple, un ensemble de fichiers peut facilement être géré dans une " +"unique instruction *with* comme suit : ::" #: ../Doc/library/contextlib.rst:369 msgid "" @@ -303,6 +419,11 @@ msgid "" "at the end of a :keyword:`with` statement). Note that callbacks are *not* " "invoked implicitly when the context stack instance is garbage collected." msgstr "" +"Chaque instance maintient une pile de *callbacks* enregistrés qui sont " +"appelés en ordre inverse quand l'instance est fermée (explicitement ou " +"implicitement à la fin d'un bloc :keyword:`with`). Notez que ces *callbacks* " +"ne sont *pas* invoqués implicitement quand l'instance de la pile de " +"contextes est collectée par le ramasse-miettes." #: ../Doc/library/contextlib.rst:374 msgid "" @@ -310,6 +431,9 @@ msgid "" "resources in their ``__init__`` method (such as file objects) can be handled " "correctly." msgstr "" +"Ce modèle de pile est utilisé afin que les gestionnaires de contexte qui " +"acquièrent leurs ressources dans leur méthode ``__init__`` (tels que les " +"objets-fichiers) puissent être gérés correctement." #: ../Doc/library/contextlib.rst:378 msgid "" @@ -320,6 +444,12 @@ msgid "" "exception, then outer callbacks will be passed arguments based on that " "updated state." msgstr "" +"Comme les *callbacks* enregistrés sont invoqués dans l'ordre inverse " +"d'enregistrement, cela revient au même que si de multiples blocs :keyword:" +"`with` imbriqués avaient été utilisés avec l'ensemble de *callbacks* " +"enregistrés. Cela s'étend aussi à la gestion d'exceptions - si un *callback* " +"intérieur supprime ou remplace une exception, alors les *callbacks* " +"extérieurs recevront des arguments basés sur ce nouvel état." #: ../Doc/library/contextlib.rst:385 msgid "" @@ -328,6 +458,10 @@ msgid "" "foundation for higher level context managers that manipulate the exit stack " "in application specific ways." msgstr "" +"C'est une *API* relativement bas-niveau qui s'occupe de dérouler " +"correctement la pile des appels de sortie. Elle fournit une base adaptée " +"pour des gestionnaires de contexte de plus haut niveau qui manipulent la " +"pile de sortie de manière spécifique à l'application." #: ../Doc/library/contextlib.rst:394 msgid "" @@ -335,16 +469,24 @@ msgid "" "callback stack. The return value is the result of the context manager's own :" "meth:`__enter__` method." msgstr "" +"Entre dans un nouveau gestionnaire de contexte et ajoute sa méthode :meth:" +"`__exit__`à la pile d'appels. La valeur de retour est le résultat de la " +"méthode :meth:`__enter__` du gestionnaire de contexte donné." #: ../Doc/library/contextlib.rst:398 msgid "" "These context managers may suppress exceptions just as they normally would " "if used directly as part of a :keyword:`with` statement." msgstr "" +"Ces gestionnaires de contexte peuvent supprimer des exceptions comme ils le " +"feraient normalement s'ils étaient utilisés directement derrière une " +"instruction :keyword:`with`." #: ../Doc/library/contextlib.rst:403 msgid "Adds a context manager's :meth:`__exit__` method to the callback stack." msgstr "" +"Ajoute la méthode :meth:`__exit__` d'un gestionnaire de contexte à la pile " +"d'appels." #: ../Doc/library/contextlib.rst:405 msgid "" @@ -352,6 +494,9 @@ msgid "" "an :meth:`__enter__` implementation with a context manager's own :meth:" "`__exit__` method." msgstr "" +"Comme ``__enter__`` n'est *pas* invoquée, cette méthode peut être utilisée " +"pour couvrir une partie de l'implémentation de :meth:`__enter__` avec la " +"propre méthode :meth:`__exit__` d'un gestionnaire de contexte." #: ../Doc/library/contextlib.rst:409 msgid "" @@ -359,36 +504,52 @@ msgid "" "a callback with the same signature as a context manager's :meth:`__exit__` " "method and adds it directly to the callback stack." msgstr "" +"Si l'argument passé n'est pas un gestionnaire de contexte, la méthode assume " +"qu'il s'agit d'un *callback* avec la même signature que la méthode :meth:" +"`__exit__` des gestionnaires de contexte pour l'ajouter directement à la " +"pile d'appels." #: ../Doc/library/contextlib.rst:413 msgid "" "By returning true values, these callbacks can suppress exceptions the same " "way context manager :meth:`__exit__` methods can." msgstr "" +"En retournant des valeurs vraies, ces *callbacks* peuvent supprimer des " +"exceptions de la même manière que le peuvent les méthodes :meth:`__exit__` " +"des gestionnaires de contexte." #: ../Doc/library/contextlib.rst:416 msgid "" "The passed in object is returned from the function, allowing this method to " "be used as a function decorator." msgstr "" +"L'objet passé en paramètre est renvoyé par la fonction, ce qui permet à la " +"méthode d'être utilisée comme décorateur de fonction." #: ../Doc/library/contextlib.rst:421 msgid "" "Accepts an arbitrary callback function and arguments and adds it to the " "callback stack." msgstr "" +"Accepte une fonction arbitraire et ses arguments et les ajoute à la pile " +"d'appels." #: ../Doc/library/contextlib.rst:424 msgid "" "Unlike the other methods, callbacks added this way cannot suppress " "exceptions (as they are never passed the exception details)." msgstr "" +"À la différence des autres méthodes, les *callbacks* ajoutés de cette " +"manière ne peuvent pas supprimer les exceptions (puisqu'ils ne reçoivent " +"jamais les détails de l'exception)." #: ../Doc/library/contextlib.rst:427 msgid "" "The passed in callback is returned from the function, allowing this method " "to be used as a function decorator." msgstr "" +"Le *callback* passé en paramètre est renvoyé par la fonction, ce qui permet " +"à la méthode d'être utilisée comme décorateur de fonction." #: ../Doc/library/contextlib.rst:432 msgid "" @@ -397,12 +558,18 @@ msgid "" "now be invoked when the new stack is closed (either explicitly or implicitly " "at the end of a :keyword:`with` statement)." msgstr "" +"Transfère la pile d'appels à une nouvelle instance de :class:`ExitStack` et " +"la renvoie. Aucun *callback* n'est invoqué par cette opération - à la place, " +"ils seront maintenant invoqués quand la nouvelle pile sera close (soit " +"explicitement soit implicitement à la fin d'un bloc :keyword:`with`)." #: ../Doc/library/contextlib.rst:437 msgid "" "For example, a group of files can be opened as an \"all or nothing\" " "operation as follows::" msgstr "" +"Par exemple, un groupe de fichiers peut être ouvert comme une opération " +"« tout ou rien » comme suit : ::" #: ../Doc/library/contextlib.rst:451 msgid "" @@ -410,6 +577,10 @@ msgid "" "order of registration. For any context managers and exit callbacks " "registered, the arguments passed in will indicate that no exception occurred." msgstr "" +"Déroule immédiatement la pile d'appels, invoquant les *callbacks* dans " +"l'ordre inverse d'enregistrement. Pour chaque gestionnaire de contexte et " +"*callback* de sortie enregistré, les arguments passés indiqueront qu'aucune " +"exception n'est survenue." #: ../Doc/library/contextlib.rst:458 msgid "" @@ -417,49 +588,62 @@ msgid "" "class:`ExitStack`, that supports combining both synchronous and asynchronous " "context managers, as well as having coroutines for cleanup logic." msgstr "" +"Un :ref:`gestionnaire de contexte asynchrone `, " +"similaire à :class:`ExitStack`, qui supporte le fait de combiner à la fois " +"des gestionnaires de contexte synchrones et asynchrones, ainsi que la " +"gestion de coroutines pour la logique de nettoyage." #: ../Doc/library/contextlib.rst:463 msgid "" "The :meth:`close` method is not implemented, :meth:`aclose` must be used " "instead." msgstr "" +"La méthode :meth:`close` n'est pas implémentée, :meth:`aclose` doit plutôt " +"être utilisée." #: ../Doc/library/contextlib.rst:468 msgid "" "Similar to :meth:`enter_context` but expects an asynchronous context manager." msgstr "" +"Similaire à :meth:`enter_context` mais attend un gestionnaire de contexte " +"asynchrone." #: ../Doc/library/contextlib.rst:473 msgid "" "Similar to :meth:`push` but expects either an asynchronous context manager " "or a coroutine function." msgstr "" +"Similaire à :meth:`push` mais attend soit un gestionnaire de contexte " +"asynchrone soit une fonction coroutine." #: ../Doc/library/contextlib.rst:478 msgid "Similar to :meth:`callback` but expects a coroutine function." -msgstr "" +msgstr "Similaire à :meth:`callback` mais attend une fonction coroutine." #: ../Doc/library/contextlib.rst:482 msgid "Similar to :meth:`close` but properly handles awaitables." msgstr "" +"Similaire à :meth:`close` mais gère correctement les tâches asynchrones." #: ../Doc/library/contextlib.rst:484 msgid "Continuing the example for :func:`asynccontextmanager`::" -msgstr "" +msgstr "En continuité de l'exemple de :func:`asynccontextmanager` : ::" #: ../Doc/library/contextlib.rst:496 msgid "Examples and Recipes" -msgstr "" +msgstr "Exemples et Recettes" #: ../Doc/library/contextlib.rst:498 msgid "" "This section describes some examples and recipes for making effective use of " "the tools provided by :mod:`contextlib`." msgstr "" +"Cette section décrit quelques exemples et recettes pour décrire une " +"utilisation réelle des outils fournis par :mod:`contextlib`." #: ../Doc/library/contextlib.rst:503 msgid "Supporting a variable number of context managers" -msgstr "" +msgstr "Gérer une nombre variable de gestionnaires de contexte" #: ../Doc/library/contextlib.rst:505 msgid "" @@ -470,6 +654,13 @@ msgid "" "input (such as opening a user specified collection of files), or from some " "of the context managers being optional::" msgstr "" +"Le cas d'utilisation primaire de :class:`ExitStack` est celui décrit dans la " +"documentation de la classe : supporter un nombre variable de gestionnaires " +"de contexte et d'autres opérations de nettoyage en une unique instruction :" +"keyword:`with`. La variabilité peut venir du nombre de gestionnaires de " +"contexte voulus découlant d'une entrée utilisateur (comme ouvrir une " +"collection spécifique de fichiers de l'utilisateur), ou de certains " +"gestionnaires de contexte qui peuvent être optionnels : ::" #: ../Doc/library/contextlib.rst:520 msgid "" @@ -477,10 +668,13 @@ msgid "" "statements to manage arbitrary resources that don't natively support the " "context management protocol." msgstr "" +"Comme montré, :class:`ExitStack` rend aussi assez facile d'utiliser les " +"instructions :keyword:`with` pour gérer des ressources arbitraires qui ne " +"supportent pas nativement le protocole des gestionnaires de contexte." #: ../Doc/library/contextlib.rst:526 msgid "Catching exceptions from ``__enter__`` methods" -msgstr "" +msgstr "Attraper des exceptions depuis les méthodes ``__enter__``" #: ../Doc/library/contextlib.rst:528 msgid "" @@ -490,6 +684,12 @@ msgid "" "By using :class:`ExitStack` the steps in the context management protocol can " "be separated slightly in order to allow this::" msgstr "" +"Il est occasionnellement souhaitable d'attraper les exceptions depuis " +"l'implémentation d'une méthode ``__enter__``, *sans* attraper par " +"inadvertance les exceptions du corps de l'instruction :keyword:`with` ou de " +"la méthode ``__exit__`` des gestionnaires de contexte. En utilisant :class:" +"`ExitStack`, les étapes du protocole des gestionnaires de contexte peuvent " +"être légèrement séparées pour permettre le code suivant : ::" #: ../Doc/library/contextlib.rst:543 msgid "" @@ -501,10 +701,18 @@ msgid "" "to handle various situations that can't be handled directly in a :keyword:" "`with` statement." msgstr "" +"Avoir à faire cela est en fait surtout utile pour indiquer que l'*API* sous-" +"jacente devrait founir une interface directe de gestion des ressources à " +"utiliser avec les instructions :keyword:`try`/:keyword:`except`/:keyword:" +"`finally`, mais que toutes les *API* ne sont pas bien conçues dans cet " +"objectif. Quand un gestionnaire de contexte est la seule *API* de gestion " +"des ressources fournie, alors :class:`ExitStack` peut rendre plus facile la " +"gestion de plusieurs situations qui ne peuvent pas être traitées directement " +"dans une instruction :keyword:`with`." #: ../Doc/library/contextlib.rst:553 msgid "Cleaning up in an ``__enter__`` implementation" -msgstr "" +msgstr "Nettoyer dans une méthode ``__enter__``" #: ../Doc/library/contextlib.rst:555 msgid "" @@ -512,6 +720,9 @@ msgid "" "useful in cleaning up an already allocated resource if later steps in the :" "meth:`__enter__` implementation fail." msgstr "" +"Comme indiqué dans la documentation de :meth:`ExitStack.push`, cette méthode " +"peut être utile pour nettoyer une ressource déjà allouée si les dernières " +"étapes de l'implémentation de :meth:`__enter__` échouent." #: ../Doc/library/contextlib.rst:559 msgid "" @@ -519,10 +730,14 @@ msgid "" "acquisition and release functions, along with an optional validation " "function, and maps them to the context management protocol::" msgstr "" +"Voici un exemple de gestionnaire de contexte qui reçoit des fonctions " +"d'acquisition de ressources et de libération, avec une méthode de validation " +"optionnelle, et qui les adapte au protocole des gestionnaires de " +"contexte : ::" #: ../Doc/library/contextlib.rst:599 msgid "Replacing any use of ``try-finally`` and flag variables" -msgstr "" +msgstr "Remplacer un ``try-finally`` avec une option variable" #: ../Doc/library/contextlib.rst:601 msgid "" @@ -531,6 +746,10 @@ msgid "" "should be executed. In its simplest form (that can't already be handled just " "by using an ``except`` clause instead), it looks something like this::" msgstr "" +"Un modèle que vous rencontrerez parfois est un bloc ``try-finally`` avec une " +"option pour indiquer si le corps de la clause ``finally`` doit être exécuté " +"ou non. Dans sa forme la plus simple (qui ne peut pas déjà être gérée avec " +"juste une clause ``except``), cela ressemble à : ::" #: ../Doc/library/contextlib.rst:615 msgid "" @@ -538,6 +757,10 @@ msgid "" "development and review, because the setup code and the cleanup code can end " "up being separated by arbitrarily long sections of code." msgstr "" +"Comme avec n'importe quel code basé sur une instruction ``try``, cela peut " +"poser problème pour le développement et la revue, parce que beaucoup de " +"codes d'installation et de nettoyage peuvent finir par être séparés par des " +"sections de code arbitrairement longues." #: ../Doc/library/contextlib.rst:619 msgid "" @@ -545,18 +768,25 @@ msgid "" "execution at the end of a ``with`` statement, and then later decide to skip " "executing that callback::" msgstr "" +":class:`ExitStack` rend possible d'enregistrer un *callback* pour " +"l'exécution à la fin d'une instruction ``with``, et décider ensuite de " +"passer l'exécution de cet appel : ::" #: ../Doc/library/contextlib.rst:631 msgid "" "This allows the intended cleanup up behaviour to be made explicit up front, " "rather than requiring a separate flag variable." msgstr "" +"Cela permet de rendre explicite dès le départ le comportement de nettoyage " +"attendu, plutôt que de nécessiter une option séparée." #: ../Doc/library/contextlib.rst:634 msgid "" "If a particular application uses this pattern a lot, it can be simplified " "even further by means of a small helper class::" msgstr "" +"Si une application particulière utilise beaucoup ce modèle, cela peut-être " +"simplifié encore plus au moyen d'une petite classe d'aide : ::" #: ../Doc/library/contextlib.rst:652 msgid "" @@ -564,6 +794,10 @@ msgid "" "function, then it is still possible to use the decorator form of :meth:" "`ExitStack.callback` to declare the resource cleanup in advance::" msgstr "" +"Si le nettoyage de la ressource n'est pas déjà soigneusement embarqué dans " +"une fonction autonome, il est possible d'utiliser le décorateur :meth:" +"`ExitStack.callback` pour déclarer la fonction de nettoyage de ressource en " +"avance : ::" #: ../Doc/library/contextlib.rst:667 msgid "" @@ -571,16 +805,24 @@ msgid "" "this way cannot take any parameters. Instead, any resources to be released " "must be accessed as closure variables." msgstr "" +"Dû au fonctionnement du protocole des décorateurs, une fonction déclarée " +"ainsi ne peut prendre aucun paramètre. À la place, les ressources à libérer " +"doivent être récupérées depuis l'extérieur comme des variables de fermeture " +"(*closure*)." #: ../Doc/library/contextlib.rst:673 msgid "Using a context manager as a function decorator" msgstr "" +"Utiliser un gestionnaire de contexte en tant que décorateur de fonction" #: ../Doc/library/contextlib.rst:675 msgid "" ":class:`ContextDecorator` makes it possible to use a context manager in both " "an ordinary ``with`` statement and also as a function decorator." msgstr "" +":class:`ContextDecorator` rend possible l'utilisation d'un gestionnaire de " +"contexte à la fois ordinairement avec une instruction ``with`` ou comme un " +"décorateur de fonction." #: ../Doc/library/contextlib.rst:678 msgid "" @@ -590,14 +832,22 @@ msgid "" "task, inheriting from :class:`ContextDecorator` provides both capabilities " "in a single definition::" msgstr "" +"Par exemple, il est parfois utile d'emballer les fonctions ou blocs " +"d'instructions avec un journaliseur qui pourrait suivre le temps d'exécution " +"entre l'entrée et la sortie. Plutôt qu'écrire à la fois un décorateur et un " +"gestionnaire de contexte pour la même tâche, hériter de :class:" +"`ContextDecorator` fournit les deux fonctionnalités en une seule " +"définition : ::" #: ../Doc/library/contextlib.rst:699 msgid "Instances of this class can be used as both a context manager::" msgstr "" +"Les instances de cette classe peuvent être utilisées comme gestionnaires de " +"contexte : ::" #: ../Doc/library/contextlib.rst:705 msgid "And also as a function decorator::" -msgstr "" +msgstr "Et comme décorateurs de fonctions : ::" #: ../Doc/library/contextlib.rst:712 msgid "" @@ -606,6 +856,10 @@ msgid "" "`__enter__`. If that value is needed, then it is still necessary to use an " "explicit ``with`` statement." msgstr "" +"Notez qu'il y a une autre limitation en utilisant les gestionnaires de " +"contexte comme décorateurs : il n'y a aucune manière d'accéder à la valeur " +"de retour de :meth:`__enter__`. Si cette valeur est nécessaire, il faut " +"utiliser explicitement une instruction ``with``." #: ../Doc/library/contextlib.rst:720 msgid ":pep:`343` - The \"with\" statement" @@ -621,7 +875,7 @@ msgstr "" #: ../Doc/library/contextlib.rst:726 msgid "Single use, reusable and reentrant context managers" -msgstr "" +msgstr "Gestionnaires de contexte à usage unique, réutilisables et réentrants" #: ../Doc/library/contextlib.rst:728 msgid "" @@ -630,6 +884,11 @@ msgid "" "managers must be created afresh each time they're used - attempting to use " "them a second time will trigger an exception or otherwise not work correctly." msgstr "" +"La plupart des gestionnaires de contexte sont écrits d'une manière qui ne " +"leur permet que d'être utilisés une fois avec une instruction :keyword:" +"`with`. Ces gestionnaires de contexte à usage unique doivent être recréés " +"chaque fois qu'ils sont utilisés - tenter de les utiliser une seconde fois " +"lancera une exception ou ne fonctionnera pas correctement." #: ../Doc/library/contextlib.rst:734 msgid "" @@ -637,6 +896,10 @@ msgid "" "context managers directly in the header of the :keyword:`with` statement " "where they are used (as shown in all of the usage examples above)." msgstr "" +"Cette limitation commune signifie qu'il est généralement conseillé de créer " +"les gestionnaires de contexte directement dans l'en-tête du bloc :keyword:" +"`with` où ils sont utilisés (comme montré dans tous les exemples " +"d'utilisation au-dessus)." #: ../Doc/library/contextlib.rst:738 msgid "" @@ -644,6 +907,10 @@ msgid "" "first :keyword:`with` statement will close the file, preventing any further " "IO operations using that file object." msgstr "" +"Les fichiers sont un exemple de gestionnaires de contexte étant " +"effectivement à usage unique, puisque la première instruction :keyword:" +"`with` ferme le fichier, empêchant d'autres opérations d'entrée/sortie " +"d'être exécutées sur ce fichier." #: ../Doc/library/contextlib.rst:742 msgid "" @@ -651,10 +918,13 @@ msgid "" "context managers, and will complain about the underlying generator failing " "to yield if an attempt is made to use them a second time::" msgstr "" +"Les gestionnaires de contexte créés avec :func:`contextmanager` sont aussi à " +"usage unique, et se plaindront du fait que le générateur sous-jacent ne " +"produise plus de valeur si vous essayez de les utiliser une seconde fois : ::" #: ../Doc/library/contextlib.rst:770 msgid "Reentrant context managers" -msgstr "" +msgstr "Gestionnaires de contexte réentrants" #: ../Doc/library/contextlib.rst:772 msgid "" @@ -663,6 +933,11 @@ msgid "" "may also be used *inside* a :keyword:`!with` statement that is already using " "the same context manager." msgstr "" +"Certains gestionnaires de contexte plus sophistiqués peuvent être " +"« réentrants ». Ces gestionnaires de contexte ne peuvent pas seulement être " +"utilisés avec plusieurs instructions :keyword:`with`, mais aussi *à " +"l'intérieur* d'une instruction :keyword:`with` qui utilise déjà ce même " +"gestionnaire de contexte." #: ../Doc/library/contextlib.rst:777 msgid "" @@ -670,6 +945,9 @@ msgid "" "are :func:`suppress` and :func:`redirect_stdout`. Here's a very simple " "example of reentrant use::" msgstr "" +":class:`threading.RLock` est un exemple de gestionnaire de contexte " +"réentrant, comme le sont aussi :func:`suppress` et :func:`redirect_stdout`. " +"Voici un très simple exemple d'utilisation réentrante : ::" #: ../Doc/library/contextlib.rst:796 msgid "" @@ -677,6 +955,9 @@ msgid "" "functions calling each other and hence be far more complicated than this " "example." msgstr "" +"Les exemples plus réels de réentrance sont susceptibles d'invoquer plusieurs " +"fonctions s'entre-appelant, et donc être bien plus compliqués que cet " +"exemple." #: ../Doc/library/contextlib.rst:800 msgid "" @@ -685,10 +966,14 @@ msgid "" "as it makes a global modification to the system state by binding :data:`sys." "stdout` to a different stream." msgstr "" +"Notez aussi qu'être réentrant ne signifie *pas* être *thread safe*. :func:" +"`redirect_stdout`, par exemple, n'est définitivement pas *thread safe*, " +"puisqu'il effectue des changements globaux sur l'état du système en " +"branchant :data:`sys.stdout` sur différents flux." #: ../Doc/library/contextlib.rst:809 msgid "Reusable context managers" -msgstr "" +msgstr "Gestionnaires de contexte réutilisables" #: ../Doc/library/contextlib.rst:811 msgid "" @@ -699,6 +984,13 @@ msgid "" "will fail (or otherwise not work correctly) if the specific context manager " "instance has already been used in a containing with statement." msgstr "" +"D'autres gestionnaires de contexte que ceux à usage unique et les réentrants " +"sont les gestionnaires de contexte « réutilisables » (ou, pour être plus " +"explicite, « réutilisables mais pas réentrants », puisque les gestionnaires " +"de contexte réentrants sont aussi réutilisables). Ces gestionnaires de " +"contexte supportent le fait d'être utilisés plusieurs fois, mais échoueront " +"(ou ne fonctionneront pas correctement) si le gestionnaire de contexte en " +"particulier a déjà été utilisé dans une instruction *with* englobante." #: ../Doc/library/contextlib.rst:818 msgid "" @@ -706,6 +998,9 @@ msgid "" "context manager (for a reentrant lock, it is necessary to use :class:" "`threading.RLock` instead)." msgstr "" +":class:`threading.Lock` est un exemple de gestionnaire de contexte " +"réutilisable mais pas réentrant (pour un verrou réentrant, il faut à la " +"place utiliser :class:`threading.RLock`)." #: ../Doc/library/contextlib.rst:822 msgid "" @@ -713,6 +1008,10 @@ msgid "" "`ExitStack`, as it invokes *all* currently registered callbacks when leaving " "any with statement, regardless of where those callbacks were added::" msgstr "" +"Un autre exemple de gestionnaire de contexte réutilisable mais pas réentrant " +"est :class:`ExitStack`, puisqu'il invoque *tous* les *callbacks* " +"actuellement enregistrés en quittant l'instruction *with*, sans regarder où " +"ces *callbacks* ont été ajoutés : ::" #: ../Doc/library/contextlib.rst:853 msgid "" @@ -721,9 +1020,15 @@ msgid "" "cause the stack to be cleared at the end of the innermost with statement, " "which is unlikely to be desirable behaviour." msgstr "" +"Comme le montre la sortie de l'exemple, réutiliser une simple pile entre " +"plusieurs instructions *with* fonctionne correctement, mais essayer de les " +"imbriquer fera que la pile sera vidée à la fin du *with* le plus imbriqué, " +"ce qui n'est probablement pas le comportement voulu." #: ../Doc/library/contextlib.rst:858 msgid "" "Using separate :class:`ExitStack` instances instead of reusing a single " "instance avoids that problem::" msgstr "" +"Pour éviter ce problème, utilisez des instances différentes de :class:" +"`ExitStack` plutôt qu'une seule instance : ::" From cec1bfefe1c319a17449572dbbc10083996050ab Mon Sep 17 00:00:00 2001 From: Antoine Rozo Date: Fri, 1 Nov 2019 20:54:13 +0100 Subject: [PATCH 02/12] fixup! Complete library/contextlib.po --- library/contextlib.po | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/library/contextlib.po b/library/contextlib.po index 6d4f27f43..8ca53a14c 100644 --- a/library/contextlib.po +++ b/library/contextlib.po @@ -6,7 +6,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2018-12-21 09:48+0100\n" -"PO-Revision-Date: 2019-11-01 17:18+0100\n" +"PO-Revision-Date: 2019-11-01 20:53+0100\n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" @@ -447,7 +447,7 @@ msgstr "" "Comme les *callbacks* enregistrés sont invoqués dans l'ordre inverse " "d'enregistrement, cela revient au même que si de multiples blocs :keyword:" "`with` imbriqués avaient été utilisés avec l'ensemble de *callbacks* " -"enregistrés. Cela s'étend aussi à la gestion d'exceptions - si un *callback* " +"enregistrés. Cela s'étend aussi à la gestion d'exceptions — si un *callback* " "intérieur supprime ou remplace une exception, alors les *callbacks* " "extérieurs recevront des arguments basés sur ce nouvel état." @@ -559,7 +559,7 @@ msgid "" "at the end of a :keyword:`with` statement)." msgstr "" "Transfère la pile d'appels à une nouvelle instance de :class:`ExitStack` et " -"la renvoie. Aucun *callback* n'est invoqué par cette opération - à la place, " +"la renvoie. Aucun *callback* n'est invoqué par cette opération — à la place, " "ils seront maintenant invoqués quand la nouvelle pile sera close (soit " "explicitement soit implicitement à la fin d'un bloc :keyword:`with`)." @@ -702,7 +702,7 @@ msgid "" "`with` statement." msgstr "" "Avoir à faire cela est en fait surtout utile pour indiquer que l'*API* sous-" -"jacente devrait founir une interface directe de gestion des ressources à " +"jacente devrait fournir une interface directe de gestion des ressources à " "utiliser avec les instructions :keyword:`try`/:keyword:`except`/:keyword:" "`finally`, mais que toutes les *API* ne sont pas bien conçues dans cet " "objectif. Quand un gestionnaire de contexte est la seule *API* de gestion " @@ -887,7 +887,7 @@ msgstr "" "La plupart des gestionnaires de contexte sont écrits d'une manière qui ne " "leur permet que d'être utilisés une fois avec une instruction :keyword:" "`with`. Ces gestionnaires de contexte à usage unique doivent être recréés " -"chaque fois qu'ils sont utilisés - tenter de les utiliser une seconde fois " +"chaque fois qu'ils sont utilisés — tenter de les utiliser une seconde fois " "lancera une exception ou ne fonctionnera pas correctement." #: ../Doc/library/contextlib.rst:734 From 89e48a7de96e01f6d8b7874ca78ce5e216faf01c Mon Sep 17 00:00:00 2001 From: Antoine Rozo Date: Fri, 1 Nov 2019 20:54:34 +0100 Subject: [PATCH 03/12] =?UTF-8?q?Add=20r=C3=A9entrant=C2=B7e=20to=20dict?= =?UTF-8?q?=20file?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- dict | 2 ++ 1 file changed, 2 insertions(+) diff --git a/dict b/dict index 121eefedd..390c38b43 100644 --- a/dict +++ b/dict @@ -109,6 +109,8 @@ Pylint PythonWin recompilation Reedy +réentrant +réentrante réentrants réessayable réexécuter From 00638069f9f319f486e55b6e742d4e962f46ed93 Mon Sep 17 00:00:00 2001 From: Antoine Rozo Date: Wed, 6 Nov 2019 09:38:47 -0500 Subject: [PATCH 04/12] fixup! Complete library/contextlib.po --- library/contextlib.po | 146 +++++++++++++++++++++--------------------- 1 file changed, 74 insertions(+), 72 deletions(-) diff --git a/library/contextlib.po b/library/contextlib.po index 8ca53a14c..dc49cd499 100644 --- a/library/contextlib.po +++ b/library/contextlib.po @@ -6,7 +6,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2018-12-21 09:48+0100\n" -"PO-Revision-Date: 2019-11-01 20:53+0100\n" +"PO-Revision-Date: 2019-11-06 09:39-0500\n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" @@ -19,8 +19,8 @@ msgstr "" msgid "" ":mod:`!contextlib` --- Utilities for :keyword:`!with`\\ -statement contexts" msgstr "" -":mod:`!contextlib` — Utilitaires pour les contextes et le mot-clé :keyword:`!" -"with`" +":mod:`!contextlib` — Utilitaires pour les contextes s'appuyant sur " +"l'instruction :keyword:`!with`" #: ../Doc/library/contextlib.rst:7 msgid "**Source code:** :source:`Lib/contextlib.py`" @@ -52,11 +52,11 @@ msgid "" "__exit__` is an abstract method which by default returns ``None``. See also " "the definition of :ref:`typecontextmanager`." msgstr "" -"Une :term:`abstract base class` pour les classes qui implémentent les " -"méthodes :meth:`object.__enter__` et :meth:`object.__exit__`. Une " -"implémentation par défaut de :meth:`object.__enter__` est fournie, qui " -"renvoie ``self``, et :meth:`object.__exit__` est une méthode abstraite qui " -"renvoie ``None`` par défaut. Voir aussi la définition de :ref:" +":term:`Classe mère abstraite ` pour les classes qui " +"implémentent les méthodes :meth:`object.__enter__` et :meth:`object." +"__exit__`. Une implémentation par défaut de :meth:`object.__enter__` est " +"fournie, qui renvoie ``self``, et :meth:`object.__exit__` est une méthode " +"abstraite qui renvoie ``None`` par défaut. Voir aussi la définition de :ref:" "`typecontextmanager`." #: ../Doc/library/contextlib.rst:34 @@ -67,12 +67,12 @@ msgid "" "__aexit__` is an abstract method which by default returns ``None``. See also " "the definition of :ref:`async-context-managers`." msgstr "" -"Une :term:`abstract base class` pour les classes qui implémentent les " -"méthodes :meth:`object.__aenter__` et :meth:`object.__aexit__`. Une " -"implémentation par défaut de :meth:`object.__aenter__` est fournie, qui " -"renvoie ``self``, et :meth:`object.__aexit__` est une méthode abstraite qui " -"renvoie ``None`` par défaut. Voir aussi la définition de :ref:`async-context-" -"managers`." +":term:`Classe mère abstraite ` pour les classes qui " +"implémentent les méthodes :meth:`object.__aenter__` et :meth:`object." +"__aexit__`. Une implémentation par défaut de :meth:`object.__aenter__` est " +"fournie, qui renvoie ``self``, et :meth:`object.__aexit__` est une méthode " +"abstraite qui renvoie ``None`` par défaut. Voir aussi la définition de :ref:" +"`async-context-managers`." #: ../Doc/library/contextlib.rst:46 msgid "" @@ -92,7 +92,7 @@ msgid "" "and doesn't implement a ``close()`` method for use with ``contextlib." "closing``" msgstr "" -"Alors que de nombreux objets supportent nativement les instructions *with*, " +"Alors que de nombreux objets s'utilisent nativement dans des blocs *with*, " "on trouve parfois des ressources qui nécessitent d'être gérées mais ne sont " "pas des gestionnaires de contextes, et qui n'implémentent pas de méthode " "``close()``pour pouvoir être utilisées avec ``contextlib.closing``" @@ -112,9 +112,9 @@ msgid "" "the targets in the :keyword:`with` statement's :keyword:`!as` clause, if any." msgstr "" "La fonction à décorer doit renvoyer un :term:`generator`/itérateur quand " -"elle est appelée. Ce générateur ne doit produire exactement qu'une valeur, " -"qui sera récupérée dans le bloc :keyword:`with` à l'aide de la clause :" -"keyword:`!as` si précisée." +"elle est appelée. Ce générateur ne doit produire qu'une seule valeur, qui " +"sera récupérée dans le bloc :keyword:`with` à l'aide de la clause :keyword:`!" +"as` si précisée." #: ../Doc/library/contextlib.rst:77 msgid "" @@ -131,18 +131,18 @@ msgid "" "handled, and execution will resume with the statement immediately following " "the :keyword:`!with` statement." msgstr "" -"Au moment où le générateur produit une valeur, le bloc imbriqué sous le mot-" -"clé :keyword:`with` est exécuté. Le générateur est ensuite repris après la " -"sortie du bloc. Si une exception non gérée survient dans le bloc, elle est " -"relayée dans le générateur au niveau de l'instruction *yield*. Ainsi, vous " -"pouvez utiliser les instructions :keyword:`try`...\\ :keyword:`except`...\\ :" -"keyword:`finally` pour attraper l'erreur (s'il y a), ou vous assurer qu'un " -"nettoyage a bien lieu. Si une exception est attrapée dans l'unique but " -"d'être journalisée ou d'effectuer une action particulière (autre que " -"supprimer entièrement l'exception), le générateur se doit de la relayer. " -"Autrement le générateur gestionnaire de contexte doit indiquer à " +"Au moment où le générateur produit une valeur, le bloc imbriqué sous " +"l'instruction :keyword:`with` est exécuté. Le générateur est ensuite repris " +"après la sortie du bloc. Si une exception non gérée survient dans le bloc, " +"elle est relayée dans le générateur au niveau de l'instruction *yield*. " +"Ainsi, vous pouvez utiliser les instructions :keyword:`try`...\\ :keyword:" +"`except`...\\ :keyword:`finally` pour attraper l'erreur (s'il y a), ou vous " +"assurer qu'un nettoyage a bien lieu. Si une exception est attrapée dans " +"l'unique but d'être journalisée ou d'effectuer une action particulière " +"(autre que supprimer entièrement l'exception), le générateur se doit de la " +"relayer. Autrement le générateur gestionnaire de contexte doit indiquer à " "l'instruction :keyword:`!with` que l'exception a été gérée, et l'exécution " -"reprendra sur l'instruction qui suit directement le bloc :keyword:`!with`." +"reprend sur l'instruction qui suit directement le bloc :keyword:`!with`." #: ../Doc/library/contextlib.rst:89 msgid "" @@ -157,9 +157,9 @@ msgstr "" "Le décorateur :func:`contextmanager` utilise la classe :class:" "`ContextDecorator` afin que les gestionnaires de contexte qu'il crée " "puissent être utilisés aussi bien en tant que décorateurs qu'avec des " -"instructions :keyword:`with`. Quand utilisé comme décorateur, une nouvelle " -"instance du générateur est créée à chaque appel de la fonction (cela permet " -"aux gestionnaires de contexte à usage unique créés par :func:" +"instructions :keyword:`with`. Quand vous l'utilisez comme décorateur, une " +"nouvelle instance du générateur est créée à chaque appel de la fonction " +"(cela permet aux gestionnaires de contexte à usage unique créés par :func:" "`contextmanager` de remplir la condition de pouvoir être invoqués plusieurs " "fois afin d'être utilisés comme décorateurs)." @@ -187,7 +187,8 @@ msgstr "" "une fonction fabriquant des gestionnaires de contexte asynchrones à utiliser " "avec :keyword:`async with`, sans nécessiter de créer une classe ou des " "méthodes :meth:`__aenter__` et :meth:`__aexit__` séparées. Le décorateur " -"doit appliqué à une fonction renvoyant un :term:`asynchronous generator`." +"doit être appliqué à une fonction renvoyant un :term:`asynchronous " +"generator`." #: ../Doc/library/contextlib.rst:111 msgid "A simple example::" @@ -211,7 +212,7 @@ msgid "" "``page.close()`` will be called when the :keyword:`with` block is exited." msgstr "" "sans besoin de fermer explicitement ``page``. Même si une erreur survient, " -"``page.close()`` sera appelée à la fermeture du bloc :keyword:`with`." +"``page.close()`` est appelée à la fermeture du bloc :keyword:`with`." #: ../Doc/library/contextlib.rst:161 msgid "" @@ -276,7 +277,7 @@ msgid "" "hardwired to stdout." msgstr "" "Cet outil ajoute une certaine flexibilité aux fonctions ou classes " -"existantes dans la sortie est envoyée vers la sortie standard." +"existantes dont la sortie est envoyée vers la sortie standard." #: ../Doc/library/contextlib.rst:237 msgid "" @@ -308,8 +309,8 @@ msgid "" "it is still a useful approach for many utility scripts." msgstr "" "Notez que l'effet de bord global sur :data:`sys.stdout` signifie que ce " -"gestionnaire de contexte ne sera pas adapté pour une utilisation dans le " -"code d'une bibliothèque et dans la plupart des applications à plusieurs fils " +"gestionnaire de contexte n'est pas adapté à une utilisation dans le code " +"d'une bibliothèque ni dans la plupart des applications à plusieurs fils " "d'exécution. Aussi, cela n'a pas d'effet sur la sortie des sous-processus. " "Cependant, cela reste une approche utile pour beaucoup de scripts " "utilitaires." @@ -399,9 +400,9 @@ msgid "" "combine other context managers and cleanup functions, especially those that " "are optional or otherwise driven by input data." msgstr "" -"Un gestionnaire de contexte qui est prévu pour simplifier le fait de " -"combiner programmatiquement d'autres gestionnaires de contexte et fonctions " -"de nettoyage, spécifiquement ceux qui sont optionnels ou pilotés par des " +"Gestionnaire de contexte conçu pour simplifier le fait de combiner " +"programmatiquement d'autres gestionnaires de contexte et fonctions de " +"nettoyage, spécifiquement ceux qui sont optionnels ou pilotés par des " "données d'entrée." #: ../Doc/library/contextlib.rst:360 @@ -419,11 +420,11 @@ msgid "" "at the end of a :keyword:`with` statement). Note that callbacks are *not* " "invoked implicitly when the context stack instance is garbage collected." msgstr "" -"Chaque instance maintient une pile de *callbacks* enregistrés qui sont " -"appelés en ordre inverse quand l'instance est fermée (explicitement ou " -"implicitement à la fin d'un bloc :keyword:`with`). Notez que ces *callbacks* " -"ne sont *pas* invoqués implicitement quand l'instance de la pile de " -"contextes est collectée par le ramasse-miettes." +"Chaque instance maintient une pile de fonctions de rappels (*callbacks*) " +"enregistrées qui sont appelées en ordre inverse quand l'instance est fermée " +"(explicitement ou implicitement à la fin d'un bloc :keyword:`with`). Notez " +"que ces fonctions ne sont *pas* invoquées implicitement quand l'instance de " +"la pile de contextes est collectée par le ramasse-miettes." #: ../Doc/library/contextlib.rst:374 msgid "" @@ -444,12 +445,12 @@ msgid "" "exception, then outer callbacks will be passed arguments based on that " "updated state." msgstr "" -"Comme les *callbacks* enregistrés sont invoqués dans l'ordre inverse " -"d'enregistrement, cela revient au même que si de multiples blocs :keyword:" -"`with` imbriqués avaient été utilisés avec l'ensemble de *callbacks* " -"enregistrés. Cela s'étend aussi à la gestion d'exceptions — si un *callback* " -"intérieur supprime ou remplace une exception, alors les *callbacks* " -"extérieurs recevront des arguments basés sur ce nouvel état." +"Comme les fonctions de rappel enregistrées sont invoquées dans l'ordre " +"inverse d'enregistrement, cela revient au même que si de multiples blocs :" +"keyword:`with` imbriqués avaient été utilisés avec l'ensemble de fonctions " +"enregistrées. Cela s'étend aussi à la gestion d'exceptions — si une fonction " +"de rappel intérieure supprime ou remplace une exception, alors les fonctions " +"extérieures recevront des arguments basés sur ce nouvel état." #: ../Doc/library/contextlib.rst:385 msgid "" @@ -505,16 +506,16 @@ msgid "" "method and adds it directly to the callback stack." msgstr "" "Si l'argument passé n'est pas un gestionnaire de contexte, la méthode assume " -"qu'il s'agit d'un *callback* avec la même signature que la méthode :meth:" -"`__exit__` des gestionnaires de contexte pour l'ajouter directement à la " -"pile d'appels." +"qu'il s'agit d'une fonction de rappel avec la même signature que la méthode :" +"meth:`__exit__` des gestionnaires de contexte pour l'ajouter directement à " +"la pile d'appels." #: ../Doc/library/contextlib.rst:413 msgid "" "By returning true values, these callbacks can suppress exceptions the same " "way context manager :meth:`__exit__` methods can." msgstr "" -"En retournant des valeurs vraies, ces *callbacks* peuvent supprimer des " +"En retournant des valeurs vraies, ces fonctions peuvent supprimer des " "exceptions de la même manière que le peuvent les méthodes :meth:`__exit__` " "des gestionnaires de contexte." @@ -539,17 +540,17 @@ msgid "" "Unlike the other methods, callbacks added this way cannot suppress " "exceptions (as they are never passed the exception details)." msgstr "" -"À la différence des autres méthodes, les *callbacks* ajoutés de cette " -"manière ne peuvent pas supprimer les exceptions (puisqu'ils ne reçoivent " -"jamais les détails de l'exception)." +"À la différence des autres méthodes, les fonctions de rappel ajoutées de " +"cette manière ne peuvent pas supprimer les exceptions (puisqu'elles ne " +"reçoivent jamais les détails de l'exception)." #: ../Doc/library/contextlib.rst:427 msgid "" "The passed in callback is returned from the function, allowing this method " "to be used as a function decorator." msgstr "" -"Le *callback* passé en paramètre est renvoyé par la fonction, ce qui permet " -"à la méthode d'être utilisée comme décorateur de fonction." +"La fonction passée en paramètre est renvoyée par la méthode, ce qui permet à " +"la méthode d'être utilisée comme décorateur de fonction." #: ../Doc/library/contextlib.rst:432 msgid "" @@ -559,9 +560,10 @@ msgid "" "at the end of a :keyword:`with` statement)." msgstr "" "Transfère la pile d'appels à une nouvelle instance de :class:`ExitStack` et " -"la renvoie. Aucun *callback* n'est invoqué par cette opération — à la place, " -"ils seront maintenant invoqués quand la nouvelle pile sera close (soit " -"explicitement soit implicitement à la fin d'un bloc :keyword:`with`)." +"la renvoie. Aucune fonction de rappel n'est invoquée par cette opération — à " +"la place, elles seront maintenant invoquées quand la nouvelle pile sera " +"close (soit explicitement soit implicitement à la fin d'un bloc :keyword:" +"`with`)." #: ../Doc/library/contextlib.rst:437 msgid "" @@ -577,9 +579,9 @@ msgid "" "order of registration. For any context managers and exit callbacks " "registered, the arguments passed in will indicate that no exception occurred." msgstr "" -"Déroule immédiatement la pile d'appels, invoquant les *callbacks* dans " -"l'ordre inverse d'enregistrement. Pour chaque gestionnaire de contexte et " -"*callback* de sortie enregistré, les arguments passés indiqueront qu'aucune " +"Déroule immédiatement la pile d'appels, invoquant les fonctions de rappel " +"dans l'ordre inverse d'enregistrement. Pour chaque gestionnaire de contexte " +"et fonction de sortie enregistré, les arguments passés indiqueront qu'aucune " "exception n'est survenue." #: ../Doc/library/contextlib.rst:458 @@ -768,9 +770,9 @@ msgid "" "execution at the end of a ``with`` statement, and then later decide to skip " "executing that callback::" msgstr "" -":class:`ExitStack` rend possible d'enregistrer un *callback* pour " -"l'exécution à la fin d'une instruction ``with``, et décider ensuite de " -"passer l'exécution de cet appel : ::" +":class:`ExitStack` rend possible de plutôt enregistrer une fonction de " +"rappel pour être exécutée à la fin d'une instruction ``with``, et décider " +"ensuite de passer l'exécution de cet appel : ::" #: ../Doc/library/contextlib.rst:631 msgid "" @@ -1009,9 +1011,9 @@ msgid "" "any with statement, regardless of where those callbacks were added::" msgstr "" "Un autre exemple de gestionnaire de contexte réutilisable mais pas réentrant " -"est :class:`ExitStack`, puisqu'il invoque *tous* les *callbacks* " -"actuellement enregistrés en quittant l'instruction *with*, sans regarder où " -"ces *callbacks* ont été ajoutés : ::" +"est :class:`ExitStack`, puisqu'il invoque *toutes* les fonctions de rappel " +"actuellement enregistrées en quittant l'instruction *with*, sans regarder où " +"ces fonctions ont été ajoutées : ::" #: ../Doc/library/contextlib.rst:853 msgid "" From e085350014881cd5c7b1d041757c4e4d1950ef00 Mon Sep 17 00:00:00 2001 From: Antoine Rozo Date: Wed, 6 Nov 2019 09:43:24 -0500 Subject: [PATCH 05/12] =?UTF-8?q?Add=20journalis=C3=A9e=20to=20dict=20file?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- dict | 1 + 1 file changed, 1 insertion(+) diff --git a/dict b/dict index 390c38b43..fccb2a1d9 100644 --- a/dict +++ b/dict @@ -66,6 +66,7 @@ itérateur itérateurs ı journalisé +journalisée journaliser journalisés journaliseur From b867e2ee0756c47ffa40e46a0ba1b236c3c5ebdc Mon Sep 17 00:00:00 2001 From: Antoine Rozo Date: Wed, 6 Nov 2019 10:38:49 -0500 Subject: [PATCH 06/12] fixup! Complete library/contextlib.po --- library/contextlib.po | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/library/contextlib.po b/library/contextlib.po index dc49cd499..3cce84251 100644 --- a/library/contextlib.po +++ b/library/contextlib.po @@ -6,7 +6,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2018-12-21 09:48+0100\n" -"PO-Revision-Date: 2019-11-06 09:39-0500\n" +"PO-Revision-Date: 2019-11-06 10:38-0500\n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" @@ -471,7 +471,7 @@ msgid "" "meth:`__enter__` method." msgstr "" "Entre dans un nouveau gestionnaire de contexte et ajoute sa méthode :meth:" -"`__exit__`à la pile d'appels. La valeur de retour est le résultat de la " +"`__exit__` à la pile d'appels. La valeur de retour est le résultat de la " "méthode :meth:`__enter__` du gestionnaire de contexte donné." #: ../Doc/library/contextlib.rst:398 From cf948116202abf585ba745e5c1dc8ea5708254b3 Mon Sep 17 00:00:00 2001 From: Antoine Rozo Date: Wed, 6 Nov 2019 10:59:48 -0500 Subject: [PATCH 07/12] fixup! Complete library/contextlib.po --- library/contextlib.po | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/library/contextlib.po b/library/contextlib.po index 3cce84251..9b8dffb19 100644 --- a/library/contextlib.po +++ b/library/contextlib.po @@ -6,7 +6,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2018-12-21 09:48+0100\n" -"PO-Revision-Date: 2019-11-06 10:38-0500\n" +"PO-Revision-Date: 2019-11-06 10:59-0500\n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" @@ -938,7 +938,7 @@ msgstr "" "Certains gestionnaires de contexte plus sophistiqués peuvent être " "« réentrants ». Ces gestionnaires de contexte ne peuvent pas seulement être " "utilisés avec plusieurs instructions :keyword:`with`, mais aussi *à " -"l'intérieur* d'une instruction :keyword:`with` qui utilise déjà ce même " +"l'intérieur* d'une instruction :keyword:`!with` qui utilise déjà ce même " "gestionnaire de contexte." #: ../Doc/library/contextlib.rst:777 From 7560623b3a7a8a6442137fc574467828a7608f43 Mon Sep 17 00:00:00 2001 From: Antoine Rozo Date: Tue, 26 Nov 2019 17:07:23 +0100 Subject: [PATCH 08/12] fixup! Complete library/contextlib.po Co-Authored-By: Jules Lasne (jlasne) Co-Authored-By: Antoine <43954001+awecx@users.noreply.github.com> --- library/contextlib.po | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/library/contextlib.po b/library/contextlib.po index 9b8dffb19..915293628 100644 --- a/library/contextlib.po +++ b/library/contextlib.po @@ -95,7 +95,7 @@ msgstr "" "Alors que de nombreux objets s'utilisent nativement dans des blocs *with*, " "on trouve parfois des ressources qui nécessitent d'être gérées mais ne sont " "pas des gestionnaires de contextes, et qui n'implémentent pas de méthode " -"``close()``pour pouvoir être utilisées avec ``contextlib.closing``" +"``close()`` pour pouvoir être utilisées avec ``contextlib.closing``" #: ../Doc/library/contextlib.rst:54 msgid "" @@ -103,7 +103,7 @@ msgid "" "management::" msgstr "" "L'exemple abstrait suivant présente comment assurer une gestion correcte des " -"ressources : ::" +"ressources : ::" #: ../Doc/library/contextlib.rst:73 msgid "" @@ -132,9 +132,9 @@ msgid "" "the :keyword:`!with` statement." msgstr "" "Au moment où le générateur produit une valeur, le bloc imbriqué sous " -"l'instruction :keyword:`with` est exécuté. Le générateur est ensuite repris " +"l'instruction :keyword:`with` est exécuté. Le générateur est ensuite repris " "après la sortie du bloc. Si une exception non gérée survient dans le bloc, " -"elle est relayée dans le générateur au niveau de l'instruction *yield*. " +"elle est relayée dans le générateur au niveau de l'instruction *yield*. " "Ainsi, vous pouvez utiliser les instructions :keyword:`try`...\\ :keyword:" "`except`...\\ :keyword:`finally` pour attraper l'erreur (s'il y a), ou vous " "assurer qu'un nettoyage a bien lieu. Si une exception est attrapée dans " @@ -192,15 +192,15 @@ msgstr "" #: ../Doc/library/contextlib.rst:111 msgid "A simple example::" -msgstr "Un exemple simple : ::" +msgstr "Un exemple simple : ::" #: ../Doc/library/contextlib.rst:132 msgid "" "Return a context manager that closes *thing* upon completion of the block. " "This is basically equivalent to::" msgstr "" -"Renvoie un gestionnaire de contexte qui ferme *thing* à la fin du bloc. " -"C'est essentiellement équivalent à : ::" +"Renvoie un gestionnaire de contexte qui ferme *thing* à la fin du bloc. " +"C'est essentiellement équivalent à : ::" #: ../Doc/library/contextlib.rst:144 msgid "And lets you write code like this::" @@ -211,7 +211,7 @@ msgid "" "without needing to explicitly close ``page``. Even if an error occurs, " "``page.close()`` will be called when the :keyword:`with` block is exited." msgstr "" -"sans besoin de fermer explicitement ``page``. Même si une erreur survient, " +"sans besoin de fermer explicitement ``page``. Même si une erreur survient, " "``page.close()`` est appelée à la fermeture du bloc :keyword:`with`." #: ../Doc/library/contextlib.rst:161 @@ -370,8 +370,8 @@ msgid "" "just a piece of it (and saving an indentation level is nice, too)." msgstr "" "Cela éclaircit le fait que ``cm`` s'applique à la fonction entière, et pas " -"juste à un morceau en particulier (et gagner un niveau d'indentation est " -"toujours sympa)." +"seulement à un morceau en particulier (et gagner un niveau d'indentation est " +"toujours appréciable)." #: ../Doc/library/contextlib.rst:333 msgid "" @@ -645,7 +645,7 @@ msgstr "" #: ../Doc/library/contextlib.rst:503 msgid "Supporting a variable number of context managers" -msgstr "Gérer une nombre variable de gestionnaires de contexte" +msgstr "Gérer un nombre variable de gestionnaires de contexte" #: ../Doc/library/contextlib.rst:505 msgid "" @@ -836,7 +836,7 @@ msgid "" msgstr "" "Par exemple, il est parfois utile d'emballer les fonctions ou blocs " "d'instructions avec un journaliseur qui pourrait suivre le temps d'exécution " -"entre l'entrée et la sortie. Plutôt qu'écrire à la fois un décorateur et un " +"entre l'entrée et la sortie. Plutôt qu'écrire à la fois un décorateur et un " "gestionnaire de contexte pour la même tâche, hériter de :class:" "`ContextDecorator` fournit les deux fonctionnalités en une seule " "définition : ::" From ca786114256a3e5607d167aa2e76c39a8b4ab7dd Mon Sep 17 00:00:00 2001 From: Antoine Rozo Date: Tue, 26 Nov 2019 17:33:49 +0100 Subject: [PATCH 09/12] fixup! Complete library/contextlib.po --- library/contextlib.po | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/library/contextlib.po b/library/contextlib.po index 915293628..993a2c5a8 100644 --- a/library/contextlib.po +++ b/library/contextlib.po @@ -6,7 +6,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2018-12-21 09:48+0100\n" -"PO-Revision-Date: 2019-11-06 10:59-0500\n" +"PO-Revision-Date: 2019-11-26 17:33+0100\n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" @@ -106,15 +106,16 @@ msgstr "" "ressources : ::" #: ../Doc/library/contextlib.rst:73 +#, fuzzy msgid "" "The function being decorated must return a :term:`generator`-iterator when " "called. This iterator must yield exactly one value, which will be bound to " "the targets in the :keyword:`with` statement's :keyword:`!as` clause, if any." msgstr "" -"La fonction à décorer doit renvoyer un :term:`generator`/itérateur quand " -"elle est appelée. Ce générateur ne doit produire qu'une seule valeur, qui " -"sera récupérée dans le bloc :keyword:`with` à l'aide de la clause :keyword:`!" -"as` si précisée." +"La fonction à décorer doit renvoyer un :term:`générateur-itérateur " +"` quand elle est appelée. Ce générateur ne doit produire " +"qu'une seule valeur, qui sera récupérée dans le bloc :keyword:`with` à " +"l'aide de la clause :keyword:`!as` si précisée." #: ../Doc/library/contextlib.rst:77 msgid "" From ce8caadf5ee91c17895aaf40900193a53a876590 Mon Sep 17 00:00:00 2001 From: Antoine Rozo Date: Fri, 29 Nov 2019 08:37:42 +0100 Subject: [PATCH 10/12] fixup! Complete library/contextlib.po --- library/contextlib.po | 67 +++++++++++++++++++++---------------------- 1 file changed, 33 insertions(+), 34 deletions(-) diff --git a/library/contextlib.po b/library/contextlib.po index 993a2c5a8..041cfea27 100644 --- a/library/contextlib.po +++ b/library/contextlib.po @@ -6,7 +6,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2018-12-21 09:48+0100\n" -"PO-Revision-Date: 2019-11-26 17:33+0100\n" +"PO-Revision-Date: 2019-11-29 08:37+0100\n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" @@ -103,7 +103,7 @@ msgid "" "management::" msgstr "" "L'exemple abstrait suivant présente comment assurer une gestion correcte des " -"ressources : ::" +"ressources ::" #: ../Doc/library/contextlib.rst:73 #, fuzzy @@ -193,7 +193,7 @@ msgstr "" #: ../Doc/library/contextlib.rst:111 msgid "A simple example::" -msgstr "Un exemple simple : ::" +msgstr "Un exemple simple ::" #: ../Doc/library/contextlib.rst:132 msgid "" @@ -201,11 +201,11 @@ msgid "" "This is basically equivalent to::" msgstr "" "Renvoie un gestionnaire de contexte qui ferme *thing* à la fin du bloc. " -"C'est essentiellement équivalent à : ::" +"C'est essentiellement équivalent à ::" #: ../Doc/library/contextlib.rst:144 msgid "And lets you write code like this::" -msgstr "Et cela vous permet d'écrire du code tel que : ::" +msgstr "Et cela vous permet d'écrire du code tel que ::" #: ../Doc/library/contextlib.rst:153 msgid "" @@ -223,11 +223,11 @@ msgid "" msgstr "" "Renvoie un gestionnaire de contexte dont la méthode ``__enter__`` renvoie " "*enter_result*, mais ne fait rien d'autre. L'idée est de l'utiliser comme " -"remplaçant pour un gestionnaire de contexte optionnel, par exemple : ::" +"remplaçant pour un gestionnaire de contexte optionnel, par exemple ::" #: ../Doc/library/contextlib.rst:175 msgid "An example using *enter_result*::" -msgstr "Un exemple utilisant *enter_result* : ::" +msgstr "Un exemple utilisant *enter_result* ::" #: ../Doc/library/contextlib.rst:193 msgid "" @@ -253,11 +253,11 @@ msgstr "" #: ../Doc/library/contextlib.rst:202 msgid "For example::" -msgstr "Par exemple : ::" +msgstr "Par exemple ::" #: ../Doc/library/contextlib.rst:212 msgid "This code is equivalent to::" -msgstr "Ce code est équivalent à : ::" +msgstr "Ce code est équivalent à ::" #: ../Doc/library/contextlib.rst:224 ../Doc/library/contextlib.rst:263 #: ../Doc/library/contextlib.rst:273 @@ -288,7 +288,7 @@ msgid "" msgstr "" "Par exemple, la sortie de :func:`help` est normalement envoyée vers *sys." "stdout*. Vous pouvez capturer cette sortie dans une chaîne de caractères en " -"la redirigeant vers un objet :class:`io.StringIO` : ::" +"la redirigeant vers un objet :class:`io.StringIO` ::" #: ../Doc/library/contextlib.rst:246 msgid "" @@ -296,11 +296,11 @@ msgid "" "a regular file::" msgstr "" "Pour envoyer la sortie de :func:`help` vers un fichier sur le disque, " -"redirigez-la sur un fichier normal : ::" +"redirigez-la sur un fichier normal ::" #: ../Doc/library/contextlib.rst:253 msgid "To send the output of :func:`help` to *sys.stderr*::" -msgstr "Pour envoyer la sortie de :func:`help` sur *sys.stderr* : ::" +msgstr "Pour envoyer la sortie de :func:`help` sur *sys.stderr* ::" #: ../Doc/library/contextlib.rst:258 msgid "" @@ -352,18 +352,18 @@ msgstr "" #: ../Doc/library/contextlib.rst:289 msgid "Example of ``ContextDecorator``::" -msgstr "Exemple de ``ContextDecorator`` : ::" +msgstr "Exemple de ``ContextDecorator`` ::" #: ../Doc/library/contextlib.rst:318 msgid "" "This change is just syntactic sugar for any construct of the following form::" msgstr "" "Ce changement est simplement un sucre syntaxique pour les constructions de " -"la forme suivante : ::" +"la forme suivante ::" #: ../Doc/library/contextlib.rst:324 msgid "``ContextDecorator`` lets you instead write::" -msgstr "``ContextDecorator`` vous permet d'écrire à la place : ::" +msgstr "``ContextDecorator`` vous permet d'écrire à la place ::" #: ../Doc/library/contextlib.rst:330 msgid "" @@ -380,7 +380,7 @@ msgid "" "using ``ContextDecorator`` as a mixin class::" msgstr "" "Les gestionnaires de contexte existants qui ont déjà une classe mère peuvent " -"être étendus en utilisant ``ContextDecorator`` comme une *mixin* : ::" +"être étendus en utilisant ``ContextDecorator`` comme une *mixin* ::" #: ../Doc/library/contextlib.rst:346 msgid "" @@ -412,7 +412,7 @@ msgid "" "as follows::" msgstr "" "Par exemple, un ensemble de fichiers peut facilement être géré dans une " -"unique instruction *with* comme suit : ::" +"unique instruction *with* comme suit ::" #: ../Doc/library/contextlib.rst:369 msgid "" @@ -572,7 +572,7 @@ msgid "" "operation as follows::" msgstr "" "Par exemple, un groupe de fichiers peut être ouvert comme une opération " -"« tout ou rien » comme suit : ::" +"« tout ou rien » comme suit ::" #: ../Doc/library/contextlib.rst:451 msgid "" @@ -630,7 +630,7 @@ msgstr "" #: ../Doc/library/contextlib.rst:484 msgid "Continuing the example for :func:`asynccontextmanager`::" -msgstr "En continuité de l'exemple de :func:`asynccontextmanager` : ::" +msgstr "En continuité de l'exemple de :func:`asynccontextmanager` ::" #: ../Doc/library/contextlib.rst:496 msgid "Examples and Recipes" @@ -663,7 +663,7 @@ msgstr "" "keyword:`with`. La variabilité peut venir du nombre de gestionnaires de " "contexte voulus découlant d'une entrée utilisateur (comme ouvrir une " "collection spécifique de fichiers de l'utilisateur), ou de certains " -"gestionnaires de contexte qui peuvent être optionnels : ::" +"gestionnaires de contexte qui peuvent être optionnels ::" #: ../Doc/library/contextlib.rst:520 msgid "" @@ -692,7 +692,7 @@ msgstr "" "inadvertance les exceptions du corps de l'instruction :keyword:`with` ou de " "la méthode ``__exit__`` des gestionnaires de contexte. En utilisant :class:" "`ExitStack`, les étapes du protocole des gestionnaires de contexte peuvent " -"être légèrement séparées pour permettre le code suivant : ::" +"être légèrement séparées pour permettre le code suivant ::" #: ../Doc/library/contextlib.rst:543 msgid "" @@ -735,8 +735,7 @@ msgid "" msgstr "" "Voici un exemple de gestionnaire de contexte qui reçoit des fonctions " "d'acquisition de ressources et de libération, avec une méthode de validation " -"optionnelle, et qui les adapte au protocole des gestionnaires de " -"contexte : ::" +"optionnelle, et qui les adapte au protocole des gestionnaires de contexte ::" #: ../Doc/library/contextlib.rst:599 msgid "Replacing any use of ``try-finally`` and flag variables" @@ -752,7 +751,7 @@ msgstr "" "Un modèle que vous rencontrerez parfois est un bloc ``try-finally`` avec une " "option pour indiquer si le corps de la clause ``finally`` doit être exécuté " "ou non. Dans sa forme la plus simple (qui ne peut pas déjà être gérée avec " -"juste une clause ``except``), cela ressemble à : ::" +"juste une clause ``except``), cela ressemble à ::" #: ../Doc/library/contextlib.rst:615 msgid "" @@ -773,7 +772,7 @@ msgid "" msgstr "" ":class:`ExitStack` rend possible de plutôt enregistrer une fonction de " "rappel pour être exécutée à la fin d'une instruction ``with``, et décider " -"ensuite de passer l'exécution de cet appel : ::" +"ensuite de passer l'exécution de cet appel ::" #: ../Doc/library/contextlib.rst:631 msgid "" @@ -789,7 +788,7 @@ msgid "" "even further by means of a small helper class::" msgstr "" "Si une application particulière utilise beaucoup ce modèle, cela peut-être " -"simplifié encore plus au moyen d'une petite classe d'aide : ::" +"simplifié encore plus au moyen d'une petite classe d'aide ::" #: ../Doc/library/contextlib.rst:652 msgid "" @@ -800,7 +799,7 @@ msgstr "" "Si le nettoyage de la ressource n'est pas déjà soigneusement embarqué dans " "une fonction autonome, il est possible d'utiliser le décorateur :meth:" "`ExitStack.callback` pour déclarer la fonction de nettoyage de ressource en " -"avance : ::" +"avance ::" #: ../Doc/library/contextlib.rst:667 msgid "" @@ -840,17 +839,17 @@ msgstr "" "entre l'entrée et la sortie. Plutôt qu'écrire à la fois un décorateur et un " "gestionnaire de contexte pour la même tâche, hériter de :class:" "`ContextDecorator` fournit les deux fonctionnalités en une seule " -"définition : ::" +"définition ::" #: ../Doc/library/contextlib.rst:699 msgid "Instances of this class can be used as both a context manager::" msgstr "" "Les instances de cette classe peuvent être utilisées comme gestionnaires de " -"contexte : ::" +"contexte ::" #: ../Doc/library/contextlib.rst:705 msgid "And also as a function decorator::" -msgstr "Et comme décorateurs de fonctions : ::" +msgstr "Et comme décorateurs de fonctions ::" #: ../Doc/library/contextlib.rst:712 msgid "" @@ -923,7 +922,7 @@ msgid "" msgstr "" "Les gestionnaires de contexte créés avec :func:`contextmanager` sont aussi à " "usage unique, et se plaindront du fait que le générateur sous-jacent ne " -"produise plus de valeur si vous essayez de les utiliser une seconde fois : ::" +"produise plus de valeur si vous essayez de les utiliser une seconde fois ::" #: ../Doc/library/contextlib.rst:770 msgid "Reentrant context managers" @@ -950,7 +949,7 @@ msgid "" msgstr "" ":class:`threading.RLock` est un exemple de gestionnaire de contexte " "réentrant, comme le sont aussi :func:`suppress` et :func:`redirect_stdout`. " -"Voici un très simple exemple d'utilisation réentrante : ::" +"Voici un très simple exemple d'utilisation réentrante ::" #: ../Doc/library/contextlib.rst:796 msgid "" @@ -1014,7 +1013,7 @@ msgstr "" "Un autre exemple de gestionnaire de contexte réutilisable mais pas réentrant " "est :class:`ExitStack`, puisqu'il invoque *toutes* les fonctions de rappel " "actuellement enregistrées en quittant l'instruction *with*, sans regarder où " -"ces fonctions ont été ajoutées : ::" +"ces fonctions ont été ajoutées ::" #: ../Doc/library/contextlib.rst:853 msgid "" @@ -1034,4 +1033,4 @@ msgid "" "instance avoids that problem::" msgstr "" "Pour éviter ce problème, utilisez des instances différentes de :class:" -"`ExitStack` plutôt qu'une seule instance : ::" +"`ExitStack` plutôt qu'une seule instance ::" From e6312bde02656c43fc42182576a20af25d43e66f Mon Sep 17 00:00:00 2001 From: Antoine Rozo Date: Sat, 30 Nov 2019 15:57:51 +0100 Subject: [PATCH 11/12] fixup! Complete library/contextlib.po --- library/contextlib.po | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/library/contextlib.po b/library/contextlib.po index 041cfea27..878fedc25 100644 --- a/library/contextlib.po +++ b/library/contextlib.po @@ -6,7 +6,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2018-12-21 09:48+0100\n" -"PO-Revision-Date: 2019-11-29 08:37+0100\n" +"PO-Revision-Date: 2019-11-30 15:57+0100\n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" @@ -136,8 +136,8 @@ msgstr "" "l'instruction :keyword:`with` est exécuté. Le générateur est ensuite repris " "après la sortie du bloc. Si une exception non gérée survient dans le bloc, " "elle est relayée dans le générateur au niveau de l'instruction *yield*. " -"Ainsi, vous pouvez utiliser les instructions :keyword:`try`...\\ :keyword:" -"`except`...\\ :keyword:`finally` pour attraper l'erreur (s'il y a), ou vous " +"Ainsi, vous pouvez utiliser les instructions :keyword:`try`…\\ :keyword:" +"`except`…\\ :keyword:`finally` pour attraper l'erreur (s'il y a), ou vous " "assurer qu'un nettoyage a bien lieu. Si une exception est attrapée dans " "l'unique but d'être journalisée ou d'effectuer une action particulière " "(autre que supprimer entièrement l'exception), le générateur se doit de la " @@ -661,7 +661,7 @@ msgstr "" "documentation de la classe : supporter un nombre variable de gestionnaires " "de contexte et d'autres opérations de nettoyage en une unique instruction :" "keyword:`with`. La variabilité peut venir du nombre de gestionnaires de " -"contexte voulus découlant d'une entrée utilisateur (comme ouvrir une " +"contexte voulus découlant d'une entrée de utilisateur (comme ouvrir une " "collection spécifique de fichiers de l'utilisateur), ou de certains " "gestionnaires de contexte qui peuvent être optionnels ::" From 83740be85ad46d8a3ac019568e49e7b0eab025d0 Mon Sep 17 00:00:00 2001 From: Julien Palard Date: Sun, 1 Dec 2019 23:40:31 +0100 Subject: [PATCH 12/12] Proofreading by ChrisNan --- library/contextlib.po | 44 +++++++++++++++++++++---------------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/library/contextlib.po b/library/contextlib.po index 878fedc25..dd49aef59 100644 --- a/library/contextlib.po +++ b/library/contextlib.po @@ -6,7 +6,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2018-12-21 09:48+0100\n" -"PO-Revision-Date: 2019-11-30 15:57+0100\n" +"PO-Revision-Date: 2019-12-01 23:39+0100\n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" @@ -114,8 +114,8 @@ msgid "" msgstr "" "La fonction à décorer doit renvoyer un :term:`générateur-itérateur " "` quand elle est appelée. Ce générateur ne doit produire " -"qu'une seule valeur, qui sera récupérée dans le bloc :keyword:`with` à " -"l'aide de la clause :keyword:`!as` si précisée." +"qu'une seule valeur, qui est récupérée dans le bloc :keyword:`with` à l'aide " +"de la clause :keyword:`!as` si précisée." #: ../Doc/library/contextlib.rst:77 msgid "" @@ -451,7 +451,7 @@ msgstr "" "keyword:`with` imbriqués avaient été utilisés avec l'ensemble de fonctions " "enregistrées. Cela s'étend aussi à la gestion d'exceptions — si une fonction " "de rappel intérieure supprime ou remplace une exception, alors les fonctions " -"extérieures recevront des arguments basés sur ce nouvel état." +"extérieures reçoivent des arguments basés sur ce nouvel état." #: ../Doc/library/contextlib.rst:385 msgid "" @@ -533,8 +533,8 @@ msgid "" "Accepts an arbitrary callback function and arguments and adds it to the " "callback stack." msgstr "" -"Accepte une fonction arbitraire et ses arguments et les ajoute à la pile " -"d'appels." +"Accepte une fonction arbitraire et ses arguments et les ajoute à la pile des " +"fonctions de rappel." #: ../Doc/library/contextlib.rst:424 msgid "" @@ -562,9 +562,8 @@ msgid "" msgstr "" "Transfère la pile d'appels à une nouvelle instance de :class:`ExitStack` et " "la renvoie. Aucune fonction de rappel n'est invoquée par cette opération — à " -"la place, elles seront maintenant invoquées quand la nouvelle pile sera " -"close (soit explicitement soit implicitement à la fin d'un bloc :keyword:" -"`with`)." +"la place, elles sont dorénavant invoquées quand la nouvelle pile sera close " +"(soit explicitement soit implicitement à la fin d'un bloc :keyword:`with`)." #: ../Doc/library/contextlib.rst:437 msgid "" @@ -592,9 +591,9 @@ msgid "" "context managers, as well as having coroutines for cleanup logic." msgstr "" "Un :ref:`gestionnaire de contexte asynchrone `, " -"similaire à :class:`ExitStack`, qui supporte le fait de combiner à la fois " -"des gestionnaires de contexte synchrones et asynchrones, ainsi que la " -"gestion de coroutines pour la logique de nettoyage." +"similaire à :class:`ExitStack`, apte à combiner à la fois des gestionnaires " +"de contexte synchrones et asynchrones, ainsi que la gestion de coroutines " +"pour la logique de nettoyage." #: ../Doc/library/contextlib.rst:463 msgid "" @@ -658,10 +657,10 @@ msgid "" "of the context managers being optional::" msgstr "" "Le cas d'utilisation primaire de :class:`ExitStack` est celui décrit dans la " -"documentation de la classe : supporter un nombre variable de gestionnaires " -"de contexte et d'autres opérations de nettoyage en une unique instruction :" +"documentation de la classe : gérer un nombre variable de gestionnaires de " +"contexte et d'autres opérations de nettoyage en une unique instruction :" "keyword:`with`. La variabilité peut venir du nombre de gestionnaires de " -"contexte voulus découlant d'une entrée de utilisateur (comme ouvrir une " +"contexte voulus découlant d'une entrée de l'utilisateur (comme ouvrir une " "collection spécifique de fichiers de l'utilisateur), ou de certains " "gestionnaires de contexte qui peuvent être optionnels ::" @@ -673,7 +672,7 @@ msgid "" msgstr "" "Comme montré, :class:`ExitStack` rend aussi assez facile d'utiliser les " "instructions :keyword:`with` pour gérer des ressources arbitraires qui ne " -"supportent pas nativement le protocole des gestionnaires de contexte." +"gèrent pas nativement le protocole des gestionnaires de contexte." #: ../Doc/library/contextlib.rst:526 msgid "Catching exceptions from ``__enter__`` methods" @@ -890,7 +889,7 @@ msgstr "" "leur permet que d'être utilisés une fois avec une instruction :keyword:" "`with`. Ces gestionnaires de contexte à usage unique doivent être recréés " "chaque fois qu'ils sont utilisés — tenter de les utiliser une seconde fois " -"lancera une exception ou ne fonctionnera pas correctement." +"lève une exception ou ne fonctionne pas correctement." #: ../Doc/library/contextlib.rst:734 msgid "" @@ -990,9 +989,10 @@ msgstr "" "sont les gestionnaires de contexte « réutilisables » (ou, pour être plus " "explicite, « réutilisables mais pas réentrants », puisque les gestionnaires " "de contexte réentrants sont aussi réutilisables). Ces gestionnaires de " -"contexte supportent le fait d'être utilisés plusieurs fois, mais échoueront " -"(ou ne fonctionneront pas correctement) si le gestionnaire de contexte en " -"particulier a déjà été utilisé dans une instruction *with* englobante." +"contexte sont conçus afin d'être utilisés plusieurs fois, mais échoueront " +"(ou ne fonctionnent pas correctement) si l'instance de gestionnaire de " +"contexte référencée a déjà été utilisée dans une instruction *with* " +"englobante." #: ../Doc/library/contextlib.rst:818 msgid "" @@ -1024,8 +1024,8 @@ msgid "" msgstr "" "Comme le montre la sortie de l'exemple, réutiliser une simple pile entre " "plusieurs instructions *with* fonctionne correctement, mais essayer de les " -"imbriquer fera que la pile sera vidée à la fin du *with* le plus imbriqué, " -"ce qui n'est probablement pas le comportement voulu." +"imbriquer fait que la pile est vidée à la fin du *with* le plus imbriqué, ce " +"qui n'est probablement pas le comportement voulu." #: ../Doc/library/contextlib.rst:858 msgid ""