From 32024f26a88fff574bcc9fb7b695e5a14bdceca3 Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil Date: Fri, 7 Jul 2023 13:34:22 +0000 Subject: [PATCH] traduction de library/asyncio-eventloop.po (#153) Co-authored-by: Christophe Nanteuil Reviewed-on: https://git.afpy.org/AFPy/python-docs-fr/pulls/153 Reviewed-by: Julien Palard Co-authored-by: Christophe Nanteuil Co-committed-by: Christophe Nanteuil --- library/asyncio-eventloop.po | 933 +++++++++++++++++++++++++++++++---- 1 file changed, 831 insertions(+), 102 deletions(-) diff --git a/library/asyncio-eventloop.po b/library/asyncio-eventloop.po index be8dffff..f760f959 100644 --- a/library/asyncio-eventloop.po +++ b/library/asyncio-eventloop.po @@ -6,14 +6,14 @@ msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-04-14 13:19+0200\n" -"PO-Revision-Date: 2019-06-10 15:50+0200\n" -"Last-Translator: Julien Palard \n" +"PO-Revision-Date: 2023-07-05 23:26+0200\n" +"Last-Translator: Christophe Nanteuil \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.0.2\n" +"X-Generator: Poedit 3.2.2\n" #: library/asyncio-eventloop.rst:8 msgid "Event Loop" @@ -24,10 +24,12 @@ msgid "" "**Source code:** :source:`Lib/asyncio/events.py`, :source:`Lib/asyncio/" "base_events.py`" msgstr "" +"**Code source :** :source:`Lib/asyncio/events.py`, :source:`Lib/asyncio/" +"base_events.py`" #: library/asyncio-eventloop.rst:16 msgid "Preface" -msgstr "" +msgstr "Préface" #: library/asyncio-eventloop.rst:17 msgid "" @@ -35,6 +37,10 @@ msgid "" "asynchronous tasks and callbacks, perform network IO operations, and run " "subprocesses." msgstr "" +"La boucle d'événements est au cœur de chaque application *asyncio*. Les " +"boucles d'événements exécutent des tâches et des rappels asynchrones, " +"effectuent des opérations d'entrée-sorite réseau et exécutent des sous-" +"processus." #: library/asyncio-eventloop.rst:21 msgid "" @@ -44,31 +50,44 @@ msgid "" "authors of lower-level code, libraries, and frameworks, who need finer " "control over the event loop behavior." msgstr "" +"Les développeurs d'applications doivent généralement utiliser les fonctions " +"*asyncio* de haut niveau, telles que :func:`asyncio.run`, et ne doivent que " +"rarement référencer l'objet boucle ou appeler ses méthodes. Cette section " +"est principalement destinée aux auteurs de code, de bibliothèques et de " +"cadriciels de bas niveau, qui ont besoin d'un contrôle plus précis sur le " +"comportement de la boucle d'événements." #: library/asyncio-eventloop.rst:28 msgid "Obtaining the Event Loop" -msgstr "Obtenir une boucle d'évènements" +msgstr "Obtention d'une boucle d'évènements" #: library/asyncio-eventloop.rst:29 msgid "" "The following low-level functions can be used to get, set, or create an " "event loop:" msgstr "" +"Les fonctions de bas niveau suivantes peuvent être utilisées pour obtenir, " +"définir ou créer une boucle d'événements :" #: library/asyncio-eventloop.rst:34 msgid "Return the running event loop in the current OS thread." msgstr "" +"Renvoie la boucle d'événements en cours d'exécution dans le fil actuel du " +"système d'exploitation." #: library/asyncio-eventloop.rst:36 msgid "Raise a :exc:`RuntimeError` if there is no running event loop." msgstr "" +"Lève une :exc:`RuntimeError` s'il n'y a pas de boucle d'événements en cours " +"d'exécution." #: library/asyncio-eventloop.rst:38 msgid "This function can only be called from a coroutine or a callback." msgstr "" +"Cette fonction ne peut être appelée qu'à partir d'une coroutine ou d'une " +"fonction de rappel." #: library/asyncio-eventloop.rst:44 -#, fuzzy msgid "Get the current event loop." msgstr "Arrête l'exécution de la boucle d'évènements." @@ -77,12 +96,17 @@ msgid "" "When called from a coroutine or a callback (e.g. scheduled with call_soon or " "similar API), this function will always return the running event loop." msgstr "" +"Lorsqu'elle est appelée depuis une coroutine ou une fonction de rappel (par " +"exemple planifiée avec *call_soon* ou une API similaire), cette fonction " +"renvoie toujours la boucle d'événement en cours." #: library/asyncio-eventloop.rst:50 msgid "" "If there is no running event loop set, the function will return the result " "of the ``get_event_loop_policy().get_event_loop()`` call." msgstr "" +"S'il n'y a pas de boucle d'événement en cours d'exécution, la fonction " +"renvoie le résultat de l'appel ``get_event_loop_policy().get_event_loop()``." #: library/asyncio-eventloop.rst:53 msgid "" @@ -90,6 +114,11 @@ msgid "" "event loop policies are in use), using the :func:`get_running_loop` function " "is preferred to :func:`get_event_loop` in coroutines and callbacks." msgstr "" +"Étant donné que cette fonction a un comportement plutôt complexe (en " +"particulier lorsque des politiques de boucle d'événements personnalisées " +"sont utilisées), l'utilisation de la fonction :func:`get_running_loop` est " +"préférable à :func:`get_event_loop` dans les coroutines et les fonctions de " +"rappel." #: library/asyncio-eventloop.rst:58 msgid "" @@ -97,7 +126,11 @@ msgid "" "function, instead of using these lower level functions to manually create " "and close an event loop." msgstr "" +"Comme indiqué ci-dessus, envisagez d'utiliser la fonction de haut niveau :" +"func:`asyncio.run`, au lieu d'utiliser ces fonctions de bas niveau pour " +"créer et fermer manuellement une boucle d'événements." +# suit un : #: library/asyncio-eventloop.rst:63 msgid "" "In Python versions 3.10.0--3.10.8 and 3.11.0 this function (and other " @@ -107,16 +140,24 @@ msgid "" "`DeprecationWarning` if there is no running event loop and no current loop " "is set. In some future Python release this will become an error." msgstr "" +"dans les versions Python 3.10.0–3.10.8 et 3.11.0, cette fonction (et " +"d'autres fonctions qui l'utilisent implicitement) levait un :exc:" +"`DeprecationWarning` s'il n'y avait pas de boucle d'événements en cours " +"d'exécution, même si la boucle actuelle était définie dans la politique. " +"Dans les versions Python 3.10.9, 3.11.1 et 3.12, elles lèvent un :exc:" +"`DeprecationWarning` s'il n'y a pas de boucle d'événements en cours et " +"qu'aucune boucle actuelle n'est définie. Dans une future version de Python, " +"cela deviendra une erreur." #: library/asyncio-eventloop.rst:74 -#, fuzzy msgid "Set *loop* as the current event loop for the current OS thread." msgstr "" -"Appelle le gestionnaire d'exception de la boucle d'évènements actuelle." +"Définit *loop* comme boucle d'événements actuelle pour le fil d'exécution " +"actuel du système d'exploitation." #: library/asyncio-eventloop.rst:78 msgid "Create and return a new event loop object." -msgstr "" +msgstr "Crée et renvoie un nouvel objet de boucle d'événements." #: library/asyncio-eventloop.rst:80 msgid "" @@ -124,6 +165,10 @@ msgid "" "and :func:`new_event_loop` functions can be altered by :ref:`setting a " "custom event loop policy `." msgstr "" +"Notez que le comportement des fonctions :func:`get_event_loop`, :func:" +"`set_event_loop` et :func:`new_event_loop` peut être modifié en :ref:" +"`définissant une politique de boucle d'événement personnalisée `." #: library/asyncio-eventloop.rst:86 msgid "Contents" @@ -131,37 +176,53 @@ msgstr "Sommaire" #: library/asyncio-eventloop.rst:87 msgid "This documentation page contains the following sections:" -msgstr "" +msgstr "Cette page de documentation contient les sections suivantes :" +# suit un : #: library/asyncio-eventloop.rst:89 msgid "" "The `Event Loop Methods`_ section is the reference documentation of the " "event loop APIs;" msgstr "" +"la section `Event Loop Methods`_ est la documentation de référence des API " +"de boucle d'événements ;" +# suit un : #: library/asyncio-eventloop.rst:92 msgid "" "The `Callback Handles`_ section documents the :class:`Handle` and :class:" "`TimerHandle` instances which are returned from scheduling methods such as :" "meth:`loop.call_soon` and :meth:`loop.call_later`;" msgstr "" +"la section `Callback Handles`_ documente les instances :class:`Handle` et :" +"class:`TimerHandle` qui sont renvoyées par les méthodes de planification " +"telles que :meth:`loop.call_soon` et :meth:`loop.call_later` ;" +# suit un : #: library/asyncio-eventloop.rst:96 msgid "" "The `Server Objects`_ section documents types returned from event loop " "methods like :meth:`loop.create_server`;" msgstr "" +"la section `Server Objects`_ documente les types renvoyés par les méthodes " +"de boucle d'événements comme :meth:`loop.create_server` ;" +# suit un : #: library/asyncio-eventloop.rst:99 msgid "" "The `Event Loop Implementations`_ section documents the :class:" "`SelectorEventLoop` and :class:`ProactorEventLoop` classes;" msgstr "" +"la section `Event Loop Implementations`_ documente les classes :class:" +"`SelectorEventLoop` et :class:`ProactorEventLoop` ;" +# suit un : #: library/asyncio-eventloop.rst:102 msgid "" "The `Examples`_ section showcases how to work with some event loop APIs." msgstr "" +"la section `Exemples`_ montre comment travailler avec certaines API de " +"boucle d'événements." #: library/asyncio-eventloop.rst:109 msgid "Event Loop Methods" @@ -170,6 +231,8 @@ msgstr "Méthodes de la boucle d'évènements" #: library/asyncio-eventloop.rst:111 msgid "Event loops have **low-level** APIs for the following:" msgstr "" +"Les boucles d'événements ont des API **de bas niveau** pour les éléments " +"suivants :" #: library/asyncio-eventloop.rst:119 msgid "Running and stopping the loop" @@ -186,14 +249,17 @@ msgid "" "If the argument is a :ref:`coroutine object ` it is implicitly " "scheduled to run as a :class:`asyncio.Task`." msgstr "" +"Si l'argument est un objet :ref:`coroutine `, il est " +"implicitement programmé pour s'exécuter en tant que :class:`asyncio.Task`." #: library/asyncio-eventloop.rst:129 msgid "Return the Future's result or raise its exception." -msgstr "" +msgstr "Renvoie le résultat du *Future* ou lève son exception." #: library/asyncio-eventloop.rst:133 msgid "Run the event loop until :meth:`stop` is called." msgstr "" +"Exécute la boucle d'événement jusqu'à ce que :meth:`stop` soit appelée." #: library/asyncio-eventloop.rst:135 msgid "" @@ -202,6 +268,11 @@ msgid "" "scheduled in response to I/O events (and those that were already scheduled), " "and then exit." msgstr "" +"Si :meth:`stop` est appelée avant que :meth:`run_forever()` ne soit appelée, " +"la boucle interroge le sélecteur d'entrée-sortie une fois avec un délai " +"d'attente de zéro, exécute tous les rappels programmés en réponse aux " +"événements d'entrée-sortie (et ceux qui étaient déjà programmés), puis " +"quitte." #: library/asyncio-eventloop.rst:140 msgid "" @@ -211,6 +282,11 @@ msgid "" "will run the next time :meth:`run_forever` or :meth:`run_until_complete` is " "called." msgstr "" +"Si :meth:`stop` est appelée pendant que :meth:`run_forever` est en cours " +"d'exécution, la boucle exécute le lot actuel de rappels puis se termine. " +"Notez que les nouveaux rappels programmés par fonctions de rappel ne " +"s'exécuteront pas dans ce cas ; à la place, ils s'exécuteront la prochaine " +"fois que :meth:`run_forever` ou :meth:`run_until_complete` sera appelée." #: library/asyncio-eventloop.rst:148 msgid "Stop the event loop." @@ -233,18 +309,24 @@ msgid "" "The loop must not be running when this function is called. Any pending " "callbacks will be discarded." msgstr "" +"La boucle ne doit pas être en cours d'exécution lorsque cette fonction est " +"appelée. Tous les rappels en attente seront ignorés." #: library/asyncio-eventloop.rst:165 msgid "" "This method clears all queues and shuts down the executor, but does not wait " "for the executor to finish." msgstr "" +"Cette méthode efface toutes les files d'attente et arrête l'exécuteur, mais " +"n'attend pas que l'exécuteur se termine." #: library/asyncio-eventloop.rst:168 msgid "" "This method is idempotent and irreversible. No other methods should be " "called after the event loop is closed." msgstr "" +"Cette méthode est idempotente et irréversible. Aucune autre méthode ne doit " +"être appelée après la fermeture de la boucle d'événements." #: library/asyncio-eventloop.rst:173 msgid "" @@ -253,12 +335,20 @@ msgid "" "loop will issue a warning if a new asynchronous generator is iterated. This " "should be used to reliably finalize all scheduled asynchronous generators." msgstr "" +"Planifie la fermeture de tous les objets :term:`générateurs asynchrones " +"` actuellement ouverts avec un appel :meth:`~agen." +"aclose()`. Après avoir appelé cette méthode, la boucle d'événements émet un " +"avertissement si un nouveau générateur asynchrone est itéré. Elle doit être " +"utilisée pour finaliser de manière fiable tous les générateurs asynchrones " +"planifiés." #: library/asyncio-eventloop.rst:179 msgid "" "Note that there is no need to call this function when :func:`asyncio.run` is " "used." msgstr "" +"Notez qu'il n'est pas nécessaire d'appeler cette fonction lorsque :func:" +"`asyncio.run` est utilisée." #: library/asyncio-eventloop.rst:182 library/asyncio-eventloop.rst:1216 #: library/asyncio-eventloop.rst:1604 @@ -272,34 +362,47 @@ msgid "" "this method has been called, using the default executor with :meth:`loop." "run_in_executor` will raise a :exc:`RuntimeError`." msgstr "" +"Planifie la fermeture de l'exécuteur par défaut et attend que tous les fils " +"se rejoignent dans le :class:`~concurrent.futures.ThreadPoolExecutor`. Une " +"fois cette méthode appelée, l'utilisation de l'exécuteur par défaut avec :" +"meth:`loop.run_in_executor` lève une :exc:`RuntimeError`." +# suit un : #: library/asyncio-eventloop.rst:202 msgid "" "Do not call this method when using :func:`asyncio.run`, as the latter " "handles default executor shutdown automatically." msgstr "" +"n'appelez pas cette méthode lorsque vous utilisez :func:`asyncio.run`, car " +"cette dernière gère automatiquement l'arrêt de l'exécuteur par défaut." #: library/asyncio-eventloop.rst:209 msgid "Scheduling callbacks" -msgstr "" +msgstr "Planification des fonctions de rappel" #: library/asyncio-eventloop.rst:213 msgid "" "Schedule the *callback* :term:`callback` to be called with *args* arguments " "at the next iteration of the event loop." msgstr "" +"Définit la :term:`fonction de rappel ` *callback* à appeler avec " +"les arguments *args* à la prochaine itération de la boucle d'événements." #: library/asyncio-eventloop.rst:216 msgid "" "Return an instance of :class:`asyncio.Handle`, which can be used later to " "cancel the callback." msgstr "" +"Renvoie une instance de :class:`asyncio.Handle`, qui pourra être utilisée " +"ultérieurement pour annuler le rappel." #: library/asyncio-eventloop.rst:219 msgid "" "Callbacks are called in the order in which they are registered. Each " "callback will be called exactly once." msgstr "" +"Les fonctions de rappels sont appelées dans l'ordre dans lequel elles sont " +"enregistrées. Chaque fonction de rappel sera appelée exactement une fois." #: library/asyncio-eventloop.rst:222 msgid "" @@ -307,10 +410,15 @@ msgid "" "`contextvars.Context` for the *callback* to run in. Callbacks use the " "current context when no *context* is provided." msgstr "" +"L'argument facultatif nommé uniquement *context* spécifie un :class:" +"`contextvars.Context` personnalisé pour le *callback* à exécuter. Les " +"rappels utilisent le contexte actuel lorsqu'aucun *context* n'est fourni." #: library/asyncio-eventloop.rst:226 msgid "Unlike :meth:`call_soon_threadsafe`, this method is not thread-safe." msgstr "" +"Contrairement à :meth:`call_soon_threadsafe`, cette méthode n'est pas " +"compatible avec les programmes à fils d'exécution multiples." #: library/asyncio-eventloop.rst:230 msgid "" @@ -318,12 +426,19 @@ msgid "" "another thread, this function *must* be used, since :meth:`call_soon` is not " "thread-safe." msgstr "" +"Une variante compatible avec les programmes à fils d'exécution multiples de :" +"meth:`call_soon`. Lors de la planification de rappels à partir d'un autre " +"fil d'exécution, cette fonction *doit* être utilisée, puisque :meth:" +"`call_soon` n'est pas thread-safe." #: library/asyncio-eventloop.rst:234 msgid "" "Raises :exc:`RuntimeError` if called on a loop that's been closed. This can " "happen on a secondary thread when the main application is shutting down." msgstr "" +"Lève :exc:`RuntimeError` si elle est appelée sur une boucle qui a été " +"fermée. Cela peut se produire sur un fil secondaire lorsque l'application " +"principale se ferme." #: library/asyncio-eventloop.rst:238 msgid "" @@ -333,52 +448,72 @@ msgstr "" "Voir la section :ref:`exécution concurrente et multi-fils d'exécution " "` de la documentation." +# suit un : #: library/asyncio-eventloop.rst:241 library/asyncio-eventloop.rst:291 #: library/asyncio-eventloop.rst:311 msgid "" "The *context* keyword-only parameter was added. See :pep:`567` for more " "details." msgstr "" +"le paramètre nommé uniquement *context* a été ajouté. Voir :pep:`567` pour " +"plus de détails." +# suit un : #: library/asyncio-eventloop.rst:249 msgid "" "Most :mod:`asyncio` scheduling functions don't allow passing keyword " "arguments. To do that, use :func:`functools.partial`::" msgstr "" +"la plupart des fonctions d'ordonnancement :mod:`asyncio` n'autorisent pas le " +"passage d'arguments nommés. Pour le faire, utilisez :func:`functools." +"partial` ::" #: library/asyncio-eventloop.rst:256 msgid "" "Using partial objects is usually more convenient than using lambdas, as " "asyncio can render partial objects better in debug and error messages." msgstr "" +"L'utilisation d'objets partiels est généralement plus pratique que " +"l'utilisation de lambdas, car *asyncio* peut mieux rendre les objets " +"partiels dans les messages de débogage et d'erreur." #: library/asyncio-eventloop.rst:264 msgid "Scheduling delayed callbacks" -msgstr "" +msgstr "Planification des rappels différés" #: library/asyncio-eventloop.rst:266 msgid "" "Event loop provides mechanisms to schedule callback functions to be called " "at some point in the future. Event loop uses monotonic clocks to track time." msgstr "" +"La boucle d'événements fournit des mécanismes pour programmer les fonctions " +"de rappel à appeler à un moment donné dans le futur. La boucle d'événements " +"utilise des horloges monotones pour suivre le temps." #: library/asyncio-eventloop.rst:273 msgid "" "Schedule *callback* to be called after the given *delay* number of seconds " "(can be either an int or a float)." msgstr "" +"Planifie le rappel *callback* à appeler après *delay* secondes (peut être un " +"entier ou un flottant)." #: library/asyncio-eventloop.rst:276 library/asyncio-eventloop.rst:308 msgid "" "An instance of :class:`asyncio.TimerHandle` is returned which can be used to " "cancel the callback." msgstr "" +"Une instance de :class:`asyncio.TimerHandle` est renvoyée et peut être " +"utilisée pour annuler le rappel." #: library/asyncio-eventloop.rst:279 msgid "" "*callback* will be called exactly once. If two callbacks are scheduled for " "exactly the same time, the order in which they are called is undefined." msgstr "" +"*callback* sera appelé exactement une fois. Si deux rappels sont programmés " +"exactement à la même heure, l'ordre dans lequel ils sont appelés n'est pas " +"défini." #: library/asyncio-eventloop.rst:283 msgid "" @@ -386,6 +521,9 @@ msgid "" "called. If you want the callback to be called with keyword arguments use :" "func:`functools.partial`." msgstr "" +"L'argument positionnel facultatif *args* sera transmis au rappel lorsqu'il " +"sera appelé. Si vous voulez que le rappel soit appelé avec des arguments " +"nommés, utilisez :func:`functools.partial`." #: library/asyncio-eventloop.rst:287 msgid "" @@ -393,53 +531,75 @@ msgid "" "class:`contextvars.Context` for the *callback* to run in. The current " "context is used when no *context* is provided." msgstr "" +"Un argument facultatif *context* nommé uniquement permet de spécifier un :" +"class:`contextvars.Context` personnalisé pour le *callback* à exécuter. Le " +"contexte actuel est utilisé lorsqu'aucun *context* n'est fourni." +# suit un : #: library/asyncio-eventloop.rst:295 msgid "" "In Python 3.7 and earlier with the default event loop implementation, the " "*delay* could not exceed one day. This has been fixed in Python 3.8." msgstr "" +"dans Python 3.7 et versions antérieures avec l'implémentation de la boucle " +"d'événements par défaut, le *delay* ne pouvait pas dépasser un jour. Cela a " +"été corrigé dans Python 3.8." #: library/asyncio-eventloop.rst:302 msgid "" "Schedule *callback* to be called at the given absolute timestamp *when* (an " "int or a float), using the same time reference as :meth:`loop.time`." msgstr "" +"Planifie l'appel de *callback* à l'horodatage absolu donné *when* (un *int* " +"ou un *float*), en utilisant la même référence de temps que :meth:`loop." +"time`." #: library/asyncio-eventloop.rst:306 msgid "This method's behavior is the same as :meth:`call_later`." -msgstr "" +msgstr "Le comportement de cette méthode est le même que :meth:`call_later`." +# suit un : #: library/asyncio-eventloop.rst:315 msgid "" "In Python 3.7 and earlier with the default event loop implementation, the " "difference between *when* and the current time could not exceed one day. " "This has been fixed in Python 3.8." msgstr "" +"dans Python 3.7 et versions antérieures avec l'implémentation de la boucle " +"d'événements par défaut, la différence entre *when* et l'heure actuelle ne " +"pouvait pas dépasser un jour. Cela a été corrigé dans Python 3.8." #: library/asyncio-eventloop.rst:322 msgid "" "Return the current time, as a :class:`float` value, according to the event " "loop's internal monotonic clock." msgstr "" +"Renvoie l'heure actuelle, sous la forme d'une valeur :class:`float`, selon " +"l'horloge monotone interne de la boucle d'événements." +# suit un : #: library/asyncio-eventloop.rst:326 msgid "" "In Python 3.7 and earlier timeouts (relative *delay* or absolute *when*) " "should not exceed one day. This has been fixed in Python 3.8." msgstr "" +"dans Python 3.7 et les versions antérieures, les délais d'expiration " +"(relatif *delay* ou absolu *when*) ne doivent pas dépasser un jour. Cela a " +"été corrigé dans Python 3.8." +# suit un : #: library/asyncio-eventloop.rst:332 msgid "The :func:`asyncio.sleep` function." -msgstr "La fonction :func:`asyncio.sleep`." +msgstr "la fonction :func:`asyncio.sleep`." #: library/asyncio-eventloop.rst:336 msgid "Creating Futures and Tasks" -msgstr "" +msgstr "Création de *Futures* et des tâches" #: library/asyncio-eventloop.rst:340 msgid "Create an :class:`asyncio.Future` object attached to the event loop." msgstr "" +"Crée un objet :class:`asyncio.Future` attaché à la boucle d'événements." #: library/asyncio-eventloop.rst:342 msgid "" @@ -447,12 +607,18 @@ msgid "" "party event loops provide alternative implementations of the Future object " "(with better performance or instrumentation)." msgstr "" +"C'est la méthode préférée pour créer des *Futures* avec *asyncio*. Cela " +"permet aux boucles d'événements tierces de fournir des implémentations " +"alternatives de l'objet *Future* (avec de meilleures performances ou " +"instrumentation)." #: library/asyncio-eventloop.rst:350 msgid "" "Schedule the execution of :ref:`coroutine ` *coro*. Return a :" "class:`Task` object." msgstr "" +"Planifie l'exécution de :ref:`coroutine ` *coro*. Renvoie un " +"objet :class:`Task`." #: library/asyncio-eventloop.rst:353 msgid "" @@ -460,12 +626,17 @@ msgid "" "interoperability. In this case, the result type is a subclass of :class:" "`Task`." msgstr "" +"Les boucles d'événements tierces peuvent utiliser leur propre sous-classe " +"de :class:`Task` pour l'interopérabilité. Dans ce cas, le type de résultat " +"est une sous-classe de :class:`Task`." #: library/asyncio-eventloop.rst:357 msgid "" "If the *name* argument is provided and not ``None``, it is set as the name " "of the task using :meth:`Task.set_name`." msgstr "" +"Si l'argument *name* est fourni et non ``None``, il est défini comme le nom " +"de la tâche en utilisant :meth:`Task.set_name`." #: library/asyncio-eventloop.rst:360 msgid "" @@ -473,20 +644,23 @@ msgid "" "class:`contextvars.Context` for the *coro* to run in. The current context " "copy is created when no *context* is provided." msgstr "" +"Argument facultatif *context* nommé uniquement qui permet de spécifier un :" +"class:`contextvars.Context` personnalisé pour la *coro* à exécuter. La copie " +"de contexte actuel est créée lorsqu'aucun *context* n'est fourni." #: library/asyncio-eventloop.rst:364 -#, fuzzy msgid "Added the *name* parameter." msgstr "ajout du paramètre ``name``." #: library/asyncio-eventloop.rst:367 -#, fuzzy msgid "Added the *context* parameter." -msgstr "ajout du paramètre ``name``." +msgstr "ajout du paramètre ``context``." #: library/asyncio-eventloop.rst:372 msgid "Set a task factory that will be used by :meth:`loop.create_task`." msgstr "" +"Définit une fabrique de tâches qui sera utilisée par :meth:`loop." +"create_task`." #: library/asyncio-eventloop.rst:375 msgid "" @@ -496,20 +670,28 @@ msgid "" "*coro* is a coroutine object. The callable must return a :class:`asyncio." "Future`-compatible object." msgstr "" +"Si *factory* est ``None``, la fabrique de tâches par défaut sera définie. " +"Sinon, *factory* doit être un *appelable* avec la signature correspondant à " +"``(loop, coro, context=None)``, où *loop* est une référence à la boucle " +"d'événements active et *coro* est un objet coroutine . L'appelable doit " +"renvoyer un objet compatible avec :class:`asyncio.Future`." #: library/asyncio-eventloop.rst:383 msgid "Return a task factory or ``None`` if the default one is in use." msgstr "" +"Renvoie une fabrique de tâches ou ``None`` si celle par défaut est utilisée." #: library/asyncio-eventloop.rst:387 msgid "Opening network connections" -msgstr "Créer des connexions" +msgstr "Création de connexions" #: library/asyncio-eventloop.rst:397 msgid "" "Open a streaming transport connection to a given address specified by *host* " "and *port*." msgstr "" +"Ouvre un flux de transport connecté à l'adresse spécifiée par *host* et " +"*port*." #: library/asyncio-eventloop.rst:400 msgid "" @@ -517,10 +699,13 @@ msgid "" "`~socket.AF_INET6` depending on *host* (or the *family* argument, if " "provided)." msgstr "" +"La famille de connecteur peut être :py:data:`~socket.AF_INET` ou :py:data:" +"`~socket.AF_INET6` en fonction de *host* (ou l'argument *family*, s'il est " +"fourni)." #: library/asyncio-eventloop.rst:404 msgid "The socket type will be :py:data:`~socket.SOCK_STREAM`." -msgstr "" +msgstr "Le type de connecteur sera :py:data:`~socket.SOCK_STREAM`." #: library/asyncio-eventloop.rst:406 library/asyncio-eventloop.rst:1132 #: library/asyncio-eventloop.rst:1148 @@ -528,47 +713,58 @@ msgid "" "*protocol_factory* must be a callable returning an :ref:`asyncio protocol " "` implementation." msgstr "" +"*protocol_factory* doit être un appelable renvoyant un protocole gérant le :" +"ref:`protocole asyncio `." #: library/asyncio-eventloop.rst:409 msgid "" "This method will try to establish the connection in the background. When " "successful, it returns a ``(transport, protocol)`` pair." msgstr "" +"Cette méthode tente d'établir la connexion en arrière-plan. En cas de " +"succès, elle renvoie une paire ``(transport, protocol)``." #: library/asyncio-eventloop.rst:412 msgid "The chronological synopsis of the underlying operation is as follows:" -msgstr "" +msgstr "Le synopsis chronologique de l'opération sous-jacente est le suivant :" #: library/asyncio-eventloop.rst:414 msgid "" "The connection is established and a :ref:`transport ` is " "created for it." msgstr "" +"La connexion est établie et un :ref:`transport asyncio ` " +"est créé pour cela." #: library/asyncio-eventloop.rst:417 msgid "" "*protocol_factory* is called without arguments and is expected to return a :" "ref:`protocol ` instance." msgstr "" +"*protocol_factory* est appelée sans arguments et doit renvoyer une instance " +"de :ref:`protocol asyncio `." #: library/asyncio-eventloop.rst:420 msgid "" "The protocol instance is coupled with the transport by calling its :meth:" "`~BaseProtocol.connection_made` method." msgstr "" +"L'instance de protocole est couplée au transport en appelant sa méthode :" +"meth:`~BaseProtocol.connection_made`." #: library/asyncio-eventloop.rst:423 msgid "A ``(transport, protocol)`` tuple is returned on success." -msgstr "" +msgstr "Un *n*-uplet ``(transport, protocol)`` est renvoyé en cas de succès." #: library/asyncio-eventloop.rst:425 msgid "" "The created transport is an implementation-dependent bidirectional stream." msgstr "" +"Le transport créé est un flux bidirectionnel dépendant de l'implémentation." #: library/asyncio-eventloop.rst:428 library/asyncio-eventloop.rst:549 msgid "Other arguments:" -msgstr "" +msgstr "Autres arguments :" #: library/asyncio-eventloop.rst:430 msgid "" @@ -578,10 +774,15 @@ msgid "" "`True`, a default context returned from :func:`ssl.create_default_context` " "is used." msgstr "" +"*ssl* : s'il est donné et non faux, un transport SSL/TLS est créé (par " +"défaut un transport TCP simple est créé). Si *ssl* est un objet :class:`ssl." +"SSLContext`, ce contexte est utilisé pour créer le transport ; si *ssl* est :" +"const:`True`, un contexte par défaut renvoyé par :func:`ssl." +"create_default_context` est utilisé." #: library/asyncio-eventloop.rst:436 msgid ":ref:`SSL/TLS security considerations `" -msgstr "" +msgstr ":ref:`Considérations sur la sécurité SSL/TLS `" #: library/asyncio-eventloop.rst:438 msgid "" @@ -593,6 +794,14 @@ msgid "" "matching is disabled (which is a serious security risk, allowing for " "potential man-in-the-middle attacks)." msgstr "" +"*server_hostname* définit ou remplace le nom d'hôte auquel le certificat du " +"serveur cible sera comparé. Ne doit être passé que si *ssl* n'est pas " +"``None``. Par défaut, la valeur de l'argument *host* est utilisée. Si *host* " +"est vide, il n'y a pas de valeur par défaut et vous devez transmettre une " +"valeur pour *server_hostname*. Si *server_hostname* est une chaîne vide, la " +"correspondance du nom d'hôte est désactivée (ce qui constitue un risque de " +"sécurité sérieux, permettant des attaques potentielles de type « homme du " +"milieu »)." #: library/asyncio-eventloop.rst:446 msgid "" @@ -601,16 +810,27 @@ msgid "" "these should all be integers from the corresponding :mod:`socket` module " "constants." msgstr "" +"*family*, *proto*, *flags* sont facultatifs et sont la famille d'adresse, le " +"protocole et les drapeaux à transmettre à *getaddrinfo()* pour la résolution " +"de *host*. S'ils sont fournis, ils doivent tous être des entiers provenant " +"des constantes du module :mod:`socket`." #: library/asyncio-eventloop.rst:451 msgid "" "*happy_eyeballs_delay*, if given, enables Happy Eyeballs for this " "connection. It should be a floating-point number representing the amount of " "time in seconds to wait for a connection attempt to complete, before " -"starting the next attempt in parallel. This is the \"Connection Attempt " -"Delay\" as defined in :rfc:`8305`. A sensible default value recommended by " -"the RFC is ``0.25`` (250 milliseconds)." +"starting the next attempt in parallel. This is the \"Connection Attempt Delay" +"\" as defined in :rfc:`8305`. A sensible default value recommended by the " +"RFC is ``0.25`` (250 milliseconds)." msgstr "" +"*happy_eyeballs_delay*, s'il est fourni, active Happy Eyeballs pour cette " +"connexion. Il doit s'agir d'un nombre à virgule flottante représentant le " +"temps d'attente en secondes pour qu'une tentative de connexion se termine, " +"avant de démarrer la prochaine tentative en parallèle. Il s'agit du « délai " +"de tentative de connexion » tel que défini dans la :rfc:`8305`. Une valeur " +"par défaut raisonnable recommandée par la RFC est ``0.25`` (250 " +"millisecondes)." #: library/asyncio-eventloop.rst:459 msgid "" @@ -618,10 +838,18 @@ msgid "" "multiple IP addresses. If ``0`` or unspecified, no reordering is done, and " "addresses are tried in the order returned by :meth:`getaddrinfo`. If a " "positive integer is specified, the addresses are interleaved by address " -"family, and the given integer is interpreted as \"First Address Family " -"Count\" as defined in :rfc:`8305`. The default is ``0`` if " -"*happy_eyeballs_delay* is not specified, and ``1`` if it is." +"family, and the given integer is interpreted as \"First Address Family Count" +"\" as defined in :rfc:`8305`. The default is ``0`` if *happy_eyeballs_delay* " +"is not specified, and ``1`` if it is." msgstr "" +"*interleave* contrôle la réorganisation des adresses lorsqu'un nom d'hôte se " +"résout en plusieurs adresses IP. S'il vaut ``0`` ou n'est pas spécifié, " +"aucune réorganisation n'est effectuée et les adresses sont essayées dans " +"l'ordre renvoyé par :meth:`getaddrinfo`. Si un entier positif est spécifié, " +"les adresses sont entrelacées par famille d'adresses et l'entier donné est " +"interprété comme \"First Address Family Count\" tel que défini dans la :rfc:" +"`8305`. La valeur par défaut est ``0`` si *happy_eyeballs_delay* n'est pas " +"spécifié, et ``1`` si c'est le cas." #: library/asyncio-eventloop.rst:468 msgid "" @@ -630,7 +858,12 @@ msgid "" "*host*, *port*, *family*, *proto*, *flags*, *happy_eyeballs_delay*, " "*interleave* and *local_addr* should be specified." msgstr "" +"*sock*, s'il est fourni, doit être un objet :class:`socket.socket` existant " +"et déjà connecté à utiliser par le transport. Si *sock* est donné, aucun des " +"*host*, *port*, *family*, *proto*, *flags*, *happy_eyeballs_delay*, " +"*interleave* et *local_addr* ne doit être spécifié." +# suit un : #: library/asyncio-eventloop.rst:476 library/asyncio-eventloop.rst:580 #: library/asyncio-eventloop.rst:804 msgid "" @@ -638,6 +871,9 @@ msgid "" "created. To close the socket, call the transport's :meth:`~asyncio." "BaseTransport.close` method." msgstr "" +"l'argument *sock* transfère la propriété du connecteur au transport créé. " +"Pour fermer le connecteur, appelez la méthode :meth:`~asyncio.BaseTransport." +"close` du transport." #: library/asyncio-eventloop.rst:480 msgid "" @@ -645,6 +881,10 @@ msgid "" "the socket locally. The *local_host* and *local_port* are looked up using " "``getaddrinfo()``, similarly to *host* and *port*." msgstr "" +"*local_addr*, s'il est fourni, est un *n*-uplet ``(local_host, local_port)`` " +"utilisé pour lier le connecteur localement. *local_host* et *local_port* " +"sont recherchés en utilisant ``getaddrinfo()``, de la même manière que " +"*host* et *port*." #: library/asyncio-eventloop.rst:484 library/asyncio-eventloop.rst:895 msgid "" @@ -652,6 +892,9 @@ msgid "" "wait for the TLS handshake to complete before aborting the connection. " "``60.0`` seconds if ``None`` (default)." msgstr "" +"*ssl_handshake_timeout* est (pour une connexion TLS) le temps en secondes à " +"attendre que la poignée de main TLS se termine avant d'abandonner la " +"connexion. ``60.0`` secondes si ``None`` (par défaut)." #: library/asyncio-eventloop.rst:488 library/asyncio-eventloop.rst:721 #: library/asyncio-eventloop.rst:815 library/asyncio-eventloop.rst:899 @@ -660,25 +903,33 @@ msgid "" "to complete before aborting the connection. ``30.0`` seconds if ``None`` " "(default)." msgstr "" +"*ssl_shutdown_timeout* est le temps en secondes à attendre que l'arrêt SSL " +"se termine avant d'abandonner la connexion. ``30.0`` secondes si ``None`` " +"(par défaut)." +# suit un : #: library/asyncio-eventloop.rst:494 library/asyncio-eventloop.rst:733 msgid "Added support for SSL/TLS in :class:`ProactorEventLoop`." msgstr "" +"ajout de la prise en charge de SSL/TLS dans :class:`ProactorEventLoop`." +# suit un : #: library/asyncio-eventloop.rst:498 msgid "" "The socket option :py:data:`~socket.TCP_NODELAY` is set by default for all " "TCP connections." msgstr "" +"l'option socket :py:data:`~socket.TCP_NODELAY` est définie par défaut pour " +"toutes les connexions TCP." #: library/asyncio-eventloop.rst:503 library/asyncio-eventloop.rst:825 -#, fuzzy msgid "Added the *ssl_handshake_timeout* parameter." -msgstr "ajout du paramètre ``name``." +msgstr "ajout du paramètre *ssl handshake timeout*" +# suit un : #: library/asyncio-eventloop.rst:507 msgid "Added the *happy_eyeballs_delay* and *interleave* parameters." -msgstr "" +msgstr "ajout des paramètres *happy_eyeballs_delay* et *interleave*." #: library/asyncio-eventloop.rst:509 msgid "" @@ -690,28 +941,40 @@ msgid "" "This document specifies requirements for algorithms that reduce this user-" "visible delay and provides an algorithm." msgstr "" +"Algorithme Happy Eyeballs : « succès avec les hôtes à double pile ». Lorsque " +"le chemin et le protocole IPv4 d'un serveur fonctionnent, mais que le chemin " +"et le protocole IPv6 du serveur ne fonctionnent pas, une application cliente " +"à double pile subit un retard de connexion important par rapport à un client " +"IPv4 uniquement. Ceci n'est pas souhaitable car cela entraîne une moins " +"bonne expérience utilisateur pour le client à double pile. Ce document " +"spécifie les exigences pour les algorithmes qui réduisent ce délai visible " +"par l'utilisateur et fournit un algorithme correspondant." #: library/asyncio-eventloop.rst:518 msgid "For more information: https://tools.ietf.org/html/rfc6555" msgstr "" +"Pour plus d'informations, consultez : https://tools.ietf.org/html/rfc6555" #: library/asyncio-eventloop.rst:522 library/asyncio-eventloop.rst:641 #: library/asyncio-eventloop.rst:747 library/asyncio-eventloop.rst:782 #: library/asyncio-eventloop.rst:829 library/asyncio-eventloop.rst:907 -#, fuzzy msgid "Added the *ssl_shutdown_timeout* parameter." -msgstr "ajout du paramètre ``name``." +msgstr "ajout du paramètre *ssl shutdown timeout*" +# suit un : #: library/asyncio-eventloop.rst:526 msgid "" "The :func:`open_connection` function is a high-level alternative API. It " "returns a pair of (:class:`StreamReader`, :class:`StreamWriter`) that can be " "used directly in async/await code." msgstr "" +"la fonction :func:`open_connection` est une API alternative de haut niveau. " +"Elle renvoie une paire de (:class:`StreamReader`, :class:`StreamWriter`) qui " +"peut être utilisée directement dans le code *async/wait*." #: library/asyncio-eventloop.rst:536 msgid "Create a datagram connection." -msgstr "Créer une connexion par datagramme" +msgstr "Création d'une connexion par datagramme" #: library/asyncio-eventloop.rst:538 msgid "" @@ -719,10 +982,13 @@ msgid "" "`~socket.AF_INET6`, or :py:data:`~socket.AF_UNIX`, depending on *host* (or " "the *family* argument, if provided)." msgstr "" +"La famille de connecteur peut être :py:data:`~socket.AF_INET`, :py:data:" +"`~socket.AF_INET6` ou :py:data:`~socket.AF_UNIX`, selon *host* (ou " +"l'argument *family*, s'il est fourni)." #: library/asyncio-eventloop.rst:542 msgid "The socket type will be :py:data:`~socket.SOCK_DGRAM`." -msgstr "" +msgstr "Le type de connecteur sera :py:data:`~socket.SOCK_DGRAM`." #: library/asyncio-eventloop.rst:544 library/asyncio-eventloop.rst:664 #: library/asyncio-eventloop.rst:796 @@ -730,10 +996,12 @@ msgid "" "*protocol_factory* must be a callable returning a :ref:`protocol ` implementation." msgstr "" +"*protocol_factory* doit être un appelable gérant le :ref:`protocole asyncio " +"`." #: library/asyncio-eventloop.rst:547 library/asyncio-eventloop.rst:623 msgid "A tuple of ``(transport, protocol)`` is returned on success." -msgstr "" +msgstr "Un *n*-uplet ``(transport, protocol)`` est renvoyé en cas de succès." #: library/asyncio-eventloop.rst:551 msgid "" @@ -741,6 +1009,9 @@ msgid "" "the socket locally. The *local_host* and *local_port* are looked up using :" "meth:`getaddrinfo`." msgstr "" +"*local_addr*, s'il est fourni, est un *n*-uplet ``(local_host, local_port)`` " +"utilisé pour lier le connecteur localement. Le *local_host* et le " +"*local_port* sont recherchés en utilisant :meth:`getaddrinfo`." #: library/asyncio-eventloop.rst:555 msgid "" @@ -748,6 +1019,10 @@ msgid "" "connect the socket to a remote address. The *remote_host* and *remote_port* " "are looked up using :meth:`getaddrinfo`." msgstr "" +"*remote_addr*, s'il est fourni, est un *n*-uplet ``(remote_host, " +"remote_port)`` utilisé pour se connecter à une adresse distante. Le " +"*remote_host* et le *remote_port* sont recherchés en utilisant :meth:" +"`getaddrinfo`." #: library/asyncio-eventloop.rst:559 msgid "" @@ -756,6 +1031,10 @@ msgid "" "given, these should all be integers from the corresponding :mod:`socket` " "module constants." msgstr "" +"*family*, *proto*, *flags* sont facultatifs et représentent la famille " +"d'adresse, le protocole et les drapeaux à transmettre à :meth:`getaddrinfo` " +"pour la résolution *host*. S'ils sont fournis, ils doivent tous être des " +"entiers provenant des constantes du module :mod:`socket`." #: library/asyncio-eventloop.rst:564 msgid "" @@ -765,12 +1044,20 @@ msgid "" "Unixes. If the :py:data:`~socket.SO_REUSEPORT` constant is not defined then " "this capability is unsupported." msgstr "" +"*reuse_port* indique au noyau d'autoriser ce point de terminaison à être lié " +"au même port que les autres points de terminaison existants, tant qu'ils " +"définissent tous cet indicateur lors de leur création. Cette option n'est " +"pas prise en charge sous Windows et certains Unix. Si la constante :py:data:" +"`~socket.SO_REUSEPORT` n'est pas définie, cette fonctionnalité n'est pas " +"prise en charge." #: library/asyncio-eventloop.rst:570 msgid "" "*allow_broadcast* tells the kernel to allow this endpoint to send messages " "to the broadcast address." msgstr "" +"*allow_broadcast* indique au noyau d'autoriser ce point de terminaison à " +"envoyer des messages à l'adresse de *broadcast*." #: library/asyncio-eventloop.rst:573 msgid "" @@ -779,25 +1066,38 @@ msgid "" "specified, *local_addr* and *remote_addr* should be omitted (must be :const:" "`None`)." msgstr "" +"*sock* peut éventuellement être spécifié afin d'utiliser un objet :class:" +"`socket.socket` préexistant, déjà connecté, à utiliser par le transport. Si " +"spécifié, *local_addr* et *remote_addr* doivent être omis (doit être :const:" +"`None`)." #: library/asyncio-eventloop.rst:584 msgid "" "See :ref:`UDP echo client protocol ` and :" "ref:`UDP echo server protocol ` examples." msgstr "" +"Voir les exemples :ref:`asyncio-udp-echo-client-protocol` et :ref:`asyncio-" +"udp-echo-server-protocol`." +# suit un : #: library/asyncio-eventloop.rst:587 msgid "" "The *family*, *proto*, *flags*, *reuse_address*, *reuse_port*, " "*allow_broadcast*, and *sock* parameters were added." msgstr "" +"les paramètres *family*, *proto*, *flags*, *reuse_address*, *reuse_port*, " +"*allow_broadcast* et *sock* ont été ajoutés." +# suit un : #: library/asyncio-eventloop.rst:591 msgid "" "The *reuse_address* parameter is no longer supported, as using :py:data:" "`~sockets.SO_REUSEADDR` poses a significant security concern for UDP. " "Explicitly passing ``reuse_address=True`` will raise an exception." msgstr "" +"le paramètre *reuse_address* n'est plus pris en charge, car l'utilisation " +"de :py:data:`~sockets.SO_REUSEADDR` pose un problème de sécurité important " +"pour UDP. Passer explicitement ``reuse_address=True`` lève une exception." #: library/asyncio-eventloop.rst:596 msgid "" @@ -805,6 +1105,10 @@ msgid "" "UDP socket address with ``SO_REUSEADDR``, incoming packets can become " "randomly distributed among the sockets." msgstr "" +"Lorsque plusieurs processus avec des UID différents attribuent des " +"connecteurs à une adresse de connecteur UDP identique avec ``SO_REUSEADDR``, " +"les paquets entrants peuvent être distribués de manière aléatoire entre les " +"connecteurs." #: library/asyncio-eventloop.rst:600 msgid "" @@ -813,26 +1117,37 @@ msgid "" "is used instead, which specifically prevents processes with differing UIDs " "from assigning sockets to the same socket address." msgstr "" +"Pour les plates-formes prises en charge, *reuse_port* peut être utilisé en " +"remplacement d'une fonctionnalité similaire. Avec *reuse_port*, :py:data:" +"`~sockets.SO_REUSEPORT` est utilisé à la place, ce qui empêche " +"spécifiquement les processus avec des UID différents d'attribuer des " +"connecteurs à la même adresse de connecteur." +# suit un : #: library/asyncio-eventloop.rst:606 msgid "Added support for Windows." -msgstr "Prise en charge sur Windows." +msgstr "prise en charge sur Windows." +# suit un : #: library/asyncio-eventloop.rst:609 msgid "" "The *reuse_address* parameter, disabled since Python 3.9.0, 3.8.1, 3.7.6 and " "3.6.10, has been entirely removed." msgstr "" +"le paramètre *reuse_address*, désactivé depuis Python 3.9.0, 3.8.1, 3.7.6 et " +"3.6.10, a été entièrement supprimé." #: library/asyncio-eventloop.rst:618 msgid "Create a Unix connection." -msgstr "Créer une connexion Unix" +msgstr "Crée une connexion Unix" #: library/asyncio-eventloop.rst:620 msgid "" "The socket family will be :py:data:`~socket.AF_UNIX`; socket type will be :" "py:data:`~socket.SOCK_STREAM`." msgstr "" +"La famille de connecteur est :py:data:`~socket.AF_UNIX` ; le type de " +"connecteur est :py:data:`~socket.SOCK_STREAM`." #: library/asyncio-eventloop.rst:625 msgid "" @@ -840,12 +1155,18 @@ msgid "" "parameter is specified. Abstract Unix sockets, :class:`str`, :class:" "`bytes`, and :class:`~pathlib.Path` paths are supported." msgstr "" +"*path* est le nom d'un connecteur de domaine Unix et est obligatoire, sauf " +"si un paramètre *sock* est spécifié. Les connecteurs Unix abstraits, les " +"chemins :class:`str`, :class:`bytes` et :class:`~pathlib.Path` sont pris en " +"charge." #: library/asyncio-eventloop.rst:630 msgid "" "See the documentation of the :meth:`loop.create_connection` method for " "information about arguments to this method." msgstr "" +"Voir la documentation de la méthode :meth:`loop.create_connection` pour plus " +"d'informations sur les arguments de cette méthode." #: library/asyncio-eventloop.rst:633 library/asyncio-eventloop.rst:773 #: library/asyncio-eventloop.rst:1199 @@ -857,23 +1178,26 @@ msgid "" "Added the *ssl_handshake_timeout* parameter. The *path* parameter can now be " "a :term:`path-like object`." msgstr "" +"ajout du paramètre *ssl_handshake_timeout*. Le paramètre *chemin* peut " +"désormais être un :term:`objet simili-chemin `." #: library/asyncio-eventloop.rst:645 msgid "Creating network servers" -msgstr "Créer des serveurs" +msgstr "Création de serveurs" #: library/asyncio-eventloop.rst:657 msgid "" "Create a TCP server (socket type :data:`~socket.SOCK_STREAM`) listening on " "*port* of the *host* address." msgstr "" +"Crée un serveur TCP (type de connecteur :data:`~socket.SOCK_STREAM`) " +"écoutant sur le *port* de l'adresse *hôte*." #: library/asyncio-eventloop.rst:660 msgid "Returns a :class:`Server` object." -msgstr "" +msgstr "Renvoie un objet :class:`Server`." #: library/asyncio-eventloop.rst:662 -#, fuzzy msgid "Arguments:" msgstr "Arguments :" @@ -882,18 +1206,24 @@ msgid "" "The *host* parameter can be set to several types which determine where the " "server would be listening:" msgstr "" +"Le paramètre *host* peut être défini sur plusieurs types qui déterminent où " +"le serveur écoute :" #: library/asyncio-eventloop.rst:670 msgid "" "If *host* is a string, the TCP server is bound to a single network interface " "specified by *host*." msgstr "" +"Si *host* est une chaîne, le serveur TCP est lié à une seule interface " +"réseau spécifiée par *host*." #: library/asyncio-eventloop.rst:673 msgid "" "If *host* is a sequence of strings, the TCP server is bound to all network " "interfaces specified by the sequence." msgstr "" +"Si *host* est une séquence de chaînes, le serveur TCP est lié à toutes les " +"interfaces réseau spécifiées par la séquence." #: library/asyncio-eventloop.rst:676 msgid "" @@ -901,6 +1231,9 @@ msgid "" "list of multiple sockets will be returned (most likely one for IPv4 and " "another one for IPv6)." msgstr "" +"Si *host* est une chaîne vide ou ``None``, toutes les interfaces sont prises " +"en compte et une liste de plusieurs connecteurs est renvoyée (probablement " +"une pour IPv4 et une autre pour IPv6)." #: library/asyncio-eventloop.rst:680 msgid "" @@ -909,6 +1242,11 @@ msgid "" "selected (note that if *host* resolves to multiple network interfaces, a " "different random port will be selected for each interface)." msgstr "" +"Le paramètre *port* peut être défini pour spécifier sur quel port le serveur " +"doit écouter. Si ``0`` ou ``None`` (la valeur par défaut), un port inutilisé " +"aléatoire est sélectionné (notez que si *host* se résout en plusieurs " +"interfaces réseau, un port aléatoire différent est sélectionné pour chaque " +"interface)." #: library/asyncio-eventloop.rst:685 msgid "" @@ -916,6 +1254,10 @@ msgid "" "AF_INET6` to force the socket to use IPv4 or IPv6. If not set, the *family* " "will be determined from host name (defaults to :data:`~socket.AF_UNSPEC`)." msgstr "" +"*family* peut être défini sur :data:`socket.AF_INET` ou sur :data:`~socket." +"AF_INET6` pour forcer le connecteur à utiliser IPv4 ou IPv6. Si elle n'est " +"pas définie, *family* est déterminée à partir du nom d'hôte (par défaut :" +"data:`~socket.AF_UNSPEC`)." #: library/asyncio-eventloop.rst:690 msgid "*flags* is a bitmask for :meth:`getaddrinfo`." @@ -926,24 +1268,35 @@ msgid "" "*sock* can optionally be specified in order to use a preexisting socket " "object. If specified, *host* and *port* must not be specified." msgstr "" +"*sock* peut éventuellement être spécifié afin d'utiliser un objet connecteur " +"préexistant. S'il est spécifié, *host* et *port* ne doivent pas être " +"spécifiés." +# suit un : #: library/asyncio-eventloop.rst:697 msgid "" "The *sock* argument transfers ownership of the socket to the server created. " "To close the socket, call the server's :meth:`~asyncio.Server.close` method." msgstr "" +"l'argument *sock* transfère la propriété du connecteur au serveur créé. Pour " +"fermer le connecteur, appelez la méthode :meth:`~asyncio.Server.close` du " +"serveur." #: library/asyncio-eventloop.rst:701 msgid "" "*backlog* is the maximum number of queued connections passed to :meth:" "`~socket.socket.listen` (defaults to 100)." msgstr "" +"*backlog* est le nombre maximum de connexions en file d'attente passées à :" +"meth:`~socket.socket.listen` (par défaut à 100)." #: library/asyncio-eventloop.rst:704 msgid "" "*ssl* can be set to an :class:`~ssl.SSLContext` instance to enable TLS over " "the accepted connections." msgstr "" +"*ssl* peut être défini sur une instance :class:`~ssl.SSLContext` pour " +"activer TLS sur les connexions acceptées." #: library/asyncio-eventloop.rst:707 msgid "" @@ -951,6 +1304,10 @@ msgid "" "state, without waiting for its natural timeout to expire. If not specified " "will automatically be set to ``True`` on Unix." msgstr "" +"*reuse_address* indique au noyau de réutiliser un connecteur local dans " +"l'état ``TIME_WAIT``, sans attendre l'expiration de son délai d'attente " +"naturel. S'il n'est pas spécifié, il est automatiquement défini sur ``True`` " +"sous Unix." #: library/asyncio-eventloop.rst:712 msgid "" @@ -958,6 +1315,10 @@ msgid "" "port as other existing endpoints are bound to, so long as they all set this " "flag when being created. This option is not supported on Windows." msgstr "" +"*reuse_port* indique au noyau d'autoriser ce point de terminaison à être lié " +"au même port que les autres points de terminaison existants, tant qu'ils " +"définissent tous cet indicateur lors de leur création. Cette option n'est " +"pas prise en charge sous Windows." #: library/asyncio-eventloop.rst:717 msgid "" @@ -965,6 +1326,9 @@ msgid "" "for the TLS handshake to complete before aborting the connection. ``60.0`` " "seconds if ``None`` (default)." msgstr "" +"*ssl_handshake_timeout* est (pour un serveur TLS) le temps en secondes à " +"attendre que la poignée de main TLS se termine avant d'abandonner la " +"connexion. ``60.0`` secondes si ``None`` (par défaut)." #: library/asyncio-eventloop.rst:725 msgid "" @@ -973,30 +1337,46 @@ msgid "" "should await on :meth:`Server.start_serving` or :meth:`Server.serve_forever` " "to make the server to start accepting connections." msgstr "" +"*start_serving* défini à ``True`` (valeur par défaut) fait que le serveur " +"créé commence immédiatement à accepter les connexions. Lorsqu'il est défini " +"sur ``False``, l'utilisateur doit attendre sur :meth:`Server.start_serving` " +"ou :meth:`Server.serve_forever` pour que le serveur commence à accepter les " +"connexions." +# suit un : #: library/asyncio-eventloop.rst:737 msgid "The *host* parameter can be a sequence of strings." -msgstr "" +msgstr "le paramètre *host* peut être une séquence de chaînes." +# suit un : #: library/asyncio-eventloop.rst:741 msgid "" "Added *ssl_handshake_timeout* and *start_serving* parameters. The socket " "option :py:data:`~socket.TCP_NODELAY` is set by default for all TCP " "connections." msgstr "" +"ajout des paramètres *ssl_handshake_timeout* et *start_serving*. L'option " +"socket :py:data:`~socket.TCP_NODELAY` est définie par défaut pour toutes les " +"connexions TCP." +# suit un : #: library/asyncio-eventloop.rst:751 msgid "" "The :func:`start_server` function is a higher-level alternative API that " "returns a pair of :class:`StreamReader` and :class:`StreamWriter` that can " "be used in an async/await code." msgstr "" +"la fonction :func:`start_server` est une API alternative de niveau supérieur " +"qui renvoie une paire de :class:`StreamReader` et :class:`StreamWriter` qui " +"peut être utilisée dans un code *async/wait*." #: library/asyncio-eventloop.rst:762 msgid "" "Similar to :meth:`loop.create_server` but works with the :py:data:`~socket." "AF_UNIX` socket family." msgstr "" +"Similaire à :meth:`loop.create_server` mais fonctionne avec la famille de " +"connecteurs :py:data:`~socket.AF_UNIX`." #: library/asyncio-eventloop.rst:765 msgid "" @@ -1004,28 +1384,40 @@ msgid "" "argument is provided. Abstract Unix sockets, :class:`str`, :class:`bytes`, " "and :class:`~pathlib.Path` paths are supported." msgstr "" +"*path* est le nom d'un connecteur de domaine Unix et est obligatoire, sauf " +"si un argument *sock* est fourni. Les connecteurs Unix abstraits, les " +"chemins :class:`str`, :class:`bytes` et :class:`~pathlib.Path` sont pris en " +"charge." #: library/asyncio-eventloop.rst:770 msgid "" "See the documentation of the :meth:`loop.create_server` method for " "information about arguments to this method." msgstr "" +"Voir la documentation de la méthode :meth:`loop.create_server` pour plus " +"d'informations sur les arguments de cette méthode." +# suit un : #: library/asyncio-eventloop.rst:777 msgid "" "Added the *ssl_handshake_timeout* and *start_serving* parameters. The *path* " "parameter can now be a :class:`~pathlib.Path` object." msgstr "" +"ajout des paramètres *ssl_handshake_timeout* et *start_serving*. Le " +"paramètre *path* peut maintenant être un objet :class:`~pathlib.Path`." #: library/asyncio-eventloop.rst:789 msgid "Wrap an already accepted connection into a transport/protocol pair." msgstr "" +"Enveloppe une connexion déjà acceptée dans une paire transport/protocole." #: library/asyncio-eventloop.rst:791 msgid "" "This method can be used by servers that accept connections outside of " "asyncio but that use asyncio to handle them." msgstr "" +"Cette méthode peut être utilisée par les serveurs qui acceptent les " +"connexions en dehors d'*asyncio* mais qui utilisent *asyncio* pour les gérer." #: library/asyncio-eventloop.rst:794 library/asyncio-eventloop.rst:881 msgid "Parameters:" @@ -1036,12 +1428,16 @@ msgid "" "*sock* is a preexisting socket object returned from :meth:`socket.accept " "`." msgstr "" +"*sock* est un objet connecteur préexistant renvoyé par :meth:`socket.accept " +"`." #: library/asyncio-eventloop.rst:808 msgid "" "*ssl* can be set to an :class:`~ssl.SSLContext` to enable SSL over the " "accepted connections." msgstr "" +"*ssl* peut être défini sur une :class:`~ssl.SSLContext` pour activer SSL sur " +"les connexions acceptées." #: library/asyncio-eventloop.rst:811 msgid "" @@ -1049,27 +1445,33 @@ msgid "" "wait for the SSL handshake to complete before aborting the connection. " "``60.0`` seconds if ``None`` (default)." msgstr "" +"*ssl_handshake_timeout* est (pour une connexion SSL) le temps en secondes à " +"attendre que la poignée de main SSL se termine avant d'abandonner la " +"connexion. ``60.0`` secondes si ``None`` (par défaut)." #: library/asyncio-eventloop.rst:819 msgid "Returns a ``(transport, protocol)`` pair." -msgstr "" +msgstr "Renvoie une paire ``(transport, protocole)``." #: library/asyncio-eventloop.rst:833 msgid "Transferring files" -msgstr "" +msgstr "Transfert de fichiers" #: library/asyncio-eventloop.rst:838 msgid "" "Send a *file* over a *transport*. Return the total number of bytes sent." msgstr "" +"Envoie *file* via *transport*. Renvoie le nombre total d'octets envoyés." #: library/asyncio-eventloop.rst:841 msgid "The method uses high-performance :meth:`os.sendfile` if available." msgstr "" +"La méthode utilise :meth:`os.sendfile` (hautes performances) si elle est " +"disponible." #: library/asyncio-eventloop.rst:843 msgid "*file* must be a regular file object opened in binary mode." -msgstr "" +msgstr "*file* doit être un objet fichier normal ouvert en mode binaire." #: library/asyncio-eventloop.rst:845 library/asyncio-eventloop.rst:1087 msgid "" @@ -1079,6 +1481,12 @@ msgid "" "raises an error, and :meth:`file.tell() ` can be used to " "obtain the actual number of bytes sent." msgstr "" +"*offset* indique où commencer la lecture du fichier. Si spécifié, *count* " +"est le nombre total d'octets à transmettre, par opposition à l'envoi du " +"fichier jusqu'à ce que EOF soit atteint. La position du fichier est toujours " +"mise à jour, même lorsque cette méthode génère une erreur. :meth:`file." +"tell() ` peut être utilisée pour obtenir le nombre d'octets " +"réellement envoyés." #: library/asyncio-eventloop.rst:852 msgid "" @@ -1086,16 +1494,21 @@ msgid "" "when the platform does not support the sendfile system call (e.g. Windows or " "SSL socket on Unix)." msgstr "" +"*fallback* défini sur ``True`` permet à *asyncio* de lire et d'envoyer " +"manuellement le fichier lorsque la plateforme ne prend pas en charge l'appel " +"système *sendfile* (par exemple, Windows ou connecteur SSL sous Unix)." #: library/asyncio-eventloop.rst:856 msgid "" "Raise :exc:`SendfileNotAvailableError` if the system does not support the " "*sendfile* syscall and *fallback* is ``False``." msgstr "" +"Lève :exc:`SendfileNotAvailableError` si le système ne prend pas en charge " +"l'appel système *sendfile* et que *fallback* est ``False``." #: library/asyncio-eventloop.rst:863 msgid "TLS Upgrade" -msgstr "" +msgstr "Passage du flux en TLS" #: library/asyncio-eventloop.rst:870 msgid "Upgrade an existing transport-based connection to TLS." @@ -1107,6 +1520,9 @@ msgid "" "and the *protocol*. The coder/decoder implements both *transport*-facing " "protocol and *protocol*-facing transport." msgstr "" +"Crée une instance de codeur-décodeur TLS et l'insère entre le *transport* et " +"le *protocol*. Le codeur-décodeur implémente à la fois le protocole vers le " +"*transport* et le transport vers le *protocol*." #: library/asyncio-eventloop.rst:876 msgid "" @@ -1115,72 +1531,99 @@ msgid "" "object only because the coder caches *protocol*-side data and sporadically " "exchanges extra TLS session packets with *transport*." msgstr "" +"Renvoie l'instance à deux interfaces créée. Après *await*, le *protocol* " +"doit cesser d'utiliser le *transport* d'origine et communiquer avec l'objet " +"renvoyé uniquement parce que le codeur met en cache les données côté " +"*protocol* et échange sporadiquement des paquets de session TLS " +"supplémentaires avec *transport*." #: library/asyncio-eventloop.rst:883 msgid "" "*transport* and *protocol* instances that methods like :meth:`~loop." "create_server` and :meth:`~loop.create_connection` return." msgstr "" +"*transport* et *protocol* que des méthodes comme :meth:`~loop.create_server` " +"et :meth:`~loop.create_connection` renvoient." #: library/asyncio-eventloop.rst:887 msgid "*sslcontext*: a configured instance of :class:`~ssl.SSLContext`." -msgstr "" +msgstr "*sslcontext* : une instance configurée de :class:`~ssl.SSLContext`." #: library/asyncio-eventloop.rst:889 msgid "" "*server_side* pass ``True`` when a server-side connection is being upgraded " "(like the one created by :meth:`~loop.create_server`)." msgstr "" +"*server_side* passe à ``True`` lorsqu'une connexion côté serveur est mise à " +"jour (comme celle créée par :meth:`~loop.create_server`)." #: library/asyncio-eventloop.rst:892 msgid "" "*server_hostname*: sets or overrides the host name that the target server's " "certificate will be matched against." msgstr "" +"*server_hostname* : définit ou remplace le nom d'hôte auquel le certificat " +"du serveur cible est comparé." #: library/asyncio-eventloop.rst:912 msgid "Watching file descriptors" -msgstr "Surveiller des descripteurs de fichiers" +msgstr "Surveillance de descripteur de fichier" #: library/asyncio-eventloop.rst:916 msgid "" "Start monitoring the *fd* file descriptor for read availability and invoke " "*callback* with the specified arguments once *fd* is available for reading." msgstr "" +"Commence à surveiller la disponibilité en lecture du descripteur de fichier " +"*fd* et appelle *callback* avec les arguments spécifiés une fois que *fd* " +"est disponible en lecture." #: library/asyncio-eventloop.rst:922 msgid "" "Stop monitoring the *fd* file descriptor for read availability. Returns " "``True`` if *fd* was previously being monitored for reads." msgstr "" +"Arrête de surveiller le descripteur de fichier *fd* pour la disponibilité en " +"lecture. Renvoie ``True`` si *fd* était précédemment surveillé pour les " +"lectures." #: library/asyncio-eventloop.rst:927 msgid "" "Start monitoring the *fd* file descriptor for write availability and invoke " "*callback* with the specified arguments once *fd* is available for writing." msgstr "" +"Commence à surveiller le descripteur de fichier *fd* pour la disponibilité " +"en écriture et appelle *callback* avec les arguments spécifiés une fois que " +"*fd* est disponible en écriture." #: library/asyncio-eventloop.rst:931 library/asyncio-eventloop.rst:1186 msgid "" "Use :func:`functools.partial` :ref:`to pass keyword arguments ` to *callback*." msgstr "" +"Utilisez :func:`functools.partial` pour :ref:`passer des arguments nommés " +"` à *callback*." #: library/asyncio-eventloop.rst:936 msgid "" "Stop monitoring the *fd* file descriptor for write availability. Returns " "``True`` if *fd* was previously being monitored for writes." msgstr "" +"Arrête de surveiller le descripteur de fichier *fd* pour la disponibilité en " +"écriture. Renvoie ``True`` si *fd* était précédemment surveillé pour les " +"écritures." #: library/asyncio-eventloop.rst:939 msgid "" "See also :ref:`Platform Support ` section for some " "limitations of these methods." msgstr "" +"Voir aussi la section :ref:`Prise en charge de la plate-forme ` pour certaines limitations de ces méthodes." #: library/asyncio-eventloop.rst:944 msgid "Working with socket objects directly" -msgstr "" +msgstr "Travail direct avec des objets *socket*" #: library/asyncio-eventloop.rst:946 msgid "" @@ -1190,16 +1633,24 @@ msgid "" "cases when performance is not critical, and working with :class:`~socket." "socket` objects directly is more convenient." msgstr "" +"En général, les implémentations de protocole qui utilisent des API basées " +"sur le transport telles que :meth:`loop.create_connection` et :meth:`loop." +"create_server` sont plus rapides que les implémentations qui fonctionnent " +"directement avec les *sockets*. Cependant, il existe des cas d'utilisation " +"où les performances ne sont pas critiques, et travailler directement avec " +"les objets :class:`~socket.socket` est plus pratique." #: library/asyncio-eventloop.rst:955 msgid "" "Receive up to *nbytes* from *sock*. Asynchronous version of :meth:`socket." "recv() `." msgstr "" +"Reçoit jusqu'à *nbytes* de *sock*. Version asynchrone de :meth:`socket." +"recv() `." #: library/asyncio-eventloop.rst:958 msgid "Return the received data as a bytes object." -msgstr "" +msgstr "Renvoie les données reçues sous la forme d'un objet bytes." #: library/asyncio-eventloop.rst:960 library/asyncio-eventloop.rst:974 #: library/asyncio-eventloop.rst:985 library/asyncio-eventloop.rst:997 @@ -1209,48 +1660,60 @@ msgstr "" msgid "*sock* must be a non-blocking socket." msgstr "Le connecteur *sock* ne doit pas être bloquant." +# suit un : #: library/asyncio-eventloop.rst:962 msgid "" "Even though this method was always documented as a coroutine method, " "releases before Python 3.7 returned a :class:`Future`. Since Python 3.7 this " "is an ``async def`` method." msgstr "" +"même si cette méthode a toujours été documentée en tant que méthode " +"coroutine, les versions antérieures à Python 3.7 renvoyaient un :class:" +"`Future`. Depuis Python 3.7, il s'agit d'une méthode ``async def``." #: library/asyncio-eventloop.rst:969 msgid "" "Receive data from *sock* into the *buf* buffer. Modeled after the blocking :" "meth:`socket.recv_into() ` method." msgstr "" +"Reçoit les données de *sock* dans le tampon *buf*. Basée sur le modèle de la " +"méthode bloquante :meth:`socket.recv_into() `." #: library/asyncio-eventloop.rst:972 msgid "Return the number of bytes written to the buffer." -msgstr "" +msgstr "Renvoie le nombre d'octets écrits dans le tampon." #: library/asyncio-eventloop.rst:980 msgid "" "Receive a datagram of up to *bufsize* from *sock*. Asynchronous version of :" "meth:`socket.recvfrom() `." msgstr "" +"Reçoit un datagramme jusqu'à *bufsize* de *sock*. Version asynchrone de :" +"meth:`socket.recvfrom() `." #: library/asyncio-eventloop.rst:983 msgid "Return a tuple of (received data, remote address)." -msgstr "" +msgstr "Renvoie un *n*-uplet (données reçues, adresse distante)." #: library/asyncio-eventloop.rst:991 msgid "" "Receive a datagram of up to *nbytes* from *sock* into *buf*. Asynchronous " "version of :meth:`socket.recvfrom_into() `." msgstr "" +"Reçoit un datagramme jusqu'à *nbytes* de *sock* vers *buf*. Version " +"asynchrone de :meth:`socket.recvfrom_into() `." #: library/asyncio-eventloop.rst:995 msgid "Return a tuple of (number of bytes received, remote address)." -msgstr "" +msgstr "Renvoie un *n*-uplet (nombre d'octets reçus, adresse distante)." #: library/asyncio-eventloop.rst:1003 msgid "" "Send *data* to the *sock* socket. Asynchronous version of :meth:`socket." "sendall() `." msgstr "" +"Envoie les données *data* au connecteur *sock*. Version asynchrone de :meth:" +"`socket.sendall() `." #: library/asyncio-eventloop.rst:1006 msgid "" @@ -1260,33 +1723,45 @@ msgid "" "how much data, if any, was successfully processed by the receiving end of " "the connection." msgstr "" +"Cette méthode continue d'envoyer des données au connecteur jusqu'à ce que " +"toutes les *data* aient été envoyées ou qu'une erreur se produise. ``None`` " +"est renvoyé en cas de succès. En cas d'erreur, une exception est levée. De " +"plus, il n'existe aucun moyen de déterminer la quantité de données, le cas " +"échéant, qui a été traitée avec succès par l'extrémité réceptrice de la " +"connexion." +# suit un : #: library/asyncio-eventloop.rst:1014 library/asyncio-eventloop.rst:1065 msgid "" "Even though the method was always documented as a coroutine method, before " "Python 3.7 it returned a :class:`Future`. Since Python 3.7, this is an " "``async def`` method." msgstr "" +"même si la méthode a toujours été documentée en tant que méthode coroutine, " +"avant Python 3.7, elle renvoyait un :class:`Future`. Depuis Python 3.7, il " +"s'agit d'une méthode ``async def``." #: library/asyncio-eventloop.rst:1021 msgid "" "Send a datagram from *sock* to *address*. Asynchronous version of :meth:" "`socket.sendto() `." msgstr "" +"Envoie un datagramme de *sock* à *address*. Version asynchrone de :meth:" +"`socket.sendto() `." #: library/asyncio-eventloop.rst:1025 -#, fuzzy msgid "Return the number of bytes sent." -msgstr "Active le mode débogage pour la boucle d'évènements." +msgstr "Renvoie le nombre d'octets envoyés." #: library/asyncio-eventloop.rst:1033 msgid "Connect *sock* to a remote socket at *address*." -msgstr "" +msgstr "Connecte *sock* à un connecteur distant situé à *address*." #: library/asyncio-eventloop.rst:1035 msgid "" "Asynchronous version of :meth:`socket.connect() `." msgstr "" +"Version asynchrone de :meth:`socket.connect() `." #: library/asyncio-eventloop.rst:1039 msgid "" @@ -1295,18 +1770,25 @@ msgid "" "inet_pton`. If not, :meth:`loop.getaddrinfo` will be used to resolve the " "*address*." msgstr "" +"``address`` n'a plus besoin d'être résolu. ``sock_connect`` essaie de " +"vérifier si *address* est déjà résolue en appelant :func:`socket.inet_pton`. " +"Sinon, :meth:`loop.getaddrinfo` est utilisé pour résoudre *address*." #: library/asyncio-eventloop.rst:1048 msgid "" ":meth:`loop.create_connection` and :func:`asyncio.open_connection() " "`." msgstr "" +":meth:`loop.create_connection` et :func:`asyncio.open_connection() " +"`." #: library/asyncio-eventloop.rst:1054 msgid "" "Accept a connection. Modeled after the blocking :meth:`socket.accept() " "` method." msgstr "" +"Accepte une connexion. Basée sur le modèle de la méthode bloquante :meth:" +"`socket.accept() `." #: library/asyncio-eventloop.rst:1057 msgid "" @@ -1315,31 +1797,41 @@ msgid "" "object usable to send and receive data on the connection, and *address* is " "the address bound to the socket on the other end of the connection." msgstr "" +"Le connecteur doit être lié à une adresse et écouter les connexions. La " +"valeur de retour est une paire ``(conn, adresse)`` où *conn* est un *nouvel* " +"objet socket utilisable pour envoyer et recevoir des données sur la " +"connexion, et *adresse* est l'adresse liée au connecteur de l'autre côté de " +"la connexion." #: library/asyncio-eventloop.rst:1072 msgid ":meth:`loop.create_server` and :func:`start_server`." -msgstr "" +msgstr ":meth:`loop.create_server` et :func:`start_server`." #: library/asyncio-eventloop.rst:1077 msgid "" "Send a file using high-performance :mod:`os.sendfile` if possible. Return " "the total number of bytes sent." msgstr "" +"Envoie le fichier en utilisant :mod:`os.sendfile` (haute performance) si " +"possible. Renvoie le nombre total d'octets envoyés." #: library/asyncio-eventloop.rst:1080 msgid "" "Asynchronous version of :meth:`socket.sendfile() `." msgstr "" +"Version asynchrone de :meth:`socket.sendfile() `." #: library/asyncio-eventloop.rst:1082 msgid "" "*sock* must be a non-blocking :const:`socket.SOCK_STREAM` :class:`~socket." "socket`." msgstr "" +"*sock* doit être un :const:`socket.SOCK_STREAM` :class:`~socket.socket` non " +"bloquant." #: library/asyncio-eventloop.rst:1085 msgid "*file* must be a regular file object open in binary mode." -msgstr "" +msgstr "*file* doit être un objet fichier normal ouvert en mode binaire." #: library/asyncio-eventloop.rst:1094 msgid "" @@ -1347,25 +1839,32 @@ msgid "" "file when the platform does not support the sendfile syscall (e.g. Windows " "or SSL socket on Unix)." msgstr "" +"*fallback*, lorsqu'il est défini à ``True``, permet à *asyncio* de lire et " +"d'envoyer manuellement le fichier lorsque la plateforme ne prend pas en " +"charge l'appel système *sendfile* (par exemple, Windows ou connecteur SSL " +"sous Unix)." #: library/asyncio-eventloop.rst:1098 msgid "" "Raise :exc:`SendfileNotAvailableError` if the system does not support " "*sendfile* syscall and *fallback* is ``False``." msgstr "" +"Lève une :exc:`SendfileNotAvailableError` si le système ne prend pas en " +"charge l'appel système *sendfile* et que *fallback* est ``False``." #: library/asyncio-eventloop.rst:1107 msgid "DNS" -msgstr "" +msgstr "DNS" #: library/asyncio-eventloop.rst:1112 msgid "Asynchronous version of :meth:`socket.getaddrinfo`." -msgstr "" +msgstr "Version asynchrone de :meth:`socket.getaddrinfo`." #: library/asyncio-eventloop.rst:1116 msgid "Asynchronous version of :meth:`socket.getnameinfo`." -msgstr "" +msgstr "Version asynchrone de :meth:`socket.getnameinfo`." +# suit un : #: library/asyncio-eventloop.rst:1118 msgid "" "Both *getaddrinfo* and *getnameinfo* methods were always documented to " @@ -1373,10 +1872,14 @@ msgid "" "class:`asyncio.Future` objects. Starting with Python 3.7 both methods are " "coroutines." msgstr "" +"les méthodes *getaddrinfo* et *getnameinfo* ont toujours été documentées " +"pour renvoyer une coroutine, mais avant Python 3.7, elles renvoyaient en " +"fait des objets :class:`asyncio.Future`. À partir de Python 3.7, les deux " +"méthodes sont des coroutines." #: library/asyncio-eventloop.rst:1126 msgid "Working with pipes" -msgstr "" +msgstr "Travail avec des tubes (*pipes*)" #: library/asyncio-eventloop.rst:1130 msgid "Register the read end of *pipe* in the event loop." @@ -1385,7 +1888,7 @@ msgstr "" #: library/asyncio-eventloop.rst:1135 msgid "*pipe* is a :term:`file-like object `." -msgstr "" +msgstr "*pipe* est un :term:`simili-fichier `." #: library/asyncio-eventloop.rst:1137 msgid "" @@ -1393,12 +1896,17 @@ msgid "" "`ReadTransport` interface and *protocol* is an object instantiated by the " "*protocol_factory*." msgstr "" +"Renvoie la paire ``(transport, protocol)``, où *transport* prend en charge " +"l'interface :class:`ReadTransport` et *protocol* est un objet instancié par " +"*protocol_factory*." #: library/asyncio-eventloop.rst:1141 library/asyncio-eventloop.rst:1157 msgid "" "With :class:`SelectorEventLoop` event loop, the *pipe* is set to non-" "blocking mode." msgstr "" +"Avec la boucle d'événements :class:`SelectorEventLoop`, le *pipe* est mis en " +"mode non bloquant." #: library/asyncio-eventloop.rst:1146 msgid "Register the write end of *pipe* in the event loop." @@ -1406,7 +1914,7 @@ msgstr "Branche l'extrémité en écriture de *pipe* à la boucle d'évènements #: library/asyncio-eventloop.rst:1151 msgid "*pipe* is :term:`file-like object `." -msgstr "" +msgstr "*pipe* est un :term:`simili-fichier `." #: library/asyncio-eventloop.rst:1153 msgid "" @@ -1414,17 +1922,24 @@ msgid "" "`WriteTransport` interface and *protocol* is an object instantiated by the " "*protocol_factory*." msgstr "" +"Renvoie la paire ``(transport, protocol)``, où *transport* prend en charge " +"l'interface :class:`WriteTransport` et *protocol* est un objet instancié par " +"*protocol_factory*." #: library/asyncio-eventloop.rst:1162 msgid "" ":class:`SelectorEventLoop` does not support the above methods on Windows. " "Use :class:`ProactorEventLoop` instead for Windows." msgstr "" +":class:`SelectorEventLoop` ne prend pas en charge les méthodes ci-dessus " +"sous Windows. Utilisez :class:`ProactorEventLoop` à la place pour Windows." +# suit un : #: library/asyncio-eventloop.rst:1167 msgid "" "The :meth:`loop.subprocess_exec` and :meth:`loop.subprocess_shell` methods." msgstr "" +"les méthodes :meth:`loop.subprocess_exec` et :meth:`loop.subprocess_shell`." #: library/asyncio-eventloop.rst:1172 msgid "Unix signals" @@ -1432,7 +1947,7 @@ msgstr "Signaux Unix" #: library/asyncio-eventloop.rst:1176 msgid "Set *callback* as the handler for the *signum* signal." -msgstr "" +msgstr "Définit *callback* comme gestionnaire du signal *signum*." #: library/asyncio-eventloop.rst:1178 msgid "" @@ -1441,17 +1956,27 @@ msgid "" "registered using :func:`signal.signal`, a callback registered with this " "function is allowed to interact with the event loop." msgstr "" +"La fonction de rappel sera appelée par *loop*, avec d'autres rappels en file " +"d'attente et des coroutines exécutables de cette boucle d'événements. " +"Contrairement aux gestionnaires de signaux enregistrés à l'aide de :func:" +"`signal.signal`, un rappel enregistré avec cette fonction est autorisé à " +"interagir avec la boucle d'événements." #: library/asyncio-eventloop.rst:1183 msgid "" "Raise :exc:`ValueError` if the signal number is invalid or uncatchable. " "Raise :exc:`RuntimeError` if there is a problem setting up the handler." msgstr "" +"Lève une :exc:`ValueError` si le numéro de signal est invalide ou non " +"attrapable. Lève une :exc:`RuntimeError` s'il y a un problème lors de la " +"configuration du gestionnaire." #: library/asyncio-eventloop.rst:1189 msgid "" "Like :func:`signal.signal`, this function must be invoked in the main thread." msgstr "" +"Comme :func:`signal.signal`, cette fonction doit être invoquée dans le fil " +"d'exécution principal." #: library/asyncio-eventloop.rst:1194 msgid "Remove the handler for the *sig* signal." @@ -1462,24 +1987,29 @@ msgid "" "Return ``True`` if the signal handler was removed, or ``False`` if no " "handler was set for the given signal." msgstr "" +"Renvoie ``True`` si le gestionnaire de signal a été supprimé, ou ``False`` " +"si aucun gestionnaire n'a été défini pour le signal donné." +# suit un : #: library/asyncio-eventloop.rst:1203 msgid "The :mod:`signal` module." -msgstr "Le module :mod:`signal`." +msgstr "le module :mod:`signal`." #: library/asyncio-eventloop.rst:1207 msgid "Executing code in thread or process pools" -msgstr "" +msgstr "Exécution de code dans des pools de threads ou de processus" #: library/asyncio-eventloop.rst:1211 msgid "Arrange for *func* to be called in the specified executor." -msgstr "" +msgstr "Fait en sorte que *func* soit appelée dans l'exécuteur spécifié." #: library/asyncio-eventloop.rst:1213 msgid "" "The *executor* argument should be an :class:`concurrent.futures.Executor` " "instance. The default executor is used if *executor* is ``None``." msgstr "" +"L'argument *executor* doit être une instance :class:`concurrent.futures." +"Executor`. L'exécuteur par défaut est utilisé si *executor* vaut ``None``." #: library/asyncio-eventloop.rst:1258 msgid "" @@ -1488,16 +2018,23 @@ msgid "" "used by :class:`~concurrent.futures.ProcessPoolExecutor`. See :ref:`Safe " "importing of main module `." msgstr "" +"Notez que la garde du point d'entrée (``if __name__ == '__main__'``) est " +"requis pour l'option 3 en raison des particularités de :mod:" +"`multiprocessing`, qui est utilisé par :class:`~concurrent.futures." +"ProcessPoolExecutor`. Voir :ref:`Importation sécurisée du module principal " +"`." #: library/asyncio-eventloop.rst:1263 msgid "This method returns a :class:`asyncio.Future` object." -msgstr "" +msgstr "Cette méthode renvoie un objet :class:`asyncio.Future`." #: library/asyncio-eventloop.rst:1265 msgid "" "Use :func:`functools.partial` :ref:`to pass keyword arguments ` to *func*." msgstr "" +"Utilisez :func:`functools.partial` pour :ref:`passer des arguments nommés " +"` à *func*." #: library/asyncio-eventloop.rst:1268 msgid "" @@ -1506,6 +2043,10 @@ msgid "" "executor (:class:`~concurrent.futures.ThreadPoolExecutor`) to set the " "default." msgstr "" +":meth:`loop.run_in_executor` ne configure plus le ``max_workers`` de " +"l'exécuteur de pool de threads qu'il crée, laissant à la place à l'exécuteur " +"de pool de threads (:class:`~concurrent.futures.ThreadPoolExecutor`) le soin " +"de définir le défaut." #: library/asyncio-eventloop.rst:1277 msgid "" @@ -1513,12 +2054,17 @@ msgid "" "*executor* must be an instance of :class:`~concurrent.futures." "ThreadPoolExecutor`." msgstr "" +"Définit *executor* comme exécuteur par défaut utilisé par :meth:" +"`run_in_executor`. *executor* doit être une instance de :class:`~concurrent." +"futures.ThreadPoolExecutor`." #: library/asyncio-eventloop.rst:1281 msgid "" "*executor* must be an instance of :class:`~concurrent.futures." "ThreadPoolExecutor`." msgstr "" +"*executor* doit être une instance de :class:`~concurrent.futures." +"ThreadPoolExecutor`." #: library/asyncio-eventloop.rst:1287 msgid "Error Handling API" @@ -1527,10 +2073,14 @@ msgstr "API de gestion d'erreur" #: library/asyncio-eventloop.rst:1289 msgid "Allows customizing how exceptions are handled in the event loop." msgstr "" +"Permet de personnaliser la façon dont les exceptions sont gérées dans la " +"boucle d'événements." #: library/asyncio-eventloop.rst:1293 msgid "Set *handler* as the new event loop exception handler." msgstr "" +"Définit *handler* comme nouveau gestionnaire d'exceptions de boucle " +"d'événements." #: library/asyncio-eventloop.rst:1295 msgid "" @@ -1540,12 +2090,20 @@ msgid "" "``context`` is a ``dict`` object containing the details of the exception " "(see :meth:`call_exception_handler` documentation for details about context)." msgstr "" +"Si *handler* est ``None``, le gestionnaire d'exceptions par défaut est " +"activé. Sinon, *handler* doit être un appelable avec la signature " +"correspondant à ``(loop, context)``, où ``loop`` est une référence à la " +"boucle d'événements active et ``context`` est un ``dict`` contenant les " +"détails de l'exception (voir la documentation :meth:`call_exception_handler` " +"pour plus de détails sur le contexte)." #: library/asyncio-eventloop.rst:1305 msgid "" "Return the current exception handler, or ``None`` if no custom exception " "handler was set." msgstr "" +"Renvoie le gestionnaire d'exceptions actuel ou ``None`` si aucun " +"gestionnaire d'exceptions personnalisé n'a été défini." #: library/asyncio-eventloop.rst:1312 msgid "Default exception handler." @@ -1557,12 +2115,18 @@ msgid "" "This can be called by a custom exception handler that wants to defer to the " "default handler behavior." msgstr "" +"Appelée lorsqu'une exception se produit et qu'aucun gestionnaire d'exception " +"n'est défini. Elle peut être appelée par un gestionnaire d'exceptions " +"personnalisé qui souhaite s'en remettre au comportement du gestionnaire par " +"défaut." #: library/asyncio-eventloop.rst:1318 msgid "" "*context* parameter has the same meaning as in :meth:" "`call_exception_handler`." msgstr "" +"Le paramètre *context* a la même signification que dans :meth:" +"`call_exception_handler`." #: library/asyncio-eventloop.rst:1323 msgid "Call the current event loop exception handler." @@ -1574,85 +2138,100 @@ msgid "" "*context* is a ``dict`` object containing the following keys (new keys may " "be introduced in future Python versions):" msgstr "" +"*context* est un objet ``dict`` contenant les clés suivantes (de nouvelles " +"clés pourront être introduites dans les futures versions de Python) :" #: library/asyncio-eventloop.rst:1328 msgid "'message': Error message;" -msgstr "``message`` : Message d'erreur ;" +msgstr "'message' : message d'erreur ;" #: library/asyncio-eventloop.rst:1329 msgid "'exception' (optional): Exception object;" -msgstr "``exception`` (optionnel): Un objet exception ;" +msgstr "'exception' (facultatif) : objet exception ;" #: library/asyncio-eventloop.rst:1330 msgid "'future' (optional): :class:`asyncio.Future` instance;" -msgstr "" +msgstr "'future' (facultatif) : instance de :class:`asyncio.Future` ;" #: library/asyncio-eventloop.rst:1331 msgid "'task' (optional): :class:`asyncio.Task` instance;" -msgstr "" +msgstr "'task' (facultatif) : instance de :class:`asyncio.Task` ;" #: library/asyncio-eventloop.rst:1332 msgid "'handle' (optional): :class:`asyncio.Handle` instance;" -msgstr "" +msgstr "*'handle'* (facultatif) : instance de :class:`asyncio.Handle` ;" #: library/asyncio-eventloop.rst:1333 msgid "'protocol' (optional): :ref:`Protocol ` instance;" msgstr "" +"*'protocol'* (facultatif) : instance de :ref:`protocole asyncio ` ;" #: library/asyncio-eventloop.rst:1334 msgid "'transport' (optional): :ref:`Transport ` instance;" msgstr "" +"'transport' (facultatif) : instance de :ref:`transport asyncio ` ;" #: library/asyncio-eventloop.rst:1335 msgid "'socket' (optional): :class:`socket.socket` instance;" -msgstr "" +msgstr "'socket' (facultatif) : instance de :class:`socket.socket` ;" #: library/asyncio-eventloop.rst:1337 msgid "'asyncgen' (optional): Asynchronous generator that caused" -msgstr "" +msgstr "*'asyncgen'* (facultatif) : générateur asynchrone qui a causé" #: library/asyncio-eventloop.rst:1337 -#, fuzzy msgid "the exception." -msgstr "Gestionnaire d'exception par défaut." +msgstr "l'exception" +# suit un : #: library/asyncio-eventloop.rst:1341 msgid "" "This method should not be overloaded in subclassed event loops. For custom " "exception handling, use the :meth:`set_exception_handler()` method." msgstr "" +"cette méthode ne doit pas être surchargée dans les boucles d'événements sous-" +"classées. Pour la gestion personnalisée des exceptions, utilisez la méthode :" +"meth:`set_exception_handler()`." #: library/asyncio-eventloop.rst:1346 msgid "Enabling debug mode" -msgstr "Active le mode débogage" +msgstr "Activation du mode débogage" #: library/asyncio-eventloop.rst:1350 msgid "Get the debug mode (:class:`bool`) of the event loop." -msgstr "" +msgstr "Obtient le mode de débogage (:class:`bool`) de la boucle d'événements." #: library/asyncio-eventloop.rst:1352 msgid "" "The default value is ``True`` if the environment variable :envvar:" "`PYTHONASYNCIODEBUG` is set to a non-empty string, ``False`` otherwise." msgstr "" +"La valeur par défaut est ``True`` si la variable d'environnement :envvar:" +"`PYTHONASYNCIODEBUG` est définie sur une chaîne non vide, ``False`` sinon." #: library/asyncio-eventloop.rst:1358 msgid "Set the debug mode of the event loop." msgstr "Active le mode débogage pour la boucle d'évènements." +# suit un : #: library/asyncio-eventloop.rst:1362 msgid "" "The new :ref:`Python Development Mode ` can now also be used to " "enable the debug mode." msgstr "" +"le nouveau :ref:`mode de développement Python ` peut désormais " +"également être utilisé pour activer le mode de débogage." +# suit un : #: library/asyncio-eventloop.rst:1367 msgid "The :ref:`debug mode of asyncio `." -msgstr "" +msgstr "le :ref:`mode debogage d'asyncio `." #: library/asyncio-eventloop.rst:1371 msgid "Running Subprocesses" -msgstr "" +msgstr "Exécution de sous-processus" #: library/asyncio-eventloop.rst:1373 msgid "" @@ -1660,33 +2239,45 @@ msgid "" "code consider using the high-level :func:`asyncio.create_subprocess_shell` " "and :func:`asyncio.create_subprocess_exec` convenience functions instead." msgstr "" +"Les méthodes décrites dans ces sous-sections sont de bas niveau. Dans le " +"code *async/await* normal, pensez à utiliser les fonctions de commodité de " +"haut niveau :func:`asyncio.create_subprocess_shell` et :func:`asyncio." +"create_subprocess_exec` à la place." +# suit un : #: library/asyncio-eventloop.rst:1380 msgid "" "On Windows, the default event loop :class:`ProactorEventLoop` supports " "subprocesses, whereas :class:`SelectorEventLoop` does not. See :ref:" "`Subprocess Support on Windows ` for details." msgstr "" +"sous Windows, la boucle d'événements par défaut :class:`ProactorEventLoop` " +"prend en charge les sous-processus, contrairement à :class:" +"`SelectorEventLoop`. Voir :ref:`Prise en charge des sous-processus sous " +"Windows ` pour plus de détails." #: library/asyncio-eventloop.rst:1389 msgid "" "Create a subprocess from one or more string arguments specified by *args*." msgstr "" +"Crée un sous-processus à partir d'un ou plusieurs arguments de chaîne " +"spécifiés par *args*." #: library/asyncio-eventloop.rst:1392 msgid "*args* must be a list of strings represented by:" -msgstr "" +msgstr "*args* doit être une liste de chaînes représentée par :" #: library/asyncio-eventloop.rst:1394 -#, fuzzy msgid ":class:`str`;" -msgstr ":class:`str`" +msgstr ":class:`str` ;" #: library/asyncio-eventloop.rst:1395 msgid "" "or :class:`bytes`, encoded to the :ref:`filesystem encoding `." msgstr "" +"ou :class:`bytes`, encodés selon l':ref:`encodage du système de fichiers " +"`." #: library/asyncio-eventloop.rst:1398 msgid "" @@ -1694,6 +2285,9 @@ msgid "" "specify the arguments. Together, string arguments form the ``argv`` of the " "program." msgstr "" +"La première chaîne spécifie l'exécutable du programme et les chaînes " +"restantes spécifient les arguments. Ensemble, les arguments de chaîne " +"forment le ``argv`` du programme." #: library/asyncio-eventloop.rst:1402 msgid "" @@ -1702,12 +2296,19 @@ msgid "" "argument; however, where :class:`~subprocess.Popen` takes a single argument " "which is list of strings, *subprocess_exec* takes multiple string arguments." msgstr "" +"C'est similaire à la classe standard de la bibliothèque :class:`subprocess." +"Popen` appelée avec ``shell=False`` et la liste des chaînes passées en " +"premier argument ; cependant, où :class:`~subprocess.Popen` prend un seul " +"argument qui est une liste de chaînes, *subprocess_exec* prend plusieurs " +"arguments de chaînes." #: library/asyncio-eventloop.rst:1408 msgid "" "The *protocol_factory* must be a callable returning a subclass of the :class:" "`asyncio.SubprocessProtocol` class." msgstr "" +"Le *protocol_factory* doit être un appelable renvoyant une sous-classe de la " +"classe :class:`asyncio.SubprocessProtocol`." #: library/asyncio-eventloop.rst:1411 msgid "Other parameters:" @@ -1715,13 +2316,15 @@ msgstr "Autres paramètres :" #: library/asyncio-eventloop.rst:1413 msgid "*stdin* can be any of these:" -msgstr "" +msgstr "*stdin* peut être l'un de ces éléments :" #: library/asyncio-eventloop.rst:1415 msgid "" "a file-like object representing a pipe to be connected to the subprocess's " "standard input stream using :meth:`~loop.connect_write_pipe`" msgstr "" +"un objet de type fichier représentant un tube à connecter au flux d'entrée " +"standard du sous-processus en utilisant :meth:`~loop.connect_write_pipe`," #: library/asyncio-eventloop.rst:1418 library/asyncio-eventloop.rst:1430 #: library/asyncio-eventloop.rst:1442 @@ -1729,6 +2332,8 @@ msgid "" "the :const:`subprocess.PIPE` constant (default) which will create a new pipe " "and connect it," msgstr "" +"la constante :const:`subprocess.PIPE` (par défaut) qui va créer un nouveau " +"tube et le connecter," #: library/asyncio-eventloop.rst:1420 library/asyncio-eventloop.rst:1432 #: library/asyncio-eventloop.rst:1444 @@ -1736,6 +2341,8 @@ msgid "" "the value ``None`` which will make the subprocess inherit the file " "descriptor from this process" msgstr "" +"la valeur ``None`` qui fera que le sous-processus héritera du descripteur de " +"fichier de ce processus," #: library/asyncio-eventloop.rst:1422 library/asyncio-eventloop.rst:1434 #: library/asyncio-eventloop.rst:1446 @@ -1743,32 +2350,40 @@ msgid "" "the :const:`subprocess.DEVNULL` constant which indicates that the special :" "data:`os.devnull` file will be used" msgstr "" +"la constante :const:`subprocess.DEVNULL` qui indique que le fichier spécial :" +"data:`os.devnull` sera utilisé." #: library/asyncio-eventloop.rst:1425 msgid "*stdout* can be any of these:" -msgstr "" +msgstr "*stdout* peut être l'un de ces éléments :" #: library/asyncio-eventloop.rst:1427 msgid "" "a file-like object representing a pipe to be connected to the subprocess's " "standard output stream using :meth:`~loop.connect_write_pipe`" msgstr "" +"un objet de type fichier représentant un tube à connecter au flux de sortie " +"standard du sous-processus en utilisant :meth:`~loop.connect_write_pipe`," #: library/asyncio-eventloop.rst:1437 msgid "*stderr* can be any of these:" -msgstr "" +msgstr "*stderr* peut être l'un de ces éléments :" #: library/asyncio-eventloop.rst:1439 msgid "" "a file-like object representing a pipe to be connected to the subprocess's " "standard error stream using :meth:`~loop.connect_write_pipe`" msgstr "" +"un objet de type fichier représentant un tube à connecter au flux d'erreurs " +"standard du sous-processus en utilisant :meth:`~loop.connect_write_pipe`," #: library/asyncio-eventloop.rst:1448 msgid "" "the :const:`subprocess.STDOUT` constant which will connect the standard " "error stream to the process' standard output stream" msgstr "" +"la constante :const:`subprocess.STDOUT` qui connectera le flux d'erreur " +"standard au flux de sortie standard du processus." #: library/asyncio-eventloop.rst:1451 msgid "" @@ -1776,6 +2391,10 @@ msgid "" "interpretation, except for *bufsize*, *universal_newlines*, *shell*, *text*, " "*encoding* and *errors*, which should not be specified at all." msgstr "" +"Tous les autres arguments nommés sont passés à :class:`subprocess.Popen` " +"sans interprétation, à l'exception de *bufsize*, *universal_newlines*, " +"*shell*, *text*, *encoding* et *errors*, qui ne doivent pas être spécifiés " +"du tout." #: library/asyncio-eventloop.rst:1456 msgid "" @@ -1783,12 +2402,17 @@ msgid "" "text. :func:`bytes.decode` can be used to convert the bytes returned from " "the stream to text." msgstr "" +"L'API de sous-processus ``asyncio`` ne prend pas en charge le décodage des " +"flux sous forme de texte. :func:`bytes.decode` peut être utilisée pour " +"convertir les octets renvoyés par le flux en texte." #: library/asyncio-eventloop.rst:1460 msgid "" "See the constructor of the :class:`subprocess.Popen` class for documentation " "on other arguments." msgstr "" +"Voir le constructeur de la classe :class:`subprocess.Popen` pour la " +"documentation sur les autres arguments." #: library/asyncio-eventloop.rst:1463 msgid "" @@ -1796,6 +2420,9 @@ msgid "" "the :class:`asyncio.SubprocessTransport` base class and *protocol* is an " "object instantiated by the *protocol_factory*." msgstr "" +"Renvoie une paire ``(transport, protocol)``, où *transport* est conforme à " +"la classe de base :class:`asyncio.SubprocessTransport` et *protocol* est un " +"objet instancié par *protocol_factory*." #: library/asyncio-eventloop.rst:1471 msgid "" @@ -1803,24 +2430,34 @@ msgid "" "`bytes` string encoded to the :ref:`filesystem encoding `, using the platform's \"shell\" syntax." msgstr "" +"Crée un sous-processus à partir de *cmd*, qui peut être une chaîne :class:" +"`str` ou une chaîne :class:`bytes` encodée avec l':ref:`encodage du système " +"de fichiers `, en utilisant la syntaxe \"shell\" de la " +"plate-forme." #: library/asyncio-eventloop.rst:1476 msgid "" "This is similar to the standard library :class:`subprocess.Popen` class " "called with ``shell=True``." msgstr "" +"C'est similaire à la classe standard de la bibliothèque :class:`subprocess." +"Popen` appelée avec ``shell=True``." #: library/asyncio-eventloop.rst:1479 msgid "" "The *protocol_factory* must be a callable returning a subclass of the :class:" "`SubprocessProtocol` class." msgstr "" +"Le *protocol_factory* doit être un appelable renvoyant une sous-classe de la " +"classe :class:`SubprocessProtocol`." #: library/asyncio-eventloop.rst:1482 msgid "" "See :meth:`~loop.subprocess_exec` for more details about the remaining " "arguments." msgstr "" +"Voir :meth:`~loop.subprocess_exec` pour plus de détails sur les arguments " +"restants." #: library/asyncio-eventloop.rst:1485 msgid "" @@ -1828,7 +2465,11 @@ msgid "" "the :class:`SubprocessTransport` base class and *protocol* is an object " "instantiated by the *protocol_factory*." msgstr "" +"Renvoie une paire ``(transport, protocol)``, où *transport* est conforme à " +"la classe de base :class:`SubprocessTransport` et *protocol* est un objet " +"instancié par *protocol_factory*." +# suit un : #: library/asyncio-eventloop.rst:1490 msgid "" "It is the application's responsibility to ensure that all whitespace and " @@ -1838,46 +2479,62 @@ msgid "" "escape whitespace and special characters in strings that are going to be " "used to construct shell commands." msgstr "" +"il est de la responsabilité de l'application de s'assurer que tous les " +"espaces blancs et les caractères spéciaux sont correctement échappés pour " +"éviter les vulnérabilités d'`injection de shell `_. La fonction :func:`shlex.quote` " +"peut être utilisée pour échapper correctement les espaces blancs et les " +"caractères spéciaux dans les chaînes qui seront utilisées pour construire " +"des commandes shell." #: library/asyncio-eventloop.rst:1499 msgid "Callback Handles" -msgstr "" +msgstr "Fonctions de rappel sur des descripteurs" #: library/asyncio-eventloop.rst:1503 msgid "" "A callback wrapper object returned by :meth:`loop.call_soon`, :meth:`loop." "call_soon_threadsafe`." msgstr "" +"Objet encapsulant une fonction de rappel renvoyé par :meth:`loop." +"call_soon`, :meth:`loop.call_soon_threadsafe`." #: library/asyncio-eventloop.rst:1508 msgid "" "Cancel the callback. If the callback has already been canceled or executed, " "this method has no effect." msgstr "" +"Annule le rappel. Si le rappel a déjà été annulé ou exécuté, cette méthode " +"n'a aucun effet." #: library/asyncio-eventloop.rst:1513 msgid "Return ``True`` if the callback was cancelled." -msgstr "Renvoie ``True`` si la fonction de rappel à été annulé." +msgstr "Renvoie ``True`` si la fonction de rappel a été annulée." #: library/asyncio-eventloop.rst:1519 msgid "" "A callback wrapper object returned by :meth:`loop.call_later`, and :meth:" "`loop.call_at`." msgstr "" +"Objet encapsulant la fonction de rappel renvoyé par :meth:`loop.call_later` " +"et :meth:`loop.call_at`." #: library/asyncio-eventloop.rst:1522 msgid "This class is a subclass of :class:`Handle`." -msgstr "" +msgstr "Cette classe est une sous-classe de :class:`Handle`." #: library/asyncio-eventloop.rst:1526 msgid "Return a scheduled callback time as :class:`float` seconds." msgstr "" +"Renvoie une heure de rappel planifiée sous forme de :class:`float` secondes." #: library/asyncio-eventloop.rst:1528 msgid "" "The time is an absolute timestamp, using the same time reference as :meth:" "`loop.time`." msgstr "" +"L'heure est un horodatage absolu, utilisant la même référence de temps que :" +"meth:`loop.time`." #: library/asyncio-eventloop.rst:1535 msgid "Server Objects" @@ -1889,10 +2546,13 @@ msgid "" "create_unix_server`, :func:`start_server`, and :func:`start_unix_server` " "functions." msgstr "" +"Les objets serveur sont créés par les fonctions :meth:`loop.create_server`, :" +"meth:`loop.create_unix_server`, :func:`start_server` et :func:" +"`start_unix_server`." #: library/asyncio-eventloop.rst:1541 msgid "Do not instantiate the class directly." -msgstr "" +msgstr "N'instanciez pas la classe directement." #: library/asyncio-eventloop.rst:1545 msgid "" @@ -1900,32 +2560,44 @@ msgid "" "with`` statement, it's guaranteed that the Server object is closed and not " "accepting new connections when the ``async with`` statement is completed::" msgstr "" +"Les objets *Server* sont des gestionnaires de contexte asynchrones. " +"Lorsqu'il est utilisé dans une instruction ``async with``, il est garanti " +"que l'objet Serveur est fermé et n'accepte pas de nouvelle connexion lorsque " +"l'instruction ``async with`` est terminée ::" +# suit un : #: library/asyncio-eventloop.rst:1558 msgid "Server object is an asynchronous context manager since Python 3.7." msgstr "" +"l'objet serveur est un gestionnaire de contexte asynchrone depuis Python 3.7." #: library/asyncio-eventloop.rst:1563 msgid "" "Stop serving: close listening sockets and set the :attr:`sockets` attribute " "to ``None``." msgstr "" +"Arrête le serveur : ferme les connecteurs d'écoute et définit l'attribut :" +"attr:`sockets` à ``None``." #: library/asyncio-eventloop.rst:1566 msgid "" "The sockets that represent existing incoming client connections are left " "open." msgstr "" +"Les connecteurs qui représentent les connexions client entrantes existantes " +"restent ouvertes." #: library/asyncio-eventloop.rst:1569 msgid "" "The server is closed asynchronously, use the :meth:`wait_closed` coroutine " "to wait until the server is closed." msgstr "" +"Le serveur est fermé de manière asynchrone, utilisez la coroutine :meth:" +"`wait_closed` pour attendre que le serveur soit fermé." #: library/asyncio-eventloop.rst:1574 msgid "Return the event loop associated with the server object." -msgstr "" +msgstr "Renvoie la boucle d'événement associée à l'objet serveur." #: library/asyncio-eventloop.rst:1580 msgid "Start accepting connections." @@ -1936,6 +2608,8 @@ msgid "" "This method is idempotent, so it can be called when the server is already " "serving." msgstr "" +"Cette méthode est idempotente, elle peut donc être appelée lorsque le " +"serveur est déjà en service." #: library/asyncio-eventloop.rst:1585 msgid "" @@ -1945,36 +2619,49 @@ msgid "" "or :meth:`Server.serve_forever` can be used to make the Server start " "accepting connections." msgstr "" +"Le paramètre nommé *start_serving* de :meth:`loop.create_server` et :meth:" +"`asyncio.start_server` permet de créer un objet *Server* qui n'accepte pas " +"les connexions initialement. Dans ce cas, ``Server.start_serving()`` ou :" +"meth:`Server.serve_forever` peut être utilisée pour que le serveur commence " +"à accepter les connexions." #: library/asyncio-eventloop.rst:1596 msgid "" "Start accepting connections until the coroutine is cancelled. Cancellation " "of ``serve_forever`` task causes the server to be closed." msgstr "" +"Commence à accepter les connexions jusqu'à ce que la coroutine soit annulée. " +"L'annulation de la tâche ``serve_forever`` provoque la fermeture du serveur." #: library/asyncio-eventloop.rst:1600 msgid "" "This method can be called if the server is already accepting connections. " "Only one ``serve_forever`` task can exist per one *Server* object." msgstr "" +"Cette méthode peut être appelée si le serveur accepte déjà les connexions. " +"Une seule tâche ``serve_forever`` peut exister par objet *Server*." #: library/asyncio-eventloop.rst:1622 msgid "Return ``True`` if the server is accepting new connections." -msgstr "Donne ``True`` si le serveur accepte de nouvelles connexions." +msgstr "Renvoie ``True`` si le serveur accepte de nouvelles connexions." #: library/asyncio-eventloop.rst:1628 msgid "Wait until the :meth:`close` method completes." -msgstr "Attends que la méthode :meth:`close` se termine." +msgstr "Attend que la méthode :meth:`close` se termine." #: library/asyncio-eventloop.rst:1632 msgid "List of :class:`socket.socket` objects the server is listening on." msgstr "" +"Liste les objets :class:`socket.socket` sur lesquels le serveur écoute." +# vulnérabilités #: library/asyncio-eventloop.rst:1634 msgid "" "Prior to Python 3.7 ``Server.sockets`` used to return an internal list of " "server sockets directly. In 3.7 a copy of that list is returned." msgstr "" +"avant Python 3.7, ``Server.sockets`` renvoyait directement une liste interne " +"de sockets de serveur. En 3.7, une copie de cette liste est renvoyée." #: library/asyncio-eventloop.rst:1644 msgid "Event Loop Implementations" @@ -1985,16 +2672,20 @@ msgid "" "asyncio ships with two different event loop implementations: :class:" "`SelectorEventLoop` and :class:`ProactorEventLoop`." msgstr "" +"*asyncio* est livré avec deux implémentations de boucles d'événements " +"différentes : :class:`SelectorEventLoop` et :class:`ProactorEventLoop`." #: library/asyncio-eventloop.rst:1649 msgid "" "By default asyncio is configured to use :class:`SelectorEventLoop` on Unix " "and :class:`ProactorEventLoop` on Windows." msgstr "" +"Par défaut, *asyncio* est configuré pour utiliser :class:`SelectorEventLoop` " +"sous Unix et :class:`ProactorEventLoop` sous Windows." #: library/asyncio-eventloop.rst:1655 msgid "An event loop based on the :mod:`selectors` module." -msgstr "" +msgstr "Boucle d'événements basée sur le module :mod:`selectors`." #: library/asyncio-eventloop.rst:1657 msgid "" @@ -2002,6 +2693,9 @@ msgid "" "also possible to manually configure the exact selector implementation to be " "used::" msgstr "" +"Utilise le *sélecteur* le plus efficace disponible pour la plate-forme " +"donnée. Il est également possible de configurer manuellement " +"l'implémentation exacte du sélecteur à utiliser ::" #: library/asyncio-eventloop.rst:1672 msgid ":ref:`Availability `: Unix, Windows." @@ -2010,6 +2704,8 @@ msgstr ":ref:`Disponibilité ` : Unix, Windows." #: library/asyncio-eventloop.rst:1677 msgid "An event loop for Windows that uses \"I/O Completion Ports\" (IOCP)." msgstr "" +"Boucle d'événements pour Windows qui utilise des \"I/O Completion Ports" +"\" (IOCP)." #: library/asyncio-eventloop.rst:1679 msgid ":ref:`Availability `: Windows." @@ -2020,16 +2716,21 @@ msgid "" "`MSDN documentation on I/O Completion Ports `_." msgstr "" +"`Documentation MSDN sur les ports de saisie semi-automatique d’E/S `_." #: library/asyncio-eventloop.rst:1689 msgid "Abstract base class for asyncio-compliant event loops." msgstr "" +"Classe mère abstraite pour les boucles d'événements conforme à *asyncio*." #: library/asyncio-eventloop.rst:1691 msgid "" "The :ref:`asyncio-event-loop-methods` section lists all methods that an " "alternative implementation of ``AbstractEventLoop`` should have defined." msgstr "" +"La section :ref:`asyncio-event-loop-methods` liste toutes les méthodes " +"qu'une implémentation alternative de ``AbstractEventLoop`` doit définir." #: library/asyncio-eventloop.rst:1697 msgid "Examples" @@ -2042,6 +2743,11 @@ msgid "" "call_soon`. Modern asyncio applications rarely need to be written this way; " "consider using the high-level functions like :func:`asyncio.run`." msgstr "" +"Notez que tous les exemples de cette section montrent **à dessein** comment " +"utiliser les API de boucle d'événement de bas niveau, telles que :meth:`loop." +"run_forever` et :meth:`loop.call_soon`. Les applications *asyncio* modernes " +"ont rarement besoin d'être écrites de cette façon ; pensez à utiliser les " +"fonctions de haut niveau comme :func:`asyncio.run`." #: library/asyncio-eventloop.rst:1709 msgid "Hello World with call_soon()" @@ -2052,16 +2758,22 @@ msgid "" "An example using the :meth:`loop.call_soon` method to schedule a callback. " "The callback displays ``\"Hello World\"`` and then stops the event loop::" msgstr "" +"Un exemple utilisant la méthode :meth:`loop.call_soon` pour programmer un " +"rappel. Le rappel affiche ``\"Hello World\"`` puis arrête la boucle " +"d'événements ::" +# suit un : #: library/asyncio-eventloop.rst:1735 msgid "" "A similar :ref:`Hello World ` example created with a coroutine " "and the :func:`run` function." msgstr "" +"un exemple similaire de :ref:`Hello World ` créé avec une " +"coroutine et la fonction :func:`run`." #: library/asyncio-eventloop.rst:1742 msgid "Display the current date with call_later()" -msgstr "Afficher la date actuelle avec ``call_later()``" +msgstr "Affichage de la date actuelle avec ``call_later()``" #: library/asyncio-eventloop.rst:1744 msgid "" @@ -2069,38 +2781,53 @@ msgid "" "callback uses the :meth:`loop.call_later` method to reschedule itself after " "5 seconds, and then stops the event loop::" msgstr "" +"Un exemple de rappel affichant la date actuelle toutes les secondes. Le " +"rappel utilise la méthode :meth:`loop.call_later` pour se re-planifier après " +"5 secondes, puis arrête la boucle d'événements ::" +# suit un : #: library/asyncio-eventloop.rst:1772 msgid "" "A similar :ref:`current date ` example created with a " "coroutine and the :func:`run` function." msgstr "" +"un exemple similaire de :ref:`date actuelle ` créé " +"avec une coroutine et la fonction :func:`run`." #: library/asyncio-eventloop.rst:1779 msgid "Watch a file descriptor for read events" -msgstr "" +msgstr "Surveillance des événements de lecture pour un descripteur de fichier" #: library/asyncio-eventloop.rst:1781 msgid "" "Wait until a file descriptor received some data using the :meth:`loop." "add_reader` method and then close the event loop::" msgstr "" +"Attend qu'un descripteur de fichier reçoive des données en utilisant la " +"méthode :meth:`loop.add_reader` puis ferme la boucle d'événements ::" +# suit un : #: library/asyncio-eventloop.rst:1819 msgid "" "A similar :ref:`example ` using " "transports, protocols, and the :meth:`loop.create_connection` method." msgstr "" +"un :ref:`exemple ` similaire utilisant " +"les transports, les protocoles et la méthode :meth:`loop.create_connection`," +# suit un : #: library/asyncio-eventloop.rst:1823 msgid "" "Another similar :ref:`example ` " "using the high-level :func:`asyncio.open_connection` function and streams." msgstr "" +"un autre :ref:`exemple ` " +"utilisant la fonction et les flux de haut niveau :func:`asyncio." +"open_connection`." #: library/asyncio-eventloop.rst:1831 msgid "Set signal handlers for SIGINT and SIGTERM" -msgstr "Définit les gestionnaires de signaux pour *SIGINT* et *SIGTERM*" +msgstr "Gestion des signaux *SIGINT* et *SIGTERM*" #: library/asyncio-eventloop.rst:1833 msgid "(This ``signals`` example only works on Unix.)" @@ -2111,3 +2838,5 @@ msgid "" "Register handlers for signals :py:data:`SIGINT` and :py:data:`SIGTERM` using " "the :meth:`loop.add_signal_handler` method::" msgstr "" +"Enregistre des gestionnaires pour les signaux :py:data:`SIGINT` et :py:data:" +"`SIGTERM` en utilisant la méthode :meth:`loop.add_signal_handler` ::"