Update app.py

app.py

@@ -21,55 +21,27 @@ 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)
+    if text is None:
+        return "Error: ASR returned None"
     sentence = trn.transform(text)
+    if sentence is None:
+        return "Error: Transliteration returned None"
     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
+    return process_transcription(processed_sentence)
 
 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)
+    if text is None:
+        return "Error: ASR returned None"
     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 sentence
+    if sentence is None:
+        return "Error: Transliteration returned None"
+    replaced_words = replace_words(sentence)
+    processed_sentence = process_doubles(replaced_words)
+    return process_transcription(processed_sentence)
     
 def sel_lng(lng,mic=None, file=None):
     if mic is not None:
@@ -89,6 +61,21 @@ def sel_lng(lng,mic=None, file=None):
 
 #####################################################
 
+def process_transcription(input_sentence):
+    word_to_code_map = {}
+    code_to_word_map = {}
+
+    transcript_1 = sentence_to_transcript(input_sentence, word_to_code_map)
+    if transcript_1 is None:
+        return "Error: Transcript conversion returned None"
+
+    numbers = text2int(transcript_1)
+    if numbers is None:
+        return "Error: Text to number conversion returned None"
+
+    code_to_word_map = {v: k for k, v in word_to_code_map.items()}
+    text = transcript_to_sentence(numbers, code_to_word_map)
+    return text
 
 def replace_words(sentence):
     replacements = [
@@ -103,7 +90,6 @@ def replace_words(sentence):
         sentence = re.sub(pattern, replacement, sentence)
     return sentence
 
-# Function to process "double" followed by a number
 def process_doubles(sentence):
     tokens = sentence.split()
     result = []
@@ -122,7 +108,6 @@ def process_doubles(sentence):
             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))
@@ -150,122 +135,10 @@ def is_number(x):
         return False
     return True
 
-# 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']
-    tens = ['', '', 'T537', 'T637', 'F637', 'F137', 'S230', 'S153', 'E230', 'N530']
-    scales = ['H536', 'T253', 'M450', 'C600']
-    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', '')]
-    if not numwords:
-        numwords['and'] = (1, 0)
-        for idx, word in enumerate(units): numwords[word] = (1, idx)
-        for idx, word in enumerate(tens): numwords[word] = (1, idx * 10)
-        for idx, word in enumerate(scales): numwords[word] = (10 ** (idx * 3 or 2), 0)
-
-    textnum = textnum.replace('-', ' ')
-
-    current = result = 0
-    curstring = ''
-    onnumber = False
-    lastunit = False
-    lastscale = False
-
-def is_numword(x):
-    if is_number(x):
-        return True
-    if word in numwords:
-        return True
-    return False
-
-
-    def from_numword(x):
-        if is_number(x):
-            scale = 0
-            increment = int(x.replace(',', ''))
-            return scale, increment
-        return numwords[x]
-
-    for word in textnum.split():
-        if word in ordinal_words:
-            scale, increment = (1, ordinal_words[word])
-            current = current * scale + increment
-            if scale > 100:
-                result += current
-                current = 0
-            onnumber = True
-            lastunit = False
-            lastscale = False
-        else:
-            for ending, replacement in ordinal_endings:
-                if word.endswith(ending):
-                    word = "%s%s" % (word[:-len(ending)], replacement)
-
-            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
-                onnumber = False
-                lastunit = False
-                lastscale = False
-            else:
-                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:                                                                                                                                                                                                             
-                    lastunit = True
-
-    if onnumber:
-        curstring += repr(result + current)
-
-    return curstring
-
-
-# Convert sentence to transcript using Soundex
-def sentence_to_transcript(sentence, word_to_code_map):
-    words = sentence.split()
-    transcript_codes = []
-
-    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])
-    
-    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 = []
+    if not textnum:
+        return None
 
-    for code in codes:
-        sentence_words.append(code_to_word_map.get(code, code))
-    
-    sentence = ' '.join(sentence_words)
-    return sentence
     
 ######################################################     
 demo=gr.Interface(