django-content-studio 1.0.0a1__py3-none-any.whl

content_studio/__init__.py

@@ -0,0 +1,7 @@
+__title__ = "Django Content Studio"
+__version__ = "1.0.0-canary.1"
+__author__ = "Leon van der Grient"
+__license__ = "BSD 3-Clause"
+
+# Version synonym
+VERSION = __version__

content_studio/admin.py

@@ -0,0 +1,154 @@
+from django.contrib.admin import *
+from rest_framework.request import HttpRequest
+
+from .dashboard import Dashboard
+from .form import FormSet, FormSetGroup
+from .login_backends import LoginBackendManager
+from .token_backends import TokenBackendManager
+
+
+class AdminSite(AdminSite):
+    """
+    Enhanced admin site for Django Content Studio and integration with
+    Django Content Framework.
+    """
+
+    token_backend = TokenBackendManager()
+
+    login_backend = LoginBackendManager()
+
+    dashboard = Dashboard()
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Add token backend's view set to the
+        # Content Studio router.
+        self.token_backend.set_up_router()
+        # Add login backend's view set to the
+        # Content Studio router.
+        self.login_backend.set_up_router()
+
+
+admin_site = AdminSite()
+
+
+class ModelAdmin(ModelAdmin):
+    """
+    Enhanced model admin for Django Content Studio and integration with
+    Django Content Framework. Although it's relatively backwards compatible,
+    some default behavior has been changed.
+    """
+
+    # We set a lower limit than Django's default of 100
+    list_per_page = 20
+
+    # Configure the main section in the edit-view.
+    edit_main: list[type[FormSetGroup | FormSet | str]] = []
+
+    # Configure the sidebar in the edit-view.
+    edit_sidebar: list[type[FormSet | str]] = []
+
+    def save_model(self, request, obj, form, change):
+        if hasattr(obj, "edited_by"):
+            obj.edited_by = request.user
+        super().save_model(request, obj, form, change)
+
+    def has_add_permission(self, request):
+        is_singleton = getattr(self.model, "is_singleton", False)
+
+        # Don't allow to add more than one singleton object.
+        if is_singleton and self.model.objects.get():
+            return False
+
+        return super().has_add_permission(request)
+
+    def has_delete_permission(self, request, obj=None):
+        is_singleton = getattr(self.model, "is_singleton", False)
+
+        if is_singleton:
+            return False
+
+        return super().has_delete_permission(request, obj)
+
+    def render_change_form(self, request, context, *args, **kwargs):
+        is_singleton = getattr(self.model, "is_singleton", False)
+
+        context["show_save_and_add_another"] = not is_singleton
+
+        return super().render_change_form(request, context, *args, **kwargs)
+
+
+class AdminSerializer:
+    """
+    Class for serializing Django admin classes.
+    """
+
+    def __init__(self, admin_class: ModelAdmin):
+        self.admin_class = admin_class
+
+    def serialize(self, request: HttpRequest):
+        admin_class = self.admin_class
+
+        return {
+            "edit": {
+                "main": self.serialize_edit_main(request),
+                "sidebar": self.serialize_edit_sidebar(request),
+            },
+            "list": {
+                "per_page": admin_class.list_per_page,
+            },
+            "permissions": {
+                "add_permission": admin_class.has_add_permission(request),
+                "delete_permission": admin_class.has_delete_permission(request),
+                "change_permission": admin_class.has_change_permission(request),
+                "view_permission": admin_class.has_view_permission(request),
+            },
+        }
+
+    def serialize_edit_main(self, request):
+        admin_class = self.admin_class
+
+        return [
+            i.serialize()
+            for i in self.get_edit_main(
+                getattr(admin_class, "edit_main", admin_class.get_fields(request))
+            )
+        ]
+
+    def serialize_edit_sidebar(self, request):
+        admin_class = self.admin_class
+
+        return [
+            i.serialize()
+            for i in self.get_edit_sidebar(getattr(admin_class, "edit_sidebar", None))
+        ]
+
+    def get_edit_main(self, edit_main):
+        """
+        Returns a normalized list of form set groups.
+
+        Form sets will be wrapped in a form set group. If the edit_main attribute is a list of fields,
+        they are wrapped in a form set and a form set group.
+        """
+        if not edit_main:
+            return []
+        if isinstance(edit_main[0], FormSetGroup):
+            return edit_main
+        if isinstance(edit_main[0], FormSet):
+            return [FormSetGroup(formsets=edit_main)]
+
+        return [FormSetGroup(formsets=[FormSet(fields=edit_main)])]
+
+    def get_edit_sidebar(self, edit_sidebar):
+        """
+        Returns a normalized list of form sets for the edit_sidebar.
+
+        If the edit_sidebar attribute is a list of fields,
+        they are wrapped in a form set.
+        """
+        if not edit_sidebar:
+            return []
+        if isinstance(edit_sidebar[0], FormSet):
+            return edit_sidebar
+
+        return [FormSet(fields=edit_sidebar)]

content_studio/apps.py

@@ -0,0 +1,59 @@
+from django.apps import AppConfig
+from django.contrib import admin
+from rest_framework import serializers
+
+from headless.utils import is_runserver
+from . import VERSION
+
+
+class DjangoContentStudioConfig(AppConfig):
+    name = "content_studio"
+    label = "content_studio"
+    initialized = False
+
+    def ready(self):
+        from .utils import log
+
+        if is_runserver() and not self.initialized:
+            self.initialized = True
+
+            log("\n")
+            log("----------------------------------------")
+            log("Django Content Studio")
+            log(f"Version {VERSION}")
+            log("----------------------------------------")
+            log(":rocket:", "Starting Django Content Studio")
+            log(":mag:", "Discovering admin models...")
+            registered_models = len(admin.site._registry)
+            log(
+                ":white_check_mark:",
+                f"[green]Found {registered_models} admin models[/green]",
+            )
+            self._create_crud_api()
+            log("\n")
+
+    def _create_crud_api(self):
+        from .viewsets import BaseModelViewSet
+        from .router import content_studio_router
+        from .utils import log
+
+        for _model, admin_model in admin.site._registry.items():
+
+            class Serializer(serializers.ModelSerializer):
+                class Meta:
+                    model = _model
+                    fields = "__all__"
+
+            class ViewSet(BaseModelViewSet):
+                serializer_class = Serializer
+                queryset = _model.objects.all()
+
+            content_studio_router.register(
+                f"api/content/{_model._meta.label_lower}",
+                ViewSet,
+                f"content_studio_api-{_model._meta.label_lower}",
+            )
+        log(
+            ":white_check_mark:",
+            f"[green]Created CRUD API[/green]",
+        )

content_studio/dashboard.py

@@ -0,0 +1,7 @@
+class Dashboard:
+    """
+    The Dashboard class is used to define the structure of the dashboard
+    in Django Content Studio.
+    """
+
+    pass

content_studio/form.py

@@ -0,0 +1,76 @@
+class Field:
+    """
+    Field class for configuring the fields in content edit views in Django Content Studio.
+    """
+
+    def __init__(self, name: str, col_span: int = 1):
+        self.name = name
+        self.col_span = col_span
+
+    def serialize(self):
+        return {
+            "name": self.name,
+            "col_span": self.col_span,
+        }
+
+
+class FieldLayout:
+    """
+    Field layout class for configuring the layout of fields in content edit views in Django Content Studio.
+    """
+
+    def __init__(self, fields: list[str | Field] = None, columns: int = 1):
+        self.fields = fields or []
+        self.columns = columns
+
+    def serialize(self):
+        return {
+            "fields": [
+                field.serialize() if isinstance(field, Field) else field
+                for field in self.fields
+            ],
+            "columns": self.columns,
+        }
+
+
+class FormSet:
+    """
+    Formset class for configuring the blocks of fields in content edit views
+    in Django Content Studio.
+    """
+
+    def __init__(
+        self,
+        title: str = "",
+        description: str = "",
+        fields: list[str | Field | FieldLayout] = None,
+    ):
+        self.title = title
+        self.description = description
+        self.fields = fields or []
+
+    def serialize(self):
+        return {
+            "title": self.title,
+            "description": self.description,
+            "fields": [
+                field.serialize() if isinstance(field, (Field, FieldLayout)) else field
+                for field in self.fields
+            ],
+        }
+
+
+class FormSetGroup:
+    """
+    Formset group class for configuring the groups of form sets in content edit views.
+    """
+
+    def __init__(self, label: str = "", formsets: list[FormSet] = None):
+        self.label = label
+        self.formsets = formsets or []
+
+    def serialize(self):
+        return {
+            "label": self.label,
+            "formsets": [formset.serialize() for formset in self.formsets],
+        }

content_studio/login_backends/__init__.py

@@ -0,0 +1,21 @@
+from .username_password import UsernamePasswordBackend
+from ..router import content_studio_router
+from ..settings import cs_settings
+
+
+class LoginBackendManager:
+    """
+    Manages different login backends for use by
+    Content Studio.
+    """
+
+    def __init__(self, **kwargs):
+        self.active_backends = cs_settings.LOGIN_BACKENDS
+
+    def set_up_router(self):
+        for backend in self.active_backends:
+            content_studio_router.register(
+                f"api/login/{backend.__name__.lower().replace('backend', '')}",
+                backend.view_set,
+                basename="content_studio_login_backend",
+            )

content_studio/login_backends/username_password.py

@@ -0,0 +1,79 @@
+from django.contrib.auth import get_user_model, authenticate
+from rest_framework import serializers
+from rest_framework.exceptions import PermissionDenied
+from rest_framework.permissions import AllowAny
+from rest_framework.renderers import JSONRenderer
+from rest_framework.viewsets import ViewSet
+
+
+class UsernamePasswordSerializer(serializers.Serializer):
+    username = serializers.CharField(required=True)
+    password = serializers.CharField(required=True)
+
+
+class UsernamePasswordViewSet(ViewSet):
+    """
+    View set for username and password endpoints.
+    """
+
+    permission_classes = [AllowAny]
+    renderer_classes = [JSONRenderer]
+
+    def create(self, request):
+        serializer = UsernamePasswordSerializer(data=request.data)
+
+        serializer.is_valid(raise_exception=True)
+
+        user = UsernamePasswordBackend.login(
+            username=serializer.validated_data["username"],
+            password=serializer.validated_data["password"],
+        )
+
+        if user is None or not user.is_active:
+            raise PermissionDenied()
+
+        from ..admin import admin_site
+
+        return admin_site.auth_backend.active_backend.get_response_for_user(user)
+
+
+class UsernamePasswordBackend:
+    name = "Username password"
+    view_set = UsernamePasswordViewSet
+
+    @classmethod
+    def get_info(cls):
+        """
+        Returns information about the backend.
+        """
+        user_model = get_user_model()
+        username_field = getattr(user_model, user_model.USERNAME_FIELD, None)
+
+        return {
+            "type": cls.__name__,
+            "config": {"username_field_type": username_field.field.__class__.__name__},
+        }
+
+    @classmethod
+    def login(cls, username, password):
+        """
+        Authenticates user using username and password.
+        Returns the user if successful, None otherwise.
+        """
+        return authenticate(username=username, password=password)
+
+    def request_password_reset(self, username):
+        """
+        Sends a password reset email.
+        """
+        raise NotImplemented(
+            "You need to implement a method for sending a password reset token."
+        )
+
+    def complete_password_reset(self, reset_token, new_password):
+        """
+        Sets the new password based on the reset token.
+        """
+        raise NotImplemented(
+            "You need to implement a method for validating a reset token and setting a new password."
+        )

content_studio/models.py

@@ -0,0 +1,86 @@
+from django.db import models
+
+from content_framework import fields as cf_fields
+from . import widgets
+from .utils import is_jsonable
+
+
+class ModelSerializer:
+    def __init__(self, model: type[models.Model]):
+        self.model = model
+
+    widgets = {
+        models.CharField: widgets.InputWidget,
+        models.IntegerField: widgets.InputWidget,
+        models.SmallIntegerField: widgets.InputWidget,
+        models.BigIntegerField: widgets.InputWidget,
+        models.PositiveIntegerField: widgets.InputWidget,
+        models.PositiveSmallIntegerField: widgets.InputWidget,
+        models.PositiveBigIntegerField: widgets.InputWidget,
+        models.FloatField: widgets.InputWidget,
+        models.DecimalField: widgets.InputWidget,
+        models.SlugField: widgets.SlugWidget,
+        models.TextField: widgets.TextAreaWidget,
+        models.BooleanField: widgets.BooleanWidget,
+        models.NullBooleanField: widgets.BooleanWidget,
+        cf_fields.MultipleChoiceField: widgets.MultipleChoiceWidget,
+        cf_fields.TagField: widgets.TagWidget,
+        cf_fields.HTMLField: widgets.RichTextWidget,
+        cf_fields.URLPathField: widgets.URLPathWidget,
+    }
+
+    def serialize(self):
+        model = self.model
+
+        return {
+            "label": model._meta.label,
+            "verbose_name": model._meta.verbose_name,
+            "verbose_name_plural": model._meta.verbose_name_plural,
+            "fields": self.get_fields(),
+        }
+
+    def get_fields(self):
+        fields = {}
+
+        for field in self.model._meta.fields:
+            fields[field.name] = self.get_field(field)
+
+        return fields
+
+    def get_field(self, field):
+        widget = self.get_widget(field)
+
+        data = {
+            "verbose_name": field.verbose_name,
+            "required": not field.null or not field.blank,
+        }
+
+        if field.help_text:
+            data["help_text"] = field.help_text
+
+        if is_jsonable(field.default):
+            data["default"] = field.default
+
+        if widget:
+            data["widget"] = widget
+
+        if not field.editable:
+            data["readonly"] = True
+
+        if field.primary_key:
+            data["primary_key"] = True
+            data["readonly"] = True
+
+        if getattr(field, "choices", None) is not None:
+            data["choices"] = field.choices
+
+        if getattr(field, "max_length", None) is not None:
+            data["max_length"] = field.max_length
+
+        return data
+
+    def get_widget(self, field):
+        try:
+            return self.widgets[field.__class__].__name__
+        except KeyError:
+            return None

content_studio/router.py

@@ -0,0 +1,14 @@
+from rest_framework.routers import DefaultRouter
+
+
+class ExtendedRouter(DefaultRouter):
+    def get_method_map(self, viewset, method_map):
+        _method_map = super().get_method_map(viewset, method_map)
+
+        if getattr(viewset, "is_singleton", False):
+            _method_map["patch"] = "update"
+
+        return _method_map
+
+
+content_studio_router = ExtendedRouter(trailing_slash=False)

content_studio/serializers.py

@@ -0,0 +1,16 @@
+from django.contrib.auth import get_user_model
+from rest_framework import serializers
+
+user_model = get_user_model()
+
+
+class CurrentUserSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = user_model
+        fields = (
+            "id",
+            user_model.USERNAME_FIELD,
+            user_model.EMAIL_FIELD,
+            "first_name",
+            "last_name",
+        )

content_studio/settings.py

@@ -0,0 +1,146 @@
+"""
+Settings for Django Content Studio are all namespaced in the CONTENT_STUDIO setting.
+For example your project's `settings.py` file might look like this:
+
+CONTENT_STUDIO = {
+    'AUTH_STRATEGIES': [
+        'content_studio.strategies.UsernamePasswordStrategy',
+    ],
+}
+
+This module provides the `api_setting` object, that is used to access
+Django Content Studio settings, checking for user settings first, then falling
+back to the defaults.
+"""
+
+from django.conf import settings
+
+from django.core.signals import setting_changed
+from django.utils.module_loading import import_string
+
+SETTINGS_NAMESPACE = "CONTENT_STUDIO"
+
+DEFAULTS = {
+    "LOGIN_BACKENDS": [
+        "content_studio.login_backends.UsernamePasswordBackend",
+    ],
+    "EDITED__BY_ATTR": "edited_by",
+    "EDITED_AT_ATTR": "edited_at",
+    "CREATED_BY_ATTR": "created_by",
+    "CREATED_AT_ATTR": "created_at",
+}
+
+
+# List of settings that may be in string import notation.
+IMPORT_STRINGS = [
+    "LOGIN_BACKENDS",
+]
+
+
+# List of settings that have been removed
+REMOVED_SETTINGS = []
+
+
+def perform_import(val, setting_name):
+    """
+    If the given setting is a string import notation,
+    then perform the necessary import or imports.
+    """
+    if val is None:
+        return None
+    elif isinstance(val, str):
+        return import_from_string(val, setting_name)
+    elif isinstance(val, (list, tuple)):
+        return [import_from_string(item, setting_name) for item in val]
+    return val
+
+
+def import_from_string(val, setting_name):
+    """
+    Attempt to import a class from a string representation.
+    """
+    try:
+        return import_string(val)
+    except ImportError as e:
+        msg = "Could not import '%s' for Content Studio setting '%s'. %s: %s." % (
+            val,
+            setting_name,
+            e.__class__.__name__,
+            e,
+        )
+        raise ImportError(msg)
+
+
+class ContentStudioSettings:
+    """
+    A settings object that allows Django Content Studio settings to be accessed as
+    properties. For example:
+
+        from content_studio.settings import api_settings
+        print(api_settings.AUTH_STRATEGIES)
+
+    Any setting with string import paths will be automatically resolved
+    and return the class, rather than the string literal.
+    """
+
+    def __init__(self, user_settings=None, defaults=None, import_strings=None):
+        if user_settings:
+            self._user_settings = self.__check_user_settings(user_settings)
+        self.defaults = defaults or DEFAULTS
+        self.import_strings = import_strings or IMPORT_STRINGS
+        self._cached_attrs = set()
+
+    @property
+    def user_settings(self):
+        if not hasattr(self, "_user_settings"):
+            self._user_settings = getattr(settings, SETTINGS_NAMESPACE, {})
+        return self._user_settings
+
+    def __getattr__(self, attr):
+        if attr not in self.defaults:
+            raise AttributeError("Invalid Content Studio setting: '%s'" % attr)
+
+        try:
+            # Check if present in user settings
+            val = self.user_settings[attr]
+        except KeyError:
+            # Fall back to defaults
+            val = self.defaults[attr]
+
+        # Coerce import strings into classes
+        if attr in self.import_strings:
+            val = perform_import(val, attr)
+
+        # Cache the result
+        self._cached_attrs.add(attr)
+        setattr(self, attr, val)
+        return val
+
+    def __check_user_settings(self, user_settings):
+        SETTINGS_DOC = "https://www.django-content-studio.org/settings/"
+        for setting in REMOVED_SETTINGS:
+            if setting in user_settings:
+                raise RuntimeError(
+                    "The '%s' setting has been removed. Please refer to '%s' for available settings."
+                    % (setting, SETTINGS_DOC)
+                )
+        return user_settings
+
+    def reload(self):
+        for attr in self._cached_attrs:
+            delattr(self, attr)
+        self._cached_attrs.clear()
+        if hasattr(self, "_user_settings"):
+            delattr(self, "_user_settings")
+
+
+cs_settings = ContentStudioSettings(None, DEFAULTS, IMPORT_STRINGS)
+
+
+def reload_settings(*args, **kwargs):
+    setting = kwargs["setting"]
+    if setting == SETTINGS_NAMESPACE:
+        cs_settings.reload()
+
+
+setting_changed.connect(reload_settings)

content_studio/templates/content_studio/index.html

@@ -0,0 +1,20 @@
+{% load static %}
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="icon" href={% static 'content_studio/icon.png' %}>
+    <title>Django Content Studio</title>
+    <script>
+        window.DCS_STATIC_PREFIX = "{% static '' %}content_studio/";
+        window.DCS_BASENAME = "{% url 'content_studio' %}";
+        window.DCS_API_URL = "{% url 'headless_rest' %}";
+    </script>
+  <script type="module" crossorigin src="{% static 'content_studio/assets/index.js' %}"></script>
+  <link rel="stylesheet" crossorigin href="{% static 'content_studio/assets/index.css' %}">
+</head>
+<body>
+    <div id="root"></div>
+</body>
+</html>

content_studio/token_backends/__init__.py

@@ -0,0 +1,39 @@
+from django.core.exceptions import ImproperlyConfigured
+
+from .jwt import SimpleJwtBackend
+from ..router import content_studio_router
+
+
+class TokenBackendManager:
+    """
+    Manages different token authentication backends for use by
+    Content Studio.
+
+    While login backends are used to identify a user,
+    token backends determine are used to authenticate
+    communication between Content Studio and the admin API.
+    """
+
+    available_backends = [SimpleJwtBackend]
+    _active_backend = None
+
+    @property
+    def active_backend(self):
+        if self._active_backend:
+            return self._active_backend
+
+        for backend in self.available_backends:
+            if backend.is_available:
+                self._active_backend = backend
+                return backend
+
+        raise ImproperlyConfigured(
+            "You need to install at least one of the support authentication backends."
+        )
+
+    def set_up_router(self):
+        content_studio_router.register(
+            f"api/tokens/{self.active_backend.__name__.lower().replace('backend', '')}",
+            self.active_backend.view_set,
+            basename="content_studio_token_backend",
+        )

content_studio/token_backends/jwt.py

@@ -0,0 +1,61 @@
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework.viewsets import ViewSet
+
+
+class SimpleJwtViewSet(ViewSet):
+    @action(
+        detail=False, methods=["post"], permission_classes=[], authentication_classes=[]
+    )
+    def refresh(self, request):
+        from rest_framework_simplejwt.views import TokenRefreshView
+
+        view_instance = TokenRefreshView()
+        view_instance.request = request
+        view_instance.format_kwarg = None
+        return view_instance.post(request)
+
+
+class SimpleJwtBackend:
+    name = "Simple JWT"
+    authentication_class = None
+    view_set = SimpleJwtViewSet
+
+    def __init__(self):
+        from rest_framework_simplejwt.authentication import JWTAuthentication
+
+        self.authentication_class = JWTAuthentication
+
+    @classmethod
+    def get_info(cls):
+
+        from rest_framework_simplejwt.settings import api_settings as simplejwt_settings
+
+        return {
+            "type": cls.__name__,
+            "settings": {
+                "ACCESS_TOKEN_LIFETIME": simplejwt_settings.ACCESS_TOKEN_LIFETIME.total_seconds(),
+            },
+        }
+
+    @property
+    def is_available(self) -> bool:
+        try:
+            import rest_framework_simplejwt
+
+            return True
+        except ImportError:
+            return False
+
+    @classmethod
+    def get_response_for_user(cls, user):
+        from rest_framework_simplejwt.tokens import RefreshToken
+
+        refresh = RefreshToken.for_user(user)
+
+        return Response(
+            {
+                "refresh": str(refresh),
+                "access": str(refresh.access_token),
+            }
+        )

content_studio/urls.py

@@ -0,0 +1,12 @@
+from django.urls import re_path
+
+from .router import content_studio_router
+from .views import ContentStudioWebAppView, AdminApiViewSet
+
+content_studio_router.register("api", AdminApiViewSet, "content_studio_admin")
+
+urlpatterns = content_studio_router.urls + [
+    re_path(
+        "^(?!api).*$", ContentStudioWebAppView.as_view(), name="content_studio_web"
+    ),
+]

content_studio/utils.py

@@ -0,0 +1,30 @@
+import json
+import sys
+
+from rich.console import Console
+
+console = Console()
+
+
+def log(*args, **kwargs):
+    console.print(*args, **kwargs)
+
+
+def is_runserver():
+    """
+    Checks if the Django application is started as a server.
+    We'll also assume it started if manage.py is not used (e.g. when Django is started using wsgi/asgi).
+    The main purpose of this check is to not run certain code on other management commands such
+    as `migrate`.
+    """
+    is_manage_cmd = sys.argv[0].endswith("/manage.py")
+
+    return not is_manage_cmd or sys.argv[1] == "runserver"
+
+
+def is_jsonable(x):
+    try:
+        json.dumps(x)
+        return True
+    except (TypeError, OverflowError):
+        return False

content_studio/views.py

@@ -0,0 +1,94 @@
+from django.contrib import admin
+from django.urls import reverse, NoReverseMatch
+from django.views.generic import TemplateView
+from rest_framework.decorators import action
+from rest_framework.permissions import IsAdminUser, AllowAny
+from rest_framework.renderers import JSONRenderer
+from rest_framework.response import Response
+from rest_framework.viewsets import ViewSet
+
+from .admin import AdminSerializer, admin_site
+from .models import ModelSerializer
+from .serializers import CurrentUserSerializer
+
+
+class ContentStudioWebAppView(TemplateView):
+    """
+    View for rendering the content studio web app.
+    """
+
+    template_name = "content_studio/index.html"
+
+
+class AdminApiViewSet(ViewSet):
+    """
+    Viewset for special admin endpoints.
+    """
+
+    permission_classes = [IsAdminUser]
+    renderer_classes = [JSONRenderer]
+
+    @action(
+        methods=["get"],
+        detail=False,
+        url_path="info",
+        permission_classes=[AllowAny],
+    )
+    def info(self, request):
+        """
+        Returns public information about the Content Studio admin.
+        """
+
+        data = {
+            "site_header": admin_site.site_header,
+            "site_title": admin_site.site_title,
+            "index_title": admin_site.index_title,
+            "site_url": admin_site.site_url,
+            "health_check": get_health_check_path(),
+            "login_backends": [
+                backend.get_info()
+                for backend in admin_site.login_backend.active_backends
+            ],
+            "token_backend": admin_site.token_backend.active_backend.get_info(),
+        }
+
+        return Response(data=data)
+
+    @action(
+        methods=["get"],
+        detail=False,
+        url_path="discover",
+    )
+    def discover(
+        self,
+        request,
+    ):
+        """
+        Returns information about the Django app (models, admin models, admin site, settings, etc.).
+        """
+        data = {"models": []}
+        registered_models = admin.site._registry
+
+        for model, admin_class in registered_models.items():
+            data["models"].append(
+                {
+                    **ModelSerializer(model).serialize(),
+                    "admin": AdminSerializer(admin_class).serialize(request),
+                }
+            )
+
+        return Response(data=data)
+
+    @action(methods=["get"], detail=False, url_path="me")
+    def me(self, request):
+        """
+        Returns information about the current user.
+        """
+        return Response(CurrentUserSerializer(request.user).data)
+
+
+def get_health_check_path():
+    try:
+        return reverse("healthcheck")
+    except NoReverseMatch:
+        return None

content_studio/viewsets.py

@@ -0,0 +1,128 @@
+from django.contrib.admin.models import LogEntry, ADDITION, CHANGE, DELETION
+from django.contrib.contenttypes.models import ContentType
+from rest_framework.exceptions import MethodNotAllowed, NotFound
+from rest_framework.filters import SearchFilter, OrderingFilter
+from rest_framework.pagination import PageNumberPagination
+from rest_framework.parsers import JSONParser
+from rest_framework.permissions import DjangoModelPermissions
+from rest_framework.renderers import JSONRenderer
+from rest_framework.viewsets import ModelViewSet
+
+from .admin import admin_site
+from .settings import cs_settings
+
+
+class BaseModelViewSet(ModelViewSet):
+    lookup_field = "id"
+    parser_classes = [JSONParser]
+    renderer_classes = [JSONRenderer]
+    permission_classes = [DjangoModelPermissions]
+    pagination_class = [PageNumberPagination]
+    filter_backends = [SearchFilter, OrderingFilter]
+
+    def __init__(self):
+        super(BaseModelViewSet, self).__init__()
+
+        self.authentication_classes = [
+            admin_site.auth_backend.active_backend.authentication_class
+        ]
+
+    def retrieve(self, request, *args, **kwargs):
+        """
+        Disable this endpoint for singletons. They should use
+        the list endpoint instead.
+        """
+        if self.is_singleton:
+            raise MethodNotAllowed(
+                method="GET",
+                detail="Singleton objects do not support the retrieve endpoint.",
+            )
+
+        return super().retrieve(request, *args, **kwargs)
+
+    def update(self, request, *args, **kwargs):
+        """
+        We overwrite the update method to support singletons. If a singleton
+        doesn't exist it will be created.
+        """
+        if self.is_singleton:
+            try:
+                super().update(request, *args, **kwargs)
+            except NotFound:
+                self.create(request, *args, **kwargs)
+
+        return super().update(request, *args, **kwargs)
+
+    def list(self, request, *args, **kwargs):
+        """
+        We overwrite the list method to support singletons. If a singleton
+        doesn't exist this will raise a NotFound exception.
+        """
+        if self.is_singleton:
+            return super().retrieve(request, *args, **kwargs)
+
+        return super().list(request, *args, **kwargs)
+
+    def perform_create(self, serializer):
+        instance = serializer.save()
+
+        if hasattr(instance, cs_settings.CREATED_BY):
+            setattr(instance, cs_settings.CREATED_BY, self.request.user)
+            instance.save()
+
+        content_type = ContentType.objects.get_for_model(instance)
+        LogEntry.objects.create(
+            user=self.request.user,
+            action_flag=ADDITION,
+            content_type=content_type,
+            object_id=instance.id,
+            object_repr=str(instance)[:200],
+            change_message="",
+        )
+
+    def perform_update(self, serializer):
+        instance = serializer.save()
+
+        if hasattr(instance, cs_settings.EDITED_BY):
+            setattr(instance, cs_settings.EDITED_BY, self.request.user)
+            instance.save()
+
+        content_type = ContentType.objects.get_for_model(instance)
+        LogEntry.objects.create(
+            user=self.request.user,
+            action_flag=CHANGE,
+            content_type=content_type,
+            object_id=instance.id,
+            object_repr=str(instance)[:200],
+            change_message="",
+        )
+
+    def perform_destroy(self, instance):
+        content_type = ContentType.objects.get_for_model(instance)
+        LogEntry.objects.create(
+            user=self.request.user,
+            action_flag=DELETION,
+            content_type=content_type,
+            object_id=instance.id,
+            object_repr=str(instance)[:200],
+            change_message="",
+        )
+
+        instance.delete()
+
+    def get_object(self):
+        """
+        We overwrite this method to add support for singletons.
+        If a singleton doesn't exist it will raise a NotFound exception.
+        """
+        if self.is_singleton:
+            try:
+                return self.get_queryset().get()
+            except self.queryset.model.DoesNotExist:
+                raise NotFound()
+
+        return super().get_object()
+
+    @property
+    def is_singleton(self):
+        return getattr(self.get_queryset().model, "is_singleton", False)

content_studio/widgets.py

@@ -0,0 +1,30 @@
+class InputWidget:
+    pass
+
+
+class TextAreaWidget:
+    pass
+
+
+class BooleanWidget:
+    pass
+
+
+class TagWidget:
+    pass
+
+
+class RichTextWidget:
+    pass
+
+
+class MultipleChoiceWidget:
+    pass
+
+
+class URLPathWidget:
+    pass
+
+
+class SlugWidget:
+    pass

django_content_studio-1.0.0a1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Leon van der Grient
+
+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_content_studio-1.0.0a1.dist-info/METADATA

@@ -0,0 +1,88 @@
+Metadata-Version: 2.3
+Name: django-content-studio
+Version: 1.0.0a1
+Summary: Modern & flexible Django admin
+License: MIT
+Author: Leon van der Grient
+Author-email: leon@devtastic.io
+Requires-Python: >=3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Description-Content-Type: text/markdown
+
+# Django Content Studio
+
+[![PyPI version](https://badge.fury.io/py/django-content-studio.svg)](https://badge.fury.io/py/django-content-studio)
+[![Python versions](https://img.shields.io/pypi/pyversions/django-content-studio.svg)](https://pypi.org/project/django-content-studio/)
+[![Django versions](https://img.shields.io/badge/django-5.0%2B-blue.svg)](https://www.djangoproject.com/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Django Content Studio is a modern, flexible alternative to the Django admin.
+
+> This package is still under development
+
+## 🚀 Quick Start
+
+### Installation
+
+☝️ Django Content Studio depends on Django and Django Rest Framework.
+
+```bash
+pip install django-content-studio
+```
+
+### Add to Django Settings
+
+```python
+# settings.py
+INSTALLED_APPS = [
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+    'rest_framework',
+    'content_studio',  # Add this
+    # ... your apps
+]
+```
+### Add URLs
+
+```python
+# urls.py
+urlpatterns = [
+    path("admin/", include("content_studio.urls")),
+    # ... your urls
+]
+```
+
+## 🐛 Issues & Support
+
+- 🐛 **Bug Reports**: [GitHub Issues](https://github.com/StructuralRealist/django-content-studio/issues)
+- 💬 **Discussions**: [GitHub Discussions](https://github.com/StructuralRealist/django-content-studio/discussions)
+- 📧 **Email**: leon@devtastic.io
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- Built with React and Tailwind CSS
+- Inspired by the original Django admin
+- Thanks to all contributors and the Django community
+
+## 🔗 Links
+
+- [PyPI Package](https://pypi.org/project/django-content-studio/)
+- [GitHub Repository](https://github.com/StructuralRealist/django-content-studio)
+- [Changelog](CHANGELOG.md)
+
+---
+
+Made in Europe 🇪🇺 with 💚 for Django

django_content_studio-1.0.0a1.dist-info/RECORD

@@ -0,0 +1,23 @@
+content_studio/__init__.py,sha256=9XVz23GA6n6RDutB7K90md10AoDlSqDnilzAo1VCvhc,172
+content_studio/admin.py,sha256=H5gx6RKljSITL9UtE3yech97o2ZZhALgS9Mf0yWechA,4812
+content_studio/apps.py,sha256=OmOcBLnzUnP5T8oOd1iTrNNnrDRHUsX6WMQQV1IEc00,1880
+content_studio/dashboard.py,sha256=ptQ-cYp9ltsWeO3YK7Q_7WGgYwwzuM6zU0rxcuybjw4,146
+content_studio/form.py,sha256=-SZZ_OBCgn023GWMJEQqVdyZLA2hqDtDCdrqVLB4mNE,2006
+content_studio/login_backends/__init__.py,sha256=hgPJh9hFobubImfhynaeZ_dku3sjqNQvN5B43TVg7Gw,643
+content_studio/login_backends/username_password.py,sha256=QRkilK5E2S2o6xfK_jK64OdJ93Ima3lRYnvjncnVaH8,2441
+content_studio/models.py,sha256=Kk4Hw3T3impuWZ5Pfq1259KILq3wyqIBsXfA0MyuA3A,2613
+content_studio/router.py,sha256=7Up_sipGaUDoY6ElJNRf85ADaYfJCWV4To523L4LGuw,393
+content_studio/serializers.py,sha256=uOUXe7aDpgYN6B5rlZsN1_pFSPspV5exg3L7RxsTEhg,393
+content_studio/settings.py,sha256=wbwNN_RAk6Sv8hlB02dOveqUCzc-TVThau5rO47ANS0,4306
+content_studio/templates/content_studio/index.html,sha256=nzCbBJGhZijNYszIMB-NvCIqCP7KzDbpleKH1dVOw-c,729
+content_studio/token_backends/__init__.py,sha256=dO3aWIHXX8He399ZEvlS4fNgyL84OY9TEtkva9b5N5Q,1183
+content_studio/token_backends/jwt.py,sha256=Gd0IuhS6rjCzjTqkHWFMSpIt-x-07Jgr59moAVympBw,1667
+content_studio/urls.py,sha256=Rkb6QuyAGtn8MqkK7GmyVJXAq-q0mQT3CedhBSaCOr0,367
+content_studio/utils.py,sha256=8MibAxBgSZASZjPbPPpW9KplCUSHlM4TbUMkCNh5SDs,707
+content_studio/views.py,sha256=FR9CxuYJ-YiSVnxiFEwZlfpWfFSKv1hKtbUB6PC5qDE,2662
+content_studio/viewsets.py,sha256=sWbPRXm6UEkKUYPCjALZACWbixwI68BO_WB6Z2pj0Pg,4342
+content_studio/widgets.py,sha256=cBGvFrklzDkbwa39jhXc4Jp-kvykahpA01yk307VRXw,254
+django_content_studio-1.0.0a1.dist-info/LICENSE,sha256=Wnx2EJhtSNnXE5Qs80i1HTBNFZTi8acEtC5TYqtFlnQ,1075
+django_content_studio-1.0.0a1.dist-info/METADATA,sha256=GQq4ncwdxjf3FW2dW_jJUsaie0Lv0EVq0l2qhmNj8e4,2555
+django_content_studio-1.0.0a1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+django_content_studio-1.0.0a1.dist-info/RECORD,,

django_content_studio-1.0.0a1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.3
+Root-Is-Purelib: true
+Tag: py3-none-any