django-smartbase-admin 2.0.1__tar.gz → 2.0.3__tar.gz

{django_smartbase_admin-2.0.1 → django_smartbase_admin-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-smartbase-admin
-Version: 2.0.1
+Version: 2.0.3
 Summary: 
 Home-page: https://smartbase-sk.github.io/django-smartbase-admin-docs/
 License: MIT

{django_smartbase_admin-2.0.1 → django_smartbase_admin-2.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-smartbase-admin"
-version = "2.0.1"
+version = "2.0.3"
 description = ""
 authors = ["SmartBase <info@smartbase.sk>"]
 readme = "README.md"

{django_smartbase_admin-2.0.1 → django_smartbase_admin-2.0.3}/src/django_smartbase_admin/actions/admin_action_list.py

@@ -5,7 +5,7 @@ from typing import Any, TYPE_CHECKING
 
 from django.contrib.admin.utils import lookup_spawns_duplicates
 from django.core.exceptions import FieldError
-from django.db.models import Avg, Count, Field, Max, Min, Q, Sum
+from django.db.models import Avg, Count, Field, Max, Min, Q, Sum, Value
 from django.utils import timezone
 from django.utils.html import escape
 from django.utils.safestring import SafeString
@@ -783,14 +783,49 @@ class SBAdminListAction(SBAdminAction):
             )
         return specs
 
-    def get_aggregates(self, aggregate, field_map=None) -> dict:
-        """Compute ``{alias: value}`` for ``aggregate`` over the filtered set.
+    def validate_group_by(self, group_by, field_map=None) -> list:
+        """Resolve ``group_by`` names to declared SBAdminFields to GROUP BY on.
 
-        Reuses the list's filtered, annotated queryset. Non-multiplying
-        metrics batch into one query; a ``count`` over a multi-valued
-        relation runs separately and is merged.
+        A multi-valued (relation) field is rejected — grouping on it fans
+        the rows out. ``None`` / ``[]`` → no grouping; raises ``ValueError``
+        / ``LookupError`` on a bad entry.
+        """
+        if not group_by:
+            return []
+        if not isinstance(group_by, list):
+            raise ValueError("group_by must be a list of declared field names.")
+        if field_map is None:
+            field_map = self.view.get_field_map(self.threadsafe_request)
+
+        fields = []
+        for name in group_by:
+            sbfield = field_map.get(name)
+            if sbfield is None:
+                raise LookupError(
+                    f"Unknown field {name!r}; declared fields: {sorted(field_map)}."
+                )
+            if sbfield.is_multivalued():
+                raise ValueError(f"Cannot group by multi-valued field {name!r}.")
+            fields.append(sbfield)
+        return fields
+
+    def get_aggregates(self, aggregate, field_map=None, group_by=None):
+        """Compute ``aggregate`` totals over the filtered set.
+
+        Reuses the list's filtered, annotated queryset and runs a single
+        ``values(*group).annotate(**aggs)``. No ``group_by`` collapses to
+        one constant group (``Value(1)``), so the scalar rollup is just the
+        degenerate case of the same query.
+
+        Without ``group_by`` returns a scalar ``{alias: value}`` dict; with
+        ``group_by`` returns a list of ``{**group_fields, **aliases}`` rows,
+        ordered by the group columns. Each metric runs in its own query and
+        is merged by group key, so a metric that traverses a to-many
+        relation (a multi-valued ``count``, or an annotated field that
+        aggregates a related set) can never fan-out-inflate a sibling.
         """
         specs = self.validate_aggregate(aggregate, field_map=field_map)
+        group_fields = self.validate_group_by(group_by, field_map=field_map)
         # Full base so every aggregable field's annotation is present.
         queryset = self.get_data_queryset()
         pk_name = self.get_pk_field().name
@@ -812,6 +847,23 @@ class SBAdminListAction(SBAdminAction):
             if field.supporting_annotates:
                 extra.update(field.supporting_annotates)
             extra[field.field] = field.annotate
+
+        # Resolve group targets the same way; a computed (annotated) group
+        # column needs its expression present before ``.values()``.
+        group_targets: list[str] = []
+        for field in group_fields:
+            target = (
+                field.model_field.name if field.model_field is not None else field.field
+            )
+            group_targets.append(target)
+            if (
+                field.model_field is None
+                and target not in queryset.query.annotations
+                and field.annotate is not None
+            ):
+                if field.supporting_annotates:
+                    extra.update(field.supporting_annotates)
+                extra[target] = field.annotate
         if extra:
             queryset = queryset.annotate(**extra)
 
@@ -822,23 +874,34 @@ class SBAdminListAction(SBAdminAction):
         for plugin in request.request_data.configuration.plugins:
             queryset = plugin.modify_count_queryset(self, request=request, qs=queryset)
 
-        batch: dict = {}
-        isolated: list[tuple[str, Any]] = []
-        for spec in specs:
-            agg = LIST_AGGREGATE_FUNCTIONS[spec["fn"]](spec["target"])
-            if spec["multiplying"]:
-                isolated.append((spec["alias"], agg))
-            else:
-                batch[spec["alias"]] = agg
-
-        # Undetermined-type expressions are only rejected once Django
-        # resolves them against the query.
+        # GROUP BY: no group_by → a single constant group, so the scalar
+        # case falls out of the same path.
+        if group_targets:
+            base = queryset.values(*group_targets)
+        else:
+            base = queryset.annotate(_sb_group=Value(1)).values("_sb_group")
+
+        # One query per metric, merged by group key — a metric that
+        # traverses a to-many relation never shares a query with (and so
+        # never inflates) another. Undetermined-type expressions are only
+        # rejected once Django resolves them against the query.
+        merged: dict = {}
+        order: list = []
         try:
-            result: dict = {}
-            if batch:
-                result.update(queryset.aggregate(**batch))
-            for alias, agg in isolated:
-                result[alias] = queryset.aggregate(**{alias: agg})[alias]
+            for spec in specs:
+                alias = spec["alias"]
+                agg = LIST_AGGREGATE_FUNCTIONS[spec["fn"]](spec["target"])
+                for row in base.annotate(**{alias: agg}).order_by(*group_targets):
+                    key = tuple(row[t] for t in group_targets)
+                    slot = merged.get(key)
+                    if slot is None:
+                        slot = {t: row[t] for t in group_targets}
+                        merged[key] = slot
+                        order.append(key)
+                    slot[alias] = row[alias]
         except FieldError as exc:
             raise ValueError(f"Cannot aggregate the requested field(s): {exc}") from exc
-        return result
+
+        if not group_targets:
+            return merged[order[0]] if order else {}
+        return [merged[key] for key in order]

{django_smartbase_admin-2.0.1 → django_smartbase_admin-2.0.3}/src/django_smartbase_admin/admin/widgets.py

@@ -33,8 +33,9 @@ from filer.models import File
 
 from django_smartbase_admin.admin.site import sb_admin_site
 from django_smartbase_admin.engine.admin_base_view import (
-    SBADMIN_PARENT_INSTANCE_PK_VAR,
+    SBADMIN_PARENT_INSTANCE_FIELD_NAME_VAR,
     SBADMIN_PARENT_INSTANCE_LABEL_VAR,
+    SBADMIN_PARENT_INSTANCE_PK_VAR,
 )
 from django_smartbase_admin.engine.const import (
     ACTION_AUTOCOMPLETE_MODIFIER_SEPARATOR,
@@ -44,6 +45,10 @@ from django_smartbase_admin.engine.filter_widgets import (
     AutocompleteFilterWidget,
     SBAdminTreeWidgetMixin,
 )
+from django_smartbase_admin.services.request_cache import (
+    RequestCacheKey,
+    cache_on_request,
+)
 from django_smartbase_admin.services.thread_local import SBAdminThreadLocalService
 from django_smartbase_admin.templatetags.sb_admin_tags import (
     SBAdminJSONEncoder,
@@ -104,7 +109,7 @@ class SBAdminBaseWidget(ContextMixin):
                     if is_modal(SBAdminThreadLocalService.get_request())
                     else ""
                 )
-            except:
+            except Exception:
                 pass
             widget_id = f"{modal_prefix}{opts.app_label}_{opts.model_name}_{context['widget']['attrs']['id']}"
             context["widget"]["attrs"]["id"] = widget_id
@@ -114,40 +119,181 @@ class SBAdminBaseWidget(ContextMixin):
 
 
 class SBAdminInputAffixMixin:
-    def __init__(self, *args, prefix=None, suffix=None, **kwargs):
+    def __init__(
+        self,
+        *args,
+        prefix=None,
+        suffix=None,
+        prefix_icon=None,
+        suffix_icon=None,
+        prefix_button_attrs=None,
+        suffix_button_attrs=None,
+        media_js=(),
+        **kwargs,
+    ):
+        self.validate_affix_config(
+            prefix=prefix,
+            suffix=suffix,
+            prefix_icon=prefix_icon,
+            suffix_icon=suffix_icon,
+        )
         self.prefix = prefix
         self.suffix = suffix
+        self.prefix_icon = prefix_icon
+        self.suffix_icon = suffix_icon
+        self.prefix_button_attrs = self.get_affix_button_attrs(
+            (prefix_button_attrs or {}) if prefix_icon else None
+        )
+        self.suffix_button_attrs = self.get_affix_button_attrs(
+            (suffix_button_attrs or {}) if suffix_icon else None
+        )
+        self.media_js = media_js
         super().__init__(*args, **kwargs)
 
+    def validate_affix_config(
+        self,
+        *,
+        prefix=None,
+        suffix=None,
+        prefix_icon=None,
+        suffix_icon=None,
+    ):
+        if prefix and prefix_icon:
+            raise ImproperlyConfigured("Use either prefix or prefix_icon, not both.")
+        if suffix and suffix_icon:
+            raise ImproperlyConfigured("Use either suffix or suffix_icon, not both.")
+
     def get_context(self, name, value, attrs):
         context = super().get_context(name, value, attrs)
         context["widget"]["prefix"] = self.prefix
         context["widget"]["suffix"] = self.suffix
+        context["widget"]["prefix_icon"] = self.prefix_icon
+        context["widget"]["suffix_icon"] = self.suffix_icon
+        context["widget"]["prefix_button_attrs"] = (
+            self.get_positioned_affix_button_attrs(
+                self.prefix_button_attrs, "input-affix__prefix"
+            )
+        )
+        context["widget"]["suffix_button_attrs"] = (
+            self.get_positioned_affix_button_attrs(
+                self.suffix_button_attrs, "input-affix__suffix"
+            )
+        )
         return context
 
-    def get_attrs_with_affix_classes(self, attrs, prefix=None, suffix=None):
+    def get_affix_button_attrs(self, attrs):
+        if attrs is None:
+            return None
+        attrs = dict(attrs)
+        attrs.setdefault("type", "button")
+        attrs["class"] = " ".join(
+            filter(
+                None,
+                (
+                    "input-affix__addon input-affix__button text-dark-900",
+                    attrs.get("class", ""),
+                ),
+            )
+        )
+        return attrs
+
+    def get_positioned_affix_button_attrs(self, attrs, position_class):
+        if attrs is None:
+            return None
+        attrs = dict(attrs)
+        attrs["class"] = " ".join(
+            filter(None, (attrs.get("class", ""), position_class))
+        )
+        return attrs
+
+    def get_attrs_with_affix_classes(
+        self,
+        attrs,
+        prefix=None,
+        suffix=None,
+        prefix_icon=None,
+        suffix_icon=None,
+    ):
         attrs = dict(attrs or {})
         classes = attrs.get("class", "")
-        if prefix:
+        if prefix or prefix_icon:
             classes = f"{classes} rounded-l-none".strip()
-        if suffix:
+        if suffix or suffix_icon:
             classes = f"{classes} rounded-r-none".strip()
         attrs["class"] = classes
         return attrs
 
+    @property
+    def media(self):
+        media = super().media
+        if self.media_js:
+            media += forms.Media(js=self.media_js)
+        return media
+
 
 class SBAdminTextInputWidget(
     SBAdminInputAffixMixin, SBAdminBaseWidget, forms.TextInput
 ):
     template_name = "sb_admin/widgets/text.html"
 
-    def __init__(self, form_field=None, attrs=None, prefix=None, suffix=None):
+    def __init__(
+        self,
+        form_field=None,
+        attrs=None,
+        prefix=None,
+        suffix=None,
+        prefix_icon=None,
+        suffix_icon=None,
+        prefix_button_attrs=None,
+        suffix_button_attrs=None,
+        media_js=(),
+    ):
         attrs = self.get_attrs_with_affix_classes(
             {"class": "input", **(attrs or {})},
             prefix=prefix,
             suffix=suffix,
+            prefix_icon=prefix_icon,
+            suffix_icon=suffix_icon,
+        )
+        super().__init__(
+            form_field,
+            attrs=attrs,
+            prefix=prefix,
+            suffix=suffix,
+            prefix_icon=prefix_icon,
+            suffix_icon=suffix_icon,
+            prefix_button_attrs=prefix_button_attrs,
+            suffix_button_attrs=suffix_button_attrs,
+            media_js=media_js,
+        )
+
+
+class SBAdminCopyableTextInputWidget(SBAdminTextInputWidget):
+    def __init__(
+        self,
+        form_field=None,
+        attrs=None,
+        prefix=None,
+        suffix=None,
+        *,
+        copy_label="Copy",
+        copied_label="Copied",
+        copy_icon="Minus-the-top",
+    ):
+        super().__init__(
+            form_field=form_field,
+            attrs=attrs,
+            prefix=prefix,
+            suffix=suffix,
+            suffix_icon=copy_icon,
+            suffix_button_attrs={
+                "title": copy_label,
+                "aria-label": copy_label,
+                "data-sbadmin-copy-button": True,
+                "data-sbadmin-copy-label": copy_label,
+                "data-sbadmin-copied-label": copied_label,
+            },
         )
-        super().__init__(form_field, attrs=attrs, prefix=prefix, suffix=suffix)
 
 
 class SBAdminTextTagsWidget(SBAdminBaseWidget, forms.TextInput):
@@ -161,6 +307,7 @@ class SBAdminTextTagsWidget(SBAdminBaseWidget, forms.TextInput):
                 "class": "input js-sbadmin-text-tags",
                 "data-choices-delimiter": delimiter,
                 "autocomplete": "off",
+                "dir": "ltr",
                 **(attrs or {}),
             },
         )
@@ -180,11 +327,41 @@ class SBAdminTextareaWidget(SBAdminBaseWidget, forms.Textarea):
         super().__init__(form_field, attrs={"class": "input", **(attrs or {})})
 
 
-class SBAdminEmailInputWidget(SBAdminBaseWidget, forms.EmailInput):
+class SBAdminEmailInputWidget(
+    SBAdminInputAffixMixin, SBAdminBaseWidget, forms.EmailInput
+):
     template_name = "sb_admin/widgets/email.html"
 
-    def __init__(self, form_field=None, attrs=None):
-        super().__init__(form_field, attrs={"class": "input", **(attrs or {})})
+    def __init__(
+        self,
+        form_field=None,
+        attrs=None,
+        prefix=None,
+        suffix=None,
+        prefix_icon=None,
+        suffix_icon=None,
+        prefix_button_attrs=None,
+        suffix_button_attrs=None,
+        media_js=(),
+    ):
+        attrs = self.get_attrs_with_affix_classes(
+            {"class": "input", **(attrs or {})},
+            prefix=prefix,
+            suffix=suffix,
+            prefix_icon=prefix_icon,
+            suffix_icon=suffix_icon,
+        )
+        super().__init__(
+            form_field,
+            attrs=attrs,
+            prefix=prefix,
+            suffix=suffix,
+            prefix_icon=prefix_icon,
+            suffix_icon=suffix_icon,
+            prefix_button_attrs=prefix_button_attrs,
+            suffix_button_attrs=suffix_button_attrs,
+            media_js=media_js,
+        )
 
 
 class SBAdminURLFieldWidget(SBAdminBaseWidget, AdminURLFieldWidget):
@@ -198,13 +375,36 @@ class SBAdminNumberWidget(SBAdminInputAffixMixin, SBAdminBaseWidget, forms.Numbe
     class_name = "input"
     template_name = "sb_admin/widgets/number.html"
 
-    def __init__(self, form_field=None, attrs=None, prefix=None, suffix=None):
+    def __init__(
+        self,
+        form_field=None,
+        attrs=None,
+        prefix=None,
+        suffix=None,
+        prefix_icon=None,
+        suffix_icon=None,
+        prefix_button_attrs=None,
+        suffix_button_attrs=None,
+        media_js=(),
+    ):
         attrs = self.get_attrs_with_affix_classes(
             {"class": self.class_name, **(attrs or {})},
             prefix=prefix,
             suffix=suffix,
+            prefix_icon=prefix_icon,
+            suffix_icon=suffix_icon,
+        )
+        super().__init__(
+            form_field,
+            attrs=attrs,
+            prefix=prefix,
+            suffix=suffix,
+            prefix_icon=prefix_icon,
+            suffix_icon=suffix_icon,
+            prefix_button_attrs=prefix_button_attrs,
+            suffix_button_attrs=suffix_button_attrs,
+            media_js=media_js,
         )
-        super().__init__(form_field, attrs=attrs, prefix=prefix, suffix=suffix)
 
 
 class SBAdminCheckboxWidget(SBAdminBaseWidget, forms.CheckboxInput):
@@ -726,7 +926,6 @@ class SBAdminAutocompleteWidget(
     reload_on_save = None
     full_width = False
     REQUEST_CREATED_DATA_KEY = "autocomplete_created_data"
-    SELECTED_OPTION_CACHE_KEY = "_sbadmin_autocomplete_selected_options"
 
     def __init__(self, form_field=None, *args, **kwargs):
         attrs = kwargs.pop("attrs", None)
@@ -785,28 +984,20 @@ class SBAdminAutocompleteWidget(
 
     def get_selected_option_cache_key(self, request):
         formset = getattr(getattr(self, "bound_form", None), "_sbadmin_formset", None)
-        return (
+        formset_prefix = getattr(formset, "prefix", "") or ""
+        return RequestCacheKey.autocomplete_selected_options(
             self.get_id(),
-            getattr(formset, "prefix", None),
+            formset_prefix,
             # Defensive: value_field changes how submitted values map back to rows.
             self.get_value_field(),
         )
 
-    def get_selected_option_cache(self, request):
-        cache = getattr(request, self.SELECTED_OPTION_CACHE_KEY, None)
-        if cache is None:
-            cache = {}
-            setattr(request, self.SELECTED_OPTION_CACHE_KEY, cache)
-        return cache
-
     def get_selected_option_items_from_cache(self, request, parsed_value):
         formset = getattr(getattr(self, "bound_form", None), "_sbadmin_formset", None)
         if formset is None:
             return None
 
-        cache = self.get_selected_option_cache(request)
-        cache_key = self.get_selected_option_cache_key(request)
-        if cache_key not in cache:
+        def load_items_by_value():
             values = []
             value_set = set()
             for form in formset.forms:
@@ -831,9 +1022,13 @@ class SBAdminAutocompleteWidget(
                     **{f"{self.get_value_field()}__in": values}
                 ):
                     items_by_value[str(self.get_value(request, item))] = item
-            cache[cache_key] = items_by_value
+            return items_by_value
 
-        items_by_value = cache[cache_key]
+        items_by_value = cache_on_request(
+            self.get_selected_option_cache_key(request),
+            load_items_by_value,
+            request=request,
+        )
         parsed_values = (
             parsed_value if isinstance(parsed_value, list) else [parsed_value]
         )
@@ -860,23 +1055,15 @@ class SBAdminAutocompleteWidget(
         if not self.is_multiselect():
             query_suffix = ""
             self.multiselect = False
-        context["widget"]["attrs"]["preselect_field"] = threadsafe_request.GET.get(
-            "sbadmin_parent_instance_field"
-        )
-        context["widget"]["attrs"]["preselect_field_label"] = (
-            threadsafe_request.GET.get(SBADMIN_PARENT_INSTANCE_LABEL_VAR)
-        )
-        context["widget"]["attrs"]["preselect_field_value"] = (
-            threadsafe_request.GET.get(SBADMIN_PARENT_INSTANCE_PK_VAR)
-        )
         parsed_value = None
+        selected_options = []
+        has_bound_value = bool(value)
         if value:
             parsed_value = self.parse_value_from_input(threadsafe_request, value)
             is_create = self.parse_is_create_from_input(
                 threadsafe_request,
                 threadsafe_request.request_data.request_post.get(name),
             )
-            selected_options = []
             if is_create:
                 errors = getattr(self.form, "errors", {})
                 if errors.get(self.field_name):
@@ -884,6 +1071,8 @@ class SBAdminAutocompleteWidget(
             if parsed_value:
                 if self.is_multiselect() and not isinstance(parsed_value, list):
                     parsed_value = [parsed_value]
+                elif not self.is_multiselect() and isinstance(parsed_value, list):
+                    parsed_value = next(iter(parsed_value), None)
 
                 try:
                     items = self.get_selected_option_items_from_cache(
@@ -900,7 +1089,7 @@ class SBAdminAutocompleteWidget(
                                 "label": self.get_label(threadsafe_request, item),
                             }
                         )
-                except ValueError as e:
+                except ValueError:
                     new_object_id = threadsafe_request.request_data.additional_data.get(
                         self.REQUEST_CREATED_DATA_KEY, {}
                     ).get(self.field_name)
@@ -919,6 +1108,18 @@ class SBAdminAutocompleteWidget(
                             ),
                         )
 
+        elif self._should_preselect_parent_instance(threadsafe_request):
+            parsed_value = threadsafe_request.GET.get(SBADMIN_PARENT_INSTANCE_PK_VAR)
+            selected_options = [
+                {
+                    "value": parsed_value,
+                    "label": threadsafe_request.GET.get(
+                        SBADMIN_PARENT_INSTANCE_LABEL_VAR, ""
+                    ),
+                }
+            ]
+
+        if has_bound_value or selected_options:
             context["widget"]["value"] = json.dumps(selected_options)
             context["widget"]["value_list"] = selected_options
 
@@ -936,6 +1137,11 @@ class SBAdminAutocompleteWidget(
 
         return context
 
+    def _should_preselect_parent_instance(self, request):
+        parent_field = request.GET.get(SBADMIN_PARENT_INSTANCE_FIELD_NAME_VAR)
+        parent_pk = request.GET.get(SBADMIN_PARENT_INSTANCE_PK_VAR)
+        return parent_field == self.input_id and bool(parent_pk)
+
     def add_related_buttons_urls(self, parsed_value, request, context):
         try:
             if hasattr(sb_admin_site, "get_model_admin"):

{django_smartbase_admin-2.0.1 → django_smartbase_admin-2.0.3}/src/django_smartbase_admin/audit/tests/test_action_processing.py

@@ -129,11 +129,25 @@ class RowList:
         self.rows = rows
 
     def filter(self, *args, **kwargs):
-        return self
+        rows = self.rows
+        for key, value in kwargs.items():
+            if key.endswith("__in"):
+                field_name = key.removesuffix("__in")
+                allowed = set(value)
+                rows = [row for row in rows if row.get(field_name) in allowed]
+            else:
+                rows = [row for row in rows if row.get(key) == value]
+        return RowList(rows)
 
     def order_by(self, *args):
         return self
 
+    def none(self):
+        return RowList([])
+
+    def union(self, other, all=False):
+        return RowList([*self.rows, *other.rows])
+
     def __iter__(self):
         return iter(self.rows)
 
@@ -380,7 +394,10 @@ class RowActionIntegrationTests(TestCase):
 
         with patch(
             "django_smartbase_admin.plugins.nested.resolve_nested",
-            return_value={"parent_field": "parent"},
+            return_value={
+                "parent_field": "parent",
+                "only_show_filtered_children": False,
+            },
         ):
             result = TabulatorNestedPlugin.modify_final_data(
                 action,

{django_smartbase_admin-2.0.1 → django_smartbase_admin-2.0.3}/src/django_smartbase_admin/engine/dynamic_forms.py

@@ -15,6 +15,25 @@ SBADMIN_DYNAMIC_REGION_PARAM = "sbadmin_dynamic_region"
 SBADMIN_DYNAMIC_REGION_PREFIX_PARAM = "sbadmin_dynamic_region_prefix"
 SBADMIN_DYNAMIC_REGION_ACTION = "sbadmin_dynamic_region"
 SBADMIN_DYNAMIC_REGION_ADD_MODIFIER = "add"
+_FORMSET_PREFIX_PLACEHOLDER = "__prefix__"
+_FORMSET_PREFIX_PLACEHOLDER_TOKEN = "\x00"
+
+
+def _dynamic_region_wrapper_id_from_parts(value: str) -> str:
+    """Build a wrapper id from joined prefix/region parts.
+
+    Django formset empty forms keep ``__prefix__`` in the prefix so
+    ``sbadmin_formset.js`` can substitute the row index. Slugify collapses
+    that token; underscore-to-hyphen replacement turns it into ``---prefix---``.
+    """
+    if _FORMSET_PREFIX_PLACEHOLDER in value:
+        protected = value.replace(
+            _FORMSET_PREFIX_PLACEHOLDER, _FORMSET_PREFIX_PLACEHOLDER_TOKEN
+        )
+        return protected.replace("_", "-").replace(
+            _FORMSET_PREFIX_PLACEHOLDER_TOKEN, _FORMSET_PREFIX_PLACEHOLDER
+        )
+    return slugify(value).replace("_", "-")
 
 
 def field_names_from_layout(layout: Iterable[Any]) -> tuple[str, ...]:
@@ -141,7 +160,7 @@ class SBDynamicRegion:
         if prefix:
             pieces.append(str(prefix))
         pieces.append(self.name)
-        return slugify("-".join(pieces)).replace("_", "-")
+        return _dynamic_region_wrapper_id_from_parts("-".join(pieces))
 
     def resolve(
         self, form: forms.Form, request: HttpRequest | None = None
@@ -535,6 +554,7 @@ class SBAdminDynamicFormMixin:
         collapsible = bool(fieldset_data.get("collapsible", False))
         default_collapsed = bool(fieldset_data.get("default_collapsed", False))
         hide_if_empty = bool(fieldset_data.get("hide_if_empty", False))
+        skip_header = bool(fieldset_data.get("skip_header", False))
         fieldset_layout = self.get_fieldset_layout(fieldset, fieldset_data, request)
         fieldset_empty = (
             hide_if_empty
@@ -551,6 +571,7 @@ class SBAdminDynamicFormMixin:
             "actions": self.get_fieldset_actions(fieldset, fieldset_data, request),
             "hide_if_empty": hide_if_empty,
             "empty": fieldset_empty,
+            "skip_header": skip_header,
         }
 
     def get_fieldset_layout(