File storage refactoring, adding far more flexibility to Django's file... (7899568e) · Commits · Dom Sekotill / django

django/conf/global_settings.py

+3 −0

Original line number	Diff line number	Diff line
		@@ -226,6 +226,9 @@ SECRET_KEY = ''
		# 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.files.storage.FileSystemStorage'

		# Absolute path to the directory that holds media.
		# Example: "/home/media/media.lawrence.com/"
		MEDIA_ROOT = ''

django/contrib/admin/widgets.py

+2 −2

Original line number	Diff line number	Diff line
		@@ -85,8 +85,8 @@ class AdminFileWidget(forms.FileInput):
		def render(self, name, value, attrs=None):
		output = []
		if value:
		output.append('%s <a target="_blank" href="%s%s">%s</a> <br />%s ' % \
		(_('Currently:'), settings.MEDIA_URL, value, value, _('Change:')))
		output.append('%s <a target="_blank" href="%s">%s</a> <br />%s ' % \
		(_('Currently:'), value.url, value, _('Change:')))
		output.append(super(AdminFileWidget, self).render(name, value, attrs))
		return mark_safe(u''.join(output))

django/core/files/init.py

+1 −0

Original line number	Diff line number	Diff line
		from django.core.files.base import File

django/core/files/base.py

0 → 100644

+169 −0

Original line number	Diff line number	Diff line
		import os

		from django.utils.encoding import smart_str, smart_unicode

		try:
		from cStringIO import StringIO
		except ImportError:
		from StringIO import StringIO

		class File(object):
		DEFAULT_CHUNK_SIZE = 64 * 2**10

		def __init__(self, file):
		self.file = file
		self._name = file.name
		self._mode = file.mode
		self._closed = False

		def __str__(self):
		return smart_str(self.name or '')

		def __unicode__(self):
		return smart_unicode(self.name or u'')

		def __repr__(self):
		return "<%s: %s>" % (self.__class__.__name__, self or "None")

		def __nonzero__(self):
		return not not self.name

		def __len__(self):
		return self.size

		def _get_name(self):
		return self._name
		name = property(_get_name)

		def _get_mode(self):
		return self._mode
		mode = property(_get_mode)

		def _get_closed(self):
		return self._closed
		closed = property(_get_closed)

		def _get_size(self):
		if not hasattr(self, '_size'):
		if hasattr(self.file, 'size'):
		self._size = self.file.size
		elif os.path.exists(self.file.name):
		self._size = os.path.getsize(self.file.name)
		else:
		raise AttributeError("Unable to determine the file's size.")
		return self._size

		def _set_size(self, size):
		self._size = size

		size = property(_get_size, _set_size)

		def chunks(self, chunk_size=None):
		"""
		Read the file and yield chucks of ``chunk_size`` bytes (defaults to
		``UploadedFile.DEFAULT_CHUNK_SIZE``).
		"""
		if not chunk_size:
		chunk_size = self.__class__.DEFAULT_CHUNK_SIZE

		if hasattr(self, 'seek'):
		self.seek(0)
		# Assume the pointer is at zero...
		counter = self.size

		while counter > 0:
		yield self.read(chunk_size)
		counter -= chunk_size

		def multiple_chunks(self, chunk_size=None):
		"""
		Returns ``True`` if you can expect multiple chunks.

		NB: If a particular file representation is in memory, subclasses should
		always return ``False`` -- there's no good reason to read from memory in
		chunks.
		"""
		if not chunk_size:
		chunk_size = self.DEFAULT_CHUNK_SIZE
		return self.size > chunk_size

		def xreadlines(self):
		return iter(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_

		def open(self, mode=None):
		if not self.closed:
		self.seek(0)
		elif os.path.exists(self.file.name):
		self.file = open(self.file.name, mode or self.file.mode)
		else:
		raise ValueError("The file cannot be reopened.")

		def seek(self, position):
		self.file.seek(position)

		def tell(self):
		return self.file.tell()

		def read(self, num_bytes=None):
		if num_bytes is None:
		return self.file.read()
		return self.file.read(num_bytes)

		def write(self, content):
		if not self.mode.startswith('w'):
		raise IOError("File was not opened with write access.")
		self.file.write(content)

		def flush(self):
		if not self.mode.startswith('w'):
		raise IOError("File was not opened with write access.")
		self.file.flush()

		def close(self):
		self.file.close()
		self._closed = True

		class ContentFile(File):
		"""
		A File-like object that takes just raw content, rather than an actual file.
		"""
		def __init__(self, content):
		self.file = StringIO(content or '')
		self.size = len(content or '')
		self.file.seek(0)
		self._closed = False

		def __str__(self):
		return 'Raw content'

		def __nonzero__(self):
		return True

		def open(self, mode=None):
		if self._closed:
		self._closed = False
		self.seek(0)

django/core/files/images.py

0 → 100644

+42 −0

Original line number	Diff line number	Diff line
		"""
		Utility functions for handling images.

		Requires PIL, as you might imagine.
		"""

		from PIL import ImageFile as PIL
		from django.core.files import File

		class ImageFile(File):
		"""
		A mixin for use alongside django.core.files.base.File, which provides
		additional features for dealing with images.
		"""
		def _get_width(self):
		return self._get_image_dimensions()[0]
		width = property(_get_width)

		def _get_height(self):
		return self._get_image_dimensions()[1]
		height = property(_get_height)

		def _get_image_dimensions(self):
		if not hasattr(self, '_dimensions_cache'):
		self._dimensions_cache = get_image_dimensions(self)
		return self._dimensions_cache

		def get_image_dimensions(file_or_path):
		"""Returns the (width, height) of an image, given an open file or a path."""
		p = PIL.Parser()
		if hasattr(file_or_path, 'read'):
		file = file_or_path
		else:
		file = open(file_or_path, 'rb')
		while 1:
		data = file.read(1024)
		if not data:
		break
		p.feed(data)
		if p.image:
		return p.image.size
		return None