refactor: refactored get_wordnet_synonyms()

my_ghost_writer/text_parsers2.py

@@ -219,93 +219,8 @@ def get_wordnet_synonyms(word: str, pos_tag: Optional[str] = None) -> list[dict[
     related_word_groups_raw: list[dict[str, Any]] = []
     word_lower = word.lower()
 
-    def _get_related_words(related_object, relation_type: TermRelationships, inner_word_lower: str):
-        related_words = []
-
-        if relation_type == TermRelationships.SYNONYM:
-            # related_object is a Synset
-            for local_lemma in related_object.lemmas():
-                lemma_name = local_lemma.name().replace("_", " ")
-                if lemma_name.lower() != inner_word_lower:
-                    related_words.append({
-                        "base_form": lemma_name
-                    })
-        elif relation_type == TermRelationships.ANTONYM:
-            # related_object is a Lemma
-            for ant in related_object.antonyms():
-                ant_name = ant.name().replace("_", " ")
-                if ant_name.lower() != inner_word_lower:
-                    related_words.append({
-                        "base_form": ant_name
-                    })
-        else:
-            # related_object is a Synset
-            # Get related synsets from the appropriate method
-            relation_methods = {
-                TermRelationships.HYPERNYM: related_object.hypernyms,
-                TermRelationships.HYPONYM: related_object.hyponyms,
-                TermRelationships.MERONYM: lambda: related_object.member_meronyms() + related_object.substance_meronyms() + related_object.part_meronyms(),
-                TermRelationships.HOLONYM: lambda: related_object.member_holonyms() + related_object.substance_holonyms() + related_object.part_holonyms(),
-                TermRelationships.ALSO_SEE: related_object.also_sees,
-                TermRelationships.CAUSE: related_object.causes,
-                # TermRelationships.DERIVATIONALLY_RELATED_FORM: related_object.derivationally_related_forms,
-                # TermRelationships.ENTAILMENT: related_object.entails,
-                # TermRelationships.PERTAINYM: related_object.pertainyms,
-                TermRelationships.SIMILAR_TO: related_object.similar_tos,
-            }
-            get_words_fn = relation_methods.get(relation_type)
-            if get_words_fn:
-                for related_synset in get_words_fn():
-                    # Some methods return Lemma objects, handle both cases
-                    if hasattr(related_synset, "lemmas"):
-                        for local_lemma in related_synset.lemmas():
-                            lemma_name = local_lemma.name().replace("_", " ")
-                            if lemma_name.lower() != inner_word_lower:
-                                related_words.append({
-                                    "base_form": lemma_name,
-                                    # "is_custom": False,
-                                })
-                    elif hasattr(related_synset, "name"):
-                        lemma_name = related_synset.name().replace("_", " ")
-                        if lemma_name.lower() != inner_word_lower:
-                            related_words.append({
-                                "base_form": lemma_name,
-                                # "is_custom": False,
-                            })
-
-        if related_words:
-            return {
-                "relation_type": relation_type,
-                "source": "wordnet",
-                "definition": related_object.definition() if hasattr(related_object, "definition") else "",
-                "examples": related_object.examples()[:2] if hasattr(related_object, "examples") else [],
-                "wordnet_pos": related_object.pos() if hasattr(related_object, "pos") else None,
-                "related_words": related_words,
-            }
-        return None
-
     # 1. Custom Related Word Lookup (all relationships)
-    for rel_type in TermRelationships:
-        custom_groups = custom_synonym_handler.get_related(word_lower, rel_type)
-        if custom_groups:
-            for related in custom_groups:
-                words = related["words"]
-                definition = related.get("definition", "")
-                related_word_options = []
-                for word_from_related_words in words:
-                    related_word_options.append({
-                        "base_form": word_from_related_words,
-                        "is_custom": True,
-                        "definition": definition,
-                    })
-                related_word_groups_raw.append({
-                    "relation_type": rel_type,
-                    "source": "custom",
-                    "definition": definition,
-                    "examples": [],
-                    "wordnet_pos": None,
-                    "related_words": related_word_options,
-                })
+    _extract_related_word_groups_custom(related_word_groups_raw, word_lower)
     # 2. WordNet Lookup
     try:
         # Map spaCy POS to wn POS
@@ -326,36 +241,123 @@ def get_wordnet_synonyms(word: str, pos_tag: Optional[str] = None) -> list[dict[
         # Process each synset and its relations
         for synset in synsets:
             result = _get_related_words(synset, TermRelationships.SYNONYM, word_lower)
-            if result:
-                related_word_groups_raw.append(result)
-            # todo: check if it's possible to remove the first 'IF result:...' and move the second one
+            related_word_groups_raw.append(result)
             for lemma in synset.lemmas():
                 result = _get_related_words(lemma, TermRelationships.ANTONYM, word_lower)
-                if result:
-                    related_word_groups_raw.append(result)
+                related_word_groups_raw.append(result)
             for rel_type in [
-                    TermRelationships.HYPERNYM, TermRelationships.HYPONYM, TermRelationships.MERONYM,
-                    TermRelationships.HOLONYM, TermRelationships.ALSO_SEE, TermRelationships.CAUSE,
-                    # todo: try to understand how to fix the related missing methods
-                    # TermRelationships.DERIVATIONALLY_RELATED_FORM,
-                    # TermRelationships.ENTAILMENT,
-                    # TermRelationships.PERTAINYM,
-                    TermRelationships.SIMILAR_TO
-                ]:
-                app_logger.info(f"synset: {type(synset)}, '{synset}'")
-                if not isinstance(synset, Synset):
-                    pass
+                TermRelationships.HYPERNYM, TermRelationships.HYPONYM, TermRelationships.MERONYM,
+                TermRelationships.HOLONYM, TermRelationships.ALSO_SEE, TermRelationships.CAUSE,
+                # todo: try to understand how to fix the related missing methods
+                # TermRelationships.DERIVATIONALLY_RELATED_FORM,
+                # TermRelationships.ENTAILMENT,
+                # TermRelationships.PERTAINYM,
+                TermRelationships.SIMILAR_TO
+            ]:
                 result = _get_related_words(synset, rel_type, word_lower)
-                if result:
-                    if result["relation_type"] == TermRelationships.CAUSE:
-                        app_logger.info(f"Adding result for relation type '{rel_type}': {result}")
-                    related_word_groups_raw.append(result)
+                related_word_groups_raw.append(result)
 
     except Exception as ex1:
         app_logger.error(f"Error getting wn synonyms: '{ex1}' with: word:{type(word)}, '{word}', pos_tag: {type(pos_tag)}, '{pos_tag}'")
         raise HTTPException(status_code=500, detail=f"Error retrieving related words: '{str(ex1)}'")
 
-    return related_word_groups_raw
+    return [related_words for related_words in related_word_groups_raw if related_words is not None]
+
+
+def _extract_related_word_groups_custom(related_word_groups_raw, word_lower):
+    for rel_type in TermRelationships:
+        custom_groups = custom_synonym_handler.get_related(word_lower, rel_type)
+        if custom_groups:
+            for related in custom_groups:
+                words = related["words"]
+                definition = related.get("definition", "")
+                related_word_options = []
+                for word_from_related_words in words:
+                    related_word_options.append({
+                        "base_form": word_from_related_words,
+                        "is_custom": True,
+                        "definition": definition,
+                    })
+                related_word_groups_raw.append({
+                    "relation_type": rel_type,
+                    "source": "custom",
+                    "definition": definition,
+                    "examples": [],
+                    "wordnet_pos": None,
+                    "related_words": related_word_options,
+                })
+
+
+def _get_base_form_by_synset_type(local_lemma: str, inner_word_lower: str, related_words: list[dict]) -> list[dict]:
+    lemma_name = local_lemma.replace("_", " ")
+    if lemma_name.lower() != inner_word_lower:
+        related_words.append({
+            "base_form": lemma_name
+        })
+    return related_words
+
+
+def _get_related_words(related_object, relation_type: TermRelationships, inner_word_lower: str) -> dict|None:
+    related_words = []
+
+    if relation_type == TermRelationships.SYNONYM:
+        # related_object is a Synset
+        for local_lemma in related_object.lemmas():
+            _get_base_form_by_synset_type(local_lemma.name(), inner_word_lower, related_words)
+    elif relation_type == TermRelationships.ANTONYM:
+        # related_object is a Lemma
+        for ant in related_object.antonyms():
+            _get_base_form_by_synset_type(ant.name(), inner_word_lower, related_words)
+    else:
+        # related_object is a Synset
+        # Get related synsets from the appropriate method
+        relation_methods = {
+            TermRelationships.HYPERNYM: related_object.hypernyms,
+            TermRelationships.HYPONYM: related_object.hyponyms,
+            TermRelationships.MERONYM: lambda: related_object.member_meronyms() + related_object.substance_meronyms() + related_object.part_meronyms(),
+            TermRelationships.HOLONYM: lambda: related_object.member_holonyms() + related_object.substance_holonyms() + related_object.part_holonyms(),
+            TermRelationships.ALSO_SEE: related_object.also_sees,
+            TermRelationships.CAUSE: related_object.causes,
+            # TermRelationships.DERIVATIONALLY_RELATED_FORM: related_object.derivationally_related_forms,
+            # TermRelationships.ENTAILMENT: related_object.entails,
+            # TermRelationships.PERTAINYM: related_object.pertainyms,
+            TermRelationships.SIMILAR_TO: related_object.similar_tos,
+        }
+        get_words_fn = relation_methods.get(relation_type)
+        if get_words_fn:
+            for related_synset in get_words_fn():
+                _extract_lemmas_or_names_from_synset(inner_word_lower, related_synset, related_words)
+    if related_words:
+        return {
+            "relation_type": relation_type,
+            "source": "wordnet",
+            "definition": _get_related_object_definition(related_object),
+            "examples": _get_related_object_examples(related_object),
+            "wordnet_pos": _get_related_wordnet_pos(related_object),
+            "related_words": related_words,
+        }
+    return None
+
+
+def _extract_lemmas_or_names_from_synset(inner_word_lower, related_synset, related_words):
+    # Some methods return Lemma objects, handle both cases
+    if hasattr(related_synset, "lemmas"):
+        for local_lemma in related_synset.lemmas():
+            _get_base_form_by_synset_type(local_lemma.name(), inner_word_lower, related_words)
+    elif hasattr(related_synset, "name"):
+        _get_base_form_by_synset_type(related_synset.name(), inner_word_lower, related_words)
+
+
+def _get_related_wordnet_pos(related_object: Synset):
+    return related_object.pos() if hasattr(related_object, "pos") else None
+
+
+def _get_related_object_examples(related_object: Synset, n: int = 2) -> list[str]:
+    return related_object.examples()[:n] if hasattr(related_object, "examples") else []
+
+
+def _get_related_object_definition(related_object: Synset) -> str:
+    return related_object.definition() if hasattr(related_object, "definition") else ""
 
 
 def inflect_synonym(synonym: str, original_token_info: dict[str, Any]) -> str: