feat: add /words-frequency POST route to return a wordsapi compatible response from nltk wordnet corpus

my_ghost_writer/app.py

@@ -21,6 +21,7 @@ from my_ghost_writer.constants import (app_logger, ALLOWED_ORIGIN_LIST, API_MODE
 from my_ghost_writer.pymongo_utils import mongodb_health_check
 from my_ghost_writer.text_parsers import text_stemming
 from my_ghost_writer.type_hints import RequestTextFrequencyBody, RequestQueryThesaurusWordsapiBody
+from my_ghost_writer.thesaurus import get_current_info_wordnet, get_synsets_by_word_and_language
 
 
 async def mongo_health_check_background_task():
@@ -28,7 +29,7 @@ async def mongo_health_check_background_task():
     while ME_CONFIG_MONGODB_USE_OK:
         try:
             db_ok["mongo_ok"] = health_mongo() == "Mongodb: still alive..."
-        except PyMongoError:
+        except (PyMongoError, HTTPException):
             db_ok["mongo_ok"] = False
         await asyncio.sleep(ME_CONFIG_MONGODB_HEALTHCHECK_SLEEP)
 
@@ -72,6 +73,17 @@ def health():
     return "Still alive..."
 
 
+@app.get("/health-wordnet")
+def get_wordnet_languages():
+    try:
+        info = get_current_info_wordnet()
+        return JSONResponse(status_code=200, content={"msg": info})
+    except Exception as e:
+        app_logger.error("exception:")
+        app_logger.error(e)
+        raise HTTPException(status_code=503, detail=str(type(e)))
+
+
 @app.get("/health-mongo")
 def health_mongo() -> str:
     app_logger.info(f"pymongo driver version:{pymongo_version}!")
@@ -107,6 +119,32 @@ def get_words_frequency(body: RequestTextFrequencyBody | str) -> JSONResponse:
     return JSONResponse(status_code=200, content=content_response)
 
 
+@app.post("/thesaurus-wordnet")
+def get_thesaurus_wordnet(body: RequestQueryThesaurusWordsapiBody | str) -> JSONResponse:
+    t0 = datetime.now()
+    app_logger.info(f"body type: {type(body)} => {body}.")
+    body_validated = RequestQueryThesaurusWordsapiBody.model_validate_json(body)
+    query = body_validated.query
+    app_logger.info(f"query: {type(query)} => {query}, starting get_synsets_by_word_and_language...")
+    use_mongo: bool = db_ok["mongo_ok"]
+    app_logger.info(f"query: {type(query)} => {query}, use mongo? {use_mongo}.")
+    if use_mongo:
+        try:
+            response = pymongo_operations_rw.get_document_by_word(query=query)
+            t1 = datetime.now()
+            duration = (t1 - t0).total_seconds()
+            app_logger.info(f"found local data, duration: {duration:.3f}s.")
+            return JSONResponse(status_code=200, content={"duration": duration, "thesaurus": response, "source": "local"})
+        except (PyMongoError, AssertionError) as pme:
+            app_logger.info(f"{pme}! Let's try the remote service...")
+
+    response = get_synsets_by_word_and_language(query, lang="eng")
+    t1 = datetime.now()
+    duration = (t1 - t0).total_seconds()
+    app_logger.info(f"response.status_code: {response.status_code}, duration: {duration:.3f}s.")
+    return JSONResponse(status_code=200, content={"duration": duration, "thesaurus": response, "source": "wordnet"})
+
+
 @app.post("/thesaurus-wordsapi")
 def get_thesaurus_wordsapi(body: RequestQueryThesaurusWordsapiBody | str) -> JSONResponse:
     t0 = datetime.now()

my_ghost_writer/constants.py

@@ -20,6 +20,7 @@ IS_TESTING = bool(os.getenv('IS_TESTING', ""))
 LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
 API_MODE = bool(os.getenv("API_MODE", ""))
 N_WORDS_GRAM = int(os.getenv("N_WORDS_GRAM", 2))
+WORDNET_LANGUAGES=(os.getenv("WORDNET_LANGUAGES", "eng,"))
 WORDSAPI_KEY = os.getenv("WORDSAPI_KEY")
 WORDSAPI_URL = os.getenv("WORDSAPI_URL", "https://wordsapiv1.p.rapidapi.com/words")
 RAPIDAPI_HOST = os.getenv("RAPIDAPI_HOST", "wordsapiv1.p.rapidapi.com")

my_ghost_writer/thesaurus.py

@@ -0,0 +1,200 @@
+from typing import Any
+
+from nltk.corpus import wordnet31 as wn
+
+from my_ghost_writer.type_hints import ResponseWordsAPI
+
+
+def get_current_info_wordnet():
+    return {"languages": wn.langs(), "version": wn.get_version()}
+
+
+def get_synsets_by_word_and_language(word: str, lang: str = "eng") -> ResponseWordsAPI:
+    results = []
+    for synset in wn.synsets(word, lang=lang):
+        # Synonyms (lemmas for this synset, excluding the input word)
+        synonyms = sorted(
+            set(
+                l.name().replace('_', ' ')
+                for l in synset.lemmas(lang=lang)
+                if l.name().lower() != word.lower()
+            )
+        )
+        # Antonyms (from lemmas)
+        antonyms = sorted(
+            set(
+                ant.name().replace('_', ' ')
+                for l in synset.lemmas(lang=lang)
+                for ant in l.antonyms()
+            )
+        )
+        # Derivationally related forms (from lemmas)
+        derivation = sorted(
+            set(
+                d.name().replace('_', ' ')
+                for l in synset.lemmas(lang=lang)
+                for d in l.derivationally_related_forms()
+            )
+        )
+        # Pertainyms (from lemmas)
+        pertains_to = sorted(
+            set(
+                p.name().replace('_', ' ')
+                for l in synset.lemmas(lang=lang)
+                for p in l.pertainyms()
+            )
+        )
+        # Synset relations
+        type_of = sorted(
+            set(
+                l.name().replace('_', ' ')
+                for h in synset.hypernyms()
+                for l in h.lemmas(lang=lang)
+            )
+        )
+        # Hyponyms (hasTypes)
+        has_types = sorted(
+            set(
+                l.name().replace('_', ' ')
+                for h in synset.hyponyms()
+                for l in h.lemmas(lang=lang)
+            )
+        )
+        # Holonyms (partOf)
+        part_of = sorted(
+            set(
+                l.name().replace('_', ' ')
+                for h in synset.member_holonyms() + synset.part_holonyms() + synset.substance_holonyms()
+                for l in h.lemmas(lang=lang)
+            )
+        )
+        # Meronyms (hasParts)
+        has_parts = sorted(
+            set(
+                l.name().replace('_', ' ')
+                for h in synset.member_meronyms() + synset.part_meronyms() + synset.substance_meronyms()
+                for l in h.lemmas(lang=lang)
+            )
+        )
+        instance_of = sorted(
+            set(
+                l.name().replace('_', ' ')
+                for h in synset.instance_hypernyms()
+                for l in h.lemmas(lang=lang)
+            )
+        )
+        has_instances = sorted(
+            set(
+                l.name().replace('_', ' ')
+                for h in synset.instance_hyponyms()
+                for l in h.lemmas(lang=lang)
+            )
+        )
+        similar_to = sorted(
+            set(
+                l.name().replace('_', ' ')
+                for h in synset.similar_tos()
+                for l in h.lemmas(lang=lang)
+            )
+        )
+        also = sorted(
+            set(
+                l.name().replace('_', ' ')
+                for h in synset.also_sees()
+                for l in h.lemmas(lang=lang)
+            )
+        )
+        entails = sorted(
+            set(
+                l.name().replace('_', ' ')
+                for h in synset.entailments()
+                for l in h.lemmas(lang=lang)
+            )
+        )
+        causes = sorted(
+            set(
+                l.name().replace('_', ' ')
+                for h in synset.causes()
+                for l in h.lemmas(lang=lang)
+            )
+        )
+        verb_groups = sorted(
+            set(
+                l.name().replace('_', ' ')
+                for h in synset.verb_groups()
+                for l in h.lemmas(lang=lang)
+            )
+        )
+        has_substances = sorted(
+            set(
+                l.name().replace('_', ' ')
+                for h in synset.substance_meronyms()
+                for l in h.lemmas(lang=lang)
+            )
+        )
+        in_category = sorted(
+            set(
+                l.name().replace('_', ' ')
+                for h in synset.topic_domains()
+                for l in h.lemmas(lang=lang)
+            )
+        )
+        usage_of = sorted(
+            set(
+                l.name().replace('_', ' ')
+                for h in synset.usage_domains()
+                for l in h.lemmas(lang=lang)
+            )
+        )
+        obj = {
+            "definition": synset.definition(lang=lang),
+        }
+        if synonyms:
+            obj["synonyms"] = synonyms
+        if type_of:
+            obj["typeOf"] = type_of
+        if has_types:
+            obj["hasTypes"] = has_types
+        if part_of:
+            obj["partOf"]: part_of
+        if has_parts:
+            obj["hasParts"]: has_parts
+        if antonyms:
+            obj["antonyms"] = antonyms
+        if derivation:
+            obj["derivation"] = derivation
+        if pertains_to:
+            obj["pertainsTo"] = pertains_to
+        if instance_of:
+            obj["instanceOf"] = instance_of
+        if has_instances:
+            obj["hasInstances"] = has_instances
+        if similar_to:
+            obj["similarTo"] = similar_to
+        if also:
+            obj["also"] = also
+        if entails:
+            obj["entails"] = entails
+        if has_substances:
+            obj["hasSubstances"] = has_substances
+        if in_category:
+            obj["inCategory"] = in_category
+        if usage_of:
+            obj["usageOf"] = usage_of
+        if causes:
+            obj["causes"] = causes
+        if verb_groups:
+            obj["verbGroups"] = verb_groups
+        results.append(obj)
+    return {
+        "word": word,
+        "results": results
+    }
+
+
+if __name__ == '__main__':
+    res = {}
+    for w in ["dog", "spider", "look", "tree"]:
+        oo = get_synsets_by_word_and_language(w, lang="eng")
+        res[w] = oo
+    pass

my_ghost_writer/type_hints.py

@@ -1,4 +1,4 @@
-from typing import TypedDict
+from typing import TypedDict, Optional
 from pydantic import BaseModel
 
 
@@ -45,6 +45,34 @@ class WordStem(TypedDict):
     offsets_array: list[OffsetArray]
 
 
+class ResultWordsAPI(TypedDict):
+    definition: str
+    synonyms: Optional[list[str]]
+    typeOf: Optional[list[str]]
+    hasTypes: Optional[list[str]]
+    partOf: Optional[list[str]]
+    hasParts: Optional[list[str]]
+    antonyms: Optional[list[str]]
+    derivation: Optional[list[str]]
+    pertainsTo: Optional[list[str]]
+    instanceOf: Optional[list[str]]
+    hasInstances: Optional[list[str]]
+    similarTo: Optional[list[str]]
+    also: Optional[list[str]]
+    entails: Optional[list[str]]
+    hasSubstances: Optional[list[str]]
+    inCategory: Optional[list[str]]
+    usageOf: Optional[list[str]]
+    causes: Optional[list[str]]
+    verbGroups: Optional[list[str]]
+
+
+class ResponseWordsAPI(TypedDict):
+    word: str
+    results: list[ResultWordsAPI]
+
+
 RequestTextRowsList = list[InputTextRow]
 RequestTextRowsParentList = list[InputTextRowWithParent]
 ResponseTextRowsDict = tuple[int, dict[str, WordStem]]
+#ResponseWordsAPI = dict[str, str | list[str]]

tests/events/expected_get_synsets_by_word_and_language_dog.json

@@ -0,0 +1 @@
+{"word": "dog", "results": [{"definition": "a member of the genus Canis (probably descended from the common wolf) that has been domesticated by man since prehistoric times; occurs in many breeds", "synonyms": ["Canis familiaris", "domestic dog"], "typeOf": ["canid", "canine", "domestic animal", "domesticated animal"], "hasTypes": ["Belgian griffon", "Brussels griffon", "Great Pyrenees", "Leonberg", "Mexican hairless", "Newfoundland", "Newfoundland dog", "Welsh corgi", "barker", "basenji", "bow-wow", "carriage dog", "coach dog", "corgi", "cur", "dalmatian", "doggie", "doggy", "griffon", "hunting dog", "lapdog", "mongrel", "mutt", "pooch", "poodle", "poodle dog", "pug", "pug-dog", "puppy", "spitz", "toy", "toy dog", "working dog"]}, {"definition": "a dull unattractive unpleasant girl or woman", "synonyms": ["frump"], "typeOf": ["disagreeable woman", "unpleasant woman"], "derivation": ["frumpy"]}, {"definition": "informal term for a man", "typeOf": ["blighter", "bloke", "chap", "cuss", "fella", "feller", "fellow", "gent", "lad"]}, {"definition": "someone who is morally reprehensible", "synonyms": ["blackguard", "bounder", "cad", "heel", "hound"], "typeOf": ["scoundrel", "villain"], "hasTypes": ["perisher"], "derivation": ["blackguardly"]}, {"definition": "a smooth-textured sausage of minced beef or pork usually smoked; often served on a bread roll", "synonyms": ["frank", "frankfurter", "hot dog", "hotdog", "weenie", "wiener", "wienerwurst"], "typeOf": ["sausage"], "hasTypes": ["Vienna sausage"]}, {"definition": "a hinged catch that fits into a notch of a ratchet to move a wheel forward or prevent it from moving backward", "synonyms": ["click", "detent", "pawl"], "typeOf": ["catch", "stop"]}, {"definition": "metal supports for logs in a fireplace", "synonyms": ["andiron", "dog-iron", "firedog"], "typeOf": ["support"]}, {"definition": "go after with the intent to catch", "synonyms": ["chase", "chase after", "give chase", "go after", "tag", "tail", "track", "trail"], "typeOf": ["follow", "pursue"], "hasTypes": ["hound", "hunt", "quest", "run down", "trace", "tree"], "derivation": ["chase", "chaser", "tag", "tail", "tailing", "track", "tracker", "tracking", "trailing"]}]}

tests/events/expected_get_synsets_by_word_and_language_look.json

@@ -0,0 +1 @@
+{"word": "look", "results": [{"definition": "the feelings expressed on a person's face", "synonyms": ["aspect", "expression", "face", "facial expression"], "typeOf": ["countenance", "visage"], "hasTypes": ["leer", "light", "spark", "sparkle", "twinkle"], "derivation": ["look"]}, {"definition": "the act of directing the eyes toward something and perceiving it visually", "synonyms": ["looking", "looking at"], "typeOf": ["perception", "sensing"], "hasTypes": ["coup d'oeil", "dekko", "evil eye", "glance", "glimpse", "lookout", "observance", "observation", "outlook", "peek", "peep", "rubber-necking", "scrutiny", "sight", "sightseeing", "squint", "stare", "survey", "view", "watching"], "derivation": ["look"]}, {"definition": "physical appearance", "typeOf": ["appearance", "visual aspect"], "derivation": ["look"]}, {"definition": "the general atmosphere of a place or situation and the effect that it has on people", "synonyms": ["feel", "feeling", "flavor", "flavour", "smell", "spirit", "tone"], "typeOf": ["ambiance", "ambience", "atmosphere"], "hasTypes": ["Hollywood", "Zeitgeist"], "derivation": ["feel", "look", "spirit", "spiritize"]}, {"definition": "perceive with attention; direct one's gaze towards", "hasTypes": ["admire", "consider", "eye", "eyeball", "gape", "gawk", "gawp", "gaze", "get a load", "give the eye", "give the glad eye", "give the once over", "glance", "glint", "gloat", "goggle", "have a look", "leer", "look around", "look away", "look back", "look backward", "ogle", "peek", "peep", "peer", "regard", "squint", "stare", "take a look"], "derivation": ["look", "looker"], "entails": ["see"]}, {"definition": "give a certain impression or have a certain outward aspect", "synonyms": ["appear", "seem"], "typeOf": ["be"], "hasTypes": ["beam", "come across", "cut", "feel", "gleam", "glint", "glisten", "glitter", "glow", "jump", "jump out", "leap out", "lift", "loom", "make", "pass off", "radiate", "rear", "rise", "shine", "sound", "stand out", "stick out"], "derivation": ["appearance", "look"]}, {"definition": "have a certain outward or facial expression", "typeOf": ["be"], "hasTypes": ["squint"], "derivation": ["look"]}, {"definition": "search or seek", "synonyms": ["search"], "typeOf": ["examine", "see"], "hasTypes": ["cruise", "horn in", "hunt", "intrude", "nose", "poke", "prospect", "pry"], "derivation": ["search", "searcher"]}, {"definition": "be oriented in a certain direction, often with respect to another reference point; be opposite to", "synonyms": ["face", "front"], "typeOf": ["lie"], "hasTypes": ["confront"], "antonyms": ["back"], "derivation": ["front", "frontage"], "verbGroups": ["face"]}, {"definition": "take charge of or deal with", "synonyms": ["attend", "see", "take care"], "typeOf": ["care", "give care"], "hasTypes": ["minister", "tend"], "derivation": ["attention"]}, {"definition": "convey by one's expression", "typeOf": ["convey"], "derivation": ["look"]}, {"definition": "look forward to the probable occurrence of", "synonyms": ["await", "expect", "wait"], "hasTypes": ["anticipate", "expect", "hang on", "hold on", "hold the line", "look for", "look forward", "look to"], "derivation": ["expectancy", "expectant", "expectation", "waiter"], "verbGroups": ["anticipate", "expect"]}, {"definition": "accord in appearance with", "typeOf": ["agree", "check", "correspond", "fit", "gibe", "jibe", "match", "tally"]}, {"definition": "have faith or confidence in", "synonyms": ["bank", "bet", "calculate", "count", "depend", "reckon", "rely", "swear"], "typeOf": ["trust"], "derivation": ["dependency", "reliance", "reliant"]}]}

tests/events/expected_get_synsets_by_word_and_language_power.json

@@ -0,0 +1 @@
+{"word": "power", "results": [{"definition": "possession of controlling influence", "synonyms": ["powerfulness"], "typeOf": ["quality"], "hasTypes": ["chokehold", "control", "discretion", "disposal", "effectiveness", "effectivity", "effectuality", "effectualness", "free will", "influence", "interest", "interestingness", "irresistibility", "irresistibleness", "jurisdiction", "legal power", "persuasiveness", "potency", "preponderance", "puissance", "repellant", "repellent", "stranglehold", "strength", "sway", "throttlehold", "valence", "valency", "veto"], "antonyms": ["powerlessness"], "derivation": ["powerful"]}, {"definition": "(physics) the rate of doing work; measured in watts (= joules/second)", "typeOf": ["physical phenomenon"], "hasTypes": ["electric power", "electrical power", "waterpower", "wattage"], "derivation": ["power"], "inCategory": ["natural philosophy", "physics"]}, {"definition": "possession of the qualities (especially mental qualities) required to do something or get something done", "synonyms": ["ability"], "typeOf": ["cognition", "knowledge", "noesis"], "hasTypes": ["accomplishment", "acquirement", "acquisition", "aptitude", "attainment", "bilingualism", "capacity", "creative thinking", "creativeness", "creativity", "faculty", "hand", "intelligence", "know-how", "leadership", "mental ability", "mental faculty", "module", "originality", "science", "skill", "superior skill"], "antonyms": ["inability"], "derivation": ["able"]}, {"definition": "(of a government or government official) holding an office means being in power", "synonyms": ["office"], "typeOf": ["state"], "hasTypes": ["executive clemency", "war power"], "derivation": ["official", "officiate"], "inCategory": ["administration", "governance", "governing", "government", "government activity"]}, {"definition": "one possessing or exercising power or influence or authority", "synonyms": ["force"], "typeOf": ["causal agency", "causal agent", "cause"], "hasTypes": ["Moloch", "influence", "juggernaut", "steamroller"], "derivation": ["force"]}, {"definition": "a mathematical notation indicating the number of times a quantity is multiplied by itself", "synonyms": ["exponent", "index"], "typeOf": ["mathematical notation"], "hasTypes": ["degree", "log", "logarithm"], "derivation": ["exponential"]}, {"definition": "physical strength", "synonyms": ["might", "mightiness"], "typeOf": ["strength"], "derivation": ["mighty"]}, {"definition": "a state powerful enough to influence events throughout the world", "synonyms": ["great power", "major power", "superpower", "world power"], "typeOf": ["body politic", "commonwealth", "country", "land", "nation", "res publica", "state"], "hasTypes": ["hegemon"]}, {"definition": "energy made available by the flow of electric charge through a conductor", "synonyms": ["electrical energy", "electricity"], "typeOf": ["energy", "free energy"], "hasTypes": ["AC", "DC", "alternating current", "alternating electric current", "direct current", "direct electric current", "signal"], "derivation": ["electric", "electrify"]}, {"definition": "a very wealthy or powerful businessman", "synonyms": ["baron", "big businessman", "business leader", "king", "magnate", "mogul", "top executive", "tycoon"], "typeOf": ["businessman", "man of affairs"], "hasTypes": ["oil tycoon"]}, {"definition": "supply the force or power for the functioning of", "typeOf": ["cater", "ply", "provide", "supply"], "hasTypes": ["drive"], "derivation": ["power"]}]}

tests/events/expected_get_synsets_by_word_and_language_term.json

@@ -0,0 +1 @@
+{"word": "term", "results": [{"definition": "a word or expression used for some particular thing", "typeOf": ["word"], "hasTypes": ["referent"], "derivation": ["term"]}, {"definition": "a limited period of time", "typeOf": ["period", "period of time", "time period"], "hasTypes": ["academic session", "academic term", "incumbency", "prison term", "school term", "sentence", "session", "tenure", "term of office", "time"]}, {"definition": "(usually plural) a statement of what is required as part of an agreement", "synonyms": ["condition", "strings"], "typeOf": ["statement"], "derivation": ["condition"], "usageOf": ["plural", "plural form"]}, {"definition": "any distinct quantity contained in a polynomial", "typeOf": ["quantity"]}, {"definition": "one of the substantive phrases in a logical proposition", "typeOf": ["constituent", "grammatical constituent"], "hasTypes": ["categorem", "categoreme", "major term", "middle term", "minor term", "predicate", "referent", "relatum", "subject"]}, {"definition": "the end of gestation or point at which birth is imminent", "synonyms": ["full term"], "typeOf": ["point", "point in time"]}, {"definition": "(architecture) a statue or a human bust or an animal carved out of the top of a square pillar; originally used as a boundary marker in ancient Rome", "synonyms": ["terminal figure", "terminus"], "typeOf": ["statue"], "inCategory": ["architecture"]}, {"definition": "name formally or designate with a term", "typeOf": ["be known as", "call", "know as", "name"], "derivation": ["term"]}]}

tests/events/look_wordsapi_response.json

@@ -0,0 +1,169 @@
+{
+  "word": "example",
+  "results": [
+    {
+      "definition": "a representative form or pattern",
+      "partOfSpeech": "noun",
+      "synonyms": [
+        "model"
+      ],
+      "typeOf": [
+        "representation",
+        "internal representation",
+        "mental representation"
+      ],
+      "hasTypes": [
+        "prefiguration",
+        "archetype",
+        "epitome",
+        "guide",
+        "holotype",
+        "image",
+        "loadstar",
+        "lodestar",
+        "microcosm",
+        "original",
+        "paradigm",
+        "pilot",
+        "prototype",
+        "template",
+        "templet",
+        "type specimen"
+      ],
+      "derivation": [
+        "exemplify"
+      ],
+      "examples": [
+        "I profited from his example"
+      ]
+    },
+    {
+      "definition": "something to be imitated",
+      "partOfSpeech": "noun",
+      "synonyms": [
+        "exemplar",
+        "good example",
+        "model"
+      ],
+      "typeOf": [
+        "ideal"
+      ],
+      "hasTypes": [
+        "pacemaker",
+        "pattern",
+        "beauty",
+        "prodigy",
+        "beaut",
+        "pacesetter"
+      ],
+      "derivation": [
+        "exemplify",
+        "exemplary"
+      ]
+    },
+    {
+      "definition": "an occurrence of something",
+      "partOfSpeech": "noun",
+      "synonyms": [
+        "case",
+        "instance"
+      ],
+      "typeOf": [
+        "happening",
+        "natural event",
+        "occurrence",
+        "occurrent"
+      ],
+      "hasTypes": [
+        "clip",
+        "mortification",
+        "piece",
+        "time",
+        "humiliation",
+        "bit"
+      ],
+      "derivation": [
+        "exemplify"
+      ],
+      "examples": [
+        "but there is always the famous example of the Smiths"
+      ]
+    },
+    {
+      "definition": "an item of information that is typical of a class or group",
+      "partOfSpeech": "noun",
+      "synonyms": [
+        "illustration",
+        "instance",
+        "representative"
+      ],
+      "typeOf": [
+        "information"
+      ],
+      "hasTypes": [
+        "excuse",
+        "apology",
+        "specimen",
+        "case in point",
+        "sample",
+        "exception",
+        "quintessence",
+        "precedent"
+      ],
+      "derivation": [
+        "exemplify",
+        "exemplary"
+      ],
+      "examples": [
+        "this patient provides a typical example of the syndrome",
+        "there is an example on page 10"
+      ]
+    },
+    {
+      "definition": "punishment intended as a warning to others",
+      "partOfSpeech": "noun",
+      "synonyms": [
+        "deterrent example",
+        "lesson",
+        "object lesson"
+      ],
+      "typeOf": [
+        "monition",
+        "admonition",
+        "word of advice",
+        "warning"
+      ],
+      "derivation": [
+        "exemplary"
+      ],
+      "examples": [
+        "they decided to make an example of him"
+      ]
+    },
+    {
+      "definition": "a task performed or problem solved in order to develop skill or understanding",
+      "partOfSpeech": "noun",
+      "synonyms": [
+        "exercise"
+      ],
+      "typeOf": [
+        "lesson"
+      ],
+      "examples": [
+        "you must work the examples at the end of each chapter in the textbook"
+      ]
+    }
+  ],
+  "syllables": {
+    "count": 3,
+    "list": [
+      "ex",
+      "am",
+      "ple"
+    ]
+  },
+  "pronunciation": {
+    "all": "ɪɡ'zæmpəl"
+  },
+  "frequency": 4.67
+}

tests/events/thesaurus-wordnet.http

@@ -0,0 +1,16 @@
+@domain = http://localhost:7860
+
+### Thesaurus WordNet Query
+POST {{domain}}/thesaurus-wordnet
+Content-Type: text/plain;charset=UTF-8
+
+{"query": "dog"}
+
+> {%
+    client.log("Status:", response.status);
+    if (response.status >= 400) {
+        client.log("Error:", response.body);
+    } else {
+        client.log("Response:", response.body);
+    }
+%}

tests/events/thesaurus-wordsapi.http

@@ -0,0 +1,16 @@
+@domain = http://localhost:7860
+
+### Thesaurus WordsAPI Query (with browser-like headers)
+POST {{domain}}/thesaurus-wordsapi
+Content-Type: text/plain;charset=UTF-8
+
+{"query":"look"}
+
+> {%
+    client.log("Status:", response.status);
+    if (response.status >= 400) {
+        client.log("Error:", response.body);
+    } else {
+        client.log("Response:", response.body);
+    }
+%}

tests/test_thesaurus_wordnet.py

@@ -0,0 +1,49 @@
+import json
+import unittest
+
+from tests import EVENTS_FOLDER
+
+
+def assert_get_synsets_by_word_and_language(cls, q):
+    from my_ghost_writer.thesaurus import get_synsets_by_word_and_language
+
+    response = get_synsets_by_word_and_language(q, lang="eng")
+    cls.assertEqual(list(response.keys()), ['word', 'results'])
+    cls.assertEqual(response["word"], q)
+    cls.assertIsInstance(response["results"], list)
+    results = response["results"]
+    for result in results:
+        for k, v in result.items():
+            cls.assertIsInstance(k, str)
+            try:
+                if k == "definition":
+                    cls.assertIsInstance(v, str)
+                else:
+                    cls.assertIsInstance(v, list)
+            except AssertionError as ae:
+                print(k, v, ae)
+            for s in v:
+                cls.assertIsInstance(s, str)
+    with open(EVENTS_FOLDER / f"expected_get_synsets_by_word_and_language_{q}.json", "r") as src:
+        # json.dump(response, src)
+        expected_response = json.load(src)
+        cls.assertEqual(response, expected_response)
+
+
+class TestThesaurusWordnet(unittest.TestCase):
+    def test_get_current_info_wordnet(self):
+        from my_ghost_writer.thesaurus import get_current_info_wordnet
+
+        current_info = get_current_info_wordnet()
+        self.assertEqual(list(current_info.keys()), ['languages', 'version'])
+        languages = current_info["languages"]
+        self.assertIn("eng", languages)
+        self.assertIsInstance(languages, list)
+        self.assertIsInstance(current_info["version"], str)
+        self.assertGreaterEqual(len(languages), 1)
+
+    def test_get_synsets_by_word_and_language(self):
+        assert_get_synsets_by_word_and_language(self, "dog")
+        assert_get_synsets_by_word_and_language(self, "look")
+        assert_get_synsets_by_word_and_language(self, "power")
+        assert_get_synsets_by_word_and_language(self, "term")