[ SEA-GHOST MINI SHELL]

Path : /proc/2/cwd/proc/2/root/usr/share/doc/python-docs-2.7.5/html/library/
FILE UPLOADER :
Current File : //proc/2/cwd/proc/2/root/usr/share/doc/python-docs-2.7.5/html/library/email.message.html


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">


<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    
    <title>18.1.1. email.message: Representing an email message &mdash; Python 2.7.5 documentation</title>
    
    <link rel="stylesheet" href="../_static/default.css" type="text/css" />
    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
    
    <script type="text/javascript">
      var DOCUMENTATION_OPTIONS = {
        URL_ROOT:    '../',
        VERSION:     '2.7.5',
        COLLAPSE_INDEX: false,
        FILE_SUFFIX: '.html',
        HAS_SOURCE:  true
      };
    </script>
    <script type="text/javascript" src="../_static/jquery.js"></script>
    <script type="text/javascript" src="../_static/underscore.js"></script>
    <script type="text/javascript" src="../_static/doctools.js"></script>
    <script type="text/javascript" src="../_static/sidebar.js"></script>
    <link rel="search" type="application/opensearchdescription+xml"
          title="Search within Python 2.7.5 documentation"
          href="../_static/opensearch.xml"/>
    <link rel="author" title="About these documents" href="../about.html" />
    <link rel="copyright" title="Copyright" href="../copyright.html" />
    <link rel="top" title="Python 2.7.5 documentation" href="../index.html" />
    <link rel="up" title="18.1. email — An email and MIME handling package" href="email.html" />
    <link rel="next" title="18.1.2. email.parser: Parsing email messages" href="email.parser.html" />
    <link rel="prev" title="18.1. email — An email and MIME handling package" href="email.html" />
    <link rel="shortcut icon" type="image/png" href="../_static/py.png" />
    <script type="text/javascript" src="../_static/copybutton.js"></script>
    
 

  </head>
  <body>
    <div class="related">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="../genindex.html" title="General Index"
             accesskey="I">index</a></li>
        <li class="right" >
          <a href="../py-modindex.html" title="Python Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="email.parser.html" title="18.1.2. email.parser: Parsing email messages"
             accesskey="N">next</a> |</li>
        <li class="right" >
          <a href="email.html" title="18.1. email — An email and MIME handling package"
             accesskey="P">previous</a> |</li>
        <li><img src="../_static/py.png" alt=""
                 style="vertical-align: middle; margin-top: -1px"/></li>
        <li><a href="http://www.python.org/">Python</a> &raquo;</li>
        <li>
          <a href="../index.html">Python 2.7.5 documentation</a> &raquo;
        </li>

          <li><a href="index.html" >The Python Standard Library</a> &raquo;</li>
          <li><a href="netdata.html" >18. Internet Data Handling</a> &raquo;</li>
          <li><a href="email.html" accesskey="U">18.1. <tt class="docutils literal"><span class="pre">email</span></tt> &#8212; An email and MIME handling package</a> &raquo;</li> 
      </ul>
    </div>  

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body">
            
  <div class="section" id="module-email.message">
<span id="email-message-representing-an-email-message"></span><h1>18.1.1. <a class="reference internal" href="#module-email.message" title="email.message: The base class representing email messages."><tt class="xref py py-mod docutils literal"><span class="pre">email.message</span></tt></a>: Representing an email message<a class="headerlink" href="#module-email.message" title="Permalink to this headline">¶</a></h1>
<p>The central class in the <a class="reference internal" href="email.html#module-email" title="email: Package supporting the parsing, manipulating, and generating email messages, including MIME documents."><tt class="xref py py-mod docutils literal"><span class="pre">email</span></tt></a> package is the <a class="reference internal" href="#email.message.Message" title="email.message.Message"><tt class="xref py py-class docutils literal"><span class="pre">Message</span></tt></a> class,
imported from the <a class="reference internal" href="#module-email.message" title="email.message: The base class representing email messages."><tt class="xref py py-mod docutils literal"><span class="pre">email.message</span></tt></a> module.  It is the base class for the
<a class="reference internal" href="email.html#module-email" title="email: Package supporting the parsing, manipulating, and generating email messages, including MIME documents."><tt class="xref py py-mod docutils literal"><span class="pre">email</span></tt></a> object model.  <a class="reference internal" href="#email.message.Message" title="email.message.Message"><tt class="xref py py-class docutils literal"><span class="pre">Message</span></tt></a> provides the core functionality for
setting and querying header fields, and for accessing message bodies.</p>
<p>Conceptually, a <a class="reference internal" href="#email.message.Message" title="email.message.Message"><tt class="xref py py-class docutils literal"><span class="pre">Message</span></tt></a> object consists of <em>headers</em> and <em>payloads</em>.
Headers are <span class="target" id="index-0"></span><a class="rfc reference external" href="http://tools.ietf.org/html/rfc2822.html"><strong>RFC 2822</strong></a> style field names and values where the field name and
value are separated by a colon.  The colon is not part of either the field name
or the field value.</p>
<p>Headers are stored and returned in case-preserving form but are matched
case-insensitively.  There may also be a single envelope header, also known as
the <em>Unix-From</em> header or the <tt class="docutils literal"><span class="pre">From_</span></tt> header.  The payload is either a string
in the case of simple message objects or a list of <a class="reference internal" href="#email.message.Message" title="email.message.Message"><tt class="xref py py-class docutils literal"><span class="pre">Message</span></tt></a> objects for
MIME container documents (e.g. <em class="mimetype">multipart/*</em> and
<em class="mimetype">message/rfc822</em>).</p>
<p><a class="reference internal" href="#email.message.Message" title="email.message.Message"><tt class="xref py py-class docutils literal"><span class="pre">Message</span></tt></a> objects provide a mapping style interface for accessing the
message headers, and an explicit interface for accessing both the headers and
the payload.  It provides convenience methods for generating a flat text
representation of the message object tree, for accessing commonly used header
parameters, and for recursively walking over the object tree.</p>
<p>Here are the methods of the <a class="reference internal" href="#email.message.Message" title="email.message.Message"><tt class="xref py py-class docutils literal"><span class="pre">Message</span></tt></a> class:</p>
<dl class="class">
<dt id="email.message.Message">
<em class="property">class </em><tt class="descclassname">email.message.</tt><tt class="descname">Message</tt><a class="headerlink" href="#email.message.Message" title="Permalink to this definition">¶</a></dt>
<dd><p>The constructor takes no arguments.</p>
<dl class="method">
<dt id="email.message.Message.as_string">
<tt class="descname">as_string</tt><big>(</big><span class="optional">[</span><em>unixfrom</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#email.message.Message.as_string" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the entire message flattened as a string.  When optional <em>unixfrom</em>
is <tt class="docutils literal"><span class="pre">True</span></tt>, the envelope header is included in the returned string.
<em>unixfrom</em> defaults to <tt class="docutils literal"><span class="pre">False</span></tt>.  Flattening the message may trigger
changes to the <a class="reference internal" href="#email.message.Message" title="email.message.Message"><tt class="xref py py-class docutils literal"><span class="pre">Message</span></tt></a> if defaults need to be filled in to
complete the transformation to a string (for example, MIME boundaries may
be generated or modified).</p>
<p>Note that this method is provided as a convenience and may not always
format the message the way you want.  For example, by default it mangles
lines that begin with <tt class="docutils literal"><span class="pre">From</span></tt>.  For more flexibility, instantiate a
<a class="reference internal" href="email.generator.html#email.generator.Generator" title="email.generator.Generator"><tt class="xref py py-class docutils literal"><span class="pre">Generator</span></tt></a> instance and use its <tt class="xref py py-meth docutils literal"><span class="pre">flatten()</span></tt>
method directly.  For example:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="kn">from</span> <span class="nn">cStringIO</span> <span class="kn">import</span> <span class="n">StringIO</span>
<span class="kn">from</span> <span class="nn">email.generator</span> <span class="kn">import</span> <span class="n">Generator</span>
<span class="n">fp</span> <span class="o">=</span> <span class="n">StringIO</span><span class="p">()</span>
<span class="n">g</span> <span class="o">=</span> <span class="n">Generator</span><span class="p">(</span><span class="n">fp</span><span class="p">,</span> <span class="n">mangle_from_</span><span class="o">=</span><span class="bp">False</span><span class="p">,</span> <span class="n">maxheaderlen</span><span class="o">=</span><span class="mi">60</span><span class="p">)</span>
<span class="n">g</span><span class="o">.</span><span class="n">flatten</span><span class="p">(</span><span class="n">msg</span><span class="p">)</span>
<span class="n">text</span> <span class="o">=</span> <span class="n">fp</span><span class="o">.</span><span class="n">getvalue</span><span class="p">()</span>
</pre></div>
</div>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.__str__">
<tt class="descname">__str__</tt><big>(</big><big>)</big><a class="headerlink" href="#email.message.Message.__str__" title="Permalink to this definition">¶</a></dt>
<dd><p>Equivalent to <tt class="docutils literal"><span class="pre">as_string(unixfrom=True)</span></tt>.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.is_multipart">
<tt class="descname">is_multipart</tt><big>(</big><big>)</big><a class="headerlink" href="#email.message.Message.is_multipart" title="Permalink to this definition">¶</a></dt>
<dd><p>Return <tt class="docutils literal"><span class="pre">True</span></tt> if the message&#8217;s payload is a list of sub-<a class="reference internal" href="#email.message.Message" title="email.message.Message"><tt class="xref py py-class docutils literal"><span class="pre">Message</span></tt></a> objects, otherwise return <tt class="docutils literal"><span class="pre">False</span></tt>.  When
<a class="reference internal" href="#email.message.Message.is_multipart" title="email.message.Message.is_multipart"><tt class="xref py py-meth docutils literal"><span class="pre">is_multipart()</span></tt></a> returns False, the payload should be a string object.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.set_unixfrom">
<tt class="descname">set_unixfrom</tt><big>(</big><em>unixfrom</em><big>)</big><a class="headerlink" href="#email.message.Message.set_unixfrom" title="Permalink to this definition">¶</a></dt>
<dd><p>Set the message&#8217;s envelope header to <em>unixfrom</em>, which should be a string.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.get_unixfrom">
<tt class="descname">get_unixfrom</tt><big>(</big><big>)</big><a class="headerlink" href="#email.message.Message.get_unixfrom" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the message&#8217;s envelope header.  Defaults to <tt class="docutils literal"><span class="pre">None</span></tt> if the
envelope header was never set.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.attach">
<tt class="descname">attach</tt><big>(</big><em>payload</em><big>)</big><a class="headerlink" href="#email.message.Message.attach" title="Permalink to this definition">¶</a></dt>
<dd><p>Add the given <em>payload</em> to the current payload, which must be <tt class="docutils literal"><span class="pre">None</span></tt> or
a list of <a class="reference internal" href="#email.message.Message" title="email.message.Message"><tt class="xref py py-class docutils literal"><span class="pre">Message</span></tt></a> objects before the call. After the call, the
payload will always be a list of <a class="reference internal" href="#email.message.Message" title="email.message.Message"><tt class="xref py py-class docutils literal"><span class="pre">Message</span></tt></a> objects.  If you want to
set the payload to a scalar object (e.g. a string), use
<a class="reference internal" href="#email.message.Message.set_payload" title="email.message.Message.set_payload"><tt class="xref py py-meth docutils literal"><span class="pre">set_payload()</span></tt></a> instead.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.get_payload">
<tt class="descname">get_payload</tt><big>(</big><span class="optional">[</span><em>i</em><span class="optional">[</span>, <em>decode</em><span class="optional">]</span><span class="optional">]</span><big>)</big><a class="headerlink" href="#email.message.Message.get_payload" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the current payload, which will be a list of
<a class="reference internal" href="#email.message.Message" title="email.message.Message"><tt class="xref py py-class docutils literal"><span class="pre">Message</span></tt></a> objects when <a class="reference internal" href="#email.message.Message.is_multipart" title="email.message.Message.is_multipart"><tt class="xref py py-meth docutils literal"><span class="pre">is_multipart()</span></tt></a> is <tt class="docutils literal"><span class="pre">True</span></tt>, or a
string when <a class="reference internal" href="#email.message.Message.is_multipart" title="email.message.Message.is_multipart"><tt class="xref py py-meth docutils literal"><span class="pre">is_multipart()</span></tt></a> is <tt class="docutils literal"><span class="pre">False</span></tt>.  If the payload is a list
and you mutate the list object, you modify the message&#8217;s payload in place.</p>
<p>With optional argument <em>i</em>, <a class="reference internal" href="#email.message.Message.get_payload" title="email.message.Message.get_payload"><tt class="xref py py-meth docutils literal"><span class="pre">get_payload()</span></tt></a> will return the <em>i</em>-th
element of the payload, counting from zero, if <a class="reference internal" href="#email.message.Message.is_multipart" title="email.message.Message.is_multipart"><tt class="xref py py-meth docutils literal"><span class="pre">is_multipart()</span></tt></a> is
<tt class="docutils literal"><span class="pre">True</span></tt>.  An <a class="reference internal" href="exceptions.html#exceptions.IndexError" title="exceptions.IndexError"><tt class="xref py py-exc docutils literal"><span class="pre">IndexError</span></tt></a> will be raised if <em>i</em> is less than 0 or
greater than or equal to the number of items in the payload.  If the
payload is a string (i.e.  <a class="reference internal" href="#email.message.Message.is_multipart" title="email.message.Message.is_multipart"><tt class="xref py py-meth docutils literal"><span class="pre">is_multipart()</span></tt></a> is <tt class="docutils literal"><span class="pre">False</span></tt>) and <em>i</em> is
given, a <a class="reference internal" href="exceptions.html#exceptions.TypeError" title="exceptions.TypeError"><tt class="xref py py-exc docutils literal"><span class="pre">TypeError</span></tt></a> is raised.</p>
<p>Optional <em>decode</em> is a flag indicating whether the payload should be
decoded or not, according to the <em class="mailheader">Content-Transfer-Encoding</em>
header. When <tt class="docutils literal"><span class="pre">True</span></tt> and the message is not a multipart, the payload will
be decoded if this header&#8217;s value is <tt class="docutils literal"><span class="pre">quoted-printable</span></tt> or <tt class="docutils literal"><span class="pre">base64</span></tt>.
If some other encoding is used, or <em class="mailheader">Content-Transfer-Encoding</em>
header is missing, or if the payload has bogus base64 data, the payload is
returned as-is (undecoded).  If the message is a multipart and the
<em>decode</em> flag is <tt class="docutils literal"><span class="pre">True</span></tt>, then <tt class="docutils literal"><span class="pre">None</span></tt> is returned.  The default for
<em>decode</em> is <tt class="docutils literal"><span class="pre">False</span></tt>.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.set_payload">
<tt class="descname">set_payload</tt><big>(</big><em>payload</em><span class="optional">[</span>, <em>charset</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#email.message.Message.set_payload" title="Permalink to this definition">¶</a></dt>
<dd><p>Set the entire message object&#8217;s payload to <em>payload</em>.  It is the client&#8217;s
responsibility to ensure the payload invariants.  Optional <em>charset</em> sets
the message&#8217;s default character set; see <a class="reference internal" href="#email.message.Message.set_charset" title="email.message.Message.set_charset"><tt class="xref py py-meth docutils literal"><span class="pre">set_charset()</span></tt></a> for details.</p>
<p class="versionchanged">
<span class="versionmodified">Changed in version 2.2.2: </span><em>charset</em> argument added.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.set_charset">
<tt class="descname">set_charset</tt><big>(</big><em>charset</em><big>)</big><a class="headerlink" href="#email.message.Message.set_charset" title="Permalink to this definition">¶</a></dt>
<dd><p>Set the character set of the payload to <em>charset</em>, which can either be a
<a class="reference internal" href="email.charset.html#email.charset.Charset" title="email.charset.Charset"><tt class="xref py py-class docutils literal"><span class="pre">Charset</span></tt></a> instance (see <a class="reference internal" href="email.charset.html#module-email.charset" title="email.charset: Character Sets"><tt class="xref py py-mod docutils literal"><span class="pre">email.charset</span></tt></a>), a
string naming a character set, or <tt class="docutils literal"><span class="pre">None</span></tt>.  If it is a string, it will
be converted to a <a class="reference internal" href="email.charset.html#email.charset.Charset" title="email.charset.Charset"><tt class="xref py py-class docutils literal"><span class="pre">Charset</span></tt></a> instance.  If <em>charset</em>
is <tt class="docutils literal"><span class="pre">None</span></tt>, the <tt class="docutils literal"><span class="pre">charset</span></tt> parameter will be removed from the
<em class="mailheader">Content-Type</em> header (the message will not be otherwise
modified).  Anything else will generate a <a class="reference internal" href="exceptions.html#exceptions.TypeError" title="exceptions.TypeError"><tt class="xref py py-exc docutils literal"><span class="pre">TypeError</span></tt></a>.</p>
<p>If there is no existing <em class="mailheader">MIME-Version</em> header one will be
added.  If there is no existing <em class="mailheader">Content-Type</em> header, one
will be added with a value of <em class="mimetype">text/plain</em>.  Whether the
<em class="mailheader">Content-Type</em> header already exists or not, its <tt class="docutils literal"><span class="pre">charset</span></tt>
parameter will be set to <em>charset.output_charset</em>.   If
<em>charset.input_charset</em> and <em>charset.output_charset</em> differ, the payload
will be re-encoded to the <em>output_charset</em>.  If there is no existing
<em class="mailheader">Content-Transfer-Encoding</em> header, then the payload will be
transfer-encoded, if needed, using the specified
<a class="reference internal" href="email.charset.html#email.charset.Charset" title="email.charset.Charset"><tt class="xref py py-class docutils literal"><span class="pre">Charset</span></tt></a>, and a header with the appropriate value
will be added.  If a <em class="mailheader">Content-Transfer-Encoding</em> header
already exists, the payload is assumed to already be correctly encoded
using that <em class="mailheader">Content-Transfer-Encoding</em> and is not modified.</p>
<p>The message will be assumed to be of type <em class="mimetype">text/*</em>, with the
payload either in unicode or encoded with <em>charset.input_charset</em>.
It will be encoded or converted to <em>charset.output_charset</em>
and transfer encoded properly, if needed, when generating the plain text
representation of the message.  MIME headers (<em class="mailheader">MIME-Version</em>,
<em class="mailheader">Content-Type</em>, <em class="mailheader">Content-Transfer-Encoding</em>) will
be added as needed.</p>
<p class="versionadded">
<span class="versionmodified">New in version 2.2.2.</span></p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.get_charset">
<tt class="descname">get_charset</tt><big>(</big><big>)</big><a class="headerlink" href="#email.message.Message.get_charset" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the <a class="reference internal" href="email.charset.html#email.charset.Charset" title="email.charset.Charset"><tt class="xref py py-class docutils literal"><span class="pre">Charset</span></tt></a> instance associated with the
message&#8217;s payload.</p>
<p class="versionadded">
<span class="versionmodified">New in version 2.2.2.</span></p>
</dd></dl>

<p>The following methods implement a mapping-like interface for accessing the
message&#8217;s <span class="target" id="index-1"></span><a class="rfc reference external" href="http://tools.ietf.org/html/rfc2822.html"><strong>RFC 2822</strong></a> headers.  Note that there are some semantic differences
between these methods and a normal mapping (i.e. dictionary) interface.  For
example, in a dictionary there are no duplicate keys, but here there may be
duplicate message headers.  Also, in dictionaries there is no guaranteed
order to the keys returned by <a class="reference internal" href="#email.message.Message.keys" title="email.message.Message.keys"><tt class="xref py py-meth docutils literal"><span class="pre">keys()</span></tt></a>, but in a <a class="reference internal" href="#email.message.Message" title="email.message.Message"><tt class="xref py py-class docutils literal"><span class="pre">Message</span></tt></a> object,
headers are always returned in the order they appeared in the original
message, or were added to the message later.  Any header deleted and then
re-added are always appended to the end of the header list.</p>
<p>These semantic differences are intentional and are biased toward maximal
convenience.</p>
<p>Note that in all cases, any envelope header present in the message is not
included in the mapping interface.</p>
<dl class="method">
<dt id="email.message.Message.__len__">
<tt class="descname">__len__</tt><big>(</big><big>)</big><a class="headerlink" href="#email.message.Message.__len__" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the total number of headers, including duplicates.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.__contains__">
<tt class="descname">__contains__</tt><big>(</big><em>name</em><big>)</big><a class="headerlink" href="#email.message.Message.__contains__" title="Permalink to this definition">¶</a></dt>
<dd><p>Return true if the message object has a field named <em>name</em>. Matching is
done case-insensitively and <em>name</em> should not include the trailing colon.
Used for the <tt class="docutils literal"><span class="pre">in</span></tt> operator, e.g.:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">if</span> <span class="s">&#39;message-id&#39;</span> <span class="ow">in</span> <span class="n">myMessage</span><span class="p">:</span>
    <span class="k">print</span> <span class="s">&#39;Message-ID:&#39;</span><span class="p">,</span> <span class="n">myMessage</span><span class="p">[</span><span class="s">&#39;message-id&#39;</span><span class="p">]</span>
</pre></div>
</div>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.__getitem__">
<tt class="descname">__getitem__</tt><big>(</big><em>name</em><big>)</big><a class="headerlink" href="#email.message.Message.__getitem__" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the value of the named header field.  <em>name</em> should not include the
colon field separator.  If the header is missing, <tt class="docutils literal"><span class="pre">None</span></tt> is returned; a
<a class="reference internal" href="exceptions.html#exceptions.KeyError" title="exceptions.KeyError"><tt class="xref py py-exc docutils literal"><span class="pre">KeyError</span></tt></a> is never raised.</p>
<p>Note that if the named field appears more than once in the message&#8217;s
headers, exactly which of those field values will be returned is
undefined.  Use the <a class="reference internal" href="#email.message.Message.get_all" title="email.message.Message.get_all"><tt class="xref py py-meth docutils literal"><span class="pre">get_all()</span></tt></a> method to get the values of all the
extant named headers.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.__setitem__">
<tt class="descname">__setitem__</tt><big>(</big><em>name</em>, <em>val</em><big>)</big><a class="headerlink" href="#email.message.Message.__setitem__" title="Permalink to this definition">¶</a></dt>
<dd><p>Add a header to the message with field name <em>name</em> and value <em>val</em>.  The
field is appended to the end of the message&#8217;s existing fields.</p>
<p>Note that this does <em>not</em> overwrite or delete any existing header with the same
name.  If you want to ensure that the new header is the only one present in the
message with field name <em>name</em>, delete the field first, e.g.:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">del</span> <span class="n">msg</span><span class="p">[</span><span class="s">&#39;subject&#39;</span><span class="p">]</span>
<span class="n">msg</span><span class="p">[</span><span class="s">&#39;subject&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="s">&#39;Python roolz!&#39;</span>
</pre></div>
</div>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.__delitem__">
<tt class="descname">__delitem__</tt><big>(</big><em>name</em><big>)</big><a class="headerlink" href="#email.message.Message.__delitem__" title="Permalink to this definition">¶</a></dt>
<dd><p>Delete all occurrences of the field with name <em>name</em> from the message&#8217;s
headers.  No exception is raised if the named field isn&#8217;t present in the headers.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.has_key">
<tt class="descname">has_key</tt><big>(</big><em>name</em><big>)</big><a class="headerlink" href="#email.message.Message.has_key" title="Permalink to this definition">¶</a></dt>
<dd><p>Return true if the message contains a header field named <em>name</em>, otherwise
return false.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.keys">
<tt class="descname">keys</tt><big>(</big><big>)</big><a class="headerlink" href="#email.message.Message.keys" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a list of all the message&#8217;s header field names.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.values">
<tt class="descname">values</tt><big>(</big><big>)</big><a class="headerlink" href="#email.message.Message.values" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a list of all the message&#8217;s field values.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.items">
<tt class="descname">items</tt><big>(</big><big>)</big><a class="headerlink" href="#email.message.Message.items" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a list of 2-tuples containing all the message&#8217;s field headers and
values.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.get">
<tt class="descname">get</tt><big>(</big><em>name</em><span class="optional">[</span>, <em>failobj</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#email.message.Message.get" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the value of the named header field.  This is identical to
<a class="reference internal" href="#email.message.Message.__getitem__" title="email.message.Message.__getitem__"><tt class="xref py py-meth docutils literal"><span class="pre">__getitem__()</span></tt></a> except that optional <em>failobj</em> is returned if the
named header is missing (defaults to <tt class="docutils literal"><span class="pre">None</span></tt>).</p>
</dd></dl>

<p>Here are some additional useful methods:</p>
<dl class="method">
<dt id="email.message.Message.get_all">
<tt class="descname">get_all</tt><big>(</big><em>name</em><span class="optional">[</span>, <em>failobj</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#email.message.Message.get_all" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a list of all the values for the field named <em>name</em>. If there are
no such named headers in the message, <em>failobj</em> is returned (defaults to
<tt class="docutils literal"><span class="pre">None</span></tt>).</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.add_header">
<tt class="descname">add_header</tt><big>(</big><em>_name</em>, <em>_value</em>, <em>**_params</em><big>)</big><a class="headerlink" href="#email.message.Message.add_header" title="Permalink to this definition">¶</a></dt>
<dd><p>Extended header setting.  This method is similar to <a class="reference internal" href="#email.message.Message.__setitem__" title="email.message.Message.__setitem__"><tt class="xref py py-meth docutils literal"><span class="pre">__setitem__()</span></tt></a>
except that additional header parameters can be provided as keyword
arguments.  <em>_name</em> is the header field to add and <em>_value</em> is the
<em>primary</em> value for the header.</p>
<p>For each item in the keyword argument dictionary <em>_params</em>, the key is
taken as the parameter name, with underscores converted to dashes (since
dashes are illegal in Python identifiers).  Normally, the parameter will
be added as <tt class="docutils literal"><span class="pre">key=&quot;value&quot;</span></tt> unless the value is <tt class="docutils literal"><span class="pre">None</span></tt>, in which case
only the key will be added.  If the value contains non-ASCII characters,
it must be specified as a three tuple in the format
<tt class="docutils literal"><span class="pre">(CHARSET,</span> <span class="pre">LANGUAGE,</span> <span class="pre">VALUE)</span></tt>, where <tt class="docutils literal"><span class="pre">CHARSET</span></tt> is a string naming the
charset to be used to encode the value, <tt class="docutils literal"><span class="pre">LANGUAGE</span></tt> can usually be set
to <tt class="docutils literal"><span class="pre">None</span></tt> or the empty string (see <span class="target" id="index-2"></span><a class="rfc reference external" href="http://tools.ietf.org/html/rfc2231.html"><strong>RFC 2231</strong></a> for other possibilities),
and <tt class="docutils literal"><span class="pre">VALUE</span></tt> is the string value containing non-ASCII code points.</p>
<p>Here&#8217;s an example:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">msg</span><span class="o">.</span><span class="n">add_header</span><span class="p">(</span><span class="s">&#39;Content-Disposition&#39;</span><span class="p">,</span> <span class="s">&#39;attachment&#39;</span><span class="p">,</span> <span class="n">filename</span><span class="o">=</span><span class="s">&#39;bud.gif&#39;</span><span class="p">)</span>
</pre></div>
</div>
<p>This will add a header that looks like</p>
<div class="highlight-python"><pre>Content-Disposition: attachment; filename="bud.gif"</pre>
</div>
<p>An example with non-ASCII characters:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">msg</span><span class="o">.</span><span class="n">add_header</span><span class="p">(</span><span class="s">&#39;Content-Disposition&#39;</span><span class="p">,</span> <span class="s">&#39;attachment&#39;</span><span class="p">,</span>
               <span class="n">filename</span><span class="o">=</span><span class="p">(</span><span class="s">&#39;iso-8859-1&#39;</span><span class="p">,</span> <span class="s">&#39;&#39;</span><span class="p">,</span> <span class="s">&#39;Fußballer.ppt&#39;</span><span class="p">))</span>
</pre></div>
</div>
<p>Which produces</p>
<div class="highlight-python"><pre>Content-Disposition: attachment; filename*="iso-8859-1''Fu%DFballer.ppt"</pre>
</div>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.replace_header">
<tt class="descname">replace_header</tt><big>(</big><em>_name</em>, <em>_value</em><big>)</big><a class="headerlink" href="#email.message.Message.replace_header" title="Permalink to this definition">¶</a></dt>
<dd><p>Replace a header.  Replace the first header found in the message that
matches <em>_name</em>, retaining header order and field name case.  If no
matching header was found, a <a class="reference internal" href="exceptions.html#exceptions.KeyError" title="exceptions.KeyError"><tt class="xref py py-exc docutils literal"><span class="pre">KeyError</span></tt></a> is raised.</p>
<p class="versionadded">
<span class="versionmodified">New in version 2.2.2.</span></p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.get_content_type">
<tt class="descname">get_content_type</tt><big>(</big><big>)</big><a class="headerlink" href="#email.message.Message.get_content_type" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the message&#8217;s content type.  The returned string is coerced to
lower case of the form <em class="mimetype">maintype/subtype</em>.  If there was no
<em class="mailheader">Content-Type</em> header in the message the default type as given
by <a class="reference internal" href="#email.message.Message.get_default_type" title="email.message.Message.get_default_type"><tt class="xref py py-meth docutils literal"><span class="pre">get_default_type()</span></tt></a> will be returned.  Since according to
<span class="target" id="index-3"></span><a class="rfc reference external" href="http://tools.ietf.org/html/rfc2045.html"><strong>RFC 2045</strong></a>, messages always have a default type, <a class="reference internal" href="#email.message.Message.get_content_type" title="email.message.Message.get_content_type"><tt class="xref py py-meth docutils literal"><span class="pre">get_content_type()</span></tt></a>
will always return a value.</p>
<p><span class="target" id="index-4"></span><a class="rfc reference external" href="http://tools.ietf.org/html/rfc2045.html"><strong>RFC 2045</strong></a> defines a message&#8217;s default type to be <em class="mimetype">text/plain</em>
unless it appears inside a <em class="mimetype">multipart/digest</em> container, in
which case it would be <em class="mimetype">message/rfc822</em>.  If the
<em class="mailheader">Content-Type</em> header has an invalid type specification,
<span class="target" id="index-5"></span><a class="rfc reference external" href="http://tools.ietf.org/html/rfc2045.html"><strong>RFC 2045</strong></a> mandates that the default type be <em class="mimetype">text/plain</em>.</p>
<p class="versionadded">
<span class="versionmodified">New in version 2.2.2.</span></p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.get_content_maintype">
<tt class="descname">get_content_maintype</tt><big>(</big><big>)</big><a class="headerlink" href="#email.message.Message.get_content_maintype" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the message&#8217;s main content type.  This is the <em class="mimetype">maintype</em>
part of the string returned by <a class="reference internal" href="#email.message.Message.get_content_type" title="email.message.Message.get_content_type"><tt class="xref py py-meth docutils literal"><span class="pre">get_content_type()</span></tt></a>.</p>
<p class="versionadded">
<span class="versionmodified">New in version 2.2.2.</span></p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.get_content_subtype">
<tt class="descname">get_content_subtype</tt><big>(</big><big>)</big><a class="headerlink" href="#email.message.Message.get_content_subtype" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the message&#8217;s sub-content type.  This is the <em class="mimetype">subtype</em>
part of the string returned by <a class="reference internal" href="#email.message.Message.get_content_type" title="email.message.Message.get_content_type"><tt class="xref py py-meth docutils literal"><span class="pre">get_content_type()</span></tt></a>.</p>
<p class="versionadded">
<span class="versionmodified">New in version 2.2.2.</span></p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.get_default_type">
<tt class="descname">get_default_type</tt><big>(</big><big>)</big><a class="headerlink" href="#email.message.Message.get_default_type" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the default content type.  Most messages have a default content
type of <em class="mimetype">text/plain</em>, except for messages that are subparts of
<em class="mimetype">multipart/digest</em> containers.  Such subparts have a default
content type of <em class="mimetype">message/rfc822</em>.</p>
<p class="versionadded">
<span class="versionmodified">New in version 2.2.2.</span></p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.set_default_type">
<tt class="descname">set_default_type</tt><big>(</big><em>ctype</em><big>)</big><a class="headerlink" href="#email.message.Message.set_default_type" title="Permalink to this definition">¶</a></dt>
<dd><p>Set the default content type.  <em>ctype</em> should either be
<em class="mimetype">text/plain</em> or <em class="mimetype">message/rfc822</em>, although this is not
enforced.  The default content type is not stored in the
<em class="mailheader">Content-Type</em> header.</p>
<p class="versionadded">
<span class="versionmodified">New in version 2.2.2.</span></p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.get_params">
<tt class="descname">get_params</tt><big>(</big><span class="optional">[</span><em>failobj</em><span class="optional">[</span>, <em>header</em><span class="optional">[</span>, <em>unquote</em><span class="optional">]</span><span class="optional">]</span><span class="optional">]</span><big>)</big><a class="headerlink" href="#email.message.Message.get_params" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the message&#8217;s <em class="mailheader">Content-Type</em> parameters, as a list.
The elements of the returned list are 2-tuples of key/value pairs, as
split on the <tt class="docutils literal"><span class="pre">'='</span></tt> sign.  The left hand side of the <tt class="docutils literal"><span class="pre">'='</span></tt> is the key,
while the right hand side is the value.  If there is no <tt class="docutils literal"><span class="pre">'='</span></tt> sign in
the parameter the value is the empty string, otherwise the value is as
described in <a class="reference internal" href="#email.message.Message.get_param" title="email.message.Message.get_param"><tt class="xref py py-meth docutils literal"><span class="pre">get_param()</span></tt></a> and is unquoted if optional <em>unquote</em> is
<tt class="docutils literal"><span class="pre">True</span></tt> (the default).</p>
<p>Optional <em>failobj</em> is the object to return if there is no
<em class="mailheader">Content-Type</em> header.  Optional <em>header</em> is the header to
search instead of <em class="mailheader">Content-Type</em>.</p>
<p class="versionchanged">
<span class="versionmodified">Changed in version 2.2.2: </span><em>unquote</em> argument added.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.get_param">
<tt class="descname">get_param</tt><big>(</big><em>param</em><span class="optional">[</span>, <em>failobj</em><span class="optional">[</span>, <em>header</em><span class="optional">[</span>, <em>unquote</em><span class="optional">]</span><span class="optional">]</span><span class="optional">]</span><big>)</big><a class="headerlink" href="#email.message.Message.get_param" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the value of the <em class="mailheader">Content-Type</em> header&#8217;s parameter
<em>param</em> as a string.  If the message has no <em class="mailheader">Content-Type</em>
header or if there is no such parameter, then <em>failobj</em> is returned
(defaults to <tt class="docutils literal"><span class="pre">None</span></tt>).</p>
<p>Optional <em>header</em> if given, specifies the message header to use instead of
<em class="mailheader">Content-Type</em>.</p>
<p>Parameter keys are always compared case insensitively.  The return value
can either be a string, or a 3-tuple if the parameter was <span class="target" id="index-6"></span><a class="rfc reference external" href="http://tools.ietf.org/html/rfc2231.html"><strong>RFC 2231</strong></a>
encoded.  When it&#8217;s a 3-tuple, the elements of the value are of the form
<tt class="docutils literal"><span class="pre">(CHARSET,</span> <span class="pre">LANGUAGE,</span> <span class="pre">VALUE)</span></tt>.  Note that both <tt class="docutils literal"><span class="pre">CHARSET</span></tt> and
<tt class="docutils literal"><span class="pre">LANGUAGE</span></tt> can be <tt class="docutils literal"><span class="pre">None</span></tt>, in which case you should consider <tt class="docutils literal"><span class="pre">VALUE</span></tt>
to be encoded in the <tt class="docutils literal"><span class="pre">us-ascii</span></tt> charset.  You can usually ignore
<tt class="docutils literal"><span class="pre">LANGUAGE</span></tt>.</p>
<p>If your application doesn&#8217;t care whether the parameter was encoded as in
<span class="target" id="index-7"></span><a class="rfc reference external" href="http://tools.ietf.org/html/rfc2231.html"><strong>RFC 2231</strong></a>, you can collapse the parameter value by calling
<a class="reference internal" href="email.util.html#email.utils.collapse_rfc2231_value" title="email.utils.collapse_rfc2231_value"><tt class="xref py py-func docutils literal"><span class="pre">email.utils.collapse_rfc2231_value()</span></tt></a>, passing in the return value
from <a class="reference internal" href="#email.message.Message.get_param" title="email.message.Message.get_param"><tt class="xref py py-meth docutils literal"><span class="pre">get_param()</span></tt></a>.  This will return a suitably decoded Unicode
string when the value is a tuple, or the original string unquoted if it
isn&#8217;t.  For example:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">rawparam</span> <span class="o">=</span> <span class="n">msg</span><span class="o">.</span><span class="n">get_param</span><span class="p">(</span><span class="s">&#39;foo&#39;</span><span class="p">)</span>
<span class="n">param</span> <span class="o">=</span> <span class="n">email</span><span class="o">.</span><span class="n">utils</span><span class="o">.</span><span class="n">collapse_rfc2231_value</span><span class="p">(</span><span class="n">rawparam</span><span class="p">)</span>
</pre></div>
</div>
<p>In any case, the parameter value (either the returned string, or the
<tt class="docutils literal"><span class="pre">VALUE</span></tt> item in the 3-tuple) is always unquoted, unless <em>unquote</em> is set
to <tt class="docutils literal"><span class="pre">False</span></tt>.</p>
<p class="versionchanged">
<span class="versionmodified">Changed in version 2.2.2: </span><em>unquote</em> argument added, and 3-tuple return value possible.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.set_param">
<tt class="descname">set_param</tt><big>(</big><em>param</em>, <em>value</em><span class="optional">[</span>, <em>header</em><span class="optional">[</span>, <em>requote</em><span class="optional">[</span>, <em>charset</em><span class="optional">[</span>, <em>language</em><span class="optional">]</span><span class="optional">]</span><span class="optional">]</span><span class="optional">]</span><big>)</big><a class="headerlink" href="#email.message.Message.set_param" title="Permalink to this definition">¶</a></dt>
<dd><p>Set a parameter in the <em class="mailheader">Content-Type</em> header.  If the
parameter already exists in the header, its value will be replaced with
<em>value</em>.  If the <em class="mailheader">Content-Type</em> header as not yet been defined
for this message, it will be set to <em class="mimetype">text/plain</em> and the new
parameter value will be appended as per <span class="target" id="index-8"></span><a class="rfc reference external" href="http://tools.ietf.org/html/rfc2045.html"><strong>RFC 2045</strong></a>.</p>
<p>Optional <em>header</em> specifies an alternative header to
<em class="mailheader">Content-Type</em>, and all parameters will be quoted as necessary
unless optional <em>requote</em> is <tt class="docutils literal"><span class="pre">False</span></tt> (the default is <tt class="docutils literal"><span class="pre">True</span></tt>).</p>
<p>If optional <em>charset</em> is specified, the parameter will be encoded
according to <span class="target" id="index-9"></span><a class="rfc reference external" href="http://tools.ietf.org/html/rfc2231.html"><strong>RFC 2231</strong></a>. Optional <em>language</em> specifies the RFC 2231
language, defaulting to the empty string.  Both <em>charset</em> and <em>language</em>
should be strings.</p>
<p class="versionadded">
<span class="versionmodified">New in version 2.2.2.</span></p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.del_param">
<tt class="descname">del_param</tt><big>(</big><em>param</em><span class="optional">[</span>, <em>header</em><span class="optional">[</span>, <em>requote</em><span class="optional">]</span><span class="optional">]</span><big>)</big><a class="headerlink" href="#email.message.Message.del_param" title="Permalink to this definition">¶</a></dt>
<dd><p>Remove the given parameter completely from the <em class="mailheader">Content-Type</em>
header.  The header will be re-written in place without the parameter or
its value.  All values will be quoted as necessary unless <em>requote</em> is
<tt class="docutils literal"><span class="pre">False</span></tt> (the default is <tt class="docutils literal"><span class="pre">True</span></tt>).  Optional <em>header</em> specifies an
alternative to <em class="mailheader">Content-Type</em>.</p>
<p class="versionadded">
<span class="versionmodified">New in version 2.2.2.</span></p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.set_type">
<tt class="descname">set_type</tt><big>(</big><em>type[, header][, requote]</em><big>)</big><a class="headerlink" href="#email.message.Message.set_type" title="Permalink to this definition">¶</a></dt>
<dd><p>Set the main type and subtype for the <em class="mailheader">Content-Type</em>
header. <em>type</em> must be a string in the form <em class="mimetype">maintype/subtype</em>,
otherwise a <a class="reference internal" href="exceptions.html#exceptions.ValueError" title="exceptions.ValueError"><tt class="xref py py-exc docutils literal"><span class="pre">ValueError</span></tt></a> is raised.</p>
<p>This method replaces the <em class="mailheader">Content-Type</em> header, keeping all
the parameters in place.  If <em>requote</em> is <tt class="docutils literal"><span class="pre">False</span></tt>, this leaves the
existing header&#8217;s quoting as is, otherwise the parameters will be quoted
(the default).</p>
<p>An alternative header can be specified in the <em>header</em> argument. When the
<em class="mailheader">Content-Type</em> header is set a <em class="mailheader">MIME-Version</em>
header is also added.</p>
<p class="versionadded">
<span class="versionmodified">New in version 2.2.2.</span></p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.get_filename">
<tt class="descname">get_filename</tt><big>(</big><span class="optional">[</span><em>failobj</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#email.message.Message.get_filename" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the value of the <tt class="docutils literal"><span class="pre">filename</span></tt> parameter of the
<em class="mailheader">Content-Disposition</em> header of the message.  If the header
does not have a <tt class="docutils literal"><span class="pre">filename</span></tt> parameter, this method falls back to looking
for the <tt class="docutils literal"><span class="pre">name</span></tt> parameter on the <em class="mailheader">Content-Type</em> header.  If
neither is found, or the header is missing, then <em>failobj</em> is returned.
The returned string will always be unquoted as per
<a class="reference internal" href="email.util.html#email.utils.unquote" title="email.utils.unquote"><tt class="xref py py-func docutils literal"><span class="pre">email.utils.unquote()</span></tt></a>.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.get_boundary">
<tt class="descname">get_boundary</tt><big>(</big><span class="optional">[</span><em>failobj</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#email.message.Message.get_boundary" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the value of the <tt class="docutils literal"><span class="pre">boundary</span></tt> parameter of the
<em class="mailheader">Content-Type</em> header of the message, or <em>failobj</em> if either
the header is missing, or has no <tt class="docutils literal"><span class="pre">boundary</span></tt> parameter.  The returned
string will always be unquoted as per <a class="reference internal" href="email.util.html#email.utils.unquote" title="email.utils.unquote"><tt class="xref py py-func docutils literal"><span class="pre">email.utils.unquote()</span></tt></a>.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.set_boundary">
<tt class="descname">set_boundary</tt><big>(</big><em>boundary</em><big>)</big><a class="headerlink" href="#email.message.Message.set_boundary" title="Permalink to this definition">¶</a></dt>
<dd><p>Set the <tt class="docutils literal"><span class="pre">boundary</span></tt> parameter of the <em class="mailheader">Content-Type</em> header to
<em>boundary</em>.  <a class="reference internal" href="#email.message.Message.set_boundary" title="email.message.Message.set_boundary"><tt class="xref py py-meth docutils literal"><span class="pre">set_boundary()</span></tt></a> will always quote <em>boundary</em> if
necessary.  A <tt class="xref py py-exc docutils literal"><span class="pre">HeaderParseError</span></tt> is raised if the message object has
no <em class="mailheader">Content-Type</em> header.</p>
<p>Note that using this method is subtly different than deleting the old
<em class="mailheader">Content-Type</em> header and adding a new one with the new
boundary via <a class="reference internal" href="#email.message.Message.add_header" title="email.message.Message.add_header"><tt class="xref py py-meth docutils literal"><span class="pre">add_header()</span></tt></a>, because <a class="reference internal" href="#email.message.Message.set_boundary" title="email.message.Message.set_boundary"><tt class="xref py py-meth docutils literal"><span class="pre">set_boundary()</span></tt></a> preserves
the order of the <em class="mailheader">Content-Type</em> header in the list of
headers. However, it does <em>not</em> preserve any continuation lines which may
have been present in the original <em class="mailheader">Content-Type</em> header.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.get_content_charset">
<tt class="descname">get_content_charset</tt><big>(</big><span class="optional">[</span><em>failobj</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#email.message.Message.get_content_charset" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the <tt class="docutils literal"><span class="pre">charset</span></tt> parameter of the <em class="mailheader">Content-Type</em> header,
coerced to lower case.  If there is no <em class="mailheader">Content-Type</em> header, or if
that header has no <tt class="docutils literal"><span class="pre">charset</span></tt> parameter, <em>failobj</em> is returned.</p>
<p>Note that this method differs from <a class="reference internal" href="#email.message.Message.get_charset" title="email.message.Message.get_charset"><tt class="xref py py-meth docutils literal"><span class="pre">get_charset()</span></tt></a> which returns the
<a class="reference internal" href="email.charset.html#email.charset.Charset" title="email.charset.Charset"><tt class="xref py py-class docutils literal"><span class="pre">Charset</span></tt></a> instance for the default encoding of the message body.</p>
<p class="versionadded">
<span class="versionmodified">New in version 2.2.2.</span></p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.get_charsets">
<tt class="descname">get_charsets</tt><big>(</big><span class="optional">[</span><em>failobj</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#email.message.Message.get_charsets" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a list containing the character set names in the message.  If the
message is a <em class="mimetype">multipart</em>, then the list will contain one element
for each subpart in the payload, otherwise, it will be a list of length 1.</p>
<p>Each item in the list will be a string which is the value of the
<tt class="docutils literal"><span class="pre">charset</span></tt> parameter in the <em class="mailheader">Content-Type</em> header for the
represented subpart.  However, if the subpart has no
<em class="mailheader">Content-Type</em> header, no <tt class="docutils literal"><span class="pre">charset</span></tt> parameter, or is not of
the <em class="mimetype">text</em> main MIME type, then that item in the returned list
will be <em>failobj</em>.</p>
</dd></dl>

<dl class="method">
<dt id="email.message.Message.walk">
<tt class="descname">walk</tt><big>(</big><big>)</big><a class="headerlink" href="#email.message.Message.walk" title="Permalink to this definition">¶</a></dt>
<dd><p>The <a class="reference internal" href="#email.message.Message.walk" title="email.message.Message.walk"><tt class="xref py py-meth docutils literal"><span class="pre">walk()</span></tt></a> method is an all-purpose generator which can be used to
iterate over all the parts and subparts of a message object tree, in
depth-first traversal order.  You will typically use <a class="reference internal" href="#email.message.Message.walk" title="email.message.Message.walk"><tt class="xref py py-meth docutils literal"><span class="pre">walk()</span></tt></a> as the
iterator in a <tt class="docutils literal"><span class="pre">for</span></tt> loop; each iteration returns the next subpart.</p>
<p>Here&#8217;s an example that prints the MIME type of every part of a multipart
message structure:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="k">for</span> <span class="n">part</span> <span class="ow">in</span> <span class="n">msg</span><span class="o">.</span><span class="n">walk</span><span class="p">():</span>
<span class="gp">... </span>    <span class="k">print</span> <span class="n">part</span><span class="o">.</span><span class="n">get_content_type</span><span class="p">()</span>
<span class="go">multipart/report</span>
<span class="go">text/plain</span>
<span class="go">message/delivery-status</span>
<span class="go">text/plain</span>
<span class="go">text/plain</span>
<span class="go">message/rfc822</span>
</pre></div>
</div>
</dd></dl>

<p class="versionchanged">
<span class="versionmodified">Changed in version 2.5: </span>The previously deprecated methods <tt class="xref py py-meth docutils literal"><span class="pre">get_type()</span></tt>, <tt class="xref py py-meth docutils literal"><span class="pre">get_main_type()</span></tt>, and
<tt class="xref py py-meth docutils literal"><span class="pre">get_subtype()</span></tt> were removed.</p>
<p><a class="reference internal" href="#email.message.Message" title="email.message.Message"><tt class="xref py py-class docutils literal"><span class="pre">Message</span></tt></a> objects can also optionally contain two instance attributes,
which can be used when generating the plain text of a MIME message.</p>
<dl class="attribute">
<dt id="email.message.Message.preamble">
<tt class="descname">preamble</tt><a class="headerlink" href="#email.message.Message.preamble" title="Permalink to this definition">¶</a></dt>
<dd><p>The format of a MIME document allows for some text between the blank line
following the headers, and the first multipart boundary string. Normally,
this text is never visible in a MIME-aware mail reader because it falls
outside the standard MIME armor.  However, when viewing the raw text of
the message, or when viewing the message in a non-MIME aware reader, this
text can become visible.</p>
<p>The <em>preamble</em> attribute contains this leading extra-armor text for MIME
documents.  When the <a class="reference internal" href="email.parser.html#email.parser.Parser" title="email.parser.Parser"><tt class="xref py py-class docutils literal"><span class="pre">Parser</span></tt></a> discovers some text
after the headers but before the first boundary string, it assigns this
text to the message&#8217;s <em>preamble</em> attribute.  When the
<a class="reference internal" href="email.generator.html#email.generator.Generator" title="email.generator.Generator"><tt class="xref py py-class docutils literal"><span class="pre">Generator</span></tt></a> is writing out the plain text
representation of a MIME message, and it finds the
message has a <em>preamble</em> attribute, it will write this text in the area
between the headers and the first boundary.  See <a class="reference internal" href="email.parser.html#module-email.parser" title="email.parser: Parse flat text email messages to produce a message object structure."><tt class="xref py py-mod docutils literal"><span class="pre">email.parser</span></tt></a> and
<a class="reference internal" href="email.generator.html#module-email.generator" title="email.generator: Generate flat text email messages from a message structure."><tt class="xref py py-mod docutils literal"><span class="pre">email.generator</span></tt></a> for details.</p>
<p>Note that if the message object has no preamble, the <em>preamble</em> attribute
will be <tt class="docutils literal"><span class="pre">None</span></tt>.</p>
</dd></dl>

<dl class="attribute">
<dt id="email.message.Message.epilogue">
<tt class="descname">epilogue</tt><a class="headerlink" href="#email.message.Message.epilogue" title="Permalink to this definition">¶</a></dt>
<dd><p>The <em>epilogue</em> attribute acts the same way as the <em>preamble</em> attribute,
except that it contains text that appears between the last boundary and
the end of the message.</p>
<p class="versionchanged">
<span class="versionmodified">Changed in version 2.5: </span>You do not need to set the epilogue to the empty string in order for the
<tt class="xref py py-class docutils literal"><span class="pre">Generator</span></tt> to print a newline at the end of the file.</p>
</dd></dl>

<dl class="attribute">
<dt id="email.message.Message.defects">
<tt class="descname">defects</tt><a class="headerlink" href="#email.message.Message.defects" title="Permalink to this definition">¶</a></dt>
<dd><p>The <em>defects</em> attribute contains a list of all the problems found when
parsing this message.  See <a class="reference internal" href="email.errors.html#module-email.errors" title="email.errors: The exception classes used by the email package."><tt class="xref py py-mod docutils literal"><span class="pre">email.errors</span></tt></a> for a detailed description
of the possible parsing defects.</p>
<p class="versionadded">
<span class="versionmodified">New in version 2.4.</span></p>
</dd></dl>

</dd></dl>

</div>


          </div>
        </div>
      </div>
      <div class="sphinxsidebar">
        <div class="sphinxsidebarwrapper">
  <h4>Previous topic</h4>
  <p class="topless"><a href="email.html"
                        title="previous chapter">18.1. <tt class="docutils literal"><span class="pre">email</span></tt> &#8212; An email and MIME handling package</a></p>
  <h4>Next topic</h4>
  <p class="topless"><a href="email.parser.html"
                        title="next chapter">18.1.2. <tt class="docutils literal"><span class="pre">email.parser</span></tt>: Parsing email messages</a></p>
<h3>This Page</h3>
<ul class="this-page-menu">
  <li><a href="../bugs.html">Report a Bug</a></li>
  <li><a href="../_sources/library/email.message.txt"
         rel="nofollow">Show Source</a></li>
</ul>

<div id="searchbox" style="display: none">
  <h3>Quick search</h3>
    <form class="search" action="../search.html" method="get">
      <input type="text" name="q" />
      <input type="submit" value="Go" />
      <input type="hidden" name="check_keywords" value="yes" />
      <input type="hidden" name="area" value="default" />
    </form>
    <p class="searchtip" style="font-size: 90%">
    Enter search terms or a module, class or function name.
    </p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
        </div>
      </div>
      <div class="clearer"></div>
    </div>
    <div class="related">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="../genindex.html" title="General Index"
             >index</a></li>
        <li class="right" >
          <a href="../py-modindex.html" title="Python Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="email.parser.html" title="18.1.2. email.parser: Parsing email messages"
             >next</a> |</li>
        <li class="right" >
          <a href="email.html" title="18.1. email — An email and MIME handling package"
             >previous</a> |</li>
        <li><img src="../_static/py.png" alt=""
                 style="vertical-align: middle; margin-top: -1px"/></li>
        <li><a href="http://www.python.org/">Python</a> &raquo;</li>
        <li>
          <a href="../index.html">Python 2.7.5 documentation</a> &raquo;
        </li>

          <li><a href="index.html" >The Python Standard Library</a> &raquo;</li>
          <li><a href="netdata.html" >18. Internet Data Handling</a> &raquo;</li>
          <li><a href="email.html" >18.1. <tt class="docutils literal"><span class="pre">email</span></tt> &#8212; An email and MIME handling package</a> &raquo;</li> 
      </ul>
    </div>
    <div class="footer">
    &copy; <a href="../copyright.html">Copyright</a> 1990-2020, Python Software Foundation.
    <br />
    The Python Software Foundation is a non-profit corporation.
    <a href="http://www.python.org/psf/donations/">Please donate.</a>
    <br />
    Last updated on Oct 13, 2020.
    <a href="../bugs.html">Found a bug</a>?
    <br />
    Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
    </div>

  </body>
</html>

SEA-GHOST - SHELL CODING BY SEA-GHOST