plain 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

plain/assets/storage.py

@@ -1,916 +0,0 @@
-import json
-import os
-import pathlib
-import posixpath
-import re
-from datetime import datetime, timezone
-from hashlib import md5
-from urllib.parse import unquote, urldefrag, urljoin, urlsplit, urlunsplit
-
-from plain.assets.utils import check_settings, matches_patterns
-from plain.exceptions import ImproperlyConfigured, SuspiciousFileOperation
-from plain.internal.files import File, locks
-from plain.internal.files.base import ContentFile
-from plain.internal.files.move import file_move_safe
-from plain.internal.files.utils import validate_file_name
-from plain.runtime import settings
-from plain.utils._os import safe_join
-from plain.utils.crypto import get_random_string
-from plain.utils.deconstruct import deconstructible
-from plain.utils.encoding import filepath_to_uri
-from plain.utils.functional import LazyObject, cached_property
-from plain.utils.module_loading import import_string
-from plain.utils.text import get_valid_filename
-
-
-class Storage:
-    """
-    A base storage class, providing some default behaviors that all other
-    storage systems can inherit or override, as necessary.
-    """
-
-    # The following methods represent a public interface to private methods.
-    # These shouldn't be overridden by subclasses unless absolutely necessary.
-
-    def open(self, name, mode="rb"):
-        """Retrieve the specified file from storage."""
-        return self._open(name, mode)
-
-    def save(self, name, content, max_length=None):
-        """
-        Save new content to the file specified by name. The content should be
-        a proper File object or any Python file-like object, ready to be read
-        from the beginning.
-        """
-        # Get the proper name for the file, as it will actually be saved.
-        if name is None:
-            name = content.name
-
-        if not hasattr(content, "chunks"):
-            content = File(content, name)
-
-        name = self.get_available_name(name, max_length=max_length)
-        name = self._save(name, content)
-        # Ensure that the name returned from the storage system is still valid.
-        validate_file_name(name, allow_relative_path=True)
-        return name
-
-    # These methods are part of the public API, with default implementations.
-
-    def get_valid_name(self, name):
-        """
-        Return a filename, based on the provided filename, that's suitable for
-        use in the target storage system.
-        """
-        return get_valid_filename(name)
-
-    def get_alternative_name(self, file_root, file_ext):
-        """
-        Return an alternative filename, by adding an underscore and a random 7
-        character alphanumeric string (before the file extension, if one
-        exists) to the filename.
-        """
-        return f"{file_root}_{get_random_string(7)}{file_ext}"
-
-    def get_available_name(self, name, max_length=None):
-        """
-        Return a filename that's free on the target storage system and
-        available for new content to be written to.
-        """
-        name = str(name).replace("\\", "/")
-        dir_name, file_name = os.path.split(name)
-        if ".." in pathlib.PurePath(dir_name).parts:
-            raise SuspiciousFileOperation(
-                "Detected path traversal attempt in '%s'" % dir_name
-            )
-        validate_file_name(file_name)
-        file_root, file_ext = os.path.splitext(file_name)
-        # If the filename already exists, generate an alternative filename
-        # until it doesn't exist.
-        # Truncate original name if required, so the new filename does not
-        # exceed the max_length.
-        while self.exists(name) or (max_length and len(name) > max_length):
-            # file_ext includes the dot.
-            name = os.path.join(
-                dir_name, self.get_alternative_name(file_root, file_ext)
-            )
-            if max_length is None:
-                continue
-            # Truncate file_root if max_length exceeded.
-            truncation = len(name) - max_length
-            if truncation > 0:
-                file_root = file_root[:-truncation]
-                # Entire file_root was truncated in attempt to find an
-                # available filename.
-                if not file_root:
-                    raise SuspiciousFileOperation(
-                        'Storage can not find an available filename for "%s". '
-                        "Please make sure that the corresponding file field "
-                        'allows sufficient "max_length".' % name
-                    )
-                name = os.path.join(
-                    dir_name, self.get_alternative_name(file_root, file_ext)
-                )
-        return name
-
-    def path(self, name):
-        """
-        Return a local filesystem path where the file can be retrieved using
-        Python's built-in open() function. Storage systems that can't be
-        accessed using open() should *not* implement this method.
-        """
-        raise NotImplementedError("This backend doesn't support absolute paths.")
-
-    # The following methods form the public API for storage systems, but with
-    # no default implementations. Subclasses must implement *all* of these.
-
-    def delete(self, name):
-        """
-        Delete the specified file from the storage system.
-        """
-        raise NotImplementedError(
-            "subclasses of Storage must provide a delete() method"
-        )
-
-    def exists(self, name):
-        """
-        Return True if a file referenced by the given name already exists in the
-        storage system, or False if the name is available for a new file.
-        """
-        raise NotImplementedError(
-            "subclasses of Storage must provide an exists() method"
-        )
-
-    def listdir(self, path):
-        """
-        List the contents of the specified path. Return a 2-tuple of lists:
-        the first item being directories, the second item being files.
-        """
-        raise NotImplementedError(
-            "subclasses of Storage must provide a listdir() method"
-        )
-
-    def size(self, name):
-        """
-        Return the total size, in bytes, of the file specified by name.
-        """
-        raise NotImplementedError("subclasses of Storage must provide a size() method")
-
-    def url(self, name):
-        """
-        Return an absolute URL where the file's contents can be accessed
-        directly by a web browser.
-        """
-        raise NotImplementedError("subclasses of Storage must provide a url() method")
-
-    def get_accessed_time(self, name):
-        """
-        Return the last accessed time (as a datetime) of the file specified by
-        name. The datetime will be timezone-aware if USE_TZ=True.
-        """
-        raise NotImplementedError(
-            "subclasses of Storage must provide a get_accessed_time() method"
-        )
-
-    def get_created_time(self, name):
-        """
-        Return the creation time (as a datetime) of the file specified by name.
-        The datetime will be timezone-aware if USE_TZ=True.
-        """
-        raise NotImplementedError(
-            "subclasses of Storage must provide a get_created_time() method"
-        )
-
-    def get_modified_time(self, name):
-        """
-        Return the last modified time (as a datetime) of the file specified by
-        name. The datetime will be timezone-aware if USE_TZ=True.
-        """
-        raise NotImplementedError(
-            "subclasses of Storage must provide a get_modified_time() method"
-        )
-
-
-class StorageSettingsMixin:
-    def _clear_cached_properties(self, setting, **kwargs):
-        """Reset setting based property values."""
-        if setting == "FILE_UPLOAD_PERMISSIONS":
-            self.__dict__.pop("file_permissions_mode", None)
-        elif setting == "FILE_UPLOAD_DIRECTORY_PERMISSIONS":
-            self.__dict__.pop("directory_permissions_mode", None)
-
-    def _value_or_setting(self, value, setting):
-        return setting if value is None else value
-
-
-@deconstructible(path="plain.assets.storage.FileSystemStorage")
-class FileSystemStorage(Storage, StorageSettingsMixin):
-    """
-    Standard filesystem storage
-    """
-
-    # The combination of O_CREAT and O_EXCL makes os.open() raise OSError if
-    # the file already exists before it's opened.
-    OS_OPEN_FLAGS = os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_BINARY", 0)
-
-    def __init__(
-        self,
-        location=None,
-        base_url=None,
-        file_permissions_mode=None,
-        directory_permissions_mode=None,
-    ):
-        self.base_location = location
-        self.base_url = base_url
-        if self.base_url and not self.base_url.endswith("/"):
-            self.base_url += "/"
-        self._file_permissions_mode = file_permissions_mode
-        self._directory_permissions_mode = directory_permissions_mode
-
-    @cached_property
-    def location(self):
-        return os.path.abspath(self.base_location)
-
-    @cached_property
-    def file_permissions_mode(self):
-        return self._value_or_setting(
-            self._file_permissions_mode, settings.FILE_UPLOAD_PERMISSIONS
-        )
-
-    @cached_property
-    def directory_permissions_mode(self):
-        return self._value_or_setting(
-            self._directory_permissions_mode, settings.FILE_UPLOAD_DIRECTORY_PERMISSIONS
-        )
-
-    def _open(self, name, mode="rb"):
-        return File(open(self.path(name), mode))
-
-    def _save(self, name, content):
-        full_path = self.path(name)
-
-        # Create any intermediate directories that do not exist.
-        directory = os.path.dirname(full_path)
-        try:
-            if self.directory_permissions_mode is not None:
-                # Set the umask because os.makedirs() doesn't apply the "mode"
-                # argument to intermediate-level directories.
-                old_umask = os.umask(0o777 & ~self.directory_permissions_mode)
-                try:
-                    os.makedirs(
-                        directory, self.directory_permissions_mode, exist_ok=True
-                    )
-                finally:
-                    os.umask(old_umask)
-            else:
-                os.makedirs(directory, exist_ok=True)
-        except FileExistsError:
-            raise FileExistsError("%s exists and is not a directory." % directory)
-
-        # There's a potential race condition between get_available_name and
-        # saving the file; it's possible that two threads might return the
-        # same name, at which point all sorts of fun happens. So we need to
-        # try to create the file, but if it already exists we have to go back
-        # to get_available_name() and try again.
-
-        while True:
-            try:
-                # This file has a file path that we can move.
-                if hasattr(content, "temporary_file_path"):
-                    file_move_safe(content.temporary_file_path(), full_path)
-
-                # This is a normal uploadedfile that we can stream.
-                else:
-                    # The current umask value is masked out by os.open!
-                    fd = os.open(full_path, self.OS_OPEN_FLAGS, 0o666)
-                    _file = None
-                    try:
-                        locks.lock(fd, locks.LOCK_EX)
-                        for chunk in content.chunks():
-                            if _file is None:
-                                mode = "wb" if isinstance(chunk, bytes) else "wt"
-                                _file = os.fdopen(fd, mode)
-                            _file.write(chunk)
-                    finally:
-                        locks.unlock(fd)
-                        if _file is not None:
-                            _file.close()
-                        else:
-                            os.close(fd)
-            except FileExistsError:
-                # A new name is needed if the file exists.
-                name = self.get_available_name(name)
-                full_path = self.path(name)
-            else:
-                # OK, the file save worked. Break out of the loop.
-                break
-
-        if self.file_permissions_mode is not None:
-            os.chmod(full_path, self.file_permissions_mode)
-
-        # Ensure the saved path is always relative to the storage root.
-        name = os.path.relpath(full_path, self.location)
-        # Ensure the moved file has the same gid as the storage root.
-        self._ensure_location_group_id(full_path)
-        # Store filenames with forward slashes, even on Windows.
-        return str(name).replace("\\", "/")
-
-    def _ensure_location_group_id(self, full_path):
-        if os.name == "posix":
-            file_gid = os.stat(full_path).st_gid
-            location_gid = os.stat(self.location).st_gid
-            if file_gid != location_gid:
-                try:
-                    os.chown(full_path, uid=-1, gid=location_gid)
-                except PermissionError:
-                    pass
-
-    def delete(self, name):
-        if not name:
-            raise ValueError("The name must be given to delete().")
-        name = self.path(name)
-        # If the file or directory exists, delete it from the filesystem.
-        try:
-            if os.path.isdir(name):
-                os.rmdir(name)
-            else:
-                os.remove(name)
-        except FileNotFoundError:
-            # FileNotFoundError is raised if the file or directory was removed
-            # concurrently.
-            pass
-
-    def exists(self, name):
-        return os.path.lexists(self.path(name))
-
-    def listdir(self, path):
-        path = self.path(path)
-        directories, files = [], []
-        with os.scandir(path) as entries:
-            for entry in entries:
-                if entry.is_dir():
-                    directories.append(entry.name)
-                else:
-                    files.append(entry.name)
-        return directories, files
-
-    def path(self, name):
-        return safe_join(self.location, name)
-
-    def size(self, name):
-        return os.path.getsize(self.path(name))
-
-    def url(self, name):
-        if self.base_url is None:
-            raise ValueError("This file is not accessible via a URL.")
-        url = filepath_to_uri(name)
-        if url is not None:
-            url = url.lstrip("/")
-        return urljoin(self.base_url, url)
-
-    def _datetime_from_timestamp(self, ts):
-        """
-        If timezone support is enabled, make an aware datetime object in UTC;
-        otherwise make a naive one in the local timezone.
-        """
-        tz = timezone.utc if settings.USE_TZ else None
-        return datetime.fromtimestamp(ts, tz=tz)
-
-    def get_accessed_time(self, name):
-        return self._datetime_from_timestamp(os.path.getatime(self.path(name)))
-
-    def get_created_time(self, name):
-        return self._datetime_from_timestamp(os.path.getctime(self.path(name)))
-
-    def get_modified_time(self, name):
-        return self._datetime_from_timestamp(os.path.getmtime(self.path(name)))
-
-
-class StaticFilesStorage(FileSystemStorage):
-    """
-    Standard file system storage for static files.
-
-    The defaults for ``location`` and ``base_url`` are
-    ``ASSETS_ROOT`` and ``ASSETS_URL``.
-    """
-
-    def __init__(self, location=None, base_url=None, *args, **kwargs):
-        if location is None:
-            location = settings.ASSETS_ROOT
-        if base_url is None:
-            base_url = settings.ASSETS_URL
-        check_settings(base_url)
-        super().__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 assets app "
-                "without having set the ASSETS_ROOT "
-                "setting to a filesystem path."
-            )
-        return super().path(name)
-
-
-class HashedFilesMixin:
-    default_template = """url("%(url)s")"""
-    max_post_process_passes = 5
-    support_js_module_import_aggregation = False
-    _js_module_import_aggregation_patterns = (
-        "*.js",
-        (
-            (
-                (
-                    r"""(?P<matched>import(?s:(?P<import>[\s\{].*?))"""
-                    r"""\s*from\s*['"](?P<url>[\.\/].*?)["']\s*;)"""
-                ),
-                """import%(import)s from "%(url)s";""",
-            ),
-            (
-                (
-                    r"""(?P<matched>export(?s:(?P<exports>[\s\{].*?))"""
-                    r"""\s*from\s*["'](?P<url>[\.\/].*?)["']\s*;)"""
-                ),
-                """export%(exports)s from "%(url)s";""",
-            ),
-            (
-                r"""(?P<matched>import\s*['"](?P<url>[\.\/].*?)["']\s*;)""",
-                """import"%(url)s";""",
-            ),
-            (
-                r"""(?P<matched>import\(["'](?P<url>.*?)["']\))""",
-                """import("%(url)s")""",
-            ),
-        ),
-    )
-    patterns = (
-        (
-            "*.css",
-            (
-                r"""(?P<matched>url\(['"]{0,1}\s*(?P<url>.*?)["']{0,1}\))""",
-                (
-                    r"""(?P<matched>@import\s*["']\s*(?P<url>.*?)["'])""",
-                    """@import url("%(url)s")""",
-                ),
-                (
-                    (
-                        r"(?m)(?P<matched>)^(/\*#[ \t]"
-                        r"(?-i:sourceMappingURL)=(?P<url>.*)[ \t]*\*/)$"
-                    ),
-                    "/*# sourceMappingURL=%(url)s */",
-                ),
-            ),
-        ),
-        (
-            "*.js",
-            (
-                (
-                    r"(?m)(?P<matched>)^(//# (?-i:sourceMappingURL)=(?P<url>.*))$",
-                    "//# sourceMappingURL=%(url)s",
-                ),
-            ),
-        ),
-    )
-    keep_intermediate_files = True
-
-    def __init__(self, *args, **kwargs):
-        if self.support_js_module_import_aggregation:
-            self.patterns += (self._js_module_import_aggregation_patterns,)
-        super().__init__(*args, **kwargs)
-        self._patterns = {}
-        self.hashed_files = {}
-        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):
-        """
-        Return a hash of the file with the given name and optional content.
-        """
-        if content is None:
-            return None
-        hasher = md5(usedforsecurity=False)
-        for chunk in content.chunks():
-            hasher.update(chunk)
-        return hasher.hexdigest()[:12]
-
-    def hashed_name(self, name, content=None, filename=None):
-        # `filename` is the name of file to hash if `content` isn't given.
-        # `name` is the base name to construct the new hashed filename from.
-        parsed_name = urlsplit(unquote(name))
-        clean_name = parsed_name.path.strip()
-        filename = (filename and urlsplit(unquote(filename)).path.strip()) or clean_name
-        opened = content is None
-        if opened:
-            if not self.exists(filename):
-                raise ValueError(
-                    f"The file '{filename}' could not be found with {self!r}."
-                )
-            try:
-                content = self.open(filename)
-            except OSError:
-                # Handle directory paths and fragments
-                return name
-        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)
-        file_hash = (".%s" % file_hash) if file_hash else ""
-        hashed_name = os.path.join(path, f"{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 _url(self, hashed_name_func, name, force=False, hashed_files=None):
-        """
-        Return the non-hashed 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:
-                args = (clean_name,)
-                if hashed_files is not None:
-                    args += (hashed_files,)
-                hashed_name = hashed_name_func(*args)
-
-        final_url = super().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(self, name, force=False):
-        """
-        Return the non-hashed URL in DEBUG mode.
-        """
-        return self._url(self.stored_name, name, force)
-
-    def url_converter(self, name, hashed_files, template=None):
-        """
-        Return the custom URL converter for the given file name.
-        """
-        if template is None:
-            template = self.default_template
-
-        def converter(matchobj):
-            """
-            Convert the matched URL to a normalized and hashed URL.
-
-            This requires figuring out which files the matched URL resolves
-            to and calling the url() method of the storage.
-            """
-            matches = matchobj.groupdict()
-            matched = matches["matched"]
-            url = matches["url"]
-
-            # Ignore absolute/protocol-relative and data-uri URLs.
-            if re.match(r"^[a-z]+:", url):
-                return matched
-
-            # Ignore absolute URLs that don't point to a static file (dynamic
-            # CSS / JS?). Note that ASSETS_URL cannot be empty.
-            if url.startswith("/") and not url.startswith(settings.ASSETS_URL):
-                return matched
-
-            # Strip off the fragment so a path-like fragment won't interfere.
-            url_path, fragment = urldefrag(url)
-
-            # Ignore URLs without a path
-            if not url_path:
-                return matched
-
-            if url_path.startswith("/"):
-                # Otherwise the condition above would have returned prematurely.
-                assert url_path.startswith(settings.ASSETS_URL)
-                target_name = url_path.removeprefix(settings.ASSETS_URL)
-            else:
-                # We're using the posixpath module to mix paths and URLs conveniently.
-                source_name = name if os.sep == "/" else name.replace(os.sep, "/")
-                target_name = posixpath.join(posixpath.dirname(source_name), url_path)
-
-            # Determine the hashed name of the target file with the storage backend.
-            hashed_url = self._url(
-                self._stored_name,
-                unquote(target_name),
-                force=True,
-                hashed_files=hashed_files,
-            )
-
-            transformed_url = "/".join(
-                url_path.split("/")[:-1] + hashed_url.split("/")[-1:]
-            )
-
-            # Restore the fragment that was stripped off earlier.
-            if fragment:
-                transformed_url += ("?#" if "?#" in url else "#") + fragment
-
-            # Return the hashed version to the file
-            matches["url"] = unquote(transformed_url)
-            return template % matches
-
-        return converter
-
-    def post_process(self, paths, dry_run=False, **options):
-        """
-        Post process the given dictionary 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_files = {}
-
-        # build a list of adjustable files
-        adjustable_paths = [
-            path for path in paths if matches_patterns(path, self._patterns)
-        ]
-
-        # Adjustable files to yield at end, keyed by the original path.
-        processed_adjustable_paths = {}
-
-        # Do a single pass first. Post-process all files once, yielding not
-        # adjustable files and exceptions, and collecting adjustable files.
-        for name, hashed_name, processed, _ in self._post_process(
-            paths, adjustable_paths, hashed_files
-        ):
-            if name not in adjustable_paths or isinstance(processed, Exception):
-                yield name, hashed_name, processed
-            else:
-                processed_adjustable_paths[name] = (name, hashed_name, processed)
-
-        paths = {path: paths[path] for path in adjustable_paths}
-        substitutions = False
-
-        for i in range(self.max_post_process_passes):
-            substitutions = False
-            for name, hashed_name, processed, subst in self._post_process(
-                paths, adjustable_paths, hashed_files
-            ):
-                # Overwrite since hashed_name may be newer.
-                processed_adjustable_paths[name] = (name, hashed_name, processed)
-                substitutions = substitutions or subst
-
-            if not substitutions:
-                break
-
-        if substitutions:
-            yield "All", None, RuntimeError("Max post-process passes exceeded.")
-
-        # Store the processed paths
-        self.hashed_files.update(hashed_files)
-
-        # Yield adjustable files with final, hashed name.
-        yield from processed_adjustable_paths.values()
-
-    def _post_process(self, paths, adjustable_paths, hashed_files):
-        # Sort the files by directory level
-        def path_level(name):
-            return len(name.split(os.sep))
-
-        for name in sorted(paths, key=path_level, reverse=True):
-            substitutions = 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:
-                cleaned_name = self.clean_name(name)
-                hash_key = self.hash_key(cleaned_name)
-
-                # generate the hash with the original content, even for
-                # adjustable files.
-                if hash_key not in hashed_files:
-                    hashed_name = self.hashed_name(name, original_file)
-                else:
-                    hashed_name = hashed_files[hash_key]
-
-                # 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:
-                    old_hashed_name = hashed_name
-                    try:
-                        content = original_file.read().decode("utf-8")
-                    except UnicodeDecodeError as exc:
-                        yield name, None, exc, False
-                    for extension, patterns in self._patterns.items():
-                        if matches_patterns(path, (extension,)):
-                            for pattern, template in patterns:
-                                converter = self.url_converter(
-                                    name, hashed_files, template
-                                )
-                                try:
-                                    content = pattern.sub(converter, content)
-                                except ValueError as exc:
-                                    yield name, None, exc, False
-                    if hashed_file_exists:
-                        self.delete(hashed_name)
-                    # then save the processed result
-                    content_file = ContentFile(content.encode())
-                    if self.keep_intermediate_files:
-                        # Save intermediate file for reference
-                        self._save(hashed_name, content_file)
-                    hashed_name = self.hashed_name(name, content_file)
-
-                    if self.exists(hashed_name):
-                        self.delete(hashed_name)
-
-                    saved_name = self._save(hashed_name, content_file)
-                    hashed_name = self.clean_name(saved_name)
-                    # If the file hash stayed the same, this file didn't change
-                    if old_hashed_name == hashed_name:
-                        substitutions = False
-                    processed = True
-
-                if not processed:
-                    # 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 = self.clean_name(saved_name)
-
-                # and then set the cache accordingly
-                hashed_files[hash_key] = hashed_name
-
-                yield name, hashed_name, processed, substitutions
-
-    def clean_name(self, name):
-        return name.replace("\\", "/")
-
-    def hash_key(self, name):
-        return name
-
-    def _stored_name(self, name, hashed_files):
-        # Normalize the path to avoid multiple names for the same file like
-        # ../foo/bar.css and ../foo/../foo/bar.css which normalize to the same
-        # path.
-        name = posixpath.normpath(name)
-        cleaned_name = self.clean_name(name)
-        hash_key = self.hash_key(cleaned_name)
-        cache_name = hashed_files.get(hash_key)
-        if cache_name is None:
-            cache_name = self.clean_name(self.hashed_name(name))
-        return cache_name
-
-    def stored_name(self, name):
-        cleaned_name = self.clean_name(name)
-        hash_key = self.hash_key(cleaned_name)
-        cache_name = self.hashed_files.get(hash_key)
-        if cache_name:
-            return cache_name
-        # No cached name found, recalculate it from the files.
-        intermediate_name = name
-        for i in range(self.max_post_process_passes + 1):
-            cache_name = self.clean_name(
-                self.hashed_name(name, content=None, filename=intermediate_name)
-            )
-            if intermediate_name == cache_name:
-                # Store the hashed name if there was a miss.
-                self.hashed_files[hash_key] = cache_name
-                return cache_name
-            else:
-                # Move on to the next intermediate file.
-                intermediate_name = cache_name
-        # If the cache name can't be determined after the max number of passes,
-        # the intermediate files on disk may be corrupt; avoid an infinite loop.
-        raise ValueError(f"The name '{name}' could not be hashed with {self!r}.")
-
-
-class ManifestFilesMixin(HashedFilesMixin):
-    manifest_version = "1.1"  # the manifest format standard
-    manifest_name = "assets.json"
-    manifest_strict = True
-    keep_intermediate_files = False
-
-    def __init__(self, *args, manifest_storage=None, **kwargs):
-        super().__init__(*args, **kwargs)
-        if manifest_storage is None:
-            manifest_storage = self
-        self.manifest_storage = manifest_storage
-        self.hashed_files, self.manifest_hash = self.load_manifest()
-
-    def read_manifest(self):
-        try:
-            with self.manifest_storage.open(self.manifest_name) as manifest:
-                return manifest.read().decode()
-        except FileNotFoundError:
-            return None
-
-    def load_manifest(self):
-        content = self.read_manifest()
-        if content is None:
-            return {}, ""
-        try:
-            stored = json.loads(content)
-        except json.JSONDecodeError:
-            pass
-        else:
-            version = stored.get("version")
-            if version in ("1.0", "1.1"):
-                return stored.get("paths", {}), stored.get("hash", "")
-        raise ValueError(
-            "Couldn't load manifest '{}' (version {})".format(
-                self.manifest_name, self.manifest_version
-            )
-        )
-
-    def post_process(self, *args, **kwargs):
-        self.hashed_files = {}
-        yield from super().post_process(*args, **kwargs)
-        if not kwargs.get("dry_run"):
-            self.save_manifest()
-
-    def save_manifest(self):
-        self.manifest_hash = self.file_hash(
-            None, ContentFile(json.dumps(sorted(self.hashed_files.items())).encode())
-        )
-        payload = {
-            "paths": self.hashed_files,
-            "version": self.manifest_version,
-            "hash": self.manifest_hash,
-        }
-        if self.manifest_storage.exists(self.manifest_name):
-            self.manifest_storage.delete(self.manifest_name)
-        contents = json.dumps(payload).encode()
-        self.manifest_storage._save(self.manifest_name, ContentFile(contents))
-
-    def stored_name(self, name):
-        parsed_name = urlsplit(unquote(name))
-        clean_name = parsed_name.path.strip()
-        hash_key = self.hash_key(clean_name)
-        cache_name = self.hashed_files.get(hash_key)
-        if cache_name is None:
-            if self.manifest_strict:
-                raise ValueError("Missing assets manifest entry for '%s'" % clean_name)
-            cache_name = self.clean_name(self.hashed_name(name))
-        unparsed_name = list(parsed_name)
-        unparsed_name[2] = cache_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)
-
-
-class ManifestStaticFilesStorage(ManifestFilesMixin, StaticFilesStorage):
-    """
-    A static file system storage backend which also saves
-    hashed copies of the files it saves.
-    """
-
-    pass
-
-
-class ConfiguredStorage(LazyObject):
-    def _setup(self):
-        backend_class = import_string(settings.ASSETS_BACKEND)
-        self._wrapped = backend_class()
-
-
-assets_storage = ConfiguredStorage()