Upload tool

tool.py

@@ -1,6 +1,6 @@
 from smolagents.tools import Tool
-import string
 import pronouncing
+import string
 import json
 
 class ParodyWordSuggestionTool(Tool):
@@ -34,12 +34,12 @@ class ParodyWordSuggestionTool(Tool):
         last_vowel_idx = -1
         last_vowel = None
         vowel_groups = self._get_vowel_groups()
-        v = ""
     
         # Initialize loop variables
         i = 0
         phone = ""
         base_phone = ""
+        v = ""
         group = []
     
         # First, find the primary stressed vowel if it exists
@@ -95,6 +95,69 @@ class ParodyWordSuggestionTool(Tool):
         return False
 
 
+    def _consonants_are_similar(self, c1, c2):
+        """Check if two consonants belong to similar phonetic groups."""
+        # Group consonants by articulation manner
+        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']
+    
+        # Check if consonants are in the same group
+        if c1 in nasals and c2 in nasals:
+            return True
+        if c1 in stops and c2 in stops:
+            return True
+        if c1 in fricatives and c2 in fricatives:
+            return True
+        if c1 in liquids and c2 in liquids:
+            return True
+        if c1 in glides and c2 in glides:
+            return True
+    
+        return False
+
+
+    def _words_have_similar_structure(self, word1, word2, phones1, phones2):
+        """Check if words have similar structure beyond just ending."""
+        p = ""
+        v = ""
+        # Similar word length
+        if abs(len(word1) - len(word2)) > 2:
+            return False
+        
+        # Similar syllable count
+        import pronouncing
+        syllables1 = len(pronouncing.stresses(phones1))
+        syllables2 = len(pronouncing.stresses(phones2))
+        if syllables1 != syllables2:
+            return False
+        
+        # For -ing words, check if consonants before -ing have similar patterns
+        if word1.endswith('ing') and word2.endswith('ing'):
+            # Get consonant patterns (c-v-c structure)
+            phone_list1 = phones1.split()
+            phone_list2 = phones2.split()
+        
+            # Get consonants
+            consonants1 = [p for p in self._strip_stress(phone_list1) if not any(v in p for v in 'AEIOU')]
+            consonants2 = [p for p in self._strip_stress(phone_list2) if not any(v in p for v in 'AEIOU')]
+        
+            # Same consonant count is promising
+            if len(consonants1) == len(consonants2):
+                return True
+            
+            # For words like 'running' and 'cumming', check pre-final consonant similarity
+            if len(consonants1) >= 2 and len(consonants2) >= 2:
+                pre_final1 = consonants1[-2]
+                pre_final2 = consonants2[-2]
+                if pre_final1 == pre_final2 or self._consonants_are_similar(pre_final1, pre_final2):
+                    return True
+                
+        return False
+
+
     def _calculate_similarity(self, word1, phones1, word2, phones2):
         """Calculate similarity score using refined metrics for parody."""
         # Initialize all variables
@@ -197,22 +260,33 @@ class ParodyWordSuggestionTool(Tool):
         # Near rhyme check - 15% of score
         near_rhyme_score = 0.0
     
-        # Check for specific endings
+        # Enhanced check for -ing endings
         if len(phone_list1) >= 2 and len(phone_list2) >= 2:
             # Check for -ing endings
             if (self._strip_stress(phone_list1[-2:]) == ['IH', 'NG'] and 
                 self._strip_stress(phone_list2[-2:]) == ['IH', 'NG']):
             
-                # For -ing endings, also consider the consonant before -ing
-                if len(phone_list1) >= 3 and len(phone_list2) >= 3:
-                    # If the consonants before -ing match, higher score
-                    if self._strip_stress(phone_list1[-3:-2]) == self._strip_stress(phone_list2[-3:-2]):
-                        near_rhyme_score = 0.9
-                    else:
-                        near_rhyme_score = 0.6
+                # Check if the words have similar structure (important for parody)
+                if self._words_have_similar_structure(word1, word2, phones1, phones2):
+                    near_rhyme_score = 0.8
                 else:
-                    near_rhyme_score = 0.6
+                    # Words ending in -ing but with very different structure
+                    # like "running" vs "kinging" should score lower
+                    near_rhyme_score = 0.4
+            
+                # Additional boost if the consonant before -ing is similar
+                if len(phone_list1) >= 3 and len(phone_list2) >= 3:
+                    consonant1 = self._strip_stress(phone_list1[-3:-2])
+                    consonant2 = self._strip_stress(phone_list2[-3:-2])
                 
+                    if len(consonant1) > 0 and len(consonant2) > 0:
+                        # Same consonant gets highest score
+                        if consonant1[0] == consonant2[0]:
+                            near_rhyme_score = max(near_rhyme_score, 0.9)
+                        # Similar consonants (e.g., 'N' and 'M' are both nasals)
+                        elif self._consonants_are_similar(consonant1[0], consonant2[0]):
+                            near_rhyme_score = max(near_rhyme_score, 0.8)
+                        
             # Check for -y endings (like happy/sappy) 
             elif (self._strip_stress(phone_list1[-1:]) == ['IY'] and 
                   self._strip_stress(phone_list2[-1:]) == ['IY']):
@@ -242,6 +316,13 @@ class ParodyWordSuggestionTool(Tool):
             (front_score)                     # Front consonants (10%)
         )
     
+        # IMPORTANT: Special case for words like "running"/"cumming"
+        # These should match well for parody purposes
+        if (word1.endswith('ing') and word2.endswith('ing') and 
+            front_consonant_score < 0.5 and  # Different initial consonants
+            near_rhyme_score >= 0.8):        # Good near-rhyme pattern
+            similarity = max(similarity, 0.8)  # Ensure high enough score
+    
         # IMPORTANT: Penalty for words that are too similar to be funny
         # For parody, slightly different words are better than almost identical words
         if word1 and word2: