django-dynamic-template 0.1.0__py3-none-any.whl

django_dynamic_template-0.1.0.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: django-dynamic-template
+Version: 0.1.0
+Summary: Django app for content-type–scoped dynamic templates with NamedID slugs
+Author-email: Octolo <dev@octolo.tech>
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Django
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Django>=3.2
+Requires-Dist: django-namedid>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3; extra == "dev"
+Requires-Dist: pytest-django>=4.5; extra == "dev"
+Requires-Dist: django-virtualqueryset>=0.1.1; extra == "dev"
+Requires-Dist: django-boosted>=1.0.0; extra == "dev"
+Requires-Dist: django-richtextfield>=1.6; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: django-stubs>=5.0.0; extra == "dev"
+Dynamic: license-file
+
+# django-dynamic-template
+
+Django app for **content-type–scoped dynamic templates**: store DTL fragments in the database, address them with a **`named_id`** slug ([django-namedid](https://github.com/octolo/django-namedid)), inject optional **related querysets** and a structured **`object`** dict into each fragment.
+
+## Requirements
+
+- Python ≥ 3.10  
+- Django ≥ 3.2  
+- **django-namedid** ≥ 0.1.0 (installed automatically via `pyproject.toml`)
+
+## Installation
+
+From the repository root (editable install recommended for local work):
+
+```bash
+pip install -e .
+```
+
+Add the app and dependencies you need:
+
+```python
+INSTALLED_APPS = [
+    # ...
+    "dynamic_template",
+]
+```
+
+Optional: **django-boosted** (admin preview), **django-richtextfield** (TinyMCE-style widget) — see `pyproject.toml` `[project.optional-dependencies]` **dev**.
+
+## Concepts
+
+| Piece | Role |
+|--------|------|
+| **`DynamicTemplate`** | `label`, `content_type`, `named_id`, `template` (richtext), plus `model_fields`, `annotate_fields`, `fields` shaping **`object`** in the fragment |
+| **`DynamicRelationContext`** | Related queryset (manager + filters), same three JSON fields per **row**; rows are **tuples of dicts** in the fragment |
+| **`{% dyntpl %}`** | Loads a template by `named_id`, merges context, evaluates relation contexts, then replaces **`object`** with a plain **dict** |
+
+- **`model_fields`**: ORM column names (empty → all concrete fields on the model).  
+- **`annotate_fields`**: list of annotation **aliases** already on the queryset / instance — this app does **not** call `.annotate()`; your manager or view must provide them.  
+- **`fields`**: extra Python names resolved with **`getattr`** (`@property`, class attributes, methods).
+
+Filters on relations: **`filter_spec`** (resolved from **`object`** + template context) and **`filter_literal`** (static ORM kwargs). See **`docs/purpose.md`** for full detail.
+
+## Template tag
+
+```django
+{% load dyntpl %}
+
+{% dyntpl "my-block-named-id" %}
+{% dyntpl tpl_id obj=article %}
+{% dyntpl tpl_id ctype=Product obj=product %}
+```
+
+- **`obj=`**: must match the template’s `content_type`.  
+- **`ctype=`**: disambiguates when the same `named_id` exists for several models.  
+- Other keyword arguments are merged into the **inner** fragment context.
+
+In the fragment, use **`{{ object.name }}`**, **`{% for row in article %}{{ row.title }}{% endfor %}`**, **`{{ rows|length }}`** (not `.count` on querysets).
+
+## Settings (optional)
+
+```python
+# Import path to a widget class for the template field in admin
+DYNAMIC_TEMPLATE_RICHTEXT_WIDGET = "djrichtextfield.widgets.RichTextWidget"
+```
+
+## Development
+
+```bash
+pytest
+```
+
+`pyproject.toml` sets `DJANGO_SETTINGS_MODULE=tests.settings` and `pythonpath=["src"]`.
+
+Apply migrations for the bundled test project:
+
+```bash
+PYTHONPATH=src DJANGO_SETTINGS_MODULE=tests.settings python manage.py migrate
+```
+
+More detail: **`docs/`** (`purpose.md`, `structure.md`, `development.md`).
+
+## License
+
+MIT

django_dynamic_template-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+django_dynamic_template-0.1.0.dist-info/licenses/LICENSE,sha256=oZt4vlNwtZQ6WPaqWnQu-KtlTCThT67jqVt02pAVXKE,1064
+dynamic_template/__init__.py,sha256=vbqOVeJ9JahvW_4-Cbfqjdz9i6BJFm5T1JgREB3Y-74,80
+dynamic_template/apps.py,sha256=xuCHWlxnr-RmvTTtodppKz-BoCHDrQIEmZ84UtAZZMc,163
+dynamic_template/fields.py,sha256=cvyJHoH-v0pS5hjbC9jEVJpL-BLv0MBu6T3wBdmCWw4,769
+dynamic_template/io.py,sha256=trZEuL5xVmmG7L8wjNP3B52kvozoAzu2ovMYDlVgYdc,7323
+dynamic_template/rendering.py,sha256=QGEcRyQbiPH4sXFILDq2lxkYB0tGe3lx6QxCYV5l-hY,1657
+dynamic_template/resolve.py,sha256=vmrqx9OcU_T2vgXWfP69R32IPwLbkvrh7h9f3iwAw0s,1375
+dynamic_template/admin/__init__.py,sha256=XkS1WOY3R95XaNCUAGqfX7FEKJItITTP9vmdzWG8RPk,168
+dynamic_template/admin/relation_context.py,sha256=bYMOHePRKLm5EC_NG1avZnnAj6Rof4Vxw-rz9z1goas,201
+dynamic_template/admin/template.py,sha256=0U2Us5kVD1wfXH2Fs4wNRTMYwvFG-yy6RyrRRDdmUn0,7445
+dynamic_template/migrations/0001_initial.py,sha256=lS8LmzsZO03Duj2hqCKEsLkANegOTR9f2euqMYON5so,9690
+dynamic_template/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dynamic_template/models/__init__.py,sha256=kStCI74bke8it51CjXaPtRBOWLXFHMxvkCb9jTtIndw,517
+dynamic_template/models/_helpers.py,sha256=niZ7f0XEUbjPLagtHvBQbosTPGiLUYDUdzkCi1MwX4k,923
+dynamic_template/models/relation_context.py,sha256=b24EuWbKv1NlrArcxohqbcGhu_K0dY_pTPHQEhYbaF8,8081
+dynamic_template/models/template.py,sha256=NmpTmshoZYUrWl0ue7HZdtgGosUi661wMqFApDplNKc,5282
+dynamic_template/templatetags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dynamic_template/templatetags/dyntpl.py,sha256=6CIXChBTTEFEqZzxa8whrukIpWyP3ElUrEPCMYJuNOU,6899
+django_dynamic_template-0.1.0.dist-info/METADATA,sha256=hxBpHa4rib6nMFNdFu5Lc_gwtRkfTBmER_ERynJZiko,3927
+django_dynamic_template-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+django_dynamic_template-0.1.0.dist-info/top_level.txt,sha256=5l2JWqtr23SfBck5FF4fmQABbBWKvb7s_srWA1zfq3w,17
+django_dynamic_template-0.1.0.dist-info/RECORD,,

django_dynamic_template-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

django_dynamic_template-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Octolo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

django_dynamic_template-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dynamic_template

dynamic_template/__init__.py

@@ -0,0 +1 @@
+"""Django app: dynamic DB-backed templates keyed by NamedID and ContentType."""

dynamic_template/admin/__init__.py

@@ -0,0 +1,5 @@
+"""Django admin for dynamic_template (import submodules for @admin.register side effects)."""
+
+from __future__ import annotations
+
+from . import template  # noqa: F401

dynamic_template/admin/relation_context.py

@@ -0,0 +1,8 @@
+from django.contrib import admin
+
+from dynamic_template.models import DynamicRelationContext
+
+
+class DynamicRelationContextInline(admin.TabularInline):
+    model = DynamicRelationContext
+    extra = 0

dynamic_template/admin/template.py

@@ -0,0 +1,216 @@
+import json
+
+from django import forms
+from django.contrib import admin, messages
+from django.core.exceptions import PermissionDenied
+from django.urls import reverse
+from django.utils.translation import gettext_lazy as _
+from django_boosted import AdminBoostModel, admin_boost_view
+from django_boosted.decorators import AdminBoostViewConfig
+
+from .relation_context import DynamicRelationContextInline
+from dynamic_template.io import import_payload, json_attachment_response, serialize_export
+from dynamic_template.models import DynamicTemplate
+from dynamic_template.rendering import render_dynamic_template_fragment
+
+
+def _preview_form_for_template(obj: DynamicTemplate) -> type[forms.Form]:
+    Model = obj.content_type.model_class()
+    model_label = Model._meta.label if Model else "?"
+
+    class DynamicTemplatePreviewForm(forms.Form):
+        object_id = forms.CharField(
+            label=_("Object primary key"),
+            required=False,
+            help_text=_(
+                "Primary key of a %(model)s instance for relation filters and for `object` in the fragment "
+                "(after relation contexts, `object` is a dict from model_fields / annotate_fields / fields). "
+                "Leave empty if the fragment does not use `object`."
+            )
+            % {"model": model_label},
+        )
+
+    return DynamicTemplatePreviewForm
+
+
+class DynamicTemplateImportForm(forms.Form):
+    file = forms.FileField(label=_("JSON file"), required=False)
+    payload = forms.CharField(
+        label=_("Or paste JSON"),
+        widget=forms.Textarea(attrs={"rows": 24, "cols": 100, "class": "vLargeTextField"}),
+        required=False,
+    )
+    replace = forms.BooleanField(
+        label=_("Replace existing templates (same content type + label)"),
+        required=False,
+        initial=True,
+    )
+
+    def clean(self):
+        cleaned = super().clean()
+        file = cleaned.get("file")
+        text = (cleaned.get("payload") or "").strip()
+        raw: str | None = None
+        if file:
+            data = file.read()
+            raw = data.decode("utf-8") if isinstance(data, bytes) else str(data)
+        elif text:
+            raw = text
+        if not raw:
+            raise forms.ValidationError(_("Provide a JSON file or paste JSON."))
+        try:
+            parsed = json.loads(raw)
+        except json.JSONDecodeError as exc:
+            raise forms.ValidationError(str(exc)) from exc
+        if not isinstance(parsed, dict):
+            raise forms.ValidationError(_("Root JSON value must be an object."))
+        cleaned["parsed"] = parsed
+        return cleaned
+
+
+@admin.register(DynamicTemplate)
+class DynamicTemplateAdmin(AdminBoostModel):
+    list_display = ("label", "named_id", "content_type", "relation_context_count_display")
+    list_filter = ("content_type",)
+    search_fields = ("label", "named_id", "template")
+    readonly_fields = ("named_id",)
+    fieldsets = (
+        (
+            None,
+            {
+                "fields": (
+                    "label",
+                    "named_id",
+                    "content_type",
+                    "model_fields",
+                    "annotate_fields",
+                    "fields",
+                    "raw_object",
+                    "context_object",
+                    "template",
+                ),
+            },
+        ),
+    )
+    inlines = (DynamicRelationContextInline,)
+
+    def get_queryset(self, request):
+        return super().get_queryset(request).with_relation_context_count()
+
+    @admin.display(
+        ordering="relation_context_count",
+        description=_("Relation contexts"),
+    )
+    def relation_context_count_display(self, obj):
+        return getattr(obj, "relation_context_count", 0)
+
+    @admin_boost_view(
+        "adminform",
+        _("Import JSON"),
+        config=AdminBoostViewConfig(
+            path_fragment="import-json",
+            requires_object=False,
+            permission="change",
+        ),
+    )
+    def admin_import_json(self, request, form=None):
+        if not self.has_change_permission(request):
+            raise PermissionDenied
+        if form is None:
+            return {"form": DynamicTemplateImportForm()}
+        result = import_payload(
+            form.cleaned_data["parsed"],
+            replace=form.cleaned_data.get("replace", True),
+        )
+        messages.success(
+            request,
+            _("Import finished: %(c)d created, %(u)d updated.")
+            % {"c": result["created"], "u": result["updated"]},
+        )
+        for err in result["errors"][:25]:
+            messages.warning(request, err)
+        url = reverse(
+            f"admin:{self.model._meta.app_label}_{self.model._meta.model_name}_changelist",
+            current_app=self.admin_site.name,
+        )
+        return {"redirect_url": url}
+
+    @admin_boost_view(
+        "json",
+        _("Export JSON (all)"),
+        config=AdminBoostViewConfig(
+            path_fragment="export-json-bulk",
+            requires_object=False,
+            permission="view",
+        ),
+    )
+    def admin_export_json_bulk(self, request):
+        qs = self.get_queryset(request).prefetch_related("relation_contexts")
+        return json_attachment_response("dynamic-templates.json", serialize_export(qs))
+
+    @admin_boost_view(
+        "json",
+        _("Export JSON"),
+        config=AdminBoostViewConfig(
+            path_fragment="export-json",
+            requires_object=True,
+            permission="view",
+        ),
+    )
+    def admin_export_json_single(self, request, obj):
+        payload = serialize_export(
+            DynamicTemplate.objects.filter(pk=obj.pk).prefetch_related("relation_contexts"),
+        )
+        safe = "".join(c if c.isalnum() or c in "-_" else "-" for c in obj.named_id)[:80]
+        return json_attachment_response(
+            f"dynamic-template-{obj.pk}-{safe}.json",
+            payload,
+        )
+
+    @admin_boost_view(
+        "adminform",
+        _("Preview fragment"),
+        config=AdminBoostViewConfig(
+            template_name="dynamic_template/admin/preview_render.html",
+            path_fragment="preview-render",
+            permission="change",
+        ),
+    )
+    def admin_preview_render(self, request, obj, form=None):
+        PreviewForm = _preview_form_for_template(obj)
+        Model = obj.content_type.model_class()
+
+        if form is None:
+            return {"form": PreviewForm()}
+
+        bound = None
+        oid = (form.cleaned_data.get("object_id") or "").strip()
+        if oid:
+            if Model is None:
+                form.add_error("object_id", _("Unknown content type."))
+            else:
+                try:
+                    bound = Model.objects.get(pk=oid)
+                except (Model.DoesNotExist, ValueError, TypeError):
+                    form.add_error(
+                        "object_id",
+                        _("No %(model)s found with this primary key.")
+                        % {"model": Model._meta.verbose_name},
+                    )
+
+        if form.errors:
+            return {"form": form}
+
+        try:
+            html = render_dynamic_template_fragment(
+                obj,
+                request=request,
+                bound=bound,
+                base_context={},
+                extra={},
+            )
+        except ValueError as exc:
+            form.add_error(None, str(exc))
+            return {"form": form}
+
+        return {"form": form, "rendered_preview": html}

dynamic_template/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class DynamicTemplateConfig(AppConfig):
+    name = "dynamic_template"
+    default_auto_field = "django.db.models.BigAutoField"

dynamic_template/fields.py

@@ -0,0 +1,24 @@
+"""Model fields; rich-text widget is chosen via ``DYNAMIC_TEMPLATE_RICHTEXT_WIDGET`` (like django-pymissive)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from django.db import models
+
+
+class RichTextField(models.TextField):
+    """``TextField`` whose ModelForm/admin widget is configurable in settings."""
+
+    def formfield(self, **kwargs: Any) -> Any:
+        from django.conf import settings
+        from django.utils.module_loading import import_string
+
+        widget_path = getattr(
+            settings,
+            "DYNAMIC_TEMPLATE_RICHTEXT_WIDGET",
+            "django.forms.Textarea",
+        )
+        widget_class = import_string(widget_path)
+        kwargs.setdefault("widget", widget_class)
+        return super().formfield(**kwargs)

dynamic_template/io.py

@@ -0,0 +1,187 @@
+"""JSON export / import for :class:`~dynamic_template.models.DynamicTemplate` (+ relation contexts)."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+from urllib.parse import quote
+
+from django.apps import apps
+from django.http import HttpResponse
+from django.contrib.contenttypes.models import ContentType
+from django.db import transaction
+
+from dynamic_template.models import DynamicRelationContext, DynamicTemplate
+
+EXPORT_FORMAT_VERSION = 1
+
+
+def _split_ct(label: str) -> tuple[str, str]:
+    label = str(label).strip()
+    parts = label.split(".", 1)
+    if len(parts) != 2:
+        raise ValueError(f"Invalid content_type label {label!r} (expected app_label.model).")
+    return parts[0], parts[1].lower()
+
+
+def resolve_content_type(label: str) -> ContentType:
+    app_label, model_name = _split_ct(label)
+    Model = apps.get_model(app_label, model_name)
+    if Model is None:
+        raise ValueError(f"Unknown model {label!r}.")
+    return ContentType.objects.get_for_model(Model, for_concrete_model=False)
+
+
+def serialize_relation(rc: DynamicRelationContext) -> dict[str, Any]:
+    return {
+        "content_type": f"{rc.content_type.app_label}.{rc.content_type.model}",
+        "manager_method": rc.manager_method,
+        "filter_spec": rc.filter_spec or {},
+        "filter_literal": rc.filter_literal or {},
+        "model_fields": list(rc.model_fields) if rc.model_fields is not None else [],
+        "annotate_fields": list(rc.annotate_fields) if rc.annotate_fields is not None else [],
+        "fields": list(rc.fields) if rc.fields is not None else [],
+        "name": rc.name,
+    }
+
+
+def serialize_template(dt: DynamicTemplate) -> dict[str, Any]:
+    data: dict[str, Any] = {
+        "label": dt.label,
+        "named_id": dt.named_id,
+        "content_type": f"{dt.content_type.app_label}.{dt.content_type.model}",
+        "template": dt.template,
+        "model_fields": list(dt.model_fields) if dt.model_fields is not None else [],
+        "annotate_fields": list(dt.annotate_fields) if dt.annotate_fields is not None else [],
+        "fields": list(dt.fields) if dt.fields is not None else [],
+        "raw_object": dt.raw_object,
+        "context_object": dt.context_object or "",
+        "relation_contexts": [serialize_relation(r) for r in dt.relation_contexts.all()],
+    }
+    return data
+
+
+def serialize_export(qs) -> dict[str, Any]:
+    templates = []
+    for dt in qs.order_by("pk").select_related("content_type").prefetch_related(
+        "relation_contexts", "relation_contexts__content_type"
+    ):
+        templates.append(serialize_template(dt))
+    return {
+        "format_version": EXPORT_FORMAT_VERSION,
+        "dynamic_templates": templates,
+    }
+
+
+def content_disposition_attachment(filename: str) -> str:
+    """``Content-Disposition`` with ASCII ``filename`` and RFC 5987 ``filename*`` when needed."""
+    try:
+        filename.encode("ascii")
+    except UnicodeEncodeError:
+        pass
+    else:
+        return f'attachment; filename="{filename}"'
+    ascii_fallback = filename.encode("ascii", "replace").decode("ascii").replace("?", "_")
+    quoted = quote(filename, safe="")
+    return f'attachment; filename="{ascii_fallback}"; filename*=UTF-8\'\'{quoted}'
+
+
+def json_attachment_response(filename: str, payload: dict[str, Any]) -> HttpResponse:
+    body = (
+        json.dumps(payload, ensure_ascii=False, indent=2, allow_nan=False) + "\n"
+    ).encode("utf-8")
+    response = HttpResponse(body, content_type="application/json; charset=utf-8")
+    response["Content-Disposition"] = content_disposition_attachment(filename)
+    return response
+
+
+def import_payload(data: dict[str, Any], *, replace: bool = True) -> dict[str, Any]:
+    version = data.get("format_version", 1)
+    if version != EXPORT_FORMAT_VERSION:
+        raise ValueError(f"Unsupported format_version {version!r} (expected {EXPORT_FORMAT_VERSION}).")
+    items = data.get("dynamic_templates") or data.get("templates")
+    if not isinstance(items, list):
+        raise ValueError("Expected a JSON object with key 'dynamic_templates' (array).")
+    created = 0
+    updated = 0
+    errors: list[str] = []
+    for idx, item in enumerate(items):
+        if not isinstance(item, dict):
+            errors.append(f"#{idx}: not an object")
+            continue
+        try:
+            with transaction.atomic():
+                c, u = _import_one_template(item, replace=replace)
+                created += c
+                updated += u
+        except (ValueError, TypeError, KeyError, ContentType.DoesNotExist) as exc:
+            errors.append(f"#{idx} ({item.get('label', '?')}): {exc}")
+    return {"created": created, "updated": updated, "errors": errors}
+
+
+def _import_one_template(item: dict[str, Any], *, replace: bool) -> tuple[int, int]:
+    label = str(item.get("label", "")).strip()
+    if not label:
+        raise ValueError("label is required")
+    ct = resolve_content_type(item["content_type"])
+    template_body = item.get("template", "") or ""
+    model_fields = item.get("model_fields") or []
+    annotate_fields = item.get("annotate_fields") or []
+    fields = item.get("fields") or []
+
+    if not isinstance(model_fields, list):
+        raise ValueError("model_fields must be a list")
+    if not isinstance(annotate_fields, list):
+        raise ValueError("annotate_fields must be a list")
+    if not isinstance(fields, list):
+        raise ValueError("fields must be a list")
+
+    raw_object = bool(item.get("raw_object", False))
+    context_object = str(item.get("context_object", "") or "").strip()
+
+    dt = DynamicTemplate.objects.filter(content_type=ct, label=label).first()
+    if dt:
+        if not replace:
+            return (0, 0)
+        dt.template = template_body
+        dt.model_fields = model_fields
+        dt.annotate_fields = annotate_fields
+        dt.fields = fields
+        dt.raw_object = raw_object
+        dt.context_object = context_object
+        dt.save()
+        DynamicRelationContext.objects.filter(dynamic_template=dt).delete()
+        updated = 1
+        created = 0
+    else:
+        dt = DynamicTemplate.objects.create(
+            label=label,
+            content_type=ct,
+            template=template_body,
+            model_fields=model_fields,
+            annotate_fields=annotate_fields,
+            fields=fields,
+            raw_object=raw_object,
+            context_object=context_object,
+        )
+        created, updated = 1, 0
+
+    rels = item.get("relation_contexts") or []
+    if not isinstance(rels, list):
+        raise ValueError("relation_contexts must be a list")
+    for rel in rels:
+        if not isinstance(rel, dict):
+            raise ValueError("Each relation_context must be an object")
+        r_ct = resolve_content_type(rel["content_type"])
+        DynamicRelationContext.objects.create(
+            dynamic_template=dt,
+            content_type=r_ct,
+            manager_method=str(rel.get("manager_method") or "objects.all"),
+            filter_spec=rel.get("filter_spec") or {},
+            filter_literal=rel.get("filter_literal") or {},
+            model_fields=rel.get("model_fields") or [],
+            annotate_fields=rel.get("annotate_fields") or [],
+            fields=rel.get("fields") or [],
+            name=str(rel.get("name", "")).strip(),
+        )
+    return (created, updated)