diff --git a/.flake8 b/.flake8
index 8483785..571a5a6 100644
--- a/.flake8
+++ b/.flake8
@@ -1,31 +1,29 @@
 # -*- mode: conf; -*-
 [flake8]
 ignore =
     # continuation line under-indented for hanging indent
     E121
     # continuation line missing indentation or outdented
     E122
     # continuation line with same indent as next logical line
     E125
     # visually indented line with same indent as next logical line
     E129
     # whitespace after '{' or '['
     E201
     # whitespace before '}' or ']'
     E202
     # missing whitespace after ','
     E231
-    # at least two spaces before inline comment
-    E261
     # expected 2 blank lines
     E302
     # expected 2 blank lines after class or function definition
     E305
     # expected 1 blank line before a nested definition
     E306
     # line too long
     E501
     # line break before binary operator
     W503
     # line break after binary operator
     W504
diff --git a/app.py b/app.py
index 719c4e4..5fc64c3 100644
--- a/app.py
+++ b/app.py
@@ -1,925 +1,925 @@
 import babel
 import collections
 import copy
 import decorator
 import flask
 import jinja2
 import json
 import mwapi
 import mwoauth
 import os
 import random
 import re
 import requests_oauthlib
 import string
 import toolforge
 import yaml
 
 from flask_utils import OrderedFlask, TagOrderedMultiDict, TagImmutableOrderedMultiDict
 from formatters import I18nFormatter
 from language_names import autonym
 from matching import match_template_to_lexeme_data, match_lexeme_forms_to_template, match_template_entity_to_lexeme_entity
 from parse_tpsv import parse_lexemes
 from templates import templates
 from translations import translations
 
 app = OrderedFlask(__name__)
 app.session_interface.serializer.register(TagOrderedMultiDict, index=0)
 app.session_interface.serializer.register(TagImmutableOrderedMultiDict, index=0)
 
 user_agent = toolforge.set_user_agent('lexeme-forms', email='mail@lucaswerkmeister.de')
 
 __dir__ = os.path.dirname(__file__)
 try:
     with open(os.path.join(__dir__, 'config.yaml')) as config_file:
         app.config.update(yaml.safe_load(config_file))
         consumer_token = mwoauth.ConsumerToken(app.config['oauth']['consumer_key'], app.config['oauth']['consumer_secret'])
 except FileNotFoundError:
     print('config.yaml file not found, assuming local development setup')
     app.secret_key = 'fake'
 
 @decorator.decorator
 def enableCORS(func, *args, **kwargs):
     rv = func(*args, **kwargs)
     response = flask.make_response(rv)
     response.headers['Access-Control-Allow-Origin'] = '*'
     return response
 
 @app.after_request
 def denyFrame(response):
     """Disallow embedding the tool’s pages in other websites.
 
     If other websites can embed this tool’s pages, e. g. in <iframe>s,
     other tools hosted on tools.wmflabs.org can send arbitrary web
     requests from this tool’s context, bypassing the referrer-based
     CSRF protection.
     """
     response.headers['X-Frame-Options'] = 'deny'
     return response
 
 @app.template_filter()
 @jinja2.contextfilter
 def form2input(context, form, first=False, template_language_code=None, representation_language_code=None):
     (prefix, placeholder, suffix) = split_example(form)
     if 'lexeme_forms' in form and template_language_code != representation_language_code:
         placeholder = '/'.join(lexeme_form['representations'][template_language_code]['value']
                                for lexeme_form in form['lexeme_forms']
                                if template_language_code in lexeme_form['representations'])
     return (flask.Markup.escape(prefix) +
             flask.Markup(r'<input type="text" name="form_representation" placeholder="') +
             flask.Markup.escape(placeholder) +
             flask.Markup(r'"') +
             flask.Markup(r' pattern="[^/]+(?:/[^/]+)*"') +
             (flask.Markup(r' required') if not context['advanced'] else flask.Markup('')) +
             (flask.Markup(r' autofocus') if first else flask.Markup('')) +
             (flask.Markup(r' value="') + flask.Markup.escape(form['value']) + flask.Markup(r'"') if 'value' in form else flask.Markup('')) +
             flask.Markup(r' spellcheck="true"') +
             (flask.Markup(r' lang="') + flask.Markup.escape(representation_language_code) + flask.Markup(r'"') if representation_language_code != template_language_code else flask.Markup('')) +
             flask.Markup(r'>') +
             flask.Markup.escape(suffix))
 
 def split_example(form):
     example = form['example']
     match = re.match(r'^(.*)\[(.*)\](.*)$', example)
     if match:
         (prefix, placeholder, suffix) = match.groups()
         return (prefix, placeholder, suffix)
     else:
         raise Exception('Invalid template: missing [placeholder]: ' + example)
 
 @app.template_filter()
 def render_duplicates(duplicates, language_code, actionable, template_name=None, form_representations=[]):
     return flask.render_template(
         'duplicates.html',
         duplicates=duplicates,
         actionable=actionable,
         template_name=template_name,
         form_representations=form_representations,
     )
 
 @app.template_filter()
 def augment_description(description, forms_count, senses_count):
     if forms_count is None or senses_count is None:
         return description
     return message_with_kwargs(
         'description_with_forms_and_senses',
         description=description,
         forms=int(forms_count),
         senses=int(senses_count),
     )
 
 @app.template_global()
 def csrf_token():
     if '_csrf_token' not in flask.session:
         flask.session['_csrf_token'] = ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(64))
     return flask.session['_csrf_token']
 
 @app.template_global()
 def template_group(template):
     group = language_autonym_with_code(template['language_code'])
     if 'test' in template:
         group += ', test.wikidata.org'
     return group
 
 @app.template_filter()
 def user_link(user_name):
     return (flask.Markup(r'<a href="https://www.wikidata.org/wiki/User:') +
             flask.Markup.escape(user_name.replace(' ', '_')) +
             flask.Markup(r'">') +
             flask.Markup(r'<bdi>') +
             flask.Markup.escape(user_name) +
             flask.Markup(r'</bdi>') +
             flask.Markup(r'</a>'))
 
 @app.template_global()
 def render_oauth_username():
     identity = identify()
     if identity is None:
         return flask.Markup(r'')
     return (flask.Markup(r'<span class="navbar-text">Logged in as ') +
             user_link(identity['username']) +
             flask.Markup(r'</span>'))
 
 @app.template_global()
 def message(message_code, language_code=None):
     message, language = message_with_language(message_code, language_code)
     return message
 
 def message_with_language(message_code, language_code=None):
     if not language_code:
         language_code = flask.g.interface_language_code
     if language_code == 'bn-x-Q6747180':
         # Manbhumi reuses the standard Bengali messages
         language_code = 'bn'
     if message_code not in translations.get(language_code, {}):
         language_code = 'en'
     text = translations[language_code][message_code]
     return flask.Markup(text), language_code
 
 @app.template_global()
 def message_with_kwargs(message_code, **kwargs):
     template, language = message_with_language(message_code)
     if language == 'la':
-        language = 'en' # Latin is not in CLDR, English has same plural forms
+        language = 'en'  # Latin is not in CLDR, English has same plural forms
     return I18nFormatter(locale_identifier=language,
                          get_gender=get_gender).format(template, **kwargs)
 
 @app.template_filter()
 def text_direction(language_code):
     try:
-        locale = babel.Locale.parse(language_code.split('-')[0]) # the -x-Qid stuff is not understood by Babel
+        locale = babel.Locale.parse(language_code.split('-')[0])  # the -x-Qid stuff is not understood by Babel
     except babel.UnknownLocaleError:
         return 'auto'
     else:
         return locale.text_direction
 
 @app.template_filter()
 def term_span(term):
     return (flask.Markup(r'<span lang="') +
             flask.Markup.escape(term['language']) +
             flask.Markup(r'" dir="') +
             flask.Markup.escape(text_direction(term['language'])) +
             flask.Markup(r'">') +
             flask.Markup.escape(term['value']) +
             flask.Markup(r'</span>'))
 
 @app.template_filter()
 def language_autonym_with_code(language_code):
     code_zxx = (flask.Markup(r'<span lang=zxx>') +
                 flask.Markup.escape(language_code) +
                 flask.Markup(r'</span>'))
     language_autonym = autonym(language_code)
     if language_autonym is None:
         return code_zxx
     return (flask.Markup(r'<span lang="') +
             flask.Markup.escape(language_code) +
             flask.Markup(r'" dir="') +
             flask.Markup.escape(text_direction(language_code)) +
             flask.Markup(r'">') +
             flask.Markup.escape(language_autonym) +
             flask.Markup(r' (') +
             code_zxx +
             flask.Markup(r')</span>'))
 
 @app.route('/')
 def index():
     return flask.render_template(
         'index.html',
         templates=templates,
         can_use_bulk_mode=can_use_bulk_mode(),
     )
 
 @app.route('/template/<template_name>/', methods=['GET', 'POST'])
 def process_template(template_name):
     return process_template_advanced(template_name=template_name, advanced=False)
 
 @app.route('/template/<template_name>/advanced/', methods=['GET', 'POST'])
 def process_template_advanced(template_name, advanced=True):
     response = if_no_such_template_redirect(template_name)
     if response:
         return response
 
     response = if_needs_oauth_redirect()
     if response:
         return response
 
     template = templates[template_name]
     flask.g.interface_language_code = template['language_code']
     form_data = flask.request.form
 
     if (flask.request.method == 'POST' and
         form_data.get('_advanced_mode', 'None') == str(advanced)):
         response = if_has_duplicates_redirect(template, advanced, form_data)
         if response:
             return response
 
         response = if_needs_csrf_redirect(template, advanced, form_data)
         if response:
             return response
 
         lexeme_data = build_lexeme(template, form_data)
         summary = build_summary(template, form_data)
 
         if 'oauth' in app.config:
             lexeme_uri = submit_lexeme(template, lexeme_data, summary)
             return flask.redirect(lexeme_uri, code=303)
         else:
             print(summary)
             return flask.jsonify(lexeme_data)
     else:
         if not form_data:
             form_data = flask.request.args
         return flask.render_template(
             'template.html',
             template=add_form_data_to_template(form_data, template),
             advanced=advanced,
             can_use_bulk_mode=can_use_bulk_mode(),
         )
 
 @app.route('/template/<template_name>/bulk/', methods=['GET', 'POST'])
 def process_template_bulk(template_name):
     response = if_no_such_template_redirect(template_name)
     if response:
         return response
 
     response = if_needs_oauth_redirect()
     if response:
         return response
 
     template = templates[template_name]
     flask.g.interface_language_code = template['language_code']
 
     if not can_use_bulk_mode():
         return flask.render_template(
             'bulk-not-allowed.html',
             template=template,
         )
 
     if (flask.request.method == 'POST' and
         '_bulk_mode' in flask.request.form and
         csrf_token_matches(flask.request.form)):
 
         form_data = flask.request.form
         try:
             lexemes = parse_lexemes(form_data.get('lexemes'), template)
         except ValueError as parse_error:
             return flask.render_template(
                 'bulk.html',
                 template=template,
                 value=form_data.get('lexemes'),
                 parse_error=parse_error,
             )
 
         results = []
 
         for lexeme in lexemes:
             if not lexeme.get('lexeme_id'):
                 duplicates = find_duplicates(template, lexeme)
                 if duplicates:
                     results.append(('duplicates', duplicates))
                     continue
             lexeme_data = build_lexeme(template, lexeme)
             summary = build_summary(template, form_data)
 
             if 'oauth' in app.config:
                 lexeme_uri = submit_lexeme(template, lexeme_data, summary)
                 results.append(('lexeme_uri', lexeme_uri))
             else:
                 print(summary)
                 results.append(('lexeme_data', lexeme_data))
 
         if 'oauth' in app.config:
             return flask.render_template(
                 'bulk-result.html',
                 template=template,
                 results=results,
             )
         else:
             return flask.jsonify([result[1] for result in results])
 
     else:
         placeholder = ''
         for form in template['forms']:
             if placeholder:
                 placeholder += '|'
             (prefix, form_placeholder, suffix) = split_example(form)
             placeholder += form_placeholder
         placeholder += '\n...'
         csrf_error = False
 
         if flask.request.method == 'POST':
             form_data = flask.request.form
             if 'form_representation' in form_data:
                 # user came from non-bulk mode
                 representations = form_data.getlist('form_representation')
                 value = '|'.join(representations)
                 if value == '|' * (len(representations) - 1):
                     # ...but had not typed anything into non-bulk mode yet,
                     # clear the value so that the placeholder is shown
                     value = ''
                 else:
-                    value += '\n' # for convenience when adding more
+                    value += '\n'  # for convenience when adding more
             else:
                 # user came from bulk mode with CSRF error
                 value = form_data.get('lexemes')
                 csrf_error = True
         else:
             value = None
 
         return flask.render_template(
             'bulk.html',
             template=template,
             placeholder=placeholder,
             value=value,
             csrf_error=csrf_error,
         )
 
 @app.route('/template/<template_name>/edit/<lexeme_id>', methods=['GET', 'POST'])
 def process_template_edit(template_name, lexeme_id):
     response = if_no_such_template_redirect(template_name)
     if response:
         return response
 
     response = if_needs_oauth_redirect()
     if response:
         return response
 
     template = templates[template_name]
     template_language_code = template['language_code']
     flask.g.interface_language_code = template_language_code
     representation_language_code = flask.request.args.get('language_code', template_language_code)
     wiki = 'test' if 'test' in template else 'www'
 
     if flask.request.method == 'POST':
         lexeme_revision = flask.request.form['_lexeme_revision']
         lexeme_data = get_lexeme_data(lexeme_id, wiki, lexeme_revision)
     else:
         lexeme_data = get_lexeme_data(lexeme_id, wiki)
         lexeme_revision = lexeme_data['lastrevid']
 
     lexeme_match = match_template_to_lexeme_data(template, lexeme_data)
     lexeme_matches_template = (
         lexeme_match['language']
         and lexeme_match['lexical_category']
         and not lexeme_match['conflicting_statements']
     )
     template = match_lexeme_forms_to_template(lexeme_data['forms'], template)
     template['lexeme_id'] = lexeme_id
     template['lexeme_revision'] = lexeme_revision
 
     if (flask.request.method == 'POST' and
         '_edit_mode' in flask.request.form and
         csrf_token_matches(flask.request.form)):
         form_data = flask.request.form
         lexeme_data = update_lexeme(lexeme_data, template, form_data, representation_language_code, missing_statements=lexeme_match['missing_statements'])
         summary = build_summary(template, form_data)
 
         if 'oauth' in app.config:
             lexeme_uri = submit_lexeme(template, lexeme_data, summary)
             return flask.redirect(lexeme_uri, code=303)
         else:
             print(summary)
             return flask.jsonify(lexeme_data)
 
     for template_form in template['forms']:
         lexeme_forms = template_form.get('lexeme_forms')
-        if lexeme_forms: # TODO use walrus operator in Python 3.8
+        if lexeme_forms:  # TODO use walrus operator in Python 3.8
             template_form['value'] = '/'.join(lexeme_form['representations'][representation_language_code]['value']
                                               for lexeme_form in lexeme_forms
                                               if representation_language_code in lexeme_form['representations'])
     if flask.request.method == 'POST':
         template = add_form_data_to_template(flask.request.form, template)
     elif flask.request.args:
         template = add_form_data_to_template(flask.request.args, template, overwrite=False)
 
     add_labels_to_lexeme_forms_grammatical_features(
         mwapi.Session(
             'https://' + wiki + '.wikidata.org',
             user_agent=user_agent,
         ),
         template_language_code,
         template.get('unmatched_lexeme_forms', []) + template.get('ambiguous_lexeme_forms', [])
     )
 
     return flask.render_template(
         'edit.html',
         template=template,
         lemmas=lexeme_data['lemmas'],
         lexeme_matches_template=lexeme_matches_template,
         template_language_code=template_language_code,
         representation_language_code=representation_language_code,
-        advanced=True, # for form2input
+        advanced=True,  # for form2input
         csrf_error=flask.request.method == 'POST',
     )
 
 def if_no_such_template_redirect(template_name):
     if template_name not in templates:
         return flask.render_template(
             'no-such-template.html',
             template_name=template_name,
         )
     else:
         return None
 
 def if_needs_oauth_redirect():
     if 'oauth' in app.config and 'oauth_access_token' not in flask.session:
         (redirect, request_token) = mwoauth.initiate('https://www.wikidata.org/w/index.php', consumer_token, user_agent=user_agent)
         flask.session['oauth_request_token'] = dict(zip(request_token._fields, request_token))
         flask.session['oauth_redirect_target'] = current_url()
         return flask.redirect(redirect)
     else:
         return None
 
 @app.route('/oauth/callback')
 def oauth_callback():
     access_token = mwoauth.complete('https://www.wikidata.org/w/index.php', consumer_token, mwoauth.RequestToken(**flask.session.pop('oauth_request_token')), flask.request.query_string, user_agent=user_agent)
     flask.session['oauth_access_token'] = dict(zip(access_token._fields, access_token))
     flask.session.pop('_csrf_token', None)
     return flask.redirect(flask.session.pop('oauth_redirect_target'))
 
 @app.route('/logout')
 def logout():
     flask.session.pop('oauth_access_token', None)
     return flask.redirect(flask.url_for('index'))
 
 def if_has_duplicates_redirect(template, advanced, form_data):
     if 'no_duplicate' in form_data:
         return None
     if 'lexeme_id' in form_data and form_data['lexeme_id']:
         return None
 
     duplicates = find_duplicates(template, form_data)
     if duplicates:
         return flask.render_template(
             'template.html',
             template=add_form_data_to_template(form_data, template),
             advanced=advanced,
             duplicates=duplicates,
             submitted_form_representations=form_data.getlist('form_representation'),
         )
     else:
         return None
 
 def find_duplicates(template, form_data):
     wiki = 'test' if 'test' in template else 'www'
     language_code = template['language_code']
     lemma = get_lemma(form_data)
     if lemma:
         return get_duplicates(wiki, language_code, lemma)
     else:
         flask.abort(400)
 
 def get_lemma(form_data):
     for form_representation in form_data.getlist('form_representation'):
         for form_representation_variant in form_representation.split('/'):
             if form_representation_variant != '':
                 return form_representation_variant
     return None
 
 @app.route('/api/v1/duplicates/<any(www,test):wiki>/<language_code>/<path:lemma>')
 @enableCORS
 def get_duplicates_api(wiki, language_code, lemma):
     flask.g.interface_language_code = language_code
     matches = get_duplicates(wiki, language_code, lemma)
     if not matches:
         return flask.Response(status=204)
     if flask.request.accept_mimetypes.accept_html:
         return render_duplicates(
             matches,
             language_code,
             actionable=True,
             template_name=flask.request.args.get('template_name'),
         )
     else:
         return flask.jsonify(matches)
 
 def get_duplicates(wiki, language_code, lemma):
     host = 'https://' + wiki + '.wikidata.org'
     session = mwapi.Session(
         host,
         user_agent=user_agent,
     )
 
     api_language_code = 'bn' if language_code == 'bn-x-Q6747180' else language_code
 
     response = session.get(
         action='wbsearchentities',
         search=lemma,
         language=api_language_code,
-        uselang=api_language_code, # for the result descriptions
+        uselang=api_language_code,  # for the result descriptions
         type='lexeme',
         limit=50,
     )
     matches = collections.OrderedDict()
     for result in response['search']:
         if (result.get('label') == lemma and
             (result['match']['language'] == language_code or
-             (len(language_code) > 2 and result['match']['language'] == 'und'))): # T230833
+             (len(language_code) > 2 and result['match']['language'] == 'und'))):  # T230833
             matches[result['id']] = {'id': result['id'], 'uri': result['concepturi'], 'label': result['label'], 'description': result['description']}
 
     if matches:
-        response = session.get( # no, this can’t be combined with the previous call by using generator=wbsearch – then we don’t get the match language
+        response = session.get(  # no, this can’t be combined with the previous call by using generator=wbsearch – then we don’t get the match language
             action='query',
             titles=['Lexeme:' + id for id in matches],
             prop=['pageprops'],
             ppprop=['wbl-forms', 'wbl-senses'],
         )
         for page in response['query']['pages'].values():
             id = page['title'][len('Lexeme:'):]
             pageprops = page.get('pageprops', {})
             matches[id]['forms_count'] = pageprops.get('wbl-forms')
             matches[id]['senses_count'] = pageprops.get('wbl-senses')
 
-    return list(matches.values()) # list() to turn odict_values (not JSON serializable) into plain list
+    return list(matches.values())  # list() to turn odict_values (not JSON serializable) into plain list
 
 @app.route('/api/v1/no_duplicate/<language_code>')
 @app.template_global()
 def render_no_duplicate(language_code):
     flask.g.interface_language_code = language_code
     return flask.render_template(
         'no_duplicate.html',
     )
 
 @app.route('/api/v1/advanced_partial_forms_hint/<language_code>')
 def render_advanced_partial_forms_hint(language_code):
     flask.g.interface_language_code = language_code
     return flask.render_template(
         'advanced_partial_forms_hint.html',
     )
 
 @app.route('/api/v1/match_template_to_lexeme/<any(www,test):wiki>/<lexeme_id>')
 @enableCORS
 def match_templates_to_lexeme_id(wiki, lexeme_id):
     lexeme_data = get_lexeme_data(lexeme_id, wiki)
 
     return flask.jsonify({
         template_name: match_template_to_lexeme_data(template, lexeme_data)
         for template_name, template in templates.items()
     })
 
 @app.route('/api/v1/match_template_to_lexeme/<any(www,test):wiki>/<lexeme_id>/<template_name>')
 @enableCORS
 def match_template_to_lexeme_id(wiki, lexeme_id, template_name):
     template = templates.get(template_name)
     if not template:
         return 'no such template\n', 404
 
     lexeme_data = get_lexeme_data(lexeme_id, wiki)
 
     return flask.jsonify(match_template_to_lexeme_data(template, lexeme_data))
 
 def get_lexeme_data(lexeme_id, wiki, revision=None):
     host = 'https://' + wiki + '.wikidata.org'
     session = mwapi.Session(
         host,
         user_agent=user_agent,
     )
 
     if revision:
         entities_data = session.session.get(
             f'{host}/wiki/Special:EntityData/{lexeme_id}.json?revision={revision}',
         ).json()
-    else: # TODO when T128486 is fixed, use Special:EntityData without revision too, for better caching
+    else:  # TODO when T128486 is fixed, use Special:EntityData without revision too, for better caching
         entities_data = session.get(
             action='wbgetentities',
             ids=[lexeme_id],
         )
 
     lexeme_data = entities_data['entities'][lexeme_id]
     return lexeme_data
 
 def add_form_data_to_template(form_data, template, overwrite=True):
     template = copy.deepcopy(template)
     for (form_representation, form) in zip(form_data.getlist('form_representation'), template['forms']):
         if overwrite or not form.get('value'):
             form['value'] = form_representation
     if 'lexeme_id' in form_data:
         template['lexeme_id'] = form_data['lexeme_id']
     if 'generated_via' in form_data:
         template['generated_via'] = form_data['generated_via']
     return template
 
 def if_needs_csrf_redirect(template, advanced, form_data):
     if not csrf_token_matches(form_data):
         return flask.render_template(
             'template.html',
             template=add_form_data_to_template(form_data, template),
             advanced=advanced,
             csrf_error=True,
         )
     else:
         return None
 
 def csrf_token_matches(form_data):
     token = flask.session.get('_csrf_token')
     if not token or token != form_data.get('_csrf_token'):
         return False
     else:
         return True
 
 def current_url():
     return flask.url_for(
         flask.request.endpoint,
         _external=True,
         _scheme=flask.request.headers.get('X-Forwarded-Proto', 'http'),
         **flask.request.view_args,
         **flask.request.args.to_dict(flat=False),
     ).replace('+', '%20')
 
 @app.template_global()
 def can_use_bulk_mode():
     if 'oauth' not in app.config:
         return True
     identity = identify()
     if not identity:
         return False
     return 'autoconfirmed' in identity['groups']
 
 def build_lexeme(template, form_data):
     lang = template['language_code']
     forms = []
     form_representations = form_data.getlist('form_representation')
     for form_representation, form in zip(form_representations, template['forms']):
         if not form_representation:
             continue
         for form_representation_variant in form_representation.split('/'):
             if not form_representation_variant:
                 flask.abort(400)
             forms.append(build_form(form, lang, form_representation_variant))
     lexeme_data = {
         'type': 'lexeme',
         'forms': forms,
     }
     lexeme_id = form_data.get('lexeme_id', '')
     if lexeme_id:
         lexeme_data['id'] = lexeme_id
         wiki = 'test' if 'test' in template else 'www'
         match = match_template_to_lexeme_data(template, get_lexeme_data(lexeme_id, wiki))
         # TODO warn if match['conflicting_statements']?
         lexeme_data['claims'] = match['missing_statements']
     else:
         lemma = get_lemma(form_data)
         if lemma is None:
             flask.abort(400)
         lexeme_data.update({
             'lemmas': {lang: {'language': lang, 'value': lemma}},
             'language': template['language_item_id'],
             'lexicalCategory': template['lexical_category_item_id'],
             'claims': template.get('statements', {}),
         })
     return lexeme_data
 
 def build_form(template_form, template_language, form_representation):
     return {
         'add': '',
         'representations': {template_language: {'language': template_language, 'value': form_representation}},
         'grammaticalFeatures': template_form['grammatical_features_item_ids'],
         'claims': template_form.get('statements', {})
     }
 
 def update_lexeme(lexeme_data, template, form_data, representation_language_code, missing_statements=None):
     lexeme_data = copy.deepcopy(lexeme_data)
     lexeme_data['base_revision_id'] = template['lexeme_revision']
 
     for form_data_representation, template_form in zip(form_data.getlist('form_representation'), template['forms']):
         form_data_representation_variants = form_data_representation.split('/')
         if form_data_representation_variants == ['']:
             form_data_representation_variants = []
         lexeme_forms = template_form.get('lexeme_forms', []).copy()
         # process “representations” that actually reference existing forms first
-        for form_data_representation_variant in reversed(form_data_representation_variants): # reversed so that the remove within the loop doesn’t disturb the iteration
+        for form_data_representation_variant in reversed(form_data_representation_variants):  # reversed so that the remove within the loop doesn’t disturb the iteration
             if not re.match(r'^L[1-9][0-9]*-F[1-9][0-9]*$', form_data_representation_variant):
                 continue
             lexeme_form = find_form(lexeme_data, form_id=form_data_representation_variant)
             if lexeme_form in template.get('unmatched_lexeme_forms', []):
                 template['unmatched_lexeme_forms'].remove(lexeme_form)
             elif lexeme_form in template.get('ambiguous_lexeme_forms', []):
                 template['ambiguous_lexeme_forms'].remove(lexeme_form)
             else:
                 raise Exception('Form %s is neither unmatched nor ambiguous, refusing to re-match it to a different template form' % form_data_representation_variant)
             # add missing grammatical features
             for grammatical_feature_item_id in template_form['grammatical_features_item_ids']:
                 if grammatical_feature_item_id not in lexeme_form['grammaticalFeatures']:
                     lexeme_form['grammaticalFeatures'].append(grammatical_feature_item_id)
             # add missing statements (and complain about conflicting ones)
             form_matched_statements, form_missing_statements, form_conflicting_statements = match_template_entity_to_lexeme_entity('test' in template, template_form, lexeme_form)
             if form_conflicting_statements:
-                raise Exception('Conflicting statements!') # TODO better error reporting
+                raise Exception('Conflicting statements!')  # TODO better error reporting
             for property_id, statements in form_missing_statements.items():
                 lexeme_form.setdefault('claims', {}).setdefault(property_id, []).extend(statements)
             form_data_representation_variants.remove(form_data_representation_variant)
         # find and remove matching forms (no modification necessary)
-        for lexeme_form in reversed(lexeme_forms): # reversed so that the remove within the loop doesn’t disturb the iteration
+        for lexeme_form in reversed(lexeme_forms):  # reversed so that the remove within the loop doesn’t disturb the iteration
             if representation_language_code not in lexeme_form['representations']:
                 continue
             lexeme_form_representation = lexeme_form['representations'][representation_language_code]
             if lexeme_form_representation['value'] in form_data_representation_variants:
                 lexeme_forms.remove(lexeme_form)
                 form_data_representation_variants.remove(lexeme_form_representation['value'])
                 break
         # overwrite remaining lexeme forms with form data as long as we have both
         # currently simply in order, cleverer matching via edit distance may be possible but likely not necessary
         overwritten_forms = 0
         for form_data_representation_variant, lexeme_form in zip(form_data_representation_variants, lexeme_forms):
             lexeme_form = find_form(lexeme_data, lexeme_form['id'])
             lexeme_form_representation = lexeme_form['representations'].setdefault(representation_language_code, {'language': representation_language_code})
             assert form_data_representation_variant, 'Representation cannot be empty'
             lexeme_form_representation['value'] = form_data_representation_variant
             overwritten_forms += 1
         form_data_representation_variants = form_data_representation_variants[overwritten_forms:]
         lexeme_forms = lexeme_forms[overwritten_forms:]
         # add remaining form data as new OR delete remaining lexeme form representations or forms
         assert not (form_data_representation_variants and lexeme_forms), 'After previous loop, at least one list must be exhausted'
         for form_data_representation_variant in form_data_representation_variants:
             assert form_data_representation_variant, 'Representation cannot be empty'
             lexeme_form = build_form(template_form, representation_language_code, form_data_representation_variant)
             lexeme_data['forms'].append(lexeme_form)
-            template_form.setdefault('lexeme_forms', []).append(lexeme_form) # so it can be found as first_form below
+            template_form.setdefault('lexeme_forms', []).append(lexeme_form)  # so it can be found as first_form below
         for lexeme_form in lexeme_forms:
             lexeme_form = find_form(lexeme_data, lexeme_form['id'])
             if representation_language_code in lexeme_form['representations']:
                 if len(lexeme_form['representations']) == 1:
-                    lexeme_form['remove'] = '' # remove whole form
+                    lexeme_form['remove'] = ''  # remove whole form
                 else:
-                    lexeme_form['representations'][representation_language_code]['remove'] = '' # remove only this representation
+                    lexeme_form['representations'][representation_language_code]['remove'] = ''  # remove only this representation
             # otherwise it’s an unrelated form that wasn’t shown to begin with, leave it alone
 
     for property_id, statements in (missing_statements or {}).items():
         lexeme_data.setdefault('claims', {}).setdefault(property_id, []).extend(statements)
 
     first_form = next(iter(template['forms'][0].get('lexeme_forms', [])), None)
     if first_form:
         first_form_id = first_form.get('id')
-        if first_form_id: # TODO use walrus operator in Python 3.8+
-            first_form = find_form(lexeme_data, first_form_id) # find edited version
+        if first_form_id:  # TODO use walrus operator in Python 3.8+
+            first_form = find_form(lexeme_data, first_form_id)  # find edited version
         else:
             # it’s a new form, first_form is already the edited version
             pass
         if representation_language_code in first_form['representations']:
             lexeme_data['lemmas'][representation_language_code] = first_form['representations'][representation_language_code]
         else:
             lexeme_data['lemmas'].pop(representation_language_code, None)
 
     return lexeme_data
 
 def find_form(lexeme_data, form_id):
     for form in lexeme_data['forms']:
         if form['id'] == form_id:
             return form
     raise LookupError(f'Form {form_id} not found in lexeme data for {lexeme_data["id"]}')
 
 def build_summary(template, form_data):
     template_name = template['@template_name']
     url = current_url()
     toolforge_match = re.match(r'https://([a-z0-9-_]+).toolforge.org/(.*)$', url)
-    if toolforge_match: # TODO use walrus operator in Python 3.8+
+    if toolforge_match:  # TODO use walrus operator in Python 3.8+
         tool_name = toolforge_match.group(1)
         rest = toolforge_match.group(2)
         summary = '[[toolforge:%s/%s|%s]]' % (tool_name, rest, template_name)
     elif url.startswith('https://tools.wmflabs.org/'):
         relative = url[len('https://tools.wmflabs.org/'):]
         summary = '[[toolforge:%s|%s]]' % (relative, template_name)
     else:
         summary = template_name
 
     if 'generated_via' in form_data:
         summary += ', generated via ' + form_data['generated_via']
 
     return summary
 
 def submit_lexeme(template, lexeme_data, summary):
     if 'test' in template:
         host = 'https://test.wikidata.org'
     else:
         host = 'https://www.wikidata.org'
     session = mwapi.Session(
         host=host,
         auth=generate_auth(),
         user_agent=user_agent,
     )
 
     token = session.get(action='query', meta='tokens')['query']['tokens']['csrftoken']
     selector = {'id': lexeme_data['id']} if 'id' in lexeme_data else {'new': 'lexeme'}
     if 'base_revision_id' in lexeme_data:
         selector['baserevid'] = lexeme_data['base_revision_id']
     response = session.post(
         action='wbeditentity',
         data=json.dumps(lexeme_data),
         summary=summary,
         token=token,
         **selector
     )
     lexeme_id = response['entity']['id']
 
     return host + '/entity/' + lexeme_id
 
 def add_labels_to_lexeme_forms_grammatical_features(session, language, lexeme_forms):
     grammatical_features_item_ids = set()
     for lexeme_form in lexeme_forms:
         grammatical_features_item_ids.update(lexeme_form['grammaticalFeatures'])
     grammatical_features_item_ids = list(grammatical_features_item_ids)
-    labels_map = {} # item ID to label
+    labels_map = {}  # item ID to label
     while grammatical_features_item_ids:
         chunk, grammatical_features_item_ids = grammatical_features_item_ids[:50], grammatical_features_item_ids[50:]
         response = session.get(action='wbgetentities',
                                ids=chunk,
                                props=['labels'],
                                languages=[language],
-                               languagefallback=1, # TODO use True once mediawiki-utilities/python-mwapi#38 is in a released version
+                               languagefallback=1,  # TODO use True once mediawiki-utilities/python-mwapi#38 is in a released version
                                formatversion=2)
         for item_id, item in response['entities'].items():
             labels_map[item_id] = item['labels'].get(language, {'language': 'zxx', 'value': item_id})
     for lexeme_form in lexeme_forms:
         lexeme_form['grammaticalFeatures_labels'] = [labels_map[grammatical_feature_item_id]
                                                      for grammatical_feature_item_id in lexeme_form['grammaticalFeatures']]
 
 @app.route('/api/v1/template/')
 @enableCORS
 def get_all_templates_api():
     return flask.jsonify(templates)
 
 @app.route('/api/v1/template/<template_name>')
 @enableCORS
 def get_template_api(template_name):
     template = templates.get(template_name)
     if template:
         return flask.jsonify(template)
     else:
         return '"no such template"\n', 404
 
 def get_gender(user):
     if user is None:
         gender_option = gender_option_of_user()
     else:
         gender_option = gender_option_of_user_name(user)
     return {
         'male': 'm',
         'female': 'f',
         'unknown': 'n',
     }[gender_option]
 
 def gender_option_of_user_name(user_name):
     session = mwapi.Session(
         host='https://www.wikidata.org',
         user_agent=user_agent,
     )
     response = session.get(action='query',
                            list=['users'],
                            usprop=['gender'],
                            ususers=[user_name],
                            formatversion=2)
     return response['query']['users'][0]['gender']
 
 def gender_option_of_user():
     if 'oauth_access_token' not in flask.session:
         return 'unknown'
 
     session = mwapi.Session(
         host='https://www.wikidata.org',
         auth=generate_auth(),
         user_agent=user_agent,
     )
     response = session.get(action='query',
                            meta=['userinfo'],
                            uiprop=['options'],
                            formatversion=2)
     return response['query']['userinfo']['options']['gender']
 
 def generate_auth():
     access_token = mwoauth.AccessToken(**flask.session['oauth_access_token'])
     return requests_oauthlib.OAuth1(
         client_key=consumer_token.key,
         client_secret=consumer_token.secret,
         resource_owner_key=access_token.key,
         resource_owner_secret=access_token.secret,
     )
 
 def identify():
     if 'oauth_access_token' not in flask.session:
         return None
     access_token = mwoauth.AccessToken(**flask.session['oauth_access_token'])
     return mwoauth.identify(
         'https://www.wikidata.org/w/index.php',
         consumer_token,
         access_token,
     )
diff --git a/matching.py b/matching.py
index 88e6ccc..cc789a0 100644
--- a/matching.py
+++ b/matching.py
@@ -1,133 +1,133 @@
 import copy
 
 
 # whether the presence of some statement for a property
 # rules the lexeme out as a match for a template
 # with a different statement for that property
 properties_exclusive = {
     'www': {
         # other “instance of” are likely unrelated and okay
         'P31': False,
         # other “grammatical gender” are incompatible
         'P5185': True,
         # other “grammatical aspect” are incompatible
         'P7486': True,
     },
     'test': {
         # other “instance of” are likely unrelated and okay
         'P82': False,
         # other “grammatical gender” are incompatible
         'P73601': True,
     },
 }
 
 
 def match_template_to_lexeme_data(template, lexeme_data):
     language_matches = template['language_item_id'] == lexeme_data['language']
     lexical_category_matches = template['lexical_category_item_id'] == lexeme_data['lexicalCategory']
     matched_statements, missing_statements, conflicting_statements = match_template_entity_to_lexeme_entity('test' in template, template, lexeme_data)
 
     return {
         'language': language_matches,
         'lexical_category': lexical_category_matches,
         'matched_statements': matched_statements,
         'missing_statements': missing_statements,
         'conflicting_statements': conflicting_statements,
     }
 
 
-def match_template_entity_to_lexeme_entity(test, template_entity, lexeme_entity): # may be template + lexeme or template form + lexeme form
+def match_template_entity_to_lexeme_entity(test, template_entity, lexeme_entity):  # may be template + lexeme or template form + lexeme form
     matched_statements = {}
     missing_statements = {}
     conflicting_statements = {}
 
     properties_exclusive_for_template_entity = properties_exclusive['test' if test else 'www']
     for property_id in template_entity.get('statements', {}):
         property_exclusive = properties_exclusive_for_template_entity[property_id]
         for template_statement in template_entity['statements'][property_id]:
             found_matching_statement = False
             if lexeme_entity.get('claims') == []:
-                lexeme_entity['claims'] = {} # work around T241422
+                lexeme_entity['claims'] = {}  # work around T241422
             for lexeme_statement in lexeme_entity.get('claims', {}).get(property_id, []):
                 if match_statement(template_statement, lexeme_statement):
                     found_matching_statement = True
                     if property_id not in matched_statements:
                         matched_statements[property_id] = []
                     matched_statements[property_id].append(lexeme_statement)
                 elif property_exclusive:
                     if property_id not in conflicting_statements:
                         conflicting_statements[property_id] = []
                     conflicting_statements[property_id].append(lexeme_statement)
 
             if not found_matching_statement:
                 if property_id not in missing_statements:
                     missing_statements[property_id] = []
                 missing_statements[property_id].append(template_statement)
 
     return matched_statements, missing_statements, conflicting_statements
 
 
 def match_statement(template_statement, lexeme_statement):
     # so far, we only compare the main snak (ignoring qualifiers and references),
     # and only support entity ID values, because that’s all the templates use
     if lexeme_statement['mainsnak']['snaktype'] == 'value':
         template_statement_value_id = template_statement['mainsnak']['datavalue']['value']['id']
         lexeme_statement_value_id = lexeme_statement['mainsnak']['datavalue']['value']['id']
         return template_statement_value_id == lexeme_statement_value_id
     else:
         return False
 
 
 def match_lexeme_forms_to_template(lexeme_forms, template):
     template = copy.deepcopy(template)
     for lexeme_form in lexeme_forms:
         best_template_forms = match_lexeme_form_to_template_forms('test' in template, lexeme_form, template['forms'])
         if len(best_template_forms) == 1:
             best_template_form = best_template_forms[0]
             best_template_form.setdefault('lexeme_forms', []).append(lexeme_form)
         elif best_template_forms:
             template.setdefault('ambiguous_lexeme_forms', []).append(lexeme_form)
         else:
             template.setdefault('unmatched_lexeme_forms', []).append(lexeme_form)
     return template
 
 
 def match_lexeme_form_to_template_forms(test, lexeme_form, template_forms):
     best_template_forms = []
     best_matching_features = 0
     for template_form in template_forms:
         matching_features = match_lexeme_form_to_template_form(test, lexeme_form, template_form)
         if matching_features > best_matching_features:
             best_matching_features = matching_features
             best_template_forms = [template_form]
         elif matching_features == best_matching_features and best_matching_features > 0:
             best_template_forms.append(template_form)
     if not best_template_forms and len(template_forms) == 1 and matchable_features(template_form) == 0:
         # as a special exception, in a template with a single featureless form, a lexeme form is allowed to match with no matching features
         return [template_forms[0]]
     return best_template_forms
 
 
 def match_lexeme_form_to_template_form(test, lexeme_form, template_form):
     matching_features = 0
 
     for grammatical_feature_item_id in template_form['grammatical_features_item_ids']:
         if grammatical_feature_item_id in lexeme_form['grammaticalFeatures']:
             matching_features += 1
         else:
             return 0
 
     matched_statements, missing_statements, conflicting_statements = match_template_entity_to_lexeme_entity(test, template_form, lexeme_form)
     if missing_statements or conflicting_statements:
         return 0
     else:
         matching_features += len(matched_statements)
 
     return matching_features
 
 
 def matchable_features(template_form):
     features = len(template_form['grammatical_features_item_ids'])
     for property_id in template_form.get('statements', {}):
         features += len(template_form['statements'][property_id])
     return features
diff --git a/purge-all-lexemes.py b/purge-all-lexemes.py
index a57af35..e72cf30 100644
--- a/purge-all-lexemes.py
+++ b/purge-all-lexemes.py
@@ -1,28 +1,28 @@
 #!/usr/bin/env python3
 
 import time
 
 import mwapi
 import toolforge
 
 user_agent = toolforge.set_user_agent('lexeme-forms', email='mail@lucaswerkmeister.de')
 session = mwapi.Session(
     host='https://www.wikidata.org',
     user_agent=user_agent
 )
 
 for result in session.post(
         action='purge',
         generator='allpages',
-        gapnamespace=146, # Lexeme
-        gaplimit=30, # rate limit permits 30 purges per 60 seconds
+        gapnamespace=146,  # Lexeme
+        gaplimit=30,  # rate limit permits 30 purges per 60 seconds
         forcelinkupdate=True,
         continuation=True
     ):
     pages = result['purge']
     first_id = pages[0]['title'][len('Lexeme:'):]
     last_id = pages[-1]['title'][len('Lexeme:'):]
     print('Purged {:>6} ... {:>6}'.format(first_id, last_id), flush=True)
-    time.sleep(75) # rate limit permits 30 purges per 60 seconds, +15s for some buffer
+    time.sleep(75)  # rate limit permits 30 purges per 60 seconds, +15s for some buffer
 
 print('Done.')
diff --git a/test_app.py b/test_app.py
index 4c13392..4d4e388 100644
--- a/test_app.py
+++ b/test_app.py
@@ -1,1196 +1,1196 @@
 import copy
 import flask
 import json
 import mwoauth
 import pytest
 import werkzeug
 
 import app as lexeme_forms
 import matching
 from templates import templates
 
 def test_form2input_basic():
     markup = lexeme_forms.form2input({'advanced': False}, {'example': 'Left [placeholder] right.'})
     assert str(markup) == 'Left <input type="text" name="form_representation" placeholder="placeholder" pattern="[^/]+(?:/[^/]+)*" required spellcheck="true"> right.'
 
 def test_form2input_advanced():
     markup = lexeme_forms.form2input({'advanced': True}, {'example': 'Left [placeholder] right.'})
     assert str(markup) == 'Left <input type="text" name="form_representation" placeholder="placeholder" pattern="[^/]+(?:/[^/]+)*" spellcheck="true"> right.'
 
 def test_form2input_first():
     markup = lexeme_forms.form2input({'advanced': True}, {'example': 'Left [placeholder] right.'}, first=True)
     assert str(markup) == 'Left <input type="text" name="form_representation" placeholder="placeholder" pattern="[^/]+(?:/[^/]+)*" autofocus spellcheck="true"> right.'
 
 def test_form2input_preserve_value():
     markup = lexeme_forms.form2input({'advanced': True}, {'example': 'Left [placeholder] right.', 'value': 'value'})
     assert str(markup) == 'Left <input type="text" name="form_representation" placeholder="placeholder" pattern="[^/]+(?:/[^/]+)*" value="value" spellcheck="true"> right.'
 
 def test_form2input_escape_value():
     markup = lexeme_forms.form2input({'advanced': True}, {'example': 'Left [placeholder] right.', 'value': '"<>&'})
     assert str(markup) == 'Left <input type="text" name="form_representation" placeholder="placeholder" pattern="[^/]+(?:/[^/]+)*" value="&#34;&lt;&gt;&amp;" spellcheck="true"> right.'
 
 def test_form2input_invalid():
     with pytest.raises(Exception) as excinfo:
-        markup = lexeme_forms.form2input({'advanced': True}, {'example': 'No placeholder.'}) # noqa:F841
+        markup = lexeme_forms.form2input({'advanced': True}, {'example': 'No placeholder.'})  # noqa:F841
     assert 'missing [placeholder]' in str(excinfo.value)
 
 @pytest.mark.parametrize('example, expected_prefix, expected_placeholder, expected_suffix', [
     ('Left [placeholder] right.', 'Left ', 'placeholder', ' right.'),
     ('[placeholder] right.', '', 'placeholder', ' right.'),
     ('Left [placeholder]', 'Left ', 'placeholder', ''),
     ('[placeholder]', '', 'placeholder', ''),
     ('Left [] right.', 'Left ', '', ' right.'),
 ])
 def test_split_example(example, expected_prefix, expected_placeholder, expected_suffix):
     form = {'example': example}
     (actual_prefix, actual_placeholder, actual_suffix) = lexeme_forms.split_example(form)
     assert (expected_prefix, expected_placeholder, expected_suffix) \
         == (actual_prefix, actual_placeholder, actual_suffix)
 
 @pytest.mark.parametrize('example', [
     'Left right.',
     'Left [placeholder right.',
     'Left placeholder] right.',
     'Left ]placeholder[ right.',
 ])
 def test_split_example_error(example):
     form = {'example': example}
     with pytest.raises(Exception):
         lexeme_forms.split_example(form)
 
 def test_csrf_token_generate():
     with lexeme_forms.app.test_request_context():
         token = lexeme_forms.csrf_token()
         assert token != ''
 
 def test_csrf_token_save():
     with lexeme_forms.app.test_request_context() as context:
         token = lexeme_forms.csrf_token()
         assert token == context.session['_csrf_token']
 
 def test_csrf_token_load():
     with lexeme_forms.app.test_request_context() as context:
         context.session['_csrf_token'] = 'test token'
         assert lexeme_forms.csrf_token() == 'test token'
 
 def test_template_group():
     group = lexeme_forms.template_group({'language_code': 'de'})
     assert group == '<span lang="de" dir="ltr">Deutsch (<span lang=zxx>de</span>)</span>'
 
 def test_template_group_test():
     group = lexeme_forms.template_group({'language_code': 'de', 'test': True})
     assert group == '<span lang="de" dir="ltr">Deutsch (<span lang=zxx>de</span>)</span>, test.wikidata.org'
 
 @pytest.mark.parametrize('template_name', templates.keys())
 @pytest.mark.parametrize('number', range(-1,5))
 def test_message_with_kwargs(template_name, number):
     template = templates[template_name]
     with lexeme_forms.app.test_request_context():
         flask.g.interface_language_code = template['language_code']
-        message = lexeme_forms.message_with_kwargs('description_with_forms_and_senses', description='', forms=number, senses=number) # noqa:F841
+        message = lexeme_forms.message_with_kwargs('description_with_forms_and_senses', description='', forms=number, senses=number)  # noqa:F841
     # should not have failed
 
 @pytest.mark.parametrize('language_code, expected_direction', [
     ('en', 'ltr'),
     ('fa', 'rtl'),
     ('mis', 'auto'),
     ('mis-x-Q401', 'auto'),
 ])
 def test_text_direction(language_code, expected_direction):
     assert lexeme_forms.text_direction(language_code) == expected_direction
 
 def test_if_no_such_template_redirect_known_template():
     assert lexeme_forms.if_no_such_template_redirect('english-noun') is None
 
 def test_if_no_such_template_redirect_unknown_template():
     template_name = 'no-such-template'
     with lexeme_forms.app.test_request_context():
         response = lexeme_forms.if_no_such_template_redirect(template_name)
     assert response is not None
     assert type(response) is str
     assert 'alert' in response
     assert template_name in response
 
 def test_if_needs_oauth_redirect_not_configured(monkeypatch):
     monkeypatch.delitem(lexeme_forms.app.config, 'oauth', raising=False)
     assert lexeme_forms.if_needs_oauth_redirect() is None
 
 def test_if_needs_oauth_redirect_logged_in(monkeypatch):
     monkeypatch.setitem(lexeme_forms.app.config, 'oauth', {})
     with lexeme_forms.app.test_request_context() as context:
         context.session['oauth_access_token'] = 'test token'
         assert lexeme_forms.if_needs_oauth_redirect() is None
 
 def test_if_needs_oauth_redirect_not_logged_in(monkeypatch):
     monkeypatch.setitem(lexeme_forms.app.config, 'oauth', {})
     monkeypatch.setattr(lexeme_forms, 'consumer_token', mwoauth.ConsumerToken('test key', 'test secret'), raising=False)
     monkeypatch.setattr(mwoauth, 'initiate', lambda mw_uri, consumer_token, user_agent: ('test redirect', mwoauth.RequestToken('test key', 'test secret')))
-    with lexeme_forms.app.test_request_context() as context: # noqa: F841
+    with lexeme_forms.app.test_request_context() as context:  # noqa: F841
         response = lexeme_forms.if_needs_oauth_redirect()
     assert response is not None
     assert str(response.status_code).startswith('3')
 
 def test_if_has_duplicates_redirect_checkbox_checked():
     assert lexeme_forms.if_has_duplicates_redirect(
         {},
         False,
         werkzeug.datastructures.ImmutableMultiDict({'no_duplicate': True}),
     ) is None
 
 def test_if_has_duplicates_redirect_lexeme_id_specified():
     assert lexeme_forms.if_has_duplicates_redirect(
         {},
         False,
         werkzeug.datastructures.ImmutableMultiDict({'lexeme_id': 'L123'}),
     ) is None
 
 def test_if_has_duplicates_redirect_lexeme_id_blank(monkeypatch):
     monkeypatch.setattr(lexeme_forms, 'find_duplicates', lambda template, form_data: ['duplicate'])
     monkeypatch.setattr(lexeme_forms, 'add_form_data_to_template', lambda form_data, template: True)
     monkeypatch.setattr(flask, 'render_template', lambda template_file_name, **kwargs: True)
     assert lexeme_forms.if_has_duplicates_redirect(
         minimal_template,
         False,
         werkzeug.datastructures.ImmutableMultiDict({'lexeme_id': ''}),
     ) is not None
 
 def test_if_has_duplicates_redirect_some_duplicates(monkeypatch):
     monkeypatch.setattr(lexeme_forms, 'find_duplicates', lambda template, form_data: ['duplicate'])
     monkeypatch.setattr(lexeme_forms, 'add_form_data_to_template', lambda form_data, template: True)
     monkeypatch.setattr(flask, 'render_template', lambda template_file_name, **kwargs: 'rendered duplicates')
     assert lexeme_forms.if_has_duplicates_redirect(
         minimal_template,
         False,
         werkzeug.datastructures.ImmutableMultiDict(),
     ) == 'rendered duplicates'
 
 def test_if_has_duplicates_redirect_no_duplicates(monkeypatch):
     monkeypatch.setattr(lexeme_forms, 'find_duplicates', lambda template, form_data: [])
     assert lexeme_forms.if_has_duplicates_redirect(
         {},
         False,
         werkzeug.datastructures.ImmutableMultiDict(),
     ) is None
 
 def test_if_has_duplicates_redirect_submitted_form_representations(monkeypatch):
     def render_template(template_file_name, **kwargs):
         assert template_file_name == 'template.html'
         assert kwargs['submitted_form_representations'] == ['noun', 'nouns']
         return 'rendered duplicates'
     monkeypatch.setattr(lexeme_forms, 'find_duplicates', lambda template, form_data: ['duplicate'])
     monkeypatch.setattr(lexeme_forms, 'add_form_data_to_template', lambda form_data, template: True)
     monkeypatch.setattr(flask, 'render_template', render_template)
     assert lexeme_forms.if_has_duplicates_redirect(
         copy.deepcopy(templates['english-noun']),
         False,
         werkzeug.datastructures.ImmutableMultiDict([('form_representation', 'noun'), ('form_representation', 'nouns')]),
     ) == 'rendered duplicates'
 
 def test_get_lemma_first_form_representation():
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', 'noun'), ('form_representation', 'nouns')])
     lemma = lexeme_forms.get_lemma(form_data)
     assert lemma == 'noun'
 
 def test_get_lemma_second_form_representation():
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', ''), ('form_representation', 'nouns')])
     lemma = lexeme_forms.get_lemma(form_data)
     assert lemma == 'nouns'
 
 def test_get_lemma_no_form_representation():
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', ''), ('form_representation', '')])
     lemma = lexeme_forms.get_lemma(form_data)
     assert lemma is None
 
 def test_get_duplicates_api_json(monkeypatch):
     duplicates = [{'id': 'L1', 'uri': 'http://www.wikidata.org/wiki/Lexeme:L1', 'label': 'lemma', 'description': 'a lexeme', 'forms_count': None, 'senses_count': None}]
     monkeypatch.setattr(lexeme_forms, 'get_duplicates', lambda wiki, language_code, lemma: duplicates)
     with lexeme_forms.app.test_client() as client:
         response = client.get('/api/v1/duplicates/www/en/lemma')
     assert response.content_type == 'application/json'
     assert json.loads(response.get_data(as_text=True)) == duplicates
 
 def test_get_duplicates_api_html_two(monkeypatch):
     duplicates = [{'id': 'L1', 'uri': 'http://www.wikidata.org/wiki/Lexeme:L1', 'label': 'test1 lemma', 'description': 'a test1 lexeme', 'forms_count': None, 'senses_count': None},
                   {'id': 'L2', 'uri': 'http://www.wikidata.org/wiki/Lexeme:L2', 'label': 'test2 lemma', 'description': 'a test2 lexeme', 'forms_count': None, 'senses_count': None}]
     monkeypatch.setattr(lexeme_forms, 'get_duplicates', lambda wiki, language_code, lemma: duplicates)
     with lexeme_forms.app.test_client() as client:
         response = client.get('/api/v1/duplicates/www/de/lemma', headers={'Accept': 'text/html'})
     assert response.content_type == 'text/html; charset=utf-8'
     response_text = response.get_data(as_text=True)
     assert 'haben das gleiche Lemma' in response_text
     assert 'kreuze das Kästchen' in response_text
     assert 'test1 lemma' in response_text
     assert 'a test1 lexeme' in response_text
     assert 'test2 lemma' in response_text
     assert 'a test2 lexeme' in response_text
 
 def test_get_duplicates_api_html_one(monkeypatch):
     duplicates = [{'id': 'L1', 'uri': 'http://www.wikidata.org/wiki/Lexeme:L1', 'label': 'test lemma', 'description': 'a test lexeme', 'forms_count': None, 'senses_count': None}]
     monkeypatch.setattr(lexeme_forms, 'get_duplicates', lambda wiki, language_code, lemma: duplicates)
     with lexeme_forms.app.test_client() as client:
         response = client.get('/api/v1/duplicates/www/de/lemma', headers={'Accept': 'text/html'})
     assert response.content_type == 'text/html; charset=utf-8'
     response_text = response.get_data(as_text=True)
     assert 'hat das gleiche Lemma' in response_text
     assert 'kreuze das Kästchen' in response_text
     assert 'test lemma' in response_text
     assert 'a test lexeme' in response_text
 
 def test_get_duplicates_api_html_empty(monkeypatch):
     duplicates = []
     monkeypatch.setattr(lexeme_forms, 'get_duplicates', lambda wiki, language_code, lemma: duplicates)
     with lexeme_forms.app.test_client() as client:
         response = client.get('/api/v1/duplicates/www/de/lemma', headers={'Accept': 'text/html'})
     assert response.content_type == 'text/html; charset=utf-8'
     assert response.get_data(as_text=True) == ''
 
 minimal_template = {
     '@template_name': 'minimal-template',
     'language_code': 'en',
 }
 
 def test_if_needs_csrf_redirect_no_token(monkeypatch):
     monkeypatch.setattr(lexeme_forms, 'add_form_data_to_template', lambda form_data, template: True)
     monkeypatch.setattr(flask, 'render_template', lambda template_file_name, **kwargs: 'rendered template')
     with lexeme_forms.app.test_request_context():
         response = lexeme_forms.if_needs_csrf_redirect(minimal_template, False, {})
     assert response == 'rendered template'
     # TODO instead of monkeypatching, assert that form_data is correctly preserved (possibly in separate test)
 
 def test_if_needs_csrf_redirect_wrong_token(monkeypatch):
     monkeypatch.setattr(lexeme_forms, 'add_form_data_to_template', lambda form_data, template: True)
     monkeypatch.setattr(flask, 'render_template', lambda template_file_name, **kwargs: 'rendered template')
     with lexeme_forms.app.test_request_context() as context:
         context.session['_csrf_token'] = 'token 1'
         response = lexeme_forms.if_needs_csrf_redirect(minimal_template, False, {'_csrf_token': 'token 2'})
     assert response == 'rendered template'
 
 def test_if_needs_csrf_redirect_correct_token(monkeypatch):
     monkeypatch.setattr(lexeme_forms, 'add_form_data_to_template', lambda form_data, template: True)
     monkeypatch.setattr(flask, 'render_template', lambda template_file_name, **kwargs: 'rendered template')
     with lexeme_forms.app.test_request_context() as context:
         context.session['_csrf_token'] = 'token'
         response = lexeme_forms.if_needs_csrf_redirect(minimal_template, False, {'_csrf_token': 'token'})
     assert response is None
 
 def test_add_form_data_to_template():
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', 'noun'), ('form_representation', 'nouns')])
     template = {
         'forms': [
             {
                 'label': 'singular',
                 'example': 'One [thing].',
                 'grammatical_features_item_ids': ['Q110786'],
                 'value': 'Noun',
             },
             {
                 'label': 'plural',
                 'example': 'Two [things]',
                 'grammatical_features_item_ids': ['Q146786'],
             },
         ],
         'other_data': 'preserve',
     }
     new_template = lexeme_forms.add_form_data_to_template(form_data, template)
     assert new_template == {
         'forms': [
             {
                 'label': 'singular',
                 'example': 'One [thing].',
                 'grammatical_features_item_ids': ['Q110786'],
                 'value': 'noun',
             },
             {
                 'label': 'plural',
                 'example': 'Two [things]',
                 'grammatical_features_item_ids': ['Q146786'],
                 'value': 'nouns',
             },
         ],
         'other_data': 'preserve',
     }
 
 def test_add_form_data_to_template_no_overwrite():
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', 'noun'), ('form_representation', 'nouns')])
     template = {
         'forms': [
             {
                 'label': 'singular',
                 'example': 'One [thing].',
                 'grammatical_features_item_ids': ['Q110786'],
                 'value': 'Noun',
             },
             {
                 'label': 'plural',
                 'example': 'Two [things]',
                 'grammatical_features_item_ids': ['Q146786'],
             },
         ],
         'other_data': 'preserve',
     }
     new_template = lexeme_forms.add_form_data_to_template(form_data, template, overwrite=False)
     assert new_template == {
         'forms': [
             {
                 'label': 'singular',
                 'example': 'One [thing].',
                 'grammatical_features_item_ids': ['Q110786'],
                 'value': 'Noun',
             },
             {
                 'label': 'plural',
                 'example': 'Two [things]',
                 'grammatical_features_item_ids': ['Q146786'],
                 'value': 'nouns',
             },
         ],
         'other_data': 'preserve',
     }
 
 def test_add_form_data_to_template_lexeme_id():
     form_data = werkzeug.datastructures.ImmutableMultiDict([('lexeme_id', 'L123')])
     template = {'forms': []}
     new_template = lexeme_forms.add_form_data_to_template(form_data, template)
     assert new_template['lexeme_id'] == 'L123'
 
 def test_add_form_data_to_template_no_template_modification():
     form_data = werkzeug.datastructures.ImmutableMultiDict([('lexeme_id', 'L123')])
     template = {'forms': []}
     new_template = lexeme_forms.add_form_data_to_template(form_data, template)
     assert template is not new_template
     assert 'lexeme_id' not in template
 
 def test_current_url_index(monkeypatch):
     monkeypatch.setitem(lexeme_forms.app.config, 'APPLICATION_ROOT', '/')
     with lexeme_forms.app.test_request_context('/'):
         current_url = lexeme_forms.current_url()
         assert current_url == 'http://localhost/'
 
 def test_current_url_template(monkeypatch):
     monkeypatch.setitem(lexeme_forms.app.config, 'APPLICATION_ROOT', '/')
     with lexeme_forms.app.test_request_context('/template/foo/'):
         current_url = lexeme_forms.current_url()
         assert current_url == 'http://localhost/template/foo/'
 
 def test_current_url_template_advanced(monkeypatch):
     monkeypatch.setitem(lexeme_forms.app.config, 'APPLICATION_ROOT', '/')
     with lexeme_forms.app.test_request_context('/template/foo/advanced/'):
         current_url = lexeme_forms.current_url()
         assert current_url == 'http://localhost/template/foo/advanced/'
 
 def test_current_url_application_root(monkeypatch):
     monkeypatch.setitem(lexeme_forms.app.config, 'APPLICATION_ROOT', '/foo/')
     with lexeme_forms.app.test_request_context('/template/bar/'):
         current_url = lexeme_forms.current_url()
         assert current_url == 'http://localhost/foo/template/bar/'
 
 def test_current_url_arglist(monkeypatch):
     monkeypatch.setitem(lexeme_forms.app.config, 'APPLICATION_ROOT', '/')
     with lexeme_forms.app.test_request_context('/template/foo/?form_representation=X&form_representation=Y'):
         current_url = lexeme_forms.current_url()
         assert current_url == 'http://localhost/template/foo/?form_representation=X&form_representation=Y'
 
 def test_current_url_space(monkeypatch):
     monkeypatch.setitem(lexeme_forms.app.config, 'APPLICATION_ROOT', '/')
     with lexeme_forms.app.test_request_context('/template/foo/?form_representation=X%20Y%20Z'):
         current_url = lexeme_forms.current_url()
         assert current_url == 'http://localhost/template/foo/?form_representation=X%20Y%20Z'
 
 def test_current_url_encoded(monkeypatch):
     monkeypatch.setitem(lexeme_forms.app.config, 'APPLICATION_ROOT', '/')
     with lexeme_forms.app.test_request_context('/template/bokm%C3%A5l-noun-masculine/'):
         current_url = lexeme_forms.current_url()
         assert current_url == 'http://localhost/template/bokm%C3%A5l-noun-masculine/'
 
 def test_build_lexeme():
     template = {
         'language_item_id': 'Q1860',
         'language_code': 'en',
         'lexical_category_item_id': 'Q1084',
         'forms': [
             {
                 'grammatical_features_item_ids': ['Q110786'],
             },
             {
                 'grammatical_features_item_ids': ['Q146786'],
             },
         ],
     }
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', 'noun'), ('form_representation', 'nouns')])
     lexeme_data = lexeme_forms.build_lexeme(template, form_data)
     assert lexeme_data == {
         'type': 'lexeme',
         'forms': [
             {
                 'add': '',
                 'representations': {'en': {'language': 'en', 'value': 'noun'}},
                 'grammaticalFeatures': ['Q110786'],
                 'claims': {},
             },
             {
                 'add': '',
                 'representations': {'en': {'language': 'en', 'value': 'nouns'}},
                 'grammaticalFeatures': ['Q146786'],
                 'claims': {},
             },
         ],
         'lemmas': {'en': {'language': 'en', 'value': 'noun'}},
         'language': 'Q1860',
         'lexicalCategory': 'Q1084',
         'claims': {},
     }
 
 def test_build_lexeme_with_empty_lexeme_id():
     template = {
         'language_item_id': 'Q1860',
         'language_code': 'en',
         'lexical_category_item_id': 'Q1084',
         'forms': [
             {
                 'grammatical_features_item_ids': ['Q110786'],
             },
         ],
     }
     form_data = werkzeug.datastructures.ImmutableMultiDict([('lexeme_id', ''), ('form_representation', 'noun')])
     lexeme_data = lexeme_forms.build_lexeme(template, form_data)
     assert lexeme_data == {
         'type': 'lexeme',
         'forms': [
             {
                 'add': '',
                 'representations': {'en': {'language': 'en', 'value': 'noun'}},
                 'grammaticalFeatures': ['Q110786'],
                 'claims': {},
             },
         ],
         'lemmas': {'en': {'language': 'en', 'value': 'noun'}},
         'language': 'Q1860',
         'lexicalCategory': 'Q1084',
         'claims': {},
     }
 
 def test_build_lexeme_with_nonempty_lexeme_id(monkeypatch):
     monkeypatch.setattr(lexeme_forms, 'get_lexeme_data', lambda lexeme_id, wiki: {'language': 'Q1860', 'lexicalCategory': 'Q1084'})
     template = {
         'language_item_id': 'Q1860',
         'language_code': 'en',
         'lexical_category_item_id': 'Q1084',
         'forms': [
             {
                 'grammatical_features_item_ids': ['Q110786'],
             },
         ],
     }
     form_data = werkzeug.datastructures.ImmutableMultiDict([('lexeme_id', 'L123'), ('form_representation', 'noun')])
     lexeme_data = lexeme_forms.build_lexeme(template, form_data)
     assert lexeme_data == {
         'type': 'lexeme',
         'forms': [
             {
                 'add': '',
                 'representations': {'en': {'language': 'en', 'value': 'noun'}},
                 'grammaticalFeatures': ['Q110786'],
                 'claims': {},
             },
         ],
         'id': 'L123',
         'claims': {},
     }
 
 def test_build_lexeme_blank_form(monkeypatch):
     monkeypatch.setattr(lexeme_forms, 'get_lexeme_data', lambda lexeme_id, wiki: {'language': 'Q1860', 'lexicalCategory': 'Q1084'})
     template = {
         'language_item_id': 'Q1860',
         'language_code': 'en',
         'lexical_category_item_id': 'Q1084',
         'forms': [
             {
                 'grammatical_features_item_ids': ['Q110786'],
             },
             {
                 'grammatical_features_item_ids': ['Q146786'],
             },
         ],
     }
     form_data = werkzeug.datastructures.ImmutableMultiDict([('lexeme_id', 'L123'), ('form_representation', ''), ('form_representation', 'nouns')])
     lexeme_data = lexeme_forms.build_lexeme(template, form_data)
     assert lexeme_data == {
         'type': 'lexeme',
         'forms': [
             {
                 'add': '',
                 'representations': {'en': {'language': 'en', 'value': 'nouns'}},
                 'grammaticalFeatures': ['Q146786'],
                 'claims': {},
             },
         ],
         'id': 'L123',
         'claims': {},
     }
 
 def test_build_lexeme_with_statements():
     template = {
         'language_item_id': 'Q1860',
         'language_code': 'en',
         'lexical_category_item_id': 'Q1084',
         'forms': [
             {
                 'grammatical_features_item_ids': ['Q110786'],
                 'statements': 'singular test statements',
             },
             {
                 'grammatical_features_item_ids': ['Q146786'],
                 'statements': 'plural test statements',
             },
         ],
         'statements': 'lexeme test statements',
     }
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', 'noun'), ('form_representation', 'nouns')])
     lexeme_data = lexeme_forms.build_lexeme(template, form_data)
     assert lexeme_data == {
         'type': 'lexeme',
         'forms': [
             {
                 'add': '',
                 'representations': {'en': {'language': 'en', 'value': 'noun'}},
                 'grammaticalFeatures': ['Q110786'],
                 'claims': 'singular test statements',
             },
             {
                 'add': '',
                 'representations': {'en': {'language': 'en', 'value': 'nouns'}},
                 'grammaticalFeatures': ['Q146786'],
                 'claims': 'plural test statements',
             },
         ],
         'lemmas': {'en': {'language': 'en', 'value': 'noun'}},
         'language': 'Q1860',
         'lexicalCategory': 'Q1084',
         'claims': 'lexeme test statements',
     }
 
 def test_build_lexeme_with_variants():
     template = {
         'language_item_id': 'Q1860',
         'language_code': 'en',
         'lexical_category_item_id': 'Q1084',
         'forms': [
             {
                 'grammatical_features_item_ids': ['Q110786'],
             },
             {
                 'grammatical_features_item_ids': ['Q146786'],
             },
         ],
     }
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', 'noun/NOUN'), ('form_representation', 'nouns/NOUNS/nounS')])
     lexeme_data = lexeme_forms.build_lexeme(template, form_data)
     assert lexeme_data == {
         'type': 'lexeme',
         'forms': [
             {
                 'add': '',
                 'representations': {'en': {'language': 'en', 'value': 'noun'}},
                 'grammaticalFeatures': ['Q110786'],
                 'claims': {},
             },
             {
                 'add': '',
                 'representations': {'en': {'language': 'en', 'value': 'NOUN'}},
                 'grammaticalFeatures': ['Q110786'],
                 'claims': {},
             },
             {
                 'add': '',
                 'representations': {'en': {'language': 'en', 'value': 'nouns'}},
                 'grammaticalFeatures': ['Q146786'],
                 'claims': {},
             },
             {
                 'add': '',
                 'representations': {'en': {'language': 'en', 'value': 'NOUNS'}},
                 'grammaticalFeatures': ['Q146786'],
                 'claims': {},
             },
             {
                 'add': '',
                 'representations': {'en': {'language': 'en', 'value': 'nounS'}},
                 'grammaticalFeatures': ['Q146786'],
                 'claims': {},
             },
         ],
         'lemmas': {'en': {'language': 'en', 'value': 'noun'}},
         'language': 'Q1860',
         'lexicalCategory': 'Q1084',
         'claims': {},
     }
 
 def test_build_lexeme_with_statements_for_existing_lexeme(monkeypatch):
     p5185 = [
         {
             'mainsnak': {
                 'snaktype': 'value',
                 'property': 'P5185',
                 'datatype': 'wikibase-item',
                 'datavalue': {
                     'type': 'wikibase-entityid',
                     'value': {
                         'entity-type': 'item',
                         'id': 'Q499327',
                     },
                 },
             },
             'type': 'statement',
             'rank': 'normal',
         }
     ]
     p31 = [
         {
             'mainsnak': {
                 'snaktype': 'value',
                 'property': 'P31',
                 'datatype': 'wikibase-item',
                 'datavalue': {
                     'type': 'wikibase-entityid',
                     'value': {
                         'entity-type': 'item',
                         'id': 'Q604984',
                     },
                 },
             },
             'type': 'statement',
             'rank': 'normal',
         }
     ]
     monkeypatch.setattr(lexeme_forms, 'get_lexeme_data', lambda lexeme_id, wiki: {
         'language': 'Q1860',
         'lexicalCategory': 'Q1084',
         'claims': {
             'P5185': p5185,
         },
     })
     template = {
         'language_item_id': 'Q1860',
         'language_code': 'en',
         'lexical_category_item_id': 'Q1084',
         'forms': [
             {
                 'grammatical_features_item_ids': ['Q110786'],
                 'statements': 'singular test statements',
             },
             {
                 'grammatical_features_item_ids': ['Q146786'],
                 'statements': 'plural test statements',
             },
         ],
         'statements': {
             'P5185': p5185,
             'P31': p31,
         },
     }
     form_data = werkzeug.datastructures.ImmutableMultiDict([('lexeme_id', 'L123'), ('form_representation', 'noun'), ('form_representation', 'nouns')])
     lexeme_data = lexeme_forms.build_lexeme(template, form_data)
     assert lexeme_data == {
         'id': 'L123',
         'type': 'lexeme',
         'forms': [
             {
                 'add': '',
                 'representations': {'en': {'language': 'en', 'value': 'noun'}},
                 'grammaticalFeatures': ['Q110786'],
                 'claims': 'singular test statements',
             },
             {
                 'add': '',
                 'representations': {'en': {'language': 'en', 'value': 'nouns'}},
                 'grammaticalFeatures': ['Q146786'],
                 'claims': 'plural test statements',
             },
         ],
         'claims': {
             'P31': p31,
         },
     }
 
 def test_build_summary_localhost(monkeypatch):
     monkeypatch.setattr(lexeme_forms, 'current_url', lambda: 'http://localhost/template/foo/')
     template = {
         '@template_name': 'foo',
     }
     form_data = {}
     summary = lexeme_forms.build_summary(template, form_data)
     assert summary == 'foo'
 
 def test_build_summary_internet(monkeypatch):
     monkeypatch.setattr(lexeme_forms, 'current_url', lambda: 'https://example.com/lexeme-forms/template/foo/')
     template = {
         '@template_name': 'foo',
     }
     form_data = {}
     summary = lexeme_forms.build_summary(template, form_data)
     assert summary == 'foo'
 
 def test_build_summary_toolforge_lexeme_forms(monkeypatch):
     monkeypatch.setattr(lexeme_forms, 'current_url', lambda: 'https://tools.wmflabs.org/lexeme-forms/template/foo/')
     template = {
         '@template_name': 'foo',
     }
     form_data = {}
     summary = lexeme_forms.build_summary(template, form_data)
     assert summary == '[[toolforge:lexeme-forms/template/foo/|foo]]'
 
 def test_build_summary_toolforge_other(monkeypatch):
     monkeypatch.setattr(lexeme_forms, 'current_url', lambda: 'https://tools.wmflabs.org/other/template/foo/')
     template = {
         '@template_name': 'foo',
     }
     form_data = {}
     summary = lexeme_forms.build_summary(template, form_data)
     assert summary == '[[toolforge:other/template/foo/|foo]]'
 
 def test_build_summary_toolforge_lexeme_forms_advanced(monkeypatch):
     monkeypatch.setattr(lexeme_forms, 'current_url', lambda: 'https://tools.wmflabs.org/lexeme-forms/template/foo/advanced/')
     template = {
         '@template_name': 'foo',
     }
     form_data = {}
     summary = lexeme_forms.build_summary(template, form_data)
     assert summary == '[[toolforge:lexeme-forms/template/foo/advanced/|foo]]'
 
 def test_build_summary_toolforge_canonical_lexeme_forms(monkeypatch):
     monkeypatch.setattr(lexeme_forms, 'current_url', lambda: 'https://lexeme-forms.toolforge.org/template/foo/')
     template = {
         '@template_name': 'foo',
     }
     form_data = {}
     summary = lexeme_forms.build_summary(template, form_data)
     assert summary == '[[toolforge:lexeme-forms/template/foo/|foo]]'
 
 def test_build_summary_toolforge_canonical_other(monkeypatch):
     monkeypatch.setattr(lexeme_forms, 'current_url', lambda: 'https://other.toolforge.org/template/foo/')
     template = {
         '@template_name': 'foo',
     }
     form_data = {}
     summary = lexeme_forms.build_summary(template, form_data)
     assert summary == '[[toolforge:other/template/foo/|foo]]'
 
 def test_build_summary_toolforge_canonical_lexeme_forms_advanced(monkeypatch):
     monkeypatch.setattr(lexeme_forms, 'current_url', lambda: 'https://lexeme-forms.toolforge.org/template/foo/advanced/')
     template = {
         '@template_name': 'foo',
     }
     form_data = {}
     summary = lexeme_forms.build_summary(template, form_data)
     assert summary == '[[toolforge:lexeme-forms/template/foo/advanced/|foo]]'
 
 def test_build_summary_generated_via(monkeypatch):
     monkeypatch.setattr(lexeme_forms, 'current_url', lambda: 'https://tools.wmflabs.org/lexeme-forms/template/foo/')
     template = {
         '@template_name': 'foo',
     }
     form_data = {
         'generated_via': '[[toolforge:other/bar|other tool, bar]]'
     }
     summary = lexeme_forms.build_summary(template, form_data)
     assert summary == '[[toolforge:lexeme-forms/template/foo/|foo]], generated via [[toolforge:other/bar|other tool, bar]]'
 
 def test_build_summary_canonical_generated_via(monkeypatch):
     monkeypatch.setattr(lexeme_forms, 'current_url', lambda: 'https://lexeme-forms.toolforge.org/template/foo/')
     template = {
         '@template_name': 'foo',
     }
     form_data = {
         'generated_via': '[[toolforge:other/bar|other tool, bar]]'
     }
     summary = lexeme_forms.build_summary(template, form_data)
     assert summary == '[[toolforge:lexeme-forms/template/foo/|foo]], generated via [[toolforge:other/bar|other tool, bar]]'
 
 def test_get_all_templates_api():
     with lexeme_forms.app.test_client() as client:
         response = client.get('/api/v1/template/')
     assert response.status_code == 200
     assert response.content_type == 'application/json'
     for template in json.loads(response.get_data(as_text=True)).values():
         assert '@attribution' in template
 
 def test_get_template_api_exists():
     with lexeme_forms.app.test_client() as client:
         response = client.get('/api/v1/template/german-noun-feminine')
     assert response.status_code == 200
     assert response.content_type == 'application/json'
     template = json.loads(response.get_data(as_text=True))
     assert '@attribution' in template
 
 def test_get_template_api_missing():
     with lexeme_forms.app.test_client() as client:
         response = client.get('/api/v1/template/german-noun')
     assert response.status_code == 404
     # we don’t say that this is JSON,
     # but for the benefit of clients who try to deserialize the response without checking the headers,
     # we still want to reply with valid JSON
     json.loads(response.get_data(as_text=True))
     # the previous statement should not have thrown an exception
 
 
 def test_update_lexeme_add_dwarves_dwarrows():
     lexeme_data = {
         'lemmas': {'en': {'language': 'en', 'value': 'dwarf'}},
         'forms': [
             {'id': 'L22936-F1', 'representations': {'en': {'language': 'en', 'value': 'dwarf'}}, 'grammaticalFeatures': ['Q110786']},
             {'id': 'L22936-F2', 'representations': {'en': {'language': 'en', 'value': 'dwarfs'}}, 'grammaticalFeatures': ['Q146786']},
         ],
     }
     template = copy.deepcopy(templates['english-noun'])
     template['lexeme_revision'] = 123
     template['forms'][0]['lexeme_forms'] = [lexeme_data['forms'][0]]
     template['forms'][1]['lexeme_forms'] = [lexeme_data['forms'][1]]
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', 'dwarf'), ('form_representation', 'dwarfs/dwarves/dwarrows')])
     updated_lexeme_data = lexeme_forms.update_lexeme(lexeme_data, template, form_data, 'en')
     assert updated_lexeme_data == {
         'lemmas': {'en': {'language': 'en', 'value': 'dwarf'}},
         'forms': [
             {'id': 'L22936-F1', 'representations': {'en': {'language': 'en', 'value': 'dwarf'}}, 'grammaticalFeatures': ['Q110786']},
             {'id': 'L22936-F2', 'representations': {'en': {'language': 'en', 'value': 'dwarfs'}}, 'grammaticalFeatures': ['Q146786']},
             {'add': '', 'representations': {'en': {'language': 'en', 'value': 'dwarves'}}, 'grammaticalFeatures': ['Q146786'], 'claims': {}},
             {'add': '', 'representations': {'en': {'language': 'en', 'value': 'dwarrows'}}, 'grammaticalFeatures': ['Q146786'], 'claims': {}},
         ],
         'base_revision_id': 123,
     }
 
 def test_update_lexeme_match_forms():
     lexeme_data = {
         'lemmas': {'en': {'language': 'en', 'value': 'dwarf'}},
         'forms': [
             {'id': 'L22936-F1', 'representations': {'en': {'language': 'en', 'value': 'dwarf'}}, 'grammaticalFeatures': []},
             {'id': 'L22936-F2', 'representations': {'en': {'language': 'en', 'value': 'dwarfs'}}, 'grammaticalFeatures': []},
             {'id': 'L22936-F3', 'representations': {'en': {'language': 'en', 'value': 'dwarves'}}, 'grammaticalFeatures': []},
             {'id': 'L22936-F4', 'representations': {'en': {'language': 'en', 'value': 'dwarrows'}}, 'grammaticalFeatures': []},
         ],
     }
     template = copy.deepcopy(templates['english-noun'])
     template['lexeme_revision'] = 123
     template['unmatched_lexeme_forms'] = lexeme_data['forms'][:]
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', 'L22936-F1'), ('form_representation', 'L22936-F2/L22936-F3/L22936-F4')])
     updated_lexeme_data = lexeme_forms.update_lexeme(lexeme_data, template, form_data, 'en')
     assert updated_lexeme_data == {
         'lemmas': {'en': {'language': 'en', 'value': 'dwarf'}},
         'forms': [
             {'id': 'L22936-F1', 'representations': {'en': {'language': 'en', 'value': 'dwarf'}}, 'grammaticalFeatures': ['Q110786']},
             {'id': 'L22936-F2', 'representations': {'en': {'language': 'en', 'value': 'dwarfs'}}, 'grammaticalFeatures': ['Q146786']},
             {'id': 'L22936-F3', 'representations': {'en': {'language': 'en', 'value': 'dwarves'}}, 'grammaticalFeatures': ['Q146786']},
             {'id': 'L22936-F4', 'representations': {'en': {'language': 'en', 'value': 'dwarrows'}}, 'grammaticalFeatures': ['Q146786']},
         ],
         'base_revision_id': 123,
     }
 
 def test_update_lexeme_edit_lemma():
     lexeme_data = {
         'lemmas': {'en': {'language': 'en', 'value': 'fuschia'}},
         'forms': [
             {'id': 'L3280-F1', 'representations': {'en': {'language': 'en', 'value': 'fuschia'}}, 'grammaticalFeatures': ['Q3482678']},
         ],
     }
     template = copy.deepcopy(templates['english-adjective'])
     template['lexeme_revision'] = 123
     template['forms'][0]['lexeme_forms'] = [lexeme_data['forms'][0]]
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', 'fuchsia')])
     updated_lexeme_data = lexeme_forms.update_lexeme(lexeme_data, template, form_data, 'en')
     assert updated_lexeme_data == {
         'lemmas': {'en': {'language': 'en', 'value': 'fuchsia'}},
         'forms': [
             {'id': 'L3280-F1', 'representations': {'en': {'language': 'en', 'value': 'fuchsia'}}, 'grammaticalFeatures': ['Q3482678']},
         ],
         'base_revision_id': 123,
     }
 
 def test_update_lexeme_edit_lemma_new_form():
     lexeme_data = {
         'lemmas': {'en': {'language': 'en', 'value': 'fuschia'}},
         'forms': [],
     }
     template = copy.deepcopy(templates['english-adjective'])
     template['lexeme_revision'] = 123
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', 'fuchsia')])
     updated_lexeme_data = lexeme_forms.update_lexeme(lexeme_data, template, form_data, 'en')
     assert updated_lexeme_data == {
         'lemmas': {'en': {'language': 'en', 'value': 'fuchsia'}},
         'forms': [
             {'add': '', 'claims': {}, 'representations': {'en': {'language': 'en', 'value': 'fuchsia'}}, 'grammaticalFeatures': ['Q3482678']},
         ],
         'base_revision_id': 123,
     }
 
 def test_update_lexeme_different_language():
     lexeme_data = {
         'lemmas': {
             'de': {'language': 'de', 'value': 'Straße'},
         },
         'forms': [
             {
                 'id': 'L44061-F1',
                 'representations': {
                     'de': {'language': 'de', 'value': 'Straße'},
                 },
                 'grammaticalFeatures': ['Q110786', 'Q131105'],
             },
         ],
     }
     template = copy.deepcopy(templates['german-noun-feminine'])
     template['lexeme_revision'] = 123
     template['forms'][0]['lexeme_forms'] = [lexeme_data['forms'][0]]
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', 'Strasse')])
     updated_lexeme_data = lexeme_forms.update_lexeme(lexeme_data, template, form_data, 'de-ch')
     assert updated_lexeme_data == {
         'lemmas': {
             'de': {'language': 'de', 'value': 'Straße'},
             'de-ch': {'language': 'de-ch', 'value': 'Strasse'},
         },
         'forms': [
             {
                 'id': 'L44061-F1',
                 'representations': {
                     'de': {'language': 'de', 'value': 'Straße'},
                     'de-ch': {'language': 'de-ch', 'value': 'Strasse'},
                 },
                 'grammaticalFeatures': ['Q110786', 'Q131105'],
             },
         ],
         'base_revision_id': 123,
     }
 
 def test_update_lexeme_different_language_for_some_forms():
     lexeme_data = {
         'lemmas': {
             'de': {'language': 'de', 'value': 'müssen'},
             'de-1901': {'language': 'de-1901', 'value': 'müßen'},
         },
         'forms': [
             {
                 'id': 'L315210-F1',
                 'representations': {
                     'de': {'language': 'de', 'value': 'muss'},
                 },
                 'grammaticalFeatures': ['Q110786', 'Q1317831', 'Q192613', 'Q21714344', 'Q682111'],
             },
             {
                 'id': 'L315210-F2',
                 'representations': {
                     'de': {'language': 'de', 'value': 'müssen'},
                 },
                 'grammaticalFeatures': ['Q179230'],
             },
         ],
     }
     template = copy.deepcopy(templates['german-verb'])
     template['lexeme_revision'] = 123
     template['forms'][0]['lexeme_forms'] = [lexeme_data['forms'][1]]
     template['forms'][1]['lexeme_forms'] = [lexeme_data['forms'][0]]
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', ''), ('form_representation', 'muß')])
     updated_lexeme_data = lexeme_forms.update_lexeme(lexeme_data, template, form_data, 'de-1901')
     assert updated_lexeme_data == {
         'lemmas': {
             'de': {'language': 'de', 'value': 'müssen'},
         },
         'forms': [
             {
                 'id': 'L315210-F1',
                 'representations': {
                     'de': {'language': 'de', 'value': 'muss'},
                     'de-1901': {'language': 'de-1901', 'value': 'muß'},
                 },
                 'grammaticalFeatures': ['Q110786', 'Q1317831', 'Q192613', 'Q21714344', 'Q682111'],
             },
             {
                 'id': 'L315210-F2',
                 'representations': {
                     'de': {'language': 'de', 'value': 'müssen'},
                 },
                 'grammaticalFeatures': ['Q179230'],
             },
         ],
         'base_revision_id': 123,
     }
 
 def test_update_lexeme_noop():
     lexeme_data = {
         'lemmas': {'en': {'language': 'en', 'value': 'dwarf'}},
         'forms': [
             {'id': 'L22936-F1', 'representations': {'en': {'language': 'en', 'value': 'dwarf'}}, 'grammaticalFeatures': ['Q110786']},
             {'id': 'L22936-F2', 'representations': {'en': {'language': 'en', 'value': 'dwarfs'}}, 'grammaticalFeatures': ['Q146786']},
             {'id': 'L22936-F3', 'representations': {'en': {'language': 'en', 'value': 'dwarves'}}, 'grammaticalFeatures': ['Q146786']},
             {'id': 'L22936-F4', 'representations': {'en': {'language': 'en', 'value': 'dwarrows'}}, 'grammaticalFeatures': ['Q146786']},
             {'id': 'L22936-F5', 'representations': {'en': {'language': 'en', 'value': 'dweorgas'}}, 'grammaticalFeatures': ['Q146786']},
         ],
     }
     template = copy.deepcopy(templates['english-noun'])
     template['lexeme_revision'] = 123
     template['forms'][0]['lexeme_forms'] = [lexeme_data['forms'][0]]
     template['forms'][1]['lexeme_forms'] = [lexeme_data['forms'][1], lexeme_data['forms'][2], lexeme_data['forms'][3], lexeme_data['forms'][4]]
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', 'dwarf'), ('form_representation', 'dwarfs/dweorgas/dwarves/dwarrows')])
     updated_lexeme_data = lexeme_forms.update_lexeme(lexeme_data, template, form_data, 'en')
     assert updated_lexeme_data == {
         'lemmas': lexeme_data['lemmas'],
         'forms': lexeme_data['forms'],
         'base_revision_id': 123,
     }
 
 def test_update_lexeme_rematch_already_matched_form():
     lexeme_data = {'forms': [{'id': 'L4592-F1', 'representations': {'en': {'language': 'en', 'value': 'gold'}}, 'grammaticalFeatures': ['Q110786']}]}
     template = copy.deepcopy(templates['english-noun'])
     template['lexeme_revision'] = 123
     template['forms'][0]['lexeme_forms'] = [lexeme_data['forms'][0]]
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', 'gold'), ('form_representation', 'L4592-F1')])
     with pytest.raises(Exception):
         lexeme_forms.update_lexeme(lexeme_data, template, form_data)
 
 def test_update_lexeme_rematch_same_form_twice():
     lexeme_data = {'forms': [{'id': 'L4592-F1', 'representations': {'en': {'language': 'en', 'value': 'gold'}}, 'grammaticalFeatures': []}]}
     template = copy.deepcopy(templates['english-noun'])
     template['lexeme_revision'] = 123
     template['unmatched_lexeme_forms'] = lexeme_data['forms'][:]
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', 'L4592-F1'), ('form_representation', 'L4592-F1')])
     with pytest.raises(Exception):
         lexeme_forms.update_lexeme(lexeme_data, template, form_data)
 
 def test_update_lexeme_remove_form_representation():
     lexeme_data = {
         'lemmas': {
             'de': {'language': 'de', 'value': 'Straße'},
             'de-ch': {'language': 'de-ch', 'value': 'Strasse'},
         },
         'forms': [
             {
                 'id': 'L44061-F1',
                 'representations': {
                     'de': {'language': 'de', 'value': 'Straße'},
                     'de-ch': {'language': 'de-ch', 'value': 'Strasse'},
                 },
                 'grammaticalFeatures': ['Q110786', 'Q131105'],
             },
             {
                 'id': 'L44061-F2',
                 'representations': {
                     'de': {'language': 'de', 'value': 'Straße'},
                     'de-ch': {'language': 'de-ch', 'value': 'Strasse'},
                 },
                 'grammaticalFeatures': ['Q110786', 'Q146233'],
             },
         ],
     }
     template = copy.deepcopy(templates['german-noun-feminine'])
     template['lexeme_revision'] = 123
     template['forms'][0]['lexeme_forms'] = [lexeme_data['forms'][0]]
     template['forms'][1]['lexeme_forms'] = [lexeme_data['forms'][1]]
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', ''), ('form_representation', 'Strasse')])
     updated_lexeme_data = lexeme_forms.update_lexeme(lexeme_data, template, form_data, 'de-ch')
     assert updated_lexeme_data == {
         'lemmas': {
             'de': {'language': 'de', 'value': 'Straße'},
             'de-ch': {'language': 'de-ch', 'value': 'Strasse', 'remove': ''},
         },
         'forms': [
             {
                 'id': 'L44061-F1',
                 'representations': {
                     'de': {'language': 'de', 'value': 'Straße'},
                     'de-ch': {'language': 'de-ch', 'value': 'Strasse', 'remove': ''},
                 },
                 'grammaticalFeatures': ['Q110786', 'Q131105'],
             },
             {
                 'id': 'L44061-F2',
                 'representations': {
                     'de': {'language': 'de', 'value': 'Straße'},
                     'de-ch': {'language': 'de-ch', 'value': 'Strasse'},
                 },
                 'grammaticalFeatures': ['Q110786', 'Q146233'],
             },
         ],
         'base_revision_id': 123,
     }
 
 def test_update_lexeme_remove_main_form_representation():
     lexeme_data = {
         'lemmas': {
             'de': {'language': 'de', 'value': 'Straße'},
             'de-ch': {'language': 'de-ch', 'value': 'Strasse'},
         },
         'forms': [
             {
                 'id': 'L44061-F1',
                 'representations': {
                     'de': {'language': 'de', 'value': 'Straße'},
                     'de-ch': {'language': 'de-ch', 'value': 'Strasse'},
                 },
                 'grammaticalFeatures': ['Q110786', 'Q131105'],
             },
             {
                 'id': 'L44061-F2',
                 'representations': {
                     'de': {'language': 'de', 'value': 'Straße'},
                     'de-ch': {'language': 'de-ch', 'value': 'Strasse'},
                 },
                 'grammaticalFeatures': ['Q110786', 'Q146233'],
             },
         ],
     }
     template = copy.deepcopy(templates['german-noun-feminine'])
     template['lexeme_revision'] = 123
     template['forms'][0]['lexeme_forms'] = [lexeme_data['forms'][0]]
     template['forms'][1]['lexeme_forms'] = [lexeme_data['forms'][1]]
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', ''), ('form_representation', 'Straße')])
     updated_lexeme_data = lexeme_forms.update_lexeme(lexeme_data, template, form_data, 'de')
     assert updated_lexeme_data == {
         'lemmas': {
             'de': {'language': 'de', 'value': 'Straße', 'remove': ''},
             'de-ch': {'language': 'de-ch', 'value': 'Strasse'},
         },
         'forms': [
             {
                 'id': 'L44061-F1',
                 'representations': {
                     'de': {'language': 'de', 'value': 'Straße', 'remove': ''},
                     'de-ch': {'language': 'de-ch', 'value': 'Strasse'},
                 },
                 'grammaticalFeatures': ['Q110786', 'Q131105'],
             },
             {
                 'id': 'L44061-F2',
                 'representations': {
                     'de': {'language': 'de', 'value': 'Straße'},
                     'de-ch': {'language': 'de-ch', 'value': 'Strasse'},
                 },
                 'grammaticalFeatures': ['Q110786', 'Q146233'],
             },
         ],
         'base_revision_id': 123,
     }
 
 
 @pytest.mark.parametrize('user, expected', [
     ('علاء', 'm'),
     ('Harmonia Amanda', 'f'),
     ('Nikki', 'n'),
     (None, 'n'),
 ])
 def test_get_gender(user, expected):
     with lexeme_forms.app.test_request_context():
         assert lexeme_forms.get_gender(user) == expected
 
 
 @pytest.mark.parametrize('template_name', templates.keys())
 def test_integration_edit(template_name):
     """Create a lexeme from a template, then match it against the same template.
 
     If this fails, then there might be a bug when creating or matching lexemes,
     or the template might have ambiguous forms."""
     template = templates[template_name]
     form_data = werkzeug.datastructures.ImmutableMultiDict([('form_representation', str(index)) for index in range(0, len(template['forms']))])
     lexeme_data = lexeme_forms.build_lexeme(template, form_data)
     matched_template = matching.match_lexeme_forms_to_template(lexeme_data['forms'], template)
     assert matched_template.get('ambiguous_lexeme_forms') is None
     assert matched_template.get('unmatched_lexeme_forms') is None
     for index, form in enumerate(matched_template['forms']):
         assert len(form['lexeme_forms']) == 1
         assert form['lexeme_forms'][0]['representations'][template['language_code']]['value'] == str(index)
diff --git a/test_parse_tpsv.py b/test_parse_tpsv.py
index 59a24e0..c0b189b 100644
--- a/test_parse_tpsv.py
+++ b/test_parse_tpsv.py
@@ -1,63 +1,63 @@
 import pytest
 from werkzeug.datastructures import ImmutableMultiDict
 
 import parse_tpsv
 
 
 @pytest.mark.parametrize('line, expected_representations', [
     ('thing|things', ['thing', 'things']),
     ('thing\tthings', ['thing', 'things']),
     (' thing    \t  things  ', ['thing', 'things']),
     ('thing|', ['thing', '']),
     ('|things', ['', 'things']),
 ])
 def test_parse_lexeme_two_forms_no_lexeme_id(line, expected_representations):
     template = { 'forms': [ {}, {} ] }
     actual_data = parse_tpsv.parse_lexeme(line, template)
     actual_representations = actual_data.getlist('form_representation')
     assert expected_representations == actual_representations
 
 
 @pytest.mark.parametrize('line, expected_representations', [
     ('thing|things\tthinges', ['thing', 'things', 'thinges']),
     ('thing||things', ['thing', '', 'things']),
 ])
 def test_parse_lexeme_three_forms_no_lexeme_id(line, expected_representations):
     template = { 'forms': [ {}, {}, {} ] }
     actual_data = parse_tpsv.parse_lexeme(line, template)
     actual_representations = actual_data.getlist('form_representation')
     assert expected_representations == actual_representations
 
 
 @pytest.mark.parametrize('line, expected_lexeme_id, expected_representations', [
     ('L123|thing|things', 'L123', ['thing', 'things']),
     ('L123\tthing\tthings', 'L123', ['thing', 'things']),
 ])
 def test_parse_lexeme_two_forms_lexeme_id(line, expected_lexeme_id, expected_representations):
     template = { 'forms': [ {}, {} ] }
     actual_data = parse_tpsv.parse_lexeme(line, template)
-    [actual_lexeme_id] = actual_data.getlist('lexeme_id') # unpack + getlist guards against extra lexeme IDs
+    [actual_lexeme_id] = actual_data.getlist('lexeme_id')  # unpack + getlist guards against extra lexeme IDs
     actual_representations = actual_data.getlist('form_representation')
     assert expected_lexeme_id == actual_lexeme_id
     assert expected_representations == actual_representations
 
 
 def test_parse_lexemes():
     tpsv = '''
 thing|things
 
 \r
 
 L123|entity|entities
 '''.strip()
     assert parse_tpsv.parse_lexemes(tpsv, { 'forms': [ {}, {} ] }) == [
         ImmutableMultiDict([
             ('form_representation', 'thing'),
             ('form_representation', 'things'),
         ]),
         ImmutableMultiDict([
             ('lexeme_id', 'L123'),
             ('form_representation', 'entity'),
             ('form_representation', 'entities'),
         ]),
     ]