feat: make /thesaurus-inflated-phrase agnostic, not bounded to synonyms - /thesaurus-custom fixed

my_ghost_writer/app.py

@@ -27,7 +27,7 @@ from my_ghost_writer.pymongo_utils import mongodb_health_check
 from my_ghost_writer.text_parsers2 import find_synonyms_for_phrase, custom_synonym_handler
 from my_ghost_writer.thesaurus import get_current_info_wordnet
 from my_ghost_writer.type_hints import (RequestQueryThesaurusInflatedBody, RequestQueryThesaurusWordsapiBody,
-    RequestSplitText, RequestTextFrequencyBody, MultiWordSynonymResponse, CustomSynonymRequest)
+    RequestSplitText, RequestTextFrequencyBody, MultiRelatedWordResponse, CustomRelatedWordRequest)
 
 
 async def mongo_health_check_background_task():
@@ -225,7 +225,7 @@ def get_thesaurus_wordsapi(body: RequestQueryThesaurusWordsapiBody | str) -> JSO
         raise HTTPException(status_code=response.status_code, detail=msg)
 
 
-@app.post("/thesaurus-inflated-phrase", response_model=MultiWordSynonymResponse)
+@app.post("/thesaurus-inflated-phrase", response_model=MultiRelatedWordResponse)
 async def get_synonyms_for_phrase(body: RequestQueryThesaurusInflatedBody):
     """
     Get contextual synonyms for a selected phrase (one or more words).
@@ -252,7 +252,7 @@ async def get_synonyms_for_phrase(body: RequestQueryThesaurusInflatedBody):
     app_logger.info(f"text:{text}!")
     app_logger.info(f"word:{word}!")
 
-    # if use_mongo...
+    # persistence
 
     try:
         # The new function in text_parsers2 does all the heavy lifting
@@ -266,7 +266,7 @@ async def get_synonyms_for_phrase(body: RequestQueryThesaurusInflatedBody):
         app_logger.info(f"got find_synonyms_for_phrase() result in: {duration:.3f}s. ...")
         app_logger.debug(results)
 
-        # if use_mongo and results: ...
+        # persistence
 
         message = f"Got {len(results)} synonym groups." if results else "No words with synonyms found in the selected phrase."
 
@@ -274,13 +274,16 @@ async def get_synonyms_for_phrase(body: RequestQueryThesaurusInflatedBody):
         duration = (t2 - t1).total_seconds()
         app_logger.info(f"got MultiWordSynonymResponse() result in: {duration:.3f}s. ...")
         # Construct the final response using our Pydantic model
-        return MultiWordSynonymResponse(
+        response_object = MultiRelatedWordResponse(
             success=True,
             original_phrase=body.word,
             original_indices={"start": body.start, "end": body.end},
             results=results,
-            message=message
+            message=message,
+            duration=duration
         )
+        response_json = response_object.model_dump_json(exclude_none=True)
+        return JSONResponse(status_code=200, content=json.loads(response_json))
 
     except HTTPException as http_ex:
         # Re-raise known HTTP exceptions to be handled by FastAPI's handler
@@ -292,10 +295,12 @@ async def get_synonyms_for_phrase(body: RequestQueryThesaurusInflatedBody):
 
 
 @app.post("/thesaurus-custom")
-async def add_custom_synonyms(body: CustomSynonymRequest):
+async def add_custom_synonyms(body: CustomRelatedWordRequest):
     """Adds custom synonyms for a given word to the in-memory store."""
     try:
-        custom_synonym_handler.add_entry(body.word, [r.model_dump() for r in body.related])
+        word = body.word
+        related_list = body.related
+        custom_synonym_handler.add_entry(word, related_list)
         return {"message": f"Custom entry for '{body.word}' added/updated successfully (in-memory)."}
 
     except Exception as e:

my_ghost_writer/custom_synonym_handler.py

@@ -1,22 +1,46 @@
 from typing import Any
 
+from my_ghost_writer.constants import app_logger
+from my_ghost_writer.type_hints import RelatedEntry, TermRelationships
+
 
 class CustomSynonymHandler:
+    """
+    Handles the storage and retrieval of custom-related words.
+    """
     def __init__(self):
-        # {word: {relation_type: [{word: related_word, definition: definition}]}}
-        self.lexicon: dict[str, dict[str, list[dict[str, Any]]]] = {}
+        """
+        Initializes the CustomSynonymHandler with an empty lexicon and inverted index.
+        """
+        # {word: {relation_type: [{words: related_word, definition: definition}]}}
+        self.lexicon: dict[str, dict[TermRelationships, list[dict[str, Any]]]] = {}
         # For reverse lookups
         self.inverted_index: dict[str, set[str]] = {}
 
-    def add_entry(self, word: str, related: list[dict[str, Any]]):
+    def add_entry(self, word: str, related: list[RelatedEntry]):
+        """
+        Adds a custom-related word entry to the lexicon.
+        Side Effects: Updates the lexicon and inverted_index with the new related word entry.
+
+        Args:
+            word: The word to add related words for (str).
+            related: A list of RelatedEntry objects representing the related words (list[RelatedEntry]).
+
+        Returns:
+            None
+        """
         word = word.lower()
         if word not in self.lexicon:
             self.lexicon[word] = {}
-        for relation in related:
-            relation_type = relation["type"]
+        for n, relation in enumerate(related):
+            try:
+                relation_type = relation.type
+            except AttributeError as attr_err:
+                app_logger.error(f"AttributeError: {attr_err}, n:{n}.")
+                raise attr_err
             group = {
-                "words": [w.lower().strip() for w in relation["words"]],
-                "definition": relation.get("definition")
+                "words": [w.lower().strip() for w in relation.words],
+                "definition": relation.definition
             }
             if relation_type not in self.lexicon[word]:
                 self.lexicon[word][relation_type] = []
@@ -27,9 +51,20 @@ class CustomSynonymHandler:
                 self.inverted_index[w].add(word)
 
     def delete_entry(self, word: str):
+        """
+        Deletes a custom-related word entry from the lexicon.
+        Side Effects: Removes the related word entry from the lexicon and updates the inverted_index.
+        Raises: KeyError: If the word is not found in the lexicon.
+
+        Args:
+            word: The word to delete related words for (str).
+
+        Returns:
+            None
+        """
         word = word.lower()
         if word not in self.lexicon:
-            raise KeyError(f"No custom synonyms found for word '{word}'.")
+            raise KeyError(f"No custom related words found for word '{word}'.")
         # Remove from inverted index
         for relation_groups in self.lexicon[word].values():
             for group in relation_groups:
@@ -37,18 +72,51 @@ class CustomSynonymHandler:
         del self.lexicon[word]
 
     def _update_group_words(self, group, word):
+        """
+        Updates the inverted index when a related word entry is deleted.
+        Side Effects: Updates the inverted_index by discarding or deleting entries.
+
+        Args:
+            group: The group of related words (dict).
+            word: The word that the related words are associated with (str).
+
+        Returns:
+            None
+        """
         for w in group["words"]:
             if w in self.inverted_index:
                 self.inverted_index[w].discard(word)
                 if not self.inverted_index[w]:
                     del self.inverted_index[w]
 
-    def get_related(self, word: str, relation_type: str) -> list[dict[str, Any]]:
+    def get_related(self, word: str, relation_type: TermRelationships) -> list[dict[str, Any]]:
+        """
+        Retrieves related words for a given word and relation type.
+
+        Args:
+            word: The word to retrieve related words for (str).
+            relation_type: The type of relationship to retrieve (TermRelationships).
+
+        Returns:
+            A list of dictionaries, where each dictionary represents a related word group (list[dict[str, Any]]).
+            Returns an empty list if no related words are found.
+        """
         word = word.lower()
-        if word in self.lexicon and relation_type in self.lexicon[word]:
-            return self.lexicon[word][relation_type]
+        if word in self.lexicon:
+            word_lexicon = self.lexicon[word]
+            if relation_type in word_lexicon:
+                return word_lexicon[relation_type]
         return []
 
     def reverse_lookup(self, related_word: str) -> set[str]:
+        """
+        Performs a reverse lookup to find words that have the given word as a related word.
+
+        Args:
+            related_word: The word to search for (str).
+
+        Returns:
+            A set of words that have the given word as a related word (set[str]).
+        """
         related_word = related_word.lower()
         return self.inverted_index.get(related_word, set())

my_ghost_writer/jsonpath_comparator.py

@@ -0,0 +1,317 @@
+from jsonpath_ng import parse
+from jsonpath_ng.ext import parse as parse_ext
+from typing import Dict, Set, Any, List
+
+
+def extract_structure_paths(data: dict) -> Set[str]:
+    """
+    Extract all available paths from JSON data
+
+    Args:
+        data: JSON data to analyze
+
+    Returns:
+        Set of all JSONPath expressions found in the data
+    """
+    paths = set()
+
+    def _collect_paths(obj: Any, path: str = "$"):
+        if isinstance(obj, dict):
+            for key, value in obj.items():
+                current_path = f"{path}.{key}"
+                paths.add(current_path)
+                _collect_paths(value, current_path)
+        elif isinstance(obj, list):
+            array_path = f"{path}[*]"
+            paths.add(array_path)
+            if obj:
+                for item in obj:
+                    _collect_paths(item, array_path)
+
+    _collect_paths(data)
+    return paths
+
+
+def extract_structure_paths_with_types(data: dict) -> Dict[str, str]:
+    """
+    Extract all available paths from JSON data with their value types
+
+    Args:
+        data: JSON data to analyze
+
+    Returns:
+        Dictionary mapping JSONPath expressions to their value types
+    """
+    paths_with_types = {}
+
+    def _get_type_name(value: Any) -> str:
+        """Get a descriptive type name for the value"""
+        if value is None:
+            return "null"
+        elif isinstance(value, bool):
+            return "boolean"
+        elif isinstance(value, int):
+            return "integer"
+        elif isinstance(value, float):
+            return "number"
+        elif isinstance(value, str):
+            return "string"
+        elif isinstance(value, list):
+            if not value:
+                return "array(empty)"
+            # Get the types of array elements
+            element_types = set(_get_type_name(item) for item in value)
+            if len(element_types) == 1:
+                return f"array({element_types.pop()})"
+            else:
+                return f"array(mixed: {', '.join(sorted(element_types))})"
+        elif isinstance(value, dict):
+            return "object"
+        else:
+            return type(value).__name__
+
+    def _collect_paths(obj: Any, path: str = "$"):
+        paths_with_types[path] = _get_type_name(obj)
+        
+        if isinstance(obj, dict):
+            for key, value in obj.items():
+                current_path = f"{path}.{key}"
+                _collect_paths(value, current_path)
+        elif isinstance(obj, list):
+            array_path = f"{path}[*]"
+            if obj:
+                # Use first item as representative type for array elements
+                _collect_paths(obj[0], array_path)
+
+    _collect_paths(data)
+    return paths_with_types
+
+
+def print_comparison_report(comparison: Dict[str, Any]):
+    """
+    Print formatted comparison report
+
+    Args:
+        comparison: Results from compare_structures method
+    """
+
+    print("=== JSONPATH STRUCTURE COMPARISON ===\n")
+
+    if comparison["added_paths"]:
+        print("➕ ADDED PATHS:")
+        for path in sorted(comparison["added_paths"]):
+            print(f"   {path}")
+        print()
+
+    if comparison["removed_paths"]:
+        print("➖ REMOVED PATHS:")
+        for path in sorted(comparison["removed_paths"]):
+            print(f"   {path}")
+        print()
+
+    if comparison.get("path_validations"):
+        print("🔍 PATH VALIDATIONS:")
+        for path, validation in comparison["path_validations"].items():
+            if "error" in validation:
+                print(f"   ⚠️  {path}: {validation['error']}")
+            else:
+                status = validation["status"]
+                old_count = validation["old_count"]
+                new_count = validation["new_count"]
+                print(f"   {status} {path}: {old_count} → {new_count}")
+
+
+def print_comparison_report_with_types(comparison: Dict[str, Any]):
+    """
+    Print formatted comparison report including type information
+
+    Args:
+        comparison: Results from compare_structures_with_types method
+    """
+    print("=== JSONPATH STRUCTURE COMPARISON WITH TYPES ===\n")
+
+    if comparison["added_paths"]:
+        print("➕ ADDED PATHS:")
+        for path, type_info in sorted(comparison["added_paths"].items()):
+            print(f"   {path} ({type_info})")
+        print()
+
+    if comparison["removed_paths"]:
+        print("➖ REMOVED PATHS:")
+        for path, type_info in sorted(comparison["removed_paths"].items()):
+            print(f"   {path} ({type_info})")
+        print()
+
+    if comparison.get("type_changes"):
+        print("🔄 TYPE CHANGES:")
+        for path, change in sorted(comparison["type_changes"].items()):
+            print(f"   {path}: {change['old_type']} → {change['new_type']}")
+        print()
+
+    if comparison.get("path_validations"):
+        print("🔍 PATH VALIDATIONS:")
+        for path, validation in comparison["path_validations"].items():
+            if "error" in validation:
+                print(f"   ⚠️  {path}: {validation['error']}")
+            else:
+                status = validation["status"]
+                old_count = validation["old_count"]
+                new_count = validation["new_count"]
+                print(f"   {status} {path}: {old_count} → {new_count}")
+
+
+class JSONPathComparator:
+    """
+    Compare JSON structures using JSONPath expressions
+
+    This class allows you to define expected paths and compare different
+    JSON responses to detect structural changes during refactoring.
+    """
+
+    def __init__(self, common_paths: List[str] = None):
+        """
+        Initialize comparator with common paths to validate
+
+        Args:
+            common_paths: List of JSONPath expressions to validate across responses
+        """
+        self.common_paths = common_paths or []
+
+    def compare_structures(self, old_data: dict, new_data: dict) -> Dict[str, Any]:
+        """
+        Compare two JSON structures using JSONPath
+
+        Args:
+            old_data: Original JSON structure
+            new_data: New JSON structure to compare against
+
+        Returns:
+            Dictionary containing comparison results with added/removed paths
+            and validation results for common paths
+        """
+
+        old_paths = extract_structure_paths(old_data)
+        new_paths = extract_structure_paths(new_data)
+
+        comparison = {
+            "added_paths": new_paths - old_paths,
+            "removed_paths": old_paths - new_paths,
+            "common_paths": old_paths & new_paths,
+            "path_validations": {}
+        }
+
+        # Test common JSONPath expressions
+        for path_expr in self.common_paths:
+            try:
+                jsonpath = parse_ext(path_expr)
+
+                old_matches = [match.value for match in jsonpath.find(old_data)]
+                new_matches = [match.value for match in jsonpath.find(new_data)]
+
+                comparison["path_validations"][path_expr] = {
+                    "old_found": len(old_matches) > 0,
+                    "new_found": len(new_matches) > 0,
+                    "old_count": len(old_matches),
+                    "new_count": len(new_matches),
+                    "status": "✅" if (len(old_matches) > 0) == (len(new_matches) > 0) else "❌"
+                }
+
+            except Exception as e:
+                comparison["path_validations"][path_expr] = {
+                    "error": str(e),
+                    "status": "⚠️"
+                }
+
+        return comparison
+
+    def compare_structures_with_types(self, old_data: dict, new_data: dict) -> Dict[str, Any]:
+        """
+        Compare two JSON structures using JSONPath including type information
+
+        Args:
+            old_data: Original JSON structure
+            new_data: New JSON structure to compare against
+
+        Returns:
+            Dictionary containing comparison results with type information
+        """
+        old_paths = extract_structure_paths_with_types(old_data)
+        new_paths = extract_structure_paths_with_types(new_data)
+
+        # Find paths that exist in both but have different types
+        type_changes = {}
+        common_paths = set(old_paths.keys()) & set(new_paths.keys())
+        for path in common_paths:
+            if old_paths[path] != new_paths[path]:
+                type_changes[path] = {
+                    "old_type": old_paths[path],
+                    "new_type": new_paths[path]
+                }
+
+        comparison = {
+            "added_paths": {k: v for k, v in new_paths.items() if k not in old_paths},
+            "removed_paths": {k: v for k, v in old_paths.items() if k not in new_paths},
+            "common_paths": {k: v for k, v in old_paths.items() if k in new_paths},
+            "type_changes": type_changes,
+            "path_validations": {}
+        }
+
+        # Test common JSONPath expressions
+        for path_expr in self.common_paths:
+            try:
+                jsonpath = parse_ext(path_expr)
+
+                old_matches = [match.value for match in jsonpath.find(old_data)]
+                new_matches = [match.value for match in jsonpath.find(new_data)]
+
+                comparison["path_validations"][path_expr] = {
+                    "old_found": len(old_matches) > 0,
+                    "new_found": len(new_matches) > 0,
+                    "old_count": len(old_matches),
+                    "new_count": len(new_matches),
+                    "status": "✅" if (len(old_matches) > 0) == (len(new_matches) > 0) else "❌"
+                }
+
+            except Exception as e:
+                comparison["path_validations"][path_expr] = {
+                    "error": str(e),
+                    "status": "⚠️"
+                }
+
+        return comparison
+
+
+def compare_json_with_jsonpath(old_data: dict, new_data: dict, common_paths: List[str] = None):
+    """
+    Main function to compare JSON structures
+
+    Args:
+        old_data: Original JSON structure
+        new_data: New JSON structure to compare
+        common_paths: Optional list of JSONPath expressions to validate
+
+    Returns:
+        Dictionary containing comparison results
+    """
+    comparator = JSONPathComparator(common_paths)
+    comparison = comparator.compare_structures(old_data, new_data)
+    print_comparison_report(comparison)
+    return comparison
+
+
+def compare_json_with_jsonpath_and_types(old_data: dict, new_data: dict, common_paths: List[str] = None):
+    """
+    Main function to compare JSON structures with type information
+
+    Args:
+        old_data: Original JSON structure
+        new_data: New JSON structure to compare
+        common_paths: Optional list of JSONPath expressions to validate
+
+    Returns:
+        Dictionary containing comparison results with type information
+    """
+    comparator = JSONPathComparator(common_paths)
+    comparison = comparator.compare_structures_with_types(old_data, new_data)
+    print_comparison_report_with_types(comparison)
+    return comparison

my_ghost_writer/jsonpath_extractor.py

@@ -0,0 +1,558 @@
+from collections import defaultdict
+from typing import Any, Dict, Set
+
+
+class JSONPathStructureAnalyzer:
+    """
+    Analyze JSON structure using JSONPath expressions
+
+    Example usage:
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths({"success": True, "data": {"users": [{"id": 1}]}})
+        print(analyzer.get_structure_report())
+    """
+
+    def __init__(self):
+        self.paths = set()
+        self.types = defaultdict(set)
+        self.samples = defaultdict(list)
+        self.array_lengths = {}  # New: Store array lengths separately
+
+    def extract_all_paths(self, data: dict, max_samples: int = 3) -> Set[str]:
+        """
+        Extract all possible JSONPath expressions from data
+
+        Args:
+            data: JSON data to analyze
+            max_samples: Maximum number of sample values to collect per path
+
+        Returns:
+            Set of JSONPath expressions found in the data
+        """
+
+        def _extract_recursive(obj: Any, path: str = "$"):
+            if isinstance(obj, dict):
+                for key, value in obj.items():
+                    current_path = f"{path}.{key}"
+                    self.paths.add(current_path)
+                    self.types[current_path].add(type(value).__name__)
+
+                    if not isinstance(value, (dict, list)) and len(self.samples[current_path]) < max_samples:
+                        self.samples[current_path].append(str(value))
+
+                    _extract_recursive(value, current_path)
+
+            elif isinstance(obj, list):
+                array_path = f"{path}[*]"
+                self.paths.add(array_path)
+                self.types[array_path].add("array")  # Just store "array" as type
+                self.array_lengths[array_path] = len(obj)  # Store length separately
+
+                if obj:  # If array is not empty
+                    # Process each item in the array to capture all possible structures
+                    for item in obj:
+                        _extract_recursive(item, array_path)
+
+        _extract_recursive(data)
+        return self.paths
+
+    def get_structure_report(self) -> str:
+        """
+        Generate a structure report using JSONPath notation
+
+        Returns:
+            Formatted string showing all paths with their types and sample values
+        """
+        report = []
+
+        for path in sorted(self.paths):
+            types = list(self.types[path])
+            samples = self.samples.get(path, [])
+
+            if "array" in types:
+                array_length = self.array_lengths.get(path, 0)
+                report.append(f"{path} -- array[{array_length}]")
+            elif samples:
+                if len(samples) > 1:
+                    unique_count = len(set(samples))
+                    if unique_count > 1:
+                        sample_range = f"{samples[0]} .. {samples[-1]} ({unique_count} unique values)"
+                    else:
+                        sample_range = samples[0]
+                else:
+                    sample_range = samples[0]
+                report.append(f"{path} -- {sample_range}")
+            else:
+                type_info = "/".join(types)
+                report.append(f"{path} -- {type_info}")
+
+        return "\n".join(report)
+
+    def get_paths_with_types(self) -> Dict[str, str]:
+        """
+        Get all paths with their associated value types
+
+        Returns:
+            Dictionary mapping JSONPath expressions to their value types
+        """
+        paths_with_types = {}
+
+        for path in self.paths:
+            types = list(self.types[path])
+
+            if "array" in types:
+                paths_with_types[path] = "array"
+            elif len(types) == 1:
+                # Single type
+                paths_with_types[path] = types[0]
+            elif len(types) > 1:
+                # Multiple types (mixed)
+                paths_with_types[path] = f"mixed({', '.join(sorted(types))})"
+            else:
+                # No type info available
+                paths_with_types[path] = "unknown"
+
+        return paths_with_types
+
+    def get_array_lengths(self) -> Dict[str, int]:
+        """
+        Get array lengths for all array paths
+
+        Returns:
+            Dictionary mapping array paths to their lengths
+        """
+        return self.array_lengths.copy()
+
+    def get_detailed_type_report(self, get_samples: bool = True) -> Dict[str, Dict[str, Any]]:
+        """
+        Get detailed type information for each path including samples
+
+        Returns:
+            Dictionary with detailed type information for each path
+        """
+        detailed_report = {}
+
+        for path in sorted(self.paths):
+            types = list(self.types[path])
+            samples = self.samples.get(path, [])
+
+            path_info = {
+                "types": types,
+                "primary_type": None,
+                "is_array": "array" in types,
+                # "samples": samples,
+                # "sample_count": len(samples)
+            }
+            if get_samples:
+                path_info["samples"] = samples
+                path_info["sample_count"] = len(samples)
+
+            # Add array length if it's an array
+            if path_info["is_array"]:
+                path_info["array_length"] = self.array_lengths.get(path, 0)
+
+            # Determine primary type
+            if path_info["is_array"]:
+                path_info["primary_type"] = "array"
+            elif len(types) == 1:
+                path_info["primary_type"] = types[0]
+            elif len(types) > 1:
+                path_info["primary_type"] = f"mixed({', '.join(sorted(types))})"
+            else:
+                path_info["primary_type"] = "unknown"
+
+            detailed_report[path] = path_info
+
+        return detailed_report
+
+    def compare_json_structures(self, other_data: dict) -> Dict[str, Any]:
+        """
+        Compare this analyzer's data with another JSON structure
+
+        Args:
+            other_data: JSON data to compare against
+
+        Returns:
+            Dictionary containing detailed comparison results
+        """
+        # Analyze the other data
+        other_analyzer = JSONPathStructureAnalyzer()
+        other_analyzer.extract_all_paths(other_data)
+
+        # Get paths and types for both
+        self_paths_types = self.get_paths_with_types()
+        other_paths_types = other_analyzer.get_paths_with_types()
+
+        # Get array lengths
+        self_array_lengths = self.get_array_lengths()
+        other_array_lengths = other_analyzer.get_array_lengths()
+
+        # Find path differences
+        self_only_paths = set(self_paths_types.keys()) - set(other_paths_types.keys())
+        other_only_paths = set(other_paths_types.keys()) - set(self_paths_types.keys())
+        common_paths = set(self_paths_types.keys()) & set(other_paths_types.keys())
+
+        # Analyze changes
+        type_changes = {}
+        value_differences = {}
+        array_size_changes = {}
+
+        for path in common_paths:
+            self_type = self_paths_types[path]
+            other_type = other_paths_types[path]
+
+            # Check for type changes
+            if self_type != other_type:
+                type_changes[path] = {
+                    "old_type": self_type,
+                    "new_type": other_type
+                }
+
+            # Check for array size changes (now much cleaner!)
+            if self_type == "array" and other_type == "array":
+                self_length = self_array_lengths.get(path, 0)
+                other_length = other_array_lengths.get(path, 0)
+
+                if self_length != other_length:
+                    array_size_changes[path] = {
+                        "old_size": self_length,
+                        "new_size": other_length,
+                        "size_change": other_length - self_length
+                    }
+
+            # Check for value differences (non-array paths)
+            if self_type != "array" and other_type != "array":
+                self_samples = self.samples.get(path, [])
+                other_samples = other_analyzer.samples.get(path, [])
+
+                if self_samples and other_samples:
+                    # Compare first sample values
+                    if self_samples[0] != other_samples[0]:
+                        value_differences[path] = {
+                            "old_value": self_samples[0],
+                            "new_value": other_samples[0],
+                            "old_samples": self_samples,
+                            "new_samples": other_samples
+                        }
+
+        return {
+            "added_paths": {path: other_paths_types[path] for path in other_only_paths},
+            "removed_paths": {path: self_paths_types[path] for path in self_only_paths},
+            "common_paths": {path: self_paths_types[path] for path in common_paths},
+            "type_changes": type_changes,
+            "value_differences": value_differences,
+            "array_size_changes": array_size_changes,
+            "array_lengths_old": {path: length for path, length in self_array_lengths.items() if path in common_paths or path in self_only_paths},
+            "array_lengths_new": {path: length for path, length in other_array_lengths.items() if path in common_paths or path in other_only_paths},
+            "summary": {
+                "total_paths_old": len(self_paths_types),
+                "total_paths_new": len(other_paths_types),
+                "paths_added": len(other_only_paths),
+                "paths_removed": len(self_only_paths),
+                "paths_common": len(common_paths),
+                "type_changes_count": len(type_changes),
+                "value_changes_count": len(value_differences),
+                "array_size_changes_count": len(array_size_changes)
+            }
+        }
+
+    def filter_paths_excluding_keys(self, exclude_keys: set[str]) -> set[str]:
+        """
+        Filter existing paths to exclude those containing specific keys
+
+        Args:
+            exclude_keys: set of keys to exclude
+
+        Returns:
+            Filtered set of paths
+        """
+        filtered_paths = set()
+
+        for path in self.paths:
+            # Check if any excluded key appears in the path
+            path_contains_excluded = False
+            for exclude_key in exclude_keys:
+                if f".{exclude_key}" in path or f".{exclude_key}[" in path:
+                    path_contains_excluded = True
+                    break
+
+            if not path_contains_excluded:
+                filtered_paths.add(path)
+
+        return filtered_paths
+
+    def get_filtered_structure_report(self, exclude_keys: set[str] = None) -> str:
+        """
+        Generate structure report excluding specific keys
+
+        Args:
+            exclude_keys: set of keys to exclude from report
+
+        Returns:
+            Filtered structure report
+        """
+        if exclude_keys is None:
+            exclude_keys = set()
+
+        filtered_paths = self.filter_paths_excluding_keys(exclude_keys)
+        report = []
+
+        for path in sorted(filtered_paths):
+            types = list(self.types[path])
+            samples = self.samples.get(path, [])
+
+            if "array" in types:
+                array_length = self.array_lengths.get(path, 0)
+                report.append(f"{path} -- array[{array_length}]")
+            elif samples:
+                if len(samples) > 1:
+                    unique_count = len(set(samples))
+                    if unique_count > 1:
+                        sample_range = f"{samples[0]} .. {samples[-1]} ({unique_count} unique values)"
+                    else:
+                        sample_range = samples[0]
+                else:
+                    sample_range = samples[0]
+                report.append(f"{path} -- {sample_range}")
+            else:
+                type_info = "/".join(types)
+                report.append(f"{path} -- {type_info}")
+
+        return "\n".join(report)
+
+    def get_filtered_paths_with_types(self, exclude_keys: set[str] = None) -> dict[str, str]:
+        """
+        Get paths with types excluding specific keys
+
+        Args:
+            exclude_keys: set of keys to exclude
+
+        Returns:
+            Dictionary mapping filtered JSONPath expressions to their value types
+        """
+        if exclude_keys is None:
+            exclude_keys = set()
+
+        filtered_paths = self.filter_paths_excluding_keys(exclude_keys)
+        paths_with_types = {}
+
+        for path in filtered_paths:
+            types = list(self.types[path])
+
+            if "array" in types:
+                paths_with_types[path] = "array"
+            elif len(types) == 1:
+                paths_with_types[path] = types[0]
+            elif len(types) > 1:
+                paths_with_types[path] = f"mixed({', '.join(sorted(types))})"
+            else:
+                paths_with_types[path] = "unknown"
+
+        return paths_with_types
+
+    def get_filtered_detailed_type_report(self, exclude_keys: set[str] = None) -> dict[str, dict[str, Any]]:
+        """
+        Get detailed type information excluding specific keys
+
+        Args:
+            exclude_keys: set of keys to exclude
+
+        Returns:
+            Dictionary with detailed type information for filtered paths
+        """
+        if exclude_keys is None:
+            exclude_keys = set()
+
+        filtered_paths = self.filter_paths_excluding_keys(exclude_keys)
+        detailed_report = {}
+
+        for path in sorted(filtered_paths):
+            types = list(self.types[path])
+            samples = self.samples.get(path, [])
+
+            path_info = {
+                "types": types,
+                "primary_type": None,
+                "is_array": "array" in types,
+                "samples": samples,
+                "sample_count": len(samples)
+            }
+
+            if path_info["is_array"]:
+                path_info["array_length"] = self.array_lengths.get(path, 0)
+
+            if path_info["is_array"]:
+                path_info["primary_type"] = "array"
+            elif len(types) == 1:
+                path_info["primary_type"] = types[0]
+            elif len(types) > 1:
+                path_info["primary_type"] = f"mixed({', '.join(sorted(types))})"
+            else:
+                path_info["primary_type"] = "unknown"
+
+            detailed_report[path] = path_info
+
+        return detailed_report
+
+
+def analyze_with_jsonpath(data: dict) -> str:
+    """
+    Analyze JSON structure using JSONPath
+
+    Args:
+        data: Dictionary containing JSON data to analyze
+
+    Returns:
+        Formatted structure report string
+    """
+    analyzer = JSONPathStructureAnalyzer()
+    analyzer.extract_all_paths(data)
+    return analyzer.get_structure_report()
+
+
+def analyze_with_jsonpath_types(data: dict) -> Dict[str, str]:
+    """
+    Analyze JSON structure and return paths with their types
+
+    Args:
+        data: Dictionary containing JSON data to analyze
+
+    Returns:
+        Dictionary mapping JSONPath expressions to their value types
+    """
+    analyzer = JSONPathStructureAnalyzer()
+    analyzer.extract_all_paths(data)
+    return analyzer.get_paths_with_types()
+
+
+def analyze_with_jsonpath_detailed(data: dict) -> Dict[str, Dict[str, Any]]:
+    """
+    Analyze JSON structure and return detailed type information
+
+    Args:
+        data: Dictionary containing JSON data to analyze
+
+    Returns:
+        Dictionary with detailed type information for each path
+    """
+    analyzer = JSONPathStructureAnalyzer()
+    analyzer.extract_all_paths(data)
+    return analyzer.get_detailed_type_report()
+
+
+def compare_json_with_jsonpath_structures(old_data: dict, new_data: dict, print_report: bool = True) -> Dict[str, Any]:
+    """
+    Compare two JSON structures using JSONPath analysis
+
+    Args:
+        old_data: Original JSON structure
+        new_data: New JSON structure to compare against
+        print_report: Whether to print the comparison report
+
+    Returns:
+        Dictionary containing detailed comparison results
+    """
+    # Analyze old structure
+    old_analyzer = JSONPathStructureAnalyzer()
+    old_analyzer.extract_all_paths(old_data)
+
+    # Compare with new structure
+    comparison = old_analyzer.compare_json_structures(new_data)
+
+    if print_report:
+        print_comparison_report(comparison)
+
+    return comparison
+
+
+def print_comparison_report(comparison: Dict[str, Any]):
+    """
+    Print a formatted comparison report
+
+    Args:
+        comparison: Result from compare_json_structures method
+    """
+    print("=== JSON STRUCTURE COMPARISON REPORT ===\n")
+
+    # Summary
+    summary = comparison["summary"]
+    print(f"📊 SUMMARY:")
+    print(f"   Old structure: {summary['total_paths_old']} paths")
+    print(f"   New structure: {summary['total_paths_new']} paths")
+    print(f"   Added: {summary['paths_added']} paths")
+    print(f"   Removed: {summary['paths_removed']} paths")
+    print(f"   Common: {summary['paths_common']} paths")
+    print(f"   Type changes: {summary['type_changes_count']}")
+    print(f"   Value changes: {summary['value_changes_count']}")
+    print(f"   Array size changes: {summary['array_size_changes_count']}")
+    print()
+
+    # Added paths
+    if comparison["added_paths"]:
+        print("➕ ADDED PATHS:")
+        for path, type_info in sorted(comparison["added_paths"].items()):
+            print(f"   {path} ({type_info})")
+        print()
+
+    # Removed paths
+    if comparison["removed_paths"]:
+        print("➖ REMOVED PATHS:")
+        for path, type_info in sorted(comparison["removed_paths"].items()):
+            print(f"   {path} ({type_info})")
+        print()
+
+    # Type changes
+    if comparison["type_changes"]:
+        print("🔄 TYPE CHANGES:")
+        for path, change in sorted(comparison["type_changes"].items()):
+            print(f"   {path}: {change['old_type']} → {change['new_type']}")
+        print()
+
+    # Array size changes
+    if comparison["array_size_changes"]:
+        print("📏 ARRAY SIZE CHANGES:")
+        for path, change in sorted(comparison["array_size_changes"].items()):
+            size_change = change['size_change']
+            direction = "📈" if size_change > 0 else "📉"
+            print(f"   {direction} {path}: {change['old_size']} → {change['new_size']} (Δ{size_change:+d})")
+        print()
+
+    # Value differences
+    if comparison["value_differences"]:
+        print("💱 VALUE CHANGES:")
+        for path, change in sorted(comparison["value_differences"].items()):
+            print(f"   {path}: '{change['old_value']}' → '{change['new_value']}'")
+        print()
+
+
+def analyze_dict_list_simple(dict_list: list[dict], exclude_keys: set[str] = None) -> list[dict[str, Any]]:
+    """
+    Analyze each dict separately and return list of results
+
+    Args:
+        dict_list: list of dictionaries to analyze
+        exclude_keys: set of keys to exclude from analysis
+
+    Returns:
+        list of individual analysis results
+    """
+    if exclude_keys is None:
+        exclude_keys = set()
+
+    results = []
+
+    for i, data_dict in enumerate(dict_list):
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(data_dict)
+
+        result = {
+            "index": i,
+            "paths_with_types": analyzer.get_filtered_paths_with_types(exclude_keys),
+            "detailed_report": analyzer.get_filtered_detailed_type_report(exclude_keys),
+            "array_lengths": {k: v for k, v in analyzer.get_array_lengths().items()
+                            if k in analyzer.filter_paths_excluding_keys(exclude_keys)},
+            "structure_report": analyzer.get_filtered_structure_report(exclude_keys)
+        }
+        results.append(result)
+
+    return results

my_ghost_writer/text_parsers2.py

@@ -1,16 +1,17 @@
 from datetime import datetime
+from typing import Any, Optional
 
-import spacy
 import nltk
 # pynflect needed to avoid different inflection
 import pyinflect
-from typing import Any, Optional
+import spacy
 from fastapi import HTTPException
 
-from my_ghost_writer.constants import SPACY_MODEL_NAME, app_logger, ELIGIBLE_POS, NLTK_DATA
+from my_ghost_writer.constants import ELIGIBLE_POS, NLTK_DATA, SPACY_MODEL_NAME, app_logger
 from my_ghost_writer.custom_synonym_handler import CustomSynonymHandler
 from my_ghost_writer.thesaurus import wn
-from my_ghost_writer.type_hints import WordSynonymResult, ContextInfo, SynonymGroup
+from my_ghost_writer.type_hints import ContextInfo, RelatedWordGroup, RelatedWordOption, RelatedWordWordResult, \
+    TermRelationships
 
 
 custom_synonym_handler = CustomSynonymHandler()
@@ -40,11 +41,20 @@ def is_nlp_available() -> bool:
     return nlp is not None
 
 
-def find_synonyms_for_phrase(text: str, start_idx: int, end_idx: int) -> list[WordSynonymResult]:
+def find_synonyms_for_phrase(text: str, start_idx: int, end_idx: int) -> list[RelatedWordWordResult]:
     """
-    Finds synonyms for all eligible words within a selected text span.
+    Finds related words for all eligible words within a selected text span.
     It analyzes the span, filters for meaningful words (nouns, verbs, etc.),
-    and returns a list of synonym results for each.
+    and returns a list of related word results for each.
+    Raises: HTTPException: If the spaCy model is unavailable.
+
+    Args:
+        text: The input text (str).
+        start_idx: The start index of the phrase within the text (int).
+        end_idx: The end index of the phrase within the text (int).
+
+    Returns:
+        A list of RelatedWordWordResult objects, representing the related words for each eligible word (list[RelatedWordWordResult]).
     """
     if nlp is None:
         app_logger.error(
@@ -62,7 +72,7 @@ def find_synonyms_for_phrase(text: str, start_idx: int, end_idx: int) -> list[Wo
         return []
 
     # Define which POS tags are eligible for synonym lookup
-    results: list[WordSynonymResult] = []
+    results: list[RelatedWordWordResult] = []
 
     for token in span:
         # Process only if the token is an eligible part of speech and not a stop word or punctuation
@@ -73,18 +83,18 @@ def find_synonyms_for_phrase(text: str, start_idx: int, end_idx: int) -> list[Wo
                     text, token.idx, token.idx + len(token.text), token.text
                 )
 
-                # 2. Get synonym groups using the token's lemma for a better search
-                synonym_groups_list = process_synonym_groups(context_info_dict['lemma'], context_info_dict)
+                # 2. Get related word groups using the token's lemma for a better search
+                related_word_groups_list = process_synonym_groups(context_info_dict["lemma"], context_info_dict)
 
-                # 3. If we find synonyms, build the result object for this word
-                if synonym_groups_list:
+                # 3. If we find related words, build the result object for this word
+                if related_word_groups_list:
                     # Restructure dicts into Pydantic models for type safety
                     context_info_model = ContextInfo(
-                        pos=context_info_dict['pos'],
-                        sentence=context_info_dict['context_sentence'],
-                        grammatical_form=context_info_dict['tag'],
-                        context_words=context_info_dict['context_words'],
-                        dependency=context_info_dict['dependency']
+                        pos=context_info_dict["pos"],
+                        sentence=context_info_dict["context_sentence"],
+                        grammatical_form=context_info_dict["tag"],
+                        context_words=context_info_dict["context_words"],
+                        dependency=context_info_dict["dependency"],
                     )
                     local_start_idx = token.idx - start_idx
                     local_end_idx = local_start_idx + len(token.text)
@@ -92,17 +102,17 @@ def find_synonyms_for_phrase(text: str, start_idx: int, end_idx: int) -> list[Wo
                     sliced_word = sliced_sentence[local_start_idx:local_end_idx]
                     assert sliced_word == token.text, (f"Mismatch! sliced_word ({sliced_word}) != token.text ({token.text}), but these substrings should be equal.\n"
                                                        f" start_idx:{start_idx}, End_word:{end_idx}. local_start_idx:{local_start_idx}, local_end_idx:{local_end_idx}.")
-                    word_result = WordSynonymResult(
+                    word_result = RelatedWordWordResult(
                         original_word=token.text,
                         original_indices={"start": local_start_idx, "end": local_end_idx},
                         context_info=context_info_model,
-                        synonym_groups=[SynonymGroup(**sg) for sg in synonym_groups_list],
+                        related_word_groups=related_word_groups_list,
                         debug_info={
                             "spacy_token_indices": {
-                                "start": context_info_dict['char_start'],
-                                "end": context_info_dict['char_end']
+                                "start": context_info_dict["char_start"],
+                                "end": context_info_dict["char_end"],
                             },
-                            "lemma": context_info_dict['lemma']
+                            "lemma": context_info_dict["lemma"]
                         }
                     )
                     results.append(word_result)
@@ -116,7 +126,19 @@ def find_synonyms_for_phrase(text: str, start_idx: int, end_idx: int) -> list[Wo
 
 
 def extract_contextual_info_by_indices(text: str, start_idx: int, end_idx: int, target_word: str) -> dict[str, Any]:
-    """Extract grammatical and contextual information using character indices"""
+    """
+    Extract grammatical and contextual information using character indices.
+    Raises: HTTPException: If the spaCy model is unavailable or if the indices are invalid.
+
+    Args:
+        text: The input text (str).
+        start_idx: The start index of the word within the text (int).
+        end_idx: The end index of the word within the text (int).
+        target_word: The target word (str).
+
+    Returns:
+        A dictionary containing contextual information about the word (dict[str, Any).
+    """
     if nlp is None:
         raise HTTPException(status_code=500, detail="spaCy model not available")
 
@@ -160,20 +182,20 @@ def extract_contextual_info_by_indices(text: str, start_idx: int, end_idx: int,
         context_words = [t.text for t in sentence_tokens[context_start:context_end]]
 
         return {
-            'word': target_token.text,
-            'lemma': target_token.lemma_,
-            'pos': target_token.pos_,
-            'tag': target_token.tag_,
-            'is_title': target_token.is_title,
-            'is_upper': target_token.is_upper,
-            'is_lower': target_token.is_lower,
-            'dependency': target_token.dep_,
-            'context_sentence': target_token.sent.text,
-            'context_words': context_words,
-            'sentence_position': target_position_in_sentence,
-            'char_start': target_token.idx,
-            'char_end': target_token.idx + len(target_token.text),
-            'original_indices': {'start': start_idx, 'end': end_idx}
+            "word": target_token.text,
+            "lemma": target_token.lemma_,
+            "pos": target_token.pos_,
+            "tag": target_token.tag_,
+            "is_title": target_token.is_title,
+            "is_upper": target_token.is_upper,
+            "is_lower": target_token.is_lower,
+            "dependency": target_token.dep_,
+            "context_sentence": target_token.sent.text,
+            "context_words": context_words,
+            "sentence_position": target_position_in_sentence,
+            "char_start": target_token.idx,
+            "char_end": target_token.idx + len(target_token.text),
+            "original_indices": {"start": start_idx, "end": end_idx},
         }
 
     except Exception as indices_ex:
@@ -182,58 +204,115 @@ def extract_contextual_info_by_indices(text: str, start_idx: int, end_idx: int,
 
 
 def get_wordnet_synonyms(word: str, pos_tag: Optional[str] = None) -> list[dict[str, Any]]:
-    """Get synonyms from wn with optional POS filtering.
-    Includes custom synonyms with a flag.  Also performs a reverse lookup."""
+    """
+    Gets related words from WordNet and custom synonym handler,
+    returning a list of dictionaries containing the raw data, grouped by relation type.
+
+    Args:
+        word: The word to get related words for (str).
+        pos_tag: An optional part-of-speech tag to filter WordNet results (Optional[str]).
 
-    # 1. Check for custom synonyms in in-memory store
+    Returns:
+        A list of dictionaries, where each dictionary represents a group of related words (list[dict[str, Any]]).
+    """
+    related_word_groups_raw: list[dict[str, Any]] = []
     word_lower = word.lower()
-    synonyms_by_sense: list[dict[str, Any]] = []  # Initialize the list here
-
-    # 1. Custom Synonym Lookup and Preparation
-    custom_synset = None  # Initialize to None
-    # 1. Direct Lookup: Check if the word is directly in custom_synonyms
-    related_synonyms = custom_synonym_handler.get_related(word_lower, "synonym")
-    if related_synonyms:
-        app_logger.info(f"found custom_synonyms:{related_synonyms} by word:{word_lower}!")
-        synonyms_list: list[dict[str, Any]] = []
-        for related in related_synonyms:
-            words = related["words"]
-            for word_from_related_words in words:
-                synonyms_list.append({"synonym": word_from_related_words, "is_custom": True, "definition": related.get("definition")})
-        if synonyms_list:
-            custom_synset = {
-                'definition': 'User-defined synonym.',
-                'examples': [],
-                'synonyms': synonyms_list
-            }
-            if pos_tag:
-                custom_synset["pos"] = pos_tag
-
-    # 2. Reverse Lookup: Check if the word is a *synonym* of any custom word
-    reverse_lookup_words = custom_synonym_handler.reverse_lookup(word_lower)
-
-    if reverse_lookup_words:
-        app_logger.info(f"found reverse match: '{word_lower}' is a synonym of '{reverse_lookup_words}'")
-        # Found a reverse match!
-        # The reverse_lookup return the original word, not a list of synonyms
-        synonyms_list: list[dict[str, Any]] = [{"synonym": reverse_word, "is_custom": True} for reverse_word in reverse_lookup_words]
-
-        custom_synset = {
-            'definition': f'User-defined synonym (reverse match for "{word}").',
-            'examples': [],
-            'synonyms': synonyms_list
-        }
-        if pos_tag:
-            custom_synset["pos"] = pos_tag
 
-    # 3. WordNet Lookup
+    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,
+                })
+    # 2. WordNet Lookup
     try:
         # Map spaCy POS to wn POS
         pos_map = {
-            'NOUN': wn.NOUN,
-            'VERB': wn.VERB,
-            'ADJ': wn.ADJ,
-            'ADV': wn.ADV
+            "NOUN": wn.NOUN,
+            "VERB": wn.VERB,
+            "ADJ": wn.ADJ,
+            "ADV": wn.ADV,
         }
 
         # Get all synsets for the word
@@ -243,38 +322,34 @@ def get_wordnet_synonyms(word: str, pos_tag: Optional[str] = None) -> list[dict[
         if pos_tag and pos_tag in pos_map:
             synsets = [s for s in synsets if s.pos() == pos_map[pos_tag]]
 
+        # Process each synset and its relations
         for synset in synsets:
-            sense_data = {
-                'definition': synset.definition(),
-                'examples': synset.examples()[:2],  # Limit examples
-                'synonyms': [],
-            }
-            # Add pos only if it's available
-            syn_pos = synset.pos()
-            if syn_pos:
-              sense_data['pos'] = syn_pos
-
-            # Use a set to avoid duplicate synonyms from different lemmas in the same synset
-            unique_synonyms = set()
+            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
             for lemma in synset.lemmas():
-                synonym = lemma.name().replace('_', ' ')
-                if synonym.lower() != word.lower():
-                    unique_synonyms.add(synonym)
-
-            if unique_synonyms:
-                # add synonyms (without is_custom) since these are WordNet synonyms
-                sense_data['synonyms'] = sorted(list(unique_synonyms))
-                synonyms_by_sense.append(sense_data)
+                result = _get_related_words(lemma, TermRelationships.ANTONYM, word_lower)
+                if 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
+                ]:
+                result = _get_related_words(synset, rel_type, word_lower)
+                if result:
+                    related_word_groups_raw.append(result)
 
     except Exception as ex1:
-        app_logger.error(f"Error getting wn synonyms: {ex1}")
-        raise HTTPException(status_code=500, detail=f"Error retrieving synonyms: {str(ex1)}")
-
-    # 4. Combine Custom and WordNet Synsets
-    if custom_synset:
-        synonyms_by_sense.insert(0, custom_synset)  # Add custom synset at the beginning
+        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 synonyms_by_sense
+    return related_word_groups_raw
 
 
 def inflect_synonym(synonym: str, original_token_info: dict[str, Any]) -> str:
@@ -283,24 +358,24 @@ def inflect_synonym(synonym: str, original_token_info: dict[str, Any]) -> str:
     if nlp is None:
         return synonym
 
-    pos = original_token_info.get('pos')
-    tag = original_token_info.get('tag')
+    pos = original_token_info.get("pos")
+    tag = original_token_info.get("tag")
 
     # Handle capitalization first using .get() for safety
-    if original_token_info.get('is_title'):
+    if original_token_info.get("is_title"):
         synonym = synonym.title() # .title() is better for multi-word phrases
-    elif original_token_info.get('is_upper'):
+    elif original_token_info.get("is_upper"):
         synonym = synonym.upper()
-    elif original_token_info.get('is_lower', True):  # Default to lower
+    elif original_token_info.get("is_lower", True):  # Default to lower
         synonym = synonym.lower()
 
     # Handle grammatical inflection
     try:
         # Define all tags that require inflection in one place
         inflection_tags = {
-            'NOUN': ['NNS', 'NNPS'],
-            'VERB': ['VBD', 'VBN', 'VBZ', 'VBG'],
-            'ADJ': ['JJR', 'JJS']
+            "NOUN": ["NNS", "NNPS"],
+            "VERB": ["VBD", "VBN", "VBZ", "VBG"],
+            "ADJ": ["JJR", "JJS"],
         }
 
         # Single check for all inflection cases
@@ -320,50 +395,58 @@ def inflect_synonym(synonym: str, original_token_info: dict[str, Any]) -> str:
     return synonym
 
 
-def process_synonym_groups(word: str, context_info: dict[str, Any]) -> list[dict[str, Any]]:
-    """Process synonym groups with inflection matching"""
-    # Get synonyms from wn
+def process_synonym_groups(word: str, context_info: dict[str, Any]) -> list[RelatedWordGroup]:
+    """Process given related word groups with inflection matching
+
+    Args:
+        word (str): the word
+        context_info (dict[str, Any]): the original form of data
+
+    Returns:
+        list[RelatedWordGroup]: List of the processed related words
+    """
+    # Get related words from wn
     t0 = datetime.now()
-    # Get synonyms from wn using the lemma
-    synonyms_by_sense = get_wordnet_synonyms(context_info['lemma'], context_info['pos'])
+    # Get related words from wn using the lemma
+    related_words_raw = get_wordnet_synonyms(context_info["lemma"], context_info["pos"])
     t1 = datetime.now()
     duration = (t1 - t0).total_seconds()
     app_logger.info(f"# 1/Got get_wordnet_synonyms result with '{word}' word in {duration:.3f}s.")
 
-    if not synonyms_by_sense:
+    if not related_words_raw:
         return []
 
-    # Process each synonym group
-    processed_synonyms = []
-    for sense in synonyms_by_sense:
-        processed_sense = {
-            "definition": sense['definition'],
-            "examples": sense['examples'],
-            "wordnet_pos": sense['pos'],
-            "synonyms": []
-        }
-
-        for synonym in sense['synonyms']:
-            # Get both the base form and inflected form
-            app_logger.info("## synonym ##")
-            app_logger.info(type(synonym))
-            app_logger.info(synonym)
-            synonym_str = synonym
-            if isinstance(synonym, dict):
-                synonym_str = synonym["synonym"]
-
-            base_form = synonym_str
-            app_logger.info("## synonym ##")
-            app_logger.info(type(synonym_str))
-            app_logger.info(synonym_str)
-            inflected_form = inflect_synonym(synonym_str, context_info)
-
-            processed_sense["synonyms"].append({
-                "base_form": base_form,
-                "inflected_form": inflected_form,
-                "matches_context": inflected_form.lower() != base_form.lower()
-            })
-
-        processed_synonyms.append(processed_sense)
-
-    return processed_synonyms
+    # Process each related word group
+    processed_groups: list[RelatedWordGroup] = []
+    for related_group in related_words_raw:
+        app_logger.info(f"related_group:'{related_group}'")
+        relation_type = related_group["relation_type"]
+        definition = related_group.get("definition", "")
+        examples = related_group.get("examples", [])
+        wordnet_pos = related_group.get("wordnet_pos")
+        related_words = related_group["related_words"]
+        processed_options: list[RelatedWordOption] = []
+
+        for related_word in related_words:
+            base_form = related_word["base_form"]
+            inflected_form = inflect_synonym(base_form, context_info)
+
+            related_word_option = RelatedWordOption(
+                base_form=base_form,
+                inflected_form=inflected_form,
+                matches_context=inflected_form.lower() != base_form.lower()
+            )
+            if "is_custom" in related_word:
+                related_word_option.is_custom = related_word["is_custom"]
+            processed_options.append(related_word_option)
+        app_logger.info(f"wordnet_pos:{type(wordnet_pos)}, '{wordnet_pos}'")
+        processed_groups.append(
+            RelatedWordGroup(
+                relation_type=relation_type,
+                definition=definition,
+                examples=examples,
+                related_words=processed_options,
+                wordnet_pos=wordnet_pos
+            )
+        )
+    return processed_groups

my_ghost_writer/type_hints.py

@@ -1,23 +1,41 @@
-from typing import Any, TypedDict, Optional, Literal
-from pydantic import BaseModel, field_validator
+from decimal import Decimal
+from enum import Enum
+from typing import Any, Optional, TypedDict, Union
+
+from pydantic import BaseModel, field_validator, Field, field_serializer
+
+decimal_places = 4
+
+
+class TermRelationships(str, Enum):
+    """
+    An enumeration representing the possible relationships between terms.
+    """
+    ALSO_SEE = "also_see"
+    ANTONYM = "antonym"
+    CAUSE = "cause"
+    DERIVATIONALLY_RELATED_FORM = "derivationally_related_form"
+    ENTAILMENT = "entailment"
+    HOLONYM = "holonym"
+    HYPERNYM = "hypernym"
+    HYPONYM = "hyponym"
+    MERONYM = "meronym"
+    PERTAINYM = "pertainym"
+    SIMILAR_TO = "similar_to"
+    SYNONYM = "synonym"
 
 
 class RelatedEntry(BaseModel):
-    type: Literal["synonym", "antonym", "homonym", "homophone", "homograph"]
+    """Represents a related entry for a custom-related word."""
+    type: TermRelationships
     words: list[str]
-    definition: Optional[str] = None  # Definition is now within RelatedEntry
+    definition: Optional[str] = None
 
 
-class CustomSynonymRequest(BaseModel):
+class CustomRelatedWordRequest(BaseModel):
     word: str
     related: list[RelatedEntry]
 
-    # @field_validator("synonyms")
-    # def synonyms_must_not_be_empty(cls, v):
-    #     if not v:
-    #         raise ValueError("Synonym list cannot be empty.")
-    #     return v
-
 
 class SynonymInfo(TypedDict):
     synonym: str
@@ -50,17 +68,19 @@ class RequestQueryThesaurusInflatedBody(BaseModel):
     word: str
 
 
-class SynonymOption(BaseModel):
+class RelatedWordOption(BaseModel):
     base_form: str
     inflected_form: str
     matches_context: bool
+    is_custom: Optional[bool] = None
 
 
-class SynonymGroup(BaseModel):
+class RelatedWordGroup(BaseModel):
+    relation_type: TermRelationships
     definition: str
     examples: list[str]
-    wordnet_pos: str
-    synonyms: list[SynonymOption]
+    wordnet_pos: Optional[str]
+    related_words: list[RelatedWordOption]
 
 
 class ContextInfo(BaseModel):
@@ -76,25 +96,40 @@ class SingleWordSynonymResponse(BaseModel):
     original_word: str
     original_indices: dict[str, int]
     context_info: ContextInfo
-    synonym_groups: list[SynonymGroup]
+    synonym_groups: list[RelatedWordGroup]
     message: Optional[str] = None
     debug_info: Optional[dict[str, Any]] = None
 
 
-class WordSynonymResult(BaseModel):
+class RelatedWordWordResult(BaseModel):
     original_word: str
     original_indices: dict[str, int]
     context_info: ContextInfo
-    synonym_groups: list[SynonymGroup]
+    related_word_groups: list[RelatedWordGroup]
+    message: Optional[str] = None
     debug_info: Optional[dict[str, Any]] = None
 
 
-class MultiWordSynonymResponse(BaseModel):
+class MultiRelatedWordResponse(BaseModel):
     success: bool
     original_phrase: str
     original_indices: dict[str, int]
-    results: list[WordSynonymResult]
+    results: list[RelatedWordWordResult]
     message: Optional[str] = None
+    duration: Optional[Decimal] = Field(gt=0, decimal_places=decimal_places)
+
+    @field_validator('duration', mode="before")
+    def validate_duration(cls, v: Union[float, Decimal, str, None]) -> Optional[Decimal]:
+        if v is None:
+            return v
+        return Decimal(f"{v:.{decimal_places}f}")
+
+    @field_serializer('duration')
+    def serialize_duration(self, value: Optional[Decimal]) -> Optional[float]:
+        """Serialize Decimal as float for JSON output"""
+        if value is None:
+            return None
+        return float(value)
 
 
 class HealthCheckResponse(BaseModel):
@@ -105,7 +140,7 @@ class HealthCheckResponse(BaseModel):
 
 class InputTextRow(TypedDict):
     """
-    TypedDict for input text row.
+    TypedDict for an input text row.
     """
     idxRow: int
     text: str

poetry.lock

@@ -601,6 +601,22 @@ files = [
     {file = "joblib-1.5.1.tar.gz", hash = "sha256:f4f86e351f39fe3d0d32a9f2c3d8af1ee4cec285aafcb27003dda5205576b444"},
 ]
 
+[[package]]
+name = "jsonpath-ng"
+version = "1.7.0"
+description = "A final implementation of JSONPath for Python that aims to be standard compliant, including arithmetic and binary comparison operators and providing clear AST for metaprogramming."
+optional = false
+python-versions = "*"
+groups = ["test"]
+files = [
+    {file = "jsonpath-ng-1.7.0.tar.gz", hash = "sha256:f6f5f7fd4e5ff79c785f1573b394043b39849fb2bb47bcead935d12b00beab3c"},
+    {file = "jsonpath_ng-1.7.0-py2-none-any.whl", hash = "sha256:898c93fc173f0c336784a3fa63d7434297544b7198124a68f9a3ef9597b0ae6e"},
+    {file = "jsonpath_ng-1.7.0-py3-none-any.whl", hash = "sha256:f3d7f9e848cba1b6da28c55b1c26ff915dc9e0b1ba7e752a53d6da8d5cbd00b6"},
+]
+
+[package.dependencies]
+ply = "*"
+
 [[package]]
 name = "langcodes"
 version = "3.5.0"
@@ -1004,6 +1020,18 @@ files = [
 dev = ["pre-commit", "tox"]
 testing = ["coverage", "pytest", "pytest-benchmark"]
 
+[[package]]
+name = "ply"
+version = "3.11"
+description = "Python Lex & Yacc"
+optional = false
+python-versions = "*"
+groups = ["test"]
+files = [
+    {file = "ply-3.11-py2.py3-none-any.whl", hash = "sha256:096f9b8350b65ebd2fd1346b12452efe5b9607f7482813ffca50c22722a807ce"},
+    {file = "ply-3.11.tar.gz", hash = "sha256:00c7c1aaa88358b9c765b6d3000c6eec0ba42abca5351b095321aef446081da3"},
+]
+
 [[package]]
 name = "preshed"
 version = "3.0.10"
@@ -2136,4 +2164,4 @@ files = [
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.10,<3.14.0"
-content-hash = "98791d1abc3f92349756a2c761df7c0acedaf9aa1e482c42ae7986329c90ddb7"
+content-hash = "ae8867d9a28d2dee6521df2f2ba249d664340d8e3b0ff65260e6ff70e45d1839"

pyproject.toml

@@ -28,6 +28,7 @@ optional = true
 pytest = "^8.3.5"
 pytest-cov = "^6.1.1"
 httpx = "^0.28.1"
+jsonpath-ng = "^1.7.0"
 
 [tool.poetry.group.webserver]
 optional = true

requirements-test.txt

@@ -1,3 +1,3 @@
 httpx==0.28.1
 pytest-cov==6.2.1
-pytest==8.4.1
+pytest==8.4.1

requirements-webserver.txt

@@ -1,4 +1,5 @@
 asgi-correlation-id==4.3.4
 fastapi==0.115.14
+pymongo==4.13.2
 requests==2.32.4
 uvicorn==0.34.3

requirements.txt

@@ -2,5 +2,7 @@ nltk==3.9.1
 pyinflect==0.5.1
 pymongo==4.13.2
 python-dotenv==1.1.1
+spacy-legacy==3.0.12
+spacy-loggers==1.0.5
 spacy==3.8.7
-structlog==25.4.0
+structlog==25.4.0

tests/events/get_wordnet_synonyms_custom_entry_happy.json

@@ -0,0 +1 @@
+[{"$.definition": {"types": ["str"], "primary_type": "str", "is_array": false}, "$.related_words": {"types": ["list"], "primary_type": "list", "is_array": false}, "$.related_words[*]": {"types": ["array"], "primary_type": "array", "is_array": true, "array_length": 1}, "$.related_words[*].base_form": {"types": ["str"], "primary_type": "str", "is_array": false}, "$.relation_type": {"types": ["TermRelationships"], "primary_type": "TermRelationships", "is_array": false}, "$.source": {"types": ["str"], "primary_type": "str", "is_array": false}, "$.wordnet_pos": {"types": ["NoneType"], "primary_type": "NoneType", "is_array": false}}, {"$.definition": {"types": ["str"], "primary_type": "str", "is_array": false}, "$.related_words": {"types": ["list"], "primary_type": "list", "is_array": false}, "$.related_words[*]": {"types": ["array"], "primary_type": "array", "is_array": true, "array_length": 9}, "$.related_words[*].base_form": {"types": ["str"], "primary_type": "str", "is_array": false}, "$.relation_type": {"types": ["TermRelationships"], "primary_type": "TermRelationships", "is_array": false}, "$.source": {"types": ["str"], "primary_type": "str", "is_array": false}, "$.wordnet_pos": {"types": ["str"], "primary_type": "str", "is_array": false}}, {"$.definition": {"types": ["str"], "primary_type": "str", "is_array": false}, "$.related_words": {"types": ["list"], "primary_type": "list", "is_array": false}, "$.related_words[*]": {"types": ["array"], "primary_type": "array", "is_array": true, "array_length": 8}, "$.related_words[*].base_form": {"types": ["str"], "primary_type": "str", "is_array": false}, "$.relation_type": {"types": ["TermRelationships"], "primary_type": "TermRelationships", "is_array": false}, "$.source": {"types": ["str"], "primary_type": "str", "is_array": false}, "$.wordnet_pos": {"types": ["str"], "primary_type": "str", "is_array": false}}]

tests/events/get_wordnet_synonyms_piano_ok1.json

@@ -0,0 +1 @@
+{"$.definition": {"types": ["str"], "primary_type": "str", "is_array": false, "samples": ["a keyboard instrument that is played by depressing keys that cause hammers to strike tuned strings and produce sounds"], "sample_count": 1}, "$.examples": {"types": ["list"], "primary_type": "list", "is_array": false, "samples": [], "sample_count": 0}, "$.examples[*]": {"types": ["array"], "primary_type": "array", "is_array": true, "samples": [], "sample_count": 0, "array_length": 0}, "$.related_words": {"types": ["list"], "primary_type": "list", "is_array": false, "samples": [], "sample_count": 0}, "$.related_words[*]": {"types": ["array"], "primary_type": "array", "is_array": true, "samples": [], "sample_count": 0, "array_length": 2}, "$.related_words[*].base_form": {"types": ["str"], "primary_type": "str", "is_array": false, "samples": ["pianoforte", "forte-piano"], "sample_count": 2}, "$.relation_type": {"types": ["TermRelationships"], "primary_type": "TermRelationships", "is_array": false, "samples": ["TermRelationships.SYNONYM"], "sample_count": 1}, "$.source": {"types": ["str"], "primary_type": "str", "is_array": false, "samples": ["wordnet"], "sample_count": 1}, "$.wordnet_pos": {"types": ["str"], "primary_type": "str", "is_array": false, "samples": ["n"], "sample_count": 1}}

tests/events/request_thesaurus_custom4.json

@@ -0,0 +1,20 @@
+{
+  "word": "happy",
+  "related": [
+    {
+      "definition": "def happy 1 - custom.",
+      "type": "synonym",
+      "words": ["joyful", "cheerful"]
+    },
+    {
+      "definition": "def happy 2 - custom.",
+      "type": "synonym",
+      "words": ["joy", "cheer", "elated"]
+    },
+    {
+      "definition": "def sad - custom.",
+      "type": "antonym",
+      "words": ["sad", "unhappy"]
+    }
+  ]
+}

tests/events/response_thesaurus_phrase_inflated.json

@@ -31,15 +31,182 @@
                 ],
                 "dependency": "amod"
             },
-            "synonym_groups": [
+            "related_word_groups": [
                 {
+                    "relation_type": "hyponym",
+                    "definition": "perceive with attention; direct one's gaze towards",
+                    "examples": [
+                        "She looked over the expanse of land",
+                        "Look at your child!"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "goggle",
+                            "inflected_form": "goggling",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "gape",
+                            "inflected_form": "gaping",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "gawp",
+                            "inflected_form": "gawping",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "gawk",
+                            "inflected_form": "gawking",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "gloat",
+                            "inflected_form": "gloating",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "look around",
+                            "inflected_form": "looking around",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "ogle",
+                            "inflected_form": "ogling",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "give the glad eye",
+                            "inflected_form": "giving the glad eye",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "peep",
+                            "inflected_form": "peeping",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "look back",
+                            "inflected_form": "looking back",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "look backward",
+                            "inflected_form": "looking backward",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "regard",
+                            "inflected_form": "regarding",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "consider",
+                            "inflected_form": "considering",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "glance",
+                            "inflected_form": "glancing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "peek",
+                            "inflected_form": "peeking",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "glint",
+                            "inflected_form": "glinting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "eye",
+                            "inflected_form": "eyeing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "eyeball",
+                            "inflected_form": "eyeballing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "peer",
+                            "inflected_form": "peering",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "admire",
+                            "inflected_form": "admiring",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "gaze",
+                            "inflected_form": "gazing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "stare",
+                            "inflected_form": "staring",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "look away",
+                            "inflected_form": "looking away",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "leer",
+                            "inflected_form": "leering",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "give the eye",
+                            "inflected_form": "giving the eye",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "give the once over",
+                            "inflected_form": "giving the once over",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "squint",
+                            "inflected_form": "squinting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "take a look",
+                            "inflected_form": "taking a look",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "have a look",
+                            "inflected_form": "having a look",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "get a load",
+                            "inflected_form": "getting a load",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "stare",
+                            "inflected_form": "staring",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "synonym",
                     "definition": "give a certain impression or have a certain outward aspect",
                     "examples": [
                         "She seems to be sleeping",
                         "This appears to be a very difficult problem"
                     ],
                     "wordnet_pos": "v",
-                    "synonyms": [
+                    "related_words": [
                         {
                             "base_form": "appear",
                             "inflected_form": "appearing",
@@ -53,235 +220,1474 @@
                     ]
                 },
                 {
-                    "definition": "search or seek",
+                    "relation_type": "hypernym",
+                    "definition": "give a certain impression or have a certain outward aspect",
                     "examples": [
-                        "We looked all day and finally found the child in the forest",
-                        "Look elsewhere for the perfect gift!"
+                        "She seems to be sleeping",
+                        "This appears to be a very difficult problem"
                     ],
                     "wordnet_pos": "v",
-                    "synonyms": [
+                    "related_words": [
                         {
-                            "base_form": "search",
-                            "inflected_form": "searching",
+                            "base_form": "be",
+                            "inflected_form": "being",
                             "matches_context": true
                         }
                     ]
                 },
                 {
-                    "definition": "be oriented in a certain direction, often with respect to another reference point; be opposite to",
+                    "relation_type": "hyponym",
+                    "definition": "give a certain impression or have a certain outward aspect",
                     "examples": [
-                        "The house looks north",
-                        "My backyard look onto the pond"
+                        "She seems to be sleeping",
+                        "This appears to be a very difficult problem"
                     ],
                     "wordnet_pos": "v",
-                    "synonyms": [
+                    "related_words": [
                         {
-                            "base_form": "face",
-                            "inflected_form": "facing",
+                            "base_form": "glow",
+                            "inflected_form": "glowing",
                             "matches_context": true
                         },
                         {
-                            "base_form": "front",
-                            "inflected_form": "fronting",
+                            "base_form": "beam",
+                            "inflected_form": "beaming",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "radiate",
+                            "inflected_form": "radiating",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "shine",
+                            "inflected_form": "shining",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "rise",
+                            "inflected_form": "rising",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "lift",
+                            "inflected_form": "lifting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "rear",
+                            "inflected_form": "rearing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "glitter",
+                            "inflected_form": "glittering",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "glisten",
+                            "inflected_form": "glistening",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "glint",
+                            "inflected_form": "glinting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "gleam",
+                            "inflected_form": "gleaming",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "shine",
+                            "inflected_form": "shining",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "leap out",
+                            "inflected_form": "leaping out",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "jump out",
+                            "inflected_form": "jumping out",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "jump",
+                            "inflected_form": "jumping",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "stand out",
+                            "inflected_form": "standing out",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "stick out",
+                            "inflected_form": "sticking out",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "make",
+                            "inflected_form": "making",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "loom",
+                            "inflected_form": "looming",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "sound",
+                            "inflected_form": "sounding",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "cut",
+                            "inflected_form": "cutting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "pass off",
+                            "inflected_form": "passing off",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "come across",
+                            "inflected_form": "coming across",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "feel",
+                            "inflected_form": "feeling",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "feel",
+                            "inflected_form": "feeling",
                             "matches_context": true
                         }
                     ]
                 },
                 {
-                    "definition": "take charge of or deal with",
+                    "relation_type": "hypernym",
+                    "definition": "have a certain outward or facial expression",
                     "examples": [
-                        "Could you see about lunch?",
-                        "I must attend to this matter"
+                        "How does she look?",
+                        "The child looks unhappy"
                     ],
                     "wordnet_pos": "v",
-                    "synonyms": [
-                        {
-                            "base_form": "attend",
-                            "inflected_form": "attending",
-                            "matches_context": true
-                        },
+                    "related_words": [
                         {
-                            "base_form": "see",
-                            "inflected_form": "seeing",
+                            "base_form": "be",
+                            "inflected_form": "being",
                             "matches_context": true
-                        },
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hyponym",
+                    "definition": "have a certain outward or facial expression",
+                    "examples": [
+                        "How does she look?",
+                        "The child looks unhappy"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
                         {
-                            "base_form": "take care",
-                            "inflected_form": "taking care",
+                            "base_form": "squint",
+                            "inflected_form": "squinting",
                             "matches_context": true
                         }
                     ]
                 },
                 {
-                    "definition": "look forward to the probable occurrence of",
+                    "relation_type": "synonym",
+                    "definition": "search or seek",
                     "examples": [
-                        "We were expecting a visit from our relatives",
-                        "She is looking to a promotion"
+                        "We looked all day and finally found the child in the forest",
+                        "Look elsewhere for the perfect gift!"
                     ],
                     "wordnet_pos": "v",
-                    "synonyms": [
+                    "related_words": [
                         {
-                            "base_form": "await",
-                            "inflected_form": "awaiting",
+                            "base_form": "search",
+                            "inflected_form": "searching",
                             "matches_context": true
-                        },
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "search or seek",
+                    "examples": [
+                        "We looked all day and finally found the child in the forest",
+                        "Look elsewhere for the perfect gift!"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
                         {
-                            "base_form": "expect",
-                            "inflected_form": "expecting",
+                            "base_form": "examine",
+                            "inflected_form": "examining",
                             "matches_context": true
                         },
                         {
-                            "base_form": "wait",
-                            "inflected_form": "waiting",
+                            "base_form": "see",
+                            "inflected_form": "seeing",
                             "matches_context": true
                         }
                     ]
                 },
                 {
-                    "definition": "have faith or confidence in",
+                    "relation_type": "hyponym",
+                    "definition": "search or seek",
                     "examples": [
-                        "you can count on me to help you any time",
-                        "Look to your friends for support"
+                        "We looked all day and finally found the child in the forest",
+                        "Look elsewhere for the perfect gift!"
                     ],
                     "wordnet_pos": "v",
-                    "synonyms": [
+                    "related_words": [
                         {
-                            "base_form": "bank",
-                            "inflected_form": "banking",
+                            "base_form": "hunt",
+                            "inflected_form": "hunting",
                             "matches_context": true
                         },
                         {
-                            "base_form": "bet",
-                            "inflected_form": "betting",
+                            "base_form": "cruise",
+                            "inflected_form": "cruising",
                             "matches_context": true
                         },
                         {
-                            "base_form": "calculate",
-                            "inflected_form": "calculating",
+                            "base_form": "prospect",
+                            "inflected_form": "prospecting",
                             "matches_context": true
                         },
                         {
-                            "base_form": "count",
-                            "inflected_form": "counting",
+                            "base_form": "intrude",
+                            "inflected_form": "intruding",
                             "matches_context": true
                         },
                         {
-                            "base_form": "depend",
-                            "inflected_form": "depending",
+                            "base_form": "horn in",
+                            "inflected_form": "horning in",
                             "matches_context": true
                         },
                         {
-                            "base_form": "reckon",
-                            "inflected_form": "reckoning",
+                            "base_form": "pry",
+                            "inflected_form": "prying",
                             "matches_context": true
                         },
                         {
-                            "base_form": "rely",
-                            "inflected_form": "relying",
+                            "base_form": "nose",
+                            "inflected_form": "nosing",
                             "matches_context": true
                         },
                         {
-                            "base_form": "swear",
-                            "inflected_form": "swearing",
+                            "base_form": "poke",
+                            "inflected_form": "poking",
                             "matches_context": true
                         }
                     ]
-                }
+                },
+                {
+                    "relation_type": "synonym",
+                    "definition": "be oriented in a certain direction, often with respect to another reference point; be opposite to",
+                    "examples": [
+                        "The house looks north",
+                        "My backyard look onto the pond"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "front",
+                            "inflected_form": "fronting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "face",
+                            "inflected_form": "facing",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "antonym",
+                    "definition": "",
+                    "examples": [],
+                    "related_words": [
+                        {
+                            "base_form": "back",
+                            "inflected_form": "backing",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "be oriented in a certain direction, often with respect to another reference point; be opposite to",
+                    "examples": [
+                        "The house looks north",
+                        "My backyard look onto the pond"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "lie",
+                            "inflected_form": "lying",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hyponym",
+                    "definition": "be oriented in a certain direction, often with respect to another reference point; be opposite to",
+                    "examples": [
+                        "The house looks north",
+                        "My backyard look onto the pond"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "confront",
+                            "inflected_form": "confronting",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "synonym",
+                    "definition": "take charge of or deal with",
+                    "examples": [
+                        "Could you see about lunch?",
+                        "I must attend to this matter"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "attend",
+                            "inflected_form": "attending",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "take care",
+                            "inflected_form": "taking care",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "see",
+                            "inflected_form": "seeing",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "take charge of or deal with",
+                    "examples": [
+                        "Could you see about lunch?",
+                        "I must attend to this matter"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "care",
+                            "inflected_form": "caring",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "give care",
+                            "inflected_form": "giving care",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hyponym",
+                    "definition": "take charge of or deal with",
+                    "examples": [
+                        "Could you see about lunch?",
+                        "I must attend to this matter"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "tend",
+                            "inflected_form": "tending",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "minister",
+                            "inflected_form": "ministering",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "convey by one's expression",
+                    "examples": [
+                        "She looked her devotion to me"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "convey",
+                            "inflected_form": "conveying",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "synonym",
+                    "definition": "look forward to the probable occurrence of",
+                    "examples": [
+                        "We were expecting a visit from our relatives",
+                        "She is looking to a promotion"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "expect",
+                            "inflected_form": "expecting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "await",
+                            "inflected_form": "awaiting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "wait",
+                            "inflected_form": "waiting",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hyponym",
+                    "definition": "look forward to the probable occurrence of",
+                    "examples": [
+                        "We were expecting a visit from our relatives",
+                        "She is looking to a promotion"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "look forward",
+                            "inflected_form": "looking forward",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "anticipate",
+                            "inflected_form": "anticipating",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "look for",
+                            "inflected_form": "looking for",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "look to",
+                            "inflected_form": "looking to",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "hang on",
+                            "inflected_form": "hanging on",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "hold the line",
+                            "inflected_form": "holding the line",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "hold on",
+                            "inflected_form": "holding on",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "expect",
+                            "inflected_form": "expecting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "look to",
+                            "inflected_form": "looking to",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "accord in appearance with",
+                    "examples": [
+                        "You don't look your age!"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "match",
+                            "inflected_form": "matching",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "fit",
+                            "inflected_form": "fitting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "correspond",
+                            "inflected_form": "corresponding",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "check",
+                            "inflected_form": "checking",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "jibe",
+                            "inflected_form": "jibing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "gibe",
+                            "inflected_form": "gibing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "tally",
+                            "inflected_form": "tallying",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "agree",
+                            "inflected_form": "agreeing",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "synonym",
+                    "definition": "have faith or confidence in",
+                    "examples": [
+                        "you can count on me to help you any time",
+                        "Look to your friends for support"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "count",
+                            "inflected_form": "counting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "bet",
+                            "inflected_form": "betting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "depend",
+                            "inflected_form": "depending",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "swear",
+                            "inflected_form": "swearing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "rely",
+                            "inflected_form": "relying",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "bank",
+                            "inflected_form": "banking",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "calculate",
+                            "inflected_form": "calculating",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "reckon",
+                            "inflected_form": "reckoning",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "have faith or confidence in",
+                    "examples": [
+                        "you can count on me to help you any time",
+                        "Look to your friends for support"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "trust",
+                            "inflected_form": "trusting",
+                            "matches_context": true
+                        }
+                    ]
+                }
             ],
             "debug_info": {
                 "spacy_token_indices": {
                     "start": 42,
                     "end": 49
                 },
-                "lemma": "look"
-            }
-        },
-        {
-            "original_word": "woman",
-            "original_indices": {
-                "start": 22,
-                "end": 27
-            },
-            "context_info": {
-                "pos": "NOUN",
-                "sentence": "Instead he was smiling at a rather severe-looking woman who was wearing square glasses exactly the shape of the markings the cat had had around its eyes.",
-                "grammatical_form": "NN",
-                "context_words": [
-                    "a",
-                    "rather",
-                    "severe",
-                    "-",
-                    "looking",
-                    "woman",
-                    "who",
-                    "was",
-                    "wearing",
-                    "square",
-                    "glasses"
-                ],
-                "dependency": "pobj"
-            },
-            "synonym_groups": [
+                "lemma": "look"
+            }
+        },
+        {
+            "original_word": "woman",
+            "original_indices": {
+                "start": 22,
+                "end": 27
+            },
+            "context_info": {
+                "pos": "NOUN",
+                "sentence": "Instead he was smiling at a rather severe-looking woman who was wearing square glasses exactly the shape of the markings the cat had had around its eyes.",
+                "grammatical_form": "NN",
+                "context_words": [
+                    "a",
+                    "rather",
+                    "severe",
+                    "-",
+                    "looking",
+                    "woman",
+                    "who",
+                    "was",
+                    "wearing",
+                    "square",
+                    "glasses"
+                ],
+                "dependency": "pobj"
+            },
+            "related_word_groups": [
+                {
+                    "relation_type": "synonym",
+                    "definition": "an adult female person (as opposed to a man)",
+                    "examples": [
+                        "the woman kept house while the man hunted"
+                    ],
+                    "wordnet_pos": "n",
+                    "related_words": [
+                        {
+                            "base_form": "adult female",
+                            "inflected_form": "adult female",
+                            "matches_context": false
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "antonym",
+                    "definition": "",
+                    "examples": [],
+                    "related_words": [
+                        {
+                            "base_form": "man",
+                            "inflected_form": "man",
+                            "matches_context": false
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "an adult female person (as opposed to a man)",
+                    "examples": [
+                        "the woman kept house while the man hunted"
+                    ],
+                    "wordnet_pos": "n",
+                    "related_words": [
+                        {
+                            "base_form": "female",
+                            "inflected_form": "female",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "female person",
+                            "inflected_form": "female person",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "adult",
+                            "inflected_form": "adult",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "grownup",
+                            "inflected_form": "grownup",
+                            "matches_context": false
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hyponym",
+                    "definition": "an adult female person (as opposed to a man)",
+                    "examples": [
+                        "the woman kept house while the man hunted"
+                    ],
+                    "wordnet_pos": "n",
+                    "related_words": [
+                        {
+                            "base_form": "jezebel",
+                            "inflected_form": "jezebel",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "mother figure",
+                            "inflected_form": "mother figure",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "smasher",
+                            "inflected_form": "smasher",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "stunner",
+                            "inflected_form": "stunner",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "knockout",
+                            "inflected_form": "knockout",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "beauty",
+                            "inflected_form": "beauty",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "ravisher",
+                            "inflected_form": "ravisher",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "sweetheart",
+                            "inflected_form": "sweetheart",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "peach",
+                            "inflected_form": "peach",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "lulu",
+                            "inflected_form": "lulu",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "looker",
+                            "inflected_form": "looker",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "mantrap",
+                            "inflected_form": "mantrap",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "dish",
+                            "inflected_form": "dish",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "B-girl",
+                            "inflected_form": "b-girl",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "bar girl",
+                            "inflected_form": "bar girl",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "heroine",
+                            "inflected_form": "heroine",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "prostitute",
+                            "inflected_form": "prostitute",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "cocotte",
+                            "inflected_form": "cocotte",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "whore",
+                            "inflected_form": "whore",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "harlot",
+                            "inflected_form": "harlot",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "bawd",
+                            "inflected_form": "bawd",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "tart",
+                            "inflected_form": "tart",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "cyprian",
+                            "inflected_form": "cyprian",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "fancy woman",
+                            "inflected_form": "fancy woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "working girl",
+                            "inflected_form": "working girl",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "sporting lady",
+                            "inflected_form": "sporting lady",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "lady of pleasure",
+                            "inflected_form": "lady of pleasure",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "woman of the street",
+                            "inflected_form": "woman of the street",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "inamorata",
+                            "inflected_form": "inamorata",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "cat",
+                            "inflected_form": "cat",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "girl",
+                            "inflected_form": "girl",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "miss",
+                            "inflected_form": "miss",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "missy",
+                            "inflected_form": "missy",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "young lady",
+                            "inflected_form": "young lady",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "young woman",
+                            "inflected_form": "young woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "fille",
+                            "inflected_form": "fille",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "matriarch",
+                            "inflected_form": "matriarch",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "wife",
+                            "inflected_form": "wife",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "married woman",
+                            "inflected_form": "married woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "girlfriend",
+                            "inflected_form": "girlfriend",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "Cinderella",
+                            "inflected_form": "cinderella",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "bachelor girl",
+                            "inflected_form": "bachelor girl",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "bachelorette",
+                            "inflected_form": "bachelorette",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "vestal",
+                            "inflected_form": "vestal",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "widow",
+                            "inflected_form": "widow",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "widow woman",
+                            "inflected_form": "widow woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "Wave",
+                            "inflected_form": "wave",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "nymphet",
+                            "inflected_form": "nymphet",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "bluestocking",
+                            "inflected_form": "bluestocking",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "bas bleu",
+                            "inflected_form": "bas bleu",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "coquette",
+                            "inflected_form": "coquette",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "flirt",
+                            "inflected_form": "flirt",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "vamp",
+                            "inflected_form": "vamp",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "vamper",
+                            "inflected_form": "vamper",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "minx",
+                            "inflected_form": "minx",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "tease",
+                            "inflected_form": "tease",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "prickteaser",
+                            "inflected_form": "prickteaser",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "bridesmaid",
+                            "inflected_form": "bridesmaid",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "maid of honor",
+                            "inflected_form": "maid of honor",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "white woman",
+                            "inflected_form": "white woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "wonder woman",
+                            "inflected_form": "wonder woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "Wac",
+                            "inflected_form": "wac",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "mestiza",
+                            "inflected_form": "mestiza",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "nanny",
+                            "inflected_form": "nanny",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "nursemaid",
+                            "inflected_form": "nursemaid",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "nurse",
+                            "inflected_form": "nurse",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "debutante",
+                            "inflected_form": "debutante",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "deb",
+                            "inflected_form": "deb",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "dominatrix",
+                            "inflected_form": "dominatrix",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "girlfriend",
+                            "inflected_form": "girlfriend",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "girl",
+                            "inflected_form": "girl",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "lady friend",
+                            "inflected_form": "lady friend",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "unmarried woman",
+                            "inflected_form": "unmarried woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "donna",
+                            "inflected_form": "donna",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "eyeful",
+                            "inflected_form": "eyeful",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "divorcee",
+                            "inflected_form": "divorcee",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "grass widow",
+                            "inflected_form": "grass widow",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "amazon",
+                            "inflected_form": "amazon",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "virago",
+                            "inflected_form": "virago",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "lady",
+                            "inflected_form": "lady",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "maenad",
+                            "inflected_form": "maenad",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "mistress",
+                            "inflected_form": "mistress",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "kept woman",
+                            "inflected_form": "kept woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "fancy woman",
+                            "inflected_form": "fancy woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "nymph",
+                            "inflected_form": "nymph",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "houri",
+                            "inflected_form": "houri",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "geisha",
+                            "inflected_form": "geisha",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "geisha girl",
+                            "inflected_form": "geisha girl",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "matriarch",
+                            "inflected_form": "matriarch",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "materfamilias",
+                            "inflected_form": "materfamilias",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "matron",
+                            "inflected_form": "matron",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "baggage",
+                            "inflected_form": "baggage",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "broad",
+                            "inflected_form": "broad",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "girl",
+                            "inflected_form": "girl",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "enchantress",
+                            "inflected_form": "enchantress",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "temptress",
+                            "inflected_form": "temptress",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "siren",
+                            "inflected_form": "siren",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "Delilah",
+                            "inflected_form": "delilah",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "femme fatale",
+                            "inflected_form": "femme fatale",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "gravida",
+                            "inflected_form": "gravida",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "jilt",
+                            "inflected_form": "jilt",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "maenad",
+                            "inflected_form": "maenad",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "nullipara",
+                            "inflected_form": "nullipara",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "shiksa",
+                            "inflected_form": "shiksa",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "shikse",
+                            "inflected_form": "shikse",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "ex-wife",
+                            "inflected_form": "ex-wife",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "ex",
+                            "inflected_form": "ex",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "gold digger",
+                            "inflected_form": "gold digger",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "old woman",
+                            "inflected_form": "old woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "dame",
+                            "inflected_form": "dame",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "madam",
+                            "inflected_form": "madam",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "ma'am",
+                            "inflected_form": "ma'am",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "lady",
+                            "inflected_form": "lady",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "gentlewoman",
+                            "inflected_form": "gentlewoman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "sylph",
+                            "inflected_form": "sylph",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "ball-buster",
+                            "inflected_form": "ball-buster",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "ball-breaker",
+                            "inflected_form": "ball-breaker",
+                            "matches_context": false
+                        }
+                    ]
+                },
                 {
+                    "relation_type": "meronym",
                     "definition": "an adult female person (as opposed to a man)",
                     "examples": [
                         "the woman kept house while the man hunted"
                     ],
                     "wordnet_pos": "n",
-                    "synonyms": [
+                    "related_words": [
                         {
-                            "base_form": "adult female",
-                            "inflected_form": "adult female",
+                            "base_form": "adult female body",
+                            "inflected_form": "adult female body",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "woman's body",
+                            "inflected_form": "woman's body",
+                            "matches_context": false
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "antonym",
+                    "definition": "",
+                    "examples": [],
+                    "related_words": [
+                        {
+                            "base_form": "man",
+                            "inflected_form": "man",
+                            "matches_context": false
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "a female person who plays a significant role (wife or mistress or girlfriend) in the life of a particular man",
+                    "examples": [
+                        "he was faithful to his woman"
+                    ],
+                    "wordnet_pos": "n",
+                    "related_words": [
+                        {
+                            "base_form": "female",
+                            "inflected_form": "female",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "female person",
+                            "inflected_form": "female person",
                             "matches_context": false
                         }
                     ]
                 },
                 {
+                    "relation_type": "synonym",
                     "definition": "a human female employed to do housework",
                     "examples": [
                         "the char will clean the carpet",
                         "I have a woman who comes in four hours a day while I write"
                     ],
                     "wordnet_pos": "n",
-                    "synonyms": [
+                    "related_words": [
+                        {
+                            "base_form": "charwoman",
+                            "inflected_form": "charwoman",
+                            "matches_context": false
+                        },
                         {
                             "base_form": "char",
                             "inflected_form": "char",
                             "matches_context": false
                         },
                         {
-                            "base_form": "charwoman",
-                            "inflected_form": "charwoman",
+                            "base_form": "cleaning woman",
+                            "inflected_form": "cleaning woman",
                             "matches_context": false
                         },
                         {
                             "base_form": "cleaning lady",
                             "inflected_form": "cleaning lady",
                             "matches_context": false
-                        },
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "a human female employed to do housework",
+                    "examples": [
+                        "the char will clean the carpet",
+                        "I have a woman who comes in four hours a day while I write"
+                    ],
+                    "wordnet_pos": "n",
+                    "related_words": [
                         {
-                            "base_form": "cleaning woman",
-                            "inflected_form": "cleaning woman",
+                            "base_form": "cleaner",
+                            "inflected_form": "cleaner",
                             "matches_context": false
                         }
                     ]
                 },
                 {
+                    "relation_type": "synonym",
                     "definition": "women as a class",
                     "examples": [
                         "it's an insult to American womanhood",
                         "woman is the glory of creation"
                     ],
                     "wordnet_pos": "n",
-                    "synonyms": [
+                    "related_words": [
+                        {
+                            "base_form": "womanhood",
+                            "inflected_form": "womanhood",
+                            "matches_context": false
+                        },
                         {
                             "base_form": "fair sex",
                             "inflected_form": "fair sex",
                             "matches_context": false
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "women as a class",
+                    "examples": [
+                        "it's an insult to American womanhood",
+                        "woman is the glory of creation"
+                    ],
+                    "wordnet_pos": "n",
+                    "related_words": [
+                        {
+                            "base_form": "class",
+                            "inflected_form": "class",
+                            "matches_context": false
                         },
                         {
-                            "base_form": "womanhood",
-                            "inflected_form": "womanhood",
+                            "base_form": "stratum",
+                            "inflected_form": "stratum",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "social class",
+                            "inflected_form": "social class",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "socio-economic class",
+                            "inflected_form": "socio-economic class",
+                            "matches_context": false
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "holonym",
+                    "definition": "women as a class",
+                    "examples": [
+                        "it's an insult to American womanhood",
+                        "woman is the glory of creation"
+                    ],
+                    "wordnet_pos": "n",
+                    "related_words": [
+                        {
+                            "base_form": "womankind",
+                            "inflected_form": "womankind",
                             "matches_context": false
                         }
                     ]
@@ -296,5 +1702,6 @@
             }
         }
     ],
-    "message": "Got 2 synonym groups."
+    "message": "Got 2 synonym groups.",
+    "duration": 0.0003
 }

tests/events/response_thesaurus_phrase_inflated2.json

@@ -0,0 +1,1707 @@
+{
+    "success": true,
+    "original_phrase": "rather severe-looking woman",
+    "original_indices": {
+        "start": 28,
+        "end": 55
+    },
+    "results": [
+        {
+            "original_word": "looking",
+            "original_indices": {
+                "start": 14,
+                "end": 21
+            },
+            "context_info": {
+                "pos": "VERB",
+                "sentence": "Instead he was smiling at a rather severe-looking woman who was wearing square glasses exactly the shape of the markings the cat had had around its eyes.",
+                "grammatical_form": "VBG",
+                "context_words": [
+                    "at",
+                    "a",
+                    "rather",
+                    "severe",
+                    "-",
+                    "looking",
+                    "woman",
+                    "who",
+                    "was",
+                    "wearing",
+                    "square"
+                ],
+                "dependency": "amod"
+            },
+            "related_word_groups": [
+                {
+                    "relation_type": "hyponym",
+                    "definition": "perceive with attention; direct one's gaze towards",
+                    "examples": [
+                        "She looked over the expanse of land",
+                        "Look at your child!"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "goggle",
+                            "inflected_form": "goggling",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "gape",
+                            "inflected_form": "gaping",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "gawp",
+                            "inflected_form": "gawping",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "gawk",
+                            "inflected_form": "gawking",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "gloat",
+                            "inflected_form": "gloating",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "look around",
+                            "inflected_form": "looking around",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "ogle",
+                            "inflected_form": "ogling",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "give the glad eye",
+                            "inflected_form": "giving the glad eye",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "peep",
+                            "inflected_form": "peeping",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "look back",
+                            "inflected_form": "looking back",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "look backward",
+                            "inflected_form": "looking backward",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "regard",
+                            "inflected_form": "regarding",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "consider",
+                            "inflected_form": "considering",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "glance",
+                            "inflected_form": "glancing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "peek",
+                            "inflected_form": "peeking",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "glint",
+                            "inflected_form": "glinting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "eye",
+                            "inflected_form": "eyeing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "eyeball",
+                            "inflected_form": "eyeballing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "peer",
+                            "inflected_form": "peering",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "admire",
+                            "inflected_form": "admiring",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "gaze",
+                            "inflected_form": "gazing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "stare",
+                            "inflected_form": "staring",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "look away",
+                            "inflected_form": "looking away",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "leer",
+                            "inflected_form": "leering",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "give the eye",
+                            "inflected_form": "giving the eye",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "give the once over",
+                            "inflected_form": "giving the once over",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "squint",
+                            "inflected_form": "squinting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "take a look",
+                            "inflected_form": "taking a look",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "have a look",
+                            "inflected_form": "having a look",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "get a load",
+                            "inflected_form": "getting a load",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "stare",
+                            "inflected_form": "staring",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "synonym",
+                    "definition": "give a certain impression or have a certain outward aspect",
+                    "examples": [
+                        "She seems to be sleeping",
+                        "This appears to be a very difficult problem"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "appear",
+                            "inflected_form": "appearing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "seem",
+                            "inflected_form": "seeming",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "give a certain impression or have a certain outward aspect",
+                    "examples": [
+                        "She seems to be sleeping",
+                        "This appears to be a very difficult problem"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "be",
+                            "inflected_form": "being",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hyponym",
+                    "definition": "give a certain impression or have a certain outward aspect",
+                    "examples": [
+                        "She seems to be sleeping",
+                        "This appears to be a very difficult problem"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "glow",
+                            "inflected_form": "glowing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "beam",
+                            "inflected_form": "beaming",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "radiate",
+                            "inflected_form": "radiating",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "shine",
+                            "inflected_form": "shining",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "rise",
+                            "inflected_form": "rising",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "lift",
+                            "inflected_form": "lifting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "rear",
+                            "inflected_form": "rearing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "glitter",
+                            "inflected_form": "glittering",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "glisten",
+                            "inflected_form": "glistening",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "glint",
+                            "inflected_form": "glinting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "gleam",
+                            "inflected_form": "gleaming",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "shine",
+                            "inflected_form": "shining",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "leap out",
+                            "inflected_form": "leaping out",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "jump out",
+                            "inflected_form": "jumping out",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "jump",
+                            "inflected_form": "jumping",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "stand out",
+                            "inflected_form": "standing out",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "stick out",
+                            "inflected_form": "sticking out",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "make",
+                            "inflected_form": "making",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "loom",
+                            "inflected_form": "looming",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "sound",
+                            "inflected_form": "sounding",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "cut",
+                            "inflected_form": "cutting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "pass off",
+                            "inflected_form": "passing off",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "come across",
+                            "inflected_form": "coming across",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "feel",
+                            "inflected_form": "feeling",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "feel",
+                            "inflected_form": "feeling",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "have a certain outward or facial expression",
+                    "examples": [
+                        "How does she look?",
+                        "The child looks unhappy"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "be",
+                            "inflected_form": "being",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hyponym",
+                    "definition": "have a certain outward or facial expression",
+                    "examples": [
+                        "How does she look?",
+                        "The child looks unhappy"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "squint",
+                            "inflected_form": "squinting",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "synonym",
+                    "definition": "search or seek",
+                    "examples": [
+                        "We looked all day and finally found the child in the forest",
+                        "Look elsewhere for the perfect gift!"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "search",
+                            "inflected_form": "searching",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "search or seek",
+                    "examples": [
+                        "We looked all day and finally found the child in the forest",
+                        "Look elsewhere for the perfect gift!"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "examine",
+                            "inflected_form": "examining",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "see",
+                            "inflected_form": "seeing",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hyponym",
+                    "definition": "search or seek",
+                    "examples": [
+                        "We looked all day and finally found the child in the forest",
+                        "Look elsewhere for the perfect gift!"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "hunt",
+                            "inflected_form": "hunting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "cruise",
+                            "inflected_form": "cruising",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "prospect",
+                            "inflected_form": "prospecting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "intrude",
+                            "inflected_form": "intruding",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "horn in",
+                            "inflected_form": "horning in",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "pry",
+                            "inflected_form": "prying",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "nose",
+                            "inflected_form": "nosing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "poke",
+                            "inflected_form": "poking",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "synonym",
+                    "definition": "be oriented in a certain direction, often with respect to another reference point; be opposite to",
+                    "examples": [
+                        "The house looks north",
+                        "My backyard look onto the pond"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "front",
+                            "inflected_form": "fronting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "face",
+                            "inflected_form": "facing",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "antonym",
+                    "definition": "",
+                    "examples": [],
+                    "related_words": [
+                        {
+                            "base_form": "back",
+                            "inflected_form": "backing",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "be oriented in a certain direction, often with respect to another reference point; be opposite to",
+                    "examples": [
+                        "The house looks north",
+                        "My backyard look onto the pond"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "lie",
+                            "inflected_form": "lying",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hyponym",
+                    "definition": "be oriented in a certain direction, often with respect to another reference point; be opposite to",
+                    "examples": [
+                        "The house looks north",
+                        "My backyard look onto the pond"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "confront",
+                            "inflected_form": "confronting",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "synonym",
+                    "definition": "take charge of or deal with",
+                    "examples": [
+                        "Could you see about lunch?",
+                        "I must attend to this matter"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "attend",
+                            "inflected_form": "attending",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "take care",
+                            "inflected_form": "taking care",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "see",
+                            "inflected_form": "seeing",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "take charge of or deal with",
+                    "examples": [
+                        "Could you see about lunch?",
+                        "I must attend to this matter"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "care",
+                            "inflected_form": "caring",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "give care",
+                            "inflected_form": "giving care",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hyponym",
+                    "definition": "take charge of or deal with",
+                    "examples": [
+                        "Could you see about lunch?",
+                        "I must attend to this matter"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "tend",
+                            "inflected_form": "tending",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "minister",
+                            "inflected_form": "ministering",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "convey by one's expression",
+                    "examples": [
+                        "She looked her devotion to me"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "convey",
+                            "inflected_form": "conveying",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "synonym",
+                    "definition": "look forward to the probable occurrence of",
+                    "examples": [
+                        "We were expecting a visit from our relatives",
+                        "She is looking to a promotion"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "expect",
+                            "inflected_form": "expecting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "await",
+                            "inflected_form": "awaiting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "wait",
+                            "inflected_form": "waiting",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hyponym",
+                    "definition": "look forward to the probable occurrence of",
+                    "examples": [
+                        "We were expecting a visit from our relatives",
+                        "She is looking to a promotion"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "look forward",
+                            "inflected_form": "looking forward",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "anticipate",
+                            "inflected_form": "anticipating",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "look for",
+                            "inflected_form": "looking for",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "look to",
+                            "inflected_form": "looking to",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "hang on",
+                            "inflected_form": "hanging on",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "hold the line",
+                            "inflected_form": "holding the line",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "hold on",
+                            "inflected_form": "holding on",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "expect",
+                            "inflected_form": "expecting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "look to",
+                            "inflected_form": "looking to",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "accord in appearance with",
+                    "examples": [
+                        "You don't look your age!"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "match",
+                            "inflected_form": "matching",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "fit",
+                            "inflected_form": "fitting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "correspond",
+                            "inflected_form": "corresponding",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "check",
+                            "inflected_form": "checking",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "jibe",
+                            "inflected_form": "jibing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "gibe",
+                            "inflected_form": "gibing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "tally",
+                            "inflected_form": "tallying",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "agree",
+                            "inflected_form": "agreeing",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "synonym",
+                    "definition": "have faith or confidence in",
+                    "examples": [
+                        "you can count on me to help you any time",
+                        "Look to your friends for support"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "count",
+                            "inflected_form": "counting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "bet",
+                            "inflected_form": "betting",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "depend",
+                            "inflected_form": "depending",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "swear",
+                            "inflected_form": "swearing",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "rely",
+                            "inflected_form": "relying",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "bank",
+                            "inflected_form": "banking",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "calculate",
+                            "inflected_form": "calculating",
+                            "matches_context": true
+                        },
+                        {
+                            "base_form": "reckon",
+                            "inflected_form": "reckoning",
+                            "matches_context": true
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "have faith or confidence in",
+                    "examples": [
+                        "you can count on me to help you any time",
+                        "Look to your friends for support"
+                    ],
+                    "wordnet_pos": "v",
+                    "related_words": [
+                        {
+                            "base_form": "trust",
+                            "inflected_form": "trusting",
+                            "matches_context": true
+                        }
+                    ]
+                }
+            ],
+            "debug_info": {
+                "spacy_token_indices": {
+                    "start": 42,
+                    "end": 49
+                },
+                "lemma": "look"
+            }
+        },
+        {
+            "original_word": "woman",
+            "original_indices": {
+                "start": 22,
+                "end": 27
+            },
+            "context_info": {
+                "pos": "NOUN",
+                "sentence": "Instead he was smiling at a rather severe-looking woman who was wearing square glasses exactly the shape of the markings the cat had had around its eyes.",
+                "grammatical_form": "NN",
+                "context_words": [
+                    "a",
+                    "rather",
+                    "severe",
+                    "-",
+                    "looking",
+                    "woman",
+                    "who",
+                    "was",
+                    "wearing",
+                    "square",
+                    "glasses"
+                ],
+                "dependency": "pobj"
+            },
+            "related_word_groups": [
+                {
+                    "relation_type": "synonym",
+                    "definition": "an adult female person (as opposed to a man)",
+                    "examples": [
+                        "the woman kept house while the man hunted"
+                    ],
+                    "wordnet_pos": "n",
+                    "related_words": [
+                        {
+                            "base_form": "adult female",
+                            "inflected_form": "adult female",
+                            "matches_context": false
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "antonym",
+                    "definition": "",
+                    "examples": [],
+                    "related_words": [
+                        {
+                            "base_form": "man",
+                            "inflected_form": "man",
+                            "matches_context": false
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "an adult female person (as opposed to a man)",
+                    "examples": [
+                        "the woman kept house while the man hunted"
+                    ],
+                    "wordnet_pos": "n",
+                    "related_words": [
+                        {
+                            "base_form": "female",
+                            "inflected_form": "female",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "female person",
+                            "inflected_form": "female person",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "adult",
+                            "inflected_form": "adult",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "grownup",
+                            "inflected_form": "grownup",
+                            "matches_context": false
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hyponym",
+                    "definition": "an adult female person (as opposed to a man)",
+                    "examples": [
+                        "the woman kept house while the man hunted"
+                    ],
+                    "wordnet_pos": "n",
+                    "related_words": [
+                        {
+                            "base_form": "jezebel",
+                            "inflected_form": "jezebel",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "mother figure",
+                            "inflected_form": "mother figure",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "smasher",
+                            "inflected_form": "smasher",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "stunner",
+                            "inflected_form": "stunner",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "knockout",
+                            "inflected_form": "knockout",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "beauty",
+                            "inflected_form": "beauty",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "ravisher",
+                            "inflected_form": "ravisher",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "sweetheart",
+                            "inflected_form": "sweetheart",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "peach",
+                            "inflected_form": "peach",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "lulu",
+                            "inflected_form": "lulu",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "looker",
+                            "inflected_form": "looker",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "mantrap",
+                            "inflected_form": "mantrap",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "dish",
+                            "inflected_form": "dish",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "B-girl",
+                            "inflected_form": "b-girl",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "bar girl",
+                            "inflected_form": "bar girl",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "heroine",
+                            "inflected_form": "heroine",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "prostitute",
+                            "inflected_form": "prostitute",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "cocotte",
+                            "inflected_form": "cocotte",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "whore",
+                            "inflected_form": "whore",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "harlot",
+                            "inflected_form": "harlot",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "bawd",
+                            "inflected_form": "bawd",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "tart",
+                            "inflected_form": "tart",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "cyprian",
+                            "inflected_form": "cyprian",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "fancy woman",
+                            "inflected_form": "fancy woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "working girl",
+                            "inflected_form": "working girl",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "sporting lady",
+                            "inflected_form": "sporting lady",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "lady of pleasure",
+                            "inflected_form": "lady of pleasure",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "woman of the street",
+                            "inflected_form": "woman of the street",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "inamorata",
+                            "inflected_form": "inamorata",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "cat",
+                            "inflected_form": "cat",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "girl",
+                            "inflected_form": "girl",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "miss",
+                            "inflected_form": "miss",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "missy",
+                            "inflected_form": "missy",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "young lady",
+                            "inflected_form": "young lady",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "young woman",
+                            "inflected_form": "young woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "fille",
+                            "inflected_form": "fille",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "matriarch",
+                            "inflected_form": "matriarch",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "wife",
+                            "inflected_form": "wife",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "married woman",
+                            "inflected_form": "married woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "girlfriend",
+                            "inflected_form": "girlfriend",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "Cinderella",
+                            "inflected_form": "cinderella",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "bachelor girl",
+                            "inflected_form": "bachelor girl",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "bachelorette",
+                            "inflected_form": "bachelorette",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "vestal",
+                            "inflected_form": "vestal",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "widow",
+                            "inflected_form": "widow",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "widow woman",
+                            "inflected_form": "widow woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "Wave",
+                            "inflected_form": "wave",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "nymphet",
+                            "inflected_form": "nymphet",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "bluestocking",
+                            "inflected_form": "bluestocking",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "bas bleu",
+                            "inflected_form": "bas bleu",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "coquette",
+                            "inflected_form": "coquette",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "flirt",
+                            "inflected_form": "flirt",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "vamp",
+                            "inflected_form": "vamp",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "vamper",
+                            "inflected_form": "vamper",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "minx",
+                            "inflected_form": "minx",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "tease",
+                            "inflected_form": "tease",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "prickteaser",
+                            "inflected_form": "prickteaser",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "bridesmaid",
+                            "inflected_form": "bridesmaid",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "maid of honor",
+                            "inflected_form": "maid of honor",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "white woman",
+                            "inflected_form": "white woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "wonder woman",
+                            "inflected_form": "wonder woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "Wac",
+                            "inflected_form": "wac",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "mestiza",
+                            "inflected_form": "mestiza",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "nanny",
+                            "inflected_form": "nanny",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "nursemaid",
+                            "inflected_form": "nursemaid",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "nurse",
+                            "inflected_form": "nurse",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "debutante",
+                            "inflected_form": "debutante",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "deb",
+                            "inflected_form": "deb",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "dominatrix",
+                            "inflected_form": "dominatrix",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "girlfriend",
+                            "inflected_form": "girlfriend",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "girl",
+                            "inflected_form": "girl",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "lady friend",
+                            "inflected_form": "lady friend",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "unmarried woman",
+                            "inflected_form": "unmarried woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "donna",
+                            "inflected_form": "donna",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "eyeful",
+                            "inflected_form": "eyeful",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "divorcee",
+                            "inflected_form": "divorcee",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "grass widow",
+                            "inflected_form": "grass widow",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "amazon",
+                            "inflected_form": "amazon",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "virago",
+                            "inflected_form": "virago",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "lady",
+                            "inflected_form": "lady",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "maenad",
+                            "inflected_form": "maenad",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "mistress",
+                            "inflected_form": "mistress",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "kept woman",
+                            "inflected_form": "kept woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "fancy woman",
+                            "inflected_form": "fancy woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "nymph",
+                            "inflected_form": "nymph",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "houri",
+                            "inflected_form": "houri",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "geisha",
+                            "inflected_form": "geisha",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "geisha girl",
+                            "inflected_form": "geisha girl",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "matriarch",
+                            "inflected_form": "matriarch",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "materfamilias",
+                            "inflected_form": "materfamilias",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "matron",
+                            "inflected_form": "matron",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "baggage",
+                            "inflected_form": "baggage",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "broad",
+                            "inflected_form": "broad",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "girl",
+                            "inflected_form": "girl",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "enchantress",
+                            "inflected_form": "enchantress",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "temptress",
+                            "inflected_form": "temptress",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "siren",
+                            "inflected_form": "siren",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "Delilah",
+                            "inflected_form": "delilah",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "femme fatale",
+                            "inflected_form": "femme fatale",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "gravida",
+                            "inflected_form": "gravida",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "jilt",
+                            "inflected_form": "jilt",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "maenad",
+                            "inflected_form": "maenad",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "nullipara",
+                            "inflected_form": "nullipara",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "shiksa",
+                            "inflected_form": "shiksa",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "shikse",
+                            "inflected_form": "shikse",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "ex-wife",
+                            "inflected_form": "ex-wife",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "ex",
+                            "inflected_form": "ex",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "gold digger",
+                            "inflected_form": "gold digger",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "old woman",
+                            "inflected_form": "old woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "dame",
+                            "inflected_form": "dame",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "madam",
+                            "inflected_form": "madam",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "ma'am",
+                            "inflected_form": "ma'am",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "lady",
+                            "inflected_form": "lady",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "gentlewoman",
+                            "inflected_form": "gentlewoman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "sylph",
+                            "inflected_form": "sylph",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "ball-buster",
+                            "inflected_form": "ball-buster",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "ball-breaker",
+                            "inflected_form": "ball-breaker",
+                            "matches_context": false
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "meronym",
+                    "definition": "an adult female person (as opposed to a man)",
+                    "examples": [
+                        "the woman kept house while the man hunted"
+                    ],
+                    "wordnet_pos": "n",
+                    "related_words": [
+                        {
+                            "base_form": "adult female body",
+                            "inflected_form": "adult female body",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "woman's body",
+                            "inflected_form": "woman's body",
+                            "matches_context": false
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "antonym",
+                    "definition": "",
+                    "examples": [],
+                    "related_words": [
+                        {
+                            "base_form": "man",
+                            "inflected_form": "man",
+                            "matches_context": false
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "a female person who plays a significant role (wife or mistress or girlfriend) in the life of a particular man",
+                    "examples": [
+                        "he was faithful to his woman"
+                    ],
+                    "wordnet_pos": "n",
+                    "related_words": [
+                        {
+                            "base_form": "female",
+                            "inflected_form": "female",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "female person",
+                            "inflected_form": "female person",
+                            "matches_context": false
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "synonym",
+                    "definition": "a human female employed to do housework",
+                    "examples": [
+                        "the char will clean the carpet",
+                        "I have a woman who comes in four hours a day while I write"
+                    ],
+                    "wordnet_pos": "n",
+                    "related_words": [
+                        {
+                            "base_form": "charwoman",
+                            "inflected_form": "charwoman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "char",
+                            "inflected_form": "char",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "cleaning woman",
+                            "inflected_form": "cleaning woman",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "cleaning lady",
+                            "inflected_form": "cleaning lady",
+                            "matches_context": false
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "a human female employed to do housework",
+                    "examples": [
+                        "the char will clean the carpet",
+                        "I have a woman who comes in four hours a day while I write"
+                    ],
+                    "wordnet_pos": "n",
+                    "related_words": [
+                        {
+                            "base_form": "cleaner",
+                            "inflected_form": "cleaner",
+                            "matches_context": false
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "synonym",
+                    "definition": "women as a class",
+                    "examples": [
+                        "it's an insult to American womanhood",
+                        "woman is the glory of creation"
+                    ],
+                    "wordnet_pos": "n",
+                    "related_words": [
+                        {
+                            "base_form": "womanhood",
+                            "inflected_form": "womanhood",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "fair sex",
+                            "inflected_form": "fair sex",
+                            "matches_context": false
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "hypernym",
+                    "definition": "women as a class",
+                    "examples": [
+                        "it's an insult to American womanhood",
+                        "woman is the glory of creation"
+                    ],
+                    "wordnet_pos": "n",
+                    "related_words": [
+                        {
+                            "base_form": "class",
+                            "inflected_form": "class",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "stratum",
+                            "inflected_form": "stratum",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "social class",
+                            "inflected_form": "social class",
+                            "matches_context": false
+                        },
+                        {
+                            "base_form": "socio-economic class",
+                            "inflected_form": "socio-economic class",
+                            "matches_context": false
+                        }
+                    ]
+                },
+                {
+                    "relation_type": "holonym",
+                    "definition": "women as a class",
+                    "examples": [
+                        "it's an insult to American womanhood",
+                        "woman is the glory of creation"
+                    ],
+                    "wordnet_pos": "n",
+                    "related_words": [
+                        {
+                            "base_form": "womankind",
+                            "inflected_form": "womankind",
+                            "matches_context": false
+                        }
+                    ]
+                }
+            ],
+            "debug_info": {
+                "spacy_token_indices": {
+                    "start": 50,
+                    "end": 55
+                },
+                "lemma": "woman"
+            }
+        }
+    ],
+    "message": "Got 2 synonym groups.",
+    "duration": 0.0003
+}

tests/events/response_thesaurus_phrase_inflated_structure.json

@@ -0,0 +1 @@
+{"$[*]": {"types": ["array"], "primary_type": "array", "is_array": true, "samples": [], "sample_count": 0, "array_length": 2}, "$[*].context_info": {"types": ["dict"], "primary_type": "dict", "is_array": false, "samples": [], "sample_count": 0}, "$[*].context_info.context_words": {"types": ["list"], "primary_type": "list", "is_array": false, "samples": [], "sample_count": 0}, "$[*].context_info.context_words[*]": {"types": ["array"], "primary_type": "array", "is_array": true, "samples": [], "sample_count": 0, "array_length": 11}, "$[*].context_info.dependency": {"types": ["str"], "primary_type": "str", "is_array": false, "samples": ["amod", "pobj"], "sample_count": 2}, "$[*].context_info.grammatical_form": {"types": ["str"], "primary_type": "str", "is_array": false, "samples": ["VBG", "NN"], "sample_count": 2}, "$[*].context_info.pos": {"types": ["str"], "primary_type": "str", "is_array": false, "samples": ["VERB", "NOUN"], "sample_count": 2}, "$[*].context_info.sentence": {"types": ["str"], "primary_type": "str", "is_array": false, "samples": ["Instead he was smiling at a rather severe-looking woman who was wearing square glasses exactly the shape of the markings the cat had had around its eyes.", "Instead he was smiling at a rather severe-looking woman who was wearing square glasses exactly the shape of the markings the cat had had around its eyes."], "sample_count": 2}, "$[*].debug_info": {"types": ["dict"], "primary_type": "dict", "is_array": false, "samples": [], "sample_count": 0}, "$[*].debug_info.lemma": {"types": ["str"], "primary_type": "str", "is_array": false, "samples": ["look", "woman"], "sample_count": 2}, "$[*].debug_info.spacy_token_indices": {"types": ["dict"], "primary_type": "dict", "is_array": false, "samples": [], "sample_count": 0}, "$[*].debug_info.spacy_token_indices.end": {"types": ["int"], "primary_type": "int", "is_array": false, "samples": ["49", "55"], "sample_count": 2}, "$[*].debug_info.spacy_token_indices.start": {"types": ["int"], "primary_type": "int", "is_array": false, "samples": ["42", "50"], "sample_count": 2}, "$[*].original_indices": {"types": ["dict"], "primary_type": "dict", "is_array": false, "samples": [], "sample_count": 0}, "$[*].original_indices.end": {"types": ["int"], "primary_type": "int", "is_array": false, "samples": ["21", "27"], "sample_count": 2}, "$[*].original_indices.start": {"types": ["int"], "primary_type": "int", "is_array": false, "samples": ["14", "22"], "sample_count": 2}, "$[*].original_word": {"types": ["str"], "primary_type": "str", "is_array": false, "samples": ["looking", "woman"], "sample_count": 2}, "$[*].related_word_groups": {"types": ["list"], "primary_type": "list", "is_array": false, "samples": [], "sample_count": 0}, "$[*].related_word_groups[*]": {"types": ["array"], "primary_type": "array", "is_array": true, "samples": [], "sample_count": 0, "array_length": 12}, "$[*].related_word_groups[*].definition": {"types": ["str"], "primary_type": "str", "is_array": false, "samples": ["perceive with attention; direct one's gaze towards", "give a certain impression or have a certain outward aspect", "give a certain impression or have a certain outward aspect"], "sample_count": 3}, "$[*].related_word_groups[*].examples": {"types": ["list"], "primary_type": "list", "is_array": false, "samples": [], "sample_count": 0}, "$[*].related_word_groups[*].examples[*]": {"types": ["array"], "primary_type": "array", "is_array": true, "samples": [], "sample_count": 0, "array_length": 2}, "$[*].related_word_groups[*].related_words": {"types": ["list"], "primary_type": "list", "is_array": false, "samples": [], "sample_count": 0}, "$[*].related_word_groups[*].related_words[*]": {"types": ["array"], "primary_type": "array", "is_array": true, "samples": [], "sample_count": 0, "array_length": 1}, "$[*].related_word_groups[*].related_words[*].base_form": {"types": ["str"], "primary_type": "str", "is_array": false, "samples": ["look away", "admire", "gaze"], "sample_count": 3}, "$[*].related_word_groups[*].related_words[*].inflected_form": {"types": ["str"], "primary_type": "str", "is_array": false, "samples": ["looking away", "admiring", "gazing"], "sample_count": 3}, "$[*].related_word_groups[*].related_words[*].matches_context": {"types": ["bool"], "primary_type": "bool", "is_array": false, "samples": ["True", "True", "True"], "sample_count": 3}, "$[*].related_word_groups[*].relation_type": {"types": ["str"], "primary_type": "str", "is_array": false, "samples": ["hyponym", "synonym", "hypernym"], "sample_count": 3}, "$[*].related_word_groups[*].wordnet_pos": {"types": ["str"], "primary_type": "str", "is_array": false, "samples": ["v", "v", "v"], "sample_count": 3}}

tests/my_ghost_writer/helpers_tests.py

@@ -0,0 +1,10 @@
+
+
+def analyze_detailed_report_lists(cls, detailed_report: dict, expected_detailed_report: dict):
+    for (row_k, row_v), (expected_row_k, expected_row_v) in zip(detailed_report.items(), expected_detailed_report.items()):
+        cls.assertEqual(row_k, expected_row_k)
+        del row_v["samples"]
+        del expected_row_v["samples"]
+        del row_v["sample_count"]
+        del expected_row_v["sample_count"]
+        cls.assertDictEqual(row_v, expected_row_v)

tests/my_ghost_writer/test_app.py

@@ -12,6 +12,9 @@ from my_ghost_writer import __version__ as version_module
 from my_ghost_writer.app import app, mongo_health_check_background_task, lifespan
 from my_ghost_writer.constants import app_logger
 from tests import EVENTS_FOLDER
+from my_ghost_writer.jsonpath_comparator import JSONPathComparator
+from my_ghost_writer.jsonpath_extractor import JSONPathStructureAnalyzer
+from tests.my_ghost_writer.helpers_tests import analyze_detailed_report_lists
 
 
 class TestVersion(unittest.TestCase):
@@ -210,11 +213,12 @@ class TestAppEndpoints(unittest.TestCase):
     # --- /thesaurus-inflated-phrase Endpoint ---
     def test_get_synonyms_for_phrase_success(self):
         """Tests the success case for /thesaurus-inflated-phrase."""
-        # Load the expected response from JSON file
         import json
-        with open(EVENTS_FOLDER / "response_thesaurus_phrase_inflated.json", "r") as f:
-            expected_response = json.load(f)
-
+        with open(EVENTS_FOLDER / "response_thesaurus_phrase_inflated.json", "r") as src:
+            expected_response = json.load(src)
+        with open(EVENTS_FOLDER / "response_thesaurus_phrase_inflated_structure.json", "r") as src:
+            expected_detailed_report = json.load(src)
+        self.maxDiff = None
         body = {
             "word": "rather severe-looking woman",
             "text": "Instead he was smiling at a rather severe-looking woman who was wearing square glasses exactly the shape of the markings the cat had had around its eyes.",
@@ -223,13 +227,32 @@ class TestAppEndpoints(unittest.TestCase):
         }
         response = self.client.post("/thesaurus-inflated-phrase", json=body)
         self.assertEqual(response.status_code, 200)
-        json_response = response.json()
-        self.assertEqual(json_response["success"], expected_response["success"])
-        self.assertEqual(json_response["original_phrase"], expected_response["original_phrase"])
-        self.assertEqual(json_response["original_indices"], expected_response["original_indices"])
-        self.assertEqual(json_response["message"], expected_response["message"])
+        response_json = response.json()
+        duration = response_json["duration"]
+        self.assertIsInstance(duration, float)
+        self.assertGreater(duration, 0)
+        del response_json["duration"]
+        del expected_response["duration"]
+        app_logger.info(f"response_json.keys():{response_json.keys()}.")
+        self.assertEqual(response_json["success"], expected_response["success"])
+        self.assertEqual(response_json["original_phrase"], expected_response["original_phrase"])
+        self.assertEqual(response_json["original_indices"], expected_response["original_indices"])
+        self.assertEqual(response_json["message"], expected_response["message"])
         # check only the first result
-        self.assertEqual(json_response["results"][0], expected_response["results"][0])
+        comparator = JSONPathComparator()
+        comparison = comparator.compare_structures(response_json["results"], expected_response["results"])
+        assert comparison is not None
+        added = comparison.get('added_paths')
+        removed = comparison.get("removed_paths")
+        self.assertEqual(added, set())
+        self.assertEqual(removed, set())
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(response_json["results"])
+        detailed_report = analyzer.get_detailed_type_report()
+        analyze_detailed_report_lists(self, detailed_report, expected_detailed_report)
+
+        # with open(EVENTS_FOLDER / "response_thesaurus_phrase_inflated_structure.json", "w") as src:
+        #     json.dump(detailed_report, src)
 
     def test_get_synonyms_for_phrase_no_synonyms(self):
         """Tests the case where no synonyms are found for the phrase."""
@@ -240,8 +263,13 @@ class TestAppEndpoints(unittest.TestCase):
             "end": 18
         }
         response = self.client.post("/thesaurus-inflated-phrase", json=body)
+        response_json = response.json()
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.json(), {
+        duration = response_json["duration"]
+        self.assertIsInstance(duration, float)
+        self.assertGreater(duration, 0)
+        del response_json["duration"]
+        self.assertEqual(response_json, {
             "success": True,
             "original_phrase": "some phrase",
             "original_indices": {
@@ -262,9 +290,17 @@ class TestAppEndpoints(unittest.TestCase):
         }
         response = self.client.post("/thesaurus-inflated-phrase", json=body)
         self.assertEqual(response.status_code, 200)
+        response_json = response.json()
+        duration = response_json["duration"]
+        self.assertIsInstance(duration, float)
+        self.assertGreater(duration, 0)
+        del response_json["duration"]
         self.assertDictEqual(
-            response.json(),
-            {'message': 'No words with synonyms found in the selected phrase.', 'original_indices': {'end': 18, 'start': 20}, 'original_phrase': 'some phrase', 'results': [], 'success': True}
+            response_json,
+            {
+                'success': True, 'original_phrase': 'some phrase', 'original_indices': {'start': 20, 'end': 18},
+                'results': [], 'message': 'No words with synonyms found in the selected phrase.'
+            }
         )
 
     def test_get_synonyms_for_phrase_error_validation(self):

tests/my_ghost_writer/test_custom_synonym_handler.py

@@ -1,16 +1,20 @@
 import unittest
 
 from my_ghost_writer.custom_synonym_handler import CustomSynonymHandler
+from my_ghost_writer.type_hints import RelatedEntry, TermRelationships
 
 
 class TestCustomSynonymHandler(unittest.TestCase):
     def test_custom_synonym_handler_add_entry_ok1(self):
         word_input = "happy"
-        related_input = [
-            {'definition': 'definition of happy', 'type': 'synonym', 'words': ['joy', 'cheer']},
-            {'definition': 'definition of sad', 'type': 'antonym', 'words': ['sad', 'sadness']},
-            {'definition': 'another definition of happy', 'type': 'synonym', 'words': ['content', 'cheerful', 'joyful']}
-        ]
+        related_input = []
+        for rel in [
+                    {'definition': 'definition of happy', 'type': 'synonym', 'words': ['joy', 'cheer']},
+                    {'definition': 'definition of sad', 'type': 'antonym', 'words': ['sad', 'sadness']},
+                    {'definition': 'another definition of happy', 'type': 'synonym', 'words': ['content', 'cheerful', 'joyful']}
+                ]:
+            tmp = RelatedEntry(**rel)
+            related_input.append(tmp)
         test_custom_synonym_handler = CustomSynonymHandler()
         self.assertEqual(test_custom_synonym_handler.inverted_index, {})
         self.assertEqual(test_custom_synonym_handler.lexicon, {})
@@ -48,16 +52,16 @@ class TestCustomSynonymHandler(unittest.TestCase):
         self.assertEqual(test_custom_synonym_handler.lexicon, expected_lexicon)
         self.assertEqual(test_custom_synonym_handler.inverted_index, expected_inverted_index)
 
-        synonyms_related = test_custom_synonym_handler.get_related("happy", "synonym")
+        synonyms_related = test_custom_synonym_handler.get_related("happy", TermRelationships.SYNONYM)
         self.assertListEqual(synonyms_related, [
             {'definition': 'definition of happy', 'words': ['joy', 'cheer']},
             {'definition': 'another definition of happy', 'words': ['content', 'cheerful', 'joyful']}
         ])
-        antonyms_related = test_custom_synonym_handler.get_related("happy", "antonym")
+        antonyms_related = test_custom_synonym_handler.get_related("happy", TermRelationships.ANTONYM)
         self.assertListEqual(antonyms_related, [{'definition': 'definition of sad', 'words': ['sad', 'sadness']}])
 
         test_custom_synonym_handler.add_entry("text", [
-            {'definition': 'definition of text', 'type': 'synonym', 'words': ['word', 'sentence']}
+            RelatedEntry(**{'definition': 'definition of text', 'type': 'synonym', 'words': ['word', 'sentence']})
         ])
         self.assertEqual(test_custom_synonym_handler.lexicon, {
             **{"text": {'synonym': [{'definition': 'definition of text', 'words': ['word', 'sentence']}]}},

tests/my_ghost_writer/test_extract_jsonpaths.py

@@ -0,0 +1,1440 @@
+import unittest
+import json
+
+from my_ghost_writer.constants import app_logger
+from my_ghost_writer.jsonpath_comparator import (compare_json_with_jsonpath, compare_json_with_jsonpath_and_types,
+    JSONPathComparator, extract_structure_paths, extract_structure_paths_with_types)
+from my_ghost_writer.jsonpath_extractor import (JSONPathStructureAnalyzer, analyze_with_jsonpath_detailed,
+    analyze_with_jsonpath_types, analyze_with_jsonpath, compare_json_with_jsonpath_structures, analyze_dict_list_simple)
+
+
+old_json = {
+    "key1": "row 1",
+    "key2": 22,
+    "key_nested1": {
+        "key_nested2": "row 3",
+        "key_nested3": "row 4",
+        "array_nested_4": [
+            "row 5",
+            "row 6",
+            "row 7 nested",
+            {
+                "key_nested4": "row 8",
+                "array_nested_5": ["row 9", "row 10"]
+            }
+        ]
+    }
+}
+
+new_json = {
+    "key1": "row 1",
+    "key2": 22,
+    "key_nested1": {
+        "key_nested2": "row 3",
+        "key_nested3": "row 4",
+        "array_changed_4": [
+            "row 5",
+            "row changed 6",
+            "row 7 nested",
+            {
+                "last_change": "row 8",
+                "array_nested_5": ["row 9", "row 10"]
+            }
+        ]
+    }
+}
+
+
+class TestJSONPathStructureAnalyzer(unittest.TestCase):
+    """
+    Test JSONPath structure analysis with the provided nested JSON data
+    """
+    
+    def test_get_paths_with_types_basic(self):
+        """
+        Test get_paths_with_types with basic data types
+        """
+        test_data = {
+            "string_field": "hello",
+            "int_field": 42,
+            "float_field": 3.14,
+            "bool_field": True,
+            "null_field": None
+        }
+        
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(test_data)
+        paths_with_types = analyzer.get_paths_with_types()
+        
+        # Verify basic types
+        self.assertEqual(paths_with_types["$.string_field"], "str")
+        self.assertEqual(paths_with_types["$.int_field"], "int")
+        self.assertEqual(paths_with_types["$.float_field"], "float")
+        self.assertEqual(paths_with_types["$.bool_field"], "bool")
+        self.assertEqual(paths_with_types["$.null_field"], "NoneType")
+    
+    def test_get_paths_with_types_arrays(self):
+        """
+        Test get_paths_with_types with arrays
+        """
+        test_data = {
+            "simple_array": [1, 2, 3],
+            "empty_array": [],
+            "mixed_array": ["string", 42, True],
+            "nested_array": [[1, 2], [3, 4]]
+        }
+        
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(test_data)
+        paths_with_types = analyzer.get_paths_with_types()
+
+        self.assertEqual(paths_with_types["$.simple_array[*]"], "array")
+        self.assertEqual(paths_with_types["$.empty_array[*]"], "array")
+        self.assertEqual(paths_with_types["$.mixed_array[*]"], "array")
+        self.assertEqual(paths_with_types["$.nested_array[*]"], "array")
+    
+    def test_get_paths_with_types_with_old_json(self):
+        """
+        Test get_paths_with_types with the old_json test data
+        """
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(old_json)
+        paths_with_types = analyzer.get_paths_with_types()
+        
+        # Test specific paths from old_json
+        self.assertEqual(paths_with_types["$.key1"], "str")
+        self.assertEqual(paths_with_types["$.key2"], "int")
+        self.assertEqual(paths_with_types["$.key_nested1"], "dict")
+        self.assertEqual(paths_with_types["$.key_nested1.array_nested_4[*]"], "array")
+        self.assertEqual(paths_with_types["$.key_nested1.key_nested2"], "str")
+        
+        # Verify all expected paths are present
+        expected_paths = [
+            "$.key1", "$.key2", "$.key_nested1",
+            "$.key_nested1.key_nested2", "$.key_nested1.key_nested3",
+            "$.key_nested1.array_nested_4[*]"
+        ]
+        
+        for path in expected_paths:
+            self.assertIn(path, paths_with_types, f"Path {path} should be in paths_with_types")
+    
+    def test_get_detailed_type_report_basic(self):
+        """
+        Test get_detailed_type_report with basic data
+        """
+        test_data = {
+            "test_field": "sample_value",
+            "array_field": [1, 2, 3]
+        }
+        
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(test_data)
+        detailed_report = analyzer.get_detailed_type_report()
+        
+        # Test structure of the detailed report
+        self.assertIn("$.test_field", detailed_report)
+        self.assertIn("$.array_field[*]", detailed_report)
+        
+        # Test field details
+        field_info = detailed_report["$.test_field"]
+        self.assertIn("types", field_info)
+        self.assertIn("primary_type", field_info)
+        self.assertIn("is_array", field_info)
+        self.assertIn("samples", field_info)
+        self.assertIn("sample_count", field_info)
+        
+        # Verify field values
+        self.assertEqual(field_info["primary_type"], "str")
+        self.assertFalse(field_info["is_array"])
+        self.assertIn("sample_value", field_info["samples"])
+        self.assertGreater(field_info["sample_count"], 0)
+        
+        # Test array field details
+        array_info = detailed_report["$.array_field[*]"]
+        self.assertTrue(array_info["is_array"])
+        self.assertEqual(array_info["primary_type"], "array")
+        self.assertEqual(array_info['array_length'], 3)
+    
+    def test_get_detailed_type_report_with_old_json(self):
+        """
+        Test get_detailed_type_report with old_json data
+        """
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(old_json)
+        detailed_report = analyzer.get_detailed_type_report()
+        
+        # Test specific fields from old_json
+        key1_info = detailed_report["$.key1"]
+        self.assertEqual(key1_info["primary_type"], "str")
+        self.assertFalse(key1_info["is_array"])
+        self.assertIn("row 1", key1_info["samples"])
+        
+        key2_info = detailed_report["$.key2"]
+        self.assertEqual(key2_info["primary_type"], "int")
+        self.assertFalse(key2_info["is_array"])
+        self.assertIn("22", key2_info["samples"])
+        
+        # Test array field
+        array_info = detailed_report["$.key_nested1.array_nested_4[*]"]
+        self.assertTrue(array_info["is_array"])
+        self.assertEqual(array_info["primary_type"], "array")
+        self.assertEqual(array_info["array_length"], 4)
+    
+    def test_get_detailed_type_report_mixed_types(self):
+        """
+        Test get_detailed_type_report with mixed types (hypothetical case)
+        """
+        # Create a scenario where a path might have mixed types
+        analyzer = JSONPathStructureAnalyzer()
+        
+        # Manually add mixed type data to test the logic
+        analyzer.paths.add("$.mixed_field")
+        analyzer.types["$.mixed_field"].add("str")
+        analyzer.types["$.mixed_field"].add("int")
+        analyzer.samples["$.mixed_field"] = ["hello", "42"]
+        
+        detailed_report = analyzer.get_detailed_type_report()
+        
+        mixed_info = detailed_report["$.mixed_field"]
+        self.assertIn("mixed(", mixed_info["primary_type"])
+        self.assertFalse(mixed_info["is_array"])
+        self.assertEqual(len(mixed_info["types"]), 2)
+    
+    def test_analyze_with_jsonpath_types_function(self):
+        """
+        Test the convenience function analyze_with_jsonpath_types
+        """
+        test_data = {
+            "name": "test",
+            "count": 5,
+            "items": ["a", "b", "c"]
+        }
+        
+        paths_with_types = analyze_with_jsonpath_types(test_data)
+        
+        # Verify function returns expected structure
+        self.assertIsInstance(paths_with_types, dict)
+        self.assertIn("$.name", paths_with_types)
+        self.assertIn("$.count", paths_with_types)
+        self.assertIn("$.items[*]", paths_with_types)
+        
+        # Verify types
+        self.assertEqual(paths_with_types["$.name"], "str")
+        self.assertEqual(paths_with_types["$.count"], "int")
+        self.assertEqual(paths_with_types["$.items[*]"], "array")
+    
+    def test_analyze_with_jsonpath_detailed_function(self):
+        """
+        Test the convenience function analyze_with_jsonpath_detailed
+        """
+        test_data = {
+            "description": "test description",
+            "tags": ["tag1", "tag2"]
+        }
+        
+        detailed_info = analyze_with_jsonpath_detailed(test_data)
+        
+        # Verify function returns expected structure
+        self.assertIsInstance(detailed_info, dict)
+        self.assertIn("$.description", detailed_info)
+        self.assertIn("$.tags[*]", detailed_info)
+        
+        # Verify detailed structure
+        desc_info = detailed_info["$.description"]
+        self.assertIn("types", desc_info)
+        self.assertIn("primary_type", desc_info)
+        self.assertIn("samples", desc_info)
+        self.assertEqual(desc_info["primary_type"], "str")
+        
+        tags_info = detailed_info["$.tags[*]"]
+        self.assertTrue(tags_info["is_array"])
+        self.assertEqual(tags_info["primary_type"], "array")
+        self.assertEqual(tags_info["array_length"], 2)
+    
+    def test_get_paths_with_types_empty_data(self):
+        """
+        Test get_paths_with_types with empty data
+        """
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths({})
+        paths_with_types = analyzer.get_paths_with_types()
+        
+        # Should return empty dict for empty input
+        self.assertEqual(len(paths_with_types), 0)
+    
+    def test_get_detailed_type_report_empty_data(self):
+        """
+        Test get_detailed_type_report with empty data
+        """
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths({})
+        detailed_report = analyzer.get_detailed_type_report()
+        
+        # Should return empty dict for empty input
+        self.assertEqual(len(detailed_report), 0)
+    
+    def test_paths_with_types_comparison_old_vs_new(self):
+        """
+        Test comparing paths with types between old and new JSON
+        """
+        analyzer_old = JSONPathStructureAnalyzer()
+        analyzer_old.extract_all_paths(old_json)
+        old_paths_with_types = analyzer_old.get_paths_with_types()
+        
+        analyzer_new = JSONPathStructureAnalyzer()
+        analyzer_new.extract_all_paths(new_json)
+        new_paths_with_types = analyzer_new.get_paths_with_types()
+        
+        # Find differences
+        old_only = set(old_paths_with_types.keys()) - set(new_paths_with_types.keys())
+        new_only = set(new_paths_with_types.keys()) - set(old_paths_with_types.keys())
+        common = set(old_paths_with_types.keys()) & set(new_paths_with_types.keys())
+        
+        # Verify expected differences
+        self.assertIn("$.key_nested1.array_nested_4[*]", old_only)
+        self.assertIn("$.key_nested1.array_changed_4[*]", new_only)
+        
+        # Verify common paths have same types
+        for path in common:
+            self.assertEqual(old_paths_with_types[path], new_paths_with_types[path],
+                           f"Type mismatch for common path {path}")
+    
+    def test_detailed_report_comparison_old_vs_new(self):
+        """
+        Test comparing detailed reports between old and new JSON
+        """
+        old_detailed = analyze_with_jsonpath_detailed(old_json)
+        new_detailed = analyze_with_jsonpath_detailed(new_json)
+        
+        # Check that common fields have consistent detailed info
+        common_paths = set(old_detailed.keys()) & set(new_detailed.keys())
+        
+        for path in common_paths:
+            old_info = old_detailed[path]
+            new_info = new_detailed[path]
+            
+            # Primary types should match for common paths
+            self.assertEqual(old_info["primary_type"], new_info["primary_type"],
+                           f"Primary type mismatch for {path}")
+            
+            # Array status should match
+            self.assertEqual(old_info["is_array"], new_info["is_array"],
+                           f"Array status mismatch for {path}")
+    
+    def test_integration_all_new_methods(self):
+        """
+        Integration test using all new methods together
+        """
+        test_data = {
+            "user": {
+                "name": "John Doe",
+                "age": 30,
+                "hobbies": ["reading", "coding", "gaming"],
+                "profile": {
+                    "active": True,
+                    "settings": {
+                        "theme": "dark",
+                        "notifications": False
+                    }
+                }
+            }
+        }
+        
+        # Test all three approaches
+        structure_report = analyze_with_jsonpath(test_data)
+        paths_with_types = analyze_with_jsonpath_types(test_data)
+        detailed_info = analyze_with_jsonpath_detailed(test_data)
+        
+        # Verify all methods found the same paths
+        report_paths = set()
+        for line in structure_report.split('\n'):
+            if ' -- ' in line:
+                path = line.split(' -- ')[0]
+                report_paths.add(path)
+        
+        types_paths = set(paths_with_types.keys())
+        detailed_paths = set(detailed_info.keys())
+        
+        # All methods should find the same paths
+        self.assertEqual(report_paths, types_paths)
+        self.assertEqual(types_paths, detailed_paths)
+        
+        # Verify specific expected paths exist
+        expected_paths = [
+            "$.user",
+            "$.user.name",
+            "$.user.age", 
+            "$.user.hobbies[*]",
+            "$.user.profile",
+            "$.user.profile.active",
+            "$.user.profile.settings",
+            "$.user.profile.settings.theme",
+            "$.user.profile.settings.notifications"
+        ]
+        
+        for path in expected_paths:
+            self.assertIn(path, types_paths, f"Path {path} should be found by all methods")
+            self.assertIn(path, detailed_paths, f"Path {path} should be in detailed info")
+    
+    def test_type_consistency_across_methods(self):
+        """
+        Test that type information is consistent across different methods
+        """
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(old_json)
+        
+        # Get data using different methods
+        # structure_report = analyzer.get_structure_report()
+        paths_with_types = analyzer.get_paths_with_types()
+        detailed_report = analyzer.get_detailed_type_report()
+        
+        # For each path, verify consistency
+        for path in paths_with_types:
+            # Detailed report should have the same primary type
+            if path in detailed_report:
+                detailed_type = detailed_report[path]["primary_type"]
+                simple_type = paths_with_types[path]
+                
+                # They should match (detailed might have more info for mixed types)
+                if not detailed_type.startswith("mixed("):
+                    self.assertEqual(simple_type, detailed_type,
+                                   f"Type inconsistency for {path}: {simple_type} vs {detailed_type}")
+    
+    def test_extract_all_paths_from_old_structure(self):
+        """
+        Test that analyzer correctly extracts all paths from the old JSON structure
+        """
+        analyzer = JSONPathStructureAnalyzer()
+        paths = analyzer.extract_all_paths(old_json)
+        
+        # Verify the top-level paths
+        self.assertIn("$.key1", paths)
+        self.assertIn("$.key2", paths)
+        self.assertIn("$.key_nested1", paths)
+        
+        # Verify the nested object paths
+        self.assertIn("$.key_nested1.key_nested2", paths)
+        self.assertIn("$.key_nested1.key_nested3", paths)
+        self.assertIn("$.key_nested1.array_nested_4[*]", paths)
+        
+        # Verify the deeply nested paths (3-4 levels deep)
+        self.assertIn("$.key_nested1.array_nested_4[*].key_nested4", paths)
+        self.assertIn("$.key_nested1.array_nested_4[*].array_nested_5[*]", paths)
+    
+    def test_extract_all_paths_from_new_structure(self):
+        """
+        Test that analyzer correctly extracts paths from the new JSON structure
+        """
+        analyzer = JSONPathStructureAnalyzer()
+        paths = analyzer.extract_all_paths(new_json)
+        
+        # Verify renamed the array path
+        self.assertIn("$.key_nested1.array_changed_4[*]", paths)
+        
+        # Verify renamed the nested key
+        self.assertIn("$.key_nested1.array_changed_4[*].last_change", paths)
+        
+        # Verify unchanged the nested array
+        self.assertIn("$.key_nested1.array_changed_4[*].array_nested_5[*]", paths)
+    
+    def test_structure_report_format_old_json(self):
+        """
+        Test structure report format for old JSON
+        """
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(old_json)
+        report = analyzer.get_structure_report()
+        
+        # Check specific format elements
+        self.assertIn("$.key1 -- row 1", report)
+        self.assertIn("$.key2 -- 22", report)
+        self.assertIn("$.key_nested1.array_nested_4[*] -- array[4]", report)
+        self.assertIn("$.key_nested1.array_nested_4[*].key_nested4 -- row 8", report)
+        self.assertIn("$.key_nested1.array_nested_4[*].array_nested_5[*] -- array[2]", report)
+    
+    def test_structure_report_format_new_json(self):
+        """
+        Test structure report format for new JSON
+        """
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(new_json)
+        report = analyzer.get_structure_report()
+        
+        # Check renamed elements appear correctly
+        self.assertIn("$.key_nested1.array_changed_4[*] -- array[4]", report)
+        self.assertIn("$.key_nested1.array_changed_4[*].last_change -- row 8", report)
+        
+        # Check unchanged elements
+        self.assertIn("$.key1 -- row 1", report)
+        self.assertIn("$.key2 -- 22", report)
+    
+    def test_analyze_with_jsonpath_function(self):
+        """
+        Test the convenience function for structure analysis
+        """
+        old_report = analyze_with_jsonpath(old_json)
+        new_report = analyze_with_jsonpath(new_json)
+        
+        # Verify both reports are valid strings
+        self.assertIsInstance(old_report, str)
+        self.assertGreater(len(old_report), 0)
+        self.assertIsInstance(new_report, str)
+        self.assertGreater(len(new_report), 0)
+        
+        # Verify key differences
+        self.assertIn("array_nested_4", old_report)
+        self.assertIn("array_changed_4", new_report)
+        self.assertIn("key_nested4", old_report)
+        self.assertIn("last_change", new_report)
+
+    def test_compare_json_structures_method(self):
+        """
+        Test the compare_json_structures method directly
+        """
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(old_json)
+
+        comparison = analyzer.compare_json_structures(new_json)
+
+        # Test all expected keys within the comparison result
+        expected_keys = [
+            "added_paths", "removed_paths", "common_paths",
+            "type_changes", "value_differences", "array_size_changes",
+            "array_lengths_old", "array_lengths_new", "summary"
+        ]
+
+        for key in expected_keys:
+            self.assertIn(key, comparison, f"Key {key} should be in comparison result")
+
+        # Test summary statistics
+        summary = comparison["summary"]
+        self.assertGreater(summary["total_paths_old"], 0)
+        self.assertGreater(summary["total_paths_new"], 0)
+        self.assertGreater(summary["paths_removed"], 0)
+        self.assertGreater(summary["paths_added"], 0)
+
+        # Test array length tracking
+        self.assertIn("$.key_nested1.array_nested_4[*]", comparison["array_lengths_old"])
+        self.assertIn("$.key_nested1.array_changed_4[*]", comparison["array_lengths_new"])
+        self.assertEqual(comparison["array_lengths_old"]["$.key_nested1.array_nested_4[*]"], 4)
+        self.assertEqual(comparison["array_lengths_new"]["$.key_nested1.array_changed_4[*]"], 4)
+
+    def test_get_array_lengths_method(self):
+        """
+        Test the get_array_lengths method
+        """
+        test_data = {
+            "empty_array": [],
+            "small_array": [1, 2],
+            "large_array": list(range(100)),
+            "nested": {
+                "inner_array": ["a", "b", "c", "d", "e"]
+            }
+        }
+
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(test_data)
+        array_lengths = analyzer.get_array_lengths()
+
+        # Test all array lengths are captured
+        self.assertEqual(array_lengths["$.empty_array[*]"], 0)
+        self.assertEqual(array_lengths["$.small_array[*]"], 2)
+        self.assertEqual(array_lengths["$.large_array[*]"], 100)
+        self.assertEqual(array_lengths["$.nested.inner_array[*]"], 5)
+
+        # Test that non-array paths are not in array_lengths
+        for path in array_lengths.keys():
+            self.assertTrue(path.endswith("[*]"), f"Array length path {path} should end with [*]")
+
+    def test_value_differences_detection(self):
+        """
+        Test detection of value changes in compare_json_structures
+        """
+        old_data = {
+            "name": "John",
+            "age": 25,
+            "city": "New York"
+        }
+
+        new_data = {
+            "name": "John",  # unchanged
+            "age": 26,  # changed
+            "city": "Boston"  # changed
+        }
+
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(old_data)
+        comparison = analyzer.compare_json_structures(new_data)
+
+        # Should detect value changes
+        self.assertIn("$.age", comparison["value_differences"])
+        self.assertIn("$.city", comparison["value_differences"])
+        self.assertNotIn("$.name", comparison["value_differences"])
+
+        # Test change details
+        age_change = comparison["value_differences"]["$.age"]
+        self.assertEqual(age_change["old_value"], "25")
+        self.assertEqual(age_change["new_value"], "26")
+
+        city_change = comparison["value_differences"]["$.city"]
+        self.assertEqual(city_change["old_value"], "New York")
+        self.assertEqual(city_change["new_value"], "Boston")
+
+    def test_array_size_changes_detection(self):
+        """
+        Test detection of array size changes
+        """
+        old_data = {
+            "items": [1, 2, 3],
+            "tags": ["a", "b"]
+        }
+
+        new_data = {
+            "items": [1, 2, 3, 4, 5],  # size increased
+            "tags": ["a"]  # size decreased
+        }
+
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(old_data)
+        comparison = analyzer.compare_json_structures(new_data)
+
+        # Should detect array size changes
+        self.assertIn("$.items[*]", comparison["array_size_changes"])
+        self.assertIn("$.tags[*]", comparison["array_size_changes"])
+
+        # Test size change details
+        items_change = comparison["array_size_changes"]["$.items[*]"]
+        self.assertEqual(items_change["old_size"], 3)
+        self.assertEqual(items_change["new_size"], 5)
+        self.assertEqual(items_change["size_change"], 2)
+
+        tags_change = comparison["array_size_changes"]["$.tags[*]"]
+        self.assertEqual(tags_change["old_size"], 2)
+        self.assertEqual(tags_change["new_size"], 1)
+        self.assertEqual(tags_change["size_change"], -1)
+
+    def test_compare_json_with_jsonpath_structures_function(self):
+        """
+        Test the compare_json_with_jsonpath_structures convenience function
+        """
+        # Test with print_report=False
+        comparison = compare_json_with_jsonpath_structures(old_json, new_json, print_report=False)
+
+        # Should return the same structure as the method
+        self.assertIn("summary", comparison)
+        self.assertIn("added_paths", comparison)
+        self.assertIn("removed_paths", comparison)
+
+        # Test that it works without printing (no exception thrown)
+        self.assertIsInstance(comparison, dict)
+
+        # Test specific changes
+        self.assertIn("$.key_nested1.array_nested_4[*]", comparison["removed_paths"])
+        self.assertIn("$.key_nested1.array_changed_4[*]", comparison["added_paths"])
+
+    def test_nested_arrays_length_tracking(self):
+        """
+        Test array length tracking for deeply nested arrays
+        """
+        test_data = {
+            "level1": [
+                {"level2": [1, 2, 3]},
+                {"level2": [4, 5]},
+                {"level2": [6, 7, 8, 9]}
+            ]
+        }
+
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(test_data)
+        array_lengths = analyzer.get_array_lengths()
+
+        # Should track both levels of arrays
+        self.assertIn("$.level1[*]", array_lengths)
+        self.assertIn("$.level1[*].level2[*]", array_lengths)
+
+        # Check lengths
+        self.assertEqual(array_lengths["$.level1[*]"], 3)
+        # Note: The nested array length will be from the last item processed (current implementation)
+        self.assertEqual(array_lengths["$.level1[*].level2[*]"], 4)
+
+    def test_type_changes_detection_in_comparison(self):
+        """
+        Test detection of type changes in compare_json_structures
+        """
+        old_data = {
+            "field1": "string_value",
+            "field2": 42,
+            "field3": [1, 2, 3]
+        }
+
+        new_data = {
+            "field1": 123,
+            "field2": 42,
+            "field3": "not_array"
+        }
+
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(old_data)
+        comparison = analyzer.compare_json_structures(new_data)
+
+        # Should detect type changes
+        self.assertIn("$.field1", comparison["type_changes"])
+        self.assertIn("$.field3", comparison["type_changes"])
+        self.assertNotIn("$.field2", comparison["type_changes"])
+
+        # Test change details
+        field1_change = comparison["type_changes"]["$.field1"]
+        self.assertEqual(field1_change["old_type"], "str")
+        self.assertEqual(field1_change["new_type"], "int")
+
+        field3_change = comparison["type_changes"]["$.field3"]
+        self.assertEqual(field3_change["new_type"], "str")
+        # This will check the type and expect a list
+        self.assertEqual(field3_change["old_type"], "list")
+
+    def test_analyze_dict_list_simple(self):
+        """
+        Test analyze_dict_list_simple function with a list of dictionaries
+        """
+        dict_list = [
+            {
+                "user": "john",
+                "age": 25,
+                "tags": ["admin", "user"]
+            },
+            {
+                "user": "jane",
+                "age": 30,
+                "tags": ["user"],
+                "active": True
+            },
+            {
+                "user": "bob",
+                "score": 95.5,
+                "tags": ["guest", "temp", "new"]
+            }
+        ]
+
+        # Test the function
+        results = analyze_dict_list_simple(dict_list)
+
+        # Basic structure tests
+        self.assertEqual(len(results), 3)
+        self.assertIsInstance(results, list)
+
+        # Test each result has expected keys
+        for i, result in enumerate(results):
+            self.assertEqual(result["index"], i)
+            self.assertIn("paths_with_types", result)
+            self.assertIn("detailed_report", result)
+            self.assertIn("array_lengths", result)
+            self.assertIn("structure_report", result)
+
+        # Test first dict analysis
+        first_result = results[0]
+        self.assertIn("$.user", first_result["paths_with_types"])
+        self.assertIn("$.age", first_result["paths_with_types"])
+        self.assertIn("$.tags[*]", first_result["paths_with_types"])
+        self.assertEqual(first_result["paths_with_types"]["$.user"], "str")
+        self.assertEqual(first_result["paths_with_types"]["$.age"], "int")
+        self.assertEqual(first_result["paths_with_types"]["$.tags[*]"], "array")
+        self.assertEqual(first_result["array_lengths"]["$.tags[*]"], 2)
+
+        # Test second dict has additional field
+        second_result = results[1]
+        self.assertIn("$.active", second_result["paths_with_types"])
+        self.assertEqual(second_result["paths_with_types"]["$.active"], "bool")
+        self.assertEqual(second_result["array_lengths"]["$.tags[*]"], 1)
+
+        # Test third dict differences
+        third_result = results[2]
+        self.assertIn("$.score", third_result["paths_with_types"])
+        self.assertNotIn("$.age", third_result["paths_with_types"])  # age missing in third dict
+        self.assertEqual(third_result["paths_with_types"]["$.score"], "float")
+        self.assertEqual(third_result["array_lengths"]["$.tags[*]"], 3)
+
+        # Test structure reports are strings
+        for result in results:
+            self.assertIsInstance(result["structure_report"], str)
+            self.assertGreater(len(result["structure_report"]), 0)
+
+        # Test detailed reports have proper structure
+        for result in results:
+            detailed = result["detailed_report"]
+            for path, info in detailed.items():
+                self.assertIn("types", info)
+                self.assertIn("primary_type", info)
+                self.assertIn("is_array", info)
+                self.assertIn("samples", info)
+                self.assertIn("sample_count", info)
+
+    def test_filter_paths_excluding_keys(self):
+        """
+        Test filtering paths to exclude specific keys
+        """
+        test_data = {
+            'definition': 'enjoying or showing or marked by joy or pleasure',
+            'examples': ['a happy smile', 'spent many happy days on the beach'],
+            'related_words': [{'base_form': 'euphoric'}, {'base_form': 'elated'}],
+            'relation_type': 'also_see',
+            'source': 'wordnet',
+            'wordnet_pos': 'a'
+        }
+
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(test_data)
+
+        # Test without exclusion
+        all_paths = analyzer.paths
+        self.assertIn("$.examples[*]", all_paths)
+        self.assertIn("$.definition", all_paths)
+
+        # Test with exclusion
+        filtered_paths = analyzer.filter_paths_excluding_keys({'examples'})
+        self.assertNotIn("$.examples[*]", filtered_paths)
+        self.assertIn("$.definition", filtered_paths)
+        self.assertIn("$.related_words[*]", filtered_paths)
+        self.assertIn("$.related_words[*].base_form", filtered_paths)
+
+        # Test excluding multiple keys
+        filtered_paths_multi = analyzer.filter_paths_excluding_keys({'examples', 'source'})
+        self.assertNotIn("$.examples[*]", filtered_paths_multi)
+        self.assertNotIn("$.source", filtered_paths_multi)
+        self.assertIn("$.definition", filtered_paths_multi)
+
+
+    def test_get_filtered_structure_report(self):
+        """
+        Test filtered structure report generation
+        """
+        test_data = {
+            'definition': 'test definition',
+            'examples': ['example1', 'example2'],
+            'metadata': {'source': 'test', 'version': 1},
+            'tags': ['tag1', 'tag2', 'tag3']
+        }
+
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(test_data)
+
+        # Test filtered report
+        filtered_report = analyzer.get_filtered_structure_report({'examples'})
+
+        # Should not contain examples
+        self.assertNotIn("examples", filtered_report)
+
+        # Should contain other fields
+        self.assertIn("$.definition", filtered_report)
+        self.assertIn("$.metadata", filtered_report)
+        self.assertIn("$.tags[*]", filtered_report)
+
+        # Test structure
+        lines = filtered_report.split('\n')
+        self.assertGreater(len(lines), 0)
+
+        # Verify specific content
+        self.assertIn("$.definition -- test definition", filtered_report)
+        self.assertIn("$.tags[*] -- array[3]", filtered_report)
+
+    def test_get_filtered_paths_with_types(self):
+        """
+        Test filtered paths with types
+        """
+        test_data = {
+            'name': 'test',
+            'count': 42,
+            'items': [1, 2, 3],
+            'exclude_me': {'nested': 'value'}
+        }
+
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(test_data)
+
+        # Test filtered paths with types
+        filtered_paths_types = analyzer.get_filtered_paths_with_types({'exclude_me'})
+
+        # Should not contain excluded paths
+        self.assertNotIn("$.exclude_me", filtered_paths_types)
+        self.assertNotIn("$.exclude_me.nested", filtered_paths_types)
+
+        # Should contain other paths
+        self.assertIn("$.name", filtered_paths_types)
+        self.assertIn("$.count", filtered_paths_types)
+        self.assertIn("$.items[*]", filtered_paths_types)
+
+        # Test types
+        self.assertEqual(filtered_paths_types["$.name"], "str")
+        self.assertEqual(filtered_paths_types["$.count"], "int")
+        self.assertEqual(filtered_paths_types["$.items[*]"], "array")
+
+    def test_get_filtered_detailed_type_report(self):
+        """
+        Test filtered detailed type report
+        """
+        test_data = {
+            'title': 'Sample Title',
+            'description': 'Sample Description',
+            'private_data': {'secret': 'hidden'},
+            'public_list': ['item1', 'item2']
+        }
+
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(test_data)
+
+        # Test filtered detailed report
+        filtered_detailed = analyzer.get_filtered_detailed_type_report({'private_data'})
+
+        # Should not contain excluded paths
+        self.assertNotIn("$.private_data", filtered_detailed)
+        self.assertNotIn("$.private_data.secret", filtered_detailed)
+
+        # Should contain other paths
+        self.assertIn("$.title", filtered_detailed)
+        self.assertIn("$.public_list[*]", filtered_detailed)
+
+        # Test structure of remaining items
+        title_info = filtered_detailed["$.title"]
+        self.assertEqual(title_info["primary_type"], "str")
+        self.assertFalse(title_info["is_array"])
+        self.assertIn("Sample Title", title_info["samples"])
+
+        list_info = filtered_detailed["$.public_list[*]"]
+        self.assertEqual(list_info["primary_type"], "array")
+        self.assertTrue(list_info["is_array"])
+        self.assertEqual(list_info["array_length"], 2)
+
+    def test_analyze_dict_list_simple_with_exclusion(self):
+        """
+        Test analyze_dict_list_simple with key exclusion
+        """
+        dict_list = [
+            {
+                "name": "John",
+                "age": 25,
+                "private_info": {"ssn": "123-45-6789"},
+                "tags": ["user", "admin"]
+            },
+            {
+                "name": "Jane",
+                "age": 30,
+                "private_info": {"ssn": "987-65-4321"},
+                "tags": ["user"],
+                "active": True
+            }
+        ]
+
+        # Test with exclusion
+        results = analyze_dict_list_simple(dict_list, exclude_keys={'private_info'})
+
+        # Basic structure tests
+        self.assertEqual(len(results), 2)
+
+        # Test that private_info is excluded from all results
+        for result in results:
+            paths_with_types = result["paths_with_types"]
+            detailed_report = result["detailed_report"]
+
+            # Should not contain private_info paths
+            private_paths = [path for path in paths_with_types.keys() if 'private_info' in path]
+            self.assertEqual(len(private_paths), 0, "private_info paths should be excluded")
+
+            private_detailed = [path for path in detailed_report.keys() if 'private_info' in path]
+            self.assertEqual(len(private_detailed), 0, "private_info should be excluded from detailed report")
+
+            # Should contain other paths
+            self.assertIn("$.name", paths_with_types)
+            self.assertIn("$.age", paths_with_types)
+            self.assertIn("$.tags[*]", paths_with_types)
+
+        # Test second dict has additional field (but not private_info)
+        second_result = results[1]
+        self.assertIn("$.active", second_result["paths_with_types"])
+        self.assertEqual(second_result["paths_with_types"]["$.active"], "bool")
+
+        # Test structure reports don't contain excluded keys
+        for result in results:
+            structure_report = result["structure_report"]
+            self.assertNotIn("private_info", structure_report)
+            self.assertIn("$.name", structure_report)
+
+    def test_exclusion_with_nested_arrays(self):
+        """
+        Test exclusion works with nested arrays and complex structures
+        """
+        test_data = {
+            "valid_data": {
+                "items": [
+                    {"id": 1, "name": "item1"},
+                    {"id": 2, "name": "item2"}
+                ]
+            },
+            "sensitive_data": {
+                "secrets": [
+                    {"key": "secret1", "value": "hidden1"},
+                    {"key": "secret2", "value": "hidden2"}
+                ]
+            }
+        }
+
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(test_data)
+
+        # Test exclusion of nested structure
+        filtered_paths = analyzer.filter_paths_excluding_keys({'sensitive_data'})
+
+        # Should exclude all sensitive_data paths
+        sensitive_paths = [path for path in analyzer.paths if 'sensitive_data' in path]
+        self.assertGreater(len(sensitive_paths), 0, "Should have sensitive_data paths in original")
+
+        for sensitive_path in sensitive_paths:
+            self.assertNotIn(sensitive_path, filtered_paths, f"Should exclude {sensitive_path}")
+
+        # Should keep valid_data paths
+        self.assertIn("$.valid_data", filtered_paths)
+        self.assertIn("$.valid_data.items[*]", filtered_paths)
+        self.assertIn("$.valid_data.items[*].id", filtered_paths)
+        self.assertIn("$.valid_data.items[*].name", filtered_paths)
+
+
+class TestJSONPathComparator(unittest.TestCase):
+    """
+    Test JSONPath structure comparison functionality
+    """
+    
+    def test_extract_structure_paths_comparison(self):
+        """
+        Test extraction of structure paths from both JSON structures
+        """
+        old_paths = extract_structure_paths(old_json)
+        new_paths = extract_structure_paths(new_json)
+        
+        # Verify we get a reasonable number of paths
+        self.assertGreaterEqual(len(old_paths), 7)
+        self.assertGreaterEqual(len(new_paths), 7)
+        
+        # Verify specific differences
+        self.assertIn("$.key_nested1.array_nested_4[*]", old_paths)
+        self.assertIn("$.key_nested1.array_changed_4[*]", new_paths)
+        self.assertIn("$.key_nested1.array_nested_4[*].key_nested4", old_paths)
+        self.assertIn("$.key_nested1.array_changed_4[*].last_change", new_paths)
+    
+    def test_extract_structure_paths_with_types(self):
+        """
+        Test extraction of structure paths with type information
+        """
+        old_paths_with_types = extract_structure_paths_with_types(old_json)
+        new_paths_with_types = extract_structure_paths_with_types(new_json)
+        
+        # Verify we get type information
+        self.assertEqual(old_paths_with_types["$.key1"], "string")
+        self.assertEqual(old_paths_with_types["$.key2"], "integer")
+        self.assertEqual(old_paths_with_types["$.key_nested1"], "object")
+        
+        # Check the actual array field, not the [*] path
+        self.assertIn("array", old_paths_with_types["$.key_nested1.array_nested_4"])
+        
+        # The [*] path represents the type of array elements (first element)
+        self.assertEqual(old_paths_with_types["$.key_nested1.array_nested_4[*]"], "string")
+        
+        # Verify type differences between old and new
+        self.assertIn("$.key_nested1.array_nested_4", old_paths_with_types)
+        self.assertIn("$.key_nested1.array_changed_4", new_paths_with_types)
+        self.assertNotIn("$.key_nested1.array_nested_4", new_paths_with_types)
+    
+    def test_compare_structures_array_rename(self):
+        """
+        Test comparison detects array field rename
+        """
+        comparator = JSONPathComparator()
+        comparison = comparator.compare_structures(old_json, new_json)
+        
+        # Should detect removed paths (old structure)
+        self.assertIn("$.key_nested1.array_nested_4[*]", comparison["removed_paths"])
+        self.assertIn("$.key_nested1.array_nested_4[*].key_nested4", comparison["removed_paths"])
+        
+        # Should detect added paths (new structure)
+        self.assertIn("$.key_nested1.array_changed_4[*]", comparison["added_paths"])
+        self.assertIn("$.key_nested1.array_changed_4[*].last_change", comparison["added_paths"])
+    
+    def test_compare_structures_with_types(self):
+        """
+        Test comparison with type information
+        """
+        comparator = JSONPathComparator()
+        comparison = comparator.compare_structures_with_types(old_json, new_json)
+        
+        # Should detect added paths with types
+        self.assertIn("$.key_nested1.array_changed_4", comparison["added_paths"])
+        
+        # Check for the actual existing paths in the comparison
+        # The deeply nested paths might not be included in the type comparison
+        if "$.key_nested1.array_changed_4[*].last_change" in comparison["added_paths"]:
+            self.assertIn("string", comparison["added_paths"]["$.key_nested1.array_changed_4[*].last_change"])
+        
+        # Should detect removed paths with types
+        self.assertIn("$.key_nested1.array_nested_4", comparison["removed_paths"])
+        
+        # Should detect common paths with types
+        self.assertIn("$.key1", comparison["common_paths"])
+        self.assertEqual(comparison["common_paths"]["$.key1"], "string")
+        
+        # Should not detect type changes for this example (same types, different paths)
+        self.assertEqual(len(comparison["type_changes"]), 0)
+    
+    def test_type_changes_detection(self):
+        """
+        Test detection of type changes in paths
+        """
+        # Create test data with type changes
+        json_with_string = {"test_field": "hello"}
+        json_with_number = {"test_field": 42}
+        
+        comparator = JSONPathComparator()
+        comparison = comparator.compare_structures_with_types(json_with_string, json_with_number)
+        
+        # Should detect type change
+        self.assertIn("$.test_field", comparison["type_changes"])
+        self.assertEqual(comparison["type_changes"]["$.test_field"]["old_type"], "string")
+        self.assertEqual(comparison["type_changes"]["$.test_field"]["new_type"], "integer")
+    
+    def test_compare_structures_unchanged_paths(self):
+        """
+        Test that unchanged paths are correctly identified
+        """
+        comparator = JSONPathComparator()
+        comparison = comparator.compare_structures(old_json, new_json)
+        
+        # These paths should remain unchanged
+        unchanged_paths = [
+            "$.key1",
+            "$.key2", 
+            "$.key_nested1",
+            "$.key_nested1.key_nested2",
+            "$.key_nested1.key_nested3"
+        ]
+        
+        for path in unchanged_paths:
+            self.assertIn(path, comparison["common_paths"], f"Path {path} should be in common paths")
+            self.assertNotIn(path, comparison["added_paths"], f"Path {path} should not be added")
+            self.assertNotIn(path, comparison["removed_paths"], f"Path {path} should not be removed")
+    
+    def test_compare_structures_nested_array_preserved(self):
+        """
+        Test the deeply nested array structure is preserved despite parent changes
+        """
+        comparator = JSONPathComparator()
+        comparison = comparator.compare_structures(old_json, new_json)
+        
+        # The nested array should exist in both (though path changed due to parent rename)
+        old_nested_array = "$.key_nested1.array_nested_4[*].array_nested_5[*]"
+        new_nested_array = "$.key_nested1.array_changed_4[*].array_nested_5[*]"
+        
+        self.assertIn(old_nested_array, comparison["removed_paths"])
+        self.assertIn(new_nested_array, comparison["added_paths"])
+    
+    def test_path_validations_with_specific_paths(self):
+        """
+        Test validation of specific paths between old and new structures
+        """
+        common_paths = [
+            "$.key1",  # Should exist in both
+            "$.key2",  # Should exist in both
+            "$.key_nested1.array_nested_4[*]",  # Exists only in old
+            "$.key_nested1.array_changed_4[*]",  # Exists only in new
+            "$.key_nested1.key_nested2"  # Should exist in both
+        ]
+        
+        comparator = JSONPathComparator(common_paths)
+        comparison = comparator.compare_structures(old_json, new_json)
+        
+        validations = comparison["path_validations"]
+        
+        # Test paths that exist in both
+        self.assertEqual(validations["$.key1"]["status"], "✅")
+        self.assertTrue(validations["$.key1"]["old_found"])
+        self.assertTrue(validations["$.key1"]["new_found"])
+        
+        # Test paths that exist only in old
+        self.assertEqual(validations["$.key_nested1.array_nested_4[*]"]["status"], "❌")
+        self.assertTrue(validations["$.key_nested1.array_nested_4[*]"]["old_found"])
+        self.assertFalse(validations["$.key_nested1.array_nested_4[*]"]["new_found"])
+        
+        # Test paths that exist only in new
+        self.assertEqual(validations["$.key_nested1.array_changed_4[*]"]["status"], "❌")
+        self.assertFalse(validations["$.key_nested1.array_changed_4[*]"]["old_found"])
+        self.assertTrue(validations["$.key_nested1.array_changed_4[*]"]["new_found"])
+
+
+class TestJSONPathIntegration(unittest.TestCase):
+    """
+    Integration tests for the complete JSONPath diff workflow
+    """
+    
+    def test_complete_diff_workflow(self):
+        """
+        Test the complete workflow from analysis to comparison using the provided data
+        """
+        # Step 1: Analyze the old structure
+        old_report = analyze_with_jsonpath(old_json)
+        self.assertIn("$.key_nested1.array_nested_4[*].key_nested4", old_report)
+        
+        # Step 2: Analyze the new structure
+        new_report = analyze_with_jsonpath(new_json)
+        self.assertIn("$.key_nested1.array_changed_4[*].last_change", new_report)
+        
+        # Step 3: Compare structures
+        critical_paths = [
+            "$.key1",
+            "$.key2",
+            "$.key_nested1.key_nested2",
+            "$.key_nested1.key_nested3"
+        ]
+        
+        comparison = compare_json_with_jsonpath(old_json, new_json, critical_paths)
+        
+        # Verify comparison results
+        self.assertIsInstance(comparison, dict)
+        self.assertGreater(len(comparison["added_paths"]), 0)
+        self.assertGreater(len(comparison["removed_paths"]), 0)
+        self.assertGreater(len(comparison["common_paths"]), 0)
+    
+    def test_complete_diff_workflow_with_types(self):
+        """
+        Test the complete workflow with type information
+        """
+        # Step 1: Compare structures with types
+        critical_paths = [
+            "$.key1",
+            "$.key2",
+            "$.key_nested1.key_nested2"
+        ]
+        
+        comparison = compare_json_with_jsonpath_and_types(old_json, new_json, critical_paths)
+        
+        # Verify comparison results include type information
+        self.assertIsInstance(comparison, dict)
+        self.assertIn("added_paths", comparison)
+        self.assertIn("removed_paths", comparison)
+        self.assertIn("type_changes", comparison)
+        
+        # Verify type information is included
+        if comparison["added_paths"]:
+            for path, type_info in comparison["added_paths"].items():
+                self.assertIsInstance(type_info, str)
+                self.assertGreater(len(type_info), 0)
+    
+    def test_detect_specific_changes(self):
+        """
+        Test detection of the specific changes between old and new JSON
+        """
+        comparison = compare_json_with_jsonpath(old_json, new_json)
+        
+        # Key changes that should be detected:
+        # 1. array_nested_4 -> array_changed_4
+        # 2. key_nested4 -> last_change
+        
+        expected_removed = [
+            "$.key_nested1.array_nested_4[*]",
+            "$.key_nested1.array_nested_4[*].key_nested4"
+        ]
+        
+        expected_added = [
+            "$.key_nested1.array_changed_4[*]", 
+            "$.key_nested1.array_changed_4[*].last_change"
+        ]
+        
+        for path in expected_removed:
+            self.assertIn(path, comparison["removed_paths"], f"Expected removed path {path} not found")
+        
+        for path in expected_added:
+            self.assertIn(path, comparison["added_paths"], f"Expected added path {path} not found")
+    
+    def test_structure_variations_old(self):
+        """
+        Test that old JSON structure contains expected array name
+        """
+        analyzer = JSONPathStructureAnalyzer()
+        paths = analyzer.extract_all_paths(old_json)
+        
+        expected_path = "$.key_nested1.array_nested_4[*]"
+        self.assertIn(expected_path, paths, f"Expected path {expected_path} not found")
+    
+    def test_structure_variations_new(self):
+        """
+        Test that new JSON structure contains expected array name
+        """
+        analyzer = JSONPathStructureAnalyzer()
+        paths = analyzer.extract_all_paths(new_json)
+        
+        expected_path = "$.key_nested1.array_changed_4[*]"
+        self.assertIn(expected_path, paths, f"Expected path {expected_path} not found")
+    
+    def test_json_string_compatibility(self):
+        """
+        Test that the tools work with JSON strings (serialized/deserialized)
+        """
+        # Convert to JSON string and back
+        old_string = json.dumps(old_json)
+        new_string = json.dumps(new_json)
+        
+        old_parsed = json.loads(old_string)
+        new_parsed = json.loads(new_string)
+        
+        # Should work the same as with dict objects
+        comparison = compare_json_with_jsonpath(old_parsed, new_parsed)
+        
+        self.assertIn("$.key_nested1.array_nested_4[*]", comparison["removed_paths"])
+        self.assertIn("$.key_nested1.array_changed_4[*]", comparison["added_paths"])
+
+
+class TestEdgeCases(unittest.TestCase):
+    """
+    Test edge cases with the provided data structure
+    """
+    
+    def test_empty_json_comparison(self):
+        """
+        Test comparison with empty JSON
+        """
+        empty_json = {}
+        
+        comparison = compare_json_with_jsonpath(old_json, empty_json)
+        
+        # All old paths should be removed
+        self.assertGreater(len(comparison["removed_paths"]), 0)
+        self.assertEqual(len(comparison["added_paths"]), 0)
+        self.assertEqual(len(comparison["common_paths"]), 0)
+    
+    def test_empty_json_comparison_with_types(self):
+        """
+        Test comparison with empty JSON including types
+        """
+        empty_json = {}
+        
+        comparison = compare_json_with_jsonpath_and_types(old_json, empty_json)
+        
+        # All old paths should be removed with type info
+        self.assertGreater(len(comparison["removed_paths"]), 0)
+        self.assertEqual(len(comparison["added_paths"]), 0)
+        
+        # Empty JSON still has the root path "$" in common
+        # The comparison includes the root "$" path in both structures
+        self.assertLessEqual(len(comparison["common_paths"]), 1)
+        
+        # Verify type information is preserved
+        for path, type_info in comparison["removed_paths"].items():
+            self.assertIsInstance(type_info, str)
+    
+    def test_identical_json_comparison(self):
+        """
+        Test comparison of identical JSON structures
+        """
+        comparison = compare_json_with_jsonpath(old_json, old_json)
+        
+        # Should have no changes
+        self.assertEqual(len(comparison["added_paths"]), 0)
+        self.assertEqual(len(comparison["removed_paths"]), 0)
+        self.assertGreater(len(comparison["common_paths"]), 0)
+    
+    def test_identical_json_comparison_with_types(self):
+        """
+        Test comparison of identical JSON structures with types
+        """
+        comparison = compare_json_with_jsonpath_and_types(old_json, old_json)
+        
+        # Should have no changes
+        self.assertEqual(len(comparison["added_paths"]), 0)
+        self.assertEqual(len(comparison["removed_paths"]), 0)
+        self.assertEqual(len(comparison["type_changes"]), 0)
+        self.assertGreater(len(comparison["common_paths"]), 0)
+    
+    def test_deep_nested_array_analysis(self):
+        """
+        Test analysis of the deepest nested array (array_nested_5)
+        """
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(old_json)
+        report = analyzer.get_structure_report()
+        
+        # Should properly analyze the deeply nested array
+        self.assertIn("$.key_nested1.array_nested_4[*].array_nested_5[*] -- array[2]", report)
+
+    def test_array_type_detection(self):
+        """
+        Test proper detection of array types in extract_structure_paths_with_types
+        """
+        paths_with_types = extract_structure_paths_with_types(old_json)
+
+        # Test array type detection on the actual array field, not the [*] path
+        # The array field itself should have "array" in its type
+        self.assertIn("array", paths_with_types["$.key_nested1.array_nested_4"])
+        # The [*] path represents the type of array elements (the first element is a string)
+        self.assertEqual(paths_with_types["$.key_nested1.array_nested_4[*]"], "string")
+
+
+class TestSimpleUsageExamples(unittest.TestCase):
+    """
+    Simple examples showing how to use the JSONPath diff tool
+    """
+    
+    def test_basic_structure_analysis_old(self):
+        """
+        Analyze the structure of the old JSON
+        """
+        report = analyze_with_jsonpath(old_json)
+        app_logger.info("\nOLD JSON STRUCTURE:")
+        app_logger.info(report)
+        
+        # Basic assertions
+        self.assertIn("$.key1 -- row 1", report)
+        self.assertIn("$.key2 -- 22", report)
+        self.assertIn("array_nested_4", report)
+        self.assertIn("key_nested4", report)
+    
+    def test_basic_structure_analysis_new(self):
+        """
+        Analyze the structure of the new JSON
+        """
+        report = analyze_with_jsonpath(new_json)
+        app_logger.info("\nNEW JSON STRUCTURE:")
+        app_logger.info(report)
+        
+        # Basic assertions
+        self.assertIn("$.key1 -- row 1", report)
+        self.assertIn("$.key2 -- 22", report)
+        self.assertIn("array_changed_4", report)
+        self.assertIn("last_change", report)
+    
+    def test_basic_comparison(self):
+        """
+        Compare old versus new JSON structures
+        """
+        app_logger.info("\nCOMPARISON RESULTS:")
+        comparison = compare_json_with_jsonpath(old_json, new_json)
+        
+        # Verify the main changes
+        self.assertIn("$.key_nested1.array_nested_4[*]", comparison["removed_paths"])
+        self.assertIn("$.key_nested1.array_changed_4[*]", comparison["added_paths"])
+        
+        # Verify unchanged elements
+        self.assertIn("$.key1", comparison["common_paths"])
+        self.assertIn("$.key2", comparison["common_paths"])
+    
+    def test_basic_comparison_with_types(self):
+        """
+        Compare old versus new JSON structures with type information
+        """
+        app_logger.info("\nCOMPARISON RESULTS WITH TYPES:")
+        comparison = compare_json_with_jsonpath_and_types(old_json, new_json)
+        
+        # Verify the main changes with types
+        self.assertIn("$.key_nested1.array_nested_4", comparison["removed_paths"])
+        self.assertIn("$.key_nested1.array_changed_4", comparison["added_paths"])
+        
+        # Verify type information is included
+        self.assertEqual(comparison["common_paths"]["$.key1"], "string")
+        self.assertEqual(comparison["common_paths"]["$.key2"], "integer")
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/my_ghost_writer/test_text_parsers2.py

@@ -1,3 +1,4 @@
+import json
 import unittest
 from unittest.mock import patch, MagicMock
 
@@ -5,6 +6,11 @@ from fastapi import HTTPException
 
 from my_ghost_writer.text_parsers2 import (extract_contextual_info_by_indices, get_wordnet_synonyms, inflect_synonym,
     is_nlp_available, process_synonym_groups)
+from my_ghost_writer.jsonpath_comparator import JSONPathComparator
+from my_ghost_writer.jsonpath_extractor import JSONPathStructureAnalyzer, analyze_dict_list_simple
+from my_ghost_writer.type_hints import TermRelationships
+from tests import EVENTS_FOLDER
+from tests.my_ghost_writer.helpers_tests import analyze_detailed_report_lists
 
 
 class TestTextParsers2(unittest.TestCase):
@@ -77,42 +83,45 @@ class TestTextParsers2(unittest.TestCase):
 
     def test_get_wordnet_synonyms(self):
         # Test with a word that has known synonyms
+        with open(EVENTS_FOLDER / "get_wordnet_synonyms_piano_ok1.json", "r") as src:
+            expected_detailed_report = json.load(src)
         word = "piano"
-        synonyms = get_wordnet_synonyms(word)
+        related_words = get_wordnet_synonyms(word)
+        first_related_words = related_words[0]
+        analyzer = JSONPathStructureAnalyzer()
+        analyzer.extract_all_paths(first_related_words)
+        detailed_report = analyzer.get_detailed_type_report()
+        analyze_detailed_report_lists(self, detailed_report, expected_detailed_report)
 
-        self.assertGreater(len(synonyms), 0)
-        first_result = synonyms[0]
-        self.assertIsInstance(first_result, dict)
-        self.assertIn('definition', first_result)
-        self.assertIn('examples', first_result)
-        self.assertIn('pos', first_result)
-        self.assertIn('synonyms', first_result)
-        self.assertIsInstance(first_result['synonyms'], list)
+        # with open(EVENTS_FOLDER / "get_wordnet_synonyms_piano_ok1.json", "w") as src:
+        #     json.dump(detailed_report, src)
 
     def test_get_wordnet_synonyms_custom_entry(self):
         word = "happy"
         pos = "ADJ"
-        synonyms_list = get_wordnet_synonyms(word, pos)
-        for synonym_by_sense in synonyms_list:
-            self.assertIsInstance(synonym_by_sense, dict)
-            self.assertIsInstance(synonym_by_sense["definition"], str)
-            self.assertEqual(synonym_by_sense["pos"], pos)
-            self.assertIsInstance(synonym_by_sense["examples"], list)
-            synonyms = synonym_by_sense["synonyms"]
-            for synonym_dict in synonyms:
-                self.assertIsInstance(synonym_dict, dict)
-                self.assertIsInstance(synonym_dict["definition"], str)
-                self.assertIsInstance(synonym_dict["synonym"], str)
-                self.assertIsInstance(synonym_dict["is_custom"], bool)
+        with open(EVENTS_FOLDER / "get_wordnet_synonyms_custom_entry_happy.json", "r") as src:
+            expected_report_dict_list = json.load(src)
+        # expected_detailed_report = []
+        related_word_groups = get_wordnet_synonyms(word, pos)
+        self.assertIsInstance(related_word_groups[0]["examples"], list)
+        for related_word_nth, expected_detailed_report_nth in zip(related_word_groups, expected_report_dict_list):
+            del related_word_nth['examples']
+            analyzer = JSONPathStructureAnalyzer()
+            analyzer.extract_all_paths(related_word_nth)
+            detailed_report = analyzer.get_detailed_type_report(get_samples=False)
+            self.assertDictEqual(detailed_report, expected_detailed_report_nth)
+            # expected_detailed_report.append(detailed_report)
+        # with open(EVENTS_FOLDER / "get_wordnet_synonyms_custom_entry_happy.json", "w") as src:
+        #     json.dump(expected_detailed_report, src)
 
     def test_get_wordnet_synonyms_pos_filter(self):
         # Test with POS filtering
         word = "hunt"
-        synonyms_verbs = get_wordnet_synonyms(word, pos_tag="VERB")
+        related_words_verbs = get_wordnet_synonyms(word, pos_tag="VERB")
 
-        self.assertGreater(len(synonyms_verbs), 0)
-        for sense in synonyms_verbs:
-            self.assertEqual(sense['pos'], 'v')  # 'v' is the WordNet tag for VERB
+        self.assertGreater(len(related_words_verbs), 0)
+        for sense in related_words_verbs:
+            self.assertEqual(sense['wordnet_pos'], 'v')  # 'v' is the WordNet tag for VERB
 
     @patch("my_ghost_writer.text_parsers2.wn.synsets")
     def test_get_wordnet_synonyms_generic_exception(self, mock_synsets):
@@ -122,7 +131,7 @@ class TestTextParsers2(unittest.TestCase):
 
         # 400 Exception intercepted and relaunched as 500
         self.assertEqual(context.exception.status_code, 500)
-        self.assertIn("Error retrieving synonyms: test exception", context.exception.detail)
+        self.assertIn("Error retrieving related words: 'test exception'", context.exception.detail)
 
     def test_inflect_synonym_noun_plural(self):
         # Test noun pluralization
@@ -263,11 +272,11 @@ class TestTextParsers2(unittest.TestCase):
         self.assertIsInstance(result, list)
         self.assertGreater(len(result), 0)
 
-        first_sense = result[0]
+        first_sense = dict(result[0])
         self.assertIn('definition', first_sense)
-        self.assertIn('synonyms', first_sense)
+        self.assertIn('related_words', first_sense)
 
-        first_synonym_info = first_sense['synonyms'][0]
+        first_synonym_info = dict(first_sense['related_words'][0])
         self.assertIn('base_form', first_synonym_info)
         self.assertIn('inflected_form', first_synonym_info)
         # For a past-tense verb, the inflected form should be different from the base
@@ -283,19 +292,24 @@ class TestTextParsers2(unittest.TestCase):
             'original_indices': {'end': 60, 'start': 55}, 'pos': 'ADJ', 'sentence_position': 9,
             'tag': 'JJ', 'word': 'happy'
         }
-        result_synonym_groups_list = process_synonym_groups(word, context_info)
-        self.assertIsInstance(result_synonym_groups_list, list)
-        for expected_synonym_group in result_synonym_groups_list:
-            self.assertIsInstance(expected_synonym_group, dict)
-            self.assertIsInstance(expected_synonym_group["definition"], str)
-            self.assertEqual(expected_synonym_group["wordnet_pos"], context_info["pos"])
-            self.assertIsInstance(expected_synonym_group["examples"], list)
-            synonyms = expected_synonym_group["synonyms"]
-            for synonym_dict in synonyms:
-                self.assertIsInstance(synonym_dict, dict)
-                self.assertIsInstance(synonym_dict["base_form"], str)
-                self.assertIsInstance(synonym_dict["inflected_form"], str)
-                self.assertIsInstance(synonym_dict["matches_context"], bool)
+        # RelatedWordGroup
+        result_related_word_groups_list = process_synonym_groups(word, context_info)
+        self.assertIsInstance(result_related_word_groups_list, list)
+        for related_words_group in result_related_word_groups_list:
+            related_word_group_dict = dict(related_words_group)
+            self.assertIsInstance(related_word_group_dict, dict)
+            self.assertIsInstance(related_word_group_dict["definition"], str)
+            self.assertIn("relation_type", related_word_group_dict)
+            self.assertIn(related_word_group_dict["relation_type"], TermRelationships)
+            self.assertIsInstance(related_word_group_dict["examples"], list)
+            related_words = related_word_group_dict["related_words"]
+            for _word_dict in related_words:
+                word_dict = dict(_word_dict)
+                self.assertIsInstance(word_dict, dict)
+                self.assertIsInstance(word_dict["base_form"], str)
+                self.assertIsInstance(word_dict["inflected_form"], str)
+                self.assertIsInstance(word_dict["matches_context"], bool)
+                self.assertIn("is_custom", word_dict)
 
     @patch("my_ghost_writer.text_parsers2.wn.synsets")
     def test_process_synonym_groups_not_synonyms_by_sense(self, mock_synsets):