1108 lines
53 KiB
Plaintext
1108 lines
53 KiB
Plaintext
# 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-18 17:17+0200\n"
|
||
"PO-Revision-Date: 2024-03-17 11:54+0100\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/email.policy.rst:2
|
||
msgid ":mod:`email.policy`: Policy Objects"
|
||
msgstr ":mod:`email.policy` : objets de définition de politique"
|
||
|
||
#: library/email.policy.rst:12
|
||
msgid "**Source code:** :source:`Lib/email/policy.py`"
|
||
msgstr "**Code source :** :source:`Lib/email/policy.py`"
|
||
|
||
#: library/email.policy.rst:16
|
||
msgid ""
|
||
"The :mod:`email` package's prime focus is the handling of email messages as "
|
||
"described by the various email and MIME RFCs. However, the general format "
|
||
"of email messages (a block of header fields each consisting of a name "
|
||
"followed by a colon followed by a value, the whole block followed by a blank "
|
||
"line and an arbitrary 'body'), is a format that has found utility outside of "
|
||
"the realm of email. Some of these uses conform fairly closely to the main "
|
||
"email RFCs, some do not. Even when working with email, there are times when "
|
||
"it is desirable to break strict compliance with the RFCs, such as generating "
|
||
"emails that interoperate with email servers that do not themselves follow "
|
||
"the standards, or that implement extensions you want to use in ways that "
|
||
"violate the standards."
|
||
msgstr ""
|
||
"Le principal objectif du paquet :mod:`email` est la gestion des messages "
|
||
"électroniques comme décrit par les diverses RFC de messagerie et MIME. "
|
||
"Cependant, le format général des messages électroniques (un bloc de champs "
|
||
"d'en-tête composés chacun d'un nom suivi de deux-points suivi d'une valeur, "
|
||
"le bloc entier suivi d'une ligne vide et d'un « corps » arbitraire), est un "
|
||
"format qui a trouvé son utilité en dehors du domaine du courrier "
|
||
"électronique. Certaines de ces utilisations sont assez conformes aux "
|
||
"principales RFC de messagerie, d'autres non. Même lorsque vous travaillez "
|
||
"avec des e-mails, il est parfois souhaitable de ne pas respecter strictement "
|
||
"les RFC, par exemple en générant des e-mails qui interagissent avec des "
|
||
"serveurs de messagerie qui ne respectent pas eux-mêmes les normes ou qui "
|
||
"implémentent des extensions que vous souhaitez utiliser d'une manière qui "
|
||
"enfreint les normes."
|
||
|
||
#: library/email.policy.rst:28
|
||
msgid ""
|
||
"Policy objects give the email package the flexibility to handle all these "
|
||
"disparate use cases."
|
||
msgstr ""
|
||
"Les objets de définition de politique donnent au paquet de messagerie la "
|
||
"flexibilité nécessaire pour gérer tous ces cas d'utilisation disparates."
|
||
|
||
#: library/email.policy.rst:31
|
||
msgid ""
|
||
"A :class:`Policy` object encapsulates a set of attributes and methods that "
|
||
"control the behavior of various components of the email package during use. :"
|
||
"class:`Policy` instances can be passed to various classes and methods in the "
|
||
"email package to alter the default behavior. The settable values and their "
|
||
"defaults are described below."
|
||
msgstr ""
|
||
"Un objet :class:`Policy` encapsule un ensemble d'attributs et de méthodes "
|
||
"qui contrôlent le comportement de divers composants du paquet de messagerie "
|
||
"lors de son utilisation. Les instances :class:`Policy` peuvent être "
|
||
"transmises à diverses classes et méthodes dans le paquet de courrier "
|
||
"électronique pour modifier le comportement par défaut. Les valeurs réglables "
|
||
"et leurs valeurs par défaut sont décrites ci-dessous."
|
||
|
||
#: library/email.policy.rst:37
|
||
msgid ""
|
||
"There is a default policy used by all classes in the email package. For all "
|
||
"of the :mod:`~email.parser` classes and the related convenience functions, "
|
||
"and for the :class:`~email.message.Message` class, this is the :class:"
|
||
"`Compat32` policy, via its corresponding pre-defined instance :const:"
|
||
"`compat32`. This policy provides for complete backward compatibility (in "
|
||
"some cases, including bug compatibility) with the pre-Python3.3 version of "
|
||
"the email package."
|
||
msgstr ""
|
||
"Il existe une politique par défaut utilisée par toutes les classes dans le "
|
||
"paquet de messagerie. Pour toutes les classes :mod:`~email.parser` et les "
|
||
"fonctions pratiques associées, et pour la classe :class:`~email.message."
|
||
"Message`, il s'agit de la politique :class:`Compat32`, via son instance "
|
||
"correspondante prédéfinie :const:`compat32`. Cette politique fournit une "
|
||
"rétrocompatibilité complète (dans certains cas, y compris la compatibilité "
|
||
"des bogues) avec la version pré-Python3.3 du paquet de messagerie."
|
||
|
||
#: library/email.policy.rst:44
|
||
msgid ""
|
||
"This default value for the *policy* keyword to :class:`~email.message."
|
||
"EmailMessage` is the :class:`EmailPolicy` policy, via its pre-defined "
|
||
"instance :data:`~default`."
|
||
msgstr ""
|
||
"Cette valeur par défaut pour le paramètre nommé *policy* de :class:`~email."
|
||
"message.EmailMessage` est la politique :class:`EmailPolicy`, via son "
|
||
"instance prédéfinie :data:`~default`."
|
||
|
||
#: library/email.policy.rst:48
|
||
msgid ""
|
||
"When a :class:`~email.message.Message` or :class:`~email.message."
|
||
"EmailMessage` object is created, it acquires a policy. If the message is "
|
||
"created by a :mod:`~email.parser`, a policy passed to the parser will be the "
|
||
"policy used by the message it creates. If the message is created by the "
|
||
"program, then the policy can be specified when it is created. When a "
|
||
"message is passed to a :mod:`~email.generator`, the generator uses the "
|
||
"policy from the message by default, but you can also pass a specific policy "
|
||
"to the generator that will override the one stored on the message object."
|
||
msgstr ""
|
||
"Lorsqu'un objet :class:`~email.message.Message` ou :class:`~email.message."
|
||
"EmailMessage` est créé, il acquiert une politique. Si le message est créé "
|
||
"par un :mod:`~email.parser`, la politique transmise à l'analyseur est la "
|
||
"politique utilisée par le message qu'il crée. Si le message est créé par le "
|
||
"programme, la stratégie peut être spécifiée lors de sa création. Lorsqu'un "
|
||
"message est passé à un :mod:`~email.generator`, le générateur utilise la "
|
||
"politique du message par défaut, mais vous pouvez également passer une "
|
||
"politique spécifique au générateur qui remplace celle stockée sur l'objet "
|
||
"message."
|
||
|
||
#: library/email.policy.rst:57
|
||
msgid ""
|
||
"The default value for the *policy* keyword for the :mod:`email.parser` "
|
||
"classes and the parser convenience functions **will be changing** in a "
|
||
"future version of Python. Therefore you should **always specify explicitly "
|
||
"which policy you want to use** when calling any of the classes and functions "
|
||
"described in the :mod:`~email.parser` module."
|
||
msgstr ""
|
||
"La valeur par défaut du paramètre nommé *policy* pour les classes :mod:"
|
||
"`email.parser` et les fonctions pratiques de l'analyseur **va changer** dans "
|
||
"une future version de Python. Par conséquent, vous devez **toujours "
|
||
"spécifier explicitement la stratégie que vous souhaitez utiliser** lors de "
|
||
"l'appel de l'une des classes et fonctions décrites dans le module :mod:"
|
||
"`~email.parser`."
|
||
|
||
#: library/email.policy.rst:63
|
||
msgid ""
|
||
"The first part of this documentation covers the features of :class:`Policy`, "
|
||
"an :term:`abstract base class` that defines the features that are common to "
|
||
"all policy objects, including :const:`compat32`. This includes certain hook "
|
||
"methods that are called internally by the email package, which a custom "
|
||
"policy could override to obtain different behavior. The second part "
|
||
"describes the concrete classes :class:`EmailPolicy` and :class:`Compat32`, "
|
||
"which implement the hooks that provide the standard behavior and the "
|
||
"backward compatible behavior and features, respectively."
|
||
msgstr ""
|
||
"La première partie de cette documentation couvre les fonctionnalités de :"
|
||
"class:`Policy`, une :term:`classe mère abstraite <abstract base class>` qui "
|
||
"définit les fonctionnalités communes à tous les objets de stratégie, y "
|
||
"compris :const:`compat32`. Cela inclut certaines méthodes automatiques "
|
||
"(*hooks* en anglais) appelées en interne par le paquet de messagerie, qu'une "
|
||
"stratégie personnalisée peut remplacer pour obtenir un comportement "
|
||
"différent. La deuxième partie décrit les classes concrètes :class:"
|
||
"`EmailPolicy` et :class:`Compat32`, qui implémentent les points d'entrée "
|
||
"automatiques qui fournissent respectivement le comportement standard et le "
|
||
"comportement et les fonctionnalités rétrocompatibles."
|
||
|
||
#: library/email.policy.rst:72
|
||
msgid ""
|
||
":class:`Policy` instances are immutable, but they can be cloned, accepting "
|
||
"the same keyword arguments as the class constructor and returning a new :"
|
||
"class:`Policy` instance that is a copy of the original but with the "
|
||
"specified attributes values changed."
|
||
msgstr ""
|
||
"Les instances :class:`Policy` sont immuables, mais elles peuvent être "
|
||
"clonées, en acceptant les mêmes arguments nommés que le constructeur de "
|
||
"classe et en renvoyant une nouvelle instance :class:`Policy` qui est une "
|
||
"copie de l'original mais avec les valeurs d'attributs spécifiées modifiées."
|
||
|
||
#: library/email.policy.rst:77
|
||
msgid ""
|
||
"As an example, the following code could be used to read an email message "
|
||
"from a file on disk and pass it to the system ``sendmail`` program on a Unix "
|
||
"system:"
|
||
msgstr ""
|
||
"Par exemple, le code suivant peut être utilisé pour lire un message "
|
||
"électronique à partir d'un fichier sur le disque et le transmettre au "
|
||
"programme système ``sendmail`` sur un système Unix :"
|
||
|
||
#: library/email.policy.rst:114
|
||
msgid ""
|
||
"Here we are telling :class:`~email.generator.BytesGenerator` to use the RFC "
|
||
"correct line separator characters when creating the binary string to feed "
|
||
"into ``sendmail's`` ``stdin``, where the default policy would use ``\\n`` "
|
||
"line separators."
|
||
msgstr ""
|
||
"Ici, nous disons à :class:`~email.generator.BytesGenerator` d'utiliser les "
|
||
"caractères de séparation de ligne corrects de la RFC lors de la création de "
|
||
"la chaîne binaire à fournir à ``stdin`` de ``sendmail``, où la politique par "
|
||
"défaut utiliserait ``\\n`` comme séparateur de ligne."
|
||
|
||
#: library/email.policy.rst:119
|
||
msgid ""
|
||
"Some email package methods accept a *policy* keyword argument, allowing the "
|
||
"policy to be overridden for that method. For example, the following code "
|
||
"uses the :meth:`~email.message.Message.as_bytes` method of the *msg* object "
|
||
"from the previous example and writes the message to a file using the native "
|
||
"line separators for the platform on which it is running::"
|
||
msgstr ""
|
||
"Certaines méthodes du paquet de messagerie acceptent un argument nommé "
|
||
"*policy*, permettant à la politique d'être remplacée pour cette méthode. Par "
|
||
"exemple, le code suivant utilise la méthode :meth:`~email.message.Message."
|
||
"as_bytes` de l'objet *msg* de l'exemple précédent et écrit le message dans "
|
||
"un fichier en utilisant les séparateurs de ligne natifs de la plate-forme "
|
||
"sur laquelle il est en cours d'exécution ::"
|
||
|
||
#: library/email.policy.rst:130
|
||
msgid ""
|
||
"Policy objects can also be combined using the addition operator, producing a "
|
||
"policy object whose settings are a combination of the non-default values of "
|
||
"the summed objects::"
|
||
msgstr ""
|
||
"Les objets de stratégie peuvent également être combinés à l'aide de "
|
||
"l'opérateur d'addition, produisant un objet de stratégie dont les paramètres "
|
||
"sont une combinaison des objets additionnées (en ne prenant en compte que "
|
||
"les paramètres données explicitement) ::"
|
||
|
||
#: library/email.policy.rst:138
|
||
msgid ""
|
||
"This operation is not commutative; that is, the order in which the objects "
|
||
"are added matters. To illustrate::"
|
||
msgstr ""
|
||
"Cette opération n'est pas commutative ; c'est-à-dire que l'ordre dans lequel "
|
||
"les objets sont ajoutés est important. Pour illustrer ::"
|
||
|
||
#: library/email.policy.rst:153
|
||
msgid ""
|
||
"This is the :term:`abstract base class` for all policy classes. It provides "
|
||
"default implementations for a couple of trivial methods, as well as the "
|
||
"implementation of the immutability property, the :meth:`clone` method, and "
|
||
"the constructor semantics."
|
||
msgstr ""
|
||
"C'est la :term:`classe mère abstraite <abstract base class>` pour toutes les "
|
||
"classes de définition de politique. Elle fournit des implémentations par "
|
||
"défaut pour quelques méthodes triviales, ainsi que l'implémentation de la "
|
||
"propriété d'immutabilité, la méthode :meth:`clone` et la sémantique du "
|
||
"constructeur."
|
||
|
||
#: library/email.policy.rst:158
|
||
msgid ""
|
||
"The constructor of a policy class can be passed various keyword arguments. "
|
||
"The arguments that may be specified are any non-method properties on this "
|
||
"class, plus any additional non-method properties on the concrete class. A "
|
||
"value specified in the constructor will override the default value for the "
|
||
"corresponding attribute."
|
||
msgstr ""
|
||
"Le constructeur d'une classe de définition de politique peut recevoir divers "
|
||
"arguments nommés. Les arguments qui peuvent être spécifiés sont toutes les "
|
||
"propriétés qui ne sont pas des méthodes sur cette classe, plus toutes les "
|
||
"propriétés qui ne sont pas des méthodes supplémentaires sur la classe "
|
||
"concrète. Une valeur spécifiée dans le constructeur remplace la valeur par "
|
||
"défaut de l'attribut correspondant."
|
||
|
||
#: library/email.policy.rst:164
|
||
msgid ""
|
||
"This class defines the following properties, and thus values for the "
|
||
"following may be passed in the constructor of any policy class:"
|
||
msgstr ""
|
||
"Cette classe définit les propriétés suivantes, et ainsi les valeurs des "
|
||
"éléments suivants peuvent être passées dans le constructeur de n'importe "
|
||
"quelle classe de définition de politique :"
|
||
|
||
#: library/email.policy.rst:170
|
||
msgid ""
|
||
"The maximum length of any line in the serialized output, not counting the "
|
||
"end of line character(s). Default is 78, per :rfc:`5322`. A value of ``0`` "
|
||
"or :const:`None` indicates that no line wrapping should be done at all."
|
||
msgstr ""
|
||
"La longueur maximale de toute ligne dans la sortie sérialisée, sans compter "
|
||
"le(s) caractère(s) de fin de ligne. La valeur par défaut est 78, selon la :"
|
||
"rfc:`5322`. Une valeur de ``0`` ou :const:`None` indique qu'aucun retour à "
|
||
"la ligne ne doit être fait."
|
||
|
||
#: library/email.policy.rst:178
|
||
msgid ""
|
||
"The string to be used to terminate lines in serialized output. The default "
|
||
"is ``\\n`` because that's the internal end-of-line discipline used by "
|
||
"Python, though ``\\r\\n`` is required by the RFCs."
|
||
msgstr ""
|
||
"La chaîne à utiliser pour terminer les lignes dans la sortie sérialisée. La "
|
||
"valeur par défaut est ``\\n`` car c'est la définition interne de fin de "
|
||
"ligne utilisée par Python, bien que ``\\r\\n`` soit requis par les RFC."
|
||
|
||
#: library/email.policy.rst:185
|
||
msgid ""
|
||
"Controls the type of Content Transfer Encodings that may be or are required "
|
||
"to be used. The possible values are:"
|
||
msgstr ""
|
||
"Contrôle le type d'encodage de contenu qui peut ou doit être utilisé. Les "
|
||
"valeurs possibles sont :"
|
||
|
||
#: library/email.policy.rst:191
|
||
msgid "``7bit``"
|
||
msgstr "``7bit``"
|
||
|
||
#: library/email.policy.rst:191
|
||
msgid ""
|
||
"all data must be \"7 bit clean\" (ASCII-only). This means that where "
|
||
"necessary data will be encoded using either quoted-printable or base64 "
|
||
"encoding."
|
||
msgstr ""
|
||
"toutes les données doivent être « complétement 7 bits » (ASCII uniquement). "
|
||
"Cela signifie que si nécessaire, les données seront encodées à l'aide de "
|
||
"l'encodage *quoted-printable* ou *base64*."
|
||
|
||
#: library/email.policy.rst:195
|
||
msgid "``8bit``"
|
||
msgstr "``8bit``"
|
||
|
||
#: library/email.policy.rst:195
|
||
msgid ""
|
||
"data is not constrained to be 7 bit clean. Data in headers is still "
|
||
"required to be ASCII-only and so will be encoded (see :meth:`fold_binary` "
|
||
"and :attr:`~EmailPolicy.utf8` below for exceptions), but body parts may use "
|
||
"the ``8bit`` CTE."
|
||
msgstr ""
|
||
"les données ne sont pas contraintes d'être uniquement sur 7 bits. Les "
|
||
"données dans les en-têtes doivent toujours être en ASCII uniquement et "
|
||
"seront donc encodées (voir :meth:`fold_binary` et :attr:`~EmailPolicy.utf8` "
|
||
"ci-dessous pour les exceptions), mais les parties du corps peuvent utiliser "
|
||
"le ``8bit`` CTE."
|
||
|
||
#: library/email.policy.rst:201
|
||
msgid ""
|
||
"A ``cte_type`` value of ``8bit`` only works with ``BytesGenerator``, not "
|
||
"``Generator``, because strings cannot contain binary data. If a "
|
||
"``Generator`` is operating under a policy that specifies ``cte_type=8bit``, "
|
||
"it will act as if ``cte_type`` is ``7bit``."
|
||
msgstr ""
|
||
"Une valeur ``cte_type`` de ``8bit`` ne fonctionne qu'avec "
|
||
"``BytesGenerator``, et pas avec ``Generator`` car les chaînes ne peuvent "
|
||
"pas contenir de données binaires. Si un ``Generator`` fonctionne sous une "
|
||
"politique qui spécifie ``cte_type=8bit``, il agit comme si ``cte_type`` "
|
||
"était ``7bit``."
|
||
|
||
#: library/email.policy.rst:209
|
||
msgid ""
|
||
"If :const:`True`, any defects encountered will be raised as errors. If :"
|
||
"const:`False` (the default), defects will be passed to the :meth:"
|
||
"`register_defect` method."
|
||
msgstr ""
|
||
"Si :const:`True`, tous les défauts rencontrés sont signalés comme des "
|
||
"erreurs. Si :const:`False` (la valeur par défaut), les défauts sont passés à "
|
||
"la méthode :meth:`register_defect`."
|
||
|
||
#: library/email.policy.rst:216
|
||
msgid ""
|
||
"If :const:`True`, lines starting with *\"From \"* in the body are escaped by "
|
||
"putting a ``>`` in front of them. This parameter is used when the message is "
|
||
"being serialized by a generator. Default: :const:`False`."
|
||
msgstr ""
|
||
"Si :const:`True`, les lignes commençant par *\"From \"* dans le corps sont "
|
||
"échappées en mettant un ``>`` devant elles. Ce paramètre est utilisé lorsque "
|
||
"le message est sérialisé par un générateur. Par défaut, vaut :const:`False`."
|
||
|
||
# suit un :
|
||
#: library/email.policy.rst:221
|
||
msgid "The *mangle_from_* parameter."
|
||
msgstr "le paramètre *mangle_from_*."
|
||
|
||
#: library/email.policy.rst:227
|
||
msgid ""
|
||
"A factory function for constructing a new empty message object. Used by the "
|
||
"parser when building messages. Defaults to ``None``, in which case :class:"
|
||
"`~email.message.Message` is used."
|
||
msgstr ""
|
||
"Une fonction de fabrique pour construire un nouvel objet de message vide. "
|
||
"Utilisé par l'analyseur lors de la construction des messages. La valeur par "
|
||
"défaut est ``None``, :class:`~email.message.Message` est alors utilisé."
|
||
|
||
#: library/email.policy.rst:233
|
||
msgid ""
|
||
"The following :class:`Policy` method is intended to be called by code using "
|
||
"the email library to create policy instances with custom settings:"
|
||
msgstr ""
|
||
"La méthode :class:`Policy` suivante est destinée à être appelée par le code "
|
||
"à l'aide de la bibliothèque de messagerie pour créer des instances de "
|
||
"stratégie avec des paramètres personnalisés :"
|
||
|
||
#: library/email.policy.rst:239
|
||
msgid ""
|
||
"Return a new :class:`Policy` instance whose attributes have the same values "
|
||
"as the current instance, except where those attributes are given new values "
|
||
"by the keyword arguments."
|
||
msgstr ""
|
||
"Renvoie une nouvelle instance de :class:`Policy` dont les attributs ont les "
|
||
"mêmes valeurs que l'instance actuelle, sauf si ces attributs reçoivent de "
|
||
"nouvelles valeurs par les arguments nommés."
|
||
|
||
#: library/email.policy.rst:244
|
||
msgid ""
|
||
"The remaining :class:`Policy` methods are called by the email package code, "
|
||
"and are not intended to be called by an application using the email package. "
|
||
"A custom policy must implement all of these methods."
|
||
msgstr ""
|
||
"Les méthodes :class:`Policy` restantes sont appelées par le code du paquet "
|
||
"de messagerie et ne sont pas destinées à être appelées par une application "
|
||
"utilisant le paquet de messagerie. Une stratégie personnalisée doit "
|
||
"implémenter toutes ces méthodes."
|
||
|
||
#: library/email.policy.rst:251
|
||
msgid ""
|
||
"Handle a *defect* found on *obj*. When the email package calls this method, "
|
||
"*defect* will always be a subclass of :class:`~email.errors.Defect`."
|
||
msgstr ""
|
||
"Gère un *defect* trouvé sur *obj*. Lorsque le paquet de messagerie appelle "
|
||
"cette méthode, *defect* est toujours une sous-classe de :class:`~email."
|
||
"errors.Defect`."
|
||
|
||
#: library/email.policy.rst:255
|
||
msgid ""
|
||
"The default implementation checks the :attr:`raise_on_defect` flag. If it "
|
||
"is ``True``, *defect* is raised as an exception. If it is ``False`` (the "
|
||
"default), *obj* and *defect* are passed to :meth:`register_defect`."
|
||
msgstr ""
|
||
"L'implémentation par défaut vérifie le drapeau :attr:`raise_on_defect`. Si "
|
||
"c'est ``True``, *defect* est levé comme une exception. Si c'est ``False`` "
|
||
"(par défaut), *obj* et *defect* sont passés à :meth:`register_defect`."
|
||
|
||
#: library/email.policy.rst:262
|
||
msgid ""
|
||
"Register a *defect* on *obj*. In the email package, *defect* will always be "
|
||
"a subclass of :class:`~email.errors.Defect`."
|
||
msgstr ""
|
||
"Enregistre un *defect* sur *obj*. Dans le paquet de messagerie, *defect* "
|
||
"sera toujours une sous-classe de :class:`~email.errors.Defect`."
|
||
|
||
#: library/email.policy.rst:265
|
||
msgid ""
|
||
"The default implementation calls the ``append`` method of the ``defects`` "
|
||
"attribute of *obj*. When the email package calls :attr:`handle_defect`, "
|
||
"*obj* will normally have a ``defects`` attribute that has an ``append`` "
|
||
"method. Custom object types used with the email package (for example, "
|
||
"custom ``Message`` objects) should also provide such an attribute, otherwise "
|
||
"defects in parsed messages will raise unexpected errors."
|
||
msgstr ""
|
||
"L'implémentation par défaut appelle la méthode ``append`` de l'attribut "
|
||
"``defects`` de *obj*. Lorsque le paquet de courrier électronique appelle :"
|
||
"attr:`handle_defect`, *obj* a normalement un attribut ``defects`` qui a une "
|
||
"méthode ``append``. Les types d'objets personnalisés utilisés avec le paquet "
|
||
"de messagerie (par exemple, les objets ``Message`` personnalisés) doivent "
|
||
"également fournir un tel attribut, sinon les défauts dans les messages "
|
||
"analysés généreront des erreurs inattendues."
|
||
|
||
#: library/email.policy.rst:275
|
||
msgid "Return the maximum allowed number of headers named *name*."
|
||
msgstr "Renvoie le nombre maximal autorisé d'en-têtes nommés *name*."
|
||
|
||
#: library/email.policy.rst:277
|
||
msgid ""
|
||
"Called when a header is added to an :class:`~email.message.EmailMessage` or :"
|
||
"class:`~email.message.Message` object. If the returned value is not ``0`` "
|
||
"or ``None``, and there are already a number of headers with the name *name* "
|
||
"greater than or equal to the value returned, a :exc:`ValueError` is raised."
|
||
msgstr ""
|
||
"Appelé lorsqu'un en-tête est ajouté à un objet :class:`~email.message."
|
||
"EmailMessage` ou :class:`~email.message.Message`. Si la valeur renvoyée "
|
||
"n'est pas ``0`` ou ``None``, et qu'il y a déjà un certain nombre d'en-têtes "
|
||
"avec le nom *name* supérieur ou égal à la valeur renvoyée, une :exc:"
|
||
"`ValueError` est levée."
|
||
|
||
#: library/email.policy.rst:283
|
||
msgid ""
|
||
"Because the default behavior of ``Message.__setitem__`` is to append the "
|
||
"value to the list of headers, it is easy to create duplicate headers without "
|
||
"realizing it. This method allows certain headers to be limited in the "
|
||
"number of instances of that header that may be added to a ``Message`` "
|
||
"programmatically. (The limit is not observed by the parser, which will "
|
||
"faithfully produce as many headers as exist in the message being parsed.)"
|
||
msgstr ""
|
||
"Parce que le comportement par défaut de ``Message.__setitem__`` est "
|
||
"d'ajouter la valeur à la liste des en-têtes, il est facile de créer des en-"
|
||
"têtes en double sans s'en rendre compte. Cette méthode permet à certains en-"
|
||
"têtes d'être limités dans le nombre d'instances de cet en-tête qui peuvent "
|
||
"être ajoutées à un ``Message`` par programme (la limite n'est pas respectée "
|
||
"par l'analyseur, qui produit fidèlement autant d'en-têtes qu'il en existe "
|
||
"dans le message analysé)."
|
||
|
||
#: library/email.policy.rst:291
|
||
msgid "The default implementation returns ``None`` for all header names."
|
||
msgstr ""
|
||
"L'implémentation par défaut renvoie ``None`` pour tous les noms d'en-tête."
|
||
|
||
#: library/email.policy.rst:296
|
||
msgid ""
|
||
"The email package calls this method with a list of strings, each string "
|
||
"ending with the line separation characters found in the source being "
|
||
"parsed. The first line includes the field header name and separator. All "
|
||
"whitespace in the source is preserved. The method should return the "
|
||
"``(name, value)`` tuple that is to be stored in the ``Message`` to represent "
|
||
"the parsed header."
|
||
msgstr ""
|
||
"Le paquet de courrier électronique appelle cette méthode avec une liste de "
|
||
"chaînes, chaque chaîne se terminant par les caractères de séparation de "
|
||
"ligne trouvés dans la source analysée. La première ligne comprend le nom de "
|
||
"l'en-tête de champ et le séparateur. Tous les espaces blancs dans la source "
|
||
"sont préservés. La méthode doit renvoyer le couple ``(name, value)`` qui "
|
||
"doit être stocké dans le ``Message`` pour représenter l'en-tête analysé."
|
||
|
||
#: library/email.policy.rst:303
|
||
msgid ""
|
||
"If an implementation wishes to retain compatibility with the existing email "
|
||
"package policies, *name* should be the case preserved name (all characters "
|
||
"up to the '``:``' separator), while *value* should be the unfolded value "
|
||
"(all line separator characters removed, but whitespace kept intact), "
|
||
"stripped of leading whitespace."
|
||
msgstr ""
|
||
"Si une implémentation souhaite conserver la compatibilité avec les "
|
||
"politiques de paquet de messagerie existantes, *name* doit être le nom "
|
||
"préservé de la casse (tous les caractères jusqu'au séparateur ``:``), tandis "
|
||
"que *value* doit être la valeur dépliée (c.-à-d. tous les caractères de "
|
||
"séparation de ligne supprimés, mais les espaces blancs conservés intacts), "
|
||
"dépouillés des espaces blancs de tête."
|
||
|
||
#: library/email.policy.rst:309
|
||
msgid "*sourcelines* may contain surrogateescaped binary data."
|
||
msgstr ""
|
||
"*sourcelines* peut contenir des données binaires échappées de substitution."
|
||
|
||
#: library/email.policy.rst:327 library/email.policy.rst:343
|
||
msgid "There is no default implementation"
|
||
msgstr "Il n'y a pas d'implémentation par défaut"
|
||
|
||
#: library/email.policy.rst:316
|
||
msgid ""
|
||
"The email package calls this method with the name and value provided by the "
|
||
"application program when the application program is modifying a ``Message`` "
|
||
"programmatically (as opposed to a ``Message`` created by a parser). The "
|
||
"method should return the ``(name, value)`` tuple that is to be stored in the "
|
||
"``Message`` to represent the header."
|
||
msgstr ""
|
||
"Le paquet de courrier électronique appelle cette méthode avec le nom et la "
|
||
"valeur fournis par le programme d'application lorsque le programme "
|
||
"d'application modifie un ``Message`` par programme (par opposition à un "
|
||
"``Message`` créé par un analyseur). La méthode doit renvoyer le couple "
|
||
"``(name, value)`` qui doit être stocké dans le ``Message`` pour représenter "
|
||
"l'en-tête."
|
||
|
||
#: library/email.policy.rst:322
|
||
msgid ""
|
||
"If an implementation wishes to retain compatibility with the existing email "
|
||
"package policies, the *name* and *value* should be strings or string "
|
||
"subclasses that do not change the content of the passed in arguments."
|
||
msgstr ""
|
||
"Si une implémentation souhaite conserver la compatibilité avec les "
|
||
"politiques existantes du paquet de messagerie, le *name* et la *value* "
|
||
"doivent être des chaînes ou des sous-classes de chaînes qui ne modifient pas "
|
||
"le contenu des arguments transmis."
|
||
|
||
#: library/email.policy.rst:332
|
||
msgid ""
|
||
"The email package calls this method with the *name* and *value* currently "
|
||
"stored in the ``Message`` when that header is requested by the application "
|
||
"program, and whatever the method returns is what is passed back to the "
|
||
"application as the value of the header being retrieved. Note that there may "
|
||
"be more than one header with the same name stored in the ``Message``; the "
|
||
"method is passed the specific name and value of the header destined to be "
|
||
"returned to the application."
|
||
msgstr ""
|
||
"Le paquet de courrier électronique appelle cette méthode avec le *name* et "
|
||
"la *value* actuellement stockés dans le ``Message`` lorsque cet en-tête est "
|
||
"demandé par le programme d'application, et tout ce que la méthode renvoie "
|
||
"est ce qui est renvoyé à l'application comme valeur de l'en-tête récupéré. "
|
||
"Notez qu'il peut y avoir plus d'un en-tête avec le même nom stocké dans le "
|
||
"``Message`` ; la méthode reçoit le nom et la valeur spécifiques de l'en-tête "
|
||
"destiné à être renvoyé à l'application."
|
||
|
||
#: library/email.policy.rst:340
|
||
msgid ""
|
||
"*value* may contain surrogateescaped binary data. There should be no "
|
||
"surrogateescaped binary data in the value returned by the method."
|
||
msgstr ""
|
||
"*value* peut contenir des données binaires de substitution échappées. Il ne "
|
||
"doit pas y avoir de données binaires échappées de substitution dans la "
|
||
"valeur renvoyée par la méthode."
|
||
|
||
#: library/email.policy.rst:348
|
||
msgid ""
|
||
"The email package calls this method with the *name* and *value* currently "
|
||
"stored in the ``Message`` for a given header. The method should return a "
|
||
"string that represents that header \"folded\" correctly (according to the "
|
||
"policy settings) by composing the *name* with the *value* and inserting :"
|
||
"attr:`linesep` characters at the appropriate places. See :rfc:`5322` for a "
|
||
"discussion of the rules for folding email headers."
|
||
msgstr ""
|
||
"Le paquet de courrier électronique appelle cette méthode avec le *name* et "
|
||
"la *value* actuellement stockés dans le ``Message`` pour un en-tête donné. "
|
||
"La méthode doit renvoyer une chaîne qui représente correctement cet en-tête "
|
||
"« plié » (selon les paramètres de la politique) en mettant en forme le "
|
||
"couple *name* - *value* et en insérant les caractères :attr:`linesep` aux "
|
||
"endroits appropriés. Voir :rfc:`5322` pour une discussion sur les règles de "
|
||
"mise en forme (« pliage » ou *folding* en anglais) des en-têtes de courrier "
|
||
"électronique."
|
||
|
||
#: library/email.policy.rst:355
|
||
msgid ""
|
||
"*value* may contain surrogateescaped binary data. There should be no "
|
||
"surrogateescaped binary data in the string returned by the method."
|
||
msgstr ""
|
||
"*value* peut contenir des données binaires de substitution échappées. Il ne "
|
||
"doit pas y avoir de données binaires échappées de substitution dans la "
|
||
"chaîne renvoyée par la méthode."
|
||
|
||
#: library/email.policy.rst:361
|
||
msgid ""
|
||
"The same as :meth:`fold`, except that the returned value should be a bytes "
|
||
"object rather than a string."
|
||
msgstr ""
|
||
"Identique à :meth:`fold`, sauf que la valeur renvoyée doit être un objet "
|
||
"bytes plutôt qu'une chaîne."
|
||
|
||
#: library/email.policy.rst:364
|
||
msgid ""
|
||
"*value* may contain surrogateescaped binary data. These could be converted "
|
||
"back into binary data in the returned bytes object."
|
||
msgstr ""
|
||
"*value* peut contenir des données binaires de substitution échappées. Celles-"
|
||
"ci pourraient être reconverties en données binaires dans l'objet bytes "
|
||
"renvoyé."
|
||
|
||
#: library/email.policy.rst:371
|
||
msgid ""
|
||
"This concrete :class:`Policy` provides behavior that is intended to be fully "
|
||
"compliant with the current email RFCs. These include (but are not limited "
|
||
"to) :rfc:`5322`, :rfc:`2047`, and the current MIME RFCs."
|
||
msgstr ""
|
||
"Cette :class:`Policy` concrète fournit un comportement destiné à être "
|
||
"entièrement conforme aux RFC de messagerie actuelles. Ce qui inclut (mais "
|
||
"n'est pas limité à) la :rfc:`5322`, la :rfc:`2047` et les RFC MIME actuelles."
|
||
|
||
#: library/email.policy.rst:375
|
||
msgid ""
|
||
"This policy adds new header parsing and folding algorithms. Instead of "
|
||
"simple strings, headers are ``str`` subclasses with attributes that depend "
|
||
"on the type of the field. The parsing and folding algorithm fully "
|
||
"implement :rfc:`2047` and :rfc:`5322`."
|
||
msgstr ""
|
||
"Cette politique ajoute de nouveaux algorithmes d'analyse d'en-tête et de "
|
||
"mise en forme (« pliage »). Au lieu de simples chaînes, les en-têtes sont "
|
||
"des sous-classes ``str`` avec des attributs qui dépendent du type du champ. "
|
||
"L'algorithme d'analyse et de pliage implémente entièrement la :rfc:`2047` et "
|
||
"la :rfc:`5322`."
|
||
|
||
#: library/email.policy.rst:380
|
||
msgid ""
|
||
"The default value for the :attr:`~email.policy.Policy.message_factory` "
|
||
"attribute is :class:`~email.message.EmailMessage`."
|
||
msgstr ""
|
||
"La valeur par défaut de l'attribut :attr:`~email.policy.Policy."
|
||
"message_factory` est :class:`~email.message.EmailMessage`."
|
||
|
||
#: library/email.policy.rst:383
|
||
msgid ""
|
||
"In addition to the settable attributes listed above that apply to all "
|
||
"policies, this policy adds the following additional attributes:"
|
||
msgstr ""
|
||
"Outre les attributs définissables répertoriés ci-dessus qui s'appliquent à "
|
||
"toutes les règles, cette règle ajoute les attributs supplémentaires "
|
||
"suivants :"
|
||
|
||
#: library/email.policy.rst:386
|
||
msgid "[1]_"
|
||
msgstr "[1]_"
|
||
|
||
#: library/email.policy.rst:391
|
||
msgid ""
|
||
"If ``False``, follow :rfc:`5322`, supporting non-ASCII characters in headers "
|
||
"by encoding them as \"encoded words\". If ``True``, follow :rfc:`6532` and "
|
||
"use ``utf-8`` encoding for headers. Messages formatted in this way may be "
|
||
"passed to SMTP servers that support the ``SMTPUTF8`` extension (:rfc:`6531`)."
|
||
msgstr ""
|
||
"Si c'est ``False``, suit la :rfc:`5322`, en prenant en charge les caractères "
|
||
"non-ASCII dans les en-têtes en les encodant comme des « mots encodés ». Si "
|
||
"c'est ``True``, suit la :rfc:`6532` et utilise l'encodage ``utf-8`` pour les "
|
||
"en-têtes. Les messages formatés de cette manière peuvent être transmis aux "
|
||
"serveurs SMTP qui gèrent l'extension ``SMTPUTF8`` (:rfc:`6531`)."
|
||
|
||
#: library/email.policy.rst:400
|
||
msgid ""
|
||
"If the value for a header in the ``Message`` object originated from a :mod:"
|
||
"`~email.parser` (as opposed to being set by a program), this attribute "
|
||
"indicates whether or not a generator should refold that value when "
|
||
"transforming the message back into serialized form. The possible values are:"
|
||
msgstr ""
|
||
"Si la valeur d'un en-tête dans l'objet ``Message`` provient d'un :mod:"
|
||
"`~email.parser` (au lieu d'être définie par un programme), cet attribut "
|
||
"indique si un générateur doit ou non remettre en forme cette valeur "
|
||
"lorsqu'il retransforme le message sous forme sérialisée. Les valeurs "
|
||
"possibles sont :"
|
||
|
||
#: library/email.policy.rst:407
|
||
msgid "``none``"
|
||
msgstr "``none``"
|
||
|
||
#: library/email.policy.rst:407
|
||
msgid "all source values use original folding"
|
||
msgstr ""
|
||
"toutes les valeurs sources utilisent la mise en forme (*folding* en anglais) "
|
||
"d'origine"
|
||
|
||
#: library/email.policy.rst:409
|
||
msgid "``long``"
|
||
msgstr "``long``"
|
||
|
||
#: library/email.policy.rst:409
|
||
msgid ""
|
||
"source values that have any line that is longer than ``max_line_length`` "
|
||
"will be refolded"
|
||
msgstr ""
|
||
"les valeurs sources dont une ligne est plus longue que ``max_line_length`` "
|
||
"sont remises en forme"
|
||
|
||
#: library/email.policy.rst:412
|
||
msgid "``all``"
|
||
msgstr "``all``"
|
||
|
||
#: library/email.policy.rst:412
|
||
msgid "all values are refolded."
|
||
msgstr "toutes les valeurs sont remises en forme."
|
||
|
||
#: library/email.policy.rst:415
|
||
msgid "The default is ``long``."
|
||
msgstr "La valeur par défaut est ``long``."
|
||
|
||
#: library/email.policy.rst:420
|
||
msgid ""
|
||
"A callable that takes two arguments, ``name`` and ``value``, where ``name`` "
|
||
"is a header field name and ``value`` is an unfolded header field value, and "
|
||
"returns a string subclass that represents that header. A default "
|
||
"``header_factory`` (see :mod:`~email.headerregistry`) is provided that "
|
||
"supports custom parsing for the various address and date :RFC:`5322` header "
|
||
"field types, and the major MIME header field stypes. Support for additional "
|
||
"custom parsing will be added in the future."
|
||
msgstr ""
|
||
"Appelable qui prend deux arguments, ``name`` et ``value``, où ``name`` est "
|
||
"un nom de champ d'en-tête et ``value`` est une valeur de champ d'en-tête "
|
||
"dépliée (c-à-d. sans retours à la ligne de mise en forme), et renvoie une "
|
||
"sous-classe de chaîne qui représente cet en-tête. Un ``header_factory`` par "
|
||
"défaut (voir :mod:`~email.headerregistry`) est fourni qui prend en charge "
|
||
"l'analyse personnalisée pour les divers types de champs d'en-tête d'adresse "
|
||
"et de date :RFC:`5322`, et les principaux types de champs d'en-tête MIME. La "
|
||
"prise en charge d'une analyse personnalisée supplémentaire sera ajoutée à "
|
||
"l'avenir."
|
||
|
||
#: library/email.policy.rst:431
|
||
msgid ""
|
||
"An object with at least two methods: get_content and set_content. When the :"
|
||
"meth:`~email.message.EmailMessage.get_content` or :meth:`~email.message."
|
||
"EmailMessage.set_content` method of an :class:`~email.message.EmailMessage` "
|
||
"object is called, it calls the corresponding method of this object, passing "
|
||
"it the message object as its first argument, and any arguments or keywords "
|
||
"that were passed to it as additional arguments. By default "
|
||
"``content_manager`` is set to :data:`~email.contentmanager.raw_data_manager`."
|
||
msgstr ""
|
||
"Objet avec au moins deux méthodes : *get_content* et *set_content*. Lorsque "
|
||
"la méthode :meth:`~email.message.EmailMessage.get_content` ou :meth:`~email."
|
||
"message.EmailMessage.set_content` d'un objet :class:`~email.message."
|
||
"EmailMessage` est appelée, elle appelle la méthode correspondante de cet "
|
||
"objet, en lui transmettant l'objet message comme premier argument, et tous "
|
||
"les arguments positionnels ou nommés qui lui ont été transmis comme "
|
||
"arguments supplémentaires. Par défaut, ``content_manager`` est défini sur :"
|
||
"data:`~email.contentmanager.raw_data_manager`."
|
||
|
||
#: library/email.policy.rst:601
|
||
msgid ""
|
||
"The class provides the following concrete implementations of the abstract "
|
||
"methods of :class:`Policy`:"
|
||
msgstr ""
|
||
"La classe fournit les implémentations concrètes suivantes des méthodes "
|
||
"abstraites de :class:`Policy` :"
|
||
|
||
#: library/email.policy.rst:449
|
||
msgid ""
|
||
"Returns the value of the :attr:`~email.headerregistry.BaseHeader.max_count` "
|
||
"attribute of the specialized class used to represent the header with the "
|
||
"given name."
|
||
msgstr ""
|
||
"Renvoie la valeur de l'attribut :attr:`~email.headerregistry.BaseHeader."
|
||
"max_count` de la classe spécialisée utilisée pour représenter l'en-tête avec "
|
||
"le nom donné."
|
||
|
||
#: library/email.policy.rst:607
|
||
msgid ""
|
||
"The name is parsed as everything up to the '``:``' and returned unmodified. "
|
||
"The value is determined by stripping leading whitespace off the remainder of "
|
||
"the first line, joining all subsequent lines together, and stripping any "
|
||
"trailing carriage return or linefeed characters."
|
||
msgstr ""
|
||
"Le nom est analysé comme le reste jusqu'au ``:`` et renvoyé sans "
|
||
"modification. La valeur est déterminée en supprimant les espaces blancs de "
|
||
"début du reste de la première ligne, en joignant toutes les lignes suivantes "
|
||
"et en supprimant tous les caractères de retour chariot ou de saut de ligne "
|
||
"de fin."
|
||
|
||
#: library/email.policy.rst:465
|
||
msgid ""
|
||
"The name is returned unchanged. If the input value has a ``name`` attribute "
|
||
"and it matches *name* ignoring case, the value is returned unchanged. "
|
||
"Otherwise the *name* and *value* are passed to ``header_factory``, and the "
|
||
"resulting header object is returned as the value. In this case a "
|
||
"``ValueError`` is raised if the input value contains CR or LF characters."
|
||
msgstr ""
|
||
"Le nom est renvoyé tel quel. Si la valeur d'entrée a un attribut ``name`` et "
|
||
"qu'elle correspond à *name* sans tenir compte de la casse, la valeur est "
|
||
"renvoyée inchangée. Sinon, le *name* et la *value* sont passés à "
|
||
"``header_factory``, et l'objet d'en-tête résultant est renvoyé comme valeur. "
|
||
"Dans ce cas, une ``ValueError`` est levée si la valeur d'entrée contient des "
|
||
"caractères CR ou LF."
|
||
|
||
#: library/email.policy.rst:475
|
||
msgid ""
|
||
"If the value has a ``name`` attribute, it is returned to unmodified. "
|
||
"Otherwise the *name*, and the *value* with any CR or LF characters removed, "
|
||
"are passed to the ``header_factory``, and the resulting header object is "
|
||
"returned. Any surrogateescaped bytes get turned into the unicode unknown-"
|
||
"character glyph."
|
||
msgstr ""
|
||
"Si la valeur a un attribut ``name``, elle est renvoyée sans modification. "
|
||
"Sinon, le *name* et la *value* sans les caractères CR ou LF sont passés à "
|
||
"``header_factory``, et l'objet d'en-tête résultant est renvoyé. Tous les "
|
||
"octets échappés de substitution sont transformés en glyphe Unicode de "
|
||
"caractère inconnu."
|
||
|
||
#: library/email.policy.rst:484
|
||
msgid ""
|
||
"Header folding is controlled by the :attr:`refold_source` policy setting. A "
|
||
"value is considered to be a 'source value' if and only if it does not have a "
|
||
"``name`` attribute (having a ``name`` attribute means it is a header object "
|
||
"of some sort). If a source value needs to be refolded according to the "
|
||
"policy, it is converted into a header object by passing the *name* and the "
|
||
"*value* with any CR and LF characters removed to the ``header_factory``. "
|
||
"Folding of a header object is done by calling its ``fold`` method with the "
|
||
"current policy."
|
||
msgstr ""
|
||
"La mise en forme d'en-tête est contrôlée par le paramètre de politique :attr:"
|
||
"`refold_source`. Une valeur est considérée comme une « valeur source » si et "
|
||
"seulement si elle n'a pas d'attribut ``name`` (avoir un attribut ``name`` "
|
||
"signifie qu'il s'agit d'un objet d'en-tête quelconque). Si une valeur source "
|
||
"doit être mise en forme conformément à la politique, elle est convertie en "
|
||
"un objet d'en-tête en passant le *name* et la *value* avec tous les "
|
||
"caractères CR et LF supprimés à ``header_factory``. La mise en forme multi-"
|
||
"lignes d'un objet d'en-tête (« pliage » ou *folding* en anglais) se fait en "
|
||
"appelant sa méthode ``fold`` avec la politique actuelle."
|
||
|
||
#: library/email.policy.rst:493
|
||
msgid ""
|
||
"Source values are split into lines using :meth:`~str.splitlines`. If the "
|
||
"value is not to be refolded, the lines are rejoined using the ``linesep`` "
|
||
"from the policy and returned. The exception is lines containing non-ascii "
|
||
"binary data. In that case the value is refolded regardless of the "
|
||
"``refold_source`` setting, which causes the binary data to be CTE encoded "
|
||
"using the ``unknown-8bit`` charset."
|
||
msgstr ""
|
||
"Les valeurs sources sont divisées en lignes en utilisant :meth:`~str."
|
||
"splitlines`. Si la valeur ne doit pas être remise en forme, les lignes sont "
|
||
"jointes en utilisant le caractère ``linesep`` de la politique et renvoyées. "
|
||
"L'exception concerne les lignes contenant des données binaires non ASCII. "
|
||
"Dans ce cas, la valeur est remise en forme quel que soit le paramètre "
|
||
"``refold_source``, ce qui entraîne le codage CTE des données binaires à "
|
||
"l'aide du jeu de caractères ``unknown-8bit``."
|
||
|
||
#: library/email.policy.rst:503
|
||
msgid ""
|
||
"The same as :meth:`fold` if :attr:`~Policy.cte_type` is ``7bit``, except "
|
||
"that the returned value is bytes."
|
||
msgstr ""
|
||
"Identique à :meth:`fold` si :attr:`~Policy.cte_type` vaut ``7bit``, sauf que "
|
||
"la valeur renvoyée est de type *bytes*."
|
||
|
||
#: library/email.policy.rst:506
|
||
msgid ""
|
||
"If :attr:`~Policy.cte_type` is ``8bit``, non-ASCII binary data is converted "
|
||
"back into bytes. Headers with binary data are not refolded, regardless of "
|
||
"the ``refold_header`` setting, since there is no way to know whether the "
|
||
"binary data consists of single byte characters or multibyte characters."
|
||
msgstr ""
|
||
"Si :attr:`~Policy.cte_type` est ``8bit``, les données binaires non-ASCII "
|
||
"sont reconverties en octets. Les en-têtes contenant des données binaires ne "
|
||
"sont pas remises en forme, quel que soit le paramètre ``refold_header``, "
|
||
"puisqu'il n'y a aucun moyen de savoir si les données binaires sont "
|
||
"constituées de caractères à un seul octet ou de caractères à plusieurs "
|
||
"octets."
|
||
|
||
#: library/email.policy.rst:513
|
||
msgid ""
|
||
"The following instances of :class:`EmailPolicy` provide defaults suitable "
|
||
"for specific application domains. Note that in the future the behavior of "
|
||
"these instances (in particular the ``HTTP`` instance) may be adjusted to "
|
||
"conform even more closely to the RFCs relevant to their domains."
|
||
msgstr ""
|
||
"Les instances suivantes de :class:`EmailPolicy` fournissent des valeurs par "
|
||
"défaut adaptées à des domaines d'application spécifiques. Notez qu'à "
|
||
"l'avenir, le comportement de ces instances (en particulier l'instance "
|
||
"``HTTP``) pourra être ajusté pour se conformer encore plus étroitement aux "
|
||
"RFC relatives à leurs domaines."
|
||
|
||
#: library/email.policy.rst:521
|
||
msgid ""
|
||
"An instance of ``EmailPolicy`` with all defaults unchanged. This policy "
|
||
"uses the standard Python ``\\n`` line endings rather than the RFC-correct ``"
|
||
"\\r\\n``."
|
||
msgstr ""
|
||
"Une instance de ``EmailPolicy`` avec toutes les valeurs par défaut "
|
||
"inchangées. Cette politique utilise les fins de ligne standard Python "
|
||
"``\\n`` plutôt que le ``\\r\\n`` conforme à la RFC."
|
||
|
||
#: library/email.policy.rst:528
|
||
msgid ""
|
||
"Suitable for serializing messages in conformance with the email RFCs. Like "
|
||
"``default``, but with ``linesep`` set to ``\\r\\n``, which is RFC compliant."
|
||
msgstr ""
|
||
"Convient pour la sérialisation des messages conformément aux RFC des e-"
|
||
"mails. Comme ``default``, mais avec ``linesep`` défini sur ``\\r\\n``, ce "
|
||
"qui est conforme à la RFC."
|
||
|
||
#: library/email.policy.rst:535
|
||
msgid ""
|
||
"The same as ``SMTP`` except that :attr:`~EmailPolicy.utf8` is ``True``. "
|
||
"Useful for serializing messages to a message store without using encoded "
|
||
"words in the headers. Should only be used for SMTP transmission if the "
|
||
"sender or recipient addresses have non-ASCII characters (the :meth:`smtplib."
|
||
"SMTP.send_message` method handles this automatically)."
|
||
msgstr ""
|
||
"Identique à ``SMTP`` sauf que :attr:`~EmailPolicy.utf8` vaut ``True``. Utile "
|
||
"pour sérialiser des messages dans une banque de messages sans utiliser de "
|
||
"mots encodés dans les en-têtes. Ne doit être utilisée pour la transmission "
|
||
"SMTP que si les adresses de l'expéditeur ou du destinataire contiennent des "
|
||
"caractères non ASCII (la méthode :meth:`smtplib.SMTP.send_message` gère cela "
|
||
"automatiquement)."
|
||
|
||
#: library/email.policy.rst:544
|
||
msgid ""
|
||
"Suitable for serializing headers with for use in HTTP traffic. Like "
|
||
"``SMTP`` except that ``max_line_length`` is set to ``None`` (unlimited)."
|
||
msgstr ""
|
||
"Convient pour la sérialisation des en-têtes à utiliser dans le trafic HTTP. "
|
||
"Comme ``SMTP`` sauf que ``max_line_length`` est défini sur ``None`` "
|
||
"(illimité)."
|
||
|
||
#: library/email.policy.rst:550
|
||
msgid ""
|
||
"Convenience instance. The same as ``default`` except that "
|
||
"``raise_on_defect`` is set to ``True``. This allows any policy to be made "
|
||
"strict by writing::"
|
||
msgstr ""
|
||
"Exemple de commodité. Identique à ``default`` sauf que ``raise_on_defect`` "
|
||
"est défini sur ``True``. Cela permet de rendre stricte toute politique en "
|
||
"écrivant ::"
|
||
|
||
#: library/email.policy.rst:557
|
||
msgid ""
|
||
"With all of these :class:`EmailPolicies <.EmailPolicy>`, the effective API "
|
||
"of the email package is changed from the Python 3.2 API in the following "
|
||
"ways:"
|
||
msgstr ""
|
||
"Avec toutes ces :class:`EmailPolicies <.EmailPolicy>`, l'API effective du "
|
||
"paquet de messagerie est modifiée par rapport à l'API Python 3.2 de la "
|
||
"manière suivante :"
|
||
|
||
#: library/email.policy.rst:560
|
||
msgid ""
|
||
"Setting a header on a :class:`~email.message.Message` results in that header "
|
||
"being parsed and a header object created."
|
||
msgstr ""
|
||
"Définir un en-tête sur un :class:`~email.message.Message` entraîne l'analyse "
|
||
"de cet en-tête et la création d'un objet d'en-tête."
|
||
|
||
#: library/email.policy.rst:563
|
||
msgid ""
|
||
"Fetching a header value from a :class:`~email.message.Message` results in "
|
||
"that header being parsed and a header object created and returned."
|
||
msgstr ""
|
||
"La récupération d'une valeur d'en-tête à partir d'un :class:`~email.message."
|
||
"Message` entraîne l'analyse de cet en-tête ainsi que la création et le "
|
||
"renvoi d'un objet d'en-tête."
|
||
|
||
#: library/email.policy.rst:567
|
||
msgid ""
|
||
"Any header object, or any header that is refolded due to the policy "
|
||
"settings, is folded using an algorithm that fully implements the RFC folding "
|
||
"algorithms, including knowing where encoded words are required and allowed."
|
||
msgstr ""
|
||
"Tout objet d'en-tête, ou tout en-tête qui est remis en forme en raison des "
|
||
"paramètres de politique, est mis en forme à l'aide d'un algorithme qui "
|
||
"implémente entièrement les algorithmes de pliage de la RFC, notamment en "
|
||
"sachant où les mots encodés sont requis et autorisés."
|
||
|
||
#: library/email.policy.rst:572
|
||
msgid ""
|
||
"From the application view, this means that any header obtained through the :"
|
||
"class:`~email.message.EmailMessage` is a header object with extra "
|
||
"attributes, whose string value is the fully decoded unicode value of the "
|
||
"header. Likewise, a header may be assigned a new value, or a new header "
|
||
"created, using a unicode string, and the policy will take care of converting "
|
||
"the unicode string into the correct RFC encoded form."
|
||
msgstr ""
|
||
"Du point de vue de l'application, cela signifie que tout en-tête obtenu via :"
|
||
"class:`~email.message.EmailMessage` est un objet d'en-tête avec des "
|
||
"attributs supplémentaires, dont la valeur de chaîne est la valeur Unicode "
|
||
"entièrement décodée de l'en-tête. De même, un en-tête peut se voir attribuer "
|
||
"une nouvelle valeur, ou un nouvel en-tête créé, à l'aide d'une chaîne "
|
||
"Unicode, et la politique se chargera de convertir la chaîne Unicode dans la "
|
||
"forme encodée RFC correcte."
|
||
|
||
#: library/email.policy.rst:579
|
||
msgid ""
|
||
"The header objects and their attributes are described in :mod:`~email."
|
||
"headerregistry`."
|
||
msgstr ""
|
||
"Les objets d'en-tête et leurs attributs sont décrits dans :mod:`~email."
|
||
"headerregistry`."
|
||
|
||
#: library/email.policy.rst:586
|
||
msgid ""
|
||
"This concrete :class:`Policy` is the backward compatibility policy. It "
|
||
"replicates the behavior of the email package in Python 3.2. The :mod:"
|
||
"`~email.policy` module also defines an instance of this class, :const:"
|
||
"`compat32`, that is used as the default policy. Thus the default behavior "
|
||
"of the email package is to maintain compatibility with Python 3.2."
|
||
msgstr ""
|
||
"Cette :class:`Policy` concrète est la politique de rétrocompatibilité. Elle "
|
||
"reproduit le comportement du paquet de courrier électronique dans Python "
|
||
"3.2. Le module :mod:`~email.policy` définit également une instance de cette "
|
||
"classe, :const:`compat32`, qui est utilisée comme politique par défaut. "
|
||
"Ainsi, le comportement par défaut du paquet de messagerie est de maintenir "
|
||
"la compatibilité avec Python 3.2."
|
||
|
||
#: library/email.policy.rst:592
|
||
msgid ""
|
||
"The following attributes have values that are different from the :class:"
|
||
"`Policy` default:"
|
||
msgstr ""
|
||
"Les attributs suivants ont des valeurs différentes de la valeur par défaut "
|
||
"de :class:`Policy` :"
|
||
|
||
#: library/email.policy.rst:598
|
||
msgid "The default is ``True``."
|
||
msgstr "La valeur par défaut est ``True``."
|
||
|
||
#: library/email.policy.rst:615
|
||
msgid "The name and value are returned unmodified."
|
||
msgstr "Le nom et la valeur sont renvoyés sans modification."
|
||
|
||
#: library/email.policy.rst:620
|
||
msgid ""
|
||
"If the value contains binary data, it is converted into a :class:`~email."
|
||
"header.Header` object using the ``unknown-8bit`` charset. Otherwise it is "
|
||
"returned unmodified."
|
||
msgstr ""
|
||
"Si la valeur contient des données binaires, elle est convertie en un objet :"
|
||
"class:`~email.header.Header` en utilisant le jeu de caractères "
|
||
"``unknown-8bit``. Sinon, elle est renvoyée sans modification."
|
||
|
||
#: library/email.policy.rst:627
|
||
msgid ""
|
||
"Headers are folded using the :class:`~email.header.Header` folding "
|
||
"algorithm, which preserves existing line breaks in the value, and wraps each "
|
||
"resulting line to the ``max_line_length``. Non-ASCII binary data are CTE "
|
||
"encoded using the ``unknown-8bit`` charset."
|
||
msgstr ""
|
||
"Les en-têtes sont mis en forme à l'aide de l'algorithme de pliage :class:"
|
||
"`~email.header.Header`, qui préserve les sauts de ligne existants dans la "
|
||
"valeur et encapsule chaque ligne résultante dans la ``max_line_length``. Les "
|
||
"données binaires non-ASCII sont codées en CTE à l'aide du jeu de caractères "
|
||
"``unknown-8bit``."
|
||
|
||
#: library/email.policy.rst:635
|
||
msgid ""
|
||
"Headers are folded using the :class:`~email.header.Header` folding "
|
||
"algorithm, which preserves existing line breaks in the value, and wraps each "
|
||
"resulting line to the ``max_line_length``. If ``cte_type`` is ``7bit``, non-"
|
||
"ascii binary data is CTE encoded using the ``unknown-8bit`` charset. "
|
||
"Otherwise the original source header is used, with its existing line breaks "
|
||
"and any (RFC invalid) binary data it may contain."
|
||
msgstr ""
|
||
"Les en-têtes sont mis en forme à l'aide de l'algorithme de pliage :class:"
|
||
"`~email.header.Header`, qui préserve les sauts de ligne existants dans la "
|
||
"valeur et encapsule chaque ligne résultante dans la ``max_line_length``. Si "
|
||
"``cte_type`` est ``7bit``, les données binaires non-ASCII sont encodées en "
|
||
"CTE en utilisant le jeu de caractères ``unknown-8bit``. Sinon, l'en-tête "
|
||
"source d'origine est utilisé, avec ses sauts de ligne existants et toutes "
|
||
"les données binaires (non conformes à la RFC) qu'il peut contenir."
|
||
|
||
#: library/email.policy.rst:645
|
||
msgid ""
|
||
"An instance of :class:`Compat32`, providing backward compatibility with the "
|
||
"behavior of the email package in Python 3.2."
|
||
msgstr ""
|
||
"Instance de :class:`Compat32`, offrant une rétrocompatibilité avec le "
|
||
"comportement du paquet de messagerie dans Python 3.2."
|
||
|
||
#: library/email.policy.rst:650
|
||
msgid "Footnotes"
|
||
msgstr "Notes"
|
||
|
||
#: library/email.policy.rst:651
|
||
msgid ""
|
||
"Originally added in 3.3 as a :term:`provisional feature <provisional "
|
||
"package>`."
|
||
msgstr ""
|
||
"Initialement ajouté dans 3.3 en tant que :term:`paquet provisoire "
|
||
"<provisional package>`."
|