Index: django/conf/global_settings.py =================================================================== --- django/conf/global_settings.py (revision 7520) +++ django/conf/global_settings.py (working copy) @@ -216,6 +216,9 @@ # Path to the "jing" executable -- needed to validate XMLFields JING_PATH = "/usr/bin/jing" +# Default file storage mechanism that holds media. +DEFAULT_FILE_STORAGE = 'django.core.filestorage.filesystem.FileSystemStorage' + # Absolute path to the directory that holds media. # Example: "/home/media/media.lawrence.com/" MEDIA_ROOT = '' Property changes on: django/core/filestorage ___________________________________________________________________ Name: svn:ignore + *.pyc Index: django/core/filestorage/__init__.py =================================================================== --- django/core/filestorage/__init__.py (revision 0) +++ django/core/filestorage/__init__.py (revision 0) @@ -0,0 +1,20 @@ +from django.conf import settings +from django.core.exceptions import ImproperlyConfigured + +def get_storage(import_path): + try: + dot = import_path.rindex('.') + except ValueError: + raise ImproperlyConfigured("%s isn't a storage module." % import_path) + module, classname = import_path[:dot], import_path[dot+1:] + try: + mod = __import__(module, {}, {}, ['']) + except ImportError, e: + raise ImproperlyConfigured('Error importing storage module %s: "%s"' % (module, e)) + try: + storage_class = getattr(mod, classname) + except AttributeError: + raise ImproperlyConfigured('Storage module "%s" does not define a "%s" class.' % (module, classname)) + return storage_class() + +storage = get_storage(settings.DEFAULT_FILE_STORAGE) Index: django/core/filestorage/base.py =================================================================== --- django/core/filestorage/base.py (revision 0) +++ django/core/filestorage/base.py (revision 0) @@ -0,0 +1,39 @@ +from StringIO import StringIO + +from django.utils.text import get_valid_filename + +class Storage(object): + def get_valid_filename(self, filename): + return get_valid_filename(filename) + + def get_available_filename(self, filename): + # If the filename already exists, keep adding an underscore to the name + # of the file until the filename doesn't exist. + while self.exists(filename): + try: + dot_index = filename.rindex('.') + except ValueError: # filename has no dot + filename += '_' + else: + filename = filename[:dot_index] + '_' + filename[dot_index:] + return filename + +class RemoteFile(StringIO): + """Sends files to remote storage automatically, when necessary.""" + + def __init__(self, data, mode, writer): + self._mode = mode + self._write_to_storage = writer + self._is_dirty = False + StringIO.__init__(self, data) + + def write(self, data): + if 'w' not in self._mode: + raise AttributeError("File was opened for read-only access.") + StringIO.write(self, data) + self._is_dirty = True + + def close(self): + if self._is_dirty: + self._write_to_storage(self.getvalue()) + StringIO.close(self) Index: django/core/filestorage/filesystem.py =================================================================== --- django/core/filestorage/filesystem.py (revision 0) +++ django/core/filestorage/filesystem.py (revision 0) @@ -0,0 +1,58 @@ +import os +import urlparse + +from django.conf import settings +from django.core.exceptions import SuspiciousOperation +from django.utils.encoding import force_unicode, smart_str +from django.core.filestorage.base import Storage +from django.utils.text import force_unicode +from django.utils._os import safe_join + +class FileSystemStorage(Storage): + """Standard filesystem storage""" + + def __init__(self, location=settings.MEDIA_ROOT, base_url=settings.MEDIA_URL): + self.location = os.path.abspath(location) + self.base_url = base_url + + def path(self, filename): + try: + path = safe_join(self.location, filename) + except ValueError: + raise SuspiciousOperation("Attempted access to '%s' denied." % filename) + return os.path.normpath(path) + + def filesize(self, filename): + return os.path.getsize(self.path(filename)) + + def url(self, filename): + return urlparse.urljoin(self.base_url, filename).replace('\\', '/') + + def exists(self, filename): + return os.path.exists(self.path(filename)) + + def open(self, filename, mode='rb'): + return open(self.path(filename), mode) + + def save(self, filename, raw_contents): + directory = self.path(os.path.dirname(filename)) + if not os.path.exists(directory): + os.makedirs(directory) + elif not os.path.isdir(directory): + raise IOError("%s exists and is not a directory." % directory) + + filename = self.get_available_filename(filename) + + # Write the file to disk. + fp = self.open(filename, 'wb') + fp.write(raw_contents) + fp.close() + + # Store filenames with forward slashes, even on Windows + return force_unicode(filename.replace('\\', '/')) + + def delete(self, filename): + file_name = self.path(filename) + # If the file exists, delete it from the filesystem. + if os.path.exists(file_name): + os.remove(file_name) Index: django/db/models/__init__.py =================================================================== --- django/db/models/__init__.py (revision 7520) +++ django/db/models/__init__.py (working copy) @@ -8,6 +8,7 @@ from django.db.models.base import Model, AdminOptions from django.db.models.fields import * from django.db.models.fields.subclassing import SubfieldBase +from django.db.models.fields.files import FileField, ImageField from django.db.models.fields.related import ForeignKey, OneToOneField, ManyToManyField, ManyToOneRel, ManyToManyRel, OneToOneRel, TABULAR, STACKED from django.db.models import signals from django.utils.functional import curry Index: django/db/models/base.py =================================================================== --- django/db/models/base.py (revision 7520) +++ django/db/models/base.py (working copy) @@ -8,7 +8,7 @@ import django.db.models.manager # Ditto. from django.core import validators from django.core.exceptions import ObjectDoesNotExist, MultipleObjectsReturned, FieldError -from django.db.models.fields import AutoField, ImageField, FieldDoesNotExist +from django.db.models.fields import AutoField, FieldDoesNotExist from django.db.models.fields.related import OneToOneRel, ManyToOneRel, OneToOneField from django.db.models.query import delete_objects, Q from django.db.models.options import Options, AdminOptions @@ -20,6 +20,7 @@ from django.utils.functional import curry from django.utils.encoding import smart_str, force_unicode, smart_unicode from django.conf import settings +from warnings import warn try: set @@ -432,74 +433,43 @@ return getattr(self, cachename) def _get_FIELD_filename(self, field): - if getattr(self, field.attname): # value is not blank - return os.path.join(settings.MEDIA_ROOT, getattr(self, field.attname)) - return '' + warn("instance.get_%s_filename() is deprecated. Use instance.%s.path() instead." % \ + (field.attname, field.attname), DeprecationWarning) + try: + return getattr(self, field.attname).path() + except ValueError: + # For backward compatibility + return settings.MEDIA_ROOT def _get_FIELD_url(self, field): - if getattr(self, field.attname): # value is not blank - import urlparse - return urlparse.urljoin(settings.MEDIA_URL, getattr(self, field.attname)).replace('\\', '/') - return '' + warn("instance.get_%s_url() is deprecated. Use instance.%s.url() instead." % \ + (field.attname, field.attname), DeprecationWarning) + try: + return getattr(self, field.attname).url() + except ValueError: + # For backward compatibility + return settings.MEDIA_URL def _get_FIELD_size(self, field): - return os.path.getsize(self._get_FIELD_filename(field)) + warn("instance.get_%s_size() is deprecated. Use instance.%s.filesize() instead." % \ + (field.attname, field.attname), DeprecationWarning) + return getattr(self, field.attname).filesize() def _save_FIELD_file(self, field, filename, raw_contents, save=True): - directory = field.get_directory_name() - try: # Create the date-based directory if it doesn't exist. - os.makedirs(os.path.join(settings.MEDIA_ROOT, directory)) - except OSError: # Directory probably already exists. - pass - filename = field.get_filename(filename) + warn("instance.save_%s_file() is deprecated. Use instance.%s.save() instead." % \ + (field.attname, field.attname), DeprecationWarning) + return getattr(self, field.attname).save(filename, raw_contents, save) - # If the filename already exists, keep adding an underscore to the name of - # the file until the filename doesn't exist. - while os.path.exists(os.path.join(settings.MEDIA_ROOT, filename)): - try: - dot_index = filename.rindex('.') - except ValueError: # filename has no dot - filename += '_' - else: - filename = filename[:dot_index] + '_' + filename[dot_index:] - - # Write the file to disk. - setattr(self, field.attname, filename) - - full_filename = self._get_FIELD_filename(field) - fp = open(full_filename, 'wb') - fp.write(raw_contents) - fp.close() - - # Save the width and/or height, if applicable. - if isinstance(field, ImageField) and (field.width_field or field.height_field): - from django.utils.images import get_image_dimensions - width, height = get_image_dimensions(full_filename) - if field.width_field: - setattr(self, field.width_field, width) - if field.height_field: - setattr(self, field.height_field, height) - - # Save the object because it has changed unless save is False - if save: - self.save() - - _save_FIELD_file.alters_data = True - def _get_FIELD_width(self, field): - return self._get_image_dimensions(field)[0] + warn("instance.get_%s_width() is deprecated. Use instance.%s.width() instead." % \ + (field.attname, field.attname), DeprecationWarning) + return getattr(self, field.attname).width() def _get_FIELD_height(self, field): - return self._get_image_dimensions(field)[1] + warn("instance.get_%s_height() is deprecated. Use instance.%s.height() instead." % \ + (field.attname, field.attname), DeprecationWarning) + return getattr(self, field.attname).height() - def _get_image_dimensions(self, field): - cachename = "__%s_dimensions_cache" % field.name - if not hasattr(self, cachename): - from django.utils.images import get_image_dimensions - filename = self._get_FIELD_filename(field) - setattr(self, cachename, get_image_dimensions(filename)) - return getattr(self, cachename) - ############################################ # HELPER FUNCTIONS (CURRIED MODEL METHODS) # ############################################ Index: django/db/models/fields/__init__.py =================================================================== --- django/db/models/fields/__init__.py (revision 7520) +++ django/db/models/fields/__init__.py (working copy) @@ -1,6 +1,5 @@ import copy import datetime -import os import time try: import decimal @@ -306,6 +305,8 @@ name_prefix is a prefix to prepend to the "field_name" argument. rel is a boolean specifying whether this field is in a related context. """ + from django.db.models.fields import files + field_objs, params = self.prepare_field_objs_and_params(manipulator, name_prefix) # Add the "unique" validator(s). @@ -337,7 +338,7 @@ # If this field is in a related context, check whether any other fields # in the related object have core=True. If so, add a validator -- # RequiredIfOtherFieldsGiven -- to this FormField. - if rel and not self.blank and not isinstance(self, AutoField) and not isinstance(self, FileField): + if rel and not self.blank and not isinstance(self, AutoField) and not isinstance(self, files.FileField): # First, get the core fields, if any. core_field_names = [] for f in opts.fields: @@ -749,115 +750,6 @@ defaults.update(kwargs) return super(EmailField, self).formfield(**defaults) -class FileField(Field): - def __init__(self, verbose_name=None, name=None, upload_to='', **kwargs): - self.upload_to = upload_to - kwargs['max_length'] = kwargs.get('max_length', 100) - Field.__init__(self, verbose_name, name, **kwargs) - - def get_internal_type(self): - return "FileField" - - 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 - if value is None: - return None - return unicode(value) - - 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) - if not self.blank: - if rel: - # This validator makes sure FileFields work in a related context. - class RequiredFileField(object): - def __init__(self, other_field_names, other_file_field_name): - self.other_field_names = other_field_names - self.other_file_field_name = other_file_field_name - self.always_test = True - def __call__(self, field_data, all_data): - if not all_data.get(self.other_file_field_name, False): - c = validators.RequiredIfOtherFieldsGiven(self.other_field_names, ugettext_lazy("This field is required.")) - c(field_data, all_data) - # First, get the core fields, if any. - core_field_names = [] - for f in opts.fields: - if f.core and f != self: - core_field_names.extend(f.get_manipulator_field_names(name_prefix)) - # Now, if there are any, add the validator to this FormField. - if core_field_names: - field_list[0].validator_list.append(RequiredFileField(core_field_names, field_list[1].field_name)) - else: - v = validators.RequiredIfOtherFieldNotGiven(field_list[1].field_name, ugettext_lazy("This field is required.")) - v.always_test = True - field_list[0].validator_list.append(v) - field_list[0].is_required = field_list[1].is_required = False - - # If the raw path is passed in, validate it's under the MEDIA_ROOT. - def isWithinMediaRoot(field_data, all_data): - f = os.path.abspath(os.path.join(settings.MEDIA_ROOT, field_data)) - if not f.startswith(os.path.abspath(os.path.normpath(settings.MEDIA_ROOT))): - raise validators.ValidationError, _("Enter a valid filename.") - field_list[1].validator_list.append(isWithinMediaRoot) - return field_list - - def contribute_to_class(self, cls, name): - super(FileField, self).contribute_to_class(cls, name) - setattr(cls, 'get_%s_filename' % self.name, curry(cls._get_FIELD_filename, field=self)) - setattr(cls, 'get_%s_url' % self.name, curry(cls._get_FIELD_url, field=self)) - setattr(cls, 'get_%s_size' % self.name, curry(cls._get_FIELD_size, field=self)) - setattr(cls, 'save_%s_file' % self.name, lambda instance, filename, raw_contents, save=True: instance._save_FIELD_file(self, filename, raw_contents, save)) - dispatcher.connect(self.delete_file, signal=signals.post_delete, sender=cls) - - def delete_file(self, instance): - if getattr(instance, self.attname): - file_name = getattr(instance, 'get_%s_filename' % self.name)() - # If the file exists and no other object of this type references it, - # delete it from the filesystem. - if os.path.exists(file_name) and \ - not instance.__class__._default_manager.filter(**{'%s__exact' % self.name: getattr(instance, self.attname)}): - os.remove(file_name) - - def get_manipulator_field_objs(self): - return [oldforms.FileUploadField, oldforms.HiddenField] - - def get_manipulator_field_names(self, name_prefix): - return [name_prefix + self.name + '_file', name_prefix + self.name] - - def save_file(self, new_data, new_object, original_object, change, rel, save=True): - upload_field_name = self.get_manipulator_field_names('')[0] - if new_data.get(upload_field_name, False): - func = getattr(new_object, 'save_%s_file' % self.name) - if rel: - func(new_data[upload_field_name][0]["filename"], new_data[upload_field_name][0]["content"], save) - else: - func(new_data[upload_field_name]["filename"], new_data[upload_field_name]["content"], save) - - def get_directory_name(self): - return os.path.normpath(force_unicode(datetime.datetime.now().strftime(smart_str(self.upload_to)))) - - def get_filename(self, filename): - from django.utils.text import get_valid_filename - f = os.path.join(self.get_directory_name(), get_valid_filename(os.path.basename(filename))) - return os.path.normpath(f) - - def save_form_data(self, instance, data): - from django.newforms.fields import UploadedFile - if data and isinstance(data, UploadedFile): - getattr(instance, "save_%s_file" % self.name)(data.filename, data.content, save=False) - - def formfield(self, **kwargs): - defaults = {'form_class': forms.FileField} - # If a file has been provided previously, then the form doesn't require - # that a new file is provided this time. - # The code to mark the form field as not required is used by - # form_for_instance, but can probably be removed once form_for_instance - # is gone. ModelForm uses a different method to check for an existing file. - if 'initial' in kwargs: - defaults['required'] = False - defaults.update(kwargs) - return super(FileField, self).formfield(**defaults) - class FilePathField(Field): def __init__(self, verbose_name=None, name=None, path='', match=None, recursive=False, **kwargs): self.path, self.match, self.recursive = path, match, recursive @@ -894,43 +786,6 @@ defaults.update(kwargs) return super(FloatField, self).formfield(**defaults) -class ImageField(FileField): - def __init__(self, verbose_name=None, name=None, width_field=None, height_field=None, **kwargs): - self.width_field, self.height_field = width_field, height_field - FileField.__init__(self, verbose_name, name, **kwargs) - - def get_manipulator_field_objs(self): - return [oldforms.ImageUploadField, oldforms.HiddenField] - - def contribute_to_class(self, cls, name): - super(ImageField, self).contribute_to_class(cls, name) - # Add get_BLAH_width and get_BLAH_height methods, but only if the - # image field doesn't have width and height cache fields. - if not self.width_field: - setattr(cls, 'get_%s_width' % self.name, curry(cls._get_FIELD_width, field=self)) - if not self.height_field: - setattr(cls, 'get_%s_height' % self.name, curry(cls._get_FIELD_height, field=self)) - - def get_internal_type(self): - return "ImageField" - - def save_file(self, new_data, new_object, original_object, change, rel, save=True): - FileField.save_file(self, new_data, new_object, original_object, change, rel, save) - # If the image has height and/or width field(s) and they haven't - # changed, set the width and/or height field(s) back to their original - # values. - if change and (self.width_field or self.height_field) and save: - if self.width_field: - setattr(new_object, self.width_field, getattr(original_object, self.width_field)) - if self.height_field: - setattr(new_object, self.height_field, getattr(original_object, self.height_field)) - new_object.save() - - def formfield(self, **kwargs): - defaults = {'form_class': forms.ImageField} - defaults.update(kwargs) - return super(ImageField, self).formfield(**defaults) - class IntegerField(Field): empty_strings_allowed = False def get_manipulator_field_objs(self): Index: django/db/models/fields/files.py =================================================================== --- django/db/models/fields/files.py (revision 0) +++ django/db/models/fields/files.py (revision 0) @@ -0,0 +1,306 @@ +import datetime +import os + +from django.conf import settings +from django.db.models.fields import Field +from django.core.filestorage import storage as default_storage +from django.utils.functional import curry +from django.dispatch import dispatcher +from django.db.models import signals +from django.utils.encoding import force_unicode, smart_str +from django.utils.translation import ugettext_lazy, ugettext as _ +from django import oldforms +from django import newforms as forms +from django.core import validators + +class File(object): + def __init__(self, instance, field, filename): + self.instance = instance + self.field = field + self.storage = field.storage + self.filename = filename or u'' + + def __unicode__(self): + return self.filename or u'' + + def __repr__(self): + return smart_str(u'<%s: %s>' % (self.__class__.__name__, unicode(self) or u'None')) + + def __nonzero__(self): + return not not self.filename + + def __eq__(self, other): + return self.filename == other + + def path(self): + if not self: + raise ValueError("The '%s' attribute has no file associated with it." % self.field.name) + return self.storage.path(self.filename) + + def url(self): + if not self: + raise ValueError("The '%s' attribute has no file associated with it." % self.field.name) + return self.storage.url(self.filename) + + def filesize(self): + if not self: + raise ValueError("The '%s' attribute has no file associated with it." % self.field.name) + if not hasattr(self, '_filesize'): + self._filesize = self.storage.filesize(self.filename) + return self._filesize + + def open(self, mode='rb'): + if not self: + raise ValueError("The '%s' attribute has no file associated with it." % self.field.name) + return self.storage.open(self.filename, mode) + + def save(self, filename, raw_contents, save=True): + filename = self.field.generate_filename(self.instance, filename) + self.filename = self.storage.save(filename, raw_contents) + setattr(self.instance, self.field.name, self.filename) + self._has_file = True + + # Update the filesize cache + self._filesize = len(raw_contents) + + # Save the object because it has changed, unless save is False + if save: + self.instance.save() + + def delete(self, save=True): + if not self: + raise ValueError("The '%s' attribute has no file associated with it." % self.field.name) + self.storage.delete(self.filename) + + self.filename = None + setattr(self.instance, self.field.name, self.filename) + + # Delete the filesize cache + if hasattr(self, '_filesize'): + del self._filesize + + if save: + self.instance.save() + +class FileDescriptor(object): + def __init__(self, field): + self.field = field + + def __get__(self, instance=None, owner=None): + if instance is None: + raise AttributeError, "%s can only be accessed from %s instances." % (self.field.name(self.owner.__name__)) + return self.field.attr_class(instance, self.field, instance.__dict__[self.field.name]) + + def __set__(self, instance, value): + instance.__dict__[self.field.name] = value + +class FileField(Field): + attr_class = File + + def __init__(self, verbose_name=None, name=None, upload_to='', storage=None, **kwargs): + for arg in ('core', 'primary_key', 'unique'): + if arg in kwargs: + raise TypeError("__init__() got an unexpected keyword argument '%s'" % arg) + + self.storage = storage or default_storage + self.upload_to = upload_to + if callable(upload_to): + self.generate_filename = upload_to + + kwargs['max_length'] = kwargs.get('max_length', 100) + super(FileField, self).__init__(verbose_name, name, **kwargs) + + def get_internal_type(self): + return "FileField" + + def get_db_prep_lookup(self, lookup_type, value): + if hasattr(value, 'filename'): + value = value.filename + return super(FileField, self).get_db_prep_lookup(lookup_type, value) + + 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 + if value is None: + return None + return unicode(value.filename) + + 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) + if not self.blank: + if rel: + # This validator makes sure FileFields work in a related context. + class RequiredFileField(object): + def __init__(self, other_field_names, other_file_field_name): + self.other_field_names = other_field_names + self.other_file_field_name = other_file_field_name + self.always_test = True + def __call__(self, field_data, all_data): + if not all_data.get(self.other_file_field_name, False): + c = validators.RequiredIfOtherFieldsGiven(self.other_field_names, ugettext_lazy("This field is required.")) + c(field_data, all_data) + # First, get the core fields, if any. + core_field_names = [] + for f in opts.fields: + if f.core and f != self: + core_field_names.extend(f.get_manipulator_field_names(name_prefix)) + # Now, if there are any, add the validator to this FormField. + if core_field_names: + field_list[0].validator_list.append(RequiredFileField(core_field_names, field_list[1].field_name)) + else: + v = validators.RequiredIfOtherFieldNotGiven(field_list[1].field_name, ugettext_lazy("This field is required.")) + v.always_test = True + field_list[0].validator_list.append(v) + field_list[0].is_required = field_list[1].is_required = False + + # If the raw path is passed in, validate it's under the MEDIA_ROOT. + def isWithinMediaRoot(field_data, all_data): + f = os.path.abspath(os.path.join(settings.MEDIA_ROOT, field_data)) + if not f.startswith(os.path.abspath(os.path.normpath(settings.MEDIA_ROOT))): + raise validators.ValidationError(_("Enter a valid filename.")) + field_list[1].validator_list.append(isWithinMediaRoot) + return field_list + + def contribute_to_class(self, cls, name): + super(FileField, self).contribute_to_class(cls, name) + setattr(cls, self.name, FileDescriptor(self)) + setattr(cls, 'get_%s_filename' % self.name, curry(cls._get_FIELD_filename, field=self)) + setattr(cls, 'get_%s_url' % self.name, curry(cls._get_FIELD_url, field=self)) + setattr(cls, 'get_%s_size' % self.name, curry(cls._get_FIELD_size, field=self)) + setattr(cls, 'save_%s_file' % self.name, lambda instance, filename, raw_contents, save=True: instance._save_FIELD_file(self, filename, raw_contents, save)) + dispatcher.connect(self.delete_file, signal=signals.post_delete, sender=cls) + + def delete_file(self, instance, sender): + filename = getattr(instance, self.attname).filename + # If no other object of this type references the file, + # and it's not the default value for future objects, + # delete it from the backend. + if filename and filename != self.default and \ + not sender._default_manager.filter(**{self.name: filename}): + self.storage.delete(filename) + + def get_manipulator_field_objs(self): + return [oldforms.FileUploadField, oldforms.HiddenField] + + def get_manipulator_field_names(self, name_prefix): + return [name_prefix + self.name + '_file', name_prefix + self.name] + + def save_file(self, new_data, new_object, original_object, change, rel, save=True): + upload_field_name = self.get_manipulator_field_names('')[0] + if new_data.get(upload_field_name, False): + if rel: + field = new_data[upload_field_name][0] + else: + field = new_data[upload_field_name] + filename = self.get_filename(field["filename"]) + getattr(new_object, self.attname).save(filename, field["content"], save) + + def get_directory_name(self): + return os.path.normpath(force_unicode(datetime.datetime.now().strftime(smart_str(self.upload_to)))) + + def get_filename(self, filename): + return os.path.normpath(self.storage.get_valid_filename(os.path.basename(filename))) + + def generate_filename(self, instance, filename): + return os.path.join(self.get_directory_name(), self.get_filename(filename)) + + def save_form_data(self, instance, data): + from django.newforms.fields import UploadedFile + if data and isinstance(data, UploadedFile): + getattr(instance, self.attname).save(data.filename, data.content, save=False) + + def formfield(self, **kwargs): + defaults = {'form_class': forms.FileField} + # If a file has been provided previously, then the form doesn't require + # that a new file is provided this time. + # The code to mark the form field as not required is used by + # form_for_instance, but can probably be removed once form_for_instance + # is gone. ModelForm uses a different method to check for an existing file. + if 'initial' in kwargs: + defaults['required'] = False + defaults.update(kwargs) + return super(FileField, self).formfield(**defaults) + +class ImageFile(File): + def get_width(self): + return self._get_image_dimensions()[0] + + def get_height(self): + return self._get_image_dimensions()[1] + + def _get_image_dimensions(self): + if not hasattr(self, '_dimensions_cache'): + from django.utils.images import get_image_dimensions + self._dimensions_cache = get_image_dimensions(self.open()) + return self._dimensions_cache + + def save(self, filename, raw_contents, save=True): + super(ImageFile, self).save(filename, raw_contents, save) + + # Update the cache for image dimensions + from django.utils.images import get_image_dimensions + from cStringIO import StringIO + self._dimensions_cache = get_image_dimensions(StringIO(raw_contents)) + + def delete(self, save=True): + # Clear the image dimensions cache + del self._dimensions_cache + + super(ImageFile, self).delete(save) + +class ImageField(FileField): + attr_class = ImageFile + + def __init__(self, verbose_name=None, name=None, width_field=None, height_field=None, **kwargs): + self.width_field, self.height_field = width_field, height_field + FileField.__init__(self, verbose_name, name, **kwargs) + + def get_manipulator_field_objs(self): + return [oldforms.ImageUploadField, oldforms.HiddenField] + + def contribute_to_class(self, cls, name): + super(ImageField, self).contribute_to_class(cls, name) + # Add get_BLAH_width and get_BLAH_height methods, but only if the + # image field doesn't have width and height cache fields. + if not self.width_field: + setattr(cls, 'get_%s_width' % self.name, curry(cls._get_FIELD_width, field=self)) + if not self.height_field: + setattr(cls, 'get_%s_height' % self.name, curry(cls._get_FIELD_height, field=self)) + + def get_internal_type(self): + return "ImageField" + + def save_file(self, new_data, new_object, original_object, change, rel, save=True): + # If the image has height and/or width field(s) and they haven't + # changed, set the width and/or height field(s) back to their original + # values. + if self.width_field or self.height_field: + if original_object and not change: + if self.width_field: + setattr(new_object, self.width_field, getattr(original_object, self.width_field)) + if self.height_field: + setattr(new_object, self.height_field, getattr(original_object, self.height_field)) + else: + from cStringIO import StringIO + from django.utils.images import get_image_dimensions + + upload_field_name = self.get_manipulator_field_names('')[0] + if rel: + field = new_data[upload_field_name][0] + else: + field = new_data[upload_field_name] + + # Get the width and height from the raw content to avoid extra + # unnecessary trips to the file backend. + width, height = get_image_dimensions(StringIO(field["content"])) + + if self.width_field: + setattr(new_object, self.width_field, width) + if self.height_field: + setattr(new_object, self.height_field, height) + FileField.save_file(self, new_data, new_object, original_object, change, rel, save) + + def formfield(self, **kwargs): + defaults = {'form_class': forms.ImageField} + defaults.update(kwargs) + return super(ImageField, self).formfield(**defaults) Index: django/db/models/manipulators.py =================================================================== --- django/db/models/manipulators.py (revision 7520) +++ django/db/models/manipulators.py (working copy) @@ -1,7 +1,8 @@ from django.core.exceptions import ObjectDoesNotExist from django import oldforms from django.core import validators -from django.db.models.fields import FileField, AutoField +from django.db.models.fields import AutoField +from django.db.models.fields.files import FileField from django.dispatch import dispatcher from django.db.models import signals from django.utils.functional import curry Index: django/utils/images.py =================================================================== --- django/utils/images.py (revision 7520) +++ django/utils/images.py (working copy) @@ -6,10 +6,13 @@ import ImageFile -def get_image_dimensions(path): - """Returns the (width, height) of an image at a given path.""" +def get_image_dimensions(file_or_path): + """Returns the (width, height) of an image, given an open file or a path.""" p = ImageFile.Parser() - fp = open(path, 'rb') + if hasattr(file_or_path, 'read'): + fp = file_or_path + else: + fp = open(file_or_path, 'rb') while 1: data = fp.read(1024) if not data: Index: docs/custom_model_fields.txt =================================================================== --- docs/custom_model_fields.txt (revision 7520) +++ docs/custom_model_fields.txt (working copy) @@ -580,3 +580,42 @@ instance, not a ``HandField``). So if your ``__unicode__()`` method automatically converts to the string form of your Python object, you can save yourself a lot of work. + +Writing a ``FileField`` subclass +================================= + +In addition to the above methods, fields that deal with files have a few other +special requirements which must be taken into account. The majority of the +mechanics provided by ``FileField``, such as controlling database storage and +retrieval, can remain unchanged, leaving subclasses to deal with the challenge +of supporting a particular type of file. + +Django provides a ``File`` class, which is used as a proxy to the file's +contents and operations. This can be subclassed to customzie hwo the file is +accessed, and what methods are available. It lives at +``django.db.models.fields.files``, and its default behavior is explained in the +`file documentation`_. + +Once a subclass of ``File`` is created, the new ``FileField`` subclass must be +told to use it. To do so, simply assign the new ``File`` subclass to the special +``attr_class`` attribute of the ``FileField`` subclass. + +.. _file documentation: ../files/ + +A few suggestions +------------------ + +In addition to the above details, there are a few guidelines which can greatly +improve the efficiency and readability of the field's code. + + 1. The source for Django's own ``ImageField`` (in + ``django/db/models/fields/files.py``) is a great example of how to + subclass ``FileField`` to support a particular type of file, as it + incorporates all of the techniques described above. + + 2. Cache file attributes wherever possible. Since files may be stored in + remote storage systems, retrieving them may cost extra time, or even + money, that isn't always necessary. Once a file is retrieved to obtain + some data about its content, cache as much of that data as possible to + reduce the number of times the file must be retrieved on subsequent + calls for that information. Index: docs/db-api.txt =================================================================== --- docs/db-api.txt (revision 7520) +++ docs/db-api.txt (working copy) @@ -2198,6 +2198,9 @@ get_FOO_filename() ------------------ +**Deprecated in Django development version. See `managing files`_ for the new, +preferred method for dealing with files.** + For every ``FileField``, the object will have a ``get_FOO_filename()`` method, where ``FOO`` is the name of the field. This returns the full filesystem path to the file, according to your ``MEDIA_ROOT`` setting. @@ -2208,6 +2211,9 @@ get_FOO_url() ------------- +**Deprecated in Django development version. See `managing files`_ for the new, +preferred method for dealing with files.** + For every ``FileField``, the object will have a ``get_FOO_url()`` method, where ``FOO`` is the name of the field. This returns the full URL to the file, according to your ``MEDIA_URL`` setting. If the value is blank, this method @@ -2216,6 +2222,9 @@ get_FOO_size() -------------- +**Deprecated in Django development version. See `managing files`_ for the new, +preferred method for dealing with files.** + For every ``FileField``, the object will have a ``get_FOO_size()`` method, where ``FOO`` is the name of the field. This returns the size of the file, in bytes. (Behind the scenes, it uses ``os.path.getsize``.) @@ -2223,6 +2232,9 @@ save_FOO_file(filename, raw_contents) ------------------------------------- +**Deprecated in Django development version. See `managing files`_ for the new, +preferred method for dealing with files.** + For every ``FileField``, the object will have a ``save_FOO_file()`` method, where ``FOO`` is the name of the field. This saves the given file to the filesystem, using the given filename. If a file with the given filename already @@ -2232,10 +2244,15 @@ get_FOO_height() and get_FOO_width() ------------------------------------ +**Deprecated in Django development version. See `managing files`_ for the new, +preferred method for dealing with files.** + For every ``ImageField``, the object will have ``get_FOO_height()`` and ``get_FOO_width()`` methods, where ``FOO`` is the name of the field. This returns the height (or width) of the image, as an integer, in pixels. +.. _`managing files`: ../files/ + Shortcuts ========= Index: docs/files.txt =================================================================== --- docs/files.txt (revision 0) +++ docs/files.txt (revision 0) @@ -0,0 +1,279 @@ +============== +Managing files +============== + +**New in Django development version** + +When dealing with files, Django provides a number of features to make this task +easier and more portable. A storage protocol is available to allow files to be +stored in a variety of locations, and a special object is provided to allow +models to make use of this protocol, without having to worry about which storage +system is being used. + +Using files in models +===================== + +When accessing a ``FileField`` attached to a model, a special object provides +access to the file and information about it. + +Example +------- + +Consider the following model, using an ``ImageField`` to store a product photo:: + + class Product(models.Model): + name = models.CharField(maxlength=255) + price = models.DecimalField(max_digits=5, decimal_places=2) + photo = models.ImageField(upload_to='product_photos') + +Your views can then use the ``photo`` attribute with the functions described +above, as follows:: + + >>> car = Product.object.get(name="'57 Chevy") + >>> car.photo + + >>> car.photo.url() + '/products/photo/123.jpg' + >>> car.photo.width(), car.photo.height() + (800, 600) + +``path()`` +---------- + +Returns the absolute path to the file's location on a local filesystem. For +storage systems which do not store files locally, this will return `None`. + +``url()`` +--------- + +Provides a URL where the content of the file can be retrieved. Therefore, +returned from this method is suitable for use as the destination of a link to +the file. + +``filesize()`` +-------------- + +Returns the size of the file, as an integer. + +``open(mode='rb')`` +------------------- + +Returns an open file object, providing read or write access to the file's +contents. The ``mode`` argument allows the same values as Python's standard +``open()`` function. + +``save(filename, raw_contents, save=True)`` +------------------------------------------- + +Saves a new file with the filename and contents provided. This will not replace +the existing file, but will create a new file and update the object to point to +it. The optional ``save`` argument dictates whether the model instance will be +saved to the database immediately. + +``width() and height()`` +------------------------ + +When using an ``ImageField``, these two methods will be available, providing +easy access to the dimensions of the image. + +Using a storage system with FileField +===================================== + +When using a storage system, supply whatever options are appropriate for +that system when creating a new object. Then pass that object as the ``storage`` +argument to a ``FileField``. Details on the requirements for the included +storage system can be found below. + +If using the default storage system, it is not necessary to create a storage +object explicitly. In this case, the ``FileField`` will use the one referenced +by the `DEFAULT_FILE_STORAGE setting`_. + +See the ```FileField`` documentation`_ for more information on using the field. + +.. _DEFAULT_FILE_STORAGE setting: ../settings/#default-file-storage +.. _FileField documentation: ../model-api/#filefield + +For example, the following code will explicitly use the ``FileSystemStorage``:: + + from django.db import models + from django.core.filestorage.filesystem import FileSystemStorage + + fs = FileSystemStorage(location='product_photos') + + class Product(models.Model): + name = models.CharField(maxlength=255) + price = models.DecimalField(max_digits=5, decimal_places=2) + photo = models.ImageField(storage=fs) + +Using a storage system on its own +================================= + +Storage systems may also be used directly, without being attached to a model. +Simply use the following API on any instantiated storage system to access files +without having to worry about the underlying mechanism. + +In addition to explicit storage mechanisms, the file storage module, +``django.core.filestorage``, exports a ``storage`` object that's automatically +created from the ``DEFAULT_FILE_STORAGE`` setting:: + + >>> from django.core.filestorage import storage + +With a functional storage system on hand, managing files is quite simple, with a +few basic methods to handle the most common operations:: + + >>> path = storage.save('/path/to/file', 'new content') + >>> path + u'/path/to/file' + >>> storage.filesize(path) + 11 + >>> storage.open(path).read() + 'new content' + >>> storage.delete(path) + >>> storage.exists(path) + False + +``exists(filename)`` +-------------------- + +Returns ``True`` or ``False, indicating whether there is already a file present +at the location referenced by``filename``. + +``open(filename, mode='rb')`` +----------------------------- + +Returns an open file, or file-like, object to provide access to the contents of +the file referenced by ``filename``. The ``mode`` argument allows the same +values as Python's standard ``open()`` function. + +``filesize(filename)`` +---------------------- + +Returns the total size of the file referenced by ``filename``, as an integer. + +``url(filename)`` +----------------- + +Returns the URL where the contents of the file referenced by ``filename`` can +be accessed. + +``save(filename, raw_contents)`` +-------------------------------- + +Saves a new file using the storage system, preferably with the name specified. +If there already exists a file at the location referenced by ``filename``, this +may modify the filename as necessary to locate one that is available. Once the +file is saved, this method will return the filename where the file was actually +stored. + +``delete(filename)`` +-------------------- + +Deletes the file referenced by ``filename``. If the file does not already exist, +this method will simply return without raising an exception. + +Available storage systems +========================= + +Only one storage system is supplied in the official Django distribution, but +more may be available elsewhere. If you'd like to use a different storage system +than the one listed below, see the documentation included with it. + +``django.core.filestorage.filesystem.FileSystemStorage`` +-------------------------------------------------------- + +This simply stores files on the system's standard filesystem. + + ====================== =================================================== + Argument Description + ====================== =================================================== + ``location`` Optional. Absolute path to the directory that will + hold the files. If omitted, it will be set to the + value of your ``MEDIA_ROOT`` setting. + ``base_url`` Optional. URL that serves the files stored at this + location. If omitted, it will default to the value + of your ``MEDIA_URL`` setting. + ====================== =================================================== + +Writing a storage system +======================== + +While the default filesystem storage is suitable for most needs, there are many +other storage mechanisms that may be used, and situations that will require +special processing. In order to use Django in these environments, it's fairly +simple to write a new storage system, creating a wrapper around whatever +libraries are used to access your files, or simply customizing method calls on +an existing storage class. + +If a storage system requires any configuration options to determine how it +should access the underlying storage mechanism or cusotmize its behavior in +other ways, those options should be specified in a particular way. Because the +default storage system is specified as a string, Django must be able to +instantiate it without any arguments, and any required arguments should be +specified as global settings, which can be referenced from the storage system. +For example:: + + from django.conf import settings + from django.core.filestorage.base import Storage + + class CustomStorage(Storage): + def __init__(self, option=settings.CUSTOM_STORAGE_OPTION): + ... + +All storage systems must implement the methods described above, but Django also +uses two other methods to assist in the process. When writing a custom class, +these methods may be inherited from the built-in ``Storage`` class, living at +``django.core.filestorage.base``. When extending an existing storage class, they +can be overriden to allow a great deal of customization. + +``get_valid_filename(filename)`` +-------------------------------- + +Returns a filename suitable for use with the underlying storage system. The +``filename`` argument passed to this method is the original filename sent to the +server, after having any path information removed. Override this to customize +how non-standard characters are converted to safe filenames. + +The code provided on ``Storage`` retains only alpha-numeric characters, periods +and underscores from the original filename, removing everything else. + +``get_available_filename(filename)`` +------------------------------------ + +Returns a filename that is available in the storage mechanism, possibly taking +the provided filename into account. The ``filename`` argument passed to this +method will have already cleaned to a filename valid for the storage system, +according to the ``get_valid_filename()`` method described above. + +The code provided on ``Storage`` simply appends underscores to the filename +until it finds one that's available in the destination directory. + +Opening remote files +-------------------- + +When accessing a file stored at a remote location, the object returned by +``open()`` should function like a standard `file object`_, but to keep +network traffic to a minimum, writes to the remote storage system should only +occur if actually necessary. To make this task easier, Django provides a class +to automate this process. + +Living at ``django.core.filestorage.base``, the ``RemoteFile`` class simulates +a standard Python `file object`_, but can write changes to a remote storage +system when application using a function provided by the storage system. +Creating an instance of this object requires three arguments, which are +described below. + + ====================== =================================================== + Argument Description + ====================== =================================================== + ``data`` The raw content of the file. + ``mode`` The access mode that was passed to the ``open()`` + method. + ``writer`` A function that will be used to write the contents + to the underlying storage mechanism. The function + provided here will need to take a single argument, + which will be the raw content to be written to the + file. + ====================== =================================================== + +.. _file object: http://docs.python.org/lib/bltin-file-objects.html + Index: docs/model-api.txt =================================================================== --- docs/model-api.txt (revision 7520) +++ docs/model-api.txt (working copy) @@ -230,26 +230,64 @@ ``FileField`` ~~~~~~~~~~~~~ -A file-upload field. Has one **required** argument: +A file-upload field. Has two special arguments, of which the first is +**required**: ====================== =================================================== Argument Description ====================== =================================================== - ``upload_to`` A local filesystem path that will be appended to - your ``MEDIA_ROOT`` setting to determine the - output of the ``get__url()`` helper - function. + ``upload_to`` Required. A filesystem-style path that will be + prepended to the filename before being committed to + the final storage destination. + + **New in Django development version** + + This may also be a callable, such as a function, + which will be called to obtain the upload path, + including the filename. See below for details. + + ``storage`` **New in Django development version** + + Optional. A storage object, which handles the + storage and retrieval of your files. See `managing + files`_ for details on how to provide this object. ====================== =================================================== -This path may contain `strftime formatting`_, which will be replaced by the -date/time of the file upload (so that uploaded files don't fill up the given -directory). +.. _managing files: ../files/ +The ``upload_to`` path may contain `strftime formatting`_, which will be +replaced by the date/time of the file upload (so that uploaded files don't fill +up the given directory). + +**New in Django development version** + +If a callable is provided for the ``upload_to`` argument, that callable must be +able to accept two arguments, and return a Unix-style path (with forward +slashes) to be passed along to the storage system. The two arguments that will +be passed are: + + ====================== =================================================== + Argument Description + ====================== =================================================== + ``instance`` An instance of the model where the ``FileField`` is + defined. More specifically, this is the particular + instance where the current file is being attached. + + **Note**: In most cases, this object will not have + been saved to the database yet, so if it uses the + default ``AutoField``, *it might not yet have a + value for its primary key field*. + + ``filename`` The filename that was originally given to the file. + This may or may not be taken into account when + determining the final destination path. + ====================== =================================================== + The admin represents this field as an ```` (a file-upload widget). -Using a ``FileField`` or an ``ImageField`` (see below) in a model takes a few -steps: +Using a ``FileField`` or an ``ImageField`` (see below) in a model without a +specified storage system takes a few steps: 1. In your settings file, you'll need to define ``MEDIA_ROOT`` as the full path to a directory where you'd like Django to store uploaded Index: docs/settings.txt =================================================================== --- docs/settings.txt (revision 7520) +++ docs/settings.txt (working copy) @@ -409,6 +409,16 @@ isn't manually specified. Used with ``DEFAULT_CHARSET`` to construct the ``Content-Type`` header. +DEFAULT_FILE_STORAGE +-------------------- + +Default: ``'django.core.filestorage.filesystem.FileSystemStorage'`` + +Default file storage class to be used for any file-related operations that don't +specify a particular storage system. See the `file documentation`_ for details. + +.. _file documentation: ../files/ + DEFAULT_FROM_EMAIL ------------------ Property changes on: tests/modeltests/files ___________________________________________________________________ Name: svn:ignore + *.pyc Index: tests/modeltests/files/__init__.py =================================================================== --- tests/modeltests/files/__init__.py (revision 0) +++ tests/modeltests/files/__init__.py (revision 0) @@ -0,0 +1,1 @@ + Index: tests/modeltests/files/models.py =================================================================== --- tests/modeltests/files/models.py (revision 0) +++ tests/modeltests/files/models.py (revision 0) @@ -0,0 +1,95 @@ +""" +42. Storing files according to a custom storage system + +FileField and its variations can take a "storage" argument to specify how and +where files should be stored. +""" + +import tempfile + +from django.db import models +from django.core.filestorage.filesystem import FileSystemStorage +from django.core.cache import cache + +temp_dir = tempfile.gettempdir() + +temp_storage = FileSystemStorage(location=temp_dir) + +# Write out a file to be used as default content +temp_storage.save('tests/default.txt', 'default_content') +open('%s/tests/default.txt' % temp_dir, 'w').write('default content') + +class Storage(models.Model): + def custom_upload_to(self, filename): + return 'foo' + + normal = models.FileField(storage=temp_storage, upload_to='tests') + custom = models.FileField(storage=temp_storage, upload_to=custom_upload_to) + default = models.FileField(storage=temp_storage, upload_to='tests', default='tests/default.txt') + +__test__ = {'API_TESTS':""" +# An object without a file has limited functionality + +>>> obj1 = Storage() +>>> obj1.normal + +>>> obj1.normal.filesize() +Traceback (most recent call last): +... +ValueError: The 'normal' attribute has no file associated with it. + +# Saving a file enables full functionality + +>>> obj1.normal.save('django_test.txt', 'content') +>>> obj1.normal + +>>> obj1.normal.filesize() +7 +>>> obj1.normal.open().read() +'content' + +# Save another file with the same name + +>>> obj2 = Storage() +>>> obj2.normal.save('django_test.txt', 'more content') +>>> obj2.normal + +>>> obj2.normal.filesize() +12 + +# Push the objects into the cache to make sure they pickle properly + +>>> cache.set('obj1', obj1) +>>> cache.set('obj2', obj2) +>>> cache.get('obj2').normal + + +# Deleting an object deletes the file it uses, if there are no other objects +# still using that file + +>>> obj2.delete() +>>> obj2.normal.save('django_test.txt', 'more content') +>>> obj2.normal + + +# Default values allow an object to access a single file + +>>> obj3 = Storage.objects.create() +>>> obj3.default + +>>> obj3.default.open().read() +'default content' + +# But it shouldn't be deleted, even if there are no more objects using it + +>>> obj3.delete() +>>> obj3 = Storage() +>>> obj3.default.open().read() +'default content' + +# Clean up the temporary files + +>>> obj1.normal.delete() +>>> obj2.normal.delete() +>>> obj3.default.delete() +"""} Index: tests/modeltests/model_forms/models.py =================================================================== --- tests/modeltests/model_forms/models.py (revision 7520) +++ tests/modeltests/model_forms/models.py (working copy) @@ -11,7 +11,10 @@ import tempfile from django.db import models +from django.core.filestorage.filesystem import FileSystemStorage +temp_storage = FileSystemStorage(tempfile.gettempdir()) + ARTICLE_STATUS = ( (1, 'Draft'), (2, 'Pending'), @@ -60,14 +63,14 @@ class TextFile(models.Model): description = models.CharField(max_length=20) - file = models.FileField(upload_to=tempfile.gettempdir()) + file = models.FileField(storage=temp_storage, upload_to='tests') def __unicode__(self): return self.description class ImageFile(models.Model): description = models.CharField(max_length=20) - image = models.FileField(upload_to=tempfile.gettempdir()) + image = models.FileField(storage=temp_storage, upload_to='tests') def __unicode__(self): return self.description @@ -799,7 +802,7 @@ >>> instance = f.save() >>> instance.file -u'...test1.txt' + # Edit an instance that already has the file defined in the model. This will not # save the file again, but leave it exactly as it is. @@ -808,14 +811,14 @@ >>> f.is_valid() True >>> f.cleaned_data['file'] -u'...test1.txt' + >>> instance = f.save() >>> instance.file -u'...test1.txt' + # Delete the current file since this is not done by Django. ->>> os.unlink(instance.get_file_filename()) +>>> instance.file.delete() # Override the file by uploading a new one. @@ -824,7 +827,7 @@ True >>> instance = f.save() >>> instance.file -u'...test2.txt' + >>> instance.delete() @@ -836,14 +839,14 @@ True >>> instance = f.save() >>> instance.file -'' + >>> f = TextFileForm(data={'description': u'Assistance'}, files={'file': {'filename': 'test3.txt', 'content': 'hello world'}}, instance=instance) >>> f.is_valid() True >>> instance = f.save() >>> instance.file -u'...test3.txt' + >>> instance.delete() # ImageField ################################################################### @@ -865,7 +868,7 @@ >>> instance = f.save() >>> instance.image -u'...test.png' + # Edit an instance that already has the image defined in the model. This will not # save the image again, but leave it exactly as it is. @@ -874,14 +877,14 @@ >>> f.is_valid() True >>> f.cleaned_data['image'] -u'...test.png' + >>> instance = f.save() >>> instance.image -u'...test.png' + # Delete the current image since this is not done by Django. ->>> os.unlink(instance.get_image_filename()) +>>> instance.image.delete() # Override the file by uploading a new one. @@ -890,7 +893,7 @@ True >>> instance = f.save() >>> instance.image -u'...test2.png' + >>> instance.delete() @@ -902,14 +905,14 @@ True >>> instance = f.save() >>> instance.image -'' + >>> f = ImageFileForm(data={'description': u'And a final one'}, files={'image': {'filename': 'test3.png', 'content': image_data}}, instance=instance) >>> f.is_valid() True >>> instance = f.save() >>> instance.image -u'...test3.png' + >>> instance.delete() """} Index: tests/regressiontests/bug639/models.py =================================================================== --- tests/regressiontests/bug639/models.py (revision 7520) +++ tests/regressiontests/bug639/models.py (working copy) @@ -1,16 +1,20 @@ import tempfile + from django.db import models +from django.core.filestorage.filesystem import FileSystemStorage +temp_storage = FileSystemStorage(tempfile.gettempdir()) + class Photo(models.Model): title = models.CharField(max_length=30) - image = models.FileField(upload_to=tempfile.gettempdir()) + image = models.FileField(storage=temp_storage, upload_to='tests') # Support code for the tests; this keeps track of how many times save() gets # called on each instance. def __init__(self, *args, **kwargs): - super(Photo, self).__init__(*args, **kwargs) - self._savecount = 0 + super(Photo, self).__init__(*args, **kwargs) + self._savecount = 0 def save(self): super(Photo, self).save() - self._savecount +=1 \ No newline at end of file + self._savecount += 1 \ No newline at end of file Index: tests/regressiontests/bug639/tests.py =================================================================== --- tests/regressiontests/bug639/tests.py (revision 7520) +++ tests/regressiontests/bug639/tests.py (working copy) @@ -39,4 +39,4 @@ Make sure to delete the "uploaded" file to avoid clogging /tmp. """ p = Photo.objects.get() - os.unlink(p.get_image_filename()) \ No newline at end of file + p.image.delete(save=False) Index: tests/regressiontests/serializers_regress/models.py =================================================================== --- tests/regressiontests/serializers_regress/models.py (revision 7520) +++ tests/regressiontests/serializers_regress/models.py (working copy) @@ -157,8 +157,8 @@ class EmailPKData(models.Model): data = models.EmailField(primary_key=True) -class FilePKData(models.Model): - data = models.FileField(primary_key=True, upload_to='/foo/bar') +# class FilePKData(models.Model): +# data = models.FileField(primary_key=True, upload_to='/foo/bar') class FilePathPKData(models.Model): data = models.FilePathField(primary_key=True) Index: tests/regressiontests/serializers_regress/tests.py =================================================================== --- tests/regressiontests/serializers_regress/tests.py (revision 7520) +++ tests/regressiontests/serializers_regress/tests.py (working copy) @@ -125,7 +125,7 @@ (data_obj, 41, EmailData, None), (data_obj, 42, EmailData, ""), (data_obj, 50, FileData, 'file:///foo/bar/whiz.txt'), - (data_obj, 51, FileData, None), +# (data_obj, 51, FileData, None), (data_obj, 52, FileData, ""), (data_obj, 60, FilePathData, "/foo/bar/whiz.txt"), (data_obj, 61, FilePathData, None), @@ -223,7 +223,7 @@ # (pk_obj, 620, DatePKData, datetime.date(2006,6,16)), # (pk_obj, 630, DateTimePKData, datetime.datetime(2006,6,16,10,42,37)), (pk_obj, 640, EmailPKData, "hovercraft@example.com"), - (pk_obj, 650, FilePKData, 'file:///foo/bar/whiz.txt'), +# (pk_obj, 650, FilePKData, 'file:///foo/bar/whiz.txt'), (pk_obj, 660, FilePathPKData, "/foo/bar/whiz.txt"), (pk_obj, 670, DecimalPKData, decimal.Decimal('12.345')), (pk_obj, 671, DecimalPKData, decimal.Decimal('-12.345')), Property changes on: tests/regressiontests/storage ___________________________________________________________________ Name: svn:ignore + *.pyc Index: tests/regressiontests/storage/__init__.py =================================================================== --- tests/regressiontests/storage/__init__.py (revision 0) +++ tests/regressiontests/storage/__init__.py (revision 0) @@ -0,0 +1,1 @@ + Index: tests/regressiontests/storage/models.py =================================================================== --- tests/regressiontests/storage/models.py (revision 0) +++ tests/regressiontests/storage/models.py (revision 0) @@ -0,0 +1 @@ +# Empty file to force tests to run \ No newline at end of file Index: tests/regressiontests/storage/tests.py =================================================================== --- tests/regressiontests/storage/tests.py (revision 0) +++ tests/regressiontests/storage/tests.py (revision 0) @@ -0,0 +1,89 @@ +""" +Tests for the file storage mechanism + +>>> import tempfile +>>> from django.core.filestorage.filesystem import FileSystemStorage + +# Instantiate a storage system manually, specifying a location. + +>>> temp_storage = FileSystemStorage(tempfile.gettempdir()) + +# Standard file access options are available, and work as expected. + +>>> temp_storage.exists('storage_test') +False +>>> file = temp_storage.open('storage_test', 'w') +>>> file.write('storage contents') +>>> file.close() + +>>> temp_storage.exists('storage_test') +True +>>> file = temp_storage.open('storage_test', 'r') +>>> file.read() +'storage contents' +>>> file.close() + +>>> temp_storage.delete('storage_test') +>>> temp_storage.exists('storage_test') +False + +# Files can only be accessed if they're below the specified location. + +>>> temp_storage.exists('..') +Traceback (most recent call last): +... +SuspiciousOperation: Attempted access to '..' denied. +>>> temp_storage.open('/etc/passwd') +Traceback (most recent call last): + ... +SuspiciousOperation: Attempted access to '/etc/passwd' denied. + +# RemoteFile allows files to be committed by way of a user-defined function. + +>>> from django.core.filestorage.base import RemoteFile +>>> def write_file(contents): +... print 'Writing %s' % contents + +# Opening for read access doesn't commit back to the server + +>>> file = RemoteFile('', 'r', write_file) +>>> file.close() + +# The same goes for opening for write access, but not actually writing + +>>> file = RemoteFile('', 'w', write_file) +>>> file.close() + +# But once it's written to, it gets committed on close + +>>> file = RemoteFile('', 'w', write_file) +>>> file.write('remote contents') # Content isn't committed yet +>>> file.close() # Content gets committed to the storage system +Writing remote contents + +# Custom storage systems can be created to customize behavior + +>>> class CustomStorage(FileSystemStorage): +... def get_available_filename(self, filename): +... # Append numbers to duplicate files rather than underscores, like Trac +... +... parts = filename.split('.') +... basename, ext = parts[0], parts[1:] +... number = 2 +... +... while self.exists(filename): +... filename = '.'.join([basename, str(number)] + ext) +... number += 1 +... +... return filename +>>> custom_storage = CustomStorage(tempfile.gettempdir()) + +>>> first = custom_storage.save('custom_storage', 'custom contents') +>>> first +u'custom_storage' +>>> second = custom_storage.save('custom_storage', 'more contents') +>>> second +u'custom_storage.2' +>>> custom_storage.delete(first) +>>> custom_storage.delete(second) +""" \ No newline at end of file