# 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 \n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Generator: Poedit 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 `: not Emscripten, not WASI." msgstr ":ref:`Disponibilité ` : 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 `_ 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 " "`_ 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 " "```` tag." msgstr "" ":class:`int` compris entre -2147483648 et 2147483647. Les valeurs sont " "marquées avec la balise ````." #: library/xmlrpc.client.rst:104 msgid "``double`` or ``float``" msgstr "``double`` ou ``float``" #: library/xmlrpc.client.rst:104 msgid ":class:`float`. Values get the ```` tag." msgstr ":class:`float`. Les valeurs reçoivent la balise ````." #: 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 `." msgstr "" ":class:`liste ` ou :class:`n-uplet ` contenant des éléments " "conformes. Les tableaux sont renvoyés sous forme de :class:`listes `." #: 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 `_" msgstr "" "`Guide pratique XML-RPC `_" #: 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 `_" msgstr "" "`Introspection de XML-RPC `_" #: 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 `_" msgstr "`Spécification XML-RPC `_" #: 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 ` ; 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 " "`_." msgstr "" "Cette approche a été présentée pour la première fois dans `une discussion " "sur xmlrpc.com `_ ."