email.message: Representing an email message

Code source : Lib/email/message.py

Ajouté 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. 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)

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

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.

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

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