jazzband / django-queued-storage / 107

pending completion

Build # 107

Build Type

push

travis-ci

Committed by

onekiloparsec

Commit Message

<a href="https://github.com/jazzband/django-queued-storage/commit/5579471e5">&lt;a href=&quot;https://github.com/jazzband/django-queued-storage/commit/</a><a class="double-link" href="https://github.com/jazzband/django-queued-storage/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/jazzband/django-queued-storage/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/jazzband/django-queued-storage/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/jazzband/django-queued-storage/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/jazzband/django-queued-storage/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/jazzband/django-queued-storage/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/jazzband/django-queued-storage/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/jazzband/django-queued-storage/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/jazzband/django-queued-storage/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/jazzband/django-queued-storage/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/jazzband/django-queued-storage/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/jazzband/django-queued-storage/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/jazzband/django-queued-storage/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/jazzband/django-queued-storage/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/jazzband/django-queued-storage/commit/&lt;a... (continued)

Run Details

16 of 16 new or added lines in 3 files covered. (100.0%)

172 of 196 relevant lines covered (87.76%)

6.14 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.83

/queued_storage/backends.py

import six

from django.core.cache import cache
from django.core.exceptions import ImproperlyConfigured
from django.utils.functional import SimpleLazyObject
from django.utils.http import urlquote

from .conf import settings
from .utils import import_attribute, django_version

if django_version()[1] >= 7:
    from django.utils.deconstruct import deconstructible


class LazyBackend(SimpleLazyObject):

    def __init__(self, import_path, options):
        backend = import_attribute(import_path)
        super(LazyBackend, self).__init__(lambda: backend(**options))


class QueuedStorage(object):
    """
    Base class for queued storages. You can use this to specify your own
    backends.

    :param local: local storage class to transfer from
    :type local: str
    :param local_options: options of the local storage class
    :type local_options: dict
    :param remote: remote storage class to transfer to
    :type remote: str
    :param remote_options: options of the remote storage class
    :type remote_options: dict
    :param cache_prefix: prefix to use in the cache key
    :type cache_prefix: str
    :param delayed: whether the transfer task should be executed automatically
    :type delayed: bool
    :param task: Celery task to use for the transfer
    :type task: str
    """
    #: The local storage class to use. A dotted path (e.g.
    #: ``'django.core.files.storage.FileSystemStorage'``).
    local = None

    #: The options of the local storage class, defined as a dictionary.
    local_options = None

    #: The remote storage class to use. A dotted path (e.g.
    #: ``'django.core.files.storage.FileSystemStorage'``).
    remote = None

    #: The options of the remote storage class, defined as a dictionary.
    remote_options = None

    #: The Celery task class to use to transfer files from the local
    #: to the remote storage. A dotted path (e.g.
    #: ``'queued_storage.tasks.Transfer'``).
    task = 'queued_storage.tasks.Transfer'

    #: If set to ``True`` the backend will *not* transfer files to the remote
    #: location automatically, but instead requires manual intervention by the
    #: user with the :meth:`~queued_storage.backends.QueuedStorage.transfer`
    #: method.
    delayed = False

    #: The cache key prefix to use when saving the which storage backend
    #: to use, local or remote (default see
    #: :attr:`~queued_storage.conf.settings.QUEUED_STORAGE_CACHE_PREFIX`)
    cache_prefix = settings.QUEUED_STORAGE_CACHE_PREFIX

    def __init__(self, local=None, remote=None,
                 local_options=None, remote_options=None,
                 cache_prefix=None, delayed=None, task=None):

        self.local_path = local or self.local
        self.local_options = local_options or self.local_options or {}
        self.local = self._load_backend(backend=self.local_path,
                                        options=self.local_options)

        self.remote_path = remote or self.remote
        self.remote_options = remote_options or self.remote_options or {}
        self.remote = self._load_backend(backend=self.remote_path,
                                         options=self.remote_options)

        self.task = self._load_backend(backend=task or self.task,
                                       handler=import_attribute)
        if delayed is not None:
            self.delayed = delayed
        if cache_prefix is not None:
            self.cache_prefix = cache_prefix

    def _load_backend(self, backend=None, options=None, handler=LazyBackend):
        if backend is None:  # pragma: no cover
            raise ImproperlyConfigured("The QueuedStorage class '%s' "
                                       "doesn't define a needed backend." %
                                       (self))
        if not isinstance(backend, six.string_types):
            raise ImproperlyConfigured("The QueuedStorage class '%s' "
                                       "requires its backends to be "
                                       "specified as dotted import paths "
                                       "not instances or classes" % self)
        return handler(backend, options)

    def get_storage(self, name):
        """
        Returns the storage backend instance responsible for the file
        with the given name (either local or remote). This method is
        used in most of the storage API methods.

        :param name: file name
        :type name: str
        :rtype: :class:`~django:django.core.files.storage.Storage`
        """
        cache_result = cache.get(self.get_cache_key(name))
        if cache_result:
            return self.remote
        elif cache_result is None and self.remote.exists(name):
            cache.set(self.get_cache_key(name), True)
            return self.remote
        else:
            return self.local

    def get_cache_key(self, name):
        """
        Returns the cache key for the given file name.

        :param name: file name
        :type name: str
        :rtype: str
        """
        return '%s_%s' % (self.cache_prefix, urlquote(name))

    def using_local(self, name):
        """
        Determines for the file with the given name whether
        the local storage is current used.

        :param name: file name
        :type name: str
        :rtype: bool
        """
        return self.get_storage(name) is self.local

    def using_remote(self, name):
        """
        Determines for the file with the given name whether
        the remote storage is current used.

        :param name: file name
        :type name: str
        :rtype: bool
        """
        return self.get_storage(name) is self.remote

    def open(self, name, mode='rb'):
        """
        Retrieves the specified file from storage.

        :param name: file name
        :type name: str
        :param mode: mode to open the file with
        :type mode: str
        :rtype: :class:`~django:django.core.files.File`
        """
        return self.get_storage(name).open(name, mode)

    def save(self, name, content):
        """
        Saves the given content with the given name using the local
        storage. If the :attr:`~queued_storage.backends.QueuedStorage.delayed`
        attribute is ``True`` this will automatically call the
        :meth:`~queued_storage.backends.QueuedStorage.transfer` method
        queuing the transfer from local to remote storage.

        :param name: file name
        :type name: str
        :param content: content of the file specified by name
        :type content: :class:`~django:django.core.files.File`
        :rtype: str
        """
        cache_key = self.get_cache_key(name)
        cache.set(cache_key, False)

        # Use a name that is available on both the local and remote storage
        # systems and save locally.
        name = self.get_available_name(name)
        name = self.local.save(name, content)

        # Pass on the cache key to prevent duplicate cache key creation,
        # we save the result in the storage to be able to test for it
        if not self.delayed:
            self.result = self.transfer(name, cache_key=cache_key)
        return name

    def transfer(self, name, cache_key=None):
        """
        Transfers the file with the given name to the remote storage
        backend by queuing the task.

        :param name: file name
        :type name: str
        :param cache_key: the cache key to set after a successful task run
        :type cache_key: str
        :rtype: task result
        """
        if cache_key is None:
            cache_key = self.get_cache_key(name)
        return self.task.delay(name, cache_key,
                               self.local_path, self.remote_path,
                               self.local_options, self.remote_options)

    def get_valid_name(self, name):
        """
        Returns a filename, based on the provided filename, that's suitable
        for use in the current storage system.

        :param name: file name
        :type name: str
        :rtype: str
        """
        return self.get_storage(name).get_valid_name(name)

    def get_available_name(self, name):
        """
        Returns a filename that's free on both the local and remote storage
        systems, and available for new content to be written to.

        :param name: file name
        :type name: str
        :rtype: str
        """
        local_available_name = self.local.get_available_name(name)
        remote_available_name = self.remote.get_available_name(name)

        if remote_available_name > local_available_name:
            return remote_available_name
        return local_available_name

    def path(self, name):
        """
        Returns a local filesystem path where the file can be retrieved using
        Python's built-in open() function. Storage systems that can't be
        accessed using open() should *not* implement this method.

        :param name: file name
        :type name: str
        :rtype: str
        """
        return self.get_storage(name).path(name)

    def delete(self, name):
        """
        Deletes the specified file from the storage system.

        :param name: file name
        :type name: str
        """
        return self.get_storage(name).delete(name)

    def exists(self, name):
        """
        Returns ``True`` if a file referened by the given name already exists
        in the storage system, or False if the name is available for a new
        file.

        :param name: file name
        :type name: str
        :rtype: bool
        """
        return self.get_storage(name).exists(name)

    def listdir(self, name):
        """
        Lists the contents of the specified path, returning a 2-tuple of lists;
        the first item being directories, the second item being files.

        :param name: file name
        :type name: str
        :rtype: tuple
        """
        return self.get_storage(name).listdir(name)

    def size(self, name):
        """
        Returns the total size, in bytes, of the file specified by name.

        :param name: file name
        :type name: str
        :rtype: int
        """
        return self.get_storage(name).size(name)

    def url(self, name):
        """
        Returns an absolute URL where the file's contents can be accessed
        directly by a Web browser.

        :param name: file name
        :type name: str
        :rtype: str
        """
        return self.get_storage(name).url(name)

    def accessed_time(self, name):
        """
        Returns the last accessed time (as datetime object) of the file
        specified by name.

        :param name: file name
        :type name: str
        :rtype: :class:`~python:datetime.datetime`
        """
        return self.get_storage(name).accessed_time(name)

    def created_time(self, name):
        """
        Returns the creation time (as datetime object) of the file
        specified by name.

        :param name: file name
        :type name: str
        :rtype: :class:`~python:datetime.datetime`
        """
        return self.get_storage(name).created_time(name)

    def modified_time(self, name):
        """
        Returns the last modified time (as datetime object) of the file
        specified by name.

        :param name: file name
        :type name: str
        :rtype: :class:`~python:datetime.datetime`
        """
        return self.get_storage(name).modified_time(name)
if django_version()[1] >= 7:
    QueuedStorage = deconstructible(QueuedStorage)


class QueuedFileSystemStorage(QueuedStorage):
    """
    A :class:`~queued_storage.backends.QueuedStorage` subclass which
    conveniently uses
    :class:`~django:django.core.files.storage.FileSystemStorage` as the local
    storage.
    """
    def __init__(self, local='django.core.files.storage.FileSystemStorage', *args, **kwargs):
        super(QueuedFileSystemStorage, self).__init__(local=local, *args, **kwargs)


class QueuedS3BotoStorage(QueuedFileSystemStorage):
    """
    A custom :class:`~queued_storage.backends.QueuedFileSystemStorage`
    subclass which uses the ``S3BotoStorage`` storage of the
    `django-storages <https://django-storages.readthedocs.io/>`_ app as
    the remote storage.
    """
    def __init__(self, remote='storages.backends.s3boto.S3BotoStorage', *args, **kwargs):
        super(QueuedS3BotoStorage, self).__init__(remote=remote, *args, **kwargs)


class QueuedCouchDBStorage(QueuedFileSystemStorage):
    """
    A custom :class:`~queued_storage.backends.QueuedFileSystemStorage`
    subclass which uses the ``CouchDBStorage`` storage of the
    `django-storages <https://django-storages.readthedocs.io/>`_ app as
    the remote storage.
    """
    def __init__(self, remote='storages.backends.couchdb.CouchDBStorage', *args, **kwargs):
        super(QueuedCouchDBStorage, self).__init__(remote=remote, *args, **kwargs)


class QueuedDatabaseStorage(QueuedFileSystemStorage):
    """
    A custom :class:`~queued_storage.backends.QueuedFileSystemStorage`
    subclass which uses the ``DatabaseStorage`` storage of the
    `django-storages <https://django-storages.readthedocs.io/>`_ app as
    the remote storage.
    """
    def __init__(self, remote='storages.backends.database.DatabaseStorage', *args, **kwargs):
        super(QueuedDatabaseStorage, self).__init__(remote=remote, *args, **kwargs)


class QueuedFTPStorage(QueuedFileSystemStorage):
    """
    A custom :class:`~queued_storage.backends.QueuedFileSystemStorage`
    subclass which uses the ``FTPStorage`` storage of the
    `django-storages <https://django-storages.readthedocs.io/>`_ app as
    the remote storage.
    """
    def __init__(self, remote='storages.backends.ftp.FTPStorage', *args, **kwargs):
        super(QueuedFTPStorage, self).__init__(remote=remote, *args, **kwargs)


class QueuedMogileFSStorage(QueuedFileSystemStorage):
    """
    A custom :class:`~queued_storage.backends.QueuedFileSystemStorage`
    subclass which uses the ``MogileFSStorage`` storage of the
    `django-storages <https://django-storages.readthedocs.io/>`_ app as
    the remote storage.
    """
    def __init__(self, remote='storages.backends.mogile.MogileFSStorage', *args, **kwargs):
        super(QueuedMogileFSStorage, self).__init__(remote=remote, *args, **kwargs)


class QueuedGridFSStorage(QueuedFileSystemStorage):
    """
    A custom :class:`~queued_storage.backends.QueuedFileSystemStorage`
    subclass which uses the ``GridFSStorage`` storage of the
    `django-storages <https://django-storages.readthedocs.io/>`_ app as
    the remote storage.
    """
    def __init__(self, remote='storages.backends.mongodb.GridFSStorage', *args, **kwargs):
        super(QueuedGridFSStorage, self).__init__(remote=remote, *args, **kwargs)


class QueuedCloudFilesStorage(QueuedFileSystemStorage):
    """
    A custom :class:`~queued_storage.backends.QueuedFileSystemStorage`
    subclass which uses the ``CloudFilesStorage`` storage of the
    `django-storages <https://django-storages.readthedocs.io/>`_ app as
    the remote storage.
    """
    def __init__(self, remote='storages.backends.mosso.CloudFilesStorage', *args, **kwargs):
        super(QueuedCloudFilesStorage, self).__init__(remote=remote, *args, **kwargs)


class QueuedSFTPStorage(QueuedFileSystemStorage):
    """
    A custom :class:`~queued_storage.backends.QueuedFileSystemStorage`
    subclass which uses the ``SFTPStorage`` storage of the
    `django-storages <https://django-storages.readthedocs.io/>`_ app as
    the remote storage.
    """
    def __init__(self, remote='storages.backends.sftpstorage.SFTPStorage', *args, **kwargs):
        super(QueuedSFTPStorage, self).__init__(remote=remote, *args, **kwargs)

1	import six	7✔
2
3	from django.core.cache import cache	7✔
4	from django.core.exceptions import ImproperlyConfigured	7✔
5	from django.utils.functional import SimpleLazyObject	7✔
6	from django.utils.http import urlquote	7✔
7
8	from .conf import settings	7✔
9	from .utils import import_attribute, django_version	7✔
10
11	if django_version()[1] >= 7:	7✔
12	from django.utils.deconstruct import deconstructible	7✔
13
14
15	class LazyBackend(SimpleLazyObject):	7✔
16
17	def __init__(self, import_path, options):	7✔
18	backend = import_attribute(import_path)	7✔
19	super(LazyBackend, self).__init__(lambda: backend(**options))	7✔
20
21
22	class QueuedStorage(object):	7✔
23	"""
24	Base class for queued storages. You can use this to specify your own
25	backends.
26
27	:param local: local storage class to transfer from
28	:type local: str
29	:param local_options: options of the local storage class
30	:type local_options: dict
31	:param remote: remote storage class to transfer to
32	:type remote: str
33	:param remote_options: options of the remote storage class
34	:type remote_options: dict
35	:param cache_prefix: prefix to use in the cache key
36	:type cache_prefix: str
37	:param delayed: whether the transfer task should be executed automatically
38	:type delayed: bool
39	:param task: Celery task to use for the transfer
40	:type task: str
41	"""
42	#: The local storage class to use. A dotted path (e.g.
43	#: ``'django.core.files.storage.FileSystemStorage'``).
44	local = None	7✔
45
46	#: The options of the local storage class, defined as a dictionary.
47	local_options = None	7✔
48
49	#: The remote storage class to use. A dotted path (e.g.
50	#: ``'django.core.files.storage.FileSystemStorage'``).
51	remote = None	7✔
52
53	#: The options of the remote storage class, defined as a dictionary.
54	remote_options = None	7✔
55
56	#: The Celery task class to use to transfer files from the local
57	#: to the remote storage. A dotted path (e.g.
58	#: ``'queued_storage.tasks.Transfer'``).
59	task = 'queued_storage.tasks.Transfer'	7✔
60
61	#: If set to ``True`` the backend will not transfer files to the remote
62	#: location automatically, but instead requires manual intervention by the
63	#: user with the :meth:`~queued_storage.backends.QueuedStorage.transfer`
64	#: method.
65	delayed = False	7✔
66
67	#: The cache key prefix to use when saving the which storage backend
68	#: to use, local or remote (default see
69	#: :attr:`~queued_storage.conf.settings.QUEUED_STORAGE_CACHE_PREFIX`)
70	cache_prefix = settings.QUEUED_STORAGE_CACHE_PREFIX	7✔
71
72	def __init__(self, local=None, remote=None,	7✔
73	local_options=None, remote_options=None,
74	cache_prefix=None, delayed=None, task=None):
75
76	self.local_path = local or self.local	7✔
77	self.local_options = local_options or self.local_options or {}	7✔
78	self.local = self._load_backend(backend=self.local_path,	7✔
79	options=self.local_options)
80
81	self.remote_path = remote or self.remote	7✔
82	self.remote_options = remote_options or self.remote_options or {}	7✔
83	self.remote = self._load_backend(backend=self.remote_path,	7✔
84	options=self.remote_options)
85
86	self.task = self._load_backend(backend=task or self.task,	7✔
87	handler=import_attribute)
88	if delayed is not None:	7✔
89	self.delayed = delayed	7✔
90	if cache_prefix is not None:	7✔
91	self.cache_prefix = cache_prefix	7✔
92
93	def _load_backend(self, backend=None, options=None, handler=LazyBackend):	7✔
94	if backend is None: # pragma: no cover
95	raise ImproperlyConfigured("The QueuedStorage class '%s' "
96	"doesn't define a needed backend." %
97	(self))
98	if not isinstance(backend, six.string_types):	7✔
99	raise ImproperlyConfigured("The QueuedStorage class '%s' "	×
100	"requires its backends to be "
101	"specified as dotted import paths "
102	"not instances or classes" % self)
103	return handler(backend, options)	7✔
104
105	def get_storage(self, name):	7✔
106	"""
107	Returns the storage backend instance responsible for the file
108	with the given name (either local or remote). This method is
109	used in most of the storage API methods.
110
111	:param name: file name
112	:type name: str
113	:rtype: :class:`~django:django.core.files.storage.Storage`
114	"""
115	cache_result = cache.get(self.get_cache_key(name))	7✔
116	if cache_result:	7✔
117	return self.remote	7✔
118	elif cache_result is None and self.remote.exists(name):	7✔
119	cache.set(self.get_cache_key(name), True)	7✔
120	return self.remote	7✔
121	else:
122	return self.local	7✔
123
124	def get_cache_key(self, name):	7✔
125	"""
126	Returns the cache key for the given file name.
127
128	:param name: file name
129	:type name: str
130	:rtype: str
131	"""
132	return '%s_%s' % (self.cache_prefix, urlquote(name))	7✔
133
134	def using_local(self, name):	7✔
135	"""
136	Determines for the file with the given name whether
137	the local storage is current used.
138
139	:param name: file name
140	:type name: str
141	:rtype: bool
142	"""
143	return self.get_storage(name) is self.local	7✔
144
145	def using_remote(self, name):	7✔
146	"""
147	Determines for the file with the given name whether
148	the remote storage is current used.
149
150	:param name: file name
151	:type name: str
152	:rtype: bool
153	"""
154	return self.get_storage(name) is self.remote	7✔
155
156	def open(self, name, mode='rb'):	7✔
157	"""
158	Retrieves the specified file from storage.
159
160	:param name: file name
161	:type name: str
162	:param mode: mode to open the file with
163	:type mode: str
164	:rtype: :class:`~django:django.core.files.File`
165	"""
166	return self.get_storage(name).open(name, mode)	7✔
167
168	def save(self, name, content):	7✔
169	"""
170	Saves the given content with the given name using the local
171	storage. If the :attr:`~queued_storage.backends.QueuedStorage.delayed`
172	attribute is ``True`` this will automatically call the
173	:meth:`~queued_storage.backends.QueuedStorage.transfer` method
174	queuing the transfer from local to remote storage.
175
176	:param name: file name
177	:type name: str
178	:param content: content of the file specified by name
179	:type content: :class:`~django:django.core.files.File`
180	:rtype: str
181	"""
182	cache_key = self.get_cache_key(name)	7✔
183	cache.set(cache_key, False)	7✔
184
185	# Use a name that is available on both the local and remote storage
186	# systems and save locally.
187	name = self.get_available_name(name)	7✔
188	name = self.local.save(name, content)	7✔
189
190	# Pass on the cache key to prevent duplicate cache key creation,
191	# we save the result in the storage to be able to test for it
192	if not self.delayed:	7✔
193	self.result = self.transfer(name, cache_key=cache_key)	7✔
194	return name	7✔
195
196	def transfer(self, name, cache_key=None):	7✔
197	"""
198	Transfers the file with the given name to the remote storage
199	backend by queuing the task.
200
201	:param name: file name
202	:type name: str
203	:param cache_key: the cache key to set after a successful task run
204	:type cache_key: str
205	:rtype: task result
206	"""
207	if cache_key is None:	7✔
208	cache_key = self.get_cache_key(name)	7✔
209	return self.task.delay(name, cache_key,	7✔
210	self.local_path, self.remote_path,
211	self.local_options, self.remote_options)
212
213	def get_valid_name(self, name):	7✔
214	"""
215	Returns a filename, based on the provided filename, that's suitable
216	for use in the current storage system.
217
218	:param name: file name
219	:type name: str
220	:rtype: str
221	"""
222	return self.get_storage(name).get_valid_name(name)	7✔
223
224	def get_available_name(self, name):	7✔
225	"""
226	Returns a filename that's free on both the local and remote storage
227	systems, and available for new content to be written to.
228
229	:param name: file name
230	:type name: str
231	:rtype: str
232	"""
233	local_available_name = self.local.get_available_name(name)	7✔
234	remote_available_name = self.remote.get_available_name(name)	7✔
235
236	if remote_available_name > local_available_name:	7✔
237	return remote_available_name	×
238	return local_available_name	7✔
239
240	def path(self, name):	7✔
241	"""
242	Returns a local filesystem path where the file can be retrieved using
243	Python's built-in open() function. Storage systems that can't be
244	accessed using open() should not implement this method.
245
246	:param name: file name
247	:type name: str
248	:rtype: str
249	"""
250	return self.get_storage(name).path(name)	7✔
251
252	def delete(self, name):	7✔
253	"""
254	Deletes the specified file from the storage system.
255
256	:param name: file name
257	:type name: str
258	"""
259	return self.get_storage(name).delete(name)	7✔
260
261	def exists(self, name):	7✔
262	"""
263	Returns ``True`` if a file referened by the given name already exists
264	in the storage system, or False if the name is available for a new
265	file.
266
267	:param name: file name
268	:type name: str
269	:rtype: bool
270	"""
271	return self.get_storage(name).exists(name)	7✔
272
273	def listdir(self, name):	7✔
274	"""
275	Lists the contents of the specified path, returning a 2-tuple of lists;
276	the first item being directories, the second item being files.
277
278	:param name: file name
279	:type name: str
280	:rtype: tuple
281	"""
282	return self.get_storage(name).listdir(name)	7✔
283
284	def size(self, name):	7✔
285	"""
286	Returns the total size, in bytes, of the file specified by name.
287
288	:param name: file name
289	:type name: str
290	:rtype: int
291	"""
292	return self.get_storage(name).size(name)	7✔
293
294	def url(self, name):	7✔
295	"""
296	Returns an absolute URL where the file's contents can be accessed
297	directly by a Web browser.
298
299	:param name: file name
300	:type name: str
301	:rtype: str
302	"""
303	return self.get_storage(name).url(name)	7✔
304
305	def accessed_time(self, name):	7✔
306	"""
307	Returns the last accessed time (as datetime object) of the file
308	specified by name.
309
310	:param name: file name
311	:type name: str
312	:rtype: :class:`~python:datetime.datetime`
313	"""
314	return self.get_storage(name).accessed_time(name)	7✔
315
316	def created_time(self, name):	7✔
317	"""
318	Returns the creation time (as datetime object) of the file
319	specified by name.
320
321	:param name: file name
322	:type name: str
323	:rtype: :class:`~python:datetime.datetime`
324	"""
325	return self.get_storage(name).created_time(name)	7✔
326
327	def modified_time(self, name):	7✔
328	"""
329	Returns the last modified time (as datetime object) of the file
330	specified by name.
331
332	:param name: file name
333	:type name: str
334	:rtype: :class:`~python:datetime.datetime`
335	"""
336	return self.get_storage(name).modified_time(name)	7✔
337	if django_version()[1] >= 7:	7✔
338	QueuedStorage = deconstructible(QueuedStorage)	7✔
339
340
341	class QueuedFileSystemStorage(QueuedStorage):	7✔
342	"""
343	A :class:`~queued_storage.backends.QueuedStorage` subclass which
344	conveniently uses
345	:class:`~django:django.core.files.storage.FileSystemStorage` as the local
346	storage.
347	"""
348	def __init__(self, local='django.core.files.storage.FileSystemStorage', args, *kwargs):	7✔
349	super(QueuedFileSystemStorage, self).__init__(local=local, args, *kwargs)	×
350
351
352	class QueuedS3BotoStorage(QueuedFileSystemStorage):	7✔
353	"""
354	A custom :class:`~queued_storage.backends.QueuedFileSystemStorage`
355	subclass which uses the ``S3BotoStorage`` storage of the
356	`django-storages <https://django-storages.readthedocs.io/>`_ app as
357	the remote storage.
358	"""
359	def __init__(self, remote='storages.backends.s3boto.S3BotoStorage', args, *kwargs):	7✔
360	super(QueuedS3BotoStorage, self).__init__(remote=remote, args, *kwargs)	×
361
362
363	class QueuedCouchDBStorage(QueuedFileSystemStorage):	7✔
364	"""
365	A custom :class:`~queued_storage.backends.QueuedFileSystemStorage`
366	subclass which uses the ``CouchDBStorage`` storage of the
367	`django-storages <https://django-storages.readthedocs.io/>`_ app as
368	the remote storage.
369	"""
370	def __init__(self, remote='storages.backends.couchdb.CouchDBStorage', args, *kwargs):	7✔
371	super(QueuedCouchDBStorage, self).__init__(remote=remote, args, *kwargs)	×
372
373
374	class QueuedDatabaseStorage(QueuedFileSystemStorage):	7✔
375	"""
376	A custom :class:`~queued_storage.backends.QueuedFileSystemStorage`
377	subclass which uses the ``DatabaseStorage`` storage of the
378	`django-storages <https://django-storages.readthedocs.io/>`_ app as
379	the remote storage.
380	"""
381	def __init__(self, remote='storages.backends.database.DatabaseStorage', args, *kwargs):	7✔
382	super(QueuedDatabaseStorage, self).__init__(remote=remote, args, *kwargs)	×
383
384
385	class QueuedFTPStorage(QueuedFileSystemStorage):	7✔
386	"""
387	A custom :class:`~queued_storage.backends.QueuedFileSystemStorage`
388	subclass which uses the ``FTPStorage`` storage of the
389	`django-storages <https://django-storages.readthedocs.io/>`_ app as
390	the remote storage.
391	"""
392	def __init__(self, remote='storages.backends.ftp.FTPStorage', args, *kwargs):	7✔
393	super(QueuedFTPStorage, self).__init__(remote=remote, args, *kwargs)	×
394
395
396	class QueuedMogileFSStorage(QueuedFileSystemStorage):	7✔
397	"""
398	A custom :class:`~queued_storage.backends.QueuedFileSystemStorage`
399	subclass which uses the ``MogileFSStorage`` storage of the
400	`django-storages <https://django-storages.readthedocs.io/>`_ app as
401	the remote storage.
402	"""
403	def __init__(self, remote='storages.backends.mogile.MogileFSStorage', args, *kwargs):	7✔
404	super(QueuedMogileFSStorage, self).__init__(remote=remote, args, *kwargs)	×
405
406
407	class QueuedGridFSStorage(QueuedFileSystemStorage):	7✔
408	"""
409	A custom :class:`~queued_storage.backends.QueuedFileSystemStorage`
410	subclass which uses the ``GridFSStorage`` storage of the
411	`django-storages <https://django-storages.readthedocs.io/>`_ app as
412	the remote storage.
413	"""
414	def __init__(self, remote='storages.backends.mongodb.GridFSStorage', args, *kwargs):	7✔
415	super(QueuedGridFSStorage, self).__init__(remote=remote, args, *kwargs)	×
416
417
418	class QueuedCloudFilesStorage(QueuedFileSystemStorage):	7✔
419	"""
420	A custom :class:`~queued_storage.backends.QueuedFileSystemStorage`
421	subclass which uses the ``CloudFilesStorage`` storage of the
422	`django-storages <https://django-storages.readthedocs.io/>`_ app as
423	the remote storage.
424	"""
425	def __init__(self, remote='storages.backends.mosso.CloudFilesStorage', args, *kwargs):	7✔
426	super(QueuedCloudFilesStorage, self).__init__(remote=remote, args, *kwargs)	×
427
428
429	class QueuedSFTPStorage(QueuedFileSystemStorage):	7✔
430	"""
431	A custom :class:`~queued_storage.backends.QueuedFileSystemStorage`
432	subclass which uses the ``SFTPStorage`` storage of the
433	`django-storages <https://django-storages.readthedocs.io/>`_ app as
434	the remote storage.
435	"""
436	def __init__(self, remote='storages.backends.sftpstorage.SFTPStorage', args, *kwargs):	7✔
437	super(QueuedSFTPStorage, self).__init__(remote=remote, args, *kwargs)	×

jazzband / django-queued-storage / 107

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous