glitchlings 0.4.2__cp310-cp310-macosx_11_0_universal2.whl → 0.4.3__cp310-cp310-macosx_11_0_universal2.whl

glitchlings/zoo/jargoyle.py

@@ -2,20 +2,25 @@ import random
 import re
 from collections.abc import Iterable
 from dataclasses import dataclass
+from types import ModuleType
 from typing import Any, Literal, cast
 
 from glitchlings.lexicon import Lexicon, get_default_lexicon
 
+from ._rate import resolve_rate
+from .core import AttackWave, Glitchling
+
+_wordnet_module: ModuleType | None
+
 try:  # pragma: no cover - optional WordNet dependency
-    from glitchlings.lexicon.wordnet import (
-        WordNetLexicon,
-    )
-    from glitchlings.lexicon.wordnet import (
-        dependencies_available as _lexicon_dependencies_available,
-    )
-    from glitchlings.lexicon.wordnet import ensure_wordnet as _lexicon_ensure_wordnet
+    import glitchlings.lexicon.wordnet as _wordnet_module
 except Exception:  # pragma: no cover - triggered when nltk unavailable
-    WordNetLexicon = None  # type: ignore[assignment]
+    _wordnet_module = None
+
+_wordnet_runtime: ModuleType | None = _wordnet_module
+
+WordNetLexicon: type[Lexicon] | None
+if _wordnet_runtime is None:
 
     def _lexicon_dependencies_available() -> bool:
         return False
@@ -26,9 +31,12 @@ except Exception:  # pragma: no cover - triggered when nltk unavailable
             "and download its WordNet corpus manually if you need legacy synonyms."
         )
 
+    WordNetLexicon = None
+else:
+    WordNetLexicon = cast(type[Lexicon], _wordnet_runtime.WordNetLexicon)
+    _lexicon_dependencies_available = _wordnet_runtime.dependencies_available
+    _lexicon_ensure_wordnet = _wordnet_runtime.ensure_wordnet
 
-from ._rate import resolve_rate
-from .core import AttackWave, Glitchling
 
 ensure_wordnet = _lexicon_ensure_wordnet
 
@@ -169,34 +177,36 @@ def substitute_random_synonyms(
         candidate_indices: list[int] = []
         candidate_metadata: dict[int, CandidateInfo] = {}
         for idx, tok in enumerate(tokens):
-            if idx % 2 == 0 and tok and not tok.isspace():
-                prefix, core_word, suffix = _split_token(tok)
-                if not core_word:
-                    continue
-
-                chosen_pos: str | None = None
-                synonyms: list[str] = []
+            if idx % 2 != 0 or not tok or tok.isspace():
+                continue
 
-                for pos in target_pos:
-                    if not active_lexicon.supports_pos(pos):
-                        continue
-                    synonyms = active_lexicon.get_synonyms(core_word, pos=pos)
-                    if synonyms:
-                        chosen_pos = pos
-                        break
+            prefix, core_word, suffix = _split_token(tok)
+            if not core_word:
+                continue
 
-                if not synonyms and active_lexicon.supports_pos(None):
-                    synonyms = active_lexicon.get_synonyms(core_word, pos=None)
+            chosen_pos: str | None = None
+            synonyms: list[str] = []
 
+            for tag in target_pos:
+                if not active_lexicon.supports_pos(tag):
+                    continue
+                synonyms = active_lexicon.get_synonyms(core_word, pos=tag)
                 if synonyms:
-                    candidate_indices.append(idx)
-                    candidate_metadata[idx] = CandidateInfo(
-                        prefix=prefix,
-                        core_word=core_word,
-                        suffix=suffix,
-                        part_of_speech=chosen_pos,
-                        synonyms=synonyms,
-                    )
+                    chosen_pos = tag
+                    break
+
+            if not synonyms and active_lexicon.supports_pos(None):
+                synonyms = active_lexicon.get_synonyms(core_word, pos=None)
+
+            if synonyms:
+                candidate_indices.append(idx)
+                candidate_metadata[idx] = CandidateInfo(
+                    prefix=prefix,
+                    core_word=core_word,
+                    suffix=suffix,
+                    part_of_speech=chosen_pos,
+                    synonyms=synonyms,
+                )
 
         if not candidate_indices:
             return text

glitchlings/zoo/redactyl.py

@@ -1,6 +1,6 @@
 import random
 import re
-from typing import Any
+from typing import Any, cast
 
 from ._rate import resolve_rate
 from ._sampling import weighted_sample_without_replacement
@@ -119,13 +119,16 @@ def redact_words(
     use_rust = _redact_words_rust is not None and isinstance(merge_adjacent, bool)
 
     if use_rust:
-        return _redact_words_rust(
-            text,
-            replacement_char,
-            clamped_rate,
-            merge_adjacent,
-            unweighted_flag,
-            rng,
+        return cast(
+            str,
+            _redact_words_rust(
+                text,
+                replacement_char,
+                clamped_rate,
+                merge_adjacent,
+                unweighted_flag,
+                rng,
+            ),
         )
 
     return _python_redact_words(

glitchlings/zoo/reduple.py

@@ -1,5 +1,5 @@
 import random
-from typing import Any
+from typing import Any, cast
 
 from ._rate import resolve_rate
 from ._text_utils import WordToken, collect_word_tokens, split_preserving_whitespace
@@ -94,7 +94,7 @@ def reduplicate_words(
     unweighted_flag = bool(unweighted)
 
     if _reduplicate_words_rust is not None:
-        return _reduplicate_words_rust(text, clamped_rate, unweighted_flag, rng)
+        return cast(str, _reduplicate_words_rust(text, clamped_rate, unweighted_flag, rng))
 
     return _python_reduplicate_words(
         text,

glitchlings/zoo/rushmore.py

@@ -1,7 +1,7 @@
 import math
 import random
 import re
-from typing import Any
+from typing import Any, cast
 
 from ._rate import resolve_rate
 from ._text_utils import WordToken, collect_word_tokens, split_preserving_whitespace
@@ -97,7 +97,7 @@ def delete_random_words(
     unweighted_flag = bool(unweighted)
 
     if _delete_random_words_rust is not None:
-        return _delete_random_words_rust(text, clamped_rate, unweighted_flag, rng)
+        return cast(str, _delete_random_words_rust(text, clamped_rate, unweighted_flag, rng))
 
     return _python_delete_random_words(
         text,

glitchlings/zoo/scannequin.py

@@ -1,6 +1,6 @@
 import random
 import re
-from typing import Any
+from typing import Any, cast
 
 from ._ocr_confusions import load_confusion_table
 from ._rate import resolve_rate
@@ -126,7 +126,7 @@ def ocr_artifacts(
     clamped_rate = max(0.0, effective_rate)
 
     if _ocr_artifacts_rust is not None:
-        return _ocr_artifacts_rust(text, clamped_rate, rng)
+        return cast(str, _ocr_artifacts_rust(text, clamped_rate, rng))
 
     return _python_ocr_artifacts(text, rate=clamped_rate, rng=rng)
 

glitchlings/zoo/typogre.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import math
 import random
-from typing import Any, Optional
+from typing import Any, Optional, cast
 
 from ..util import KEYNEIGHBORS
 from ._rate import resolve_rate
@@ -168,7 +168,10 @@ def fatfinger(
     layout = getattr(KEYNEIGHBORS, keyboard)
 
     if _fatfinger_rust is not None:
-        return _fatfinger_rust(text, max_change_rate=clamped_rate, layout=layout, rng=rng)
+        return cast(
+            str,
+            _fatfinger_rust(text, max_change_rate=clamped_rate, layout=layout, rng=rng),
+        )
 
     return _fatfinger_python(text, rate=clamped_rate, layout=layout, rng=rng)
 

glitchlings/zoo/zeedub.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import math
 import random
 from collections.abc import Sequence
-from typing import Any
+from typing import Any, cast
 
 from ._rate import resolve_rate
 from .core import AttackOrder, AttackWave, Glitchling
@@ -115,7 +115,10 @@ def insert_zero_widths(
             if hasattr(rng, "getstate"):
                 python_state = rng.getstate()
             rng.setstate(state)
-        rust_result = _inject_zero_widths_rust(text, clamped_rate, list(cleaned_palette), rng)
+        rust_result = cast(
+            str,
+            _inject_zero_widths_rust(text, clamped_rate, list(cleaned_palette), rng),
+        )
         if rust_result == python_result:
             return rust_result
         if python_state is not None and hasattr(rng, "setstate"):

{glitchlings-0.4.2.dist-info → glitchlings-0.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glitchlings
-Version: 0.4.2
+Version: 0.4.3
 Summary: Monsters for your language games.
 Author: osoleve
 License:                                  Apache License
@@ -226,15 +226,37 @@ License-File: LICENSE
 Requires-Dist: confusable-homoglyphs>=3.3.1
 Requires-Dist: tomli>=2.0.1; python_version < "3.11"
 Requires-Dist: pyyaml>=6.0.0
+Provides-Extra: all
+Requires-Dist: black>=24.4.0; extra == "all"
+Requires-Dist: hypothesis>=6.140.0; extra == "all"
+Requires-Dist: interrogate>=1.5.0; extra == "all"
+Requires-Dist: jellyfish>=1.2.0; extra == "all"
+Requires-Dist: isort>=5.13.0; extra == "all"
+Requires-Dist: mkdocs>=1.6.0; extra == "all"
+Requires-Dist: mkdocs-material>=9.5.0; extra == "all"
+Requires-Dist: mkdocstrings[python]>=0.24.0; extra == "all"
+Requires-Dist: mkdocstrings-python>=1.10.0; extra == "all"
+Requires-Dist: mypy>=1.8.0; extra == "all"
+Requires-Dist: numpy<=2.0,>=1.24; extra == "all"
+Requires-Dist: pre-commit>=3.8.0; extra == "all"
+Requires-Dist: pytest>=8.0.0; extra == "all"
+Requires-Dist: ruff>=0.6.0; extra == "all"
+Requires-Dist: verifiers>=0.1.3.post0; extra == "all"
 Provides-Extra: hf
 Requires-Dist: datasets>=4.0.0; extra == "hf"
+Provides-Extra: lightning
+Requires-Dist: pytorch_lightning>=2.0.0; extra == "lightning"
 Provides-Extra: vectors
 Requires-Dist: numpy<=2.0,>=1.24; extra == "vectors"
 Requires-Dist: spacy>=3.7.2; extra == "vectors"
 Requires-Dist: gensim>=4.3.2; extra == "vectors"
+Provides-Extra: st
+Requires-Dist: sentence-transformers>=3.0.0; extra == "st"
 Provides-Extra: prime
 Requires-Dist: verifiers>=0.1.3.post0; extra == "prime"
 Requires-Dist: jellyfish>=1.2.0; extra == "prime"
+Provides-Extra: torch
+Requires-Dist: torch>=2.0.0; extra == "torch"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: hypothesis>=6.140.0; extra == "dev"
@@ -307,7 +329,7 @@ print(gaggle(SAMPLE_TEXT))
 > Onҽ m‎ھ‎rning, wһen Gregor Samƽa woke from trouble𝐝 𝑑reams, he found himself transformed in his bed into a horrible vermin‎٠‎ He l   lay on his armour-like back, and if he lifted his head a little he could see his brown belly, slightlh domed and divided by arches ino stiff sections. The bedding was adly able to cover it and and seemed ready to slide off any  moment. His many legxs, pitifully thin compared with the size of the the rest of him, waved about helplessly ashe looked looked.
 
 Consult the [Glitchlings Usage Guide](docs/index.md)
-for end-to-end instructions spanning the Python API, CLI, HuggingFace and Prime Intellect
+for end-to-end instructions spanning the Python API, CLI, HuggingFace, PyTorch, and Prime Intellect
 integrations, and the autodetected Rust pipeline (enabled whenever the extension is present).
 
 ## Motivation
@@ -356,6 +378,7 @@ glitchlings --list
 
 ```text
    Typogre — scope: Character, order: early
+Apostrofae — scope: Character, order: normal
      Mim1c — scope: Character, order: last
   Jargoyle — scope: Word, order: normal
      Adjax — scope: Word, order: normal
@@ -458,6 +481,16 @@ _What a nice word, would be a shame if something happened to it._
 > - `keyboard (str)`: Keyboard layout key-neighbor map to use (default: "CURATOR_QWERTY"; also accepts "QWERTY", "DVORAK", "COLEMAK", and "AZERTY").
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 
+### Apostrofae
+
+_It looks like you're trying to paste some text. Can I help?_
+
+> _**Paperclip Manager.**_ Apostrofae scans for balanced runs of straight quotes, apostrophes, and backticks before replacing them with randomly sampled smart-quote pairs from a curated lookup table. The swap happens in-place so contractions and unpaired glyphs remain untouched.
+>
+> Args
+>
+> - `seed (int)`: Optional seed controlling the deterministic smart-quote sampling (default: 151).
+
 ### Mim1c
 
 _Wait, was that...?_

glitchlings-0.4.3.dist-info/RECORD

@@ -0,0 +1,46 @@
+glitchlings/__init__.py,sha256=bkyRgzjC8ssidEO9UL9VpbYXQxTV1Hz3VAPOIqd9uMg,1182
+glitchlings/__main__.py,sha256=f-P4jiVBd7ZpS6QxRpa_6SJgOG03UhZhcWasMDRWLs8,120
+glitchlings/_zoo_rust.cpython-310-darwin.so,sha256=JiW71HlRNYLu0G2bCRnjHrYxjbQ7fvGXjyc4tAWE-5c,2587040
+glitchlings/compat.py,sha256=T_5Ia8yCzZvsMdicZ2TCcOgDO53_AjNGkSXWTR_qEnA,8908
+glitchlings/config.py,sha256=ofxDMkoMg4j51CFube54aca1Ky9y_ZeVktXpeUEdWmA,12953
+glitchlings/config.toml,sha256=04-Y_JCdQU68SRmwk2qZqrH_bbX4jEH9uh7URtxdIHA,99
+glitchlings/main.py,sha256=uw8VbDgxov1m-wYHPDl2dP5ItpLB4ZHpb0ChJXzcL0o,10623
+glitchlings/dlc/__init__.py,sha256=qlY4nuagy4AAWuPMwmuhwK2m36ktp-qkeiIxC7OXg34,305
+glitchlings/dlc/_shared.py,sha256=EFSnush3rjjaf4La5QfVaf_KEp0U_l_3-q4PKx0A6NQ,1972
+glitchlings/dlc/huggingface.py,sha256=9lW7TnTHA_bXyo4Is8pymZchrB9BIL1bMCP2p7LCMtg,2576
+glitchlings/dlc/prime.py,sha256=qGFI1d4BiOEIgQZ5v9QnlbYx4J4q-vNlh5tWZng11xs,8607
+glitchlings/dlc/pytorch.py,sha256=tfHEDsDAOUnEvImFgRMjqC7Ig_aNVO8suXKpv24C2cA,7823
+glitchlings/dlc/pytorch_lightning.py,sha256=Om45BHYx8tMoUwYOOTk5B5A5AIjNkh58V37OC2IBFxE,8553
+glitchlings/lexicon/__init__.py,sha256=PLuu63iX6GSRypGI4DxiN_U-QmqmDobk1Xb7B5IrsZg,5951
+glitchlings/lexicon/_cache.py,sha256=aWSUb5Ex162dr3HouO2Ic2O8ck3ViEFWs8-XMLKMeJ0,4086
+glitchlings/lexicon/metrics.py,sha256=VBFfFpxjiEwZtK-jS55H8xP7MTC_0OjY8lQ5zSQ9aTY,4572
+glitchlings/lexicon/vector.py,sha256=yWf-vlN2OEHnTCPu7tgDnJbhm47cmhdrTtjR0RZKkUM,22530
+glitchlings/lexicon/wordnet.py,sha256=YcOliPHuesdlekmGspwAyR4fWDDxZWR_dIt_Nsq7ag0,7608
+glitchlings/lexicon/data/default_vector_cache.json,sha256=3iVH0nX8EqMbqOkKWvORCGYtN0LKHn5G_Snlizsnm1g,997
+glitchlings/util/__init__.py,sha256=vc3EAY8ehRjbOiryFdaqvvljXcyNGtZSPiEp9ok1vVw,4674
+glitchlings/util/adapters.py,sha256=psxQFYSFmh1u7NuqtIrKwQP5FOhOrZoxZzc7X7DDi9U,693
+glitchlings/zoo/__init__.py,sha256=1dWZPCTXuh5J7WdCxHX7ZX9bNd8bakzYndxQRhF43i8,5243
+glitchlings/zoo/_ocr_confusions.py,sha256=Ju2_avXiwsr1p8zWFUTOzMxJ8vT5PpYobuGIn4L_sqI,1204
+glitchlings/zoo/_rate.py,sha256=Vb1_5HAzrqr9eAh_zzngSV-d0zI264zcYspnT3VHPkE,504
+glitchlings/zoo/_sampling.py,sha256=KrWyUSsYXghlvktS5hQBO0bPqywEEyA49A2qDWInB7Q,1586
+glitchlings/zoo/_text_utils.py,sha256=fS5L_eq-foBbBdiv4ymI8-O0D0csc3yDekHpX8bqfV4,2754
+glitchlings/zoo/adjax.py,sha256=TABKGQOwpyj_5czSoN8tPyEinwp8oZHKOBfU78ae9n0,3545
+glitchlings/zoo/apostrofae.py,sha256=m2-VPO-ahp0zAEJTHPItXMwnpD9D8bQIjVyyIRzj46k,3922
+glitchlings/zoo/core.py,sha256=3IHYEo8f2K7q4EbSZBYPb4MQXUVoMPm6B0IgsjiWNXk,20493
+glitchlings/zoo/jargoyle.py,sha256=zGXi6WFSzYA_44UXvyK0aj18CMFHIFL4eQeijEHfZl4,11568
+glitchlings/zoo/mim1c.py,sha256=-fgodKWZq--Xw8L2t1EqNbsh48bwX5jZxmiXdoaQShI,3437
+glitchlings/zoo/ocr_confusions.tsv,sha256=KhtR7vJDTITpfTSGa-I7RHr6CK7LkGi2KjdhEWipI6o,183
+glitchlings/zoo/redactyl.py,sha256=9Rtgkg87LnGt47DHKsD8XW25gtg9pv2aXvrFv46XOTQ,5516
+glitchlings/zoo/reduple.py,sha256=ttHha3Yl0SRzEyAx9SfENbJRO_WhmJYL8ow5LGKn248,4258
+glitchlings/zoo/rushmore.py,sha256=R6dgt4HSvkt31foazNmUhO4wL9PHpjh_7pzJ8vQPgO0,4322
+glitchlings/zoo/scannequin.py,sha256=AQ7JPIxLiPFy4fDV6MgO4OFo34dMShc7sipStUaCG40,4900
+glitchlings/zoo/typogre.py,sha256=AuAtx-KyWrk-zX3uuxjkvjiduLyDwGJNW7XYktnsuos,6712
+glitchlings/zoo/zeedub.py,sha256=3VneZOEeL98Ek1VnZQI4V2o1alv41vvMzZXrKc9Lt1s,4875
+glitchlings/zoo/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+glitchlings/zoo/assets/apostrofae_pairs.json,sha256=bfjSEaMTI_axGNJ93nI431KXU0IVp7ayO42gGcMgL6U,521
+glitchlings-0.4.3.dist-info/licenses/LICENSE,sha256=YCvGip-LoaRyu6h0nPo71q6eHEkzUpsE11psDJOIRkw,11337
+glitchlings-0.4.3.dist-info/METADATA,sha256=NV0-8T4jx5R2Eswhib6B29vAeoiXBdIDBFOu6KrzqdM,32242
+glitchlings-0.4.3.dist-info/WHEEL,sha256=G4cu_uTI97hAXSudQC0D9fpgNQkuavCNljtwFXiUqZM,114
+glitchlings-0.4.3.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
+glitchlings-0.4.3.dist-info/top_level.txt,sha256=VHFNBrLjtDwPCYXbGKi6o17Eueedi81eNbR3hBOoST0,12
+glitchlings-0.4.3.dist-info/RECORD,,

glitchlings/lexicon/graph.py

@@ -1,282 +0,0 @@
-"""Graph-based lexicon backed by ConceptNet/Numberbatch embeddings."""
-
-from __future__ import annotations
-
-import re
-from pathlib import Path
-from typing import Iterable, Mapping, MutableMapping, Sequence
-
-from . import LexiconBackend
-from ._cache import CacheSnapshot
-from ._cache import load_cache as _load_cache_file
-from ._cache import write_cache as _write_cache_file
-from .vector import VectorLexicon
-
-_CONCEPT_RE = re.compile(r"^/c/(?P<lang>[a-z]{2})/(?P<term>[^/]+)")
-_PUNCTUATION_RE = re.compile(r"[^\w\s-]+", re.UNICODE)
-
-
-def _lemmatize_token(token: str) -> str:
-    """Return a lightweight lemma for ``token`` using heuristic rules."""
-    irregular = {
-        "children": "child",
-        "mice": "mouse",
-        "geese": "goose",
-        "feet": "foot",
-        "teeth": "tooth",
-        "men": "man",
-        "women": "woman",
-        "better": "good",
-        "worse": "bad",
-    }
-    lowered = token.lower()
-    if lowered in irregular:
-        return irregular[lowered]
-
-    if lowered.endswith("ies") and len(lowered) > 3:
-        return lowered[:-3] + "y"
-    if lowered.endswith("ves") and len(lowered) > 3:
-        return lowered[:-3] + "f"
-    if lowered.endswith("men") and len(lowered) > 3:
-        return lowered[:-3] + "man"
-    if lowered.endswith("ses") and len(lowered) > 3:
-        return lowered[:-2]
-    if lowered.endswith("es") and len(lowered) > 3:
-        return lowered[:-2]
-    if lowered.endswith("s") and len(lowered) > 2 and not lowered.endswith("ss"):
-        return lowered[:-1]
-    if lowered.endswith("ing") and len(lowered) > 4:
-        stem = lowered[:-3]
-        if len(stem) > 2 and stem[-1] == stem[-2]:
-            stem = stem[:-1]
-        return stem
-    if lowered.endswith("ed") and len(lowered) > 3:
-        stem = lowered[:-2]
-        if len(stem) > 2 and stem[-1] == stem[-2]:
-            stem = stem[:-1]
-        return stem
-    return lowered
-
-
-def _normalize_phrase(phrase: str) -> str:
-    """Normalise ``phrase`` for ConceptNet lookups."""
-    stripped = _PUNCTUATION_RE.sub(" ", phrase.lower())
-    tokens = [token for token in stripped.split() if token]
-    if not tokens:
-        return ""
-    lemmatised = [_lemmatize_token(token) for token in tokens]
-    return " ".join(lemmatised)
-
-
-def _concept_terms(normalized: str) -> list[str]:
-    """Return ConceptNet term variants for ``normalized``."""
-    collapsed = normalized.replace(" ", "_")
-    if not collapsed:
-        return []
-    variants = {collapsed}
-    variants.add(collapsed.replace("_", "-"))
-    variants.add(collapsed.replace("-", "_"))
-    return list(variants)
-
-
-def _surface_from_concept(concept: str) -> str | None:
-    """Return a human-readable surface form for ``concept``."""
-    match = _CONCEPT_RE.match(concept)
-    if match is None:
-        return None
-    term = match.group("term")
-    surface = term.replace("_", " ")
-    surface = surface.replace("-", " ")
-    return " ".join(surface.split())
-
-
-def _language_from_concept(concept: str) -> str | None:
-    match = _CONCEPT_RE.match(concept)
-    if match is None:
-        return None
-    return match.group("lang")
-
-
-def _load_numberbatch(path: Path, *, languages: set[str]) -> Mapping[str, list[float]]:
-    """Load ConceptNet Numberbatch embeddings from ``path``."""
-    if not path.exists():
-        return {}
-
-    if path.suffix == ".gz":
-        import gzip
-
-        handle = gzip.open(path, "rt", encoding="utf8")
-    else:
-        handle = path.open("r", encoding="utf8")
-
-    with handle as stream:
-        header = stream.readline()
-        try:
-            parts = header.strip().split()
-            if len(parts) >= 2:
-                int(parts[0])
-                int(parts[1])
-        except ValueError:
-            stream.seek(0)
-
-        embeddings: dict[str, list[float]] = {}
-        for line in stream:
-            tokens = line.strip().split()
-            if len(tokens) <= 2:
-                continue
-            concept = tokens[0]
-            lang = _language_from_concept(concept)
-            if lang is None or lang not in languages:
-                continue
-            try:
-                vector = [float(value) for value in tokens[1:]]
-            except ValueError:
-                continue
-            embeddings[concept] = vector
-    return embeddings
-
-
-class GraphLexicon(LexiconBackend):
-    """Lexicon backed by ConceptNet/Numberbatch embeddings."""
-
-    def __init__(
-        self,
-        *,
-        source: Mapping[str, Sequence[float]] | str | Path | None = None,
-        cache: Mapping[str, Sequence[str]] | None = None,
-        cache_path: str | Path | None = None,
-        languages: Iterable[str] = ("en",),
-        max_neighbors: int = 50,
-        min_similarity: float = 0.0,
-        seed: int | None = None,
-    ) -> None:
-        super().__init__(seed=seed)
-        self._languages = {language.lower() for language in languages}
-        if not self._languages:
-            self._languages = {"en"}
-        self._max_neighbors = max(1, max_neighbors)
-        self._min_similarity = min_similarity
-        self._cache: MutableMapping[str, list[str]] = {}
-        self._cache_path: Path | None = Path(cache_path) if cache_path is not None else None
-        self._cache_checksum: str | None = None
-        if self._cache_path is not None:
-            snapshot = _load_cache_file(self._cache_path)
-            self._cache.update(snapshot.entries)
-            self._cache_checksum = snapshot.checksum
-        if cache is not None:
-            for key, values in cache.items():
-                self._cache[str(key)] = [str(value) for value in values]
-        self._cache_dirty = False
-
-        prepared_source = self._prepare_source(source)
-        self._backend = VectorLexicon(
-            source=prepared_source if prepared_source else None,
-            max_neighbors=self._max_neighbors,
-            min_similarity=self._min_similarity,
-            case_sensitive=True,
-            seed=seed,
-        )
-
-    def _prepare_source(
-        self, source: Mapping[str, Sequence[float]] | str | Path | None
-    ) -> Mapping[str, Sequence[float]]:
-        if source is None:
-            return {}
-        if isinstance(source, Mapping):
-            prepared: dict[str, list[float]] = {}
-            for key, vector in source.items():
-                lang = _language_from_concept(key)
-                if lang is None or lang not in self._languages:
-                    continue
-                prepared[key] = [float(value) for value in vector]
-            return prepared
-        path = Path(source)
-        embeddings = _load_numberbatch(path, languages=self._languages)
-        return embeddings
-
-    def reseed(self, seed: int | None) -> None:
-        super().reseed(seed)
-        self._backend.reseed(seed)
-
-    def _concept_candidates(self, normalized: str) -> list[str]:
-        terms = _concept_terms(normalized)
-        concepts = []
-        for language in sorted(self._languages):
-            for term in terms:
-                concepts.append(f"/c/{language}/{term}")
-        return concepts
-
-    def _collect_synonyms(self, normalized: str) -> list[str]:
-        candidates: list[str] = []
-        seen: set[str] = set()
-        for concept in self._concept_candidates(normalized):
-            neighbors = self._backend.precompute(concept, limit=self._max_neighbors)
-            for neighbor in neighbors:
-                lang = _language_from_concept(neighbor)
-                if lang is None or lang not in self._languages:
-                    continue
-                surface = _surface_from_concept(neighbor)
-                if surface is None:
-                    continue
-                surface_norm = _normalize_phrase(surface)
-                if not surface_norm or surface_norm == normalized:
-                    continue
-                if surface_norm in seen:
-                    continue
-                seen.add(surface_norm)
-                candidates.append(surface)
-        return candidates
-
-    def _ensure_cached(self, normalized: str) -> list[str]:
-        if normalized in self._cache:
-            return self._cache[normalized]
-        synonyms = self._collect_synonyms(normalized)
-        self._cache[normalized] = synonyms
-        if self._cache_path is not None:
-            self._cache_dirty = True
-        return synonyms
-
-    def get_synonyms(self, word: str, pos: str | None = None, n: int = 5) -> list[str]:
-        normalized = _normalize_phrase(word)
-        if not normalized:
-            return []
-        synonyms = self._ensure_cached(normalized)
-        return self._deterministic_sample(synonyms, limit=n, word=word, pos=pos)
-
-    def precompute(self, word: str) -> list[str]:
-        normalized = _normalize_phrase(word)
-        if not normalized:
-            return []
-        return list(self._ensure_cached(normalized))
-
-    def export_cache(self) -> dict[str, list[str]]:
-        return {key: list(values) for key, values in self._cache.items()}
-
-    @classmethod
-    def load_cache(cls, path: str | Path) -> CacheSnapshot:
-        """Load and validate a persisted ConceptNet cache file."""
-        return _load_cache_file(Path(path))
-
-    def save_cache(self, path: str | Path | None = None) -> Path:
-        if path is None:
-            if self._cache_path is None:
-                raise RuntimeError("No cache path supplied to GraphLexicon.")
-            target = self._cache_path
-        else:
-            target = Path(path)
-            self._cache_path = target
-        snapshot = _write_cache_file(target, self._cache)
-        self._cache_checksum = snapshot.checksum
-        self._cache_dirty = False
-        return target
-
-    def supports_pos(self, pos: str | None) -> bool:
-        return True
-
-    def __repr__(self) -> str:  # pragma: no cover - debug helper
-        adapter = getattr(self._backend, "_adapter", None)
-        state = "loaded" if adapter else "empty"
-        return (
-            f"GraphLexicon(languages={sorted(self._languages)!r}, "
-            f"max_neighbors={self._max_neighbors}, seed={self.seed!r}, state={state})"
-        )