multifile — Support for files containing distinct parts
MultiFile object enables you to treat sections of a text file as
file-like input objects, with
'' being returned by
readline() when a
given delimiter pattern is encountered. The defaults of this class are designed
to make it useful for parsing MIME multipart messages, but by subclassing it and
overriding methods it can be easily adapted for more general use.
MultiFileonly ever looks at the input object’s
tell()methods, and the latter two are only needed if you want random access to the individual MIME parts. To use
MultiFileon a non-seekable stream object, set the optional seekable argument to false; this will prevent using the input object’s
It will be useful to know that in
MultiFile‘s view of the world, text
is composed of three kinds of lines: data, section-dividers, and end-markers.
MultiFile is designed to support parsing of messages that may have multiple
nested message parts, each with its own pattern for section-divider and
18.10.1. MultiFile Objects
MultiFile instance has the following methods:
Read a line. If the line is data (not a section-divider or end-marker or real EOF) return it. If the line matches the most-recently-stacked boundary, return
self.lastto 1 or 0 according as the match is or is not an end-marker. If the line matches any other stacked boundary, raise an error. On encountering end-of-file on the underlying stream object, the method raises
Errorunless all boundaries have been popped.
Return all lines remaining in this part as a list of strings.
Read all lines, up to the next section. Return them as a single (multiline) string. Note that this doesn’t take a size argument!
Seek. Seek indices are relative to the start of the current section. The pos and whence arguments are interpreted as for a file seek.
Return the file position relative to the start of the current section.
Skip lines to the next section (that is, read lines until a section-divider or end-marker has been consumed). Return true if there is such a section, false if an end-marker is seen. Re-enable the most-recently-pushed boundary.
Return true if str is data and false if it might be a section boundary. As written, it tests for a prefix other than
-'at start of line (which all MIME boundaries have) but it is declared so it can be overridden in derived classes.
Note that this test is used intended as a fast guard for the real boundary tests; if it always returns false it will merely slow processing, not cause it to fail.
Push a boundary string. When a decorated version of this boundary is found as an input line, it will be interpreted as a section-divider or end-marker (depending on the decoration, see RFC 2045). All subsequent reads will return the empty string to indicate end-of-file, until a call to
pop()removes the boundary a or
next()call reenables it.
It is possible to push more than one boundary. Encountering the most-recently-pushed boundary will return EOF; encountering any other boundary will raise an error.
Pop a section boundary. This boundary will no longer be interpreted as EOF.
Turn a boundary into a section-divider line. By default, this method prepends
'--'(which MIME section boundaries have) but it is declared so it can be overridden in derived classes. This method need not append LF or CR-LF, as comparison with the result ignores trailing whitespace.
Turn a boundary string into an end-marker line. By default, this method prepends
'--'(like a MIME-multipart end-of-message marker) but it is declared so it can be overridden in derived classes. This method need not append LF or CR-LF, as comparison with the result ignores trailing whitespace.
MultiFile instances have two public instance variables:
Nesting depth of the current part.
True if the last end-of-file was for an end-of-message marker.
import mimetools import multifile import StringIO def extract_mime_part_matching(stream, mimetype): """Return the first element in a multipart MIME message on stream matching mimetype.""" msg = mimetools.Message(stream) msgtype = msg.gettype() params = msg.getplist() data = StringIO.StringIO() if msgtype[:10] == "multipart/": file = multifile.MultiFile(stream) file.push(msg.getparam("boundary")) while file.next(): submsg = mimetools.Message(file) try: data = StringIO.StringIO() mimetools.decode(file, data, submsg.getencoding()) except ValueError: continue if submsg.gettype() == mimetype: break file.pop() return data.getvalue()