changed word service to handle coroutine problem

services/study_service.py

@@ -80,38 +80,38 @@ class StudyService:
                 "vector_norm": None
             }
 
+
     async def analyze_analogy(self, 
-                            word1: str, 
-                            word2: str, 
-                            word3: str,
-                            n_results: int = 10) -> Dict:
+                              word1: str, 
+                              word2: str, 
+                              word3: str,
+                              n_results: int = 10) -> Dict:
         """
-        Analyze word analogies (a:b :: c:?)
-        
+        Analyze word analogies (a:b :: c:?).
         Example: paris:france :: berlin:? (should find "allemagne")
         """
         try:
-            # Get vectors
+            # Get vectors for each word
             vec1 = await self.word_service.get_vector(word1)
             vec2 = await self.word_service.get_vector(word2)
             vec3 = await self.word_service.get_vector(word3)
-            
-            if None in (vec1, vec2, vec3):
+
+            # Use explicit checks to see if any vector is missing
+            if vec1 is None or vec2 is None or vec3 is None:
                 return {
                     "analogy": f"{word1}:{word2} :: {word3}:?",
                     "similar_words": [],
                     "error": "One or more words not found in vocabulary"
                 }
-            
+
             # Calculate analogy vector (vec2 - vec1 + vec3)
             analogy_vec = vec2 - vec1 + vec3
-            
-            # Normalize the vector
+
+            # Normalize the analogy vector
             analogy_vec = analogy_vec / np.linalg.norm(analogy_vec)
-            
-            # Find similar words
+
+            # Find similar words using the analogy vector
             similar_words = await self.word_service.get_similar_by_vector(analogy_vec, n=n_results)
-            
             return {
                 "analogy": f"{word1}:{word2} :: {word3}:?",
                 "similar_words": similar_words

services/word_service.py

@@ -121,8 +121,9 @@ class WordEmbeddingService:
             logger.exception(f"Error finding similar words for: {target_word}")
             return []
 
+
     async def get_words_in_range(self, target_word: str, min_similarity: float,
-                                max_similarity: float, n: int = 5) -> List[Dict[str, float]]:
+                                 max_similarity: float, n: int = 5) -> List[Dict[str, float]]:
         """Get words within a similarity range"""
         try:
             logger.info(f"Finding words for '{target_word}' in range [{min_similarity}, {max_similarity}]")
@@ -131,8 +132,8 @@ class WordEmbeddingService:
                 logger.warning(f"No vector for target word: {target_word}")
                 return []
 
-            # Run the CPU-intensive operations in a thread pool
-            async def process_words():
+            # Define a synchronous function to process words
+            def process_words():
                 similarities = []
                 norm_target = np.linalg.norm(target_vec)
                 sample_size = min(100000, len(self.vocab_vectors))
@@ -141,24 +142,24 @@ class WordEmbeddingService:
                 for vocab_word in sampled_words:
                     if vocab_word == target_word.lower():
                         continue
-                    
+
                     vector = self.vocab_vectors[vocab_word]
                     sim = float(np.dot(vector, target_vec) /
-                              (np.linalg.norm(vector) * norm_target))
-                    
+                                (np.linalg.norm(vector) * norm_target))
+
                     if min_similarity <= sim <= max_similarity:
                         similarities.append({'word': vocab_word, 'similarity': sim})
-                
+
                 return similarities
 
+            # Use to_thread to run the synchronous function in a thread
             similarities = await asyncio.to_thread(process_words)
-            
+
             if not similarities:
                 return []
 
             similarities.sort(key=lambda x: x['similarity'], reverse=True)
             selected_words = random.sample(similarities, min(n, len(similarities)))
-            
             return selected_words
 
         except Exception as e: