adjudicate 0.3.0__py3-none-any.whl

adjudicate/__init__.py

@@ -0,0 +1,18 @@
+"""adjudicate: bounded, auditable text edits chosen by a language model.
+
+A detector proposes a span and a short list of candidate replacements; the
+model picks one (or KEEP) from the sentence and a rule of thumb; the applier
+splices the choice in. The toolkit behind stylefix and proofix.
+"""
+
+from .apply import Edit, apply_edits, line_offsets, match_case, to_offsets  # noqa: F401
+from .context import (FENCE, FRONT_MATTER, HTML_ENTITY, at_sentence_start,  # noqa: F401
+                      inside_quotes, map_prose, paragraph_bounds,
+                      prose_regions, protected_spans, sentence_context)
+from .core import (Cache, Decision, Item, adjudicate, decide_batch, parse_response,  # noqa: F401
+                   render_batch, system_prompt, DEFAULT_KEEP_RULE, match_choice)
+from .llm import ConfigError, Endpoint, LLMError, resolve_endpoint, strip_thinking  # noqa: F401
+from .setup import check_endpoint, run_setup  # noqa: F401
+from .dictionary import known, known_anywhere  # noqa: F401
+
+__version__ = "0.3.0"

adjudicate/apply.py

@@ -0,0 +1,71 @@
+"""Splice replacements into text at Vale's (line, span) positions."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Edit:
+    line: int      # 1-indexed
+    start: int     # 1-indexed inclusive column
+    end: int       # 1-indexed inclusive column
+    original: str
+    replacement: str
+    source: str    # check name or "adjudicated"
+
+
+def match_case(original: str, replacement: str) -> str:
+    """Give `replacement` the casing pattern of `original`, unless the
+    replacement is already deliberately cased (it contains a capital), as
+    with abbreviations and names: "US" -> "United States", not "UNITED
+    STATES"; "us" -> "U.S." stays "U.S."."""
+    if any(ch.isupper() for ch in replacement):
+        return replacement
+    if original.isupper() and len(original) > 1:
+        return replacement.upper()
+    if original[:1].isupper():
+        return replacement[:1].upper() + replacement[1:]
+    return replacement
+
+
+def line_offsets(text: str) -> list[int]:
+    """Absolute offset of the start of each line (index 0 = line 1)."""
+    offsets = [0]
+    for i, ch in enumerate(text):
+        if ch == "\n":
+            offsets.append(i + 1)
+    return offsets
+
+
+def to_offsets(text: str, edit: Edit) -> tuple[int, int]:
+    starts = line_offsets(text)
+    base = starts[edit.line - 1]
+    return base + edit.start - 1, base + edit.end
+
+
+def apply_edits(text: str, edits: list[Edit]) -> tuple[str, list[Edit]]:
+    """Apply edits whose span still contains the expected original text.
+
+    Returns the new text and the edits that were skipped because the text
+    at their position no longer matched.
+    """
+    skipped: list[Edit] = []
+    spans = []
+    for e in edits:
+        s, t = to_offsets(text, e)
+        if text[s:t] != e.original:
+            skipped.append(e)
+            continue
+        spans.append((s, t, e))
+    # Apply from the end so earlier offsets stay valid; drop overlaps.
+    spans.sort(key=lambda x: (x[0], x[1]), reverse=True)
+    out = text
+    last_start = len(text) + 1
+    for s, t, e in spans:
+        if t > last_start:
+            skipped.append(e)
+            continue
+        out = out[:s] + match_case(e.original, e.replacement) + out[t:]
+        last_start = s
+    return out, skipped

adjudicate/context.py

@@ -0,0 +1,139 @@
+"""Sentence context, position heuristics, and Markdown prose regions."""
+
+from __future__ import annotations
+
+import re
+
+from dataclasses import dataclass  # noqa: F401
+
+FENCE = re.compile(r"^(```|~~~)[^\n]*\n.*?^\1[ \t]*$", re.M | re.S)
+_INLINE_CODE = re.compile(r"(`+)[^`\n]*?\1")
+_LINK_DEST = re.compile(r"\]\([^)\s]*(?:\s+\"[^\"]*\")?\)")
+_URL = re.compile(r"<?(?:https?|ftp|mailto):[^\s>)]+>?")
+FRONT_MATTER = re.compile(r"\A---\n.*?\n---\n", re.S)
+_HTML_COMMENT = re.compile(r"<!--.*?-->", re.S)
+_HTML_TAG = re.compile(r"</?[A-Za-z][^<>\n]*>")
+HTML_ENTITY = re.compile(r"&(?:#\d+|#x[0-9A-Fa-f]+|[A-Za-z][A-Za-z0-9]*);")
+
+# Pre-0.3 names, kept so an old consumer does not break mid-upgrade; removed in 0.4.
+_FENCE, _FRONT, _HTML_ENTITY = FENCE, FRONT_MATTER, HTML_ENTITY
+
+
+@dataclass
+class _Unused:
+    quotes: int = 0
+    apostrophes: int = 0
+    dashes: int = 0
+    ranges: int = 0
+    dates: int = 0
+    punctuation_moved: int = 0
+
+    def as_dict(self) -> dict[str, int]:
+        return {k: v for k, v in self.__dict__.items() if v}
+
+
+def protected_spans(text: str, entities: bool = True) -> list[tuple[int, int]]:
+    """Spans no tool should edit: front matter, fenced and inline code, link
+    targets, URLs, HTML comments and tags, and (unless entities=False) HTML
+    entities."""
+    spans = []
+    m = FRONT_MATTER.match(text)
+    if m:
+        spans.append((0, m.end()))
+    rxs = [FENCE, _INLINE_CODE, _LINK_DEST, _URL, _HTML_COMMENT, _HTML_TAG]
+    if entities:
+        rxs.append(HTML_ENTITY)
+    for rx in rxs:
+        spans.extend(m.span() for m in rx.finditer(text))
+    spans.sort()
+    merged: list[tuple[int, int]] = []
+    for s, e in spans:
+        if merged and s <= merged[-1][1]:
+            merged[-1] = (merged[-1][0], max(merged[-1][1], e))
+        else:
+            merged.append((s, e))
+    return merged
+
+
+def prose_regions(text: str) -> list[tuple[int, int]]:
+    regions, cursor = [], 0
+    for s, e in protected_spans(text):
+        if s > cursor:
+            regions.append((cursor, s))
+        cursor = e
+    if cursor < len(text):
+        regions.append((cursor, len(text)))
+    return regions
+
+
+def map_prose(text: str, fn) -> str:
+    out, cursor = [], 0
+    for s, e in prose_regions(text):
+        out.append(text[cursor:s])
+        out.append(fn(text[s:e]))
+        cursor = e
+    out.append(text[cursor:])
+    return "".join(out)
+
+
+
+_SENT_END = re.compile(r"(?<=[.!?])\s+")
+
+
+def paragraph_bounds(text: str, pos: int) -> tuple[int, int]:
+    start = text.rfind("\n\n", 0, pos)
+    start = 0 if start < 0 else start + 2
+    end = text.find("\n\n", pos)
+    end = len(text) if end < 0 else end
+    return start, end
+
+
+def sentence_context(text: str, start: int, end: int, radius: int = 1,
+                     max_chars: int = 400) -> str:
+    """The sentence containing [start, end) plus `radius` neighbours, with
+    the target span marked as [[...]]."""
+    ps, pe = paragraph_bounds(text, start)
+    para = text[ps:pe]
+    rel_s, rel_e = start - ps, end - ps
+    pieces, cursor = [], 0
+    for m in _SENT_END.finditer(para):
+        pieces.append((cursor, m.start()))
+        cursor = m.end()
+    pieces.append((cursor, len(para)))
+    idx = next((i for i, (a, b) in enumerate(pieces) if a <= rel_s < b), len(pieces) - 1)
+    lo = pieces[max(0, idx - radius)][0]
+    hi = pieces[min(len(pieces) - 1, idx + radius)][1]
+    snippet = para[lo:rel_s] + "[[" + para[rel_s:rel_e] + "]]" + para[rel_e:hi]
+    snippet = re.sub(r"\s+", " ", snippet).strip()
+    if len(snippet) > max_chars:
+        mark = snippet.find("[[")
+        a = max(0, mark - max_chars // 2)
+        snippet = ("…" if a else "") + snippet[a:a + max_chars] + "…"
+    return snippet
+
+
+# Brackets are not sentence starts: "[Center for X](url)" and "(Centre for Y)"
+# keep their capital because of the name, so the word is adjudicated.
+_SENTENCE_START_PUNCT = set('.!?:"“‘\'')
+
+
+def at_sentence_start(text: str, pos: int) -> bool:
+    """True when a capital at `pos` is explained by position, not by being a name."""
+    line_start = text.rfind("\n", 0, pos) + 1
+    before = text[line_start:pos].rstrip()
+    if not before:
+        return True
+    # Markdown markers: headings, list bullets, numbered items, blockquotes.
+    if re.fullmatch(r"(#{1,6}|[-*+]|\d+[.)]|>|\|)", before):
+        return True
+    return before[-1] in _SENTENCE_START_PUNCT
+
+
+def inside_quotes(text: str, pos: int) -> bool:
+    """Cheap check: an odd number of opening quotes precede `pos` in the paragraph."""
+    ps, _ = paragraph_bounds(text, pos)
+    seg = text[ps:pos]
+    opens = seg.count("“") + seg.count("‘") + len(re.findall(r'(?:^|\s)["\']', seg))
+    # `seg` ends where the word starts, so a quote at its very end is an opener.
+    closes = seg.count("”") + seg.count("’") + len(re.findall(r'["\'](?=[\s.,;:!?)])', seg))
+    return opens > closes

adjudicate/core.py

@@ -0,0 +1,206 @@
+"""Ask a model to choose between supplied candidates for marked spans.
+
+The contract: each item carries a short list of options (the last usually
+KEEP), a rule of thumb, and the sentence with the span marked [[...]].
+The model picks one option per item. Anything else is rejected."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass, field, asdict
+from pathlib import Path
+
+from .llm import Endpoint, LLMError
+
+SYSTEM_TEMPLATE = """{task}
+For each item, choose exactly one option from its numbered list. {keep_rule}
+Answer with the option's number (or the word KEEP); never retype or paraphrase the option text.
+Respond with JSON only, in this shape:
+{{"decisions": [{{"id": 1, "choice": "<option number, or KEEP>", "confidence": 0.0, "reason": "<under 12 words>"}}]}}"""
+
+DEFAULT_KEEP_RULE = ("Choose KEEP when the marked text is already correct in context, is part of a "
+                     "proper name, a title, a quotation, a URL or code, or when no option fits.")
+
+
+def system_prompt(task: str, keep_rule: str = DEFAULT_KEEP_RULE) -> str:
+    return SYSTEM_TEMPLATE.format(task=task, keep_rule=keep_rule)
+
+
+@dataclass
+class Item:
+    id: int
+    word: str
+    options: tuple[str, ...]
+    rule: str
+    context: str
+    line: int
+    start: int
+    end: int
+    source: str = "ambiguous"     # caller-defined tag for reporting
+
+
+@dataclass
+class Decision:
+    item: Item
+    choice: str | None            # None = could not decide
+    confidence: float
+    reason: str
+    cached: bool = False
+
+    @property
+    def replacement(self) -> str | None:
+        """The text to substitute, or None to leave the word alone."""
+        if self.choice is None or self.choice == "KEEP":
+            return None
+        if self.choice.lower() == self.item.word.lower():
+            return None
+        return self.choice
+
+
+class Cache:
+    def __init__(self, path: Path | None):
+        self.path = path
+        self.data: dict[str, dict] = {}
+        if path and path.exists():
+            try:
+                self.data = json.loads(path.read_text())
+            except json.JSONDecodeError:
+                self.data = {}
+
+    @staticmethod
+    def key(scope: str, item: Item) -> str:
+        """scope: anything that changes the right answer (target variety, task)."""
+        norm = re.sub(r"\s+", " ", item.context).strip().lower()
+        h = hashlib.sha256(f"{scope}|{item.word.lower()}|{'|'.join(item.options)}|{norm}".encode()).hexdigest()
+        return h[:24]
+
+    def get(self, k: str) -> dict | None:
+        return self.data.get(k)
+
+    def put(self, k: str, d: Decision) -> None:
+        self.data[k] = {"word": d.item.word, "choice": d.choice,
+                        "confidence": d.confidence, "reason": d.reason,
+                        "context": d.item.context}
+
+    def save(self) -> None:
+        if self.path:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            self.path.write_text(json.dumps(self.data, indent=1, ensure_ascii=False))
+
+
+def render_batch(items: list[Item]) -> str:
+    parts = []
+    for it in items:
+        opts = " | ".join(o if o == "KEEP" else f"[{n}] {o}" for n, o in enumerate(it.options, 1))
+        parts.append(
+            f"Item {it.id} — word: \"{it.word}\" — options: {opts}\n"
+            f"Rule: {it.rule}\n"
+            f"Context: {it.context}")
+    return "\n\n".join(parts)
+
+
+def match_choice(choice: str, options: tuple[str, ...]) -> str | None:
+    """Resolve the model's answer to one option: by number ("2", "[2]"),
+    by the word KEEP, or by the option text (trimmed, case-insensitive)."""
+    c = str(choice).strip()
+    m = re.fullmatch(r"\[?(\d+)\]?", c)
+    if m:
+        n = int(m.group(1))
+        return options[n - 1] if 1 <= n <= len(options) else None
+    if c.upper() == "KEEP" and "KEEP" in options:
+        return "KEEP"
+    c = re.sub(r"^\[\d+\]\s*", "", c)
+    return next((o for o in options if o.strip().lower() == c.lower()), None)
+
+
+def parse_response(text: str) -> dict[int, dict]:
+    """Return {id: {choice, confidence, reason}} from the model's reply."""
+    text = text.strip()
+    text = re.sub(r"^```(?:json)?\s*|\s*```$", "", text, flags=re.S)
+    m = re.search(r"[\[{]", text)
+    if not m:
+        return {}
+    try:
+        data = json.loads(text[m.start():])
+    except json.JSONDecodeError:
+        # Try to salvage the largest balanced object.
+        end = max(text.rfind("}"), text.rfind("]"))
+        try:
+            data = json.loads(text[m.start():end + 1])
+        except json.JSONDecodeError:
+            return {}
+    if isinstance(data, dict):
+        data = data.get("decisions", data.get("items", []))
+    out = {}
+    for d in data if isinstance(data, list) else []:
+        if isinstance(d, dict) and "id" in d:
+            try:
+                out[int(d["id"])] = d
+            except (TypeError, ValueError):
+                continue
+    return out
+
+
+def decide_batch(ep: Endpoint, system: str, items: list[Item]) -> list[Decision]:
+    try:
+        reply = ep.chat(system, render_batch(items))
+    except LLMError as e:
+        return [Decision(it, None, 0.0, f"model error: {e}") for it in items]
+    answers = parse_response(reply)
+    out = []
+    for it in items:
+        a = answers.get(it.id)
+        if not a:
+            out.append(Decision(it, None, 0.0, "no answer from model"))
+            continue
+        choice = str(a.get("choice", "")).strip()
+        matched = match_choice(choice, it.options)
+        try:
+            conf = float(a.get("confidence", 0))
+        except (TypeError, ValueError):
+            conf = 0.0
+        reason = str(a.get("reason", ""))[:200]
+        if matched is None:
+            out.append(Decision(it, None, 0.0, f"invalid choice {choice!r}"))
+        else:
+            out.append(Decision(it, matched, conf, reason))
+    return out
+
+
+def adjudicate(ep: Endpoint | None, scope: str, items: list[Item], cache: Cache,
+               batch_size: int = 20, parallel: int = 4, verbose: bool = False,
+               system: str | None = None, log_name: str = "adjudicate") -> list[Decision]:
+    """Decide every item: from cache where possible, otherwise from the model
+    in parallel batches. `scope` keys the cache; `system` is the task prompt
+    (see system_prompt)."""
+    system = system or system_prompt("You are a meticulous copy editor.")
+    decisions: dict[int, Decision] = {}
+    todo: list[Item] = []
+    for it in items:
+        k = Cache.key(scope, it)
+        hit = cache.get(k)
+        if hit and hit.get("choice") in it.options:
+            decisions[it.id] = Decision(it, hit["choice"], float(hit.get("confidence", 1.0)),
+                                        hit.get("reason", ""), cached=True)
+        else:
+            todo.append(it)
+    if todo and ep is None:
+        for it in todo:
+            decisions[it.id] = Decision(it, None, 0.0, "no model configured")
+    elif todo:
+        batches = [todo[i:i + batch_size] for i in range(0, len(todo), batch_size)]
+        if verbose:
+            print(f"{log_name}: asking {ep.name} ({ep.model}) about {len(todo)} items "
+                  f"in {len(batches)} batch(es), {parallel} in parallel", file=sys.stderr)
+        with ThreadPoolExecutor(max_workers=max(1, parallel)) as pool:
+            for result in pool.map(lambda b: decide_batch(ep, system, b), batches):
+                for d in result:
+                    decisions[d.item.id] = d
+                    if d.choice is not None:
+                        cache.put(Cache.key(scope, d.item), d)
+        cache.save()
+    return [decisions[it.id] for it in items]

adjudicate/dict/LICENSE-en_GB.txt

@@ -0,0 +1,175 @@
+This dictionary was initially based on a subset of the
+original English wordlist created by Kevin Atkinson for
+Pspell and Aspell and thus is covered by his original
+LGPL licence.
+
+It has been extensively updated by David Bartlett, Brian Kelk,
+Andrew Brown and Marco A.G.Pinto:
+ — Numerous Americanisms/spellings have been removed;
+ — Missing words have been added;
+ — Many errors have been corrected;
+ — Compound hyphenated words have been added where appropriate;
+ — Thousands of proper/places names have been added;
+ — Thousands of possessives have been added;
+ — Thousands of plurals have been added;
+ — Thousands of duplicates have been removed.
+
+Valuable inputs to this process were received from many other
+people — far too numerous to name. Serious thanks to all for
+your greatly appreciated help.
+
+This wordlist is intended to be a good representation of
+current modern British English and thus it should be a good
+basis for Commonwealth English in most countries of the world
+outside North America.
+
+The affix file has been created completely from scratch
+by David Bartlett and Andrew Brown, based on the published
+rules for MySpell and is also provided under the LGPL.
+
+In creating the affix rules an attempt has been made to
+reproduce the most general rules for English word
+formation, rather than merely use it to compress the
+size of the dictionary. It is hoped that this will
+facilitate future localisation to other variants of English.
+
+---
+
+This is a locally hosted copy of the English dictionaries with fixed
+dash handling and new ligature and phonetic suggestion support extension:
+https://extensions.openoffice.org/en/node/3785
+
+Original version of the en_GB dictionary:
+https://bz.apache.org/ooo/show_bug.cgi?id=72145
+
+OpenOffice.org patch and morphological extension.
+
+The morphological extension based on Wordlist POS and AGID data
+created by Kevin Atkinson and released on http://wordlist.sourceforge.net.
+
+Other fixes:
+
+OOo Issue 48060 — add numbers with affixes by COMPOUNDRULE (1st, 111th, 1990s etc.)
+OOo Issue 29112, 55498 — add NOSUGGEST flags to taboo words
+New REP items (better suggestions for accented words and a few mistakes)
+OOo Issue 63541 — remove *dessicated
+
+2008-12-18 — NOSUGGEST, NUMBER/COMPOUNDRULE patches (nemeth AT OOo)
+2010-03-09 (nemeth AT OOo)
+		   — UTF-8 encoded dictionary:
+			 — Fix em-dash problem of OOo 3.2 by BREAK
+			 — Suggesting words with typographical apostrophes
+			 — Recognising words with Unicode f ligatures
+			 — Add phonetic suggestion (© 2000 Björn Jacke)
+2013-08-25 — GB forked by Marco A.G.Pinto
+2016-06-10 — NOSUGGEST added to this clean version of the GB .AFF (Marco A.G.Pinto)
+2016-06-21 — COMPOUNDING added to this clean version of the GB .AFF (Áron Budea)
+2016-08-01 — GB changelog is no longer included in the README file
+2016-09-11 — .AFF + .DIC now use UNIX line endings
+2017-10-08 — Mozilla: used <em:maxVersion>*</em:maxVersion> to work with all future
+			 versions, except Thunderbird
+2017-12-16 — Added to the .AFF:
+			 ICONV 1
+			 ICONV ’ '
+			 Thanks to Jeroen Ooms
+2018-05-01 — Andrew Ziem suggested a list of 328 names of famous people on Kevin's GitHub:
+			 "These 328 name tokens were derived from the top 100 lists in Google Trends via
+			 this repository (https://github.com/az0/google-trend-names). The geography was
+			 set to US, and it spanned dates from 2004 to 2018."
+2018-08-01 — Slightly higher quality icon
+		   — Added tons of drugs names supplied by the user Andrew Ziem on Kevin's GitHub
+		   — Fixed/improved flag "5": "women's" was missing
+2018-06-01
+to
+2018-09-01 — Added places from New Zealand/UK (England, Scotland, Wales & Northern Ireland):
+			 On V2.61–2.64 I included tons of place names.
+			 My scientist friend, Peter McGavin, told me that in NZ they use British, so I decided
+			 to do something about it. I did the same for UK. I searched on Wikipedia for "towns",
+			 "counties", "villages", "boroughs", "suburbs", etc. and based me on:
+			  — https://en.wikipedia.org/wiki/List_of_towns_in_England;
+			  — https://en.wikipedia.org/wiki/List_of_towns_in_New_Zealand;
+			  — https://en.wikipedia.org/wiki/List_of_civil_parishes_in_England;
+			  — https://en.wikipedia.org/wiki/List_of_civil_parishes_in_Scotland;
+			  — https://en.wikipedia.org/wiki/List_of_places_in_Scotland;
+			  — https://en.wikipedia.org/wiki/List_of_communities_in_Wales;
+			  — https://en.wikipedia.org/wiki/Local_government_in_Wales;
+			  — https://en.wikipedia.org/wiki/List_of_towns_and_villages_in_Northern_Ireland;
+			  — https://en.wikipedia.org/wiki/Counties_of_Northern_Ireland;
+			  — https://en.wikipedia.org/wiki/Category:Suburbs_in_New_Zealand;
+			  — https://en.wikipedia.org/wiki/List_of_Church_of_Scotland_parishes.
+			 Also, added places sent to me by Peter C.:
+			 © OpenStreetMap contributors: www.openstreetmap.org/copyright.
+			 © The Clergy of the Church of England Database Project, 2005.
+2018-10-01 — Added the cities from Australia by population:
+			  — https://en.wikipedia.org/wiki/List_of_cities_in_Australia_by_population
+		   — Added tons of cities from the US with a 10 000+ population.
+			 This list was supplied by Michael Holroyd on Kevin Atkinson's GitHub.
+		   — Added tons of possessives to nouns, thanks to Jörg Knobloch.
+2018-12-01 — Added the cities from Canada:
+			  — https://en.wikipedia.org/wiki/List_of_cities_in_Canada
+2019-02-01 — Improved flag "5" thanks to the GitHub user Ding-adong:
+			 Some "swomen's" and "women's" entries were missing.
+		   — Fixed flag "3": -ists, -ists, -ist's → -ist, -ists, -ist's.
+		   — Improved flag "N".
+2019-03-01 — Added the LGPL_V3 License .txt into the Extension.
+		   — Ding-adong added a flag "=" for suffixes: -lessness, -lessnesses, -lessness's.
+		   — Ding-adong changed the prefix flag "O" to "^" since "O" was both prefix and suffix.
+		   — Small fixes and enhancements on flags "z" and "O" by Ding-adong.
+2019-04-01 — Improved flag "P" thanks to Ding-adong, giving also -nesses which
+			 increased the wordlist in ~1800 valid words.
+2019-07-01
+to
+2019-10-01 — Major cleanup of the .dic by removing thousands of duplicates, merging flags, adding
+			 possessives and plurals.
+		   — Improved flags: "i", "n", "N", "O", "W", "Z", "2" and "3":
+			  — Flag "2" increased the wordlist in ~400 valid words;
+			  — Flag "i" increased the wordlist in ~200 valid words;
+			  — Flag "n" increased the wordlist in ~1000 valid words.
+2019-11-01
+to
+2020-11-01 — Added thousands of possessives and plurals.
+		   — Improved flags: "3", "N", "O", "W".
+-------
+
+MARCO A.G.PINTO:
+Since the dictionary wasn't updated for many years, I forked it to add new words and fixes.
+
+I grabbed Mozilla's version since it wasn't obfuscated. Alexandro Colorado and I
+tried to unmunch the OpenOffice version but all we got was rubbish.
+
+The dictionary icon in the Extension Manager was designed by Pedro Marques.
+
+The sources used to verify the spelling of the words I included in the dictionary:
+ 1) Oxford Dictionaries;
+ 2) Collins Dictionary;
+ 3) Macmillan Dictionary;
+ 4) Cambridge Dictionary;
+ 5) Merriam-Webster Dictionary (used with caution ⚠);
+ 6) Wiktionary (used with caution ⚠);
+ 7) Wikipedia (used with caution ⚠);
+ 8) Physical dictionaries.
+
+Main difficulties developing this dictionary:
+ 1) Proper names;
+ 2) Possessive forms;
+ 3) Plurals.
+
+Please let Marco A.G.Pinto know of any errors that you find:
+E-mail:
+marcoagpinto@sapo.pt
+
+Site:
+https://proofingtoolgui.org
+
+FAQ:
+https://proofingtoolgui.org/faq.html
+
+FAQ ("movie", "automobile", "airplane", "hardcover" and "bookstore"):
+https://proofingtoolgui.org/faq.html#7
+Notice: Due to complaints, "movie" was added on V2.57 since it is a widely used word.
+
+Changelog:
+https://proofingtoolgui.org/en_GB_CHANGES.txt
+
+Nightly changes (GitHub):
+https://github.com/marcoagpinto/aoo-mozilla-en-dict