[WIP] Implement language detection features in REMUX script

[Copilot]

Thanks for asking me to work on this. I will get started on it and keep this PR's description up to date as I form a plan and make progress.

Original prompt

Problem: No changes were made in the previous PR

The previous pull request #1 was merged but contained 0 additions and 0 deletions - no actual code changes were made. We need to actually implement the language detection features.

Required Changes for REMUX Python Scripts/1_Improved_REMUX_Script.py:

1. Add get_available_languages() function after line 43 (after identify_tracks())

def get_available_languages(mkvmerge_path: str, files: list):
    """Scan all MKV files and return available audio and subtitle languages."""
    all_audio_langs = set()
    all_sub_langs = set()
    
    console.print("\n[yellow]Scanning files for available languages...[/yellow]")
    
    for file in files:
        ident = identify_tracks(mkvmerge_path, file)
        if not ident["ok"]:
            continue
        
        for track in ident["data"].get("tracks", []):
            track_type = track.get("type", "").lower()
            lang = track.get("properties", {}).get("language", "und").lower()
            
            if track_type == "audio":
                all_audio_langs.add(lang)
            elif track_type in ("subtitles", "subtitle"):
                all_sub_langs.add(lang)
    
    return sorted(all_audio_langs), sorted(all_sub_langs)

2. Add prompt_language_selection() function after get_available_languages()

def prompt_language_selection(audio_langs_available, sub_langs_available):
    """Prompt user to select languages from available options."""
    console.print(f"\n[bold cyan]Available Audio Languages:[/bold cyan] {', '.join(audio_langs_available) if audio_langs_available else 'None found'}")
    console.print(f"[bold cyan]Available Subtitle Languages:[/bold cyan] {', '.join(sub_langs_available) if sub_langs_available else 'None found'}\n")
    
    # Audio language selection
    audio_input = input("Enter audio languages to keep (comma-separated, e.g., 'eng,jpn') or press Enter for all: ").strip()
    if audio_input:
        audio_langs = [lang.strip().lower() for lang in audio_input.split(",") if lang.strip()]
        # Validate user input
        invalid_audio = [lang for lang in audio_langs if lang not in audio_langs_available]
        if invalid_audio:
            console.print(f"[yellow]Warning: These audio languages were not found: {', '.join(invalid_audio)}[/yellow]")
    else:
        audio_langs = list(audio_langs_available)
    
    # Subtitle language selection
    sub_input = input("Enter subtitle languages to keep (comma-separated, e.g., 'eng,jpn') or press Enter for all: ").strip()
    if sub_input:
        sub_langs = [lang.strip().lower() for lang in sub_input.split(",") if lang.strip()]
        # Validate user input
        invalid_subs = [lang for lang in sub_langs if lang not in sub_langs_available]
        if invalid_subs:
            console.print(f"[yellow]Warning: These subtitle languages were not found: {', '.join(invalid_subs)}[/yellow]")
    else:
        sub_langs = list(sub_langs_available)
    
    console.print(f"\n[green]Selected audio languages:[/green] {', '.join(audio_langs) if audio_langs else 'None'}")
    console.print(f"[green]Selected subtitle languages:[/green] {', '.join(sub_langs) if sub_langs else 'None'}\n")
    
    return audio_langs, sub_langs

3. Modify the main() function:

REMOVE these lines (lines 407-414):

    audio_langs_str = input("Enter desired audio languages (comma-separated, e.g., eng,jpn): ").strip().lower()
    audio_langs = [lang.strip() for lang in audio_langs_str.split(',') if lang.strip()]
    if not audio_langs:
        console.print("[red]At least one audio language is required.[/]")
        return

    sub_langs_str = input("Enter desired subtitle languages (comma-separated, e.g., eng,ger) (blank for none): ").strip().lower()
    sub_langs = [lang.strip() for lang in sub_langs_str.split(',') if lang.strip()]

REPLACE with this code after line 431 (after console.print(f"Found {total} MKV file(s) in: {input_dir}\n")):

    # Scan files for available languages
    audio_langs_available, sub_langs_available = get_available_languages(mkvmerge_path, mkv_files)
    
    if not audio_langs_available:
        console.print("[red]No audio tracks found in any file. Cannot proceed.[/]")
        return
    
    # Prompt user for language selection
    audio_langs, sub_langs = prompt_language_selection(audio_langs_available, sub_langs_available)
    
    if not audio_langs:
        console.print("[red]At least one audio language must be selected.[/]")
        return

UPDATE the log file writing (around line 452) to include selected languages:

    with open(log_path, "a", encoding="utf-8") as lf:
        lf.write(f"==== remux run: {time.strftime('%Y-%m-%d %H:%M:%S')} ====\n")
        lf.write(f"Input dir: {input_dir}\nOutput dir: {output_dir}\nFiles: {total}\n")
        lf.write(f"Audio languages: {', '.join(audio_langs)}\nSubtitle languages: ...

</details>

*This pull request was created as a result of the following prompt from Copilot chat.*
> 
> ## Problem: No changes were made in the previous PR
> 
> The previous pull request #1 was merged but contained 0 additions and 0 deletions - no actual code changes were made. We need to actually implement the language detection features.
> 
> ## Required Changes for `REMUX Python Scripts/1_Improved_REMUX_Script.py`:
> 
> ### 1. Add `get_available_languages()` function after line 43 (after `identify_tracks()`)
> 
> ```python
> def get_available_languages(mkvmerge_path: str, files: list):
>     """Scan all MKV files and return available audio and subtitle languages."""
>     all_audio_langs = set()
>     all_sub_langs = set()
>     
>     console.print("\n[yellow]Scanning files for available languages...[/yellow]")
>     
>     for file in files:
>         ident = identify_tracks(mkvmerge_path, file)
>         if not ident["ok"]:
>             continue
>         
>         for track in ident["data"].get("tracks", []):
>             track_type = track.get("type", "").lower()
>             lang = track.get("properties", {}).get("language", "und").lower()
>             
>             if track_type == "audio":
>                 all_audio_langs.add(lang)
>             elif track_type in ("subtitles", "subtitle"):
>                 all_sub_langs.add(lang)
>     
>     return sorted(all_audio_langs), sorted(all_sub_langs)
> ```
> 
> ### 2. Add `prompt_language_selection()` function after `get_available_languages()`
> 
> ```python
> def prompt_language_selection(audio_langs_available, sub_langs_available):
>     """Prompt user to select languages from available options."""
>     console.print(f"\n[bold cyan]Available Audio Languages:[/bold cyan] {', '.join(audio_langs_available) if audio_langs_available else 'None found'}")
>     console.print(f"[bold cyan]Available Subtitle Languages:[/bold cyan] {', '.join(sub_langs_available) if sub_langs_available else 'None found'}\n")
>     
>     # Audio language selection
>     audio_input = input("Enter audio languages to keep (comma-separated, e.g., 'eng,jpn') or press Enter for all: ").strip()
>     if audio_input:
>         audio_langs = [lang.strip().lower() for lang in audio_input.split(",") if lang.strip()]
>         # Validate user input
>         invalid_audio = [lang for lang in audio_langs if lang not in audio_langs_available]
>         if invalid_audio:
>             console.print(f"[yellow]Warning: These audio languages were not found: {', '.join(invalid_audio)}[/yellow]")
>     else:
>         audio_langs = list(audio_langs_available)
>     
>     # Subtitle language selection
>     sub_input = input("Enter subtitle languages to keep (comma-separated, e.g., 'eng,jpn') or press Enter for all: ").strip()
>     if sub_input:
>         sub_langs = [lang.strip().lower() for lang in sub_input.split(",") if lang.strip()]
>         # Validate user input
>         invalid_subs = [lang for lang in sub_langs if lang not in sub_langs_available]
>         if invalid_subs:
>             console.print(f"[yellow]Warning: These subtitle languages were not found: {', '.join(invalid_subs)}[/yellow]")
>     else:
>         sub_langs = list(sub_langs_available)
>     
>     console.print(f"\n[green]Selected audio languages:[/green] {', '.join(audio_langs) if audio_langs else 'None'}")
>     console.print(f"[green]Selected subtitle languages:[/green] {', '.join(sub_langs) if sub_langs else 'None'}\n")
>     
>     return audio_langs, sub_langs
> ```
> 
> ### 3. Modify the `main()` function:
> 
> **REMOVE these lines (lines 407-414):**
> ```python
>     audio_langs_str = input("Enter desired audio languages (comma-separated, e.g., eng,jpn): ").strip().lower()
>     audio_langs = [lang.strip() for lang in audio_langs_str.split(',') if lang.strip()]
>     if not audio_langs:
>         console.print("[red]At least one audio language is required.[/]")
>         return
> 
>     sub_langs_str = input("Enter desired subtitle languages (comma-separated, e.g., eng,ger) (blank for none): ").strip().lower()
>     sub_langs = [lang.strip() for lang in sub_langs_str.split(',') if lang.strip()]
> ```
> 
> **REPLACE with this code after line 431 (after `console.print(f"Found {total} MKV file(s) in: {input_dir}\n")`):**
> ```python
>     # Scan files for available languages
>     audio_langs_available, sub_langs_available = get_available_languages(mkvmerge_path, mkv_files)
>     
>     if not audio_langs_available:
>         console.print("[red]No audio tracks found in any file. Cannot proceed.[/]")
>         return
>     
>     # Prompt user for language selection
>     audio_langs, sub_langs = prompt_language_selection(audio_langs_available, sub_langs_available)
>     
>     if not audio_langs:
>         console.print("[red]At least one audio language must be selected.[/]")
>         return
> ```
> 
> **UPDATE the log file writing (around line 452) to include selected languages:**
> ```python
>     with open(log_path, "a", encoding="utf-8") as lf:
>         lf.write(f"==== remux run: {time.strftime('%Y-%m-%d %H:%M:%S')} ====\n")
>         lf.write(f"Input dir: {input_dir}\nOutput dir: {output_dir}\nFiles: {total}\n")
>         lf.write(f"Audio languages: {', '.join(audio_langs)}\nSubtitle languages: {', '.join(sub_langs)}\n\n")
> ```
> 
> ## Required Changes for `REMUX Python Scripts/remux_gui.py`:
> 
> ### 1. Add `get_available_languages()` function after line 37 (after `identify_tracks()`)
> 
> ```python
> def get_available_languages(mkvmerge_path: str, files: list):
>     """Scan all files and return available audio and subtitle languages."""
>     all_audio_langs = set()
>     all_sub_langs = set()
>     
>     for file in files:
>         ident = identify_tracks(mkvmerge_path, file)
>         if not ident["ok"]:
>             continue
>         
>         for track in ident["data"].get("tracks", []):
>             track_type = track.get("type", "").lower()
>             lang = track.get("properties", {}).get("language", "und").lower()
>             
>             if track_type == "audio":
>                 all_audio_langs.add(lang)
>             elif track_type in ("subtitles", "subtitle"):
>                 all_sub_langs.add(lang)
>     
>     return sorted(all_audio_langs), sorted(all_sub_langs)
> ```
> 
> ### 2. Add `scan_languages()` method to RemuxApp class (after `browse_output()` around line 220)
> 
> ```python
>     def scan_languages(self):
>         """Scan MKV files in input directory and display available languages."""
>         input_path = Path(self.input_dir.get())
>         
>         if not input_path.is_dir():
>             self.show_error("Please select a valid input directory first.")
>             return
>         
>         mkv_files = sorted(input_path.glob("*.mkv"))
>         if not mkv_files:
>             messagebox.showwarning("No Files", "No .mkv files found in the input directory.")
>             return
>         
>         self.status_label.config(text=f"Scanning {len(mkv_files)} files for available languages...")
>         self.scan_button.config(state=tk.DISABLED)
>         self.root.update()
>         
>         # Run scan in separate thread to avoid freezing GUI
>         def scan_thread():
>             audio_langs, sub_langs = get_available_languages(self.mkvmerge_path, mkv_files)
>             self.root.after(0, lambda: self.display_scan_results(audio_langs, sub_langs))
>         
>         threading.Thread(target=scan_thread, daemon=True).start()
> ```
> 
> ### 3. Add `display_scan_results()` method to RemuxApp class
> 
> ```python
>     def display_scan_results(self, audio_langs, sub_langs):
>         """Display the scan results and update the language fields."""
>         self.scan_button.config(state=tk.NORMAL)
>         self.status_label.config(text="Ready.")
>         
>         # Create popup window with results
>         result_window = tk.Toplevel(self.root)
>         result_window.title("Available Languages")
>         result_window.geometry("500x400")
>         result_window.transient(self.root)
>         result_window.grab_set()
>         
>         main = ttk.Frame(result_window, padding="10")
>         main.pack(fill=tk.BOTH, expand=True)
>         
>         # Audio languages
>         ttk.Label(main, text="Available Audio Languages:", font=("TkDefaultFont", 10, "bold")).pack(anchor=tk.W, pady=(0,5))
>         audio_frame = ttk.Frame(main)
>         audio_frame.pack(fill=tk.BOTH, expand=True, pady=(0,10))
>         
>         audio_text = tk.Text(audio_frame, height=8, wrap=tk.WORD)
>         audio_scroll = ttk.Scrollbar(audio_frame, orient="vertical", command=audio_text.yview)
>         audio_text.configure(yscrollcommand=audio_scroll.set)
>         audio_scroll.pack(side=tk.RIGHT, fill=tk.Y)
>         audio_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
>         
>         if audio_langs:
>             audio_text.insert("1.0", ", ".join(audio_langs))
>         else:
>             audio_text.insert("1.0", "None found")
>         audio_text.config(state=tk.DISABLED)
>         
>         # Subtitle languages
>         ttk.Label(main, text="Available Subtitle Languages:", font=("TkDefaultFont", 10, "bold")).pack(anchor=tk.W, pady=(0,5))
>         sub_frame = ttk.Frame(main)
>         sub_frame.pack(fill=tk.BOTH, expand=True, pady=(0,10))
>         
>         sub_text = tk.Text(sub_frame, height=8, wrap=tk.WORD)
>         sub_scroll = ttk.Scrollbar(sub_frame, orient="vertical", command=sub_text.yview)
>         sub_text.configure(yscrollcommand=sub_scroll.set)
>         sub_scroll.pack(side=tk.RIGHT, fill=tk.Y)
>         sub_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
>         
>         if sub_langs:
>             sub_text.insert("1.0", ", ".join(sub_langs))
>         else:
>             sub_text.insert("1.0", "None found")
>         sub_text.config(state=tk.DISABLED)
>         
>         # Button frame
>         btn_frame = ttk.Frame(main)
>         btn_frame.pack(fill=tk.X, pady=(10,0))
>         
>         def use_languages():
>             if audio_langs:
>                 self.audio_langs.set(",".join(audio_langs))
>             if sub_langs:
>                 self.sub_langs.set(",".join(sub_langs))
>             result_window.destroy()
>         
>         ttk.Button(btn_frame, text="Use These Languages", command=use_languages).pack(side=tk.RIGHT, padx=5)
>         ttk.Button(btn_frame, text="Close", command=result_window.destroy).pack(side=tk.RIGHT)
> ```
> 
> ### 4. Add "Scan Languages" button in `__init__()` method (after line 164)
> 
> After the subtitle language entry field, add:
> ```python
>         # Scan Languages Button
>         scan_frame = ttk.Frame(opts_frame)
>         scan_frame.grid(row=1, column=0, columnspan=4, pady=5)
>         self.scan_button = ttk.Button(scan_frame, text="🔍 Scan Available Languages", command=self.scan_languages)
>         self.scan_button.pack()
> ```
> 
> And update the mkvmerge check to disable the scan button:
> ```python
>         if not self.mkvmerge_path:
>             self.show_error("mkvmerge not found. Please install MKVToolNix and ensure mkvmerge is in your system's PATH.")
>             self.start_button.config(state=tk.DISABLED)
>             self.scan_button.config(state=tk.DISABLED)
> ```
> 
> ### 5. Update `start_remux()` method to disable scan button
> 
> Add this line after `self.running = True`:
> ```python
>         self.scan_button.config(state=tk.DISABLED)
> ```
> 
> ### 6. Update `process_queue()` method to re-enable scan button
> 
> In the "finished" message handling section, add:
> ```python
>                     self.scan_button.config(state=tk.NORMAL)
> ```
> 
> ## Implementation Notes:
> - Keep all existing functionality
> - Language codes are normalized to lowercase
> - Handle "und" (undefined) language codes
> - Display clear progress messages during scanning
> - Validate user input against available languages
> - The remux logic already accepts audio_langs and sub_langs parameters
> 
> THIS TIME, ACTUALLY IMPLEMENT THE CHANGES - DON'T JUST CREATE AN EMPTY PR!
> 

<!-- START COPILOT CODING AGENT TIPS -->
---

💬 Share your feedback on Copilot coding agent for the chance to win a $200 gift card! Click [here](https://survey3.medallia.com/?EAHeSx-AP01bZqG0Ld9QLQ) to start the survey.