Upload tool

requirements.txt

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

tool.py

@@ -1,27 +1,16 @@
 from smolagents.tools import Tool
-import string
 import pronouncing
 import json
+import string
 
 class ParodyWordSuggestionTool(Tool):
     name = "parody_word_suggester"
     description = "Suggests rhyming funny words using CMU dictionary pronunciations."
     inputs = {'target': {'type': 'string', 'description': 'The word you want to find rhyming alternatives for'}, 'word_list_str': {'type': 'string', 'description': 'JSON string of word list (e.g. \'["word1", "word2"]\')'}, 'min_similarity': {'type': 'string', 'description': 'Minimum similarity threshold (0.0-1.0)', 'nullable': True, 'default': '0.5'}, 'custom_phones': {'type': 'object', 'description': 'Optional dictionary of custom word pronunciations', 'nullable': True, 'default': None}}
     output_type = "string"
-    RHYME_WEIGHT = 0.6
-    PHONE_PATTERN_WEIGHT = 0.2
-    CHAR_DIFF_WEIGHT = 0.1
-    CONSONANT_WEIGHT = 0.1
-    CONSONANT_REF = "M,N,NG|P,B|T,D|K,G|F,V|TH,DH|S,Z|SH,ZH|L,R|W,Y"
-
-    def _get_consonant_groups(self):
-        """Get consonant similarity groups."""
-        groups = []
-        group_strs = self.CONSONANT_REF.split("|")
-        for group_str in group_strs:
-            groups.append(group_str.split(","))
-        return groups
-
+    RHYME_WEIGHT = 0.5
+    PHONE_SEQUENCE_WEIGHT = 0.3
+    LENGTH_WEIGHT = 0.2
 
     def _get_word_phones(self, word, custom_phones=None):
         """Get phones for a word, checking custom dictionary first."""
@@ -35,139 +24,76 @@ class ParodyWordSuggestionTool(Tool):
 
     def _get_primary_vowel(self, phones: list) -> str:
         """Get the primary stressed vowel from phone list."""
-        vowel_chars = 'AEIOU'  # Initialize the vowel characters set
-        phone_str = ""  # Initialize phone string
-        vowel_char = ""
-    
-        for phone_str in phones:
-            if '1' in phone_str and any(vowel_char in phone_str for vowel_char in vowel_chars):
-                return phone_str.rstrip('012')
+        v = ""
+        for phone in phones:
+            if '1' in phone and any(v in phone for v in 'AEIOU'):
+                return phone.rstrip('012')
         return None
 
 
-    def _calculate_char_difference(self, word1: str, word2: str) -> float:
-        """Calculate character difference score."""
-        if not word1 or not word2:
+    def _calculate_phone_sequence_similarity(self, phones1: list, phones2: list) -> float:
+        """Calculate similarity based on matching phones in sequence."""
+        p = ""
+        if not phones1 or not phones2:
             return 0.0
     
-        # Initialize variables
-        changes = 0
-        char1 = ""
-        char2 = ""
+        # Strip stress markers for comparison
+        clean_phones1 = [p.rstrip('012') for p in phones1]
+        clean_phones2 = [p.rstrip('012') for p in phones2]
     
-        # Count character differences
-        for char1, char2 in zip(word1, word2):
-            if char1 != char2:
-                changes += 1
-            
-        # Add difference for length mismatch
-        changes += abs(len(word1) - len(word2))
-    
-        # Score based on changes (0 changes = 1.0, more changes = lower score)
-        max_changes = max(len(word1), len(word2))
-        return 1.0 - (changes / max_changes) if max_changes > 0 else 0.0
-
-
-    def _calculate_consonant_similarity(self, phone_list1: list, phone_list2: list) -> float:
-        """Calculate consonant similarity score."""
-        # Initialize variables
-        consonant_score = 0.0
-        consonant_groups = self._get_consonant_groups()
-        vowel_chars = 'AEIOU'
-        phone_str = ""
-        vowel_char = ""
-        consonants1 = []
-        consonants2 = []
         matches = 0
-        comparisons = 0
-        cons1 = ""
-        cons2 = ""
-        group = []
-    
-        # Get consonants (non-vowel phones)
-        consonants1 = [phone_str for phone_str in phone_list1 
-                      if not any(vowel_char in phone_str for vowel_char in vowel_chars)]
-        consonants2 = [phone_str for phone_str in phone_list2 
-                      if not any(vowel_char in phone_str for vowel_char in vowel_chars)]
+        total_comparisons = max(len(clean_phones1), len(clean_phones2))
     
-        if not consonants1 or not consonants2:
-            return 0.0
-    
-        # Compare each consonant
-        matches = 0
-        comparisons = min(len(consonants1), len(consonants2))
-    
-        for cons1, cons2 in zip(consonants1, consonants2):
-            cons1 = cons1.rstrip('012')
-            cons2 = cons2.rstrip('012')
-        
-            if cons1 == cons2:
+        # Compare phones in sequence
+        for i in range(min(len(clean_phones1), len(clean_phones2))):
+            if clean_phones1[i] == clean_phones2[i]:
                 matches += 1
-                continue
-        
-            # Check if in same group
-            for group in consonant_groups:
-                if cons1 in group and cons2 in group:
-                    matches += 0.5
-                    break
-    
-        return matches / comparisons if comparisons > 0 else 0.0
+            
+        return matches / total_comparisons if total_comparisons > 0 else 0.0
+
+
+    def _calculate_length_similarity(self, phones1: list, phones2: list) -> float:
+        """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."""
-        # Initialize scores
-        rhyme_score = 0.0
-        phone_score = 0.0
-        char_diff_score = 0.0
-        consonant_score = 0.0
-    
         # Initialize phone lists
         phone_list1 = phones1.split()
         phone_list2 = phones2.split()
     
-        # Initialize variables for details
-        vowel1 = None
-        vowel2 = None
-    
-        # 1. Rhyme score (60%) - based on primary vowel
+        # 1. Rhyme score (50%) - based on primary vowel
         vowel1 = self._get_primary_vowel(phone_list1)
         vowel2 = self._get_primary_vowel(phone_list2)
-        if vowel1 and vowel2 and vowel1 == vowel2:
-            rhyme_score = 1.0
-    
-        # 2. Phone pattern score (20%) - based on number of phones
-        if len(phone_list1) == len(phone_list2):
-            phone_score = 1.0
-        else:
-            phone_score = 1.0 - (abs(len(phone_list1) - len(phone_list2)) / max(len(phone_list1), len(phone_list2)))
+        rhyme_score = 1.0 if vowel1 and vowel2 and vowel1 == vowel2 else 0.0
     
-        # 3. Character difference score (10%)
-        char_diff_score = self._calculate_char_difference(word1, word2)
+        # 2. Phone sequence similarity (30%)
+        phone_sequence_score = self._calculate_phone_sequence_similarity(phone_list1, phone_list2)
     
-        # 4. Consonant similarity score (10%)
-        consonant_score = self._calculate_consonant_similarity(phone_list1, phone_list2)
+        # 3. Length similarity (20%)
+        length_score = self._calculate_length_similarity(phone_list1, phone_list2)
     
         # Combined weighted score
         similarity = (
             (rhyme_score * self.RHYME_WEIGHT) +
-            (phone_score * self.PHONE_PATTERN_WEIGHT) +
-            (char_diff_score * self.CHAR_DIFF_WEIGHT) +
-            (consonant_score * self.CONSONANT_WEIGHT)
+            (phone_sequence_score * self.PHONE_SEQUENCE_WEIGHT) +
+            (length_score * self.LENGTH_WEIGHT)
         )
     
         return {
             "similarity": round(similarity, 3),
             "rhyme_score": round(rhyme_score, 3),
-            "phone_score": round(phone_score, 3),
-            "char_diff_score": round(char_diff_score, 3),
-            "consonant_score": round(consonant_score, 3),
+            "phone_sequence_score": round(phone_sequence_score, 3),
+            "length_score": round(length_score, 3),
             "details": {
                 "primary_vowel1": vowel1,
                 "primary_vowel2": vowel2,
                 "phone_count1": len(phone_list1),
                 "phone_count2": len(phone_list2),
-                "char_differences": abs(len(word1) - len(word2))
+                "matching_phones": round(phone_sequence_score * len(phone_list1))
             }
         }
 
@@ -183,11 +109,6 @@ class ParodyWordSuggestionTool(Tool):
         suggestions = []
         valid_words = []
         invalid_words = []
-        words = []
-        target_phones = ""
-        word_phones = ""
-        word = ""
-        similarity_result = {}
     
         # Parse JSON string to list
         try:
@@ -232,9 +153,8 @@ class ParodyWordSuggestionTool(Tool):
                         "word": word,
                         "similarity": similarity_result["similarity"],
                         "rhyme_score": similarity_result["rhyme_score"],
-                        "phone_score": similarity_result["phone_score"],
-                        "char_diff_score": similarity_result["char_diff_score"],
-                        "consonant_score": similarity_result["consonant_score"],
+                        "phone_sequence_score": similarity_result["phone_sequence_score"],
+                        "length_score": similarity_result["length_score"],
                         "phones": word_phones,
                         "is_custom": word in custom_phones if custom_phones else False,
                         "details": similarity_result["details"]