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

plain/packages/registry.py

@@ -1,9 +1,6 @@
-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
@@ -29,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)
@@ -87,7 +70,7 @@ class PackagesRegistry:
                 if isinstance(entry, PackageConfig):
                     # Some instances of the registry pass in the
                     # PackageConfig directly...
-                    self.register_config(entry)
+                    self.register_config(package_config=entry)
                 else:
                     try:
                         import_module(f"{entry}.{CONFIG_MODULE_NAME}")
@@ -104,9 +87,8 @@ class PackagesRegistry:
 
                     if not entry_config:
                         # Use PackageConfig class as-is, without any customization.
-                        entry_config = self.register_config(
-                            PackageConfig, module_name=entry
-                        )
+                        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):
@@ -133,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):
@@ -150,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()
@@ -177,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.
@@ -292,108 +169,7 @@ class PackagesRegistry:
         if candidates:
             return sorted(candidates, key=lambda ac: -len(ac.name))[0]
 
-    def get_registered_model(self, package_label, model_name):
-        """
-        Similar to get_model(), but doesn't require that an app exists with
-        the given package_label.
-
-        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
-
-    @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.
-        """
-        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.
-
-        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()
-
-    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)
-
-    def register_config(self, package_config, module_name=""):
+    def register_config(self, package_config):
         """
         Add a config to the registry.
 
@@ -403,19 +179,6 @@ class PackagesRegistry:
         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}"
@@ -427,4 +190,18 @@ class PackagesRegistry:
 
 
 packages_registry = PackagesRegistry(installed_packages=None)
-register_config = packages_registry.register_config
+
+
+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-0.26.0.dist-info → plain-0.27.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain
-Version: 0.26.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.26.0.dist-info → plain-0.27.0.dist-info}/RECORD

@@ -62,7 +62,7 @@ plain/logs/utils.py,sha256=9UzdCCQXJinGDs71Ngw297mlWkhgZStSd67ya4NOW98,1257
 plain/packages/README.md,sha256=Vq1Nw3mmEmZ2IriQavuVi4BjcQC2nb8k7YIbnm8QjIg,799
 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/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
@@ -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.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,,
+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,,