diff --git a/wikidict/check_word.py b/wikidict/check_word.py
index ef4b9e68..41c323ec 100644
--- a/wikidict/check_word.py
+++ b/wikidict/check_word.py
@@ -153,7 +153,7 @@ def filter_html(html: str, locale: str) -> str:
     elif locale == "en":
         for span in bs.find_all("span"):
             if span.string == "and other forms":
-                span.string += f' {span["title"]}'
+                span.string += f" {span['title']}"
         # other anchors
         for a in bs.find_all("a", href=True):
             if a["href"].lower().startswith(("#cite", "#mw")):
diff --git a/wikidict/lang/da/__init__.py b/wikidict/lang/da/__init__.py
index d885aefc..bcc90b38 100644
--- a/wikidict/lang/da/__init__.py
+++ b/wikidict/lang/da/__init__.py
@@ -26,7 +26,7 @@
     "noun",
     "personligt prononmen",
     "possessivt prononmen",
-    "possessivt pronomen" "possessivt pronomen (ejestedord)" "præfiks",
+    "possessivt pronomenpossessivt pronomen (ejestedord)præfiks",
     "prefix",
     "pronomen",
     "prœposition",
diff --git a/wikidict/lang/el/__init__.py b/wikidict/lang/el/__init__.py
index bfb75c92..3dce6f28 100644
--- a/wikidict/lang/el/__init__.py
+++ b/wikidict/lang/el/__init__.py
@@ -301,7 +301,7 @@ def labels_output(text_in: str, *, args: dict[str, str] = defaultdict(str)) -> s
             if isinstance(all_labels, list):
                 all_labels = all_labels[0]
             if all_labels.get("link") not in {None, "πατρότητα"}:
-                mytext = show or f'{italic(all_labels["linkshow"])}'
+                mytext = show or f"{italic(all_labels['linkshow'])}"
         mytext = mytext if noparenthesis else f"({mytext})"
     return mytext
 
diff --git a/wikidict/lang/en/template_handlers.py b/wikidict/lang/en/template_handlers.py
index 85fdb6d4..028d3851 100644
--- a/wikidict/lang/en/template_handlers.py
+++ b/wikidict/lang/en/template_handlers.py
@@ -293,7 +293,7 @@ def render_coinage(tpl: str, parts: list[str], data: defaultdict[str, str], *, w
         phrase += " "
     phrase += f"{p}"
     if data["in"]:
-        phrase += f' in {data["in"]}'
+        phrase += f" in {data['in']}"
     return phrase
 
 
@@ -567,7 +567,7 @@ def render_foreign_derivation(tpl: str, parts: list[str], data: defaultdict[str,
     elif word:
         phrase += f" {italic(word)}"
     if data["g"]:
-        phrase += f' {gender_number_specs(data["g"])}'
+        phrase += f" {gender_number_specs(data['g'])}"
     trans = "" if data["tr"] else transliterate(dst_locale, word)
     if parts:
         gloss = parts.pop(0)  # 5, t=, gloss=
@@ -636,7 +636,7 @@ def render_given_name(tpl: str, parts: list[str], data: defaultdict[str, str], *
     """
     parts.pop(0)  # language
     gender = data["gender"] or (parts.pop(0) if parts else "")
-    gender += f' or {data["or"]}' if data["or"] else ""
+    gender += f" or {data['or']}" if data["or"] else ""
     art = data["A"] or "A"
     phrase = f"{art} "
     dimtext = join_names(data, "dim", " or ", include_langname=False, key_alias="diminutive")
@@ -863,7 +863,7 @@ def render_lit(tpl: str, parts: list[str], data: defaultdict[str, str], *, word:
     """
     starter = "Used other than figuratively or idiomatically"
     if data["qualifier"]:
-        phrase = f'{data["qualifier"]} {starter.lower()}'
+        phrase = f"{data['qualifier']} {starter.lower()}"
     else:
         phrase = starter
     parts.pop(0)  # language
@@ -1297,7 +1297,7 @@ def render_si_unit_2(tpl: str, parts: list[str], data: defaultdict[str, str], *,
     category = data["3"] or (parts.pop(0) if parts else "")
     alt = data["3"] or (parts.pop(0) if parts else "")
     exp = prefix_to_exp.get(prefix, "")
-    return f"({italic('metrology')}) An SI unit of {category} equal to 10{superscript(exp)} {unit}s; alternative spelling of {italic(prefix+alt)}."
+    return f"({italic('metrology')}) An SI unit of {category} equal to 10{superscript(exp)} {unit}s; alternative spelling of {italic(prefix + alt)}."
 
 
 def render_si_unit_abb(tpl: str, parts: list[str], data: defaultdict[str, str], *, word: str = "") -> str:
@@ -1309,7 +1309,7 @@ def render_si_unit_abb(tpl: str, parts: list[str], data: defaultdict[str, str],
     unit = data["2"] or (parts.pop(0) if parts else "")
     category = data["3"] or (parts.pop(0) if parts else "")
     exp = prefix_to_exp.get(prefix, "")
-    return f"({italic('metrology')}) {italic('Symbol for')} {strong(prefix+unit)}, an SI unit of {category} equal to 10{superscript(exp)} {unit}s"
+    return f"({italic('metrology')}) {italic('Symbol for')} {strong(prefix + unit)}, an SI unit of {category} equal to 10{superscript(exp)} {unit}s"
 
 
 def render_surface_analysis(tpl: str, parts: list[str], data: defaultdict[str, str], *, word: str = "") -> str:
diff --git a/wikidict/lang/eo/template_handlers.py b/wikidict/lang/eo/template_handlers.py
index a91608c3..daa10556 100644
--- a/wikidict/lang/eo/template_handlers.py
+++ b/wikidict/lang/eo/template_handlers.py
@@ -58,7 +58,7 @@ def render_elpropra(tpl: str, parts: list[str], data: defaultdict[str, str], *,
         phrase += f" {italic(ts)}"
 
     if special := data["not"]:
-        phrase += f" {small('('+special+')')}"
+        phrase += f" {small('(' + special + ')')}"
 
     return phrase
 
diff --git a/wikidict/lang/es/__init__.py b/wikidict/lang/es/__init__.py
index 680d24f9..d1ad67af 100644
--- a/wikidict/lang/es/__init__.py
+++ b/wikidict/lang/es/__init__.py
@@ -319,7 +319,7 @@ def last_template_handler(template: tuple[str, ...], locale: str, *, word: str =
                     added.add(local_phrase)
                     sindex = str(index) if index > 1 else ""
                     if data[f"nota{sindex}"]:
-                        local_phrase += f' ({data[f"nota{sindex}"]})'
+                        local_phrase += f" ({data[f'nota{sindex}']})"
                 else:
                     local_phrase = part
             if index > 1 and local_phrase in lowercase_italic:
@@ -329,7 +329,7 @@ def last_template_handler(template: tuple[str, ...], locale: str, *, word: str =
                 append_to_last = False
             else:
                 phrase_a.append(local_phrase)
-        return italic(f'({concat(phrase_a, ", ")})') if phrase_a else ""
+        return italic(f"({concat(phrase_a, ', ')})") if phrase_a else ""
 
     if lang := langs.get(template[0]):
         return capitalize(lang)
diff --git a/wikidict/lang/es/template_handlers.py b/wikidict/lang/es/template_handlers.py
index a2191578..13593f5c 100644
--- a/wikidict/lang/es/template_handlers.py
+++ b/wikidict/lang/es/template_handlers.py
@@ -101,7 +101,7 @@ def render_afi(tpl: str, parts: list[str], data: defaultdict[str, str], *, word:
     >>> render_afi("IPA", ["/oː/"], defaultdict(str))
     '/oː/ <small>(AFI)</small>'
     """
-    return concat(parts, ", ") + f' {small("(AFI)")}'
+    return concat(parts, ", ") + f" {small('(AFI)')}"
 
 
 def render_aumentativo(tpl: str, parts: list[str], data: defaultdict[str, str], *, word: str = "") -> str:
@@ -167,7 +167,7 @@ def render_comparativo(tpl: str, parts: list[str], data: defaultdict[str, str],
     word = parts[0] if parts else ""
     start = "Comparativo"
     if data["tipo"]:
-        start += f' {data["tipo"]}'
+        start += f" {data['tipo']}"
     if data["i"] or data["irr"] or data["irreg"] or data["irregular"]:
         start += " irregular"
     start += " de"
@@ -572,7 +572,7 @@ def render_forma(tpl: str, parts: list[str], data: defaultdict[str, str], *, wor
         start = f"Forma del {concat([caso, numero, genero], ' ')} de"
     phrase = f"{italic(capitalize(start))} {parts[0]}"
     if data["texto_pos"]:
-        phrase += f'{data["texto_pos"]}'
+        phrase += f"{data['texto_pos']}"
     return phrase
 
 
@@ -639,7 +639,7 @@ def render_grafia(tpl: str, parts: list[str], data: defaultdict[str, str], *, wo
     phrase = f"{italic(start)} "
     phrase += render_l("l", [data["alt"] or parts[0]], data)
     if data["texto_pos"]:
-        phrase += f' {italic(data["texto_pos"])}'
+        phrase += f" {italic(data['texto_pos'])}"
     return phrase
 
 
@@ -733,7 +733,7 @@ def render_superlativo(tpl: str, parts: list[str], data: defaultdict[str, str],
     if data["glosa"]:
         local_phrase.append(f'"{data["glosa"]}"')
     if local_phrase:
-        phrase += f' ({concat(local_phrase, ", ")})'
+        phrase += f" ({concat(local_phrase, ', ')})"
     if not data["def"] and not parts:
         phrase += f":&nbsp;sumamente {word}"
     return phrase
diff --git a/wikidict/lang/fr/__init__.py b/wikidict/lang/fr/__init__.py
index 92412476..21198750 100644
--- a/wikidict/lang/fr/__init__.py
+++ b/wikidict/lang/fr/__init__.py
@@ -851,7 +851,7 @@ def last_template_handler(template: tuple[str, ...], locale: str, *, word: str =
         return phrase
 
     if tpl in ("ellipse", "par ellipse"):
-        return f'{italic("(Ellipse de")} {data["de"]}{italic(")")}' if data["de"] else term("Par ellipse")
+        return f"{italic('(Ellipse de')} {data['de']}{italic(')')}" if data["de"] else term("Par ellipse")
 
     if tpl == "R:DAF6":
         w = parts[0] if parts else word
diff --git a/wikidict/lang/fr/arabiser.py b/wikidict/lang/fr/arabiser.py
index 27d785e9..2356ee35 100644
--- a/wikidict/lang/fr/arabiser.py
+++ b/wikidict/lang/fr/arabiser.py
@@ -767,61 +767,61 @@ def appliquer(scheme: str, racine: str, *, var: str = "") -> str:  # pragma: no
                 # la lettre en position +2 est-elle une finale de syllable ?
                 if nature(scheme, position + 2)[0] in {"f", "d"}:
                     if racine[1] == "w":
-                        scheme = f"{scheme[:position - 1]}u{scheme[position + 2:]}"
+                        scheme = f"{scheme[: position - 1]}u{scheme[position + 2 :]}"
                     else:
-                        scheme = f"{scheme[:position - 1]}i{scheme[position + 2:]}"
+                        scheme = f"{scheme[: position - 1]}i{scheme[position + 2 :]}"
                 else:
-                    scheme = f"{scheme[:position - 1]}â{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}â{scheme[position + 2 :]}"
 
             elif contexte == "a2a" and position != 2:
                 # la lettre en position +2 est-elle une finale de syllable ?
                 if nature(scheme, position + 2)[0] == "f":
-                    scheme = f"{scheme[:position - 1]}a{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}a{scheme[position + 2 :]}"
                 else:
-                    scheme = f"{scheme[:position - 1]}â{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}â{scheme[position + 2 :]}"
 
             # a2i remplacé par â ou i
             elif contexte == "a2i":
                 # la lettre en position +2 est-elle une finale de syllable ?
                 if nature(scheme, position + 2)[0] in {"f", "d"}:
-                    scheme = f"{scheme[:position - 1]}i{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}i{scheme[position + 2 :]}"
                 else:
-                    scheme = f"{scheme[:position - 1]}â{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}â{scheme[position + 2 :]}"
 
             # a2u remplacé par â ou u
             elif contexte == "a2u":
                 # la lettre en position +2 est-elle une finale de syllable ?
                 if nature(scheme, position + 2)[0] in {"f", "d"}:
-                    scheme = f"{scheme[:position - 1]}u{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}u{scheme[position + 2 :]}"
                 else:
-                    scheme = f"{scheme[:position - 1]}â{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}â{scheme[position + 2 :]}"
 
             # a2î remplacé par âyi dans ar-*a*î*ũ
             elif contexte == "a2î":
-                scheme = f"{scheme[:position - 1]}âyi{scheme[position + 2:]}"
+                scheme = f"{scheme[: position - 1]}âyi{scheme[position + 2 :]}"
 
             # a2²i remplacé par ay²i mais pas dans ar-mu*a2²i*ũ (forme 2 invariable)
             elif contexte == "a2²i" and scheme != "mu1a2²iµũ":
-                scheme = f"{scheme[:position - 1]}ay²i{scheme[position + 2:]}"
+                scheme = f"{scheme[: position - 1]}ay²i{scheme[position + 2 :]}"
 
             # âwi : remplacé par â'i sauf formes verbales 2, 3, 5 et 6
             elif contexte == "â2i":
-                scheme = f"{scheme[:position - 1]}â'i{scheme[position + 2:]}"
+                scheme = f"{scheme[: position - 1]}â'i{scheme[position + 2 :]}"
 
             # i2° remplacé par î
             elif contexte == "i2°":
-                scheme = f"{scheme[:position - 1]}î{scheme[position + 2:]}"
+                scheme = f"{scheme[: position - 1]}î{scheme[position + 2 :]}"
 
             # iwâ remplacé par iyâ
             elif contexte == "i2â":
-                scheme = f"{scheme[:position - 1]}iyâ{scheme[position + 2:]}"
+                scheme = f"{scheme[: position - 1]}iyâ{scheme[position + 2 :]}"
 
             # uwi (passif) remplacé par î ou i
             elif contexte == "u2i":
                 if nature(scheme, position + 2)[0] in {"f", "d"}:
-                    scheme = f"{scheme[:position - 1]}i{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}i{scheme[position + 2 :]}"
                 else:
-                    scheme = f"{scheme[:position - 1]}î{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}î{scheme[position + 2 :]}"
 
             # °2a : problème à l'impératif pour toutes ces formes : quand l'impératif se termine par
             # la troisième radicale, celle-ci doit fermer la syllabe, et non ouvrir sur une terminaison.
@@ -829,45 +829,45 @@ def appliquer(scheme: str, racine: str, *, var: str = "") -> str:  # pragma: no
                 # °wa : â si la syllable longue est possible, a sinon
                 suite = nature(scheme, position + 2)
                 if suite == "ff":
-                    scheme = f"{scheme[:position]}a{scheme[position + 2:]}"
+                    scheme = f"{scheme[:position]}a{scheme[position + 2 :]}"
                 elif suite[0] == "f":
-                    scheme = f"{scheme[:position]}a{scheme[position + 2:]}"
+                    scheme = f"{scheme[:position]}a{scheme[position + 2 :]}"
                 elif suite[0] == "d":
-                    scheme = f"{scheme[:position]}a{scheme[position + 2:]}"
+                    scheme = f"{scheme[:position]}a{scheme[position + 2 :]}"
                 else:
-                    scheme = f"{scheme[:position]}â{scheme[position + 2:]}"
+                    scheme = f"{scheme[:position]}â{scheme[position + 2 :]}"
             # °2â : â, et w supprimé
             elif contexte == "°2â":
                 # distinction entre le nom verbal de la forme (iv) **â*ũ
                 # et le pluriel irrégulier a**â*ũ (régulier) & mi**â*ũ régulier
                 if scheme[0] == "a" or scheme[:2] == "mi":
-                    scheme = f"{scheme[:position]}wâ{scheme[position + 2:]}"
+                    scheme = f"{scheme[:position]}wâ{scheme[position + 2 :]}"
                 else:
-                    scheme = f"{scheme[:position]}â{scheme[position + 2:]}"
+                    scheme = f"{scheme[:position]}â{scheme[position + 2 :]}"
 
             # °2i : î si la syllable longue est possible, i sinon
             elif contexte == "°2i":
                 if nature(scheme, position + 2)[0] == "f":
-                    scheme = f"{scheme[:position]}i{scheme[position + 2:]}"
+                    scheme = f"{scheme[:position]}i{scheme[position + 2 :]}"
                 else:
-                    scheme = f"{scheme[:position]}î{scheme[position + 2:]}"
+                    scheme = f"{scheme[:position]}î{scheme[position + 2 :]}"
 
             # °2u : û si la syllable longue est possible, u sinon
             elif contexte == "°2u":
                 if nature(scheme, position + 2)[0] in {"f", "d"}:
-                    scheme = f"{scheme[:position]}u{scheme[position + 2:]}"
+                    scheme = f"{scheme[:position]}u{scheme[position + 2 :]}"
                 else:
-                    scheme = f"{scheme[:position]}û{scheme[position + 2:]}"
+                    scheme = f"{scheme[:position]}û{scheme[position + 2 :]}"
 
             # °2û remplacé par û ou î (participe passif)
             elif contexte == "°2û":
                 if racine[1] == "w":
-                    scheme = f"{scheme[:position]}û{scheme[position + 2:]}"
+                    scheme = f"{scheme[:position]}û{scheme[position + 2 :]}"
                 else:
-                    scheme = f"{scheme[:position]}î{scheme[position + 2:]}"
+                    scheme = f"{scheme[:position]}î{scheme[position + 2 :]}"
 
             elif contexte == "°û":
-                scheme = f"{scheme[:position]}û{scheme[position + 2:]}"
+                scheme = f"{scheme[:position]}û{scheme[position + 2 :]}"
 
             # voiture balai : on remplace tous les "2" par la lettre radicale :
             scheme = scheme.replace("2", racine[1])
@@ -879,7 +879,7 @@ def appliquer(scheme: str, racine: str, *, var: str = "") -> str:  # pragma: no
         if position > -1:
             # première forme, suppression du w dans les formes w2i3, sauf dans les verbes sourds (2=3)
             if scheme[position + 2] == "i" and var == "(1)" and racine[1] != racine[2]:
-                scheme = f"{scheme[:-1]}{scheme[position + 1:]}"
+                scheme = f"{scheme[:-1]}{scheme[position + 1 :]}"
             # huitième forme : iwta2a3 => it²a2a3 : à faire à la main, la forme i*ta*a*a est une "exception régulière"
 
     # fin verbes assimilés en W
@@ -910,7 +910,7 @@ def appliquer(scheme: str, racine: str, *, var: str = "") -> str:  # pragma: no
             if nature2 == "io" and (var != "" or var == "" and scheme[position2 - 1] not in "aiu"):
                 if est_voyelle(scheme[position2 - 1]):  # ie, la première radicale est vocalisée
                     # alors on peut supprimer la deuxième radicale
-                    scheme = f"{scheme[:position3 - 1]}{scheme[position3:]}"
+                    scheme = f"{scheme[: position3 - 1]}{scheme[position3:]}"
                 else:
                     # sinon on transfère la voyelle de la deuxième radicale sur la première
                     scheme = "".join(
@@ -945,7 +945,7 @@ def appliquer(scheme: str, racine: str, *, var: str = "") -> str:  # pragma: no
             if est_voyelle(scheme[position3 - 1]):
                 # ie, la deuxième radicale est vocalisée
                 # alors on peut supprimer la troisième radicale
-                scheme = f"{scheme[:position4 - 1]}{scheme[position4:]}"
+                scheme = f"{scheme[: position4 - 1]}{scheme[position4:]}"
             else:
                 # sinon on transfère la voyelle de la troisième radicale sur la deuxième
                 scheme = "".join(
@@ -969,7 +969,7 @@ def appliquer(scheme: str, racine: str, *, var: str = "") -> str:  # pragma: no
         scheme = sub(r"µ²", "µµ", scheme, count=1)  # homogénéisation des cas
         position3 = scheme.find("µµ")
         if not est_voyelle(scheme[position3 + 2]) or not scheme[position3 + 2]:
-            scheme = f"{scheme[:position3 - 1]}a{scheme[position3 + 1:]}"
+            scheme = f"{scheme[: position3 - 1]}a{scheme[position3 + 1 :]}"
 
     scheme = scheme.replace("2", racine[1])
 
@@ -1000,11 +1000,11 @@ def appliquer(scheme: str, racine: str, *, var: str = "") -> str:  # pragma: no
                     if position == len(scheme) - 1:
                         # position finale
                         if position == 5 and scheme[1] == "a":  # première forme
-                            scheme = f"{scheme[:position - 1]}â{scheme[position + 2:]}"
+                            scheme = f"{scheme[: position - 1]}â{scheme[position + 2 :]}"
                         else:
-                            scheme = f"{scheme[:position - 1]}é{scheme[position + 2:]}"
+                            scheme = f"{scheme[: position - 1]}é{scheme[position + 2 :]}"
                     else:
-                        scheme = f"{scheme[:position - 1]}a{scheme[position + 2:]}"
+                        scheme = f"{scheme[: position - 1]}a{scheme[position + 2 :]}"
 
                 # test sur première forme
                 elif contexte == "a3â":
@@ -1012,125 +1012,125 @@ def appliquer(scheme: str, racine: str, *, var: str = "") -> str:  # pragma: no
                     if (
                         position == len(scheme) - 3 and scheme[position + 2 : position + 4] == "ni" and (var != "")
                     ):  # les duels ne sont pas concernés.
-                        scheme = f"{scheme[:position - 1]}ayâ{scheme[position + 2:]}"
+                        scheme = f"{scheme[: position - 1]}ayâ{scheme[position + 2 :]}"
                     else:
-                        scheme = f"{scheme[:position]}{racine[2]}{scheme[position + 1:]}"
+                        scheme = f"{scheme[:position]}{racine[2]}{scheme[position + 1 :]}"
 
                 elif contexte == "a3@":
-                    scheme = f"{scheme[:position - 1]}â@{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}â@{scheme[position + 2 :]}"
 
                 elif contexte == "a3î":
-                    scheme = f"{scheme[:position - 1]}ay{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}ay{scheme[position + 2 :]}"
 
                 elif contexte == "a3u":
-                    scheme = f"{scheme[:position - 1]}é{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}é{scheme[position + 2 :]}"
 
                 elif contexte == "a3û":
-                    scheme = f"{scheme[:position - 1]}aw{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}aw{scheme[position + 2 :]}"
 
                 elif contexte == "a3ũ":
                     # Pb ici, "ã" pour *a*a*ũ, *i*a*ũ et *u*a*ũ, "ãé" sinon. Cf. Palmer §50 p100
                     if shemeinit in {"1a2aµũ", "1i2aµũ", "1u2aµũ"}:
-                        scheme = f"{scheme[:position - 1]}ã"
+                        scheme = f"{scheme[: position - 1]}ã"
                     else:
-                        scheme = f"{scheme[:position - 1]}ãé"
+                        scheme = f"{scheme[: position - 1]}ãé"
 
                 elif contexte == "a3ã":
                     # Pb ici, "ã" pour *a*a*ũ, *i*a*ũ et *u*a*ũ, "ãé" sinon. Cf. Palmer §50 p100
                     if shemeinit in {"1a2aµã", "1i2aµã", "1u2aµã"}:
-                        scheme = f"{scheme[:position - 1]}ã"
+                        scheme = f"{scheme[: position - 1]}ã"
                     else:
-                        scheme = f"{scheme[:position - 1]}ãé"
+                        scheme = f"{scheme[: position - 1]}ãé"
 
                 elif contexte == "a3ĩ":
                     # Pb ici, "ã" pour *a*a*ũ, *i*a*ũ et *u*a*ũ, "ãé" sinon. Cf. Palmer §50 p100
                     if shemeinit in {"1a2aµĩ", "1i2aµĩ", "1u2aµĩ"}:
-                        scheme = f"{scheme[:position - 1]}ã"
+                        scheme = f"{scheme[: position - 1]}ã"
                     else:
-                        scheme = f"{scheme[:position - 1]}ãé"
+                        scheme = f"{scheme[: position - 1]}ãé"
 
                 elif contexte == "â3ũ":
                     # seul cas pratique derrière un â long?
-                    scheme = f"{scheme[:position - 1]}â'u"  # diptote dans ce cas
+                    scheme = f"{scheme[: position - 1]}â'u"  # diptote dans ce cas
 
                 elif contexte == "a3°":
                     # inaccompli passif (2FP, 3FP) en ay
                     # versus accompli actif en voyelle de l'inaccompli (?) :
                     if scheme[position - 3] == "a":  # on est à l'inaccompli
-                        scheme = f"{scheme[:position - 1]}aw{scheme[position + 1:]}"
+                        scheme = f"{scheme[: position - 1]}aw{scheme[position + 1 :]}"
                     else:
-                        scheme = f"{scheme[:position - 1]}ay{scheme[position + 1:]}"
+                        scheme = f"{scheme[: position - 1]}ay{scheme[position + 1 :]}"
 
                 elif contexte == "i3a":
-                    scheme = f"{scheme[:position - 1]}iya{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}iya{scheme[position + 2 :]}"
 
                 elif contexte == "i3@":
-                    scheme = f"{scheme[:position - 1]}iy@{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}iy@{scheme[position + 2 :]}"
 
                 elif contexte == "i3i":
-                    scheme = f"{scheme[:position - 1]}i{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}i{scheme[position + 2 :]}"
 
                 elif contexte == "i3â":
-                    scheme = f"{scheme[:position - 1]}iyâ{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}iyâ{scheme[position + 2 :]}"
 
                 elif contexte == "i3î":
-                    scheme = f"{scheme[:position - 1]}î{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}î{scheme[position + 2 :]}"
 
                 elif contexte == "i3ĩ":
-                    scheme = f"{scheme[:position - 1]}ĩ{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}ĩ{scheme[position + 2 :]}"
 
                 elif contexte == "i3u":
-                    scheme = f"{scheme[:position - 1]}iy{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}iy{scheme[position + 2 :]}"
 
                 elif contexte == "i3û":
-                    scheme = f"{scheme[:position - 1]}û{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}û{scheme[position + 2 :]}"
 
                 elif contexte == "i3ũ":
-                    scheme = f"{scheme[:position - 1]}ĩ{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}ĩ{scheme[position + 2 :]}"
 
                 elif contexte == "i3°":
-                    scheme = f"{scheme[:position - 1]}î{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}î{scheme[position + 2 :]}"
 
                 elif contexte == "u3i":
-                    scheme = f"{scheme[:position - 1]}i{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}i{scheme[position + 2 :]}"
 
                 elif contexte == "u3î":
-                    scheme = f"{scheme[:position - 1]}î{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}î{scheme[position + 2 :]}"
 
                 elif contexte == "u3u":
                     # dépend si c'est en fin de mot
                     if position == len(scheme) - 1:
-                        scheme = f"{scheme[:position - 1]}îû{scheme[position + 2:]}"
+                        scheme = f"{scheme[: position - 1]}îû{scheme[position + 2 :]}"
                     else:
-                        scheme = f"{scheme[:position - 1]}u{scheme[position + 2:]}"
+                        scheme = f"{scheme[: position - 1]}u{scheme[position + 2 :]}"
 
                 elif contexte == "u3û":
-                    scheme = f"{scheme[:position - 1]}îû{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}îû{scheme[position + 2 :]}"
 
                 elif contexte == "u3ũ":
-                    scheme = f"{scheme[:position - 1]}ĩ{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}ĩ{scheme[position + 2 :]}"
 
                 elif contexte == "u3":  # en fin de mot
-                    scheme = f"{scheme[:position - 1]}u{scheme[position + 1:]}"
+                    scheme = f"{scheme[: position - 1]}u{scheme[position + 1 :]}"
 
                 elif contexte == "u3°":
-                    scheme = f"{scheme[:position - 1]}û{scheme[position + 1:]}"
+                    scheme = f"{scheme[: position - 1]}û{scheme[position + 1 :]}"
 
                 elif scheme[position - 1] == "y":  # cas du diminutif en *u*ay*ũ ou *u*ay*@ũ:
-                    scheme = f"{scheme[:position]}y{scheme[position + 1:]}"
+                    scheme = f"{scheme[:position]}y{scheme[position + 1 :]}"
 
                 elif contexte == "û3ũ":  # Pb d'écriture
-                    scheme = f"{scheme[:position - 1]}uw²ũ{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}uw²ũ{scheme[position + 2 :]}"
 
                 elif contexte == "°3ũ" and scheme[position - 2] == "a":
                     # traitement différent de *a*wũ et *u*wũ - bon, enfin, du moins ça marche :-/
-                    scheme = f"{scheme[:position]}wũ{scheme[position + 2:]}"
+                    scheme = f"{scheme[:position]}wũ{scheme[position + 2 :]}"
 
                 elif contexte in {"°3ũ", "°3ĩ"}:
-                    scheme = f"{scheme[:position]}ã{scheme[position + 2:]}"
+                    scheme = f"{scheme[:position]}ã{scheme[position + 2 :]}"
 
                 elif contexte == "°3ã" and scheme[position + 2] != "é":
-                    scheme = f"{scheme[:position]}ã{scheme[position + 2:]}"
+                    scheme = f"{scheme[:position]}ã{scheme[position + 2 :]}"
 
                 # la radicale faible disparaît parfois devant @, mais il faut dans ce cas la supprimer à la main.
                 # fin traitement des cas particuliers en w
@@ -1140,94 +1140,94 @@ def appliquer(scheme: str, racine: str, *, var: str = "") -> str:  # pragma: no
                 # ou formes dérivées d'un verbe défectif, traité comme un "y"
                 if contexte == "a3a":
                     if position == len(scheme) - 1:  # position finale
-                        scheme = f"{scheme[:position - 1]}é{scheme[position + 2:]}"
+                        scheme = f"{scheme[: position - 1]}é{scheme[position + 2 :]}"
                     else:
-                        scheme = f"{scheme[:position - 1]}a{scheme[position + 2:]}"
+                        scheme = f"{scheme[: position - 1]}a{scheme[position + 2 :]}"
 
                 elif contexte == "a3â":
-                    scheme = f"{scheme[:position - 1]}ayâ{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}ayâ{scheme[position + 2 :]}"
 
                 elif contexte == "a3@":
-                    scheme = f"{scheme[:position - 1]}â@{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}â@{scheme[position + 2 :]}"
 
                 elif contexte == "â3@":
-                    scheme = f"{scheme[:position - 1]}ây@{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}ây@{scheme[position + 2 :]}"
 
                 elif contexte == "a3î":
-                    scheme = f"{scheme[:position - 1]}ay{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}ay{scheme[position + 2 :]}"
 
                 elif contexte == "a3u":
                     # dépend si c'est en fin de mot
                     if position == len(scheme) - 1:
-                        scheme = f"{scheme[:position - 1]}é{scheme[position + 2:]}"
+                        scheme = f"{scheme[: position - 1]}é{scheme[position + 2 :]}"
                     else:
-                        scheme = f"{scheme[:position - 1]}ay{scheme[position + 2:]}"
+                        scheme = f"{scheme[: position - 1]}ay{scheme[position + 2 :]}"
 
                 elif contexte == "a3û":
-                    scheme = f"{scheme[:position - 1]}aw{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}aw{scheme[position + 2 :]}"
 
                 elif contexte in {"a3ũ", "a3ã", "a3ĩ"}:
-                    scheme = f"{scheme[:position - 1]}ãé"
+                    scheme = f"{scheme[: position - 1]}ãé"
 
                 elif contexte == "â3i":
-                    scheme = f"{scheme[:position - 1]}â'i{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}â'i{scheme[position + 2 :]}"
                     # typiquement -*i*â*iy²ũ doit conserver la hamza de -*i*â*ũ
                     # en fait on peut neutraliser via un W fort.
                 elif contexte == "â3ũ":
-                    scheme = f"{scheme[:position - 1]}â'u"  # diptote dans ce cas
+                    scheme = f"{scheme[: position - 1]}â'u"  # diptote dans ce cas
 
                 elif contexte == "a3°":  # ay devant consonne, é en finale
-                    scheme = f"{scheme[:position - 1]}ay{scheme[position + 1:]}"
+                    scheme = f"{scheme[: position - 1]}ay{scheme[position + 1 :]}"
 
                 elif contexte == "a3":
-                    scheme = f"{scheme[:position - 1]}i"
+                    scheme = f"{scheme[: position - 1]}i"
 
                 elif contexte == "i3a":
-                    scheme = f"{scheme[:position - 1]}iya{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}iya{scheme[position + 2 :]}"
 
                 elif contexte == "i3@":
-                    scheme = f"{scheme[:position - 1]}iy@{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}iy@{scheme[position + 2 :]}"
 
                 elif contexte == "î3@":
-                    scheme = f"{scheme[:position - 1]}îy@{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}îy@{scheme[position + 2 :]}"
 
                 elif contexte == "i3â":
-                    scheme = f"{scheme[:position - 1]}iyâ{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}iyâ{scheme[position + 2 :]}"
 
                 elif contexte == "i3i":
-                    scheme = f"{scheme[:position - 1]}i{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}i{scheme[position + 2 :]}"
 
                 elif contexte == "i3î":  # î
-                    scheme = f"{scheme[:position - 1]}î{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}î{scheme[position + 2 :]}"
 
                 elif contexte == "i3ĩ":
-                    scheme = f"{scheme[:position - 1]}ĩ{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}ĩ{scheme[position + 2 :]}"
 
                 elif contexte == "i3u":  # dépend si c'est en fin de mot
                     if position == len(scheme) - 1:
-                        scheme = f"{scheme[:position - 1]}î{scheme[position + 2:]}"
+                        scheme = f"{scheme[: position - 1]}î{scheme[position + 2 :]}"
                     else:
-                        scheme = f"{scheme[:position - 1]}u{scheme[position + 2:]}"
+                        scheme = f"{scheme[: position - 1]}u{scheme[position + 2 :]}"
 
                 elif contexte == "i3û":
-                    scheme = f"{scheme[:position - 1]}û{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}û{scheme[position + 2 :]}"
 
                 elif contexte == "i3ũ":
-                    scheme = f"{scheme[:position - 1]}ĩ"
+                    scheme = f"{scheme[: position - 1]}ĩ"
 
                 elif contexte == "i3°":
-                    scheme = f"{scheme[:position - 1]}î{scheme[position + 1:]}"
+                    scheme = f"{scheme[: position - 1]}î{scheme[position + 1 :]}"
 
                 elif contexte == "i3":  # en fin de mot
-                    scheme = f"{scheme[:position - 1]}i{scheme[position + 1:]}"
+                    scheme = f"{scheme[: position - 1]}i{scheme[position + 1 :]}"
 
                 elif contexte == "u3ũ":
-                    scheme = f"{scheme[:position - 1]}ĩ{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}ĩ{scheme[position + 2 :]}"
 
                 elif (contexte == "û3ũ") and scheme[:3] == "ma1":
                     # contamination du y sur le û dans la forme ma**û*ũ, cf Wright 1874 §170,
                     # mais la 2 est déjà remplacée dans le schème donc on ne peut pas tester le schème d'origine
-                    scheme = f"{scheme[:position - 1]}iy²ũ{scheme[position + 2:]}"
+                    scheme = f"{scheme[: position - 1]}iy²ũ{scheme[position + 2 :]}"
 
                 # fin traitement des cas particuliers en y
             # verbe défectifs
@@ -1254,53 +1254,53 @@ def appliquer(scheme: str, racine: str, *, var: str = "") -> str:  # pragma: no
     # (ne concerne pas les W et Y, invariables par principe) :
     while (position := scheme.find("iw")) > -1:
         if est_voyelle(scheme[position + 2]):
-            scheme = f"{scheme[:position]}iW{scheme[position + 2:]}"  # éviter une boucle infinie
+            scheme = f"{scheme[:position]}iW{scheme[position + 2 :]}"  # éviter une boucle infinie
         elif (
             scheme[position + 2] == "²"
         ):  # Pb sinon avec les -iw²- qu'il ne faut pas transformer en î², ce qui n'aurait aucun sens...
-            scheme = f"{scheme[:position]}iY{scheme[position + 2:]}"
+            scheme = f"{scheme[:position]}iY{scheme[position + 2 :]}"
         else:
-            scheme = f"{scheme[:position]}î{scheme[position + 2:]}"
+            scheme = f"{scheme[:position]}î{scheme[position + 2 :]}"
 
     while (position := scheme.find("uy")) > -1:
         if est_voyelle(scheme[position + 2]):
-            scheme = f"{scheme[:position]}uY{scheme[position + 2:]}"
+            scheme = f"{scheme[:position]}uY{scheme[position + 2 :]}"
         else:
-            scheme = f"{scheme[:position]}û{scheme[position + 2:]}"
+            scheme = f"{scheme[:position]}û{scheme[position + 2 :]}"
 
     while (position := scheme.find("wî")) > -1:
-        scheme = f"{scheme[:position]}yi{scheme[position + 2:]}"
+        scheme = f"{scheme[:position]}yi{scheme[position + 2 :]}"
 
     # nettoyage éventuel : Y et W des verbes réguliers
     scheme = scheme.replace("Y", "y").replace("W", "w")
 
     # écriture des lettres de prolongations
     while (position := scheme.find("ûw")) > -1:
-        scheme = f"{scheme[:position]}uw²{scheme[position + 2:]}"
+        scheme = f"{scheme[:position]}uw²{scheme[position + 2 :]}"
 
     while (position := scheme.find("uw")) > -1:
         if est_voyelle(scheme[position + 2]):
-            scheme = f"{scheme[:position]}uW{scheme[position + 2:]}"
+            scheme = f"{scheme[:position]}uW{scheme[position + 2 :]}"
         else:
-            scheme = f"{scheme[:position]}û{scheme[position + 2:]}"
+            scheme = f"{scheme[:position]}û{scheme[position + 2 :]}"
 
     while (position := scheme.find("iy")) > -1:
         if est_voyelle(scheme[position + 2]) or scheme[position + 2] == "²":  # Pb sinon avec les -iy²-
-            scheme = f"{scheme[:position]}iY{scheme[position + 2:]}"
+            scheme = f"{scheme[:position]}iY{scheme[position + 2 :]}"
         else:
-            scheme = f"{scheme[:position]}î{scheme[position + 2:]}"
+            scheme = f"{scheme[:position]}î{scheme[position + 2 :]}"
 
     while (position := scheme.find("îy")) > -1:
-        scheme = f"{scheme[:position]}iy²{scheme[position + 2:]}"
+        scheme = f"{scheme[:position]}iy²{scheme[position + 2 :]}"
 
     while (position := scheme.find("yî")) > -1:
         if est_voyelle(scheme[position - 1]):  # intercepter des cas comme taXyîTũ => taXYîTũ et pas taXy²iTũ
-            scheme = f"{scheme[:position]}y²i{scheme[position + 2:]}"
+            scheme = f"{scheme[:position]}y²i{scheme[position + 2 :]}"
         else:
-            scheme = f"{scheme[:position]}Yî{scheme[position + 2:]}"
+            scheme = f"{scheme[:position]}Yî{scheme[position + 2 :]}"
 
     while (position := scheme.find("û²")) > -1:
-        scheme = f"{scheme[:position]}uw²{scheme[position + 2:]}"
+        scheme = f"{scheme[:position]}uw²{scheme[position + 2 :]}"
 
     # nettoyage éventuel : Y et W des verbes réguliers
     scheme = scheme.replace("Y", "y").replace("W", "w")
@@ -1322,6 +1322,6 @@ def appliquer(scheme: str, racine: str, *, var: str = "") -> str:  # pragma: no
     # ajustement pour les verbes assimilés en y
     if (position := scheme.find("uy")) > -1:
         if not est_voyelle(scheme[position + 2]):
-            scheme = f"{scheme[:position]}û{scheme[position + 2:]}"
+            scheme = f"{scheme[:position]}û{scheme[position + 2 :]}"
 
     return scheme
diff --git a/wikidict/lang/fr/racines_arabes.py b/wikidict/lang/fr/racines_arabes.py
index 9b3e674b..4de1d801 100644
--- a/wikidict/lang/fr/racines_arabes.py
+++ b/wikidict/lang/fr/racines_arabes.py
@@ -9069,7 +9069,7 @@
         "ar-**a*²a": "",
         "ar-**â*ũ": "achèvement",
         "ar-*a**ũ": "complément",
-        "ar-*a*a*a-u": "compléter",
+        "ar-*a*a*a-i": "compléter",
         "ar-*a*a*ũ": "entier",
         "ar-*a*²a*a": "terminer",
         "ar-*a*²â*ũ": "multitude",
@@ -9088,6 +9088,7 @@
         "ar-*u**ũ": "complément",
         "ar-*u*a*ũ": "amulettes",
         "ar-*u*â*@ũ": "reste",
+        "ar-*u*â*ũ": "complétion",
         "ar-*â**@ũ": "{{f}} achevée",
         "ar-*â**ũ": "terminé",
         "ar-*â*a*a": "lutter pour achever",
@@ -9102,7 +9103,7 @@
         "ar-ta**î*ũ": "complétion",
         "ar-ta*a*²a*a": "être fendu",
         "ar-ta*â*a*a": "se réunir",
-    },  # 38
+    },  # 39
     "ar-trk": {
         "aa_sens": "laisser, abandonner",
         "ar-**a*²a": "",
diff --git a/wikidict/lang/fr/template_handlers.py b/wikidict/lang/fr/template_handlers.py
index 5c23f15f..f907bfae 100644
--- a/wikidict/lang/fr/template_handlers.py
+++ b/wikidict/lang/fr/template_handlers.py
@@ -86,9 +86,9 @@ def render_abreviation(tpl: str, parts: list[str], data: defaultdict[str, str],
 
     phrase = "abréviation" if data["m"] in ("1", "oui") else "Abréviation"
     if data["texte"] and data["nolien"] not in ("1", "oui"):
-        phrase += f' de {italic(data["texte"])}'
+        phrase += f" de {italic(data['texte'])}"
     elif data["de"]:
-        phrase += f' de {italic(data["de"])}'
+        phrase += f" de {italic(data['de'])}"
     else:
         phrase = term("Abréviation")
     return phrase
@@ -189,9 +189,9 @@ def render_apherese(tpl: str, parts: list[str], data: defaultdict[str, str], *,
     auto_cap = data["m"] in ("1", "oui")
     phrase = capitalize(tpl) if auto_cap else tpl
     if data["texte"] and data["nolien"] not in ("1", "oui"):
-        phrase += f' de {italic(data["texte"])}'
+        phrase += f" de {italic(data['texte'])}"
     elif data["de"]:
-        phrase += f' de {italic(data["de"])}'
+        phrase += f" de {italic(data['de'])}"
     return phrase
 
 
@@ -416,8 +416,8 @@ def render_compose_de(tpl: str, parts: list[str], data: defaultdict[str, str], *
             phrase += " préfixe " + word_tr_sens(parts[0], data.get("tr1", ""), data.get("sens1", ""))
             phrase += " et le suffixe " + word_tr_sens(parts[2], data.get("tr3", ""), data.get("sens3", ""))
         elif b == "1100":
-            phrase += f' du préfixe {word_tr_sens(parts[0], data.get("tr1", ""), data.get("sens1", ""))},'
-            phrase += f' avec le suffixe {word_tr_sens(parts[1], data.get("tr2", ""), data.get("sens2", ""))}'
+            phrase += f" du préfixe {word_tr_sens(parts[0], data.get('tr1', ''), data.get('sens1', ''))},"
+            phrase += f" avec le suffixe {word_tr_sens(parts[1], data.get('tr2', ''), data.get('sens2', ''))}"
 
         if data["sens"]:
             phrase += f", littéralement «&nbsp;{data['sens']}&nbsp;»"
@@ -476,7 +476,7 @@ def render_equiv_pour(tpl: str, parts: list[str], data: defaultdict[str, str], *
     phrase += data.get("texte", "on dit" if len(parts) == 1 else "on peut dire")
     phrase = f"{italic(phrase)}&nbsp: {', '.join(parts)}"
     if "2egenre" in data:
-        phrase2 = f' ; pour {data["2egenre"]}, '
+        phrase2 = f" ; pour {data['2egenre']}, "
         phrase2 += data.get("texte", "on peut dire" if "2egenre2" in data else "on dit")
         parts2: list[str] = []
         for i in range(1, 7):
@@ -873,14 +873,14 @@ def render_mot_valise(tpl: str, parts: list[str], data: defaultdict[str, str], *
     phrase = "Mot-valise" if data["m"] in ("oui", "1") else "mot-valise"
     if data["de"] or data["texte"]:
         if data["nolien"] in ("", "non", "0") and data["texte"]:
-            phrase += f' formé de {italic(data["texte"])}'
+            phrase += f" formé de {italic(data['texte'])}"
         elif data["de"]:
-            phrase += f' formé de {italic(data["de"])}'
+            phrase += f" formé de {italic(data['de'])}"
     if data["de2"] or data["texte2"]:
         if data["nolien"] in ("", "non", "0") and data["texte2"]:
-            phrase += f' et de {italic(data["texte2"])}'
+            phrase += f" et de {italic(data['texte2'])}"
         elif data["de2"]:
-            phrase += f' et de {italic(data["de2"])}'
+            phrase += f" et de {italic(data['de2'])}"
 
     return phrase
 
@@ -1230,7 +1230,7 @@ def render_variante_ortho(tpl: str, parts: list[str], data: defaultdict[str, str
         return ""
     phrase = italic("Variante orthographique de" if "ortho" in tpl else "Variante de")
     w = data["dif"] or parts.pop(0)
-    phrase += f' {word_tr_sens(w, data["tr"], data["sens"], use_italic=False)}'
+    phrase += f" {word_tr_sens(w, data['tr'], data['sens'], use_italic=False)}"
     return phrase