plain 0.25.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

plain/packages/__init__.py

@@ -1,4 +1,4 @@
 from .config import PackageConfig
-from .registry import packages_registry
+from .registry import packages_registry, register_config
 
-__all__ = ["PackageConfig", "packages_registry"]
+__all__ = ["PackageConfig", "packages_registry", "register_config"]

plain/packages/config.py

@@ -1,9 +1,8 @@
-import inspect
 import os
+from functools import cached_property
 from importlib import import_module
 
 from plain.exceptions import ImproperlyConfigured
-from plain.utils.module_loading import import_string, module_has_submodule
 
 CONFIG_MODULE_NAME = "config"
 
@@ -13,13 +12,9 @@ class PackageConfig:
 
     migrations_module = "migrations"
 
-    def __init__(self, package_name, package_module):
+    def __init__(self, name, *, label=""):
         # Full Python path to the application e.g. 'plain.admin.admin'.
-        self.name = package_name
-
-        # Root module for the application e.g. <module 'plain.admin.admin'
-        # from 'admin/__init__.py'>.
-        self.module = package_module
+        self.name = name
 
         # Reference to the Packages registry that holds this PackageConfig. Set by the
         # registry when it registers the PackageConfig instance.
@@ -27,168 +22,61 @@ class PackageConfig:
 
         # The following attributes could be defined at the class level in a
         # subclass, hence the test-and-set pattern.
+        if label and hasattr(self, "label"):
+            raise ImproperlyConfigured(
+                "PackageConfig class should not define a class label attribute and an init label"
+            )
+
+        if label:
+            # Set the label explicitly from the init
+            self.label = label
+        elif not hasattr(self, "label"):
+            # Last component of the Python path to the application e.g. 'admin'.
+            # This value must be unique across a Plain project.
+            self.label = self.name.rpartition(".")[2]
 
-        # Last component of the Python path to the application e.g. 'admin'.
-        # This value must be unique across a Plain project.
-        if not hasattr(self, "label"):
-            self.label = package_name.rpartition(".")[2]
         if not self.label.isidentifier():
             raise ImproperlyConfigured(
                 f"The app label '{self.label}' is not a valid Python identifier."
             )
 
-        # Filesystem path to the application directory e.g.
-        # '/path/to/admin'.
-        if not hasattr(self, "path"):
-            self.path = self._path_from_module(package_module)
-
     def __repr__(self):
         return f"<{self.__class__.__name__}: {self.label}>"
 
-    def _path_from_module(self, module):
-        """Attempt to determine app's filesystem path from its module."""
-        # See #21874 for extended discussion of the behavior of this method in
-        # various cases.
-        # Convert to list because __path__ may not support indexing.
-        paths = list(getattr(module, "__path__", []))
-        if len(paths) != 1:
-            filename = getattr(module, "__file__", None)
-            if filename is not None:
-                paths = [os.path.dirname(filename)]
-            else:
-                # For unknown reasons, sometimes the list returned by __path__
-                # contains duplicates that must be removed (#25246).
-                paths = list(set(paths))
-        if len(paths) > 1:
-            raise ImproperlyConfigured(
-                f"The app module {module!r} has multiple filesystem locations ({paths!r}); "
-                "you must configure this app with an PackageConfig subclass "
-                "with a 'path' class attribute."
-            )
-        elif not paths:
-            raise ImproperlyConfigured(
-                f"The app module {module!r} has no filesystem location, "
-                "you must configure this app with an PackageConfig subclass "
-                "with a 'path' class attribute."
-            )
-        return paths[0]
-
-    @classmethod
-    def create(cls, entry):
-        """
-        Factory that creates an app config from an entry in INSTALLED_PACKAGES.
-        """
-        # create() eventually returns package_config_class(package_name, package_module).
-        package_config_class = None
-        package_name = None
-        package_module = None
-
-        # If import_module succeeds, entry points to the app module.
-        try:
-            package_module = import_module(entry)
-        except Exception:
-            pass
-        else:
-            # If package_module has an packages submodule that defines a single
-            # PackageConfig subclass, use it automatically.
-            # To prevent this, an PackageConfig subclass can declare a class
-            # variable default = False.
-            # If the packages module defines more than one PackageConfig subclass,
-            # the default one can declare default = True.
-            if module_has_submodule(package_module, CONFIG_MODULE_NAME):
-                mod_path = f"{entry}.{CONFIG_MODULE_NAME}"
-                mod = import_module(mod_path)
-                # Check if there's exactly one PackageConfig candidate,
-                # excluding those that explicitly define default = False.
-                package_configs = [
-                    (name, candidate)
-                    for name, candidate in inspect.getmembers(mod, inspect.isclass)
-                    if (
-                        issubclass(candidate, cls)
-                        and candidate is not cls
-                        and getattr(candidate, "default", True)
-                    )
-                ]
-                if len(package_configs) == 1:
-                    package_config_class = package_configs[0][1]
+    @cached_property
+    def path(self):
+        # Filesystem path to the application directory e.g.
+        # '/path/to/admin'.
+        def _path_from_module(module):
+            """Attempt to determine app's filesystem path from its module."""
+            # See #21874 for extended discussion of the behavior of this method in
+            # various cases.
+            # Convert to list because __path__ may not support indexing.
+            paths = list(getattr(module, "__path__", []))
+            if len(paths) != 1:
+                filename = getattr(module, "__file__", None)
+                if filename is not None:
+                    paths = [os.path.dirname(filename)]
                 else:
-                    # Check if there's exactly one PackageConfig subclass,
-                    # among those that explicitly define default = True.
-                    package_configs = [
-                        (name, candidate)
-                        for name, candidate in package_configs
-                        if getattr(candidate, "default", False)
-                    ]
-                    if len(package_configs) > 1:
-                        candidates = [repr(name) for name, _ in package_configs]
-                        raise RuntimeError(
-                            "{!r} declares more than one default PackageConfig: "
-                            "{}.".format(mod_path, ", ".join(candidates))
-                        )
-                    elif len(package_configs) == 1:
-                        package_config_class = package_configs[0][1]
-
-            # Use the default app config class if we didn't find anything.
-            if package_config_class is None:
-                package_config_class = cls
-                package_name = entry
-
-        # If import_string succeeds, entry is an app config class.
-        if package_config_class is None:
-            try:
-                package_config_class = import_string(entry)
-            except Exception:
-                pass
-        # If both import_module and import_string failed, it means that entry
-        # doesn't have a valid value.
-        if package_module is None and package_config_class is None:
-            # If the last component of entry starts with an uppercase letter,
-            # then it was likely intended to be an app config class; if not,
-            # an app module. Provide a nice error message in both cases.
-            mod_path, _, cls_name = entry.rpartition(".")
-            if mod_path and cls_name[0].isupper():
-                # We could simply re-trigger the string import exception, but
-                # we're going the extra mile and providing a better error
-                # message for typos in INSTALLED_PACKAGES.
-                # This may raise ImportError, which is the best exception
-                # possible if the module at mod_path cannot be imported.
-                mod = import_module(mod_path)
-                candidates = [
-                    repr(name)
-                    for name, candidate in inspect.getmembers(mod, inspect.isclass)
-                    if issubclass(candidate, cls) and candidate is not cls
-                ]
-                msg = f"Module '{mod_path}' does not contain a '{cls_name}' class."
-                if candidates:
-                    msg += " Choices are: {}.".format(", ".join(candidates))
-                raise ImportError(msg)
-            else:
-                # Re-trigger the module import exception.
-                import_module(entry)
-
-        # Check for obvious errors. (This check prevents duck typing, but
-        # it could be removed if it became a problem in practice.)
-        if not issubclass(package_config_class, PackageConfig):
-            raise ImproperlyConfigured(f"'{entry}' isn't a subclass of PackageConfig.")
-
-        # Obtain package name here rather than in PackageClass.__init__ to keep
-        # all error checking for entries in INSTALLED_PACKAGES in one place.
-        if package_name is None:
-            try:
-                package_name = package_config_class.name
-            except AttributeError:
-                raise ImproperlyConfigured(f"'{entry}' must supply a name attribute.")
-
-        # Ensure package_name points to a valid module.
-        try:
-            package_module = import_module(package_name)
-        except ImportError:
-            raise ImproperlyConfigured(
-                f"Cannot import '{package_name}'. Check that '{package_config_class.__module__}.{package_config_class.__qualname__}.name' is correct."
-            )
-
-        # Entry is a path to an app config class.
-        return package_config_class(package_name, package_module)
+                    # For unknown reasons, sometimes the list returned by __path__
+                    # contains duplicates that must be removed (#25246).
+                    paths = list(set(paths))
+            if len(paths) > 1:
+                raise ImproperlyConfigured(
+                    f"The app module {module!r} has multiple filesystem locations ({paths!r}); "
+                    "you must configure this app with an PackageConfig subclass "
+                    "with a 'path' class attribute."
+                )
+            elif not paths:
+                raise ImproperlyConfigured(
+                    f"The app module {module!r} has no filesystem location, "
+                    "you must configure this app with an PackageConfig subclass "
+                    "with a 'path' class attribute."
+                )
+            return paths[0]
+
+        module = import_module(self.name)
+        return _path_from_module(module)
 
     def ready(self):
         """

plain/packages/registry.py

@@ -1,14 +1,14 @@
-import functools
 import sys
 import threading
-import warnings
-from collections import Counter, defaultdict
-from functools import partial
+from collections import Counter
+from importlib import import_module
 
 from plain.exceptions import ImproperlyConfigured, PackageRegistryNotReady
 
 from .config import PackageConfig
 
+CONFIG_MODULE_NAME = "config"
+
 
 class PackagesRegistry:
     """
@@ -26,30 +26,16 @@ class PackagesRegistry:
         ):
             raise RuntimeError("You must supply an installed_packages argument.")
 
-        # Mapping of app labels => model names => model classes.
-        # Models are registered with @models.register_model, which
-        # creates an entry in all_models. All imported models are registered,
-        # regardless of whether they're defined in an installed application
-        # and whether the registry has been populated. Since it isn't possible
-        # to reimport a module safely (it could reexecute initialization code)
-        # all_models is never overridden or reset.
-        self.all_models = defaultdict(dict)
-
         # Mapping of labels to PackageConfig instances for installed packages.
         self.package_configs = {}
 
         # Whether the registry is populated.
-        self.packages_ready = self.models_ready = self.ready = False
+        self.packages_ready = self.ready = False
 
         # Lock for thread-safe population.
         self._lock = threading.RLock()
         self.loading = False
 
-        # Maps ("package_label", "modelname") tuples to lists of functions to be
-        # called when the corresponding model is ready. Used by this class's
-        # `lazy_model_operation()` and `do_pending_operations()` methods.
-        self._pending_operations = defaultdict(list)
-
         # Populate packages and models, unless it's the main registry.
         if installed_packages is not None:
             self.populate(installed_packages)
@@ -82,17 +68,34 @@ 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(package_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.
+                        auto_package_config = PackageConfig(entry)
+                        entry_config = self.register_config(auto_package_config)
+
+            # 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(
@@ -112,10 +115,6 @@ class PackagesRegistry:
             for package_config in self.get_package_configs():
                 package_config.ready()
 
-            self.clear_cache()
-
-            self.models_ready = True
-
             self.ready = True
 
     def check_packages_ready(self):
@@ -129,11 +128,6 @@ class PackagesRegistry:
             settings.INSTALLED_PACKAGES
             raise PackageRegistryNotReady("Packages aren't loaded yet.")
 
-    def check_models_ready(self):
-        """Raise an exception if all models haven't been imported yet."""
-        if not self.models_ready:
-            raise PackageRegistryNotReady("Models aren't loaded yet.")
-
     def get_package_configs(self):
         """Import applications and return an iterable of app configs."""
         self.check_packages_ready()
@@ -156,102 +150,6 @@ class PackagesRegistry:
                     break
             raise LookupError(message)
 
-    # This method is performance-critical at least for Plain's test suite.
-    @functools.cache
-    def get_models(
-        self, *, package_label="", include_auto_created=False, include_swapped=False
-    ):
-        """
-        Return a list of all installed models.
-
-        By default, the following models aren't included:
-
-        - auto-created models for many-to-many relations without
-          an explicit intermediate table,
-        - models that have been swapped out.
-
-        Set the corresponding keyword argument to True to include such models.
-        """
-        self.check_models_ready()
-
-        result = []
-
-        # Get models for a single package
-        if package_label:
-            package_models = self.all_models[package_label]
-            for model in package_models.values():
-                if model._meta.auto_created and not include_auto_created:
-                    continue
-                if model._meta.swapped and not include_swapped:
-                    continue
-                result.append(model)
-            return result
-
-        # Get models for all packages
-        for package_models in self.all_models.values():
-            for model in package_models.values():
-                if model._meta.auto_created and not include_auto_created:
-                    continue
-                if model._meta.swapped and not include_swapped:
-                    continue
-                result.append(model)
-
-        return result
-
-    def get_model(self, package_label, model_name=None, require_ready=True):
-        """
-        Return the model matching the given package_label and model_name.
-
-        As a shortcut, package_label may be in the form <package_label>.<model_name>.
-
-        model_name is case-insensitive.
-
-        Raise LookupError if no application exists with this label, or no
-        model exists with this name in the application. Raise ValueError if
-        called with a single argument that doesn't contain exactly one dot.
-        """
-        if require_ready:
-            self.check_models_ready()
-        else:
-            self.check_packages_ready()
-
-        if model_name is None:
-            package_label, model_name = package_label.split(".")
-
-        # package_config = self.get_package_config(package_label)
-
-        # if not require_ready and package_config.models is None:
-        #     package_config.import_models()
-
-        package_models = self.all_models[package_label]
-        return package_models[model_name.lower()]
-
-    def register_model(self, package_label, model):
-        # Since this method is called when models are imported, it cannot
-        # perform imports because of the risk of import loops. It mustn't
-        # call get_package_config().
-        model_name = model._meta.model_name
-        app_models = self.all_models[package_label]
-        if model_name in app_models:
-            if (
-                model.__name__ == app_models[model_name].__name__
-                and model.__module__ == app_models[model_name].__module__
-            ):
-                warnings.warn(
-                    f"Model '{package_label}.{model_name}' was already registered. Reloading models is not "
-                    "advised as it can lead to inconsistencies, most notably with "
-                    "related models.",
-                    RuntimeWarning,
-                    stacklevel=2,
-                )
-            else:
-                raise RuntimeError(
-                    f"Conflicting '{model_name}' models in application '{package_label}': {app_models[model_name]} and {model}."
-                )
-        app_models[model_name] = model
-        self.do_pending_operations(model)
-        self.clear_cache()
-
     def get_containing_package_config(self, object_name):
         """
         Look for an app config containing a given object.
@@ -271,106 +169,39 @@ class PackagesRegistry:
         if candidates:
             return sorted(candidates, key=lambda ac: -len(ac.name))[0]
 
-    def get_registered_model(self, package_label, model_name):
+    def register_config(self, package_config):
         """
-        Similar to get_model(), but doesn't require that an app exists with
-        the given package_label.
+        Add a config to the registry.
 
-        It's safe to call this method at import time, even while the registry
-        is being populated.
-        """
-        model = self.all_models[package_label].get(model_name.lower())
-        if model is None:
-            raise LookupError(f"Model '{package_label}.{model_name}' not registered.")
-        return model
+        Typically used as a decorator on a PackageConfig subclass. Example:
 
-    @functools.cache
-    def get_swappable_settings_name(self, to_string):
-        """
-        For a given model string (e.g. "auth.User"), return the name of the
-        corresponding settings name if it refers to a swappable model. If the
-        referred model is not swappable, return None.
-
-        This method is decorated with @functools.cache because it's performance
-        critical when it comes to migrations. Since the swappable settings don't
-        change after Plain has loaded the settings, there is no reason to get
-        the respective settings attribute over and over again.
+        @register_config
+        class Config(PackageConfig):
+            pass
         """
-        to_string = to_string.lower()
-        for model in self.get_models(include_swapped=True):
-            swapped = model._meta.swapped
-            # Is this model swapped out for the model given by to_string?
-            if swapped and swapped.lower() == to_string:
-                return model._meta.swappable
-            # Is this model swappable and the one given by to_string?
-            if model._meta.swappable and model._meta.label_lower == to_string:
-                return model._meta.swappable
-        return None
-
-    def clear_cache(self):
-        """
-        Clear all internal caches, for methods that alter the app registry.
+        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
 
-        This is mostly used in tests.
-        """
-        # Call expire cache on each model. This will purge
-        # the relation tree and the fields cache.
-        self.get_models.cache_clear()
-        if self.ready:
-            # Circumvent self.get_models() to prevent that the cache is refilled.
-            # This particularly prevents that an empty value is cached while cloning.
-            for package_models in self.all_models.values():
-                for model in package_models.values():
-                    model._meta._expire_cache()
+        return package_config
 
-    def lazy_model_operation(self, function, *model_keys):
-        """
-        Take a function and a number of ("package_label", "modelname") tuples, and
-        when all the corresponding models have been imported and registered,
-        call the function with the model classes as its arguments.
 
-        The function passed to this method must accept exactly n models as
-        arguments, where n=len(model_keys).
-        """
-        # Base case: no arguments, just execute the function.
-        if not model_keys:
-            function()
-        # Recursive case: take the head of model_keys, wait for the
-        # corresponding model class to be imported and registered, then apply
-        # that argument to the supplied function. Pass the resulting partial
-        # to lazy_model_operation() along with the remaining model args and
-        # repeat until all models are loaded and all arguments are applied.
-        else:
-            next_model, *more_models = model_keys
-
-            # This will be executed after the class corresponding to next_model
-            # has been imported and registered. The `func` attribute provides
-            # duck-type compatibility with partials.
-            def apply_next_model(model):
-                next_function = partial(apply_next_model.func, model)
-                self.lazy_model_operation(next_function, *more_models)
-
-            apply_next_model.func = function
-
-            # If the model has already been imported and registered, partially
-            # apply it to the function now. If not, add it to the list of
-            # pending operations for the model, where it will be executed with
-            # the model class as its sole argument once the model is ready.
-            try:
-                model_class = self.get_registered_model(*next_model)
-            except LookupError:
-                self._pending_operations[next_model].append(apply_next_model)
-            else:
-                apply_next_model(model_class)
-
-    def do_pending_operations(self, model):
-        """
-        Take a newly-prepared model and pass it to each function waiting for
-        it. This is called at the very end of Packages.register_model().
-        """
-        key = model._meta.package_label, model._meta.model_name
-        for function in self._pending_operations.pop(key, []):
-            function(model)
+packages_registry = PackagesRegistry(installed_packages=None)
 
 
-packages_registry = PackagesRegistry(installed_packages=None)
+def register_config(package_config_class):
+    """A decorator to register a PackageConfig subclass."""
+    module_name = package_config_class.__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]
+
+    package_config = package_config_class(module_name)
+
+    packages_registry.register_config(package_config)
+
+    return package_config_class

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/utils/module_loading.py

@@ -1,7 +1,6 @@
 import os
 import sys
 from importlib import import_module
-from importlib.util import find_spec as importlib_find
 
 
 def cached_import(module_path, class_name):
@@ -33,24 +32,6 @@ def import_string(dotted_path):
         ) from err
 
 
-def module_has_submodule(package, module_name):
-    """See if 'module' is in 'package'."""
-    try:
-        package_name = package.__name__
-        package_path = package.__path__
-    except AttributeError:
-        # package isn't a package.
-        return False
-
-    full_module_name = package_name + "." + module_name
-    try:
-        return importlib_find(full_module_name, package_path) is not None
-    except ModuleNotFoundError:
-        # When module_name is an invalid dotted path, Python raises
-        # ModuleNotFoundError.
-        return False
-
-
 def module_dir(module):
     """
     Find the name of the directory that contains a module, if possible.

{plain-0.25.0.dist-info → plain-0.27.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain
-Version: 0.25.0
+Version: 0.27.0
 Summary: A web framework for building products with Python.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-File: LICENSE

{plain-0.25.0.dist-info → plain-0.27.0.dist-info}/RECORD

@@ -60,9 +60,9 @@ plain/logs/configure.py,sha256=6mV7d1IxkDYT3VBz61qhIj0Esuy5l5QdQfsHaGCfI6w,1063
 plain/logs/loggers.py,sha256=iz9SYcwP9w5QAuwpULl48SFkVyJuuMoQ_fdLgdCHpNg,2121
 plain/logs/utils.py,sha256=9UzdCCQXJinGDs71Ngw297mlWkhgZStSd67ya4NOW98,1257
 plain/packages/README.md,sha256=Vq1Nw3mmEmZ2IriQavuVi4BjcQC2nb8k7YIbnm8QjIg,799
-plain/packages/__init__.py,sha256=75ILri5V7gm9k5RzvrYNBHPdLUZNbO65Go3kBg95O8w,124
-plain/packages/config.py,sha256=oOXy_k2qzy1i221hCsayVx0xPVLBxb_pwOVDDxPVfDI,8842
-plain/packages/registry.py,sha256=PeVoYbMwYqg7VTMB3QIWL3YUve9l2Ki-AJx29tm6SWs,15432
+plain/packages/__init__.py,sha256=OpQny0xLplPdPpozVUUkrW2gB-IIYyDT1b4zMzOcCC4,160
+plain/packages/config.py,sha256=Gmu7QW4Z3Cx9_d7N2D5o7t292t7vAOE8aL-3yO7sGqc,3327
+plain/packages/registry.py,sha256=Aklno7y7UrBZlidtUR_YO3B5xqF46UbUtalReNcYHm8,7937
 plain/preflight/README.md,sha256=-PKVd0RBMh4ROiMkegPS2PgvT1Kq9qqN1KfNkmUSdFc,177
 plain/preflight/__init__.py,sha256=H-TNRvaddPtOGmv4RXoc1fxDV1AOb7_K3u7ECF8mV58,607
 plain/preflight/files.py,sha256=wbHCNgps7o1c1zQNBd8FDCaVaqX90UwuvLgEQ_DbUpY,510
@@ -83,7 +83,7 @@ plain/templates/README.md,sha256=VfA2HmrklG5weE1md85q9g84cWnMBEiXAynKzM7S1Sk,464
 plain/templates/__init__.py,sha256=bX76FakE9T7mfK3N0deN85HlwHNQpeigytSC9Z8LcOs,451
 plain/templates/core.py,sha256=iw58EAmyyv8N5HDA-Sq4-fLgz_qx8v8WJfurgR116jw,625
 plain/templates/jinja/README.md,sha256=ft4781b4IAVI6fsIdAHIpOigdsZ6wGg06LK7BHxoj-g,6996
-plain/templates/jinja/__init__.py,sha256=Nm34l_heWGYKFetO-GcAmr5qVbuQtyCJBy2jrEAoK-c,2671
+plain/templates/jinja/__init__.py,sha256=qBESSL8XfwdxtwujjR5mZvk4VddlMn1-jOsSxGQy0oE,2768
 plain/templates/jinja/environments.py,sha256=9plifzvQj--aTN1cCpJ2WdzQxZJpzB8S_4hghgQRQT0,2064
 plain/templates/jinja/extensions.py,sha256=AEmmmHDbdRW8fhjYDzq9eSSNbp9WHsXenD8tPthjc0s,1351
 plain/templates/jinja/filters.py,sha256=3KJKKbxcv9dLzUDWPcaa88k3NU2m1GG3iMIgFhzXrBA,860
@@ -117,7 +117,7 @@ plain/utils/http.py,sha256=VOOnwRXnDp5PL_qEmkInLTm10fF58vlhVjeSTdzV2cQ,6031
 plain/utils/inspect.py,sha256=O3VMH5f4aGOrVpXJBKtQOxx01XrKnjjz6VO_MCV0xkE,1140
 plain/utils/ipv6.py,sha256=pISQ2AIlG8xXlxpphn388q03fq-fOrlu4GZR0YYjQXw,1267
 plain/utils/itercompat.py,sha256=lacIDjczhxbwG4ON_KfG1H6VNPOGOpbRhnVhbedo2CY,184
-plain/utils/module_loading.py,sha256=CWl7Shoax9Zkevf1pM9PpS_0V69J5Cukjyj078UPCAw,2252
+plain/utils/module_loading.py,sha256=11a1JbASB-KbahQe2Dlhiw_2VD71lKKZYmo3y_wfJeI,1640
 plain/utils/regex_helper.py,sha256=pAdh_xG52BOyXLsiuIMPFgduUAoWOEje1ZpjhcefxiA,12769
 plain/utils/safestring.py,sha256=sawOehuWjr4bkF5jXXCcziILQGoqUcA_eEfsURrAyN0,1801
 plain/utils/text.py,sha256=42hJv06sadbWfsaAHNhqCQaP1W9qZ69trWDTS-Xva7k,9496
@@ -134,8 +134,8 @@ plain/views/forms.py,sha256=RhlaUcZCkeqokY_fvv-NOS-kgZAG4XhDLOPbf9K_Zlc,2691
 plain/views/objects.py,sha256=g5Lzno0Zsv0K449UpcCtxwCoO7WMRAWqKlxxV2V0_qg,8263
 plain/views/redirect.py,sha256=9zHZgKvtSkdrMX9KmsRM8hJTPmBktxhc4d8OitbuniI,1724
 plain/views/templates.py,sha256=cBkFNCSXgVi8cMqQbhsqJ4M_rIQYVl8cUvq9qu4YIes,1951
-plain-0.25.0.dist-info/METADATA,sha256=ErgfCIZpGA9-NDGsjKHueIWtZ2LhJquSTQ37ycDo2BQ,319
-plain-0.25.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-plain-0.25.0.dist-info/entry_points.txt,sha256=DHHprvufgd7xypiBiqMANYRnpJ9xPPYhYbnPGwOkWqE,40
-plain-0.25.0.dist-info/licenses/LICENSE,sha256=m0D5O7QoH9l5Vz_rrX_9r-C8d9UNr_ciK6Qwac7o6yo,3175
-plain-0.25.0.dist-info/RECORD,,
+plain-0.27.0.dist-info/METADATA,sha256=5bkOqMEQNCnkyEx011gMDQNmLjzncCOXJ2zPGti0HHo,319
+plain-0.27.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+plain-0.27.0.dist-info/entry_points.txt,sha256=DHHprvufgd7xypiBiqMANYRnpJ9xPPYhYbnPGwOkWqE,40
+plain-0.27.0.dist-info/licenses/LICENSE,sha256=m0D5O7QoH9l5Vz_rrX_9r-C8d9UNr_ciK6Qwac7o6yo,3175
+plain-0.27.0.dist-info/RECORD,,