Update processing.py

processing.py

@@ -53,7 +53,7 @@ def extract_model_name(full_model_string):
             cleaned = cleaned[len(prefix):]
     return cleaned.strip()
 
-def run_command_and_process_files(model_type, config_path, start_check_point, INPUT_DIR, OUTPUT_DIR, extract_instrumental, use_tta, demud_phaseremix_inst, clean_model):
+def run_command_and_process_files(model_type, config_path, start_check_point, INPUT_DIR, OUTPUT_DIR, extract_instrumental, use_tta, demud_phaseremix_inst, clean_model, progress=gr.Progress()):
     try:
         # inference.py'nin tam yolunu kullan
         cmd_parts = [
@@ -81,12 +81,30 @@ def run_command_and_process_files(model_type, config_path, start_check_point, IN
             universal_newlines=True
         )
 
+        # Progress bar ile subprocess çıktısını izleme
+        progress(0, desc="Starting audio separation...", total=100)
+        progress_bar = tqdm(total=100, desc="Processing audio", unit="%", position=0, leave=False)
+
         for line in process.stdout:
             print(line.strip())
+            # İlerleme yüzdesini parse et (ondalık olarak)
+            if "Progress:" in line:
+                try:
+                    percentage = float(re.search(r"Progress: (\d+\.\d+)%", line).group(1))
+                    progress(percentage, desc=f"Separating audio... ({percentage:.1f}%)")
+                    progress_bar.n = percentage  # tqdm'i güncelle
+                    progress_bar.refresh()
+                except (AttributeError, ValueError) as e:
+                    print(f"Progress parsing error: {e}")
+            elif "Processing file" in line:
+                progress(0, desc=line.strip())  # Yeni dosya işleniyorsa sıfırla
+
         for line in process.stderr:
             print(line.strip())
 
         process.wait()
+        progress_bar.close()
+        progress(100, desc="Separation complete!")
 
         filename_model = clean_model_name(clean_model)
 
@@ -148,10 +166,11 @@ def run_command_and_process_files(model_type, config_path, start_check_point, IN
         print(f"An error occurred: {e}")
         return (None,) * 14
 
+    finally:
         clear_directory(INPUT_DIR)
 
-def process_audio(input_audio_file, model, chunk_size, overlap, export_format, use_tta, demud_phaseremix_inst, extract_instrumental, clean_model, *args, **kwargs):
-    """Processes audio using the specified model and returns separated stems."""
+def process_audio(input_audio_file, model, chunk_size, overlap, export_format, use_tta, demud_phaseremix_inst, extract_instrumental, clean_model, progress=gr.Progress(track_tqdm=True), *args, **kwargs):
+    """Processes audio using the specified model and returns separated stems with progress."""
     if input_audio_file is not None:
         audio_path = input_audio_file.name
     else:
@@ -169,6 +188,7 @@ def process_audio(input_audio_file, model, chunk_size, overlap, export_format, u
     clean_model_name_full = extract_model_name(model)
     print(f"Processing audio from: {audio_path} using model: {clean_model_name_full}")
 
+    progress(0, desc="Starting audio separation...", total=100)
     model_type, config_path, start_check_point = get_model_config(clean_model_name_full, chunk_size, overlap)
 
     outputs = run_command_and_process_files(
@@ -180,12 +200,14 @@ def process_audio(input_audio_file, model, chunk_size, overlap, export_format, u
         extract_instrumental=extract_instrumental,
         use_tta=use_tta,
         demud_phaseremix_inst=demud_phaseremix_inst,
-        clean_model=clean_model_name_full
+        clean_model=clean_model_name_full,
+        progress=progress
     )
 
+    progress(100, desc="Audio processing completed!")
     return outputs
 
-def ensemble_audio_fn(files, method, weights):
+def ensemble_audio_fn(files, method, weights, progress=gr.Progress()):
     try:
         if len(files) < 2:
             return None, "⚠️ Minimum 2 files required"
@@ -210,20 +232,33 @@ def ensemble_audio_fn(files, method, weights):
             weights_list = [str(w) for w in map(float, weights.split(','))]
             ensemble_args += ["--weights", *weights_list]
         
+        progress(0, desc="Starting ensemble process...", total=100)
         result = subprocess.run(
             ["python", "ensemble.py"] + ensemble_args,
             capture_output=True,
             text=True
         )
         
+        # Ensemble için gerçek süreye dayalı ilerleme (0.1'lik adımlarla)
+        start_time = time.time()
+        total_estimated_time = 10.0  # Tahmini toplam süre (saniye, gerçek süreye göre ayarlanabilir)
+        for i in np.arange(0.1, 100.1, 0.1):
+            elapsed_time = time.time() - start_time
+            progress_value = min(i, (elapsed_time / total_estimated_time) * 100)
+            time.sleep(0.001)  # Çok küçük bir gecikme, gerçek işlem süresiyle değiştirilebilir
+            progress(progress_value, desc=f"Ensembling... ({progress_value:.1f}%)")
+        
+        progress(100, desc="Finalizing ensemble output...")
         log = f"✅ Success!\n{result.stdout}" if not result.stderr else f"❌ Error!\n{result.stderr}"
         return output_path, log
 
     except Exception as e:
         return None, f"⛔ Critical Error: {str(e)}"
+    finally:
+        progress(100, desc="Ensemble process completed!")
 
-def auto_ensemble_process(input_audio_file, selected_models, chunk_size, overlap, export_format, use_tta, extract_instrumental, ensemble_type, _state, *args, **kwargs):
-    """Processes audio with multiple models and performs ensemble."""
+def auto_ensemble_process(input_audio_file, selected_models, chunk_size, overlap, export_format, use_tta, extract_instrumental, ensemble_type, _state, progress=gr.Progress(track_tqdm=True), *args, **kwargs):
+    """Processes audio with multiple models and performs ensemble with progress."""
     try:
         if not selected_models or len(selected_models) < 1:
             return None, "❌ No models selected"
@@ -236,18 +271,23 @@ def auto_ensemble_process(input_audio_file, selected_models, chunk_size, overlap
         else:
             audio_path = input_audio_file.name
 
-        # AUTO_ENSEMBLE_TEMP'i de BASE_DIR üzerinden tanımla
         auto_ensemble_temp = os.path.join(BASE_DIR, "auto_ensemble_temp")
         os.makedirs(auto_ensemble_temp, exist_ok=True)
         os.makedirs(AUTO_ENSEMBLE_OUTPUT, exist_ok=True)
         clear_directory(auto_ensemble_temp)
 
         all_outputs = []
-        for model in selected_models:
+        total_models = len(selected_models)
+        total_steps = int(total_models * 10 + 20)  # Her model için 10 adım + final adımlar, ondalık için tam sayı
+
+        progress(0, desc="Starting ensemble process...", total=total_steps)
+
+        for i, model in enumerate(selected_models):
             clean_model = extract_model_name(model)
             model_output_dir = os.path.join(auto_ensemble_temp, clean_model)
             os.makedirs(model_output_dir, exist_ok=True)
 
+            progress(i * 10, desc=f"Loading model {i+1}/{total_models}: {model}...")
             model_type, config_path, start_check_point = get_model_config(clean_model, chunk_size, overlap)
 
             cmd = [
@@ -273,11 +313,22 @@ def auto_ensemble_process(input_audio_file, selected_models, chunk_size, overlap
             except Exception as e:
                 return None, f"Critical error with {model}: {str(e)}"
 
+            # Her model için gerçek süreye dayalı ilerleme (0.1'lik adımlarla)
+            start_time = time.time()
+            total_estimated_time = 1.0  # Tahmini toplam süre (saniye, gerçek süreye göre ayarlanabilir)
+            for j in np.arange(0.1, 10.1, 0.1):
+                elapsed_time = time.time() - start_time
+                progress_value = (i * 10) + j
+                progress_value = min(progress_value, (i * 10) + (elapsed_time / total_estimated_time) * 10)
+                time.sleep(0.001)  # Çok küçük bir gecikme, gerçek işlem süresiyle değiştirilebilir
+                progress(progress_value, desc=f"Separating with {model} ({progress_value:.1f}%)")
+
             model_outputs = glob.glob(os.path.join(model_output_dir, "*.wav"))
             if not model_outputs:
                 raise FileNotFoundError(f"{model} failed to produce output")
             all_outputs.extend(model_outputs)
 
+        progress(total_models * 10 + 5, desc="Waiting for all files to be ready...")
         def wait_for_files(files, timeout=300):
             start = time.time()
             while time.time() - start < timeout:
@@ -289,6 +340,7 @@ def auto_ensemble_process(input_audio_file, selected_models, chunk_size, overlap
 
         wait_for_files(all_outputs)
 
+        progress(total_models * 10 + 10, desc="Performing ensemble...")
         quoted_files = [f'"{f}"' for f in all_outputs]
         timestamp = str(int(time.time()))
         output_path = os.path.join(AUTO_ENSEMBLE_OUTPUT, f"ensemble_{timestamp}.wav")
@@ -308,12 +360,22 @@ def auto_ensemble_process(input_audio_file, selected_models, chunk_size, overlap
             check=True
         )
 
+        # Ensemble için gerçek süreye dayalı ilerleme (0.1'lik adımlarla)
+        start_time = time.time()
+        total_estimated_time = 10.0  # Tahmini toplam süre (saniye, gerçek süreye göre ayarlanabilir)
+        for i in np.arange(total_models * 10 + 11, total_steps - 0.1, 0.1):
+            elapsed_time = time.time() - start_time
+            progress_value = min(i, (elapsed_time / total_estimated_time) * (total_steps - (total_models * 10 + 10)) + (total_models * 10 + 10))
+            time.sleep(0.001)  # Çok küçük bir gecikme, gerçek işlem süresiyle değiştirilebilir
+            progress(progress_value, desc=f"Ensembling... ({progress_value:.1f}%)")
+
         if not os.path.exists(output_path):
             raise RuntimeError("Ensemble dosyası oluşturulamadı")
         
+        progress(total_steps, desc="Ensemble completed successfully!")
         return output_path, "✅ Success!"
     except Exception as e:
         return None, f"❌ Error: {str(e)}"
     finally:
         shutil.rmtree(auto_ensemble_temp, ignore_errors=True)
-        gc.collect()
+        gc.collect()