plain 0.1.0__py3-none-any.whl

plain/templates/jinja/defaults.py

@@ -0,0 +1,119 @@
+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

plain/templates/jinja/extensions.py

@@ -0,0 +1,39 @@
+from jinja2 import nodes
+from jinja2.ext import Extension
+
+
+class InclusionTagExtension(Extension):
+    """Intended to be subclassed"""
+
+    # tags = {'inclusion_tag'}
+    tags: set[str]
+    template_name: str
+
+    def parse(self, parser):
+        lineno = next(parser.stream).lineno
+        args = [
+            nodes.DerivedContextReference(),
+        ]
+        kwargs = []
+        while parser.stream.current.type != "block_end":
+            if parser.stream.current.type == "name":
+                key = parser.stream.current.value
+                parser.stream.skip()
+                parser.stream.expect("assign")
+                value = parser.parse_expression()
+                kwargs.append(nodes.Keyword(key, value))
+            else:
+                args.append(parser.parse_expression())
+
+        call = self.call_method("_render", args=args, kwargs=kwargs, lineno=lineno)
+        return nodes.CallBlock(call, [], [], []).set_lineno(lineno)
+
+    def _render(self, context, *args, **kwargs):
+        context = self.get_context(context, *args, **kwargs)
+        template = self.environment.get_template(self.template_name)
+        return template.render(context)
+
+    def get_context(self, context, *args, **kwargs):
+        raise NotImplementedError(
+            "You need to implement the `get_context` method in your subclass."
+        )

plain/templates/jinja/filters.py

@@ -0,0 +1,28 @@
+import datetime
+from itertools import islice
+
+from plain.utils.html import json_script
+from plain.utils.timesince import timesince, timeuntil
+from plain.utils.timezone import localtime
+
+
+def localtime_filter(value, timezone=None):
+    """Converts a datetime to local time in a template."""
+    if not value:
+        # Without this, we get the current localtime
+        # which doesn't make sense as a filter
+        raise ValueError("localtime filter requires a datetime")
+    return localtime(value, timezone)
+
+
+default_filters = {
+    # The standard Python ones
+    "strftime": datetime.datetime.strftime,
+    "strptime": datetime.datetime.strptime,
+    # To convert to user time zone
+    "localtime": localtime_filter,
+    "timeuntil": timeuntil,
+    "timesince": timesince,
+    "json_script": json_script,
+    "islice": islice,  # slice for dict.items()
+}

plain/templates/jinja/globals.py

@@ -0,0 +1,19 @@
+from plain.assets import get_asset_url
+from plain.paginator import Paginator
+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)
+
+
+default_globals = {
+    "asset": get_asset_url,
+    "url": url,
+    "Paginator": Paginator,
+    "now": timezone.now,
+    "localtime": timezone.localtime,
+}

plain/test/README.md

@@ -0,0 +1,3 @@
+# test
+
+Testing utilities for Plain.

plain/test/__init__.py

@@ -0,0 +1,16 @@
+"""Plain Unit Test framework."""
+
+from plain.test.client import Client, RequestFactory
+from plain.test.utils import (
+    ignore_warnings,
+    modify_settings,
+    override_settings,
+)
+
+__all__ = [
+    "Client",
+    "RequestFactory",
+    "ignore_warnings",
+    "modify_settings",
+    "override_settings",
+]