Update app.py

app.py

@@ -1,24 +1,36 @@
+import warnings
+warnings.filterwarnings("ignore")
+
 import gradio as gr
 from transformers import pipeline
+from indictrans import Transliterator
 import os
 import re
+import torchaudio
+
+
+# Initialize the speech recognition pipeline and transliterator
+pipe = pipeline(task="automatic-speech-recognition", model="cdactvm/w2v-bert-2.0-odia_v1")
+trn = Transliterator(source='ori', target='eng', build_lookup=True)
 os.system('git clone https://github.com/irshadbhat/indic-trans.git')
 os.system('pip install ./indic-trans/.')
-p1= pipeline(task="automatic-speech-recognition", model="cdactvm/w2v-bert-2.0-odia_v1")
-p2=pipeline(task="automatic-speech-recognition", model="cdactvm/w2v-bert-2.0-hindi_v1")
+
+p1 = pipeline(task="automatic-speech-recognition", model="cdactvm/w2v-bert-2.0-odia_v1")
+p2 = pipeline(task="automatic-speech-recognition", model="cdactvm/w2v-bert-2.0-hindi_v1")
 
 def transcribe_odiya(speech):
-    #print (p1(speech))
     text = p1(speech)["text"]
-    #text=cleanhtml(text)
+    if text is None:
+        return "Error: ASR returned None"
     return text
+
 def transcribe_hindi(speech):
-    #print (p1(speech))
     text = p2(speech)["text"]
-    #text=cleanhtml(text)
+    if text is None:
+        return "Error: ASR returned None"
     return text
+
 def transcribe_odiya_eng(speech):
-    from indictrans import Transliterator
     trn = Transliterator(source='ori', target='eng', build_lookup=True)
     text = p1(speech)["text"]
     if text is None:
@@ -31,7 +43,6 @@ def transcribe_odiya_eng(speech):
     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"]
     if text is None:
@@ -42,24 +53,6 @@ def transcribe_hin_eng(speech):
     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:
-        audio = mic
-    elif file is not None:
-        audio = file
-    else:
-        return "You must either provide a mic recording or a file"
-    if (lng=="Odiya"):
-        return transcribe_odiya(audio)
-    elif (lng=="Odiya-trans"):
-        return transcribe_odiya_eng(audio)
-    elif (lng=="Hindi-trans"):
-        return transcribe_hin_eng(audio)
-    elif (lng=="Hindi"):
-        return transcribe_hindi(audio)
-
-#####################################################
 
 def process_transcription(input_sentence):
     word_to_code_map = {}
@@ -77,6 +70,24 @@ def process_transcription(input_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
+    elif file is not None:
+        audio = file
+    else:
+        return "You must either provide a mic recording or a file"
+    
+    if lng == "Odiya":
+        return transcribe_odiya(audio)
+    elif lng == "Odiya-trans":
+        return transcribe_odiya_eng(audio)
+    elif lng == "Hindi-trans":
+        return transcribe_hin_eng(audio)
+    elif lng == "Hindi":
+        return transcribe_hindi(audio)
+    
+# Function to replace incorrectly spelled words
 def replace_words(sentence):
     replacements = [
         (r'\bjiro\b', 'zero'), (r'\bjero\b', 'zero'), (r'\bnn\b', 'one'),
@@ -90,6 +101,7 @@ 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 = []
@@ -108,6 +120,7 @@ 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))
@@ -126,6 +139,7 @@ def soundex(word):
             soundex_code = soundex_code.replace('0', '') + '000'
     return soundex_code[:4]
 
+# Function to convert text to numerical representation
 def is_number(x):
     if type(x) == str:
         x = x.replace(',', '')
@@ -136,8 +150,91 @@ def is_number(x):
     return True
 
 def text2int(textnum, numwords={}):
-    if not textnum:
-        return None
+    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:
+                    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):
+                    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):
@@ -151,6 +248,62 @@ def sentence_to_transcript(sentence, word_to_code_map):
     
     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 = []
+
+    for code in codes:
+        sentence_words.append(code_to_word_map.get(code, code))
+    
+    sentence = ' '.join(sentence_words)
+    return sentence
+
+# # Process the audio file
+# transcript = pipe("./odia_recorded/AUD-20240614-WA0004.wav")
+# text_value = transcript['text']
+# sentence = trn.transform(text_value)
+# 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
+# reconstructed_sentence_1 = transcript_to_sentence(numbers, code_to_word_map)
+
+# demo=gr.Interface(
+#     fn=sel_lng, 
+      
+#     inputs=[
+        
+#         gr.Dropdown(["Hindi","Hindi-trans","Odiya","Odiya-trans"],value="Hindi",label="Select Language"),
+#         gr.Audio(source="microphone", type="filepath"),
+#         gr.Audio(source= "upload", type="filepath"),
+#         #gr.Audio(sources="upload", type="filepath"),
+#         #"state"
+#     ],
+#     outputs=[
+#         "textbox"
+# #        #"state"
+#     ],
+#     title="Automatic Speech Recognition",
+#     description = "Demo for Automatic Speech Recognition. Use microphone to record speech. Please press Record button. Initially it will take some time to load the model. The recognized text will appear in the output textbox",
+#       ).launch()
+
     
 ######################################################     
 demo=gr.Interface(