You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tooling.apache.org by sb...@apache.org on 2025/11/09 11:51:45 UTC

(tooling-trusted-releases) branch main updated (63c4ccf -> 7a8534d)

This is an automated email from the ASF dual-hosted git repository.

sbp pushed a change to branch main
in repository https://gitbox.apache.org/repos/asf/tooling-trusted-releases.git


 discard 63c4ccf  Allow custom field errors after Pydantic validation
     new 7a8534d  Allow custom field errors after Pydantic validation

This update added new revisions after undoing existing revisions.
That is to say, some revisions that were in the old version of the
branch are not in the new version.  This situation occurs
when a user --force pushes a change and generates a repository
containing something like this:

 * -- * -- B -- O -- O -- O   (63c4ccf)
            \
             N -- N -- N   refs/heads/main (7a8534d)

You should already have received notification emails for all of the O
revisions, and so the following emails describe only the N revisions
from the common base, B.

Any revisions marked "omit" are not gone; other references still
refer to them.  Any revisions marked "discard" are gone forever.

The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 atr/principal.py | 2 +-
 atr/web.py       | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@tooling.apache.org
For additional commands, e-mail: commits-help@tooling.apache.org


(tooling-trusted-releases) 01/01: Allow custom field errors after Pydantic validation

Posted by sb...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

sbp pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/tooling-trusted-releases.git

commit 7a8534d11bfb2f0e716013595908c591b16e9fdf
Author: Sean B. Palmer <se...@miscoranda.com>
AuthorDate: Sun Nov 9 11:29:36 2025 +0000

    Allow custom field errors after Pydantic validation
---
 atr/blueprints/post.py | 63 ++++++++++++++++++++++++++++-------------------
 atr/form.py            | 17 ++++++++++++-
 atr/htm.py             |  7 ++++--
 atr/post/test.py       |  5 ++++
 atr/principal.py       |  2 +-
 atr/web.py             | 67 ++++++++++++++++++++++++++++++++++++++++----------
 6 files changed, 119 insertions(+), 42 deletions(-)

diff --git a/atr/blueprints/post.py b/atr/blueprints/post.py
index 1e1286d..5498b3e 100644
--- a/atr/blueprints/post.py
+++ b/atr/blueprints/post.py
@@ -24,12 +24,10 @@ from typing import Any
 import asfquart.auth as auth
 import asfquart.base as base
 import asfquart.session
-import markupsafe
 import pydantic
 import quart
 
 import atr.form
-import atr.htm as htm
 import atr.log as log
 import atr.web as web
 
@@ -108,21 +106,34 @@ def empty() -> Callable[[Callable[..., Awaitable[Any]]], Callable[..., Awaitable
     #     pass
     def decorator(func: Callable[..., Awaitable[Any]]) -> Callable[..., Awaitable[Any]]:
         async def wrapper(session: web.Committer | None, *args: Any, **kwargs: Any) -> Any:
+            match session:
+                case web.Committer() as committer:
+                    form_data = await committer.form_data()
+                case None:
+                    form_data = await atr.form.quart_request()
             try:
-                form_data = await atr.form.quart_request()
-                context = {"session": session}
-                atr.form.validate(atr.form.Empty, form_data, context)
+                context = {
+                    "args": args,
+                    "kwargs": kwargs,
+                    "session": session,
+                }
+                match session:
+                    case web.Committer() as committer:
+                        await committer.form_validate(atr.form.Empty, context=context)
+                    case None:
+                        atr.form.validate(atr.form.Empty, form_data, context=context)
                 return await func(session, *args, **kwargs)
             except pydantic.ValidationError:
-                # This presumably should not happen, because the CSRF token checker reaches it first
-                msg = "Sorry, your form session expired for security reasons. Please try again."
+                # This could happen if the form was tampered with
+                # It should not happen if the CSRF token is invalid
+                msg = "Sorry, there was an empty form validation error. Please try again."
                 await quart.flash(msg, "error")
                 return quart.redirect(quart.request.path)
 
-        wrapper.__name__ = func.__name__
-        wrapper.__module__ = func.__module__
-        wrapper.__doc__ = func.__doc__
         wrapper.__annotations__ = func.__annotations__.copy()
+        wrapper.__doc__ = func.__doc__
+        wrapper.__module__ = func.__module__
+        wrapper.__name__ = func.__name__
         return wrapper
 
     return decorator
@@ -133,31 +144,33 @@ def form(
 ) -> Callable[[Callable[..., Awaitable[Any]]], Callable[..., Awaitable[Any]]]:
     def decorator(func: Callable[..., Awaitable[Any]]) -> Callable[..., Awaitable[Any]]:
         async def wrapper(session: web.Committer | None, *args: Any, **kwargs: Any) -> Any:
-            form_data = await atr.form.quart_request()
+            match session:
+                case web.Committer() as committer:
+                    form_data = await committer.form_data()
+                case None:
+                    form_data = await atr.form.quart_request()
             try:
-                context = {"session": session}
-                validated_form = atr.form.validate(form_cls, form_data, context)
+                context = {
+                    "args": args,
+                    "kwargs": kwargs,
+                    "session": session,
+                }
+                match session:
+                    case web.Committer() as committer:
+                        validated_form = await committer.form_validate(form_cls, context)
+                    case None:
+                        validated_form = atr.form.validate(form_cls, form_data, context=context)
                 return await func(session, validated_form, *args, **kwargs)
             except pydantic.ValidationError as e:
                 errors = e.errors()
                 if len(errors) == 0:
                     raise RuntimeError("Validation failed, but no errors were reported")
                 flash_data = atr.form.flash_error_data(form_cls, errors, form_data)
-
-                plural = len(errors) > 1
-                summary = f"Please fix the following issue{'s' if plural else ''}:"
-                ul = htm.Block(htm.ul, classes=".mt-2.mb-0")
-                for i, flash_datum in enumerate(flash_data.values()):
-                    if i > 9:
-                        ul.li["And more, not shown here..."]
-                        break
-                    if "msg" in flash_datum:
-                        ul.li[htm.strong[flash_datum["label"]], ": ", flash_datum["msg"]]
-                summary = f"{summary}\n{ul.collect()}"
+                summary = atr.form.flash_error_summary(errors, flash_data)
 
                 # TODO: Centralise all uses of markupsafe.Markup
                 # log.info(f"Flash data: {flash_data}")
-                await quart.flash(markupsafe.Markup(summary), category="error")
+                await quart.flash(summary, category="error")
                 await quart.flash(json.dumps(flash_data), category="form-error-data")
                 return quart.redirect(quart.request.path)
 
diff --git a/atr/form.py b/atr/form.py
index 06744e4..81ad0d7 100644
--- a/atr/form.py
+++ b/atr/form.py
@@ -23,6 +23,7 @@ import types
 from typing import TYPE_CHECKING, Annotated, Any, Final, Literal, get_args, get_origin
 
 import htpy
+import markupsafe
 import pydantic
 import pydantic.functional_validators as functional_validators
 import quart
@@ -35,7 +36,6 @@ import atr.models.schema as schema
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
-    import markupsafe
     import pydantic_core
 
     import atr.web as web
@@ -96,6 +96,21 @@ def flash_error_data(
     return flash_data
 
 
+def flash_error_summary(errors: list[pydantic_core.ErrorDetails], flash_data: dict[str, Any]) -> markupsafe.Markup:
+    div = htm.Block()
+    plural = len(errors) > 1
+    div.text(f"Please fix the following issue{'s' if plural else ''}:")
+    with div.block(htm.ul, classes=".mt-2.mb-0") as ul:
+        for i, flash_datum in enumerate(flash_data.values()):
+            if i > 9:
+                ul.li["And more, not shown here..."]
+                break
+            if "msg" in flash_datum:
+                ul.li[htm.strong[flash_datum["label"]], ": ", flash_datum["msg"]]
+    summary = div.collect()
+    return markupsafe.Markup(summary)
+
+
 def json_suitable(field_value: Any) -> Any:
     if isinstance(field_value, datastructures.FileStorage):
         return field_value.filename
diff --git a/atr/htm.py b/atr/htm.py
index 720febe..530800d 100644
--- a/atr/htm.py
+++ b/atr/htm.py
@@ -129,9 +129,12 @@ class Block:
 
     @contextlib.contextmanager
     def block(
-        self, element: Element | None = None, separator: Element | VoidElement | str | None = None
+        self,
+        element: Element | None = None,
+        classes: str | None = None,
+        separator: Element | VoidElement | str | None = None,
     ) -> Generator[Block, Any, Any]:
-        block = Block(element)
+        block = Block(element, classes=classes)
         yield block
         self.append(block.collect(separator=separator))
 
diff --git a/atr/post/test.py b/atr/post/test.py
index 3e3ef1e..d5a4a01 100644
--- a/atr/post/test.py
+++ b/atr/post/test.py
@@ -55,6 +55,11 @@ async def test_multiple(session: web.Committer | None, form: shared.test.Multipl
 async def test_single(session: web.Committer | None, form: shared.test.SingleForm) -> web.WerkzeugResponse:
     file_names = [f.filename for f in form.files] if form.files else []
     compatibility_names = [f.value for f in form.compatibility] if form.compatibility else []
+    if (form.message == "Forbidden message!") and (session is not None):
+        return await session.form_error(
+            "message",
+            "You are not permitted to submit the forbidden message",
+        )
     msg = (
         f"Single form received:"
         f" name={form.name},"
diff --git a/atr/principal.py b/atr/principal.py
index 66c7d99..911dce1 100644
--- a/atr/principal.py
+++ b/atr/principal.py
@@ -356,7 +356,7 @@ class Authorisation(AsyncObject):
             case ArgumentNoneType() | web.Committer():
                 match asf_uid:
                     case web.Committer():
-                        asfquart_session = asf_uid._session
+                        asfquart_session = asf_uid.session
                     case _:
                         asfquart_session = await asfquart.session.read()
                 # asfquart_session = await session.read()
diff --git a/atr/web.py b/atr/web.py
index a843fde..da2c0b5 100644
--- a/atr/web.py
+++ b/atr/web.py
@@ -17,16 +17,19 @@
 
 from __future__ import annotations
 
+import json
 import urllib.parse
 from typing import TYPE_CHECKING, Any, Protocol, TypeVar
 
 import asfquart.base as base
 import asfquart.session as session
+import pydantic_core
 import quart
 import werkzeug.datastructures.headers
 
 import atr.config as config
 import atr.db as db
+import atr.form as form
 import atr.htm as htm
 import atr.models.sql as sql
 import atr.user as user
@@ -35,9 +38,9 @@ import atr.util as util
 if TYPE_CHECKING:
     from collections.abc import Awaitable, Sequence
 
+    import pydantic
     import werkzeug.wrappers.response as response
 
-
 R = TypeVar("R", covariant=True)
 
 type WerkzeugResponse = response.Response
@@ -58,19 +61,25 @@ class Committer:
     """Session with extra information about committers."""
 
     def __init__(self, web_session: session.ClientSession) -> None:
-        self._projects: list[sql.Project] | None = None
-        self._session = web_session
+        self.__form_cls: type[form.Form] | None = None
+        self.__form_data: dict[str, Any] | None = None
+        self.__projects: list[sql.Project] | None = None
+        self.session = web_session
 
     @property
     def asf_uid(self) -> str:
-        if self._session.uid is None:
+        if self.session.uid is None:
             raise base.ASFQuartException("Not authenticated", errorcode=401)
-        return self._session.uid
+        return self.session.uid
 
     def __getattr__(self, name: str) -> Any:
         # TODO: Not type safe, should subclass properly if possible
         # For example, we can access session.no_such_attr and the type checkers won't notice
-        return getattr(self._session, name)
+        return getattr(self.session, name)
+
+    @property
+    def app_host(self) -> str:
+        return config.get().APP_HOST
 
     async def check_access(self, project_name: str) -> None:
         if not any((p.name == project_name) for p in (await self.user_projects)):
@@ -93,9 +102,37 @@ class Committer:
                 return
             raise base.ASFQuartException("You do not have access to this committee", errorcode=403)
 
-    @property
-    def app_host(self) -> str:
-        return config.get().APP_HOST
+    async def form_data(self) -> dict[str, Any]:
+        if self.__form_data is None:
+            self.__form_data = await form.quart_request()
+        # Avoid mutations from writing back to our copy
+        return self.__form_data.copy()
+
+    async def form_error(self, field_name: str, error_msg: str) -> WerkzeugResponse:
+        if self.__form_cls is None:
+            raise ValueError("Form class not set")
+        if self.__form_data is None:
+            raise ValueError("Form data not set")
+        errors = [
+            pydantic_core.ErrorDetails(
+                loc=(field_name,),
+                msg=error_msg,
+                input=self.__form_data[field_name],
+                type="atr_error",
+            )
+        ]
+        flash_data = form.flash_error_data(self.__form_cls, errors, self.__form_data)
+        summary = form.flash_error_summary(errors, flash_data)
+
+        await quart.flash(summary, category="error")
+        await quart.flash(json.dumps(flash_data), category="form-error-data")
+        return quart.redirect(quart.request.path)
+
+    async def form_validate(self, form_cls: type[form.Form], context: dict[str, Any]) -> pydantic.BaseModel:
+        self.__form_cls = form_cls
+        if self.__form_data is None:
+            self.__form_data = await form.quart_request()
+        return form.validate(form_cls, self.__form_data.copy(), context=context)
 
     @property
     def host(self) -> str:
@@ -165,7 +202,7 @@ class Committer:
 
     @property
     async def user_candidate_drafts(self) -> list[sql.Release]:
-        return await user.candidate_drafts(self.uid, user_projects=self._projects)
+        return await user.candidate_drafts(self.uid, user_projects=self.__projects)
 
     # @property
     # async def user_committees(self) -> list[models.Committee]:
@@ -173,9 +210,9 @@ class Committer:
 
     @property
     async def user_projects(self) -> list[sql.Project]:
-        if self._projects is None:
-            self._projects = await user.projects(self.uid)
-        return self._projects[:]
+        if self.__projects is None:
+            self.__projects = await user.projects(self.uid)
+        return self.__projects[:]
 
 
 class ElementResponse(quart.Response):
@@ -241,6 +278,10 @@ class ZipResponse(quart.Response):
         super().__init__(response, status=status, headers=raw_headers, mimetype="application/zip")
 
 
+async def form_error(error: str) -> None:
+    pass
+
+
 async def redirect[R](
     route: RouteFunction[R], success: str | None = None, error: str | None = None, **kwargs: Any
 ) -> WerkzeugResponse:


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@tooling.apache.org
For additional commands, e-mail: commits-help@tooling.apache.org