python-docs-fr/library/socketserver.po

# 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-01-15 22:33+0100\n"
"PO-Revision-Date: 2022-05-19 21:40-0400\n"
"Last-Translator: Nicolas Haller <python@haller.im>\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 3.0.1\n"

#: library/socketserver.rst:2
msgid ":mod:`socketserver` --- A framework for network servers"
msgstr ":mod:`socketserver` — Cadriciel pour serveurs réseaux"

#: library/socketserver.rst:7
msgid "**Source code:** :source:`Lib/socketserver.py`"
msgstr "**Code source :** :source:`Lib/socketserver.py`"

#: library/socketserver.rst:11
msgid ""
"The :mod:`socketserver` module simplifies the task of writing network "
"servers."
msgstr ""
"Le module :mod:`socketserver` permet de simplifier le développement de "
"serveurs réseaux."

#: includes/wasm-notavail.rst:None
msgid ":ref:`Availability <availability>`: not Emscripten, not WASI."
msgstr ""

#: includes/wasm-notavail.rst:5
msgid ""
"This module does not work or is not available on WebAssembly platforms "
"``wasm32-emscripten`` and ``wasm32-wasi``. See :ref:`wasm-availability` for "
"more information."
msgstr ""

#: library/socketserver.rst:15
msgid "There are four basic concrete server classes:"
msgstr "Il existe quatre classes concrètes fondamentales :"

#: library/socketserver.rst:20
msgid ""
"This uses the internet TCP protocol, which provides for continuous streams "
"of data between the client and server. If *bind_and_activate* is true, the "
"constructor automatically attempts to invoke :meth:`~BaseServer.server_bind` "
"and :meth:`~BaseServer.server_activate`.  The other parameters are passed to "
"the :class:`BaseServer` base class."
msgstr ""
"Cette classe permet de créer des flux continus de données entre un client et "
"un serveur en utilisant le protocole internet TCP. Si *bind_and_activate* "
"est vrai, le constructeur tente automatiquement d'invoquer  :meth:"
"`~BaseServer.server_bind` et :meth:`~BaseServer.server_activate`. Les autres "
"paramètres sont passés à la classe de base :class:`BaseServer`."

#: library/socketserver.rst:30
msgid ""
"This uses datagrams, which are discrete packets of information that may "
"arrive out of order or be lost while in transit.  The parameters are the "
"same as for :class:`TCPServer`."
msgstr ""
"Cette classe utilise des datagrammes, qui sont des paquets d'information "
"pouvant arriver dans le désordre, voire être perdus, durant le transport. "
"Les paramètres sont identiques à :class:`TCPServer`."

#: library/socketserver.rst:38
msgid ""
"These more infrequently used classes are similar to the TCP and UDP classes, "
"but use Unix domain sockets; they're not available on non-Unix platforms.  "
"The parameters are the same as for :class:`TCPServer`."
msgstr ""
"Ces classes, moins fréquemment utilisées, sont similaires aux classes pour "
"TCP et UDP mais utilisent des connecteurs UNIX ; ces connecteurs ne sont "
"disponibles que sur les plateformes UNIX. Les paramètres sont identiques à :"
"class:`TCPServer`."

#: library/socketserver.rst:44
msgid ""
"These four classes process requests :dfn:`synchronously`; each request must "
"be completed before the next request can be started.  This isn't suitable if "
"each request takes a long time to complete, because it requires a lot of "
"computation, or because it returns a lot of data which the client is slow to "
"process.  The solution is to create a separate process or thread to handle "
"each request; the :class:`ForkingMixIn` and :class:`ThreadingMixIn` mix-in "
"classes can be used to support asynchronous behaviour."
msgstr ""
"Ces quatre classes traitent les requêtes de façon :dfn:`synchrone` : chaque "
"requête doit être terminée avant de pouvoir traiter la suivante. Cette "
"méthode n'est pas adaptée si les requêtes prennent beaucoup de temps à être "
"traitées. Cela peut arriver si les requêtes demandent beaucoup de calcul, ou "
"si elles renvoient beaucoup de données que le client peine à traiter. Dans "
"ce cas, la solution est de créer un processus ou un fil d’exécution séparé "
"pour chaque requête ; les classes de mélange :class:`ForkingMixIn` et :class:"
"`ThreadingMixIn` peuvent être utilisées pour réaliser ce comportement "
"asynchrone."

#: library/socketserver.rst:52
msgid ""
"Creating a server requires several steps.  First, you must create a request "
"handler class by subclassing the :class:`BaseRequestHandler` class and "
"overriding its :meth:`~BaseRequestHandler.handle` method; this method will "
"process incoming requests.  Second, you must instantiate one of the server "
"classes, passing it the server's address and the request handler class. It "
"is recommended to use the server in a :keyword:`with` statement. Then call "
"the :meth:`~BaseServer.handle_request` or :meth:`~BaseServer.serve_forever` "
"method of the server object to process one or many requests.  Finally, call :"
"meth:`~BaseServer.server_close` to close the socket (unless you used a :"
"keyword:`!with` statement)."
msgstr ""
"La création d'un serveur requiert plusieurs étapes. Premièrement, vous devez "
"créer une classe pour gérer les requêtes en héritant de :class:"
"`BaseRequestHandler` et surcharger sa méthode :meth:`~BaseRequestHandler."
"handle`, laquelle traitera les requêtes entrantes. Deuxièmement, vous devez "
"instancier l'une des classes serveurs et lui passer l’adresse du serveur "
"ainsi que la classe gérant les requêtes. Il est recommandé de faire ceci "
"dans une instruction :keyword:`with`. Ensuite, appelez la méthode :meth:"
"`~BaseServer.handle_request` ou :meth:`~BaseServer.serve_forever` de l'objet "
"serveur afin de traiter une ou plusieurs requêtes. Enfin, appelez la "
"méthode :meth:`~BaseServer.server_close` pour fermer le connecteur (à moins "
"que vous n'ayez utilisé une instruction :keyword:`!with`)."

#: library/socketserver.rst:64
msgid ""
"When inheriting from :class:`ThreadingMixIn` for threaded connection "
"behavior, you should explicitly declare how you want your threads to behave "
"on an abrupt shutdown.  The :class:`ThreadingMixIn` class defines an "
"attribute *daemon_threads*, which indicates whether or not the server should "
"wait for thread termination.  You should set the flag explicitly if you "
"would like threads to behave autonomously; the default is :const:`False`, "
"meaning that Python will not exit until all threads created by :class:"
"`ThreadingMixIn` have exited."
msgstr ""
"Lorsque vous héritez de :class:`ThreadingMixIn` pour déléguer les connexions "
"à différent fils d’exécution, vous devez déclarer explicitement comment les "
"fils d’exécution doivent se comporter en cas d'arrêt abrupt. La classe :"
"class:`ThreadingMixIn` définit un attribut *daemon_threads*, indiquant si le "
"serveur doit attendre la fin des fils d’exécution ou non. Vous pouvez "
"utiliser cet attribut si vous souhaitez que les fils d’exécution soient "
"autonomes. La valeur par défaut est :const:`False`, indiquant que Python ne "
"doit pas quitter avant que tous les fils d'exécution créés par :class:"
"`ThreadingMixIn` ne soient terminés."

#: library/socketserver.rst:73
msgid ""
"Server classes have the same external methods and attributes, no matter what "
"network protocol they use."
msgstr ""
"Toutes les classes de serveurs exposent les mêmes méthodes et attributs, peu "
"importe le protocole réseau utilisé."

#: library/socketserver.rst:78
msgid "Server Creation Notes"
msgstr "Notes sur la création de serveurs"

#: library/socketserver.rst:80
msgid ""
"There are five classes in an inheritance diagram, four of which represent "
"synchronous servers of four types::"
msgstr ""
"Il y a cinq classes dans la hiérarchie. Quatre d'entre elles représentent "
"des serveurs synchrones de quatre types différents ::"

#: library/socketserver.rst:97
#, fuzzy
msgid ""
"Note that :class:`UnixDatagramServer` derives from :class:`UDPServer`, not "
"from :class:`UnixStreamServer` --- the only difference between an IP and a "
"Unix server is the address family."
msgstr ""
"Notez que la classe :class:`UnixDatagramServer` hérite de :class:`UDPServer` "
"et pas de :class:`UnixStreamServer` — la seule différente entre un serveur à "
"flux de données IP et Unix est la famille d’adresse, qui est simplement "
"répétée dans les deux classes serveur Unix."

#: library/socketserver.rst:105
msgid ""
"Forking and threading versions of each type of server can be created using "
"these mix-in classes.  For instance, :class:`ThreadingUDPServer` is created "
"as follows::"
msgstr ""
"Des versions utilisant des fils d’exécution ou des processus peuvent être "
"créées pour chaque type de serveur, en utilisant ces classes de mélange. Par "
"exemple, :class:`ThreadingUDPServer` est créé comme suit ::"

#: library/socketserver.rst:112
msgid ""
"The mix-in class comes first, since it overrides a method defined in :class:"
"`UDPServer`.  Setting the various attributes also changes the behavior of "
"the underlying server mechanism."
msgstr ""
"La classe de mélange est en premier car elle surcharge une méthode définie "
"dans :class:`UDPServer`. Configurer les différents attributs changera "
"également le comportement du serveur."

#: library/socketserver.rst:116
msgid ""
":class:`ForkingMixIn` and the Forking classes mentioned below are only "
"available on POSIX platforms that support :func:`~os.fork`."
msgstr ""
"La classe :class:`ForkingMixIn` et les classes créant des processus "
"mentionnées ci-dessous sont uniquement disponibles sur les plateformes POSIX "
"prenant en charge :func:`~os.fork`."

#: library/socketserver.rst:119
msgid ""
":meth:`socketserver.ForkingMixIn.server_close` waits until all child "
"processes complete, except if :attr:`socketserver.ForkingMixIn."
"block_on_close` attribute is false."
msgstr ""
"La méthode :meth:`socketserver.ForkingMixIn.server_close` attend jusqu'à ce "
"que tous les processus enfants soient terminés, sauf si l'attribut :attr:"
"`socketserver.ForkingMixIn.block_on_close` est faux."

#: library/socketserver.rst:123
msgid ""
":meth:`socketserver.ThreadingMixIn.server_close` waits until all non-daemon "
"threads complete, except if :attr:`socketserver.ThreadingMixIn."
"block_on_close` attribute is false. Use daemonic threads by setting :data:"
"`ThreadingMixIn.daemon_threads` to ``True`` to not wait until threads "
"complete."
msgstr ""
"La méthode :meth:`socketserver.ThreadingMixIn.server_close` attend que tous "
"les fils d'exécution non-*daemon* soit terminés, sauf si l'attribut :attr:"
"`socketserver.ThreadingMixIn.block_on_close` est faux. Utilisez des fils "
"d'exécution *daemon* en réglant :data:`ThreadingMixIn.daemon_threads` à "
"``True`` afin de ne pas attendre que les fils d’exécution soit terminés."

#: library/socketserver.rst:132
msgid ""
":meth:`socketserver.ForkingMixIn.server_close` and :meth:`socketserver."
"ThreadingMixIn.server_close` now waits until all child processes and non-"
"daemonic threads complete. Add a new :attr:`socketserver.ForkingMixIn."
"block_on_close` class attribute to opt-in for the pre-3.7 behaviour."
msgstr ""
"Désormais, :meth:`socketserver.ForkingMixIn.server_close` et :meth:"
"`socketserver.ThreadingMixIn.server_close` attendent que tous les processus "
"enfants et les fils d’exécution non-*daemon* soit terminés. Ajout de :attr:"
"`socketserver.ForkingMixIn.block_on_close`, un nouvel attribut de classe "
"permettant de conserver le comportement pré-3.7."

#: library/socketserver.rst:144
msgid "These classes are pre-defined using the mix-in classes."
msgstr "Ces classes sont prédéfinies en utilisant les classes de mélange."

#: library/socketserver.rst:147
msgid ""
"To implement a service, you must derive a class from :class:"
"`BaseRequestHandler` and redefine its :meth:`~BaseRequestHandler.handle` "
"method. You can then run various versions of the service by combining one of "
"the server classes with your request handler class.  The request handler "
"class must be different for datagram or stream services.  This can be hidden "
"by using the handler subclasses :class:`StreamRequestHandler` or :class:"
"`DatagramRequestHandler`."
msgstr ""
"Pour implémenter un service, vous devez créer une classe héritant de :class:"
"`BaseRequestHandler` et redéfinir sa méthode :meth:`~BaseRequestHandler."
"handle`. Ensuite, vous pourrez créer différentes versions de votre service "
"en combinant les classes serveurs avec votre classe de gestion des requêtes. "
"Cette classe de gestion des requêtes doit être différente pour les services "
"utilisant des datagrammes ou des flux de données. Cette contrainte peut être "
"dissimulée en utilisant les classes de gestion dérivées :class:"
"`StreamRequestHandler` ou :class:`DatagramRequestHandler`."

#: library/socketserver.rst:155
msgid ""
"Of course, you still have to use your head!  For instance, it makes no sense "
"to use a forking server if the service contains state in memory that can be "
"modified by different requests, since the modifications in the child process "
"would never reach the initial state kept in the parent process and passed to "
"each child.  In this case, you can use a threading server, but you will "
"probably have to use locks to protect the integrity of the shared data."
msgstr ""
"Bien entendu, vous devrez toujours utiliser votre tête ! Par exemple, "
"utiliser un serveur utilisant des processus clonés (*forking*) n'aurait "
"aucun sens si le serveur garde en mémoire des états pouvant être modifiés "
"par les requêtes reçues. En effet, un processus enfant traitant une requête "
"n'aurait alors aucun moyen de propager le nouvel état à son parent. Dans ce "
"cas, vous devez utiliser un serveur utilisant des fils d'exécution, mais "
"cela demande probablement d'utiliser des verrous pour protéger l’intégrité "
"des données partagées."

#: library/socketserver.rst:162
msgid ""
"On the other hand, if you are building an HTTP server where all data is "
"stored externally (for instance, in the file system), a synchronous class "
"will essentially render the service \"deaf\" while one request is being "
"handled -- which may be for a very long time if a client is slow to receive "
"all the data it has requested.  Here a threading or forking server is "
"appropriate."
msgstr ""
"D'un autre côté, si vous développez un serveur HTTP qui a toutes ses données "
"stockées hors de la mémoire (sur un système de fichiers par exemple), une "
"classe synchrone rendrait le service sourd à toute nouvelle requête aussi "
"longtemps qu'une précédente soit en cours de traitement. Cette situation "
"pourrait perdurer pendant un long moment si le client prend du temps à "
"recevoir toutes les données demandées. Dans ce cas, un serveur utilisant des "
"processus ou des fils d'exécutions est approprié."

#: library/socketserver.rst:168
msgid ""
"In some cases, it may be appropriate to process part of a request "
"synchronously, but to finish processing in a forked child depending on the "
"request data.  This can be implemented by using a synchronous server and "
"doing an explicit fork in the request handler class :meth:"
"`~BaseRequestHandler.handle` method."
msgstr ""
"Dans certains cas, il peut être judicieux de commencer à traiter une requête "
"de façon synchrone mais de pouvoir déléguer le reste du traitement à un "
"processus enfant si besoin. Ce comportement peut être implémenté en "
"utilisant un serveur synchrone et en laissant à la méthode :meth:"
"`~BaseRequestHandler.handle`, de la classe gérant les requêtes, le soin de "
"créer le processus enfant explicitement."

#: library/socketserver.rst:173
msgid ""
"Another approach to handling multiple simultaneous requests in an "
"environment that supports neither threads nor :func:`~os.fork` (or where "
"these are too expensive or inappropriate for the service) is to maintain an "
"explicit table of partially finished requests and to use :mod:`selectors` to "
"decide which request to work on next (or whether to handle a new incoming "
"request).  This is particularly important for stream services where each "
"client can potentially be connected for a long time (if threads or "
"subprocesses cannot be used).  See :mod:`asyncore` for another way to manage "
"this."
msgstr ""
"Une autre méthode pour gérer plusieurs requêtes simultanément dans un "
"environnement ne prenant en charge ni les fils d’exécution ni :func:`~os."
"fork` (ou si cela est trop coûteux ou inapproprié compte tenu de la nature "
"du service) est de maintenir une table des requêtes en cours de traitement "
"et d’utiliser :mod:`selectors` pour décider sur quelle requête travailler "
"(et quand accepter une nouvelle requête). Cela est particulièrement "
"important pour les services utilisant des flux de données où chaque client "
"peut rester connecté pour longtemps. Pour une autre façon de gérer cela, "
"voir :mod:`asyncore`."

#: library/socketserver.rst:187
msgid "Server Objects"
msgstr "Objets serveur"

#: library/socketserver.rst:191
msgid ""
"This is the superclass of all Server objects in the module.  It defines the "
"interface, given below, but does not implement most of the methods, which is "
"done in subclasses.  The two parameters are stored in the respective :attr:"
"`server_address` and :attr:`RequestHandlerClass` attributes."
msgstr ""
"Il s'agit de la classe parente de tous les objets serveur du module. Elle "
"déclare l'interface, définie ci-dessous, mais laisse aux classes filles le "
"soin d'implémenter la plupart des méthodes. Les deux paramètres sont stockés "
"respectivement dans les attributs :attr:`server_address` et :attr:"
"`RequestHandlerClass`."

#: library/socketserver.rst:199
msgid ""
"Return an integer file descriptor for the socket on which the server is "
"listening.  This function is most commonly passed to :mod:`selectors`, to "
"allow monitoring multiple servers in the same process."
msgstr ""
"Renvoie un entier représentant le descripteur de fichier pour le connecteur "
"que le serveur écoute. Cette fonction est, la plupart du temps, passée à :"
"mod:`selectors` afin de pouvoir surveiller plusieurs serveurs dans le même "
"processus."

#: library/socketserver.rst:206
msgid ""
"Process a single request.  This function calls the following methods in "
"order: :meth:`get_request`, :meth:`verify_request`, and :meth:"
"`process_request`.  If the user-provided :meth:`~BaseRequestHandler.handle` "
"method of the handler class raises an exception, the server's :meth:"
"`handle_error` method will be called.  If no request is received within :"
"attr:`timeout` seconds, :meth:`handle_timeout` will be called and :meth:"
"`handle_request` will return."
msgstr ""
"Traite une seule requête. Cette fonction appelle, dans l'ordre, les "
"méthodes :meth:`get_request`, :meth:`verify_request` et :meth:"
"`process_request`. Si la méthode :meth:`~BaseRequestHandler.handle` de la "
"classe de gestion des requêtes lève une exception, alors la méthode :meth:"
"`handle_error` du serveur est appelée. Si aucune requête n'est reçue avant "
"« :attr:`timeout` » secondes, :meth:`handle_timeout` est appelée et :meth:"
"`handle_request` rend la main."

#: library/socketserver.rst:218
msgid ""
"Handle requests until an explicit :meth:`shutdown` request.  Poll for "
"shutdown every *poll_interval* seconds. Ignores the :attr:`timeout` "
"attribute.  It also calls :meth:`service_actions`, which may be used by a "
"subclass or mixin to provide actions specific to a given service.  For "
"example, the :class:`ForkingMixIn` class uses :meth:`service_actions` to "
"clean up zombie child processes."
msgstr ""
"Gère les requêtes indéfiniment jusqu'à ce que :meth:`shutdown` soit appelée. "
"Vérifie si une demande d’arrêt (*shutdown*) a été émise toutes les "
"*poll_interval* secondes. Ignore l'attribut :attr:`timeout`. Appelle "
"également :meth:`service_actions`, qui peut être utilisée par une classe "
"enfant ou une classe de mélange afin d'implémenter une action spécifique "
"pour un service donné. Par exemple, la classe :class:`ForkingMixIn` utilise :"
"meth:`service_actions` pour supprimer les processus enfants zombies."

#: library/socketserver.rst:226
msgid "Added ``service_actions`` call to the ``serve_forever`` method."
msgstr "La méthode ``serve_forever`` appelle dorénavant ``service_actions``."

#: library/socketserver.rst:232
msgid ""
"This is called in the :meth:`serve_forever` loop. This method can be "
"overridden by subclasses or mixin classes to perform actions specific to a "
"given service, such as cleanup actions."
msgstr ""
"Cette méthode est appelée dans la boucle de :meth:`serve_forever`. Cette "
"méthode peut être surchargée par une classe fille ou une classe de mélange "
"afin d'effectuer une action spécifique à un service donné, comme une action "
"de nettoyage."

#: library/socketserver.rst:240
msgid ""
"Tell the :meth:`serve_forever` loop to stop and wait until it does. :meth:"
"`shutdown` must be called while :meth:`serve_forever` is running in a "
"different thread otherwise it will deadlock."
msgstr ""
"Demande l'arrêt de la boucle de :meth:`serve_forever` et attend jusqu'à ce "
"que ce soit fait. :meth:`shutdown` doit être appelée dans un fil d’exécution "
"différent de :meth:`serve_forever` sous peine d'interblocage."

#: library/socketserver.rst:247
msgid "Clean up the server. May be overridden."
msgstr "Nettoie le serveur. Peut être surchargée."

#: library/socketserver.rst:252
msgid ""
"The family of protocols to which the server's socket belongs. Common "
"examples are :const:`socket.AF_INET` and :const:`socket.AF_UNIX`."
msgstr ""
"La famille de protocoles auquel le connecteur appartient. Les exemples les "
"plus communs sont :const:`socket.AF_INET` et :const:`socket.AF_UNIX`."

#: library/socketserver.rst:258
msgid ""
"The user-provided request handler class; an instance of this class is "
"created for each request."
msgstr ""
"La classe de gestion des requêtes, fournie par l'utilisateur. Une instance "
"de cette classe est créée pour chaque requête."

#: library/socketserver.rst:264
msgid ""
"The address on which the server is listening.  The format of addresses "
"varies depending on the protocol family; see the documentation for the :mod:"
"`socket` module for details.  For internet protocols, this is a tuple "
"containing a string giving the address, and an integer port number: "
"``('127.0.0.1', 80)``, for example."
msgstr ""
"Renvoie l’adresse sur laquelle le serveur écoute. Le format de l’adresse "
"dépend de la famille de protocoles utilisée ; pour plus de détails, voir la "
"documentation du module :mod:`socket`. Pour les protocoles Internet, cette "
"valeur est une paire formée d'une chaine de caractère pour l’adresse et d'un "
"entier pour le port. Exemple : ``('127.0.0.1', 80)``."

#: library/socketserver.rst:273
msgid ""
"The socket object on which the server will listen for incoming requests."
msgstr ""
"L'objet connecteur utilisé par le serveur pour écouter les nouvelles "
"requêtes."

#: library/socketserver.rst:276
msgid "The server classes support the following class variables:"
msgstr ""
"Les classes serveurs prennent en charge les variables de classe suivantes :"

#: library/socketserver.rst:282
msgid ""
"Whether the server will allow the reuse of an address.  This defaults to :"
"const:`False`, and can be set in subclasses to change the policy."
msgstr ""
"Indique si le serveur autorise la réutilisation d'une adresse. La valeur par "
"défaut est :const:`False` mais cela peut être changé dans les classes "
"enfants."

#: library/socketserver.rst:288
msgid ""
"The size of the request queue.  If it takes a long time to process a single "
"request, any requests that arrive while the server is busy are placed into a "
"queue, up to :attr:`request_queue_size` requests.  Once the queue is full, "
"further requests from clients will get a \"Connection denied\" error.  The "
"default value is usually 5, but this can be overridden by subclasses."
msgstr ""
"La taille de la file des requêtes. Lorsque traiter une requête prend du "
"temps, toute nouvelle requête arrivant pendant que le serveur est occupé est "
"placé dans une file jusqu'à atteindre « :attr:`request_queue_size` » "
"requêtes. Si la queue est pleine, les nouvelles requêtes clientes se voient "
"renvoyer une erreur *Connection denied*. La valeur par défaut est "
"habituellement 5 mais peut être changée par les classes filles."

#: library/socketserver.rst:297
msgid ""
"The type of socket used by the server; :const:`socket.SOCK_STREAM` and :"
"const:`socket.SOCK_DGRAM` are two common values."
msgstr ""
"Le type de connecteur utilisé par le serveur ; :const:`socket.SOCK_STREAM` "
"et :const:`socket.SOCK_DGRAM` sont deux valeurs usuelles."

#: library/socketserver.rst:303
msgid ""
"Timeout duration, measured in seconds, or :const:`None` if no timeout is "
"desired.  If :meth:`handle_request` receives no incoming requests within the "
"timeout period, the :meth:`handle_timeout` method is called."
msgstr ""
"Délai d'attente en secondes, ou :const:`None` si aucune limite n'est "
"demandée. Si :meth:`handle_request` ne reçoit aucune requête entrante "
"pendant le délai d'attente, la méthode :meth:`handle_timeout` est appelée."

#: library/socketserver.rst:308
msgid ""
"There are various server methods that can be overridden by subclasses of "
"base server classes like :class:`TCPServer`; these methods aren't useful to "
"external users of the server object."
msgstr ""
"Il existe plusieurs méthodes serveur pouvant être surchargées par des "
"classes dérivant de classes de base comme :class:`TCPServer` ; ces méthodes "
"ne sont pas utiles aux utilisateurs externes de l'objet serveur."

#: library/socketserver.rst:317
msgid ""
"Actually processes the request by instantiating :attr:`RequestHandlerClass` "
"and calling its :meth:`~BaseRequestHandler.handle` method."
msgstr ""
"Méthode en charge de traiter la requête en instanciant :attr:"
"`RequestHandlerClass` et en appelant sa méthode :meth:`~BaseRequestHandler."
"handle`."

#: library/socketserver.rst:323
msgid ""
"Must accept a request from the socket, and return a 2-tuple containing the "
"*new* socket object to be used to communicate with the client, and the "
"client's address."
msgstr ""
"Accepte obligatoirement une requête depuis le connecteur et renvoie une "
"paire contenant le *nouvel* objet connecteur utilisé pour communiquer avec "
"le client et l'adresse du client."

#: library/socketserver.rst:330
msgid ""
"This function is called if the :meth:`~BaseRequestHandler.handle` method of "
"a :attr:`RequestHandlerClass` instance raises an exception.  The default "
"action is to print the traceback to standard error and continue handling "
"further requests."
msgstr ""
"Cette fonction est appelée si la méthode :meth:`~BaseRequestHandler.handle` "
"de l'objet :attr:`RequestHandlerClass` lève une exception. Par défaut, la "
"méthode imprime la trace d'appels sur la sortie d'erreur standard et "
"continue de traiter les requêtes suivantes."

#: library/socketserver.rst:335
msgid "Now only called for exceptions derived from the :exc:`Exception` class."
msgstr ""
"N'est maintenant appelée que sur les exceptions dérivant de la classe :exc:"
"`Exception`."

#: library/socketserver.rst:342
msgid ""
"This function is called when the :attr:`timeout` attribute has been set to a "
"value other than :const:`None` and the timeout period has passed with no "
"requests being received.  The default action for forking servers is to "
"collect the status of any child processes that have exited, while in "
"threading servers this method does nothing."
msgstr ""
"Cette fonction est appelée lorsque l'attribut :attr:`timeout` est réglé à "
"autre chose que :const:`None` et que le délai d'attente expire sans "
"qu'aucune requête ne soit reçue. Par défaut, cette fonction récupère le "
"statut de tous les processus enfants ayant terminé pour les serveurs "
"utilisant des processus ou ne fait rien pour le cas des serveurs utilisant "
"des fils d’exécution."

#: library/socketserver.rst:351
msgid ""
"Calls :meth:`finish_request` to create an instance of the :attr:"
"`RequestHandlerClass`.  If desired, this function can create a new process "
"or thread to handle the request; the :class:`ForkingMixIn` and :class:"
"`ThreadingMixIn` classes do this."
msgstr ""
"Appelle :meth:`finish_request` pour instancier :attr:`RequestHandlerClass`. "
"Si désiré, cette fonction peut créer des processus fils ou des fils "
"d’exécution pour traiter les requêtes ; les classes de mélange :class:"
"`ForkingMixIn` et :class:`ThreadingMixIn` implémentent cela."

#: library/socketserver.rst:363
msgid ""
"Called by the server's constructor to activate the server.  The default "
"behavior for a TCP server just invokes :meth:`~socket.socket.listen` on the "
"server's socket.  May be overridden."
msgstr ""
"Appelée par le constructeur du serveur afin de l'activer. Le comportement "
"par défaut pour un serveur TCP est de seulement invoquer :meth:`~socket."
"socket.listen` sur le connecteur du serveur. Peut être surchargée."

#: library/socketserver.rst:370
msgid ""
"Called by the server's constructor to bind the socket to the desired "
"address. May be overridden."
msgstr ""
"Appelée par le constructeur du serveur afin d'assigner (*bind*) l'adresse "
"requise au connecteur du serveur. Peut être surchargée."

#: library/socketserver.rst:376
msgid ""
"Must return a Boolean value; if the value is :const:`True`, the request will "
"be processed, and if it's :const:`False`, the request will be denied.  This "
"function can be overridden to implement access controls for a server. The "
"default implementation always returns :const:`True`."
msgstr ""
"Doit renvoyer un booléen. Si la valeur est :const:`True`, la requête sera "
"traitée. Si la valeur est :const:`False`, la requête sera refusée. Cette "
"fonction peut être surchargée afin d'implémenter une stratégie de contrôle "
"d'accès au serveur. L'implémentation par défaut renvoie toujours :const:"
"`True`."

#: library/socketserver.rst:382
msgid ""
"Support for the :term:`context manager` protocol was added.  Exiting the "
"context manager is equivalent to calling :meth:`server_close`."
msgstr ""
"La gestion du protocole :term:`context manager` a été ajoutée. Sortir du "
"gestionnaire de contexte revient à appeler :meth:`server_close`."

#: library/socketserver.rst:388
msgid "Request Handler Objects"
msgstr "Objets gestionnaire de requêtes"

#: library/socketserver.rst:392
msgid ""
"This is the superclass of all request handler objects.  It defines the "
"interface, given below.  A concrete request handler subclass must define a "
"new :meth:`handle` method, and can override any of the other methods.  A new "
"instance of the subclass is created for each request."
msgstr ""
"Classe de base de tous les objets gestionnaire de requêtes. Elle déclare "
"l'interface, définie ci-dessous, pour tous les gestionnaires. Une "
"implémentation concrète doit définir une nouvelle méthode :meth:`handle` et "
"peut surcharger n'importe quelle autre méthode. Cette classe concrète est "
"instanciée pour chaque requête."

#: library/socketserver.rst:401
msgid ""
"Called before the :meth:`handle` method to perform any initialization "
"actions required.  The default implementation does nothing."
msgstr ""
"Appelée avant la méthode :meth:`handle` afin d'effectuer toutes les "
"opérations d'initialisation requises. L'implémentation par défaut ne fait "
"rien."

#: library/socketserver.rst:407
msgid ""
"This function must do all the work required to service a request.  The "
"default implementation does nothing.  Several instance attributes are "
"available to it; the request is available as :attr:`self.request`; the "
"client address as :attr:`self.client_address`; and the server instance as :"
"attr:`self.server`, in case it needs access to per-server information."
msgstr ""
"Cette fonction doit faire tout le nécessaire pour traiter une requête. "
"L'implémentation par défaut ne fait rien. La fonction peut accéder à "
"plusieurs attributs d'instance : la requête elle-même se trouve dans :attr:"
"`self.request`, l'adresse du client dans :attr:`self.client_address` et "
"l'instance du serveur dans :attr:`self.server` (dans le cas où il aurait "
"besoin d'accéder aux informations du serveur)."

#: library/socketserver.rst:413
msgid ""
"The type of :attr:`self.request` is different for datagram or stream "
"services.  For stream services, :attr:`self.request` is a socket object; for "
"datagram services, :attr:`self.request` is a pair of string and socket."
msgstr ""
"Le type de :attr:`self.request` est différent pour les services utilisant "
"des datagrammes ou des flux de données. Pour les services à flux de "
"données, :attr:`self.request` renvoie l'objet connecteur ; pour les services "
"à datagrammes, :attr:`self.request` est une paire constituée d'une chaîne de "
"caractères et du connecteur."

#: library/socketserver.rst:420
msgid ""
"Called after the :meth:`handle` method to perform any clean-up actions "
"required.  The default implementation does nothing.  If :meth:`setup` raises "
"an exception, this function will not be called."
msgstr ""
"Appelée après la méthode :meth:`handle` pour effectuer les opérations de "
"nettoyage requises. L'implémentation par défaut ne fait rien. Si :meth:"
"`setup` lève une exception, cette méthode n'est pas appelée."

#: library/socketserver.rst:428
#, fuzzy
msgid ""
"These :class:`BaseRequestHandler` subclasses override the :meth:"
"`~BaseRequestHandler.setup` and :meth:`~BaseRequestHandler.finish` methods, "
"and provide :attr:`self.rfile` and :attr:`self.wfile` attributes. The :attr:"
"`self.rfile` and :attr:`self.wfile` attributes can be read or written, "
"respectively, to get the request data or return data to the client. The :"
"attr:`!rfile` attributes support the :class:`io.BufferedIOBase` readable "
"interface, and :attr:`!wfile` attributes support the :class:`!io."
"BufferedIOBase` writable interface."
msgstr ""
"Ces classes, héritant de :class:`BaseRequestHandler`, redéfinissent les "
"méthodes :meth:`~BaseRequestHandler.setup` et :meth:`~BaseRequestHandler."
"finish` et fournissent les attributs :attr:`self.rfile` et :attr:`self."
"wfile`. Les deux attributs :attr:`self.rfile` et :attr:`self.wfile` peuvent "
"être respectivement lus ou écrits, afin de récupérer les données de la "
"requête ou d'envoyer des données au client."

#: library/socketserver.rst:437
msgid ""
":attr:`StreamRequestHandler.wfile` also supports the :class:`io."
"BufferedIOBase` writable interface."
msgstr ""
":attr:`StreamRequestHandler.wfile`  prend également en charge l'interface "
"d'écriture de :class:`io.BufferedIOBase`."

#: library/socketserver.rst:443
msgid "Examples"
msgstr "Exemples"

#: library/socketserver.rst:446
msgid ":class:`socketserver.TCPServer` Example"
msgstr "Exemple pour :class:`socketserver.TCPServer`"

#: library/socketserver.rst:547
msgid "This is the server side::"
msgstr "Implémentation côté serveur ::"

#: library/socketserver.rst:478
msgid ""
"An alternative request handler class that makes use of streams (file-like "
"objects that simplify communication by providing the standard file "
"interface)::"
msgstr ""
"Une implémentation alternative du gestionnaire de requêtes utilisant les "
"flux de données (avec des objets fichier-compatibles simplifiant la "
"communication en fournissant l'interface fichier standard) ::"

#: library/socketserver.rst:493
msgid ""
"The difference is that the ``readline()`` call in the second handler will "
"call ``recv()`` multiple times until it encounters a newline character, "
"while the single ``recv()`` call in the first handler will just return what "
"has been sent from the client in one ``sendall()`` call."
msgstr ""
"La différence est que l'appel à ``readline()`` dans le second gestionnaire "
"permet d'appeler ``recv()`` jusqu'à rencontrer un caractère de fin de ligne "
"alors que dans le premier gestionnaire appelle directement ``recv()``, "
"renvoyant toutes les données envoyées par le client en un seul appel à "
"``sendall()``."

#: library/socketserver.rst:571
msgid "This is the client side::"
msgstr "Implémentation côté client ::"

#: library/socketserver.rst:646
msgid "The output of the example should look something like this:"
msgstr "La sortie de cet exemple devrait ressembler à ça :"

#: library/socketserver.rst:522
msgid "Server:"
msgstr "Serveur :"

#: library/socketserver.rst:532
msgid "Client:"
msgstr "Client :"

#: library/socketserver.rst:545
msgid ":class:`socketserver.UDPServer` Example"
msgstr "Exemple pour :class:`socketserver.UDPServer`"

#: library/socketserver.rst:590
msgid ""
"The output of the example should look exactly like for the TCP server "
"example."
msgstr ""
"La sortie de cet exemple devrait ressembler exactement à la sortie de "
"l'exemple pour le serveur TCP."

#: library/socketserver.rst:594
msgid "Asynchronous Mixins"
msgstr "Classes de mélange asynchrone"

#: library/socketserver.rst:596
msgid ""
"To build asynchronous handlers, use the :class:`ThreadingMixIn` and :class:"
"`ForkingMixIn` classes."
msgstr ""
"Pour développer des gestionnaires asynchrones, utilisez les classes :class:"
"`ThreadingMixIn` et :class:`ForkingMixIn`."

#: library/socketserver.rst:599
msgid "An example for the :class:`ThreadingMixIn` class::"
msgstr "Exemple pour :class:`ThreadingMixIn` ::"

#: library/socketserver.rst:657
msgid ""
"The :class:`ForkingMixIn` class is used in the same way, except that the "
"server will spawn a new process for each request. Available only on POSIX "
"platforms that support :func:`~os.fork`."
msgstr ""
"La classe :class:`ForkingMixIn` est utilisable de la même façon à la "
"différence près que le serveur crée un nouveau processus fils pour chaque "
"requête. Disponible uniquement sur les plateformes POSIX prenant en charge :"
"func:`~os.fork`."

#~ msgid ""
#~ "The :attr:`rfile` attributes of both classes support the :class:`io."
#~ "BufferedIOBase` readable interface, and :attr:`DatagramRequestHandler."
#~ "wfile` supports the :class:`io.BufferedIOBase` writable interface."
#~ msgstr ""
#~ "L'attribut :attr:`rfile` des deux classes prend en charge l'interface de "
#~ "lecture de :class:`io.BufferedIOBase`. L'attribut :attr:"
#~ "`DatagramRequestHandler.wfile` sait gérer l'interface d'écriture de :"
#~ "class:`io.BufferedIOBase`."