Forms with Deform & Colander

import colander


def strip_text(value):
    return value.strip() if isinstance(value, str) else value


class BookSchema(colander.Schema):
    title = colander.SchemaNode(colander.String(), validator=colander.Length(min=1, max=120))
    author = colander.SchemaNode(colander.String(), preparer=strip_text)
    year = colander.SchemaNode(
        colander.Integer(), validator=colander.Range(1450, 2100), missing=None
    )


book_schema = BookSchema()
appstruct = book_schema.deserialize(
    {"title": "Dune", "author": "  Frank Herbert ", "year": "1965"}
)
print(appstruct)

try:
    book_schema.deserialize({"title": "", "author": "Anon", "year": "abc"})
except colander.Invalid as exc:
    print(exc.asdict())

{'title': 'Dune', 'author': 'Frank Herbert', 'year': 1965}
{'title': 'Required', 'year': '"abc" is not a number'}

import deform


class PersonSchema(colander.Schema):
    name = colander.SchemaNode(colander.String())
    age = colander.SchemaNode(colander.Integer(), validator=colander.Range(0, 200))


form = deform.Form(PersonSchema(), buttons=("submit",))
html = form.render()
print(html.splitlines()[0].strip(), "| submit button:", 'name="submit"' in html)

try:
    form.validate([("name", "Ada"), ("age", "-5"), ("submit", "submit")])
except deform.ValidationFailure as exc:
    print(exc.error.asdict())
    print("error markup present:", "is-invalid" in exc.render())

print(form.validate([("name", "Ada"), ("age", "36"), ("submit", "submit")]))

<form | submit button: True
{'age': '-5 is less than minimum value 0'}
error markup present: True
{'name': 'Ada', 'age': 36}

import pathlib
import secrets
import tempfile

from deform.schema import CSRFSchema
from pyramid.config import Configurator
from pyramid.httpexceptions import HTTPNotFound, HTTPSeeOther
from pyramid.response import Response
from pyramid.session import SignedCookieSessionFactory
from webtest import TestApp

SHELVES = {"classics": []}

PAGE = """<!doctype html>
<html lang="en"><head><meta charset="utf-8"><title>{{ heading }}</title>
{% for href in css_links %}<link rel="stylesheet" href="{{ href }}">
{% endfor %}{% for src in js_links %}<script src="{{ src }}"></script>
{% endfor %}</head>
<body><main><h1>{{ heading }}</h1>{{ form|safe }}</main></body></html>
"""


@colander.deferred
def tag_widget(node, kw):
    return deform.widget.CheckboxChoiceWidget(values=kw["tags"])


class BookForm(CSRFSchema):
    title = colander.SchemaNode(
        colander.String(),
        validator=colander.Length(max=120),
        description="As printed on the cover",
    )
    author = colander.SchemaNode(colander.String(), preparer=strip_text)
    year = colander.SchemaNode(
        colander.Integer(), validator=colander.Range(1450, 2100), missing=None
    )
    status = colander.SchemaNode(
        colander.String(),
        validator=colander.OneOf(["want", "reading", "read"]),
        widget=deform.widget.SelectWidget(
            values=[("want", "Want to read"), ("reading", "Reading"), ("read", "Read")]
        ),
        default="want",
    )
    tags = colander.SchemaNode(
        colander.Set(), validator=tag_validator, widget=tag_widget, missing=frozenset()
    )
    started = colander.SchemaNode(colander.Date(), missing=None)
    notes = colander.SchemaNode(
        colander.String(), widget=deform.widget.TextAreaWidget(rows=4), missing=""
    )


def resource_links(request, form):
    resources = form.get_widget_resources()
    css = ["deform:static/css/bootstrap.min.css", "deform:static/css/form.css"]
    js = ["deform:static/scripts/jquery-2.0.3.min.js"]
    return {
        "css_links": [request.static_url(spec) for spec in css + resources["css"]],
        "js_links": [request.static_url(spec) for spec in js + resources["js"]],
    }


def new_book(request):
    shelf = request.matchdict["shelf"]
    if shelf not in SHELVES:
        raise HTTPNotFound()
    schema = BookForm().bind(request=request, tags=TAGS)
    form = deform.Form(schema, buttons=("submit",))
    if request.method == "POST":
        try:
            appstruct = form.validate(request.POST.items())
        except deform.ValidationFailure as exc:
            return dict(heading="Fix the errors", form=exc.render(), **resource_links(request, form))
        del appstruct["csrf_token"]
        SHELVES[shelf].append(appstruct)
        return HTTPSeeOther(request.route_url("shelf", shelf=shelf))
    return dict(heading="New book", form=form.render(), **resource_links(request, form))


def show_shelf(request):
    books = SHELVES[request.matchdict["shelf"]]
    return [
        {**book, "tags": sorted(book["tags"]), "started": book["started"] and book["started"].isoformat()}
        for book in books
    ]


templates = pathlib.Path(tempfile.mkdtemp())
(templates / "page.jinja2").write_text(PAGE)

with Configurator(settings={"jinja2.directories": str(templates)}) as config:
    config.include("pyramid_jinja2")
    config.set_session_factory(SignedCookieSessionFactory(secrets.token_hex(32)))
    config.set_default_csrf_options(require_csrf=True)
    config.add_static_view("deform_static", "deform:static")
    config.add_route("new_book", "/shelves/{shelf}/books/new")
    config.add_route("shelf", "/shelves/{shelf}")
    config.add_view(new_book, route_name="new_book", renderer="page.jinja2")
    config.add_view(show_shelf, route_name="shelf", renderer="json")
    app = config.make_wsgi_app()

browser = TestApp(app)
page = browser.get("/shelves/classics/books/new")
print(page.status, page.content_type)
print(sorted(set(page.html.find("form")["class"])), page.html.find("form")["method"])

200 OK text/html
['deform'] POST

anonymous = TestApp(app)
rejected = anonymous.post(
    "/shelves/classics/books/new", {"title": "Evil", "author": "Eve", "submit": "submit"},
    expect_errors=True,
)
print(rejected.status)

token_page = anonymous.get("/shelves/classics/books/new")
token = token_page.html.find("input", {"name": "csrf_token"})["value"]
accepted = anonymous.post(
    "/shelves/classics/books/new",
    {"csrf_token": token, "title": "Emma", "author": "Jane Austen", "status": "read", "submit": "submit"},
)
print(accepted.status, len(SHELVES["classics"]))

400 Bad Request
303 See Other 2

class ShelfForm(colander.Schema):
    slug = colander.SchemaNode(colander.String(), validator=colander.Regex(r"^[a-z0-9-]+$"))


TAKEN = {"classics"}
slug_form = deform.Form(ShelfForm(), buttons=("submit",))
try:
    slug_data = slug_form.validate([("slug", "classics")])
    if slug_data["slug"] in TAKEN:
        error = colander.Invalid(slug_form.schema)
        error["slug"] = "This slug is already taken"
        slug_form.widget.handle_error(slug_form, error)
        raise deform.ValidationFailure(slug_form, slug_form.cstruct, error)
except deform.ValidationFailure as exc:
    print(exc.error.asdict(), exc.field["slug"].errormsg, exc.cstruct)

{'slug': 'This slug is already taken'} This slug is already taken {'slug': 'classics'}

import importlib.resources as resources

default_templates = resources.files("deform") / "templates"
custom = pathlib.Path(tempfile.mkdtemp())
(custom / "textinput.pt").write_text(
    (default_templates / "textinput.pt").read_text().replace("string:form-control ", "string:form-control form-control-lg ")
)
renderer = deform.ZPTRendererFactory([str(custom), str(default_templates)], auto_reload=False)

large = deform.Form(PersonSchema(), renderer=renderer).render()
standard = deform.Form(PersonSchema()).render()
print("form-control-lg" in large, "form-control-lg" in standard)

True False

from pyramid.i18n import get_localizer
from pyramid.threadlocal import get_current_request


def translator(term):
    return get_localizer(get_current_request()).translate(term)


deform.Form.set_zpt_renderer([str(default_templates)], translator=translator)


def required_form(request):
    form = deform.Form(PersonSchema(), buttons=("submit",))
    try:
        form.validate([("name", ""), ("age", "x")])
    except deform.ValidationFailure as exc:
        return Response(exc.render())


with Configurator() as config:
    config.add_translation_dirs("colander:locale", "deform:locale")
    config.add_route("required", "/required")
    config.add_view(required_form, route_name="required")
    i18n_app = TestApp(config.make_wsgi_app())

for locale in ("en", "es"):
    body = i18n_app.get("/required", {"_LOCALE_": locale}).text
    print(locale, "Requerido" in body, "Required" in body)

en False True
es True False

from webtest import Upload


class MemoryTmpStore(dict):
    def preview_url(self, uid):
        return None


STORES = {}


def tmpstore_for(request):
    key = request.session.setdefault("tmp_key", secrets.token_hex(16))
    return STORES.setdefault(key, MemoryTmpStore())


@colander.deferred
def cover_widget(node, kw):
    return deform.widget.FileUploadWidget(tmpstore_for(kw["request"]), accept="image/*")


class CoverForm(CSRFSchema):
    cover = colander.SchemaNode(deform.FileData(), widget=cover_widget, missing=None)
    caption = colander.SchemaNode(colander.String())


def upload_cover(request):
    form = deform.Form(CoverForm().bind(request=request), buttons=("submit",))
    if request.method == "POST":
        try:
            data = form.validate(request.POST.items())
        except deform.ValidationFailure as exc:
            return Response(exc.render())
        cover = data["cover"]
        return Response(f"{cover['filename']} {cover['mimetype']} {cover['fp'].read()!r}", content_type="text/plain")
    return Response(form.render())


with Configurator() as config:
    config.set_session_factory(SignedCookieSessionFactory(secrets.token_hex(32)))
    config.set_default_csrf_options(require_csrf=True)
    config.add_route("cover", "/cover")
    config.add_view(upload_cover, route_name="cover")
    upload_app = TestApp(config.make_wsgi_app())

cover_form = upload_app.get("/cover").forms["deform"]
cover_form["upload"] = Upload("cover.png", b"fake png bytes", "image/png")
cover_form["caption"] = ""
again = cover_form.submit("submit")
print(again.status, "uid" in again.forms["deform"].fields, "cover.png" in again.text)
fixed = again.forms["deform"]
fixed["caption"] = "Dune, first edition"
print(fixed.submit("submit").text)

200 OK True True
cover.png image/png b'fake png bytes'

import json

from pydantic import BaseModel, Field, ValidationError
from wtforms import Form as WTForm, IntegerField, StringField, validators


class BookIn(BaseModel):
    title: str = Field(min_length=1, max_length=120)
    year: int | None = Field(default=None, ge=1450, le=2100)


def api_create_colander(request):
    try:
        payload = request.json_body
    except ValueError:
        request.response.status = 400
        return {"errors": {"": "Body is not valid JSON"}}
    try:
        data = BookSchema().deserialize(payload)
    except colander.Invalid as exc:
        request.response.status = 422
        return {"errors": exc.asdict()}
    return data


def api_create_pydantic(request):
    try:
        book = BookIn.model_validate_json(request.body)
    except ValidationError as exc:
        request.response.status = 422
        return {"errors": json.loads(exc.json(include_url=False))}
    return book.model_dump()


class BookWTForm(WTForm):
    title = StringField(validators=[validators.DataRequired(), validators.Length(max=120)])
    year = IntegerField(validators=[validators.Optional(), validators.NumberRange(1450, 2100)])


def create_wtforms(request):
    form = BookWTForm(request.POST)
    if request.method == "POST" and form.validate():
        return {"ok": form.data}
    request.response.status = 422
    return {"errors": form.errors}


with Configurator() as config:
    config.add_route("colander_api", "/api/colander")
    config.add_route("pydantic_api", "/api/pydantic")
    config.add_route("wtforms", "/wtforms")
    config.add_view(api_create_colander, route_name="colander_api", renderer="json", request_method="POST")
    config.add_view(api_create_pydantic, route_name="pydantic_api", renderer="json", request_method="POST")
    config.add_view(create_wtforms, route_name="wtforms", renderer="json", request_method="POST")
    alt = TestApp(config.make_wsgi_app())

print(alt.post_json("/api/colander", {"title": "Dune", "author": " Frank ", "year": "1965"}).json)
print(alt.post_json("/api/colander", {"title": "", "author": "x", "year": "abc"}, status=422).json)
print(alt.post_json("/api/pydantic", {"title": "Dune", "year": 1965}).json)
print(alt.post_json("/api/pydantic", {"title": "Dune", "year": 3000}, status=422).json["errors"][0]["msg"])
print(alt.post("/wtforms", {"title": "Dune", "year": "1965"}).json)
print(alt.post("/wtforms", {"title": "", "year": "x"}, status=422).json)

{'title': 'Dune', 'author': 'Frank', 'year': 1965}
{'errors': {'title': 'Required', 'year': '"abc" is not a number'}}
{'title': 'Dune', 'year': 1965}
Input should be less than or equal to 2100
{'ok': {'title': 'Dune', 'year': 1965}}
{'errors': {'title': ['This field is required.'], 'year': ['Not a valid integer value.', 'Number must be between 1450 and 2100.']}}