python-docs-fr/library/xmlrpc.client.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-07-23 14:38+0200\n"
"PO-Revision-Date: 2023-09-15 23:59+0200\n"
"Last-Translator: Christophe Nanteuil <christophe.nanteuil@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 3.2.2\n"

#: library/xmlrpc.client.rst:2
msgid ":mod:`xmlrpc.client` --- XML-RPC client access"
msgstr ":mod:`xmlrpc.client` — client XML-RPC"

#: library/xmlrpc.client.rst:10
msgid "**Source code:** :source:`Lib/xmlrpc/client.py`"
msgstr "**Source code:** :source:`Lib/xmlrpc/client.py`"

#: library/xmlrpc.client.rst:17
msgid ""
"XML-RPC is a Remote Procedure Call method that uses XML passed via HTTP(S) "
"as a transport.  With it, a client can call methods with parameters on a "
"remote server (the server is named by a URI) and get back structured data.  "
"This module supports writing XML-RPC client code; it handles all the details "
"of translating between conformable Python objects and XML on the wire."
msgstr ""
"XML-RPC est une méthode d'appel de procédure distante qui utilise le XML "
"transmis via HTTP(S) comme transport. Un client peut ainsi appeler des "
"méthodes avec des paramètres sur un serveur distant (le serveur est nommé "
"par un URI) et récupérer des données structurées. Ce module prend en charge "
"l'écriture de code client XML-RPC ; il gère tous les détails de la "
"traduction entre les objets Python conformes et XML sur le réseau."

# suit un :
#: library/xmlrpc.client.rst:26
msgid ""
"The :mod:`xmlrpc.client` module is not secure against maliciously "
"constructed data.  If you need to parse untrusted or unauthenticated data "
"see :ref:`xml-vulnerabilities`."
msgstr ""
"le module :mod:`xmlrpc.client` n'est pas sécurisé contre les données "
"construites de façon malveillante. Si vous avez besoin d'analyser des "
"données non sécurisées ou non authentifiées, référez-vous à :ref:`xml-"
"vulnerabilities`."

# suit un :
#: library/xmlrpc.client.rst:32
msgid ""
"For HTTPS URIs, :mod:`xmlrpc.client` now performs all the necessary "
"certificate and hostname checks by default."
msgstr ""
"pour les URI HTTPS, :mod:`xmlrpc.client` effectue désormais par défaut "
"toutes les vérifications nécessaires des certificats et des noms d'hôtes."

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

#: 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 ""
"Ce module ne fonctionne pas ou n'est pas disponible sur les plateformes "
"WebAssembly ``wasm32-emscripten`` et ``wasm32-wasi``. Voir :ref:`wasm-"
"availability` pour plus d'informations."

#: library/xmlrpc.client.rst:41
msgid ""
"A :class:`ServerProxy` instance is an object that manages communication with "
"a remote XML-RPC server.  The required first argument is a URI (Uniform "
"Resource Indicator), and will normally be the URL of the server.  The "
"optional second argument is a transport factory instance; by default it is "
"an internal :class:`SafeTransport` instance for https: URLs and an internal "
"HTTP :class:`Transport` instance otherwise.  The optional third argument is "
"an encoding, by default UTF-8. The optional fourth argument is a debugging "
"flag."
msgstr ""
"Une instance :class:`ServerProxy` est un objet qui gère la communication "
"avec un serveur XML-RPC distant. Le premier argument requis est un URI "
"(*Uniform Resource Indicator*), et est normalement l'URL du serveur. Le "
"deuxième argument facultatif est une instance de fabrique de transport ; par "
"défaut, il s'agit d'une instance interne :class:`SafeTransport` pour les URL "
"HTTPS et d'une instance HTTP interne :class:`Transport` sinon. Le troisième "
"argument facultatif est un encodage, par défaut UTF-8. Le quatrième argument "
"facultatif est un indicateur de débogage."

#: library/xmlrpc.client.rst:49
msgid ""
"The following parameters govern the use of the returned proxy instance. If "
"*allow_none* is true,  the Python constant ``None`` will be translated into "
"XML; the default behaviour is for ``None`` to raise a :exc:`TypeError`. This "
"is a commonly used extension to the XML-RPC specification, but isn't "
"supported by all clients and servers; see `http://ontosys.com/xml-rpc/"
"extensions.php <https://web.archive.org/web/20130120074804/http://ontosys."
"com/xml-rpc/extensions.php>`_ for a description. The *use_builtin_types* "
"flag can be used to cause date/time values to be presented as :class:"
"`datetime.datetime` objects and binary data to be presented as :class:"
"`bytes` objects; this flag is false by default. :class:`datetime.datetime`, :"
"class:`bytes` and :class:`bytearray` objects may be passed to calls. The "
"*headers* parameter is an optional sequence of HTTP headers to send with "
"each request, expressed as a sequence of 2-tuples representing the header "
"name and value. (e.g. ``[('Header-Name', 'value')]``). The obsolete "
"*use_datetime* flag is similar to *use_builtin_types* but it applies only to "
"date/time values."
msgstr ""
"Les paramètres suivants régissent l'utilisation de l'instance de mandataire "
"renvoyée. Si *allow_none* est vrai, la constante Python ``None`` est "
"traduite en XML ; le comportement par défaut est que ``None`` lève une :exc:"
"`TypeError`. Il s'agit d'une extension couramment utilisée de la "
"spécification XML-RPC, mais elle n'est pas prise en charge par tous les "
"clients et serveurs ; voir `http://ontosys.com/xml-rpc/extensions.php "
"<https://web.archive.org/web/20130120074804/http://ontosys.com/xml-rpc/"
"extensions.php>`_ pour un descriptif. L'indicateur *use_builtin_types* peut "
"être utilisé pour que les valeurs de date-heure soient présentées comme des "
"objets :class:`datetime.datetime` et que les données binaires soient "
"présentées comme des objets :class:`bytes` ; cet indicateur est faux par "
"défaut. Les objets :class:`datetime.datetime`, :class:`bytes` et :class:"
"`bytearray` peuvent être transmis aux appels. Le paramètre *headers* est une "
"séquence facultative d'en-têtes HTTP à envoyer avec chaque requête, exprimée "
"sous la forme d'une séquence de paires représentant le nom et la valeur de "
"l'en-tête (par exemple ``[('Header-Name', 'value')]``). L'indicateur "
"obsolète *use_datetime* est similaire à *use_builtin_types* mais il "
"s'applique uniquement aux valeurs de date-heure."

# suit un :
#: library/xmlrpc.client.rst:548
msgid "The *use_builtin_types* flag was added."
msgstr "l'indicateur *use_builtin_types* a été ajouté."

# suit un :
#: library/xmlrpc.client.rst:70
msgid "The *headers* parameter was added."
msgstr "le paramètre *headers* a été ajouté."

#: library/xmlrpc.client.rst:73
msgid ""
"Both the HTTP and HTTPS transports support the URL syntax extension for HTTP "
"Basic Authentication: ``http://user:pass@host:port/path``.  The  ``user:"
"pass`` portion will be base64-encoded as an HTTP 'Authorization' header, and "
"sent to the remote server as part of the connection process when invoking an "
"XML-RPC method.  You only need to use this if the remote server requires a "
"Basic Authentication user and password. If an HTTPS URL is provided, "
"*context* may be :class:`ssl.SSLContext` and configures the SSL settings of "
"the underlying HTTPS connection."
msgstr ""
"Les transports HTTP et HTTPS prennent en charge l'extension de syntaxe URL "
"pour l'authentification HTTP basique : ``http://user:pass@host:port/path``. "
"La partie ``user:pass`` est codée en base64 en tant qu'en-tête HTTP "
"« *Authorization* » et envoyée au serveur distant dans le cadre du processus "
"de connexion lors de l'appel d'une méthode XML-RPC. Vous ne devez l'utiliser "
"que si le serveur distant nécessite un utilisateur et un mot de passe "
"d'authentification basique. Si une URL HTTPS est fournie, *context* peut "
"être :class:`ssl.SSLContext` et configure les paramètres SSL de la connexion "
"HTTPS sous-jacente."

#: library/xmlrpc.client.rst:82
msgid ""
"The returned instance is a proxy object with methods that can be used to "
"invoke corresponding RPC calls on the remote server.  If the remote server "
"supports the introspection API, the proxy can also be used to query the "
"remote server for the methods it supports (service discovery) and fetch "
"other server-associated metadata."
msgstr ""
"L'instance renvoyée est un objet mandataire avec des méthodes qui peuvent "
"être utilisées pour effectuer les appels RPC correspondants sur le serveur "
"distant. Si le serveur distant prend en charge l'API d'introspection, le "
"mandataire peut également être utilisé pour interroger le serveur distant "
"sur les méthodes qu'il prend en charge (découverte de services) et récupérer "
"d'autres métadonnées associées au serveur."

#: library/xmlrpc.client.rst:88
msgid ""
"Types that are conformable (e.g. that can be marshalled through XML), "
"include the following (and except where noted, they are unmarshalled as the "
"same Python type):"
msgstr ""
"Les types qui sont conformes (par exemple, qui peuvent être sérialisés via "
"XML) incluent les éléments suivants (et, sauf indication contraire, ne sont "
"pas sérialisés comme le même type Python) :"

#: library/xmlrpc.client.rst:95
msgid "XML-RPC type"
msgstr "Type XML-RPC"

#: library/xmlrpc.client.rst:95
msgid "Python type"
msgstr "Type Python"

#: library/xmlrpc.client.rst:97
msgid "``boolean``"
msgstr "``boolean``"

#: library/xmlrpc.client.rst:97
msgid ":class:`bool`"
msgstr ":class:`bool`"

#: library/xmlrpc.client.rst:99
msgid "``int``, ``i1``, ``i2``,  ``i4``, ``i8`` or ``biginteger``"
msgstr "``int``, ``i1``, ``i2``, ``i4``, ``i8`` ou ``biginteger``"

#: library/xmlrpc.client.rst:99
msgid ""
":class:`int` in range from -2147483648 to 2147483647. Values get the "
"``<int>`` tag."
msgstr ""
":class:`int` compris entre -2147483648 et 2147483647. Les valeurs sont "
"marquées avec la balise ``<int>``."

#: library/xmlrpc.client.rst:104
msgid "``double`` or ``float``"
msgstr "``double`` ou ``float``"

#: library/xmlrpc.client.rst:104
msgid ":class:`float`.  Values get the ``<double>`` tag."
msgstr ":class:`float`. Les valeurs reçoivent la balise ``<double>``."

#: library/xmlrpc.client.rst:107
msgid "``string``"
msgstr "``string``"

#: library/xmlrpc.client.rst:107
msgid ":class:`str`"
msgstr ":class:`str`"

#: library/xmlrpc.client.rst:109
msgid "``array``"
msgstr "``array``"

#: library/xmlrpc.client.rst:109
msgid ""
":class:`list` or :class:`tuple` containing conformable elements.  Arrays are "
"returned as :class:`lists <list>`."
msgstr ""
":class:`liste <list>` ou :class:`n-uplet <tuple>` contenant des éléments "
"conformes. Les tableaux sont renvoyés sous forme de :class:`listes <list>`."

#: library/xmlrpc.client.rst:113
msgid "``struct``"
msgstr "``struct``"

#: library/xmlrpc.client.rst:113
msgid ""
":class:`dict`.  Keys must be strings, values may be any conformable type.  "
"Objects of user-defined classes can be passed in; only their :attr:`~object."
"__dict__` attribute is transmitted."
msgstr ""
":class:`dict`. Les clés doivent être des chaînes, les valeurs peuvent être "
"de n'importe quel type conforme. Les objets des classes définies par "
"l'utilisateur peuvent être transmis ; seul leur attribut :attr:`~object."
"__dict__` est transmis."

#: library/xmlrpc.client.rst:118
msgid "``dateTime.iso8601``"
msgstr "``dateTime.iso8601``"

#: library/xmlrpc.client.rst:118
msgid ""
":class:`DateTime` or :class:`datetime.datetime`. Returned type depends on "
"values of *use_builtin_types* and *use_datetime* flags."
msgstr ""
":class:`DateTime` ou :class:`datetime.datetime`. Le type renvoyé dépend des "
"valeurs des indicateurs *use_builtin_types* et *use_datetime*."

#: library/xmlrpc.client.rst:122
msgid "``base64``"
msgstr "``base64``"

#: library/xmlrpc.client.rst:122
msgid ""
":class:`Binary`, :class:`bytes` or :class:`bytearray`.  Returned type "
"depends on the value of the *use_builtin_types* flag."
msgstr ""
":class:`Binary`, :class:`bytes` ou :class:`bytearray`. Le type renvoyé "
"dépend de la valeur de l'indicateur *use_builtin_types*."

#: library/xmlrpc.client.rst:126
msgid "``nil``"
msgstr "``nil``"

#: library/xmlrpc.client.rst:126
msgid ""
"The ``None`` constant.  Passing is allowed only if *allow_none* is true."
msgstr ""
"La constante ``None``. Le passage n'est autorisé que si *allow_none* est "
"vrai."

#: library/xmlrpc.client.rst:129
msgid "``bigdecimal``"
msgstr "``bigdecimal``"

#: library/xmlrpc.client.rst:129
msgid ":class:`decimal.Decimal`.  Returned type only."
msgstr ":class:`decimal.Decimal`. Type renvoyé uniquement."

#: library/xmlrpc.client.rst:132
msgid ""
"This is the full set of data types supported by XML-RPC.  Method calls may "
"also raise a special :exc:`Fault` instance, used to signal XML-RPC server "
"errors, or :exc:`ProtocolError` used to signal an error in the HTTP/HTTPS "
"transport layer. Both :exc:`Fault` and :exc:`ProtocolError` derive from a "
"base class called :exc:`Error`.  Note that the xmlrpc client module "
"currently does not marshal instances of subclasses of built-in types."
msgstr ""
"Il s'agit de l'ensemble complet des types de données pris en charge par XML-"
"RPC. Les appels de méthode peuvent également déclencher une instance "
"spéciale de :exc:`Fault`, utilisée pour signaler les erreurs du serveur XML-"
"RPC, ou de :exc:`ProtocolError` utilisée pour signaler une erreur dans la "
"couche de transport HTTP/HTTPS. :exc:`Fault` et :exc:`ProtocolError` "
"dérivent toutes deux d'une classe mère appelée :exc:`Error`. Notez que le "
"module client XMLRPC ne sérialise actuellement pas les instances de sous-"
"classes de types natifs."

#: library/xmlrpc.client.rst:139
msgid ""
"When passing strings, characters special to XML such as ``<``, ``>``, and "
"``&`` will be automatically escaped.  However, it's the caller's "
"responsibility to ensure that the string is free of characters that aren't "
"allowed in XML, such as the control characters with ASCII values between 0 "
"and 31 (except, of course, tab, newline and carriage return); failing to do "
"this will result in an XML-RPC request that isn't well-formed XML.  If you "
"have to pass arbitrary bytes via XML-RPC, use :class:`bytes` or :class:"
"`bytearray` classes or the :class:`Binary` wrapper class described below."
msgstr ""
"Lors du passage de chaînes, les caractères spéciaux à XML tels que ``<``, "
"``>`` et ``&`` sont automatiquement échappés. Cependant, il est de la "
"responsabilité de l'appelant de s'assurer que la chaîne ne contient pas de "
"caractères non autorisés en XML, tels que les caractères de contrôle avec "
"des valeurs ASCII comprises entre 0 et 31 (sauf, bien sûr, la tabulation, la "
"nouvelle ligne et le retour chariot) ; si vous ne le faites pas, vous "
"obtiendrez une requête XML-RPC qui n'est pas du XML bien formé. Si vous "
"devez transmettre des octets arbitraires via XML-RPC, utilisez les classes :"
"class:`bytes` ou :class:`bytearray` ou la classe de surcouche :class:"
"`Binary` décrite ci-dessous."

#: library/xmlrpc.client.rst:148
msgid ""
":class:`Server` is retained as an alias for :class:`ServerProxy` for "
"backwards compatibility.  New code should use :class:`ServerProxy`."
msgstr ""
":class:`Server` est conservé comme alias pour :class:`ServerProxy` pour des "
"raisons de compatibilité ascendante. Le nouveau code doit utiliser :class:"
"`ServerProxy`."

# suit un :
#: library/xmlrpc.client.rst:151
msgid "Added the *context* argument."
msgstr "ajout de l'argument *context*."

# suit un :
#: library/xmlrpc.client.rst:154
msgid ""
"Added support of type tags with prefixes (e.g. ``ex:nil``). Added support of "
"unmarshalling additional types used by Apache XML-RPC implementation for "
"numerics: ``i1``, ``i2``, ``i8``, ``biginteger``, ``float`` and "
"``bigdecimal``. See https://ws.apache.org/xmlrpc/types.html for a "
"description."
msgstr ""
"ajout du support des balises de type avec préfixes (par exemple ``ex:nil``). "
"Ajout de la prise en charge des types supplémentaires de désorganisation "
"utilisés par l'implémentation Apache XML-RPC pour les valeurs numériques : "
"``i1``, ``i2``, ``i8``, ``biginteger``, ``float`` et ``bigdecimal``. Voir "
"https://ws.apache.org/xmlrpc/types.html pour une description."

#: library/xmlrpc.client.rst:166
msgid "`XML-RPC HOWTO <https://tldp.org/HOWTO/XML-RPC-HOWTO/index.html>`_"
msgstr ""
"`Guide pratique XML-RPC <https://tldp.org/HOWTO/XML-RPC-HOWTO/index.html>`_"

#: library/xmlrpc.client.rst:165
msgid ""
"A good description of XML-RPC operation and client software in several "
"languages. Contains pretty much everything an XML-RPC client developer needs "
"to know."
msgstr ""
"Une bonne description du fonctionnement de XML-RPC et du logiciel client "
"pour plusieurs langages. Contient à peu près tout ce qu'un développeur "
"client XML-RPC doit savoir."

#: library/xmlrpc.client.rst:169
msgid ""
"`XML-RPC Introspection <https://xmlrpc-c.sourceforge.net/introspection."
"html>`_"
msgstr ""
"`Introspection de XML-RPC <https://xmlrpc-c.sourceforge.net/introspection."
"html>`_"

#: library/xmlrpc.client.rst:169
msgid "Describes the XML-RPC protocol extension for introspection."
msgstr "Décrit l'extension du protocole XML-RPC pour l'introspection."

#: library/xmlrpc.client.rst:171
msgid "`XML-RPC Specification <http://xmlrpc.scripting.com/spec.html>`_"
msgstr "`Spécification XML-RPC <http://xmlrpc.scripting.com/spec.html>`_"

#: library/xmlrpc.client.rst:172
msgid "The official specification."
msgstr "La spécification officielle."

#: library/xmlrpc.client.rst:177
msgid "ServerProxy Objects"
msgstr "Objets *ServerProxy*"

#: library/xmlrpc.client.rst:179
msgid ""
"A :class:`ServerProxy` instance has a method corresponding to each remote "
"procedure call accepted by the XML-RPC server.  Calling the method performs "
"an RPC, dispatched by both name and argument signature (e.g. the same method "
"name can be overloaded with multiple argument signatures).  The RPC finishes "
"by returning a value, which may be either returned data in a conformant type "
"or a :class:`Fault` or :class:`ProtocolError` object indicating an error."
msgstr ""
"Une instance :class:`ServerProxy` possède une méthode correspondant à chaque "
"appel de procédure distante accepté par le serveur XML-RPC. L'appel de la "
"méthode effectue un RPC, distribué à la fois par nom et par signature "
"d'argument (par exemple, le même nom de méthode peut être surchargé avec "
"plusieurs signatures d'argument). Le RPC termine en renvoyant une valeur, "
"qui peut être soit des données renvoyées dans un type conforme, soit un "
"objet :class:`Fault` ou :class:`ProtocolError` indiquant une erreur."

#: library/xmlrpc.client.rst:186
msgid ""
"Servers that support the XML introspection API support some common methods "
"grouped under the reserved :attr:`~ServerProxy.system` attribute:"
msgstr ""
"Les serveurs qui prennent en charge l'API d'introspection XML prennent en "
"charge certaines méthodes courantes regroupées sous l'attribut réservé :attr:"
"`~ServerProxy.system` :"

#: library/xmlrpc.client.rst:192
msgid ""
"This method returns a list of strings, one for each (non-system) method "
"supported by the XML-RPC server."
msgstr ""
"Cette méthode renvoie une liste de chaînes, une pour chaque méthode (non "
"système) prise en charge par le serveur XML-RPC."

#: library/xmlrpc.client.rst:198
msgid ""
"This method takes one parameter, the name of a method implemented by the XML-"
"RPC server. It returns an array of possible signatures for this method. A "
"signature is an array of types. The first of these types is the return type "
"of the method, the rest are parameters."
msgstr ""
"Cette méthode prend un paramètre, le nom d'une méthode implémentée par le "
"serveur XML-RPC. Elle renvoie un tableau de signatures possibles pour cette "
"méthode. Une signature est un tableau de types. Le premier de ces types est "
"le type de retour de la méthode, les autres sont des paramètres."

#: library/xmlrpc.client.rst:203
msgid ""
"Because multiple signatures (ie. overloading) is permitted, this method "
"returns a list of signatures rather than a singleton."
msgstr ""
"Étant donné que plusieurs signatures (c'est-à-dire surcharges) sont "
"autorisées, cette méthode renvoie une liste de signatures plutôt qu'un "
"singleton."

#: library/xmlrpc.client.rst:206
msgid ""
"Signatures themselves are restricted to the top level parameters expected by "
"a method. For instance if a method expects one array of structs as a "
"parameter, and it returns a string, its signature is simply \"string, array"
"\". If it expects three integers and returns a string, its signature is "
"\"string, int, int, int\"."
msgstr ""
"Les signatures elles-mêmes sont limitées aux paramètres de niveau supérieur "
"attendus par une méthode. Par exemple, si une méthode attend un tableau de "
"structures comme paramètre et qu'elle renvoie une chaîne, sa signature est "
"simplement ``\"string, array\"``. Si elle attend trois entiers et renvoie "
"une chaîne, sa signature est ``\"string, int, int, int\"``."

#: library/xmlrpc.client.rst:211
msgid ""
"If no signature is defined for the method, a non-array value is returned. In "
"Python this means that the type of the returned  value will be something "
"other than list."
msgstr ""
"Si aucune signature n'est définie pour la méthode, une valeur autre qu'un "
"tableau est renvoyée. En Python, cela signifie que le type de la valeur "
"renvoyée est autre chose qu'une liste."

#: library/xmlrpc.client.rst:218
msgid ""
"This method takes one parameter, the name of a method implemented by the XML-"
"RPC server.  It returns a documentation string describing the use of that "
"method. If no such string is available, an empty string is returned. The "
"documentation string may contain HTML markup."
msgstr ""
"Cette méthode prend un paramètre, le nom d'une méthode implémentée par le "
"serveur XML-RPC. Elle renvoie une chaîne de documentation décrivant "
"l'utilisation de cette méthode. Si aucune chaîne de ce type n'est "
"disponible, une chaîne vide est renvoyée. La chaîne de documentation peut "
"contenir un balisage HTML."

# suit un :
#: library/xmlrpc.client.rst:225
msgid ""
"Instances of :class:`ServerProxy` support the :term:`context manager` "
"protocol for closing the underlying transport."
msgstr ""
"les instances de :class:`ServerProxy` prennent en charge le protocole :term:"
"`context manager` pour fermer le transport sous-jacent."

#: library/xmlrpc.client.rst:275
msgid "A working example follows. The server code::"
msgstr "Voici un exemple concret. Le code du serveur ::"

#: library/xmlrpc.client.rst:290 library/xmlrpc.client.rst:506
msgid "The client code for the preceding server::"
msgstr "Le code client correspondant au serveur précédent ::"

#: library/xmlrpc.client.rst:252
msgid "DateTime Objects"
msgstr "Objets *DateTime*"

#: library/xmlrpc.client.rst:256
msgid ""
"This class may be initialized with seconds since the epoch, a time tuple, an "
"ISO 8601 time/date string, or a :class:`datetime.datetime` instance.  It has "
"the following methods, supported mainly for internal use by the marshalling/"
"unmarshalling code:"
msgstr ""
"Cette classe peut être initialisée avec les secondes écoulées depuis "
"*epoch*, un *n*-uplet temporel, une chaîne date-heure ISO 8601 ou une "
"instance :class:`datetime.datetime`. Elle dispose des méthodes suivantes, "
"prises en charge principalement pour un usage interne par le code de "
"sérialisation-désérialisation :"

#: library/xmlrpc.client.rst:264
msgid "Accept a string as the instance's new time value."
msgstr "Accepte une chaîne comme nouvelle valeur temporelle de l'instance."

#: library/xmlrpc.client.rst:269
msgid ""
"Write the XML-RPC encoding of this :class:`DateTime` item to the *out* "
"stream object."
msgstr ""
"Écrit le codage XML-RPC de cet élément :class:`DateTime` dans l'objet de "
"flux *out*."

#: library/xmlrpc.client.rst:272
msgid ""
"It also supports certain of Python's built-in operators through rich "
"comparison and :meth:`__repr__` methods."
msgstr ""
"Elle prend également en charge certains opérateurs natifs de Python via des "
"méthodes de comparaison riches et :meth:`__repr__`."

#: library/xmlrpc.client.rst:305
msgid "Binary Objects"
msgstr "Objets binaires"

#: library/xmlrpc.client.rst:309
msgid ""
"This class may be initialized from bytes data (which may include NULs). The "
"primary access to the content of a :class:`Binary` object is provided by an "
"attribute:"
msgstr ""
"Cette classe peut être initialisée à partir de données d'octets (qui peuvent "
"inclure des NUL). L'accès principal au contenu d'un objet :class:`Binary` "
"est fourni par un attribut :"

#: library/xmlrpc.client.rst:316
msgid ""
"The binary data encapsulated by the :class:`Binary` instance.  The data is "
"provided as a :class:`bytes` object."
msgstr ""
"Données binaires encapsulées par l'instance :class:`Binary`. Les données "
"sont fournies sous forme d'objet :class:`bytes`."

#: library/xmlrpc.client.rst:319
msgid ""
":class:`Binary` objects have the following methods, supported mainly for "
"internal use by the marshalling/unmarshalling code:"
msgstr ""
"Les objets :class:`Binary` ont les méthodes suivantes, prises en charge "
"principalement pour un usage interne par le code de sérialisation-"
"désérialisation :"

#: library/xmlrpc.client.rst:325
msgid ""
"Accept a base64 :class:`bytes` object and decode it as the instance's new "
"data."
msgstr ""
"Accepte un objet base64 :class:`bytes` et le décode comme les nouvelles "
"données de l'instance."

#: library/xmlrpc.client.rst:330
msgid ""
"Write the XML-RPC base 64 encoding of this binary item to the *out* stream "
"object."
msgstr ""
"Écrit le codage XML-RPC base 64 de cet élément binaire dans l'objet de flux "
"*out*."

# Erreur Sphinx sur 2045#section...
#: library/xmlrpc.client.rst:332
msgid ""
"The encoded data will have newlines every 76 characters as per :rfc:`RFC "
"2045 section 6.8 <2045#section-6.8>`, which was the de facto standard base64 "
"specification when the XML-RPC spec was written."
msgstr ""
"Les données codées ont des nouvelles lignes tous les 76 caractères "
"conformément à la :rfc:`RFC 2045 section 6.8 <2045>`, qui était la "
"spécification base64 standard *de facto* lorsque la spécification XML-RPC a "
"été écrite."

#: library/xmlrpc.client.rst:337
msgid ""
"It also supports certain of Python's built-in operators through :meth:"
"`__eq__` and :meth:`__ne__` methods."
msgstr ""
"Elle prend également en charge certains opérateurs natifs de Python via les "
"méthodes :meth:`__eq__` et :meth:`__ne__`."

#: library/xmlrpc.client.rst:340
msgid ""
"Example usage of the binary objects.  We're going to transfer an image over "
"XMLRPC::"
msgstr ""
"Exemple d'utilisation des objets binaires. Nous allons transférer une image "
"via XMLRPC ::"

#: library/xmlrpc.client.rst:356
msgid "The client gets the image and saves it to a file::"
msgstr "Le client récupère l'image et l'enregistre dans un fichier ::"

#: library/xmlrpc.client.rst:367
msgid "Fault Objects"
msgstr "Objets *Fault*"

#: library/xmlrpc.client.rst:371
msgid ""
"A :class:`Fault` object encapsulates the content of an XML-RPC fault tag. "
"Fault objects have the following attributes:"
msgstr ""
"Un objet :class:`Fault` encapsule le contenu d'une balise d'erreur XML-RPC. "
"Les objets d'erreurs ont les attributs suivants :"

#: library/xmlrpc.client.rst:377
msgid "An int indicating the fault type."
msgstr "Entier indiquant le type d'erreur."

#: library/xmlrpc.client.rst:382
msgid "A string containing a diagnostic message associated with the fault."
msgstr "Chaîne contenant un message de diagnostic associé à l'erreur."

#: library/xmlrpc.client.rst:384
msgid ""
"In the following example we're going to intentionally cause a :exc:`Fault` "
"by returning a complex type object.  The server code::"
msgstr ""
"Dans l'exemple suivant, nous allons provoquer intentionnellement une :exc:"
"`Fault` en renvoyant un objet de type complexe. Le code du serveur ::"

#: library/xmlrpc.client.rst:417
msgid "ProtocolError Objects"
msgstr "Objets *ProtocolError*"

#: library/xmlrpc.client.rst:421
msgid ""
"A :class:`ProtocolError` object describes a protocol error in the underlying "
"transport layer (such as a 404 'not found' error if the server named by the "
"URI does not exist).  It has the following attributes:"
msgstr ""
"Un objet :class:`ProtocolError` décrit une erreur de protocole dans la "
"couche de transport sous-jacente (telle qu'une erreur 404 « *not found* » si "
"le serveur nommé par l'URI n'existe pas). Il possède les attributs suivants :"

#: library/xmlrpc.client.rst:428
msgid "The URI or URL that triggered the error."
msgstr "URI ou URL qui a déclenché l'erreur."

#: library/xmlrpc.client.rst:433
msgid "The error code."
msgstr "Code d'erreur."

#: library/xmlrpc.client.rst:438
msgid "The error message or diagnostic string."
msgstr "Message d'erreur ou chaîne de diagnostic."

#: library/xmlrpc.client.rst:443
msgid ""
"A dict containing the headers of the HTTP/HTTPS request that triggered the "
"error."
msgstr ""
"Dictionnaire contenant les en-têtes de la requête HTTP/HTTPS qui a déclenché "
"l'erreur."

#: library/xmlrpc.client.rst:446
msgid ""
"In the following example we're going to intentionally cause a :exc:"
"`ProtocolError` by providing an invalid URI::"
msgstr ""
"Dans l'exemple suivant, nous allons intentionnellement provoquer une :exc:"
"`ProtocolError` en fournissant un URI non valide ::"

#: library/xmlrpc.client.rst:464
msgid "MultiCall Objects"
msgstr "Objets multi-appels"

#: library/xmlrpc.client.rst:466
msgid ""
"The :class:`MultiCall` object provides a way to encapsulate multiple calls "
"to a remote server into a single request [#]_."
msgstr ""
"L'objet :class:`MultiCall` fournit un moyen d'encapsuler plusieurs appels "
"vers un serveur distant dans une seule requête [#]_."

#: library/xmlrpc.client.rst:472
msgid ""
"Create an object used to boxcar method calls. *server* is the eventual "
"target of the call. Calls can be made to the result object, but they will "
"immediately return ``None``, and only store the call name and parameters in "
"the :class:`MultiCall` object. Calling the object itself causes all stored "
"calls to be transmitted as a single ``system.multicall`` request. The result "
"of this call is a :term:`generator`; iterating over this generator yields "
"the individual results."
msgstr ""
"Crée un objet utilisé pour les appels de méthode *boxcar*. *server* est la "
"cible éventuelle de l'appel. Des appels peuvent être effectués vers l'objet "
"résultat, mais ils renverront immédiatement ``None`` et stockeront "
"uniquement le nom de l'appel et les paramètres dans l'objet :class:"
"`MultiCall`. L'appel de l'objet lui-même entraîne la transmission de tous "
"les appels stockés sous la forme d'une seule requête ``system.multicall``. "
"Le résultat de cet appel est un :term:`générateur <generator>` ; itérer sur "
"ce générateur donne les résultats individuels."

#: library/xmlrpc.client.rst:480
msgid "A usage example of this class follows.  The server code::"
msgstr "Voici un exemple d'utilisation de cette classe. Le code du serveur ::"

#: library/xmlrpc.client.rst:522
msgid "Convenience Functions"
msgstr "Fonctions utilitaires"

#: library/xmlrpc.client.rst:526
msgid ""
"Convert *params* into an XML-RPC request. or into a response if "
"*methodresponse* is true. *params* can be either a tuple of arguments or an "
"instance of the :exc:`Fault` exception class.  If *methodresponse* is true, "
"only a single value can be returned, meaning that *params* must be of length "
"1. *encoding*, if supplied, is the encoding to use in the generated XML; the "
"default is UTF-8. Python's :const:`None` value cannot be used in standard "
"XML-RPC; to allow using it via an extension,  provide a true value for "
"*allow_none*."
msgstr ""
"Convertit *params* en une requête XML-RPC. ou dans une réponse si "
"*methodresponse* est vrai. *params* peut être soit un *n*-uplet d'arguments, "
"soit une instance de la classe d'exception :exc:`Fault`. Si *methodresponse* "
"est vrai, une seule valeur peut être renvoyée, ce qui signifie que *params* "
"doit être de longueur 1. *encoding*, s'il est fourni, est l'encodage à "
"utiliser dans le XML généré ; la valeur par défaut est UTF-8. La valeur :"
"const:`None` de Python ne peut pas être utilisée dans le XML-RPC standard ; "
"pour permettre son utilisation via une extension, fournissez une valeur "
"vraie pour *allow_none*."

#: library/xmlrpc.client.rst:537
msgid ""
"Convert an XML-RPC request or response into Python objects, a ``(params, "
"methodname)``.  *params* is a tuple of argument; *methodname* is a string, "
"or ``None`` if no method name is present in the packet. If the XML-RPC "
"packet represents a fault condition, this function will raise a :exc:`Fault` "
"exception. The *use_builtin_types* flag can be used to cause date/time "
"values to be presented as :class:`datetime.datetime` objects and binary data "
"to be presented as :class:`bytes` objects; this flag is false by default."
msgstr ""
"Convertit une requête ou une réponse XML-RPC en objets Python, un ``(params, "
"methodname)``. *params* est un *n*-uplet d'arguments ; *methodname* est une "
"chaîne, ou ``None`` si aucun nom de méthode n'est présent dans le paquet. Si "
"le paquet XML-RPC représente une condition d'erreur, cette fonction lève une "
"exception :exc:`Fault`. L'indicateur *use_builtin_types* peut être utilisé "
"pour que les valeurs de date-heure soient présentées comme des objets :class:"
"`datetime.datetime` et que les données binaires soient présentées comme des "
"objets :class:`bytes` ; cet indicateur est faux par défaut."

#: library/xmlrpc.client.rst:545
msgid ""
"The obsolete *use_datetime* flag is similar to *use_builtin_types* but it "
"applies only to date/time values."
msgstr ""
"L'indicateur obsolète *use_datetime* est similaire à *use_builtin_types* "
"mais il s'applique uniquement aux valeurs de date-heure."

#: library/xmlrpc.client.rst:555
msgid "Example of Client Usage"
msgstr "Exemple d'utilisation client"

#: library/xmlrpc.client.rst:572
msgid ""
"To access an XML-RPC server through a HTTP proxy, you need to define a "
"custom transport.  The following example shows how::"
msgstr ""
"Pour accéder à un serveur XML-RPC via un mandataire HTTP, vous devez définir "
"un transport personnalisé. L'exemple suivant montre comment faire ::"

#: library/xmlrpc.client.rst:597
msgid "Example of Client and Server Usage"
msgstr "Exemple d'utilisation du client et du serveur"

#: library/xmlrpc.client.rst:599
msgid "See :ref:`simplexmlrpcserver-example`."
msgstr "Voir :ref:`simplexmlrpcserver-example`."

#: library/xmlrpc.client.rst:603
msgid "Footnotes"
msgstr "Notes"

#: library/xmlrpc.client.rst:604
msgid ""
"This approach has been first presented in `a discussion on xmlrpc.com "
"<https://web.archive.org/web/20060624230303/http://www.xmlrpc.com/discuss/"
"msgReader$1208?mode=topic>`_."
msgstr ""
"Cette approche a été présentée pour la première fois dans `une discussion "
"sur xmlrpc.com <https://web.archive.org/web/20060624230303/http://www.xmlrpc."
"com/discuss/msgReader$1208?mode=topic>`_ ."