plain 0.28.0__tar.gz → 0.30.0__tar.gz

{plain-0.28.0 → plain-0.30.0}/PKG-INFO

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

{plain-0.28.0 → plain-0.30.0}/plain/__main__.py

@@ -1,4 +1,4 @@
-from .cli import cli
+from .cli.core import cli
 
 # Make the CLI available as `python -m plain`
 if __name__ == "__main__":

{plain-0.28.0 → plain-0.30.0}/plain/assets/urls.py

@@ -1,12 +1,11 @@
 from plain.runtime import settings
-from plain.urls import RouterBase, path, register_router, reverse
+from plain.urls import Router, path, reverse
 
 from .fingerprints import get_fingerprinted_url_path
 from .views import AssetView
 
 
-@register_router
-class Router(RouterBase):
+class AssetsRouter(Router):
     namespace = "assets"
     urls = [
         path("<path:path>", AssetView, name="asset"),
@@ -29,4 +28,4 @@ def get_asset_url(url_path):
     if settings.ASSETS_BASE_URL:
         return settings.ASSETS_BASE_URL + resolved_url_path
 
-    return reverse(Router.namespace + ":asset", path=resolved_url_path)
+    return reverse(AssetsRouter.namespace + ":asset", path=resolved_url_path)

{plain-0.28.0 → plain-0.30.0}/plain/assets/views.py

@@ -206,9 +206,9 @@ class AssetView(View):
             # or we're already looking at it.
             return
 
-        from .urls import Router
+        from .urls import AssetsRouter
 
-        namespace = Router.namespace
+        namespace = AssetsRouter.namespace
 
         return ResponseRedirect(
             redirect_to=reverse(f"{namespace}:asset", fingerprinted_url_path),

{plain-0.28.0 → plain-0.30.0}/plain/cli/README.md

@@ -99,19 +99,3 @@ then any commands you defined.
 $ plain <pkg> hello
 Hello, world!
 ```
-
-### Add CLI commands to published packages
-
-Some packages, like [plain-dev](https://plainframework.com/docs/plain-dev/),
-never show up in `INSTALLED_PACKAGES` but still have CLI commands.
-These are detected via Python entry points.
-
-An example with `pyproject.toml` and UV:
-
-```toml
-# pyproject.toml
-[project.entry-points."plain.cli"]
-"dev" = "plain.dev:cli"
-"pre-commit" = "plain.dev.precommit:cli"
-"contrib" = "plain.dev.contribute:cli"
-```

plain-0.30.0/plain/cli/__init__.py

@@ -0,0 +1,3 @@
+from .registry import register_cli
+
+__all__ = ["register_cli"]

plain-0.28.0/plain/cli/cli.py → plain-0.30.0/plain/cli/core.py

@@ -1,4 +1,3 @@
-import importlib
 import os
 import shutil
 import subprocess
@@ -6,7 +5,6 @@ import sys
 import tomllib
 import traceback
 from importlib.metadata import entry_points
-from importlib.util import find_spec
 from pathlib import Path
 
 import click
@@ -20,7 +18,7 @@ from plain.packages import packages_registry
 from plain.utils.crypto import get_random_string
 
 from .formatting import PlainContext
-from .packages import EntryPointGroup, InstalledPackagesGroup
+from .registry import cli_registry
 
 
 @click.group()
@@ -381,10 +379,10 @@ def create(package_name):
     # Create a urls.py file with a default namespace
     if not (package_dir / "urls.py").exists():
         (package_dir / "urls.py").write_text(
-            f"""from plain.urls import path, RouterBase, register_router
+            f"""from plain.urls import path, Router
 
-@register_router
-class Router(RouterBase):
+
+class {package_name.capitalize()}Router(Router):
     namespace = f"{package_name}"
     urls = [
         # path("", views.IndexView, name="index"),
@@ -424,10 +422,15 @@ def generate_secret_key():
 @plain_cli.command()
 @click.option("--flat", is_flag=True, help="List all URLs in a flat list")
 def urls(flat):
-    """Print all URL patterns under settings.URLS_MODULE"""
+    """Print all URL patterns under settings.URLS_ROUTER"""
+    from plain.runtime import settings
     from plain.urls import URLResolver, get_resolver
 
-    resolver = get_resolver()
+    if not settings.URLS_ROUTER:
+        click.secho("URLS_ROUTER is not set", fg="red")
+        sys.exit(1)
+
+    resolver = get_resolver(settings.URLS_ROUTER)
     if flat:
 
         def flat_list(patterns, prefix="", curr_ns=""):
@@ -500,25 +503,21 @@ def urls(flat):
         print_tree(resolver.url_patterns)
 
 
-class AppCLIGroup(click.Group):
+class CLIRegistryGroup(click.Group):
     """
-    Loads app.cli if it exists as `plain app`
+    Click Group that exposes commands from the CLI registry.
     """
 
-    MODULE_NAME = "app.cli"
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        cli_registry.import_modules()
 
     def list_commands(self, ctx):
-        if find_spec(self.MODULE_NAME):
-            return ["app"]
-        else:
-            return []
+        return sorted(cli_registry.get_commands().keys())
 
     def get_command(self, ctx, name):
-        if name != "app":
-            return
-
-        cli = importlib.import_module(self.MODULE_NAME)
-        return cli.cli
+        commands = cli_registry.get_commands()
+        return commands.get(name)
 
 
 class PlainCommandCollection(click.CommandCollection):
@@ -531,9 +530,7 @@ class PlainCommandCollection(click.CommandCollection):
             plain.runtime.setup()
 
             sources = [
-                InstalledPackagesGroup(),
-                EntryPointGroup(),
-                AppCLIGroup(),
+                CLIRegistryGroup(),
                 plain_cli,
             ]
         except plain.runtime.AppPathNotFound:
@@ -545,7 +542,6 @@ class PlainCommandCollection(click.CommandCollection):
             )
 
             sources = [
-                EntryPointGroup(),
                 plain_cli,
             ]
         except ImproperlyConfigured as e:

plain-0.30.0/plain/cli/registry.py

@@ -0,0 +1,62 @@
+from importlib import import_module
+from importlib.util import find_spec
+
+from plain.packages import packages_registry
+
+
+class CLIRegistry:
+    def __init__(self):
+        self._commands = {}
+
+    def register_command(self, cmd, name):
+        """
+        Register a CLI command or group with the specified name.
+        """
+        self._commands[name] = cmd
+
+    def import_modules(self):
+        """
+        Import modules from installed packages and app to trigger registration.
+        """
+        # Import from installed packages
+        for package_config in packages_registry.get_package_configs():
+            import_name = f"{package_config.name}.cli"
+            try:
+                import_module(import_name)
+            except ModuleNotFoundError:
+                pass
+
+        # Import from app
+        import_name = "app.cli"
+        if find_spec(import_name):
+            try:
+                import_module(import_name)
+            except ModuleNotFoundError:
+                pass
+
+    def get_commands(self):
+        """
+        Get all registered commands.
+        """
+        return self._commands
+
+
+cli_registry = CLIRegistry()
+
+
+def register_cli(name):
+    """
+    Register a CLI command or group with the given name.
+
+    Usage:
+        @register_cli("users")
+        @click.group()
+        def users_cli():
+            pass
+    """
+
+    def wrapper(cmd):
+        cli_registry.register_command(cmd, name)
+        return cmd
+
+    return wrapper

{plain-0.28.0 → plain-0.30.0}/plain/packages/config.py

@@ -10,8 +10,6 @@ CONFIG_MODULE_NAME = "config"
 class PackageConfig:
     """Class representing a Plain application and its configuration."""
 
-    migrations_module = "migrations"
-
     def __init__(self, name, *, label=""):
         # Full Python path to the application e.g. 'plain.admin.admin'.
         self.name = name

{plain-0.28.0 → plain-0.30.0}/plain/preflight/urls.py

@@ -7,11 +7,12 @@ from . import Error, Warning, register
 
 @register
 def check_url_config(package_configs, **kwargs):
-    if getattr(settings, "URLS_MODULE", None):
+    if getattr(settings, "URLS_ROUTER", None):
         from plain.urls import get_resolver
 
         resolver = get_resolver()
         return check_resolver(resolver)
+
     return []
 
 
@@ -33,7 +34,7 @@ def check_url_namespaces_unique(package_configs, **kwargs):
     """
     Warn if URL namespaces used in applications aren't unique.
     """
-    if not getattr(settings, "URLS_MODULE", None):
+    if not getattr(settings, "URLS_ROUTER", None):
         return []
 
     from plain.urls import get_resolver

{plain-0.28.0 → plain-0.30.0}/plain/runtime/global_settings.py

@@ -74,7 +74,7 @@ SECRET_KEY: str
 # secret key rotation.
 SECRET_KEY_FALLBACKS: list[str] = []
 
-URLS_MODULE = "app.urls"
+URLS_ROUTER: str
 
 # List of upload handler classes to be applied in order.
 FILE_UPLOAD_HANDLERS = [

{plain-0.28.0 → plain-0.30.0}/plain/urls/__init__.py

@@ -6,7 +6,7 @@ from .resolvers import (
     URLResolver,
     get_resolver,
 )
-from .routers import RouterBase, include, path, register_router
+from .routers import Router, include, path
 from .utils import (
     reverse,
     reverse_lazy,
@@ -24,6 +24,5 @@ __all__ = [
     "register_converter",
     "reverse",
     "reverse_lazy",
-    "RouterBase",
-    "register_router",
+    "Router",
 ]

{plain-0.28.0 → plain-0.30.0}/plain/urls/resolvers.py

@@ -8,7 +8,6 @@ attributes of the resolved URL match.
 
 import functools
 import re
-from importlib import import_module
 from pickle import PicklingError
 from threading import local
 from urllib.parse import quote
@@ -17,6 +16,7 @@ from plain.preflight.urls import check_resolver
 from plain.runtime import settings
 from plain.utils.datastructures import MultiValueDict
 from plain.utils.http import RFC3986_SUBDELIMS, escape_leading_slashes
+from plain.utils.module_loading import import_string
 from plain.utils.regex_helper import normalize
 
 from .exceptions import NoReverseMatch, Resolver404
@@ -87,30 +87,26 @@ class ResolverMatch:
         raise PicklingError(f"Cannot pickle {self.__class__.__qualname__}.")
 
 
-def get_resolver(urls_module=None):
-    if urls_module is None:
-        urls_module = settings.URLS_MODULE
+def get_resolver(router=None):
+    if router is None:
+        router = settings.URLS_ROUTER
 
-    return _get_cached_resolver(urls_module)
+    return _get_cached_resolver(router)
 
 
 @functools.cache
-def _get_cached_resolver(urls_module):
-    from .routers import routers_registry
+def _get_cached_resolver(router):
+    if isinstance(router, str):
+        # Do this inside the cached call, primarily for the URLS_ROUTER
+        router_class = import_string(router)
+        router = router_class()
 
-    if isinstance(urls_module, str):
-        # Need to trigger an import in order for the @register_router
-        # decorators to run. So this is a sensible entrypoint to do that,
-        # usually just for the root URLS_MODULE but could be for anything.
-        urls_module = import_module(urls_module)
-
-    router = routers_registry.get_module_router(urls_module)
     return URLResolver(pattern=RegexPattern(r"^/"), router=router)
 
 
 @functools.cache
 def get_ns_resolver(ns_pattern, resolver, converters):
-    from .routers import RouterBase
+    from .routers import Router
 
     # Build a namespaced resolver for the given parent urls_module pattern.
     # This makes it possible to have captured parameters in the parent
@@ -118,13 +114,13 @@ def get_ns_resolver(ns_pattern, resolver, converters):
     pattern = RegexPattern(ns_pattern)
     pattern.converters = dict(converters)
 
-    class _NestedRouter(RouterBase):
+    class _NestedRouter(Router):
         namespace = ""
         urls = resolver.url_patterns
 
     ns_resolver = URLResolver(pattern=pattern, router=_NestedRouter())
 
-    class _NamespacedRouter(RouterBase):
+    class _NamespacedRouter(Router):
         namespace = ""
         urls = [ns_resolver]
 

{plain-0.28.0 → plain-0.30.0}/plain/urls/routers.py

@@ -1,9 +1,6 @@
 import re
-from types import ModuleType
 from typing import TYPE_CHECKING
 
-from plain.exceptions import ImproperlyConfigured
-
 from .patterns import RegexPattern, RoutePattern, URLPattern
 from .resolvers import (
     URLResolver,
@@ -13,7 +10,7 @@ if TYPE_CHECKING:
     from plain.views import View
 
 
-class RouterBase:
+class Router:
     """
     Base class for defining url patterns.
 
@@ -25,37 +22,8 @@ class RouterBase:
     urls: list
 
 
-class RoutersRegistry:
-    """Keep track of all the Routers that are explicitly registered in packages."""
-
-    def __init__(self):
-        self._routers = {}
-
-    def register_router(self, router_class):
-        router = (
-            router_class()
-        )  # Don't necessarily need to instantiate it yet, but will likely add methods.
-        router_module_name = router_class.__module__
-        self._routers[router_module_name] = router
-        return router
-
-    def get_module_router(self, module):
-        if isinstance(module, str):
-            module_name = module
-        else:
-            module_name = module.__name__
-
-        try:
-            return self._routers[module_name]
-        except KeyError as e:
-            registered_routers = ", ".join(self._routers.keys()) or "None"
-            raise ImproperlyConfigured(
-                f"Router {module_name} is not registered with the resolver. Use @register_router on the Router class in urls.py.\n\nRegistered routers: {registered_routers}"
-            ) from e
-
-
 def include(
-    route: str | re.Pattern, module_or_urls: list | tuple | str | ModuleType
+    route: str | re.Pattern, router_or_urls: list | tuple | str | Router
 ) -> URLResolver:
     """
     Include URLs from another module or a nested list of URL patterns.
@@ -67,23 +35,26 @@ def include(
     else:
         raise TypeError("include() route must be a string or regex")
 
-    if isinstance(module_or_urls, list | tuple):
+    if isinstance(router_or_urls, list | tuple):
         # We were given an explicit list of sub-patterns,
         # so we generate a router for it
-        class _IncludeRouter(RouterBase):
+        class _IncludeRouter(Router):
             namespace = ""
-            urls = module_or_urls
+            urls = router_or_urls
 
         return URLResolver(pattern=pattern, router=_IncludeRouter())
-    else:
-        # We were given a module, so we need to look up the router for that module
-        module = module_or_urls
-        router = routers_registry.get_module_router(module)
+    elif isinstance(router_or_urls, type) and issubclass(router_or_urls, Router):
+        router_class = router_or_urls
+        router = router_class()
 
         return URLResolver(
             pattern=pattern,
             router=router,
         )
+    else:
+        raise TypeError(
+            f"include() urls must be a list, tuple, or Router class (not a Router() instance): {router_or_urls}"
+        )
 
 
 def path(route: str | re.Pattern, view: "View", *, name: str = "") -> URLPattern:
@@ -116,12 +87,3 @@ def path(route: str | re.Pattern, view: "View", *, name: str = "") -> URLPattern
         return URLPattern(pattern=pattern, view=view, name=name)
 
     raise TypeError("view must be a View class or View.as_view()")
-
-
-routers_registry = RoutersRegistry()
-
-
-def register_router(router_class):
-    """Decorator to register a router class"""
-    routers_registry.register_router(router_class)
-    return router_class  # Return the class, not the instance

{plain-0.28.0 → plain-0.30.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plain"
-version = "0.28.0"
+version = "0.30.0"
 description = "A web framework for building products with Python."
 authors = [{name = "Dave Gaeddert", email = "dave.gaeddert@dropseed.dev"}]
 readme = "README.md"
@@ -11,7 +11,7 @@ dependencies = [
 requires-python = ">=3.11"
 
 [project.scripts]
-plain = "plain.cli:cli"
+plain = "plain.cli.core:cli"
 
 [tool.uv]
 dev-dependencies = [

{plain-0.28.0 → plain-0.30.0}/tests/app/settings.py

@@ -1,6 +1,8 @@
 SECRET_KEY = "secret"
 DEBUG = True
 
+URLS_ROUTER = "app.urls.AppRouter"
+
 INSTALLED_PACKAGES = [
     "app.test",
 ]

{plain-0.28.0 → plain-0.30.0}/tests/app/urls.py

@@ -1,4 +1,4 @@
-from plain.urls import RouterBase, path, register_router
+from plain.urls import Router, path
 from plain.views import View
 
 
@@ -7,8 +7,7 @@ class TestView(View):
         return "Hello, world!"
 
 
-@register_router
-class Router(RouterBase):
+class AppRouter(Router):
     namespace = ""
     urls = [
         path("", TestView),

plain-0.28.0/plain/cli/__init__.py

@@ -1,3 +0,0 @@
-from .cli import cli
-
-__all__ = ["cli"]

plain-0.28.0/plain/cli/packages.py

@@ -1,94 +0,0 @@
-import importlib
-from importlib.metadata import entry_points
-from importlib.util import find_spec
-
-import click
-
-from plain.packages import packages_registry
-
-
-class InstalledPackagesGroup(click.Group):
-    """
-    Packages in INSTALLED_PACKAGES with a cli.py module
-    will be discovered automatically.
-    """
-
-    PLAIN_APPS_PREFIX = "plain."
-    APP_PREFIX = "app."
-    MODULE_NAME = "cli"
-
-    def list_commands(self, ctx):
-        command_names = []
-
-        # Get installed packages with a cli.py module
-        for app in packages_registry.get_package_configs():
-            if not find_spec(f"{app.name}.{self.MODULE_NAME}"):
-                continue
-
-            cli_name = app.name
-
-            # Change plain.{pkg} to just {pkg}
-            if cli_name.startswith(self.PLAIN_APPS_PREFIX):
-                cli_name = cli_name[len(self.PLAIN_APPS_PREFIX) :]
-
-            # Change app.{pkg} to just {pkg}
-            if cli_name.startswith(self.APP_PREFIX):
-                cli_name = cli_name[len(self.APP_PREFIX) :]
-
-            if cli_name in command_names:
-                raise ValueError(
-                    f"Duplicate command name {cli_name} found in installed packages."
-                )
-
-            command_names.append(cli_name)
-
-        return command_names
-
-    def get_command(self, ctx, name):
-        # Try it as plain.x, app.x, and just x (we don't know ahead of time which it is)
-        for n in [self.PLAIN_APPS_PREFIX + name, self.APP_PREFIX + name, name]:
-            try:
-                if not find_spec(n):
-                    # plain.<name> doesn't exist at all
-                    continue
-            except ModuleNotFoundError:
-                continue
-
-            try:
-                if not find_spec(f"{n}.{self.MODULE_NAME}"):
-                    continue
-            except ModuleNotFoundError:
-                continue
-
-            cli = importlib.import_module(f"{n}.{self.MODULE_NAME}")
-
-            # Get the app's cli.py group
-            try:
-                return cli.cli
-            except AttributeError:
-                continue
-
-
-class EntryPointGroup(click.Group):
-    """
-    Python packages can be added to the Plain CLI
-    via the plain_cli entrypoint in their setup.py.
-
-    This is intended for packages that don't go in INSTALLED_PACKAGES.
-    """
-
-    ENTRYPOINT_NAME = "plain.cli"
-
-    def list_commands(self, ctx):
-        rv = []
-
-        for entry_point in entry_points().select(group=self.ENTRYPOINT_NAME):
-            rv.append(entry_point.name)
-
-        rv.sort()
-        return rv
-
-    def get_command(self, ctx, name):
-        for entry_point in entry_points().select(group=self.ENTRYPOINT_NAME):
-            if entry_point.name == name:
-                return entry_point.load()