wagtail 7.2rc1__py3-none-any.whl → 7.3rc1__py3-none-any.whl

wagtail/admin/views/workflows.py

@@ -184,6 +184,12 @@ class Create(CreateView):
     def get_form_class(self):
         return self.get_edit_handler().get_form_class()
 
+    def get_initial_form_instance(self):
+        # defining this method ensures that self.object is set to a new instance
+        # while constructing the form, making it available to get_pages_formset
+        # and get_content_type_form during is_valid
+        return self.model()
+
     def get_pages_formset(self):
         if self.request.method == "POST":
             return WorkflowPagesFormSet(
@@ -213,36 +219,41 @@ class Create(CreateView):
         context["media"] = form.media + bound_panel.media + pages_formset.media
         return context
 
+    def is_valid(self, form):
+        if not super().is_valid(form):
+            return False
+
+        self.pages_formset = self.get_pages_formset()
+        self.content_type_form = self.get_content_type_form()
+
+        if not self.pages_formset.is_valid() or not self.content_type_form.is_valid():
+            self.produced_error_message = self.get_error_message()
+            return False
+
+        return True
+
     def form_valid(self, form):
         self.form = form
 
         with transaction.atomic():
             self.object = self.save_instance()
 
-            pages_formset = self.get_pages_formset()
-            content_type_form = self.get_content_type_form()
-            if pages_formset.is_valid() and content_type_form.is_valid():
-                pages_formset.save()
-                content_type_form.save()
-
-                success_message = self.get_success_message(self.object)
-                if success_message is not None:
-                    messages.success(
-                        self.request,
-                        success_message,
-                        buttons=[
-                            messages.button(
-                                reverse(self.edit_url_name, args=(self.object.id,)),
-                                _("Edit"),
-                            )
-                        ],
-                    )
-                return redirect(self.get_success_url())
-
-            else:
-                transaction.set_rollback(True)
-
-        return self.form_invalid(form)
+            self.pages_formset.save()
+            self.content_type_form.save()
+
+            success_message = self.get_success_message(self.object)
+            if success_message is not None:
+                messages.success(
+                    self.request,
+                    success_message,
+                    buttons=[
+                        messages.button(
+                            reverse(self.edit_url_name, args=(self.object.id,)),
+                            _("Edit"),
+                        )
+                    ],
+                )
+            return redirect(self.get_success_url())
 
 
 class Edit(EditView):
@@ -326,42 +337,50 @@ class Edit(EditView):
     def get_enable_url(self):
         return reverse(self.enable_url_name, args=(self.object.pk,))
 
+    def is_valid(self, form):
+        if not super().is_valid(form):
+            return False
+
+        if self.object.active:
+            # Note: These are hidden when the workflow is inactive
+            self.pages_formset = self.get_pages_formset()
+            self.content_type_form = self.get_content_type_form()
+
+            if (
+                not self.pages_formset.is_valid()
+                or not self.content_type_form.is_valid()
+            ):
+                self.produced_error_message = self.get_error_message()
+                return False
+
+        return True
+
     @transaction.atomic()
     def form_valid(self, form):
         self.form = form
 
         with transaction.atomic():
             self.object = self.save_instance()
-            successful = True
 
-            # Save pages formset and content type form
-            # Note: These are hidden when the workflow is inactive
             if self.object.active:
-                pages_formset = self.get_pages_formset()
-                content_type_form = self.get_content_type_form()
-                if pages_formset.is_valid() and content_type_form.is_valid():
-                    pages_formset.save()
-                    content_type_form.save()
-                else:
-                    transaction.set_rollback(True)
-                    successful = False
-
-            if successful:
-                success_message = self.get_success_message()
-                if success_message is not None:
-                    messages.success(
-                        self.request,
-                        success_message,
-                        buttons=[
-                            messages.button(
-                                reverse(self.edit_url_name, args=(self.object.id,)),
-                                _("Edit"),
-                            )
-                        ],
-                    )
-                return redirect(self.get_success_url())
-
-        return self.form_invalid(form)
+                # Save pages formset and content type form
+                # Note: These are hidden when the workflow is inactive
+                self.pages_formset.save()
+                self.content_type_form.save()
+
+            success_message = self.get_success_message()
+            if success_message is not None:
+                messages.success(
+                    self.request,
+                    success_message,
+                    buttons=[
+                        messages.button(
+                            reverse(self.edit_url_name, args=(self.object.id,)),
+                            _("Edit"),
+                        )
+                    ],
+                )
+            return redirect(self.get_success_url())
 
 
 class Disable(DeleteView):
@@ -651,8 +670,8 @@ class CreateTask(CreateView):
             content_type = ContentType.objects.get_by_natural_key(
                 self.kwargs["app_label"], self.kwargs["model_name"]
             )
-        except (ContentType.DoesNotExist, AttributeError):
-            raise Http404
+        except (ContentType.DoesNotExist, AttributeError) as e:
+            raise Http404 from e
 
         # Get class
         model = content_type.model_class()

wagtail/admin/viewsets/model.py

@@ -2,8 +2,10 @@ from django.contrib.auth import get_permission_codename
 from django.contrib.auth.models import Permission
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ImproperlyConfigured
+from django.db import models
 from django.forms.models import modelform_factory
 from django.urls import path
+from django.urls.converters import get_converters
 from django.utils.functional import cached_property
 from django.utils.text import capfirst
 
@@ -129,6 +131,24 @@ class ModelViewSet(ViewSet):
     def permission_policy(self):
         return ModelPermissionPolicy(self.model)
 
+    @cached_property
+    def pk_path_converter(self):
+        """
+        :ref:`Path converter <topics/http/urls:path converters>` to use for
+        the model's primary key in URL patterns. Defaults to ``"int"`` for
+        ``IntegerField``, ``"uuid"`` for ``UUIDField``, and ``"str"`` for all
+        other types.
+
+        .. versionadded:: 7.3
+           The ``pk_path_converter`` property was added.
+        """
+        if isinstance(self.model_opts.pk, models.UUIDField):
+            return "uuid"
+        if isinstance(self.model_opts.pk, models.IntegerField):
+            return "int"
+        # Default to string if unknown
+        return "str"
+
     @cached_property
     def name(self):
         """
@@ -649,38 +669,44 @@ class ModelViewSet(ViewSet):
         hooks.register("register_permissions", self.get_permissions_to_register)
 
     def get_urlpatterns(self):
+        conv = self.pk_path_converter
         urlpatterns = [
             path("", self.index_view, name="index"),
             path("results/", self.index_results_view, name="index_results"),
             path("new/", self.add_view, name="add"),
-            path("edit/<str:pk>/", self.edit_view, name="edit"),
-            path("delete/<str:pk>/", self.delete_view, name="delete"),
-            path("history/<str:pk>/", self.history_view, name="history"),
+            path(f"edit/<{conv}:pk>/", self.edit_view, name="edit"),
+            path(f"delete/<{conv}:pk>/", self.delete_view, name="delete"),
+            path(f"history/<{conv}:pk>/", self.history_view, name="history"),
             path(
-                "history-results/<str:pk>/",
+                f"history-results/<{conv}:pk>/",
                 self.history_results_view,
                 name="history_results",
             ),
-            path("usage/<str:pk>/", self.usage_view, name="usage"),
+            path(f"usage/<{conv}:pk>/", self.usage_view, name="usage"),
         ]
 
         if self.reorder_view_enabled:
             urlpatterns.append(
-                path("reorder/<str:pk>/", self.reorder_view, name="reorder")
+                path(f"reorder/<{conv}:pk>/", self.reorder_view, name="reorder")
             )
 
         if self.inspect_view_enabled:
             urlpatterns.append(
-                path("inspect/<str:pk>/", self.inspect_view, name="inspect")
+                path(f"inspect/<{conv}:pk>/", self.inspect_view, name="inspect")
             )
 
         if self.copy_view_enabled:
-            urlpatterns.append(path("copy/<str:pk>/", self.copy_view, name="copy"))
+            urlpatterns.append(path(f"copy/<{conv}:pk>/", self.copy_view, name="copy"))
 
         return urlpatterns
 
     def on_register(self):
         super().on_register()
+        if self.pk_path_converter not in get_converters():
+            raise ImproperlyConfigured(
+                f"{self.__class__.__name__}.pk_path_converter is not a "
+                "registered path converter"
+            )
         self.register_admin_url_finder()
         self.register_reference_index()
         self.register_permissions()

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: