plain 0.12.1__tar.gz → 0.13.1__tar.gz

{plain-0.12.1 → plain-0.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: plain
-Version: 0.12.1
+Version: 0.13.1
 Summary: A web framework for building products with Python.
 Author: Dave Gaeddert
 Author-email: dave.gaeddert@dropseed.dev

{plain-0.12.1 → plain-0.13.1}/plain/cli/cli.py

@@ -446,8 +446,6 @@ class PlainCommandCollection(click.CommandCollection):
         sources = []
 
         try:
-            # Setup has to run before the installed packages CLI work
-            # and it also does the .env file loading right now...
             plain.runtime.setup()
 
             sources = [
@@ -457,6 +455,7 @@ class PlainCommandCollection(click.CommandCollection):
                 plain_cli,
             ]
         except plain.runtime.AppPathNotFound:
+            # Allow some commands to work regardless of being in a valid app
             click.secho(
                 "Plain `app` directory not found. Some commands may be missing.",
                 fg="yellow",
@@ -468,19 +467,16 @@ class PlainCommandCollection(click.CommandCollection):
                 plain_cli,
             ]
         except ImproperlyConfigured as e:
+            # Show what was configured incorrectly and exit
             click.secho(
                 str(e),
                 fg="red",
                 err=True,
             )
 
-            # None of these require the app to be setup
-            sources = [
-                EntryPointGroup(),
-                AppCLIGroup(),
-                plain_cli,
-            ]
+            exit(1)
         except Exception as e:
+            # Show the exception and exit
             print("---")
             print(traceback.format_exc())
             print("---")
@@ -491,12 +487,7 @@ class PlainCommandCollection(click.CommandCollection):
                 err=True,
             )
 
-            # None of these require the app to be setup
-            sources = [
-                EntryPointGroup(),
-                AppCLIGroup(),
-                plain_cli,
-            ]
+            exit(1)
 
         super().__init__(*args, **kwargs)
 

{plain-0.12.1 → plain-0.13.1}/plain/debug.py

@@ -6,20 +6,22 @@ from plain.http import Response
 from plain.views.exceptions import ResponseException
 
 
-def dd(obj):
+def dd(*objs):
     """
     Dump and die.
 
     Dump the object and raise a ResponseException with the dump as the response content.
     """
-    dump_str = pformat(obj)
+    dump_strs = [
+        Markup("<pre><code>") + escape(pformat(obj)) + Markup("</code></pre>")
+        for obj in objs
+    ]
+    combined_dump_str = Markup("\n\n").join(dump_strs)
 
-    print(f"Dumping object:\n{dump_str}")
+    print(f"Dumping objects:\n{combined_dump_str}")
 
     response = Response()
     response.status_code = 500
-    response.content = (
-        Markup("<pre><code>") + escape(dump_str) + Markup("</code></pre>")
-    )
+    response.content = combined_dump_str
     response.content_type = "text/html"
     raise ResponseException(response)

{plain-0.12.1 → plain-0.13.1}/plain/runtime/global_settings.py

@@ -167,5 +167,4 @@ SILENCED_PREFLIGHT_CHECKS = []
 # Templates #
 #############
 
-JINJA_LOADER = "jinja2.loaders.FileSystemLoader"
-JINJA_ENVIRONMENT = "plain.templates.jinja.defaults.create_default_environment"
+TEMPLATES_JINJA_ENVIRONMENT = "plain.templates.jinja.DefaultEnvironment"

plain-0.13.1/plain/templates/__init__.py

@@ -0,0 +1,17 @@
+from .core import Template, TemplateFileMissing
+from .jinja import (
+    register_template_extension,
+    register_template_filter,
+    register_template_global,
+)
+
+__all__ = [
+    "Template",
+    "TemplateFileMissing",
+    # Technically these are jinja-specific,
+    # but expected to be used pretty frequently so
+    # the shorter import is handy.
+    "register_template_extension",
+    "register_template_filter",
+    "register_template_global",
+]

{plain-0.12.1 → plain-0.13.1}/plain/templates/jinja/README.md

@@ -105,25 +105,11 @@ TODO - example middleware, `|localtime` filter
 
 ## Settings
 
-Most Jinja customization happens in `jinja.py` at the root of your app or in `INSTALLED_PACKAGES`.
+Most Jinja customization happens in `templates.py` at the root of your app or in `INSTALLED_PACKAGES`.
 But if you need to further customize the environment,
-you can define your own callable which will be used to create the Jinja environment.
+you can define your own class via `TEMPLATES_JINJA_ENVIRONMENT`.
 
-```python
-# app/settings.py
-JINJA_ENVIRONMENT = "myjinja.create_environment"
-```
-
-```python
-# app/myjinja.py
-from jinja2 import Environment
-
-
-def create_environment():
-    return Environment(
-        # ...
-    )
-```
+TODO
 
 ## HTML Components
 

plain-0.13.1/plain/templates/jinja/__init__.py

@@ -0,0 +1,88 @@
+from importlib import import_module
+
+from plain.packages import packages
+from plain.runtime import settings
+from plain.utils.functional import LazyObject
+from plain.utils.module_loading import import_string, module_has_submodule
+
+from .environments import DefaultEnvironment, get_template_dirs
+
+
+class JinjaEnvironment(LazyObject):
+    def __init__(self, *args, **kwargs):
+        self.__dict__["_imported_modules"] = set()
+        super().__init__(*args, **kwargs)
+
+    def _setup(self):
+        environment_setting = settings.TEMPLATES_JINJA_ENVIRONMENT
+
+        if isinstance(environment_setting, str):
+            env = import_string(environment_setting)()
+        else:
+            env = environment_setting()
+
+        # 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.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")
+
+
+environment = JinjaEnvironment()
+
+
+def register_template_extension(extension_class):
+    environment.add_extension(extension_class)
+    return extension_class
+
+
+def register_template_global(value, name=None):
+    """
+    Adds a global to the Jinja environment.
+
+    Can be used as a decorator on a function:
+
+            @register_template_global
+            def my_global():
+                return "Hello, world!"
+
+    Or as a function:
+
+            register_template_global("Hello, world!", name="my_global")
+    """
+    if callable(value):
+        environment.globals[name or value.__name__] = value
+    elif name:
+        environment.globals[name] = value
+    else:
+        raise ValueError("name must be provided if value is not callable")
+
+    return value
+
+
+def register_template_filter(func, name=None):
+    """Adds a filter to the Jinja environment."""
+    environment.filters[name or func.__name__] = func
+    return func
+
+
+__all__ = [
+    "environment",
+    "DefaultEnvironment",
+    "get_template_dirs",
+    "register_template_extension",
+    "register_template_filter",
+    "register_template_global",
+]

plain-0.13.1/plain/templates/jinja/environments.py

@@ -0,0 +1,63 @@
+import functools
+from pathlib import Path
+
+from jinja2 import Environment, StrictUndefined
+from jinja2.loaders import FileSystemLoader
+
+from plain.packages import packages
+from plain.runtime import settings
+
+from .filters import default_filters
+from .globals import default_globals
+
+
+def finalize_callable_error(obj):
+    """Prevent direct rendering of a callable (likely just forgotten ()) by raising a TypeError"""
+    if callable(obj):
+        raise TypeError(f"{obj} is callable, did you forget parentheses?")
+
+    # TODO find a way to prevent <object representation> from being rendered
+    # if obj.__class__.__str__ is object.__str__:
+    #     raise TypeError(f"{obj} does not have a __str__ method")
+
+    return obj
+
+
+def get_template_dirs():
+    jinja_templates = Path(__file__).parent / "templates"
+    app_templates = settings.path.parent / "templates"
+    return (jinja_templates, app_templates) + _get_app_template_dirs()
+
+
+@functools.lru_cache
+def _get_app_template_dirs():
+    """
+    Return an iterable of paths of directories to load app templates from.
+
+    dirname is the name of the subdirectory containing templates inside
+    installed applications.
+    """
+    dirname = "templates"
+    template_dirs = [
+        Path(package_config.path) / dirname
+        for package_config in packages.get_package_configs()
+        if package_config.path and (Path(package_config.path) / dirname).is_dir()
+    ]
+    # Immutable return value because it will be cached and shared by callers.
+    return tuple(template_dirs)
+
+
+class DefaultEnvironment(Environment):
+    def __init__(self):
+        super().__init__(
+            loader=FileSystemLoader(get_template_dirs()),
+            autoescape=True,
+            auto_reload=settings.DEBUG,
+            undefined=StrictUndefined,
+            finalize=finalize_callable_error,
+            extensions=["jinja2.ext.loopcontrols", "jinja2.ext.debug"],
+        )
+
+        # Load the top-level defaults
+        self.globals.update(default_globals)
+        self.filters.update(default_filters)

{plain-0.12.1 → plain-0.13.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "plain"
-version = "0.12.1"
+version = "0.13.1"
 description = "A web framework for building products with Python."
 authors = ["Dave Gaeddert <dave.gaeddert@dropseed.dev>"]
 readme = "README.md"

plain-0.12.1/plain/templates/__init__.py

@@ -1,6 +0,0 @@
-from .core import Template, TemplateFileMissing
-
-__all__ = [
-    "Template",
-    "TemplateFileMissing",
-]

plain-0.12.1/plain/templates/jinja/__init__.py

@@ -1,22 +0,0 @@
-from plain.runtime import settings
-from plain.utils.functional import LazyObject
-from plain.utils.module_loading import import_string
-
-from .defaults import create_default_environment, get_template_dirs
-
-
-class JinjaEnvironment(LazyObject):
-    def _setup(self):
-        environment_setting = settings.JINJA_ENVIRONMENT
-
-        if isinstance(environment_setting, str):
-            environment = import_string(environment_setting)()
-        else:
-            environment = environment_setting()
-
-        self._wrapped = environment
-
-
-environment = JinjaEnvironment()
-
-__all__ = ["environment", "create_default_environment", "get_template_dirs"]

plain-0.12.1/plain/templates/jinja/defaults.py

@@ -1,119 +0,0 @@
-import functools
-from importlib import import_module
-from pathlib import Path
-
-from jinja2 import Environment, StrictUndefined
-
-from plain.packages import packages
-from plain.runtime import settings
-from plain.utils.module_loading import import_string, module_has_submodule
-
-from .filters import default_filters
-from .globals import default_globals
-
-
-@functools.lru_cache
-def _get_app_template_dirs():
-    """
-    Return an iterable of paths of directories to load app templates from.
-
-    dirname is the name of the subdirectory containing templates inside
-    installed applications.
-    """
-    dirname = "templates"
-    template_dirs = [
-        Path(package_config.path) / dirname
-        for package_config in packages.get_package_configs()
-        if package_config.path and (Path(package_config.path) / dirname).is_dir()
-    ]
-    # Immutable return value because it will be cached and shared by callers.
-    return tuple(template_dirs)
-
-
-def _get_installed_extensions() -> tuple[list, dict, dict]:
-    """Automatically load extensions, globals, filters from INSTALLED_PACKAGES jinja module and root jinja module"""
-    extensions = []
-    globals = {}
-    filters = {}
-
-    for package_config in packages.get_package_configs():
-        if module_has_submodule(package_config.module, "jinja"):
-            module = import_module(f"{package_config.name}.jinja")
-        else:
-            continue
-
-        if hasattr(module, "extensions"):
-            extensions.extend(module.extensions)
-
-        if hasattr(module, "globals"):
-            globals.update(module.globals)
-
-        if hasattr(module, "filters"):
-            filters.update(module.filters)
-
-    try:
-        import jinja
-
-        if hasattr(jinja, "extensions"):
-            extensions.extend(jinja.extensions)
-
-        if hasattr(jinja, "globals"):
-            globals.update(jinja.globals)
-
-        if hasattr(jinja, "filters"):
-            filters.update(jinja.filters)
-    except ImportError:
-        pass
-
-    return extensions, globals, filters
-
-
-def finalize_callable_error(obj):
-    """Prevent direct rendering of a callable (likely just forgotten ()) by raising a TypeError"""
-    if callable(obj):
-        raise TypeError(f"{obj} is callable, did you forget parentheses?")
-
-    # TODO find a way to prevent <object representation> from being rendered
-    # if obj.__class__.__str__ is object.__str__:
-    #     raise TypeError(f"{obj} does not have a __str__ method")
-
-    return obj
-
-
-def get_template_dirs():
-    jinja_templates = Path(__file__).parent / "templates"
-    app_templates = settings.path.parent / "templates"
-    return (jinja_templates, app_templates) + _get_app_template_dirs()
-
-
-def create_default_environment(include_packages=True, **environment_kwargs):
-    """
-    This default jinja environment, also used by the error rendering and internal views so
-    customization needs to happen by using this function, not settings that hook in internally.
-    """
-    loader = import_string(settings.JINJA_LOADER)(get_template_dirs())
-    kwargs = {
-        "loader": loader,
-        "autoescape": True,
-        "auto_reload": settings.DEBUG,
-        "undefined": StrictUndefined,
-        "finalize": finalize_callable_error,
-        "extensions": ["jinja2.ext.loopcontrols", "jinja2.ext.debug"],
-    }
-    kwargs.update(**environment_kwargs)
-    env = Environment(**kwargs)
-
-    # Load the top-level defaults
-    env.globals.update(default_globals)
-    env.filters.update(default_filters)
-
-    if include_packages:
-        app_extensions, app_globals, app_filters = _get_installed_extensions()
-
-        for extension in app_extensions:
-            env.add_extension(extension)
-
-        env.globals.update(app_globals)
-        env.filters.update(app_filters)
-
-    return env