diff options
Diffstat (limited to 'lib/python2.7/site-packages/django/contrib/staticfiles')
15 files changed, 0 insertions, 1180 deletions
diff --git a/lib/python2.7/site-packages/django/contrib/staticfiles/__init__.py b/lib/python2.7/site-packages/django/contrib/staticfiles/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/lib/python2.7/site-packages/django/contrib/staticfiles/__init__.py +++ /dev/null diff --git a/lib/python2.7/site-packages/django/contrib/staticfiles/finders.py b/lib/python2.7/site-packages/django/contrib/staticfiles/finders.py deleted file mode 100644 index 6dfa31b..0000000 --- a/lib/python2.7/site-packages/django/contrib/staticfiles/finders.py +++ /dev/null @@ -1,266 +0,0 @@ -import os -from django.conf import settings -from django.core.exceptions import ImproperlyConfigured -from django.core.files.storage import default_storage, Storage, FileSystemStorage -from django.utils.datastructures import SortedDict -from django.utils.functional import empty, memoize, LazyObject -from django.utils.module_loading import import_by_path -from django.utils._os import safe_join -from django.utils import six - -from django.contrib.staticfiles import utils -from django.contrib.staticfiles.storage import AppStaticStorage - -_finders = SortedDict() - - -class BaseFinder(object): - """ - A base file finder to be used for custom staticfiles finder classes. - """ - def find(self, path, all=False): - """ - Given a relative file path this ought to find an - absolute file path. - - If the ``all`` parameter is ``False`` (default) only - the first found file path will be returned; if set - to ``True`` a list of all found files paths is returned. - """ - raise NotImplementedError() - - def list(self, ignore_patterns): - """ - Given an optional list of paths to ignore, this should return - a two item iterable consisting of the relative path and storage - instance. - """ - raise NotImplementedError() - - -class FileSystemFinder(BaseFinder): - """ - A static files finder that uses the ``STATICFILES_DIRS`` setting - to locate files. - """ - def __init__(self, apps=None, *args, **kwargs): - # List of locations with static files - self.locations = [] - # Maps dir paths to an appropriate storage instance - self.storages = SortedDict() - if not isinstance(settings.STATICFILES_DIRS, (list, tuple)): - raise ImproperlyConfigured( - "Your STATICFILES_DIRS setting is not a tuple or list; " - "perhaps you forgot a trailing comma?") - for root in settings.STATICFILES_DIRS: - if isinstance(root, (list, tuple)): - prefix, root = root - else: - prefix = '' - if settings.STATIC_ROOT and os.path.abspath(settings.STATIC_ROOT) == os.path.abspath(root): - raise ImproperlyConfigured( - "The STATICFILES_DIRS setting should " - "not contain the STATIC_ROOT setting") - if (prefix, root) not in self.locations: - self.locations.append((prefix, root)) - for prefix, root in self.locations: - filesystem_storage = FileSystemStorage(location=root) - filesystem_storage.prefix = prefix - self.storages[root] = filesystem_storage - super(FileSystemFinder, self).__init__(*args, **kwargs) - - def find(self, path, all=False): - """ - Looks for files in the extra locations - as defined in ``STATICFILES_DIRS``. - """ - matches = [] - for prefix, root in self.locations: - matched_path = self.find_location(root, path, prefix) - if matched_path: - if not all: - return matched_path - matches.append(matched_path) - return matches - - def find_location(self, root, path, prefix=None): - """ - Finds a requested static file in a location, returning the found - absolute path (or ``None`` if no match). - """ - if prefix: - prefix = '%s%s' % (prefix, os.sep) - if not path.startswith(prefix): - return None - path = path[len(prefix):] - path = safe_join(root, path) - if os.path.exists(path): - return path - - def list(self, ignore_patterns): - """ - List all files in all locations. - """ - for prefix, root in self.locations: - storage = self.storages[root] - for path in utils.get_files(storage, ignore_patterns): - yield path, storage - - -class AppDirectoriesFinder(BaseFinder): - """ - A static files finder that looks in the directory of each app as - specified in the source_dir attribute of the given storage class. - """ - storage_class = AppStaticStorage - - def __init__(self, apps=None, *args, **kwargs): - # The list of apps that are handled - self.apps = [] - # Mapping of app module paths to storage instances - self.storages = SortedDict() - if apps is None: - apps = settings.INSTALLED_APPS - for app in apps: - app_storage = self.storage_class(app) - if os.path.isdir(app_storage.location): - self.storages[app] = app_storage - if app not in self.apps: - self.apps.append(app) - super(AppDirectoriesFinder, self).__init__(*args, **kwargs) - - def list(self, ignore_patterns): - """ - List all files in all app storages. - """ - for storage in six.itervalues(self.storages): - if storage.exists(''): # check if storage location exists - for path in utils.get_files(storage, ignore_patterns): - yield path, storage - - def find(self, path, all=False): - """ - Looks for files in the app directories. - """ - matches = [] - for app in self.apps: - match = self.find_in_app(app, path) - if match: - if not all: - return match - matches.append(match) - return matches - - def find_in_app(self, app, path): - """ - Find a requested static file in an app's static locations. - """ - storage = self.storages.get(app, None) - if storage: - if storage.prefix: - prefix = '%s%s' % (storage.prefix, os.sep) - if not path.startswith(prefix): - return None - path = path[len(prefix):] - # only try to find a file if the source dir actually exists - if storage.exists(path): - matched_path = storage.path(path) - if matched_path: - return matched_path - - -class BaseStorageFinder(BaseFinder): - """ - A base static files finder to be used to extended - with an own storage class. - """ - storage = None - - def __init__(self, storage=None, *args, **kwargs): - if storage is not None: - self.storage = storage - if self.storage is None: - raise ImproperlyConfigured("The staticfiles storage finder %r " - "doesn't have a storage class " - "assigned." % self.__class__) - # Make sure we have an storage instance here. - if not isinstance(self.storage, (Storage, LazyObject)): - self.storage = self.storage() - super(BaseStorageFinder, self).__init__(*args, **kwargs) - - def find(self, path, all=False): - """ - Looks for files in the default file storage, if it's local. - """ - try: - self.storage.path('') - except NotImplementedError: - pass - else: - if self.storage.exists(path): - match = self.storage.path(path) - if all: - match = [match] - return match - return [] - - def list(self, ignore_patterns): - """ - List all files of the storage. - """ - for path in utils.get_files(self.storage, ignore_patterns): - yield path, self.storage - - -class DefaultStorageFinder(BaseStorageFinder): - """ - A static files finder that uses the default storage backend. - """ - storage = default_storage - - def __init__(self, *args, **kwargs): - super(DefaultStorageFinder, self).__init__(*args, **kwargs) - base_location = getattr(self.storage, 'base_location', empty) - if not base_location: - raise ImproperlyConfigured("The storage backend of the " - "staticfiles finder %r doesn't have " - "a valid location." % self.__class__) - - -def find(path, all=False): - """ - Find a static file with the given path using all enabled finders. - - If ``all`` is ``False`` (default), return the first matching - absolute path (or ``None`` if no match). Otherwise return a list. - """ - matches = [] - for finder in get_finders(): - result = finder.find(path, all=all) - if not all and result: - return result - if not isinstance(result, (list, tuple)): - result = [result] - matches.extend(result) - if matches: - return matches - # No match. - return [] if all else None - - -def get_finders(): - for finder_path in settings.STATICFILES_FINDERS: - yield get_finder(finder_path) - - -def _get_finder(import_path): - """ - Imports the staticfiles finder class described by import_path, where - import_path is the full Python path to the class. - """ - Finder = import_by_path(import_path) - if not issubclass(Finder, BaseFinder): - raise ImproperlyConfigured('Finder "%s" is not a subclass of "%s"' % - (Finder, BaseFinder)) - return Finder() -get_finder = memoize(_get_finder, _finders, 1) diff --git a/lib/python2.7/site-packages/django/contrib/staticfiles/handlers.py b/lib/python2.7/site-packages/django/contrib/staticfiles/handlers.py deleted file mode 100644 index e6db3dc..0000000 --- a/lib/python2.7/site-packages/django/contrib/staticfiles/handlers.py +++ /dev/null @@ -1,68 +0,0 @@ -from django.conf import settings -from django.core.handlers.base import get_path_info -from django.core.handlers.wsgi import WSGIHandler -from django.utils.six.moves.urllib.parse import urlparse -from django.utils.six.moves.urllib.request import url2pathname - -from django.contrib.staticfiles import utils -from django.contrib.staticfiles.views import serve - -class StaticFilesHandler(WSGIHandler): - """ - WSGI middleware that intercepts calls to the static files directory, as - defined by the STATIC_URL setting, and serves those files. - """ - def __init__(self, application, base_dir=None): - self.application = application - if base_dir: - self.base_dir = base_dir - else: - self.base_dir = self.get_base_dir() - self.base_url = urlparse(self.get_base_url()) - super(StaticFilesHandler, self).__init__() - - def get_base_dir(self): - return settings.STATIC_ROOT - - def get_base_url(self): - utils.check_settings() - return settings.STATIC_URL - - def _should_handle(self, path): - """ - Checks if the path should be handled. Ignores the path if: - - * the host is provided as part of the base_url - * the request's path isn't under the media path (or equal) - """ - return path.startswith(self.base_url[2]) and not self.base_url[1] - - def file_path(self, url): - """ - Returns the relative path to the media file on disk for the given URL. - """ - relative_url = url[len(self.base_url[2]):] - return url2pathname(relative_url) - - def serve(self, request): - """ - Actually serves the request path. - """ - return serve(request, self.file_path(request.path), insecure=True) - - def get_response(self, request): - from django.http import Http404 - - if self._should_handle(request.path): - try: - return self.serve(request) - except Http404 as e: - if settings.DEBUG: - from django.views import debug - return debug.technical_404_response(request, e) - return super(StaticFilesHandler, self).get_response(request) - - def __call__(self, environ, start_response): - if not self._should_handle(get_path_info(environ)): - return self.application(environ, start_response) - return super(StaticFilesHandler, self).__call__(environ, start_response) diff --git a/lib/python2.7/site-packages/django/contrib/staticfiles/management/__init__.py b/lib/python2.7/site-packages/django/contrib/staticfiles/management/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/lib/python2.7/site-packages/django/contrib/staticfiles/management/__init__.py +++ /dev/null diff --git a/lib/python2.7/site-packages/django/contrib/staticfiles/management/commands/__init__.py b/lib/python2.7/site-packages/django/contrib/staticfiles/management/commands/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/lib/python2.7/site-packages/django/contrib/staticfiles/management/commands/__init__.py +++ /dev/null diff --git a/lib/python2.7/site-packages/django/contrib/staticfiles/management/commands/collectstatic.py b/lib/python2.7/site-packages/django/contrib/staticfiles/management/commands/collectstatic.py deleted file mode 100644 index 90552b1..0000000 --- a/lib/python2.7/site-packages/django/contrib/staticfiles/management/commands/collectstatic.py +++ /dev/null @@ -1,319 +0,0 @@ -from __future__ import unicode_literals - -import os -import sys -from optparse import make_option - -from django.core.files.storage import FileSystemStorage -from django.core.management.base import CommandError, NoArgsCommand -from django.utils.encoding import smart_text -from django.utils.datastructures import SortedDict -from django.utils.functional import LazyObject -from django.utils.six.moves import input - -from django.contrib.staticfiles import finders, storage - - -class Command(NoArgsCommand): - """ - Command that allows to copy or symlink static files from different - locations to the settings.STATIC_ROOT. - """ - option_list = NoArgsCommand.option_list + ( - make_option('--noinput', - action='store_false', dest='interactive', default=True, - help="Do NOT prompt the user for input of any kind."), - make_option('--no-post-process', - action='store_false', dest='post_process', default=True, - help="Do NOT post process collected files."), - make_option('-i', '--ignore', action='append', default=[], - dest='ignore_patterns', metavar='PATTERN', - help="Ignore files or directories matching this glob-style " - "pattern. Use multiple times to ignore more."), - make_option('-n', '--dry-run', - action='store_true', dest='dry_run', default=False, - help="Do everything except modify the filesystem."), - make_option('-c', '--clear', - action='store_true', dest='clear', default=False, - help="Clear the existing files using the storage " - "before trying to copy or link the original file."), - make_option('-l', '--link', - action='store_true', dest='link', default=False, - help="Create a symbolic link to each file instead of copying."), - make_option('--no-default-ignore', action='store_false', - dest='use_default_ignore_patterns', default=True, - help="Don't ignore the common private glob-style patterns 'CVS', " - "'.*' and '*~'."), - ) - help = "Collect static files in a single location." - requires_model_validation = False - - def __init__(self, *args, **kwargs): - super(NoArgsCommand, self).__init__(*args, **kwargs) - self.copied_files = [] - self.symlinked_files = [] - self.unmodified_files = [] - self.post_processed_files = [] - self.storage = storage.staticfiles_storage - try: - self.storage.path('') - except NotImplementedError: - self.local = False - else: - self.local = True - - def set_options(self, **options): - """ - Set instance variables based on an options dict - """ - self.interactive = options['interactive'] - self.verbosity = int(options.get('verbosity', 1)) - self.symlink = options['link'] - self.clear = options['clear'] - self.dry_run = options['dry_run'] - ignore_patterns = options['ignore_patterns'] - if options['use_default_ignore_patterns']: - ignore_patterns += ['CVS', '.*', '*~'] - self.ignore_patterns = list(set(ignore_patterns)) - self.post_process = options['post_process'] - - def collect(self): - """ - Perform the bulk of the work of collectstatic. - - Split off from handle_noargs() to facilitate testing. - """ - if self.symlink: - if sys.platform == 'win32': - raise CommandError("Symlinking is not supported by this " - "platform (%s)." % sys.platform) - if not self.local: - raise CommandError("Can't symlink to a remote destination.") - - if self.clear: - self.clear_dir('') - - if self.symlink: - handler = self.link_file - else: - handler = self.copy_file - - found_files = SortedDict() - for finder in finders.get_finders(): - for path, storage in finder.list(self.ignore_patterns): - # Prefix the relative path if the source storage contains it - if getattr(storage, 'prefix', None): - prefixed_path = os.path.join(storage.prefix, path) - else: - prefixed_path = path - - if prefixed_path not in found_files: - found_files[prefixed_path] = (storage, path) - handler(path, prefixed_path, storage) - - # Here we check if the storage backend has a post_process - # method and pass it the list of modified files. - if self.post_process and hasattr(self.storage, 'post_process'): - processor = self.storage.post_process(found_files, - dry_run=self.dry_run) - for original_path, processed_path, processed in processor: - if isinstance(processed, Exception): - self.stderr.write("Post-processing '%s' failed!" % original_path) - # Add a blank line before the traceback, otherwise it's - # too easy to miss the relevant part of the error message. - self.stderr.write("") - raise processed - if processed: - self.log("Post-processed '%s' as '%s'" % - (original_path, processed_path), level=1) - self.post_processed_files.append(original_path) - else: - self.log("Skipped post-processing '%s'" % original_path) - - return { - 'modified': self.copied_files + self.symlinked_files, - 'unmodified': self.unmodified_files, - 'post_processed': self.post_processed_files, - } - - def handle_noargs(self, **options): - self.set_options(**options) - - message = ['\n'] - if self.dry_run: - message.append( - 'You have activated the --dry-run option so no files will be modified.\n\n' - ) - - message.append( - 'You have requested to collect static files at the destination\n' - 'location as specified in your settings' - ) - - if self.is_local_storage() and self.storage.location: - destination_path = self.storage.location - message.append(':\n\n %s\n\n' % destination_path) - else: - destination_path = None - message.append('.\n\n') - - if self.clear: - message.append('This will DELETE EXISTING FILES!\n') - else: - message.append('This will overwrite existing files!\n') - - message.append( - 'Are you sure you want to do this?\n\n' - "Type 'yes' to continue, or 'no' to cancel: " - ) - - if self.interactive and input(''.join(message)) != 'yes': - raise CommandError("Collecting static files cancelled.") - - collected = self.collect() - modified_count = len(collected['modified']) - unmodified_count = len(collected['unmodified']) - post_processed_count = len(collected['post_processed']) - - if self.verbosity >= 1: - template = ("\n%(modified_count)s %(identifier)s %(action)s" - "%(destination)s%(unmodified)s%(post_processed)s.\n") - summary = template % { - 'modified_count': modified_count, - 'identifier': 'static file' + ('' if modified_count == 1 else 's'), - 'action': 'symlinked' if self.symlink else 'copied', - 'destination': (" to '%s'" % destination_path if destination_path else ''), - 'unmodified': (', %s unmodified' % unmodified_count if collected['unmodified'] else ''), - 'post_processed': (collected['post_processed'] and - ', %s post-processed' - % post_processed_count or ''), - } - self.stdout.write(summary) - - def log(self, msg, level=2): - """ - Small log helper - """ - if self.verbosity >= level: - self.stdout.write(msg) - - def is_local_storage(self): - if issubclass(self.storage.__class__, LazyObject): - storage = self.storage._wrapped - else: - storage = self.storage - return isinstance(storage, FileSystemStorage) - - def clear_dir(self, path): - """ - Deletes the given relative path using the destination storage backend. - """ - dirs, files = self.storage.listdir(path) - for f in files: - fpath = os.path.join(path, f) - if self.dry_run: - self.log("Pretending to delete '%s'" % - smart_text(fpath), level=1) - else: - self.log("Deleting '%s'" % smart_text(fpath), level=1) - self.storage.delete(fpath) - for d in dirs: - self.clear_dir(os.path.join(path, d)) - - def delete_file(self, path, prefixed_path, source_storage): - """ - Checks if the target file should be deleted if it already exists - """ - if self.storage.exists(prefixed_path): - try: - # When was the target file modified last time? - target_last_modified = \ - self.storage.modified_time(prefixed_path) - except (OSError, NotImplementedError, AttributeError): - # The storage doesn't support ``modified_time`` or failed - pass - else: - try: - # When was the source file modified last time? - source_last_modified = source_storage.modified_time(path) - except (OSError, NotImplementedError, AttributeError): - pass - else: - # The full path of the target file - if self.local: - full_path = self.storage.path(prefixed_path) - else: - full_path = None - # Skip the file if the source file is younger - # Avoid sub-second precision (see #14665, #19540) - if (target_last_modified.replace(microsecond=0) - >= source_last_modified.replace(microsecond=0)): - if not ((self.symlink and full_path - and not os.path.islink(full_path)) or - (not self.symlink and full_path - and os.path.islink(full_path))): - if prefixed_path not in self.unmodified_files: - self.unmodified_files.append(prefixed_path) - self.log("Skipping '%s' (not modified)" % path) - return False - # Then delete the existing file if really needed - if self.dry_run: - self.log("Pretending to delete '%s'" % path) - else: - self.log("Deleting '%s'" % path) - self.storage.delete(prefixed_path) - return True - - def link_file(self, path, prefixed_path, source_storage): - """ - Attempt to link ``path`` - """ - # Skip this file if it was already copied earlier - if prefixed_path in self.symlinked_files: - return self.log("Skipping '%s' (already linked earlier)" % path) - # Delete the target file if needed or break - if not self.delete_file(path, prefixed_path, source_storage): - return - # The full path of the source file - source_path = source_storage.path(path) - # Finally link the file - if self.dry_run: - self.log("Pretending to link '%s'" % source_path, level=1) - else: - self.log("Linking '%s'" % source_path, level=1) - full_path = self.storage.path(prefixed_path) - try: - os.makedirs(os.path.dirname(full_path)) - except OSError: - pass - os.symlink(source_path, full_path) - if prefixed_path not in self.symlinked_files: - self.symlinked_files.append(prefixed_path) - - def copy_file(self, path, prefixed_path, source_storage): - """ - Attempt to copy ``path`` with storage - """ - # Skip this file if it was already copied earlier - if prefixed_path in self.copied_files: - return self.log("Skipping '%s' (already copied earlier)" % path) - # Delete the target file if needed or break - if not self.delete_file(path, prefixed_path, source_storage): - return - # The full path of the source file - source_path = source_storage.path(path) - # Finally start copying - if self.dry_run: - self.log("Pretending to copy '%s'" % source_path, level=1) - else: - self.log("Copying '%s'" % source_path, level=1) - if self.local: - full_path = self.storage.path(prefixed_path) - try: - os.makedirs(os.path.dirname(full_path)) - except OSError: - pass - with source_storage.open(path) as source_file: - self.storage.save(prefixed_path, source_file) - if not prefixed_path in self.copied_files: - self.copied_files.append(prefixed_path) diff --git a/lib/python2.7/site-packages/django/contrib/staticfiles/management/commands/findstatic.py b/lib/python2.7/site-packages/django/contrib/staticfiles/management/commands/findstatic.py deleted file mode 100644 index eaf63f7..0000000 --- a/lib/python2.7/site-packages/django/contrib/staticfiles/management/commands/findstatic.py +++ /dev/null @@ -1,34 +0,0 @@ -from __future__ import unicode_literals - -import os -from optparse import make_option -from django.core.management.base import LabelCommand -from django.utils.encoding import force_text - -from django.contrib.staticfiles import finders - -class Command(LabelCommand): - help = "Finds the absolute paths for the given static file(s)." - args = "[file ...]" - label = 'static file' - option_list = LabelCommand.option_list + ( - make_option('--first', action='store_false', dest='all', default=True, - help="Only return the first match for each static file."), - ) - - def handle_label(self, path, **options): - verbosity = int(options.get('verbosity', 1)) - result = finders.find(path, all=options['all']) - path = force_text(path) - if result: - if not isinstance(result, (list, tuple)): - result = [result] - result = (force_text(os.path.realpath(path)) for path in result) - if verbosity >= 1: - output = '\n '.join(result) - return "Found '%s' here:\n %s" % (path, output) - else: - return '\n'.join(result) - else: - if verbosity >= 1: - self.stderr.write("No matching file found for '%s'." % path) diff --git a/lib/python2.7/site-packages/django/contrib/staticfiles/management/commands/runserver.py b/lib/python2.7/site-packages/django/contrib/staticfiles/management/commands/runserver.py deleted file mode 100644 index 0f9e39f..0000000 --- a/lib/python2.7/site-packages/django/contrib/staticfiles/management/commands/runserver.py +++ /dev/null @@ -1,29 +0,0 @@ -from optparse import make_option - -from django.conf import settings -from django.core.management.commands.runserver import Command as RunserverCommand - -from django.contrib.staticfiles.handlers import StaticFilesHandler - -class Command(RunserverCommand): - option_list = RunserverCommand.option_list + ( - make_option('--nostatic', action="store_false", dest='use_static_handler', default=True, - help='Tells Django to NOT automatically serve static files at STATIC_URL.'), - make_option('--insecure', action="store_true", dest='insecure_serving', default=False, - help='Allows serving static files even if DEBUG is False.'), - ) - help = "Starts a lightweight Web server for development and also serves static files." - - def get_handler(self, *args, **options): - """ - Returns the static files serving handler wrapping the default handler, - if static files should be served. Otherwise just returns the default - handler. - - """ - handler = super(Command, self).get_handler(*args, **options) - use_static_handler = options.get('use_static_handler', True) - insecure_serving = options.get('insecure_serving', False) - if use_static_handler and (settings.DEBUG or insecure_serving): - return StaticFilesHandler(handler) - return handler diff --git a/lib/python2.7/site-packages/django/contrib/staticfiles/models.py b/lib/python2.7/site-packages/django/contrib/staticfiles/models.py deleted file mode 100644 index e69de29..0000000 --- a/lib/python2.7/site-packages/django/contrib/staticfiles/models.py +++ /dev/null diff --git a/lib/python2.7/site-packages/django/contrib/staticfiles/storage.py b/lib/python2.7/site-packages/django/contrib/staticfiles/storage.py deleted file mode 100644 index 7e0b8f0..0000000 --- a/lib/python2.7/site-packages/django/contrib/staticfiles/storage.py +++ /dev/null @@ -1,313 +0,0 @@ -from __future__ import unicode_literals -import hashlib -import os -import posixpath -import re - -from django.conf import settings -from django.core.cache import (get_cache, InvalidCacheBackendError, - cache as default_cache) -from django.core.exceptions import ImproperlyConfigured -from django.core.files.base import ContentFile -from django.core.files.storage import FileSystemStorage, get_storage_class -from django.utils.datastructures import SortedDict -from django.utils.encoding import force_bytes, force_text -from django.utils.functional import LazyObject -from django.utils.importlib import import_module -from django.utils.six.moves.urllib.parse import unquote, urlsplit, urlunsplit, urldefrag -from django.utils._os import upath - -from django.contrib.staticfiles.utils import check_settings, matches_patterns - - -class StaticFilesStorage(FileSystemStorage): - """ - Standard file system storage for static files. - - The defaults for ``location`` and ``base_url`` are - ``STATIC_ROOT`` and ``STATIC_URL``. - """ - def __init__(self, location=None, base_url=None, *args, **kwargs): - if location is None: - location = settings.STATIC_ROOT - if base_url is None: - base_url = settings.STATIC_URL - check_settings(base_url) - super(StaticFilesStorage, self).__init__(location, base_url, - *args, **kwargs) - # FileSystemStorage fallbacks to MEDIA_ROOT when location - # is empty, so we restore the empty value. - if not location: - self.base_location = None - self.location = None - - def path(self, name): - if not self.location: - raise ImproperlyConfigured("You're using the staticfiles app " - "without having set the STATIC_ROOT " - "setting to a filesystem path.") - return super(StaticFilesStorage, self).path(name) - - -class CachedFilesMixin(object): - default_template = """url("%s")""" - patterns = ( - ("*.css", ( - r"""(url\(['"]{0,1}\s*(.*?)["']{0,1}\))""", - (r"""(@import\s*["']\s*(.*?)["'])""", """@import url("%s")"""), - )), - ) - - def __init__(self, *args, **kwargs): - super(CachedFilesMixin, self).__init__(*args, **kwargs) - try: - self.cache = get_cache('staticfiles') - except InvalidCacheBackendError: - # Use the default backend - self.cache = default_cache - self._patterns = SortedDict() - for extension, patterns in self.patterns: - for pattern in patterns: - if isinstance(pattern, (tuple, list)): - pattern, template = pattern - else: - template = self.default_template - compiled = re.compile(pattern, re.IGNORECASE) - self._patterns.setdefault(extension, []).append((compiled, template)) - - def file_hash(self, name, content=None): - """ - Retuns a hash of the file with the given name and optional content. - """ - if content is None: - return None - md5 = hashlib.md5() - for chunk in content.chunks(): - md5.update(chunk) - return md5.hexdigest()[:12] - - def hashed_name(self, name, content=None): - parsed_name = urlsplit(unquote(name)) - clean_name = parsed_name.path.strip() - opened = False - if content is None: - if not self.exists(clean_name): - raise ValueError("The file '%s' could not be found with %r." % - (clean_name, self)) - try: - content = self.open(clean_name) - except IOError: - # Handle directory paths and fragments - return name - opened = True - try: - file_hash = self.file_hash(clean_name, content) - finally: - if opened: - content.close() - path, filename = os.path.split(clean_name) - root, ext = os.path.splitext(filename) - if file_hash is not None: - file_hash = ".%s" % file_hash - hashed_name = os.path.join(path, "%s%s%s" % - (root, file_hash, ext)) - unparsed_name = list(parsed_name) - unparsed_name[2] = hashed_name - # Special casing for a @font-face hack, like url(myfont.eot?#iefix") - # http://www.fontspring.com/blog/the-new-bulletproof-font-face-syntax - if '?#' in name and not unparsed_name[3]: - unparsed_name[2] += '?' - return urlunsplit(unparsed_name) - - def cache_key(self, name): - return 'staticfiles:%s' % hashlib.md5(force_bytes(name)).hexdigest() - - def url(self, name, force=False): - """ - Returns the real URL in DEBUG mode. - """ - if settings.DEBUG and not force: - hashed_name, fragment = name, '' - else: - clean_name, fragment = urldefrag(name) - if urlsplit(clean_name).path.endswith('/'): # don't hash paths - hashed_name = name - else: - cache_key = self.cache_key(name) - hashed_name = self.cache.get(cache_key) - if hashed_name is None: - hashed_name = self.hashed_name(clean_name).replace('\\', '/') - # set the cache if there was a miss - # (e.g. if cache server goes down) - self.cache.set(cache_key, hashed_name) - - final_url = super(CachedFilesMixin, self).url(hashed_name) - - # Special casing for a @font-face hack, like url(myfont.eot?#iefix") - # http://www.fontspring.com/blog/the-new-bulletproof-font-face-syntax - query_fragment = '?#' in name # [sic!] - if fragment or query_fragment: - urlparts = list(urlsplit(final_url)) - if fragment and not urlparts[4]: - urlparts[4] = fragment - if query_fragment and not urlparts[3]: - urlparts[2] += '?' - final_url = urlunsplit(urlparts) - - return unquote(final_url) - - def url_converter(self, name, template=None): - """ - Returns the custom URL converter for the given file name. - """ - if template is None: - template = self.default_template - - def converter(matchobj): - """ - Converts the matched URL depending on the parent level (`..`) - and returns the normalized and hashed URL using the url method - of the storage. - """ - matched, url = matchobj.groups() - # Completely ignore http(s) prefixed URLs, - # fragments and data-uri URLs - if url.startswith(('#', 'http:', 'https:', 'data:', '//')): - return matched - name_parts = name.split(os.sep) - # Using posix normpath here to remove duplicates - url = posixpath.normpath(url) - url_parts = url.split('/') - parent_level, sub_level = url.count('..'), url.count('/') - if url.startswith('/'): - sub_level -= 1 - url_parts = url_parts[1:] - if parent_level or not url.startswith('/'): - start, end = parent_level + 1, parent_level - else: - if sub_level: - if sub_level == 1: - parent_level -= 1 - start, end = parent_level, 1 - else: - start, end = 1, sub_level - 1 - joined_result = '/'.join(name_parts[:-start] + url_parts[end:]) - hashed_url = self.url(unquote(joined_result), force=True) - file_name = hashed_url.split('/')[-1:] - relative_url = '/'.join(url.split('/')[:-1] + file_name) - - # Return the hashed version to the file - return template % unquote(relative_url) - - return converter - - def post_process(self, paths, dry_run=False, **options): - """ - Post process the given SortedDict of files (called from collectstatic). - - Processing is actually two separate operations: - - 1. renaming files to include a hash of their content for cache-busting, - and copying those files to the target storage. - 2. adjusting files which contain references to other files so they - refer to the cache-busting filenames. - - If either of these are performed on a file, then that file is considered - post-processed. - """ - # don't even dare to process the files if we're in dry run mode - if dry_run: - return - - # where to store the new paths - hashed_paths = {} - - # build a list of adjustable files - matches = lambda path: matches_patterns(path, self._patterns.keys()) - adjustable_paths = [path for path in paths if matches(path)] - - # then sort the files by the directory level - path_level = lambda name: len(name.split(os.sep)) - for name in sorted(paths.keys(), key=path_level, reverse=True): - - # use the original, local file, not the copied-but-unprocessed - # file, which might be somewhere far away, like S3 - storage, path = paths[name] - with storage.open(path) as original_file: - - # generate the hash with the original content, even for - # adjustable files. - hashed_name = self.hashed_name(name, original_file) - - # then get the original's file content.. - if hasattr(original_file, 'seek'): - original_file.seek(0) - - hashed_file_exists = self.exists(hashed_name) - processed = False - - # ..to apply each replacement pattern to the content - if name in adjustable_paths: - content = original_file.read().decode(settings.FILE_CHARSET) - for patterns in self._patterns.values(): - for pattern, template in patterns: - converter = self.url_converter(name, template) - try: - content = pattern.sub(converter, content) - except ValueError as exc: - yield name, None, exc - if hashed_file_exists: - self.delete(hashed_name) - # then save the processed result - content_file = ContentFile(force_bytes(content)) - saved_name = self._save(hashed_name, content_file) - hashed_name = force_text(saved_name.replace('\\', '/')) - processed = True - else: - # or handle the case in which neither processing nor - # a change to the original file happened - if not hashed_file_exists: - processed = True - saved_name = self._save(hashed_name, original_file) - hashed_name = force_text(saved_name.replace('\\', '/')) - - # and then set the cache accordingly - hashed_paths[self.cache_key(name.replace('\\', '/'))] = hashed_name - yield name, hashed_name, processed - - # Finally set the cache - self.cache.set_many(hashed_paths) - - -class CachedStaticFilesStorage(CachedFilesMixin, StaticFilesStorage): - """ - A static file system storage backend which also saves - hashed copies of the files it saves. - """ - pass - - -class AppStaticStorage(FileSystemStorage): - """ - A file system storage backend that takes an app module and works - for the ``static`` directory of it. - """ - prefix = None - source_dir = 'static' - - def __init__(self, app, *args, **kwargs): - """ - Returns a static file storage if available in the given app. - """ - # app is the actual app module - mod = import_module(app) - mod_path = os.path.dirname(upath(mod.__file__)) - location = os.path.join(mod_path, self.source_dir) - super(AppStaticStorage, self).__init__(location, *args, **kwargs) - - -class ConfiguredStorage(LazyObject): - def _setup(self): - self._wrapped = get_storage_class(settings.STATICFILES_STORAGE)() - -staticfiles_storage = ConfiguredStorage() diff --git a/lib/python2.7/site-packages/django/contrib/staticfiles/templatetags/__init__.py b/lib/python2.7/site-packages/django/contrib/staticfiles/templatetags/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/lib/python2.7/site-packages/django/contrib/staticfiles/templatetags/__init__.py +++ /dev/null diff --git a/lib/python2.7/site-packages/django/contrib/staticfiles/templatetags/staticfiles.py b/lib/python2.7/site-packages/django/contrib/staticfiles/templatetags/staticfiles.py deleted file mode 100644 index ab92275..0000000 --- a/lib/python2.7/site-packages/django/contrib/staticfiles/templatetags/staticfiles.py +++ /dev/null @@ -1,37 +0,0 @@ -from django import template -from django.templatetags.static import StaticNode -from django.contrib.staticfiles.storage import staticfiles_storage - -register = template.Library() - - -class StaticFilesNode(StaticNode): - - def url(self, context): - path = self.path.resolve(context) - return staticfiles_storage.url(path) - - -@register.tag('static') -def do_static(parser, token): - """ - A template tag that returns the URL to a file - using staticfiles' storage backend - - Usage:: - - {% static path [as varname] %} - - Examples:: - - {% static "myapp/css/base.css" %} - {% static variable_with_path %} - {% static "myapp/css/base.css" as admin_base_css %} - {% static variable_with_path as varname %} - - """ - return StaticFilesNode.handle_token(parser, token) - - -def static(path): - return staticfiles_storage.url(path) diff --git a/lib/python2.7/site-packages/django/contrib/staticfiles/urls.py b/lib/python2.7/site-packages/django/contrib/staticfiles/urls.py deleted file mode 100644 index 04062c1..0000000 --- a/lib/python2.7/site-packages/django/contrib/staticfiles/urls.py +++ /dev/null @@ -1,16 +0,0 @@ -from django.conf import settings -from django.conf.urls.static import static - -urlpatterns = [] - -def staticfiles_urlpatterns(prefix=None): - """ - Helper function to return a URL pattern for serving static files. - """ - if prefix is None: - prefix = settings.STATIC_URL - return static(prefix, view='django.contrib.staticfiles.views.serve') - -# Only append if urlpatterns are empty -if settings.DEBUG and not urlpatterns: - urlpatterns += staticfiles_urlpatterns() diff --git a/lib/python2.7/site-packages/django/contrib/staticfiles/utils.py b/lib/python2.7/site-packages/django/contrib/staticfiles/utils.py deleted file mode 100644 index f500ed6..0000000 --- a/lib/python2.7/site-packages/django/contrib/staticfiles/utils.py +++ /dev/null @@ -1,57 +0,0 @@ -import os -import fnmatch -from django.conf import settings -from django.core.exceptions import ImproperlyConfigured - -def matches_patterns(path, patterns=None): - """ - Return True or False depending on whether the ``path`` should be - ignored (if it matches any pattern in ``ignore_patterns``). - """ - if patterns is None: - patterns = [] - for pattern in patterns: - if fnmatch.fnmatchcase(path, pattern): - return True - return False - -def get_files(storage, ignore_patterns=None, location=''): - """ - Recursively walk the storage directories yielding the paths - of all files that should be copied. - """ - if ignore_patterns is None: - ignore_patterns = [] - directories, files = storage.listdir(location) - for fn in files: - if matches_patterns(fn, ignore_patterns): - continue - if location: - fn = os.path.join(location, fn) - yield fn - for dir in directories: - if matches_patterns(dir, ignore_patterns): - continue - if location: - dir = os.path.join(location, dir) - for fn in get_files(storage, ignore_patterns, dir): - yield fn - -def check_settings(base_url=None): - """ - Checks if the staticfiles settings have sane values. - - """ - if base_url is None: - base_url = settings.STATIC_URL - if not base_url: - raise ImproperlyConfigured( - "You're using the staticfiles app " - "without having set the required STATIC_URL setting.") - if settings.MEDIA_URL == base_url: - raise ImproperlyConfigured("The MEDIA_URL and STATIC_URL " - "settings must have different values") - if ((settings.MEDIA_ROOT and settings.STATIC_ROOT) and - (settings.MEDIA_ROOT == settings.STATIC_ROOT)): - raise ImproperlyConfigured("The MEDIA_ROOT and STATIC_ROOT " - "settings must have different values") diff --git a/lib/python2.7/site-packages/django/contrib/staticfiles/views.py b/lib/python2.7/site-packages/django/contrib/staticfiles/views.py deleted file mode 100644 index a7f9b0d..0000000 --- a/lib/python2.7/site-packages/django/contrib/staticfiles/views.py +++ /dev/null @@ -1,41 +0,0 @@ -""" -Views and functions for serving static files. These are only to be used during -development, and SHOULD NOT be used in a production setting. - -""" -import os -import posixpath - -from django.conf import settings -from django.core.exceptions import ImproperlyConfigured -from django.http import Http404 -from django.utils.six.moves.urllib.parse import unquote -from django.views import static - -from django.contrib.staticfiles import finders - -def serve(request, path, insecure=False, **kwargs): - """ - Serve static files below a given point in the directory structure or - from locations inferred from the staticfiles finders. - - To use, put a URL pattern such as:: - - (r'^(?P<path>.*)$', 'django.contrib.staticfiles.views.serve') - - in your URLconf. - - It uses the django.views.static view to serve the found files. - """ - if not settings.DEBUG and not insecure: - raise ImproperlyConfigured("The staticfiles view can only be used in " - "debug mode or if the --insecure " - "option of 'runserver' is used") - normalized_path = posixpath.normpath(unquote(path)).lstrip('/') - absolute_path = finders.find(normalized_path) - if not absolute_path: - if path.endswith('/') or path == '': - raise Http404("Directory indexes are not allowed here.") - raise Http404("'%s' could not be found" % path) - document_root, path = os.path.split(absolute_path) - return static.serve(request, path, document_root=document_root, **kwargs) |