The :mod:`email` package is a library for managing email messages, including
-MIME and other :rfc:`2822`\ -based message documents. It subsumes most of the
-functionality in several older standard modules such as :mod:`rfc822`,
-:mod:`mimetools`, :mod:`multifile`, and other non-standard packages such as
-:mod:`mimecntl`. It is specifically *not* designed to do any sending of email
-messages to SMTP (:rfc:`2821`), NNTP, or other servers; those are functions of
-modules such as :mod:`smtplib` and :mod:`nntplib`. The :mod:`email` package
-attempts to be as RFC-compliant as possible, supporting in addition to
-:rfc:`2822`, such MIME-related RFCs as :rfc:`2045`, :rfc:`2046`, :rfc:`2047`,
-and :rfc:`2231`.
+MIME and other :rfc:`2822`\ -based message documents. It is specifically *not*
+designed to do any sending of email messages to SMTP (:rfc:`2821`), NNTP, or
+other servers; those are functions of modules such as :mod:`smtplib` and
+:mod:`nntplib`. The :mod:`email` package attempts to be as RFC-compliant as
+possible, supporting in addition to :rfc:`2822`, such MIME-related RFCs as
+:rfc:`2045`, :rfc:`2046`, :rfc:`2047`, and :rfc:`2231`.
The primary distinguishing feature of the :mod:`email` package is that it splits
the parsing and generating of email messages from the internal *object model*
.. attribute:: HTTPResponse.msg
- A :class:`mimetools.Message` instance containing the response headers.
+ An :class:`email.message.Message` instance containing the response headers.
.. attribute:: HTTPResponse.version
:mailheader:`Set-Cookie2` headers in the *response* argument, and store cookies
as appropriate (subject to the :meth:`CookiePolicy.set_ok` method's approval).
- The *response* object (usually the result of a call to :meth:`urllib2.urlopen`,
- or similar) should support an :meth:`info` method, which returns an object with
- a :meth:`getallmatchingheaders` method (usually a :class:`mimetools.Message`
- instance).
+ The *response* object (usually the result of a call to
+ :meth:`urllib2.urlopen`, or similar) should support an :meth:`info` method,
+ which returns a :class:`email.message.Message` instance.
The *request* object (usually a :class:`urllib2.Request` instance) must support
the methods :meth:`get_full_url`, :meth:`get_host`, :meth:`unverifiable`, and
.. attribute:: MessageClass
- .. index:: single: Message (in module mimetools)
-
- Specifies a :class:`rfc822.Message`\ -like class to parse HTTP headers.
- Typically, this is not overridden, and it defaults to
- :class:`mimetools.Message`.
+ Specifies an :class:`email.message.Message`\ -like class to parse HTTP
+ headers. Typically, this is not overridden, and it defaults to
+ :class:`http.client.HTTPMessage`.
.. attribute:: responses
Module :mod:`mailbox`
Classes to read various mailbox formats produced by end-user mail programs.
- Module :mod:`mimetools`
- Subclass of :class:`rfc822.Message` that handles MIME encoded messages.
-
.. _message-objects:
however, so it can't be used at those few places where a true built-in file
object is required.)
- .. index:: module: mimetools
-
The :meth:`info` method returns an instance of the class
- :class:`mimetools.Message` containing meta-information associated with the
- URL. When the method is HTTP, these headers are those returned by the server
- at the head of the retrieved HTML page (including Content-Length and
+ :class:`email.message.Message` containing meta-information associated with
+ the URL. When the method is HTTP, these headers are those returned by the
+ server at the head of the retrieved HTML page (including Content-Length and
Content-Type). When the method is FTP, a Content-Length header will be
present if (as is now usual) the server passed back a file length in response
to the FTP retrieval request. A Content-Type header will be present if the
MIME type can be guessed. When the method is local-file, returned headers
will include a Date representing the file's last-modified time, a
Content-Length giving file size, and a Content-Type containing a guess at the
- file's type. See also the description of the :mod:`mimetools` module.
+ file's type.
The :meth:`geturl` method returns the real URL of the page. In some cases, the
HTTP server redirects a client to another URL. The :func:`urlopen` function
Retrieves the contents of *url* and places it in *filename*. The return value
is a tuple consisting of a local filename and either a
- :class:`mimetools.Message` object containing the response headers (for remote
+ :class:`email.message.Message` object containing the response headers (for remote
URLs) or ``None`` (for local URLs). The caller must then open and read the
contents of *filename*. If *filename* is not given and the URL refers to a
local file, the input filename is returned. If the URL is non-local and
# --------------------------------------------------- web browser interface
def serve(port, callback=None, completer=None):
- import http.server, mimetools, select
-
- # Patch up mimetools.Message so it doesn't break if rfc822 is reloaded.
- class Message(mimetools.Message):
- def __init__(self, fp, seekable=1):
- Message = self.__class__
- Message.__bases__[0].__bases__[0].__init__(self, fp, seekable)
- self.encodingheader = self.get('content-transfer-encoding')
- self.typeheader = self.get('content-type')
- self.parsetype()
- self.parseplist()
+ import http.server, email.message, select
class DocHandler(http.server.BaseHTTPRequestHandler):
def send_document(self, title, contents):
DocServer.base = http.server.HTTPServer
DocServer.handler = DocHandler
- DocHandler.MessageClass = Message
+ DocHandler.MessageClass = email.message.Message
try:
try:
DocServer(port, callback).serve_until_quit()
self.check_all("mailbox")
self.check_all("mailcap")
self.check_all("mhlib")
- self.check_all("mimetools")
self.check_all("mimetypes")
self.check_all("multifile")
self.check_all("netrc")
self.check_all("random")
self.check_all("re")
self.check_all("reprlib")
- self.check_all("rfc822")
self.check_all("rlcompleter")
self.check_all("robotparser")
self.check_all("sched")
projects / python / commitdiff