plain 0.25.0__py3-none-any.whl → 0.26.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

@@ -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/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.26.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain
-Version: 0.25.0
+Version: 0.26.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.26.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=UEagFzHXCSuGeMlz2E1JLj0fgigOR89i5yVZe8Pq9Ds,17589
 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.26.0.dist-info/METADATA,sha256=ubQaY6xdMzXNiRH6AvYXOWNyOdmthru0UB3-AKlPnxU,319
+plain-0.26.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+plain-0.26.0.dist-info/entry_points.txt,sha256=DHHprvufgd7xypiBiqMANYRnpJ9xPPYhYbnPGwOkWqE,40
+plain-0.26.0.dist-info/licenses/LICENSE,sha256=m0D5O7QoH9l5Vz_rrX_9r-C8d9UNr_ciK6Qwac7o6yo,3175
+plain-0.26.0.dist-info/RECORD,,