Added revisions to the translation app

2026-01-12 08:52:38 -05:00
parent 64add85920
commit 8181bebaa0
44 changed files with 993 additions and 375 deletions
@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+import os
+import sys
+import argparse
+import subprocess
+from dotenv import load_dotenv
+
+# Load config
+script_dir = os.path.dirname(os.path.abspath(__file__))
+env_path = os.path.abspath(os.path.join(script_dir, '../../.env_files/.env.aitranscribe'))
+if os.path.exists(env_path):
+    load_dotenv(env_path)
+else:
+    load_dotenv()
+
+from translator import translate_srt
+from utils import validate_and_repair_srt
+import pysubs2
+from deep_translator import GoogleTranslator
+from datetime import datetime
+
+def translate_fallback_free(source_srt_path, output_srt_path, target_lang="en"):
+    """
+    Fallback translation using deep-translator (free Google Translate).
+    Parses SRT, translates text line-by-line, and saves new SRT.
+    """
+# ... (rest of translate_fallback_free is same) ...
+
+# ... (rest of re_embed_subtitles is same) ...
+
+def process_recovery(folder_path, target_lang="English"):
+    print(f"Scanning {folder_path} for incomplete translations...")
+    
+    # Define log file
+    recovery_log_file = os.path.join(folder_path, "recovery_status.log")
+    print(f"Logging actions to: {recovery_log_file}")
+    
+    count_fixed = 0
+    count_skipped = 0
+
+    video_extensions = ('.mp4', '.mkv', '.mov', '.avi')
+
+    for root, dirs, files in os.walk(folder_path):
+        for file in files:
+            # We are looking for the SOURCE SRT files primarily
+            # Exclude our output files to avoid loops
+            if file.endswith(".srt") and \
+               not file.endswith(f".{target_lang}.srt") and \
+               not file.endswith(f".{target_lang}.deep_translate.srt"):
+               
+                source_srt_path = os.path.join(root, file)
+                base_name = os.path.splitext(file)[0]
+                
+                # Check if Translation exists (Standard or Fallback)
+                path_gemini = os.path.join(root, f"{base_name}.{target_lang}.srt")
+                path_deep = os.path.join(root, f"{base_name}.{target_lang}.deep_translate.srt")
+                
+                if os.path.exists(path_gemini) or os.path.exists(path_deep):
+                    continue
+                
+                print(f"\nFound untranslated transcript: {file}")
+                
+                # Try to translate
+                with open(source_srt_path, "r", encoding="utf-8") as f:
+                    content = f.read()
+                
+                new_srt_content = translate_srt(content, target_language=target_lang)
+                
+                success = False
+                method_used = "None"
+                final_srt_path = path_gemini # Default if success
+
+                if new_srt_content:
+                    # Save Gemini translation
+                    with open(path_gemini, "w", encoding="utf-8") as f:
+                        f.write(new_srt_content)
+                    success = True
+                    method_used = "Gemini"
+                    final_srt_path = path_gemini
+                else:
+                    print("❌ Gemini API failed. Attempting Free Fallback...")
+                    lang_map = {
+                        "English": "en", "French": "fr", "Spanish": "es", 
+                        "German": "de", "Italian": "it", "Portuguese": "pt",
+                        "Russian": "ru", "Japanese": "ja", "Chinese": "zh-CN"
+                    }
+                    target_code = lang_map.get(target_lang, "en")
+                    
+                    if translate_fallback_free(source_srt_path, path_deep, target_lang=target_code):
+                        success = True
+                        method_used = "DeepTranslate"
+                        final_srt_path = path_deep
+                    else:
+                        print("❌ All translation methods failed. Skipping.")
+                        continue
+                
+                if success:
+                    # Log result
+                    with open(recovery_log_file, "a", encoding="utf-8") as log:
+                        log.write(f"{datetime.now().isoformat()} | {method_used} | {file} -> {os.path.basename(final_srt_path)}\n")
+
+                    validate_and_repair_srt(final_srt_path)
+                    
+                    # Now, find the video file to update
+                    # Case 1: Original name
+                    video_candidates = [
+                        os.path.join(root, base_name + ".mp4"),
+                        os.path.join(root, base_name + ".mkv"),
+                        # Case 2: .subbed name (if original deleted)
+                        os.path.join(root, base_name + ".subbed.mp4"), 
+                    ]
+                    
+                    found_video = None
+                    for v in video_candidates:
+                        if os.path.exists(v):
+                            found_video = v
+                            break
+                    
+                    if found_video:
+                        print(f"Found video to fix: {found_video}")
+                        if re_embed_subtitles(found_video, final_srt_path):
+                            count_fixed += 1
+                    else:
+                        print("Warning: Could not find a corresponding video file to embed into.")
+
+    print(f"\nRecovery Complete. Fixed {count_fixed} files.")
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: ./recover_and_fix.py <folder_path> [target_lang]")
+        sys.exit(1)
+        
+    folder = sys.argv[1]
+    lang = sys.argv[2] if len(sys.argv) > 2 else "English"
+    
+    process_recovery(folder, lang)