3 files changed, 0 insertions, 1647 deletions

diff --git a/Mailman/pythonlib/rfc822.py b/Mailman/pythonlib/rfc822.py
deleted file mode 100644
index d7403b23a..000000000
--- a/Mailman/pythonlib/rfc822.py
+++ /dev/null
@@ -1,951 +0,0 @@
-"""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.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)
-                x = (self.dict[headerseen] + "\n " + string.strip(line))
-                self.dict[headerseen] = string.strip(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)
-                self.dict[headerseen] = string.strip(line[len(headerseen)+2:])
-                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):
-        """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 = string.lower(name) + ':'
-        n = len(name)
-        list = []
-        hit = 0
-        for line in self.headers:
-            if string.lower(line[:n]) == name:
-                hit = 1
-            elif line[:1] not in string.whitespace:
-                hit = 0
-            if hit:
-                list.append(line)
-        return list
-    
-    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 = string.lower(name) + ':'
-        n = len(name)
-        list = []
-        hit = 0
-        for line in self.headers:
-            if hit:
-                if line[:1] not in string.whitespace:
-                    break
-            elif string.lower(line[:n]) == name:
-                hit = 1
-            if hit:
-                list.append(line)
-        return list
-    
-    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):
-        """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] in string.whitespace:
-                if current:
-                    current = "%s\n %s" % (current, string.strip(s))
-                else:
-                    current = string.strip(s)
-            else:
-                if have_header:
-                    result.append(current)
-                current = string.strip(s[string.find(s, ":") + 1:])
-                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 = 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 < fieldlen:
-                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.addrlist[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()
diff --git a/Mailman/pythonlib/smtplib.py b/Mailman/pythonlib/smtplib.py
deleted file mode 100755
index 0ac6018e9..000000000
--- a/Mailman/pythonlib/smtplib.py
+++ /dev/null
@@ -1,550 +0,0 @@
-#! /usr/bin/env python
-
-'''SMTP/ESMTP client class.
-
-This should follow RFC 821 (SMTP) and RFC 1869 (ESMTP).
-
-Notes:
-
-Please remember, when doing ESMTP, that the names of the SMTP service
-extensions are NOT the same thing as the option keywords for the RCPT
-and MAIL commands!
-
-Example:
-
-  >>> import smtplib
-  >>> s=smtplib.SMTP("localhost")
-  >>> print s.help()
-  This is Sendmail version 8.8.4
-  Topics:
-      HELO    EHLO    MAIL    RCPT    DATA
-      RSET    NOOP    QUIT    HELP    VRFY
-      EXPN    VERB    ETRN    DSN
-  For more info use "HELP <topic>".
-  To report bugs in the implementation send email to
-      sendmail-bugs@sendmail.org.
-  For local information send email to Postmaster at your site.
-  End of HELP info
-  >>> s.putcmd("vrfy","someone@here")
-  >>> s.getreply()
-  (250, "Somebody OverHere <somebody@here.my.org>")
-  >>> s.quit()
-'''
-
-# Author: The Dragon De Monsyne <dragondm@integral.org>
-# ESMTP support, test code and doc fixes added by
-#     Eric S. Raymond <esr@thyrsus.com>
-# Better RFC 821 compliance (MAIL and RCPT, and CRLF in data)
-#     by Carey Evans <c.evans@clear.net.nz>, for picky mail servers.
-#    
-# This was modified from the Python 1.5 library HTTP lib.
-
-import socket
-import string
-import re
-import rfc822
-import types
-
-SMTP_PORT = 25
-CRLF="\r\n"
-
-# Exception classes used by this module. 
-class SMTPException(Exception):
-    """Base class for all exceptions raised by this module."""
-
-class SMTPServerDisconnected(SMTPException):
-    """Not connected to any SMTP server.
-
-    This exception is raised when the server unexpectedly disconnects,
-    or when an attempt is made to use the SMTP instance before
-    connecting it to a server.
-    """
-
-class SMTPResponseException(SMTPException):
-    """Base class for all exceptions that include an SMTP error code.
-
-    These exceptions are generated in some instances when the SMTP
-    server returns an error code.  The error code is stored in the
-    `smtp_code' attribute of the error, and the `smtp_error' attribute
-    is set to the error message.
-    """
-
-    def __init__(self, code, msg):
-        self.smtp_code = code
-        self.smtp_error = msg
-        self.args = (code, msg)
-
-class SMTPSenderRefused(SMTPResponseException):
-    """Sender address refused.
-    In addition to the attributes set by on all SMTPResponseException
-    exceptions, this sets `sender' to the string that the SMTP refused.
-    """
-
-    def __init__(self, code, msg, sender):
-        self.smtp_code = code
-        self.smtp_error = msg
-        self.sender = sender
-        self.args = (code, msg, sender)
-
-class SMTPRecipientsRefused(SMTPException):
-    """All recipient addresses refused.
-    The errors for each recipient are accessible through the attribute
-    'recipients', which is a dictionary of exactly the same sort as 
-    SMTP.sendmail() returns.  
-    """
-
-    def __init__(self, recipients):
-        self.recipients = recipients
-        self.args = ( recipients,)
-
-
-class SMTPDataError(SMTPResponseException):
-    """The SMTP server didn't accept the data."""
-
-class SMTPConnectError(SMTPResponseException):
-    """Error during connection establishment."""
-
-class SMTPHeloError(SMTPResponseException):
-    """The server refused our HELO reply."""
-
-
-def quoteaddr(addr):
-    """Quote a subset of the email addresses defined by RFC 821.
-
-    Should be able to handle anything rfc822.parseaddr can handle.
-    """
-    m=None
-    try:
-        m=rfc822.parseaddr(addr)[1]
-    except AttributeError:
-        pass
-    if not m:
-        #something weird here.. punt -ddm
-        return addr
-    else:
-        return "<%s>" % m
-
-def quotedata(data):
-    """Quote data for email.
-
-    Double leading '.', and change Unix newline '\\n', or Mac '\\r' into
-    Internet CRLF end-of-line.
-    """
-    return re.sub(r'(?m)^\.', '..',
-        re.sub(r'(?:\r\n|\n|\r(?!\n))', CRLF, data))
-
-def _get_fqdn_hostname(name):
-    name = string.strip(name)
-    if len(name) == 0:
-        name = socket.gethostname()
-        try:
-            hostname, aliases, ipaddrs = socket.gethostbyaddr(name)
-        except socket.error:
-            pass
-        else:
-            aliases.insert(0, hostname)
-            for name in aliases:
-                if '.' in name:
-                    break
-            else:
-                name = hostname
-    return name
-
-
-class SMTP:
-    """This class manages a connection to an SMTP or ESMTP server.
-    SMTP Objects:
-        SMTP objects have the following attributes:    
-            helo_resp 
-                This is the message given by the server in response to the 
-                most recent HELO command.
-                
-            ehlo_resp
-                This is the message given by the server in response to the 
-                most recent EHLO command. This is usually multiline.
-
-            does_esmtp 
-                This is a True value _after you do an EHLO command_, if the
-                server supports ESMTP.
-
-            esmtp_features 
-                This is a dictionary, which, if the server supports ESMTP,
-                will _after you do an EHLO command_, contain the names of the
-                SMTP service extensions this server supports, and their
-                parameters (if any).
-
-                Note, all extension names are mapped to lower case in the 
-                dictionary. 
-
-        See each method's docstrings for details.  In general, there is a
-        method of the same name to perform each SMTP command.  There is also a
-        method called 'sendmail' that will do an entire mail transaction.
-        """
-    debuglevel = 0
-    file = None
-    helo_resp = None
-    ehlo_resp = None
-    does_esmtp = 0
-
-    def __init__(self, host = '', port = 0):
-        """Initialize a new instance.
-
-        If specified, `host' is the name of the remote host to which to
-        connect.  If specified, `port' specifies the port to which to connect.
-        By default, smtplib.SMTP_PORT is used.  An SMTPConnectError is raised
-        if the specified `host' doesn't respond correctly.
-
-        """
-        self.esmtp_features = {}
-        if host:
-            (code, msg) = self.connect(host, port)
-            if code != 220:
-                raise SMTPConnectError(code, msg)
-    
-    def set_debuglevel(self, debuglevel):
-        """Set the debug output level.
-
-        A non-false value results in debug messages for connection and for all
-        messages sent to and received from the server.
-
-        """
-        self.debuglevel = debuglevel
-
-    def connect(self, host='localhost', port = 0):
-        """Connect to a host on a given port.
-
-        If the hostname ends with a colon (`:') followed by a number, and
-        there is no port specified, that suffix will be stripped off and the
-        number interpreted as the port number to use.
-
-        Note: This method is automatically invoked by __init__, if a host is
-        specified during instantiation.
-
-        """
-        if not port:
-            i = string.find(host, ':')
-            if i >= 0:
-                host, port = host[:i], host[i+1:]
-                try: port = string.atoi(port)
-                except string.atoi_error:
-                    raise socket.error, "nonnumeric port"
-        if not port: port = SMTP_PORT
-        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        if self.debuglevel > 0: print 'connect:', (host, port)
-        try:
-            self.sock.connect((host, port))
-        except socket.error:
-            self.close()
-            raise
-        (code,msg)=self.getreply()
-        if self.debuglevel >0 : print "connect:", msg
-        return (code,msg)
-    
-    def send(self, str):
-        """Send `str' to the server."""
-        if self.debuglevel > 0: print 'send:', `str`
-        if self.sock:
-            try:
-                sendptr = 0
-                while sendptr < len(str):
-                    sendptr = sendptr + self.sock.send(str[sendptr:])
-            except socket.error:
-                raise SMTPServerDisconnected('Server not connected')
-        else:
-            raise SMTPServerDisconnected('please run connect() first')
- 
-    def putcmd(self, cmd, args=""):
-        """Send a command to the server."""
-        if args == "":
-            str = '%s%s' % (cmd, CRLF)
-        else:
-            str = '%s %s%s' % (cmd, args, CRLF)
-        self.send(str)
-    
-    def getreply(self):
-        """Get a reply from the server.
-        
-        Returns a tuple consisting of:
-
-          - server response code (e.g. '250', or such, if all goes well)
-            Note: returns -1 if it can't read response code.
-
-          - server response string corresponding to response code (multiline
-            responses are converted to a single, multiline string).
-
-        Raises SMTPServerDisconnected if end-of-file is reached.
-        """
-        resp=[]
-        if self.file is None:
-            self.file = self.sock.makefile('rb')
-        while 1:
-            line = self.file.readline()
-            if line == '':
-                self.close()
-                raise SMTPServerDisconnected("Connection unexpectedly closed")
-            if self.debuglevel > 0: print 'reply:', `line`
-            resp.append(string.strip(line[4:]))
-            code=line[:3]
-            # Check that the error code is syntactically correct.
-            # Don't attempt to read a continuation line if it is broken.
-            try:
-                errcode = string.atoi(code)
-            except ValueError:
-                errcode = -1
-                break
-            # Check if multiline response.
-            if line[3:4]!="-":
-                break
-
-        errmsg = string.join(resp,"\n")
-        if self.debuglevel > 0: 
-            print 'reply: retcode (%s); Msg: %s' % (errcode,errmsg)
-        return errcode, errmsg
-    
-    def docmd(self, cmd, args=""):
-        """Send a command, and return its response code."""
-        self.putcmd(cmd,args)
-        return self.getreply()
-
-    # std smtp commands
-    def helo(self, name=''):
-        """SMTP 'helo' command.
-        Hostname to send for this command defaults to the FQDN of the local
-        host.
-        """
-        self.putcmd("helo", _get_fqdn_hostname(name))
-        (code,msg)=self.getreply()
-        self.helo_resp=msg
-        return (code,msg)
-
-    def ehlo(self, name=''):
-        """ SMTP 'ehlo' command.
-        Hostname to send for this command defaults to the FQDN of the local
-        host.
-        """
-        self.putcmd("ehlo", _get_fqdn_hostname(name))
-        (code,msg)=self.getreply()
-        # According to RFC1869 some (badly written) 
-        # MTA's will disconnect on an ehlo. Toss an exception if 
-        # that happens -ddm
-        if code == -1 and len(msg) == 0:
-            raise SMTPServerDisconnected("Server not connected")
-        self.ehlo_resp=msg
-        if code<>250:
-            return (code,msg)
-        self.does_esmtp=1
-        #parse the ehlo response -ddm
-        resp=string.split(self.ehlo_resp,'\n')
-        del resp[0]
-        for each in resp:
-            m=re.match(r'(?P<feature>[A-Za-z0-9][A-Za-z0-9\-]*)',each)
-            if m:
-                feature=string.lower(m.group("feature"))
-                params=string.strip(m.string[m.end("feature"):])
-                self.esmtp_features[feature]=params
-        return (code,msg)
-
-    def has_extn(self, opt):
-        """Does the server support a given SMTP service extension?"""
-        return self.esmtp_features.has_key(string.lower(opt))
-
-    def help(self, args=''):
-        """SMTP 'help' command.
-        Returns help text from server."""
-        self.putcmd("help", args)
-        return self.getreply()
-
-    def rset(self):
-        """SMTP 'rset' command -- resets session."""
-        return self.docmd("rset")
-
-    def noop(self):
-        """SMTP 'noop' command -- doesn't do anything :>"""
-        return self.docmd("noop")
-
-    def mail(self,sender,options=[]):
-        """SMTP 'mail' command -- begins mail xfer session."""
-        optionlist = ''
-        if options and self.does_esmtp:
-            optionlist = ' ' + string.join(options, ' ')
-        self.putcmd("mail", "FROM:%s%s" % (quoteaddr(sender) ,optionlist))
-        return self.getreply()
-
-    def rcpt(self,recip,options=[]):
-        """SMTP 'rcpt' command -- indicates 1 recipient for this mail."""
-        optionlist = ''
-        if options and self.does_esmtp:
-            optionlist = ' ' + string.join(options, ' ')
-        self.putcmd("rcpt","TO:%s%s" % (quoteaddr(recip),optionlist))
-        return self.getreply()
-
-    def data(self,msg):
-        """SMTP 'DATA' command -- sends message data to server. 
-
-        Automatically quotes lines beginning with a period per rfc821.
-        Raises SMTPDataError if there is an unexpected reply to the
-        DATA command; the return value from this method is the final
-        response code received when the all data is sent.
-        """
-        self.putcmd("data")
-        (code,repl)=self.getreply()
-        if self.debuglevel >0 : print "data:", (code,repl)
-        if code <> 354:
-            raise SMTPDataError(code,repl)
-        else:
-            q = quotedata(msg)
-            if q[-2:] != CRLF:
-                q = q + CRLF
-            q = q + "." + CRLF
-            self.send(q)
-            (code,msg)=self.getreply()
-            if self.debuglevel >0 : print "data:", (code,msg)
-            return (code,msg)
-
-    def verify(self, address):
-        """SMTP 'verify' command -- checks for address validity."""
-        self.putcmd("vrfy", quoteaddr(address))
-        return self.getreply()
-    # a.k.a.
-    vrfy=verify
-
-    def expn(self, address):
-        """SMTP 'verify' command -- checks for address validity."""
-        self.putcmd("expn", quoteaddr(address))
-        return self.getreply()
-
-    # some useful methods
-    def sendmail(self, from_addr, to_addrs, msg, mail_options=[],
-                 rcpt_options=[]): 
-        """This command performs an entire mail transaction. 
-
-        The arguments are: 
-            - from_addr    : The address sending this mail.
-            - to_addrs     : A list of addresses to send this mail to.  A bare
-                             string will be treated as a list with 1 address.
-            - msg          : The message to send. 
-            - mail_options : List of ESMTP options (such as 8bitmime) for the
-                             mail command.
-            - rcpt_options : List of ESMTP options (such as DSN commands) for
-                             all the rcpt commands.
-
-        If there has been no previous EHLO or HELO command this session, this
-        method tries ESMTP EHLO first.  If the server does ESMTP, message size
-        and each of the specified options will be passed to it.  If EHLO
-        fails, HELO will be tried and ESMTP options suppressed.
-
-        This method will return normally if the mail is accepted for at least
-        one recipient.  It returns a dictionary, with one entry for each
-        recipient that was refused.  Each entry contains a tuple of the SMTP
-        error code and the accompanying error message sent by the server.
-
-        This method may raise the following exceptions:
-
-         SMTPHeloError          The server didn't reply properly to
-                                the helo greeting. 
-         SMTPRecipientsRefused  The server rejected ALL recipients
-                                (no mail was sent).
-         SMTPSenderRefused      The server didn't accept the from_addr.
-         SMTPDataError          The server replied with an unexpected
-                                error code (other than a refusal of
-                                a recipient).
-
-        Note: the connection will be open even after an exception is raised.
-
-        Example:
-      
-         >>> import smtplib
-         >>> s=smtplib.SMTP("localhost")
-         >>> tolist=["one@one.org","two@two.org","three@three.org","four@four.org"]
-         >>> msg = '''
-         ... From: Me@my.org
-         ... Subject: testin'...
-         ...
-         ... This is a test '''
-         >>> s.sendmail("me@my.org",tolist,msg)
-         { "three@three.org" : ( 550 ,"User unknown" ) }
-         >>> s.quit()
-        
-        In the above example, the message was accepted for delivery to three
-        of the four addresses, and one was rejected, with the error code
-        550.  If all addresses are accepted, then the method will return an
-        empty dictionary.
-
-        """
-        if self.helo_resp is None and self.ehlo_resp is None:
-            if not (200 <= self.ehlo()[0] <= 299):
-                (code,resp) = self.helo()
-                if not (200 <= code <= 299):
-                    raise SMTPHeloError(code, resp)
-        esmtp_opts = []
-        if self.does_esmtp:
-            # Hmmm? what's this? -ddm
-            # self.esmtp_features['7bit']=""
-            if self.has_extn('size'):
-                esmtp_opts.append("size=" + `len(msg)`)
-            for option in mail_options:
-                esmtp_opts.append(option)
-
-        (code,resp) = self.mail(from_addr, esmtp_opts)
-        if code <> 250:
-            self.rset()
-            raise SMTPSenderRefused(code, resp, from_addr)
-        senderrs={}
-        if type(to_addrs) == types.StringType:
-            to_addrs = [to_addrs]
-        for each in to_addrs:
-            (code,resp)=self.rcpt(each, rcpt_options)
-            if (code <> 250) and (code <> 251):
-                senderrs[each]=(code,resp)
-        if len(senderrs)==len(to_addrs):
-            # the server refused all our recipients
-            self.rset()
-            raise SMTPRecipientsRefused(senderrs)
-        (code,resp)=self.data(msg)
-        if code <> 250:
-            self.rset()
-            raise SMTPDataError(code, resp)
-        #if we got here then somebody got our mail
-        return senderrs         
-
-
-    def close(self):
-        """Close the connection to the SMTP server."""
-        if self.file:
-            self.file.close()
-        self.file = None
-        if self.sock:
-            self.sock.close()
-        self.sock = None
-
-
-    def quit(self):
-        """Terminate the SMTP session."""
-        self.docmd("quit")
-        self.close()
-
-
-# Test the sendmail method, which tests most of the others.
-# Note: This always sends to localhost.
-if __name__ == '__main__':
-    import sys, rfc822
-
-    def prompt(prompt):
-        sys.stdout.write(prompt + ": ")
-        return string.strip(sys.stdin.readline())
-
-    fromaddr = prompt("From")
-    toaddrs  = string.splitfields(prompt("To"), ',')
-    print "Enter message, end with ^D:"
-    msg = ''
-    while 1:
-        line = sys.stdin.readline()
-        if not line:
-            break
-        msg = msg + line
-    print "Message length is " + `len(msg)`
-
-    server = SMTP('localhost')
-    server.set_debuglevel(1)
-    server.sendmail(fromaddr, toaddrs, msg)
-    server.quit()
diff --git a/Mailman/pythonlib/tempfile.py b/Mailman/pythonlib/tempfile.py
deleted file mode 100644
index 7c59eb6a5..000000000
--- a/Mailman/pythonlib/tempfile.py
+++ /dev/null
@@ -1,146 +0,0 @@
-# Temporary file name allocation
-#
-# XXX This tries to be not UNIX specific, but I don't know beans about
-# how to choose a temp directory or filename on MS-DOS or other
-# systems so it may have to be changed...
-
-
-import os
-
-
-# Parameters that the caller may set to override the defaults
-
-tempdir = None
-template = None
-
-
-# Function to calculate the directory to use
-
-def gettempdir():
-    global tempdir
-    if tempdir is not None:
-        return tempdir
-    try:
-        pwd = os.getcwd()
-    except (AttributeError, os.error):
-        pwd = os.curdir
-    attempdirs = ['/usr/tmp', '/tmp', pwd]
-    if os.name == 'nt':
-        attempdirs.insert(0, 'C:\\TEMP')
-        attempdirs.insert(0, '\\TEMP')
-    elif os.name == 'mac':
-        import macfs, MACFS
-        try:
-             refnum, dirid = macfs.FindFolder(MACFS.kOnSystemDisk,
-                                              MACFS.kTemporaryFolderType, 1)
-             dirname = macfs.FSSpec((refnum, dirid, '')).as_pathname()
-             attempdirs.insert(0, dirname)
-        except macfs.error:
-            pass
-    for envname in 'TMPDIR', 'TEMP', 'TMP':
-        if os.environ.has_key(envname):
-            attempdirs.insert(0, os.environ[envname])
-    testfile = gettempprefix() + 'test'
-    for dir in attempdirs:
-        try:
-            filename = os.path.join(dir, testfile)
-            fp = open(filename, 'w')
-            fp.write('blat')
-            fp.close()
-            os.unlink(filename)
-            tempdir = dir
-            break
-        except IOError:
-            pass
-    if tempdir is None:
-        msg = "Can't find a usable temporary directory amongst " + `attempdirs`
-        raise IOError, msg
-    return tempdir
-
-
-# Function to calculate a prefix of the filename to use
-
-_pid = None
-
-def gettempprefix():
-    global template, _pid
-    if os.name == 'posix' and _pid and _pid != os.getpid():
-        # Our pid changed; we must have forked -- zap the template
-        template = None
-    if template is None:
-        if os.name == 'posix':
-            _pid = os.getpid()
-            template = '@' + `_pid` + '.'
-        elif os.name == 'nt':
-            template = '~' + `os.getpid()` + '-'
-        elif os.name == 'mac':
-            template = 'Python-Tmp-'
-        else:
-            template = 'tmp' # XXX might choose a better one
-    return template
-
-
-# Counter for generating unique names
-
-counter = 0
-
-
-# User-callable function to return a unique temporary file name
-
-def mktemp(suffix=""):
-    global counter
-    dir = gettempdir()
-    pre = gettempprefix()
-    while 1:
-        counter = counter + 1
-        file = os.path.join(dir, pre + `counter` + suffix)
-        if not os.path.exists(file):
-            return file
-
-
-class TemporaryFileWrapper:
-    """Temporary file wrapper
-
-    This class provides a wrapper around files opened for temporary use.
-    In particular, it seeks to automatically remove the file when it is
-    no longer needed.
-    """
-    def __init__(self, file, path):
-        self.file = file
-        self.path = path
-
-    def close(self):
-        self.file.close()
-        os.unlink(self.path)
-
-    def __del__(self):
-        try: self.close()
-        except: pass
-
-    def __getattr__(self, name):
-        file = self.__dict__['file']
-        a = getattr(file, name)
-        setattr(self, name, a)
-        return a
-
-
-def TemporaryFile(mode='w+b', bufsize=-1, suffix=""):
-    name = mktemp(suffix)
-    if os.name == 'posix':
-        # Unix -- be very careful
-        fd = os.open(name, os.O_RDWR|os.O_CREAT|os.O_EXCL, 0700)
-        try:
-            os.unlink(name)
-            return os.fdopen(fd, mode, bufsize)
-        except:
-            os.close(fd)
-            # this is a divergence from the Python 1.5.2 copy.  Mailman can't
-            # guarantee that Python 1.5.1 or better is being used, and Python
-            # 1.5 doesn't have bare raise.
-            import sys
-            t, v, tb = sys.exc_info()
-            raise t, v, tb
-    else:
-        # Non-unix -- can't unlink file that's still open, use wrapper
-        file = open(name, mode, bufsize)
-        return TemporaryFileWrapper(file, name)