Update processing.py

processing.py

@@ -110,9 +110,9 @@ def run_command_and_process_files(
     start_check_point,
     INPUT_DIR,
     OUTPUT_DIR,
-    extract_instrumental,
-    use_tta,
-    demud_phaseremix_inst,
+    extract_instrumental=False,
+    use_tta=False,
+    demud_phaseremix_inst=False,
     progress=None,
     use_apollo=True,
     apollo_normal_model="Apollo Universal Model",
@@ -124,113 +124,137 @@ def run_command_and_process_files(
     apollo_midside_model=None,
     output_format="wav"
 ):
-    """
-    Run inference.py with specified parameters and process output files.
-    """
     try:
-        # Create directories and check Google Drive access
-        setup_directories()
-
-        print(f"run_command_and_process_files: model_type={model_type}, config_path={config_path}, start_check_point={start_check_point}, inference_chunk_size={inference_chunk_size}, inference_overlap={inference_overlap}, apollo_chunk_size={apollo_chunk_size}, apollo_overlap={apollo_overlap}, progress_type={type(progress)}")
-        if not config_path:
-            raise ValueError(f"Configuration path is empty: model_type: {model_type}")
-        if not os.path.exists(config_path):
-            raise FileNotFoundError(f"Configuration file not found: {config_path}")
-        if not start_check_point or not os.path.exists(start_check_point):
-            raise FileNotFoundError(f"Checkpoint file not found: {start_check_point}")
+        logging.info(f"Starting run_command_and_process_files: model_type={model_type}, config_path={config_path}, inference_chunk_size={inference_chunk_size}, inference_overlap={inference_overlap}")
+
+        # Doğrulama
+        for path, name in [
+            (config_path, "Configuration file"),
+            (start_check_point, "Checkpoint file"),
+            (INPUT_DIR, "Input directory")
+        ]:
+            if not path:
+                raise ValueError(f"{name} is empty")
+            if not os.path.exists(path):
+                raise FileNotFoundError(f"{name} not found: {path}")
 
-        # Validate inference parameters
-        try:
-            inference_chunk_size = int(inference_chunk_size)
-            inference_overlap = int(inference_overlap)
-        except (TypeError, ValueError) as e:
-            print(f"Invalid inference_chunk_size or inference_overlap: {e}. Defaulting to: inference_chunk_size=352800, inference_overlap=2")
-            inference_chunk_size = 352800
-            inference_overlap = 2
-
-        # Validate Apollo parameters
-        try:
-            apollo_chunk_size = int(apollo_chunk_size)
-            apollo_overlap = int(apollo_overlap)
-        except (TypeError, ValueError) as e:
-            print(f"Invalid apollo_chunk_size or apollo_overlap: {e}. Defaulting to: apollo_chunk_size=19, apollo_overlap=2")
-            apollo_chunk_size = 19
-            apollo_overlap = 2
+        os.makedirs(OUTPUT_DIR, exist_ok=True)
 
+        # Komut oluştur
         cmd_parts = [
-            "python", INFERENCE_PATH,
-            "--model_type", model_type,
-            "--config_path", config_path,
-            "--start_check_point", start_check_point,
-            "--input_folder", INPUT_DIR,
-            "--store_dir", OUTPUT_DIR,
+            "python", "-m", "inference",
+            "--model_type", str(model_type),
+            "--config_path", str(config_path),
+            "--start_check_point", str(start_check_point),
+            "--input_folder", str(INPUT_DIR),
+            "--store_dir", str(OUTPUT_DIR),
             "--chunk_size", str(inference_chunk_size),
             "--overlap", str(inference_overlap),
             "--export_format", f"{output_format} FLOAT"
         ]
-        if extract_instrumental:
-            cmd_parts.append("--extract_instrumental")
-        if use_tta:
-            cmd_parts.append("--use_tta")
-        if demud_phaseremix_inst:
-            cmd_parts.append("--demud_phaseremix_inst")
-
-        print(f"Running command: {' '.join(cmd_parts)}")
-        process = subprocess.run(
+        for flag, value in [
+            ("--extract_instrumental", extract_instrumental),
+            ("--use_tta", use_tta),
+            ("--demud_phaseremix_inst", demud_phaseremix_inst)
+        ]:
+            if value:
+                cmd_parts.append(flag)
+
+        logging.info(f"Executing command: {' '.join(cmd_parts)}")
+        start_time = time.time()
+
+        # Subprocess başlat
+        process = subprocess.Popen(
             cmd_parts,
-            cwd=BASE_DIR,
-            capture_output=True,
+            cwd=os.path.dirname(os.path.abspath(__file__)),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
             text=True,
-            check=True
+            bufsize=1,
+            universal_newlines=True
         )
 
-        # Log subprocess output
-        print(f"Subprocess stdout: {process.stdout}")
-        if process.stderr:
-            print(f"Subprocess stderr: {process.stderr}")
-
-        # Progress update (separation phase, 0-80%)
-        if progress is not None and callable(getattr(progress, '__call__', None)):
-            progress(0, desc="Starting audio separation", total=100)
-        else:
-            print("Progress is not callable or None, skipping progress update")
-
-        # Check if output files were created
+        # İlerleme takibi
+        mixture_paths = sorted(glob.glob(os.path.join(INPUT_DIR, '*.*')))
+        total_files = len(mixture_paths)
+        processed_files = 0
+        base_progress_per_file = 80 / total_files if total_files > 0 else 80  # 0-80% ayrıştırma
+
+        stderr_output = ""
+        stdout_output = ""
+        while process.poll() is None:
+            line = process.stdout.readline().strip()
+            if line:
+                stdout_output += line + "\n"
+                if i18n("loaded_audio").lower() in line.lower():
+                    processed_files += 1
+                    progress_value = round((processed_files / total_files) * 80)
+                    if progress is not None and callable(getattr(progress, '__call__', None)):
+                        progress(progress_value / 100, desc=i18n("running_separation").format(processed_files, total_files))
+                        update_progress_html(i18n("running_separation").format(processed_files, total_files), progress_value)
+                logging.debug(line)
+
+            err_line = process.stderr.readline().strip()
+            if err_line:
+                stderr_output += err_line + "\n"
+                logging.error(err_line)
+
+        # Kalan çıktıları topla
+        stdout, stderr = process.communicate()
+        stdout_output += stdout
+        stderr_output += stderr
+        logging.debug(f"Subprocess stdout: {stdout_output}")
+        if stderr_output:
+            logging.error(f"Subprocess stderr: {stderr_output}")
+
+        if process.returncode != 0:
+            raise RuntimeError(f"Subprocess failed with code {process.returncode}: {stderr_output}")
+
+        elapsed_time = time.time() - start_time
+        logging.info(f"Subprocess completed in {elapsed_time:.2f} seconds")
+
+        # Çıktıları işle
         filename_model = extract_model_name_from_checkpoint(start_check_point)
-        output_files = os.listdir(OUTPUT_DIR)
+        output_files = sorted(os.listdir(OUTPUT_DIR))
         if not output_files:
             raise FileNotFoundError("No output files created in OUTPUT_DIR")
 
-        def rename_files_with_model(folder, filename_model):
-            for filename in sorted(os.listdir(folder)):
-                file_path = os.path.join(folder, filename)
-                if not any(filename.lower().endswith(ext) for ext in ['.mp3', '.wav', '.flac', '.aac', '.ogg', '.m4a']):
-                    continue
-                base, ext = os.path.splitext(filename)
-                detected_type = None
-                for type_key in ['vocals', 'instrumental', 'phaseremix', 'drum', 'bass', 'other', 'effects', 'speech', 'music', 'dry', 'male', 'female', 'bleed', 'karaoke']:
-                    if type_key in base.lower():
-                        detected_type = type_key
-                        break
-                type_suffix = detected_type.capitalize() if detected_type else "Processed"
-                clean_base = sanitize_filename(base.split('_')[0]).rsplit('.', 1)[0]
-                new_filename = f"{clean_base}_{type_suffix}_{filename_model}{ext}"
-                new_file_path = os.path.join(folder, new_filename)
-                try:
-                    os.rename(file_path, new_file_path)
-                except Exception as e:
-                    print(f"Could not rename {file_path} to {new_file_path}: {str(e)}")
-
-        rename_files_with_model(OUTPUT_DIR, filename_model)
-
-        output_files = os.listdir(OUTPUT_DIR)
+        # Dosya yeniden adlandırma: 80-90%
+        total_output_files = len(output_files)
+        renamed_files = 0
+        for filename in output_files:
+            file_path = os.path.join(OUTPUT_DIR, filename)
+            if not any(filename.lower().endswith(ext) for ext in ['.mp3', '.wav', '.flac', '.aac', '.ogg', '.m4a']):
+                continue
+            base, ext = os.path.splitext(filename)
+            detected_type = None
+            for type_key in ['vocals', 'instrumental', 'phaseremix', 'drum', 'bass', 'other', 'effects', 'speech', 'music', 'dry', 'male', 'female', 'bleed', 'karaoke']:
+                if type_key.lower() in base.lower():
+                    detected_type = type_key
+                    break
+            type_suffix = detected_type.capitalize() if detected_type else 'Processed'
+            clean_base = sanitize_filename(base.split('_')[0]).rsplit('.', 1)[0]
+            new_filename = f"{clean_base}_{type_suffix}_{filename_model}{ext}"
+            new_file_path = os.path.join(OUTPUT_DIR, new_filename)
+            try:
+                os.rename(file_path, new_file_path)
+                renamed_files += 1
+                progress_value = round(80 + (renamed_files / total_output_files) * 10)
+                if progress is not None and callable(getattr(progress, '__call__', None)):
+                    progress(progress_value / 100, desc=i18n("renaming_files").format(renamed_files, total_output_files))
+                    update_progress_html(i18n("renaming_files").format(renamed_files, total_output_files), progress_value)
+            except Exception as e:
+                logging.error(f"Could not rename {file_path} to {new_file_path}: {e}")
+
+        output_files = sorted(os.listdir(OUTPUT_DIR))
         if not output_files:
             raise FileNotFoundError("No output files in OUTPUT_DIR after renaming")
 
+        # Çıktıları eşleştir
         def find_file(keyword):
             matching_files = [
-                os.path.join(OUTPUT_DIR, f) for f in output_files 
-                if keyword in f.lower()
+                os.path.join(OUTPUT_DIR, f) for f in output_files
+                if keyword.lower() in f.lower()
             ]
             return matching_files[0] if matching_files else None
 
@@ -241,8 +265,9 @@ def run_command_and_process_files(
             find_file('female'), find_file('bleed'), find_file('karaoke')
         ]
 
+        # Normalizasyon: 90-95%
         normalized_outputs = []
-        for output_file in output_list:
+        for i, output_file in enumerate(output_list):
             if output_file and os.path.exists(output_file):
                 normalized_file = os.path.join(OUTPUT_DIR, f"{sanitize_filename(os.path.splitext(os.path.basename(output_file))[0])}.{output_format}")
                 if output_file.endswith(f".{output_format}") and output_file != normalized_file:
@@ -253,11 +278,17 @@ def run_command_and_process_files(
                 else:
                     normalized_file = output_file
                 normalized_outputs.append(normalized_file)
+
+                progress_value = round(90 + (i + 1) / len(output_list) * 5)
+                if progress is not None and callable(getattr(progress, '__call__', None)):
+                    progress(progress_value / 100, desc=f"Normalizing output {i+1}/{len(output_list)}")
+                    update_progress_html(f"Normalizing output {i+1}/{len(output_list)}", progress_value)
             else:
-                normalized_outputs.append(output_file)
+                normalized_outputs.append(None)
 
-        # Apollo processing
+        # Apollo işlemi: 95-100%
         if use_apollo:
+            from apollo_processing import process_with_apollo  # Varsayılan modül
             normalized_outputs = process_with_apollo(
                 output_files=normalized_outputs,
                 output_dir=OUTPUT_DIR,
@@ -267,23 +298,23 @@ def run_command_and_process_files(
                 apollo_normal_model=apollo_normal_model,
                 apollo_midside_model=apollo_midside_model,
                 output_format=output_format,
-                progress=progress,
-                total_progress_start=80,
+                progress=lambda p, desc: progress((95 + p * 5) / 100, desc=desc) if progress else None,
+                total_progress_start=95,
                 total_progress_end=100
             )
 
-        # Final progress update
+        # Tamamlandı
         if progress is not None and callable(getattr(progress, '__call__', None)):
-            progress(100, desc="Separation complete")
+            progress(1.0, desc=i18n("separation_complete"))
+            update_progress_html(i18n("separation_complete"), 100)
+
+        logging.info(f"Processing completed successfully. Outputs: {normalized_outputs}")
         return tuple(normalized_outputs)
 
-    except subprocess.CalledProcessError as e:
-        print(f"Subprocess failed, code: {e.returncode}: {e.stderr}")
-        return (None,) * 14
     except Exception as e:
-        print(f"run_command_and_process_files error: {str(e)}")
+        logging.error(f"run_command_and_process_files error: {str(e)}")
         import traceback
-        traceback.print_exc()
+        traceback.print_exc(file=sys.stderr)
         return (None,) * 14
 
 def process_audio(