Fixed #7712, #9404, #10249, #10300: a light refactor and cleanup of file storage and the File object. Thanks to Armin Ronacher and Alex Gaynor.

git-svn-id: http://code.djangoproject.com/svn/django/trunk@10717 bcc190cf-cafb-0310-a4f2-bffc1f526a37

django/core/files/uploadedfile.py

@@ -26,14 +26,15 @@ class UploadedFile(File):
     """
     DEFAULT_CHUNK_SIZE = 64 * 2**10
 
-    def __init__(self, name=None, content_type=None, size=None, charset=None):
-        self.name = name
+    def __init__(self, file=None, name=None, content_type=None, size=None, charset=None):
+        super(UploadedFile, self).__init__(file, name)
         self.size = size
         self.content_type = content_type
         self.charset = charset
 
     def __repr__(self):
-        return "<%s: %s (%s)>" % (self.__class__.__name__, smart_str(self.name), self.content_type)
+        return "<%s: %s (%s)>" % (
+            self.__class__.__name__, smart_str(self.name), self.content_type)
 
     def _get_name(self):
         return self._name
@@ -53,95 +54,66 @@ class UploadedFile(File):
 
     name = property(_get_name, _set_name)
 
-    # Abstract methods; subclasses *must* define read() and probably should
-    # define open/close.
-    def read(self, num_bytes=None):
-        raise NotImplementedError()
-
-    def open(self):
-        pass
-
-    def close(self):
-        pass
-
 class TemporaryUploadedFile(UploadedFile):
     """
     A file uploaded to a temporary location (i.e. stream-to-disk).
     """
     def __init__(self, name, content_type, size, charset):
-        super(TemporaryUploadedFile, self).__init__(name, content_type, size, charset)
         if settings.FILE_UPLOAD_TEMP_DIR:
-            self._file = tempfile.NamedTemporaryFile(suffix='.upload', dir=settings.FILE_UPLOAD_TEMP_DIR)
+            file = tempfile.NamedTemporaryFile(suffix='.upload',
+                dir=settings.FILE_UPLOAD_TEMP_DIR)
         else:
-            self._file = tempfile.NamedTemporaryFile(suffix='.upload')
+            file = tempfile.NamedTemporaryFile(suffix='.upload')
+        super(TemporaryUploadedFile, self).__init__(file, name, content_type, size, charset)
 
     def temporary_file_path(self):
         """
         Returns the full path of this file.
         """
-        return self._file.name
+        return self.file.name
 
-    # Most methods on this object get proxied to NamedTemporaryFile.
-    # We can't directly subclass because NamedTemporaryFile is actually a
-    # factory function
-    def read(self, *args):          return self._file.read(*args)
-    def seek(self, *args):          return self._file.seek(*args)
-    def write(self, s):             return self._file.write(s)
-    def tell(self, *args):          return self._file.tell(*args)
-    def __iter__(self):             return iter(self._file)
-    def readlines(self, size=None): return self._file.readlines(size)
-    def xreadlines(self):           return self._file.xreadlines()
     def close(self):
         try:
-            return self._file.close()
-        except OSError, e:
-            if e.errno == 2:
-                # Means the file was moved or deleted before the tempfile could unlink it.
-                # Still sets self._file.close_called and calls self._file.file.close()
-                # before the exception
-                return
-            else:
-                raise e
+            try:
+                return self.file.close()
+            except OSError, e:
+                if e.errno != 2:
+                    # Means the file was moved or deleted before the tempfile
+                    # could unlink it.  Still sets self.file.close_called and
+                    # calls self.file.file.close() before the exception
+                    raise
+        finally:
+            self.closed = True
 
 class InMemoryUploadedFile(UploadedFile):
     """
     A file uploaded into memory (i.e. stream-to-memory).
     """
     def __init__(self, file, field_name, name, content_type, size, charset):
-        super(InMemoryUploadedFile, self).__init__(name, content_type, size, charset)
-        self._file = file
+        super(InMemoryUploadedFile, self).__init__(file, name, content_type, size, charset)
         self.field_name = field_name
-        self._file.seek(0)
 
     def open(self):
-        self._file.seek(0)
+        self.closed = False
+        self.file.seek(0)
 
     def chunks(self, chunk_size=None):
-        self._file.seek(0)
+        self.file.seek(0)
         yield self.read()
 
     def multiple_chunks(self, chunk_size=None):
         # Since it's in memory, we'll never have multiple chunks.
         return False
 
-    # proxy methods to StringIO
-    def read(self, *args): return self._file.read(*args)
-    def seek(self, *args): return self._file.seek(*args)
-    def tell(self, *args): return self._file.tell(*args)
-    def close(self):       return self._file.close()
 
 class SimpleUploadedFile(InMemoryUploadedFile):
     """
     A simple representation of a file, which just has content, size, and a name.
     """
     def __init__(self, name, content, content_type='text/plain'):
-        self._file = StringIO(content or '')
-        self.name = name
-        self.field_name = None
-        self.size = len(content or '')
-        self.content_type = content_type
-        self.charset = None
-        self._file.seek(0)
+        content = content or ''
+        super(SimpleUploadedFile, self).__init__(StringIO(content), None, name,
+                                                 content_type, len(content), None)
 
     def from_dict(cls, file_dict):
         """
@@ -154,5 +126,4 @@ class SimpleUploadedFile(InMemoryUploadedFile):
         return cls(file_dict['filename'],
                    file_dict['content'],
                    file_dict.get('content-type', 'text/plain'))
-
     from_dict = classmethod(from_dict)