# `email.message.Message` : représentation d'un message électronique à l'aide de l'API `compat32`

La classe `Message` est très similaire à la classe `EmailMessage`, sans les méthodes ajoutées par cette classe et avec le comportement par défaut légèrement différent pour certaines autres méthodes. Nous documentons également ici certaines méthodes qui, bien que prises en charge par la classe `EmailMessage`, ne sont pas recommandées, sauf si vous avez affaire à du code hérité.

La philosophie et la structure des deux classes sont par ailleurs les mêmes.

Ce document décrit le comportement avec les règles par défaut (pour `Message`) `Compat32`. Si vous envisagez d'utiliser d'autres règles, vous devriez plutôt utiliser la classe `EmailMessage`.

Un message électronique se compose d'en-têtes et d'une charge utile. Les en-têtes doivent être des noms et des valeurs de style RFC 5322, 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, ou 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 `Message` est celui d'un dictionnaire ordonné d'en-têtes avec des méthodes supplémentaires pour accéder à la fois aux informations spécialisées des en-têtes, pour accéder à la charge utile, pour générer une version sérialisée du message et pour parcourir récursivement l'arbre d'objets. Notez que les en-têtes en double sont pris en charge mais que des méthodes spéciales doivent être utilisées pour y accéder.

Le pseudo-dictionnaire `Message` est indicé par les noms d'en-tête, qui doivent être des valeurs ASCII. Les valeurs du dictionnaire sont des chaînes censées contenir uniquement des caractères ASCII ; il existe une gestion spéciale pour les entrées non ASCII, mais cela ne produit pas toujours les résultats corrects. Les en-têtes sont stockés et renvoyés sous une forme respectant la casse, mais les noms de champ sont mis en correspondance sans tenir compte de la casse. Il peut également y avoir un seul en-tête d'enveloppe, également appelé en-tête Unix-From ou en-tête `From_`. La charge utile est soit une chaîne ou des octets, dans le cas d'objets message simples, soit une liste d'objets `Message`, pour les documents conteneurs MIME (par exemple multipart/* et message/rfc822).

Voici les méthodes de la classe `Message` :

class email.message.Message(policy=compat32)

  Si policy est spécifié (il doit s'agir d'une instance d'une classe `policy`), utilise les règles spécifiées pour mettre à jour et sérialiser la représentation du message. Si policy n'est pas défini, utilise les règles `compat32`, qui maintient la rétrocompatibilité avec la version Python 3.2 du paquet de messagerie. Pour plus d'informations, consultez la documentation `policy`.

  Modifié dans la version 3.3: l'argument nommé policy a été ajouté.

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

    Renvoie le message entier aplati sous forme de chaîne. 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`. Pour des raisons de compatibilité descendante, maxheaderlen est par défaut à `0`, donc si vous voulez une valeur différente, vous devez la remplacer explicitement (la valeur spécifiée pour max_line_length dans la politique sera ignorée par cette méthode). L'argument policy peut être utilisé pour remplacer les règles par défaut obtenues à 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 est transmise au `Generator`.

    L'aplatissement du message peut déclencher des changements dans `Message` 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 peut ne pas toujours formater le message comme vous le souhaitez. Par exemple, par défaut, elle ne reformate pas les lignes qui commencent par `From` qui est requis par le format mbox Unix. Pour plus de flexibilité, instanciez une instance `Generator` et utilisez sa méthode `flatten()` directement. Par exemple :

        from io import StringIO
        from email.generator import Generator
        fp = StringIO()
        g = Generator(fp, mangle_from_=True, maxheaderlen=60)
        g.flatten(msg)
        text = fp.getvalue()

    Si l'objet message contient des données binaires qui ne sont pas encodées selon les normes RFC, les données non conformes seront remplacées par des points de code Unicode « caractère inconnu » (voir aussi `as_bytes()` et `BytesGenerator`).

    Modifié dans la version 3.4: l'argument nommé policy a été ajouté.

  __str__()

    Équivalent à `as_string()`. Permet à `str(msg)` de produire une chaîne contenant le message formaté.

  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 les règles par défaut obtenues à 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 est passée au `BytesGenerator`.

    L'aplatissement du message peut déclencher des changements dans `Message` 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 peut ne pas toujours formater le message comme vous le souhaitez. Par exemple, par défaut, elle ne reformate pas les lignes qui commencent par `From` qui est requis par le format mbox Unix. Pour plus de flexibilité, instanciez une instance `BytesGenerator` et utilisez sa méthode `flatten()` directement. Par exemple :

        from io import BytesIO
        from email.generator import BytesGenerator
        fp = BytesIO()
        g = BytesGenerator(fp, mangle_from_=True, maxheaderlen=60)
        g.flatten(msg)
        text = fp.getvalue()

    Nouveau dans la version 3.4.

  __bytes__()

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

    Nouveau dans la version 3.4.

  is_multipart()

    Renvoie `True` si la charge utile du message est une liste d'objets sous-`Message`, 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 `Message` 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.

  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.

  attach(payload)

    Ajoute le payload donné à la charge utile actuelle, qui doit être `None` ou une liste d'objets `Message` avant l'appel. Après l'appel, la charge utile sera toujours une liste d'objets `Message`. Si vous souhaitez définir la charge utile sur un objet scalaire (par exemple, une chaîne), utilisez `set_payload()` à la place.

    Il s'agit d'une ancienne méthode. Dans la classe `EmailMessage` sa fonctionnalité est remplacée par `set_content()` et les méthodes associées `make` et `add`.

  get_payload(i=None, decode=False)

    Renvoie la charge utile actuelle, qui est une liste d'objets `Message` lorsque `is_multipart()` est `True`, ou une chaîne lorsque `is_multipart()` est `False`. Si la charge utile est une liste et que vous modifiez l'objet liste, vous modifiez la charge utile du message « sur place ».

    Avec l'argument optionnel i, `get_payload()` renvoie le ième élément de la charge utile, en partant de zéro, si `is_multipart()` vaut `True`. Une `IndexError` est levée si i est inférieur à 0 ou supérieur ou égal au nombre d'éléments dans la charge utile. Si la charge utile est une chaîne (c'est-à-dire que `is_multipart()` est `False`) et que i est donné, une `TypeError` est levée.

    decode est un indicateur facultatif indiquant si la charge utile doit être décodée ou non, selon l'en-tête Content-Transfer-Encoding. Lorsqu'il vaut `True` et que le message n'est pas en plusieurs parties, la charge utile est décodée si la valeur de cet en-tête est `quoted-printable` ou `base64`. Si un autre encodage est utilisé, ou si l'en-tête Content-Transfer-Encoding est manquant, la charge utile est renvoyée telle quelle (non décodée). Dans tous les cas, la valeur renvoyée est une donnée binaire. Si le message est en plusieurs parties et que l'indicateur decode est `True`, alors `None` est renvoyé. Si la charge utile est en base64 et qu'elle n'a pas été parfaitement formée (remplissage manquant, caractères en dehors de l'alphabet base64), alors un défaut approprié est ajouté à la propriété de défaut du message (`InvalidBase64PaddingDefect` ou `InvalidBase64CharactersDefect`, respectivement).

    Lorsque decode est `False` (valeur par défaut), le corps est renvoyé sous forme de chaîne sans décoder le Content-Transfer-Encoding. Cependant, pour un Content-Transfer-Encoding de 8 bits, une tentative est faite pour décoder les octets d'origine en utilisant le `charset` spécifié par l'en-tête Content-Type, en utilisant le gestionnaire d'erreurs `replace`. Si aucun `charset` n'est spécifié, ou si le `charset` donné n'est pas reconnu par le paquet de messagerie, le corps est décodé en utilisant le jeu de caractères ASCII par défaut.

    Il s'agit d'une ancienne méthode. Dans la classe `EmailMessage` sa fonctionnalité est remplacée par `get_content()` et `iter_parts()`.

  set_payload(payload, charset=None)

    Définit la charge utile de l'objet message entier à payload. Il est de la responsabilité du client de s'assurer des invariants de la charge utile. Le charset facultatif définit le jeu de caractères par défaut du message ; voir `set_charset()` pour plus de détails.

    Il s'agit d'une ancienne méthode. Dans la classe `EmailMessage` sa fonctionnalité est remplacée par `set_content()`.

  set_charset(charset)

    Définit le jeu de caractères de la charge utile à charset, qui peut être soit une instance de `Charset` (voir `email.charset`), une chaîne nommant un jeu de caractères ou `None`. S'il s'agit d'une chaîne, elle est convertie en une instance `Charset`. Si charset est `None`, le paramètre `charset` est supprimé de l'en-tête Content-Type (le message n'est pas modifié autrement). Tout le reste lève une `TypeError`.

    S'il n'y a pas d'en-tête MIME-Version existant, un en-tête est ajouté. S'il n'y a pas d'en-tête Content-Type, un en-tête est ajouté avec une valeur de text/plain. Que l'en-tête Content-Type existe déjà ou non, son paramètre `charset` est défini sur charset.output_charset. Si charset.input_charset et charset.output_charset diffèrent, la charge utile est ré-encodée dans le output_charset. S'il n'y a pas d'en-tête Content-Transfer-Encoding existant, alors la charge utile est encodée par transfert, si nécessaire, en utilisant le `Charset` spécifié et un en-tête avec cette valeur est ajouté. Si un en-tête Content-Transfer-Encoding existe déjà, la charge utile est supposée être déjà correctement encodée à l'aide de cet en-tête Content-Transfer-Encoding et n'est pas modifiée.

    Il s'agit d'une ancienne méthode. Dans la classe `EmailMessage` sa fonctionnalité est remplacée par le paramètre charset de la méthode `email.emailmessage.EmailMessage.set_content()`.

  get_charset()

    Renvoie l'instance `Charset` associée à la charge utile du message.

    Il s'agit d'une ancienne méthode. Dans la classe `EmailMessage`, elle renvoie toujours `None`.

  Les méthodes suivantes implémentent une interface de type correspondance pour accéder aux en-têtes RFC 2822 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 `Message`, les en-têtes sont toujours renvoyés dans l'ordre dans lequel ils sont apparus dans le message d'origine, ou 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 visent une commodité maximale.

  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.

  Dans un modèle généré à partir d'octets, toutes les valeurs d'en-tête qui (en violation des RFC) contiennent des octets non-ASCII sont, lorsqu'elles sont récupérées via cette interface, représentées comme des objets `Header` avec un charset à `unknown-8bit`.

  __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 insensible à la casse et name ne doit pas inclure les deux-points à la 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 désigné. name ne doit pas inclure le séparateur de champ deux-points. Si l'en-tête est manquant, `None` est renvoyé ; `KeyError` n'est jamais levée.

    Notez que si le champ désigné apparaît plus d'une fois dans les en-têtes du message, la valeur exacte renvoyée n'est pas définie. Utilisez la méthode `get_all()` pour obtenir les valeurs de tous les en-têtes existants.

  __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 champs 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!'

  __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 désigné 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 champs associées 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 (defaults to `None`).

  Voici quelques méthodes supplémentaires utiles :

  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 de ce nom dans le message, failobj est renvoyé (la valeur par défaut est `None`).

  add_header(_name, _value, **_params)

    Définition de paramètres d'en-têtes étendus. 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, elle peut être spécifiée 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 coder la valeur, `LANGUAGE` peut généralement être défini sur `None` ou la chaîne vide (voir la RFC 2231 pour d'autres possibilités), et `VALUE` est la valeur de chaîne contenant 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 un `CHARSET` à `utf-8` et un `LANGUAGE` à `None`.

    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 avec des caractères non-ASCII :

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

    qui produit :

        Content-Disposition: attachment; filename*="iso-8859-1''Fu%DFballer.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 des noms de champs. Si aucun en-tête correspondant n'a été trouvé, une `KeyError` est levée.

  get_content_type()

    Renvoie le type de contenu du message. La chaîne renvoyée est convertie en minuscules sous la forme maintype/subtype. S'il n'y avait pas d'en-tête Content-Type dans le message, le type par défaut tel qu'indiqué par `get_default_type()` est renvoyé. Puisque 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 sauf s'il apparaît 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 par défaut de text/plain, à 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 appliqué. Le type de contenu par défaut n'est pas stocké dans l'en-tête Content-Type.

  get_params(failobj=None, header='content-type', unquote=True)

    Renvoie les paramètres Content-Type du message, sous forme de liste. Les éléments de la liste renvoyée sont des couples clé-valeur, ayant été séparés sur le signe `'='`. Le côté gauche du `'='` est la clé, tandis que le côté droit est la valeur. S'il n'y a pas de signe `'='` dans le paramètre, la valeur est la chaîne vide, sinon la valeur est telle que décrite dans `get_param()` et n'est pas entre guillemets si l'option unquote est `True` (la valeur par défaut).

    failobj (facultatif) est l'objet à renvoyer s'il n'y a pas d'en-tête Content-Type. header (facultatif) est l'en-tête à rechercher au lieu de Content-Type.

    Il s'agit d'une ancienne méthode. Dans la classe `EmailMessage`, sa fonctionnalité est remplacée par la propriété params des objets d'en-tête individuels renvoyés par les méthodes d'accès aux en-têtes.

  get_param(param, failobj=None, header='content-type', unquote=True)

    Renvoie la valeur du paramètre param de l'en-tête Content-Type sous forme de chaîne. Si le message n'a pas d'en-tête Content-Type ou s'il n'y a pas un tel paramètre, alors failobj est renvoyé (par défaut à `None`).

    header s'il est fourni, spécifie l'en-tête de message à utiliser à la place de Content-Type.

    Les clés en paramètre sont toujours comparées sans tenir compte de la casse. La valeur de retour peut être soit une chaîne, soit un triplet si le paramètre a été encodé selon la RFC 2231. Lorsqu'il s'agit d'un triplet, les éléments de la valeur sont de la forme `(CHARSET, LANGUAGE, VALUE)`. Notez que `CHARSET` et `LANGUAGE` peuvent être `None`, vous devriez alors considérer que `VALUE` est encodé dans le jeu de caractères `us-ascii`. Vous pouvez généralement ignorer `LANGUAGE`.

    Si votre application ne se soucie pas de savoir si le paramètre a été encodé conformément à la RFC 2231, vous pouvez réduire la valeur du paramètre en appelant `email.utils.collapse_rfc2231_value()`, en transmettant la valeur de retour de `get_param()`. Cela renverra une chaîne Unicode convenablement décodée lorsque la valeur est un n-uplet, ou la chaîne d'origine sans guillemets si ce n'est pas le cas. Par exemple :

        rawparam = msg.get_param('foo')
        param = email.utils.collapse_rfc2231_value(rawparam)

    Dans tous les cas, la valeur du paramètre (soit la chaîne renvoyée, soit l'élément `VALUE` dans le triplet) est toujours sans guillemets, sauf si unquote est défini sur `False`.

    Il s'agit d'une ancienne méthode. Dans la classe `EmailMessage`, sa fonctionnalité est remplacée par la propriété params des objets d'en-tête individuels renvoyés par les méthodes d'accès aux en-têtes.

  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, sa valeur est remplacée par value. Si l'en-tête Content-Type n'a pas encore été défini pour ce message, il est défini à text/plain et la nouvelle valeur du paramètre est ajoutée conformément à la RFC 2045.

    L'option header spécifie un en-tête alternatif à Content-Type, et tous les paramètres seront entre guillemets si nécessaire sauf si l'option requote est `False` (la valeur par défaut est `True`).

    Si charset est spécifié, le paramètre est encodé selon la RFC 2231. language (facultatif) spécifie la langue RFC 2231, par défaut c'est la chaîne vide. charset et language doivent être des chaînes.

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

    Modifié dans la version 3.4: l'argument 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 « sur place » sans le paramètre ou sa valeur. Toutes les valeurs seront entre guillemets si nécessaire sauf si requote est `False` (la valeur par défaut est `True`). L'option header spécifie une alternative à Content-Type.

  set_type(type, header='Content-Type', requote=True)

    Définit le type principal et le sous-type de l'en-tête Content-Type. type doit être une chaîne sous la forme maintype/subtype, sinon une `ValueError` est levée.

    Cette méthode remplace l'en-tête Content-Type, en gardant tous les paramètres en place. Si requote est `False`, cela laisse les guillemets de l'en-tête existant tels quels, sinon les paramètres sont mis entre guillemets (par défaut).

    Un en-tête alternatif peut être spécifié dans l'argument header. Lorsque l'en-tête Content-Type est défini, un en-tête MIME-Version est également ajouté.

    Il s'agit d'une ancienne méthode. Dans la classe `EmailMessage` sa fonctionnalité est remplacée par les méthodes `make_` et `add_`.

  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 comme indiqué par `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 comme indiqué par `email.utils.unquote()`.

  set_boundary(boundary)

    Définit le paramètre `boundary` de l'en-tête Content-Type sur boundary. `set_boundary()` met toujours boundary entre 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 limite via `add_header()`, car `set_boundary()` préserve l'ordre des en-têtes Content-Type dans la liste des en-têtes. Cependant, elle ne conserve pas les lignes de continuation qui auraient pu être présentes dans l'en-tête original Content-Type.

  get_content_charset(failobj=None)

    Renvoie le paramètre `charset` de l'en-tête Content-Type, mis 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é.

    Notez que cette méthode diffère de `get_charset()` qui renvoie l'instance `Charset` avec l'encodage par défaut du corps du message.

  get_charsets(failobj=None)

    Renvoie une liste contenant les 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. Cependant, 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 dans la liste renvoyée est failobj.

  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 suit la RFC 2183.

    Nouveau dans la version 3.5.

  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'une arborescence d'objets de message, dans l'ordre de parcours en profondeur d'abord. Vous utiliserez généralement `walk()` comme itérateur 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` :

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

  Les objets `Message` peuvent aussi éventuellement contenir deux attributs d'instance, qui peuvent être utilisés lors de la génération du texte brut d'un message MIME.

  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 du cadre 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 frontière. 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.

    Vous n'avez pas besoin de définir l'épilogue sur la chaîne vide pour que `Generator` imprime une nouvelle ligne à la fin du fichier.

  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.