# 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: 2018-07-27 23:21+0200\n"
"Last-Translator: Julien Palard <julien@palard.fr>\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"

#: library/asyncore.rst:2
msgid ":mod:`asyncore` --- Asynchronous socket handler"
msgstr ":mod:`asyncore` — Gestionnaire de socket asynchrone"

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

#: library/asyncore.rst:20
msgid ""
"The :mod:`asyncore` module is deprecated (see :pep:`PEP 594 <594#asyncore>` "
"for details). Please use :mod:`asyncio` instead."
msgstr ""

#: library/asyncore.rst:25
msgid ""
"This module exists for backwards compatibility only.  For new code we "
"recommend using :mod:`asyncio`."
msgstr ""
"Ce module n'existe que pour des raisons de rétrocompatibilité. Pour du code "
"nouveau, l'utilisation de :mod:`asyncio` est recommandée."

#: library/asyncore.rst:28
msgid ""
"This module provides the basic infrastructure for writing asynchronous  "
"socket service clients and servers."
msgstr ""

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

#: 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/asyncore.rst:33
msgid ""
"There are only two ways to have a program on a single processor do  \"more "
"than one thing at a time.\" Multi-threaded programming is the  simplest and "
"most popular way to do it, but there is another very different technique, "
"that lets you have nearly all the advantages of  multi-threading, without "
"actually using multiple threads.  It's really  only practical if your "
"program is largely I/O bound.  If your program is processor bound, then pre-"
"emptive scheduled threads are probably what you really need.  Network "
"servers are rarely processor bound, however."
msgstr ""

#: library/asyncore.rst:42
msgid ""
"If your operating system supports the :c:func:`select` system call in its I/"
"O library (and nearly all do), then you can use it to juggle multiple "
"communication channels at once; doing other work while your I/O is taking "
"place in the \"background.\"  Although this strategy can seem strange and "
"complex, especially at first, it is in many ways easier to understand and "
"control than multi-threaded programming.  The :mod:`asyncore` module solves "
"many of the difficult problems for you, making the task of building "
"sophisticated high-performance network servers and clients a snap.  For "
"\"conversational\" applications and protocols the companion :mod:`asynchat` "
"module is invaluable."
msgstr ""

#: library/asyncore.rst:53
msgid ""
"The basic idea behind both modules is to create one or more network "
"*channels*, instances of class :class:`asyncore.dispatcher` and :class:"
"`asynchat.async_chat`.  Creating the channels adds them to a global map, "
"used by the :func:`loop` function if you do not provide it with your own "
"*map*."
msgstr ""

#: library/asyncore.rst:59
msgid ""
"Once the initial channel(s) is(are) created, calling the :func:`loop` "
"function activates channel service, which continues until the last channel "
"(including any that have been added to the map during asynchronous service) "
"is closed."
msgstr ""

#: library/asyncore.rst:66
msgid ""
"Enter a polling loop that terminates after count passes or all open channels "
"have been closed.  All arguments are optional.  The *count* parameter "
"defaults to ``None``, resulting in the loop terminating only when all "
"channels have been closed.  The *timeout* argument sets the timeout "
"parameter for the appropriate :func:`~select.select` or :func:`~select.poll` "
"call, measured in seconds; the default is 30 seconds.  The *use_poll* "
"parameter, if true, indicates that :func:`~select.poll` should be used in "
"preference to :func:`~select.select` (the default is ``False``)."
msgstr ""

#: library/asyncore.rst:75
msgid ""
"The *map* parameter is a dictionary whose items are the channels to watch. "
"As channels are closed they are deleted from their map.  If *map* is "
"omitted, a global map is used. Channels (instances of :class:`asyncore."
"dispatcher`, :class:`asynchat.async_chat` and subclasses thereof) can freely "
"be mixed in the map."
msgstr ""

#: library/asyncore.rst:84
msgid ""
"The :class:`dispatcher` class is a thin wrapper around a low-level socket "
"object. To make it more useful, it has a few methods for event-handling "
"which are called from the asynchronous loop.   Otherwise, it can be treated "
"as a normal non-blocking socket object."
msgstr ""

#: library/asyncore.rst:89
msgid ""
"The firing of low-level events at certain times or in certain connection "
"states tells the asynchronous loop that certain higher-level events have "
"taken place.  For example, if we have asked for a socket to connect to "
"another host, we know that the connection has been made when the socket "
"becomes writable for the first time (at this point you know that you may "
"write to it with the expectation of success).  The implied higher-level "
"events are:"
msgstr ""

#: library/asyncore.rst:98
msgid "Event"
msgstr ""

#: library/asyncore.rst:98
msgid "Description"
msgstr "Description"

#: library/asyncore.rst:100
msgid "``handle_connect()``"
msgstr "``handle_connect()``"

#: library/asyncore.rst:100
msgid "Implied by the first read or write event"
msgstr ""

#: library/asyncore.rst:103
msgid "``handle_close()``"
msgstr "``handle_close()``"

#: library/asyncore.rst:103
msgid "Implied by a read event with no data available"
msgstr ""

#: library/asyncore.rst:106
msgid "``handle_accepted()``"
msgstr "``handle_accepted()``"

#: library/asyncore.rst:106
msgid "Implied by a read event on a listening socket"
msgstr ""

#: library/asyncore.rst:110
msgid ""
"During asynchronous processing, each mapped channel's :meth:`readable` and :"
"meth:`writable` methods are used to determine whether the channel's socket "
"should be added to the list of channels :c:func:`select`\\ ed or :c:func:"
"`poll`\\ ed for read and write events."
msgstr ""

#: library/asyncore.rst:115
msgid ""
"Thus, the set of channel events is larger than the basic socket events.  The "
"full set of methods that can be overridden in your subclass follows:"
msgstr ""

#: library/asyncore.rst:121
msgid ""
"Called when the asynchronous loop detects that a :meth:`read` call on the "
"channel's socket will succeed."
msgstr ""

#: library/asyncore.rst:127
msgid ""
"Called when the asynchronous loop detects that a writable socket can be "
"written.  Often this method will implement the necessary buffering for "
"performance.  For example::"
msgstr ""

#: library/asyncore.rst:138
msgid ""
"Called when there is out of band (OOB) data for a socket connection.  This "
"will almost never happen, as OOB is tenuously supported and rarely used."
msgstr ""

#: library/asyncore.rst:144
msgid ""
"Called when the active opener's socket actually makes a connection.  Might "
"send a \"welcome\" banner, or initiate a protocol negotiation with the "
"remote endpoint, for example."
msgstr ""

#: library/asyncore.rst:151
msgid "Called when the socket is closed."
msgstr "Appelé lorsque la socket est fermée."

#: library/asyncore.rst:156
msgid ""
"Called when an exception is raised and not otherwise handled.  The default "
"version prints a condensed traceback."
msgstr ""

#: library/asyncore.rst:162
msgid ""
"Called on listening channels (passive openers) when a connection can be "
"established with a new remote endpoint that has issued a :meth:`connect` "
"call for the local endpoint. Deprecated in version 3.2; use :meth:"
"`handle_accepted` instead."
msgstr ""

#: library/asyncore.rst:172
msgid ""
"Called on listening channels (passive openers) when a connection has been "
"established with a new remote endpoint that has issued a :meth:`connect` "
"call for the local endpoint.  *sock* is a *new* socket object usable to send "
"and receive data on the connection, and *addr* is the address bound to the "
"socket on the other end of the connection."
msgstr ""

#: library/asyncore.rst:183
msgid ""
"Called each time around the asynchronous loop to determine whether a "
"channel's socket should be added to the list on which read events can "
"occur.  The default method simply returns ``True``, indicating that by "
"default, all channels will be interested in read events."
msgstr ""

#: library/asyncore.rst:191
msgid ""
"Called each time around the asynchronous loop to determine whether a "
"channel's socket should be added to the list on which write events can "
"occur.  The default method simply returns ``True``, indicating that by "
"default, all channels will be interested in write events."
msgstr ""

#: library/asyncore.rst:197
msgid ""
"In addition, each channel delegates or extends many of the socket methods. "
"Most of these are nearly identical to their socket partners."
msgstr ""

#: library/asyncore.rst:203
msgid ""
"This is identical to the creation of a normal socket, and will use the same "
"options for creation.  Refer to the :mod:`socket` documentation for "
"information on creating sockets."
msgstr ""

#: library/asyncore.rst:207
msgid "*family* and *type* arguments can be omitted."
msgstr "Les arguments *family* et *type* sont optionnels."

#: library/asyncore.rst:213
msgid ""
"As with the normal socket object, *address* is a tuple with the first "
"element the host to connect to, and the second the port number."
msgstr ""

#: library/asyncore.rst:219
msgid "Send *data* to the remote end-point of the socket."
msgstr "Envoie *data* à l'autre bout de la socket."

#: library/asyncore.rst:224
msgid ""
"Read at most *buffer_size* bytes from the socket's remote end-point.  An "
"empty bytes object implies that the channel has been closed from the other "
"end."
msgstr ""

#: library/asyncore.rst:228
msgid ""
"Note that :meth:`recv` may raise :exc:`BlockingIOError` , even though :func:"
"`select.select` or :func:`select.poll` has reported the socket ready for "
"reading."
msgstr ""

#: library/asyncore.rst:235
msgid ""
"Listen for connections made to the socket.  The *backlog* argument specifies "
"the maximum number of queued connections and should be at least 1; the "
"maximum value is system-dependent (usually 5)."
msgstr ""

#: library/asyncore.rst:242
msgid ""
"Bind the socket to *address*.  The socket must not already be bound.  (The "
"format of *address* depends on the address family --- refer to the :mod:"
"`socket` documentation for more information.)  To mark the socket as re-"
"usable (setting the :const:`SO_REUSEADDR` option), call the :class:"
"`dispatcher` object's :meth:`set_reuse_addr` method."
msgstr ""

#: library/asyncore.rst:251
msgid ""
"Accept a connection.  The socket must be bound to an address and listening "
"for connections.  The return value can be either ``None`` or a pair ``(conn, "
"address)`` where *conn* is a *new* socket 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. When ``None`` is returned it means the "
"connection didn't take place, in which case the server should just ignore "
"this event and keep listening for further incoming connections."
msgstr ""

#: library/asyncore.rst:263
msgid ""
"Close the socket.  All future operations on the socket object will fail. The "
"remote end-point will receive no more data (after queued data is flushed).  "
"Sockets are automatically closed when they are garbage-collected."
msgstr ""

#: library/asyncore.rst:271
msgid ""
"A :class:`dispatcher` subclass which adds simple buffered output capability, "
"useful for simple clients. For more sophisticated usage use :class:`asynchat."
"async_chat`."
msgstr ""

#: library/asyncore.rst:277
msgid ""
"A file_dispatcher takes a file descriptor or :term:`file object` along with "
"an optional map argument and wraps it for use with the :c:func:`poll` or :c:"
"func:`loop` functions.  If provided a file object or anything with a :c:func:"
"`fileno` method, that method will be called and passed to the :class:"
"`file_wrapper` constructor."
msgstr ""

#: library/asyncore.rst:292
msgid ":ref:`Availability <availability>`: Unix."
msgstr ":ref:`Disponibilité <availability>` : Unix."

#: library/asyncore.rst:287
msgid ""
"A file_wrapper takes an integer file descriptor and calls :func:`os.dup` to "
"duplicate the handle so that the original handle may be closed independently "
"of the file_wrapper.  This class implements sufficient methods to emulate a "
"socket for use by the :class:`file_dispatcher` class."
msgstr ""

#: library/asyncore.rst:298
msgid "asyncore Example basic HTTP client"
msgstr "Exemple de client HTTP basique avec :mod:`asyncore`"

#: library/asyncore.rst:300
msgid ""
"Here is a very basic HTTP client that uses the :class:`dispatcher` class to "
"implement its socket handling::"
msgstr ""

#: library/asyncore.rst:337
msgid "asyncore Example basic echo server"
msgstr "Serveur *echo* basique avec :mod:`asyncore`"

#: library/asyncore.rst:339
msgid ""
"Here is a basic echo server that uses the :class:`dispatcher` class to "
"accept connections and dispatches the incoming connections to a handler::"
msgstr ""

#~ msgid "Please use :mod:`asyncio` instead."
#~ msgstr "Utilisez :mod:`asyncio` à la place."
