# `email.message` : représentation d'un message électronique

Code source : Lib/email/message.py

Nouveau dans la version 3.6: [1]

La classe centrale du paquet `email` est la classe `EmailMessage`, importée du module `email.message`. C'est la classe mère du modèle d'objet `email`. `EmailMessage` fournit la fonctionnalité de base pour définir et interroger les champs d'en-tête, pour accéder au corps des messages et pour créer ou modifier des messages structurés.

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. Addtional 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)

  Si policy est spécifiée, Python utilise les règles qu'elle spécifie pour mettre à jour et sérialiser la représentation du message. Si policy n'est pas définie, Python utilise la politique `default`, qui suit les règles des RFC de messagerie sauf pour les fins de ligne (au lieu de `\r\n` indiqués par la RFC, il utilise les fins de ligne standard Python `\n`). Pour plus d'informations, consultez la documentation `policy`.

  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__()

    Équivalent à `as_bytes()`. Permet à `bytes(msg)` de produire un objet bytes contenant le message sérialisé.

  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.

    Nouveau 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.