Ticket #7614: 7814_cleanups.diff

django/db/models/base.py

@@ -536 +536 @@
-            # This is a normal uploadedfile that we can stream.
-            fp = open(full_filename, 'wb')
-            locks.lock(fp, locks.LOCK_EX)
-
+s
-                fp.write(chunk)
-            locks.unlock(fp)
-            fp.close()

django/db/models/fields/__init__.py

@@ -766 +766 @@
-    def get_db_prep_save(self, value):
-        "Returns field's value prepared for saving into a database."
-        # Need to convert UploadedFile objects provided via a form to unicode for database insertion
-
+
+
+
-            return None
-
+
+
-
-    def get_manipulator_fields(self, opts, manipulator, change, name_prefix='', rel=False, follow=True):
-        field_list = Field.get_manipulator_fields(self, opts, manipulator, change, name_prefix, rel, follow)
@@ -842 +845 @@
-            # We don't need to raise a warning because Model._save_FIELD_file will
-            # do so for us.
-            try:
-file_
+
-            except AttributeError:
-                file_name = file['filename']
-
@@ -857 +860 @@
-        return os.path.normpath(f)
-
-    def save_form_data(self, instance, data):
-newforms.fields
+core.files.uploadedfile
-        if data and isinstance(data, UploadedFile):
-filename, data.
+name, 
-
-    def formfield(self, **kwargs):
-        defaults = {'form_class': forms.FileField}

django/oldforms/__init__.py

@@ -686 +686 @@
-            if upload_errors:
-                raise validators.CriticalValidationError, upload_errors
-        try:
-file_
+
-        except AttributeError:
-            file_size = len(new_data['content'])
-        if not file_size:

django/core/files/uploadedfile.py

@@ -3 +3 @@
-"""
-
-import os
+import tempfile
+import warnings
-try:
-    from cStringIO import StringIO
-except ImportError:
-    from StringIO import StringIO
-
-
+
-
+
+__all__ = ('UploadedFile', 'TemporaryUploadedFile', 'InMemoryUploadedFile', 'SimpleUploadedFile')
+
-class UploadedFile(object):
-    """
-    A abstract uploaded file (``TemporaryUploadedFile`` and
@@ -20 +25 @@
-    """
-    DEFAULT_CHUNK_SIZE = 64 * 2**10
-
-file_name=None, content_type=None, file_
-file_name = file_
-file_size = file_
+name=None, content_type=None, 
+name = 
+size = 
-        self.content_type = content_type
-        self.charset = charset
-
-    def __repr__(self):
-file_
+
-
-
+
+
+
+
-        # Sanitize the file name so that it can't be dangerous.
-        if name is not None:
-            # Just use the basename of the file -- anything else is dangerous.
-            name = os.path.basename(name)
-
+
-            # File names longer than 255 characters can cause problems on older OSes.
-            if len(name) > 255:
-                name, ext = os.path.splitext(name)
-                name = name[:255 - len(ext)] + ext
-
-
-
+
+
+
+
+
+
-    def _get_file_name(self):
-
-
-
+
+
+
+
+
+
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        """
-        Read the file and yield chucks of ``chunk_size`` bytes (defaults to
-        ``UploadedFile.DEFAULT_CHUNK_SIZE``).
@@ -58 +116 @@
-        if hasattr(self, 'seek'):
-            self.seek(0)
-        # Assume the pointer is at zero...
-file_
+
-
-        while counter > 0:
-            yield self.read(chunk_size)
-            counter -= chunk_size
-
+    def chunk(self, *args, **kwargs):
+        warnings.warn(
+            message = "Please use .chunks() instead of .chunk().",
+            category = DeprecationWarning,
+            stacklevel = 2
+            )
+        for chunk in self.chunks():
+            yield chunk
+
-    def multiple_chunks(self, chunk_size=None):
-        """
-        Returns ``True`` if you can expect multiple chunks.
@@ -74 +141 @@
-        """
-        if not chunk_size:
-            chunk_size = UploadedFile.DEFAULT_CHUNK_SIZE
-file_size <
+size >
-
-ault
+ine
-    # define open/close.
-    def read(self, num_bytes=None):
-        raise NotImplementedError()
@@ -87 +154 @@
-    def close(self):
-        pass
-
+    def xreadlines(self):
+        return self
+
+    def readlines(self):
+        return list(self.xreadlines())
+
+    def __iter__(self):
+        # Iterate over this file-like object by newlines
+        buffer_ = None
+        for chunk in self.chunks():
+            chunk_buffer = StringIO(chunk)
+
+            for line in chunk_buffer:
+                if buffer_:
+                    line = buffer_ + line
+                    buffer_ = None
+
+                # If this is the end of a line, yield
+                # otherwise, wait for the next round
+                if line[-1] in ('\n', '\r'):
+                    yield line
+                else:
+                    buffer_ = line
+
+        if buffer_ is not None:
+            yield buffer_
+
-    # Backwards-compatible support for uploaded-files-as-dictionaries.
-    def __getitem__(self, key):
-        import warnings
-        warnings.warn(
-            message = "The dictionary access of uploaded file objects is deprecated. Use the new object interface instead.",
-            category = DeprecationWarning,
-            stacklevel = 2
-        )
-        backwards_translate = {
-file_
+
-            'content-type': 'content_type',
-            }
-
-        if key == 'content':
-            return self.read()
-        elif key == 'filename':
-file_
+
-        elif key == 'content-type':
-            return self.content_type
-        else:
-            return getattr(self, key)
-
+
+def _proxy_to_file(method_name):
+    # Function factory to build proxy methods for the _file object.
+    def __inner_function(self, *args, **kwargs):
+        return getattr(self._file, method_name)(*args, **kwargs)
+    __inner_function.__name__ = method_name
+    return __inner_function
+
+
-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)
+        else:
+            self._file = tempfile.NamedTemporaryFile(suffix='.upload')
-
-    def __init__(self, file, file_name, content_type, file_size, charset):
-        super(TemporaryUploadedFile, self).__init__(file_name, content_type, file_size, charset)
-        self.file = file
-        self.path = file.name
-        self.file.seek(0)
-
-    def temporary_file_path(self):
-        """
-        Returns the full path of this file.
-        """
-path
+name
-
-
-
+
+
+
+
+
+
+
+
-
-    def open(self):
-        self.seek(0)
-
-    def seek(self, *args, **kwargs):
-        self.file.seek(*args, **kwargs)
-
-class InMemoryUploadedFile(UploadedFile):
-    """
-    A file uploaded into memory (i.e. stream-to-memory).
-    """
-file_name, content_type, file_
-file_name, content_type, file_
+name, content_type, 
+name, content_type, 
-        self.file = file
-        self.field_name = field_name
-        self.file.seek(0)
@@ -154 +257 @@
-    def read(self, *args, **kwargs):
-        return self.file.read(*args, **kwargs)
-
-
+s
-        self.file.seek(0)
-        yield self.read()
-
@@ -168 +271 @@
-    """
-    def __init__(self, name, content, content_type='text/plain'):
-        self.file = StringIO(content or '')
-file_
+
-        self.field_name = None
-file_
+
-        self.content_type = content_type
-        self.charset = None
-        self.file.seek(0)

django/core/files/uploadhandler.py

@@ -132 +132 @@
-        Create the file object to append to as data is coming in.
-        """
-        super(TemporaryFileUploadHandler, self).new_file(file_name, *args, **kwargs)
-
-
+
-
-    def receive_data_chunk(self, raw_data, start):
-
+file.
-
-    def file_complete(self, file_size):
-        self.file.seek(0)
-
-
-
-
-
-
-
+
+
-
-class MemoryFileUploadHandler(FileUploadHandler):
-    """
@@ -189 +183 @@
-        return InMemoryUploadedFile(
-            file = self.file,
-            field_name = self.field_name,
-file_
+
-            content_type = self.content_type,
-file_
+
-            charset = self.charset
-        )
-
-class TemporaryFile(object):
-    """
-    A temporary file that tries to delete itself when garbage collected.
-    """
-    def __init__(self, dir):
-        if not dir:
-            dir = tempfile.gettempdir()
-        try:
-            (fd, name) = tempfile.mkstemp(suffix='.upload', dir=dir)
-            self.file = os.fdopen(fd, 'w+b')
-        except (OSError, IOError):
-            raise OSError("Could not create temporary file for uploading, have you set settings.FILE_UPLOAD_TEMP_DIR correctly?")
-        self.name = name
-
-    def __getattr__(self, name):
-        a = getattr(self.__dict__['file'], name)
-        if type(a) != type(0):
-            setattr(self, name, a)
-        return a
-
-    def __del__(self):
-        try:
-            os.unlink(self.name)
-        except OSError:
-            pass
-
-def load_handler(path, *args, **kwargs):
-    """
-    Given a path to a handler, return an instance of that handler.

django/newforms/fields.py

@@ -27 +27 @@
-
-from util import ErrorList, ValidationError
-from widgets import TextInput, PasswordInput, HiddenInput, MultipleHiddenInput, FileInput, CheckboxInput, Select, NullBooleanSelect, SelectMultiple, DateTimeInput
+from django.core.files.uploadedfile import SimpleUploadedFile as UploadedFile
-
-
-__all__ = (
-    'Field', 'CharField', 'IntegerField',
-    'DEFAULT_DATE_INPUT_FORMATS', 'DateField',
@@ -419 +419 @@
-    # It's OK if Django settings aren't configured.
-    URL_VALIDATOR_USER_AGENT = 'Django (http://www.djangoproject.com/)'
-
-class UploadedFile(StrAndUnicode):
-    "A wrapper for files uploaded in a FileField"
-    def __init__(self, filename, data):
-        self.filename = filename
-        self.data = data
-
-    def __unicode__(self):
-        """
-        The unicode representation is the filename, so that the pre-database-insertion
-        logic can use UploadedFile objects
-        """
-        return self.filename
-
-class FileField(Field):
-    widget = FileInput
-    default_error_messages = {
@@ -460 +448 @@
-                category = DeprecationWarning,
-                stacklevel = 2
-            )
+            data = UploadedFile(data['filename'], data['content'])
-
-        try:
-file_
-file_
+
+
-        except AttributeError:
-
-
-
-
-
+
-
-        if not file_name:
-            raise ValidationError(self.error_messages['invalid'])
-        if not file_size:
-            raise ValidationError(self.error_messages['empty'])
-
-UploadedFile(file_name, data)
+data
-
-class ImageField(FileField):
-    default_error_messages = {

tests/modeltests/model_forms/models.py

@@ -803 +803 @@
->>> f.is_valid()
-True
->>> type(f.cleaned_data['file'])
-newforms.fields.
+core.files.uploadedfile.Simple
->>> instance = f.save()
->>> instance.file
-u'...test1.txt'
@@ -814 +814 @@
->>> f.is_valid()
-True
->>> type(f.cleaned_data['file'])
-newforms.fields.
+core.files.uploadedfile.Simple
->>> instance = f.save()
->>> instance.file
-u'...test1.txt'
@@ -906 +906 @@
->>> f.is_valid()
-True
->>> type(f.cleaned_data['image'])
-newforms.fields.
+core.files.uploadedfile.Simple
->>> instance = f.save()
->>> instance.image
-u'...test.png'
@@ -918 +918 @@
->>> f.is_valid()
-True
->>> type(f.cleaned_data['image'])
-newforms.fields.
+core.files.uploadedfile.Simple
->>> instance = f.save()
->>> instance.image
-u'...test.png'

tests/regressiontests/forms/fields.py

@@ -800 +800 @@
-ValidationError: [u'The submitted file is empty.']
-
->>> type(f.clean(SimpleUploadedFile('name', 'Some File Content')))
-newforms.fields.
+core.files.uploadedfile.Simple
-
->>> type(f.clean(SimpleUploadedFile('name', 'Some File Content'), 'files/test4.pdf'))
-newforms.fields.
+core.files.uploadedfile.Simple
-
-# URLField ##################################################################
-

docs/upload_handling.txt

@@ -22 +22 @@
-    class UploadFileForm(forms.Form):
-        title = forms.CharField(max_length=50)
-        file  = forms.FileField()
-
+
-A view handling this form will receive the file data in ``request.FILES``, which
-is a dictionary containing a key for each ``FileField`` (or ``ImageField``, or
-other ``FileField`` subclass) in the form. So the data from the above form would
@@ -64 +64 @@
-    ``UploadedFile.read()``
-        Read the entire uploaded data from the file. Be careful with this
-        method: if the uploaded file is huge it can overwhelm your system if you
-
+s
-        instead; see below.
-
+
-    ``UploadedFile.multiple_chunks()``
-        Returns ``True`` if the uploaded file is big enough to require
-        reading in multiple chunks. By default this will be any file
-        larger than 2.5 megabytes, but that's configurable; see below.
-
+
-    ``UploadedFile.chunk()``
-        A generator returning chunks of the file. If ``multiple_chunks()`` is
-        ``True``, you should use this method in a loop instead of ``read()``.
-
+
-        In practice, it's often easiest simply to use ``chunks()`` all the time;
-        see the example below.
-
+
-    ``UploadedFile.file_name``
-        The name of the uploaded file (e.g. ``my_file.txt``).
-
+
-    ``UploadedFile.file_size``
-        The size, in bytes, of the uploaded file.
-
+
-There are a few other methods and attributes available on ``UploadedFile``
-objects; see `UploadedFile objects`_ for a complete reference.
-
-Putting it all together, here's a common way you might handle an uploaded file::
-
+
-    def handle_uploaded_file(f):
-        destination = open('some/file/name.txt', 'wb')
-        for chunk in f.chunks():
@@ -126 +126 @@
-        The maximum size, in bytes, for files that will be uploaded
-        into memory. Files larger than ``FILE_UPLOAD_MAX_MEMORY_SIZE``
-        will be streamed to disk.
-
+
-        Defaults to 2.5 megabytes.
-
+
-    ``FILE_UPLOAD_TEMP_DIR``
-        The directory where uploaded files larger than ``FILE_UPLOAD_TEMP_DIR``
-        will be stored.
-
+
-        Defaults to your system's standard temporary directory (i.e. ``/tmp`` on
-        most Unix-like systems).
-
+
-    ``FILE_UPLOAD_HANDLERS``
-        The actual handlers for uploaded files. Changing this setting
-        allows complete customization -- even replacement -- of
-        Django's upload process. See `upload handlers`_, below,
-        for details.
-
+
-        Defaults to::
-
+
-            ("django.core.files.uploadhandler.MemoryFileUploadHandler",
-             "django.core.files.uploadhandler.TemporaryFileUploadHandler",)
-
+
-        Which means "try to upload to memory first, then fall back to temporary
-        files."
-
@@ -161 +161 @@
-        Returns a byte string of length ``num_bytes``, or the complete file if
-        ``num_bytes`` is ``None``.
-
-
+s
-        A generator yielding small chunks from the file. If ``chunk_size`` isn't
-kb
+KB
-
-    ``UploadedFile.multiple_chunks(self, chunk_size=None)``
-        Returns ``True`` if you can expect more than one chunk when calling
-
+s
-
-    ``UploadedFile.file_size``
-        The size, in bytes, of the uploaded file.
-
+
-    ``UploadedFile.file_name``
-        The name of the uploaded file as provided by the user.
-
+
-    ``UploadedFile.content_type``
-        The content-type header uploaded with the file (e.g. ``text/plain`` or
-        ``application/pdf``). Like any data supplied by the user, you shouldn't
-        trust that the uploaded file is actually this type. You'll still need to
-        validate that the file contains the content that the content-type header
-        claims -- "trust but verify."
-
+
-    ``UploadedFile.charset``
-        For ``text/*`` content-types, the character set (i.e. ``utf8``) supplied
-        by the browser. Again, "trust but verify" is the best policy here.
-
+    ``UploadedFile.__iter__()``
+        Iterates over the lines in the file.
+
-    ``UploadedFile.temporary_file_path()``
-        Only files uploaded onto disk will have this method; it returns the full
-        path to the temporary uploaded file.
-
+
-Upload Handlers
-===============
-

docs/newforms.txt

@@ -1331 +1331 @@
-    * Validates that non-empty file data has been bound to the form.
-    * Error message keys: ``required``, ``invalid``, ``missing``, ``empty``
-
-
+
-
-    ======================  ====================================================
-    Attribute               Description
-    ======================  ====================================================
-    ``filename``            The name of the file, provided by the uploading
-                            client.
-                            
-    ``content``             The array of bytes comprising the file content.
-    ======================  ====================================================
-
-The string representation of an ``UploadedFile`` is the same as the filename
-attribute.
-
-When you use a ``FileField`` in a form, you must also remember to
-`bind the file data to the form`_.
-
+.. _file uploads documentation: ../upload_handling/
-.. _`bind the file data to the form`: `Binding uploaded files to a form`_
-
-``FilePathField``

docs/settings.txt

@@ -279 +279 @@
-
-The database backend to use. The build-in database backends are
-``'postgresql_psycopg2'``, ``'postgresql'``, ``'mysql'``, ``'mysql_old'``,
-``'oracle'``, 
+
-
-In the Django development version, you can use a database backend that doesn't
-ship with Django by setting ``DATABASE_ENGINE`` to a fully-qualified path (i.e.