django-structured-metaobjects 1.0.0__py2.py3-none-any.whl

structured_metaobjects/schema_builder.py

@@ -0,0 +1,166 @@
+from enum import Enum
+from typing import Annotated, List, Optional
+
+from pydantic import ConfigDict, Field, model_validator
+from structured.pydantic.conditionals import When, conditional_schema
+from structured.pydantic.models import BaseModel
+
+
+def _target_model_enum(schema: dict) -> None:
+    """
+    Inject an enum of all installed Django models into the JSON schema.
+
+    For ``Optional[str]`` Pydantic emits ``anyOf: [{type: string}, {type: null}]``.
+    A sibling ``enum`` at that level is ignored by most JSON Schema editors,
+    so we place the enum inside the string branch instead.
+    """
+    from django.apps import apps
+
+    enum = sorted(f"{m._meta.app_label}.{m.__name__}" for m in apps.get_models())
+    for branch in schema.get("anyOf", []):
+        if branch.get("type") == "string":
+            branch["enum"] = enum
+            return
+    schema["enum"] = enum
+
+
+class SelectChoice(BaseModel):
+    """A single option for a ``select`` field."""
+    value: str = Field(min_length=1)
+    label: str = ""
+
+    @model_validator(mode="after")
+    def _fill_label(self):
+        if not self.label:
+            self.label = self.value
+        return self
+
+
+class MetaFieldKind(str, Enum):
+    string = "string"
+    html = "html"
+    number = "number"
+    boolean = "boolean"
+    date = "date"
+    datetime = "datetime"
+    select = "select"
+    ref = "ref"
+    queryset = "queryset"
+    group = "group"
+    list = "list"
+
+
+class MetaTypeFieldDef(BaseModel):
+    """
+    Describes a single field declared by an editor on a ``MetaType``.
+
+    The full ``MetaType.schema`` is a list of these (possibly nested via
+    ``children``).
+
+    Fields are conditionally shown/required based on ``kind``:
+
+    - ``target_model`` — ``ref``, ``queryset``
+    - ``children`` — ``group``, ``list``
+    - ``choices`` — ``select``
+    - ``multiline``, ``placeholder``, ``min_length``, ``max_length`` — ``string``
+    - ``placeholder`` (also) — ``html``
+    - ``integer``, ``minimum``, ``maximum`` — ``number``
+    """
+
+    # ── common ───────────────────────────────────────────────────────────
+    name: str = Field(min_length=1)
+    label: str = ""
+    kind: MetaFieldKind = MetaFieldKind.string
+    required: bool = False
+    translated: bool = False
+
+    # ── ref / queryset ───────────────────────────────────────────────────
+    target_model: Annotated[
+        Optional[str],
+        Field(default=None, json_schema_extra=_target_model_enum),
+    ] = None
+
+    # ── group / list ─────────────────────────────────────────────────────
+    children: List["MetaTypeFieldDef"] = Field(default_factory=list)
+
+    # ── select ───────────────────────────────────────────────────────────
+    choices: List[SelectChoice] = Field(default_factory=list)
+
+    # ── string ───────────────────────────────────────────────────────────
+    multiline: bool = False
+    min_length: Optional[int] = None
+    max_length: Optional[int] = None
+
+    # ── string / html ────────────────────────────────────────────────────
+    placeholder: str = ""
+
+    # ── number ───────────────────────────────────────────────────────────
+    integer: bool = False
+    minimum: Optional[float] = None
+    maximum: Optional[float] = None
+
+    model_config = ConfigDict(
+        json_schema_extra=conditional_schema(
+            When(
+                "kind",
+                in_=["ref", "queryset"],
+                controls=["target_model"],
+                then={"required": ["target_model"]},
+            ),
+            When(
+                "kind",
+                in_=["group", "list"],
+                controls=["children"],
+                then={"required": ["children"]},
+            ),
+            When(
+                "kind",
+                in_=["select"],
+                controls=["choices"],
+                then={"required": ["choices"]},
+            ),
+            When(
+                "kind",
+                in_=["string"],
+                controls=["multiline", "min_length", "max_length"],
+            ),
+            When(
+                "kind",
+                in_=["string", "html"],
+                controls=["placeholder"],
+            ),
+            When(
+                "kind",
+                in_=["number"],
+                controls=["integer", "minimum", "maximum"],
+            ),
+        )
+    )
+
+    @model_validator(mode="after")
+    def _validate_fields(self):
+        if not self.label:
+            self.label = self.name.replace("_", " ").replace("-", " ").title()
+        return self
+
+    @model_validator(mode="after")
+    def _validate_kind_dependencies(self):
+        if self.kind in (MetaFieldKind.ref, MetaFieldKind.queryset):
+            if not self.target_model:
+                raise ValueError(
+                    f"target_model is required when kind is '{self.kind.value}'"
+                )
+        if self.kind in (MetaFieldKind.group, MetaFieldKind.list):
+            if not self.children:
+                raise ValueError(
+                    f"children is required when kind is '{self.kind.value}'"
+                )
+        if self.kind == MetaFieldKind.select:
+            if not self.choices:
+                raise ValueError(
+                    "choices is required when kind is 'select'"
+                )
+        return self
+
+
+MetaTypeFieldDef.model_rebuild()

structured_metaobjects/serializers.py

@@ -0,0 +1,37 @@
+from rest_framework import serializers
+from rest_framework.exceptions import ValidationError as DRFValidationError
+
+from .models import MetaInstance, MetaType
+
+
+class MetaTypeSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = MetaType
+        fields = "__all__"
+
+
+class MetaInstanceSerializer(serializers.ModelSerializer):
+    data = serializers.JSONField()
+
+    class Meta:
+        model = MetaInstance
+        fields = "__all__"
+
+    def _resolve_meta_type(self, attrs):
+        meta_type = attrs.get("meta_type")
+        if meta_type is None and self.instance is not None:
+            meta_type = self.instance.meta_type
+        return meta_type
+
+    def validate(self, attrs):
+        attrs = super().validate(attrs)
+        meta_type = self._resolve_meta_type(attrs)
+        if meta_type is None:
+            raise DRFValidationError({"meta_type": "This field is required."})
+        model_cls = meta_type.get_pydantic_model()
+        try:
+            validated = model_cls.model_validate(attrs.get("data") or {})
+        except Exception as exc:
+            raise DRFValidationError({"data": str(exc)})
+        attrs["data"] = validated.model_dump(mode="json")
+        return attrs

structured_metaobjects/static/structured_metaobjects/admin/meta_instance.js

@@ -0,0 +1,23 @@
+// When the meta_type select changes on the MetaInstance add/change form,
+// reload the page with ?meta_type=<id> so the server-side form rebuilds
+// the "data" widget with the structured-json schema for the chosen type.
+(function () {
+  function init() {
+    var select = document.getElementById("id_meta_type");
+    if (!select) return;
+    select.addEventListener("change", function () {
+      var url = new URL(window.location.href);
+      if (select.value) {
+        url.searchParams.set("meta_type", select.value);
+      } else {
+        url.searchParams.delete("meta_type");
+      }
+      window.location.href = url.toString();
+    });
+  }
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", init);
+  } else {
+    init();
+  }
+})();

structured_metaobjects/urls.py

@@ -0,0 +1,12 @@
+from django.urls import include, path
+from rest_framework import routers
+
+from .views import MetaInstanceViewSet, MetaTypeViewSet
+
+router = routers.DefaultRouter()
+router.register(r"meta-types", MetaTypeViewSet, "meta-types")
+router.register(r"meta-instances", MetaInstanceViewSet, "meta-instances")
+
+urlpatterns = [
+    path("", include(router.urls)),
+]

structured_metaobjects/views.py

@@ -0,0 +1,35 @@
+from rest_framework import viewsets
+from rest_framework.decorators import action
+from rest_framework.exceptions import NotFound, ValidationError as DRFValidationError
+from rest_framework.response import Response
+
+from .models import MetaInstance, MetaType
+from .serializers import MetaInstanceSerializer, MetaTypeSerializer
+
+
+class MetaTypeViewSet(viewsets.ModelViewSet):
+    queryset = MetaType.objects.all()
+    serializer_class = MetaTypeSerializer
+    search_fields = ("name",)
+
+    @action(detail=True, methods=["get"], url_path="schema")
+    def schema(self, request, pk=None):
+        meta_type = self.get_object()
+        return Response(meta_type.get_json_schema())
+
+
+class MetaInstanceViewSet(viewsets.ModelViewSet):
+    queryset = MetaInstance.objects.select_related("meta_type")
+    serializer_class = MetaInstanceSerializer
+    search_fields = ()
+
+    @action(detail=False, methods=["get"], url_path="schema")
+    def schema(self, request):
+        meta_type_id = request.GET.get("meta_type")
+        if not meta_type_id:
+            raise DRFValidationError({"meta_type": "Query parameter required."})
+        try:
+            meta_type = MetaType.objects.get(pk=meta_type_id)
+        except MetaType.DoesNotExist:
+            raise NotFound("MetaType not found")
+        return Response(meta_type.get_json_schema())

tests/app/app/asgi.py

@@ -0,0 +1,5 @@
+import os
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'tests.app.app.settings')
+application = get_asgi_application()

tests/app/app/settings.py

@@ -0,0 +1,77 @@
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+SECRET_KEY = 'django-insecure-test-key-for-structured-metaobjects-only'
+
+DEBUG = True
+
+ALLOWED_HOSTS = []
+
+INSTALLED_APPS = [
+    'structured',
+    'structured_metaobjects',
+    'tests.app.test_module',
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+    'rest_framework',
+]
+
+MIDDLEWARE = [
+    'django.middleware.security.SecurityMiddleware',
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.common.CommonMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+]
+
+ROOT_URLCONF = 'tests.app.app.urls'
+
+TEMPLATES = [
+    {
+        'BACKEND': 'django.template.backends.django.DjangoTemplates',
+        'DIRS': [],
+        'APP_DIRS': True,
+        'OPTIONS': {
+            'context_processors': [
+                'django.template.context_processors.debug',
+                'django.template.context_processors.request',
+                'django.contrib.auth.context_processors.auth',
+                'django.contrib.messages.context_processors.messages',
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = 'tests.app.app.wsgi.application'
+
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3',
+        'NAME': BASE_DIR / 'db.sqlite3',
+    }
+}
+
+AUTH_PASSWORD_VALIDATORS = [
+    {'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator'},
+    {'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator'},
+    {'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator'},
+    {'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator'},
+]
+
+LANGUAGE_CODE = 'en-us'
+TIME_ZONE = 'UTC'
+USE_I18N = True
+USE_TZ = True
+
+STATIC_URL = 'static/'
+MEDIA_ROOT = Path(BASE_DIR / 'media')
+MEDIA_URL = '/media/'
+
+DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

tests/app/app/urls.py

@@ -0,0 +1,14 @@
+from django.contrib import admin
+from django.urls import path, include
+from rest_framework.routers import DefaultRouter
+from tests.app.test_module.views import PageViewSet
+
+router = DefaultRouter()
+router.register(r'pages', PageViewSet)
+
+urlpatterns = [
+    path("", include("structured.urls")),
+    path('admin/', admin.site.urls),
+    path('api/', include('structured_metaobjects.urls')),
+    path('api/', include(router.urls)),
+]

tests/app/app/wsgi.py

@@ -0,0 +1,5 @@
+import os
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'tests.app.app.settings')
+application = get_wsgi_application()

tests/app/test_module/admin.py

@@ -0,0 +1,8 @@
+from django.contrib import admin
+
+from .models import Page
+
+
+@admin.register(Page)
+class PageAdmin(admin.ModelAdmin):
+    list_display = ("title", "slug")

tests/app/test_module/apps.py

@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+
+class TestModuleConfig(AppConfig):
+    name = "tests.app.test_module"
+    label = "test_module"
+    verbose_name = "Test Module"
+    default_auto_field = "django.db.models.BigAutoField"

tests/app/test_module/migrations/0001_initial.py

@@ -0,0 +1,22 @@
+# Generated by Django 6.0.4 on 2026-04-10 07:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Page',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('title', models.CharField(max_length=200)),
+                ('slug', models.SlugField(blank=True, default='', max_length=200)),
+            ],
+        ),
+    ]

tests/app/test_module/models.py

@@ -0,0 +1,12 @@
+from django.db import models
+
+
+class Page(models.Model):
+    title = models.CharField(max_length=200)
+    slug = models.SlugField(max_length=200, blank=True, default="")
+
+    class Meta:
+        app_label = "test_module"
+
+    def __str__(self):
+        return self.title

tests/app/test_module/serializers.py

@@ -0,0 +1,9 @@
+from rest_framework import serializers
+
+from .models import Page
+
+
+class PageSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Page
+        fields = "__all__"

tests/app/test_module/views.py

@@ -0,0 +1,9 @@
+from rest_framework import viewsets
+
+from .models import Page
+from .serializers import PageSerializer
+
+
+class PageViewSet(viewsets.ModelViewSet):
+    queryset = Page.objects.all()
+    serializer_class = PageSerializer

tests/test_admin.py

@@ -0,0 +1,25 @@
+import pytest
+from django.contrib.admin.sites import AdminSite
+
+from structured_metaobjects.admin import MetaInstanceAdmin, MetaTypeAdmin
+from structured_metaobjects.models import MetaInstance, MetaType
+
+
+@pytest.mark.django_db
+class TestAdminRegistration:
+    def test_meta_type_admin_registered(self):
+        site = AdminSite()
+        admin = MetaTypeAdmin(MetaType, site)
+        assert admin.list_display == ("name",)
+
+    def test_meta_instance_admin_registered(self):
+        site = AdminSite()
+        admin = MetaInstanceAdmin(MetaInstance, site)
+        assert "meta_type" in admin.list_filter
+
+    def test_meta_instance_admin_uses_custom_form(self):
+        from structured_metaobjects.forms import MetaInstanceForm
+
+        site = AdminSite()
+        admin = MetaInstanceAdmin(MetaInstance, site)
+        assert admin.form is MetaInstanceForm