Update app.py

app.py

@@ -21,16 +21,56 @@ def transcribe_odiya_eng(speech):
     from indictrans import Transliterator
     trn = Transliterator(source='ori', target='eng', build_lookup=True)
     text = p1(speech)["text"]
-    text=trn.transform(text)
-    text = master_function(text)
+    #text=trn.transform(text)
+    #text = master_function(text)
+    sentence = trn.transform(text)
+    replaced_words = replace_words(sentence)
+    processed_sentence = process_doubles(replaced_words)
+    input_sentence_1 = processed_sentence
+    # Create empty mappings
+    word_to_code_map = {}
+    code_to_word_map = {}
+
+    # Convert sentence to transcript
+    transcript_1 = sentence_to_transcript(input_sentence_1, word_to_code_map)
+
+    # Convert transcript to numerical representation
+    numbers = text2int(transcript_1)
+
+    # Create reverse mapping
+    code_to_word_map = {v: k for k, v in word_to_code_map.items()}
+
+    # Convert transcript back to sentence
+    text = transcript_to_sentence(numbers, code_to_word_map)
     return text
+
 def transcribe_hin_eng(speech):
     from indictrans import Transliterator
     trn = Transliterator(source='hin', target='eng', build_lookup=True)
     text = p2(speech)["text"]
-    text=trn.transform(text)
-    text = master_function(text)
+    #text=trn.transform(text)
+    #text = master_function(text)
+    sentence = trn.transform(text)
+    replaced_words = replace_words(sentence)
+    processed_sentence = process_doubles(replaced_words)
+    input_sentence_1 = processed_sentence
+    # Create empty mappings
+    word_to_code_map = {}
+    code_to_word_map = {}
+
+    # Convert sentence to transcript
+    transcript_1 = sentence_to_transcript(input_sentence_1, word_to_code_map)
+
+    # Convert transcript to numerical representation
+    numbers = text2int(transcript_1)
+
+    # Create reverse mapping
+    code_to_word_map = {v: k for k, v in word_to_code_map.items()}
+
+    # Convert transcript back to sentence
+    text = transcript_to_sentence(numbers, code_to_word_map)
     return text
+    
 def sel_lng(lng,mic=None, file=None):
     if mic is not None:
         audio = mic
@@ -50,20 +90,49 @@ def sel_lng(lng,mic=None, file=None):
 #####################################################
 
 
+def replace_words(sentence):
+    replacements = [
+        (r'\bjiro\b', 'zero'), (r'\bjero\b', 'zero'), (r'\bnn\b', 'one'),
+        (r'\bn\b', 'one'), (r'\bna\b', 'one'), (r'\btu\b', 'two'),
+        (r'\btoo\b', 'two'), (r'\bthiri\b', 'three'), (r'\bfor\b', 'four'),
+        (r'\bfore\b', 'four'), (r'\bfib\b', 'five'), (r'\bdublseven\b', 'double seven'),
+        (r'\bdubalathri\b', 'double three'), (r'\bnineeit\b', 'nine eight'),
+        (r'\bfipeit\b', 'five eight'), (r'\bdubal\b', 'double'), (r'\bsevenatu\b', 'seven two'),
+    ]
+    for pattern, replacement in replacements:
+        sentence = re.sub(pattern, replacement, sentence)
+    return sentence
+
+# Function to process "double" followed by a number
+def process_doubles(sentence):
+    tokens = sentence.split()
+    result = []
+    i = 0
+    while i < len(tokens):
+        if tokens[i] in ("double", "dubal"):
+            if i + 1 < len(tokens):
+                result.append(tokens[i + 1])
+                result.append(tokens[i + 1])
+                i += 2
+            else:
+                result.append(tokens[i])
+                i += 1
+        else:
+            result.append(tokens[i])
+            i += 1
+    return ' '.join(result)
+
+# Function to generate Soundex code for a word
 def soundex(word):
     word = word.upper()
     word = ''.join(filter(str.isalpha, word))
     if not word:
         return None
     soundex_mapping = {
-     'B': '1', 'F': '1', 'P': '1', 'V': '1',
-     'C': '2', 'G': '2', 'J': '2', 'K': '2', 'Q': '2',
-     'S': '2', 'X': '2', 'Z': '2',
-     'D': '3', 'T': '3',
-     'L': '4',
-     'M': '5', 'N': '5',
-     'R': '6'
-     }
+        'B': '1', 'F': '1', 'P': '1', 'V': '1',
+        'C': '2', 'G': '2', 'J': '2', 'K': '2', 'Q': '2', 'S': '2', 'X': '2', 'Z': '2',
+        'D': '3', 'T': '3', 'L': '4', 'M': '5', 'N': '5', 'R': '6'
+    }
     soundex_code = word[0]
     for char in word[1:]:
         if char not in ('H', 'W'):
@@ -72,27 +141,12 @@ def soundex(word):
             soundex_code = soundex_code.replace('0', '') + '000'
     return soundex_code[:4]
 
-# convert special tecken to numbers
-
-def is_number(x):
-    if type(x) == str:
-        x = x.replace(',', '')
-    try:
-        float(x)
-    except:
-        return False
-    return True
-
-def text2int (textnum, numwords={}):
-    
+# Function to convert text to numerical representation
+def text2int(textnum, numwords={}):
     units = ['Z600', 'O500','T000','T600','F600','F100','S220','S150','E300','N500',
              'T500', 'E415', 'T410', 'T635', 'F635', 'F135', 'S235', 'S153', 'E235','N535']
-    # teens = ['T500', 'E415', 'T410', 'T635', 'F635', 'F135', 'S235', 'S153', 'E235','N535']
     tens = ['', '', 'T537', 'T637', 'F637', 'F137', 'S230', 'S153', 'E230', 'N530']
     scales = ['H536', 'T253', 'M450', 'C600']
-    # scale_values = [100, 1_000, 10_0000, 1000_000_000]
-    indian_scales = ['L200', 'C600', 'A610', 'K610']
-    conjunction = ['and']
     ordinal_words = {'oh': 'Z600', 'first': 'O500', 'second': 'T000', 'third': 'T600', 'fourth': 'F600', 'fifth': 'F100',
                      'sixth': 'S200','seventh': 'S150','eighth': 'E230', 'ninth': 'N500', 'twelfth': 'T410'}
     ordinal_endings = [('ieth', 'y'), ('th', '')]
@@ -141,7 +195,6 @@ def text2int (textnum, numwords={}):
 
             if (not is_numword(word)) or (word == 'and' and not lastscale):
                 if onnumber:
-                    # Flush the current number we are building
                     curstring += repr(result + current) + " "
                 curstring += word + " "
                 result = current = 0
@@ -152,25 +205,23 @@ def text2int (textnum, numwords={}):
                 scale, increment = from_numword(word)
                 onnumber = True
 
-                if lastunit and (word not in scales):                                                                                                                                                                                                                                         
-                    # Assume this is part of a string of individual numbers to                                                                                                                                                                                                                
-                    # be flushed, such as a zipcode "one two three four five"                                                                                                                                                                                                                 
-                    curstring += repr(result + current)                                                                                                                                                                                                                                       
-                    result = current = 0                                                                                                                                                                                                                                                      
-
-                if scale > 1:                                                                                                                                                                                                                                                                 
-                    current = max(1, current)                                                                                                                                                                                                                                                 
-
-                current = current * scale + increment                                                                                                                                                                                                                                         
-                if scale > 100:                                                                                                                                                                                                                                                               
-                    result += current                                                                                                                                                                                                                                                         
-                    current = 0                                                                                                                                                                                                                                                               
-
-                lastscale = False                                                                                                                                                                                                              
-                lastunit = False                                                                                                                                                
-                if word in scales:                                                                                                                                                                                                             
-                    lastscale = True                                                                                                                                                                                                         
-                elif word in units:                                                                                                                                                                                                             
+                if lastunit and (word not in scales):
+                    curstring += repr(result + current)
+                    result = current = 0
+
+                if scale > 1:
+                    current = max(1, current)
+
+                current = current * scale + increment
+                if scale > 100:
+                    result += current
+                    current = 0
+
+                lastscale = False
+                lastunit = False
+                if word in scales:
+                    lastscale = True
+                elif word in units:
                     lastunit = True
 
     if onnumber:
@@ -178,107 +229,29 @@ def text2int (textnum, numwords={}):
 
     return curstring
 
-# replace those words which are not correctly spelled to correct words.
-def replace_words(sentence):
-    # Define the replacements
-    replacements = [
-        (r'\bjiro\b', 'zero'),
-        (r'\bjero\b', 'zero'),
-        (r'\bnn\b', 'one'),
-        (r'\bn\b', 'one'),   
-        (r'\bna\b', 'one'),
-        (r'\btu\b', 'two'), 
-        (r'\btoo\b', 'two'),
-        (r'\bthiri\b', 'three'),
-        (r'\bfor\b', 'four'),
-        (r'\bfore\b', 'four'),
-        (r'\bfib\b', 'five'),
-        (r'\bdublseven\b', 'double seven'),
-        (r'\bdubalathri\b', 'double three'),
-        (r'\bnineeit\b', 'nine eight'),
-        (r'\bfipeit\b', 'five eight'),
-        (r'\bdubal\b', 'double'),
-        (r'\bsevenatu\b', 'seven two'),
-    ]
-    # Apply the replacements
-    for pattern, replacement in replacements:
-        sentence = re.sub(pattern, replacement, sentence)
-    return sentence
+# Convert sentence to transcript using Soundex
+def sentence_to_transcript(sentence, word_to_code_map):
+    words = sentence.split()
+    transcript_codes = []
 
-# split text and numbers and get it into different sentences.
-def split_sentence(sentence):
-    # List of word-based numbers
-    word_numbers = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",
-                    "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen",
-                    "seventeen", "eighteen", "nineteen", "twenty", "thirty", "forty", "fifty",
-                    "sixty", "seventy", "eighty", "ninety", "hundred", "thousand", "million",
-                    'zero', 'one', 'on','na','n','tu','two','to','too', 'three','tree','four',
-                    'for','five','fib', 'six', 'seven', 'eight', 'eit', 'nine', 'eit', 'seven', 
-                    'sics', 'thri', 'for', 'eittu', 'eittu', 'nine','dubal','sikas','tri', 'double']
+    for word in words:
+        if word not in word_to_code_map:
+            word_to_code_map[word] = soundex(word)
+        transcript_codes.append(word_to_code_map[word])
     
-    # Split the sentence into tokens
-    tokens = sentence.split()
-    # Initialize variables to store the parts of the sentence
-    pre_numbers = []
-    numbers = []
-    post_numbers = []
-    found_numbers = False
-    # Iterate through the tokens to classify them
-    for token in tokens:
-        if token.lower() in word_numbers:
-            found_numbers = True
-            numbers.append(token)
-        else:
-            if found_numbers:
-                post_numbers.append(token)
-            else:
-                pre_numbers.append(token)  
-    # Join the parts back into sentences
-    sentence1 = ' '.join(pre_numbers)
-    number = ' '.join(numbers)
-    sentence3 = ' '.join(post_numbers)  
-    return sentence1, number, sentence3
-
-# Process double followed by a numbers.
-def process_doubles(sentence):
-    tokens = sentence.split()
-    result = []
-    
-    i = 0
-    while i < len(tokens):
-        if tokens[i] == "double" or tokens[i] == "dubal":
-            if i + 1 < len(tokens):
-                # Repeat the next word twice
-                result.append(tokens[i + 1])
-                result.append(tokens[i + 1])
-                i += 2  # Skip the next word as it's already added twice
-            else:
-                # If "double" is the last word, just add it (although this case is unusual)
-                result.append(tokens[i])
-                i += 1
-        else:
-            result.append(tokens[i])
-            i += 1
-    
-    return ' '.join(result)
+    transcript = ' '.join(transcript_codes)
+    return transcript
+
+# Convert transcript back to sentence using mapping
+def transcript_to_sentence(transcript, code_to_word_map):
+    codes = transcript.split()
+    sentence_words = []
 
-# Concatenate text and numbers and form a single sentence.
-def concatenate_sentences(sentence1, numbers, sentence3):
-    full_sentence = f"{sentence1} {numbers} {sentence3}"
-    return full_sentence
-
-# define a master function to run all the above functions.
-def master_function(initial_input):
-    output_string1 = replace_words(initial_input)
-    sentence1, number, sentence3 = split_sentence(output_string1)
-    processed_sentence = process_doubles(number)
-    text = processed_sentence
-    words = text.strip().split()
-    soundex_codes = [soundex(word) for word in words]
-    combined_text = " ".join(soundex_codes)
-    numbers=text2int(combined_text)
-    full_sentence = concatenate_sentences(sentence1, numbers, sentence3)
-    return full_sentence
+    for code in codes:
+        sentence_words.append(code_to_word_map.get(code, code))
+    
+    sentence = ' '.join(sentence_words)
+    return sentence
     
 ######################################################     
 demo=gr.Interface(