plain 0.1.0__py3-none-any.whl

plain/assets/whitenoise/middleware.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+import os
+from posixpath import basename
+from urllib.parse import urlparse
+
+from plain.assets import finders
+from plain.assets.storage import assets_storage
+from plain.http import FileResponse
+from plain.runtime import settings
+
+from .base import WhiteNoise
+from .string_utils import ensure_leading_trailing_slash
+
+__all__ = ["WhiteNoiseMiddleware"]
+
+
+class WhiteNoiseFileResponse(FileResponse):
+    """
+    Wrap Plain's FileResponse to prevent setting any default headers. For the
+    most part these just duplicate work already done by WhiteNoise but in some
+    cases (e.g. the content-disposition header introduced in Plain 3.0) they
+    are actively harmful.
+    """
+
+    def set_headers(self, *args, **kwargs):
+        pass
+
+
+class WhiteNoiseMiddleware(WhiteNoise):
+    """
+    Wrap WhiteNoise to allow it to function as Plain middleware, rather
+    than WSGI middleware.
+    """
+
+    def __init__(self, get_response=None, settings=settings):
+        self.get_response = get_response
+
+        try:
+            autorefresh: bool = settings.WHITENOISE_AUTOREFRESH
+        except AttributeError:
+            autorefresh = settings.DEBUG
+        try:
+            max_age = settings.WHITENOISE_MAX_AGE
+        except AttributeError:
+            if settings.DEBUG:
+                max_age = 0
+            else:
+                max_age = 60
+        try:
+            allow_all_origins = settings.WHITENOISE_ALLOW_ALL_ORIGINS
+        except AttributeError:
+            allow_all_origins = True
+        try:
+            charset = settings.WHITENOISE_CHARSET
+        except AttributeError:
+            charset = "utf-8"
+        try:
+            mimetypes = settings.WHITENOISE_MIMETYPES
+        except AttributeError:
+            mimetypes = None
+        try:
+            add_headers_function = settings.WHITENOISE_ADD_HEADERS_FUNCTION
+        except AttributeError:
+            add_headers_function = None
+        try:
+            index_file = settings.WHITENOISE_INDEX_FILE
+        except AttributeError:
+            index_file = None
+        try:
+            immutable_file_test = settings.WHITENOISE_IMMUTABLE_FILE_TEST
+        except AttributeError:
+            immutable_file_test = None
+
+        super().__init__(
+            application=None,
+            autorefresh=autorefresh,
+            max_age=max_age,
+            allow_all_origins=allow_all_origins,
+            charset=charset,
+            mimetypes=mimetypes,
+            add_headers_function=add_headers_function,
+            index_file=index_file,
+            immutable_file_test=immutable_file_test,
+        )
+
+        try:
+            self.use_finders = settings.WHITENOISE_USE_FINDERS
+        except AttributeError:
+            self.use_finders = settings.DEBUG
+
+        try:
+            self.static_prefix = settings.WHITENOISE_STATIC_PREFIX
+        except AttributeError:
+            self.static_prefix = urlparse(settings.ASSETS_URL or "").path
+        self.static_prefix = ensure_leading_trailing_slash(self.static_prefix)
+
+        self.static_root = settings.ASSETS_ROOT
+        if self.static_root:
+            self.add_files(self.static_root, prefix=self.static_prefix)
+
+        try:
+            root = settings.WHITENOISE_ROOT
+        except AttributeError:
+            root = None
+        if root:
+            self.add_files(root)
+
+        if self.use_finders and not self.autorefresh:
+            self.add_files_from_finders()
+
+    def __call__(self, request):
+        if self.autorefresh:
+            asset_file = self.find_file(request.path_info)
+        else:
+            asset_file = self.files.get(request.path_info)
+        if asset_file is not None:
+            return self.serve(asset_file, request)
+        return self.get_response(request)
+
+    @staticmethod
+    def serve(asset_file, request):
+        response = asset_file.get_response(request.method, request.META)
+        status = int(response.status)
+        http_response = WhiteNoiseFileResponse(response.file or (), status=status)
+        # Remove default content-type
+        del http_response["content-type"]
+        for key, value in response.headers:
+            http_response[key] = value
+        return http_response
+
+    def add_files_from_finders(self):
+        files = {}
+        for finder in finders.get_finders():
+            for path, storage in finder.list(None):
+                prefix = (getattr(storage, "prefix", None) or "").strip("/")
+                url = "".join(
+                    (
+                        self.static_prefix,
+                        prefix,
+                        "/" if prefix else "",
+                        path.replace("\\", "/"),
+                    )
+                )
+                # Use setdefault as only first matching file should be used
+                files.setdefault(url, storage.path(path))
+        stat_cache = {path: os.stat(path) for path in files.values()}
+        for url, path in files.items():
+            self.add_file_to_dictionary(url, path, stat_cache=stat_cache)
+
+    def candidate_paths_for_url(self, url):
+        if self.use_finders and url.startswith(self.static_prefix):
+            path = finders.find(url[len(self.static_prefix) :])
+            if path:
+                yield path
+        paths = super().candidate_paths_for_url(url)
+        for path in paths:
+            yield path
+
+    def immutable_file_test(self, path, url):
+        """
+        Determine whether given URL represents an immutable file (i.e. a
+        file with a hash of its contents as part of its name) which can
+        therefore be cached forever
+        """
+        if not url.startswith(self.static_prefix):
+            return False
+        name = url[len(self.static_prefix) :]
+        name_without_hash = self.get_name_without_hash(name)
+        if name == name_without_hash:
+            return False
+        asset_url = self.get_asset_url(name_without_hash)
+        # If the asset_url function maps the name without hash
+        # back to the original name, then we know we've got a
+        # versioned filename
+        if asset_url and basename(asset_url) == basename(url):
+            return True
+        return False
+
+    def get_name_without_hash(self, filename):
+        """
+        Removes the version hash from a filename e.g, transforms
+        'css/application.f3ea4bcc2.css' into 'css/application.css'
+
+        Note: this is specific to the naming scheme used by Plain's
+        CachedStaticFilesStorage. You may have to override this if
+        you are using a different static files versioning system
+        """
+        name_with_hash, ext = os.path.splitext(filename)
+        name = os.path.splitext(name_with_hash)[0]
+        return name + ext
+
+    def get_asset_url(self, name):
+        try:
+            return assets_storage.url(name)
+        except ValueError:
+            return None

plain/assets/whitenoise/responders.py

@@ -0,0 +1,286 @@
+from __future__ import annotations
+
+import errno
+import os
+import re
+import stat
+from email.utils import formatdate, parsedate
+from http import HTTPStatus
+from io import BufferedIOBase
+from time import mktime
+from urllib.parse import quote
+from wsgiref.headers import Headers
+
+
+class Response:
+    __slots__ = ("status", "headers", "file")
+
+    def __init__(self, status, headers, file):
+        self.status = status
+        self.headers = headers
+        self.file = file
+
+
+NOT_ALLOWED_RESPONSE = Response(
+    status=HTTPStatus.METHOD_NOT_ALLOWED,
+    headers=[("Allow", "GET, HEAD")],
+    file=None,
+)
+
+# Headers which should be returned with a 304 Not Modified response as
+# specified here: https://tools.ietf.org/html/rfc7232#section-4.1
+NOT_MODIFIED_HEADERS = (
+    "Cache-Control",
+    "Content-Location",
+    "Date",
+    "ETag",
+    "Expires",
+    "Vary",
+)
+
+
+class SlicedFile(BufferedIOBase):
+    """
+    A file like wrapper to handle seeking to the start byte of a range request
+    and to return no further output once the end byte of a range request has
+    been reached.
+    """
+
+    def __init__(self, fileobj, start, end):
+        fileobj.seek(start)
+        self.fileobj = fileobj
+        self.remaining = end - start + 1
+
+    def read(self, size=-1):
+        if self.remaining <= 0:
+            return b""
+        if size < 0:
+            size = self.remaining
+        else:
+            size = min(size, self.remaining)
+        data = self.fileobj.read(size)
+        self.remaining -= len(data)
+        return data
+
+    def close(self):
+        self.fileobj.close()
+
+
+class StaticFile:
+    def __init__(self, path, headers, encodings=None, stat_cache=None):
+        files = self.get_file_stats(path, encodings, stat_cache)
+        headers = self.get_headers(headers, files)
+        self.last_modified = parsedate(headers["Last-Modified"])
+        self.etag = headers["ETag"]
+        self.not_modified_response = self.get_not_modified_response(headers)
+        self.alternatives = self.get_alternatives(headers, files)
+
+    def get_response(self, method, request_headers):
+        if method not in ("GET", "HEAD"):
+            return NOT_ALLOWED_RESPONSE
+        if self.is_not_modified(request_headers):
+            return self.not_modified_response
+        path, headers = self.get_path_and_headers(request_headers)
+        if method != "HEAD":
+            file_handle = open(path, "rb")
+        else:
+            file_handle = None
+        range_header = request_headers.get("HTTP_RANGE")
+        if range_header:
+            try:
+                return self.get_range_response(range_header, headers, file_handle)
+            except ValueError:
+                # If we can't interpret the Range request for any reason then
+                # just ignore it and return the standard response (this
+                # behaviour is allowed by the spec)
+                pass
+        return Response(HTTPStatus.OK, headers, file_handle)
+
+    def get_range_response(self, range_header, base_headers, file_handle):
+        headers = []
+        for item in base_headers:
+            if item[0] == "Content-Length":
+                size = int(item[1])
+            else:
+                headers.append(item)
+        start, end = self.get_byte_range(range_header, size)
+        if start >= end:
+            return self.get_range_not_satisfiable_response(file_handle, size)
+        if file_handle is not None:
+            file_handle = SlicedFile(file_handle, start, end)
+        headers.append(("Content-Range", f"bytes {start}-{end}/{size}"))
+        headers.append(("Content-Length", str(end - start + 1)))
+        return Response(HTTPStatus.PARTIAL_CONTENT, headers, file_handle)
+
+    def get_byte_range(self, range_header, size):
+        start, end = self.parse_byte_range(range_header)
+        if start < 0:
+            start = max(start + size, 0)
+        if end is None:
+            end = size - 1
+        else:
+            end = min(end, size - 1)
+        return start, end
+
+    @staticmethod
+    def parse_byte_range(range_header):
+        units, _, range_spec = range_header.strip().partition("=")
+        if units != "bytes":
+            raise ValueError()
+        # Only handle a single range spec. Multiple ranges will trigger a
+        # ValueError below which will result in the Range header being ignored
+        start_str, sep, end_str = range_spec.strip().partition("-")
+        if not sep:
+            raise ValueError()
+        if not start_str:
+            start = -int(end_str)
+            end = None
+        else:
+            start = int(start_str)
+            end = int(end_str) if end_str else None
+        return start, end
+
+    @staticmethod
+    def get_range_not_satisfiable_response(file_handle, size):
+        if file_handle is not None:
+            file_handle.close()
+        return Response(
+            HTTPStatus.REQUESTED_RANGE_NOT_SATISFIABLE,
+            [("Content-Range", f"bytes */{size}")],
+            None,
+        )
+
+    @staticmethod
+    def get_file_stats(path, encodings, stat_cache):
+        # Primary file has an encoding of None
+        files = {None: FileEntry(path, stat_cache)}
+        if encodings:
+            for encoding, alt_path in encodings.items():
+                try:
+                    files[encoding] = FileEntry(alt_path, stat_cache)
+                except MissingFileError:
+                    continue
+        return files
+
+    def get_headers(self, headers_list, files):
+        headers = Headers(headers_list)
+        main_file = files[None]
+        if len(files) > 1:
+            headers["Vary"] = "Accept-Encoding"
+        if "Last-Modified" not in headers:
+            mtime = main_file.mtime
+            # Not all filesystems report mtimes, and sometimes they report an
+            # mtime of 0 which we know is incorrect
+            if mtime:
+                headers["Last-Modified"] = formatdate(mtime, usegmt=True)
+        if "ETag" not in headers:
+            last_modified = parsedate(headers["Last-Modified"])
+            if last_modified:
+                timestamp = int(mktime(last_modified))
+                headers["ETag"] = f'"{timestamp:x}-{main_file.size:x}"'
+        return headers
+
+    @staticmethod
+    def get_not_modified_response(headers):
+        not_modified_headers = []
+        for key in NOT_MODIFIED_HEADERS:
+            if key in headers:
+                not_modified_headers.append((key, headers[key]))
+        return Response(
+            status=HTTPStatus.NOT_MODIFIED, headers=not_modified_headers, file=None
+        )
+
+    @staticmethod
+    def get_alternatives(base_headers, files):
+        # Sort by size so that the smallest compressed alternative matches first
+        alternatives = []
+        files_by_size = sorted(files.items(), key=lambda i: i[1].size)
+        for encoding, file_entry in files_by_size:
+            headers = Headers(base_headers.items())
+            headers["Content-Length"] = str(file_entry.size)
+            if encoding:
+                headers["Content-Encoding"] = encoding
+                encoding_re = re.compile(r"\b%s\b" % encoding)
+            else:
+                encoding_re = re.compile("")
+            alternatives.append((encoding_re, file_entry.path, headers.items()))
+        return alternatives
+
+    def is_not_modified(self, request_headers):
+        previous_etag = request_headers.get("HTTP_IF_NONE_MATCH")
+        if previous_etag is not None:
+            return previous_etag == self.etag
+        if self.last_modified is None:
+            return False
+        try:
+            last_requested = request_headers["HTTP_IF_MODIFIED_SINCE"]
+        except KeyError:
+            return False
+        last_requested_ts = parsedate(last_requested)
+        if last_requested_ts is not None:
+            return last_requested_ts >= self.last_modified
+        return False
+
+    def get_path_and_headers(self, request_headers):
+        accept_encoding = request_headers.get("HTTP_ACCEPT_ENCODING", "")
+        if accept_encoding == "*":
+            accept_encoding = ""
+        # These are sorted by size so first match is the best
+        for encoding_re, path, headers in self.alternatives:
+            if encoding_re.search(accept_encoding):
+                return path, headers
+
+
+class Redirect:
+    def __init__(self, location, headers=None):
+        headers = list(headers.items()) if headers else []
+        headers.append(("Location", quote(location.encode("utf8"))))
+        self.response = Response(HTTPStatus.FOUND, headers, None)
+
+    def get_response(self, method, request_headers):
+        return self.response
+
+
+class NotARegularFileError(Exception):
+    pass
+
+
+class MissingFileError(NotARegularFileError):
+    pass
+
+
+class IsDirectoryError(MissingFileError):
+    pass
+
+
+class FileEntry:
+    __slots__ = ("path", "size", "mtime")
+
+    def __init__(self, path, stat_cache=None):
+        self.path = path
+        stat_function = os.stat if stat_cache is None else stat_cache.__getitem__
+        stat = self.stat_regular_file(path, stat_function)
+        self.size = stat.st_size
+        self.mtime = stat.st_mtime
+
+    @staticmethod
+    def stat_regular_file(path, stat_function):
+        """
+        Wrap `stat_function` to raise appropriate errors if `path` is not a
+        regular file
+        """
+        try:
+            stat_result = stat_function(path)
+        except KeyError:
+            raise MissingFileError(path)
+        except OSError as e:
+            if e.errno in (errno.ENOENT, errno.ENAMETOOLONG):
+                raise MissingFileError(path)
+            else:
+                raise
+        if not stat.S_ISREG(stat_result.st_mode):
+            if stat.S_ISDIR(stat_result.st_mode):
+                raise IsDirectoryError(f"Path is a directory: {path}")
+            else:
+                raise NotARegularFileError(f"Not a regular file: {path}")
+        return stat_result

plain/assets/whitenoise/storage.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+import errno
+import os
+import re
+import textwrap
+from collections.abc import Iterator
+from typing import Any
+
+from plain.assets.storage import (
+    ManifestStaticFilesStorage,
+    StaticFilesStorage,
+)
+from plain.runtime import settings
+
+from .compress import Compressor
+
+_PostProcessT = Iterator[tuple[str, str, bool] | tuple[str, None, RuntimeError]]
+
+
+class CompressedStaticFilesStorage(StaticFilesStorage):
+    """
+    StaticFilesStorage subclass that compresses output files.
+    """
+
+    def post_process(
+        self, paths: dict[str, Any], dry_run: bool = False, **options: Any
+    ) -> _PostProcessT:
+        if dry_run:
+            return
+
+        extensions = getattr(settings, "WHITENOISE_SKIP_COMPRESS_EXTENSIONS", None)
+        compressor = self.create_compressor(extensions=extensions, quiet=True)
+
+        for path in paths:
+            if compressor.should_compress(path):
+                full_path = self.path(path)
+                prefix_len = len(full_path) - len(path)
+                for compressed_path in compressor.compress(full_path):
+                    compressed_name = compressed_path[prefix_len:]
+                    yield path, compressed_name, True
+
+    def create_compressor(self, **kwargs: Any) -> Compressor:
+        return Compressor(**kwargs)
+
+
+class MissingFileError(ValueError):
+    pass
+
+
+class CompressedManifestStaticFilesStorage(ManifestStaticFilesStorage):
+    """
+    Extends ManifestStaticFilesStorage instance to create compressed versions
+    of its output files and, optionally, to delete the non-hashed files (i.e.
+    those without the hash in their name)
+    """
+
+    _new_files = None
+
+    def __init__(self, *args, **kwargs):
+        manifest_strict = getattr(settings, "WHITENOISE_MANIFEST_STRICT", None)
+        if manifest_strict is not None:
+            self.manifest_strict = manifest_strict
+        super().__init__(*args, **kwargs)
+
+    def post_process(self, *args, **kwargs):
+        files = super().post_process(*args, **kwargs)
+
+        if not kwargs.get("dry_run"):
+            files = self.post_process_with_compression(files)
+
+        # Make exception messages helpful
+        for name, hashed_name, processed in files:
+            if isinstance(processed, Exception):
+                processed = self.make_helpful_exception(processed, name)
+            yield name, hashed_name, processed
+
+    def post_process_with_compression(self, files):
+        # Files may get hashed multiple times, we want to keep track of all the
+        # intermediate files generated during the process and which of these
+        # are the final names used for each file. As not every intermediate
+        # file is yielded we have to hook in to the `hashed_name` method to
+        # keep track of them all.
+        hashed_names = {}
+        new_files = set()
+        self.start_tracking_new_files(new_files)
+        for name, hashed_name, processed in files:
+            if hashed_name and not isinstance(processed, Exception):
+                hashed_names[self.clean_name(name)] = hashed_name
+            yield name, hashed_name, processed
+        self.stop_tracking_new_files()
+        original_files = set(hashed_names.keys())
+        hashed_files = set(hashed_names.values())
+        if self.keep_only_hashed_files:
+            files_to_delete = (original_files | new_files) - hashed_files
+            files_to_compress = hashed_files
+        else:
+            files_to_delete = set()
+            files_to_compress = original_files | hashed_files
+        self.delete_files(files_to_delete)
+        for name, compressed_name in self.compress_files(files_to_compress):
+            yield name, compressed_name, True
+
+    def hashed_name(self, *args, **kwargs):
+        name = super().hashed_name(*args, **kwargs)
+        if self._new_files is not None:
+            self._new_files.add(self.clean_name(name))
+        return name
+
+    def start_tracking_new_files(self, new_files):
+        self._new_files = new_files
+
+    def stop_tracking_new_files(self):
+        self._new_files = None
+
+    @property
+    def keep_only_hashed_files(self):
+        return getattr(settings, "WHITENOISE_KEEP_ONLY_HASHED_FILES", False)
+
+    def delete_files(self, files_to_delete):
+        for name in files_to_delete:
+            try:
+                os.unlink(self.path(name))
+            except OSError as e:
+                if e.errno != errno.ENOENT:
+                    raise
+
+    def create_compressor(self, **kwargs):
+        return Compressor(**kwargs)
+
+    def compress_files(self, names):
+        extensions = getattr(settings, "WHITENOISE_SKIP_COMPRESS_EXTENSIONS", None)
+        compressor = self.create_compressor(extensions=extensions, quiet=True)
+        for name in names:
+            if compressor.should_compress(name):
+                path = self.path(name)
+                prefix_len = len(path) - len(name)
+                for compressed_path in compressor.compress(path):
+                    compressed_name = compressed_path[prefix_len:]
+                    yield name, compressed_name
+
+    def make_helpful_exception(self, exception, name):
+        """
+        If a CSS file contains references to images, fonts etc that can't be found
+        then Plain's `post_process` blows up with a not particularly helpful
+        ValueError that leads people to think WhiteNoise is broken.
+
+        Here we attempt to intercept such errors and reformat them to be more
+        helpful in revealing the source of the problem.
+        """
+        if isinstance(exception, ValueError):
+            message = exception.args[0] if len(exception.args) else ""
+            # Stringly typed exceptions. Yay!
+            match = self._error_msg_re.search(message)
+            if match:
+                extension = os.path.splitext(name)[1].lstrip(".").upper()
+                message = self._error_msg.format(
+                    orig_message=message,
+                    filename=name,
+                    missing=match.group(1),
+                    ext=extension,
+                )
+                exception = MissingFileError(message)
+        return exception
+
+    _error_msg_re = re.compile(r"^The file '(.+)' could not be found")
+
+    _error_msg = textwrap.dedent(
+        """\
+        {orig_message}
+
+        The {ext} file '{filename}' references a file which could not be found:
+          {missing}
+
+        Please check the URL references in this {ext} file, particularly any
+        relative paths which might be pointing to the wrong location.
+        """
+    )

plain/assets/whitenoise/string_utils.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+
+# Follow Plain in treating URLs as UTF-8 encoded (which requires undoing the
+# implicit ISO-8859-1 decoding applied in Python 3). Strictly speaking, URLs
+# should only be ASCII anyway, but UTF-8 can be found in the wild.
+def decode_path_info(path_info):
+    return path_info.encode("iso-8859-1", "replace").decode("utf-8", "replace")
+
+
+def ensure_leading_trailing_slash(path):
+    path = (path or "").strip("/")
+    return f"/{path}/" if path else "/"