pydantic-forms 2.5.0__tar.gz → 2.7.0__tar.gz

pydantic_forms-2.7.0/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: pydantic-forms
+Version: 2.7.0
+Summary: Pydantic-forms engine.
+Author: SURF
+Author-email: SURF <automation-beheer@surf.nl>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: FastAPI
+Classifier: Framework :: Flask
+Classifier: Framework :: Pydantic :: 2
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Intended Audience :: Telecommunications Industry
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development
+Classifier: Typing :: Typed
+Requires-Dist: more-itertools>=10.0.0
+Requires-Dist: pydantic[email]>=2.9.0
+Requires-Dist: pydantic-i18n==0.4.5
+Requires-Dist: fastapi>=0.103.2 ; extra == 'fastapi'
+Requires-Dist: orjson>=3.10.7,<4.0.0 ; extra == 'orjson'
+Requires-Python: >=3.10, <3.15
+Project-URL: Documentation, https://workfloworchestrator.org/pydantic-forms/
+Project-URL: Homepage, https://github.com/workfloworchestrator/pydantic-forms
+Project-URL: Source, https://github.com/workfloworchestrator/pydantic-forms
+Provides-Extra: fastapi
+Provides-Extra: orjson
+Description-Content-Type: text/markdown
+
+# Pydantic forms
+
+[![pypi_version](https://img.shields.io/pypi/v/pydantic-forms?color=%2334D058&label=pypi%20package)](https://pypi.org/project/pydantic-forms)
+[![Supported python versions](https://img.shields.io/pypi/pyversions/pydantic-forms.svg?color=%2334D058)](https://pypi.org/project/pydantic-forms)
+[![Downloads](https://static.pepy.tech/badge/pydantic-forms/month)](https://pepy.tech/project/pydantic-forms)
+[![codecov](https://codecov.io/gh/workfloworchestrator/pydantic-forms/branch/main/graph/badge.svg?token=AJMOSWPHQX)](https://codecov.io/gh/workfloworchestrator/pydantic-forms)
+
+A Python package that lets you add smart forms to [FastAPI](https://fastapi.tiangolo.com/)
+and [Flask](https://palletsprojects.com/p/flask/). Forms will respond with a JSON scheme that
+contains all info needed in a React frontend with uniforms to render the forms and handle all validation tasks.
+
+Forms can also consist out of a wizard, so you can create complex form flows consisting out of multiple
+consecutive forms. The forms and the validation logic are defined by
+using [Pydantic](https://pydantic-docs.helpmanual.io/) models.
+
+Documentation regarding the usage of Forms can be found at
+[workfloworchestrator.org/pydantic-forms](https://workfloworchestrator.org/pydantic-forms/).
+
+### Installation (Development standalone)
+
+This project uses [uv](https://docs.astral.sh/uv/). Install the project and its dependencies to develop on the code:
+
+```shell
+uv sync --all-extras
+```
+
+This creates a `.venv`, installs `pydantic-forms` in editable mode, and installs the `dev` dependency group
+(which chains in `test` and `doc`) plus the `fastapi` and `orjson` extras. There is no need to create or
+activate a virtualenv yourself -- prefix commands with `uv run` and uv will use the right interpreter.
+
+### Running tests
+Run the unit-test suite to verify a correct setup.
+
+```shell
+uv run pytest tests/unit_tests
+```
+
+or with xdist:
+
+```shell
+uv run pytest -n auto tests/unit_tests
+```
+
+If you do not encounter any failures in the test, you should be able to develop features in the pydantic-forms.
+
+### Installation (Development version used by a project that depends on pydantic-forms)
+
+If you are working on a project that already uses `pydantic-forms` and you want to test your new form features
+against it, point that project at your local checkout. Run this **from the other project**:
+
+```shell
+uv add --editable /path/to/pydantic-forms
+```
+
+This replaces the PyPI dependency with an editable install of your working copy and records it under
+`[tool.uv.sources]` in that project's `pyproject.toml`. Undo it with:
+
+```shell
+uv remove pydantic-forms && uv add pydantic-forms
+```
+
+# Increasing the version number for a (pre) release.
+
+When your PR is accepted you will get a version number.
+
+You can do the necessary change with a clean, e.g. every change committed, branch:
+
+```shell
+uv version 0.0.1
+```
+
+Note: specifying the version explicitly, instead of relying on `uv version --bump patch` to increase it, allows
+you to set a "RC1" version if needed -- e.g. `uv version 0.0.1rc1`.
+
+# Debugging Form behaviour
+
+If you want/need the traceback of pydantic in a Form response you can add an env variable:
+
+`
+LOG_LEVEL_PYDANTIC_FORMS=DEBUG
+`
+
+This will add the traceback to the `JSONResponse`. If the loglevel is set to DEBUG the library will also add the
+traceback to the logger.

{pydantic_forms-2.5.0 → pydantic_forms-2.7.0}/README.md

@@ -13,75 +13,50 @@ Forms can also consist out of a wizard, so you can create complex form flows con
 consecutive forms. The forms and the validation logic are defined by
 using [Pydantic](https://pydantic-docs.helpmanual.io/) models.
 
-Documentation regarding the usage of Forms can be found
-[here](https://github.com/workfloworchestrator/orchestrator-core/blob/main/docs/architecture/application/forms-frontend.md)
+Documentation regarding the usage of Forms can be found at
+[workfloworchestrator.org/pydantic-forms](https://workfloworchestrator.org/pydantic-forms/).
 
 ### Installation (Development standalone)
-Install the project and its dependencies to develop on the code.
 
-#### Step 1 - install flit:
+This project uses [uv](https://docs.astral.sh/uv/). Install the project and its dependencies to develop on the code:
 
 ```shell
-python3 -m venv venv
-source venv/bin/activate
-pip install flit
-```
-
-#### Step 2 - install the development code:
-```shell
-flit install --deps develop --symlink --python venv/bin/python
-```
-
-!!! danger
-    Make sure to use the flit binary that is installed in your environment. You can check the correct
-    path by running
-    ```shell
-    which flit
-    ```
-
-To be sure that the packages will be installed against the correct venv you can also prepend the python interpreter
-that you want to use:
-
-```shell
-flit install --deps develop --symlink --python venv/bin/python
+uv sync --all-extras
 ```
 
+This creates a `.venv`, installs `pydantic-forms` in editable mode, and installs the `dev` dependency group
+(which chains in `test` and `doc`) plus the `fastapi` and `orjson` extras. There is no need to create or
+activate a virtualenv yourself -- prefix commands with `uv run` and uv will use the right interpreter.
 
 ### Running tests
 Run the unit-test suite to verify a correct setup.
 
-#### Step 2 - Run tests
 ```shell
-pytest tests/unit_tests
+uv run pytest tests/unit_tests
 ```
 
 or with xdist:
 
 ```shell
-pytest -n auto tests/unit_tests
+uv run pytest -n auto tests/unit_tests
 ```
 
 If you do not encounter any failures in the test, you should be able to develop features in the pydantic-forms.
 
-### Installation (Development symlinked into project that use pydantic-forms)
-
-If you are working on a project that already uses the `pydantic-forms` and you want to test your new form features
-against it, you can use some `flit` magic to symlink the dev version of the forms to your project. It will
-automatically replace the pypi dep with a symlink to the development version
-of the core and update/downgrade all required packages in your own project.
+### Installation (Development version used by a project that depends on pydantic-forms)
 
-#### Step 1 - install flit:
+If you are working on a project that already uses `pydantic-forms` and you want to test your new form features
+against it, point that project at your local checkout. Run this **from the other project**:
 
 ```shell
-python - m venv venv
-source venv/bin/activate
-pip install flit
+uv add --editable /path/to/pydantic-forms
 ```
 
-### Step 2 - symlink pydantic-forms to your own project
+This replaces the PyPI dependency with an editable install of your working copy and records it under
+`[tool.uv.sources]` in that project's `pyproject.toml`. Undo it with:
 
 ```shell
-flit install --deps develop --symlink --python /path/to/a/project/venv/bin/python
+uv remove pydantic-forms && uv add pydantic-forms
 ```
 
 # Increasing the version number for a (pre) release.
@@ -91,11 +66,11 @@ When your PR is accepted you will get a version number.
 You can do the necessary change with a clean, e.g. every change committed, branch:
 
 ```shell
-bumpversion patch --new-version 0.0.1
+uv version 0.0.1
 ```
 
-Note: specifying it like this, instead of relying on bumpversion itself to increase the version, allows you to
-set a "RC1" version if needed.
+Note: specifying the version explicitly, instead of relying on `uv version --bump patch` to increase it, allows
+you to set a "RC1" version if needed -- e.g. `uv version 0.0.1rc1`.
 
 # Debugging Form behaviour
 

{pydantic_forms-2.5.0 → pydantic_forms-2.7.0}/pydantic_forms/__init__.py

@@ -13,4 +13,6 @@
 
 """Pydantic-forms engine."""
 
-__version__ = "2.5.0"
+from importlib.metadata import version
+
+__version__ = version("pydantic-forms")

{pydantic_forms-2.5.0 → pydantic_forms-2.7.0}/pydantic_forms/core/asynchronous.py

@@ -18,11 +18,12 @@ import structlog
 from pydantic import ValidationError
 from pydantic_i18n import PydanticI18n
 
-from pydantic_forms.core.shared import FORMS
+from pydantic_forms.core.shared import FORMS, GenerateFormJsonSchema, get_form_meta
 from pydantic_forms.core.translations import translations
 from pydantic_forms.exceptions import (
     FormException,
     FormNotCompleteError,
+    FormNotFoundError,
     FormOverflowError,
     FormValidationError,
 )
@@ -102,12 +103,15 @@ async def post_form(
         return generated_form
 
     # Form is not completely filled raise next form
-    raise FormNotCompleteError(generated_form.model_json_schema(), meta=getattr(generated_form, "meta__", None))
+    raise FormNotCompleteError(
+        generated_form.model_json_schema(schema_generator=GenerateFormJsonSchema),
+        meta=get_form_meta(generated_form),
+    )
 
 
 def _get_form(key: str) -> StateInputFormGeneratorAsync:
     if not (func := FORMS.get(key)):
-        raise FormException(f"Form {key} does not exist.")
+        raise FormNotFoundError(f"Form {key} does not exist.")
 
     if not isasyncgenfunction(func):
         raise FormException(f"Form {key} is not an asyncgenerator function")

{pydantic_forms-2.5.0 → pydantic_forms-2.7.0}/pydantic_forms/core/shared.py

@@ -11,10 +11,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from inspect import isasyncgenfunction, isgeneratorfunction
-from typing import Any, Callable
+from typing import Any, Callable, ClassVar, cast
 
 import structlog
 from pydantic import BaseModel, ConfigDict, PydanticUndefinedAnnotation, version
+from pydantic.json_schema import GenerateJsonSchema, JsonSchemaValue
+from pydantic_core import core_schema
+
+from pydantic_forms.types import FormMeta
+from pydantic_forms.validators.components.buttons import merge_buttons_into_meta
 
 logger = structlog.get_logger(__name__)
 
@@ -22,6 +27,35 @@ logger = structlog.get_logger(__name__)
 PYDANTIC_VERSION = version.version_short()
 
 
+class GenerateFormJsonSchema(GenerateJsonSchema):
+    """JSON schema generator that also emits ``default`` values produced by ``default_factory``.
+
+    Pydantic intentionally leaves ``default_factory`` results out of the generated JSON schema. For
+    forms this is a problem: ``default_factory`` is the recommended way to declare mutable defaults
+    (``Field(default_factory=list)`` and friends), and frontends pre-fill fields from the schema
+    ``default``. Without it such fields render uninitialised, and dynamic array/object widgets reject
+    submission until the user performs a dummy add/remove interaction to materialise an empty value.
+
+    This generator evaluates argument-less factories and adds their result as the schema ``default``.
+    Factories that need the already-validated data (``default_factory_takes_data``) cannot be
+    evaluated at schema-generation time and are skipped, as is any factory that raises.
+    """
+
+    def default_schema(self, schema: core_schema.WithDefaultSchema) -> JsonSchemaValue:
+        json_schema = super().default_schema(schema)
+        if (
+            "default" not in json_schema
+            and "default_factory" in schema
+            and not schema.get("default_factory_takes_data", False)
+        ):
+            factory = cast(Callable[[], Any], schema["default_factory"])
+            try:
+                json_schema["default"] = self.encode_default(factory())
+            except Exception:  # never let a factory break schema generation
+                logger.debug("Could not evaluate default_factory for form schema", exc_info=True)
+        return json_schema
+
+
 class DisplayOnlyFieldType:
     pass
 
@@ -34,6 +68,18 @@ class FormPage(BaseModel):
         validate_default=True,
     )
 
+    meta__: ClassVar[FormMeta | None] = None
+    """Data about the page itself, passed to the frontend alongside its JSON schema.
+
+    Set it on a subclass to tell the frontend something the schema cannot express, such as whether
+    another page follows (`hasNext`). It travels out as the `meta` key of the `FormNotCompleteError`
+    response, see `form_meta()`. Being a `ClassVar` it is not a form field, so it stays out of the
+    schema and the validated result.
+
+    Relabel or restyle the previous/next buttons with a `ButtonsConfig` field, or else with
+    `customButtons` here. The two can't be combined.
+    """
+
     def __init__(self, **data: Any):
         frozen_fields = {k: v for k, v in self.__class__.model_fields.items() if v.frozen}
 
@@ -45,6 +91,11 @@ class FormPage(BaseModel):
         mutable_data = {k: get_value(k, v) for k, v in data.items()}
         super().__init__(**mutable_data)
 
+    @classmethod
+    def form_meta(cls) -> FormMeta | None:
+        """Return `meta__` with the page's `ButtonsConfig` field added."""
+        return merge_buttons_into_meta(cls.__name__, cls.meta__, cls.model_fields)
+
     if PYDANTIC_VERSION in ("2.9", "2.10", "2.11"):
 
         @classmethod
@@ -52,6 +103,7 @@ class FormPage(BaseModel):
             # The default and requiredness of a field is not a property of a field
             # In the case of DisplayOnlyFieldTypes, we do kind of want that.
             # Using this method we set the right properties after the form is created
+            cls.form_meta()  # run now so a conflicting declaration fails on import, not when the page is first sent
             needs_rebuild = False
 
             for field in cls.model_fields.values():
@@ -84,6 +136,7 @@ class FormPage(BaseModel):
             # The default and requiredness of a field is not a property of a field
             # In the case of DisplayOnlyFieldTypes, we do kind of want that.
             # Using this method we set the right properties after the form is created
+            cls.form_meta()
             needs_rebuild = False
 
             for field in cls.model_fields.values():
@@ -111,3 +164,13 @@ def register_form(key: str, form: Callable) -> None:
 
 def list_forms() -> list[str]:
     return list(FORMS.keys())
+
+
+def get_form_meta(form: type[BaseModel]) -> Any:
+    """Return the meta to send to the frontend with `form`.
+
+    A generator may yield any pydantic model, not only a `FormPage`; such a model can still carry a `meta__`.
+    """
+    if issubclass(form, FormPage):
+        return form.form_meta()
+    return getattr(form, "meta__", None)

{pydantic_forms-2.5.0 → pydantic_forms-2.7.0}/pydantic_forms/core/sync.py

@@ -18,9 +18,15 @@ import structlog
 from pydantic import ValidationError
 from pydantic_i18n import PydanticI18n
 
-from pydantic_forms.core.shared import FORMS
+from pydantic_forms.core.shared import FORMS, GenerateFormJsonSchema, get_form_meta
 from pydantic_forms.core.translations import translations
-from pydantic_forms.exceptions import FormException, FormNotCompleteError, FormOverflowError, FormValidationError
+from pydantic_forms.exceptions import (
+    FormException,
+    FormNotCompleteError,
+    FormNotFoundError,
+    FormOverflowError,
+    FormValidationError,
+)
 from pydantic_forms.types import InputForm, State, StateInputFormGenerator
 
 logger = structlog.get_logger(__name__)
@@ -88,7 +94,10 @@ def post_form(
             generated_form = generator.send(form_validated_data)
 
         # Form is not completely filled; raise next form
-        raise FormNotCompleteError(generated_form.model_json_schema(), meta=getattr(generated_form, "meta__", None))
+        raise FormNotCompleteError(
+            generated_form.model_json_schema(schema_generator=GenerateFormJsonSchema),
+            meta=get_form_meta(generated_form),
+        )
     except StopIteration as e:
         if user_inputs:
             raise FormOverflowError(f"Did not process all user_inputs ({len(user_inputs)} remaining)")
@@ -99,7 +108,7 @@ def post_form(
 
 def _get_form(key: str) -> StateInputFormGenerator:
     if not (func := FORMS.get(key)):
-        raise FormException(f"Form {key} does not exist.")
+        raise FormNotFoundError(f"Form {key} does not exist.")
 
     if not isgeneratorfunction(func):
         raise FormException(f"Form {key} is not a generator function")

pydantic_forms-2.7.0/pydantic_forms/exception_handlers/fastapi.py

@@ -0,0 +1,84 @@
+# Copyright 2019-2023 SURF.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+
+# TODO Decide how to expose this so pydantic-forms can be framework agnostic
+from http import HTTPStatus
+from typing import Any
+
+import structlog
+from fastapi.requests import Request
+from fastapi.responses import JSONResponse
+
+from pydantic_forms.exceptions import (
+    FormException,
+    FormNotCompleteError,
+    FormNotFoundError,
+    FormValidationError,
+    show_ex,
+)
+from pydantic_forms.utils.json import json_dumps, json_loads
+
+logger = structlog.get_logger(__name__)
+
+
+async def form_error_handler(request: Request, exc: FormException) -> JSONResponse:
+    """FastAPI exception handler that turns a FormException into a HTTP 4xx/5xx response with JSON body."""
+    match exc:
+        case FormValidationError():
+            status = HTTPStatus.BAD_REQUEST
+            base_content = _create_content(exc, status, "Form not valid")
+            detail_content = base_content | {
+                "validation_errors": json_loads(json_dumps(exc.errors)),
+            }
+            debug_content = _add_traceback(exc, detail_content)
+            return JSONResponse(debug_content, status_code=status)
+
+        case FormNotCompleteError():
+            status = HTTPStatus.NOT_EXTENDED
+            base_content = _create_content(exc, status, "Form not complete")
+            detail_content = base_content | {
+                "form": json_loads(json_dumps(exc.form)),
+                "meta": getattr(exc, "meta", None),
+            }
+            debug_content = _add_traceback(exc, detail_content)
+            return JSONResponse(debug_content, status_code=status)
+
+        case FormNotFoundError():
+            status = HTTPStatus.NOT_FOUND
+            base_content = _create_content(exc, status, "Form not found")
+            return JSONResponse(base_content, status_code=status)
+
+        case _:
+            status = HTTPStatus.INTERNAL_SERVER_ERROR
+            base_content = _create_content(exc, status, "Internal Server Error")
+            return JSONResponse(base_content, status_code=status)
+
+
+def _create_content(exc: FormException, status: HTTPStatus, title: str) -> dict[str, str | HTTPStatus]:
+    return {
+        "type": type(exc).__name__,
+        "detail": str(exc),
+        "title": title,
+        "status": status,
+    }
+
+
+def _add_traceback(exc: FormException, content: dict[str, Any]) -> dict[str, Any]:
+    LOG_LEVEL_PYDANTIC_FORMS = "DEBUG" if os.getenv("LOG_LEVEL_PYDANTIC_FORMS", "INFO").upper() == "DEBUG" else "INFO"
+    if LOG_LEVEL_PYDANTIC_FORMS == "DEBUG":
+        content_with_traceback = content | {"traceback": show_ex(exc)}
+        logger.debug("Form validation Response", result=content_with_traceback)
+        return content_with_traceback
+
+    return content

{pydantic_forms-2.5.0 → pydantic_forms-2.7.0}/pydantic_forms/exceptions.py

@@ -1,5 +1,6 @@
 import os
 import traceback
+from collections.abc import Mapping
 from typing import Any, Iterable, Optional, TypedDict, Union, cast
 
 import structlog
@@ -36,9 +37,26 @@ class FormOverflowError(FormException):
     """Raised when more inputs are provided than the form can process."""
 
 
+class FormNotFoundError(FormException):
+    """Raised when the requested form key is not registered."""
+
+
+Loc = tuple[Union[int, str], ...]
+
+
+def _error_is_nested_object_validator(error: ErrorDetails) -> bool:
+    """Return True for custom errors raised for an object payload instead of a leaf field."""
+    exc = error.get("ctx", {}).get("error")
+    return (
+        bool(error["loc"]) and isinstance(exc, (ValueError, AssertionError)) and isinstance(error.get("input"), Mapping)
+    )
+
+
 # def convert_errors(validation_error: ValidationError) -> Iterable[ErrorDetails]:
 def convert_errors(
-    validation_error: ValidationError, tr: PydanticI18n, locale: str = "en_US"
+    validation_error: ValidationError,
+    tr: PydanticI18n,
+    locale: str = "en_US",
 ) -> Iterable[ErrorDetails]:
     """Convert Pydantic's error messages to our needs.
 
@@ -55,6 +73,11 @@ def convert_errors(
             # Reinstate the "__root__" location for validation errors raised by Pydantic v1's root_validator.
             # With Pydantic v2's model_validator the location is an empty string, which breaks frontend clients.
             error["loc"] = ("__root__",)
+        elif _error_is_nested_object_validator(error):
+            # Errors raised by a model_validator on a nested model point at the nested model itself, which
+            # frontend clients cannot map to an input field. Mark them as model-level errors so that clients
+            # display the custom message, like they do for the form's own "__root__" errors.
+            error["loc"] = (*error["loc"], "__root__")
         return
 
     if LOG_LEVEL_PYDANTIC_FORMS == "DEBUG":
@@ -90,9 +113,6 @@ class FormValidationError(FormException):
         )
 
 
-Loc = tuple[Union[int, str], ...]
-
-
 class _ErrorDictRequired(TypedDict):
     loc: Loc
     msg: str
@@ -122,12 +142,15 @@ def _display_error_type_and_ctx(error: "ErrorDict") -> str:
 def show_ex(ex: Exception, stacklimit: Union[int, None] = None) -> str:
     """Show an exception, including its class name, message and (limited) stacktrace.
 
-    >>> try:
-    ...     raise Exception("Something went wrong")
-    ... except Exception as e:
-    ...     print(show_ex(e))
-    Exception: Something went wrong
-    ...
+    Examples:
+    --------
+        >>> try:
+        ...     raise Exception("Something went wrong")
+        ... except Exception as e:
+        ...     print(show_ex(e))
+        Exception: Something went wrong
+        ...
+
     """
     tbfmt = "".join(traceback.format_tb(ex.__traceback__, stacklimit))
     return "{}: {}\n{}".format(type(ex).__name__, ex, tbfmt)

{pydantic_forms-2.5.0 → pydantic_forms-2.7.0}/pydantic_forms/types.py

@@ -41,6 +41,30 @@ class SummaryData(TypedDict, total=False):
     columns: list[list[Union[str, int, bool, float]]]
 
 
+class ButtonConfig(TypedDict, total=False):
+    text: str
+    color: str
+
+
+class CustomButtons(TypedDict, total=False):
+    previous: ButtonConfig
+    next: ButtonConfig
+
+
+class FormMeta(TypedDict, total=False):
+    """Documented keys for ``FormPage.meta__``, not enforced at runtime; extra keys are allowed.
+
+    Attributes:
+        hasNext: Whether another page follows, so the frontend can label the submit button
+            accordingly.
+        customButtons: Per-button overrides (label, color) for "previous" and "next". Prefer a `ButtonsConfig`
+            field on the page, which sets this key; the two cannot be combined.
+    """
+
+    hasNext: bool
+    customButtons: CustomButtons
+
+
 InputForm = Type[BaseModel]
 AcceptData = list[Union[tuple[str, AcceptItemType], tuple[str, AcceptItemType, dict]]]
 

{pydantic_forms-2.5.0 → pydantic_forms-2.7.0}/pydantic_forms/utils/json.py

@@ -74,6 +74,7 @@ decoding functions differently then `default` and `object_hook` is that they are
 :func:`json.dumps` and :func:`json.loads`.
 
 """
+
 import re
 from collections.abc import Callable
 from contextlib import suppress

{pydantic_forms-2.5.0 → pydantic_forms-2.7.0}/pydantic_forms/validators/__init__.py

@@ -1,4 +1,5 @@
 from pydantic_forms.validators.components.accept import Accept, AcceptValues
+from pydantic_forms.validators.components.buttons import Button, ButtonsConfig
 from pydantic_forms.validators.components.callout import Callout, callout
 from pydantic_forms.validators.components.choice import Choice
 from pydantic_forms.validators.components.choice_list import choice_list
@@ -21,6 +22,8 @@ from pydantic_forms.validators.components.unique_constrained_list import unique_
 __all__ = (
     "Accept",
     "AcceptValues",
+    "Button",
+    "ButtonsConfig",
     "Choice",
     "choice_list",
     "contact_person_list",

{pydantic_forms-2.5.0 → pydantic_forms-2.7.0}/pydantic_forms/validators/components/accept.py

@@ -19,11 +19,18 @@ from pydantic_forms.types import AcceptData, strEnum
 
 
 class AcceptValues(strEnum):
+
     ACCEPTED = "ACCEPTED"
     INCOMPLETE = "INCOMPLETE"
 
 
 class Accept(str):
+    """A checklist the user works through before the form can be submitted.
+
+    Validation fails while the value is still `"INCOMPLETE"`. Subclass it and set `data` to
+    describe the items to display.
+    """
+
     data: ClassVar[Optional[AcceptData]] = None
 
     _enum_adapter = TypeAdapter(AcceptValues)