feat: debloat dictionary parsers (remove Datamuse, switch to Wiktionary REST API with English section isolation)

tests/test_api.py

@@ -1018,30 +1018,34 @@ def test_http_connection_pooling():
     from app.dictionary import get_http_client, close_http_client, lookup_term
     import asyncio
 
-    # 1. Singleton returns same instance
-    c1 = get_http_client()
-    c2 = get_http_client()
-    assert c1 is c2
-    assert not c1.is_closed
+    async def run_pool_test():
+        # 1. Singleton returns same instance
+        c1 = get_http_client()
+        c2 = get_http_client()
+        assert c1 is c2
+        assert not c1.is_closed
 
-    # 2. Check connection limits configuration
-    pool = c1._transport._pool
-    assert pool._max_keepalive_connections == 10
-    assert pool._max_connections == 20
+        # 2. Check connection limits configuration
+        pool = c1._transport._pool
+        assert pool._max_keepalive_connections == 10
+        assert pool._max_connections == 20
 
-    # 3. Lookup using pooled client
-    res = asyncio.run(lookup_term("resilience"))
-    assert res["query"] == "resilience"
-    assert "translation" in res
+        # 3. Lookup using pooled client
+        res = await lookup_term("resilience")
+        assert res["query"] == "resilience"
+        assert "translation" in res
+
+        # 4. Clean closure on shutdown
+        await close_http_client()
+        assert c1.is_closed
+        # Next call creates a new active client
+        c3 = get_http_client()
+        assert c3 is not c1
+        assert not c3.is_closed
+        await close_http_client()
+
+    asyncio.run(run_pool_test())
 
-    # 4. Clean closure on shutdown
-    asyncio.run(close_http_client())
-    assert c1.is_closed
-    # Next call creates a new active client
-    c3 = get_http_client()
-    assert c3 is not c1
-    assert not c3.is_closed
-    asyncio.run(close_http_client())
 
 
 def test_sqlite_pragma_tuning_and_composite_indexes():
@@ -1115,3 +1119,37 @@ def test_sqlite_pragma_tuning_and_composite_indexes():
     finally:
         conn.close()
 
+
+def test_debloat_dictionary_and_wiktionary_rest_parser():
+    import asyncio
+    import app.dictionary as dictionary
+    from app.dictionary import fetch_wiktionary_wikitext, fetch_wiktionary_definitions, lookup_term, get_http_client
+
+    # 1. Verify Datamuse is removed (YAGNI debloat)
+    assert not hasattr(dictionary, "fetch_datamuse"), "fetch_datamuse should be completely removed"
+
+    # 2. Test modern Wiktionary REST wikitext parser isolates English and extracts IPA & RU
+    async def run_checks():
+        client = get_http_client()
+        res_wiki = await fetch_wiktionary_wikitext("chat", client=client)
+        assert len(res_wiki["ipa"]) > 0
+        assert any("t͡ʃæt" in ipa for ipa in res_wiki["ipa"])
+        # Ensure French word "chat" (cat / кот) didn't leak into English translations
+        assert "кот" not in res_wiki["ru_translations"]
+        assert any(t in res_wiki["ru_translations"] for t in ["болтать", "разговаривать", "беседа", "разговор", "чатиться"])
+
+        # 3. Test definition cleaning and HTML entity decoding
+        res_defs = await fetch_wiktionary_definitions("reluctant", client=client)
+        assert "Adjective" in res_defs["parts_of_speech"]
+        assert len(res_defs["definitions"]) > 0
+        assert "<" not in res_defs["definitions"][0] and ">" not in res_defs["definitions"][0]
+
+        # 4. Test end-to-end lookup_term without Datamuse
+        term_res = await lookup_term("diligent")
+        assert term_res["query"] == "diligent"
+        assert len(term_res["translation"]) > 0
+        assert len(term_res["definitions"]) > 0
+
+    asyncio.run(run_checks())
+
+