Update app.py

app.py

@@ -1,7 +1,419 @@
 import gradio as gr
+import pandas as pd
+import numpy as np
+from df.enhance import enhance, init_df, load_audio, save_audio
 
-def greet(name):
-    return "Hello " + name + "!!"
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+def Read_DataSet(link):
+        dataset = DatasetDict.load_from_disk(link)
+        df = dataset["train"].to_pandas()
+        return df
+
+
+def remove_nn(wav, sample_rate=16000):
+    sf.write("full_generation.wav", wav, sample_rate, format='WAV')
+    audio, _ = load_audio('full_generation.wav', sr=df_state.sr())
+    enhanced = enhance(model_enhance, df_state, audio)
+    save_audio("enhanced.wav", enhanced, df_state.sr())
+    audiodata, samplerate = librosa.load("enhanced.wav", sr=16000)
+    return 16000, audiodata
+class DataViewerApp:
+    def __init__(self,df):
+        #df=Read_DataSet(link)
+        self.df=df
+       # self.df1=df
+        self.data =self.df[['text','speaker_id','secs','flag']]
+        self.dataa =self.df[['text','speaker_id','secs','flag']]
+        self.sdata =self.df['audio'].to_list()   # Separate audio data storage
+        self.current_page = 0
+        self.current_selected = -1
+        self.speaker_id= -1
+        class Seafoam(Base):
+            pass
+        self.seafoam = Seafoam()
+
+        #self.data =df[['text','speaker_id']]
+        #self.sdata = df['audio'].to_list()  # Separate audio data storage
+        #self.current_page = 0
+        #self.current_selected = -1
+
+    def settt(self,df):
+        self.df=pd.DataFrame()
+        self.data =pd.DataFrame()
+        self.sdata =[]
+        self.df=df
+        self.data =df[['text','speaker_id','secs','flag']]
+        self.dataa =df[['text','speaker_id','secs','flag']]
+        self.sdata =df['audio'].to_list()
+        self.current_page = 0
+        self.current_selected =1
+        self.speaker_id= -1
+        return self.data
+    def splitt(self,link,num):
+        df=download_youtube_video(link,num)
+        v=self.settt(df)
+        return self.get_page_data(self.current_page),len(v)
+    def getdataset(self,link):
+        df=Read_DataSet(link)
+        v=self.settt(df)
+        return self.get_page_data(self.current_page),len(v)
+    def remove_hamza_from_alif_and_symbols(self,text):
+            text = re.sub(r"[أإآ]", "ا", text)
+            text = re.sub(r"ٱ", "ا", text)
+            text = re.sub(r"[_\-\+\,\(\)]", " ", text)
+            text = re.sub(r"\d", " ", text)
+            return text
+    def save_row(self, text,data_oudio):
+        row = self.data.iloc[self.current_selected]
+        row['text'] = text
+        row['flag']=1
+        self.data.iloc[self.current_selected] = row
+        sr,audio=data_oudio
+        if sr!=16000:
+            sf.write("temp.wav", audio, sr,format='WAV')
+            audio, samplerate = librosa.load("temp.wav", sr=16000)
+
+        self.sdata[self.current_selected] = audio
+        return self.get_page_data(self.current_page)
+    def GetDataset_2(self,filename,ds=1.5):
+        audios_data = []
+        audios_samplerate = []
+        num_specker=[]
+        texts=[]
+        secs=[]
+
+        audiodata,samplerate = librosa.load(filename, sr=16000) # Removed extra indent here
+        audios_data.append(audiodata*ds)
+        audios_samplerate.append(samplerate)
+        texts.append(filename.replace('.wav',''))
+        secs.append(round(len(audiodata)/samplerate,2))
+        df = pd.DataFrame()
+        df['secs'] = secs
+        df['audio'] = audios_data
+        df['samplerate'] = audios_samplerate
+        df['text'] =os.path.splitext(os.path.basename(filename))[0]
+        df['speaker_id'] =self.speaker_id
+        df['_speaker_id'] =self.speaker_id
+        df['flag']=1
+        df = df[['text','audio','samplerate','secs','speaker_id','_speaker_id','flag']]
+        self.df = pd.concat([self.df, df], axis=0, ignore_index=True)
+        self.data =self.df[['text','speaker_id','secs','flag']]
+        self.sdata =self.df['audio'].to_list()
+
+        return self.get_page_data(self.current_page)
+    def trim_audio(self, text,data_oudio):
+  # Load audio
+        #row = self.data.iloc[self.current_selected]
+        #row['text'] = text  # Use .loc for safer row modification
+        #self.data.iloc[self.current_selected] = row
+        audios_data = []
+        audios_samplerate = []
+
+        sr,audio=data_oudio
+        #if sr!=16000:
+        namefile=f"{text}.wav"
+        sf.write(namefile, audio, sr,format='WAV')
+        return self.GetDataset_2(namefile)
+            #audio, samplerate = librosa.load("tempppp.wav", sr=16000)
+            #audios_data.append(audio)
+           # secs=round(len(audios_data)/samplerate,2)
+            #audios_samplerate.append(samplerate)
+        #else:
+          #  secs=round(len(audio)/sr,2)
+           # audios_data.append(audio)
+            #audios_samplerate.append(sr)
+        #secs.append(round(len(audios_data)/samplerate,2))
+        #self.df['secs'] = secs
+        #self.df['audio'] = audios_data
+        #self.df['samplerate'] = sr
+        #self.df['text'] =text
+        #self.df =self.df[['text','audio','samplerate','secs']]
+        #self.df.reset_index(drop=True, inplace=True)
+        #self.data =self.df[['text','speaker_id','secs']]
+
+
+        #self.sdata =df['audio'].to_list()
+
+
+
+        #return self.data,5.8
+    def connect_drive(self):
+        from google.colab import drive
+        drive.mount('/content/drive')
+    def get_page_data(self, page_number):
+        start_index = page_number * 10
+        end_index = start_index + 10
+        return self.data.iloc[start_index:end_index]
+    def update_page(self, new_page):
+        self.current_page = new_page
+        return (
+            self.get_page_data(self.current_page),
+            self.current_page > 0,
+            self.current_page < len(self.data) // 10 - 1,
+            self.current_page
+        )
+    def clear_txt(self):
+        self.data['text'] =self.data['text'].apply(self.remove_hamza_from_alif_and_symbols)
+        return self.get_page_data(self.current_page)
+    def  get_text_from_audio(self,audio):
+
+         sf.write("temp.wav", audio, 16000,format='WAV')
+
+         client = Client("MohamedRashad/Arabic-Whisper-CodeSwitching-Edition")
+         result = client.predict(
+         inputs=handle_file('temp.wav'),
+         api_name="/predict_1"
+    )
+         return result
+    def on_column_dropdown_change_operater(self,selected_column,selected_column1):
+        if selected_column1==">":
+            return self.data[self.data['secs'] > selected_column ]
+        elif selected_column1=="<":
+            return self.data[self.data['secs'] < selected_column]
+        elif selected_column1=="=":
+            return self.data[self.data['secs'] == selected_column]
+        else:
+            return self.data
+            # Perform actions based on the selected column
+
+    def on_column_dropdown_change(self,selected_column):
+        data=self.df1
+        if selected_column=="all":
+
+            return self.settt(data)
+        else:
+            data=data[data['speaker_id'] ==selected_column]
+            return self.settt(data)
+
+             # Perform actions based on the selected column
+
+    def on_select(self,evt:gr.SelectData):
+        index_now = evt.index[0]
+        self.current_selected = (self.current_page * 10) + index_now
+        row = self.data.iloc[self.current_selected]
+        row_audio = self.sdata[self.current_selected]
+        self.speaker_id=row['speaker_id']
+        return (16000, row_audio), row['text']
+    def finsh_data(self):
+        self.df['audio'] = self.sdata
+        self.df[['text','speaker_id','secs','flag']]=self.data
+
+        return self.df
+    def All_enhance(self):
+        for i in range(0,len(self.sdata)):
+              _,y=remove_nn(self.sdata[i])
+              self.sdata[i]=y
+        return self.data
+
+        return self.get_page_data(self.current_page)
+    def get_output_audio(self):
+        return self.sdata[self.current_selected] if self.current_selected >= 0 else None
+    def Convert_DataFreme_To_DataSet(self,namedata):
+           df=self.finsh_data()
+
+           df['audio'] = df['audio'].apply(lambda x: np.array(x, dtype=np.float32))
+           if "__index_level_0__" in df.columns:
+                df =df.drop(columns=["__index_level_0__"])
+           train_df =df
+
+           eval_df =df.sample(1,random_state=42)
+
+           ds = {
+                "train": Dataset.from_pandas(train_df),
+                 "eval": Dataset.from_pandas(eval_df),
+                 "full_generation":Dataset.from_pandas(eval_df)
+                 }
+
+           dataset = DatasetDict(ds)
+           dirr='/content/drive/MyDrive/vitsM/DATA/sata/'+namedata
+           dataset.save_to_disk(dirr)
+           return dirr
+
+    def delete_row(self):
+
+        self.data.drop(self.current_selected, inplace=True)
+        self.data.reset_index(drop=True, inplace=True)
+        self.df.drop(self.current_selected, inplace=True)
+        self.df.reset_index(drop=True, inplace=True)
+        self.sdata.pop(self.current_selected)
+        self.current_selected = -1
+        # self.audio_player.update(None)  # Clear audio player
+        # self.txt_audio.update("")  # Clear text input
+
+        return self.get_page_data(self.current_page)
+    def start_tab1(self):
+        with gr.Blocks(theme=self.seafoam, css="""
+    .checkbox-group label {
+        background-color: #f0f0f5; /* لون خلفية فاتح */
+        padding: 10px;
+        border-radius: 5px; /* زوايا دائرية */
+    }
+        const textbox = document.querySelector('.txt_audio'); // تحديد المكون النصي
+        textbox.style.direction = 'ltr';
+    .checkbox-group input:checked + label {
+        background-color: #e0f0ff; /* لون خلفية عند التحديد */
+        font-weight: bold;
+    }
+""") as demo:
+
+             with gr.Row(equal_height=False):
+                  with gr.Tabs():
+                       with gr.TabItem("Processing Data  "):
+                           self.data_Processing()
+        return demo
+    def  create_Tabs(self): # fix: method was missing
+        #with gr.Blocks() as interface:
+             with gr.Tabs():
+                  with gr.TabItem("Excel"):
+                       with gr.Row():
+                           txt_filepath_excel=gr.Text("NameFile")
+                           txt_text_excel=gr.Text("Text" )
+                           but_send_excel=gr.Button("Send",size="sm")
+
+                  with gr.TabItem("CVC"):
+                          with gr.Row():
+                           txt_filepath_cvc=gr.Text("File")
+                           txt_text_cvc=gr.Text("Text" )
+                           but_send_cvc=gr.Button("Send",size="sm")
+                  with gr.TabItem("DateSet"):
+                           self.txt_filepath_dir=gr.Text("link dir",interactive=True)
+                           #self.txt_text=gr.Text("Text" )
+                           self.but_send_dir=gr.Button("Send",size="sm")
+                  with gr.TabItem("Dir"):
+                        txt_filepath_dateSet=gr.Text("link DateSet")
+                           #self.txt_text=gr.Text("Text" )
+                        but_send_dateSet=gr.Button("Send",size="sm")
+                  with gr.TabItem("Cut  Video"):
+                       self.txt_filepath_dateSet=gr.Text("رابط الفيديو",interactive=True)
+                       self.num = gr.Number(label=" ادخل رقم طبيعي")
+
+                       self.but_send_dateSet_cut=gr.Button("Send",size="sm")
+
+    def Convert_DataFrame_to_Bitch(self):
+        with gr.Row():
+                           self.txt_output_dir=gr.Text("output Name dir",interactive=True)
+                           self.txt_train_batch_size=gr.Text("train_batch_size",interactive=True)
+                           self.txt_eval_batch_size=gr.Text("eval_batch_size",interactive=True )
+                           self.but_convert_bitch=gr.Button("Convert Bitch",size="sm")
+        with gr.Row():
+                           self.label_Bitch=gr.Label("Dir Output Bitch :")
+
+
+    def data_Processing(self):
+
+         #with gr.Column(scale=2,min_width=40):
+
+             #with gr.Row():
+                    #with gr.Accordion("Open Data", open=False):
+                         #with gr.Row():
+                            #  self.txt_filepath_dateSet=gr.Text("link DateSet",interactive=True)
+                              #self.txt_text=gr.Text("Text" )
+                              #self.but_send_dateSet=gr.Button("Send",size="sm")
+
+
+         with gr.Accordion("Install Data", open=False):
+                with gr.Row():
+                              self.create_Tabs()
+         with gr.Row():
+                             columns = []
+                             columns1 = []
+
+                             columns =unique_speaker_ids =self.df['speaker_id'].unique().tolist()
+                             columns.append("all")
+                             self.labell=gr.Label("count:")
+                             self.column_dropdown = gr.Dropdown(choices=columns, label="speaker_id")
+                             with gr.Row():
+
+                                  columns1=unique_speaker_ids =self.df['secs'].unique().tolist()
+                                  columns1.append("all")
+                                  self.column_dropdown1 = gr.Dropdown(choices=columns1 , label="secs")
+
+                                  self.column_dropdown11 = gr.Dropdown(choices=["all","<",">","="], label="operater")
+
+
+         with gr.Row():
+
+
+                   with gr.Column(scale=2):
+                        gr.Markdown("## Data Viewer")
+                        #d=self.get_page_data(self.current_page)
+                        # Correct the indentation here:
+                        self.data_table = gr.DataFrame(  # Notice 'self.' here
+                            value=self.get_page_data(self.current_page),
+                            headers=["Text","speaker_id"])
+
+                   # interactive=True
+
+                        #self.data_table1 = gr.DataFrame(headers=[ "Text","Id_spiker"])
+                        with gr.Row(equal_height=False):
+                            self.prev_button = gr.Button("Previous Page",scale=1, size="sm")
+                            self.page_number = gr.Number(value=self.current_page + 1, label="Page",scale=1)
+                            self.next_button = gr.Button("Next Page",scale=1, size="sm")
+
+                        with gr.Row(equal_height=False):
+
+                             #inputs=gr.CheckboxGroup(["John", "Mary", "Peter", "Susan"])
+                             self.but_cleartxt=gr.Button("clear Text",variant="primary")
+                             self.btn_all_enhance=gr.Button("All enhance",size="sm",variant="primary")
+
+
+
+
+
+
+
+
+
+
+                   with gr.Column(scale=1):
+                            gr.Markdown("## Row Data")
+                            self.txt_audio = gr.Textbox(label="Text", interactive=True,rtl=True)
+
+                            self.audio_player = gr.Audio(label="Audio")
+                            self.btn_del = gr.Button("Delete  ", size="sm",variant="primary")
+                            self.btn_save = gr.Button("Save", size="sm",variant="primary")
+                            self.totext=gr.Button("to text",size="sm" ,variant="primary")
+                            self.btn_newsave=gr.Button("New Save Cut",size="sm",variant="primary")
+                            self.btn_enhance = gr.Button("enhance ", size="sm",variant="primary")
+                            self.order= gr.Button("order ", size="sm",variant="primary")
+                          #  self.btn_all_enhance=gr.Button("All enhance",size="sm")
+
+
+
+
+         with gr.Row(equal_height=False,variant="heading-1"):
+              with gr.Accordion("Save Bitch", open=False):
+
+                                       self.txt_dataset=gr.Text("save dataset",interactive=True)
+                                       self.btn_convertDataset=gr.Button("Dir Output Bitch :",variant="primary")
+                                       self.label_dataset=gr.Label("count:")
+         self.but_send_dir.click(self.getdataset, [self.txt_filepath_dir],[self.data_table,self.labell])
+         #self.but_send_dateSet_cut.click(self.splitt, [self.txt_filepath_dateSet,self.num],[self.data_table,self.labell])
+         #self.txt_audio.Style(container=False, css=".txt_audio { direction: rtl; }")
+         #self.but_send_dateSet.click(self.Read_DataSet, [self.txt_filepath_dateSet],[self.data_table ])
+         self.data_table.select(self.on_select, None, [self.audio_player, self.txt_audio])
+         self.prev_button.click(lambda page: self.update_page(page - 1), [self.page_number], [self.data_table, self.prev_button, self.next_button, self.page_number])
+                   #self.btn_save.click(self.save_row, [self.txt_audio,self.audio_player], [self.data_table])
+         self.next_button.click(lambda page: self.update_page(page + 1), [self.page_number], [self.data_table, self.prev_button, self.next_button, self.page_number])
+         self.column_dropdown.change(self.on_column_dropdown_change,[self.column_dropdown], [self.data_table])
+         self.column_dropdown11.change(self.on_column_dropdown_change_operater,[self.column_dropdown1,self.column_dropdown11], [self.data_table])
+         self.btn_convertDataset.click(self.Convert_DataFreme_To_DataSet,[self.txt_dataset],[self.label_dataset])
+         self.totext.click(lambda:self.get_text_from_audio(self.get_output_audio()), [], self.txt_audio)
+         self.btn_newsave.click(self.trim_audio,[self.txt_audio,self.audio_player],[self.data_table])
+         self.btn_save.click(self.save_row, [self.txt_audio,self.audio_player], [self.data_table])
+         #self.btn_save.click(self.save_row, [self.txt_audio,self.audio_player], [self.data_table])
+         self.btn_all_enhance.click(self.All_enhance,[],[self.data_table])
+         #self.btn_enhance.click(remove_nn, [self.audio_player], [self.audio_player])
+         self.but_cleartxt.click(self.clear_txt,[],[self.data_table])
+         self.btn_del.click(self.delete_row,[], [self.data_table])
+         self.btn_enhance.click(lambda: remove_nn(self.get_output_audio()), [], self.audio_player)
+         #self.column_dropdown.change(lambda selected_column:self.settt(self.on_column_dropdown_change(selected_column)), [self.column_dropdown], [self.data_table])
+         #self.column_dropdown.change(lambda selected_column:self.settt(x.on_column_dropdown_change(selected_column)), [x.column_dropdown], [self.data_table])
+         #self.btn_denoise.click(self.remove_nn, [self.audio_player], [self.audio_player])
+
+
+
+dff=pd.DataFrame(columns=['text', 'audio', 'samplerate', 'secs', 'speaker_id', '_speaker_id','flag'])
+app=DataViewerApp(dff)
+s=app.start_tab1()
+s.launch()