From 788dbe24786eb9948eb209bfdff46b698f7be8d3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Mon, 1 Jul 2024 20:40:17 +0200
Subject: [PATCH 01/28] Initial implementation and docs

---
 .bandit.yml              |   3 +
 .flake8                  |   4 +
 .pre-commit-config.yaml  |  12 +++
 docs/api.rst             |   6 +-
 docs/conf.py             |  19 +++-
 docs/usage.rst           | 178 ++++++++++++++++++++++++++++++++-
 form2request/__init__.py |   2 +
 form2request/_base.py    | 207 +++++++++++++++++++++++++++++++++++++++
 pyproject.toml           |   1 +
 tox.ini                  |  20 +++-
 10 files changed, 444 insertions(+), 8 deletions(-)
 create mode 100644 .bandit.yml
 create mode 100644 form2request/_base.py

diff --git a/.bandit.yml b/.bandit.yml
new file mode 100644
index 0000000..2237265
--- /dev/null
+++ b/.bandit.yml
@@ -0,0 +1,3 @@
+skips:
+- B101  # assert_used, needed for mypy
+exclude_dirs: ['tests']
diff --git a/.flake8 b/.flake8
index 9ee8f89..f06e676 100644
--- a/.flake8
+++ b/.flake8
@@ -1,6 +1,10 @@
 [flake8]
+extend-select = TC, TC1
 ignore =
+max-line-length = 88
 per-file-ignores =
+    # F401: Imported but unused
+    form2request/__init__.py:F401
     # D100-D104: Missing docstring
     docs/conf.py:D100
     tests/__init__.py:D104
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 663563f..6d5a2de 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -17,8 +17,20 @@ repos:
     - flake8-debugger
     - flake8-docstrings
     - flake8-string-format
+    - flake8-type-checking
 - repo: https://github.com/asottile/pyupgrade
   rev: v3.16.0
   hooks:
   - id: pyupgrade
     args: [--py38-plus]
+- repo: https://github.com/pycqa/bandit
+  rev: 1.7.9
+  hooks:
+  - id: bandit
+    args: [-r, -c, .bandit.yml]
+- repo: https://github.com/adamchainz/blacken-docs
+  rev: 1.18.0
+  hooks:
+  - id: blacken-docs
+    additional_dependencies:
+    - black==24.4.2
diff --git a/docs/api.rst b/docs/api.rst
index 29c1176..05c1a65 100644
--- a/docs/api.rst
+++ b/docs/api.rst
@@ -2,4 +2,8 @@
 API reference
 =============
 
-…
+.. autofunction:: form2request.request_from_form
+
+.. autoclass:: form2request.Request
+    :members:
+    :undoc-members:
diff --git a/docs/conf.py b/docs/conf.py
index acc9c71..1440069 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -9,11 +9,24 @@
 
 html_theme = "sphinx_rtd_theme"
 
-autodoc_member_order = "groupwise"
-
-intersphinx_disabled_reftypes = []
+intersphinx_disabled_reftypes = [
+    "lxml.etree.FormElement",
+]
 intersphinx_mapping = {
     "lxml": ("https://lxml.de/apidoc/", None),
     "parsel": ("https://parsel.readthedocs.io/en/stable", None),
     "python": ("https://docs.python.org/3", None),
+    "scrapy": ("https://docs.scrapy.org/en/latest", None),
 }
+
+nitpick_ignore = [
+    *(
+        ("py:class", cls)
+        for cls in (
+            # https://github.com/sphinx-doc/sphinx/issues/11225
+            "Element",
+            "FormdataType",
+            "FormElement",
+        )
+    ),
+]
diff --git a/docs/usage.rst b/docs/usage.rst
index d9237b5..971b802 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -2,4 +2,180 @@
 Usage
 =====
 
-…
+:ref:`Given an HTML form <form>`:
+
+.. _fromstring-example:
+
+>>> from lxml.html import fromstring
+>>> html = b"""<form><input type="hidden" name="foo" value="bar" /></form>"""
+>>> root = fromstring(html, base_url="https://example.com")
+>>> form = root.xpath("//form")[0]
+
+You can use :func:`~form2request.request_from_form` to generate :ref:`form
+submission request data <request>`:
+
+>>> from form2request import request_from_form
+>>> request_from_form(form)
+Request(url='https://example.com?foo=bar', method='GET', headers=[], body=b'')
+
+:func:`~form2request.request_from_form` supports :ref:`user-defined form data
+<data>` and :ref:`choosing a specific form submission button (or none)
+<click>`.
+
+
+.. _form:
+
+Getting a form
+==============
+
+:func:`~form2request.request_from_form` requires an
+:class:`lxml.html.FormElement` object.
+
+You can build one using :func:`lxml.html.fromstring` to parse an HTML document
+and :meth:`lxml.html.HtmlElement.xpath` to find a form element in that
+document, as :ref:`seen above <fromstring-example>`.
+
+Here are some examples of XPath expressions that can be useful to find a form
+element using :meth:`~lxml.html.HtmlElement.xpath`:
+
+-   To find a form by one of its attributes, such as ``id`` or ``name``, use
+    ``//form[@<attribute>="<value>"]``. For example, to find ``<form id="foo"
+    …``, use ``//form[@id="foo"]``.
+
+-   To find a form by index, by order of appearance in the HTML code, use
+    ``(//form)[n]``, where ``n`` is a 1-based index. For example, to find the
+    2nd form, use ``(//form)[2]``.
+
+If you prefer, you could use the XPath of an element inside the form, and then
+visit parent elements until you reach the form element. For example:
+
+.. code-block:: python
+
+    element = root.xpath('//input[@name="zip_code"]')[0]
+    while True:
+        if element.tag == "form":
+            break
+        element = element.getparent()
+    form = element
+
+If you use an lxml-based library or framework, chances are they also let you
+get a :class:`~lxml.html.FormElement` object. For example, when using
+:doc:`parsel <parsel:index>`:
+
+>>> from parsel import Selector
+>>> selector = Selector(body=html, base_url="https://example.com")
+>>> form = selector.css("form")[0].root
+>>> type(form)
+<class 'lxml.html.FormElement'>
+
+A similar example, with a :doc:`Scrapy <scrapy:index>` response:
+
+>>> from scrapy.http import TextResponse
+>>> response = TextResponse("https://example.com", body=html)
+>>> form = response.css("form")[0].root
+>>> type(form)
+<class 'lxml.html.FormElement'>
+
+
+.. _data:
+
+Setting form data
+=================
+
+While there are forms made entirely of hidden fields, like :ref:`the one above
+<fromstring-example>`, most often you will work with forms that expect
+user-defined data:
+
+>>> html = b"""<form><input type="text" name="foo" /></form>"""
+>>> root = fromstring(html, base_url="https://example.com")
+>>> form = root.xpath("//form")[0]
+
+Use the second parameter of :func:`~form2request.request_from_form`,  to define
+the corresponding data:
+
+>>> request_from_form(form, {"foo": "bar"})
+Request(url='https://example.com?foo=bar', method='GET', headers=[], body=b'')
+
+You may sometimes find forms where more than one field has the same ``name``
+attribute:
+
+>>> html = b"""<form><input type="text" name="foo" /><input type="text" name="foo" /></form>"""
+>>> root = fromstring(html, base_url="https://example.com")
+>>> form = root.xpath("//form")[0]
+
+To specify values for all same-name fields, instead of a dictionary, use an
+iterable of key-value tuples:
+
+>>> request_from_form(form, (("foo", "bar"), ("foo", "baz")))
+Request(url='https://example.com?foo=bar&foo=baz', method='GET', headers=[], body=b'')
+
+
+.. _click:
+
+Configuring form submission
+===========================
+
+When an HTML form is submitted, the way the submission is triggered has an
+impact on the resulting request data.
+
+Given a submit button with ``name`` and ``value`` attributes:
+
+>>> html = b"""<form><input type="submit" name="foo" value="bar" /></form>"""
+>>> root = fromstring(html, base_url="https://example.com")
+>>> form = root.xpath("//form")[0]
+
+If you submit the form by clicking that button, those attributes are included
+in the request data, which is what :func:`~form2request.request_from_form` does
+by default:
+
+>>> request_from_form(form)
+Request(url='https://example.com?foo=bar', method='GET', headers=[], body=b'')
+
+However, sometimes it is possible to submit a form without clicking a submit
+button, even when there is such a button. In such cases, the button data should
+not be part of the request data. For such cases, set ``click`` to ``False``:
+
+>>> request_from_form(form, click=False)
+Request(url='https://example.com', method='GET', headers=[], body=b'')
+
+You may also find forms with more than one submit button:
+
+>>> html = b"""<form><input type="submit" name="foo" value="bar" /><input type="submit" name="foo" value="baz" /></form>"""
+>>> root = fromstring(html, base_url="https://example.com")
+>>> form = root.xpath("//form")[0]
+
+By default, :func:`~form2request.request_from_form` clicks the first submission
+element:
+
+>>> request_from_form(form)
+Request(url='https://example.com?foo=bar', method='GET', headers=[], body=b'')
+
+To change that, set ``click`` to the element that should be clicked:
+
+>>> submit_baz = form.xpath('.//*[@value="baz"]')[0]
+>>> request_from_form(form, click=submit_baz)
+Request(url='https://example.com?foo=baz', method='GET', headers=[], body=b'')
+
+
+.. _request:
+
+Using request data
+==================
+
+:class:`~form2request.Request` is a simple data container that you can use to
+build an actual request object:
+
+>>> request_data = request_from_form(form)
+
+Here are some examples for popular Python libraries and frameworks:
+
+>>> from requests import Request
+>>> request = Request(request_data.method, request_data.url, headers=request_data.headers, data=request_data.body)
+>>> request
+<Request [GET]>
+
+
+>>> from scrapy import Request
+>>> request = Request(request_data.url, method=request_data.method, headers=request_data.headers, body=request_data.body)
+>>> request
+<GET https://example.com?foo=bar>
diff --git a/form2request/__init__.py b/form2request/__init__.py
index 4908450..c6d4a5c 100644
--- a/form2request/__init__.py
+++ b/form2request/__init__.py
@@ -1 +1,3 @@
 """Build HTTP requests out of HTML forms."""
+
+from ._base import Request, request_from_form
diff --git a/form2request/_base.py b/form2request/_base.py
new file mode 100644
index 0000000..cc538cc
--- /dev/null
+++ b/form2request/_base.py
@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, Iterable, Optional, Tuple, Union, cast
+from urllib.parse import urlencode, urljoin, urlsplit, urlunsplit
+
+from w3lib.html import strip_html5_whitespace
+
+if TYPE_CHECKING:
+    from lxml.etree import Element  # nosec
+    from lxml.html import FormElement  # nosec
+    from lxml.html import InputElement  # nosec
+    from lxml.html import MultipleSelectOptions  # nosec
+    from lxml.html import SelectElement  # nosec
+    from lxml.html import TextareaElement  # nosec
+
+FormdataVType = Union[str, Iterable[str]]
+FormdataKVType = Tuple[str, FormdataVType]
+FormdataType = Optional[Union[Dict[str, FormdataVType], Iterable[FormdataKVType]]]
+
+
+def _is_listlike(x: Any) -> bool:
+    """Return ``True`` if *x* is a list-like object or ``False`` otherwise.
+
+    A list-like object is an iterable, excluding strings or bytes.
+    """
+    return hasattr(x, "__iter__") and not isinstance(x, (str, bytes))
+
+
+def _value(
+    ele: InputElement | SelectElement | TextareaElement,
+) -> tuple[str | None, None | str | MultipleSelectOptions]:
+    n = ele.name
+    v = ele.value
+    if ele.tag == "select":
+        return _select_value(cast("SelectElement", ele), n, v)
+    return n, v
+
+
+def _select_value(
+    ele: SelectElement, n: str | None, v: None | str | MultipleSelectOptions
+) -> tuple[str | None, None | str | MultipleSelectOptions]:
+    multiple = ele.multiple
+    if v is None and not multiple:
+        # Match browser behavior on simple select tag without options selected
+        # And for select tags without options
+        o = ele.value_options
+        return (n, o[0]) if o else (None, None)
+    return n, v
+
+
+def _url(form: FormElement) -> str:
+    if form.base_url is None:
+        raise ValueError(f"{form} has no base_url set.")
+    action = form.get("action")
+    if action is None:
+        return form.base_url
+    return urljoin(form.base_url, strip_html5_whitespace(action))
+
+
+def _method(form: FormElement) -> str:
+    method = form.method
+    assert method is not None
+    method = method.upper()
+    if method not in {"GET", "POST"}:
+        method = "GET"
+    return method
+
+
+class _NoClickables(ValueError):
+    pass
+
+
+def _click_data(
+    form: FormElement, click: None | bool | Element
+) -> tuple[()] | tuple[str, str]:
+    if click is False:
+        return ()
+    if click in {None, True}:
+        clickables = list(
+            form.xpath(
+                'descendant::input[re:test(@type, "^(submit|image)$", "i")]'
+                '|descendant::button[not(@type) or re:test(@type, "^submit$", "i")]',
+                namespaces={"re": "http://exslt.org/regular-expressions"},
+            )
+        )
+        if not clickables:
+            if click:
+                raise _NoClickables
+            else:
+                return ()
+        click = clickables[0]
+    return click.get("name"), click.get("value")
+
+
+def _data(data: FormdataType, click_data: tuple[()] | tuple[str, str]) -> FormdataType:
+    data = data or {}
+    if click_data:
+        assert len(click_data) == 2
+        if isinstance(data, dict):
+            data = dict(data)
+            data[click_data[0]] = click_data[1]
+        else:
+            data = list(data)
+            data.append(click_data)
+    return data
+
+
+def _query(form: FormElement, data: FormdataType) -> str:
+    keys = dict(data or ()).keys()
+    if not data:
+        data = []
+    inputs = form.xpath(
+        "descendant::textarea"
+        "|descendant::select"
+        "|descendant::input[not(@type) or @type["
+        ' not(re:test(., "^(?:submit|image|reset)$", "i"))'
+        " and (../@checked or"
+        '  not(re:test(., "^(?:checkbox|radio)$", "i")))]]',
+        namespaces={"re": "http://exslt.org/regular-expressions"},
+    )
+    values: list[FormdataKVType] = [
+        (k, "" if v is None else v)
+        for k, v in (_value(e) for e in inputs)
+        if k and k not in keys
+    ]
+    items = data.items() if isinstance(data, dict) else data
+    values.extend((k, v) for k, v in items if v is not None)
+    encoded_values = [
+        (k.encode(), v.encode())
+        for k, vs in values
+        for v in (cast("Iterable[str]", vs) if _is_listlike(vs) else [cast("str", vs)])
+    ]
+    return urlencode(encoded_values, doseq=True)
+
+
+@dataclass
+class Request:
+    """HTTP request data."""
+
+    url: str
+    method: str
+    headers: list[tuple[str, str]]
+    body: bytes
+
+
+def request_from_form(
+    form: FormElement,
+    data: FormdataType = None,
+    /,
+    *,
+    click: None | bool | Element = None,
+) -> Request:
+    """Return a form submission request.
+
+    *form* should be an instance of :class:`lxml.html.FormElement`.
+
+    *data* should be either a dictionary of a list of 2-item tuples indicating
+    the key-value pairs to include in the request as submission data.
+
+    *click* can be any of:
+
+    -   ``None`` (default): the first submission element of the form (e.g. a
+        submit button) is used to build a request for a click-based
+        form submission.
+
+        If no submission elements are found, the request is built for a
+        non-click-based form submission, i.e. a form submission triggered by a
+        non-click event, such as pressing the Enter key while the focus is in
+        a single-line text input field of the form.
+
+    -   ``True`` behaves like ``None``, but raises a :exc:`ValueError`
+        exception if no submission element is found in the form.
+
+    -   ``False`` builds a request for a non-click-based form submission.
+
+    -   A submission element of *form*, to build a request for a form submission
+        based on the clicking of that specific element.
+
+        On forms with multiple submission elements, specifying the right
+        submission element here may be necessary.
+    """
+    url = _url(form)
+    method = _method(form)
+    try:
+        click_data = _click_data(form, click)
+    except _NoClickables:
+        raise ValueError(
+            f"No clickable elements found in form {form}. Set click=False or "
+            f"point it to the element to be clicked."
+        )
+    data = _data(data, click_data)
+    query = _query(form, data)
+    headers = []
+    body = b""
+    if method == "GET":
+        url = urlunsplit(urlsplit(url)._replace(query=query))
+    else:
+        assert method == "POST"
+        headers = [("Content-Type", "application/x-www-form-urlencoded")]
+        body = query.encode()
+    return Request(
+        url=url,
+        method=method,
+        headers=headers,
+        body=body,
+    )
diff --git a/pyproject.toml b/pyproject.toml
index a566415..597272c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -25,6 +25,7 @@ classifiers = [
 requires-python = ">=3.8"
 dependencies = [
     "lxml >= 4.4.1",
+    "w3lib >= 1.17.0",
 ]
 
 [project.urls]
diff --git a/tox.ini b/tox.ini
index 4de7873..e68601f 100644
--- a/tox.ini
+++ b/tox.ini
@@ -1,5 +1,5 @@
 [tox]
-envlist = pre-commit,mypy,docs,twinecheck,min,py38,py39,py310,py311,py312
+envlist = pre-commit,mypy,docs,doctest,twinecheck,min,py38,py39,py310,py311,py312
 
 [testenv]
 deps =
@@ -10,14 +10,14 @@ commands =
         --cov-report=term-missing:skip-covered \
         --cov-report=xml \
         --cov=form2request \
-        --doctest-glob="*.rst" --doctest-modules \
-        {posargs:docs form2request tests}
+        {posargs:tests}
 
 [testenv:min]
 basepython = python3.8
 deps =
     {[testenv]deps}
     lxml==4.4.1
+    w3lib==1.17.0
 
 [testenv:pre-commit]
 deps =
@@ -41,6 +41,20 @@ setenv =
 commands =
     sphinx-build -W -n -b html . {envtmpdir}/html
 
+[testenv:doctest]
+deps =
+    {[testenv]deps}
+    parsel
+    requests
+    scrapy
+commands =
+    pytest \
+        --cov-report=term-missing:skip-covered \
+        --cov-report=xml \
+        --cov=form2request \
+        --doctest-glob="*.rst" --doctest-modules \
+        {posargs:docs}
+
 [testenv:twinecheck]
 basepython = python3
 deps =

From 612dd72c54205ce15c1331d96b4d201e8224e601 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Tue, 2 Jul 2024 09:24:15 +0200
Subject: [PATCH 02/28] Remove the AI mention from the docs

---
 README.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.rst b/README.rst
index 586477c..a6b7f0d 100644
--- a/README.rst
+++ b/README.rst
@@ -20,8 +20,8 @@ form2request
 
 .. description starts
 
-``form2request`` is an AI-powered Python 3.8+ library to build HTTP requests
-out of HTML forms.
+``form2request`` is a Python 3.8+ library to build HTTP requests out of HTML
+forms.
 
 .. description ends
 

From 83d02003e796f392132222df5b09e7d13fe85921 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Tue, 2 Jul 2024 10:19:57 +0200
Subject: [PATCH 03/28] Support formaction and formmethod, and raise
 NotImplementedError for enctype and formenctype with a known unsupported
 value

---
 form2request/_base.py | 45 +++++++++++++++++++++++++++----------------
 1 file changed, 28 insertions(+), 17 deletions(-)

diff --git a/form2request/_base.py b/form2request/_base.py
index cc538cc..88e0ba3 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -8,6 +8,7 @@
 
 if TYPE_CHECKING:
     from lxml.etree import Element  # nosec
+    from lxml.html import HtmlElement  # nosec
     from lxml.html import FormElement  # nosec
     from lxml.html import InputElement  # nosec
     from lxml.html import MultipleSelectOptions  # nosec
@@ -49,18 +50,18 @@ def _select_value(
     return n, v
 
 
-def _url(form: FormElement) -> str:
+def _url(form: FormElement, click_element: Optional[HtmlElement]) -> str:
     if form.base_url is None:
         raise ValueError(f"{form} has no base_url set.")
-    action = form.get("action")
+    action = (click_element.get("formaction") if click_element else None) or form.get("action")
     if action is None:
         return form.base_url
     return urljoin(form.base_url, strip_html5_whitespace(action))
 
 
-def _method(form: FormElement) -> str:
-    method = form.method
-    assert method is not None
+def _method(form: FormElement, click_element: Optional[HtmlElement]) -> str:
+    method = (click_element.get("formmethod") if click_element else None) or form.method
+    assert method is not None  # lxml’s form.method is always filled
     method = method.upper()
     if method not in {"GET", "POST"}:
         method = "GET"
@@ -71,11 +72,11 @@ class _NoClickables(ValueError):
     pass
 
 
-def _click_data(
+def _click_element(
     form: FormElement, click: None | bool | Element
-) -> tuple[()] | tuple[str, str]:
+) -> Optional[HtmlElement]:
     if click is False:
-        return ()
+        return None
     if click in {None, True}:
         clickables = list(
             form.xpath(
@@ -88,15 +89,15 @@ def _click_data(
             if click:
                 raise _NoClickables
             else:
-                return ()
+                return None
         click = clickables[0]
-    return click.get("name"), click.get("value")
+    return click
 
 
-def _data(data: FormdataType, click_data: tuple[()] | tuple[str, str]) -> FormdataType:
+def _data(data: FormdataType, click_element: Optional[HtmlElement]) -> FormdataType:
     data = data or {}
-    if click_data:
-        assert len(click_data) == 2
+    if click_element and (name := click_element.get("name")):
+        click_data = (name, click_element.get("value"))
         if isinstance(data, dict):
             data = dict(data)
             data[click_data[0]] = click_data[1]
@@ -180,16 +181,26 @@ def request_from_form(
         On forms with multiple submission elements, specifying the right
         submission element here may be necessary.
     """
-    url = _url(form)
-    method = _method(form)
+    if form.get("enctype") == "multipart/form-data":
+        raise NotImplementedError(
+            f"{form} has enctype set to multipart/form-data, which "
+            f"form2request does not currently support."
+        )
     try:
-        click_data = _click_data(form, click)
+        click_element = _click_element(form, click)
     except _NoClickables:
         raise ValueError(
             f"No clickable elements found in form {form}. Set click=False or "
             f"point it to the element to be clicked."
         )
-    data = _data(data, click_data)
+    if click_element and click_element.get("formenctype") == "multipart/form-data":
+        raise NotImplementedError(
+            f"{click_element} has formenctype set to multipart/form-data, "
+            f"which form2request does not currently support."
+        )
+    url = _url(form, click_element)
+    method = _method(form, click_element)
+    data = _data(data, click_element)
     query = _query(form, data)
     headers = []
     body = b""

From 564f5fc00e4ca008e786b9f4184f3df89b8eed91 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Tue, 2 Jul 2024 10:21:03 +0200
Subject: [PATCH 04/28] docs/conf.py: remove leftover

---
 docs/conf.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/docs/conf.py b/docs/conf.py
index 1440069..36483ae 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -9,9 +9,7 @@
 
 html_theme = "sphinx_rtd_theme"
 
-intersphinx_disabled_reftypes = [
-    "lxml.etree.FormElement",
-]
+intersphinx_disabled_reftypes = []
 intersphinx_mapping = {
     "lxml": ("https://lxml.de/apidoc/", None),
     "parsel": ("https://parsel.readthedocs.io/en/stable", None),

From d4d0b61b6c17204b71ed3b55c5d949982c517c87 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Tue, 2 Jul 2024 10:21:31 +0200
Subject: [PATCH 05/28] Use from None to hide internal exception

---
 form2request/_base.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/form2request/_base.py b/form2request/_base.py
index 88e0ba3..5974d99 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -192,7 +192,7 @@ def request_from_form(
         raise ValueError(
             f"No clickable elements found in form {form}. Set click=False or "
             f"point it to the element to be clicked."
-        )
+        ) from None
     if click_element and click_element.get("formenctype") == "multipart/form-data":
         raise NotImplementedError(
             f"{click_element} has formenctype set to multipart/form-data, "

From c227a4da6c95896eb224c50387c8f7791658f8fe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Tue, 2 Jul 2024 10:36:14 +0200
Subject: [PATCH 06/28] Solve issues reported by CI

---
 .gitignore                     |   1 +
 dist/form2request-0.0.0.tar.gz | Bin 4457 -> 0 bytes
 form2request/_base.py          |   5 ++---
 tox.ini                        |   3 ++-
 4 files changed, 5 insertions(+), 4 deletions(-)
 delete mode 100644 dist/form2request-0.0.0.tar.gz

diff --git a/.gitignore b/.gitignore
index b53725c..eda423e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 /.coverage
 /coverage.xml
+/dist/
diff --git a/dist/form2request-0.0.0.tar.gz b/dist/form2request-0.0.0.tar.gz
deleted file mode 100644
index f99bed94a6483bfd6e1f6ffaf4415a2e7b5c50d8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4457
zcmZ{kc{J4j_s10}W#89^tR=~wbx5IXkti9mWs8ZilrV|xvSdk?A$ziveaYBD$WV64
zzGj^fGh^oc`qt<C{{5ZjIrqQ&Jm=o~d|X)UsZ+fly&oP250O5e@;=Vqe$FUgnah{{
z$=BY8W()BRwW#NRQhf4kr``R@a*O4$FJkva_34i7((-S)J21cG%QH$kt@CX&&hWY}
z-L-ZJhD$VqjGq<mm@HgDci2{^H<*)dAHXKQJF}=R*OfMsQpTB{)18k#r^MS=XIn;>
ztc`B*^2N?p+F|L#KO|C}W}mcr@D(llAjP6|8rE)eqDXrIfwt_<H&%L4UJUkgq=++L
zP$~+&nFYV65gzx=3yiN@irwH&>Bzn+SG+42feE_e|FdG#8Y^@+2g7!P*x#D8SIK#L
z|F-#Q2MS7Yr7%b?9k+aK?fGR0MREuged+uP-RbL@AK=~6UjYolc6En<&)x?Jmj~I!
zK<SeE=!(Sj6KqPrcnolrf3WmZn%uJ+Se5+_J|)YBlkL(t-=8T6(qUIUcL_zAy+yV2
zC+m)TVTeoq9@!dvWbUVPYGGQXL<zeM-&4(NY~%Qgho#P^HSFq*rU{56*STqv1YXV8
zj2f{MnhUD5_0As^^!;&<Bg6e=kzpFuRE~v)%^!Tkg5PfrKF-Ly(hIcATNfZ35z~h<
zulEtFrJfx;plf&jfsRD>E5g8b?T!BR3}xdbwznl7r287C!Uo4PIQvBhy~RxX<wP$1
zbS-&_e4eFvd$ITFP1)<CJF2ZSpOo)<u~ImuMTL43S2$$rTui>w71pWIm)x>C<&=c$
zJMP@gFP415-JMyx71b5pb*iu_`HEPHTT1GB4Lzc4RbUv=-@)W9{KBv)0;#jJ{baG*
zB_M7^u+rdedzSY5v~T9$c{TGr%s$>-T~}Rvy?J(G=&AOcFiX#$+$s^(Pp;{5`te(=
zWiB1pWBu6^^L}ev>JYSjge8=HHGLR)UZm}2IRd_|WA>3T@_4dktp7y=k00AB-!F}x
zQA=Mvq2#*ht~Ts(D3EZ|FSYHE8n~5Lm%p9(Ea8TumH6@$wAgg;pkBw{BUPxj;<dTo
z$w5m2zpY<7`Sg<C#f8j^)=#ur1RIUaZjRqUNY<(i9~?;YJJC0e8;(X4Z3tW|OOrmS
zZvCg7K9td*c1)Pd)6_$|M$a>hi(g`~=c~b%*5vKq%LwAVrs6v_-HsBy!R2O!&NGo6
zH=VE+NY~}Co24cPEE`8k2=QAoA^Jc1Q<Lk8w@=+tOEDOUbg$LfpD{0#ztcaJ|K7Uz
zovFoM&T09y?K>9MtYu5DEUo&PtTXrO<rM{^tR{uYt=3~}JbzR!j1*d+Ti8}g%YZLU
z(%iYp^INHBOVrRu$=sp$&9zF(o>@4#(o^Shehu-TWJ=X28TG%b{@a}@LX!$fx0?UB
z=P0zcL7y@t_3?$s8Q1evtNo+Tv<OGfqB{capF^r<hulZ~8a^lF-qG%67n`w<zhCz0
z{Z-o0jRd!%8m7C`$VC0-3t5#v4xD7}yfe<#jZGEUbG>y|@qwtNzWE)PMa@a~+7I8$
zl-~A>8e5IeTe_*m)7<;+087msptW=kjMaWWS5`zYi=26&lI(hT!)-NB?+deNXZd(-
zRc4ih^iIS#ncZHH1aLhdHs+l$z)n)ol@_DhWr4a?&%VY3K8hVD3f~LS&aif)b<$#b
zK{}gFnbKp;Tr0lj@eRi3Qb$7^8hE*l=K^eWHlY0v%m(OCV2c1MW|6o46XJRA0Q>G7
zckvh+e?mNxh>fdqAw{?m^;Yth&1t`KC!L6{<VSeKb{)~fn+DYwDp{HkokCto&uE(+
zlV|iCG2v#KSB--P<+6U3(Q#|HD(;#JsyO;FHCHP+KNQ2(J?j~iv}?bSx9q!v=W2HT
zqrv*1$Xi~Kl!%H?8U8Yy-W8u_)?Mk+q9M8}AonnNT;4rL+A&$rB)R3|YcaQdjrwEk
zDld`?;`5wB^4Bu>B|OE1n8vQf7n)Tt@EPZCCM)N3OJj1`l=_s-9NkmgI`l@LaERI4
zXx={*i~C?!QR)0hD84XwoYdh?$_NX5c{PLK?N-;}(JxEo>4+q?EAL#>3#;^xT~QCM
z<8TYeN>ecrNRVu}>`7}(>psZwNYdlaC!sKtx$2-s$F@1GIvF1MsvK*fVpA@WVI3Z3
zjZd}LeZ*+zCgE}t3+|e?m@W9y=!-o6Xrqwv@-(L}v#HRz^XC_N6pR$V<xK9_c}6zz
zeR}Q&*Uf-<=2G6z2W_s^HSU#6Q;^d+Tc*>rg-mL;u)x+)raqc=qcYRw-z1LVyw6h=
z!&~3!_C6d&=CVKgP#4?Hqs(LC?K01q-0+0mZBI<zE|S@i7T!m<THib4Y27K*@6qUw
zS+FVE9J;^b!r!U&SavpW+XdrdvlcfWJn*w#{jrEI3-4+J?SsbaYPja?=IN&*Ec;2b
zuTF%#b2PP?KM^{CVC5}{YpS2|Jo78s)6Zxu|ERMyJ6LUU{d2LWT3_AshWgNJ@yXvC
zu3|<_AOG}E^nd63wr`DC<9DFMZa&rcWsL<xf4-$_dH5u?b<v!j?^pdT<sF-OhYeaU
z%rMMk>22^zgWXwLUHm5_E<wJB(@nQ}4e|2UanIt#nTR2|*9W;?v5%w?QtGS|4;x8W
z8F}YIZNQTy{?B7ym5rDKSNnKz_@$Q3?uFFOp!0-qdS~{xizX&(k8mg3;Xoq?BH*Hp
zN#f_-GFk}(K0PYO^}fPs_)f5eP8?TJS5u#z#|;F8D=fbld|?hRY6>zksOP@30ee0C
zGwQ;G4gG}d<KFSAkvTG~0vHp)SM~}p^XSM9A+xnvdR!RzY@*Hcq+U_MwK_<W>$EGl
zucuuUVZ@X%l@MAwPnN}Foy)<6mkt$C7k3}xu?$<75u)8AU}u($Y5+UkYv?QhZmj@P
zi$xm=z5$XTr1DnImP+Pj^}yQ%@CHgpJ-t4E?OqD%3eblV$lxszPDa0jSS|`$HfQH;
zKb;&G1hISQLaBKIJQ3tWcFMqo4EtxLKn6<wCoZl4S#zkeR~`?X>Gpv>K>t6bQhxt}
zE<o3SJSq$A6nH~5trQxuj}Ru}sAX{=0|JddQ>dmFqW(^JGit(SGY?65LVJoOMf^?l
zsn#D`yF85%yVaiEltRSD3tqNKBvYnP^I@Ti=zD?h!+d5z#j~438H}-=IVfeb=s8AB
z<?~#87<c8P&a`2*k8i(uzp!lElvlkG{-&Jt?j}J$b@f$~YQTUxPgjA<id3Nd)Joi4
z9op`<QnYrZF_WB5I<~@jzN6uIE)FkSxtVN*^~Y2m5)2P#gfl?_XE`N1!5Z#7lrGJk
z1Z2eLZeb^n?ZN&NFsCHoDqq)vwn_>o)c>hO7?Kt3O5b{{C=7}IpK!`KlJVfB8wI!Q
z4Pp0>5<1WR?FD*^XtS@;Q9wliNRCrD_(AnAa8Y`Z1m86!Q!p)3B7dENx+#1LXHlQD
zmPDmlCM7V1n*Ff-;GXp->$+M|0ZuioHGvW~uMk`lwGYSf@rpP!_d$+s&Q^5jn?0?x
z6<wHhVCbKEMcCo%@M_eSlp%qB+Pqtgim>>;#Qkxf-d<pEEj3!^;d**aQ3RhDe{*vI
z$z*M~)i@;JQNYCVkgfzZ85#ex;$G>%4|s4iGFWXQJhio}Tq{NyqaV!qEJ7iebJ+(@
zmRb>fwRGkhmoiUukV{f;a>K1hZg~^(U1wRsjOJ!^nvW6Ei-VPH=xfXGO6FQB`UL!q
zBY(fWB4c>y^d9rmCJ^>eVTU<U(KH~q>-NCvIir)pLMc}tJvp!+x{6S!N$g~pl~Nu!
z(rt$w$S4H!7S?L^yxcpZ6h+@|b`ozun9=E}Unf_NhO<q=h8TSkFBpsoU9}tmQ?>R6
zu(NnXk6_ily@H%R|GeXvHri0dOAR;iTjJ|pE)Ow7fyE=1G0^DTuNuv;Zubbuw?%$N
z0?QL?6dFunGzG*^U>JZ3{#U~&=wzU<#A@BMCDsFsj_g9n)P$E=Q9Ec`W>7!1B_ZAu
z*@CReY~L>O><FQ;%bk<KmoTsbHh^S>kjEk9LJ2m52zwM@@Ps0JK*0u?S?-e1Dtcg%
zjQg_=)>qLyJ`GS9dDd{LeU>l?9B|;$(ivZ>e)}p~6zEgY2nuWqT>>1Zv(pCwms}*}
zKP(Fgz`>j2AE2b1r^&1!ec2V%XYr(J%m5kb2H<hNois<QJXO9E^2`VhT-2_fhTx%S
zBonhlG3s~e2HN|QrlwX92A6XMAuXWDzMtzg>m5J1Bnk!xq)m}jwO!UmL&C1*Tvdc9
z`@huk@7d`9WEW6{Ii+zztBXXt0wRWk5C!^A&3@|u7DUp9=M{=p1jPB?&fAI}+R<;@
zY31Tx45o|3ekd|8#XcTxM||0fCMFQE7L;^+6o>)@&1}VwB(!}TaEJou7Jz&QOg0lJ
zQ0yFu@F3KhDV8#O!9i;Qz5r?$(ErFo59+^?m4{pwumy1xbj;I?Nq|!A0?y%KusAB<
zV%F<IcY)tIfalCVd(>xxC8jyFtwjM1*dxgrGSL6E`cG4TuOr(52(~PBb41Kb(CFaZ
z2g&j{1wozWSDgUh-o-rTDF;8Ke5pWSn?c2>yfUltXv7^}d$Wq)o_x6QbLqLCqA>l=
zE8D7-)^A_ZPPMK;`@i%r$rLx`IHcc|+hn|N6jd(M!XaMJp@4f~C0#m#v+<R?M$xBW
zPk~`5fe6PvgYyW1>Rq_(O7SMBft~w{z2HCxn&0vr2^>9wkVR4_FI)L~1=srJl;>*1
zWa7O@Kd}XGzC9?Mx@(#pau=`BU&s<@ff)DJwL0$qL?-$2lvZ1z-qHh^K2`r*n`80J
z|CYdm1Kt3(07ieU1v^u$V(=pn_NquEgf?Ut{7D4;tU&$eYtAE^^@<9brGW9Amek{V
z4=Ro;Jef8+HdRTLHNNL*yh^a_V!77MV(TM&Wrs(x5J%PDIB^)6l1=v5cJ8waoh_3!
zM;lN*V(^ja?M<E5wR@wH^p31cJIKSx?@fnJsUaV-@ff=7k8TacJIb1i6F%jw>fcmM
z(7y_1W_B~j2q8UdeEWUmzSoDsehR&J8AIrXorI-Ex_5)^MZDPKQV0w&Z+wvLJ!JLb
z`n7!J;O5orR#QVkDmnAvEw1(`Cmx&M86HPt>&^MMi+93TkK5{2Gky?R>{NGYVCI-h
z|F?(gUDzQIfpB5K+<_?j^-ISH1aCtJfob!Ofa+beI3?)1+2Wzg5Vlrc53n6n=7do>
z4<~)v>UFe^;gNDnrt$f~a%AYmktq?H&7bw(kfu?3K#z=fG%XO^;(wC#)<~7)p`3Ze
z_=Ry+_hgq_mhokZ_|l)r@S_k{kG<{3kBptR@+;x-5VZ9JIY-3JCqZX141;>;frBJL
zj=cJa8}uL6X~|SgF9*#P9`C%#zyVCj?kX6jV&LjKZJ)ZIAHbH-$O!QDG#<W$PA9-s
zRUye`2a4&S93(kUz@)K5S9ritb0cx~vQj2BSjYvP`Fe9FHnsZGXI{DbYKm+cehXz@
z^e$!CrHv8+XZv-C>OO*64u-L4HR$MIig#vhQV6}$fNZep{gDVnz)=z&du|FO0>mIt
zUM)taSAzIofRR$!I|lIA_rblJR~okeV5e0cQWI)X?(z2*p_rq@=59aj4Sv5f;o5)0
z-b2Mk0jqYPeq#Y`mNf<L_wwwLVE;%2@>Fz#$3A%alJJ*V!(F?iYYhJgH-9aD8FIk_
z1pjAHS~7G9&L_Wsu!anO|Fd2_`GCxADjY66{rDvJ`{Rtfmmjn}pD*TtU_%~cW*XjO
GH2(v8Z(#WV

diff --git a/form2request/_base.py b/form2request/_base.py
index 5974d99..22b8b24 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -7,7 +7,6 @@
 from w3lib.html import strip_html5_whitespace
 
 if TYPE_CHECKING:
-    from lxml.etree import Element  # nosec
     from lxml.html import HtmlElement  # nosec
     from lxml.html import FormElement  # nosec
     from lxml.html import InputElement  # nosec
@@ -73,7 +72,7 @@ class _NoClickables(ValueError):
 
 
 def _click_element(
-    form: FormElement, click: None | bool | Element
+    form: FormElement, click: None | bool | HtmlElement
 ) -> Optional[HtmlElement]:
     if click is False:
         return None
@@ -150,7 +149,7 @@ def request_from_form(
     data: FormdataType = None,
     /,
     *,
-    click: None | bool | Element = None,
+    click: None | bool | HtmlElement = None,
 ) -> Request:
     """Return a form submission request.
 
diff --git a/tox.ini b/tox.ini
index e68601f..2d05d07 100644
--- a/tox.ini
+++ b/tox.ini
@@ -28,6 +28,7 @@ commands = pre-commit run --all-files --show-diff-on-failure
 basepython = python3.12
 deps =
     mypy==1.10.0
+    lxml-stubs
 
 commands = mypy form2request tests
 
@@ -58,7 +59,7 @@ commands =
 [testenv:twinecheck]
 basepython = python3
 deps =
-    twine==5.1.0
+    twine==5.1.1
     build==1.2.1
 commands =
     python -m build --sdist

From 29d1f6f8503748529c24f133b40b6bf78a184cfa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Tue, 2 Jul 2024 10:44:09 +0200
Subject: [PATCH 07/28] Solve additional CI issues

---
 docs/conf.py          |  2 +-
 form2request/_base.py | 14 ++++++++------
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/docs/conf.py b/docs/conf.py
index 36483ae..8ab46e1 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -22,9 +22,9 @@
         ("py:class", cls)
         for cls in (
             # https://github.com/sphinx-doc/sphinx/issues/11225
-            "Element",
             "FormdataType",
             "FormElement",
+            "HtmlElement",
         )
     ),
 ]
diff --git a/form2request/_base.py b/form2request/_base.py
index 22b8b24..b5f2f53 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -7,8 +7,8 @@
 from w3lib.html import strip_html5_whitespace
 
 if TYPE_CHECKING:
-    from lxml.html import HtmlElement  # nosec
     from lxml.html import FormElement  # nosec
+    from lxml.html import HtmlElement  # nosec
     from lxml.html import InputElement  # nosec
     from lxml.html import MultipleSelectOptions  # nosec
     from lxml.html import SelectElement  # nosec
@@ -49,16 +49,18 @@ def _select_value(
     return n, v
 
 
-def _url(form: FormElement, click_element: Optional[HtmlElement]) -> str:
+def _url(form: FormElement, click_element: HtmlElement | None) -> str:
     if form.base_url is None:
         raise ValueError(f"{form} has no base_url set.")
-    action = (click_element.get("formaction") if click_element else None) or form.get("action")
+    action = (click_element.get("formaction") if click_element else None) or form.get(
+        "action"
+    )
     if action is None:
         return form.base_url
     return urljoin(form.base_url, strip_html5_whitespace(action))
 
 
-def _method(form: FormElement, click_element: Optional[HtmlElement]) -> str:
+def _method(form: FormElement, click_element: HtmlElement | None) -> str:
     method = (click_element.get("formmethod") if click_element else None) or form.method
     assert method is not None  # lxml’s form.method is always filled
     method = method.upper()
@@ -73,7 +75,7 @@ class _NoClickables(ValueError):
 
 def _click_element(
     form: FormElement, click: None | bool | HtmlElement
-) -> Optional[HtmlElement]:
+) -> HtmlElement | None:
     if click is False:
         return None
     if click in {None, True}:
@@ -93,7 +95,7 @@ def _click_element(
     return click
 
 
-def _data(data: FormdataType, click_element: Optional[HtmlElement]) -> FormdataType:
+def _data(data: FormdataType, click_element: HtmlElement | None) -> FormdataType:
     data = data or {}
     if click_element and (name := click_element.get("name")):
         click_data = (name, click_element.get("value"))

From ec0a7c9681ee811a57a038fb9a8dad0d5ed8b15d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Tue, 2 Jul 2024 10:47:22 +0200
Subject: [PATCH 08/28] Add doctest to GitHub Actions

---
 .github/workflows/test.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 0d2ca22..70870f8 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -41,7 +41,7 @@ jobs:
       fail-fast: false
       matrix:
         python-version: ['3.12']
-        tox-job: ["pre-commit", "mypy", "docs", "twinecheck"]
+        tox-job: ["pre-commit", "mypy", "docs", "doctest", "twinecheck"]
     steps:
     - uses: actions/checkout@v4
     - name: Set up Python ${{ matrix.python-version }}

From 3475f1781b69d18375c21d8daae0ee4348fae090 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Tue, 2 Jul 2024 14:30:09 +0200
Subject: [PATCH 09/28] Complete test coverage

---
 .coveragerc           |   3 +
 docs/usage.rst        |  14 +
 form2request/_base.py |  76 +++--
 tests/test_main.py    | 626 +++++++++++++++++++++++++++++++++++++++++-
 tox.ini               |   3 -
 5 files changed, 673 insertions(+), 49 deletions(-)
 create mode 100644 .coveragerc

diff --git a/.coveragerc b/.coveragerc
new file mode 100644
index 0000000..0856c03
--- /dev/null
+++ b/.coveragerc
@@ -0,0 +1,3 @@
+[report]
+exclude_lines =
+    if TYPE_CHECKING:
diff --git a/docs/usage.rst b/docs/usage.rst
index 971b802..ed030a2 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -109,6 +109,20 @@ iterable of key-value tuples:
 >>> request_from_form(form, (("foo", "bar"), ("foo", "baz")))
 Request(url='https://example.com?foo=bar&foo=baz', method='GET', headers=[], body=b'')
 
+Sometimes, you might want to prevent a value from a field from being included
+in the generated request data. For example, because the field is removed or
+disabled through JavaScript, or because the field or a parent element has the
+``disabled`` attribute (currently not supported by form2request):
+
+>>> html = b"""<form><input name="foo" value="bar" disabled /></form>"""
+>>> root = fromstring(html, base_url="https://example.com")
+>>> form = root.xpath("//form")[0]
+
+To remove a field value, set it to ``None``:
+
+>>> request_from_form(form, {"foo": None})
+Request(url='https://example.com', method='GET', headers=[], body=b'')
+
 
 .. _click:
 
diff --git a/form2request/_base.py b/form2request/_base.py
index b5f2f53..95bd402 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -27,46 +27,33 @@ def _is_listlike(x: Any) -> bool:
     return hasattr(x, "__iter__") and not isinstance(x, (str, bytes))
 
 
-def _value(
-    ele: InputElement | SelectElement | TextareaElement,
-) -> tuple[str | None, None | str | MultipleSelectOptions]:
-    n = ele.name
-    v = ele.value
-    if ele.tag == "select":
-        return _select_value(cast("SelectElement", ele), n, v)
-    return n, v
-
-
-def _select_value(
-    ele: SelectElement, n: str | None, v: None | str | MultipleSelectOptions
-) -> tuple[str | None, None | str | MultipleSelectOptions]:
-    multiple = ele.multiple
-    if v is None and not multiple:
-        # Match browser behavior on simple select tag without options selected
-        # And for select tags without options
-        o = ele.value_options
-        return (n, o[0]) if o else (None, None)
-    return n, v
-
-
-def _url(form: FormElement, click_element: HtmlElement | None) -> str:
+def _url(form: FormElement, click_element: Optional[HtmlElement]) -> str:
     if form.base_url is None:
         raise ValueError(f"{form} has no base_url set.")
-    action = (click_element.get("formaction") if click_element else None) or form.get(
-        "action"
-    )
+    action = (click_element.get("formaction") if click_element is not None else None) or form.get("action")
     if action is None:
         return form.base_url
     return urljoin(form.base_url, strip_html5_whitespace(action))
 
 
-def _method(form: FormElement, click_element: HtmlElement | None) -> str:
-    method = (click_element.get("formmethod") if click_element else None) or form.method
+def _method(form: FormElement, click_element: Optional[HtmlElement]) -> str:
+    method = None
+    if click_element is not None:
+        method = click_element.get("formmethod")
+    if method:
+        method_src = click_element
+    else:
+        method = form.method
+        method_src = form
     assert method is not None  # lxml’s form.method is always filled
-    method = method.upper()
-    if method not in {"GET", "POST"}:
-        method = "GET"
-    return method
+    upper_method = method.upper()
+    if upper_method not in {"GET", "POST"}:
+        attribute = "formmethod" if method_src is click_element else "method"
+        raise NotImplementedError(
+            f"form2request does not support the {attribute} attribute of "
+            f"{method_src}: {method!r}"
+        )
+    return upper_method
 
 
 class _NoClickables(ValueError):
@@ -75,7 +62,7 @@ class _NoClickables(ValueError):
 
 def _click_element(
     form: FormElement, click: None | bool | HtmlElement
-) -> HtmlElement | None:
+) -> Optional[HtmlElement]:
     if click is False:
         return None
     if click in {None, True}:
@@ -95,9 +82,9 @@ def _click_element(
     return click
 
 
-def _data(data: FormdataType, click_element: HtmlElement | None) -> FormdataType:
+def _data(data: FormdataType, click_element: Optional[HtmlElement]) -> FormdataType:
     data = data or {}
-    if click_element and (name := click_element.get("name")):
+    if click_element is not None and (name := click_element.get("name")):
         click_data = (name, click_element.get("value"))
         if isinstance(data, dict):
             data = dict(data)
@@ -123,7 +110,7 @@ def _query(form: FormElement, data: FormdataType) -> str:
     )
     values: list[FormdataKVType] = [
         (k, "" if v is None else v)
-        for k, v in (_value(e) for e in inputs)
+        for k, v in ((e.name, e.value) for e in inputs)
         if k and k not in keys
     ]
     items = data.items() if isinstance(data, dict) else data
@@ -182,11 +169,6 @@ def request_from_form(
         On forms with multiple submission elements, specifying the right
         submission element here may be necessary.
     """
-    if form.get("enctype") == "multipart/form-data":
-        raise NotImplementedError(
-            f"{form} has enctype set to multipart/form-data, which "
-            f"form2request does not currently support."
-        )
     try:
         click_element = _click_element(form, click)
     except _NoClickables:
@@ -194,10 +176,16 @@ def request_from_form(
             f"No clickable elements found in form {form}. Set click=False or "
             f"point it to the element to be clicked."
         ) from None
-    if click_element and click_element.get("formenctype") == "multipart/form-data":
+    if click_element is not None and (enctype := click_element.get("formenctype")):
+        if enctype != "application/x-www-form-urlencoded":
+            raise NotImplementedError(
+                f"{click_element} has formenctype set to {enctype!r}, which "
+                f"form2request does not currently support."
+            )
+    elif (enctype := form.get("enctype")) and enctype != "application/x-www-form-urlencoded":
         raise NotImplementedError(
-            f"{click_element} has formenctype set to multipart/form-data, "
-            f"which form2request does not currently support."
+            f"{form} has enctype set to {enctype!r}, which form2request does "
+            f"not currently support."
         )
     url = _url(form, click_element)
     method = _method(form, click_element)
diff --git a/tests/test_main.py b/tests/test_main.py
index e6ef5c8..83a1e46 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -1,2 +1,624 @@
-def test_main():
-    assert True
+import pytest
+from lxml.html import fromstring
+
+from form2request import Request, request_from_form
+
+@pytest.mark.parametrize(
+    ("base_url", "html", "data", "click", "expected"),
+    (
+        # Empty form.
+        (
+            "https://example.com",
+            b"""<form></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # Hidden field.
+        (
+            "https://example.com",
+            b"""<form><input type="hidden" name="a" value="b" /></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com?a=b",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # User data not defined by any form field.
+        # We need to support this, for example, to make it easy to deal with
+        # forms that may have fields injected with JavaScript.
+        (
+            "https://example.com",
+            b"""<form></form>""",
+            {"a": "b"},
+            None,
+            Request(
+                "https://example.com?a=b",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # User data setting a value for a form field.
+        (
+            "https://example.com",
+            b"""<form><input type="text" name="a" /></form>""",
+            {"a": "b"},
+            None,
+            Request(
+                "https://example.com?a=b",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # User data overriding the value of a form field.
+        # Also needed for JavaScript use cases.
+        (
+            "https://example.com",
+            b"""<form><input type="hidden" name="a" value="b" /></form>""",
+            {"a": "c"},
+            None,
+            Request(
+                "https://example.com?a=c",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # User data with None as value not present in the form is ignored.
+        (
+            "https://example.com",
+            b"""<form></form>""",
+            {"a": None},
+            None,
+            Request(
+                "https://example.com",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # User data setting a value from a form field to None removes that
+        # value.
+        (
+            "https://example.com",
+            b"""<form><input type="text" name="a" /></form>""",
+            {"a": None},
+            None,
+            Request(
+                "https://example.com",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # User data overriding the value of a form field to None removes that
+        # value.
+        (
+            "https://example.com",
+            b"""<form><input type="hidden" name="a" value="b" /></form>""",
+            {"a": None},
+            None,
+            Request(
+                "https://example.com",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # Form field with an unset value.
+        (
+            "https://example.com",
+            b"""<form><input type="text" name="a" /></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com?a=",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # User data as an iterable of key-value tuples.
+        (
+            "https://example.com",
+            b"""<form></form>""",
+            (("a", "b"), ("a", "c")),
+            None,
+            Request(
+                "https://example.com?a=b&a=c",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # A submit button is “clicked” by default, i.e. its attributes are
+        # taken into account.
+        (
+            "https://example.com",
+            b"""<form><input type="submit" name="a" value="b" /></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com?a=b",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # You can disable the clicking of any submit button.
+        (
+            "https://example.com",
+            b"""<form><input type="submit" name="a" value="b" /></form>""",
+            None,
+            False,
+            Request(
+                "https://example.com",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # You can force the clicking of the first submit button.
+        (
+            "https://example.com",
+            b"""<form><input type="submit" name="a" value="b" /></form>""",
+            None,
+            True,
+            Request(
+                "https://example.com?a=b",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # Forcing the clicking of the first submit button will trigger a
+        # ValueError if there are no submit buttons.
+        (
+            "https://example.com",
+            b"""<form></form>""",
+            None,
+            True,
+            ValueError,
+        ),
+        # If there are 2 or more submit buttons, the first one is used by
+        # default.
+        (
+            "https://example.com",
+            b"""<form><input type="submit" name="a" value="b" /><input type="submit" name="a" value="c" /></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com?a=b",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # You can force a specific submit button to be used.
+        (
+            "https://example.com",
+            b"""<form><input type="submit" name="a" value="b" /><input type="submit" name="a" value="c" /></form>""",
+            None,
+            './/*[@value="c"]',
+            Request(
+                "https://example.com?a=c",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # Only the application/x-www-form-urlencoded enctype (default) is
+        # supported.
+        *(
+            (
+                "https://example.com",
+                f"""<form enctype="{enctype}"></form>""".encode(),
+                None,
+                None,
+                Request(
+                    "https://example.com",
+                    "GET",
+                    [],
+                    b"",
+                ),
+            )
+            for enctype in (
+                "",
+                "application/x-www-form-urlencoded",
+            )
+        ),
+        # Any other raise a NotImplementedError expection.
+        *(
+            (
+                "https://example.com",
+                f"""<form enctype="{enctype}"></form>""".encode(),
+                None,
+                None,
+                NotImplementedError,
+            )
+            for enctype in (
+                "multipart/form-data",
+                "text/plain",
+                "foo",
+            )
+        ),
+        # The formenctype from the submit button is taken into account.
+        (
+            "https://example.com",
+            b"""<form enctype="foo"><input type="submit" formenctype="application/x-www-form-urlencoded" /></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # Even if the form has an unsupported enctype, things work if the
+        # submit button sets a supported one.
+        (
+            "https://example.com",
+            b"""<form enctype="application/x-www-form-urlencoded"><input type="submit" formenctype="foo" /></form>""",
+            None,
+            None,
+            NotImplementedError,
+        ),
+        # Only submit buttons are detected as such.
+        *(
+            (
+                "https://example.com",
+                f"""<form>{button}<button name="c" value="d" /></form>""".encode(),
+                None,
+                None,
+                Request(
+                    "https://example.com?a=b",
+                    "GET",
+                    [],
+                    b"",
+                ),
+            )
+            for button in (
+                """<input type="image" name="a" value="b" />""",
+                """<input type="submit" name="a" value="b" />""",
+                """<button name="a" value="b" />""",
+                """<button type="submit" name="a" value="b" />""",
+            )
+        ),
+        # Other buttons are not “clicked”.
+        *(
+            (
+                "https://example.com",
+                f"""<form>{button}<button name="c" value="d" /></form>""".encode(),
+                None,
+                None,
+                Request(
+                    f"https://example.com?{query}",
+                    "GET",
+                    [],
+                    b"",
+                ),
+            )
+            for button, query in (
+                # Not treated as a button, but as an input its name and value
+                # still make it into the request data.
+                (
+                    """<input type="button" name="a" value="b" />""",
+                    "a=b&c=d",
+                ),
+                (
+                    """<button type="" name="a" value="b" />""",
+                    "c=d",
+                ),
+            )
+        ),
+        # The action of the form is taken into account.
+        (
+            "https://example.com",
+            b"""<form action="a"></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com/a",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # The formaction of the submit button takes precedence.
+        (
+            "https://example.com",
+            b"""<form action="a"><button type="submit" formaction="b" /></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com/b",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # Spaces in the action attribute are stripped.
+        (
+            "https://example.com",
+            b"""<form action=" a "></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com/a",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # The method of the form is taken into account.
+        (
+            "https://example.com",
+            b"""<form method="get"></form>""",
+            {"a": "b"},
+            None,
+            Request(
+                "https://example.com?a=b",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        (
+            "https://example.com",
+            b"""<form method="post"></form>""",
+            {"a": "b"},
+            None,
+            Request(
+                "https://example.com",
+                "POST",
+                [("Content-Type", "application/x-www-form-urlencoded")],
+                b"a=b",
+            ),
+        ),
+        # The formmethod of the submit button overrides the form method.
+        (
+            "https://example.com",
+            b"""<form method="post"><button type="submit" formmethod="get" /></form>""",
+            {"a": "b"},
+            None,
+            Request(
+                "https://example.com?a=b",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        (
+            "https://example.com",
+            b"""<form method="get"><button formmethod="post" /></form>""",
+            {"a": "b"},
+            None,
+            Request(
+                "https://example.com",
+                "POST",
+                [("Content-Type", "application/x-www-form-urlencoded")],
+                b"a=b",
+            ),
+        ),
+        # Unsupported methods trigger a NotImplementedError, but only if they
+        # are the actual method to be used, e.g. not if overridden by a
+        # supported method.
+        (
+            "https://example.com",
+            b"""<form method="a"></form>""",
+            None,
+            None,
+            NotImplementedError,
+        ),
+        (
+            "https://example.com",
+            b"""<form><button formmethod="a" /></form>""",
+            None,
+            None,
+            NotImplementedError,
+        ),
+        (
+            "https://example.com",
+            b"""<form method="a"><button formmethod="get" /></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # User data as an iterable of key-value tuples gets merged with button
+        # name and value as expected.
+        (
+            "https://example.com",
+            b"""<form><button name="d" value="e"></form>""",
+            (("a", "b"), ("a", "c")),
+            None,
+            Request(
+                "https://example.com?a=b&a=c&d=e",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # We currently do not support ignoring disabled form elements.
+        pytest.param(
+            "https://example.com",
+            b"""<form><input disabled name="a" value="b"></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com",
+                "GET",
+                [],
+                b"",
+            ),
+            marks=pytest.mark.xfail(reason='No disabled support')
+        ),
+        pytest.param(
+            "https://example.com",
+            b"""<form><fieldset disabled><input name="a" value="b"></fieldset></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com",
+                "GET",
+                [],
+                b"",
+            ),
+            marks=pytest.mark.xfail(reason='No disabled support')
+        ),
+        # Single-choice select with a single option.
+        (
+            "https://example.com",
+            b"""<form><select name="a"><option value="b">B</option></select></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com?a=b",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # Single-choice select with a single option with no value.
+        (
+            "https://example.com",
+            b"""<form><select name="a"><option>B</option></select></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com?a=B",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # Single-choice select with multiple options. The first one is
+        # selected.
+        (
+            "https://example.com",
+            b"""<form><select name="a"><option value="b">B</option><option value="c">C</option></select></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com?a=b",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # Single-choice select with multiple options, one of which is selected.
+        (
+            "https://example.com",
+            b"""<form><select name="a"><option value="b">B</option><option selected value="c">C</option></select></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com?a=c",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # Multiple-choice select with multiple options, none of which is
+        # selected.
+        (
+            "https://example.com",
+            b"""<form><select multiple name="a"><option value="b">B</option><option value="c">C</option></select></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # Multiple-choice select with multiple options, one of which is
+        # selected.
+        (
+            "https://example.com",
+            b"""<form><select multiple name="a"><option value="b">B</option><option value="c" selected>C</option></select></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com?a=c",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # Multiple-choice select with multiple options, all of which are
+        # selected.
+        (
+            "https://example.com",
+            b"""<form><select multiple name="a"><option value="b" selected>B</option><option value="c" selected>C</option></select></form>""",
+            None,
+            None,
+            Request(
+                "https://example.com?a=b&a=c",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # Values are URL-encoded, with plus signs instead of spaces.
+        (
+            "https://example.com",
+            b"""<form><input name="a+ /" value="b+ /"></form>""",
+            {"c+ /": "d+ /"},
+            None,
+            Request(
+                "https://example.com?a%2B+%2F=b%2B+%2F&c%2B+%2F=d%2B+%2F",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        (
+            "https://example.com",
+            b"""<form method="post"><input name="a+ /" value="b+ /"></form>""",
+            {"c+ /": "d+ /"},
+            None,
+            Request(
+                "https://example.com",
+                "POST",
+                [("Content-Type", "application/x-www-form-urlencoded")],
+                b"a%2B+%2F=b%2B+%2F&c%2B+%2F=d%2B+%2F",
+            ),
+        ),
+    ),
+)
+def test_request_from_form(base_url, html, data, click, expected):
+    root = fromstring(html, base_url=base_url)
+    form = root.xpath("//form")[0]
+    if isinstance(click, str):
+        click = form.xpath(click)[0]
+    if isinstance(expected, Request):
+        actual = request_from_form(form, data, click=click)
+        assert expected == actual
+    else:
+        with pytest.raises(expected):
+            request_from_form(form, data, click=click)
+
+
+def test_request_from_form_no_base_url():
+    html = "<form></form>"
+    root = fromstring(html)
+    form = root.xpath("//form")[0]
+    with pytest.raises(ValueError):
+        request_from_form(form)
diff --git a/tox.ini b/tox.ini
index 2d05d07..e2f0cb8 100644
--- a/tox.ini
+++ b/tox.ini
@@ -50,9 +50,6 @@ deps =
     scrapy
 commands =
     pytest \
-        --cov-report=term-missing:skip-covered \
-        --cov-report=xml \
-        --cov=form2request \
         --doctest-glob="*.rst" --doctest-modules \
         {posargs:docs}
 

From ba3eb10d3d1feaf0595429b91ef5785093ab4320 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Tue, 2 Jul 2024 14:35:04 +0200
Subject: [PATCH 10/28] Install pytest for mypy

---
 tox.ini | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tox.ini b/tox.ini
index e2f0cb8..b0d96ac 100644
--- a/tox.ini
+++ b/tox.ini
@@ -28,6 +28,7 @@ commands = pre-commit run --all-files --show-diff-on-failure
 basepython = python3.12
 deps =
     mypy==1.10.0
+    pytest
     lxml-stubs
 
 commands = mypy form2request tests

From 991ab5052cb30e4d3f70b8142bcc07fd2be69156 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Tue, 2 Jul 2024 14:39:08 +0200
Subject: [PATCH 11/28] Run pre-commit

---
 form2request/_base.py | 20 ++++++++++----------
 tests/test_main.py    | 35 +++++++++++++++++++++++------------
 2 files changed, 33 insertions(+), 22 deletions(-)

diff --git a/form2request/_base.py b/form2request/_base.py
index 95bd402..64140d5 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -9,10 +9,6 @@
 if TYPE_CHECKING:
     from lxml.html import FormElement  # nosec
     from lxml.html import HtmlElement  # nosec
-    from lxml.html import InputElement  # nosec
-    from lxml.html import MultipleSelectOptions  # nosec
-    from lxml.html import SelectElement  # nosec
-    from lxml.html import TextareaElement  # nosec
 
 FormdataVType = Union[str, Iterable[str]]
 FormdataKVType = Tuple[str, FormdataVType]
@@ -27,16 +23,18 @@ def _is_listlike(x: Any) -> bool:
     return hasattr(x, "__iter__") and not isinstance(x, (str, bytes))
 
 
-def _url(form: FormElement, click_element: Optional[HtmlElement]) -> str:
+def _url(form: FormElement, click_element: HtmlElement | None) -> str:
     if form.base_url is None:
         raise ValueError(f"{form} has no base_url set.")
-    action = (click_element.get("formaction") if click_element is not None else None) or form.get("action")
+    action = (
+        click_element.get("formaction") if click_element is not None else None
+    ) or form.get("action")
     if action is None:
         return form.base_url
     return urljoin(form.base_url, strip_html5_whitespace(action))
 
 
-def _method(form: FormElement, click_element: Optional[HtmlElement]) -> str:
+def _method(form: FormElement, click_element: HtmlElement | None) -> str:
     method = None
     if click_element is not None:
         method = click_element.get("formmethod")
@@ -62,7 +60,7 @@ class _NoClickables(ValueError):
 
 def _click_element(
     form: FormElement, click: None | bool | HtmlElement
-) -> Optional[HtmlElement]:
+) -> HtmlElement | None:
     if click is False:
         return None
     if click in {None, True}:
@@ -82,7 +80,7 @@ def _click_element(
     return click
 
 
-def _data(data: FormdataType, click_element: Optional[HtmlElement]) -> FormdataType:
+def _data(data: FormdataType, click_element: HtmlElement | None) -> FormdataType:
     data = data or {}
     if click_element is not None and (name := click_element.get("name")):
         click_data = (name, click_element.get("value"))
@@ -182,7 +180,9 @@ def request_from_form(
                 f"{click_element} has formenctype set to {enctype!r}, which "
                 f"form2request does not currently support."
             )
-    elif (enctype := form.get("enctype")) and enctype != "application/x-www-form-urlencoded":
+    elif (
+        enctype := form.get("enctype")
+    ) and enctype != "application/x-www-form-urlencoded":
         raise NotImplementedError(
             f"{form} has enctype set to {enctype!r}, which form2request does "
             f"not currently support."
diff --git a/tests/test_main.py b/tests/test_main.py
index 83a1e46..723a998 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -3,6 +3,7 @@
 
 from form2request import Request, request_from_form
 
+
 @pytest.mark.parametrize(
     ("base_url", "html", "data", "click", "expected"),
     (
@@ -194,7 +195,8 @@
         # default.
         (
             "https://example.com",
-            b"""<form><input type="submit" name="a" value="b" /><input type="submit" name="a" value="c" /></form>""",
+            b"""<form><input type="submit" name="a" value="b" />
+            <input type="submit" name="a" value="c" /></form>""",
             None,
             None,
             Request(
@@ -207,7 +209,8 @@
         # You can force a specific submit button to be used.
         (
             "https://example.com",
-            b"""<form><input type="submit" name="a" value="b" /><input type="submit" name="a" value="c" /></form>""",
+            b"""<form><input type="submit" name="a" value="b" />
+            <input type="submit" name="a" value="c" /></form>""",
             None,
             './/*[@value="c"]',
             Request(
@@ -255,7 +258,8 @@
         # The formenctype from the submit button is taken into account.
         (
             "https://example.com",
-            b"""<form enctype="foo"><input type="submit" formenctype="application/x-www-form-urlencoded" /></form>""",
+            b"""<form enctype="foo"><input type="submit"
+            formenctype="application/x-www-form-urlencoded" /></form>""",
             None,
             None,
             Request(
@@ -269,7 +273,8 @@
         # submit button sets a supported one.
         (
             "https://example.com",
-            b"""<form enctype="application/x-www-form-urlencoded"><input type="submit" formenctype="foo" /></form>""",
+            b"""<form enctype="application/x-www-form-urlencoded"><input
+            type="submit" formenctype="foo" /></form>""",
             None,
             None,
             NotImplementedError,
@@ -466,11 +471,12 @@
                 [],
                 b"",
             ),
-            marks=pytest.mark.xfail(reason='No disabled support')
+            marks=pytest.mark.xfail(reason="No disabled support"),
         ),
         pytest.param(
             "https://example.com",
-            b"""<form><fieldset disabled><input name="a" value="b"></fieldset></form>""",
+            b"""<form><fieldset disabled><input name="a" value="b">
+            </fieldset></form>""",
             None,
             None,
             Request(
@@ -479,7 +485,7 @@
                 [],
                 b"",
             ),
-            marks=pytest.mark.xfail(reason='No disabled support')
+            marks=pytest.mark.xfail(reason="No disabled support"),
         ),
         # Single-choice select with a single option.
         (
@@ -511,7 +517,8 @@
         # selected.
         (
             "https://example.com",
-            b"""<form><select name="a"><option value="b">B</option><option value="c">C</option></select></form>""",
+            b"""<form><select name="a"><option value="b">B</option>
+            <option value="c">C</option></select></form>""",
             None,
             None,
             Request(
@@ -524,7 +531,8 @@
         # Single-choice select with multiple options, one of which is selected.
         (
             "https://example.com",
-            b"""<form><select name="a"><option value="b">B</option><option selected value="c">C</option></select></form>""",
+            b"""<form><select name="a"><option value="b">B</option>
+            <option selected value="c">C</option></select></form>""",
             None,
             None,
             Request(
@@ -538,7 +546,8 @@
         # selected.
         (
             "https://example.com",
-            b"""<form><select multiple name="a"><option value="b">B</option><option value="c">C</option></select></form>""",
+            b"""<form><select multiple name="a"><option value="b">B</option>
+            <option value="c">C</option></select></form>""",
             None,
             None,
             Request(
@@ -552,7 +561,8 @@
         # selected.
         (
             "https://example.com",
-            b"""<form><select multiple name="a"><option value="b">B</option><option value="c" selected>C</option></select></form>""",
+            b"""<form><select multiple name="a"><option value="b">B</option>
+            <option value="c" selected>C</option></select></form>""",
             None,
             None,
             Request(
@@ -566,7 +576,8 @@
         # selected.
         (
             "https://example.com",
-            b"""<form><select multiple name="a"><option value="b" selected>B</option><option value="c" selected>C</option></select></form>""",
+            b"""<form><select multiple name="a"><option value="b" selected>B</option>
+            <option value="c" selected>C</option></select></form>""",
             None,
             None,
             Request(

From e62c738bd83bd02e49df987ae50a7b988fe78385 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Tue, 2 Jul 2024 15:14:22 +0200
Subject: [PATCH 12/28] Allow method override

---
 .gitignore            |  1 +
 docs/usage.rst        | 19 +++++++++++
 form2request/_base.py | 47 +++++++++++++++----------
 tests/test_main.py    | 79 ++++++++++++++++++++++++++++++++++++++++---
 4 files changed, 125 insertions(+), 21 deletions(-)

diff --git a/.gitignore b/.gitignore
index eda423e..bc020ed 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 /.coverage
 /coverage.xml
 /dist/
+/.tox/
diff --git a/docs/usage.rst b/docs/usage.rst
index ed030a2..888ac42 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -123,6 +123,25 @@ To remove a field value, set it to ``None``:
 >>> request_from_form(form, {"foo": None})
 Request(url='https://example.com', method='GET', headers=[], body=b'')
 
+By default, if a form uses an unsupported method:
+
+>>> html = b"""<form method="foo"></form>"""
+>>> root = fromstring(html, base_url="https://example.com")
+>>> form = root.xpath("//form")[0]
+
+A :exc:`NotImplementedError` exception will be raised:
+
+>>> request_from_form(form)
+Traceback (most recent call last):
+...
+NotImplementedError: Found unsupported form method 'FOO'.
+
+If the reason for the bad method is that the right method is set through
+JavaScript code, you can use the ``method`` parameter to set the right value:
+
+>>> request_from_form(form, method="GET")
+Request(url='https://example.com', method='GET', headers=[], body=b'')
+
 
 .. _click:
 
diff --git a/form2request/_base.py b/form2request/_base.py
index 64140d5..d1f6bee 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -34,24 +34,36 @@ def _url(form: FormElement, click_element: HtmlElement | None) -> str:
     return urljoin(form.base_url, strip_html5_whitespace(action))
 
 
-def _method(form: FormElement, click_element: HtmlElement | None) -> str:
-    method = None
-    if click_element is not None:
-        method = click_element.get("formmethod")
+USER = object()
+
+
+def _method(
+    form: FormElement, click_element: HtmlElement | None, method: None | str
+) -> str:
     if method:
-        method_src = click_element
+        method_src = USER
     else:
-        method = form.method
-        method_src = form
-    assert method is not None  # lxml’s form.method is always filled
-    upper_method = method.upper()
-    if upper_method not in {"GET", "POST"}:
-        attribute = "formmethod" if method_src is click_element else "method"
-        raise NotImplementedError(
-            f"form2request does not support the {attribute} attribute of "
-            f"{method_src}: {method!r}"
-        )
-    return upper_method
+        if click_element is not None:
+            method = click_element.get("formmethod")
+        if method:
+            method_src = click_element
+        else:
+            method = form.method
+            assert method is not None  # lxml’s form.method is always filled
+            method_src = form
+    method = method.upper()
+    if method not in {"GET", "POST"}:
+        if method_src is USER:
+            raise ValueError(
+                f"The specified form method ({method!r}) is not supported."
+            )
+        if method_src is click_element:
+            raise NotImplementedError(
+                f"Found unsupported form method {method!r} in the formmethod "
+                f"attribute of the submission button."
+            )
+        raise NotImplementedError(f"Found unsupported form method {method!r}.")
+    return method
 
 
 class _NoClickables(ValueError):
@@ -137,6 +149,7 @@ def request_from_form(
     /,
     *,
     click: None | bool | HtmlElement = None,
+    method: None | str = None,
 ) -> Request:
     """Return a form submission request.
 
@@ -188,7 +201,7 @@ def request_from_form(
             f"not currently support."
         )
     url = _url(form, click_element)
-    method = _method(form, click_element)
+    method = _method(form, click_element, method)
     data = _data(data, click_element)
     query = _query(form, data)
     headers = []
diff --git a/tests/test_main.py b/tests/test_main.py
index 723a998..c6ecb7b 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -5,7 +5,7 @@
 
 
 @pytest.mark.parametrize(
-    ("base_url", "html", "data", "click", "expected"),
+    ("base_url", "html", "data", "click", "method", "expected"),
     (
         # Empty form.
         (
@@ -13,6 +13,7 @@
             b"""<form></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com",
                 "GET",
@@ -26,6 +27,7 @@
             b"""<form><input type="hidden" name="a" value="b" /></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -41,6 +43,7 @@
             b"""<form></form>""",
             {"a": "b"},
             None,
+            None,
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -54,6 +57,7 @@
             b"""<form><input type="text" name="a" /></form>""",
             {"a": "b"},
             None,
+            None,
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -68,6 +72,7 @@
             b"""<form><input type="hidden" name="a" value="b" /></form>""",
             {"a": "c"},
             None,
+            None,
             Request(
                 "https://example.com?a=c",
                 "GET",
@@ -81,6 +86,7 @@
             b"""<form></form>""",
             {"a": None},
             None,
+            None,
             Request(
                 "https://example.com",
                 "GET",
@@ -95,6 +101,7 @@
             b"""<form><input type="text" name="a" /></form>""",
             {"a": None},
             None,
+            None,
             Request(
                 "https://example.com",
                 "GET",
@@ -109,6 +116,7 @@
             b"""<form><input type="hidden" name="a" value="b" /></form>""",
             {"a": None},
             None,
+            None,
             Request(
                 "https://example.com",
                 "GET",
@@ -122,6 +130,7 @@
             b"""<form><input type="text" name="a" /></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com?a=",
                 "GET",
@@ -135,6 +144,7 @@
             b"""<form></form>""",
             (("a", "b"), ("a", "c")),
             None,
+            None,
             Request(
                 "https://example.com?a=b&a=c",
                 "GET",
@@ -149,6 +159,7 @@
             b"""<form><input type="submit" name="a" value="b" /></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -162,6 +173,7 @@
             b"""<form><input type="submit" name="a" value="b" /></form>""",
             None,
             False,
+            None,
             Request(
                 "https://example.com",
                 "GET",
@@ -175,6 +187,7 @@
             b"""<form><input type="submit" name="a" value="b" /></form>""",
             None,
             True,
+            None,
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -189,6 +202,7 @@
             b"""<form></form>""",
             None,
             True,
+            None,
             ValueError,
         ),
         # If there are 2 or more submit buttons, the first one is used by
@@ -199,6 +213,7 @@
             <input type="submit" name="a" value="c" /></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -213,6 +228,7 @@
             <input type="submit" name="a" value="c" /></form>""",
             None,
             './/*[@value="c"]',
+            None,
             Request(
                 "https://example.com?a=c",
                 "GET",
@@ -228,6 +244,7 @@
                 f"""<form enctype="{enctype}"></form>""".encode(),
                 None,
                 None,
+                None,
                 Request(
                     "https://example.com",
                     "GET",
@@ -247,6 +264,7 @@
                 f"""<form enctype="{enctype}"></form>""".encode(),
                 None,
                 None,
+                None,
                 NotImplementedError,
             )
             for enctype in (
@@ -262,6 +280,7 @@
             formenctype="application/x-www-form-urlencoded" /></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com",
                 "GET",
@@ -277,6 +296,7 @@
             type="submit" formenctype="foo" /></form>""",
             None,
             None,
+            None,
             NotImplementedError,
         ),
         # Only submit buttons are detected as such.
@@ -286,6 +306,7 @@
                 f"""<form>{button}<button name="c" value="d" /></form>""".encode(),
                 None,
                 None,
+                None,
                 Request(
                     "https://example.com?a=b",
                     "GET",
@@ -307,6 +328,7 @@
                 f"""<form>{button}<button name="c" value="d" /></form>""".encode(),
                 None,
                 None,
+                None,
                 Request(
                     f"https://example.com?{query}",
                     "GET",
@@ -333,6 +355,7 @@
             b"""<form action="a"></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com/a",
                 "GET",
@@ -346,6 +369,7 @@
             b"""<form action="a"><button type="submit" formaction="b" /></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com/b",
                 "GET",
@@ -359,6 +383,7 @@
             b"""<form action=" a "></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com/a",
                 "GET",
@@ -372,6 +397,7 @@
             b"""<form method="get"></form>""",
             {"a": "b"},
             None,
+            None,
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -384,6 +410,7 @@
             b"""<form method="post"></form>""",
             {"a": "b"},
             None,
+            None,
             Request(
                 "https://example.com",
                 "POST",
@@ -397,6 +424,7 @@
             b"""<form method="post"><button type="submit" formmethod="get" /></form>""",
             {"a": "b"},
             None,
+            None,
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -409,6 +437,7 @@
             b"""<form method="get"><button formmethod="post" /></form>""",
             {"a": "b"},
             None,
+            None,
             Request(
                 "https://example.com",
                 "POST",
@@ -424,6 +453,7 @@
             b"""<form method="a"></form>""",
             None,
             None,
+            None,
             NotImplementedError,
         ),
         (
@@ -431,6 +461,7 @@
             b"""<form><button formmethod="a" /></form>""",
             None,
             None,
+            None,
             NotImplementedError,
         ),
         (
@@ -438,6 +469,7 @@
             b"""<form method="a"><button formmethod="get" /></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com",
                 "GET",
@@ -445,6 +477,33 @@
                 b"",
             ),
         ),
+        # Users can override the method value, to workaround scenarios where
+        # HTML forms have an unsupported method but a supported one is set
+        # through JavaScript.
+        (
+            "https://example.com",
+            b"""<form method="a"><button formmethod="b" /></form>""",
+            None,
+            None,
+            "get",
+            Request(
+                "https://example.com",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # If users pass an unsupported method, ValueError is raised instead of
+        # NotImplementedError, since users should know which values are
+        # supported beforehand.
+        (
+            "https://example.com",
+            b"""<form method="a"><button formmethod="b" /></form>""",
+            None,
+            None,
+            "c",
+            ValueError,
+        ),
         # User data as an iterable of key-value tuples gets merged with button
         # name and value as expected.
         (
@@ -452,6 +511,7 @@
             b"""<form><button name="d" value="e"></form>""",
             (("a", "b"), ("a", "c")),
             None,
+            None,
             Request(
                 "https://example.com?a=b&a=c&d=e",
                 "GET",
@@ -465,6 +525,7 @@
             b"""<form><input disabled name="a" value="b"></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com",
                 "GET",
@@ -479,6 +540,7 @@
             </fieldset></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com",
                 "GET",
@@ -493,6 +555,7 @@
             b"""<form><select name="a"><option value="b">B</option></select></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -506,6 +569,7 @@
             b"""<form><select name="a"><option>B</option></select></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com?a=B",
                 "GET",
@@ -521,6 +585,7 @@
             <option value="c">C</option></select></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -535,6 +600,7 @@
             <option selected value="c">C</option></select></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com?a=c",
                 "GET",
@@ -550,6 +616,7 @@
             <option value="c">C</option></select></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com",
                 "GET",
@@ -565,6 +632,7 @@
             <option value="c" selected>C</option></select></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com?a=c",
                 "GET",
@@ -580,6 +648,7 @@
             <option value="c" selected>C</option></select></form>""",
             None,
             None,
+            None,
             Request(
                 "https://example.com?a=b&a=c",
                 "GET",
@@ -593,6 +662,7 @@
             b"""<form><input name="a+ /" value="b+ /"></form>""",
             {"c+ /": "d+ /"},
             None,
+            None,
             Request(
                 "https://example.com?a%2B+%2F=b%2B+%2F&c%2B+%2F=d%2B+%2F",
                 "GET",
@@ -605,6 +675,7 @@
             b"""<form method="post"><input name="a+ /" value="b+ /"></form>""",
             {"c+ /": "d+ /"},
             None,
+            None,
             Request(
                 "https://example.com",
                 "POST",
@@ -614,17 +685,17 @@
         ),
     ),
 )
-def test_request_from_form(base_url, html, data, click, expected):
+def test_request_from_form(base_url, html, data, click, method, expected):
     root = fromstring(html, base_url=base_url)
     form = root.xpath("//form")[0]
     if isinstance(click, str):
         click = form.xpath(click)[0]
     if isinstance(expected, Request):
-        actual = request_from_form(form, data, click=click)
+        actual = request_from_form(form, data, click=click, method=method)
         assert expected == actual
     else:
         with pytest.raises(expected):
-            request_from_form(form, data, click=click)
+            request_from_form(form, data, click=click, method=method)
 
 
 def test_request_from_form_no_base_url():

From f37e26975c7de8b923dd4c3b6054de628dbd6252 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Wed, 3 Jul 2024 07:10:45 +0200
Subject: [PATCH 13/28] Update docs/usage.rst

Co-authored-by: Mikhail Korobov <kmike84@gmail.com>
---
 docs/usage.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/usage.rst b/docs/usage.rst
index 888ac42..183f746 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -129,7 +129,7 @@ By default, if a form uses an unsupported method:
 >>> root = fromstring(html, base_url="https://example.com")
 >>> form = root.xpath("//form")[0]
 
-A :exc:`NotImplementedError` exception will be raised:
+A :exc:`NotImplementedError` exception is raised:
 
 >>> request_from_form(form)
 Traceback (most recent call last):

From 51e733f6126a7d373df1bc297f7c2d23ef9e7df0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Wed, 3 Jul 2024 08:09:43 +0200
Subject: [PATCH 14/28] =?UTF-8?q?request=5Ffrom=5Fform=20=E2=86=92=20form2?=
 =?UTF-8?q?request?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/api.rst             |  2 +-
 docs/usage.rst           | 36 ++++++++++++++++++------------------
 form2request/__init__.py |  2 +-
 form2request/_base.py    |  2 +-
 tests/test_main.py       | 12 ++++++------
 5 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/docs/api.rst b/docs/api.rst
index 05c1a65..18f8d4b 100644
--- a/docs/api.rst
+++ b/docs/api.rst
@@ -2,7 +2,7 @@
 API reference
 =============
 
-.. autofunction:: form2request.request_from_form
+.. autofunction:: form2request.form2request
 
 .. autoclass:: form2request.Request
     :members:
diff --git a/docs/usage.rst b/docs/usage.rst
index 183f746..d50c3d9 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -11,14 +11,14 @@ Usage
 >>> root = fromstring(html, base_url="https://example.com")
 >>> form = root.xpath("//form")[0]
 
-You can use :func:`~form2request.request_from_form` to generate :ref:`form
+You can use :func:`~form2request.form2request` to generate :ref:`form
 submission request data <request>`:
 
->>> from form2request import request_from_form
->>> request_from_form(form)
+>>> from form2request import form2request
+>>> form2request(form)
 Request(url='https://example.com?foo=bar', method='GET', headers=[], body=b'')
 
-:func:`~form2request.request_from_form` supports :ref:`user-defined form data
+:func:`~form2request.form2request` supports :ref:`user-defined form data
 <data>` and :ref:`choosing a specific form submission button (or none)
 <click>`.
 
@@ -28,7 +28,7 @@ Request(url='https://example.com?foo=bar', method='GET', headers=[], body=b'')
 Getting a form
 ==============
 
-:func:`~form2request.request_from_form` requires an
+:func:`~form2request.form2request` requires an
 :class:`lxml.html.FormElement` object.
 
 You can build one using :func:`lxml.html.fromstring` to parse an HTML document
@@ -90,10 +90,10 @@ user-defined data:
 >>> root = fromstring(html, base_url="https://example.com")
 >>> form = root.xpath("//form")[0]
 
-Use the second parameter of :func:`~form2request.request_from_form`,  to define
+Use the second parameter of :func:`~form2request.form2request`,  to define
 the corresponding data:
 
->>> request_from_form(form, {"foo": "bar"})
+>>> form2request(form, {"foo": "bar"})
 Request(url='https://example.com?foo=bar', method='GET', headers=[], body=b'')
 
 You may sometimes find forms where more than one field has the same ``name``
@@ -106,7 +106,7 @@ attribute:
 To specify values for all same-name fields, instead of a dictionary, use an
 iterable of key-value tuples:
 
->>> request_from_form(form, (("foo", "bar"), ("foo", "baz")))
+>>> form2request(form, (("foo", "bar"), ("foo", "baz")))
 Request(url='https://example.com?foo=bar&foo=baz', method='GET', headers=[], body=b'')
 
 Sometimes, you might want to prevent a value from a field from being included
@@ -120,7 +120,7 @@ disabled through JavaScript, or because the field or a parent element has the
 
 To remove a field value, set it to ``None``:
 
->>> request_from_form(form, {"foo": None})
+>>> form2request(form, {"foo": None})
 Request(url='https://example.com', method='GET', headers=[], body=b'')
 
 By default, if a form uses an unsupported method:
@@ -131,7 +131,7 @@ By default, if a form uses an unsupported method:
 
 A :exc:`NotImplementedError` exception is raised:
 
->>> request_from_form(form)
+>>> form2request(form)
 Traceback (most recent call last):
 ...
 NotImplementedError: Found unsupported form method 'FOO'.
@@ -139,7 +139,7 @@ NotImplementedError: Found unsupported form method 'FOO'.
 If the reason for the bad method is that the right method is set through
 JavaScript code, you can use the ``method`` parameter to set the right value:
 
->>> request_from_form(form, method="GET")
+>>> form2request(form, method="GET")
 Request(url='https://example.com', method='GET', headers=[], body=b'')
 
 
@@ -158,17 +158,17 @@ Given a submit button with ``name`` and ``value`` attributes:
 >>> form = root.xpath("//form")[0]
 
 If you submit the form by clicking that button, those attributes are included
-in the request data, which is what :func:`~form2request.request_from_form` does
+in the request data, which is what :func:`~form2request.form2request` does
 by default:
 
->>> request_from_form(form)
+>>> form2request(form)
 Request(url='https://example.com?foo=bar', method='GET', headers=[], body=b'')
 
 However, sometimes it is possible to submit a form without clicking a submit
 button, even when there is such a button. In such cases, the button data should
 not be part of the request data. For such cases, set ``click`` to ``False``:
 
->>> request_from_form(form, click=False)
+>>> form2request(form, click=False)
 Request(url='https://example.com', method='GET', headers=[], body=b'')
 
 You may also find forms with more than one submit button:
@@ -177,16 +177,16 @@ You may also find forms with more than one submit button:
 >>> root = fromstring(html, base_url="https://example.com")
 >>> form = root.xpath("//form")[0]
 
-By default, :func:`~form2request.request_from_form` clicks the first submission
+By default, :func:`~form2request.form2request` clicks the first submission
 element:
 
->>> request_from_form(form)
+>>> form2request(form)
 Request(url='https://example.com?foo=bar', method='GET', headers=[], body=b'')
 
 To change that, set ``click`` to the element that should be clicked:
 
 >>> submit_baz = form.xpath('.//*[@value="baz"]')[0]
->>> request_from_form(form, click=submit_baz)
+>>> form2request(form, click=submit_baz)
 Request(url='https://example.com?foo=baz', method='GET', headers=[], body=b'')
 
 
@@ -198,7 +198,7 @@ Using request data
 :class:`~form2request.Request` is a simple data container that you can use to
 build an actual request object:
 
->>> request_data = request_from_form(form)
+>>> request_data = form2request(form)
 
 Here are some examples for popular Python libraries and frameworks:
 
diff --git a/form2request/__init__.py b/form2request/__init__.py
index c6d4a5c..9868802 100644
--- a/form2request/__init__.py
+++ b/form2request/__init__.py
@@ -1,3 +1,3 @@
 """Build HTTP requests out of HTML forms."""
 
-from ._base import Request, request_from_form
+from ._base import Request, form2request
diff --git a/form2request/_base.py b/form2request/_base.py
index d1f6bee..fe1b654 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -143,7 +143,7 @@ class Request:
     body: bytes
 
 
-def request_from_form(
+def form2request(
     form: FormElement,
     data: FormdataType = None,
     /,
diff --git a/tests/test_main.py b/tests/test_main.py
index c6ecb7b..6dead32 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -1,7 +1,7 @@
 import pytest
 from lxml.html import fromstring
 
-from form2request import Request, request_from_form
+from form2request import Request, form2request
 
 
 @pytest.mark.parametrize(
@@ -685,22 +685,22 @@
         ),
     ),
 )
-def test_request_from_form(base_url, html, data, click, method, expected):
+def test_form2request(base_url, html, data, click, method, expected):
     root = fromstring(html, base_url=base_url)
     form = root.xpath("//form")[0]
     if isinstance(click, str):
         click = form.xpath(click)[0]
     if isinstance(expected, Request):
-        actual = request_from_form(form, data, click=click, method=method)
+        actual = form2request(form, data, click=click, method=method)
         assert expected == actual
     else:
         with pytest.raises(expected):
-            request_from_form(form, data, click=click, method=method)
+            form2request(form, data, click=click, method=method)
 
 
-def test_request_from_form_no_base_url():
+def test_form2request_no_base_url():
     html = "<form></form>"
     root = fromstring(html)
     form = root.xpath("//form")[0]
     with pytest.raises(ValueError):
-        request_from_form(form)
+        form2request(form)

From 0d0ded7458ee0cba397b4f57a1f95de9f0a84bdb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Wed, 3 Jul 2024 09:43:28 +0200
Subject: [PATCH 15/28] Add parsel support

---
 docs/conf.py          |  2 ++
 docs/usage.rst        | 82 +++++++++++++++++++++----------------------
 form2request/_base.py | 18 ++++++++--
 pyproject.toml        |  3 +-
 tests/test_main.py    | 23 ++++++++++++
 tox.ini               |  3 +-
 6 files changed, 84 insertions(+), 47 deletions(-)

diff --git a/docs/conf.py b/docs/conf.py
index 8ab46e1..f2435e9 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -25,6 +25,8 @@
             "FormdataType",
             "FormElement",
             "HtmlElement",
+            "Selector",
+            "SelectorList",
         )
     ),
 ]
diff --git a/docs/usage.rst b/docs/usage.rst
index d50c3d9..a515267 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -4,12 +4,12 @@ Usage
 
 :ref:`Given an HTML form <form>`:
 
-.. _fromstring-example:
+.. _parsel-example:
 
->>> from lxml.html import fromstring
+>>> from parsel import Selector
 >>> html = b"""<form><input type="hidden" name="foo" value="bar" /></form>"""
->>> root = fromstring(html, base_url="https://example.com")
->>> form = root.xpath("//form")[0]
+>>> selector = Selector(body=html, base_url="https://example.com")
+>>> form = selector.css("form")
 
 You can use :func:`~form2request.form2request` to generate :ref:`form
 submission request data <request>`:
@@ -28,20 +28,36 @@ Request(url='https://example.com?foo=bar', method='GET', headers=[], body=b'')
 Getting a form
 ==============
 
-:func:`~form2request.form2request` requires an
-:class:`lxml.html.FormElement` object.
+:func:`~form2request.form2request` requires an HTML form object. You can get
+one using :doc:`parsel <parsel:index>`, as :ref:`seen above <parsel-example>`,
+or you can use :doc:`lxml <lxml:index>`:
 
-You can build one using :func:`lxml.html.fromstring` to parse an HTML document
-and :meth:`lxml.html.HtmlElement.xpath` to find a form element in that
-document, as :ref:`seen above <fromstring-example>`.
+.. _fromstring-example:
+
+>>> from lxml.html import fromstring
+>>> root = fromstring(html, base_url="https://example.com")
+>>> form = root.xpath("//form")[0]
 
-Here are some examples of XPath expressions that can be useful to find a form
-element using :meth:`~lxml.html.HtmlElement.xpath`:
+If you use a library or framework based on :doc:`parsel <parsel:index>` or
+:doc:`lxml <lxml:index>`, chances are they also let you get a form object. For
+example, when using a :doc:`Scrapy <scrapy:index>` response:
+
+>>> from scrapy.http import TextResponse
+>>> response = TextResponse("https://example.com", body=html)
+>>> form = response.css("form")
+
+Here are some examples of XPath expressions that can be useful to get a form
+using parsel’s :meth:`Selector.xpath <parsel.selector.Selector.xpath>` or
+lxml’s :meth:`HtmlElement.xpath <lxml.html.HtmlElement.xpath>`:
 
 -   To find a form by one of its attributes, such as ``id`` or ``name``, use
     ``//form[@<attribute>="<value>"]``. For example, to find ``<form id="foo"
     …``, use ``//form[@id="foo"]``.
 
+    When using :meth:`Selector.css <parsel.selector.Selector.css>`, ``#<id>``
+    (e.g. ``#foo``) finds by ``id``, and ``[<attribute>=<value>]`` (e.g.
+    ``[name=foo]``) finds by any other attribute.
+
 -   To find a form by index, by order of appearance in the HTML code, use
     ``(//form)[n]``, where ``n`` is a 1-based index. For example, to find the
     2nd form, use ``(//form)[2]``.
@@ -58,24 +74,6 @@ visit parent elements until you reach the form element. For example:
         element = element.getparent()
     form = element
 
-If you use an lxml-based library or framework, chances are they also let you
-get a :class:`~lxml.html.FormElement` object. For example, when using
-:doc:`parsel <parsel:index>`:
-
->>> from parsel import Selector
->>> selector = Selector(body=html, base_url="https://example.com")
->>> form = selector.css("form")[0].root
->>> type(form)
-<class 'lxml.html.FormElement'>
-
-A similar example, with a :doc:`Scrapy <scrapy:index>` response:
-
->>> from scrapy.http import TextResponse
->>> response = TextResponse("https://example.com", body=html)
->>> form = response.css("form")[0].root
->>> type(form)
-<class 'lxml.html.FormElement'>
-
 
 .. _data:
 
@@ -87,8 +85,8 @@ While there are forms made entirely of hidden fields, like :ref:`the one above
 user-defined data:
 
 >>> html = b"""<form><input type="text" name="foo" /></form>"""
->>> root = fromstring(html, base_url="https://example.com")
->>> form = root.xpath("//form")[0]
+>>> selector = Selector(body=html, base_url="https://example.com")
+>>> form = selector.css("form")
 
 Use the second parameter of :func:`~form2request.form2request`,  to define
 the corresponding data:
@@ -100,8 +98,8 @@ You may sometimes find forms where more than one field has the same ``name``
 attribute:
 
 >>> html = b"""<form><input type="text" name="foo" /><input type="text" name="foo" /></form>"""
->>> root = fromstring(html, base_url="https://example.com")
->>> form = root.xpath("//form")[0]
+>>> selector = Selector(body=html, base_url="https://example.com")
+>>> form = selector.css("form")
 
 To specify values for all same-name fields, instead of a dictionary, use an
 iterable of key-value tuples:
@@ -115,8 +113,8 @@ disabled through JavaScript, or because the field or a parent element has the
 ``disabled`` attribute (currently not supported by form2request):
 
 >>> html = b"""<form><input name="foo" value="bar" disabled /></form>"""
->>> root = fromstring(html, base_url="https://example.com")
->>> form = root.xpath("//form")[0]
+>>> selector = Selector(body=html, base_url="https://example.com")
+>>> form = selector.css("form")
 
 To remove a field value, set it to ``None``:
 
@@ -126,8 +124,8 @@ Request(url='https://example.com', method='GET', headers=[], body=b'')
 By default, if a form uses an unsupported method:
 
 >>> html = b"""<form method="foo"></form>"""
->>> root = fromstring(html, base_url="https://example.com")
->>> form = root.xpath("//form")[0]
+>>> selector = Selector(body=html, base_url="https://example.com")
+>>> form = selector.css("form")
 
 A :exc:`NotImplementedError` exception is raised:
 
@@ -154,8 +152,8 @@ impact on the resulting request data.
 Given a submit button with ``name`` and ``value`` attributes:
 
 >>> html = b"""<form><input type="submit" name="foo" value="bar" /></form>"""
->>> root = fromstring(html, base_url="https://example.com")
->>> form = root.xpath("//form")[0]
+>>> selector = Selector(body=html, base_url="https://example.com")
+>>> form = selector.css("form")
 
 If you submit the form by clicking that button, those attributes are included
 in the request data, which is what :func:`~form2request.form2request` does
@@ -174,8 +172,8 @@ Request(url='https://example.com', method='GET', headers=[], body=b'')
 You may also find forms with more than one submit button:
 
 >>> html = b"""<form><input type="submit" name="foo" value="bar" /><input type="submit" name="foo" value="baz" /></form>"""
->>> root = fromstring(html, base_url="https://example.com")
->>> form = root.xpath("//form")[0]
+>>> selector = Selector(body=html, base_url="https://example.com")
+>>> form = selector.css("form")
 
 By default, :func:`~form2request.form2request` clicks the first submission
 element:
@@ -185,7 +183,7 @@ Request(url='https://example.com?foo=bar', method='GET', headers=[], body=b'')
 
 To change that, set ``click`` to the element that should be clicked:
 
->>> submit_baz = form.xpath('.//*[@value="baz"]')[0]
+>>> submit_baz = form.css("[value=baz]")
 >>> form2request(form, click=submit_baz)
 Request(url='https://example.com?foo=baz', method='GET', headers=[], body=b'')
 
diff --git a/form2request/_base.py b/form2request/_base.py
index fe1b654..6338578 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -4,6 +4,7 @@
 from typing import TYPE_CHECKING, Any, Dict, Iterable, Optional, Tuple, Union, cast
 from urllib.parse import urlencode, urljoin, urlsplit, urlunsplit
 
+from parsel import Selector, SelectorList
 from w3lib.html import strip_html5_whitespace
 
 if TYPE_CHECKING:
@@ -75,7 +76,7 @@ def _click_element(
 ) -> HtmlElement | None:
     if click is False:
         return None
-    if click in {None, True}:
+    if click is None or click is True:
         clickables = list(
             form.xpath(
                 'descendant::input[re:test(@type, "^(submit|image)$", "i")]'
@@ -89,6 +90,11 @@ def _click_element(
             else:
                 return None
         click = clickables[0]
+    else:
+        if isinstance(click, SelectorList):
+            click = click[0]
+        if isinstance(click, Selector):
+            click = click.root
     return click
 
 
@@ -144,7 +150,7 @@ class Request:
 
 
 def form2request(
-    form: FormElement,
+    form: FormElement | Selector | SelectorList,
     data: FormdataType = None,
     /,
     *,
@@ -153,7 +159,9 @@ def form2request(
 ) -> Request:
     """Return a form submission request.
 
-    *form* should be an instance of :class:`lxml.html.FormElement`.
+    *form* must be an instance of :class:`parsel.selector.Selector` or
+    :class:`parsel.selector.SelectorList` that points to an HTML form, or an
+    instance of :class:`lxml.html.FormElement`.
 
     *data* should be either a dictionary of a list of 2-item tuples indicating
     the key-value pairs to include in the request as submission data.
@@ -180,6 +188,10 @@ def form2request(
         On forms with multiple submission elements, specifying the right
         submission element here may be necessary.
     """
+    if isinstance(form, SelectorList):
+        form = form[0]
+    if isinstance(form, Selector):
+        form = form.root
     try:
         click_element = _click_element(form, click)
     except _NoClickables:
diff --git a/pyproject.toml b/pyproject.toml
index 597272c..8088639 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -25,7 +25,8 @@ classifiers = [
 requires-python = ">=3.8"
 dependencies = [
     "lxml >= 4.4.1",
-    "w3lib >= 1.17.0",
+    "parsel >= 1.8.1",
+    "w3lib >= 1.19.0",
 ]
 
 [project.urls]
diff --git a/tests/test_main.py b/tests/test_main.py
index 6dead32..68fdb43 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -1,5 +1,6 @@
 import pytest
 from lxml.html import fromstring
+from parsel import Selector
 
 from form2request import Request, form2request
 
@@ -704,3 +705,25 @@ def test_form2request_no_base_url():
     form = root.xpath("//form")[0]
     with pytest.raises(ValueError):
         form2request(form)
+
+
+def test_form2request_parsel():
+    html = b"""<form><input type="submit" name="foo" value="bar" />
+    <input type="submit" name="foo" value="baz" /></form>"""
+    selector = Selector(body=html, base_url="https://example.com")
+    form = selector.css("form")
+
+    expected = Request(
+        url="https://example.com?foo=bar", method="GET", headers=[], body=b""
+    )
+    assert form2request(form) == expected
+    assert form2request(form[0]) == expected
+    assert form2request(form[0].root) == expected
+
+    submit_baz = form.css("[value=baz]")
+    expected = Request(
+        url="https://example.com?foo=baz", method="GET", headers=[], body=b""
+    )
+    assert form2request(form, click=submit_baz) == expected
+    assert form2request(form, click=submit_baz[0]) == expected
+    assert form2request(form, click=submit_baz[0].root) == expected
diff --git a/tox.ini b/tox.ini
index b0d96ac..1553b72 100644
--- a/tox.ini
+++ b/tox.ini
@@ -17,7 +17,8 @@ basepython = python3.8
 deps =
     {[testenv]deps}
     lxml==4.4.1
-    w3lib==1.17.0
+    parsel==1.8.1
+    w3lib==1.19.0
 
 [testenv:pre-commit]
 deps =

From 9830c9f389897392b6891468baf3867428aed21e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Wed, 3 Jul 2024 10:01:36 +0200
Subject: [PATCH 16/28] Only raise NotImplementedError for the dialog method

---
 docs/usage.rst        | 21 ++++++++---
 form2request/_base.py | 10 +++---
 tests/test_main.py    | 81 ++++++++++++++++++++++++++++++++++++++-----
 3 files changed, 93 insertions(+), 19 deletions(-)

diff --git a/docs/usage.rst b/docs/usage.rst
index a515267..bb6f567 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -121,9 +121,9 @@ To remove a field value, set it to ``None``:
 >>> form2request(form, {"foo": None})
 Request(url='https://example.com', method='GET', headers=[], body=b'')
 
-By default, if a form uses an unsupported method:
+By default, if a form uses the unsupported ``dialog`` method:
 
->>> html = b"""<form method="foo"></form>"""
+>>> html = b"""<form method="dialog"></form>"""
 >>> selector = Selector(body=html, base_url="https://example.com")
 >>> form = selector.css("form")
 
@@ -132,10 +132,21 @@ A :exc:`NotImplementedError` exception is raised:
 >>> form2request(form)
 Traceback (most recent call last):
 ...
-NotImplementedError: Found unsupported form method 'FOO'.
+NotImplementedError: Found unsupported form method 'DIALOG'.
+
+If a form uses an unknown method:
+
+>>> html = b"""<form method="foo"></form>"""
+>>> selector = Selector(body=html, base_url="https://example.com")
+>>> form = selector.css("form")
+
+``GET`` is used instead, as a web browser would do:
+
+>>> form2request(form)
+Request(url='https://example.com', method='GET', headers=[], body=b'')
 
-If the reason for the bad method is that the right method is set through
-JavaScript code, you can use the ``method`` parameter to set the right value:
+If a website uses JavaScript to set or modify the method, use the ``method``
+parameter to set the right value:
 
 >>> form2request(form, method="GET")
 Request(url='https://example.com', method='GET', headers=[], body=b'')
diff --git a/form2request/_base.py b/form2request/_base.py
index 6338578..2550501 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -53,17 +53,17 @@ def _method(
             assert method is not None  # lxml’s form.method is always filled
             method_src = form
     method = method.upper()
-    if method not in {"GET", "POST"}:
-        if method_src is USER:
-            raise ValueError(
-                f"The specified form method ({method!r}) is not supported."
-            )
+    if method_src is USER and method not in {"GET", "POST"}:
+        raise ValueError(f"The specified form method ({method!r}) is not supported.")
+    if method == "DIALOG":
         if method_src is click_element:
             raise NotImplementedError(
                 f"Found unsupported form method {method!r} in the formmethod "
                 f"attribute of the submission button."
             )
         raise NotImplementedError(f"Found unsupported form method {method!r}.")
+    if method not in {"GET", "POST"}:
+        method = "GET"
     return method
 
 
diff --git a/tests/test_main.py b/tests/test_main.py
index 68fdb43..aff0efb 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -446,12 +446,12 @@
                 b"a=b",
             ),
         ),
-        # Unsupported methods trigger a NotImplementedError, but only if they
-        # are the actual method to be used, e.g. not if overridden by a
-        # supported method.
+        # The dialog method triggers a NotImplementedError, but only if it is
+        # the actual method to be used, e.g. not if overridden by another
+        # method.
         (
             "https://example.com",
-            b"""<form method="a"></form>""",
+            b"""<form method="dialog"></form>""",
             None,
             None,
             None,
@@ -459,7 +459,7 @@
         ),
         (
             "https://example.com",
-            b"""<form><button formmethod="a" /></form>""",
+            b"""<form><button formmethod="dialog" /></form>""",
             None,
             None,
             None,
@@ -467,7 +467,60 @@
         ),
         (
             "https://example.com",
-            b"""<form method="a"><button formmethod="get" /></form>""",
+            b"""<form method="dialog"><button formmethod="get" /></form>""",
+            None,
+            None,
+            None,
+            Request(
+                "https://example.com",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        (
+            "https://example.com",
+            b"""<form method="dialog"><button formmethod="a" /></form>""",
+            None,
+            None,
+            None,
+            Request(
+                "https://example.com",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        # Unknown methods are replaced with GET, and can override.
+        (
+            "https://example.com",
+            b"""<form method="a"></form>""",
+            None,
+            None,
+            None,
+            Request(
+                "https://example.com",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        (
+            "https://example.com",
+            b"""<form><button formmethod="a" /></form>""",
+            None,
+            None,
+            None,
+            Request(
+                "https://example.com",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        (
+            "https://example.com",
+            b"""<form method="post"><button formmethod="a" /></form>""",
             None,
             None,
             None,
@@ -494,9 +547,19 @@
                 b"",
             ),
         ),
-        # If users pass an unsupported method, ValueError is raised instead of
-        # NotImplementedError, since users should know which values are
-        # supported beforehand.
+        # If users pass dialog as method, ValueError is raised instead of
+        # NotImplementedError, since users should know that it is not a
+        # supported value beforehand.
+        (
+            "https://example.com",
+            b"""<form method="a"><button formmethod="b" /></form>""",
+            None,
+            None,
+            "dialog",
+            ValueError,
+        ),
+        # If users pass an unknown method, ValueError is raised since users
+        # should know which values are supported beforehand.
         (
             "https://example.com",
             b"""<form method="a"><button formmethod="b" /></form>""",

From 0337a40f2d74b6d1de27b45695bbd410b44b42eb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Wed, 3 Jul 2024 10:04:50 +0200
Subject: [PATCH 17/28] Do not make form and data position-only

---
 form2request/_base.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/form2request/_base.py b/form2request/_base.py
index 2550501..cc2be5b 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -152,7 +152,6 @@ class Request:
 def form2request(
     form: FormElement | Selector | SelectorList,
     data: FormdataType = None,
-    /,
     *,
     click: None | bool | HtmlElement = None,
     method: None | str = None,

From e098d54cf0afe7c0b1aac6ca14aec5217461f68a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Wed, 3 Jul 2024 10:46:05 +0200
Subject: [PATCH 18/28] Support text/plain enctype, only raise
 NotImplementedError for mutipart/form-data

---
 form2request/_base.py | 40 ++++++++++---------
 tests/test_main.py    | 93 ++++++++++++++++++++++++++++++++++++-------
 2 files changed, 100 insertions(+), 33 deletions(-)

diff --git a/form2request/_base.py b/form2request/_base.py
index cc2be5b..590e68a 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -98,7 +98,9 @@ def _click_element(
     return click
 
 
-def _data(data: FormdataType, click_element: HtmlElement | None) -> FormdataType:
+def _data(
+    form: FormElement, data: FormdataType, click_element: HtmlElement | None
+) -> list[tuple[str, str]]:
     data = data or {}
     if click_element is not None and (name := click_element.get("name")):
         click_data = (name, click_element.get("value"))
@@ -108,10 +110,6 @@ def _data(data: FormdataType, click_element: HtmlElement | None) -> FormdataType
         else:
             data = list(data)
             data.append(click_data)
-    return data
-
-
-def _query(form: FormElement, data: FormdataType) -> str:
     keys = dict(data or ()).keys()
     if not data:
         data = []
@@ -131,12 +129,11 @@ def _query(form: FormElement, data: FormdataType) -> str:
     ]
     items = data.items() if isinstance(data, dict) else data
     values.extend((k, v) for k, v in items if v is not None)
-    encoded_values = [
-        (k.encode(), v.encode())
+    return [
+        (k, v)
         for k, vs in values
         for v in (cast("Iterable[str]", vs) if _is_listlike(vs) else [cast("str", vs)])
     ]
-    return urlencode(encoded_values, doseq=True)
 
 
 @dataclass
@@ -198,34 +195,39 @@ def form2request(
             f"No clickable elements found in form {form}. Set click=False or "
             f"point it to the element to be clicked."
         ) from None
-    if click_element is not None and (enctype := click_element.get("formenctype")):
-        if enctype != "application/x-www-form-urlencoded":
+    if click_element is not None and (
+        enctype := (click_element.get("formenctype") or "").lower()
+    ):
+        if enctype == "multipart/form-data":
             raise NotImplementedError(
                 f"{click_element} has formenctype set to {enctype!r}, which "
                 f"form2request does not currently support."
             )
     elif (
-        enctype := form.get("enctype")
-    ) and enctype != "application/x-www-form-urlencoded":
+        enctype := (form.get("enctype") or "").lower()
+    ) and enctype == "multipart/form-data":
         raise NotImplementedError(
             f"{form} has enctype set to {enctype!r}, which form2request does "
             f"not currently support."
         )
     url = _url(form, click_element)
     method = _method(form, click_element, method)
-    data = _data(data, click_element)
-    query = _query(form, data)
+    data = _data(form, data, click_element)
     headers = []
-    body = b""
+    body = ""
     if method == "GET":
-        url = urlunsplit(urlsplit(url)._replace(query=query))
+        url = urlunsplit(urlsplit(url)._replace(query=urlencode(data, doseq=True)))
     else:
         assert method == "POST"
-        headers = [("Content-Type", "application/x-www-form-urlencoded")]
-        body = query.encode()
+        if enctype == "text/plain":
+            headers = [("Content-Type", "text/plain")]
+            body = "\n".join(f"{k}={v}" for k, v in data)
+        else:
+            headers = [("Content-Type", "application/x-www-form-urlencoded")]
+            body = urlencode(data, doseq=True)
     return Request(
         url=url,
         method=method,
         headers=headers,
-        body=body,
+        body=body.encode(),
     )
diff --git a/tests/test_main.py b/tests/test_main.py
index aff0efb..89ba578 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -237,8 +237,8 @@
                 b"",
             ),
         ),
-        # Only the application/x-www-form-urlencoded enctype (default) is
-        # supported.
+        # Supported enctypes are application/x-www-form-urlencoded (default)
+        # and text/plain. Unknown enctypes are treated as the default one.
         *(
             (
                 "https://example.com",
@@ -256,9 +256,11 @@
             for enctype in (
                 "",
                 "application/x-www-form-urlencoded",
+                "text/plain",
+                "foo",
             )
         ),
-        # Any other raise a NotImplementedError expection.
+        # multipart/form-data raises a NotImplementedError exception.
         *(
             (
                 "https://example.com",
@@ -268,16 +270,13 @@
                 None,
                 NotImplementedError,
             )
-            for enctype in (
-                "multipart/form-data",
-                "text/plain",
-                "foo",
-            )
+            for enctype in ("multipart/form-data",)
         ),
-        # The formenctype from the submit button is taken into account.
+        # The formenctype from the submit button is taken into account, even if
+        # it has an unknown value.
         (
             "https://example.com",
-            b"""<form enctype="foo"><input type="submit"
+            b"""<form enctype="multipart/form-data"><input type="submit"
             formenctype="application/x-www-form-urlencoded" /></form>""",
             None,
             None,
@@ -289,12 +288,24 @@
                 b"",
             ),
         ),
-        # Even if the form has an unsupported enctype, things work if the
-        # submit button sets a supported one.
         (
             "https://example.com",
-            b"""<form enctype="application/x-www-form-urlencoded"><input
-            type="submit" formenctype="foo" /></form>""",
+            b"""<form enctype="multipart/form-data"><input type="submit"
+            formenctype="foo" /></form>""",
+            None,
+            None,
+            None,
+            Request(
+                "https://example.com",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        (
+            "https://example.com",
+            b"""<form enctype="application/x-www-form-urlencoded"><input type="submit"
+            formenctype="multipart/form-data" /></form>""",
             None,
             None,
             None,
@@ -747,6 +758,60 @@
                 b"a%2B+%2F=b%2B+%2F&c%2B+%2F=d%2B+%2F",
             ),
         ),
+        # When using the text/plain enctype, things work the same for GET, but
+        # for POST values are not URL-encoded, and line breaks are used as
+        # separators.
+        (
+            "https://example.com",
+            b"""<form enctype="text/plain"><input name="a+ /" value="b+ /"></form>""",
+            {"c+ /": "d+ /"},
+            None,
+            None,
+            Request(
+                "https://example.com?a%2B+%2F=b%2B+%2F&c%2B+%2F=d%2B+%2F",
+                "GET",
+                [],
+                b"",
+            ),
+        ),
+        (
+            "https://example.com",
+            b"""<form enctype="text/plain" method="post">
+            <input name="a+ /" value="b+ /"></form>""",
+            {"c+ /": "d+ /"},
+            None,
+            None,
+            Request(
+                "https://example.com",
+                "POST",
+                [("Content-Type", "text/plain")],
+                b"a+ /=b+ /\nc+ /=d+ /",
+            ),
+        ),
+        # enctype and formenctype are treated case-insensitively.
+        (
+            "https://example.com",
+            b"""<form enctype="TeXt/PlAiN" method="post">
+            <input name="a+ /" value="b+ /"></form>""",
+            {"c+ /": "d+ /"},
+            None,
+            None,
+            Request(
+                "https://example.com",
+                "POST",
+                [("Content-Type", "text/plain")],
+                b"a+ /=b+ /\nc+ /=d+ /",
+            ),
+        ),
+        (
+            "https://example.com",
+            b"""<form enctype="application/x-www-form-urlencoded"><input type="submit"
+            formenctype="MuLtIpArT/fOrM-dAtA" /></form>""",
+            None,
+            None,
+            None,
+            NotImplementedError,
+        ),
     ),
 )
 def test_form2request(base_url, html, data, click, method, expected):

From 19074243f76427416f77e1ca59edb329ef4278d4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Wed, 3 Jul 2024 10:55:41 +0200
Subject: [PATCH 19/28] Remove cast usages

---
 form2request/_base.py | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

diff --git a/form2request/_base.py b/form2request/_base.py
index 590e68a..05e8027 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Iterable, Optional, Tuple, Union, cast
+from typing import TYPE_CHECKING, Dict, Iterable, Optional, Tuple, Union
 from urllib.parse import urlencode, urljoin, urlsplit, urlunsplit
 
 from parsel import Selector, SelectorList
@@ -16,14 +16,6 @@
 FormdataType = Optional[Union[Dict[str, FormdataVType], Iterable[FormdataKVType]]]
 
 
-def _is_listlike(x: Any) -> bool:
-    """Return ``True`` if *x* is a list-like object or ``False`` otherwise.
-
-    A list-like object is an iterable, excluding strings or bytes.
-    """
-    return hasattr(x, "__iter__") and not isinstance(x, (str, bytes))
-
-
 def _url(form: FormElement, click_element: HtmlElement | None) -> str:
     if form.base_url is None:
         raise ValueError(f"{form} has no base_url set.")
@@ -132,7 +124,7 @@ def _data(
     return [
         (k, v)
         for k, vs in values
-        for v in (cast("Iterable[str]", vs) if _is_listlike(vs) else [cast("str", vs)])
+        for v in ([vs] if isinstance(vs, (str, bytes)) else vs)
     ]
 
 

From 259ddde33c4fc5a0bfd999de2e9832fa368626da Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Wed, 3 Jul 2024 11:17:01 +0200
Subject: [PATCH 20/28] Allow overriding enctype

---
 docs/usage.rst        |  45 +++++++-
 form2request/_base.py |  14 ++-
 tests/test_main.py    | 247 +++++++++++++-----------------------------
 3 files changed, 128 insertions(+), 178 deletions(-)

diff --git a/docs/usage.rst b/docs/usage.rst
index bb6f567..381893c 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -121,7 +121,13 @@ To remove a field value, set it to ``None``:
 >>> form2request(form, {"foo": None})
 Request(url='https://example.com', method='GET', headers=[], body=b'')
 
-By default, if a form uses the unsupported ``dialog`` method:
+
+Handling the form method
+========================
+
+By default, if a form uses the unsupported ``dialog`` method_:
+
+.. _method: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form#method
 
 >>> html = b"""<form method="dialog"></form>"""
 >>> selector = Selector(body=html, base_url="https://example.com")
@@ -152,6 +158,43 @@ parameter to set the right value:
 Request(url='https://example.com', method='GET', headers=[], body=b'')
 
 
+Handling the form enctype
+=========================
+
+By default, if a form uses the unsupported ``multipart/form-data`` enctype_:
+
+.. _enctype: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form#enctype
+
+>>> html = b"""<form enctype="multipart/form-data"></form>"""
+>>> selector = Selector(body=html, base_url="https://example.com")
+>>> form = selector.css("form")
+
+A :exc:`NotImplementedError` exception is raised:
+
+>>> form2request(form)
+Traceback (most recent call last):
+...
+NotImplementedError: Found unsupported form enctype 'multipart/form-data'.
+
+If a form uses an unknown enctype:
+
+>>> html = b"""<form enctype="foo" method="post"></form>"""
+>>> selector = Selector(body=html, base_url="https://example.com")
+>>> form = selector.css("form")
+
+``application/x-www-form-urlencoded`` is used instead, as a web browser would
+do:
+
+>>> form2request(form)
+Request(url='https://example.com', method='POST', headers=[('Content-Type', 'application/x-www-form-urlencoded')], body=b'')
+
+If a website uses JavaScript to set or modify the enctype, use the ``enctype``
+parameter to set the right value:
+
+>>> form2request(form, enctype="application/x-www-form-urlencoded")
+Request(url='https://example.com', method='POST', headers=[('Content-Type', 'application/x-www-form-urlencoded')], body=b'')
+
+
 .. _click:
 
 Configuring form submission
diff --git a/form2request/_base.py b/form2request/_base.py
index 05e8027..4ef4129 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -144,6 +144,7 @@ def form2request(
     *,
     click: None | bool | HtmlElement = None,
     method: None | str = None,
+    enctype: None | str = None,
 ) -> Request:
     """Return a form submission request.
 
@@ -187,7 +188,13 @@ def form2request(
             f"No clickable elements found in form {form}. Set click=False or "
             f"point it to the element to be clicked."
         ) from None
-    if click_element is not None and (
+    if enctype:
+        enctype = enctype.lower()
+        if enctype not in {"application/x-www-form-urlencoded", "text/plain"}:
+            raise ValueError(
+                f"The specified form enctype ({enctype!r}) is not supported."
+            )
+    elif click_element is not None and (
         enctype := (click_element.get("formenctype") or "").lower()
     ):
         if enctype == "multipart/form-data":
@@ -198,10 +205,7 @@ def form2request(
     elif (
         enctype := (form.get("enctype") or "").lower()
     ) and enctype == "multipart/form-data":
-        raise NotImplementedError(
-            f"{form} has enctype set to {enctype!r}, which form2request does "
-            f"not currently support."
-        )
+        raise NotImplementedError(f"Found unsupported form enctype {enctype!r}.")
     url = _url(form, click_element)
     method = _method(form, click_element, method)
     data = _data(form, data, click_element)
diff --git a/tests/test_main.py b/tests/test_main.py
index 89ba578..e5bda82 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -6,15 +6,13 @@
 
 
 @pytest.mark.parametrize(
-    ("base_url", "html", "data", "click", "method", "expected"),
+    ("base_url", "html", "kwargs", "expected"),
     (
         # Empty form.
         (
             "https://example.com",
             b"""<form></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com",
                 "GET",
@@ -26,9 +24,7 @@
         (
             "https://example.com",
             b"""<form><input type="hidden" name="a" value="b" /></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -42,9 +38,7 @@
         (
             "https://example.com",
             b"""<form></form>""",
-            {"a": "b"},
-            None,
-            None,
+            {"data": {"a": "b"}},
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -56,9 +50,7 @@
         (
             "https://example.com",
             b"""<form><input type="text" name="a" /></form>""",
-            {"a": "b"},
-            None,
-            None,
+            {"data": {"a": "b"}},
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -71,9 +63,7 @@
         (
             "https://example.com",
             b"""<form><input type="hidden" name="a" value="b" /></form>""",
-            {"a": "c"},
-            None,
-            None,
+            {"data": {"a": "c"}},
             Request(
                 "https://example.com?a=c",
                 "GET",
@@ -85,9 +75,7 @@
         (
             "https://example.com",
             b"""<form></form>""",
-            {"a": None},
-            None,
-            None,
+            {"data": {"a": None}},
             Request(
                 "https://example.com",
                 "GET",
@@ -100,9 +88,7 @@
         (
             "https://example.com",
             b"""<form><input type="text" name="a" /></form>""",
-            {"a": None},
-            None,
-            None,
+            {"data": {"a": None}},
             Request(
                 "https://example.com",
                 "GET",
@@ -115,9 +101,7 @@
         (
             "https://example.com",
             b"""<form><input type="hidden" name="a" value="b" /></form>""",
-            {"a": None},
-            None,
-            None,
+            {"data": {"a": None}},
             Request(
                 "https://example.com",
                 "GET",
@@ -129,9 +113,7 @@
         (
             "https://example.com",
             b"""<form><input type="text" name="a" /></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com?a=",
                 "GET",
@@ -143,9 +125,7 @@
         (
             "https://example.com",
             b"""<form></form>""",
-            (("a", "b"), ("a", "c")),
-            None,
-            None,
+            {"data": (("a", "b"), ("a", "c"))},
             Request(
                 "https://example.com?a=b&a=c",
                 "GET",
@@ -158,9 +138,7 @@
         (
             "https://example.com",
             b"""<form><input type="submit" name="a" value="b" /></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -172,9 +150,7 @@
         (
             "https://example.com",
             b"""<form><input type="submit" name="a" value="b" /></form>""",
-            None,
-            False,
-            None,
+            {"click": False},
             Request(
                 "https://example.com",
                 "GET",
@@ -186,9 +162,7 @@
         (
             "https://example.com",
             b"""<form><input type="submit" name="a" value="b" /></form>""",
-            None,
-            True,
-            None,
+            {"click": True},
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -201,9 +175,7 @@
         (
             "https://example.com",
             b"""<form></form>""",
-            None,
-            True,
-            None,
+            {"click": True},
             ValueError,
         ),
         # If there are 2 or more submit buttons, the first one is used by
@@ -212,9 +184,7 @@
             "https://example.com",
             b"""<form><input type="submit" name="a" value="b" />
             <input type="submit" name="a" value="c" /></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -227,9 +197,7 @@
             "https://example.com",
             b"""<form><input type="submit" name="a" value="b" />
             <input type="submit" name="a" value="c" /></form>""",
-            None,
-            './/*[@value="c"]',
-            None,
+            {"click": './/*[@value="c"]'},
             Request(
                 "https://example.com?a=c",
                 "GET",
@@ -243,9 +211,7 @@
             (
                 "https://example.com",
                 f"""<form enctype="{enctype}"></form>""".encode(),
-                None,
-                None,
-                None,
+                {},
                 Request(
                     "https://example.com",
                     "GET",
@@ -265,9 +231,7 @@
             (
                 "https://example.com",
                 f"""<form enctype="{enctype}"></form>""".encode(),
-                None,
-                None,
-                None,
+                {},
                 NotImplementedError,
             )
             for enctype in ("multipart/form-data",)
@@ -278,9 +242,7 @@
             "https://example.com",
             b"""<form enctype="multipart/form-data"><input type="submit"
             formenctype="application/x-www-form-urlencoded" /></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com",
                 "GET",
@@ -292,9 +254,7 @@
             "https://example.com",
             b"""<form enctype="multipart/form-data"><input type="submit"
             formenctype="foo" /></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com",
                 "GET",
@@ -306,19 +266,29 @@
             "https://example.com",
             b"""<form enctype="application/x-www-form-urlencoded"><input type="submit"
             formenctype="multipart/form-data" /></form>""",
-            None,
-            None,
-            None,
+            {},
             NotImplementedError,
         ),
+        # enctype may be overridden, in which case it raises ValueError for
+        # both unknown and unsupported values.
+        (
+            "https://example.com",
+            b"""<form></form>""",
+            {"enctype": "multipart/form-data"},
+            ValueError,
+        ),
+        (
+            "https://example.com",
+            b"""<form></form>""",
+            {"enctype": "a"},
+            ValueError,
+        ),
         # Only submit buttons are detected as such.
         *(
             (
                 "https://example.com",
                 f"""<form>{button}<button name="c" value="d" /></form>""".encode(),
-                None,
-                None,
-                None,
+                {},
                 Request(
                     "https://example.com?a=b",
                     "GET",
@@ -338,9 +308,7 @@
             (
                 "https://example.com",
                 f"""<form>{button}<button name="c" value="d" /></form>""".encode(),
-                None,
-                None,
-                None,
+                {},
                 Request(
                     f"https://example.com?{query}",
                     "GET",
@@ -365,9 +333,7 @@
         (
             "https://example.com",
             b"""<form action="a"></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com/a",
                 "GET",
@@ -379,9 +345,7 @@
         (
             "https://example.com",
             b"""<form action="a"><button type="submit" formaction="b" /></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com/b",
                 "GET",
@@ -393,9 +357,7 @@
         (
             "https://example.com",
             b"""<form action=" a "></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com/a",
                 "GET",
@@ -407,9 +369,7 @@
         (
             "https://example.com",
             b"""<form method="get"></form>""",
-            {"a": "b"},
-            None,
-            None,
+            {"data": {"a": "b"}},
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -420,9 +380,7 @@
         (
             "https://example.com",
             b"""<form method="post"></form>""",
-            {"a": "b"},
-            None,
-            None,
+            {"data": {"a": "b"}},
             Request(
                 "https://example.com",
                 "POST",
@@ -434,9 +392,7 @@
         (
             "https://example.com",
             b"""<form method="post"><button type="submit" formmethod="get" /></form>""",
-            {"a": "b"},
-            None,
-            None,
+            {"data": {"a": "b"}},
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -447,9 +403,7 @@
         (
             "https://example.com",
             b"""<form method="get"><button formmethod="post" /></form>""",
-            {"a": "b"},
-            None,
-            None,
+            {"data": {"a": "b"}},
             Request(
                 "https://example.com",
                 "POST",
@@ -463,25 +417,19 @@
         (
             "https://example.com",
             b"""<form method="dialog"></form>""",
-            None,
-            None,
-            None,
+            {},
             NotImplementedError,
         ),
         (
             "https://example.com",
             b"""<form><button formmethod="dialog" /></form>""",
-            None,
-            None,
-            None,
+            {},
             NotImplementedError,
         ),
         (
             "https://example.com",
             b"""<form method="dialog"><button formmethod="get" /></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com",
                 "GET",
@@ -492,9 +440,7 @@
         (
             "https://example.com",
             b"""<form method="dialog"><button formmethod="a" /></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com",
                 "GET",
@@ -506,9 +452,7 @@
         (
             "https://example.com",
             b"""<form method="a"></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com",
                 "GET",
@@ -519,9 +463,7 @@
         (
             "https://example.com",
             b"""<form><button formmethod="a" /></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com",
                 "GET",
@@ -532,9 +474,7 @@
         (
             "https://example.com",
             b"""<form method="post"><button formmethod="a" /></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com",
                 "GET",
@@ -548,9 +488,7 @@
         (
             "https://example.com",
             b"""<form method="a"><button formmethod="b" /></form>""",
-            None,
-            None,
-            "get",
+            {"method": "get"},
             Request(
                 "https://example.com",
                 "GET",
@@ -564,9 +502,7 @@
         (
             "https://example.com",
             b"""<form method="a"><button formmethod="b" /></form>""",
-            None,
-            None,
-            "dialog",
+            {"method": "dialog"},
             ValueError,
         ),
         # If users pass an unknown method, ValueError is raised since users
@@ -574,9 +510,7 @@
         (
             "https://example.com",
             b"""<form method="a"><button formmethod="b" /></form>""",
-            None,
-            None,
-            "c",
+            {"method": "c"},
             ValueError,
         ),
         # User data as an iterable of key-value tuples gets merged with button
@@ -584,9 +518,7 @@
         (
             "https://example.com",
             b"""<form><button name="d" value="e"></form>""",
-            (("a", "b"), ("a", "c")),
-            None,
-            None,
+            {"data": (("a", "b"), ("a", "c"))},
             Request(
                 "https://example.com?a=b&a=c&d=e",
                 "GET",
@@ -598,9 +530,7 @@
         pytest.param(
             "https://example.com",
             b"""<form><input disabled name="a" value="b"></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com",
                 "GET",
@@ -613,9 +543,7 @@
             "https://example.com",
             b"""<form><fieldset disabled><input name="a" value="b">
             </fieldset></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com",
                 "GET",
@@ -628,9 +556,7 @@
         (
             "https://example.com",
             b"""<form><select name="a"><option value="b">B</option></select></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -642,9 +568,7 @@
         (
             "https://example.com",
             b"""<form><select name="a"><option>B</option></select></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com?a=B",
                 "GET",
@@ -658,9 +582,7 @@
             "https://example.com",
             b"""<form><select name="a"><option value="b">B</option>
             <option value="c">C</option></select></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com?a=b",
                 "GET",
@@ -673,9 +595,7 @@
             "https://example.com",
             b"""<form><select name="a"><option value="b">B</option>
             <option selected value="c">C</option></select></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com?a=c",
                 "GET",
@@ -689,9 +609,7 @@
             "https://example.com",
             b"""<form><select multiple name="a"><option value="b">B</option>
             <option value="c">C</option></select></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com",
                 "GET",
@@ -705,9 +623,7 @@
             "https://example.com",
             b"""<form><select multiple name="a"><option value="b">B</option>
             <option value="c" selected>C</option></select></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com?a=c",
                 "GET",
@@ -721,9 +637,7 @@
             "https://example.com",
             b"""<form><select multiple name="a"><option value="b" selected>B</option>
             <option value="c" selected>C</option></select></form>""",
-            None,
-            None,
-            None,
+            {},
             Request(
                 "https://example.com?a=b&a=c",
                 "GET",
@@ -735,9 +649,7 @@
         (
             "https://example.com",
             b"""<form><input name="a+ /" value="b+ /"></form>""",
-            {"c+ /": "d+ /"},
-            None,
-            None,
+            {"data": {"c+ /": "d+ /"}},
             Request(
                 "https://example.com?a%2B+%2F=b%2B+%2F&c%2B+%2F=d%2B+%2F",
                 "GET",
@@ -748,9 +660,7 @@
         (
             "https://example.com",
             b"""<form method="post"><input name="a+ /" value="b+ /"></form>""",
-            {"c+ /": "d+ /"},
-            None,
-            None,
+            {"data": {"c+ /": "d+ /"}},
             Request(
                 "https://example.com",
                 "POST",
@@ -764,9 +674,7 @@
         (
             "https://example.com",
             b"""<form enctype="text/plain"><input name="a+ /" value="b+ /"></form>""",
-            {"c+ /": "d+ /"},
-            None,
-            None,
+            {"data": {"c+ /": "d+ /"}},
             Request(
                 "https://example.com?a%2B+%2F=b%2B+%2F&c%2B+%2F=d%2B+%2F",
                 "GET",
@@ -778,9 +686,7 @@
             "https://example.com",
             b"""<form enctype="text/plain" method="post">
             <input name="a+ /" value="b+ /"></form>""",
-            {"c+ /": "d+ /"},
-            None,
-            None,
+            {"data": {"c+ /": "d+ /"}},
             Request(
                 "https://example.com",
                 "POST",
@@ -793,9 +699,7 @@
             "https://example.com",
             b"""<form enctype="TeXt/PlAiN" method="post">
             <input name="a+ /" value="b+ /"></form>""",
-            {"c+ /": "d+ /"},
-            None,
-            None,
+            {"data": {"c+ /": "d+ /"}},
             Request(
                 "https://example.com",
                 "POST",
@@ -807,24 +711,23 @@
             "https://example.com",
             b"""<form enctype="application/x-www-form-urlencoded"><input type="submit"
             formenctype="MuLtIpArT/fOrM-dAtA" /></form>""",
-            None,
-            None,
-            None,
+            {},
             NotImplementedError,
         ),
     ),
 )
-def test_form2request(base_url, html, data, click, method, expected):
+def test_form2request(base_url, html, kwargs, expected):
     root = fromstring(html, base_url=base_url)
     form = root.xpath("//form")[0]
+    click = kwargs.pop("click", None)
     if isinstance(click, str):
         click = form.xpath(click)[0]
     if isinstance(expected, Request):
-        actual = form2request(form, data, click=click, method=method)
+        actual = form2request(form, click=click, **kwargs)
         assert expected == actual
     else:
         with pytest.raises(expected):
-            form2request(form, data, click=click, method=method)
+            form2request(form, click=click, **kwargs)
 
 
 def test_form2request_no_base_url():

From e54ae782641598dd419d9f4404f2cf101aa87879 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Wed, 3 Jul 2024 11:34:23 +0200
Subject: [PATCH 21/28] Shorten attribute override docs

---
 docs/usage.rst | 87 ++++++++------------------------------------------
 1 file changed, 13 insertions(+), 74 deletions(-)

diff --git a/docs/usage.rst b/docs/usage.rst
index 381893c..f453173 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -19,8 +19,7 @@ submission request data <request>`:
 Request(url='https://example.com?foo=bar', method='GET', headers=[], body=b'')
 
 :func:`~form2request.form2request` supports :ref:`user-defined form data
-<data>` and :ref:`choosing a specific form submission button (or none)
-<click>`.
+<data>` and :ref:`choosing a specific submit button (or none) <click>`.
 
 
 .. _form:
@@ -88,7 +87,7 @@ user-defined data:
 >>> selector = Selector(body=html, base_url="https://example.com")
 >>> form = selector.css("form")
 
-Use the second parameter of :func:`~form2request.form2request`,  to define
+Use the ``data`` parameter of :func:`~form2request.form2request`,  to define
 the corresponding data:
 
 >>> form2request(form, {"foo": "bar"})
@@ -107,6 +106,8 @@ iterable of key-value tuples:
 >>> form2request(form, (("foo", "bar"), ("foo", "baz")))
 Request(url='https://example.com?foo=bar&foo=baz', method='GET', headers=[], body=b'')
 
+.. _remove-data:
+
 Sometimes, you might want to prevent a value from a field from being included
 in the generated request data. For example, because the field is removed or
 disabled through JavaScript, or because the field or a parent element has the
@@ -122,85 +123,24 @@ To remove a field value, set it to ``None``:
 Request(url='https://example.com', method='GET', headers=[], body=b'')
 
 
-Handling the form method
+Handling form attributes
 ========================
 
-By default, if a form uses the unsupported ``dialog`` method_:
-
-.. _method: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form#method
-
->>> html = b"""<form method="dialog"></form>"""
->>> selector = Selector(body=html, base_url="https://example.com")
->>> form = selector.css("form")
-
-A :exc:`NotImplementedError` exception is raised:
-
->>> form2request(form)
-Traceback (most recent call last):
-...
-NotImplementedError: Found unsupported form method 'DIALOG'.
-
-If a form uses an unknown method:
-
->>> html = b"""<form method="foo"></form>"""
->>> selector = Selector(body=html, base_url="https://example.com")
->>> form = selector.css("form")
-
-``GET`` is used instead, as a web browser would do:
-
->>> form2request(form)
-Request(url='https://example.com', method='GET', headers=[], body=b'')
-
-If a website uses JavaScript to set or modify the method, use the ``method``
-parameter to set the right value:
-
->>> form2request(form, method="GET")
-Request(url='https://example.com', method='GET', headers=[], body=b'')
-
-
-Handling the form enctype
-=========================
-
-By default, if a form uses the unsupported ``multipart/form-data`` enctype_:
+You can override the method_ and enctype_ attributes of a form:
 
 .. _enctype: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form#enctype
+.. _method: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form#method
 
->>> html = b"""<form enctype="multipart/form-data"></form>"""
->>> selector = Selector(body=html, base_url="https://example.com")
->>> form = selector.css("form")
-
-A :exc:`NotImplementedError` exception is raised:
-
->>> form2request(form)
-Traceback (most recent call last):
-...
-NotImplementedError: Found unsupported form enctype 'multipart/form-data'.
-
-If a form uses an unknown enctype:
-
->>> html = b"""<form enctype="foo" method="post"></form>"""
->>> selector = Selector(body=html, base_url="https://example.com")
->>> form = selector.css("form")
-
-``application/x-www-form-urlencoded`` is used instead, as a web browser would
-do:
-
->>> form2request(form)
-Request(url='https://example.com', method='POST', headers=[('Content-Type', 'application/x-www-form-urlencoded')], body=b'')
-
-If a website uses JavaScript to set or modify the enctype, use the ``enctype``
-parameter to set the right value:
-
->>> form2request(form, enctype="application/x-www-form-urlencoded")
-Request(url='https://example.com', method='POST', headers=[('Content-Type', 'application/x-www-form-urlencoded')], body=b'')
+>>> form2request(form, method="POST", enctype="text/plain")
+Request(url='https://example.com', method='POST', headers=[('Content-Type', 'text/plain')], body=b'foo=bar')
 
 
 .. _click:
 
-Configuring form submission
-===========================
+Choosing a submit button
+========================
 
-When an HTML form is submitted, the way the submission is triggered has an
+When an HTML form is submitted, the way form submission is triggered has an
 impact on the resulting request data.
 
 Given a submit button with ``name`` and ``value`` attributes:
@@ -229,8 +169,7 @@ You may also find forms with more than one submit button:
 >>> selector = Selector(body=html, base_url="https://example.com")
 >>> form = selector.css("form")
 
-By default, :func:`~form2request.form2request` clicks the first submission
-element:
+By default, :func:`~form2request.form2request` clicks the first submit button:
 
 >>> form2request(form)
 Request(url='https://example.com?foo=bar', method='GET', headers=[], body=b'')

From 6974d95304b0311c796879e8bbc33998219920f8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Wed, 3 Jul 2024 11:42:54 +0200
Subject: [PATCH 22/28] Minor refactoring

---
 form2request/_base.py | 80 ++++++++++++++++++++++---------------------
 1 file changed, 41 insertions(+), 39 deletions(-)

diff --git a/form2request/_base.py b/form2request/_base.py
index 4ef4129..39666e6 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -16,6 +16,38 @@
 FormdataType = Optional[Union[Dict[str, FormdataVType], Iterable[FormdataKVType]]]
 
 
+def _parsel_to_lxml(element: HtmlElement | Selector | SelectorList) -> HtmlElement:
+    if isinstance(element, SelectorList):
+        element = element[0]
+    if isinstance(element, Selector):
+        element = element.root
+    return element
+
+
+def _enctype(
+    form: FormElement, click_element: HtmlElement | None, enctype: None | str
+) -> str:
+    if enctype:
+        enctype = enctype.lower()
+        if enctype not in {"application/x-www-form-urlencoded", "text/plain"}:
+            raise ValueError(
+                f"The specified form enctype ({enctype!r}) is not supported."
+            )
+    elif click_element is not None and (
+        enctype := (click_element.get("formenctype") or "").lower()
+    ):
+        if enctype == "multipart/form-data":
+            raise NotImplementedError(
+                f"{click_element} has formenctype set to {enctype!r}, which "
+                f"form2request does not currently support."
+            )
+    elif (
+        enctype := (form.get("enctype") or "").lower()
+    ) and enctype == "multipart/form-data":
+        raise NotImplementedError(f"Found unsupported form enctype {enctype!r}.")
+    return enctype
+
+
 def _url(form: FormElement, click_element: HtmlElement | None) -> str:
     if form.base_url is None:
         raise ValueError(f"{form} has no base_url set.")
@@ -59,10 +91,6 @@ def _method(
     return method
 
 
-class _NoClickables(ValueError):
-    pass
-
-
 def _click_element(
     form: FormElement, click: None | bool | HtmlElement
 ) -> HtmlElement | None:
@@ -78,15 +106,15 @@ def _click_element(
         )
         if not clickables:
             if click:
-                raise _NoClickables
+                raise ValueError(
+                    f"No clickable elements found in form {form}. Set click=False or "
+                    f"point it to the element to be clicked."
+                )
             else:
                 return None
         click = clickables[0]
     else:
-        if isinstance(click, SelectorList):
-            click = click[0]
-        if isinstance(click, Selector):
-            click = click.root
+        click = _parsel_to_lxml(click)
     return click
 
 
@@ -177,44 +205,18 @@ def form2request(
         On forms with multiple submission elements, specifying the right
         submission element here may be necessary.
     """
-    if isinstance(form, SelectorList):
-        form = form[0]
-    if isinstance(form, Selector):
-        form = form.root
-    try:
-        click_element = _click_element(form, click)
-    except _NoClickables:
-        raise ValueError(
-            f"No clickable elements found in form {form}. Set click=False or "
-            f"point it to the element to be clicked."
-        ) from None
-    if enctype:
-        enctype = enctype.lower()
-        if enctype not in {"application/x-www-form-urlencoded", "text/plain"}:
-            raise ValueError(
-                f"The specified form enctype ({enctype!r}) is not supported."
-            )
-    elif click_element is not None and (
-        enctype := (click_element.get("formenctype") or "").lower()
-    ):
-        if enctype == "multipart/form-data":
-            raise NotImplementedError(
-                f"{click_element} has formenctype set to {enctype!r}, which "
-                f"form2request does not currently support."
-            )
-    elif (
-        enctype := (form.get("enctype") or "").lower()
-    ) and enctype == "multipart/form-data":
-        raise NotImplementedError(f"Found unsupported form enctype {enctype!r}.")
+    form = _parsel_to_lxml(form)
+    click_element = _click_element(form, click)
     url = _url(form, click_element)
     method = _method(form, click_element, method)
-    data = _data(form, data, click_element)
     headers = []
     body = ""
+    data = _data(form, data, click_element)
     if method == "GET":
         url = urlunsplit(urlsplit(url)._replace(query=urlencode(data, doseq=True)))
     else:
         assert method == "POST"
+        enctype = _enctype(form, click_element, enctype)
         if enctype == "text/plain":
             headers = [("Content-Type", "text/plain")]
             body = "\n".join(f"{k}={v}" for k, v in data)

From ba5da928452cb903accd8ce80ea60a92f07d9e75 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Wed, 3 Jul 2024 11:57:12 +0200
Subject: [PATCH 23/28] Update exception messages and test expectations after
 adding multipart/form-data support for the GET method

---
 form2request/_base.py | 11 ++++++---
 tests/test_main.py    | 55 ++++++++++++++++++++++++++-----------------
 2 files changed, 41 insertions(+), 25 deletions(-)

diff --git a/form2request/_base.py b/form2request/_base.py
index 39666e6..9299e71 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -31,7 +31,8 @@ def _enctype(
         enctype = enctype.lower()
         if enctype not in {"application/x-www-form-urlencoded", "text/plain"}:
             raise ValueError(
-                f"The specified form enctype ({enctype!r}) is not supported."
+                f"The specified form enctype ({enctype!r}) is not supported "
+                f"for forms with the POST method."
             )
     elif click_element is not None and (
         enctype := (click_element.get("formenctype") or "").lower()
@@ -39,12 +40,16 @@ def _enctype(
         if enctype == "multipart/form-data":
             raise NotImplementedError(
                 f"{click_element} has formenctype set to {enctype!r}, which "
-                f"form2request does not currently support."
+                f"form2request does not currently support for forms with the "
+                f"POST method."
             )
     elif (
         enctype := (form.get("enctype") or "").lower()
     ) and enctype == "multipart/form-data":
-        raise NotImplementedError(f"Found unsupported form enctype {enctype!r}.")
+        raise NotImplementedError(
+            f"{form} has enctype set to {enctype!r}, which form2request does "
+            f"not currently support for forms with the POST method."
+        )
     return enctype
 
 
diff --git a/tests/test_main.py b/tests/test_main.py
index e5bda82..e968502 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -226,60 +226,71 @@
                 "foo",
             )
         ),
-        # multipart/form-data raises a NotImplementedError exception.
-        *(
-            (
-                "https://example.com",
-                f"""<form enctype="{enctype}"></form>""".encode(),
-                {},
-                NotImplementedError,
-            )
-            for enctype in ("multipart/form-data",)
+        # multipart/form-data raises a NotImplementedError exception when the
+        # method is POST.
+        (
+            "https://example.com",
+            b"""<form enctype="multipart/form-data" method="post"></form>""",
+            {},
+            NotImplementedError,
+        ),
+        # multipart/form-data does work when method is GET (default).
+        (
+            "https://example.com",
+            b"""<form enctype="multipart/form-data">
+            <input name="a" value="b" /></form>""",
+            {},
+            Request(
+                "https://example.com?a=b",
+                "GET",
+                [],
+                b"",
+            ),
         ),
         # The formenctype from the submit button is taken into account, even if
         # it has an unknown value.
         (
             "https://example.com",
-            b"""<form enctype="multipart/form-data"><input type="submit"
+            b"""<form enctype="multipart/form-data" method="post"><input type="submit"
             formenctype="application/x-www-form-urlencoded" /></form>""",
             {},
             Request(
                 "https://example.com",
-                "GET",
-                [],
+                "POST",
+                [("Content-Type", "application/x-www-form-urlencoded")],
                 b"",
             ),
         ),
         (
             "https://example.com",
-            b"""<form enctype="multipart/form-data"><input type="submit"
+            b"""<form enctype="multipart/form-data" method="post"><input type="submit"
             formenctype="foo" /></form>""",
             {},
             Request(
                 "https://example.com",
-                "GET",
-                [],
+                "POST",
+                [("Content-Type", "application/x-www-form-urlencoded")],
                 b"",
             ),
         ),
         (
             "https://example.com",
-            b"""<form enctype="application/x-www-form-urlencoded"><input type="submit"
-            formenctype="multipart/form-data" /></form>""",
+            b"""<form enctype="application/x-www-form-urlencoded" method="post">
+            <input type="submit" formenctype="multipart/form-data" /></form>""",
             {},
             NotImplementedError,
         ),
         # enctype may be overridden, in which case it raises ValueError for
-        # both unknown and unsupported values.
+        # both unknown and unsupported values when method is POST.
         (
             "https://example.com",
-            b"""<form></form>""",
+            b"""<form method="post"></form>""",
             {"enctype": "multipart/form-data"},
             ValueError,
         ),
         (
             "https://example.com",
-            b"""<form></form>""",
+            b"""<form method="post"></form>""",
             {"enctype": "a"},
             ValueError,
         ),
@@ -709,8 +720,8 @@
         ),
         (
             "https://example.com",
-            b"""<form enctype="application/x-www-form-urlencoded"><input type="submit"
-            formenctype="MuLtIpArT/fOrM-dAtA" /></form>""",
+            b"""<form enctype="application/x-www-form-urlencoded" method="post">
+            <input type="submit" formenctype="MuLtIpArT/fOrM-dAtA" /></form>""",
             {},
             NotImplementedError,
         ),

From 4d6e25dfaec46f513a296d0a18eca6abacb637a7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Wed, 3 Jul 2024 12:10:56 +0200
Subject: [PATCH 24/28] Cover method and enctype in the docstring

---
 form2request/_base.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/form2request/_base.py b/form2request/_base.py
index 9299e71..6d30995 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -209,6 +209,8 @@ def form2request(
 
         On forms with multiple submission elements, specifying the right
         submission element here may be necessary.
+
+    *method* and *enctype* may be used to override matching form attributes.
     """
     form = _parsel_to_lxml(form)
     click_element = _click_element(form, click)

From f9ec401e05c34c69aeddd8556ac1d724aa2c045b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Wed, 3 Jul 2024 12:15:52 +0200
Subject: [PATCH 25/28] Improve the docstring

---
 form2request/_base.py | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/form2request/_base.py b/form2request/_base.py
index 6d30995..c7c7000 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -186,7 +186,8 @@ def form2request(
     instance of :class:`lxml.html.FormElement`.
 
     *data* should be either a dictionary of a list of 2-item tuples indicating
-    the key-value pairs to include in the request as submission data.
+    the key-value pairs to include in the request as submission data. Keys with
+    ``None`` as value exclude matching form fields.
 
     *click* can be any of:
 
@@ -204,11 +205,11 @@ def form2request(
 
     -   ``False`` builds a request for a non-click-based form submission.
 
-    -   A submission element of *form*, to build a request for a form submission
-        based on the clicking of that specific element.
+    -   A submit button of *form*, to build a request for a form submission
+        based on the clicking of that button.
 
-        On forms with multiple submission elements, specifying the right
-        submission element here may be necessary.
+        On forms with multiple submit buttons, specifying the right button here
+        may be necessary.
 
     *method* and *enctype* may be used to override matching form attributes.
     """

From 864a7e35bf2d932e46509893b5e6f2abe789d546 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Fri, 12 Jul 2024 09:17:38 +0200
Subject: [PATCH 26/28] Minor doc improvements

---
 docs/usage.rst        | 75 ++++++++++++++++++++++++++-----------------
 form2request/_base.py |  2 +-
 2 files changed, 47 insertions(+), 30 deletions(-)

diff --git a/docs/usage.rst b/docs/usage.rst
index f453173..08abe3a 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -11,15 +11,29 @@ Usage
 >>> selector = Selector(body=html, base_url="https://example.com")
 >>> form = selector.css("form")
 
-You can use :func:`~form2request.form2request` to generate :ref:`form
-submission request data <request>`:
+You can use :func:`~form2request.form2request` to generate form submission
+request data:
 
 >>> from form2request import form2request
->>> form2request(form)
+>>> req = form2request(form)
+>>> req
 Request(url='https://example.com?foo=bar', method='GET', headers=[], body=b'')
 
+:func:`~form2request.form2request` does not make requests, but you can use its
+output to build requests with any HTTP client software, e.g. with the requests_
+library:
+
+.. _requests: https://requests.readthedocs.io/en/latest/
+
+.. _requests-example:
+
+>>> import requests
+>>> requests.request(req.method, req.url, headers=req.headers, data=req.body)  # doctest: +SKIP
+<Response [200]>
+
 :func:`~form2request.form2request` supports :ref:`user-defined form data
-<data>` and :ref:`choosing a specific submit button (or none) <click>`.
+<data>`, :ref:`choosing a specific submit button (or none) <click>`, and
+:ref:`overriding form attributes <override>`.
 
 
 .. _form:
@@ -54,8 +68,8 @@ lxml’s :meth:`HtmlElement.xpath <lxml.html.HtmlElement.xpath>`:
     …``, use ``//form[@id="foo"]``.
 
     When using :meth:`Selector.css <parsel.selector.Selector.css>`, ``#<id>``
-    (e.g. ``#foo``) finds by ``id``, and ``[<attribute>=<value>]`` (e.g.
-    ``[name=foo]``) finds by any other attribute.
+    (e.g. ``#foo``) finds by ``id``, and ``[<attribute>="<value>"]`` (e.g.
+    ``[name=foo]`` or ``[name="foo bar"]``) finds by any other attribute.
 
 -   To find a form by index, by order of appearance in the HTML code, use
     ``(//form)[n]``, where ``n`` is a 1-based index. For example, to find the
@@ -123,18 +137,6 @@ To remove a field value, set it to ``None``:
 Request(url='https://example.com', method='GET', headers=[], body=b'')
 
 
-Handling form attributes
-========================
-
-You can override the method_ and enctype_ attributes of a form:
-
-.. _enctype: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form#enctype
-.. _method: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form#method
-
->>> form2request(form, method="POST", enctype="text/plain")
-Request(url='https://example.com', method='POST', headers=[('Content-Type', 'text/plain')], body=b'foo=bar')
-
-
 .. _click:
 
 Choosing a submit button
@@ -181,25 +183,40 @@ To change that, set ``click`` to the element that should be clicked:
 Request(url='https://example.com?foo=baz', method='GET', headers=[], body=b'')
 
 
+.. _override:
+
+Overriding form attributes
+==========================
+
+You can override the method_ and enctype_ attributes of a form:
+
+.. _enctype: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form#enctype
+.. _method: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form#method
+
+>>> form2request(form, method="POST", enctype="text/plain")
+Request(url='https://example.com', method='POST', headers=[('Content-Type', 'text/plain')], body=b'foo=bar')
+
+
 .. _request:
 
 Using request data
 ==================
 
-:class:`~form2request.Request` is a simple data container that you can use to
-build an actual request object:
-
->>> request_data = form2request(form)
+The output of :func:`~form2request.form2request`,
+:class:`~form2request.Request`, is a simple request data container:
 
-Here are some examples for popular Python libraries and frameworks:
+>>> req = form2request(form)
+>>> req
+Request(url='https://example.com?foo=bar', method='GET', headers=[], body=b'')
 
->>> from requests import Request
->>> request = Request(request_data.method, request_data.url, headers=request_data.headers, data=request_data.body)
->>> request
-<Request [GET]>
+While :func:`~form2request.form2request` does not make requests, you can use
+its output request data to build an actual request with any HTTP client
+software, like the requests_ library (see an example :ref:`above
+<requests-example>`) or the :doc:`Scrapy <scrapy:index>` web scraping
+framework:
 
+.. _Scrapy: https://docs.scrapy.org/en/latest/
 
 >>> from scrapy import Request
->>> request = Request(request_data.url, method=request_data.method, headers=request_data.headers, body=request_data.body)
->>> request
+>>> Request(req.url, method=req.method, headers=req.headers, body=req.body)
 <GET https://example.com?foo=bar>
diff --git a/form2request/_base.py b/form2request/_base.py
index c7c7000..11228ac 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -179,7 +179,7 @@ def form2request(
     method: None | str = None,
     enctype: None | str = None,
 ) -> Request:
-    """Return a form submission request.
+    """Return request data for an HTML form submission.
 
     *form* must be an instance of :class:`parsel.selector.Selector` or
     :class:`parsel.selector.SelectorList` that points to an HTML form, or an

From aa5ec68ac7b7fadaf7d532ebf93de4b33fb96ece Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Fri, 12 Jul 2024 09:18:13 +0200
Subject: [PATCH 27/28] =?UTF-8?q?Fix=20typo=20(of=20=E2=86=92=20or)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 form2request/_base.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/form2request/_base.py b/form2request/_base.py
index 11228ac..ceeb8f7 100644
--- a/form2request/_base.py
+++ b/form2request/_base.py
@@ -185,7 +185,7 @@ def form2request(
     :class:`parsel.selector.SelectorList` that points to an HTML form, or an
     instance of :class:`lxml.html.FormElement`.
 
-    *data* should be either a dictionary of a list of 2-item tuples indicating
+    *data* should be either a dictionary or a list of 2-item tuples indicating
     the key-value pairs to include in the request as submission data. Keys with
     ``None`` as value exclude matching form fields.
 

From 689d7eea068d7aae5bc200d5f0e674d07565e65d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= <adrian@chaves.io>
Date: Fri, 12 Jul 2024 09:20:56 +0200
Subject: [PATCH 28/28] Clarify a test scenario

---
 tests/test_main.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/tests/test_main.py b/tests/test_main.py
index e968502..82c9788 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -459,7 +459,7 @@
                 b"",
             ),
         ),
-        # Unknown methods are replaced with GET, and can override.
+        # Unknown methods are replaced with GET.
         (
             "https://example.com",
             b"""<form method="a"></form>""",
@@ -482,6 +482,9 @@
                 b"",
             ),
         ),
+        # If an unknown method is defined in a submit button and the parent
+        # form has a valid method, the submit button method (GET) still takes
+        # precedence.
         (
             "https://example.com",
             b"""<form method="post"><button formmethod="a" /></form>""",
@@ -493,7 +496,7 @@
                 b"",
             ),
         ),
-        # Users can override the method value, to workaround scenarios where
+        # Users can override the method value, to work around scenarios where
         # HTML forms have an unsupported method but a supported one is set
         # through JavaScript.
         (