Update app.py

app.py

@@ -65,7 +65,7 @@ except Exception as e:
     print(f"Setup failed: {e}")
     raise
 
-@spaces.GPU(duration=60)
+@spaces.GPU(duration=120)  # Süreyi 60'tan 120 saniyeye çıkardım
 def process_audio(input_file, model, chunk_size, overlap, progress=gr.Progress()):
     if not input_file:
         return "No file uploaded.", None, None, None
@@ -128,31 +128,38 @@ def process_audio(input_file, model, chunk_size, overlap, progress=gr.Progress()
         process.stdout.close()
         process.wait()
         if process.returncode != 0:
-            return "Error processing audio.", None, None, None
+            return f"Error processing audio: Non-zero exit code {process.returncode}.", None, None, None
         total_duration = str(timedelta(seconds=int(time.time() - start_time)))
         progress(1.0, desc=f"Processing completed. Total time: {total_duration}")
         return output_file_path, input_file_path, None, f"Processing completed. Total time: {total_duration}"
     except Exception as e:
-        return f"Error: {str(e)}", None, None, None
+        return f"Error in process_audio: {str(e)}", None, None, None
 
 def mid_side_separation(audio_file):
     try:
+        print(f"Loading audio file: {audio_file}")
         y, sr = librosa.load(audio_file, sr=None, mono=False)
+        print(f"Audio shape: {y.shape}, Sample rate: {sr}")
         if y.ndim == 1:
-            raise ValueError("Stereo audio file required!")
+            raise ValueError("Stereo audio file required! Please upload a stereo .wav or .mp3 file.")
         left, right = y[0], y[1]
+        print("Performing Mid/Side separation...")
         mid = (left + right) / 2
         side = (left - right) / 2
         mid_path = os.path.join(output_folder, "mid.wav")
         side_path = os.path.join(output_folder, "side.wav")
+        print(f"Saving Mid to {mid_path} and Side to {side_path}")
         sf.write(mid_path, mid, sr)
         sf.write(side_path, side, sr)
+        print("Mid/Side separation completed.")
         return mid_path, side_path, sr
     except Exception as e:
+        print(f"Error in mid/side separation: {str(e)}")
         raise ValueError(f"Error in mid/side separation: {str(e)}")
 
 def mid_side_combine(mid_file, side_file, output_path):
     try:
+        print(f"Combining Mid: {mid_file} and Side: {side_file}")
         mid_data, sr_mid = librosa.load(mid_file, sr=None, mono=True)
         side_data, sr_side = librosa.load(side_file, sr=None, mono=True)
         if sr_mid != sr_side:
@@ -160,42 +167,57 @@ def mid_side_combine(mid_file, side_file, output_path):
         left = mid_data + side_data
         right = mid_data - side_data
         stereo = np.stack([left, right], axis=0)
+        print(f"Saving combined audio to {output_path}")
         sf.write(output_path, stereo.T, sr_mid)
         return output_path
     except Exception as e:
+        print(f"Error in mid/side combination: {str(e)}")
         raise ValueError(f"Error in mid/side combination: {str(e)}")
 
+@spaces.GPU(duration=120)  # Süreyi 60'tan 120 saniyeye çıkardım
 def process_mid_side_upscale(input_file, model, chunk_size, overlap, progress=gr.Progress()):
     if not input_file:
         return "No file uploaded.", None, None, None
     try:
         total_start_time = time.time()
+        print(f"Starting Mid/Side upscale for: {input_file}")
         
+        # Mid/Side ayrımı
         print("Separating Mid and Side channels...")
         mid_path, side_path, sr = mid_side_separation(input_file)
+        print(f"Mid path: {mid_path}, Side path: {side_path}, Sample rate: {sr}")
         
+        # Mid kanalını işle
         print("Processing Mid channel...")
         mid_restored, _, _, mid_status = process_audio(mid_path, model, chunk_size, overlap, progress=progress)
         if not mid_restored.endswith(".wav"):
-            return mid_status, None, None, None
+            return f"Mid channel processing failed: {mid_status}", None, None, None
+        print(f"Mid channel processed: {mid_restored}")
         
+        # Side kanalını işle
         print("Processing Side channel...")
         side_restored, _, _, side_status = process_audio(side_path, model, chunk_size, overlap, progress=progress)
         if not side_restored.endswith(".wav"):
-            return side_status, None, None, None
+            return f"Side channel processing failed: {side_status}", None, None, None
+        print(f"Side channel processed: {side_restored}")
         
+        # Orijinal dosya adını al ve çıktı yolunu oluştur
         original_file_name = os.path.splitext(os.path.basename(input_file))[0]
         final_output_path = os.path.join(output_folder, f"{original_file_name}_upscaled.wav")
         
+        # Mid ve Side kanallarını birleştir
         print("Combining processed Mid and Side channels...")
         final_audio = mid_side_combine(mid_restored, side_restored, final_output_path)
+        print(f"Final audio saved: {final_audio}")
         
         total_duration = str(timedelta(seconds=int(time.time() - total_start_time)))
         progress(1.0, desc=f"Mid/Side upscaling completed. Total time: {total_duration}")
         
         return final_audio, input_file, None, f"Mid/Side upscaling completed. Total time: {total_duration}"
     except Exception as e:
-        return f"Error: {str(e)}", None, None, None
+        error_msg = f"Error in Mid/Side upscale: {str(e)}"
+        print(error_msg)
+        return error_msg, None, None, None
 
 def spectrum(audio_file):
     if not audio_file:
@@ -428,5 +450,5 @@ if __name__ == "__main__":
     app.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        show_api=False,      # Hides "Use via API"
+        show_api=False,
     )