django-content-studio 1.0.0a1__tar.gz

django_content_studio-1.0.0a1/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,72 @@
+# 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/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__

django_content_studio-1.0.0a1/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)]

django_content_studio-1.0.0a1/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]",
+        )

django_content_studio-1.0.0a1/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

django_content_studio-1.0.0a1/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],
+        }

django_content_studio-1.0.0a1/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",
+            )

django_content_studio-1.0.0a1/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."
+        )

django_content_studio-1.0.0a1/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

django_content_studio-1.0.0a1/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)