wagtail 7.2.1__py3-none-any.whl → 7.3rc1__py3-none-any.whl

wagtail/admin/widgets/button.py

@@ -19,7 +19,13 @@ class BaseButton(Component):
     allow_in_dropdown = False
 
     def __init__(
-        self, label="", url=None, classname="", icon_name=None, attrs={}, priority=1000
+        self,
+        label="",
+        url=None,
+        classname="",
+        icon_name=None,
+        attrs=None,
+        priority=1000,
     ):
         if label:
             self.label = label
@@ -33,7 +39,8 @@ class BaseButton(Component):
             self.icon_name = icon_name
 
         self.attrs = self.attrs.copy()
-        self.attrs.update(attrs)
+        if attrs:
+            self.attrs.update(attrs)
         self.priority = priority
 
     def get_context_data(self, parent_context):
@@ -115,12 +122,12 @@ class HeaderButton(BaseButton):
         url=None,
         classname="",
         icon_name=None,
-        attrs={},
+        attrs=None,
         icon_only=False,
         **kwargs,
     ):
         classname = f"{classname} w-header-button button".strip()
-        attrs = attrs.copy()
+        attrs = attrs.copy() if attrs else {}
         if icon_only:
             controller = f"{attrs.get('data-controller', '')} w-tooltip".strip()
             attrs["data-controller"] = controller

wagtail/admin/widgets/chooser.py

@@ -157,8 +157,10 @@ class BaseChooser(widgets.Input):
         # so let's make sure it fails early in the process
         try:
             id_ = attrs["id"]
-        except (KeyError, TypeError):
-            raise TypeError("BaseChooser cannot be rendered without an 'id' attribute")
+        except (KeyError, TypeError) as e:
+            raise TypeError(
+                "BaseChooser cannot be rendered without an 'id' attribute"
+            ) from e
 
         value_data = self.get_value_data(value)
         widget_html = self.render_html(name, value_data, attrs)
@@ -241,12 +243,12 @@ class AdminPageChooser(BaseChooser):
             for model in target_models:
                 try:
                     cleaned_target_models.append(resolve_model_string(model))
-                except (ValueError, LookupError):
+                except (ValueError, LookupError) as e:
                     raise ImproperlyConfigured(
                         "Could not resolve %r into a model. "
                         "Model names should be in the form app_label.model_name"
                         % (model,)
-                    )
+                    ) from e
         else:
             cleaned_target_models = [Page]
 

wagtail/admin/widgets/slug.py

@@ -27,7 +27,7 @@ class SlugInput(widgets.TextInput):
                     str | None,
                 ],
             ]
-        ) = [],
+        ) = None,
         locale: object | None = None,
     ):
         default_attrs = {

wagtail/api/v2/filters.py

@@ -45,7 +45,7 @@ class FieldsFilter(BaseFilterBackend):
                     raise BadRequestError(
                         "field filter error. '%s' is not a valid value for %s (%s)"
                         % (value, field_name, str(e))
-                    )
+                    ) from e
 
                 if "\x00" in str(value):
                     raise BadRequestError(
@@ -106,8 +106,10 @@ class OrderingFilter(BaseFilterBackend):
 
         try:
             return queryset.order_by(*validated_fields)
-        except FieldError:
-            raise BadRequestError(f"cannot order by '{order_param}' (invalid field)")
+        except FieldError as e:
+            raise BadRequestError(
+                f"cannot order by '{order_param}' (invalid field)"
+            ) from e
 
 
 class SearchFilter(BaseFilterBackend):
@@ -145,13 +147,13 @@ class SearchFilter(BaseFilterBackend):
                     "cannot filter by '{}' while searching (field is not indexed)".format(
                         e.field_name
                     )
-                )
+                ) from e
             except OrderByFieldError as e:
                 raise BadRequestError(
                     "cannot order by '{}' while searching (field is not indexed)".format(
                         e.field_name
                     )
-                )
+                ) from e
 
         return queryset
 
@@ -170,13 +172,13 @@ class ChildOfFilter(BaseFilterBackend):
                     raise ValueError()
 
                 parent_page = view.get_base_queryset().get(id=parent_page_id)
-            except ValueError:
+            except ValueError as e:
                 if request.GET["child_of"] == "root":
                     parent_page = view.get_root_page()
                 else:
-                    raise BadRequestError("child_of must be a positive integer")
-            except Page.DoesNotExist:
-                raise BadRequestError("parent page doesn't exist")
+                    raise BadRequestError("child_of must be a positive integer") from e
+            except Page.DoesNotExist as e:
+                raise BadRequestError("parent page doesn't exist") from e
 
             queryset = queryset.child_of(parent_page)
 
@@ -202,10 +204,10 @@ class AncestorOfFilter(BaseFilterBackend):
                     raise ValueError()
 
                 descendant_page = view.get_base_queryset().get(id=descendant_page_id)
-            except ValueError:
-                raise BadRequestError("ancestor_of must be a positive integer")
-            except Page.DoesNotExist:
-                raise BadRequestError("descendant page doesn't exist")
+            except ValueError as e:
+                raise BadRequestError("ancestor_of must be a positive integer") from e
+            except Page.DoesNotExist as e:
+                raise BadRequestError("descendant page doesn't exist") from e
 
             queryset = queryset.ancestor_of(descendant_page)
 
@@ -230,13 +232,15 @@ class DescendantOfFilter(BaseFilterBackend):
                     raise ValueError()
 
                 parent_page = view.get_base_queryset().get(id=parent_page_id)
-            except ValueError:
+            except ValueError as e:
                 if request.GET["descendant_of"] == "root":
                     parent_page = view.get_root_page()
                 else:
-                    raise BadRequestError("descendant_of must be a positive integer")
-            except Page.DoesNotExist:
-                raise BadRequestError("ancestor page doesn't exist")
+                    raise BadRequestError(
+                        "descendant_of must be a positive integer"
+                    ) from e
+            except Page.DoesNotExist as e:
+                raise BadRequestError("ancestor page doesn't exist") from e
 
             queryset = queryset.descendant_of(parent_page)
 
@@ -257,13 +261,15 @@ class TranslationOfFilter(BaseFilterBackend):
                     raise ValueError()
 
                 page = view.get_base_queryset().get(id=page_id)
-            except ValueError:
+            except ValueError as e:
                 if request.GET["translation_of"] == "root":
                     page = view.get_root_page()
                 else:
-                    raise BadRequestError("translation_of must be a positive integer")
-            except Page.DoesNotExist:
-                raise BadRequestError("translation_of page doesn't exist")
+                    raise BadRequestError(
+                        "translation_of must be a positive integer"
+                    ) from e
+            except Page.DoesNotExist as e:
+                raise BadRequestError("translation_of page doesn't exist") from e
 
             _filtered_by_child_of = getattr(queryset, "_filtered_by_child_of", None)
 

wagtail/api/v2/pagination.py

@@ -15,16 +15,16 @@ class WagtailPagination(BasePagination):
             offset = int(request.GET.get("offset", 0))
             if offset < 0:
                 raise ValueError()
-        except ValueError:
-            raise BadRequestError("offset must be a positive integer")
+        except ValueError as e:
+            raise BadRequestError("offset must be a positive integer") from e
 
         try:
             limit_default = 20 if not limit_max else min(20, limit_max)
             limit = int(request.GET.get("limit", limit_default))
             if limit < 0:
                 raise ValueError()
-        except ValueError:
-            raise BadRequestError("limit must be a positive integer")
+        except ValueError as e:
+            raise BadRequestError("limit must be a positive integer") from e
 
         if limit_max and limit > limit_max:
             raise BadRequestError("limit cannot be higher than %d" % limit_max)

wagtail/api/v2/views.py

@@ -109,8 +109,8 @@ class BaseAPIViewSet(GenericViewSet):
             if obj is None:
                 raise self.model.DoesNotExist
 
-        except self.model.DoesNotExist:
-            raise Http404("not found")
+        except self.model.DoesNotExist as e:
+            raise Http404("not found") from e
 
         # Generate redirect
         url = get_object_detail_url(
@@ -366,7 +366,7 @@ class BaseAPIViewSet(GenericViewSet):
             try:
                 fields_config = parse_fields_parameter(request.GET["fields"])
             except ValueError as e:
-                raise BadRequestError("fields error: %s" % str(e))
+                raise BadRequestError("fields error: %s" % str(e)) from e
         else:
             # Use default fields
             fields_config = []
@@ -549,10 +549,10 @@ class PagesAPIViewSet(BaseAPIViewSet):
                 }
             try:
                 site = Site.objects.get(**query)
-            except Site.MultipleObjectsReturned:
+            except Site.MultipleObjectsReturned as e:
                 raise BadRequestError(
                     "Your query returned multiple sites. Try adding a port number to your site filter."
-                )
+                ) from e
         else:
             # Otherwise, find the site from the request
             site = Site.find_for_request(self.request)
@@ -579,8 +579,8 @@ class PagesAPIViewSet(BaseAPIViewSet):
         try:
             models_type = request.GET.get("type", None)
             models = models_type and page_models_from_string(models_type) or []
-        except (LookupError, ValueError):
-            raise BadRequestError("type doesn't exist")
+        except (LookupError, ValueError) as e:
+            raise BadRequestError("type doesn't exist") from e
 
         if not models:
             if self.model == Page:

wagtail/blocks/list_block.py

@@ -458,14 +458,6 @@ class ListBlockAdapter(Adapter):
             "classname": block.meta.form_classname,
             "attrs": block.meta.form_attrs or {},
             "collapsed": block.meta.collapsed,
-            "strings": {
-                "MOVE_UP": _("Move up"),
-                "MOVE_DOWN": _("Move down"),
-                "DRAG": _("Drag"),
-                "DUPLICATE": _("Duplicate"),
-                "DELETE": _("Delete"),
-                "ADD": _("Add"),
-            },
         }
         help_text = getattr(block.meta, "help_text", None)
         if help_text:

wagtail/blocks/migrations/migrate_operation.py

@@ -155,8 +155,15 @@ class MigrateStreamData(RunPython):
 
         updated_revisions_buffer = []
         for revision in revision_queryset.iterator(chunk_size=self.chunk_size):
+            try:
+                json_data = revision.content[self.field_name]
+            except KeyError:
+                # The requested field doesn't exist on this revision. The revision may
+                # have been created before the creation of the field. Don't process this
+                # revision.
+                continue
 
-            raw_data = json.loads(revision.content[self.field_name])
+            raw_data = json.loads(json_data)
             for operation, block_path_str in self.operations_and_block_paths:
                 try:
                     raw_data = utils.apply_changes_to_raw_data(

wagtail/blocks/stream_block.py

@@ -812,10 +812,10 @@ class StreamValue(MutableSequence):
     def __reduce__(self):
         try:
             stream_field = self._stream_field
-        except AttributeError:
+        except AttributeError as e:
             raise PickleError(
                 "StreamValue can only be pickled if it is associated with a StreamField"
-            )
+            ) from e
 
         return (
             self._deserialize_pickle_value,
@@ -845,14 +845,6 @@ class StreamBlockAdapter(Adapter):
             "minNum": block.meta.min_num,
             "blockCounts": block.meta.block_counts,
             "collapsed": block.meta.collapsed,
-            "strings": {
-                "MOVE_UP": _("Move up"),
-                "MOVE_DOWN": _("Move down"),
-                "DRAG": _("Drag"),
-                "DUPLICATE": _("Duplicate"),
-                "DELETE": _("Delete"),
-                "ADD": _("Add"),
-            },
         }
         help_text = getattr(block.meta, "help_text", None)
         if help_text:

wagtail/blocks/struct_block.py

@@ -1,15 +1,19 @@
 import collections
+from typing import Union
 
 from django import forms
+from django.core import checks
 from django.core.exceptions import ValidationError
 from django.forms.utils import ErrorList
 from django.template.loader import render_to_string
 from django.utils.functional import cached_property
 from django.utils.html import format_html, format_html_join
 from django.utils.safestring import mark_safe
+from django.utils.translation import gettext_lazy as _
 
 from wagtail.admin.staticfiles import versioned_static
 from wagtail.admin.telepath import Adapter, register
+from wagtail.coreutils import safe_snake_case
 
 from .base import (
     Block,
@@ -21,6 +25,7 @@ from .base import (
 )
 
 __all__ = [
+    "BlockGroup",
     "BaseStructBlock",
     "StructBlock",
     "StructValue",
@@ -70,6 +75,132 @@ class StructBlockValidationError(ValidationError):
         return result
 
 
+@register
+class BlockGroup:
+    """
+    A grouping of blocks within a :class:`StructBlock`'s form layout in the
+    editing interface. Can be used directly as the ``form_layout`` in
+    :class:`StructBlock`.Meta, or nested within another ``BlockGroup``.
+    """
+
+    def __init__(
+        self,
+        children: list[Union[str, "BlockGroup"]],
+        settings: list[Union[str, "BlockGroup"]] = None,
+        heading="",
+        classname="",
+        help_text="",
+        icon="placeholder",
+        attrs: dict | None = None,
+        label_format: str | None = None,
+    ):
+        """
+        :param children: A list of block names or nested ``BlockGroup`` that will be
+            rendered in the main content area.
+        :type children: list[str | BlockGroup]
+
+        :param settings: A list of block names or nested ``BlockGroup`` that will be
+            rendered in the collapsible "settings" area that is hidden by default.
+        :type settings: list[str | BlockGroup]
+
+        The following attributes are only used when the ``BlockGroup`` is nested within
+        another ``BlockGroup``. For the top-level ``BlockGroup`` used as
+        ``Meta.form_layout`` in a :class:`StructBlock`, these attributes are ignored in
+        favor of the corresponding attributes on ``StructBlock.Meta``.
+
+        :param heading: The heading label of the collapsible panel for this block
+            group. For a top-level group, the ``StructBlock``'s ``label`` will be
+            used instead.
+        :type heading: str
+
+        :param classname: Additional CSS class name(s) to add to the block group's main
+            content area. To set the group to be initially collapsed, include the
+            ``collapsed`` class here.
+        :type classname: str
+
+        :param help_text: Help text to display below the block group's heading.
+        :type help_text: str
+
+        :param icon: The name of the icon to display alongside the block group's heading.
+        :type icon: str
+
+        :param attrs: A dictionary of HTML attributes to add to the block group's main content area.
+        :type attrs: dict
+
+        :param label_format: The summary label shown after the ``heading`` when the
+            block is collapsed in the editing interface. By default, the value of the
+            first child block is shown, but this can be customized by setting a string
+            here with block names contained in braces - for example ``label_format = "
+            {surname}, {first_name}"``. If you wish to hide the summary label entirely,
+            set this to the empty string ``""``.
+        :type label_format: str | None
+        """
+        self.children = children
+        self.settings = settings or []
+        self.heading = heading or _("Group")
+        self.clean_name = safe_snake_case(self.heading)
+        self.classname = classname
+        self.help_text = help_text
+        self.icon = icon
+        self.attrs = attrs or {}
+        self.label_format = label_format
+
+    telepath_adapter_name = "wagtail.blocks.BlockGroup"
+
+    @cached_property
+    def unique_children_and_settings(self):
+        # Ensure unique identifiers in the case of multiple BlockGroups with the
+        # same headings on the same level, either in children or settings.
+        used_names = set()
+
+        def group_with_unique_names(group):
+            results = []
+            for child in group:
+                base_name = child.clean_name if isinstance(child, BlockGroup) else child
+                candidate_name = base_name
+                suffix = 0
+                while candidate_name in used_names:
+                    suffix += 1
+                    candidate_name = "%s%d" % (base_name, suffix)
+                results.append((child, candidate_name))
+                used_names.add(candidate_name)
+            return results
+
+        children = group_with_unique_names(self.children)
+        settings = group_with_unique_names(self.settings)
+        return children, settings
+
+    def get_sorted_block_names(self):
+        """
+        Return a flat list of all block names in this ``BlockGroup`` and any
+        nested ``BlockGroups`` in the group's list order.
+        """
+        block_names = []
+        for child in self.children + self.settings:
+            if isinstance(child, BlockGroup):
+                block_names.extend(child.get_sorted_block_names())
+            else:
+                block_names.append(child)
+        return block_names
+
+    def js_opts(self):
+        children, settings = self.unique_children_and_settings
+        return {
+            "children": children,
+            "settings": settings,
+            "heading": self.heading,
+            "cleanName": self.clean_name,
+            "classname": self.classname,
+            "helpText": self.help_text,
+            "icon": self.icon,
+            "attrs": self.attrs,
+            "labelFormat": self.label_format,
+        }
+
+    def telepath_pack(self, context):
+        return (self.telepath_adapter_name, [self.js_opts()])
+
+
 class StructValue(collections.OrderedDict):
     """A class that generates a StructBlock value from provided sub-blocks"""
 
@@ -119,6 +250,17 @@ class BaseStructBlock(Block):
                 block.set_name(name)
                 self.child_blocks[name] = block
 
+        self.meta.form_layout = self.get_form_layout()
+
+        # Reorder child_blocks to match form_layout, appending any missing
+        # blocks to the end
+        sorted_block_names = self.meta.form_layout.get_sorted_block_names()
+        missing_block_names = self.child_blocks.keys() - set(sorted_block_names)
+        self.child_blocks = collections.OrderedDict(
+            (name, self.child_blocks[name])
+            for name in (sorted_block_names + list(missing_block_names))
+        )
+
     @classmethod
     def construct_from_lookup(cls, lookup, child_blocks, **kwargs):
         if child_blocks:
@@ -335,9 +477,27 @@ class BaseStructBlock(Block):
         for name, child_block in self.child_blocks.items():
             errors.extend(child_block.check(**kwargs))
             errors.extend(child_block._check_name(**kwargs))
+        errors.extend(self._check_form_layout())
 
         return errors
 
+    def _check_form_layout(self):
+        if self.meta.form_template and any(
+            isinstance(name, BlockGroup)
+            for name in (
+                self.meta.form_layout.children + self.meta.form_layout.settings
+            )
+        ):
+            return [
+                checks.Error(
+                    f"{self.__class__.__name__}.Meta.form_layout cannot have "
+                    "nested BlockGroups when using a custom form_template.",
+                    obj=self,
+                    id="wagtailcore.E007",
+                )
+            ]
+        return []
+
     def render_basic(self, value, context=None):
         return format_html(
             "<dl>\n{}\n</dl>",
@@ -363,24 +523,42 @@ class BaseStructBlock(Block):
         return super().get_description() or getattr(self.meta, "help_text", "")
 
     def get_form_context(self, value, prefix="", errors=None):
-        return {
-            "children": collections.OrderedDict(
-                [
-                    (
-                        name,
-                        PlaceholderBoundBlock(
-                            block, value.get(name), prefix=f"{prefix}-{name}"
-                        ),
-                    )
-                    for name, block in self.child_blocks.items()
-                ]
-            ),
+        children = collections.OrderedDict(
+            [
+                (
+                    name,
+                    PlaceholderBoundBlock(
+                        block, value.get(name), prefix=f"{prefix}-{name}"
+                    ),
+                )
+                for name, block in self.child_blocks.items()
+            ]
+        )
+        # Move settings blocks into a separate dict for easier access in templates
+        settings = collections.OrderedDict(
+            [(name, children.pop(name)) for name in self.meta.form_layout.settings]
+        )
+        context = {
+            "children": children,
+            "settings": settings,
             "help_text": getattr(self.meta, "help_text", None),
             "classname": self.meta.form_classname,
             "collapsed": self.meta.collapsed,
             "block_definition": self,
             "prefix": prefix,
         }
+        return context
+
+    def get_form_layout(self) -> BlockGroup:
+        """
+        Return the :class:`BlockGroup` representing the form layout for this
+        ``StructBlock``.
+        """
+        if (form_layout := self.meta.form_layout) is None:
+            return BlockGroup(list(self.child_blocks.keys()))
+        if isinstance(form_layout, list):
+            return BlockGroup(form_layout)
+        return form_layout
 
     @cached_property
     def _has_default(self):
@@ -393,6 +571,7 @@ class BaseStructBlock(Block):
         value_class = StructValue
         label_format = None
         collapsed = False
+        form_layout: BlockGroup | list[Union[str, "BlockGroup"]] | None = None
         # No icon specified here, because that depends on the purpose that the
         # block is being used for. Feel encouraged to specify an icon in your
         # descendant block type
@@ -417,6 +596,7 @@ class StructBlockAdapter(Adapter):
             "classname": block.meta.form_classname,
             "collapsed": block.meta.collapsed,
             "attrs": block.meta.form_attrs or {},
+            "formLayout": block.meta.form_layout,
         }
 
         help_text = getattr(block.meta, "help_text", None)

wagtail/compat.py

@@ -9,10 +9,10 @@ AUTH_USER_MODEL = getattr(settings, "AUTH_USER_MODEL", "auth.User")
 # specifying the user model in the FakeORM
 try:
     AUTH_USER_APP_LABEL, AUTH_USER_MODEL_NAME = AUTH_USER_MODEL.rsplit(".", 1)
-except ValueError:
+except ValueError as e:
     raise ImproperlyConfigured(
         "AUTH_USER_MODEL must be of the form 'app_label.model_name'"
-    )
+    ) from e
 
 
 try:

wagtail/contrib/forms/locale/en/LC_MESSAGES/django.po

@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2025-10-23 16:45+0100\n"
+"POT-Creation-Date: 2026-01-21 18:00+0000\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"