Update app.py

app.py

@@ -1,48 +1,167 @@
- 
-import gradio as gr
-import pandas as pd
-import numpy as np
-from df.enhance import enhance, init_df, load_audio, save_audio
-import time
+from __future__ import annotations
+
+import logging
 import os
-import gradio as gr
 import re
-from gradio.themes.base import Base
-from datasets import load_dataset
-from datasets import Dataset,DatasetDict
+from functools import lru_cache
+from typing import Any
+
+import gradio as gr
 import librosa
+import numpy as np
+import pandas as pd
+import soundfile as sf
 import torch
+from datasets import Dataset, DatasetDict, load_dataset
+from gradio.themes.base import Base
+from gradio_client import Client, handle_file
+
+LOGGER = logging.getLogger("audio-dataset-manager")
+logging.basicConfig(
+    level=os.getenv("LOG_LEVEL", "INFO"),
+    format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+)
+
+TARGET_SAMPLE_RATE = 16_000
+HF_TOKEN_ENV = "auth_acess_data"
+LOGIN_TOKEN_ENV = "token_login"
+
+
+class DeepFilterNetUnavailable(RuntimeError):
+    """Raised when DeepFilterNet is not installed or cannot be initialized."""
+
+
+@lru_cache(maxsize=1)
+def get_enhancer():
+    """
+    Load DeepFilterNet lazily.
+
+    Lazy loading prevents the whole Space from crashing during startup and
+    avoids loading the model until enhancement is actually requested.
+    """
+    try:
+        from df.enhance import enhance, init_df
+    except ModuleNotFoundError as exc:
+        raise DeepFilterNetUnavailable(
+            "DeepFilterNet is not installed. Add `deepfilternet==0.5.6` "
+            "to requirements.txt, then rebuild the Space."
+        ) from exc
+
+    try:
+        model, state, _ = init_df()
+        model.eval()
+        return enhance, model, state
+    except Exception as exc:
+        LOGGER.exception("DeepFilterNet initialization failed")
+        raise DeepFilterNetUnavailable(
+            f"DeepFilterNet could not be initialized: {exc}"
+        ) from exc
+
+
+def _as_mono_float32(audio: Any) -> np.ndarray:
+    """Convert supported audio input to finite mono float32 samples."""
+    array = np.asarray(audio, dtype=np.float32)
+
+    if array.ndim == 2:
+        # Gradio may return (samples, channels).
+        array = array.mean(axis=1)
+    elif array.ndim != 1:
+        array = array.reshape(-1)
+
+    array = np.nan_to_num(array, nan=0.0, posinf=0.0, neginf=0.0)
+    peak = float(np.max(np.abs(array))) if array.size else 0.0
+    if peak > 1.0:
+        array = array / peak
+    return np.ascontiguousarray(array, dtype=np.float32)
+
+
+def normalize_audio(audio: Any, eps: float = 1e-8) -> np.ndarray:
+    array = _as_mono_float32(audio)
+    if array.size == 0:
+        return array
+
+    peak = float(np.max(np.abs(array)))
+    return array if peak < eps else array / peak
+
+
+def read_dataset(link: str) -> pd.DataFrame:
+    if not link or not link.strip():
+        raise gr.Error("أدخل رابط أو اسم Dataset صحيح.")
+
+    token = os.getenv(HF_TOKEN_ENV) or None
+    try:
+        dataset = load_dataset(link.strip(), token=token)
+    except Exception as exc:
+        LOGGER.exception("Dataset loading failed: %s", link)
+        raise gr.Error(f"تعذر تحميل Dataset: {exc}") from exc
+
+    split = "train" if "train" in dataset else next(iter(dataset.keys()))
+    frame = dataset[split].to_pandas()
+
+    required = {
+        "text": "",
+        "audio": None,
+        "samplerate": TARGET_SAMPLE_RATE,
+        "secs": 0.0,
+        "speaker_id": -1,
+        "_speaker_id": -1,
+        "flag": 0,
+    }
+    for column, default in required.items():
+        if column not in frame.columns:
+            frame[column] = default
 
-model_enhance, df_state, _ = init_df()
-def Read_DataSet(link):
-        dataset = load_dataset(link,token=os.environ.get("auth_acess_data"))
-        df = dataset["train"].to_pandas()
-        return df
+    return frame
 
 
+# Backward-compatible name used by the original callbacks.
+Read_DataSet = read_dataset
 
 
-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())
-    print(audio)
-    
-    enhanced = enhance(model_enhance, df_state, audio)
-    print(enhanced)
-   # 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)
+def remove_nn(wav: Any, sample_rate: int = TARGET_SAMPLE_RATE):
+    """
+    Enhance a waveform with DeepFilterNet and return a Gradio audio tuple.
+    """
+    if wav is None:
+        raise gr.Error("اختر ملفًا صوتيًا أولًا.")
+
+    audio = normalize_audio(wav)
+    if audio.size == 0:
+        raise gr.Error("الملف الصوتي فارغ.")
+
+    enhance_fn, model, state = get_enhancer()
+    model_sr = int(state.sr())
+
+    if sample_rate != model_sr:
+        audio = librosa.resample(
+            audio,
+            orig_sr=int(sample_rate),
+            target_sr=model_sr,
+            res_type="soxr_hq",
+        )
+
+    tensor = torch.from_numpy(audio).unsqueeze(0)
+
+    with torch.inference_mode():
+        enhanced = enhance_fn(model, state, tensor)
+
+    enhanced_np = enhanced.squeeze(0).detach().cpu().numpy()
+
+    if model_sr != TARGET_SAMPLE_RATE:
+        enhanced_np = librosa.resample(
+            enhanced_np,
+            orig_sr=model_sr,
+            target_sr=TARGET_SAMPLE_RATE,
+            res_type="soxr_hq",
+        )
 
+    return TARGET_SAMPLE_RATE, normalize_audio(enhanced_np)
 
 
 
 class DataViewerApp:
     def __init__(self,df):
-        #df=Read_DataSet(link)
+        #df=read_dataset(link)
         self.df=df
        # self.df1=df
         self.data =self.df[['text','speaker_id','secs','flag']]
@@ -93,7 +212,7 @@ class DataViewerApp:
         return self.get_page_data(self.current_page),len(v)
     def getdataset(self,link):
         self.link_dataset=link
-        df=Read_DataSet(link)
+        df=read_dataset(link)
         v=self.settt(df)
         return self.get_page_data(self.current_page),len(v),self.link_dataset
     def remove_hamza_from_alif_and_symbols(self,text):
@@ -111,7 +230,7 @@ class DataViewerApp:
                 sr,audio=data_oudio
                 if sr!=16000:
                     audio=audio.astype(np.float32)
-                    audio/=np.max(np.abs(audio))
+                    audio=normalize_audio(audio)
                     audio=librosa.resample(audio,orig_sr=sr,target_sr=16000)
                      
                      
@@ -119,9 +238,9 @@ class DataViewerApp:
                       
         
                 self.sdata[self.current_selected] = audio
-                self.df['text'][self.current_selected] =text
-                self.df['audio'][self.current_selected] = audio
-                self.df['flag'][self.current_selected] =1
+                self.df.loc[self.current_selected, 'text'] = text
+                self.df.at[self.current_selected, 'audio'] = audio
+                self.df.loc[self.current_selected, 'flag'] = 1
         return self.get_page_data(self.current_page),None,""
     def GetDataset_2(self,filename,ds=1.5):
         audios_data = []
@@ -155,10 +274,10 @@ class DataViewerApp:
                 audios_samplerate = []
                 sr,audio=data_oudio
                 audio=audio.astype(np.float32)
-                audio/=np.max(np.abs(audio))
+                audio=normalize_audio(audio)
                 audio=librosa.resample(audio,orig_sr=sr,target_sr=16000)
                 audios_data.append(audio)
-                secs=round(len(audios_data)/16000,2)
+                secs=round(len(audio)/TARGET_SAMPLE_RATE, 2)
                 audios_samplerate.append(16000)
                 df = pd.DataFrame()
                 df['secs'] = secs
@@ -198,7 +317,7 @@ class DataViewerApp:
         return self.get_page_data(self.current_page)
     def  get_text_from_audio(self,audio):
          if len(audio)!=0:
-             sf.write("temp.wav", audio, 16000,format='WAV')
+             sf.write("temp.wav", normalize_audio(audio), TARGET_SAMPLE_RATE, format='WAV')
     
              client = Client("MohamedRashad/Arabic-Whisper-CodeSwitching-Edition")
              result = client.predict(
@@ -238,7 +357,7 @@ class DataViewerApp:
         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']
+        return (TARGET_SAMPLE_RATE, row_audio), row['text']
     def finsh_data(self):
         self.df['audio'] = self.sdata
         self.df[['text','speaker_id','secs','flag']]=self.data
@@ -269,11 +388,11 @@ class DataViewerApp:
                  }
 
            dataset = DatasetDict(ds)
-           dataset.push_to_hub(namedata,token=os.environ.get("auth_acess_data"),private=True)
+           dataset.push_to_hub(namedata, token=os.environ.get(HF_TOKEN_ENV), private=True)
            return namedata
 
     def delete_row(self):
-        if len(self.data)!=0  or  self.current_selected != -1 :
+        if len(self.data) != 0 and self.current_selected != -1:
                 self.data.drop(self.current_selected, inplace=True)
                 self.data.reset_index(drop=True, inplace=True)
                 self.df.drop(self.current_selected, inplace=True)
@@ -286,7 +405,7 @@ class DataViewerApp:
         return self.get_page_data(self.current_page),None,""
     def login(self, token):
         # Your actual login logic here (e.g., database check)
-        if token == os.environ.get("token_login") :
+        if token and token == os.environ.get(LOGIN_TOKEN_ENV):
             return gr.update(visible=False),gr.update(visible=True),True
         else:
             return gr.update(visible=True), gr.update(visible=False),None
@@ -491,4 +610,4 @@ class DataViewerApp:
 dff=pd.DataFrame(columns=['text', 'audio', 'samplerate', 'secs', 'speaker_id', '_speaker_id','flag'])
 app=DataViewerApp(dff)
 s=app.start_tab1()
-s.launch()
+s.queue(default_concurrency_limit=2).launch(show_error=True)