+++ /dev/null
-"""RFC-822 message manipulation class.
-
-XXX This is only a very rough sketch of a full RFC-822 parser;
-in particular the tokenizing of addresses does not adhere to all the
-quoting rules.
-
-Directions for use:
-
-To create a Message object: first open a file, e.g.:
- fp = open(file, 'r')
-You can use any other legal way of getting an open file object, e.g. use
-sys.stdin or call os.popen().
-Then pass the open file object to the Message() constructor:
- m = Message(fp)
-
-This class can work with any input object that supports a readline
-method. If the input object has seek and tell capability, the
-rewindbody method will work; also illegal lines will be pushed back
-onto the input stream. If the input object lacks seek but has an
-`unread' method that can push back a line of input, Message will use
-that to push back illegal lines. Thus this class can be used to parse
-messages coming from a buffered stream.
-
-The optional `seekable' argument is provided as a workaround for
-certain stdio libraries in which tell() discards buffered data before
-discovering that the lseek() system call doesn't work. For maximum
-portability, you should set the seekable argument to zero to prevent
-that initial \code{tell} when passing in an unseekable object such as
-a a file object created from a socket object. If it is 1 on entry --
-which it is by default -- the tell() method of the open file object is
-called once; if this raises an exception, seekable is reset to 0. For
-other nonzero values of seekable, this test is not made.
-
-To get the text of a particular header there are several methods:
- str = m.getheader(name)
- str = m.getrawheader(name)
-where name is the name of the header, e.g. 'Subject'.
-The difference is that getheader() strips the leading and trailing
-whitespace, while getrawheader() doesn't. Both functions retain
-embedded whitespace (including newlines) exactly as they are
-specified in the header, and leave the case of the text unchanged.
-
-For addresses and address lists there are functions
- realname, mailaddress = m.getaddr(name) and
- list = m.getaddrlist(name)
-where the latter returns a list of (realname, mailaddr) tuples.
-
-There is also a method
- time = m.getdate(name)
-which parses a Date-like field and returns a time-compatible tuple,
-i.e. a tuple such as returned by time.localtime() or accepted by
-time.mktime().
-
-See the class definition for lower level access methods.
-
-There are also some utility functions here.
-"""
-# Cleanup and extensions by Eric S. Raymond <esr@thyrsus.com>
-
-import string
-import time
-
-
-_blanklines = ('\r\n', '\n') # Optimization for islast()
-
-
-class Message:
- """Represents a single RFC-822-compliant message."""
-
- def __init__(self, fp, seekable = 1):
- """Initialize the class instance and read the headers."""
- if seekable == 1:
- # Exercise tell() to make sure it works
- # (and then assume seek() works, too)
- try:
- fp.tell()
- except:
- seekable = 0
- else:
- seekable = 1
- self.fp = fp
- self.seekable = seekable
- self.startofheaders = None
- self.startofbody = None
- #
- if self.seekable:
- try:
- self.startofheaders = self.fp.tell()
- except IOError:
- self.seekable = 0
- #
- self.readheaders()
- #
- if self.seekable:
- try:
- self.startofbody = self.fp.tell()
- except IOError:
- self.seekable = 0
-
- def rewindbody(self):
- """Rewind the file to the start of the body (if seekable)."""
- if not self.seekable:
- raise IOError, "unseekable file"
- self.fp.seek(self.startofbody)
-
- def readheaders(self):
- """Read header lines.
-
- Read header lines up to the entirely blank line that
- terminates them. The (normally blank) line that ends the
- headers is skipped, but not included in the returned list.
- If a non-header line ends the headers, (which is an error),
- an attempt is made to backspace over it; it is never
- included in the returned list.
-
- The variable self.status is set to the empty string if all
- went well, otherwise it is an error message.
- The variable self.headers is a completely uninterpreted list
- of lines contained in the header (so printing them will
- reproduce the header exactly as it appears in the file).
- """
- self.dict = {}
- self.__gamh_cache = {}
- self.__gh_cache = {}
- self.unixfrom = ''
- self.headers = list = []
- self.status = ''
- headerseen = ""
- firstline = 1
- startofline = unread = tell = None
- if hasattr(self.fp, 'unread'):
- unread = self.fp.unread
- elif self.seekable:
- tell = self.fp.tell
- while 1:
- if tell:
- startofline = tell()
- line = self.fp.readline()
- if not line:
- self.status = 'EOF in headers'
- break
- # Skip unix From name time lines
- if firstline and line[:5] == 'From ':
- self.unixfrom = self.unixfrom + line
- continue
- firstline = 0
- if headerseen and line[0] in ' \t':
- # It's a continuation line.
- list.append(line)
- self.__gamh_cache[headerseen].append(line)
- x = string.lstrip(
- "%s\n %s" % (self.dict[headerseen], string.strip(line)))
- self.dict[headerseen] = x
- self.__gh_cache[headerseen][-1] = x
- continue
- elif self.iscomment(line):
- # It's a comment. Ignore it.
- continue
- elif self.islast(line):
- # Note! No pushback here! The delimiter line gets eaten.
- break
- headerseen = self.isheader(line)
- if headerseen:
- # It's a legal header line, save it.
- list.append(line)
- l = self.__gamh_cache.get(headerseen)
- if not l:
- self.__gamh_cache[headerseen] = l = []
- l.append(line)
- x = string.strip(line[len(headerseen)+1:])
- self.dict[headerseen] = x
- l = self.__gh_cache.get(headerseen)
- if not l:
- self.__gh_cache[headerseen] = l = []
- l.append(x)
- continue
- else:
- # It's not a header line; throw it back and stop here.
- if not self.dict:
- self.status = 'No headers'
- else:
- self.status = 'Non-header line where header expected'
- # Try to undo the read.
- if unread:
- unread(line)
- elif tell:
- self.fp.seek(startofline)
- else:
- self.status = self.status + '; bad seek'
- break
-
- def isheader(self, line):
- """Determine whether a given line is a legal header.
-
- This method should return the header name, suitably canonicalized.
- You may override this method in order to use Message parsing
- on tagged data in RFC822-like formats with special header formats.
- """
- i = string.find(line, ':')
- if i > 0:
- return string.lower(line[:i])
- else:
- return None
-
- def islast(self, line):
- """Determine whether a line is a legal end of RFC-822 headers.
-
- You may override this method if your application wants
- to bend the rules, e.g. to strip trailing whitespace,
- or to recognise MH template separators ('--------').
- For convenience (e.g. for code reading from sockets) a
- line consisting of \r\n also matches.
- """
- return line in _blanklines
-
- def iscomment(self, line):
- """Determine whether a line should be skipped entirely.
-
- You may override this method in order to use Message parsing
- on tagged data in RFC822-like formats that support embedded
- comments or free-text data.
- """
- return None
-
- def getallmatchingheaders(self, name,
- # speed hack:
- lower = string.lower):
- """Find all header lines matching a given header name.
-
- Look through the list of headers and find all lines
- matching a given header name (and their continuation
- lines). A list of the lines is returned, without
- interpretation. If the header does not occur, an
- empty list is returned. If the header occurs multiple
- times, all occurrences are returned. Case is not
- important in the header name.
- """
- r = self.__gamh_cache.get(lower(name))
- if r:
- return r[:]
- return []
-
- def getfirstmatchingheader(self, name,
- # speed hack:
- lower = string.lower):
- """Get the first header line matching name.
-
- This is similar to getallmatchingheaders, but it returns
- only the first matching header (and its continuation
- lines).
- """
- l = self.__gamh_cache.get(lower(name))
- if not l:
- return []
- r = []
- for item in l:
- if r and item[0] not in " \t":
- break
- r.append(item)
- return r
-
- def getrawheader(self, name):
- """A higher-level interface to getfirstmatchingheader().
-
- Return a string containing the literal text of the
- header but with the keyword stripped. All leading,
- trailing and embedded whitespace is kept in the
- string, however.
- Return None if the header does not occur.
- """
-
- list = self.getfirstmatchingheader(name)
- if not list:
- return None
- list[0] = list[0][len(name) + 1:]
- return string.joinfields(list, '')
-
- def getheader(self, name, default=None):
- """Get the header value for a name.
-
- This is the normal interface: it returns a stripped
- version of the header value for a given header name,
- or None if it doesn't exist. This uses the dictionary
- version which finds the *last* such header.
- """
- try:
- return self.dict[string.lower(name)]
- except KeyError:
- return default
- get = getheader
-
- def getheaders(self, name,
- # speed hack:
- lower = string.lower):
- """Get all values for a header.
-
- This returns a list of values for headers given more than once;
- each value in the result list is stripped in the same way as the
- result of getheader(). If the header is not given, return an
- empty list.
- """
- r = self.__gh_cache.get(lower(name))
- if r:
- return r[:]
- return []
-
- def getaddr(self, name):
- """Get a single address from a header, as a tuple.
-
- An example return value:
- ('Guido van Rossum', 'guido@cwi.nl')
- """
- # New, by Ben Escoto
- alist = self.getaddrlist(name)
- if alist:
- return alist[0]
- else:
- return (None, None)
-
- def getaddrlist(self, name):
- """Get a list of addresses from a header.
-
- Retrieves a list of addresses from a header, where each address is a
- tuple as returned by getaddr(). Scans all named headers, so it works
- properly with multiple To: or Cc: headers for example.
-
- """
- raw = []
- for h in self.getallmatchingheaders(name):
- if h[0] in ' \t':
- raw.append(h)
- else:
- if raw:
- raw.append(', ')
- i = string.find(h, ':')
- if i > 0:
- addr = h[i+1:]
- raw.append(addr)
- alladdrs = string.join(raw, '')
- a = AddrlistClass(alladdrs)
- return a.getaddrlist()
-
- def getdate(self, name):
- """Retrieve a date field from a header.
-
- Retrieves a date field from the named header, returning
- a tuple compatible with time.mktime().
- """
- try:
- data = self[name]
- except KeyError:
- return None
- return parsedate(data)
-
- def getdate_tz(self, name):
- """Retrieve a date field from a header as a 10-tuple.
-
- The first 9 elements make up a tuple compatible with
- time.mktime(), and the 10th is the offset of the poster's
- time zone from GMT/UTC.
- """
- try:
- data = self[name]
- except KeyError:
- return None
- return parsedate_tz(data)
-
-
- # Access as a dictionary (only finds *last* header of each type):
-
- def __len__(self):
- """Get the number of headers in a message."""
- return len(self.dict)
-
- def __getitem__(self, name):
- """Get a specific header, as from a dictionary."""
- return self.dict[string.lower(name)]
-
- def __setitem__(self, name, value):
- """Set the value of a header.
-
- Note: This is not a perfect inversion of __getitem__, because
- any changed headers get stuck at the end of the raw-headers list
- rather than where the altered header was.
- """
- del self[name] # Won't fail if it doesn't exist
- self.dict[string.lower(name)] = value
- text = name + ": " + value
- lines = string.split(text, "\n")
- for line in lines:
- self.headers.append(line + "\n")
-
- def __delitem__(self, name):
- """Delete all occurrences of a specific header, if it is present."""
- name = string.lower(name)
- if not self.dict.has_key(name):
- return
- del self.dict[name]
- name = name + ':'
- n = len(name)
- list = []
- hit = 0
- for i in range(len(self.headers)):
- line = self.headers[i]
- if string.lower(line[:n]) == name:
- hit = 1
- elif line[:1] not in string.whitespace:
- hit = 0
- if hit:
- list.append(i)
- list.reverse()
- for i in list:
- del self.headers[i]
-
- def has_key(self, name):
- """Determine whether a message contains the named header."""
- return self.dict.has_key(string.lower(name))
-
- def keys(self):
- """Get all of a message's header field names."""
- return self.dict.keys()
-
- def values(self):
- """Get all of a message's header field values."""
- return self.dict.values()
-
- def items(self):
- """Get all of a message's headers.
-
- Returns a list of name, value tuples.
- """
- return self.dict.items()
-
- def __str__(self):
- str = ''
- for hdr in self.headers:
- str = str + hdr
- return str
-
-
-# Utility functions
-# -----------------
-
-# XXX Should fix unquote() and quote() to be really conformant.
-# XXX The inverses of the parse functions may also be useful.
-
-
-def unquote(str):
- """Remove quotes from a string."""
- if len(str) > 1:
- if str[0] == '"' and str[-1:] == '"':
- return str[1:-1]
- if str[0] == '<' and str[-1:] == '>':
- return str[1:-1]
- return str
-
-
-def quote(str):
- """Add quotes around a string."""
- return '"%s"' % string.join(
- string.split(
- string.join(
- string.split(str, '\\'),
- '\\\\'),
- '"'),
- '\\"')
-
-
-def parseaddr(address):
- """Parse an address into a (realname, mailaddr) tuple."""
- a = AddrlistClass(address)
- list = a.getaddrlist()
- if not list:
- return (None, None)
- else:
- return list[0]
-
-
-class AddrlistClass:
- """Address parser class by Ben Escoto.
-
- To understand what this class does, it helps to have a copy of
- RFC-822 in front of you.
-
- Note: this class interface is deprecated and may be removed in the future.
- Use rfc822.AddressList instead.
- """
-
- def __init__(self, field):
- """Initialize a new instance.
-
- `field' is an unparsed address header field, containing
- one or more addresses.
- """
- self.specials = '()<>@,:;.\"[]'
- self.pos = 0
- self.LWS = ' \t'
- self.CR = '\r\n'
- self.atomends = self.specials + self.LWS + self.CR
- self.field = field
- self.commentlist = []
-
- def gotonext(self):
- """Parse up to the start of the next address."""
- while self.pos < len(self.field):
- if self.field[self.pos] in self.LWS + '\n\r':
- self.pos = self.pos + 1
- elif self.field[self.pos] == '(':
- self.commentlist.append(self.getcomment())
- else: break
-
- def getaddrlist(self):
- """Parse all addresses.
-
- Returns a list containing all of the addresses.
- """
- ad = self.getaddress()
- if ad:
- return ad + self.getaddrlist()
- else: return []
-
- def getaddress(self):
- """Parse the next address."""
- self.commentlist = []
- self.gotonext()
-
- oldpos = self.pos
- oldcl = self.commentlist
- plist = self.getphraselist()
-
- self.gotonext()
- returnlist = []
-
- if self.pos >= len(self.field):
- # Bad email address technically, no domain.
- if plist:
- returnlist = [(string.join(self.commentlist), plist[0])]
-
- elif self.field[self.pos] in '.@':
- # email address is just an addrspec
- # this isn't very efficient since we start over
- self.pos = oldpos
- self.commentlist = oldcl
- addrspec = self.getaddrspec()
- returnlist = [(string.join(self.commentlist), addrspec)]
-
- elif self.field[self.pos] == ':':
- # address is a group
- returnlist = []
-
- fieldlen = len(self.field)
- self.pos = self.pos + 1
- while self.pos < len(self.field):
- self.gotonext()
- if self.pos < fieldlen and self.field[self.pos] == ';':
- self.pos = self.pos + 1
- break
- returnlist = returnlist + self.getaddress()
-
- elif self.field[self.pos] == '<':
- # Address is a phrase then a route addr
- routeaddr = self.getrouteaddr()
-
- if self.commentlist:
- returnlist = [(string.join(plist) + ' (' + \
- string.join(self.commentlist) + ')', routeaddr)]
- else: returnlist = [(string.join(plist), routeaddr)]
-
- else:
- if plist:
- returnlist = [(string.join(self.commentlist), plist[0])]
- elif self.field[self.pos] in self.specials:
- self.pos = self.pos + 1
-
- self.gotonext()
- if self.pos < len(self.field) and self.field[self.pos] == ',':
- self.pos = self.pos + 1
- return returnlist
-
- def getrouteaddr(self):
- """Parse a route address (Return-path value).
-
- This method just skips all the route stuff and returns the addrspec.
- """
- if self.field[self.pos] != '<':
- return
-
- expectroute = 0
- self.pos = self.pos + 1
- self.gotonext()
- adlist = None
- while self.pos < len(self.field):
- if expectroute:
- self.getdomain()
- expectroute = 0
- elif self.field[self.pos] == '>':
- self.pos = self.pos + 1
- break
- elif self.field[self.pos] == '@':
- self.pos = self.pos + 1
- expectroute = 1
- elif self.field[self.pos] == ':':
- self.pos = self.pos + 1
- expectaddrspec = 1
- else:
- adlist = self.getaddrspec()
- self.pos = self.pos + 1
- break
- self.gotonext()
-
- return adlist
-
- def getaddrspec(self):
- """Parse an RFC-822 addr-spec."""
- aslist = []
-
- self.gotonext()
- while self.pos < len(self.field):
- if self.field[self.pos] == '.':
- aslist.append('.')
- self.pos = self.pos + 1
- elif self.field[self.pos] == '"':
- aslist.append('"%s"' % self.getquote())
- elif self.field[self.pos] in self.atomends:
- break
- else: aslist.append(self.getatom())
- self.gotonext()
-
- if self.pos >= len(self.field) or self.field[self.pos] != '@':
- return string.join(aslist, '')
-
- aslist.append('@')
- self.pos = self.pos + 1
- self.gotonext()
- return string.join(aslist, '') + self.getdomain()
-
- def getdomain(self):
- """Get the complete domain name from an address."""
- sdlist = []
- while self.pos < len(self.field):
- if self.field[self.pos] in self.LWS:
- self.pos = self.pos + 1
- elif self.field[self.pos] == '(':
- self.commentlist.append(self.getcomment())
- elif self.field[self.pos] == '[':
- sdlist.append(self.getdomainliteral())
- elif self.field[self.pos] == '.':
- self.pos = self.pos + 1
- sdlist.append('.')
- elif self.field[self.pos] in self.atomends:
- break
- else: sdlist.append(self.getatom())
- return string.join(sdlist, '')
-
- def getdelimited(self, beginchar, endchars, allowcomments = 1):
- """Parse a header fragment delimited by special characters.
-
- `beginchar' is the start character for the fragment.
- If self is not looking at an instance of `beginchar' then
- getdelimited returns the empty string.
-
- `endchars' is a sequence of allowable end-delimiting characters.
- Parsing stops when one of these is encountered.
-
- If `allowcomments' is non-zero, embedded RFC-822 comments
- are allowed within the parsed fragment.
- """
- if self.field[self.pos] != beginchar:
- return ''
-
- slist = ['']
- quote = 0
- self.pos = self.pos + 1
- while self.pos < len(self.field):
- if quote == 1:
- slist.append(self.field[self.pos])
- quote = 0
- elif self.field[self.pos] in endchars:
- self.pos = self.pos + 1
- break
- elif allowcomments and self.field[self.pos] == '(':
- slist.append(self.getcomment())
- elif self.field[self.pos] == '\\':
- quote = 1
- else:
- slist.append(self.field[self.pos])
- self.pos = self.pos + 1
-
- return string.join(slist, '')
-
- def getquote(self):
- """Get a quote-delimited fragment from self's field."""
- return self.getdelimited('"', '"\r', 0)
-
- def getcomment(self):
- """Get a parenthesis-delimited fragment from self's field."""
- return self.getdelimited('(', ')\r', 1)
-
- def getdomainliteral(self):
- """Parse an RFC-822 domain-literal."""
- return self.getdelimited('[', ']\r', 0)
-
- def getatom(self):
- """Parse an RFC-822 atom."""
- atomlist = ['']
-
- while self.pos < len(self.field):
- if self.field[self.pos] in self.atomends:
- break
- else: atomlist.append(self.field[self.pos])
- self.pos = self.pos + 1
-
- return string.join(atomlist, '')
-
- def getphraselist(self):
- """Parse a sequence of RFC-822 phrases.
-
- A phrase is a sequence of words, which are in turn either
- RFC-822 atoms or quoted-strings. Phrases are canonicalized
- by squeezing all runs of continuous whitespace into one space.
- """
- plist = []
-
- while self.pos < len(self.field):
- if self.field[self.pos] in self.LWS:
- self.pos = self.pos + 1
- elif self.field[self.pos] == '"':
- plist.append(self.getquote())
- elif self.field[self.pos] == '(':
- self.commentlist.append(self.getcomment())
- elif self.field[self.pos] in self.atomends:
- break
- else: plist.append(self.getatom())
-
- return plist
-
-class AddressList(AddrlistClass):
- """An AddressList encapsulates a list of parsed RFC822 addresses."""
- def __init__(self, field):
- AddrlistClass.__init__(self, field)
- if field:
- self.addresslist = self.getaddrlist()
- else:
- self.addresslist = []
-
- def __len__(self):
- return len(self.addresslist)
-
- def __str__(self):
- return string.joinfields(map(dump_address_pair, self.addresslist),", ")
-
- def __add__(self, other):
- # Set union
- newaddr = AddressList(None)
- newaddr.addresslist = self.addresslist[:]
- for x in other.addresslist:
- if not x in self.addresslist:
- newaddr.addresslist.append(x)
- return newaddr
-
- def __sub__(self, other):
- # Set difference
- newaddr = AddressList(None)
- for x in self.addresslist:
- if not x in other.addresslist:
- newaddr.addresslist.append(x)
- return newaddr
-
- def __getitem__(self, index):
- # Make indexing, slices, and 'in' work
- return self.addresslist[index]
-
-def dump_address_pair(pair):
- """Dump a (name, address) pair in a canonicalized form."""
- if pair[0]:
- return '"' + pair[0] + '" <' + pair[1] + '>'
- else:
- return pair[1]
-
-# Parse a date field
-
-_monthnames = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul',
- 'aug', 'sep', 'oct', 'nov', 'dec',
- 'january', 'february', 'march', 'april', 'may', 'june', 'july',
- 'august', 'september', 'october', 'november', 'december']
-_daynames = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']
-
-# The timezone table does not include the military time zones defined
-# in RFC822, other than Z. According to RFC1123, the description in
-# RFC822 gets the signs wrong, so we can't rely on any such time
-# zones. RFC1123 recommends that numeric timezone indicators be used
-# instead of timezone names.
-
-_timezones = {'UT':0, 'UTC':0, 'GMT':0, 'Z':0,
- 'AST': -400, 'ADT': -300, # Atlantic (used in Canada)
- 'EST': -500, 'EDT': -400, # Eastern
- 'CST': -600, 'CDT': -500, # Central
- 'MST': -700, 'MDT': -600, # Mountain
- 'PST': -800, 'PDT': -700 # Pacific
- }
-
-
-def parsedate_tz(data):
- """Convert a date string to a time tuple.
-
- Accounts for military timezones.
- """
- data = string.split(data)
- if data[0][-1] in (',', '.') or string.lower(data[0]) in _daynames:
- # There's a dayname here. Skip it
- del data[0]
- if len(data) == 3: # RFC 850 date, deprecated
- stuff = string.split(data[0], '-')
- if len(stuff) == 3:
- data = stuff + data[1:]
- if len(data) == 4:
- s = data[3]
- i = string.find(s, '+')
- if i > 0:
- data[3:] = [s[:i], s[i+1:]]
- else:
- data.append('') # Dummy tz
- if len(data) < 5:
- return None
- data = data[:5]
- [dd, mm, yy, tm, tz] = data
- mm = string.lower(mm)
- if not mm in _monthnames:
- dd, mm = mm, string.lower(dd)
- if not mm in _monthnames:
- return None
- mm = _monthnames.index(mm)+1
- if mm > 12: mm = mm - 12
- if dd[-1] == ',':
- dd = dd[:-1]
- i = string.find(yy, ':')
- if i > 0:
- yy, tm = tm, yy
- if yy[-1] == ',':
- yy = yy[:-1]
- if yy[0] not in string.digits:
- yy, tz = tz, yy
- if tm[-1] == ',':
- tm = tm[:-1]
- tm = string.splitfields(tm, ':')
- if len(tm) == 2:
- [thh, tmm] = tm
- tss = '0'
- elif len(tm) == 3:
- [thh, tmm, tss] = tm
- else:
- return None
- try:
- yy = string.atoi(yy)
- dd = string.atoi(dd)
- thh = string.atoi(thh)
- tmm = string.atoi(tmm)
- tss = string.atoi(tss)
- except string.atoi_error:
- return None
- tzoffset=None
- tz=string.upper(tz)
- if _timezones.has_key(tz):
- tzoffset=_timezones[tz]
- else:
- try:
- tzoffset=string.atoi(tz)
- except string.atoi_error:
- pass
- # Convert a timezone offset into seconds ; -0500 -> -18000
- if tzoffset:
- if tzoffset < 0:
- tzsign = -1
- tzoffset = -tzoffset
- else:
- tzsign = 1
- tzoffset = tzsign * ( (tzoffset/100)*3600 + (tzoffset % 100)*60)
- tuple = (yy, mm, dd, thh, tmm, tss, 0, 0, 0, tzoffset)
- return tuple
-
-
-def parsedate(data):
- """Convert a time string to a time tuple."""
- t=parsedate_tz(data)
- if type(t)==type( () ):
- return t[:9]
- else: return t
-
-
-def mktime_tz(data):
- """Turn a 10-tuple as returned by parsedate_tz() into a UTC timestamp."""
- if data[9] is None:
- # No zone info, so localtime is better assumption than GMT
- return time.mktime(data[:8] + (-1,))
- else:
- t = time.mktime(data[:8] + (0,))
- return t - data[9] - time.timezone
-
-def formatdate(timeval=None):
- """Returns time format preferred for Internet standards.
-
- Sun, 06 Nov 1994 08:49:37 GMT ; RFC 822, updated by RFC 1123
- """
- if timeval is None:
- timeval = time.time()
- return "%s" % time.strftime('%a, %d %b %Y %H:%M:%S GMT',
- time.gmtime(timeval))
-
-
-# When used as script, run a small test program.
-# The first command line argument must be a filename containing one
-# message in RFC-822 format.
-
-if __name__ == '__main__':
- import sys, os
- file = os.path.join(os.environ['HOME'], 'Mail/inbox/1')
- if sys.argv[1:]: file = sys.argv[1]
- f = open(file, 'r')
- m = Message(f)
- print 'From:', m.getaddr('from')
- print 'To:', m.getaddrlist('to')
- print 'Subject:', m.getheader('subject')
- print 'Date:', m.getheader('date')
- date = m.getdate_tz('date')
- if date:
- print 'ParsedDate:', time.asctime(date[:-1]),
- hhmmss = date[-1]
- hhmm, ss = divmod(hhmmss, 60)
- hh, mm = divmod(hhmm, 60)
- print "%+03d%02d" % (hh, mm),
- if ss: print ".%02d" % ss,
- print
- else:
- print 'ParsedDate:', None
- m.rewindbody()
- n = 0
- while f.readline():
- n = n + 1
- print 'Lines:', n
- print '-'*70
- print 'len =', len(m)
- if m.has_key('Date'): print 'Date =', m['Date']
- if m.has_key('X-Nonsense'): pass
- print 'keys =', m.keys()
- print 'values =', m.values()
- print 'items =', m.items()
projects / python / commitdiff