plain 0.21.5__tar.gz → 0.22.1__tar.gz

{plain-0.21.5 → plain-0.22.1}/.gitignore

@@ -6,9 +6,6 @@ __pycache__
 *.DS_Store
 .coverage
 
-# Build files from publish
-plain*/dist/
-
 # Test apps
 plain*/tests/.plain
 

{plain-0.21.5 → plain-0.22.1}/PKG-INFO

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

{plain-0.21.5 → plain-0.22.1}/plain/assets/urls.py

@@ -1,10 +1,16 @@
 from plain.runtime import settings
-from plain.urls import path, reverse
+from plain.urls import RouterBase, path, register_router, reverse
 
 from .fingerprints import get_fingerprinted_url_path
 from .views import AssetView
 
-default_namespace = "assets"
+
+@register_router
+class Router(RouterBase):
+    namespace = "assets"
+    urls = [
+        path("<path:path>", AssetView, name="asset"),
+    ]
 
 
 def get_asset_url(url_path):
@@ -23,9 +29,4 @@ def get_asset_url(url_path):
     if settings.ASSETS_BASE_URL:
         return settings.ASSETS_BASE_URL + resolved_url_path
 
-    return reverse(default_namespace + ":asset", kwargs={"path": resolved_url_path})
-
-
-urlpatterns = [
-    path("<path:path>", AssetView, name="asset"),
-]
+    return reverse(Router.namespace + ":asset", path=resolved_url_path)

{plain-0.21.5 → plain-0.22.1}/plain/assets/views.py

@@ -206,12 +206,12 @@ class AssetView(View):
             # or we're already looking at it.
             return
 
-        from .urls import default_namespace
+        from .urls import Router
+
+        namespace = Router.namespace
 
         return ResponseRedirect(
-            redirect_to=reverse(
-                f"{default_namespace}:asset", args=[fingerprinted_url_path]
-            ),
+            redirect_to=reverse(f"{namespace}:asset", fingerprinted_url_path),
             headers={
                 "Cache-Control": "max-age=60",  # Can cache this for a short time, but the fingerprinted path can change
             },

{plain-0.21.5 → plain-0.22.1}/plain/cli/cli.py

@@ -346,6 +346,9 @@ def compile(keep_original, fingerprint, compress):
         f"\nCompiled {total_files} assets into {total_compiled} files", fg="green"
     )
 
+    # TODO could do a jinja pre-compile here too?
+    # environment.compile_templates() but it needs a target, ignore_errors=False
+
 
 @plain_cli.command()
 @click.argument("package_name")
@@ -378,13 +381,14 @@ 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
-
-default_namespace = f"{package_name}"
-
-urlpatterns = [
-    # path("", views.IndexView, name="index"),
-]
+            f"""from plain.urls import path, RouterBase, register_router
+
+@register_router
+class Router(RouterBase):
+    namespace = f"{package_name}"
+    urls = [
+        # path("", views.IndexView, name="index"),
+    ]
 """
         )
 
@@ -417,6 +421,85 @@ def generate_secret_key():
     click.echo(new_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"""
+    from plain.urls import URLResolver, get_resolver
+
+    resolver = get_resolver()
+    if flat:
+
+        def flat_list(patterns, prefix="", curr_ns=""):
+            for pattern in patterns:
+                full_pattern = f"{prefix}{pattern.pattern}"
+                if isinstance(pattern, URLResolver):
+                    # Update current namespace
+                    new_ns = (
+                        f"{curr_ns}:{pattern.namespace}"
+                        if curr_ns and pattern.namespace
+                        else (pattern.namespace or curr_ns)
+                    )
+                    yield from flat_list(
+                        pattern.url_patterns, prefix=full_pattern, curr_ns=new_ns
+                    )
+                else:
+                    if pattern.name:
+                        if curr_ns:
+                            styled_namespace = click.style(f"{curr_ns}:", fg="yellow")
+                            styled_name = click.style(pattern.name, fg="blue")
+                            full_name = f"{styled_namespace}{styled_name}"
+                        else:
+                            full_name = click.style(pattern.name, fg="blue")
+                        name_part = f" [{full_name}]"
+                    else:
+                        name_part = ""
+                    yield f"{click.style(full_pattern)}{name_part}"
+
+        for p in flat_list(resolver.url_patterns):
+            click.echo(p)
+    else:
+
+        def print_tree(patterns, prefix="", curr_ns=""):
+            count = len(patterns)
+            for idx, pattern in enumerate(patterns):
+                is_last = idx == (count - 1)
+                connector = "└── " if is_last else "├── "
+                styled_connector = click.style(connector)
+                styled_pattern = click.style(pattern.pattern)
+                if isinstance(pattern, URLResolver):
+                    if pattern.namespace:
+                        new_ns = (
+                            f"{curr_ns}:{pattern.namespace}"
+                            if curr_ns
+                            else pattern.namespace
+                        )
+                        styled_namespace = click.style(f"[{new_ns}]", fg="yellow")
+                        click.echo(
+                            f"{prefix}{styled_connector}{styled_pattern} {styled_namespace}"
+                        )
+                    else:
+                        new_ns = curr_ns
+                        click.echo(f"{prefix}{styled_connector}{styled_pattern}")
+                    extension = "    " if is_last else "│   "
+                    print_tree(pattern.url_patterns, prefix + extension, new_ns)
+                else:
+                    if pattern.name:
+                        if curr_ns:
+                            styled_namespace = click.style(f"{curr_ns}:", fg="yellow")
+                            styled_name = click.style(pattern.name, fg="blue")
+                            full_name = f"[{styled_namespace}{styled_name}]"
+                        else:
+                            full_name = click.style(f"[{pattern.name}]", fg="blue")
+                        click.echo(
+                            f"{prefix}{styled_connector}{styled_pattern} {full_name}"
+                        )
+                    else:
+                        click.echo(f"{prefix}{styled_connector}{styled_pattern}")
+
+        print_tree(resolver.url_patterns)
+
+
 class AppCLIGroup(click.Group):
     """
     Loads app.cli if it exists as `plain app`

{plain-0.21.5 → plain-0.22.1}/plain/http/request.py

@@ -328,8 +328,7 @@ class HttpRequest:
         self.upload_handlers = ImmutableList(
             self.upload_handlers,
             warning=(
-                "You cannot alter upload handlers after the upload has been "
-                "processed."
+                "You cannot alter upload handlers after the upload has been processed."
             ),
         )
         parser = MultiPartParser(META, post_data, self.upload_handlers, self.encoding)

{plain-0.21.5 → plain-0.22.1}/plain/internal/handlers/base.py

@@ -4,8 +4,7 @@ import types
 from plain.exceptions import ImproperlyConfigured
 from plain.logs import log_response
 from plain.runtime import settings
-from plain.signals import request_finished
-from plain.urls import get_resolver, set_urlconf
+from plain.urls import get_resolver
 from plain.utils.module_loading import import_string
 
 from .exception import convert_exception_to_response
@@ -61,7 +60,6 @@ class BaseHandler:
     def get_response(self, request):
         """Return a Response object for the given HttpRequest."""
         # Setup default url resolver for this thread
-        set_urlconf(settings.ROOT_URLCONF)
         response = self._middleware_chain(request)
         response._resource_closers.append(request.close)
         if response.status_code >= 400:
@@ -80,27 +78,23 @@ class BaseHandler:
         template_response middleware. This method is everything that happens
         inside the request/response middleware.
         """
-        callback, callback_args, callback_kwargs = self.resolve_request(request)
+        resolver_match = self.resolve_request(request)
 
-        response = callback(request, *callback_args, **callback_kwargs)
+        response = resolver_match.func(
+            request, *resolver_match.args, **resolver_match.kwargs
+        )
 
         # Complain if the view returned None (a common error).
-        self.check_response(response, callback)
+        self.check_response(response, resolver_match.func)
 
         return response
 
     def resolve_request(self, request):
         """
-        Retrieve/set the urlconf for the request. Return the view resolved,
+        Retrieve/set the urlrouter for the request. Return the view resolved,
         with its args and kwargs.
         """
-        # Work out the resolver.
-        if hasattr(request, "urlconf"):
-            urlconf = request.urlconf
-            set_urlconf(urlconf)
-            resolver = get_resolver(urlconf)
-        else:
-            resolver = get_resolver()
+        resolver = get_resolver()
         # Resolve the view, and assign the match object back to the request.
         resolver_match = resolver.resolve(request.path_info)
         request.resolver_match = resolver_match
@@ -117,13 +111,5 @@ class BaseHandler:
                 name = f"The view {callback.__module__}.{callback.__class__.__name__}.__call__"
         if response is None:
             raise ValueError(
-                f"{name} didn't return a Response object. It returned None " "instead."
+                f"{name} didn't return a Response object. It returned None instead."
             )
-
-
-def reset_urlconf(sender, **kwargs):
-    """Reset the URLconf after each request is finished."""
-    set_urlconf(None)
-
-
-request_finished.connect(reset_urlconf)

{plain-0.21.5 → plain-0.22.1}/plain/internal/handlers/exception.py

@@ -127,6 +127,8 @@ def handle_uncaught_exception():
     Processing for any otherwise uncaught exceptions (those that will
     generate HTTP 500 responses).
     """
+    if settings.DEBUG:
+        raise
     return ResponseServerError()
 
 

{plain-0.21.5 → plain-0.22.1}/plain/internal/middleware/slash.py

@@ -1,6 +1,6 @@
 from plain.http import ResponsePermanentRedirect
 from plain.runtime import settings
-from plain.urls import is_valid_path
+from plain.urls import Resolver404, get_resolver
 from plain.utils.http import escape_leading_slashes
 
 
@@ -26,18 +26,26 @@ class RedirectSlashMiddleware:
 
         return response
 
+    @staticmethod
+    def _is_valid_path(path):
+        """
+        Return the ResolverMatch if the given path resolves against the default URL
+        resolver, False otherwise. This is a convenience method to make working
+        with "is this a match?" cases easier, avoiding try...except blocks.
+        """
+        try:
+            return get_resolver().resolve(path)
+        except Resolver404:
+            return False
+
     def should_redirect_with_slash(self, request):
         """
         Return True if settings.APPEND_SLASH is True and appending a slash to
         the request path turns an invalid path into a valid one.
         """
         if settings.APPEND_SLASH and not request.path_info.endswith("/"):
-            urlconf = getattr(request, "urlconf", None)
-            if not is_valid_path(request.path_info, urlconf):
-                match = is_valid_path(f"{request.path_info}/", urlconf)
-                if match:
-                    view = match.func
-                    return getattr(view, "should_append_slash", True)
+            if not self._is_valid_path(request.path_info):
+                return self._is_valid_path(f"{request.path_info}/")
         return False
 
     def get_full_path_with_slash(self, request):

{plain-0.21.5 → plain-0.22.1}/plain/packages/registry.py

@@ -24,8 +24,8 @@ class Packages:
         if installed_packages is None and hasattr(sys.modules[__name__], "packages"):
             raise RuntimeError("You must supply an installed_packages argument.")
 
-        # Mapping of app labels => model names => model classes. Every time a
-        # model is imported, ModelBase.__new__ calls packages.register_model which
+        # 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
@@ -36,10 +36,6 @@ class Packages:
         # Mapping of labels to PackageConfig instances for installed packages.
         self.package_configs = {}
 
-        # Stack of package_configs. Used to store the current state in
-        # set_available_packages and set_installed_packages.
-        self.stored_package_configs = []
-
         # Whether the registry is populated.
         self.packages_ready = self.models_ready = self.ready = False
 
@@ -103,7 +99,7 @@ class Packages:
             duplicates = [name for name, count in counts.most_common() if count > 1]
             if duplicates:
                 raise ImproperlyConfigured(
-                    "Package names aren't unique, " "duplicates: {}".format(
+                    "Package names aren't unique, duplicates: {}".format(
                         ", ".join(duplicates)
                     )
                 )
@@ -238,15 +234,6 @@ class Packages:
         self.do_pending_operations(model)
         self.clear_cache()
 
-    def is_installed(self, package_name):
-        """
-        Check whether an application with this name exists in the registry.
-
-        package_name is the full name of the app e.g. 'plain.admin'.
-        """
-        self.check_packages_ready()
-        return any(ac.name == package_name for ac in self.package_configs.values())
-
     def get_containing_package_config(self, object_name):
         """
         Look for an app config containing a given object.
@@ -302,67 +289,6 @@ class Packages:
                 return model._meta.swappable
         return None
 
-    def set_available_packages(self, available):
-        """
-        Restrict the set of installed packages used by get_package_config[s].
-
-        available must be an iterable of application names.
-
-        set_available_packages() must be balanced with unset_available_packages().
-
-        Primarily used for performance optimization in TransactionTestCase.
-
-        This method is safe in the sense that it doesn't trigger any imports.
-        """
-        available = set(available)
-        installed = {
-            package_config.name for package_config in self.get_package_configs()
-        }
-        if not available.issubset(installed):
-            raise ValueError(
-                "Available packages isn't a subset of installed packages, extra packages: {}".format(
-                    ", ".join(available - installed)
-                )
-            )
-
-        self.stored_package_configs.append(self.package_configs)
-        self.package_configs = {
-            label: package_config
-            for label, package_config in self.package_configs.items()
-            if package_config.name in available
-        }
-        self.clear_cache()
-
-    def unset_available_packages(self):
-        """Cancel a previous call to set_available_packages()."""
-        self.package_configs = self.stored_package_configs.pop()
-        self.clear_cache()
-
-    def set_installed_packages(self, installed):
-        """
-        Enable a different set of installed packages for get_package_config[s].
-
-        installed must be an iterable in the same format as INSTALLED_PACKAGES.
-
-        set_installed_packages() must be balanced with unset_installed_packages(),
-        even if it exits with an exception.
-
-        Primarily used as a receiver of the setting_changed signal in tests.
-
-        This method may trigger new imports, which may add new models to the
-        registry of all imported models. They will stay in the registry even
-        after unset_installed_packages(). Since it isn't possible to replay
-        imports safely (e.g. that could lead to registering listeners twice),
-        models are registered when they're imported and never removed.
-        """
-        if not self.ready:
-            raise PackageRegistryNotReady("Package registry isn't ready yet.")
-        self.stored_package_configs.append(self.package_configs)
-        self.package_configs = {}
-        self.packages_ready = self.models_ready = self.loading = self.ready = False
-        self.clear_cache()
-        self.populate(installed)
-
     def clear_cache(self):
         """
         Clear all internal caches, for methods that alter the app registry.

{plain-0.21.5 → plain-0.22.1}/plain/preflight/urls.py

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

{plain-0.21.5 → plain-0.22.1}/plain/runtime/global_settings.py

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

{plain-0.21.5 → plain-0.22.1}/plain/templates/jinja/globals.py

@@ -1,14 +1,8 @@
 from plain.paginator import Paginator
+from plain.urls import reverse
 from plain.utils import timezone
 
 
-def url(viewname, *args, **kwargs):
-    # A modified reverse that lets you pass args directly, excluding urlconf
-    from plain.urls import reverse
-
-    return reverse(viewname, args=args, kwargs=kwargs)
-
-
 def asset(url_path):
     # An explicit callable we can control, but also delay the import of asset.urls->views->templates
     # for circular import reasons
@@ -19,7 +13,7 @@ def asset(url_path):
 
 default_globals = {
     "asset": asset,
-    "url": url,
+    "url": reverse,
     "Paginator": Paginator,
     "now": timezone.now,
     "localtime": timezone.localtime,

{plain-0.21.5 → plain-0.22.1}/plain/test/client.py

@@ -15,7 +15,7 @@ from plain.internal.handlers.wsgi import WSGIRequest
 from plain.json import PlainJSONEncoder
 from plain.runtime import settings
 from plain.signals import got_request_exception, request_started
-from plain.urls import resolve
+from plain.urls import get_resolver
 from plain.utils.encoding import force_bytes
 from plain.utils.functional import SimpleLazyObject
 from plain.utils.http import urlencode
@@ -107,9 +107,9 @@ class FakePayload(IOBase):
             self.read_started = True
         if size == -1 or size is None:
             size = self.__len
-        assert (
-            self.__len >= size
-        ), "Cannot read more than the available bytes from the HTTP incoming data."
+        assert self.__len >= size, (
+            "Cannot read more than the available bytes from the HTTP incoming data."
+        )
         content = self.__content.read(size)
         self.__len -= len(content)
         return content
@@ -120,9 +120,9 @@ class FakePayload(IOBase):
             self.read_started = True
         if size == -1 or size is None:
             size = self.__len
-        assert (
-            self.__len >= size
-        ), "Cannot read more than the available bytes from the HTTP incoming data."
+        assert self.__len >= size, (
+            "Cannot read more than the available bytes from the HTTP incoming data."
+        )
         content = self.__content.readline(size)
         self.__len -= len(content)
         return content
@@ -298,7 +298,7 @@ class RequestFactory:
     post_request = rf.post('/submit/', {'foo': 'bar'})
 
     Once you have a request object you can pass it to any view function,
-    just as if that view had been hooked up using a URLconf.
+    just as if that view had been hooked up using a urlrouter.
     """
 
     def __init__(self, *, json_encoder=PlainJSONEncoder, headers=None, **defaults):
@@ -690,9 +690,9 @@ class Client(ClientMixin, RequestFactory):
             response.user = response.wsgi_request.user
 
         # Attach the ResolverMatch instance to the response.
-        urlconf = getattr(response.wsgi_request, "urlconf", None)
+        resolver = get_resolver()
         response.resolver_match = SimpleLazyObject(
-            lambda: resolve(request["PATH_INFO"], urlconf=urlconf),
+            lambda: resolver.resolve(request["PATH_INFO"]),
         )
 
         # Update persistent cookie data.

{plain-0.21.5 → plain-0.22.1}/plain/urls/__init__.py

@@ -1,22 +1,16 @@
-from .base import (
-    clear_url_caches,
-    get_urlconf,
-    is_valid_path,
-    resolve,
-    reverse,
-    reverse_lazy,
-    set_urlconf,
-)
-from .conf import include, path, re_path
 from .converters import register_converter
 from .exceptions import NoReverseMatch, Resolver404
+from .patterns import URLPattern
 from .resolvers import (
     ResolverMatch,
-    URLPattern,
     URLResolver,
-    get_ns_resolver,
     get_resolver,
 )
+from .routers import RouterBase, include, path, register_router
+from .utils import (
+    reverse,
+    reverse_lazy,
+)
 
 __all__ = [
     "NoReverseMatch",
@@ -24,17 +18,12 @@ __all__ = [
     "URLResolver",
     "Resolver404",
     "ResolverMatch",
-    "clear_url_caches",
-    "get_ns_resolver",
     "get_resolver",
-    "get_urlconf",
     "include",
-    "is_valid_path",
     "path",
-    "re_path",
     "register_converter",
-    "resolve",
     "reverse",
     "reverse_lazy",
-    "set_urlconf",
+    "RouterBase",
+    "register_router",
 ]