"email.message": Representing an email message
**********************************************

**Code source :** Lib/email/message.py

======================================================================

Ajouté dans la version 3.6: [1]

The central class in the "email" package is the "EmailMessage" class,
imported from the "email.message" module.  It is the base class for
the "email" object model.  "EmailMessage" provides the core
functionality for setting and querying header fields, for accessing
message bodies, and for creating or modifying structured messages.

Un message électronique se compose d'en-têtes (*headers*) et d'une
*charge utile* (*payload* en anglais, également appelée *contenu* –
*content* en anglais). Les en-têtes sont des noms et valeurs de champ
de style **RFC 5322** ou **RFC 6532**, où le nom et la valeur du champ
sont séparés par deux points. Les deux-points ne font partie ni du nom
du champ ni de la valeur du champ. La charge utile peut être un simple
message texte, un objet binaire ou une séquence structurée de sous-
messages chacun avec son propre ensemble d'en-têtes et sa propre
charge utile. Ce dernier type de charge utile est indiqué par le
message ayant un type MIME tel que *multipart/** ou *message/rfc822*.

Le modèle conceptuel fourni par un objet "EmailMessage" est celui d'un
dictionnaire ordonné d'en-têtes couplé à une *charge utile* qui
représente le corps **RFC 5322** du message, qui peut être une liste
de sous-objets "EmailMessage". En plus des méthodes de dictionnaire
normales pour accéder aux noms et valeurs d'en-têtes, il existe des
méthodes pour accéder à des informations spécialisées à partir des en-
têtes (par exemple le type de contenu MIME), pour agir sur la charge
utile, pour générer une version sérialisée du message et pour
parcourir récursivement l'arborescence d'objets.

The "EmailMessage" dictionary-like interface is indexed by the header
names, which must be ASCII values.  The values of the dictionary are
strings with some extra methods.  Headers are stored and returned in
case-preserving form, but field names are matched case-insensitively.
The keys are ordered, but unlike a real dict, there can be duplicates.
Additional methods are provided for working with headers that have
duplicate keys.

La *charge utile* est soit une chaîne ou un objet d'octets, dans le
cas d'objets de message simples, soit une liste d'objets
"EmailMessage" pour les documents de conteneur MIME tels que
*multipart/** et les objets messages *message/rfc822*.

class email.message.EmailMessage(policy=default)

   If *policy* is specified use the rules it specifies to update and
   serialize the representation of the message.  If *policy* is not
   set, use the "default" policy, which follows the rules of the email
   RFCs except for line endings (instead of the RFC mandated "\r\n",
   it uses the Python standard "\n" line endings).  For more
   information see the "policy" documentation. [2]

   as_string(unixfrom=False, maxheaderlen=None, policy=None)

      Return the entire message flattened as a string.  When optional
      *unixfrom* is true, the envelope header is included in the
      returned string.  *unixfrom* defaults to "False".  For backward
      compatibility with the base "Message" class *maxheaderlen* is
      accepted, but defaults to "None", which means that by default
      the line length is controlled by the "max_line_length" of the
      policy.  The *policy* argument may be used to override the
      default policy obtained from the message instance.  This can be
      used to control some of the formatting produced by the method,
      since the specified *policy* will be passed to the "Generator".

      L'aplatissement du message peut déclencher des changements dans
      "EmailMessage" si les valeurs par défaut doivent être
      renseignées pour terminer la transformation en chaîne (par
      exemple, les limites MIME peuvent être générées ou modifiées).

      Notez que cette méthode est fournie à titre de commodité et
      n'est peut-être pas la méthode la plus utile pour sérialiser les
      messages dans votre application, en particulier si vous traitez
      plusieurs messages. Voir "email.generator.Generator" pour une
      API plus flexible pour la sérialisation des messages. Notez
      également que cette méthode est limitée à la production de
      messages sérialisés en « 7 bits propres » lorsque "utf8" est
      "False", qui est la valeur par défaut.

      Modifié dans la version 3.6: le comportement par défaut lorsque
      *maxheaderlen* n'est pas spécifié est passé de la valeur par
      défaut à 0 à la valeur par défaut de *max_line_length* de la
      politique.

   __str__()

      Équivalent à "as_string(policy=self.policy.clone(utf8=True))".
      Permet à "str(msg)" de produire une chaîne contenant le message
      sérialisé dans un format lisible.

      Modifié dans la version 3.4: la méthode a été modifiée pour
      utiliser "utf8=True", produisant ainsi une représentation de
      message semblable à **RFC 6531**, au lieu d'être un alias direct
      pour "as_string()".

   as_bytes(unixfrom=False, policy=None)

      Renvoie le message entier aplati en tant qu'objet bytes. Lorsque
      l'option *unixfrom* est vraie, l'en-tête de l'enveloppe est
      inclus dans la chaîne renvoyée. *unixfrom* par défaut est
      "False". L'argument *policy* peut être utilisé pour remplacer la
      politique par défaut obtenue à partir de l'instance de message.
      Cela peut être utilisé pour contrôler une partie du formatage
      produit par la méthode, puisque la *policy* spécifiée sera
      transmise à "BytesGenerator".

      L'aplatissement du message peut déclencher des changements dans
      "EmailMessage" si les valeurs par défaut doivent être
      renseignées pour terminer la transformation en chaîne (par
      exemple, les limites MIME peuvent être générées ou modifiées).

      Notez que cette méthode est fournie à titre de commodité et
      n'est peut-être pas la méthode la plus utile pour sérialiser les
      messages dans votre application, en particulier si vous traitez
      plusieurs messages. Voir "email.generator.BytesGenerator" pour
      une API plus flexible pour la sérialisation des messages.

   __bytes__()

      Equivalent to "as_bytes()".  Allows "bytes(msg)" to produce a
      bytes object containing the serialized message.

   is_multipart()

      Renvoie "True" si la charge utile du message est une liste
      d'objets "EmailMessage", sinon renvoie "False". Lorsque
      "is_multipart()" renvoie "False", la charge utile doit être un
      objet chaîne (qui peut être une charge utile binaire encodée
      CTE). Notez que "is_multipart()" renvoyant "True" ne signifie
      pas nécessairement que "msg.get_content_maintype() ==
      'multipart'" renvoie "True". Par exemple, "is_multipart" renvoie
      "True" lorsque le "EmailMessage" est de type "message/rfc822".

   set_unixfrom(unixfrom)

      Définit l'en-tête de l'enveloppe du message sur *unixfrom*, qui
      doit être une chaîne (voir "mboxMessage" pour une brève
      description de cet en-tête).

   get_unixfrom()

      Renvoie l'en-tête de l'enveloppe du message. La valeur par
      défaut est "None" si l'en-tête de l'enveloppe n'a jamais été
      défini.

   Les méthodes suivantes implémentent l'interface de type
   correspondance pour accéder aux en-têtes du message. Notez qu'il
   existe des différences sémantiques entre ces méthodes et une
   interface de correspondance normale (c'est-à-dire un dictionnaire).
   Par exemple, dans un dictionnaire, il n'y a pas de clés en double,
   mais ici, il peut y avoir des en-têtes de message en double. De
   plus, dans les dictionnaires, il n'y a pas d'ordre garanti pour les
   clés renvoyées par "keys()", mais dans un objet "EmailMessage", les
   en-têtes sont toujours renvoyés dans l'ordre dans lequel ils sont
   apparus dans le message d'origine, ou dans lequel ils ont été
   ajoutés au message plus tard. Tout en-tête supprimé puis rajouté
   est toujours ajouté à la fin de la liste des en-têtes.

   Ces différences sémantiques sont intentionnelles et privilégient la
   commodité dans les cas d'utilisation les plus courants.

   Notez que dans tous les cas, tout en-tête d'enveloppe présent dans
   le message n'est pas inclus dans l'interface de correspondance.

   __len__()

      Renvoie le nombre total d'en-têtes, y compris les doublons.

   __contains__(name)

      Renvoie "True" si l'objet message a un champ nommé *name*. La
      correspondance est effectuée sans tenir compte de la casse et
      *name* n'inclut pas les deux-points de fin. Utilisé pour
      l'opérateur "in". Par exemple :

         if 'message-id' in myMessage:
            print('Message-ID:', myMessage['message-id'])

   __getitem__(name)

      Renvoie la valeur du champ d'en-tête nommé. *name* n'inclut pas
      le séparateur de champ deux-points. Si l'en-tête est manquant,
      "None" est renvoyée ; "KeyError" n'est jamais levée.

      Notez que si le champ nommé apparaît plus d'une fois dans les
      en-têtes du message, il n'est pas défini la valeur de quel champ
      est renvoyée. Utilisez la méthode "get_all()" pour obtenir les
      valeurs de tous les en-têtes existants nommés *name*.

      En utilisant les politiques standard (non-"compat32"), la valeur
      renvoyée est une instance d'une sous-classe de
      "email.headerregistry.BaseHeader".

   __setitem__(name, val)

      Ajoute un en-tête au message avec le nom de champ *name* et la
      valeur *val*. Le champ est ajouté à la fin des en-têtes
      existants du message.

      Notez que cela n'écrase *pas* ou ne supprime aucun en-tête
      existant portant le même nom. Si vous voulez vous assurer que le
      nouvel en-tête est le seul présent dans le message avec le nom
      de champ *name*, supprimez d'abord le champ, par exemple :

         del msg['subject']
         msg['subject'] = 'Python roolz!'

      If the "policy" defines certain headers to be unique (as the
      standard policies do), this method may raise a "ValueError" when
      an attempt is made to assign a value to such a header when one
      already exists.  This behavior is intentional for consistency's
      sake, but do not depend on it as we may choose to make such
      assignments do an automatic deletion of the existing header in
      the future.

   __delitem__(name)

      Supprime toutes les occurrences du champ portant le nom *name*
      des en-têtes du message. Aucune exception n'est levée si le
      champ nommé n'est pas présent dans les en-têtes.

   keys()

      Renvoie une liste de tous les noms de champs d'en-tête du
      message.

   values()

      Renvoie une liste de toutes les valeurs de champ du message.

   items()

      Renvoie une liste de couples contenant tous les en-têtes et
      valeurs de champ du message.

   get(name, failobj=None)

      Return the value of the named header field.  This is identical
      to "__getitem__()" except that optional *failobj* is returned if
      the named header is missing (*failobj* defaults to "None").

   Voici quelques méthodes supplémentaires utiles liées aux en-têtes :

   get_all(name, failobj=None)

      Renvoie la liste de toutes les valeurs du champ nommé *name*.
      S'il n'y a pas d'en-têtes nommés de ce type dans le message,
      *failobj* est renvoyé (la valeur par défaut est "None").

   add_header(_name, _value, **_params)

      Étend les en-têtes. Cette méthode est similaire à
      "__setitem__()" sauf que des paramètres d'en-tête
      supplémentaires peuvent être fournis en tant qu'arguments
      nommés. *_name* est le champ d'en-tête à ajouter et *_value* est
      la valeur *primaire* de l'en-tête.

      Pour chaque élément du dictionnaire d'arguments nommés
      *_params*, la clé est prise comme nom de paramètre, avec des
      traits de soulignement convertis en tirets (puisque les tirets
      sont illégaux dans les identifiants Python). Normalement, le
      paramètre est ajouté en tant que "key="value"" sauf si la valeur
      est "None", auquel cas seule la clé est ajoutée.

      Si la valeur contient des caractères non-ASCII, le jeu de
      caractères et la langue peuvent être explicitement contrôlés en
      spécifiant la valeur sous la forme d'un triplet au format
      "(CHARSET, LANGUAGE, VALUE)", où "CHARSET" est une chaîne
      nommant le jeu de caractères à utiliser pour encoder la valeur,
      "LANGUAGE" peut généralement être défini sur "None" ou sur la
      chaîne vide (voir **RFC 2231** pour d'autres possibilités) et
      "VALUE" est la chaîne contenant les valeurs des points de code
      non-ASCII. Si un triplet n'est pas passé et que la valeur
      contient des caractères non-ASCII, elle est automatiquement
      encodée au format **RFC 2231** en utilisant "utf-8" comme
      "CHARSET" et "None" comme "LANGUAGE".

      Voici un exemple :

         msg.add_header('Content-Disposition', 'attachment', filename='bud.gif')

      Cela ajoute un en-tête qui ressemble à :

         Content-Disposition: attachment; filename="bud.gif"

      Un exemple d'interface étendue avec des caractères non-ASCII :

         msg.add_header('Content-Disposition', 'attachment',
                        filename=('iso-8859-1', '', 'Fußballer.ppt'))

   replace_header(_name, _value)

      Remplace un en-tête. Remplace le premier en-tête trouvé dans le
      message qui correspond à *_name*, en conservant l'ordre des en-
      têtes et la casse du nom de champ de l'en-tête d'origine. Si
      aucun en-tête correspondant n'est trouvé, lève une "KeyError".

   get_content_type()

      Renvoie le type de contenu du message, contraint en minuscules
      de la forme *maintype/subtype*. S'il n'y a pas d'en-tête
      *Content-Type* dans le message, renvoie la valeur renvoyée par
      "get_default_type()". Si l'en-tête *Content-Type* n'est pas
      valide, renvoie "text/plain".

      (Selon la **RFC 2045**, les messages ont toujours un type par
      défaut, "get_content_type()" renvoie toujours une valeur. La
      **RFC 2045** définit le type par défaut d'un message comme étant
      *text/plain* à moins qu'il n'apparaisse dans un conteneur
      *multipart/digest*, auquel cas ce serait *message/rfc822*. Si l
      'en-tête *Content-Type* a une spécification de type invalide, la
      **RFC 2045** exige que le type par défaut soit *text/plain*.)

   get_content_maintype()

      Renvoie le type de contenu principal du message. C'est la partie
      *maintype* de la chaîne renvoyée par "get_content_type()".

   get_content_subtype()

      Renvoie le type de sous-contenu du message. C'est la partie
      *subtype* de la chaîne renvoyée par "get_content_type()".

   get_default_type()

      Renvoie le type de contenu par défaut. La plupart des messages
      ont un type de contenu *text/plain* par défaut, à l'exception
      des messages qui sont des sous-parties des conteneurs
      *multipart/digest*. Ces sous-parties ont un type de contenu par
      défaut de *message/rfc822*.

   set_default_type(ctype)

      Définit le type de contenu par défaut. *ctype* doit être
      *text/plain* ou *message/rfc822*, bien que cela ne soit pas
      imposé. Le type de contenu par défaut n'est pas stocké dans l
      'en-tête *Content-Type*, il n'affecte donc que la valeur de
      retour des méthodes "get_content_type" lorsqu'aucun en-tête
      *Content-Type* n'est présent dans le message .

   set_param(param, value, header='Content-Type', requote=True, charset=None, language='', replace=False)

      Définit un paramètre dans l'en-tête *Content-Type*. Si le
      paramètre existe déjà dans l'en-tête, remplace sa valeur par
      *value*. Lorsque *header* est "Content-Type" (la valeur par
      défaut) et que l'en-tête n'existe pas encore dans le message,
      l'ajoute, définit sa valeur sur *text/plain* et ajoute la
      nouvelle valeur du paramètre. *header* facultatif spécifie un
      en-tête alternatif à *Content-Type*.

      Si la valeur contient des caractères non ASCII, le jeu de
      caractères et la langue peuvent être explicitement spécifiés à
      l'aide des paramètres facultatifs *charset* et *language*.
      L'option *language* spécifie la langue **RFC 2231**, par défaut
      la chaîne vide. *charset* et *language* doivent être des
      chaînes. La valeur par défaut est "utf8" pour *charset* et
      "None" pour *language*.

      Si *replace* est "False" (valeur par défaut), l'en-tête est
      déplacé à la fin de la liste des en-têtes. Si *replace* est
      "True", l'en-tête est mis à jour sur place.

      L'utilisation du paramètre *requote* avec les objets
      "EmailMessage" est obsolète.

      Note that existing parameter values of headers may be accessed
      through the "params" attribute of the header value (for example,
      "msg['Content-Type'].params['charset']").

      Modifié dans la version 3.4: le paramètre nommé "replace" a été
      ajouté.

   del_param(param, header='content-type', requote=True)

      Supprime complètement le paramètre donné de l'en-tête *Content-
      Type*. L'en-tête est réécrit en place sans le paramètre ou sa
      valeur. L'option *header* spécifie une alternative à *Content-
      Type*.

      L'utilisation du paramètre *requote* avec les objets
      "EmailMessage" est obsolète.

   get_filename(failobj=None)

      Renvoie la valeur du paramètre "filename" de l'en-tête *Content-
      Disposition* du message. Si l'en-tête n'a pas de paramètre
      "filename", cette méthode revient à rechercher le paramètre
      "name" dans l'en-tête *Content-Type*. Si aucun n'est trouvé, ou
      si l'en-tête est manquant, alors *failobj* est renvoyé. La
      chaîne renvoyée est toujours sans guillemets selon
      "email.utils.unquote()".

   get_boundary(failobj=None)

      Renvoie la valeur du paramètre "boundary" de l'en-tête *Content-
      Type* du message, ou *failobj* si l'en-tête est manquant ou n'a
      pas de paramètre "boundary". La chaîne renvoyée est toujours
      sans guillemets selon "email.utils.unquote()".

   set_boundary(boundary)

      Définit le paramètre "boundary" de l'en-tête *Content-Type* sur
      *boundary*. "set_boundary()" entoure *boundary* de guillemets si
      nécessaire. Une "HeaderParseError" est levée si l'objet message
      n'a pas d'en-tête *Content-Type*.

      Notez que l'utilisation de cette méthode est légèrement
      différente de la suppression de l'ancien en-tête *Content-Type*
      et de l'ajout d'un nouveau avec la nouvelle délimitation via
      "add_header()", car "set_boundary()" préserve l'ordre des en-
      têtes *Content-Type* dans la liste des en-têtes.

   get_content_charset(failobj=None)

      Renvoie le paramètre "charset" de l'en-tête *Content-Type*,
      contraint en minuscules. S'il n'y a pas d'en-tête *Content-
      Type*, ou si cet en-tête n'a pas de paramètre "charset",
      *failobj* est renvoyé.

   get_charsets(failobj=None)

      Renvoie la liste des noms des jeux de caractères dans le
      message. Si le message est un *multipart*, alors la liste
      contient un élément pour chaque sous-partie dans la charge
      utile, sinon c'est une liste de longueur 1.

      Chaque élément de la liste est une chaîne qui est la valeur du
      paramètre "charset" dans l'en-tête *Content-Type* pour la sous-
      partie représentée. Si la sous-partie n'a pas d'en-tête
      *Content-Type*, pas de paramètre "charset" ou n'est pas du type
      MIME principal *text*, alors cet élément est *failobj* dans la
      liste renvoyée.

   is_attachment()

      Renvoie "True" s'il y a un en-tête *Content-Disposition* et que
      sa valeur (insensible à la casse) est "attachment", "False"
      sinon.

      Modifié dans la version 3.4.2: *is_attachment* est maintenant
      une méthode au lieu d'une propriété, par souci de cohérence avec
      "is_multipart()".

   get_content_disposition()

      Renvoie la valeur en minuscules (sans paramètres) de l'en-tête
      *Content-Disposition* du message s'il en a un, ou "None". Les
      valeurs possibles pour cette méthode sont *inline*, *attachment*
      ou "None" si le message respecte la **RFC 2183**.

      Ajouté dans la version 3.5.

   Les méthodes suivantes concernent l'interrogation et la
   manipulation du contenu (charge utile) du message.

   walk()

      La méthode "walk()" est un générateur polyvalent qui peut être
      utilisé pour itérer sur toutes les parties et sous-parties d'un
      arbre d'objets de message, dans l'ordre de parcours en
      profondeur d'abord. L'utilisation classique est d'itérer avec
      "walk()" dans une boucle "for" ; chaque itération renvoie la
      sous-partie suivante.

      Voici un exemple qui imprime le type MIME de chaque partie d'une
      structure de message en plusieurs parties :

         >>> for part in msg.walk():
         ...     print(part.get_content_type())
         multipart/report
         text/plain
         message/delivery-status
         text/plain
         text/plain
         message/rfc822
         text/plain

      "walk" itère sur les sous-parties de toute partie où
      "is_multipart()" renvoie "True", même si
      "msg.get_content_maintype() == 'multipart'" peut renvoyer
      "False". Nous pouvons le voir dans notre exemple en utilisant la
      fonction d'aide au débogage "_structure" :

         >>> from email.iterators import _structure
         >>> for part in msg.walk():
         ...     print(part.get_content_maintype() == 'multipart',
         ...           part.is_multipart())
         True True
         False False
         False True
         False False
         False False
         False True
         False False
         >>> _structure(msg)
         multipart/report
             text/plain
             message/delivery-status
                 text/plain
                 text/plain
             message/rfc822
                 text/plain

      Ici, les parties "message" ne sont pas des "multiparts", mais
      elles contiennent des sous-parties. "is_multipart()" renvoie
      "True" et "walk" descend dans les sous-parties.

   get_body(preferencelist=('related', 'html', 'plain'))

      Renvoie la partie MIME qui est la meilleure candidate pour être
      le corps du message.

      *preferencelist* doit être une séquence de chaînes de l'ensemble
      "related", "html" et "plain", et indique l'ordre de préférence
      pour le type de contenu de la partie renvoyée.

      Elle commence par rechercher des correspondances candidates avec
      l'objet sur lequel la méthode "get_body" est appelée.

      Si "related" n'est pas inclus dans *preferencelist*, elle
      considère la partie racine (ou sous-partie de la partie racine)
      de tout lien rencontré comme candidat si la (sous-)partie
      correspond à une préférence.

      Lorsqu'elle rencontre un "multipart/related", elle vérifie le
      paramètre "start" et si une partie avec un *Content-ID*
      correspondant est trouvée, elle la considère uniquement lors de
      la recherche de correspondances candidates. Sinon, elle ne
      considère que la première partie (racine par défaut) de
      "multipart/related".

      Si une partie a un en-tête *Content-Disposition*, elle ne
      considère la partie comme une correspondance candidate que si la
      valeur de l'en-tête est "inline".

      Si aucun des candidats ne correspond à aucune des préférences
      dans *preferencelist*, elle renvoie "None".

      Remarques : (1) Pour la plupart des applications, les seules
      combinaisons *preferencelist* qui ont vraiment un sens sont
      "('plain',)", "('html', 'plain')" et la valeur par défaut "(
      'related', 'html', 'plain')". (2) Parce que la correspondance
      commence avec l'objet sur lequel "get_body" est appelée, appeler
      "get_body" sur un "multipart/related" renvoie l'objet lui-même à
      moins que *preferencelist* n'ait une valeur autre que celle par
      défaut. (3) Les messages (ou parties de message) qui ne
      spécifient pas un *Content-Type* ou dont l'en-tête *Content-
      Type* est invalide sont traités comme s'ils étaient de type
      "text/plain", ce qui peut occasionnellement amener "get_body" à
      renvoyer des résultats inattendus.

   iter_attachments()

      Renvoie un itérateur sur toutes les sous-parties immédiates du
      message qui ne sont pas des parties de « corps » candidates.
      Autrement dit, elle ignore la première occurrence de chacun des
      éléments suivants : "text/plain", "text/html",
      "multipart/related" ou "multipart/alternative" (sauf s'ils sont
      explicitement marqués comme pièces jointes via *Content-
      Disposition: attachment*), et renvoie toutes les parties
      restantes. Lorsqu'elle est appliquée directement à un
      "multipart/related", renvoie un itérateur sur toutes les parties
      liées sauf la partie racine (c'est-à-dire la partie pointée par
      le paramètre "start", ou la première partie s'il n'y a pas de
      paramètre "start" ou si le paramètre "start" ne correspond pas
      au *Content-ID* de l'une des parties). Lorsqu'elle est appliquée
      directement à un "multipart/alternative" ou à un
      non-"multipart", elle renvoie un itérateur vide.

   iter_parts()

      Renvoie un itérateur sur toutes les sous-parties immédiates du
      message, qui seront vides pour une non-"multipart" (voir aussi
      "walk()").

   get_content(*args, content_manager=None, **kw)

      Appelle la méthode "get_content()" du *content_manager*, en
      passant *self* comme objet message et en passant tout autre
      argument ou mot-clé comme argument supplémentaire. Si
      *content_manager* n'est pas spécifié, utilise le
      "content_manager" spécifié par la "policy" actuelle.

   set_content(*args, content_manager=None, **kw)

      Appelle la méthode "set_content()" du *content_manager*, en
      passant *self* comme objet message et en passant tout autre
      argument ou mot-clé comme argument supplémentaire. Si
      *content_manager* n'est pas spécifié, utilise le
      "content_manager" spécifié par la "policy" actuelle.

   make_related(boundary=None)

      Convertit un message non-"multipart" en un message
      "multipart/related", en déplaçant tous les en-têtes *Content-*
      existants et la charge utile dans une (nouvelle) première partie
      du "multipart". Si *boundary* est spécifié, elle l'utilise comme
      chaîne de délimitation dans le *multipart*, sinon elle laisse la
      délimitation être créée automatiquement lorsque cela est
      nécessaire (par exemple, lorsque le message est sérialisé).

   make_alternative(boundary=None)

      Convertit un non-"multipart" ou un "multipart/related" en un
      "multipart/alternative", en déplaçant tous les en-têtes
      *Content-* existants et la charge utile dans une (nouvelle)
      première partie du "multipart". Si *boundary* est spécifiée,
      l'utilise comme chaîne de délimitation dans le *multipart*,
      sinon laisse la délimitation être créée automatiquement lorsque
      cela est nécessaire (par exemple, lorsque le message est
      sérialisé).

   make_mixed(boundary=None)

      Convertit un non-"multipart", un "multipart/related" ou un
      "multipart-alternative" en un "multipart/mixed", en déplaçant
      tous les en-têtes *Content-* existants et charge utile dans une
      (nouvelle) première partie du "multipart". Si *boundary* est
      spécifiée, l'utilise comme chaîne de délimitation dans le
      *multipart*, sinon elle laisse la délimitation être créée
      automatiquement lorsque cela est nécessaire (par exemple,
      lorsque le message est sérialisé).

   add_related(*args, content_manager=None, **kw)

      Si le message est un "multipart/related", crée un nouvel objet
      message, passe tous les arguments à sa méthode "set_content()"
      et le joint avec "attach()" au "multipart". Si le message n'est
      pas en "multipart", appelle "make_related()" puis procède comme
      ci-dessus. Si le message est un autre type de "multipart", lève
      une "TypeError". Si *content_manager* n'est pas spécifié,
      utilise le "content_manager" spécifié par la "policy" actuelle.
      Si la partie ajoutée n'a pas d'en-tête *Content-Disposition*, en
      ajoute un avec la valeur "inline".

   add_alternative(*args, content_manager=None, **kw)

      Si le message est un "multipart/alternative", crée un nouvel
      objet message, transmet tous les arguments à sa méthode
      "set_content()" et le joint avec "attach()" au "multipart". Si
      le message est non-"multipart" ou "multipart/related", appelle
      "make_alternative()" puis procède comme ci-dessus. Si le message
      est un autre type de "multipart", lève une "TypeError". Si
      *content_manager* n'est pas spécifié, utilise le
      "content_manager" spécifié par la "policy" actuelle.

   add_attachment(*args, content_manager=None, **kw)

      Si le message est un "multipart/mixed", crée un nouvel objet
      message, passe tous les arguments à sa méthode "set_content()"
      et le joint avec "attach()" au "multipart". Si le message n'est
      pas en "multipart", "multipart/related" ou
      "multipart/alternative", appelle "make_mixed()" puis procède
      comme ci-dessus. Si *content_manager* n'est pas spécifié,
      utilise le "content_manager" spécifié par la "policy" actuelle.
      Si la partie ajoutée n'a pas d'en-tête *Content-Disposition*, en
      ajoute un avec la valeur "attachment". Cette méthode peut être
      utilisée à la fois pour les pièces jointes explicites (*Content-
      Disposition:attachment*) et les pièces jointes "inline"
      (*Content-Disposition:inline*), en passant les options
      appropriées au "content_manager".

   clear()

      Supprime la charge utile et tous les en-têtes.

   clear_content()

      Remove the payload and all of the *!Content-* headers, leaving
      all other headers intact and in their original order.

   Les objets "EmailMessage" ont les attributs d'instance suivants :

   preamble

      Le format d'un document MIME permet d'insérer du texte entre la
      ligne vide suivant les en-têtes et la première chaîne de
      délimitation en plusieurs parties. Normalement, ce texte n'est
      jamais visible dans un lecteur de courrier compatible MIME car
      il ne fait pas partie de l'attirail MIME standard. Toutefois,
      lors de l'affichage du texte brut du message ou lors de
      l'affichage du message dans un lecteur non compatible MIME, ce
      texte peut devenir visible.

      L'attribut *preamble* contient ce texte hors cadre de tête pour
      les documents MIME. Lorsque "Parser" découvre du texte après les
      en-têtes mais avant la première chaîne de délimitation, il
      attribue ce texte à l'attribut *preamble* du message. Lorsque
      "Generator" écrit la représentation en texte brut d'un message
      MIME, et qu'il trouve que le message a un attribut *preamble*,
      il écrit ce texte dans la zone entre les en-têtes et la première
      limite. Voir "email.parser" et "email.generator" pour plus de
      détails.

      Notez que si l'objet message n'a pas de préambule, l'attribut
      *preamble* est "None".

   epilogue

      L'attribut *epilogue* agit de la même manière que l'attribut
      *preamble*, sauf qu'il contient du texte qui apparaît entre la
      dernière limite et la fin du message. Comme avec "preamble",
      s'il n'y a pas de texte d'épilogue, cet attribut est "None".

   defects

      L'attribut *defects* contient une liste de tous les problèmes
      rencontrés lors de l'analyse de ce message. Voir "email.errors"
      pour une description détaillée des défauts d'analyse possibles.

class email.message.MIMEPart(policy=default)

   Cette classe représente une sous-partie d'un message MIME. Elle est
   identique à "EmailMessage", sauf qu'aucun en-tête *MIME-Version*
   n'est ajouté lorsque "set_content()" est appelée, car les sous-
   parties n'ont pas besoin de leurs propres en-têtes *MIME-Version*.

-[ Notes ]-

[1] Ajouté à l'origine dans 3.4 en tant que *module provisoire*. Les
    documents pour la classe de message héritée ont été déplacés dans
    email.message.Message : représentation d'un message électronique à
    l'aide de l'API compat32.

[2] The "EmailMessage" class requires a policy that provides a
    "content_manager" attribute for content management methods like
    "set_content()" and "get_content()" to work. The legacy "compat32"
    policy does not support these methods and should not be used with
    "EmailMessage".
