wagtail 6.1.3__py3-none-any.whl → 6.2rc1__py3-none-any.whl

wagtail/api/v2/filters.py

@@ -46,6 +46,12 @@ class FieldsFilter(BaseFilterBackend):
                         % (value, field_name, str(e))
                     )
 
+                if "\x00" in str(value):
+                    raise BadRequestError(
+                        "field filter error. null characters are not allowed for %s"
+                        % field_name
+                    )
+
                 if isinstance(field, TaggableManager):
                     for tag in value.split(","):
                         queryset = queryset.filter(**{field_name + "__name": tag})

wagtail/api/v2/tests/test_documents.py

@@ -590,7 +590,7 @@ class TestDocumentFind(TestCase):
     },
     WAGTAILAPI_BASE_URL="http://api.example.com",
 )
-@mock.patch("wagtail.contrib.frontend_cache.backends.HTTPBackend.purge")
+@mock.patch("wagtail.contrib.frontend_cache.backends.http.HTTPBackend.purge")
 class TestDocumentCacheInvalidation(TestCase):
     fixtures = ["demosite.json"]
 

wagtail/api/v2/tests/test_images.py

@@ -582,7 +582,7 @@ class TestImageFind(TestCase):
     },
     WAGTAILAPI_BASE_URL="http://api.example.com",
 )
-@mock.patch("wagtail.contrib.frontend_cache.backends.HTTPBackend.purge")
+@mock.patch("wagtail.contrib.frontend_cache.backends.http.HTTPBackend.purge")
 class TestImageCacheInvalidation(TestCase):
     fixtures = ["demosite.json"]
 

wagtail/api/v2/tests/test_pages.py

@@ -683,6 +683,16 @@ class TestPageListing(WagtailTestUtils, TestCase):
             },
         )
 
+    def test_slug_field_containing_null_bytes_gives_error(self):
+        response = self.get_response(slug="\0")
+        content = json.loads(response.content.decode("UTF-8"))
+
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(
+            content,
+            {"message": "field filter error. null characters are not allowed for slug"},
+        )
+
     # CHILD OF FILTER
 
     def test_child_of_filter(self):
@@ -1848,7 +1858,7 @@ class TestPageDetailWithStreamField(TestCase):
     },
     WAGTAILAPI_BASE_URL="http://api.example.com",
 )
-@mock.patch("wagtail.contrib.frontend_cache.backends.HTTPBackend.purge")
+@mock.patch("wagtail.contrib.frontend_cache.backends.http.HTTPBackend.purge")
 class TestPageCacheInvalidation(TestCase):
     fixtures = ["demosite.json"]
 

wagtail/api/v2/utils.py

@@ -1,4 +1,4 @@
-from urllib.parse import urlparse
+from urllib.parse import urlsplit
 
 from django.conf import settings
 from django.utils.encoding import force_str
@@ -21,7 +21,7 @@ def get_base_url(request=None):
 
     if base_url:
         # We only want the scheme and netloc
-        base_url_parsed = urlparse(force_str(base_url))
+        base_url_parsed = urlsplit(force_str(base_url))
 
         return base_url_parsed.scheme + "://" + base_url_parsed.netloc
 

wagtail/blocks/base.py

@@ -97,6 +97,17 @@ class Block(metaclass=BaseBlock):
 
         self.label = self.meta.label or ""
 
+    @classmethod
+    def construct_from_lookup(cls, lookup, *args, **kwargs):
+        """
+        See `wagtail.blocks.definition_lookup.BlockDefinitionLookup`.
+        Construct a block instance from the provided arguments, using the given BlockDefinitionLookup
+        object to perform any necessary lookups.
+        """
+        # In the base implementation, no lookups take place - args / kwargs are passed
+        # on to the constructor as-is
+        return cls(*args, **kwargs)
+
     def set_name(self, name):
         self.name = name
         if not self.meta.label:
@@ -376,7 +387,11 @@ class Block(metaclass=BaseBlock):
         """
         return False
 
-    def deconstruct(self):
+    @cached_property
+    def canonical_module_path(self):
+        """
+        Return the module path string that should be used to refer to this block in migrations.
+        """
         # adapted from django.utils.deconstruct.deconstructible
         module_name = self.__module__
         name = self.__class__.__name__
@@ -394,16 +409,29 @@ class Block(metaclass=BaseBlock):
         # if the module defines a DECONSTRUCT_ALIASES dictionary, see if the class has an entry in there;
         # if so, use that instead of the real path
         try:
-            path = module.DECONSTRUCT_ALIASES[self.__class__]
+            return module.DECONSTRUCT_ALIASES[self.__class__]
         except (AttributeError, KeyError):
-            path = f"{module_name}.{name}"
+            return f"{module_name}.{name}"
 
+    def deconstruct(self):
         return (
-            path,
+            self.canonical_module_path,
             self._constructor_args[0],
             self._constructor_args[1],
         )
 
+    def deconstruct_with_lookup(self, lookup):
+        """
+        Like `deconstruct`, but with a `wagtail.blocks.definition_lookup.BlockDefinitionLookupBuilder`
+        object available so that any block instances within the definition can be added to the lookup
+        table to obtain an ID (potentially shared with other matching block definitions, thus reducing
+        the overall definition size) to be used in place of the block. The resulting deconstructed form
+        returned here can then be restored into a block object using `Block.construct_from_lookup`.
+        """
+        # In the base implementation, no substitutions happen, so we ignore the lookup and just call
+        # deconstruct
+        return self.deconstruct()
+
     def __eq__(self, other):
         """
         Implement equality on block objects so that two blocks with matching definitions are considered
@@ -411,14 +439,9 @@ class Block(metaclass=BaseBlock):
         attributes identified in MUTABLE_META_ATTRIBUTES, so checking these along with the result of
         deconstruct (which captures the constructor arguments) is sufficient to identify (valid) differences.
 
-        This was originally necessary as a workaround for https://code.djangoproject.com/ticket/24340
-        in Django <1.9; the deep_deconstruct function used to detect changes for migrations did not
-        recurse into the block lists, and left them as Block instances. This __eq__ method therefore
-        came into play when identifying changes within migrations.
-
-        As of Django >=1.9, this *probably* isn't required any more. However, it may be useful in
-        future as a way of identifying blocks that can be re-used within StreamField definitions
-        (https://github.com/wagtail/wagtail/issues/4298#issuecomment-367656028).
+        This was implemented as a workaround for a Django <1.9 bug and is quite possibly not used by Wagtail
+        any more, but has been retained as it provides a sensible definition of equality (and there's no
+        reason to break it).
         """
 
         if not isinstance(other, Block):

wagtail/blocks/definition_lookup.py

@@ -0,0 +1,85 @@
+from collections import defaultdict
+from importlib import import_module
+
+
+class BlockDefinitionLookup:
+    """
+    A utility for constructing StreamField Block objects in migrations, starting from
+    a compact representation that avoids repeating the same definition whenever a
+    block is re-used in multiple places over the block definition tree.
+
+    The underlying data is a dict of block definitions, such as:
+    ```
+    {
+        0: ("wagtail.blocks.CharBlock", [], {"required": True}),
+        1: ("wagtail.blocks.RichTextBlock", [], {}),
+        2: ("wagtail.blocks.StreamBlock", [
+            [
+                ("heading", 0),
+                ("paragraph", 1),
+            ],
+        ], {}),
+    }
+    ```
+
+    where each definition is a tuple of (module_path, args, kwargs) similar to that
+    returned by `deconstruct` - with the difference that any block objects appearing
+    in args / kwargs may be substituted with an index into the lookup table that
+    points to that block's definition. Any block class that wants to support such
+    substitutions should implement a static/class method
+    `construct_from_lookup(lookup, *args, **kwargs)`, where `lookup` is
+    the `BlockDefinitionLookup` instance. The method should return a block instance
+    constructed from the provided arguments (after performing any lookups).
+    """
+
+    def __init__(self, blocks):
+        self.blocks = blocks
+        self.block_classes = {}
+
+    def get_block(self, index):
+        path, args, kwargs = self.blocks[index]
+        try:
+            cls = self.block_classes[path]
+        except KeyError:
+            module_name, class_name = path.rsplit(".", 1)
+            module = import_module(module_name)
+            cls = self.block_classes[path] = getattr(module, class_name)
+
+        return cls.construct_from_lookup(self, *args, **kwargs)
+
+
+class BlockDefinitionLookupBuilder:
+    """
+    Helper for constructing the lookup data used by BlockDefinitionLookup
+    """
+
+    def __init__(self):
+        self.blocks = []
+
+        # Lookup table mapping the deconstructed tuple forms of blocks (as obtained from
+        # `block.deconstruct_with_lookup`) to their index in the `blocks` list. These
+        # tuples can be compared for equality, but not hashed, so we cannot use them as
+        # dict keys; instead, we index them on the first tuple element (the module path)
+        # and maintain a list of (index, deconstructed_tuple) pairs for each one.
+        self.block_indexes_by_type = defaultdict(list)
+
+    def add_block(self, block):
+        """
+        Add a block to the lookup table, returning an index that can be used to refer to it
+        """
+        deconstructed = block.deconstruct_with_lookup(self)
+
+        # Check if we've already seen this block definition
+        block_indexes = self.block_indexes_by_type[deconstructed[0]]
+        for index, existing_deconstructed in block_indexes:
+            if existing_deconstructed == deconstructed:
+                return index
+
+        # If not, add it to the lookup table
+        index = len(self.blocks)
+        self.blocks.append(deconstructed)
+        block_indexes.append((index, deconstructed))
+        return index
+
+    def get_lookup_as_dict(self):
+        return dict(enumerate(self.blocks))

wagtail/blocks/list_block.py

@@ -151,6 +151,12 @@ class ListBlock(Block):
             # Default to a list consisting of one empty (i.e. default-valued) child item
             self.meta.default = [self.child_block.get_default()]
 
+    @classmethod
+    def construct_from_lookup(cls, lookup, child_block, **kwargs):
+        if isinstance(child_block, int):
+            child_block = lookup.get_block(child_block)
+        return cls(child_block, **kwargs)
+
     def value_from_datadict(self, data, files, prefix):
         count = int(data["%s-count" % prefix])
         child_blocks_with_indexes = []
@@ -396,6 +402,12 @@ class ListBlock(Block):
         errors.extend(self.child_block.check(**kwargs))
         return errors
 
+    def deconstruct_with_lookup(self, lookup):
+        path, args, kwargs = super().deconstruct_with_lookup(lookup)
+        if isinstance(args[0], Block):
+            args = (lookup.add_block(args[0]),)
+        return path, args, kwargs
+
     class Meta:
         # 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

wagtail/blocks/migrations/migrate_operation.py

@@ -110,6 +110,8 @@ class MigrateStreamData(RunPython):
 
         updated_model_instances_buffer = []
         for instance in model_queryset.iterator(chunk_size=self.chunk_size):
+            if instance.raw_content is None:
+                continue
 
             revision_query_maker.append_instance_data_for_revision_query(instance)
 

wagtail/blocks/stream_block.py

@@ -89,6 +89,14 @@ class BaseStreamBlock(Block):
                 block.set_name(name)
                 self.child_blocks[name] = block
 
+    @classmethod
+    def construct_from_lookup(cls, lookup, child_blocks, **kwargs):
+        if child_blocks:
+            child_blocks = [
+                (name, lookup.get_block(index)) for name, index in child_blocks
+            ]
+        return cls(child_blocks, **kwargs)
+
     def empty_value(self, raw_text=None):
         return StreamValue(self, [], raw_text=raw_text)
 
@@ -433,6 +441,17 @@ class BaseStreamBlock(Block):
         kwargs = self._constructor_kwargs
         return (path, args, kwargs)
 
+    def deconstruct_with_lookup(self, lookup):
+        path = "wagtail.blocks.StreamBlock"
+        args = [
+            [
+                (name, lookup.add_block(block))
+                for name, block in self.child_blocks.items()
+            ]
+        ]
+        kwargs = self._constructor_kwargs
+        return (path, args, kwargs)
+
     def check(self, **kwargs):
         errors = super().check(**kwargs)
         for name, child_block in self.child_blocks.items():

wagtail/blocks/struct_block.py

@@ -119,6 +119,14 @@ class BaseStructBlock(Block):
                 block.set_name(name)
                 self.child_blocks[name] = block
 
+    @classmethod
+    def construct_from_lookup(cls, lookup, child_blocks, **kwargs):
+        if child_blocks:
+            child_blocks = [
+                (name, lookup.get_block(index)) for name, index in child_blocks
+            ]
+        return cls(child_blocks, **kwargs)
+
     def get_default(self):
         """
         Any default value passed in the constructor or self.meta is going to be a dict
@@ -312,6 +320,17 @@ class BaseStructBlock(Block):
         kwargs = self._constructor_kwargs
         return (path, args, kwargs)
 
+    def deconstruct_with_lookup(self, lookup):
+        path = "wagtail.blocks.StructBlock"
+        args = [
+            [
+                (name, lookup.add_block(block))
+                for name, block in self.child_blocks.items()
+            ]
+        ]
+        kwargs = self._constructor_kwargs
+        return (path, args, kwargs)
+
     def check(self, **kwargs):
         errors = super().check(**kwargs)
         for name, child_block in self.child_blocks.items():

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: 2024-04-18 17:28+0100\n"
+"POT-Creation-Date: 2024-07-19 16:26+0100\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"

wagtail/contrib/frontend_cache/backends/__init__.py

@@ -0,0 +1,5 @@
+from .base import *  # noqa
+from .azure import *  # noqa
+from .http import *  # noqa
+from .cloudflare import *  # noqa
+from .cloudfront import *  # noqa

wagtail/contrib/frontend_cache/backends/azure.py

@@ -0,0 +1,179 @@
+import logging
+from urllib.parse import urlsplit, urlunsplit
+
+from django.core.exceptions import ImproperlyConfigured
+
+from .base import BaseBackend
+
+logger = logging.getLogger("wagtail.frontendcache")
+
+
+__all__ = ["AzureBaseBackend", "AzureFrontDoorBackend", "AzureCdnBackend"]
+
+
+class AzureBaseBackend(BaseBackend):
+    def __init__(self, params):
+        super().__init__(params)
+        self._credentials = params.pop("CREDENTIALS", None)
+        self._subscription_id = params.pop("SUBSCRIPTION_ID", None)
+        try:
+            self._resource_group_name = params.pop("RESOURCE_GROUP_NAME")
+        except KeyError:
+            raise ImproperlyConfigured(
+                "The setting 'WAGTAILFRONTENDCACHE' requires 'RESOURCE_GROUP_NAME' to be specified."
+            )
+        self._custom_headers = params.pop("CUSTOM_HEADERS", None)
+
+    def purge_batch(self, urls):
+        self._purge_content([self._get_path(url) for url in urls])
+
+    def purge(self, url):
+        self.purge_batch([url])
+
+    def _get_default_credentials(self):
+        try:
+            from azure.identity import DefaultAzureCredential
+        except ImportError:
+            return
+        return DefaultAzureCredential()
+
+    def _get_credentials(self):
+        """
+        Use credentials object set by user. If not set, use the one configured
+        in the current environment.
+        """
+        user_credentials = self._credentials
+        if user_credentials:
+            return user_credentials
+        return self._get_default_credentials()
+
+    def _get_default_subscription_id(self):
+        """
+        Obtain subscription ID directly from Azure.
+        """
+        try:
+            from azure.mgmt.resource import SubscriptionClient
+        except ImportError:
+            return ""
+        credential = self._get_credentials()
+        subscription_client = SubscriptionClient(credential)
+        subscription = next(subscription_client.subscriptions.list())
+        return subscription.subscription_id
+
+    def _get_subscription_id(self):
+        """
+        Use subscription ID set in the user configuration. If not set, try to
+        retrieve one from Azure directly.
+        """
+        user_subscription_id = self._subscription_id
+        if user_subscription_id:
+            return user_subscription_id
+        return self._get_default_subscription_id()
+
+    def _get_client_kwargs(self):
+        return {
+            "credential": self._get_credentials(),
+            "subscription_id": self._get_subscription_id(),
+        }
+
+    def _get_path(self, url):
+        """
+        Split netloc from the URL and return path only.
+        """
+        # Delete scheme and netloc from the URL, that will result in only path being
+        # left.
+        url_parts = ("",) * 2 + urlsplit(url)[2:]
+        return urlunsplit(url_parts)
+
+    def _get_client(self):
+        """
+        Get Azure client instance.
+        """
+        klass = self._get_client_class()
+        kwargs = self._get_client_kwargs()
+        return klass(**kwargs)
+
+    def _get_purge_kwargs(self, paths):
+        """
+        Get keyword arguments passes to Azure purge content calls.
+        """
+        return {
+            "resource_group_name": self._resource_group_name,
+            "custom_headers": self._custom_headers,
+            "content_paths": paths,
+        }
+
+    def _purge_content(self, paths):
+        from msrest.exceptions import HttpOperationError
+
+        client = self._get_client()
+        try:
+            self._make_purge_call(client, paths)
+        except HttpOperationError as exception:
+            for path in paths:
+                logger.exception(
+                    "Couldn't purge '%s' from %s cache. HttpOperationError: %r",
+                    path,
+                    type(self).__name__,
+                    exception.response,
+                )
+
+
+class AzureFrontDoorBackend(AzureBaseBackend):
+    def __init__(self, params):
+        super().__init__(params)
+        try:
+            self._front_door_name = params.pop("FRONT_DOOR_NAME")
+        except KeyError:
+            raise ImproperlyConfigured(
+                "The setting 'WAGTAILFRONTENDCACHE' requires 'FRONT_DOOR_NAME' to be specified."
+            )
+        self._front_door_service_url = params.pop("FRONT_DOOR_SERVICE_URL", None)
+
+    def _get_client_class(self):
+        from azure.mgmt.frontdoor import FrontDoorManagementClient
+
+        return FrontDoorManagementClient
+
+    def _get_client_kwargs(self):
+        kwargs = super()._get_client_kwargs()
+        kwargs.setdefault("base_url", self._front_door_service_url)
+
+        return kwargs
+
+    def _make_purge_call(self, client, paths):
+        return client.endpoints.purge_content(
+            **self._get_purge_kwargs(paths),
+            front_door_name=self._front_door_name,
+        )
+
+
+class AzureCdnBackend(AzureBaseBackend):
+    def __init__(self, params):
+        super().__init__(params)
+        try:
+            self._cdn_profile_name = params.pop("CDN_PROFILE_NAME")
+            self._cdn_endpoint_name = params.pop("CDN_ENDPOINT_NAME")
+        except KeyError:
+            raise ImproperlyConfigured(
+                "The setting 'WAGTAILFRONTENDCACHE' requires 'CDN_PROFILE_NAME' and 'CDN_ENDPOINT_NAME' to be specified."
+            )
+        self._cdn_service_url = params.pop("CDN_SERVICE_URL", None)
+
+    def _get_client_class(self):
+        from azure.mgmt.cdn import CdnManagementClient
+
+        return CdnManagementClient
+
+    def _get_client_kwargs(self):
+        kwargs = super()._get_client_kwargs()
+        kwargs.setdefault("base_url", self._cdn_service_url)
+
+        return kwargs
+
+    def _make_purge_call(self, client, paths):
+        return client.endpoints.purge_content(
+            **self._get_purge_kwargs(paths),
+            profile_name=self._cdn_profile_name,
+            endpoint_name=self._cdn_endpoint_name,
+        )

wagtail/contrib/frontend_cache/backends/base.py

@@ -0,0 +1,28 @@
+import logging
+
+from django.http.request import validate_host
+
+logger = logging.getLogger("wagtail.frontendcache")
+
+
+__all__ = ["BaseBackend"]
+
+
+class BaseBackend:
+    def __init__(self, params):
+        # If unspecified, invalidate all hosts
+        self.hostnames = params.get("HOSTNAMES", ["*"])
+
+    def purge(self, url) -> None:
+        raise NotImplementedError
+
+    def purge_batch(self, urls) -> None:
+        # Fallback for backends that do not support batch purging
+        for url in urls:
+            self.purge(url)
+
+    def invalidates_hostname(self, hostname) -> bool:
+        """
+        Can `hostname` be invalidated by this backend?
+        """
+        return validate_host(hostname, self.hostnames)