Upload tool

tool.py

@@ -1,7 +1,7 @@
 from smolagents.tools import Tool
-import pronouncing
 import json
 import string
+import pronouncing
 
 class WordPhoneTool(Tool):
     name = "word_phonetic_analyzer"
@@ -9,23 +9,13 @@ 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"
-    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"
+    VOWEL_REF = "AH,UH,AX|AE,EH|IY,IH|AO,AA|UW,UH|AY,EY|OW,AO|AW,AO|OY,OW|ER,AXR"
 
     def _get_vowel_groups(self):
-        """Get vowel groups for comparison."""
         groups = []
-        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(','))
+        group_strs = self.VOWEL_REF.split("|")
+        for group_str in group_strs:
+            groups.append(group_str.split(","))
         return groups
 
 
@@ -39,112 +29,24 @@ 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, phone in enumerate(phones):
-            base_phone = phone.rstrip('012')
-            is_vowel = False
-            for vowel in 'AEIOU':
-                if vowel in base_phone:
-                    is_vowel = True
+        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
                     break
-            if is_vowel:
-                last_vowel_idx = i
-                last_vowel = base_phone
     
         if last_vowel_idx == -1:
             return None, []
@@ -157,153 +59,122 @@ class WordPhoneTool(Tool):
 
 
     def _strip_stress(self, phones):
-        """Remove stress markers from phones."""
         result = []
         for phone in phones:
-            stripped = phone.rstrip('012')
+            stripped = ""
+            for char in phone:
+                if char not in "012":
+                    stripped += char
             result.append(stripped)
         return result
 
 
     def _vowels_match(self, v1, v2):
-        """Check if vowels are similar enough to rhyme."""
-        v1_stripped = v1.rstrip('012')
-        v2_stripped = v2.rstrip('012')
+        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
     
         if v1_stripped == v2_stripped:
             return True
         
-        for group_str in self.PHONE_GROUPS.split('|'):
-            group = group_str.split(',')
+        vowel_groups = self._get_vowel_groups()
+        for group in vowel_groups:
             if v1_stripped in group and v2_stripped in group:
                 return True
         return False
 
 
-    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:]
-    
-        # 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
+    def _calculate_similarity(self, word1, phones1, word2, phones2):
+        import pronouncing
     
-        total_similarity = 0.0
-        comparisons = max(len(phones1), len(phones2))
+        # 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
     
-        # 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 rhyme score (most important)
-        rhyme_score = self._get_rhyme_score(phone_list1, phone_list2)
+        # 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
     
-        # Calculate phone sequence similarity
-        phone_sequence_score = self._calculate_phone_sequence_similarity(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 length similarity score
-        length_score = self._calculate_length_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
     
-        # Combined weighted score
-        similarity = (
-            (rhyme_score * self.RHYME_WEIGHT) +
-            (phone_sequence_score * self.PHONE_SEQUENCE_WEIGHT) +
-            (length_score * self.LENGTH_WEIGHT)
+        # 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%)
         )
     
+        # Ensure total similarity is capped at 1.0
+        total_similarity = min(1.0, total_similarity)
+    
         return {
-            "similarity": round(similarity, 3),
+            "similarity": round(total_similarity, 3),
             "rhyme_score": round(rhyme_score, 3),
-            "phone_sequence_score": round(phone_sequence_score, 3),
             "length_score": round(length_score, 3),
-            "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)
-            }
+            "stress_score": round(stress_score, 3),
+            "phone_length_difference": phone_diff
         }
 
 
-    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
     
-        word_clean = word.lower().strip(string.punctuation)
+        # 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)
         primary_phones = self._get_word_phones(word_clean, custom_phones)
     
         if not primary_phones:
@@ -321,13 +192,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()),
-                'primary_vowel': self._get_primary_vowel(primary_phones.split())
+                'phone_count': len(primary_phones.split())
             }
         }
     
         if compare_to:
-            compare_clean = compare_to.lower().strip(string.punctuation)
+            compare_clean = compare_to.lower()
+            compare_clean = compare_clean.strip(string.punctuation)
             compare_phones = self._get_word_phones(compare_clean, custom_phones)
         
             if not compare_phones:
@@ -335,27 +206,13 @@ class WordPhoneTool(Tool):
                     'error': f'Comparison word "{compare_clean}" not found in dictionary or custom phones'
                 }
             else:
-                # 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
+                # Get rhyme components
                 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
             
-                # 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
+                # Calculate if words rhyme
                 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)
@@ -363,7 +220,7 @@ class WordPhoneTool(Tool):
                         if word_end_clean == compare_end_clean:
                             is_rhyme = True
             
-                # Basic analysis
+                # Calculate detailed comparison stats
                 word_syl_count = pronouncing.syllable_count(primary_phones)
                 compare_syl_count = pronouncing.syllable_count(compare_phones)
             
@@ -373,11 +230,10 @@ class WordPhoneTool(Tool):
                         'syllable_count': compare_syl_count,
                         'phones': compare_phones.split(),
                         'stresses': pronouncing.stresses(compare_phones),
-                        'phone_count': len(compare_phones.split()),
-                        'primary_vowel': self._get_primary_vowel(compare_phones.split())
+                        'phone_count': len(compare_phones.split())
                     },
                     'comparison_stats': {
-                        'traditional_rhyme': is_rhyme,
+                        'is_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),
@@ -385,7 +241,7 @@ class WordPhoneTool(Tool):
                     }
                 }
             
-                # Calculate detailed similarity scores with new algorithm
+                # Calculate detailed similarity scores
                 similarity_result = self._calculate_similarity(
                     word_clean, primary_phones,
                     compare_clean, compare_phones