# Copyright (C) 2001-2018, Python Software Foundation

# For licence information, see README file.

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2023-03-22 22:57+0100\n"

"PO-Revision-Date: 2019-11-17 01:26+0100\n"

"Last-Translator: Mathieu Dupuy <deronnax@gmail.com>\n"

"Language-Team: FRENCH <traductions@lists.afpy.org>\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.2.4\n"

#: library/asyncio-policy.rst:8

msgid "Policies"

msgstr "Stratégies"

#: library/asyncio-policy.rst:10

msgid ""

"An event loop policy is a global object used to get and set the current :ref:"

"`event loop <asyncio-event-loop>`, as well as create new event loops. The "

"default policy can be :ref:`replaced <asyncio-policy-get-set>` with :ref:"

"`built-in alternatives <asyncio-policy-builtin>` to use different event loop "

"implementations, or substituted by a :ref:`custom policy <asyncio-custom-"

"policies>` that can override these behaviors."

msgstr ""

#: library/asyncio-policy.rst:19

#, fuzzy

msgid ""

"The :ref:`policy object <asyncio-policy-objects>` gets and sets a separate "

"event loop per *context*. This is per-thread by default, though custom "

"policies could define *context* differently."

msgstr ""

"Une stratégie définit la notion de *contexte* et gère une boucle d'événement "

"distincte par contexte. La stratégie par défaut définit le *contexte* comme "

"étant le fil d'exécution actuel."

#: library/asyncio-policy.rst:24

#, fuzzy

msgid ""

"Custom event loop policies can control the behavior of :func:"

"`get_event_loop`, :func:`set_event_loop`, and :func:`new_event_loop`."

msgstr ""

"En utilisant une stratégie de boucle d'événement personnalisée, le "

"comportement des fonctions :func:`get_event_loop`, :func:`set_event_loop` "

"et :func:`new_event_loop` peut être personnalisé."

#: library/asyncio-policy.rst:27

msgid ""

"Policy objects should implement the APIs defined in the :class:"

"`AbstractEventLoopPolicy` abstract base class."

msgstr ""

"Les objets de stratégie doivent implémenter les API définies dans la classe "

"de base abstraite :class:`AbstractEventLoopPolicy`."

#: library/asyncio-policy.rst:34

msgid "Getting and Setting the Policy"

msgstr "Obtenir et définir la stratégie"

#: library/asyncio-policy.rst:36

msgid ""

"The following functions can be used to get and set the policy for the "

"current process:"

msgstr ""

"Les fonctions suivantes peuvent être utilisées pour obtenir et définir la "

"stratégie du processus en cours :"

#: library/asyncio-policy.rst:41

msgid "Return the current process-wide policy."

msgstr "Renvoie la stratégie actuelle à l'échelle du processus."

#: library/asyncio-policy.rst:45

msgid "Set the current process-wide policy to *policy*."

msgstr ""

"Définit la stratégie actuelle sur l'ensemble du processus sur *policy*."

#: library/asyncio-policy.rst:47

msgid "If *policy* is set to ``None``, the default policy is restored."

msgstr ""

"Si *policy* est définie sur ``None``, la stratégie par défaut est restaurée."

#: library/asyncio-policy.rst:53

msgid "Policy Objects"

msgstr "Sujets de stratégie"

#: library/asyncio-policy.rst:55

msgid "The abstract event loop policy base class is defined as follows:"

msgstr ""

"La classe de base abstraite de la stratégie de boucle d'événements est "

"définie comme suit:"

#: library/asyncio-policy.rst:59

msgid "An abstract base class for asyncio policies."

msgstr "Une classe de base abstraite pour les stratégies *asyncio*."

#: library/asyncio-policy.rst:63

msgid "Get the event loop for the current context."

msgstr "Récupère la boucle d'évènements pour le contexte actuel."

#: library/asyncio-policy.rst:65

msgid ""

"Return an event loop object implementing the :class:`AbstractEventLoop` "

"interface."

msgstr ""

"Renvoie un objet de boucle d'événements en implémentant l'interface :class:"

"`AbstractEventLoop`."

#: library/asyncio-policy.rst:80

msgid "This method should never return ``None``."

msgstr "Cette méthode ne devrait jamais renvoyer ``None``."

#: library/asyncio-policy.rst:74

msgid "Set the event loop for the current context to *loop*."

msgstr "Définit la boucle d'événements du contexte actuel sur *loop*."

#: library/asyncio-policy.rst:78

msgid "Create and return a new event loop object."

msgstr "Crée et renvoie un nouvel objet de boucle d'événements."

#: library/asyncio-policy.rst:84

msgid "Get a child process watcher object."

msgstr "Récupère un objet observateur du processus enfant."

#: library/asyncio-policy.rst:86

msgid ""

"Return a watcher object implementing the :class:`AbstractChildWatcher` "

"interface."

msgstr ""

"Renvoie un objet observateur implémentant l'interface :class:"

"`AbstractChildWatcher`."

#: library/asyncio-policy.rst:95

msgid "This function is Unix specific."

msgstr "Cette fonction est spécifique à Unix."

#: library/asyncio-policy.rst:93

msgid "Set the current child process watcher to *watcher*."

msgstr "Définit l'observateur du processus enfant actuel à *watcher*."

#: library/asyncio-policy.rst:100

msgid "asyncio ships with the following built-in policies:"

msgstr "*asyncio* est livré avec les stratégies intégrées suivantes :"

#: library/asyncio-policy.rst:105

msgid ""

"The default asyncio policy. Uses :class:`SelectorEventLoop` on Unix and :"

"class:`ProactorEventLoop` on Windows."

msgstr ""

"La stratégie *asyncio* par défaut. Utilise :class:`SelectorEventLoop` sur "

"les plates-formes Unix et :class:`ProactorEventLoop` sur Windows."

#: library/asyncio-policy.rst:108

msgid ""

"There is no need to install the default policy manually. asyncio is "

"configured to use the default policy automatically."

msgstr ""

"Il n'est pas nécessaire d'installer la stratégie par défaut manuellement. "

"*asyncio* est configuré pour utiliser automatiquement la stratégie par "

"défaut."

#: library/asyncio-policy.rst:113

msgid "On Windows, :class:`ProactorEventLoop` is now used by default."

msgstr ""

#: library/asyncio-policy.rst:116

msgid ""

"In Python versions 3.10.9, 3.11.1 and 3.12 the :meth:`get_event_loop` method "

"of the default asyncio policy emits a :exc:`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 ""

#: library/asyncio-policy.rst:124

msgid ""

"An alternative event loop policy that uses the :class:`SelectorEventLoop` "

"event loop implementation."

msgstr ""

"Stratégie de boucle d'événements alternative utilisant l'implémentation de "

"la boucle d'événements :class:`ProactorEventLoop`."

#: library/asyncio-policy.rst:135

msgid ":ref:`Availability <availability>`: Windows."

msgstr ":ref:`Disponibilité <availability>` : Windows."

#: library/asyncio-policy.rst:132

#, fuzzy

msgid ""

"An alternative event loop policy that uses the :class:`ProactorEventLoop` "

"event loop implementation."

msgstr ""

"Stratégie de boucle d'événements alternative utilisant l'implémentation de "

"la boucle d'événements :class:`ProactorEventLoop`."

#: library/asyncio-policy.rst:141

msgid "Process Watchers"

msgstr "Observateurs de processus"

#: library/asyncio-policy.rst:143

msgid ""

"A process watcher allows customization of how an event loop monitors child "

"processes on Unix. Specifically, the event loop needs to know when a child "

"process has exited."

msgstr ""

"Un observateur de processus permet de personnaliser la manière dont une "

"boucle d'événements surveille les processus enfants sous Unix. Plus "

"précisément, la boucle d'événements a besoin de savoir quand un processus "

"enfant s'est terminé."

#: library/asyncio-policy.rst:147

msgid ""

"In asyncio, child processes are created with :func:`create_subprocess_exec` "

"and :meth:`loop.subprocess_exec` functions."

msgstr ""

"Dans *asyncio*, les processus enfants sont créés avec les fonctions :func:"

"`create_subprocess_exec` et :meth:`loop.subprocess_exec`."

#: library/asyncio-policy.rst:151

#, fuzzy

msgid ""

"asyncio defines the :class:`AbstractChildWatcher` abstract base class, which "

"child watchers should implement, and has four different implementations: :"

"class:`ThreadedChildWatcher` (configured to be used by default), :class:"

"`MultiLoopChildWatcher`, :class:`SafeChildWatcher`, and :class:"

"`FastChildWatcher`."

msgstr ""

"*asyncio* définit la classe de base abstraite :class:`AbstractChildWatcher`, "

"que les observateurs enfants doivent implémenter et possède deux "

"implémentations différentes : :class:`SafeChildWatcher` (configurée pour "

"être utilisé par défaut) et :class:`FastChildWatcher`."

#: library/asyncio-policy.rst:157

msgid ""

"See also the :ref:`Subprocess and Threads <asyncio-subprocess-threads>` "

"section."

msgstr ""

"Voir aussi la section :ref:`sous-processus et fils d'exécution <asyncio-"

"subprocess-threads>`."

#: library/asyncio-policy.rst:160

msgid ""

"The following two functions can be used to customize the child process "

"watcher implementation used by the asyncio event loop:"

msgstr ""

"Les deux fonctions suivantes peuvent être utilisées pour personnaliser "

"l'implémentation de l'observateur de processus enfant utilisé par la boucle "

"d'événements *asyncio* :"

#: library/asyncio-policy.rst:165

msgid "Return the current child watcher for the current policy."

msgstr "Renvoie l'observateur enfant actuel pour la stratégie actuelle."

#: library/asyncio-policy.rst:169

msgid ""

"Set the current child watcher to *watcher* for the current policy. "

"*watcher* must implement methods defined in the :class:"

"`AbstractChildWatcher` base class."

msgstr ""

"Définit l'observateur enfant actuel à *watcher* pour la stratégie actuelle. "

"*watcher* doit implémenter les méthodes définies dans la classe de base :"

"class:`AbstractChildWatcher`."

#: library/asyncio-policy.rst:174

msgid ""

"Third-party event loops implementations might not support custom child "

"watchers. For such event loops, using :func:`set_child_watcher` might be "

"prohibited or have no effect."

msgstr ""

"Les implémentations de boucles d'événement tierces peuvent ne pas prendre en "

"charge les observateurs enfants personnalisés. Pour ces boucles "

"d'événements, utiliser :func:`set_child_watcher` pourrait être interdit ou "

"n'avoir aucun effet."

#: library/asyncio-policy.rst:182

msgid "Register a new child handler."

msgstr "Enregistre un nouveau gestionnaire."

#: library/asyncio-policy.rst:184

msgid ""

"Arrange for ``callback(pid, returncode, *args)`` to be called when a process "

"with PID equal to *pid* terminates. Specifying another callback for the "

"same process replaces the previous handler."

msgstr ""

"Organise l'appel de ``callback(pid, returncode, * args)`` lorsqu'un "

"processus dont le PID est égal à *pid* se termine. La spécification d'un "

"autre rappel pour le même processus remplace le gestionnaire précédent."

#: library/asyncio-policy.rst:189

msgid "The *callback* callable must be thread-safe."

msgstr ""

"L'appelable *callback* doit être compatible avec les programmes à fils "

"d'exécution multiples."

#: library/asyncio-policy.rst:193

msgid "Removes the handler for process with PID equal to *pid*."

msgstr "Supprime le gestionnaire de processus avec un PID égal à *pid*."

#: library/asyncio-policy.rst:195

msgid ""

"The function returns ``True`` if the handler was successfully removed, "

"``False`` if there was nothing to remove."

msgstr ""

"La fonction renvoie ``True`` si le gestionnaire a été supprimé avec succès, "

"``False`` s'il n'y a rien à supprimer."

#: library/asyncio-policy.rst:200

msgid "Attach the watcher to an event loop."

msgstr "Attache l'observateur à une boucle d'événement."

#: library/asyncio-policy.rst:202

msgid ""

"If the watcher was previously attached to an event loop, then it is first "

"detached before attaching to the new loop."

msgstr ""

"Si l'observateur était précédemment attaché à une boucle d'événements, il "

"est d'abord détaché avant d'être rattaché à la nouvelle boucle."

#: library/asyncio-policy.rst:205

msgid "Note: loop may be ``None``."

msgstr "Remarque : la boucle peut être ``None``."

#: library/asyncio-policy.rst:209

msgid "Return ``True`` if the watcher is ready to use."

msgstr ""

#: library/asyncio-policy.rst:211

msgid ""

"Spawning a subprocess with *inactive* current child watcher raises :exc:"

"`RuntimeError`."

msgstr ""

"Instancier un sous-processus avec un observateur enfant actuel *inactif* "

"lève l'exception :exc:`RuntimeError`."

#: library/asyncio-policy.rst:218

msgid "Close the watcher."

msgstr "Ferme l'observateur."

#: library/asyncio-policy.rst:220

msgid ""

"This method has to be called to ensure that underlying resources are cleaned-"

"up."

msgstr ""

"Cette méthode doit être appelée pour s'assurer que les ressources sous-"

"jacentes sont nettoyées."

#: library/asyncio-policy.rst:225

#, fuzzy

msgid ""

"This implementation starts a new waiting thread for every subprocess spawn."

msgstr ""

"Cette implémentation évite de perturber un autre code qui aurait besoin de "

"générer des processus en interrogeant chaque processus explicitement par un "

"signal :py:data:`SIGCHLD`."

#: library/asyncio-policy.rst:227

#, fuzzy

msgid ""

"It works reliably even when the asyncio event loop is run in a non-main OS "

"thread."

msgstr ""

"C'est une solution sûre, mais elle nécessite un temps système important lors "

"de la manipulation d'un grand nombre de processus (*O(n)* à chaque fois que "

"un :py:data:`SIGCHLD` est reçu)."

#: library/asyncio-policy.rst:229

#, fuzzy

msgid ""

"There is no noticeable overhead when handling a big number of children "

"(*O(1)* each time a child terminates), but starting a thread per process "

"requires extra memory."

msgstr ""

"Il n'y a pas de surcharge visible lors de la manipulation d'un grand nombre "

"d'enfants (*O(1)* à chaque fois qu'un enfant se termine)."

#: library/asyncio-policy.rst:232

msgid "This watcher is used by default."

msgstr ""

#: library/asyncio-policy.rst:238

msgid ""

"This implementation registers a :py:data:`SIGCHLD` signal handler on "

"instantiation. That can break third-party code that installs a custom "

"handler for :py:data:`SIGCHLD` signal."

msgstr ""

#: library/asyncio-policy.rst:260

msgid ""

"The watcher avoids disrupting other code spawning processes by polling every "

"process explicitly on a :py:data:`SIGCHLD` signal."

msgstr ""

#: library/asyncio-policy.rst:245

msgid ""

"There is no limitation for running subprocesses from different threads once "

"the watcher is installed."

msgstr ""

#: library/asyncio-policy.rst:248

msgid ""

"The solution is safe but it has a significant overhead when handling a big "

"number of processes (*O(n)* each time a :py:data:`SIGCHLD` is received)."

msgstr ""

#: library/asyncio-policy.rst:256

msgid ""

"This implementation uses active event loop from the main thread to handle :"

"py:data:`SIGCHLD` signal. If the main thread has no running event loop "

"another thread cannot spawn a subprocess (:exc:`RuntimeError` is raised)."

msgstr ""

#: library/asyncio-policy.rst:263

msgid ""

"This solution is as safe as :class:`MultiLoopChildWatcher` and has the same "

"*O(N)* complexity but requires a running event loop in the main thread to "

"work."

msgstr ""

#: library/asyncio-policy.rst:268

msgid ""

"This implementation reaps every terminated processes by calling ``os."

"waitpid(-1)`` directly, possibly breaking other code spawning processes and "

"waiting for their termination."

msgstr ""

"Cette implémentation récupère tous les processus terminés en appelant "

"directement ``os.waitpid(-1)``, cassant éventuellement un autre code qui "

"génère des processus et attend leur fin."

#: library/asyncio-policy.rst:272

msgid ""

"There is no noticeable overhead when handling a big number of children "

"(*O(1)* each time a child terminates)."

msgstr ""

"Il n'y a pas de surcharge visible lors de la manipulation d'un grand nombre "

"d'enfants (*O(1)* à chaque fois qu'un enfant se termine)."

#: library/asyncio-policy.rst:275

msgid ""

"This solution requires a running event loop in the main thread to work, as :"

"class:`SafeChildWatcher`."

msgstr ""

#: library/asyncio-policy.rst:280

msgid ""

"This implementation polls process file descriptors (pidfds) to await child "

"process termination. In some respects, :class:`PidfdChildWatcher` is a "

"\"Goldilocks\" child watcher implementation. It doesn't require signals or "

"threads, doesn't interfere with any processes launched outside the event "

"loop, and scales linearly with the number of subprocesses launched by the "

"event loop. The main disadvantage is that pidfds are specific to Linux, and "

"only work on recent (5.3+) kernels."

msgstr ""

#: library/asyncio-policy.rst:294

msgid "Custom Policies"

msgstr "Stratégies personnalisées"

#: library/asyncio-policy.rst:296

msgid ""

"To implement a new event loop policy, it is recommended to subclass :class:"

"`DefaultEventLoopPolicy` and override the methods for which custom behavior "

"is wanted, e.g.::"

msgstr ""

"Pour implémenter une nouvelle politique de boucle d’événements, il est "

"recommandé de sous-classer :class:`DefaultEventLoopPolicy` et de "

"réimplémenter les méthodes pour lesquelles un comportement personnalisé est "

"souhaité, par exemple ::"

#~ msgid ""

#~ "An event loop policy is a global per-process object that controls the "

#~ "management of the event loop. Each event loop has a default policy, which "

#~ "can be changed and customized using the policy API."

#~ msgstr ""

#~ "Une stratégie de boucle d'événements est un objet global, pour chaque "

#~ "processus, qui contrôle la gestion de la boucle d'événement. Chaque "

#~ "boucle d'événement a une stratégie par défaut, qui peut être modifiée et "

#~ "personnalisée à l'aide de l'API de la stratégie."