wagtail 6.3.3__py3-none-any.whl → 6.4__py3-none-any.whl

wagtail/users/utils.py

@@ -1,3 +1,5 @@
+from urllib.parse import parse_qs, urlparse, urlunparse
+
 from django.conf import settings
 from django.utils.http import urlencode
 from django.utils.translation import gettext_lazy as _
@@ -25,11 +27,29 @@ def user_can_delete_user(current_user, user_to_delete):
     return True
 
 
-def get_gravatar_url(email, size=50):
-    default = "mm"
-    size = (
-        int(size) * 2
-    )  # requested at retina size by default and scaled down at point of use with css
+def get_gravatar_url(email, size=50, default_params={"d": "mp"}):
+    """
+    See https://gravatar.com/site/implement/images/ for Gravatar image options.
+
+    Example usage:
+
+    .. code-block:: python
+
+        # Basic usage
+        gravatar_url = get_gravatar_url('user@example.com')
+
+        # Customize size and default image
+        gravatar_url = get_gravatar_url(
+            'user@example.com',
+            size=100,
+            default_params={'d': 'robohash', 'f': 'y'}
+        )
+
+    Note:
+        If any parameter in ``default_params`` also exists in the provider URL,
+        it will be overridden by the provider URL's query parameter.
+    """
+
     gravatar_provider_url = getattr(
         settings, "WAGTAIL_GRAVATAR_PROVIDER_URL", "//www.gravatar.com/avatar"
     )
@@ -37,14 +57,26 @@ def get_gravatar_url(email, size=50):
     if (not email) or (gravatar_provider_url is None):
         return None
 
-    email_bytes = email.lower().encode("utf-8")
-    hash = safe_md5(email_bytes, usedforsecurity=False).hexdigest()
-    gravatar_url = "{gravatar_provider_url}/{hash}?{params}".format(
-        gravatar_provider_url=gravatar_provider_url.rstrip("/"),
-        hash=hash,
-        params=urlencode({"s": size, "d": default}),
+    parsed_url = urlparse(gravatar_provider_url)
+
+    params = {
+        **default_params,
+        **(parse_qs(parsed_url.query or "")),
+        # requested at retina size by default and scaled down at point of use with css
+        "s": int(size) * 2,
+    }
+
+    email_hash = safe_md5(
+        email.lower().encode("utf-8"), usedforsecurity=False
+    ).hexdigest()
+
+    parsed_url = parsed_url._replace(
+        path=f"{parsed_url.path.rstrip('/')}/{email_hash}",
+        query=urlencode(params, doseq=True),
     )
 
+    gravatar_url = urlunparse(parsed_url)
+
     return gravatar_url
 
 

wagtail/utils/setup.py

@@ -29,10 +29,10 @@ class assets_mixin:
         Writes the current Wagtail version number into package.json
         """
         path = os.path.join(".", "client", "package.json")
-        input_file = open(path)
 
         try:
-            package = json.loads(input_file.read().decode("utf-8"))
+            with open(path, "r") as f:
+                package = json.loads(f.read())
         except ValueError as e:
             print("Unable to read " + path + " " + e)  # noqa: T201
             raise SystemExit(1)

wagtail/utils/templates.py

@@ -0,0 +1,26 @@
+from functools import lru_cache
+from pathlib import Path
+
+from django.template import TemplateDoesNotExist
+from django.template.loader import select_template
+
+import wagtail
+
+
+@lru_cache(maxsize=None)
+def template_is_overridden(template_name: str, expected_location: str) -> bool:
+    """
+    Check if a template has been overridden.
+
+    A template is overridden if the resolved template file is different from the
+    expected location within the `wagtail` package directory.
+    """
+    try:
+        template = select_template([template_name])
+    except TemplateDoesNotExist:
+        return False
+
+    root = Path(wagtail.__file__).resolve().parent
+    path = str(root / expected_location / template_name)
+
+    return template.origin.name != path

wagtail/utils/widgets.py

@@ -10,6 +10,7 @@ class WidgetWithScript(Widget):
     warn(
         "The usage of `WidgetWithScript` hook is deprecated. Use external scripts instead.",
         category=RemovedInWagtail70Warning,
+        stacklevel=3,
     )
 
     def render_html(self, name, value, attrs):

wagtail/views.py

@@ -9,6 +9,10 @@ from wagtail.forms import PasswordViewRestrictionForm
 from wagtail.models import Page, PageViewRestriction
 
 
+def serve_chain(page, request, args, kwargs):
+    return page.serve(request, *args, **kwargs)
+
+
 def serve(request, path):
     route_result = Page.route_for_request(request, path)
     if route_result is None:
@@ -16,12 +20,16 @@ def serve(request, path):
     else:
         page, args, kwargs = route_result
 
+    on_serve_chain = serve_chain
+    for fn in reversed(hooks.get_hooks("on_serve_page")):
+        on_serve_chain = fn(on_serve_chain)
+
     for fn in hooks.get_hooks("before_serve_page"):
         result = fn(page, request, args, kwargs)
         if isinstance(result, HttpResponse):
             return result
 
-    return page.serve(request, *args, **kwargs)
+    return on_serve_chain(page, request, args, kwargs)
 
 
 def authenticate_with_password(request, page_view_restriction_id, page_id):

wagtail/wagtail_hooks.py

@@ -1,19 +1,26 @@
+from typing import TYPE_CHECKING
+
 from django.conf import settings
 from django.contrib.auth.models import Permission
 from django.contrib.auth.views import redirect_to_login
 from django.db import models
 from django.urls import reverse
+from django.utils.cache import add_never_cache_headers
 from django.utils.text import capfirst
 from django.utils.translation import gettext_lazy as _
 from django.utils.translation import ngettext
 
 from wagtail import hooks
+from wagtail.compat import HTTPMethod
 from wagtail.coreutils import get_content_languages
 from wagtail.log_actions import LogFormatter
 from wagtail.models import ModelLogEntry, Page, PageLogEntry, PageViewRestriction
 from wagtail.rich_text.pages import PageLinkHandler
 from wagtail.utils.timestamps import parse_datetime_localized, render_timestamp
 
+if TYPE_CHECKING:
+    from django.http import HttpRequest
+
 
 def require_wagtail_login(next):
     login_url = getattr(
@@ -22,35 +29,51 @@ def require_wagtail_login(next):
     return redirect_to_login(next, login_url)
 
 
-@hooks.register("before_serve_page")
-def check_view_restrictions(page, request, serve_args, serve_kwargs):
-    """
-    Check whether there are any view restrictions on this page which are
-    not fulfilled by the given request object. If there are, return an
-    HttpResponse that will notify the user of that restriction (and possibly
-    include a password / login form that will allow them to proceed). If
-    there are no such restrictions, return None
-    """
-    for restriction in page.get_view_restrictions():
-        if not restriction.accept_request(request):
-            if restriction.restriction_type == PageViewRestriction.PASSWORD:
-                from wagtail.forms import PasswordViewRestrictionForm
-
-                form = PasswordViewRestrictionForm(
-                    instance=restriction,
-                    initial={"return_url": request.get_full_path()},
-                )
-                action_url = reverse(
-                    "wagtailcore_authenticate_with_password",
-                    args=[restriction.id, page.id],
-                )
-                return page.serve_password_required_response(request, form, action_url)
-
-            elif restriction.restriction_type in [
-                PageViewRestriction.LOGIN,
-                PageViewRestriction.GROUPS,
-            ]:
-                return require_wagtail_login(next=request.get_full_path())
+@hooks.register("on_serve_page")
+def check_view_restrictions(callback):
+    def inner(page, request, serve_args, serve_kwargs):
+        """
+        Check whether there are any view restrictions on this page which are
+        not fulfilled by the given request object. If there are, return an
+        HttpResponse that will notify the user of that restriction (and possibly
+        include a password / login form that will allow them to proceed). If
+        there are no such restrictions, return None
+        """
+        restrictions = page.get_view_restrictions()
+        response = None
+        for restriction in restrictions:
+            if not restriction.accept_request(request):
+                if restriction.restriction_type == PageViewRestriction.PASSWORD:
+                    from wagtail.forms import PasswordViewRestrictionForm
+
+                    form = PasswordViewRestrictionForm(
+                        instance=restriction,
+                        initial={"return_url": request.get_full_path()},
+                    )
+                    action_url = reverse(
+                        "wagtailcore_authenticate_with_password",
+                        args=[restriction.id, page.id],
+                    )
+
+                    response = page.serve_password_required_response(
+                        request, form, action_url
+                    )
+                    add_never_cache_headers(response)
+                    return response
+                elif restriction.restriction_type in [
+                    PageViewRestriction.LOGIN,
+                    PageViewRestriction.GROUPS,
+                ]:
+                    response = require_wagtail_login(next=request.get_full_path())
+                    add_never_cache_headers(response)
+                    return response
+
+        response = callback(page, request, serve_args, serve_kwargs)
+        if restrictions:
+            add_never_cache_headers(response)
+        return response
+
+    return inner
 
 
 @hooks.register("register_rich_text_features")
@@ -551,3 +574,18 @@ def register_workflow_log_actions(actions):
                 }
             except (KeyError, TypeError):
                 return _("Workflow cancelled")
+
+
+@hooks.register("before_serve_page", order=0)
+def check_request_method(page: Page, request: "HttpRequest", *args, **kwargs):
+    """
+    Before serving, check the request method is permitted by the page,
+    and use the page object's :meth:``wagtail.models.Page.handle_options_request``
+    method to generate a response if the OPTIONS HTTP verb is used.
+    """
+    check_response = page.check_request_method(request, *args, **kwargs)
+    if check_response is not None:
+        return check_response
+    if request.method == HTTPMethod.OPTIONS.value:
+        return page.handle_options_request(request, *args, **kwargs)
+    return None

{wagtail-6.3.3.dist-info → wagtail-6.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wagtail
-Version: 6.3.3
+Version: 6.4
 Summary: A Django content management system.
 Home-page: https://wagtail.org/
 Author: Wagtail core team + contributors
@@ -42,11 +42,11 @@ Requires-Dist: Pillow (<12.0.0,>=9.1.0)
 Requires-Dist: beautifulsoup4 (<4.13,>=4.8)
 Requires-Dist: Willow[heif] (<2,>=1.8.0)
 Requires-Dist: requests (<3.0,>=2.11.1)
-Requires-Dist: l18n (>=2018.5)
 Requires-Dist: openpyxl (<4.0,>=3.0.10)
 Requires-Dist: anyascii (>=0.1.5)
 Requires-Dist: telepath (<1,>=0.3.1)
 Requires-Dist: laces (<0.2,>=0.1)
+Requires-Dist: django-tasks (<0.7,>=0.6.1)
 Provides-Extra: docs
 Requires-Dist: pyenchant (<4,>=3.1.1) ; extra == 'docs'
 Requires-Dist: sphinxcontrib-spelling (<8,>=7) ; extra == 'docs'