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

plain/assets/utils.py

@@ -1,52 +0,0 @@
-import fnmatch
-import os
-
-from plain.exceptions import ImproperlyConfigured
-from plain.runtime import settings
-
-
-def matches_patterns(path, patterns):
-    """
-    Return True or False depending on whether the ``path`` should be
-    ignored (if it matches any pattern in ``ignore_patterns``).
-    """
-    return any(fnmatch.fnmatchcase(path, pattern) for pattern in patterns)
-
-
-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:
-        # Match only the basename.
-        if matches_patterns(fn, ignore_patterns):
-            continue
-        if location:
-            fn = os.path.join(location, fn)
-            # Match the full file path.
-            if matches_patterns(fn, ignore_patterns):
-                continue
-        yield fn
-    for dir in directories:
-        if matches_patterns(dir, ignore_patterns):
-            continue
-        if location:
-            dir = os.path.join(location, dir)
-        yield from get_files(storage, ignore_patterns, dir)
-
-
-def check_settings(base_url=None):
-    """
-    Check if the assets settings have sane values.
-    """
-    if base_url is None:
-        base_url = settings.ASSETS_URL
-    if not base_url:
-        raise ImproperlyConfigured(
-            "You're using the assets app "
-            "without having set the required ASSETS_URL setting."
-        )

plain/assets/whitenoise/__init__.py

@@ -1,5 +0,0 @@
-from __future__ import annotations
-
-from .base import WhiteNoise
-
-__all__ = ["WhiteNoise"]

plain/assets/whitenoise/base.py

@@ -1,259 +0,0 @@
-from __future__ import annotations
-
-import os
-import re
-import warnings
-from collections.abc import Callable
-from posixpath import normpath
-from wsgiref.headers import Headers
-from wsgiref.util import FileWrapper
-
-from .media_types import MediaTypes
-from .responders import IsDirectoryError, MissingFileError, Redirect, StaticFile
-from .string_utils import decode_path_info, ensure_leading_trailing_slash
-
-
-class WhiteNoise:
-    # Ten years is what nginx sets a max age if you use 'expires max;'
-    # so we'll follow its lead
-    FOREVER = 10 * 365 * 24 * 60 * 60
-
-    def __init__(
-        self,
-        application,
-        root=None,
-        prefix=None,
-        *,
-        # Re-check the filesystem on every request so that any changes are
-        # automatically picked up. NOTE: For use in development only, not supported
-        # in production
-        autorefresh: bool = False,
-        max_age: int | None = 60,  # seconds
-        # Set 'Access-Control-Allow-Origin: *' header on all files.
-        # As these are all public static files this is safe (See
-        # https://www.w3.org/TR/cors/#security) and ensures that things (e.g
-        # webfonts in Firefox) still work as expected when your static files are
-        # served from a CDN, rather than your primary domain.
-        allow_all_origins: bool = True,
-        charset: str = "utf-8",
-        mimetypes: dict[str, str] | None = None,
-        add_headers_function: Callable[[Headers, str, str], None] | None = None,
-        index_file: str | bool | None = None,
-        immutable_file_test: Callable | str | None = None,
-    ):
-        self.autorefresh = autorefresh
-        self.max_age = max_age
-        self.allow_all_origins = allow_all_origins
-        self.charset = charset
-        self.add_headers_function = add_headers_function
-        if index_file is True:
-            self.index_file: str | None = "index.html"
-        elif isinstance(index_file, str):
-            self.index_file = index_file
-        else:
-            self.index_file = None
-
-        if immutable_file_test is not None:
-            if not callable(immutable_file_test):
-                regex = re.compile(immutable_file_test)
-                self.immutable_file_test = lambda path, url: bool(regex.search(url))
-            else:
-                self.immutable_file_test = immutable_file_test
-
-        self.media_types = MediaTypes(extra_types=mimetypes)
-        self.application = application
-        self.files = {}
-        self.directories = []
-        if root is not None:
-            self.add_files(root, prefix)
-
-    def __call__(self, environ, start_response):
-        path = decode_path_info(environ.get("PATH_INFO", ""))
-        if self.autorefresh:
-            asset_file = self.find_file(path)
-        else:
-            asset_file = self.files.get(path)
-        if asset_file is None:
-            return self.application(environ, start_response)
-        else:
-            return self.serve(asset_file, environ, start_response)
-
-    @staticmethod
-    def serve(asset_file, environ, start_response):
-        response = asset_file.get_response(environ["REQUEST_METHOD"], environ)
-        status_line = f"{response.status} {response.status.phrase}"
-        start_response(status_line, list(response.headers))
-        if response.file is not None:
-            file_wrapper = environ.get("wsgi.file_wrapper", FileWrapper)
-            return file_wrapper(response.file)
-        else:
-            return []
-
-    def add_files(self, root, prefix=None):
-        root = os.path.abspath(root)
-        root = root.rstrip(os.path.sep) + os.path.sep
-        prefix = ensure_leading_trailing_slash(prefix)
-        if self.autorefresh:
-            # Later calls to `add_files` overwrite earlier ones, hence we need
-            # to store the list of directories in reverse order so later ones
-            # match first when they're checked in "autorefresh" mode
-            self.directories.insert(0, (root, prefix))
-        else:
-            if os.path.isdir(root):
-                self.update_files_dictionary(root, prefix)
-            else:
-                warnings.warn(f"No directory at: {root}", stacklevel=3)
-
-    def update_files_dictionary(self, root, prefix):
-        # Build a mapping from paths to the results of `os.stat` calls
-        # so we only have to touch the filesystem once
-        stat_cache = dict(scantree(root))
-        for path in stat_cache.keys():
-            relative_path = path[len(root) :]
-            relative_url = relative_path.replace("\\", "/")
-            url = prefix + relative_url
-            self.add_file_to_dictionary(url, path, stat_cache=stat_cache)
-
-    def add_file_to_dictionary(self, url, path, stat_cache=None):
-        if self.is_compressed_variant(path, stat_cache=stat_cache):
-            return
-        if self.index_file is not None and url.endswith("/" + self.index_file):
-            index_url = url[: -len(self.index_file)]
-            index_no_slash = index_url.rstrip("/")
-            self.files[url] = self.redirect(url, index_url)
-            self.files[index_no_slash] = self.redirect(index_no_slash, index_url)
-            url = index_url
-        asset_file = self.get_asset_file(path, url, stat_cache=stat_cache)
-        self.files[url] = asset_file
-
-    def find_file(self, url):
-        # Optimization: bail early if the URL can never match a file
-        if self.index_file is None and url.endswith("/"):
-            return
-        if not self.url_is_canonical(url):
-            return
-        for path in self.candidate_paths_for_url(url):
-            try:
-                return self.find_file_at_path(path, url)
-            except MissingFileError:
-                pass
-
-    def candidate_paths_for_url(self, url):
-        for root, prefix in self.directories:
-            if url.startswith(prefix):
-                path = os.path.join(root, url[len(prefix) :])
-                if os.path.commonprefix((root, path)) == root:
-                    yield path
-
-    def find_file_at_path(self, path, url):
-        if self.is_compressed_variant(path):
-            raise MissingFileError(path)
-
-        if self.index_file is not None:
-            if url.endswith("/"):
-                path = os.path.join(path, self.index_file)
-                return self.get_asset_file(path, url)
-            elif url.endswith("/" + self.index_file):
-                if os.path.isfile(path):
-                    return self.redirect(url, url[: -len(self.index_file)])
-            else:
-                try:
-                    return self.get_asset_file(path, url)
-                except IsDirectoryError:
-                    if os.path.isfile(os.path.join(path, self.index_file)):
-                        return self.redirect(url, url + "/")
-            raise MissingFileError(path)
-
-        return self.get_asset_file(path, url)
-
-    @staticmethod
-    def url_is_canonical(url):
-        """
-        Check that the URL path is in canonical format i.e. has normalised
-        slashes and no path traversal elements
-        """
-        if "\\" in url:
-            return False
-        normalised = normpath(url)
-        if url.endswith("/") and url != "/":
-            normalised += "/"
-        return normalised == url
-
-    @staticmethod
-    def is_compressed_variant(path, stat_cache=None):
-        if path[-3:] in (".gz", ".br"):
-            uncompressed_path = path[:-3]
-            if stat_cache is None:
-                return os.path.isfile(uncompressed_path)
-            else:
-                return uncompressed_path in stat_cache
-        return False
-
-    def get_asset_file(self, path, url, stat_cache=None):
-        # Optimization: bail early if file does not exist
-        if stat_cache is None and not os.path.exists(path):
-            raise MissingFileError(path)
-        headers = Headers([])
-        self.add_mime_headers(headers, path, url)
-        self.add_cache_headers(headers, path, url)
-        if self.allow_all_origins:
-            headers["Access-Control-Allow-Origin"] = "*"
-        if self.add_headers_function is not None:
-            self.add_headers_function(headers, path, url)
-        return StaticFile(
-            path,
-            headers.items(),
-            stat_cache=stat_cache,
-            encodings={"gzip": path + ".gz", "br": path + ".br"},
-        )
-
-    def add_mime_headers(self, headers, path, url):
-        media_type = self.media_types.get_type(path)
-        if media_type.startswith("text/"):
-            params = {"charset": str(self.charset)}
-        else:
-            params = {}
-        headers.add_header("Content-Type", str(media_type), **params)
-
-    def add_cache_headers(self, headers, path, url):
-        if self.immutable_file_test(path, url):
-            headers["Cache-Control"] = f"max-age={self.FOREVER}, public, immutable"
-        elif self.max_age is not None:
-            headers["Cache-Control"] = f"max-age={self.max_age}, public"
-
-    def immutable_file_test(self, path, url):
-        """
-        This should be implemented by sub-classes (see e.g. WhiteNoiseMiddleware)
-        or by setting the `immutable_file_test` config option
-        """
-        return False
-
-    def redirect(self, from_url, to_url):
-        """
-        Return a relative 302 redirect
-
-        We use relative redirects as we don't know the absolute URL the app is
-        being hosted under
-        """
-        if to_url == from_url + "/":
-            relative_url = from_url.split("/")[-1] + "/"
-        elif from_url == to_url + self.index_file:
-            relative_url = "./"
-        else:
-            raise ValueError(f"Cannot handle redirect: {from_url} > {to_url}")
-        if self.max_age is not None:
-            headers = {"Cache-Control": f"max-age={self.max_age}, public"}
-        else:
-            headers = {}
-        return Redirect(relative_url, headers=headers)
-
-
-def scantree(root):
-    """
-    Recurse the given directory yielding (pathname, os.stat(pathname)) pairs
-    """
-    for entry in os.scandir(root):
-        if entry.is_dir():
-            yield from scantree(entry.path)
-        else:
-            yield entry.path, entry.stat()

plain/assets/whitenoise/compress.py

@@ -1,189 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import gzip
-import os
-import re
-from io import BytesIO
-
-try:
-    import brotli
-
-    brotli_installed = True
-except ImportError:  # pragma: no cover
-    brotli_installed = False
-
-
-class Compressor:
-    # Extensions that it's not worth trying to compress
-    SKIP_COMPRESS_EXTENSIONS = (
-        # Images
-        "jpg",
-        "jpeg",
-        "png",
-        "gif",
-        "webp",
-        # Compressed files
-        "zip",
-        "gz",
-        "tgz",
-        "bz2",
-        "tbz",
-        "xz",
-        "br",
-        # Flash
-        "swf",
-        "flv",
-        # Fonts
-        "woff",
-        "woff2",
-        # Video
-        "3gp",
-        "3gpp",
-        "asf",
-        "avi",
-        "m4v",
-        "mov",
-        "mp4",
-        "mpeg",
-        "mpg",
-        "webm",
-        "wmv",
-    )
-
-    def __init__(
-        self, extensions=None, use_gzip=True, use_brotli=True, log=print, quiet=False
-    ):
-        if extensions is None:
-            extensions = self.SKIP_COMPRESS_EXTENSIONS
-        self.extension_re = self.get_extension_re(extensions)
-        self.use_gzip = use_gzip
-        self.use_brotli = use_brotli and brotli_installed
-        if not quiet:
-            self.log = log
-
-    @staticmethod
-    def get_extension_re(extensions):
-        if not extensions:
-            return re.compile("^$")
-        else:
-            return re.compile(
-                r"\.({})$".format("|".join(map(re.escape, extensions))), re.IGNORECASE
-            )
-
-    def should_compress(self, filename):
-        return not self.extension_re.search(filename)
-
-    def log(self, message):
-        pass
-
-    def compress(self, path):
-        with open(path, "rb") as f:
-            stat_result = os.fstat(f.fileno())
-            data = f.read()
-        size = len(data)
-        if self.use_brotli:
-            compressed = self.compress_brotli(data)
-            if self.is_compressed_effectively("Brotli", path, size, compressed):
-                yield self.write_data(path, compressed, ".br", stat_result)
-            else:
-                # If Brotli compression wasn't effective gzip won't be either
-                return
-        if self.use_gzip:
-            compressed = self.compress_gzip(data)
-            if self.is_compressed_effectively("Gzip", path, size, compressed):
-                yield self.write_data(path, compressed, ".gz", stat_result)
-
-    @staticmethod
-    def compress_gzip(data):
-        output = BytesIO()
-        # Explicitly set mtime to 0 so gzip content is fully determined
-        # by file content (0 = "no timestamp" according to gzip spec)
-        with gzip.GzipFile(
-            filename="", mode="wb", fileobj=output, compresslevel=9, mtime=0
-        ) as gz_file:
-            gz_file.write(data)
-        return output.getvalue()
-
-    @staticmethod
-    def compress_brotli(data):
-        return brotli.compress(data)
-
-    def is_compressed_effectively(self, encoding_name, path, orig_size, data):
-        compressed_size = len(data)
-        if orig_size == 0:
-            is_effective = False
-        else:
-            ratio = compressed_size / orig_size
-            is_effective = ratio <= 0.95
-        if is_effective:
-            self.log(
-                "{} compressed {} ({}K -> {}K)".format(
-                    encoding_name, path, orig_size // 1024, compressed_size // 1024
-                )
-            )
-        else:
-            self.log(f"Skipping {path} ({encoding_name} compression not effective)")
-        return is_effective
-
-    def write_data(self, path, data, suffix, stat_result):
-        filename = path + suffix
-        with open(filename, "wb") as f:
-            f.write(data)
-        os.utime(filename, (stat_result.st_atime, stat_result.st_mtime))
-        return filename
-
-
-def main(argv=None):
-    parser = argparse.ArgumentParser(
-        description="Search for all files inside <root> *not* matching "
-        "<extensions> and produce compressed versions with "
-        "'.gz' and '.br' suffixes (as long as this results in a "
-        "smaller file)"
-    )
-    parser.add_argument(
-        "-q", "--quiet", help="Don't produce log output", action="store_true"
-    )
-    parser.add_argument(
-        "--no-gzip",
-        help="Don't produce gzip '.gz' files",
-        action="store_false",
-        dest="use_gzip",
-    )
-    parser.add_argument(
-        "--no-brotli",
-        help="Don't produce brotli '.br' files",
-        action="store_false",
-        dest="use_brotli",
-    )
-    parser.add_argument("root", help="Path root from which to search for files")
-    default_exclude = ", ".join(Compressor.SKIP_COMPRESS_EXTENSIONS)
-    parser.add_argument(
-        "extensions",
-        nargs="*",
-        help=(
-            "File extensions to exclude from compression "
-            f"(default: {default_exclude})"
-        ),
-        default=Compressor.SKIP_COMPRESS_EXTENSIONS,
-    )
-    args = parser.parse_args(argv)
-
-    compressor = Compressor(
-        extensions=args.extensions,
-        use_gzip=args.use_gzip,
-        use_brotli=args.use_brotli,
-        quiet=args.quiet,
-    )
-    for dirpath, _dirs, files in os.walk(args.root):
-        for filename in files:
-            if compressor.should_compress(filename):
-                path = os.path.join(dirpath, filename)
-                for _compressed in compressor.compress(path):
-                    pass
-
-    return 0
-
-
-if __name__ == "__main__":  # pragma: no cover
-    raise SystemExit(main())

plain/assets/whitenoise/media_types.py

@@ -1,137 +0,0 @@
-from __future__ import annotations
-
-import os
-
-
-class MediaTypes:
-    __slots__ = ("types_map",)
-
-    def __init__(self, *, extra_types: dict[str, str] | None = None) -> None:
-        self.types_map = default_types()
-        if extra_types is not None:
-            self.types_map.update(extra_types)
-
-    def get_type(self, path: str) -> str:
-        name = os.path.basename(path).lower()
-        media_type = self.types_map.get(name)
-        if media_type is not None:
-            return media_type
-        extension = os.path.splitext(name)[1]
-        return self.types_map.get(extension, "application/octet-stream")
-
-
-def default_types() -> dict[str, str]:
-    """
-    We use our own set of default media types rather than the system-supplied
-    ones. This ensures consistent media type behaviour across varied
-    environments.  The defaults are based on those shipped with nginx, with
-    some custom additions.
-
-    (Auto-generated by scripts/generate_default_media_types.py)
-    """
-    return {
-        ".3gp": "video/3gpp",
-        ".3gpp": "video/3gpp",
-        ".7z": "application/x-7z-compressed",
-        ".ai": "application/postscript",
-        ".asf": "video/x-ms-asf",
-        ".asx": "video/x-ms-asf",
-        ".atom": "application/atom+xml",
-        ".avi": "video/x-msvideo",
-        ".avif": "image/avif",
-        ".bmp": "image/x-ms-bmp",
-        ".cco": "application/x-cocoa",
-        ".crt": "application/x-x509-ca-cert",
-        ".css": "text/css",
-        ".der": "application/x-x509-ca-cert",
-        ".doc": "application/msword",
-        ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-        ".ear": "application/java-archive",
-        ".eot": "application/vnd.ms-fontobject",
-        ".eps": "application/postscript",
-        ".flv": "video/x-flv",
-        ".gif": "image/gif",
-        ".hqx": "application/mac-binhex40",
-        ".htc": "text/x-component",
-        ".htm": "text/html",
-        ".html": "text/html",
-        ".ico": "image/x-icon",
-        ".jad": "text/vnd.sun.j2me.app-descriptor",
-        ".jar": "application/java-archive",
-        ".jardiff": "application/x-java-archive-diff",
-        ".jng": "image/x-jng",
-        ".jnlp": "application/x-java-jnlp-file",
-        ".jpeg": "image/jpeg",
-        ".jpg": "image/jpeg",
-        ".js": "text/javascript",
-        ".json": "application/json",
-        ".kar": "audio/midi",
-        ".kml": "application/vnd.google-earth.kml+xml",
-        ".kmz": "application/vnd.google-earth.kmz",
-        ".m3u8": "application/vnd.apple.mpegurl",
-        ".m4a": "audio/x-m4a",
-        ".m4v": "video/x-m4v",
-        ".md": "text/markdown",
-        ".mid": "audio/midi",
-        ".midi": "audio/midi",
-        ".mjs": "text/javascript",
-        ".mml": "text/mathml",
-        ".mng": "video/x-mng",
-        ".mov": "video/quicktime",
-        ".mp3": "audio/mpeg",
-        ".mp4": "video/mp4",
-        ".mpeg": "video/mpeg",
-        ".mpg": "video/mpeg",
-        ".odg": "application/vnd.oasis.opendocument.graphics",
-        ".odp": "application/vnd.oasis.opendocument.presentation",
-        ".ods": "application/vnd.oasis.opendocument.spreadsheet",
-        ".odt": "application/vnd.oasis.opendocument.text",
-        ".ogg": "audio/ogg",
-        ".pdb": "application/x-pilot",
-        ".pdf": "application/pdf",
-        ".pem": "application/x-x509-ca-cert",
-        ".pl": "application/x-perl",
-        ".pm": "application/x-perl",
-        ".png": "image/png",
-        ".ppt": "application/vnd.ms-powerpoint",
-        ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-        ".prc": "application/x-pilot",
-        ".ps": "application/postscript",
-        ".ra": "audio/x-realaudio",
-        ".rar": "application/x-rar-compressed",
-        ".rpm": "application/x-redhat-package-manager",
-        ".rss": "application/rss+xml",
-        ".rtf": "application/rtf",
-        ".run": "application/x-makeself",
-        ".sea": "application/x-sea",
-        ".shtml": "text/html",
-        ".sit": "application/x-stuffit",
-        ".svg": "image/svg+xml",
-        ".svgz": "image/svg+xml",
-        ".swf": "application/x-shockwave-flash",
-        ".tcl": "application/x-tcl",
-        ".tif": "image/tiff",
-        ".tiff": "image/tiff",
-        ".tk": "application/x-tcl",
-        ".ts": "video/mp2t",
-        ".txt": "text/plain",
-        ".war": "application/java-archive",
-        ".wasm": "application/wasm",
-        ".wbmp": "image/vnd.wap.wbmp",
-        ".webm": "video/webm",
-        ".webp": "image/webp",
-        ".wml": "text/vnd.wap.wml",
-        ".wmlc": "application/vnd.wap.wmlc",
-        ".wmv": "video/x-ms-wmv",
-        ".woff": "application/font-woff",
-        ".woff2": "font/woff2",
-        ".xhtml": "application/xhtml+xml",
-        ".xls": "application/vnd.ms-excel",
-        ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-        ".xml": "text/xml",
-        ".xpi": "application/x-xpinstall",
-        ".xspf": "application/xspf+xml",
-        ".zip": "application/zip",
-        "apple-app-site-association": "application/pkc7-mime",
-        "crossdomain.xml": "text/x-cross-domain-policy",
-    }