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

plain/assets/whitenoise/middleware.py

@@ -1,197 +0,0 @@
-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

@@ -1,286 +0,0 @@
-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

@@ -1,178 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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 "/"