FCL/interim/QEMU: comparison symbian-qemu-0.9.1-12/python-2.6.1/Lib/rfc822.py

equal deleted inserted replaced

-:ffa851df0825
+:2fb8b9db1c86
+"""RFC 2822 message manipulation.
+Note: 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.
+Note: RFC 2822 is a long awaited update to RFC 822.  This module should
+conform to RFC 2822, and is thus mis-named (it's not worth renaming it).  Some
+effort at RFC 2822 updates have been made, but a thorough audit has not been
+performed.  Consider any RFC 2822 non-conformance to be a bug.
+RFC 2822: http://www.faqs.org/rfcs/rfc2822.html
+RFC 822 : http://www.faqs.org/rfcs/rfc822.html (obsolete)
+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)
+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 time
+from warnings import warnpy3k
+warnpy3k("in 3.x, rfc822 has been removed in favor of the email package",
+stacklevel=2)
+__all__ = ["Message","AddressList","parsedate","parsedate_tz","mktime_tz"]
+_blanklines = ('\r\n', '\n')            # Optimization for islast()
+class Message:
+"""Represents a single RFC 2822-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 (AttributeError, IOError):
+seekable = 0
+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.unixfrom = ''
+self.headers = lst = []
+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:
+try:
+startofline = tell()
+except IOError:
+startofline = tell = None
+self.seekable = 0
+line = self.fp.readline()
+if not line:
+self.status = 'EOF in headers'
+break
+# Skip unix From name time lines
+if firstline and line.startswith('From '):
+self.unixfrom = self.unixfrom + line
+continue
+firstline = 0
+if headerseen and line[0] in ' \t':
+# It's a continuation line.
+lst.append(line)
+x = (self.dict[headerseen] + "\n " + line.strip())
+self.dict[headerseen] = x.strip()
+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.
+lst.append(line)
+self.dict[headerseen] = line[len(headerseen)+1:].strip()
+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 RFC 2822-like formats with special header formats.
+"""
+i = line.find(':')
+if i > 0:
+return line[:i].lower()
+return None
+def islast(self, line):
+"""Determine whether a line is a legal end of RFC 2822 headers.
+You may override this method if your application wants to bend the
+rules, e.g. to strip trailing whitespace, or to recognize 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 RFC 2822-like formats that support embedded comments or
+free-text data.
+"""
+return False
+def getallmatchingheaders(self, name):
+"""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.
+"""
+name = name.lower() + ':'
+n = len(name)
+lst = []
+hit = 0
+for line in self.headers:
+if line[:n].lower() == name:
+hit = 1
+elif not line[:1].isspace():
+hit = 0
+if hit:
+lst.append(line)
+return lst
+def getfirstmatchingheader(self, name):
+"""Get the first header line matching name.
+This is similar to getallmatchingheaders, but it returns only the
+first matching header (and its continuation lines).
+"""
+name = name.lower() + ':'
+n = len(name)
+lst = []
+hit = 0
+for line in self.headers:
+if hit:
+if not line[:1].isspace():
+break
+elif line[:n].lower() == name:
+hit = 1
+if hit:
+lst.append(line)
+return lst
+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.
+"""
+lst = self.getfirstmatchingheader(name)
+if not lst:
+return None
+lst[0] = lst[0][len(name) + 1:]
+return ''.join(lst)
+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.
+"""
+return self.dict.get(name.lower(), default)
+get = getheader
+def getheaders(self, name):
+"""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.
+"""
+result = []
+current = ''
+have_header = 0
+for s in self.getallmatchingheaders(name):
+if s[0].isspace():
+if current:
+current = "%s\n %s" % (current, s.strip())
+else:
+current = s.strip()
+else:
+if have_header:
+result.append(current)
+current = s[s.find(":") + 1:].strip()
+have_header = 1
+if have_header:
+result.append(current)
+return result
+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 = h.find(':')
+if i > 0:
+addr = h[i+1:]
+raw.append(addr)
+alladdrs = ''.join(raw)
+a = AddressList(alladdrs)
+return a.addresslist
+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[name.lower()]
+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[name.lower()] = value
+text = name + ": " + value
+for line in text.split("\n"):
+self.headers.append(line + "\n")
+def __delitem__(self, name):
+"""Delete all occurrences of a specific header, if it is present."""
+name = name.lower()
+if not name in self.dict:
+return
+del self.dict[name]
+name = name + ':'
+n = len(name)
+lst = []
+hit = 0
+for i in range(len(self.headers)):
+line = self.headers[i]
+if line[:n].lower() == name:
+hit = 1
+elif not line[:1].isspace():
+hit = 0
+if hit:
+lst.append(i)
+for i in reversed(lst):
+del self.headers[i]
+def setdefault(self, name, default=""):
+lowername = name.lower()
+if lowername in self.dict:
+return self.dict[lowername]
+else:
+text = name + ": " + default
+for line in text.split("\n"):
+self.headers.append(line + "\n")
+self.dict[lowername] = default
+return default
+def has_key(self, name):
+"""Determine whether a message contains the named header."""
+return name.lower() in self.dict
+def __contains__(self, name):
+"""Determine whether a message contains the named header."""
+return name.lower() in self.dict
+def __iter__(self):
+return iter(self.dict)
+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):
+return ''.join(self.headers)
+# 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(s):
+"""Remove quotes from a string."""
+if len(s) > 1:
+if s.startswith('"') and s.endswith('"'):
+return s[1:-1].replace('\\\\', '\\').replace('\\"', '"')
+if s.startswith('<') and s.endswith('>'):
+return s[1:-1]
+return s
+def quote(s):
+"""Add quotes around a string."""
+return s.replace('\\', '\\\\').replace('"', '\\"')
+def parseaddr(address):
+"""Parse an address into a (realname, mailaddr) tuple."""
+a = AddressList(address)
+lst = a.addresslist
+if not lst:
+return (None, None)
+return lst[0]
+class AddrlistClass:
+"""Address parser class by Ben Escoto.
+To understand what this class does, it helps to have a copy of
+RFC 2822 in front of you.
+http://www.faqs.org/rfcs/rfc2822.html
+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
+# Note that RFC 2822 now specifies `.' as obs-phrase, meaning that it
+# is obsolete syntax.  RFC 2822 requires that we recognize obsolete
+# syntax, so allow dots in phrases.
+self.phraseends = self.atomends.replace('.', '')
+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.
+"""
+result = []
+ad = self.getaddress()
+while ad:
+result += ad
+ad = self.getaddress()
+return result
+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 = [(' '.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 = [(' '.join(self.commentlist), addrspec)]
+elif self.field[self.pos] == ':':
+# address is a group
+returnlist = []
+fieldlen = len(self.field)
+self.pos += 1
+while self.pos < len(self.field):
+self.gotonext()
+if self.pos < fieldlen and self.field[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 = [(' '.join(plist) + ' (' + \
+' '.join(self.commentlist) + ')', routeaddr)]
+else: returnlist = [(' '.join(plist), routeaddr)]
+else:
+if plist:
+returnlist = [(' '.join(self.commentlist), plist[0])]
+elif self.field[self.pos] in self.specials:
+self.pos += 1
+self.gotonext()
+if self.pos < len(self.field) and self.field[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 += 1
+self.gotonext()
+adlist = ""
+while self.pos < len(self.field):
+if expectroute:
+self.getdomain()
+expectroute = 0
+elif self.field[self.pos] == '>':
+self.pos += 1
+break
+elif self.field[self.pos] == '@':
+self.pos += 1
+expectroute = 1
+elif self.field[self.pos] == ':':
+self.pos += 1
+else:
+adlist = self.getaddrspec()
+self.pos += 1
+break
+self.gotonext()
+return adlist
+def getaddrspec(self):
+"""Parse an RFC 2822 addr-spec."""
+aslist = []
+self.gotonext()
+while self.pos < len(self.field):
+if self.field[self.pos] == '.':
+aslist.append('.')
+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 ''.join(aslist)
+aslist.append('@')
+self.pos += 1
+self.gotonext()
+return ''.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 += 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 += 1
+sdlist.append('.')
+elif self.field[self.pos] in self.atomends:
+break
+else: sdlist.append(self.getatom())
+return ''.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 2822 comments are allowed
+within the parsed fragment.
+"""
+if self.field[self.pos] != beginchar:
+return ''
+slist = ['']
+quote = 0
+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 += 1
+break
+elif allowcomments and self.field[self.pos] == '(':
+slist.append(self.getcomment())
+continue        # have already advanced pos from getcomment
+elif self.field[self.pos] == '\\':
+quote = 1
+else:
+slist.append(self.field[self.pos])
+self.pos += 1
+return ''.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 2822 domain-literal."""
+return '[%s]' % self.getdelimited('[', ']\r', 0)
+def getatom(self, atomends=None):
+"""Parse an RFC 2822 atom.
+Optional atomends specifies a different set of end token delimiters
+(the default is to use self.atomends).  This is used e.g. in
+getphraselist() since phrase endings must not include the `.' (which
+is legal in phrases)."""
+atomlist = ['']
+if atomends is None:
+atomends = self.atomends
+while self.pos < len(self.field):
+if self.field[self.pos] in atomends:
+break
+else: atomlist.append(self.field[self.pos])
+self.pos += 1
+return ''.join(atomlist)
+def getphraselist(self):
+"""Parse a sequence of RFC 2822 phrases.
+A phrase is a sequence of words, which are in turn either RFC 2822
+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 += 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.phraseends:
+break
+else:
+plist.append(self.getatom(self.phraseends))
+return plist
+class AddressList(AddrlistClass):
+"""An AddressList encapsulates a list of parsed RFC 2822 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 ", ".join(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 __iadd__(self, other):
+# Set union, in-place
+for x in other.addresslist:
+if not x in self.addresslist:
+self.addresslist.append(x)
+return self
+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 __isub__(self, other):
+# Set difference, in-place
+for x in other.addresslist:
+if x in self.addresslist:
+self.addresslist.remove(x)
+return self
+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.
+"""
+if not data:
+return None
+data = data.split()
+if data[0][-1] in (',', '.') or data[0].lower() in _daynames:
+# There's a dayname here. Skip it
+del data[0]
+else:
+# no space after the "weekday,"?
+i = data[0].rfind(',')
+if i >= 0:
+data[0] = data[0][i+1:]
+if len(data) == 3: # RFC 850 date, deprecated
+stuff = data[0].split('-')
+if len(stuff) == 3:
+data = stuff + data[1:]
+if len(data) == 4:
+s = data[3]
+i = s.find('+')
+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 = mm.lower()
+if not mm in _monthnames:
+dd, mm = mm, dd.lower()
+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 = yy.find(':')
+if i > 0:
+yy, tm = tm, yy
+if yy[-1] == ',':
+yy = yy[:-1]
+if not yy[0].isdigit():
+yy, tz = tz, yy
+if tm[-1] == ',':
+tm = tm[:-1]
+tm = tm.split(':')
+if len(tm) == 2:
+[thh, tmm] = tm
+tss = '0'
+elif len(tm) == 3:
+[thh, tmm, tss] = tm
+else:
+return None
+try:
+yy = int(yy)
+dd = int(dd)
+thh = int(thh)
+tmm = int(tmm)
+tss = int(tss)
+except ValueError:
+return None
+tzoffset = None
+tz = tz.upper()
+if tz in _timezones:
+tzoffset = _timezones[tz]
+else:
+try:
+tzoffset = int(tz)
+except ValueError:
+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)
+return (yy, mm, dd, thh, tmm, tss, 0, 1, 0, tzoffset)
+def parsedate(data):
+"""Convert a time string to a time tuple."""
+t = parsedate_tz(data)
+if t is None:
+return t
+return t[:9]
+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
+According to RFC 1123, day and month names must always be in
+English.  If not for that, this code could use strftime().  It
+can't because strftime() honors the locale and could generated
+non-English names.
+"""
+if timeval is None:
+timeval = time.time()
+timeval = time.gmtime(timeval)
+return "%s, %02d %s %04d %02d:%02d:%02d GMT" % (
+("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun")[timeval[6]],
+timeval[2],
+("Jan", "Feb", "Mar", "Apr", "May", "Jun",
+"Jul", "Aug", "Sep", "Oct", "Nov", "Dec")[timeval[1]-1],
+timeval[0], timeval[3], timeval[4], timeval[5])
+# 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')
+tz = date[-1]
+date = time.localtime(mktime_tz(date))
+if date:
+print 'ParsedDate:', time.asctime(date),
+hhmmss = tz
+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 += 1
+print 'Lines:', n
+print '-'*70
+print 'len =', len(m)
+if 'Date' in m: print 'Date =', m['Date']
+if 'X-Nonsense' in m: pass
+print 'keys =', m.keys()
+print 'values =', m.values()
+print 'items =', m.items()