Lib/dos-8x3/mimepars.py

"""Generic MIME parser.

Classes:

        MimeParser - Generic MIME parser.

Exceptions:

        MimeError - Exception raised by MimeParser class.

XXX To do:

- Content-transfer-encoding issues
- Use Content-length header in rawbody()?
- Cache parts instead of reparsing each time
- The message strings in exceptions could use some work

"""

from types import *                     # Python types, not MIME types :-)
import string
import regex
import SubFile
import mimetools


MimeError = "MimeParser.MimeError"      # Exception raised by this class


class MimeParser:

    """Generic MIME parser.

    This requires a seekable file.

    """

    def __init__(self, fp):
        """Constructor: store the file pointer and parse the headers."""
        self._fp = fp
        self._start = fp.tell()
        self._headers = h = mimetools.Message(fp)
        self._bodystart = fp.tell()
        self._multipart = h.getmaintype() == 'multipart'

    def multipart(self):
        """Return whether this is a multipart message."""
        return self._multipart

    def headers(self):
        """Return the headers of the MIME message, as a Message object."""
        return self._headers

    def rawbody(self):
        """Return the raw body of the MIME message, as a file-like object.

        This is a fairly low-level interface -- for a multipart
        message, you'd have to parse the body yourself, and it doesn't
        translate the Content-transfer-encoding.
        
        """
        # XXX Use Content-length to set end if it exists?
        return SubFile.SubFile(self._fp, self._bodystart)

    def body(self):
        """Return the body of a 1-part MIME message, as a file-like object.

        This should interpret the Content-transfer-encoding, if any
        (XXX currently it doesn't).
        
        """
        if self._multipart:
            raise MimeError, "body() only works for 1-part messages"
        return self.rawbody()

    _re_content_length = regex.compile('content-length:[ \t]*\([0-9]+\)',
                                       regex.casefold)

    def rawparts(self):
        """Return the raw body parts of a multipart MIME message.

        This returns a list of SubFile() objects corresponding to the
        parts.  Note that the phantom part before the first separator
        is returned too, as list item 0.  If the final part is not
        followed by a terminator, it is ignored, and this error is not
        reported.  (XXX: the error should be raised).

        """
        if not self._multipart:
            raise MimeError, "[raw]parts() only works for multipart messages"
        h = self._headers
        separator = h.getparam('boundary')
        if not separator:
            raise MimeError, "multipart boundary not specified"
        separator = "--" + separator
        terminator = separator + "--"
        ns = len(separator)
        list = []
        f = self._fp
        start = f.tell()
        clength = -1
        bodystart = -1
        inheaders = 0
        while 1:
            end = f.tell()
            line = f.readline()
            if not line:
                break
            if line[:2] != "--" or line[:ns] != separator:
                if inheaders:
                    re = self._re_content_length
                    if re.match(line) > 0:
                        try:
                            clength = string.atoi(re.group(1))
                        except string.atoi_error:
                            pass
                    if not string.strip(line):
                        inheaders = 0
                        bodystart = f.tell()
                        if clength > 0:
                            # Skip binary data
                            f.read(clength)
                continue
            line = string.strip(line)
            if line == terminator or line == separator:
                if clength >= 0:
                    # The Content-length header determines the subfile size
                    end = bodystart + clength
                else:
                    # The final newline is not part of the content
                    end = end-1
                list.append(SubFile.SubFile(f, start, end))
                start = f.tell()
                clength = -1
                inheaders = 1
                if line == terminator:
                    break
        return list

    def parts(self):
        """Return the parsed body parts of a multipart MIME message.

        This returns a list of MimeParser() instances corresponding to
        the parts.  The phantom part before the first separator is not
        included.

        """
        return map(MimeParser, self.rawparts()[1:])

    def getsubpartbyposition(self, indices):
        part = self
        for i in indices:
            part = part.parts()[i]
        return part

    def getsubpartbyid(self, id):
        h = self._headers
        cid = h.getheader('content-id')
        if cid and cid == id:
            return self
        if self._multipart:
            for part in self.parts():
                parser = MimeParser(part)
                hit = parser.getsubpartbyid(id)
                if hit:
                    return hit
        return None

    def index(self):
        """Return an index of the MIME file.

        This parses the entire file and returns index information
        about it, in the form of a tuple

            (ctype, headers, body)

        where 'ctype' is the content type string of the message
        (e.g. `text/plain' or `multipart/mixed') and 'headers' is a
        Message instance containing the message headers (which should
        be treated as read-only).

        The 'body' item depends on the content type:

        - If it is an atomic message (anything except for content type
          multipart/*), it is the file-like object returned by
          self.body().

        - For a content type of multipart/*, it is the list of
          MimeParser() objects returned by self.parts().

        """
        if self._multipart:
            body = self.parts()
        else:
            body = self.body()
        return self._headers.gettype(), self._headers, body


def _show(parser, level=0):
    """Helper for _test()."""
    ctype, headers, body = parser.index()
    print ctype,
    if type(body) == ListType:
        nparts = len(body)
        print "(%d part%s):" % (nparts, nparts != 1 and "s" or "")
        n = 0
        for part in body:
            n = n+1
            print "%*d." % (4*level+2, n),
            _show(part, level+1)
    else:
        bodylines = body.readlines()
        print "(%d header lines, %d body lines)" % (
            len(headers.headers), len(bodylines))
        for line in headers.headers + ['\n'] + bodylines:
            if line[-1:] == '\n': line = line[:-1]
            print "    "*level + line

def _test(args = None):
    """Test program invoked when run as a script.

    When a filename argument is specified, it reads from that file.
    When no arguments are present, it defaults to 'testkp.txt' if it
    exists, else it defaults to stdin.

    """
    if not args:
        import sys
        args = sys.argv[1:]
    if args:
        fn = args[0]
    else:
        import os
        fn = 'testkp.txt'
        if not os.path.exists(fn):
            fn = '-'
    if fn == '-':
        fp = sys.stdin
    else:
        fp = open(fn)
    mp = MimeParser(fp)
    _show(mp)

if __name__ == '__main__':
    import sys
    _test()