Upgrade to Django 1.11

- Database integration yet to be tested

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)