Upload tool

tool.py

@@ -1,7 +1,7 @@
 from smolagents.tools import Tool
-import string
-import json
 import pronouncing
+import json
+import string
 
 class WordPhoneTool(Tool):
     name = "word_phonetic_analyzer"
@@ -9,13 +9,23 @@ class WordPhoneTool(Tool):
     Can also compare two words for phonetic similarity and rhyming."""
     inputs = {'word': {'type': 'string', 'description': 'Primary word to analyze for pronunciation patterns'}, 'compare_to': {'type': 'string', 'description': 'Optional word to compare against for similarity scoring', 'nullable': True}, 'custom_phones': {'type': 'object', 'description': 'Optional dictionary of custom word pronunciations', 'nullable': True}}
     output_type = "string"
-    VOWEL_REF = "AH,UH,AX|AE,EH|IY,IH|AO,AA|UW,UH|AY,EY|OW,AO|AW,AO|OY,OW|ER,AXR"
+    RHYME_WEIGHT = 0.6
+    PHONE_SEQUENCE_WEIGHT = 0.3
+    LENGTH_WEIGHT = 0.1
+    PHONE_GROUPS = "M,N,NG|P,B|T,D|K,G|F,V|TH,DH|S,Z|SH,ZH|L,R|W,Y|IY,IH|UW,UH|EH,AH|AO,AA|AE,AH|AY,EY|OW,UW"
 
     def _get_vowel_groups(self):
+        """Get vowel groups for comparison."""
         groups = []
-        group_strs = self.VOWEL_REF.split("|")
-        for group_str in group_strs:
-            groups.append(group_str.split(","))
+        vowel_parts = self.PHONE_GROUPS.split('|')
+        for part in vowel_parts:
+            is_vowel = False
+            for vowel in 'AEIOU':
+                if vowel in part:
+                    is_vowel = True
+                    break
+            if is_vowel:
+                groups.append(part.split(','))
         return groups
 
 
@@ -29,24 +39,112 @@ class WordPhoneTool(Tool):
         return phones[0] if phones else None
 
 
+    def _get_primary_vowel(self, phones):
+        """Get the primary stressed vowel from phone list."""
+        for phone_str in phones:
+            is_vowel_with_stress = False
+            if '1' in phone_str:
+                for vowel in 'AEIOU':
+                    if vowel in phone_str:
+                        is_vowel_with_stress = True
+                        break
+            if is_vowel_with_stress:
+                return phone_str.rstrip('012')
+        return None
+
+
+    def _get_phone_type(self, phone):
+        """Get the broad category of a phone."""
+        # Strip stress markers
+        phone = phone.rstrip('012')
+    
+        # Vowels
+        is_vowel = False
+        for vowel in 'AEIOU':
+            if vowel in phone:
+                is_vowel = True
+                break
+        if is_vowel:
+            return 'vowel'
+        
+        # Initialize fixed sets for categories
+        nasals = {'M', 'N', 'NG'}
+        stops = {'P', 'B', 'T', 'D', 'K', 'G'}
+        fricatives = {'F', 'V', 'TH', 'DH', 'S', 'Z', 'SH', 'ZH'}
+        liquids = {'L', 'R'}
+        glides = {'W', 'Y'}
+    
+        if phone in nasals:
+            return 'nasal'
+        if phone in stops:
+            return 'stop'
+        if phone in fricatives:
+            return 'fricative'
+        if phone in liquids:
+            return 'liquid'
+        if phone in glides:
+            return 'glide'
+        
+        return 'other'
+
+
+    def _phones_are_similar(self, phone1, phone2):
+        """Check if two phones are similar enough to be considered rhyming."""
+        # Strip stress markers
+        p1 = phone1.rstrip('012')
+        p2 = phone2.rstrip('012')
+    
+        # Exact match
+        if p1 == p2:
+            return True
+        
+        # Check similarity groups
+        for group_str in self.PHONE_GROUPS.split('|'):
+            group = group_str.split(',')
+            if p1 in group and p2 in group:
+                return True
+            
+        return False
+
+
+    def _get_phone_similarity(self, phone1, phone2):
+        """Calculate similarity between two phones."""
+        # Initialize variables
+        p1 = phone1.rstrip('012')
+        p2 = phone2.rstrip('012')
+    
+        # Exact match
+        if p1 == p2:
+            return 1.0
+        
+        # Check similarity groups
+        for group_str in self.PHONE_GROUPS.split('|'):
+            group = group_str.split(',')
+            if p1 in group and p2 in group:
+                return 0.7
+            
+        # Check broader categories
+        if self._get_phone_type(p1) == self._get_phone_type(p2):
+            return 0.3
+        
+        return 0.0
+
+
     def _get_last_syllable(self, phones):
+        """Get the last vowel and remaining consonants (for rhyming analysis)."""
         last_vowel_idx = -1
         last_vowel = None
-        vowel_groups = self._get_vowel_groups()
     
-        for i in range(len(phones)):
-            phone = phones[i]
-            base_phone = ""
-            for j in range(len(phone)):
-                char = phone[j]
-                if char not in "012":
-                    base_phone += char
-        
-            for group in vowel_groups:
-                if base_phone in group:
-                    last_vowel_idx = i
-                    last_vowel = base_phone
+        for i, phone in enumerate(phones):
+            base_phone = phone.rstrip('012')
+            is_vowel = False
+            for vowel in 'AEIOU':
+                if vowel in base_phone:
+                    is_vowel = True
                     break
+            if is_vowel:
+                last_vowel_idx = i
+                last_vowel = base_phone
     
         if last_vowel_idx == -1:
             return None, []
@@ -59,122 +157,153 @@ class WordPhoneTool(Tool):
 
 
     def _strip_stress(self, phones):
+        """Remove stress markers from phones."""
         result = []
         for phone in phones:
-            stripped = ""
-            for char in phone:
-                if char not in "012":
-                    stripped += char
+            stripped = phone.rstrip('012')
             result.append(stripped)
         return result
 
 
     def _vowels_match(self, v1, v2):
-        v1_stripped = ""
-        v2_stripped = ""
-    
-        for char in v1:
-            if char not in "012":
-                v1_stripped += char
-            
-        for char in v2:
-            if char not in "012":
-                v2_stripped += char
+        """Check if vowels are similar enough to rhyme."""
+        v1_stripped = v1.rstrip('012')
+        v2_stripped = v2.rstrip('012')
     
         if v1_stripped == v2_stripped:
             return True
         
-        vowel_groups = self._get_vowel_groups()
-        for group in vowel_groups:
+        for group_str in self.PHONE_GROUPS.split('|'):
+            group = group_str.split(',')
             if v1_stripped in group and v2_stripped in group:
                 return True
         return False
 
 
-    def _calculate_similarity(self, word1, phones1, word2, phones2):
-        import pronouncing
+    def _get_rhyme_score(self, phones1, phones2):
+        """Calculate rhyme score based on matching phones after primary stressed vowel."""
+        # Find primary stressed vowel position in both words
+        pos1 = -1
+        pos2 = -1
+    
+        for i, phone in enumerate(phones1):
+            is_stressed_vowel = False
+            if '1' in phone:
+                for vowel in 'AEIOU':
+                    if vowel in phone:
+                        is_stressed_vowel = True
+                        break
+            if is_stressed_vowel:
+                pos1 = i
+                break
+            
+        for i, phone in enumerate(phones2):
+            is_stressed_vowel = False
+            if '1' in phone:
+                for vowel in 'AEIOU':
+                    if vowel in phone:
+                        is_stressed_vowel = True
+                        break
+            if is_stressed_vowel:
+                pos2 = i
+                break
+        
+        if pos1 == -1 or pos2 == -1:
+            return 0.0
+    
+        # Get all phones after and including the stressed vowel
+        rhyme_part1 = phones1[pos1:]
+        rhyme_part2 = phones2[pos2:]
     
-        # Initialize variables before use
-        last_vowel1 = None
-        last_vowel2 = None
-        word1_end = []
-        word2_end = []
-        matched = 0
-        common_length = 0
-        end1_clean = []
-        end2_clean = []
-        i = 0  # Initialize i for loop variable
+        # If lengths are too different, not a good rhyme
+        if abs(len(rhyme_part1) - len(rhyme_part2)) > 1:
+            return 0.0
     
+        # Calculate similarity score for rhyming part
+        similarity_count = 0
+        max_compare = min(len(rhyme_part1), len(rhyme_part2))
+    
+        for i in range(max_compare):
+            if self._phones_are_similar(rhyme_part1[i], rhyme_part2[i]):
+                similarity_count += 1
+    
+        # Return score based on how many phones were similar
+        return similarity_count / max(len(rhyme_part1), len(rhyme_part2)) if max(len(rhyme_part1), len(rhyme_part2)) > 0 else 0.0
+
+
+    def _calculate_phone_sequence_similarity(self, phones1, phones2):
+        """Calculate similarity based on matching phones in sequence."""
+        if not phones1 or not phones2:
+            return 0.0
+    
+        total_similarity = 0.0
+        comparisons = max(len(phones1), len(phones2))
+    
+        # Compare each position
+        for i in range(min(len(phones1), len(phones2))):
+            similarity = self._get_phone_similarity(phones1[i], phones2[i])
+            total_similarity += similarity
+        
+        return total_similarity / comparisons if comparisons > 0 else 0.0
+
+
+    def _calculate_length_similarity(self, phones1, phones2):
+        """Calculate similarity based on phone length."""
+        max_length = max(len(phones1), len(phones2))
+        length_diff = abs(len(phones1) - len(phones2))
+        return 1.0 - (length_diff / max_length) if max_length > 0 else 0.0
+
+
+    def _calculate_similarity(self, word1, phones1, word2, phones2):
+        """Calculate similarity based on multiple factors."""
         phone_list1 = phones1.split()
         phone_list2 = phones2.split()
     
-        # Get last syllable components
-        result1 = self._get_last_syllable(phone_list1)
-        result2 = self._get_last_syllable(phone_list2)
-        last_vowel1, word1_end = result1
-        last_vowel2, word2_end = result2
+        # Get rhyme score (most important)
+        rhyme_score = self._get_rhyme_score(phone_list1, phone_list2)
     
-        # Calculate length similarity score first
-        phone_diff = abs(len(phone_list1) - len(phone_list2))
-        max_phones = max(len(phone_list1), len(phone_list2))
-        length_score = 1.0 if phone_diff == 0 else 1.0 - (phone_diff / max_phones)
+        # Calculate phone sequence similarity
+        phone_sequence_score = self._calculate_phone_sequence_similarity(phone_list1, phone_list2)
     
-        # Calculate rhyme score (most important)
-        rhyme_score = 0.0
-        if last_vowel1 and last_vowel2:
-            if self._vowels_match(last_vowel1, last_vowel2):
-                end1_clean = self._strip_stress(word1_end)
-                end2_clean = self._strip_stress(word2_end)
-            
-                if end1_clean == end2_clean:
-                    rhyme_score = 1.0  # Perfect rhyme, capped at 1.0
-                else:
-                    # Partial rhyme based on ending similarity
-                    common_length = min(len(end1_clean), len(end2_clean))
-                    matched = 0
-                    for i in range(common_length):
-                        if end1_clean[i] == end2_clean[i]:
-                            matched += 1
-                    rhyme_score = 0.6 * (matched / max(len(end1_clean), len(end2_clean)))
-
-        # Calculate stress pattern similarity
-        stress1 = pronouncing.stresses(phones1)
-        stress2 = pronouncing.stresses(phones2)
-        stress_score = 1.0 if stress1 == stress2 else 0.5
+        # Calculate length similarity score
+        length_score = self._calculate_length_similarity(phone_list1, phone_list2)
     
-        # Weighted combination prioritizing rhyming and length
-        total_similarity = (
-            (rhyme_score * 0.6) +       # Rhyming most important (60%)
-            (length_score * 0.3) +      # Length similarity next (30%)
-            (stress_score * 0.1)        # Stress pattern least important (10%)
+        # Combined weighted score
+        similarity = (
+            (rhyme_score * self.RHYME_WEIGHT) +
+            (phone_sequence_score * self.PHONE_SEQUENCE_WEIGHT) +
+            (length_score * self.LENGTH_WEIGHT)
         )
     
-        # Ensure total similarity is capped at 1.0
-        total_similarity = min(1.0, total_similarity)
-    
         return {
-            "similarity": round(total_similarity, 3),
+            "similarity": round(similarity, 3),
             "rhyme_score": round(rhyme_score, 3),
+            "phone_sequence_score": round(phone_sequence_score, 3),
             "length_score": round(length_score, 3),
-            "stress_score": round(stress_score, 3),
-            "phone_length_difference": phone_diff
+            "details": {
+                "primary_vowel1": self._get_primary_vowel(phone_list1),
+                "primary_vowel2": self._get_primary_vowel(phone_list2),
+                "phone_count1": len(phone_list1),
+                "phone_count2": len(phone_list2),
+                "is_rhyme": rhyme_score > 0.8,
+                "stress_pattern1": self._get_stress_pattern(phones1),
+                "stress_pattern2": self._get_stress_pattern(phones2)
+            }
         }
 
 
+    def _get_stress_pattern(self, phones):
+        """Extract stress pattern from phones."""
+        import pronouncing
+        return pronouncing.stresses(phones)
+
+
     def forward(self, word, compare_to=None, custom_phones=None):
         import json
         import string
         import pronouncing
     
-        # Initialize variables before use
-        word_last_vowel = None
-        compare_last_vowel = None
-        word_end = []
-        compare_end = []
-        is_rhyme = False
-    
-        word_clean = word.lower()
-        word_clean = word_clean.strip(string.punctuation)
+        word_clean = word.lower().strip(string.punctuation)
         primary_phones = self._get_word_phones(word_clean, custom_phones)
     
         if not primary_phones:
@@ -192,13 +321,13 @@ class WordPhoneTool(Tool):
                 'syllable_count': pronouncing.syllable_count(primary_phones),
                 'phones': primary_phones.split(),
                 'stresses': pronouncing.stresses(primary_phones),
-                'phone_count': len(primary_phones.split())
+                'phone_count': len(primary_phones.split()),
+                'primary_vowel': self._get_primary_vowel(primary_phones.split())
             }
         }
     
         if compare_to:
-            compare_clean = compare_to.lower()
-            compare_clean = compare_clean.strip(string.punctuation)
+            compare_clean = compare_to.lower().strip(string.punctuation)
             compare_phones = self._get_word_phones(compare_clean, custom_phones)
         
             if not compare_phones:
@@ -206,13 +335,27 @@ class WordPhoneTool(Tool):
                     'error': f'Comparison word "{compare_clean}" not found in dictionary or custom phones'
                 }
             else:
-                # Get rhyme components
+                # Initialize variables for traditional rhyme analysis
+                word_last_vowel = None
+                compare_last_vowel = None
+                word_end = []
+                compare_end = []
+            
+                # Get rhyme components for traditional rhyme analysis
                 word_result = self._get_last_syllable(primary_phones.split())
                 compare_result = self._get_last_syllable(compare_phones.split())
-                word_last_vowel, word_end = word_result
-                compare_last_vowel, compare_end = compare_result
             
-                # Calculate if words rhyme
+                # Unpack results with explicit assignment
+                if word_result and len(word_result) == 2:
+                    word_last_vowel = word_result[0]
+                    word_end = word_result[1]
+                
+                if compare_result and len(compare_result) == 2:
+                    compare_last_vowel = compare_result[0]
+                    compare_end = compare_result[1]
+            
+                # Calculate if words rhyme using traditional method
+                is_rhyme = False
                 if word_last_vowel and compare_last_vowel:
                     if self._vowels_match(word_last_vowel, compare_last_vowel):
                         word_end_clean = self._strip_stress(word_end)
@@ -220,7 +363,7 @@ class WordPhoneTool(Tool):
                         if word_end_clean == compare_end_clean:
                             is_rhyme = True
             
-                # Calculate detailed comparison stats
+                # Basic analysis
                 word_syl_count = pronouncing.syllable_count(primary_phones)
                 compare_syl_count = pronouncing.syllable_count(compare_phones)
             
@@ -230,10 +373,11 @@ class WordPhoneTool(Tool):
                         'syllable_count': compare_syl_count,
                         'phones': compare_phones.split(),
                         'stresses': pronouncing.stresses(compare_phones),
-                        'phone_count': len(compare_phones.split())
+                        'phone_count': len(compare_phones.split()),
+                        'primary_vowel': self._get_primary_vowel(compare_phones.split())
                     },
                     'comparison_stats': {
-                        'is_rhyme': is_rhyme,
+                        'traditional_rhyme': is_rhyme,
                         'same_syllable_count': word_syl_count == compare_syl_count,
                         'same_stress_pattern': pronouncing.stresses(primary_phones) == pronouncing.stresses(compare_phones),
                         'syllable_difference': abs(word_syl_count - compare_syl_count),
@@ -241,7 +385,7 @@ class WordPhoneTool(Tool):
                     }
                 }
             
-                # Calculate detailed similarity scores
+                # Calculate detailed similarity scores with new algorithm
                 similarity_result = self._calculate_similarity(
                     word_clean, primary_phones,
                     compare_clean, compare_phones