On 17 March 2003, I said:
> I'll take Dave's suggestion and see how tempfile does it and maybe even
> use that module instead of reinventing the wheel.

Sigh.  Turns out that tempfile.py is lazy too:

  def mktemp(suffix=""):
      """User-callable function to return a unique temporary file name."""
      dir = gettempdir()
      pre = gettempprefix()
      while 1:
          i = _counter.get_next()
          file = os.path.join(dir, pre + str(i) + suffix)
          if not os.path.exists(file):           <<< race condition again!
              return file

Also, it doesn't provide a very satisfactory means for supplying the
directory where temp files go -- all you can do is set a module-level
global, which will affect everyone else in that process using tempfile.
Yuck.  So here's another crack at patching this:

--- upload.py   (revision 21160)
+++ upload.py   (working copy)
@@ -11,6 +11,8 @@
 __revision__ = "$Id$"

 import os, string
+import errno
+from random import random
 from cgi import parse_header
 from rfc822 import Message
 from time import time, strftime, localtime
@@ -149,13 +151,46 @@
     def __repr__ (self):
         return "<%s at %x: %s>" % (self.__class__.__name__, id(self), self)

+    def _open (self, dir):
+        """
+        Generate a unique filename in 'dir'.  Open and return a
+        writeable file object.
+        """
+        while 1:
+            now = time()
+            tstamp = strftime("%Y%m%d.%H%M%S", localtime(now))
+
+            # Get 32 bits of fuzz -- don't use sys.maxint in case this
+            # is a 64-bit machine -- 32 bits is plenty.
+            # XXX random() not threadsafe!
+            fuzz = "%08x" % (random() * 2147483647)
+            filename = "upload.%s.%s.%s" % (tstamp, os.getpid(), fuzz)
+            filename = os.path.join(dir, filename)
+            flags = os.O_WRONLY|os.O_CREAT|os.O_EXCL
+            try:
+                flags |= os.O_BINARY    # for Windows
+            except AttributeError:
+                pass
+            try:
+                fd = os.open(filename, flags)
+            except OSError, err:
+                if err.strerror == errno.EAGAIN:
+                    # Filename collision -- try again on the
+                    # next time through the loop.
+                    pass
+                else:
+                    # Bomb on any other error.
+                    raise
+            else:
+                # Opened the file just fine; it now exists so no other
+                # process or thread will be able to grab that filename.
+                break
+
+        # Wrap a file object around the file descriptor.
+        return os.fdopen(fd, "wb")
+
     def receive (self, file, boundary, dir):
-        now = time()
-        tstamp = (strftime("%Y%m%d.%H%M%S", localtime(now)) +
-                  ("%.3f" % (now % 1))[1:])
-        filename = "upload.%s.%s" % (tstamp, os.getpid())
-        filename = os.path.join(dir, filename)
-        ofile = open(filename, "wb")
+        ofile = self._open(dir)
         done = read_mime_part(file, boundary, ofile=ofile)
         ofile.close()
         self.tmp_filename = filename


As before, this is *completely untested*.  Please read the code
carefully and see if it makes sense.  I'll go give it a shot on Linux
now; Graham, can you please give it a try on Windows?  Also, can someone
test to see if O_EXCL actually works on Windows?

        Greg
--
Greg Ward - software developer                gward@mems-exchange.org
MEMS Exchange                            http://www.mems-exchange.org