Upload tool

requirements.txt

@@ -1,2 +1,2 @@
-pronouncing
 smolagents
+pronouncing

tool.py

@@ -1,6 +1,6 @@
 from smolagents.tools import Tool
-import json
 import pronouncing
+import json
 import string
 
 class ParodyWordSuggestionTool(Tool):
@@ -16,16 +16,6 @@ class ParodyWordSuggestionTool(Tool):
         import string
         import json
     
-        # Define vowel sound groups (common sounds that rhyme)
-        vowel_groups = {
-            'UW1': ['UW0', 'UW1', 'UW2'],  # oo sounds
-            'UW0': ['UW0', 'UW1', 'UW2'],
-            'UW2': ['UW0', 'UW1', 'UW2'],
-            'AH1': ['AH0', 'AH1', 'AH2'],  # uh sounds
-            'AH0': ['AH0', 'AH1', 'AH2'],
-            'AH2': ['AH0', 'AH1', 'AH2'],
-        }
-    
         target = target.lower().strip(string.punctuation)
         min_similarity = float(min_similarity)
         suggestions = []
@@ -50,79 +40,62 @@ class ParodyWordSuggestionTool(Tool):
         target_phones = target_phones[0]
         target_phone_list = target_phones.split()
     
-        # Focus on the vowel sound and end consonant(s)
-        target_end = []
-        found_vowel = False
-        for i in range(len(target_phone_list) - 1, -1, -1):
-            current_phone = target_phone_list[i]
-            target_end.insert(0, current_phone)
-            # Check if current phone contains a vowel
-            has_vowel = False
-            for vowel in ['A', 'E', 'I', 'O', 'U']:
-                if vowel in current_phone:
-                    has_vowel = True
-                    found_vowel = True
-                    break
-            if found_vowel:
-                break
-            
         # Check each word
         for word in words:
             phones = pronouncing.phones_for_word(word)
-            if phones:  # Only process if word is in dictionary
+            if phones:
                 word_phones = phones[0]
                 word_phone_list = word_phones.split()
             
-                # Get ending pattern (vowel + following consonants)
-                word_end = []
-                found_vowel = False
-                for i in range(len(word_phone_list) - 1, -1, -1):
-                    current_phone = word_phone_list[i]
-                    word_end.insert(0, current_phone)
-                    # Check if current phone contains a vowel
-                    has_vowel = False
-                    for vowel in ['A', 'E', 'I', 'O', 'U']:
-                        if vowel in current_phone:
-                            has_vowel = True
-                            found_vowel = True
-                            break
-                    if found_vowel:
-                        break
-            
-                # Calculate rhyme score
-                matches = 0
-                total_checks = max(len(word_end), len(target_end))
+                # Calculate full phonetic similarity
+                phonetic_matches = 0
+                max_length = max(len(word_phone_list), len(target_phone_list))
+                min_length = min(len(word_phone_list), len(target_phone_list))
             
-                for i in range(min(len(word_end), len(target_end))):
-                    w_phone = word_end[i]
-                    t_phone = target_end[i]
+                for i in range(max_length):
+                    if i >= min_length:
+                        break
+                    
+                    w_phone = word_phone_list[i]
+                    t_phone = target_phone_list[i]
                 
-                    # Check for exact match
+                    # Exact phone match
                     if w_phone == t_phone:
-                        matches += 1
+                        phonetic_matches += 1.0
+                    # Match without stress numbers
+                    elif w_phone.rstrip('012') == t_phone.rstrip('012'):
+                        phonetic_matches += 0.8
+                    # Consonant match at start
                     else:
-                        # Check for vowel sound
+                        # Check if current phone is a consonant
                         has_vowel = False
-                        for vowel in ['A', 'E', 'I', 'O', 'U']:
+                        vowels = ['A', 'E', 'I', 'O', 'U']
+                        for vowel in vowels:
                             if vowel in w_phone:
                                 has_vowel = True
                                 break
-                            
-                        if has_vowel:
-                            # Check vowel groups
-                            is_match = False
-                            for base_vowel in vowel_groups:
-                                if w_phone in vowel_groups[base_vowel] and t_phone in vowel_groups[base_vowel]:
-                                    is_match = True
-                                    matches += 1
-                                    break
+                    
+                        if i == 0 and not has_vowel:
+                            if w_phone.rstrip('012') == t_phone.rstrip('012'):
+                                phonetic_matches += 0.5
+            
+                phonetic_similarity = phonetic_matches / max_length
+            
+                # Calculate rhyme similarity (focusing on end phones)
+                rhyme_score = 1.0 if word_phone_list[-1] == target_phone_list[-1] else 0.0
+                if len(word_phone_list) > 1 and len(target_phone_list) > 1:
+                    if word_phone_list[-2] == target_phone_list[-2]:
+                        rhyme_score += 1.0
             
-                similarity = matches / total_checks if total_checks > 0 else 0.0
+                # Combined score (weighing both phonetic similarity and rhyming)
+                similarity = (phonetic_similarity * 0.6) + (rhyme_score * 0.4)
             
                 if similarity >= min_similarity:
                     suggestions.append({
                         "word": word,
                         "similarity": round(similarity, 3),
+                        "phonetic_similarity": round(phonetic_similarity, 3),
+                        "rhyme_score": round(rhyme_score, 3),
                         "syllables": pronouncing.syllable_count(word_phones),
                         "phones": word_phones,
                     })