django-camomilla-cms 5.8.5__py2.py3-none-any.whl → 6.0.0__py2.py3-none-any.whl

camomilla/storages/optimize.py

@@ -0,0 +1,71 @@
+import traceback
+from io import BytesIO
+
+from django.core.files.base import ContentFile
+from PIL import Image
+
+from camomilla import settings
+from camomilla.storages.default import get_default_storage_class
+
+
+class OptimizedStorage(get_default_storage_class()):
+    MEDIA_MAX_WIDTH = settings.MEDIA_OPTIMIZE_MAX_WIDTH
+    MEDIA_MAX_HEIGHT = settings.MEDIA_OPTIMIZE_MAX_HEIGHT
+    MEDIA_DPI = settings.MEDIA_OPTIMIZE_DPI
+    MEDIA_OPTIMIZE_JPEG_QUALITY = settings.MEDIA_OPTIMIZE_JPEG_QUALITY
+
+    def __init__(self, *args, **kwargs) -> None:
+        self.MEDIA_MAX_WIDTH = int(kwargs.pop("max_width", self.MEDIA_MAX_WIDTH))
+        self.MEDIA_MAX_HEIGHT = int(kwargs.pop("max_height", self.MEDIA_MAX_HEIGHT))
+        self.MEDIA_DPI = int(kwargs.pop("dpi", self.MEDIA_DPI))
+        self.MEDIA_OPTIMIZE_JPEG_QUALITY = int(
+            kwargs.pop("jpeg_quality", self.MEDIA_OPTIMIZE_JPEG_QUALITY)
+        )
+        super().__init__(*args, **kwargs)
+
+    def _save(self, name: str, content: ContentFile):
+        if settings.ENABLE_MEDIA_OPTIMIZATION:
+            content, _ = self._optimize(name, content)
+        return super(OptimizedStorage, self)._save(name, content)
+
+    def _optimize(self, name: str, content: ContentFile):
+        try:
+            image = Image.open(content)
+            original_size = content.size
+            width, height = image.size
+
+            if width > self.MEDIA_MAX_WIDTH or height > self.MEDIA_MAX_HEIGHT:
+                if width <= height:
+                    selected_width = int((self.MEDIA_MAX_HEIGHT / height) * width)
+                    selected_height = self.MEDIA_MAX_HEIGHT
+                else:
+                    selected_height = int((self.MEDIA_MAX_WIDTH / width) * height)
+                    selected_width = self.MEDIA_MAX_WIDTH
+
+                image = image.resize(
+                    [selected_width, selected_height], resample=Image.LANCZOS
+                )
+            dpi = (self.MEDIA_DPI, self.MEDIA_DPI)
+            image.info["dpi"] = dpi
+            tmp = BytesIO()
+            ext = name.split(".")[-1].lower().replace("jpg", "jpeg")
+            image.save(
+                tmp,
+                ext,
+                dpi=dpi,
+                optimize=True,
+                quality=self.MEDIA_OPTIMIZE_JPEG_QUALITY,
+            )
+            tmp_size = len(tmp.getvalue())
+
+            if tmp_size > original_size:
+                tmp.close()
+                return content, False
+            optimized_content = ContentFile(tmp.getvalue())
+            tmp.close()
+            content.close()
+            return optimized_content, True
+        except Exception as e:
+            traceback.print_exc()
+            print(f"Error optimizing image {name}: {str(e)}")
+            return content, False

camomilla/{storages.py → storages/overwrite.py}

@@ -1,7 +1,7 @@
-from django.core.files.storage import FileSystemStorage
+from camomilla.storages.default import get_default_storage_class
 
 
-class OverwriteStorage(FileSystemStorage):
+class OverwriteStorage(get_default_storage_class()):
     def _save(self, name, content):
         if self.exists(name):
             self.delete(name)

camomilla/templates/admin/camomilla/page/change_form.html

@@ -0,0 +1,10 @@
+{% extends "admin/change_form.html" %}
+{% load i18n %}
+{% block object-tools-items %}
+{{block.super}}
+<li>
+  <a href="{{original.routerlink}}?preview=true" target="_blank" class="previewlink">
+    {% translate "Preview" %}
+  </a>
+</li>
+{% endblock %}

camomilla/templates/defaults/articles/default.html

@@ -0,0 +1,7 @@
+{% extends 'defaults/base.html' %} {% block template_info_title %}
+<h1><span class="temp_type">ARTICLE</span> DEFAULT TEMPLATE</h1>
+{% endblock %}
+{% block content %}
+<h2>{{page.title}}</h2>
+<div>{{page.content|safe}}</div>
+{% endblock %}

camomilla/templates/defaults/base.html

@@ -0,0 +1,170 @@
+{% load menus %}
+{% load i18n %}
+{% load model_extras %}
+
+{% get_current_language as current_lang %}
+
+
+<html>
+
+<head>
+    <title>Camomilla CMS</title>
+    <style>
+        html,
+
+        body {
+            background-color: #f7fafc;
+            color: black;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            font-family: sans-serif;
+            margin: 0;
+        }
+
+        .letter {
+            fill: black;
+        }
+
+        .language-switch {
+            position: absolute;
+            top: 6px;
+            right: 6px;
+        }
+
+
+        @media (prefers-color-scheme: dark) {
+            body {
+                background-color: #0d1117;
+                color: white;
+            }
+
+            .letter {
+                fill: #ebebeb;
+            }
+        }
+        .temp_type{
+            font-size: 18px;
+            font-style: italic;
+        }
+        .accordion {
+            margin: 2rem auto;
+            border: 1px solid #000;
+            font-family: monospace;
+            width: 800px;
+            max-width: 800px;
+        }
+
+        .accordion-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            padding: 0.75rem 1rem;
+            cursor: pointer;
+            user-select: none;
+        }
+
+        .accordion-icon {
+            width: 1rem;
+            height: 1rem;
+            transition: transform 0.3s ease;
+        }
+
+        .accordion-toggle:checked + .accordion-header .accordion-icon {
+            transform: rotate(180deg);
+        }
+
+        .accordion-body {
+            max-height: 0;
+            overflow: hidden;
+            transition: max-height 0.3s ease;
+        }
+
+        .accordion-toggle:checked + .accordion-header + .accordion-body {
+            max-height: 30vh;
+            padding: 1rem;
+            border-top: 1px solid #000;
+            overflow-y: auto;
+        }
+    </style>
+</head>
+
+<body>
+    <header >
+        {% block main_menu %}
+            {% render_menu "main_menu" %}
+        {% endblock %}
+        {% block language_switch %}
+            {% include "defaults/parts/langswitch.html" %}
+        {% endblock %}
+    </header>
+
+    <svg width="300" height="300" viewBox="0 0 180 180" fill="none" xmlns="http://www.w3.org/2000/svg">
+        <path fill-rule="evenodd" clip-rule="evenodd"
+            d="M130.84 104.52L135.262 102.465C135.262 102.465 133.122 100.134 133.122 96.8994C133.122 93.8551 135.215 91.5718 139.163 91.5718C143.539 91.5718 145.394 94.3308 145.394 97.3751C145.394 100.039 143.444 102.275 143.444 102.275L148.294 104.52L139.567 108.656L130.84 104.52Z"
+            fill="#FCB92C" />
+        <path
+            d="M138.023 65C126.947 65 117.965 73.4591 117.965 87.3252C117.965 97.9645 123.023 102.499 123.023 102.499L131.657 98.4877C131.657 98.4877 127.732 94.2146 127.732 88.2844C127.732 82.7032 131.569 78.5172 138.808 78.5172C146.831 78.5172 150.232 83.5752 150.232 89.1565C150.232 94.0402 146.656 98.1389 146.656 98.1389L156.075 102.499C156.075 102.499 159.999 96.7436 159.999 87.5868C159.999 74.244 149.709 65 138.023 65Z"
+            fill="#6AB946" />
+        <path
+            d="M58.0257 84.4732L59.1476 79.5448C57.024 80.0256 56.9439 78.9839 56.9439 76.9404V72.5329C56.9439 67.364 54.8202 65 49.0905 65C43.0001 65 40.1151 67.6445 40.5158 70.8901L46.7264 72.052C46.5261 70.249 47.2072 69.5678 48.6497 69.5678C50.1723 69.5678 50.6932 70.3291 50.6932 72.4527V73.0137C44.162 73.0537 39.8747 75.0171 39.8747 79.3445C39.8747 82.9106 42.7997 84.8338 46.2055 84.8338C49.1305 84.8338 50.573 83.3914 51.5346 82.0291C52.0555 83.4314 53.7384 85.1544 58.0257 84.4732ZM50.6932 78.0222C50.5329 79.7452 49.0905 80.3863 47.8884 80.3863C46.8466 80.3863 46.1655 79.9054 46.1655 78.8637C46.1655 77.0205 48.249 76.5798 50.6932 76.5397V78.0222Z"
+            class="letter" />
+        <path
+            d="M103.675 84.8338C111.048 84.8338 113.332 80.3462 113.332 74.8568C113.332 69.688 111.288 65 103.555 65C95.982 65 93.8183 69.5277 93.8183 74.7767C93.8183 80.1458 96.1022 84.8338 103.675 84.8338ZM103.595 80.1859C100.83 80.1859 100.309 77.5414 100.309 74.8568C100.309 72.2123 100.83 69.6479 103.555 69.6479C106.32 69.6479 106.841 72.2123 106.841 74.937C106.841 77.6616 106.32 80.1859 103.595 80.1859Z"
+            class="letter" />
+        <path
+            d="M31.9003 77.6215C31.9003 79.2243 30.9787 80.1859 29.4561 80.1859C27.2924 80.1859 26.4911 78.5431 26.4911 75.2174C26.4911 72.5329 26.7716 69.6479 29.4561 69.6479C30.578 69.6479 31.8202 70.4092 31.4596 72.9335L37.59 71.6914C38.0308 67.4442 34.665 65 29.5363 65C24.087 65 20 67.4442 20 74.8568C20 81.1876 22.8849 84.8338 29.376 84.8338C34.5448 84.8338 36.6284 82.3496 37.7102 78.7835L31.9003 77.6215Z"
+            class="letter" />
+        <path
+            d="M112.21 106.783L113.332 101.854C111.208 102.335 111.128 101.293 111.128 99.2499V94.8424C111.128 89.6736 109.004 87.3095 103.275 87.3095C97.1843 87.3095 94.2994 89.9541 94.7001 93.1996L100.911 94.3616C100.71 92.5585 101.391 91.8773 102.834 91.8773C104.357 91.8773 104.877 92.6386 104.877 94.7623V95.3232C98.3463 95.3633 94.059 97.3266 94.059 101.654C94.059 105.22 96.984 107.143 100.39 107.143C103.315 107.143 104.757 105.701 105.719 104.339C106.24 105.741 107.923 107.464 112.21 106.783ZM104.877 100.332C104.717 102.055 103.275 102.696 102.073 102.696C101.031 102.696 100.35 102.215 100.35 101.173C100.35 99.3301 102.433 98.8893 104.877 98.8492V100.332Z"
+            class="letter" />
+        <path d="M61.3508 106.581H67.6015V87.8691H61.3508V106.581Z" class="letter" />
+        <path
+            d="M64.4758 115.882C62.5525 115.882 60.9498 114.279 60.9498 112.356C60.9498 110.432 62.5525 108.87 64.4758 108.87C66.4391 108.87 68.0018 110.432 68.0018 112.356C68.0018 114.279 66.4391 115.882 64.4758 115.882Z"
+            class="letter" />
+        <path
+            d="M50.3532 106.582H56.6038V94.2814C56.6038 88.4315 53.3984 87.3095 50.6336 87.3095C46.3063 87.3095 44.7837 89.9541 44.3429 90.9558C43.5415 88.2311 41.2576 87.3095 38.8535 87.3095C34.8066 87.3095 33.244 89.7136 32.7231 90.8356V87.8705H26.9132V106.582H33.1638V97.2465C33.4844 96.0044 34.6063 92.5986 36.8501 92.5986C38.1323 92.5986 38.6532 93.7205 38.6532 95.8842V106.582H44.9039V97.1263C45.2645 95.7239 46.3864 92.5986 48.5501 92.5986C49.8323 92.5986 50.3532 93.6804 50.3532 95.8842V106.582Z"
+            class="letter" />
+        <path
+            d="M84.7527 80.6771H91.0033V71.9719C91.0033 66.1219 87.7979 65 85.0331 65C80.7058 65 79.1832 67.6445 78.7424 68.6462C77.941 65.9216 75.6571 65 73.253 65C69.2061 65 67.6435 67.4041 67.1226 68.526V65.561H61.3127V84.2729H67.5633V74.937C67.8839 73.6948 69.0058 70.289 71.2496 70.289C72.5318 70.289 73.0527 71.4109 73.0527 73.5746V80.6771H79.3034V74.8168C79.664 73.4144 80.7859 70.289 82.9496 70.289C84.2318 70.289 84.7527 71.3709 84.7527 73.5746V80.6771Z"
+            class="letter" />
+        <path d="M73.07 84.2731V106.582H79.3207V84.2731H73.07Z" class="letter" />
+        <path d="M84.7531 84.2731V106.582H91.0037V84.2731H84.7531Z" class="letter" />
+    </svg>
+    
+    {% block template_info_title %}
+        <h1><span class="temp_type">PAGE</span> DEFAULT TEMPLATE</h1>
+    {% endblock %}
+    {% block template_info %}
+    <code>
+        - <b>Class:</b> {{page_model.class}} <br>
+        - <b>Module:</b> {{page_model.module}} <br>
+        - <b>Identifier:</b> {{page.pk}} <br>
+        - <b>Permalink:</b> {{page.permalink}} <br>
+        - <b>Language:</b> {{current_lang}} <br>             
+    </code>
+    
+    {% endblock %}
+
+    {% block content %}
+    {% endblock %}
+    
+    <div class="accordion">
+    <input type="checkbox" id="accordion-toggle" class="accordion-toggle" hidden>
+    <label for="accordion-toggle" class="accordion-header">
+        <span>Page data</span>
+        <svg class="accordion-icon" viewBox="0 0 24 24">
+        <path d="M6 9l6 6 6-6" stroke="currentColor" stroke-width="2" fill="none" stroke-linecap="round"/>
+        </svg>
+    </label>
+    <div class="accordion-body">
+        <pre>{{ page|to_pretty_dict|safe }}</pre>
+    </div>
+</div>
+
+</div>
+
+</body>
+
+</html>

camomilla/templates/defaults/pages/default.html

@@ -0,0 +1,3 @@
+{% extends 'defaults/base.html' %} {% block template_info_title %}
+<h1><span class="temp_type">PAGE</span> DEFAULT TEMPLATE</h1>
+{% endblock %}

camomilla/templates/defaults/parts/langswitch.html

@@ -0,0 +1,83 @@
+{% load i18n camomilla_filters %}
+
+<div>
+    <style>
+        .language-switch {
+            font-family: monospace;
+            border-top: solid 1px;
+            border-right: solid 1px;
+            border-left: solid 1px;
+        }
+        .language-switch div {
+            border-bottom: solid 1px;
+            padding: 0.3rem 1rem;
+            cursor: pointer;
+        }
+    </style>
+    <form id="form_change_language" action="{% url 'set_language' %}" method="post" style='display: none;'>
+        {% csrf_token %}
+        <input id="next_form_change_language" name="next" type="hidden" value="{{ request.path }}" />
+        <select id="select_change_language" name="language">
+            {% get_current_language as LANGUAGE_CODE %}
+            {% get_available_languages as LANGUAGES %}
+            {% get_language_info_list for LANGUAGES as languages %}
+            {% for language in languages %}
+            <option value="{{ language.code }}" {% if language.code == LANGUAGE_CODE %} selected="selected" {% endif %}>
+                {{ language.name_local }} ({{ language.code }})
+            </option>
+            {% endfor %}
+        </select>
+        <input type="submit" value="Go" style='display: none;' />
+    </form>
+
+    <div class="language-switch">
+        {% get_current_language as LANGUAGE_CODE %}
+        {% get_available_languages as LANGUAGES %}
+        {% get_language_info_list for LANGUAGES as languages %}
+        {% get_language_info for LANGUAGE_CODE as current_lang %}
+
+        {% for lang_code, redirect in page.alternate_urls.items %}
+        <div class="language-switch--btn" data-lang="{{lang_code}}" 
+            {% if current_lang.code != lang_code %} 
+                {% if redirect is None %}
+                    onclick="submitLanguageHomeRedirect('{{lang_code}}');"
+                {% else %}
+                    onclick="submitLanguage('{{lang_code}}', '{{redirect|strip_lang:lang_code}}');"
+                {% endif %}
+            {% endif %}
+        >
+            {% get_language_info for lang_code as lang %}
+             <a>{{ lang.name_translated }} {% if current_lang.code == lang_code %} 👾 {% endif %}</a> 
+        </div>
+        {% endfor %}
+    </div>
+</div>
+
+<script>
+
+    window.submitLanguage = function (langCode, redirect) {
+        document.getElementById('select_change_language').value = langCode;
+        document.getElementById('next_form_change_language').value = redirect;
+        document.getElementById('next_form_change_language').disabled = false;
+        setTimeout(function () {
+            document.getElementById('form_change_language').submit();
+        }, 300);
+    };
+
+    window.submitLanguageWithoutRedirect = function (langCode) {
+        document.getElementById('select_change_language').value = langCode;
+        document.getElementById('next_form_change_language').disabled = true;
+        setTimeout(function () {
+            document.getElementById('form_change_language').submit();
+        }, 300);
+    };
+    window.submitLanguageHomeRedirect = function (langCode) {
+        document.getElementById('select_change_language').value = langCode;
+        document.getElementById('next_form_change_language').value = "/";
+        document.getElementById('next_form_change_language').disabled = false;
+        setTimeout(function () {
+            document.getElementById('form_change_language').submit();
+        }, 300);
+    };
+
+</script>

camomilla/templates/defaults/parts/menu.html

@@ -0,0 +1,15 @@
+{% load menus %}
+{% if menu.nodes|length %}
+<ul>
+  {% for item in menu.nodes %}
+  <li>
+    {% if item.link.url %}
+      <a href="{{ item|node_url }}{% if is_preview %}?preview=true{% endif %}">{{ item.title }}</a>
+    {% else %}
+      <span>{{item.title}}</span>
+    {% endif %}
+    {% include 'defaults/parts/menu.html' with menu=item %} 
+  </li>
+  {% endfor %}
+</ul>
+{% endif %}

camomilla/templates_context/autodiscover.py

@@ -0,0 +1,51 @@
+def autodiscover_context_files():
+    """
+    Auto-discover INSTALLED_APPS template_context.py modules and fail silently when
+    not present. This forces an import on them to register.
+    Also import explicit modules.
+    """
+    import copy
+    import sys
+    from django.utils.module_loading import module_has_submodule
+    from camomilla.templates_context.rendering import ctx_registry
+    from importlib import import_module
+    from django.apps import apps
+    from camomilla.settings import TEMPLATE_CONTEXT_FILES, DEBUG
+
+    mods = [
+        (app_config.name, app_config.module) for app_config in apps.get_app_configs()
+    ]
+
+    for app, mod in mods:
+        module = "%s.template_context" % app
+        _model_registry_bkp = copy.copy(ctx_registry._model_registry)
+        _template_registry_bkp = copy.copy(ctx_registry._template_registry)
+
+        try:
+            import_module(module)
+        except Exception:
+            ctx_registry._model_registry = _model_registry_bkp
+            ctx_registry._template_registry = _template_registry_bkp
+            if module_has_submodule(mod, "template_context"):
+                raise
+
+    for module in TEMPLATE_CONTEXT_FILES:
+        import_module(module)
+
+    if DEBUG:
+        try:
+            if sys.argv[1] in ("runserver", "runserver_plus"):
+                if not ctx_registry.get_registered_info().items():
+                    return
+                print("Camomilla context files:")
+                for k, v in ctx_registry.get_registered_info().items():
+                    print(f"{k}:")
+                    models = v.get("models")
+                    templates = v.get("templates")
+                    if models:
+                        print(f"  models: {models}")
+                    if templates:
+                        print(f"  templates: {templates}")
+                    print("\n")
+        except IndexError:
+            pass

camomilla/templates_context/rendering.py

@@ -0,0 +1,89 @@
+from collections import defaultdict
+from typing import Callable, Optional, TYPE_CHECKING, Type, Dict
+import inspect
+from django.http import HttpRequest
+
+if TYPE_CHECKING:
+    from camomilla.models.page import AbstractPage
+
+
+class PagesContextRegistry:
+    def __init__(self) -> None:
+        self._model_registry = defaultdict(set)
+        self._template_registry = defaultdict(set)
+
+    def register(
+        self,
+        func: Callable,
+        template_path: Optional[str],
+        page_model: Optional[Type["AbstractPage"]],
+    ):
+        assert (
+            template_path is not None or page_model is not None
+        ), "You must provide at least one between template_path and page_model"
+        if template_path is not None:
+            self._template_registry[template_path].add(func)
+        if page_model is not None:
+            self._model_registry[page_model].add(func)
+
+    def get_registered_info(self) -> Dict[str, dict]:
+        info = defaultdict(dict)
+        for k, v in self._template_registry.items():
+            for f in v:
+                key = f"{f.__module__}.{f.__name__}"
+                info[key]["templates"] = info[key].get("templates", set())
+                info[key]["templates"].add(k)
+                info[key]["templates_count"] = len(info[key]["templates"])
+        for k, v in self._model_registry.items():
+            key = f"{f.__module__}.{f.__name__}"
+            for f in v:
+                info[key]["models"] = info[key].get("models", set())
+                info[key]["models"].add(k)
+                info[key]["models_count"] = len(info[key]["models"])
+        return info
+
+    def get_wrapper_context_func(
+        self, template_path: str, page_model: Type["AbstractPage"]
+    ) -> Callable:
+        all_funcs = set()
+        for cls in self._model_registry.keys():
+            if issubclass(page_model, cls):
+                all_funcs.update(self._model_registry[cls])
+        all_funcs.update(self._template_registry[template_path])
+
+        def context_func(request: HttpRequest, super_ctx: dict = {}):
+            context = super_ctx.copy()
+            for func in all_funcs:
+                arg_spec = inspect.getfullargspec(func)
+                kwargs = {}
+                if "request" in arg_spec.args:
+                    kwargs["request"] = request
+                if "super_ctx" in arg_spec.args:
+                    kwargs["super_ctx"] = context
+                context.update(func(**kwargs) or {})
+            return context
+
+        return context_func
+
+    def get_context_for_page(self, page: "AbstractPage", request, super_ctx: dict = {}):
+        return self.get_wrapper_context_func(
+            page.get_template_path(request), page.__class__
+        )(request, super_ctx=super_ctx)
+
+
+def register(
+    template_path: Optional[str] = None,
+    page_model: Optional[Type["AbstractPage"]] = None,
+):
+    assert (
+        template_path is not None or page_model is not None
+    ), "You must provide at least one between template_path and page_model"
+
+    def inner(func: Callable):
+        ctx_registry.register(func, template_path, page_model)
+        return func
+
+    return inner
+
+
+ctx_registry = PagesContextRegistry()

camomilla/templatetags/camomilla_filters.py

@@ -7,14 +7,10 @@ register = template.Library()
 
 @register.filter(name="filter_content")
 def filter_content(page, args):
-    curr_lang = get_language()
     try:
-        content = page.contents.language(curr_lang).get(identifier=args)
+        content = page.contents.get(identifier=args)
     except page.contents.model.DoesNotExist:
         content, _ = page.contents.get_or_create(identifier=args)
-    if curr_lang not in content.translations.all_languages():
-        content.translate(curr_lang)
-        content.save()
     return content
 
 
@@ -22,3 +18,8 @@ def filter_content(page, args):
 def alternate_urls(page, request):
     alternates = page.alternate_urls(request)
     return alternates.get("alternate_urls", alternates).items()
+
+
+@register.filter(name="strip_lang")
+def strip_lang(value, lang=get_language()):
+    return "/%s" % value.lstrip("/%s/" % lang)

camomilla/templatetags/menus.py

@@ -0,0 +1,37 @@
+from django import template
+from camomilla.models import Menu
+
+from camomilla.models.menu import MenuNode
+
+register = template.Library()
+
+
+@register.simple_tag(takes_context=True)
+def get_menus(context, *args):
+    if "menus" in context:
+        return context["menus"]
+    qs = Menu.objects.all()
+    if len(args):
+        qs = qs.filter(key__in=args)
+    return Menu.defaultdict({m.key: m for m in qs})
+
+
+@register.simple_tag(takes_context=True)
+def render_menu(
+    context: template.RequestContext,
+    menu_key: str,
+    template_path: str = "defaults/parts/menu.html",
+):
+    if context is not None and not isinstance(context, dict):
+        context = context.__dict__
+
+    return context.get("menus", Menu.defaultdict())[menu_key].render(
+        template_path=template_path,
+        context=context,
+        request=context.get("request", None),
+    )
+
+
+@register.filter(name="node_url")
+def get_menu_node_url(node: MenuNode):
+    return node.link.url

camomilla/templatetags/model_extras.py

@@ -0,0 +1,77 @@
+from django import template
+from django.utils.safestring import mark_safe
+from django.forms.models import model_to_dict
+from structured.pydantic.models import BaseModel
+import json
+import re
+import html
+from datetime import datetime
+
+register = template.Library()
+
+
+def custom_json_serializer(obj):
+    """Serialize custom objects to JSON."""
+    if isinstance(obj, datetime):
+        return obj.isoformat()
+    raise TypeError(f"Type {type(obj)} not serializable")
+
+
+def pretty_dict(data, indent_level=0):
+    """
+    Recursive function to format a dictionary into a pretty string.
+    Args:
+        data (dict): The dictionary to format.
+        indent_level (int): The current indentation level.
+    Returns:
+        str: A pretty-printed string representation of the dictionary.
+    """
+    indent = "  " * indent_level
+    result = []
+
+    for key, value in data.items():
+
+        if isinstance(value, dict):
+            result.append(f"{indent}'{key}': {{")
+            result.append(pretty_dict(value, indent_level + 1))
+            result.append(f"{indent}}},")
+
+        elif isinstance(value, list):
+            result.append(f"{indent}'{key}': [")
+            for item in value:
+                if isinstance(item, dict):
+                    result.append(pretty_dict(item, indent_level + 1))
+                else:
+                    result.append(
+                        f"{indent}  {json.dumps(item, default=custom_json_serializer)},"
+                    )
+            result.append(f"{indent}],")
+
+        else:
+            result.append(
+                f"{indent}'{key}': {json.dumps(value, default=custom_json_serializer)},"
+            )
+
+    return "\n".join(result).rstrip(",")
+
+
+@register.filter
+def to_pretty_dict(instance):
+    data = model_to_dict(instance)
+
+    for key, value in data.items():
+        if isinstance(value, BaseModel):
+            data[key] = value.model_dump()
+
+    formatted_dict = "{\n" + pretty_dict(data, indent_level=1) + "\n}"
+
+    escaped = html.escape(formatted_dict)
+
+    # This to highlight the keys in the JSON
+    highlighted = re.sub(
+        r"(')([^&#]+?)('):",
+        r"<span style='color:#df3079'>'\2'</span>:",
+        escaped,
+    )
+
+    return mark_safe(f"<pre>{highlighted}</pre>")

camomilla/theme/__init__.py

@@ -1 +1 @@
-__version__ = "5.8.5"
+__version__ = "6.0.0"