feat: refactor get_synsets_by_word_and_language() to reduce code duplication

my_ghost_writer/app.py

@@ -132,16 +132,27 @@ def get_thesaurus_wordnet(body: RequestQueryThesaurusWordsapiBody | str) -> JSON
         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"})
+            duration_t2t1 = (t1 - t0).total_seconds()
+            app_logger.info(f"found local data, duration: {duration_t2t1:.3f}s.")
+            return JSONResponse(status_code=200, content={"duration": duration_t2t1, "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.")
+    duration_t1t0 = (t1 - t0).total_seconds()
+    n_results = len(response["results"])
+    app_logger.error(f"response, n_results: {n_results}; duration: {duration_t1t0:.3f}s.")
+    app_logger.info("=============================================================")
+    duration = duration_t1t0
+    if use_mongo:
+        app_logger.debug(f"use_mongo:{use_mongo}, inserting response '{response}' by query '{query}' on db...")
+        pymongo_operations_rw.insert_document(response)
+        del response["_id"]  # since we inserted the wordsapi response on mongodb now it have a bson _id object not serializable by default
+        t2 = datetime.now()
+        duration_t2t1 = (t2 - t1).total_seconds()
+        app_logger.info(f"mongo insert, duration: {duration_t2t1:.3f}s.")
+        duration = duration_t1t0 + duration_t2t1
     return JSONResponse(status_code=200, content={"duration": duration, "thesaurus": response, "source": "wordnet"})
 
 

my_ghost_writer/thesaurus.py

@@ -1,7 +1,6 @@
-from typing import Any
-
 from nltk.corpus import wordnet31 as wn
 
+from my_ghost_writer.constants import app_logger
 from my_ghost_writer.type_hints import ResponseWordsAPI
 
 
@@ -10,181 +9,73 @@ def get_current_info_wordnet():
 
 
 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(
+    app_logger.info("start...")
+    def lemma_names(synsets):
+        return sorted(
             set(
-                l.name().replace('_', ' ')
-                for h in synset.also_sees()
-                for l in h.lemmas(lang=lang)
+                lemma.name().replace('_', ' ')
+                for syn in synsets
+                for lemma in syn.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(
+
+    def lemma_related(lemmas_input, lemmas_method):
+        return sorted(
             set(
-                l.name().replace('_', ' ')
-                for h in synset.topic_domains()
-                for l in h.lemmas(lang=lang)
+                rel.name().replace('_', ' ')
+                for lemma in lemmas_input
+                for rel in getattr(lemma, lemmas_method)()
             )
         )
-        usage_of = sorted(
+
+    results = []
+    for synset in wn.synsets(word, lang=lang):
+        lemmas = synset.lemmas(lang=lang)
+        obj = {"definition": synset.definition(lang=lang)}
+
+        # Single-line fields
+        synonyms = sorted(
             set(
-                l.name().replace('_', ' ')
-                for h in synset.usage_domains()
-                for l in h.lemmas(lang=lang)
+                lemma.name().replace('_', ' ')
+                for lemma in lemmas
+                if lemma.name().lower() != word.lower()
             )
         )
-        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
+
+        # Lemma-based relations
+        for field, method in [
+            ("antonyms", "antonyms"),
+            ("derivation", "derivationally_related_forms"),
+            ("pertainsTo", "pertainyms"),
+        ]:
+            values = lemma_related(lemmas, method)
+            if values:
+                obj[field] = values
+
+        # Synset-based relations
+        synset_relations = [
+            ("typeOf", synset.hypernyms()),
+            ("hasTypes", synset.hyponyms()),
+            ("partOf", synset.member_holonyms() + synset.part_holonyms() + synset.substance_holonyms()),
+            ("hasParts", synset.member_meronyms() + synset.part_meronyms() + synset.substance_meronyms()),
+            ("instanceOf", synset.instance_hypernyms()),
+            ("hasInstances", synset.instance_hyponyms()),
+            ("similarTo", synset.similar_tos()),
+            ("also", synset.also_sees()),
+            ("entails", synset.entailments()),
+            ("hasSubstances", synset.substance_meronyms()),
+            ("inCategory", synset.topic_domains()),
+            ("usageOf", synset.usage_domains()),
+            ("causes", synset.causes()),
+            ("verbGroups", synset.verb_groups()),
+        ]
+        for field, syns in synset_relations:
+            values = lemma_names(syns)
+            if values:
+                obj[field] = values
+
         results.append(obj)
     return {
         "word": word,