plain 0.24.1__py3-none-any.whl → 0.26.0__py3-none-any.whl

plain/packages/registry.py

@@ -4,11 +4,14 @@ import threading
 import warnings
 from collections import Counter, defaultdict
 from functools import partial
+from importlib import import_module
 
 from plain.exceptions import ImproperlyConfigured, PackageRegistryNotReady
 
 from .config import PackageConfig
 
+CONFIG_MODULE_NAME = "config"
+
 
 class PackagesRegistry:
     """
@@ -82,17 +85,35 @@ class PackagesRegistry:
             # Phase 1: initialize app configs and import app modules.
             for entry in installed_packages:
                 if isinstance(entry, PackageConfig):
-                    package_config = entry
+                    # Some instances of the registry pass in the
+                    # PackageConfig directly...
+                    self.register_config(entry)
                 else:
-                    package_config = PackageConfig.create(entry)
-                if package_config.label in self.package_configs:
-                    raise ImproperlyConfigured(
-                        "Package labels aren't unique, "
-                        f"duplicates: {package_config.label}"
-                    )
-
-                self.package_configs[package_config.label] = package_config
-                package_config.packages_registry = self
+                    try:
+                        import_module(f"{entry}.{CONFIG_MODULE_NAME}")
+                    except ModuleNotFoundError:
+                        pass
+
+                    # The config for the package should now be registered, if it existed.
+                    # And if it didn't, now we can auto generate one.
+                    entry_config = None
+                    for config in self.package_configs.values():
+                        if config.name == entry:
+                            entry_config = config
+                            break
+
+                    if not entry_config:
+                        # Use PackageConfig class as-is, without any customization.
+                        entry_config = self.register_config(
+                            PackageConfig, module_name=entry
+                        )
+
+            # Make sure we have the same number of configs as we have installed packages
+            if len(self.package_configs) != len(installed_packages):
+                raise ImproperlyConfigured(
+                    f"The number of installed packages ({len(installed_packages)}) does not match the number of "
+                    f"registered configs ({len(self.package_configs)})."
+                )
 
             # Check for duplicate app names.
             counts = Counter(
@@ -372,5 +393,38 @@ class PackagesRegistry:
         for function in self._pending_operations.pop(key, []):
             function(model)
 
+    def register_config(self, package_config, module_name=""):
+        """
+        Add a config to the registry.
+
+        Typically used as a decorator on a PackageConfig subclass. Example:
+
+        @register_config
+        class Config(PackageConfig):
+            pass
+        """
+        if not module_name:
+            module_name = package_config.__module__
+
+        # If it is in .config like expected, return the parent module name
+        if module_name.endswith(f".{CONFIG_MODULE_NAME}"):
+            module_name = module_name[: -len(CONFIG_MODULE_NAME) - 1]
+
+        if isinstance(package_config, type) and issubclass(
+            package_config, PackageConfig
+        ):
+            # A class was passed, so init it
+            package_config = package_config(module_name)
+
+        if package_config.label in self.package_configs:
+            raise ImproperlyConfigured(
+                f"Package labels aren't unique, duplicates: {package_config.label}"
+            )
+        self.package_configs[package_config.label] = package_config
+        package_config.packages = self
+
+        return package_config
+
 
 packages_registry = PackagesRegistry(installed_packages=None)
+register_config = packages_registry.register_config

plain/paginator.py

@@ -24,10 +24,6 @@ class EmptyPage(InvalidPage):
 
 
 class Paginator:
-    # Translators: String used to replace omitted page numbers in elided page
-    # range generated by paginators, e.g. [1, 2, '…', 5, 6, 7, '…', 9, 10].
-    ELLIPSIS = "…"
-
     def __init__(self, object_list, per_page, orphans=0, allow_empty_first_page=True):
         self.object_list = object_list
         self._check_object_list_is_ordered()

plain/preflight/urls.py

@@ -98,10 +98,3 @@ def get_warning_for_invalid_pattern(pattern):
             id="urls.E004",
         )
     ]
-
-
-def E006(name):
-    return Error(
-        f"The {name} setting must end with a slash.",
-        id="urls.E006",
-    )

plain/templates/jinja/__init__.py

@@ -3,7 +3,7 @@ from importlib import import_module
 from plain.packages import packages_registry
 from plain.runtime import settings
 from plain.utils.functional import LazyObject
-from plain.utils.module_loading import import_string, module_has_submodule
+from plain.utils.module_loading import import_string
 
 from .environments import DefaultEnvironment, get_template_dirs
 
@@ -24,20 +24,25 @@ class JinjaEnvironment(LazyObject):
         # We have to set _wrapped before we trigger the autoloading of "register" commands
         self._wrapped = env
 
-        def _maybe_import_module(name):
-            if name not in self._imported_modules:
-                import_module(name)
-                self._imported_modules.add(name)
-
         for package_config in packages_registry.get_package_configs():
-            if module_has_submodule(package_config.module, "templates"):
-                # Allow this to fail in case there are import errors inside of their file
-                _maybe_import_module(f"{package_config.name}.templates")
-
-        app = import_module("app")
-        if module_has_submodule(app, "templates"):
             # Allow this to fail in case there are import errors inside of their file
-            _maybe_import_module("app.templates")
+            import_name = f"{package_config.name}.templates"
+            if import_name in self._imported_modules:
+                continue
+            try:
+                import_module(import_name)
+                self._imported_modules.add(import_name)
+            except ModuleNotFoundError:
+                pass
+
+        # Allow this to fail in case there are import errors inside of their file
+        import_name = "app.templates"
+        if import_name not in self._imported_modules:
+            try:
+                import_module(import_name)
+                self._imported_modules.add(import_name)
+            except ModuleNotFoundError:
+                pass
 
 
 environment = JinjaEnvironment()

plain/urls/resolvers.py

@@ -207,7 +207,7 @@ class URLResolver:
                     else:
                         for name in url_pattern.reverse_dict:
                             for (
-                                matches,
+                                _,
                                 pat,
                                 converters,
                             ) in url_pattern.reverse_dict.getlist(name):

plain/utils/cache.py

@@ -15,14 +15,8 @@ An example: i18n middleware would need to distinguish caches by the
 "Accept-language" header.
 """
 
-import time
 from collections import defaultdict
-from hashlib import md5
 
-from plain.http import Response, ResponseNotModified
-from plain.logs import log_response
-from plain.runtime import settings
-from plain.utils.http import http_date, parse_etags, parse_http_date_safe, quote_etag
 from plain.utils.regex_helper import _lazy_re_compile
 
 cc_delim_re = _lazy_re_compile(r"\s*,\s*")
@@ -97,202 +91,6 @@ def patch_cache_control(response, **kwargs):
     response.headers["Cache-Control"] = cc
 
 
-def get_max_age(response):
-    """
-    Return the max-age from the response Cache-Control header as an integer,
-    or None if it wasn't found or wasn't an integer.
-    """
-    if "Cache-Control" not in response.headers:
-        return
-    cc = dict(
-        _to_tuple(el) for el in cc_delim_re.split(response.headers["Cache-Control"])
-    )
-    try:
-        return int(cc["max-age"])
-    except (ValueError, TypeError, KeyError):
-        pass
-
-
-def set_response_etag(response):
-    if not response.streaming and response.content:
-        response.headers["ETag"] = quote_etag(
-            md5(response.content, usedforsecurity=False).hexdigest(),
-        )
-    return response
-
-
-def _precondition_failed(request):
-    response = Response(status=412)
-    log_response(
-        "Precondition Failed: %s",
-        request.path,
-        response=response,
-        request=request,
-    )
-    return response
-
-
-def _not_modified(request, response=None):
-    new_response = ResponseNotModified()
-    if response:
-        # Preserve the headers required by RFC 9110 Section 15.4.5, as well as
-        # Last-Modified.
-        for header in (
-            "Cache-Control",
-            "Content-Location",
-            "Date",
-            "ETag",
-            "Expires",
-            "Last-Modified",
-            "Vary",
-        ):
-            if header in response.headers:
-                new_response.headers[header] = response.headers[header]
-
-        # Preserve cookies as per the cookie specification: "If a proxy server
-        # receives a response which contains a Set-cookie header, it should
-        # propagate the Set-cookie header to the client, regardless of whether
-        # the response was 304 (Not Modified) or 200 (OK).
-        # https://curl.haxx.se/rfc/cookie_spec.html
-        new_response.cookies = response.cookies
-    return new_response
-
-
-def get_conditional_response(request, etag=None, last_modified=None, response=None):
-    # Only return conditional responses on successful requests.
-    if response and not (200 <= response.status_code < 300):
-        return response
-
-    # Get HTTP request headers.
-    if_match_etags = parse_etags(request.META.get("HTTP_IF_MATCH", ""))
-    if_unmodified_since = request.META.get("HTTP_IF_UNMODIFIED_SINCE")
-    if_unmodified_since = if_unmodified_since and parse_http_date_safe(
-        if_unmodified_since
-    )
-    if_none_match_etags = parse_etags(request.META.get("HTTP_IF_NONE_MATCH", ""))
-    if_modified_since = request.META.get("HTTP_IF_MODIFIED_SINCE")
-    if_modified_since = if_modified_since and parse_http_date_safe(if_modified_since)
-
-    # Evaluation of request preconditions below follows RFC 9110 Section
-    # 13.2.2.
-    # Step 1: Test the If-Match precondition.
-    if if_match_etags and not _if_match_passes(etag, if_match_etags):
-        return _precondition_failed(request)
-
-    # Step 2: Test the If-Unmodified-Since precondition.
-    if (
-        not if_match_etags
-        and if_unmodified_since
-        and not _if_unmodified_since_passes(last_modified, if_unmodified_since)
-    ):
-        return _precondition_failed(request)
-
-    # Step 3: Test the If-None-Match precondition.
-    if if_none_match_etags and not _if_none_match_passes(etag, if_none_match_etags):
-        if request.method in ("GET", "HEAD"):
-            return _not_modified(request, response)
-        else:
-            return _precondition_failed(request)
-
-    # Step 4: Test the If-Modified-Since precondition.
-    if (
-        not if_none_match_etags
-        and if_modified_since
-        and not _if_modified_since_passes(last_modified, if_modified_since)
-        and request.method in ("GET", "HEAD")
-    ):
-        return _not_modified(request, response)
-
-    # Step 5: Test the If-Range precondition (not supported).
-    # Step 6: Return original response since there isn't a conditional response.
-    return response
-
-
-def _if_match_passes(target_etag, etags):
-    """
-    Test the If-Match comparison as defined in RFC 9110 Section 13.1.1.
-    """
-    if not target_etag:
-        # If there isn't an ETag, then there can't be a match.
-        return False
-    elif etags == ["*"]:
-        # The existence of an ETag means that there is "a current
-        # representation for the target resource", even if the ETag is weak,
-        # so there is a match to '*'.
-        return True
-    elif target_etag.startswith("W/"):
-        # A weak ETag can never strongly match another ETag.
-        return False
-    else:
-        # Since the ETag is strong, this will only return True if there's a
-        # strong match.
-        return target_etag in etags
-
-
-def _if_unmodified_since_passes(last_modified, if_unmodified_since):
-    """
-    Test the If-Unmodified-Since comparison as defined in RFC 9110 Section
-    13.1.4.
-    """
-    return last_modified and last_modified <= if_unmodified_since
-
-
-def _if_none_match_passes(target_etag, etags):
-    """
-    Test the If-None-Match comparison as defined in RFC 9110 Section 13.1.2.
-    """
-    if not target_etag:
-        # If there isn't an ETag, then there isn't a match.
-        return True
-    elif etags == ["*"]:
-        # The existence of an ETag means that there is "a current
-        # representation for the target resource", so there is a match to '*'.
-        return False
-    else:
-        # The comparison should be weak, so look for a match after stripping
-        # off any weak indicators.
-        target_etag = target_etag.strip("W/")
-        etags = (etag.strip("W/") for etag in etags)
-        return target_etag not in etags
-
-
-def _if_modified_since_passes(last_modified, if_modified_since):
-    """
-    Test the If-Modified-Since comparison as defined in RFC 9110 Section
-    13.1.3.
-    """
-    return not last_modified or last_modified > if_modified_since
-
-
-def patch_response_headers(response, cache_timeout=None):
-    """
-    Add HTTP caching headers to the given Response: Expires and
-    Cache-Control.
-
-    Each header is only added if it isn't already set.
-
-    cache_timeout is in seconds. The CACHE_MIDDLEWARE_SECONDS setting is used
-    by default.
-    """
-    if cache_timeout is None:
-        cache_timeout = settings.CACHE_MIDDLEWARE_SECONDS
-    if cache_timeout < 0:
-        cache_timeout = 0  # Can't have max-age negative
-    if "Expires" not in response.headers:
-        response.headers["Expires"] = http_date(time.time() + cache_timeout)
-    patch_cache_control(response, max_age=cache_timeout)
-
-
-def add_never_cache_headers(response):
-    """
-    Add headers to a response to indicate that a page should never be cached.
-    """
-    patch_response_headers(response, cache_timeout=-1)
-    patch_cache_control(
-        response, no_cache=True, no_store=True, must_revalidate=True, private=True
-    )
-
-
 def patch_vary_headers(response, newheaders):
     """
     Add (or update) the "Vary" header in the given Response object.

plain/utils/encoding.py

@@ -1,6 +1,4 @@
-import codecs
 import datetime
-import locale
 from decimal import Decimal
 from types import NoneType
 from urllib.parse import quote
@@ -127,109 +125,6 @@ _hextobyte.update(
 )
 
 
-def uri_to_iri(uri):
-    """
-    Convert a Uniform Resource Identifier(URI) into an Internationalized
-    Resource Identifier(IRI).
-
-    This is the algorithm from RFC 3987 Section 3.2, excluding step 4.
-
-    Take an URI in ASCII bytes (e.g. '/I%20%E2%99%A5%20Plain/') and return
-    a string containing the encoded result (e.g. '/I%20♥%20Plain/').
-    """
-    if uri is None:
-        return uri
-    uri = force_bytes(uri)
-    # Fast selective unquote: First, split on '%' and then starting with the
-    # second block, decode the first 2 bytes if they represent a hex code to
-    # decode. The rest of the block is the part after '%AB', not containing
-    # any '%'. Add that to the output without further processing.
-    bits = uri.split(b"%")
-    if len(bits) == 1:
-        iri = uri
-    else:
-        parts = [bits[0]]
-        append = parts.append
-        hextobyte = _hextobyte
-        for item in bits[1:]:
-            hex = item[:2]
-            if hex in hextobyte:
-                append(hextobyte[item[:2]])
-                append(item[2:])
-            else:
-                append(b"%")
-                append(item)
-        iri = b"".join(parts)
-    return repercent_broken_unicode(iri).decode()
-
-
-def escape_uri_path(path):
-    """
-    Escape the unsafe characters from the path portion of a Uniform Resource
-    Identifier (URI).
-    """
-    # These are the "reserved" and "unreserved" characters specified in RFC
-    # 3986 Sections 2.2 and 2.3:
-    #   reserved    = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ","
-    #   unreserved  = alphanum | mark
-    #   mark        = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"
-    # The list of safe characters here is constructed subtracting ";", "=",
-    # and "?" according to RFC 3986 Section 3.3.
-    # The reason for not subtracting and escaping "/" is that we are escaping
-    # the entire path, not a path segment.
-    return quote(path, safe="/:@&+$,-_.!~*'()")
-
-
 def punycode(domain):
     """Return the Punycode of the given domain if it's non-ASCII."""
     return domain.encode("idna").decode("ascii")
-
-
-def repercent_broken_unicode(path):
-    """
-    As per RFC 3987 Section 3.2, step three of converting a URI into an IRI,
-    repercent-encode any octet produced that is not part of a strictly legal
-    UTF-8 octet sequence.
-    """
-    while True:
-        try:
-            path.decode()
-        except UnicodeDecodeError as e:
-            # CVE-2019-14235: A recursion shouldn't be used since the exception
-            # handling uses massive amounts of memory
-            repercent = quote(path[e.start : e.end], safe=b"/#%[]=:;$&()+,!?*@'~")
-            path = path[: e.start] + repercent.encode() + path[e.end :]
-        else:
-            return path
-
-
-def filepath_to_uri(path):
-    """Convert a file system path to a URI portion that is suitable for
-    inclusion in a URL.
-
-    Encode certain chars that would normally be recognized as special chars
-    for URIs. Do not encode the ' character, as it is a valid character
-    within URIs. See the encodeURIComponent() JavaScript function for details.
-    """
-    if path is None:
-        return path
-    # I know about `os.sep` and `os.altsep` but I want to leave
-    # some flexibility for hardcoding separators.
-    return quote(str(path).replace("\\", "/"), safe="/~!*()'")
-
-
-def get_system_encoding():
-    """
-    The encoding for the character type functions. Fallback to 'ascii' if the
-    #encoding is unsupported by Python or could not be determined. See tickets
-    #10335 and #5846.
-    """
-    try:
-        encoding = locale.getlocale()[1] or "ascii"
-        codecs.lookup(encoding)
-    except Exception:
-        encoding = "ascii"
-    return encoding
-
-
-DEFAULT_LOCALE_ENCODING = get_system_encoding()

plain/utils/functional.py

@@ -205,13 +205,6 @@ def _lazy_proxy_unpickle(func, args, kwargs, *resultclasses):
     return lazy(func, *resultclasses)(*args, **kwargs)
 
 
-def lazystr(text):
-    """
-    Shortcut for the common case of a lazy callable that returns str.
-    """
-    return lazy(str, str)(text)
-
-
 def keep_lazy(*resultclasses):
     """
     A decorator that allows a function to be called with one or more lazy