app.py

import gradio as gr
import pandas as pd
import librosa
import os
import torch
import numpy as np
from datasets import Dataset, DatasetDict
from datasets import load_dataset
from df.enhance import enhance, init_df, load_audio, save_audio
model_enhance, df_state, _ = init_df()
def remove_nn(wav, sample_rate=16000):
    
    audio=librosa.resample(wav,orig_sr=sample_rate,target_sr=df_state.sr(),)
    
    audio=torch.tensor([audio])
  #  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=librosa.resample(enhanced[0].numpy(),orig_sr=df_state.sr(),target_sr=sample_rate)
   
    return 16000, audiodata/np.max(audiodata)
class DataEditor:
    def __init__(self,df):
        self.df=df
        self.current_selected = -1
        self.current_page = 0
        self.datatable =df
        self.data =self.df[['text','flag']]
        self.sdata =self.df['audio'].to_list()
    def settt(self,df):
        self.df=pd.DataFrame()
        self.data =pd.DataFrame()
        self.sdata =[]
        self.df=df
        self.next_prveo=0
        self.data =self.df[['text','flag']]
        self.sdata =self.df['audio'].to_list()
        self.current_page = 0
        self.current_selected =1
        return self.data
    def get_output_audio(self):
        return self.sdata[self.current_selected] if self.current_selected >= 0 else None
    def get_prev_page(self,pagenumber):
        if self.next_prveo>=0:
            self.next_prveo-=1
            self.current_page=self.next_prveo
            row = self.data.iloc[self.next_prveo]
            txt_audio = row['text']
            return txt_audio
    def finsh_data(self):
        self.df['audio'] = self.sdata
        self.df[['text','flag']]=self.data
        return self.df
    def login(self, token):
        # Your actual login logic here (e.g., database check)
        if token == os.environ.get("token_login") :
            return gr.update(visible=False),gr.update(visible=True),True
        else:
            return gr.update(visible=True), gr.update(visible=False),None
    def load_demo(self,sesion):
        if sesion:
            return  gr.update(visible=False),gr.update(visible=True)
        
        return gr.update(visible=True), gr.update(visible=False)
    def get_next_page(self,pagenumber):

          if self.next_prveo<9:
            self.next_prveo+=1
            self.current_page=self.next_prveo
            row = self.data.iloc[self.next_prveo]
            txt_audio = row['text']
            return txt_audio


    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  create_Tabs(self): # fix: method was missing
        #with gr.Blocks() as interface:
             with gr.Tabs():
                  
                  with gr.TabItem("Dir"):
                        self.text_input = gr.Textbox(lines=5, placeholder="Enter your text here...",rtl=True)
                        self.sigmant_word=gr.Number(label="sigmant_word",value=6)
                        self.buttonn = gr.Button("Create Table")
                  with gr.TabItem("Cut  Text"):
                       self.txturll = gr.Textbox(placeholder="link dir", interactive=True)
                       self.btn_displayy = gr.Button("Load Dataset",scale=1, size="sm")

    def convert_to_dataframe(self,chunks):
          df = pd.DataFrame({'Text': chunks, 'Flag': 0, 'Audio': None })
          return df
    def create_chunks_with_properties(self,text,sigmant_word):
           words = text.split()  # تقسيم النص إلى كلمات
           chunks = []
           current_chunk = []
           for word in words:
            current_chunk.append(word)
            if len(current_chunk) ==sigmant_word:  # إذا وصل عدد الكلمات في الجزء الحالي إلى 6
              chunks.append(" ".join(current_chunk))  # إضافة الجزء إلى القائمة وإعادة تهيئة الجزء الحالي
              current_chunk = []
        
           if current_chunk:  # إضافة الجزء الأخير إذا لم يكن فارغًا
             chunks.append(" ".join(current_chunk))
        
           chunks=self.convert_to_dataframe(chunks)
           v=self.settt(df)
           return v
                         
    def convert_dataframe_to_dataset(self, namedata):
        datatable=self.finsh_data()
        if "__index_level_0__" in datatable.columns:
               datatable =datatable.drop(columns=["__index_level_0__"])
        train_df =datatable
        ds = {
            "train": Dataset.from_pandas(train_df)
        }
        dataset = DatasetDict(ds)
        #dirr = '/content/drive/MyDrive/vitsM/DATA/sata/NewData2hba/' + namedata
        #dataset.save_to_disk(dirr)
        dataset.push_to_hub(namedata,token=os.environ.get("auth_acess_data"),private=True)
        return namedata
        
    def read_dataset(self, link):
        try:
            dataset =load_dataset(link,token=os.environ.get("auth_acess_data")) 
            df= dataset["train"].to_pandas()
            v=self.settt(df)
            return self.get_page_data(self.current_page),link

        except FileNotFoundError:
            return None, f"Error: Dataset not found at {link}"
        except Exception as e:
            return None, f"Error loading dataset: {e}"
    def on_select(self,evt:gr.SelectData):
        if evt.index:
            index_now = evt.index[0]
            self.current_selected = (self.current_page * 10) + index_now
            row = self.data.iloc[self.current_selected]
            txt_audio = row['text']
            row_audio = self.sdata[self.current_selected]
            if row['flag'] !=0:
                return txt_audio,(16000,row_audio)
            else :
                return txt_audio,None
          

        else:
            return None," "
    def on_saveAs_row(self):
        return self.get_page_data(self.current_page),None,""

    def on_row_save(self, text,data_oudio):
        if text!="" and data_oudio is not None:                         

                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:
                    audio=audio.astype(np.float32)
                    audio/=np.max(np.abs(audio))
                    audio=librosa.resample(audio,orig_sr=sr,target_sr=16000)
                self.sdata[self.current_selected] =audio
               
        return  "",None
    def on_row_delete(self):
        if self.current_selected>=0:
              row = self.data.iloc[self.current_selected]
                #row['text'] = text
              row['flag']=0
              self.data.iloc[self.current_selected] = row
              self.sdata[self.current_selected] = None



        return self.get_page_data(self.current_page),None,""
    def startt(self):
        with gr.Blocks() as demo:
                        sesion_state = gr.State()
            
                        with gr.Column(scale=1, min_width=200,visible=True) as login_panal:  # Login panel
                                gr.Markdown("## auth acess page")
                                token_login = gr.Textbox(label="token")
                              
                                login_button = gr.Button("Login")
                        with gr.Column(scale=1, visible=False) as main_panel:
                                 self.create_interface()
                               
                        login_button.click(self.login, inputs=[token_login], outputs=[login_panal,main_panel,sesion_state])
                        demo.load(self.load_demo, [sesion_state], [login_panal,main_panel])


        return demo
    def create_interface(self):
       # with gr.Blocks() as demo:
                          
            with gr.Row():
                self.create_Tabs()
                #self.txturll = gr.Textbox(placeholder="link dir", interactive=True)
                #self.btn_displayy = gr.Button("Load Dataset",scale=1, size="sm",variant="primary")
            with gr.Row():
                with gr.Column():
                    self.table = gr.Dataframe(value=self.datatable, headers=['text', 'audio'], interactive=True)
                    with gr.Row(equal_height=False):
                            self.prev_button = gr.Button("Previous Page",scale=1, size="sm",variant="primary")
                            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",variant="primary")
                    with gr.Column():
                        self.txtsaveurl = gr.Textbox(placeholder="Save Dataset", interactive=True)
                        self.btn_savedataset = gr.Button("Save Dataset",scale=1, size="sm",variant="primary")
                        self.label =gr.Text("STATE")

                with gr.Column():

                     self.txt_audio = gr.Textbox(label="Audio Text", interactive=True,rtl=True)
                     self.btn_record = gr.Audio(interactive=True)

                     with gr.Row():
                          self.btn_save = gr.Button("Save", size="sm",variant="primary",min_width=50)
                          self.btn_saveAs = gr.Button("SaveAs", size="sm",variant="primary",min_width=50)
                          self.btn_enhance = gr.Button("enhance ", size="sm",variant="primary",min_width=50)
                         # self.buttonnext=gr.Button("Next",)
                         # self.buttonprev=gr.Button("Prev")
                          self.btn_delete = gr.Button("Delete", size="sm",variant="primary",min_width=50)


            self.btn_displayy.click(self.read_dataset, [self.txturll], [self.table, self.txtsaveurl])
            self.table.select(self.on_select, None,[self.txt_audio,self.btn_record])
            self.btn_save.click(self.on_row_save, [self.txt_audio,self.btn_record],[self.txt_audio,self.btn_record])
            self.btn_saveAs.click(self.on_saveAs_row, [], [self.table,self.btn_record , self.txt_audio])
            self.btn_delete.click(self.on_row_delete, [], [self.table,self.btn_record , self.txt_audio])
            #self.buttonnext.click(lambda page:self.get_next_page(page+1), [self.page_number], [self.txt_audio])
            #self.buttonprev.click(lambda page:self.get_prev_page(page-1), [self.page_number], [self.txt_audio])
            self.btn_savedataset.click(self.convert_dataframe_to_dataset, [self.txtsaveurl], [self.label])
            self.prev_button.click(lambda page: self.update_page(page - 1), [self.page_number], [self.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.btn_enhance.click(lambda: remove_nn(self.get_output_audio()), [],self.btn_record)
            self.buttonn.click(self.create_chunks_with_properties,[self.text_input,self.sigmant_word],[self.table])
            self.next_button.click(lambda page: self.update_page(page + 1), [self.page_number], [self.table, self.prev_button, self.next_button, self.page_number])
        #demo.launch()
df1=pd.DataFrame(columns=['text','flag','audio'])
editor = DataEditor(df1)
demo=editor.startt()
demo.launch()