django-admin-fieldsets-extra 0.1.0__py3-none-any.whl

django_admin_fieldsets_extra/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

django_admin_fieldsets_extra/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class DjangoAdminFieldsetsExtraConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "django_admin_fieldsets_extra"
+    label = "django_admin_fieldsets_extra"

django_admin_fieldsets_extra/checks.py

@@ -0,0 +1,79 @@
+"""System checks for ``FieldsetsExtraMixin``."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from django.core import checks
+
+from django_admin_fieldsets_extra.mixins import is_inline
+
+
+def check_fieldsets_with_inlines(model_admin: Any) -> list[checks.CheckMessage]:
+    errors: list[checks.CheckMessage] = []
+    name = type(model_admin).__qualname__
+    layout = model_admin.fieldsets_with_inlines
+
+    def error(msg: str, id: str) -> None:
+        errors.append(checks.Error(msg, obj=type(model_admin), id=id))
+
+    if not isinstance(layout, list | tuple):
+        error(
+            f"The value of '{name}.fieldsets_with_inlines' must be a list or tuple.",
+            "admin_fieldsets_extra.E001",
+        )
+        return errors
+
+    for index, entry in enumerate(layout):
+        if is_inline(entry):
+            continue
+        if not (
+            isinstance(entry, list | tuple)
+            and len(entry) == 2
+            and isinstance(entry[1], Mapping)
+            and "fields" in entry[1]
+        ):
+            error(
+                f"The value of '{name}.fieldsets_with_inlines[{index}]' must be a "
+                "fieldset — a (name, {'fields': ...}) pair — or an inline class.",
+                "admin_fieldsets_extra.E002",
+            )
+            continue
+        save_button = entry[1].get("save_button", False)
+        if not isinstance(save_button, bool):
+            error(
+                f"'save_button' in '{name}.fieldsets_with_inlines[{index}]' must "
+                "be True or False.",
+                "admin_fieldsets_extra.E004",
+            )
+
+    from django_admin_fieldsets_extra.mixins import FieldsetsExtraMixin
+
+    hook_overridden = (
+        type(model_admin).get_fieldsets_with_inlines
+        is not FieldsetsExtraMixin.get_fieldsets_with_inlines
+    )
+    if hook_overridden:
+        derived = model_admin._fieldsets_with_inlines_derived
+        for option in ("fieldsets", "inlines"):
+            if getattr(model_admin, option) and option not in derived:
+                errors.append(
+                    checks.Warning(
+                        f"'{name}' overrides 'get_fieldsets_with_inlines()' and "
+                        f"also sets '{option}', which is ignored whenever that "
+                        "method returns a layout.",
+                        hint=f"Remove '{option}', or return it from "
+                        "get_fieldsets_with_inlines() when there is no layout.",
+                        obj=type(model_admin),
+                        id="admin_fieldsets_extra.W001",
+                    )
+                )
+
+    for option in getattr(model_admin, "_fieldsets_with_inlines_conflicts", ()):
+        error(
+            f"'{name}' sets both 'fieldsets_with_inlines' and '{option}'; "
+            f"'{option}' is derived from 'fieldsets_with_inlines', remove it.",
+            "admin_fieldsets_extra.E003",
+        )
+    return errors

django_admin_fieldsets_extra/contrib/unfold.py

@@ -0,0 +1,95 @@
+"""django-unfold integration."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+try:
+    import unfold  # noqa: F401
+except ImportError as e:
+    raise ImportError(
+        "django_admin_fieldsets_extra.contrib.unfold requires django-unfold. "
+        "Install it with: pip install django-admin-fieldsets-extra[unfold]"
+    ) from e
+
+from django import forms
+from django.core import checks
+from django.http import HttpRequest, HttpResponse
+
+from django_admin_fieldsets_extra.mixins import FieldsetsExtraMixin, is_inline
+
+
+def is_tab(options: Mapping[str, Any]) -> bool:
+    """Whether a fieldset is one of Unfold's tabs (``"classes": ["tab"]``)."""
+    return "tab" in options.get("classes", ())
+
+
+class UnfoldFieldsetsExtraMixin(FieldsetsExtraMixin):
+    """``FieldsetsExtraMixin`` for Unfold's ``ModelAdmin``::
+
+        from unfold.admin import ModelAdmin
+
+        @admin.register(Author)
+        class AuthorAdmin(UnfoldFieldsetsExtraMixin, ModelAdmin):
+            fieldsets_with_inlines = [...]
+
+    Styles the save buttons with Unfold's colors (light and dark). Unfold's
+    tab fieldsets (``"classes": ["tab"]``) are rendered as its tabs, where
+    the first of them is in the layout.
+    """
+
+    change_form_template = "admin/fieldsets_extra/unfold/change_form.html"
+
+    def render_change_form(
+        self,
+        request: HttpRequest,
+        context: dict[str, Any],
+        add: bool = False,
+        change: bool = False,
+        form_url: str = "",
+        obj: Any = None,
+    ) -> HttpResponse:
+        # Position of the first tab fieldset: Unfold renders all its tabs there.
+        context["fieldsets_extra_tabs_index"] = next(
+            (
+                index
+                for index, (_, options) in enumerate(self.get_fieldsets(request, obj))
+                if is_tab(options)
+            ),
+            None,
+        )
+        return super().render_change_form(request, context, add, change, form_url, obj)
+
+    @property
+    def media(self) -> forms.Media:
+        return super().media + forms.Media(
+            css={"all": ["fieldsets_extra/css/contrib/unfold.css"]},
+        )
+
+    def check(self, **kwargs: Any) -> list[Any]:
+        errors = super().check(**kwargs)
+        layout = self.fieldsets_with_inlines
+        if not isinstance(layout, list | tuple):
+            return errors  # reported by E001
+        for index, entry in enumerate(layout):
+            if is_inline(entry) or not (
+                isinstance(entry, list | tuple)
+                and len(entry) == 2
+                and isinstance(entry[1], Mapping)
+            ):
+                continue
+            if entry[1].get("save_button") and is_tab(entry[1]):
+                errors.append(
+                    checks.Error(
+                        f"'{type(self).__qualname__}.fieldsets_with_inlines"
+                        f"[{index}]' is one of Unfold's tabs, which can't have "
+                        "a 'save_button'.",
+                        obj=type(self),
+                        id="admin_fieldsets_extra.E101",
+                    )
+                )
+        return errors
+
+
+__all__ = ["UnfoldFieldsetsExtraMixin"]

django_admin_fieldsets_extra/locale/es/LC_MESSAGES/django.po

@@ -0,0 +1,42 @@
+# Spanish translation of django-admin-fieldsets-extra.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: django-admin-fieldsets-extra 0.1.0\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2026-09-29 11:10-0500\n"
+"PO-Revision-Date: 2026-09-29 18:00+0200\n"
+"Last-Translator: Rodolfo Becerra\n"
+"Language-Team: Spanish\n"
+"Language: es\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=3; plural=n == 1 ? 0 : n != 0 && n % 1000000 == 0 ? "
+"1 : 2;\n"
+
+#: mixins.py
+#, python-format
+msgid "Save %(name)s"
+msgstr "Guardar %(name)s"
+
+#: mixins.py
+msgid "Save"
+msgstr "Guardar"
+
+#: mixins.py
+msgid "Saved."
+msgstr "Guardado."
+
+#: mixins.py
+msgid "Please correct the errors below."
+msgstr "Por favor, corrija los errores detallados abajo."
+
+#: templates/admin/fieldsets_extra/includes/fieldset.html
+msgid "The changes could not be saved. Please try again."
+msgstr "No se pudieron guardar los cambios. Inténtalo de nuevo."
+
+#: templates/admin/fieldsets_extra/includes/fieldset.html
+msgid ""
+"Saves only this section. Other changes on the page are kept but not saved."
+msgstr "Guarda solo esta sección. Los demás cambios de la página se mantienen, pero no se guardan."

django_admin_fieldsets_extra/mixins.py

@@ -0,0 +1,347 @@
+"""Extras for Django admin fieldsets: layout with inlines, per-fieldset save."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from django import forms
+from django.contrib.admin.helpers import AdminForm, Fieldset, InlineAdminFormSet
+from django.contrib.admin.options import InlineModelAdmin
+from django.contrib.admin.utils import flatten_fieldsets, quote
+from django.core.exceptions import PermissionDenied
+from django.db import router, transaction
+from django.http import Http404, HttpRequest, HttpResponse
+from django.template.response import TemplateResponse
+from django.urls import NoReverseMatch, URLPattern, path, reverse
+from django.utils.translation import gettext
+from django.views.decorators.http import require_POST
+
+from django_admin_fieldsets_extra.types import FieldsetSpec, Layout
+
+if TYPE_CHECKING:
+    from django.template.response import _TemplateForResponseT
+    from typing_extensions import TypeIs
+
+
+def is_inline(entry: object) -> TypeIs[type[InlineModelAdmin]]:
+    return isinstance(entry, type) and issubclass(entry, InlineModelAdmin)
+
+
+#: Fieldset options of this package; removed before Django sees them (its
+#: ``Fieldset`` rejects unknown options).
+LAYOUT_OPTIONS = frozenset({"save_button"})
+
+
+def django_fieldset(
+    entry: FieldsetSpec,
+) -> FieldsetSpec:
+    """A layout fieldset as Django expects it, without this package's options.
+
+    Malformed entries are returned as they are, for the checks to report.
+    """
+    if not (isinstance(entry, list | tuple) and len(entry) == 2):
+        return entry
+    name, options = entry
+    if not isinstance(options, dict) or not LAYOUT_OPTIONS & set(options):
+        return entry
+    return name, {k: v for k, v in options.items() if k not in LAYOUT_OPTIONS}
+
+
+def split_layout(
+    layout: Layout,
+) -> tuple[list[FieldsetSpec], list[type[InlineModelAdmin]]]:
+    """The fieldsets (Django-ready) and the inline classes of a layout."""
+    fieldsets = [django_fieldset(entry) for entry in layout if not is_inline(entry)]
+    inlines = [entry for entry in layout if is_inline(entry)]
+    return fieldsets, inlines
+
+
+@dataclass(frozen=True)
+class LayoutItem:
+    """What the change form renders at one position of the layout."""
+
+    fieldset: Fieldset | None = None
+    #: Position of the fieldset in ``get_fieldsets()`` (its id suffix).
+    index: int | None = None
+    inline_admin_formset: InlineAdminFormSet | None = None
+    #: Endpoint of the fieldset's save button, if it has one.
+    save_url: str | None = None
+    save_label: str = ""
+
+    @property
+    def is_inline(self) -> bool:
+        return self.inline_admin_formset is not None
+
+
+class FieldsetsExtraMixin:
+    """Render inlines between fieldsets, in the order you list them::
+
+        @admin.register(Author)
+        class AuthorAdmin(FieldsetsExtraMixin, admin.ModelAdmin):
+            fieldsets_with_inlines = [
+                (None, {"fields": ["name"]}),
+                BookInline,
+                ("Contact", {"fields": ["email", "phone"], "save_button": True}),
+                ArticleInline,
+            ]
+
+    ``fieldsets`` and ``inlines`` are derived from it, so the admin's own
+    checks and hooks keep working; don't set them as well. A fieldset with
+    ``"save_button": True`` gets a button that saves only its fields.
+    """
+
+    fieldsets_with_inlines: Layout = ()
+    change_form_template: _TemplateForResponseT | None = (
+        "admin/fieldsets_extra/change_form.html"
+    )
+    fieldset_save_response_template = "admin/fieldsets_extra/fieldset_response.html"
+    _fieldsets_with_inlines_conflicts: list[str] = []
+    _fieldsets_with_inlines_derived: frozenset[str] = frozenset()
+
+    # Provided by ModelAdmin.
+    fieldsets: Any
+    inlines: Any
+    model: Any
+    opts: Any
+    admin_site: Any
+
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        super().__init_subclass__(**kwargs)
+        layout = cls.__dict__.get("fieldsets_with_inlines")
+        if not layout or isinstance(layout, str):
+            return
+        # Checked by check_fieldsets_with_inlines() (E003).
+        cls._fieldsets_with_inlines_conflicts = [
+            name for name in ("fieldsets", "inlines") if cls.__dict__.get(name)
+        ]
+        try:
+            fieldsets, inlines = split_layout(layout)
+        except TypeError:  # pragma: no cover - not iterable, reported by E001
+            return
+        derived = set()
+        if not cls.__dict__.get("fieldsets"):
+            cls.fieldsets = fieldsets
+            derived.add("fieldsets")
+        if not cls.__dict__.get("inlines"):
+            cls.inlines = inlines
+            derived.add("inlines")
+        # Checked by check_fieldsets_with_inlines() (W001).
+        cls._fieldsets_with_inlines_derived = frozenset(derived)
+
+    def get_fieldsets_with_inlines(
+        self, request: HttpRequest, obj: Any = None
+    ) -> Layout:
+        """The layout for this request. Override to make it dynamic."""
+        return self.fieldsets_with_inlines
+
+    def get_fieldsets(self, request: HttpRequest, obj: Any = None) -> Any:
+        layout = self.get_fieldsets_with_inlines(request, obj)
+        if not layout:
+            return super().get_fieldsets(request, obj)  # type: ignore[misc]
+        return split_layout(layout)[0]
+
+    def get_inlines(self, request: HttpRequest, obj: Any) -> Any:
+        layout = self.get_fieldsets_with_inlines(request, obj)
+        if not layout:
+            return super().get_inlines(request, obj)  # type: ignore[misc]
+        return split_layout(layout)[1]
+
+    def get_layout_items(
+        self,
+        request: HttpRequest,
+        obj: Any,
+        adminform: Any,
+        inline_admin_formsets: Sequence[InlineAdminFormSet],
+    ) -> list[LayoutItem]:
+        """Pair the layout with what the change view built.
+
+        Fieldsets are matched by position and inlines by class; inlines the
+        user can't see are skipped. Anything the layout doesn't mention
+        (e.g. from overridden ``get_fieldsets()`` / ``get_inlines()``) is
+        appended at the end, as the admin would render it.
+        """
+        fieldsets = list(enumerate(adminform))
+        formsets = list(inline_admin_formsets)
+        can_save = (
+            obj is not None
+            and obj.pk is not None
+            and self.has_change_permission(request, obj)  # type: ignore[attr-defined]
+        )
+        items: list[LayoutItem] = []
+        for entry in self.get_fieldsets_with_inlines(request, obj):
+            if is_inline(entry):
+                match = next((f for f in formsets if type(f.opts) is entry), None)
+                if match is not None:
+                    formsets.remove(match)
+                    items.append(LayoutItem(inline_admin_formset=match))
+            elif fieldsets:
+                index, fieldset = fieldsets.pop(0)
+                save_url = None
+                if can_save and entry[1].get("save_button"):
+                    save_url = self._fieldset_save_url(obj, index)
+                items.append(
+                    LayoutItem(
+                        fieldset=fieldset,
+                        index=index,
+                        save_url=save_url,
+                        save_label=self.get_fieldset_save_label(entry[0]),
+                    )
+                )
+        items.extend(LayoutItem(fieldset=f, index=i) for i, f in fieldsets)
+        items.extend(LayoutItem(inline_admin_formset=f) for f in formsets)
+        return items
+
+    def render_change_form(
+        self,
+        request: HttpRequest,
+        context: dict[str, Any],
+        add: bool = False,
+        change: bool = False,
+        form_url: str = "",
+        obj: Any = None,
+    ) -> HttpResponse:
+        if self.get_fieldsets_with_inlines(request, obj):
+            context["fieldsets_with_inlines"] = self.get_layout_items(
+                request,
+                obj,
+                context["adminform"],
+                context["inline_admin_formsets"],
+            )
+        return super().render_change_form(  # type: ignore[misc]
+            request, context, add, change, form_url, obj
+        )
+
+    # Saving a fieldset ----------------------------------------------------
+
+    @property
+    def media(self) -> forms.Media:
+        return super().media + forms.Media(  # type: ignore[misc]
+            js=["fieldsets_extra/js/fieldsets_extra.js"],
+            css={"all": ["fieldsets_extra/css/fieldsets_extra.css"]},
+        )
+
+    def get_urls(self) -> list[URLPattern]:
+        opts = self.model._meta
+        return [
+            path(
+                "<path:object_id>/fieldsets/<int:index>/save/",
+                self.admin_site.admin_view(self.fieldset_save_view),
+                name=f"{opts.app_label}_{opts.model_name}_fieldset_save",
+            ),
+            *super().get_urls(),  # type: ignore[misc]
+        ]
+
+    def _fieldset_save_url(self, obj: Any, index: int) -> str | None:
+        opts = self.model._meta
+        try:
+            return reverse(
+                f"{self.admin_site.name}:{opts.app_label}_{opts.model_name}"
+                "_fieldset_save",
+                args=[quote(obj.pk), index],
+            )
+        except NoReverseMatch:  # pragma: no cover - get_urls() was overridden
+            return None
+
+    def get_fieldset_save_label(self, name: str | None) -> str:
+        """Text of a fieldset's save button."""
+        if name:
+            return gettext("Save %(name)s") % {"name": name}
+        return gettext("Save")
+
+    def fieldset_save_view(
+        self, request: HttpRequest, object_id: str, index: int
+    ) -> HttpResponse:
+        return require_POST(self._fieldset_save)(request, object_id, index)
+
+    def _fieldset_save(
+        self, request: HttpRequest, object_id: str, index: int
+    ) -> HttpResponse:
+        request.current_app = self.admin_site.name
+        obj = self.get_object(request, object_id)  # type: ignore[attr-defined]
+        if obj is None:
+            raise Http404
+        if not self.has_change_permission(request, obj):  # type: ignore[attr-defined]
+            raise PermissionDenied
+        layout_fieldsets = [
+            entry
+            for entry in self.get_fieldsets_with_inlines(request, obj)
+            if not is_inline(entry)
+        ]
+        if index >= len(layout_fieldsets) or not layout_fieldsets[index][1].get(
+            "save_button"
+        ):
+            raise Http404("This fieldset has no save button.")
+        name, options = django_fieldset(layout_fieldsets[index])
+        readonly = list(self.get_readonly_fields(request, obj))  # type: ignore[attr-defined]
+        fields = [
+            field
+            for field in flatten_fieldsets([(name, options)])  # type: ignore[list-item]
+            if field not in readonly
+        ]
+        if not fields:
+            raise Http404("This fieldset has no editable fields.")
+
+        # Only this fieldset's fields, on the object as stored now: the rest
+        # of the change form is neither submitted nor overwritten.
+        form_class = self.get_form(request, obj, change=True, fields=fields)  # type: ignore[attr-defined]
+        form = form_class(request.POST, request.FILES, instance=obj)
+        if form.is_valid():
+            with transaction.atomic(using=router.db_for_write(self.model)):
+                obj = self.save_form(request, form, change=True)  # type: ignore[attr-defined]
+                self.save_model(request, obj, form, change=True)  # type: ignore[attr-defined]
+                form.save_m2m()
+                message = self.construct_change_message(request, form, [])  # type: ignore[attr-defined]
+                if message:
+                    self.log_change(request, obj, message)  # type: ignore[attr-defined]
+            status, text = "saved", gettext("Saved.")
+            non_field_errors = None
+            form = form_class(instance=obj)
+        else:
+            status, text = "invalid", gettext("Please correct the errors below.")
+            non_field_errors = form.non_field_errors()
+
+        adminform = AdminForm(
+            form,
+            [(name, options)],
+            {},
+            readonly,
+            model_admin=self,  # type: ignore[arg-type]
+        )
+        item = LayoutItem(
+            fieldset=next(iter(adminform)),
+            index=index,
+            save_url=request.path,
+            save_label=self.get_fieldset_save_label(name),
+        )
+        return TemplateResponse(
+            request,
+            self.fieldset_save_response_template,
+            {
+                "item": item,
+                "status": status,
+                "message": text,
+                "non_field_errors": non_field_errors,
+                "opts": self.opts,
+                "original": obj,
+                "change": True,
+                "is_popup": False,
+            },
+        )
+
+    def check(self, **kwargs: Any) -> list[Any]:
+        from django_admin_fieldsets_extra.checks import (
+            check_fieldsets_with_inlines,
+        )
+
+        return [*super().check(**kwargs), *check_fieldsets_with_inlines(self)]  # type: ignore[misc]
+
+
+__all__ = [
+    "LAYOUT_OPTIONS",
+    "FieldsetsExtraMixin",
+    "LayoutItem",
+    "django_fieldset",
+    "split_layout",
+]

django_admin_fieldsets_extra/static/fieldsets_extra/css/contrib/unfold.css

@@ -0,0 +1,45 @@
+/* django-admin-fieldsets-extra: django-unfold's colors, light and dark. */
+.fieldset-with-save {
+    --body-quiet-color: var(--color-font-subtle-light);
+    --error-fg: var(--color-red-600);
+    --hairline-color: transparent;
+}
+
+.dark .fieldset-with-save {
+    --body-quiet-color: var(--color-font-subtle-dark);
+    --error-fg: var(--color-red-500);
+}
+
+.fieldset-with-save > fieldset.module {
+    margin-bottom: 0.75rem;
+}
+
+.fieldset-save-bar {
+    margin-bottom: 1.5rem;
+    padding: 0;
+}
+
+.fieldset-save-bar .button {
+    height: 38px;
+    padding: 0 0.75rem;
+    border: 1px solid var(--color-base-200);
+    border-radius: var(--border-radius, 6px);
+    color: var(--color-font-important-light);
+    background: #fff;
+    font-weight: 500;
+    box-shadow: 0 1px 2px 0 rgb(0 0 0 / 0.05);
+}
+
+.fieldset-save-bar .button:hover {
+    background: var(--color-base-50);
+}
+
+.dark .fieldset-save-bar .button {
+    border-color: var(--color-base-700);
+    color: var(--color-font-important-dark);
+    background: var(--color-base-900);
+}
+
+.dark .fieldset-save-bar .button:hover {
+    background: var(--color-base-800);
+}

django_admin_fieldsets_extra/static/fieldsets_extra/css/fieldsets_extra.css

@@ -0,0 +1,50 @@
+.fieldset-with-save > fieldset.module {
+    margin-bottom: 0;
+}
+
+.fieldset-save-bar {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: center;
+    justify-content: flex-end;
+    gap: 8px;
+    margin-bottom: 30px;
+    padding: 8px 10px;
+    border-top: 1px solid var(--hairline-color, #e8e8e8);
+    font-size: 0.8125rem;
+}
+
+/* Nothing to save while the fieldset is collapsed (Django 5.1+ / 4.2). */
+.fieldset-with-save:has(> fieldset > details:not([open])) > .fieldset-save-bar,
+.fieldset-with-save:has(> fieldset.collapsed) > .fieldset-save-bar {
+    display: none;
+}
+
+.fieldset-save-bar .button {
+    box-sizing: border-box;
+    height: 30px;
+    margin: 0;
+    padding: 0 12px;
+    border-radius: 4px;
+    font-size: 0.8125rem;
+    line-height: 1;
+    cursor: pointer;
+}
+
+.fieldset-save-status {
+    color: var(--body-quiet-color, #666);
+}
+
+.fieldset-save-status-invalid,
+.fieldset-save-status-failed {
+    color: var(--error-fg, #ba2121);
+}
+
+.fieldset-save-errors .errorlist {
+    margin: 10px;
+}
+
+.fieldset-with-save.fieldset-save-loading {
+    opacity: 0.6;
+    transition: opacity 0.2s;
+}

django_admin_fieldsets_extra/static/fieldsets_extra/js/fieldsets_extra.js

@@ -0,0 +1,140 @@
+/*
+ * django-admin-fieldsets-extra
+ *
+ * The "Save <fieldset>" buttons: post only that fieldset's fields and swap
+ * in the re-rendered fieldset. Plain script, no dependencies; uses
+ * django.jQuery (when present) only to re-run the admin's widget setup.
+ */
+(() => {
+    const SKIP_TYPES = ["submit", "button", "reset", "image"];
+
+    /** The admin form's values for the controls inside `container`. */
+    function fieldsetFormData(container, form) {
+        const data = new FormData();
+        const csrf = form.querySelector("[name=csrfmiddlewaretoken]");
+        if (csrf) {
+            data.append(csrf.name, csrf.value);
+        }
+        for (const el of container.querySelectorAll(
+            "input, select, textarea",
+        )) {
+            if (
+                !el.name ||
+                el.disabled ||
+                el.form !== form ||
+                SKIP_TYPES.includes(el.type)
+            ) {
+                continue;
+            }
+            if (
+                (el.type === "checkbox" || el.type === "radio") &&
+                !el.checked
+            ) {
+                continue;
+            }
+            if (el.type === "file") {
+                for (const file of el.files) {
+                    data.append(el.name, file);
+                }
+            } else if (el.tagName === "SELECT" && el.multiple) {
+                for (const option of el.selectedOptions) {
+                    data.append(el.name, option.value);
+                }
+            } else {
+                data.append(el.name, el.value);
+            }
+        }
+        return data;
+    }
+
+    /** Re-run the admin's widget setup on freshly inserted HTML. */
+    function initWidgets(container) {
+        const $ = window.django?.jQuery;
+        if ($?.fn.djangoAdminSelect2) {
+            $(container).find(".admin-autocomplete").djangoAdminSelect2();
+        }
+        if ($ && typeof window.DateTimeShortcuts !== "undefined") {
+            $(".datetimeshortcuts").remove();
+            window.DateTimeShortcuts.init();
+        }
+        if (typeof window.SelectFilter !== "undefined") {
+            for (const el of container.querySelectorAll(
+                ".selectfilter, .selectfilterstacked",
+            )) {
+                window.SelectFilter.init(
+                    el.id,
+                    el.dataset.fieldName,
+                    el.classList.contains("selectfilterstacked"),
+                );
+            }
+        }
+        if ($) {
+            $(container)
+                .find(".related-widget-wrapper select")
+                .trigger("change");
+        }
+        container.dispatchEvent(
+            new CustomEvent("fieldsets-extra:saved", { bubbles: true }),
+        );
+    }
+
+    function showFailure(container) {
+        const status = container.querySelector(".fieldset-save-status");
+        if (status) {
+            status.className =
+                "fieldset-save-status fieldset-save-status-failed";
+            status.textContent = container.dataset.fieldsetSaveFailed ?? "";
+        }
+    }
+
+    async function saveFieldset(container) {
+        const form = container.closest("form");
+        if (!form || container.classList.contains("fieldset-save-loading")) {
+            return;
+        }
+        container.classList.add("fieldset-save-loading");
+        try {
+            const response = await fetch(container.dataset.fieldsetSaveUrl, {
+                method: "POST",
+                body: fieldsetFormData(container, form),
+                credentials: "same-origin",
+                headers: { "X-Requested-With": "XMLHttpRequest" },
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            const text = await response.text();
+            const doc = new DOMParser().parseFromString(text, "text/html");
+            const fresh = doc.getElementById(container.id);
+            if (!fresh) {
+                throw new Error("Fieldset not found in response");
+            }
+            const node = document.importNode(fresh, true);
+            // Keep a collapsible fieldset open or closed as it was.
+            const details = container.querySelector("details");
+            const freshDetails = node.querySelector("details");
+            if (details && freshDetails) {
+                freshDetails.open = details.open;
+            }
+            container.replaceWith(node);
+            initWidgets(node);
+        } catch {
+            container.classList.remove("fieldset-save-loading");
+            showFailure(container);
+        }
+    }
+
+    document.addEventListener("click", (event) => {
+        const button = event.target.closest("[data-fieldset-save]");
+        const container = button?.closest(".fieldset-with-save");
+        if (container) {
+            event.preventDefault();
+            saveFieldset(container);
+        }
+    });
+
+    globalThis.DjangoAdminFieldsetsExtra = {
+        fieldsetFormData,
+        saveFieldset,
+    };
+})();

django_admin_fieldsets_extra/templates/admin/fieldsets_extra/change_form.html

@@ -0,0 +1,34 @@
+{% extends "admin/change_form.html" %}
+{% comment %}
+  Renders the fieldsets and the inlines in one loop, in the order of
+  `fieldsets_with_inlines`. To customize, extend this template and set it as
+  the ModelAdmin's `change_form_template`.
+{% endcomment %}
+
+{% block field_sets %}
+  {% if fieldsets_with_inlines %}
+    {% for item in fieldsets_with_inlines %}
+      {% if item.is_inline %}
+        {% with inline_admin_formset=item.inline_admin_formset %}
+          {% block layout_inline %}
+            {% include inline_admin_formset.opts.template %}
+          {% endblock layout_inline %}
+        {% endwith %}
+      {% else %}
+        {% with fieldset=item.fieldset %}
+          {% block layout_fieldset %}
+            {% include "admin/fieldsets_extra/includes/fieldset.html" %}
+          {% endblock layout_fieldset %}
+        {% endwith %}
+      {% endif %}
+    {% endfor %}
+  {% else %}
+    {{ block.super }}
+  {% endif %}
+{% endblock field_sets %}
+
+{% block inline_field_sets %}
+  {% if not fieldsets_with_inlines %}
+    {{ block.super }}
+  {% endif %}
+{% endblock inline_field_sets %}

django_admin_fieldsets_extra/templates/admin/fieldsets_extra/fieldset_response.html

@@ -0,0 +1,7 @@
+{% comment %}
+  Response of the fieldset save endpoint: the fieldset re-rendered with its
+  save bar (status included). The JS swaps in the container.
+{% endcomment %}
+{% block response %}
+  {% include "admin/fieldsets_extra/includes/fieldset.html" %}
+{% endblock response %}

django_admin_fieldsets_extra/templates/admin/fieldsets_extra/includes/fieldset.html

@@ -0,0 +1,28 @@
+{% load i18n %}
+{% comment %}
+  One layout fieldset (`item`). With a save button, it is wrapped with the
+  button in a container the JS replaces after saving; keep its id, the
+  data-fieldset-save-url attribute and the data-fieldset-save button.
+{% endcomment %}
+{% with fieldset=item.fieldset %}
+  {% if item.save_url %}
+    <div class="fieldset-with-save" id="fieldset-{{ item.index }}-container" data-fieldset-save-url="{{ item.save_url }}" data-fieldset-save-failed="{% translate 'The changes could not be saved. Please try again.' %}">
+      {% block non_field_errors %}
+        {% if non_field_errors %}
+          <div class="fieldset-save-errors">{{ non_field_errors }}</div>
+        {% endif %}
+      {% endblock non_field_errors %}
+      {% block fieldset %}
+        {% include "admin/includes/fieldset.html" with heading_level=2 prefix="fieldset" id_prefix=0 id_suffix=item.index %}
+      {% endblock fieldset %}
+      {% block save_bar %}
+        <div class="fieldset-save-bar">
+          <span class="fieldset-save-status{% if status %} fieldset-save-status-{{ status }}{% endif %}" role="status" aria-live="polite">{{ message }}</span>
+          <button type="button" class="button default" data-fieldset-save title="{% translate 'Saves only this section. Other changes on the page are kept but not saved.' %}">{% block save_label %}{{ item.save_label }}{% endblock %}</button>
+        </div>
+      {% endblock save_bar %}
+    </div>
+  {% else %}
+    {% include "admin/includes/fieldset.html" with heading_level=2 prefix="fieldset" id_prefix=0 id_suffix=item.index %}
+  {% endif %}
+{% endwith %}

django_admin_fieldsets_extra/templates/admin/fieldsets_extra/unfold/change_form.html

@@ -0,0 +1,15 @@
+{% extends "admin/fieldsets_extra/change_form.html" %}
+{% comment %}
+  The layout with Unfold: its tab fieldsets are rendered as its tabs, all of
+  them where the first one is in the layout.
+{% endcomment %}
+
+{% block layout_fieldset %}
+  {% if "tab" in fieldset.classes %}
+    {% if item.index == fieldsets_extra_tabs_index %}
+      {% include "unfold/helpers/fieldsets_tabs.html" %}
+    {% endif %}
+  {% else %}
+    {{ block.super }}
+  {% endif %}
+{% endblock layout_fieldset %}

django_admin_fieldsets_extra/types.py

@@ -0,0 +1,17 @@
+"""Type aliases used across the package."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any, TypeAlias
+
+from django.contrib.admin.options import InlineModelAdmin
+
+#: A fieldset, as in ``ModelAdmin.fieldsets``: ``(name, options)``.
+FieldsetSpec: TypeAlias = tuple[str | None, dict[str, Any]]
+#: One entry of ``fieldsets_with_inlines``: a fieldset or an inline class.
+LayoutEntry: TypeAlias = FieldsetSpec | type[InlineModelAdmin]
+#: The whole ``fieldsets_with_inlines``.
+Layout: TypeAlias = Sequence[LayoutEntry]
+
+__all__ = ["FieldsetSpec", "Layout", "LayoutEntry"]

django_admin_fieldsets_extra-0.1.0.dist-info/METADATA

@@ -0,0 +1,294 @@
+Metadata-Version: 2.5
+Name: django-admin-fieldsets-extra
+Version: 0.1.0
+Summary: Extras for Django admin fieldsets: interleave them with inlines, save one on its own.
+Project-URL: Homepage, https://github.com/rodolvbg/django-admin-fieldsets-extra
+Project-URL: Issues, https://github.com/rodolvbg/django-admin-fieldsets-extra/issues
+Project-URL: Repository, https://github.com/rodolvbg/django-admin-fieldsets-extra
+Author-email: Rodolfo Valentín Becerra García <rodolvbg@gmail.com>
+Maintainer-email: Rodolfo Valentín Becerra García <rodolvbg@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: admin,django,fieldsets,inlines,layout
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Framework :: Django :: 6.1
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: django>=4.2
+Provides-Extra: dev
+Requires-Dist: coverage[toml]>=7.4; extra == 'dev'
+Requires-Dist: django-stubs[compatible-mypy]>=5; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pre-commit>=4; extra == 'dev'
+Requires-Dist: pytest-cov>=5; extra == 'dev'
+Requires-Dist: pytest-django>=4.8; extra == 'dev'
+Requires-Dist: pytest-playwright>=0.5; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: tox-uv>=1; extra == 'dev'
+Requires-Dist: tox>=4; extra == 'dev'
+Provides-Extra: unfold
+Requires-Dist: django-unfold>=0.108; (python_version >= '3.12') and extra == 'unfold'
+Description-Content-Type: text/markdown
+
+# django-admin-fieldsets-extra
+
+[![Build status](https://github.com/rodolvbg/django-admin-fieldsets-extra/actions/workflows/pytest.yml/badge.svg)](https://github.com/rodolvbg/django-admin-fieldsets-extra/actions/workflows/pytest.yml)
+[![PyPI version](https://img.shields.io/pypi/v/django-admin-fieldsets-extra.svg)](https://pypi.org/project/django-admin-fieldsets-extra/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/django-admin-fieldsets-extra)](https://pypi.org/project/django-admin-fieldsets-extra/)
+[![PyPI - Django Version](https://img.shields.io/pypi/djversions/django-admin-fieldsets-extra)](https://pypi.org/project/django-admin-fieldsets-extra/)
+[![Downloads](https://static.pepy.tech/personalized-badge/django-admin-fieldsets-extra?period=month&units=international_system&left_color=black&right_color=blue&left_text=Downloads/month)](https://pepy.tech/project/django-admin-fieldsets-extra)
+
+Extras for Django admin fieldsets:
+
+- **Interleave fieldsets and inlines** in the change form: put an inline
+  right after the fields it belongs with, instead of always at the bottom.
+- **Save a fieldset on its own** with a "Save Contact" button, without
+  submitting or reloading the rest of the page.
+
+![Books inline between the name and the contact fieldset, articles before the biography](https://github.com/rodolvbg/django-admin-fieldsets-extra/blob/main/docs/screenshots/hero.png)
+
+- One ordered list replaces `fieldsets` + `inlines` (with or without
+  inlines in it).
+- No copy of Django's `change_form.html`: it only overrides its
+  `field_sets` / `inline_field_sets` blocks, so it follows your Django
+  version.
+- Nothing changes in the inlines' DOM: Django's inline JS ("Add another",
+  autocomplete, date pickers…) and inline templates work as usual.
+- Works with [django-admin-inline-controls](https://github.com/rodolvbg/django-admin-inline-controls)
+  (paginated / filterable inlines, a save button per inline).
+
+## Install
+
+```bash
+pip install django-admin-fieldsets-extra
+```
+
+Add to `INSTALLED_APPS`:
+
+```python
+INSTALLED_APPS = [
+    ...
+    "django_admin_fieldsets_extra",
+]
+```
+
+## Usage
+
+```python
+from django.contrib import admin
+
+from django_admin_fieldsets_extra.mixins import FieldsetsExtraMixin
+
+
+class BookInline(admin.TabularInline):
+    model = Book
+
+
+class ArticleInline(admin.StackedInline):
+    model = Article
+
+
+@admin.register(Author)
+class AuthorAdmin(FieldsetsExtraMixin, admin.ModelAdmin):
+    fieldsets_with_inlines = [
+        (None, {"fields": ["name"]}),
+        BookInline,
+        ("Contact", {"fields": ["email", "phone"], "save_button": True}),
+        ArticleInline,
+        ("Biography", {"fields": ["bio"], "classes": ["collapse"]}),
+    ]
+```
+
+Each entry is either a fieldset, exactly as in `ModelAdmin.fieldsets`, or an
+inline class, as in `ModelAdmin.inlines`. They are rendered in that order.
+
+- **`fieldsets` and `inlines` are derived from it** (in their relative
+  order), so Django's admin checks and every hook that reads them keep
+  working. Don't set them as well (`admin_fieldsets_extra.E003`).
+- **Dynamic layouts:** override `get_fieldsets_with_inlines(request,
+  obj=None)`; `get_fieldsets()` and `get_inlines()` follow it. Static
+  `fieldsets` / `inlines` would be ignored then
+  (`admin_fieldsets_extra.W001` warns about it).
+- **Permissions:** an inline the user can't see is simply left out, as
+  in the regular change form.
+- **Anything not in the layout** (e.g. extra fieldsets or inlines from your
+  own `get_fieldsets()` / `get_inlines()`) is rendered after it.
+- Without `fieldsets_with_inlines`, the mixin does nothing: the regular
+  change form.
+
+## Saving a fieldset
+
+Add `"save_button": True` to a fieldset of the layout to give it a
+**"Save Contact"** button (named after the fieldset; "Save" if it has no
+name) that saves only its fields:
+
+```python
+(("Contact", {"fields": ["email", "phone"], "save_button": True}),)
+```
+
+![A fieldset with its own save button, after saving](https://github.com/rodolvbg/django-admin-fieldsets-extra/blob/main/docs/screenshots/save-fieldset.png)
+
+`save_button` is an option of this package: it is removed before the
+fieldset reaches Django (whose `Fieldset` rejects unknown options), so
+`AuthorAdmin.fieldsets` and `get_fieldsets()` never contain it.
+
+**How it works**
+
+- The button is rendered by the server under the fieldset, only on existing
+  objects and for users with change permission. It is hidden while the
+  fieldset is collapsed.
+- Only the fields inside that fieldset are sent (files included), to
+  `<object_id>/fieldsets/<n>/save/`, `n` being its position in
+  `get_fieldsets()`.
+- The server builds `get_form(request, obj, fields=<its editable fields>)`
+  on the object **as stored in the database**, validates it, calls
+  `save_form()`, `save_model()` and `form.save_m2m()` in a transaction, and
+  records the change in the history ("Changed Email and Phone."; nothing if
+  nothing changed).
+- The fieldset is re-rendered and swapped in place: field errors on their
+  fields, form-wide errors (from `clean()`) above the fieldset, "Saved."
+  next to the button on success. The rest of the page (other fieldsets,
+  inlines, unsaved edits) is left untouched. A
+  `fieldsets-extra:saved` event bubbles from the new fieldset.
+
+**Caveats**
+
+1. **Validation:** only this fieldset's fields are validated as fields, but
+   `Model.clean()` / `ModelForm.clean()` still run, with the other fields'
+   *stored* values. A rule that combines fields of two fieldsets sees the
+   saved value of the other one, not what is unsaved on screen.
+2. **`save_model(request, obj, form, change)` gets a form with only these
+   fields.** If you override it and read other fields from
+   `form.cleaned_data`, it won't work from this button. `save_related()`
+   and the inlines' formsets are not called.
+3. **Concurrency:** the object is re-read from the database right before
+   saving, so the page's (possibly stale) values of other fields are never
+   written back. As with the regular Save button, two people changing the
+   same field at the same time: the last save wins.
+4. Read-only fields are never saved; a fieldset with only read-only fields
+   has no button (the endpoint answers 404).
+
+## Customizing the template
+
+The mixin sets `change_form_template` to
+`admin/fieldsets_extra/change_form.html`, which extends
+`admin/change_form.html`. For your own change form template, extend this
+one instead:
+
+```django
+{% extends "admin/fieldsets_extra/change_form.html" %}
+
+{% block layout_inline %}
+  <div class="my-inline">{{ block.super }}</div>
+{% endblock %}
+```
+
+| Block | Contains |
+|---|---|
+| `field_sets` | The whole layout (falls back to Django's when there is none). |
+| `layout_fieldset` | One fieldset (`fieldset`, and `item.index`, its position in `get_fieldsets()`); includes `admin/fieldsets_extra/includes/fieldset.html`. |
+| `layout_inline` | One inline (`inline_admin_formset`). |
+| `inline_field_sets` | Empty when there is a layout (the inlines are already rendered). |
+
+`admin/fieldsets_extra/includes/fieldset.html` renders one fieldset
+and, if it has one, its save button. Its blocks: `non_field_errors`,
+`fieldset`, `save_bar` and `save_label`. It is also the save endpoint's
+response (`fieldset_response.html`, block `response`; set
+`fieldset_save_response_template` on the `ModelAdmin` to use another one).
+The JS replaces the `fieldset-with-save` container by its id and relies on
+the `data-fieldset-save-url` attribute and the `data-fieldset-save` button:
+keep them when overriding blocks.
+
+The layout is also in the context as `fieldsets_with_inlines`: a list of
+items with `is_inline`, `fieldset`, `index`, `inline_admin_formset`,
+`save_url` and `save_label`.
+`get_layout_items()` builds it, if you need to change how the layout is
+matched to the form.
+
+## With django-admin-inline-controls
+
+Both mixins go on the `ModelAdmin`, `InlineControlsAdminMixin` first:
+
+```python
+from django_admin_inline_controls.mixins import (
+    InlineControlsAdminMixin,
+    InlineControlsMixin,
+)
+
+
+class BookInline(InlineControlsMixin, admin.TabularInline):
+    model = Book
+    inline_per_page = 20
+    inline_save_button = True
+
+
+@admin.register(Author)
+class AuthorAdmin(InlineControlsAdminMixin, FieldsetsExtraMixin, admin.ModelAdmin):
+    fieldsets_with_inlines = [
+        (None, {"fields": ["name"]}),
+        BookInline,
+        ("Contact", {"fields": ["email", "phone"], "save_button": True}),
+    ]
+```
+
+Neither package knows about the other: the controls are part of each
+inline's own template, and the fieldset save buttons belong to the
+fieldsets, wherever the layout puts them. Fieldsets keep
+their position in `get_fieldsets()`, which is how the save endpoint finds
+them.
+
+## Themes
+
+- [django-unfold](https://github.com/rodolvbg/django-admin-fieldsets-extra/blob/main/docs/themes/unfold.md): `UnfoldFieldsetsExtraMixin` (the
+  `unfold` extra).
+
+## System checks
+
+| ID | Problem |
+|---|---|
+| `admin_fieldsets_extra.E001` | `fieldsets_with_inlines` is not a list or tuple. |
+| `admin_fieldsets_extra.E002` | An entry is neither a `(name, {"fields": ...})` fieldset nor an inline class. |
+| `admin_fieldsets_extra.E003` | `fieldsets` or `inlines` is set as well. |
+| `admin_fieldsets_extra.E004` | A fieldset's `save_button` is not `True` or `False`. |
+| `admin_fieldsets_extra.E101` | An Unfold tab fieldset (`"classes": ["tab"]`) has a `save_button` (`UnfoldFieldsetsExtraMixin`). |
+| `admin_fieldsets_extra.W001` | `get_fieldsets_with_inlines()` is overridden and `fieldsets` or `inlines` is set too: they are ignored whenever it returns a layout (warning). |
+
+## Translations
+
+Ships a Spanish (`es`) translation: the save buttons, their tooltips and
+the status messages follow the admin's active language.
+
+## Demo
+
+```bash
+cd example
+python manage.py migrate
+python manage.py seed_demo      # admin/admin + an author with books
+python manage.py runserver
+
+```
+
+## Compatibility
+
+Django 4.2 – 6.1, Python 3.10+.
+
+## License
+
+MIT

django_admin_fieldsets_extra-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+django_admin_fieldsets_extra/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+django_admin_fieldsets_extra/apps.py,sha256=gBdR50k2iN11kDNLBW_N12CFtviivcGRNUu4yUFQiS0,228
+django_admin_fieldsets_extra/checks.py,sha256=QOUqokdEFF2CSIc1FxNiKEsNq-ZnVuRp5G2QqouyZyI,2965
+django_admin_fieldsets_extra/mixins.py,sha256=DwtQZIXqg2r5MPUee4QI_U-OKq9RnMfiUCx2Z5aq6ZA,13274
+django_admin_fieldsets_extra/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_admin_fieldsets_extra/types.py,sha256=p431wYfAzeHUzB2EIbFzQkfofv16B0MWy6mQXTmr99o,614
+django_admin_fieldsets_extra/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_admin_fieldsets_extra/contrib/unfold.py,sha256=Ob825kRI1ctRxcIdu_Fj1raHT96EuhwF-C-fqKkFAf4,3189
+django_admin_fieldsets_extra/locale/es/LC_MESSAGES/django.mo,sha256=_edjI3jbLTN6hM5Nze9EPoqaxS7WxBJLJxg5C2vexEs,964
+django_admin_fieldsets_extra/locale/es/LC_MESSAGES/django.po,sha256=6DXkMM68QLJKugfjiIFTzeKWUVjRsjxCTYyRVUhCUbc,1238
+django_admin_fieldsets_extra/static/fieldsets_extra/css/fieldsets_extra.css,sha256=CKzy-oIRwHQM2UNz5uKGPFwXb_aluwGPlAez4G1gMSM,1103
+django_admin_fieldsets_extra/static/fieldsets_extra/css/contrib/unfold.css,sha256=E_vjl6HCvsCkOM7BCEa7VnXCrluPvJMKaYkxUWm8U4o,1115
+django_admin_fieldsets_extra/static/fieldsets_extra/js/fieldsets_extra.js,sha256=COiDfun-XsDyFt1hxiyEuoIW-7eABgBbk--v67qGXNk,4983
+django_admin_fieldsets_extra/templates/admin/fieldsets_extra/change_form.html,sha256=A2ycbZ8EX5d9nOkCbVnuEO3Kzhq9NJ2TaEaZtmShBGc,1097
+django_admin_fieldsets_extra/templates/admin/fieldsets_extra/fieldset_response.html,sha256=Gt8GBIxtYTmCAI_Qt27eFobn7fHpojon3MeMy9lLe2g,276
+django_admin_fieldsets_extra/templates/admin/fieldsets_extra/includes/fieldset.html,sha256=HYkJW3tvRPL43skleU1P5umSjGdjKJkK43lwFL7v6jA,1609
+django_admin_fieldsets_extra/templates/admin/fieldsets_extra/unfold/change_form.html,sha256=0dHAhlzbFGZ_RMrig_gdBOyIoKU8_4V09qno3k_l_AU,481
+django_admin_fieldsets_extra-0.1.0.dist-info/METADATA,sha256=gZXwy7AHKbGX0KYDYLhIqMH2QPIs_mTrtTpfZqQOqvc,12208
+django_admin_fieldsets_extra-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+django_admin_fieldsets_extra-0.1.0.dist-info/licenses/LICENSE,sha256=0EJi4J2ISkSQsH8fR7SQvn4J66zEouFMPErgIRKn0cg,1072
+django_admin_fieldsets_extra-0.1.0.dist-info/RECORD,,

django_admin_fieldsets_extra-0.1.0.dist-info/WHEEL

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

django_admin_fieldsets_extra-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rodolfo Becerra
+
+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.