refactor: consolidate input validation and improve error handling across features

- Extract common validation logic into new utils/validation.py module
- Add validate_input_file() to check file existence and readability
- Add check_output_file() to handle output file conflicts with user prompts
- Add check_has_video_stream() to verify video stream presence
- Add check_disk_space() to estimate and validate available disk space
- Add press_continue() helper to replace repeated questionary calls
- Update audio.py to use centralized validation and improved error handling
- Update batch.py to use centralized validation and add disk space checks
- Update convert.py to use centralized validation functions
- Update crop.py to use centralized validation functions
- Update inspect.py to use centralized validation functions
- Update join.py to use centralized validation functions
- Update subtitle.py to use centralized validation functions
- Update trim.py to use centralized validation functions
- Remove trailing whitespace and improve code formatting across all feature modules
- Standardize questionary usage by removing use_indicator parameter
- Improve user feedback with better error messages and operation status
- Reduces code duplication and improves maintainability across the codebase

Author: hariharen9

src/peg_this/features/audio.py

@@ -1,38 +1,85 @@
-
 from pathlib import Path
 
 import ffmpeg
 import questionary
 from rich.console import Console
 
 from peg_this.utils.ffmpeg_utils import run_command, has_audio_stream
+from peg_this.utils.validation import (
+    validate_input_file, check_output_file, check_has_video_stream, press_continue
+)
 
 console = Console()
 
 
 def extract_audio(file_path):
-    """Extract the audio track from a video file."""
+    if not validate_input_file(file_path):
+        press_continue()
+        return
+
     if not has_audio_stream(file_path):
         console.print("[bold red]Error: No audio stream found in the file.[/bold red]")
-        questionary.press_any_key_to_continue().ask()
+        press_continue()
         return
 
-    audio_format = questionary.select("Select audio format:", choices=["mp3", "flac", "wav"], use_indicator=True).ask()
-    if not audio_format: return
+    audio_format = questionary.select(
+        "Select audio format:",
+        choices=["mp3", "flac", "wav"]
+    ).ask()
+    if not audio_format:
+        return
 
     output_file = f"{Path(file_path).stem}_audio.{audio_format}"
-    stream = ffmpeg.input(file_path).output(output_file, vn=None, acodec='libmp3lame' if audio_format == 'mp3' else audio_format, y=None)
-    
-    run_command(stream, f"Extracting audio to {audio_format.upper()}...", show_progress=True)
-    console.print(f"[bold green]Successfully extracted audio to {output_file}[/bold green]")
-    questionary.press_any_key_to_continue().ask()
+    action_result, final_output = check_output_file(output_file, "Audio file")
+
+    if action_result == 'cancel':
+        console.print("[yellow]Operation cancelled.[/yellow]")
+        press_continue()
+        return
+
+    stream = ffmpeg.input(file_path).output(
+        final_output,
+        vn=None,
+        acodec='libmp3lame' if audio_format == 'mp3' else audio_format
+    )
+
+    if action_result == 'overwrite':
+        stream = stream.overwrite_output()
+
+    if run_command(stream, f"Extracting audio to {audio_format.upper()}...", show_progress=True):
+        console.print(f"[bold green]Successfully extracted audio to {final_output}[/bold green]")
+    else:
+        console.print("[bold red]Failed to extract audio.[/bold red]")
+
+    press_continue()
 
 
 def remove_audio(file_path):
-    """Create a silent version of a video."""
+    if not validate_input_file(file_path):
+        press_continue()
+        return
+
+    if not check_has_video_stream(file_path):
+        console.print("[bold red]Error: No video stream found in the file.[/bold red]")
+        press_continue()
+        return
+
     output_file = f"{Path(file_path).stem}_no_audio{Path(file_path).suffix}"
-    stream = ffmpeg.input(file_path).output(output_file, vcodec='copy', an=None, y=None)
-    
-    run_command(stream, "Removing audio track...", show_progress=True)
-    console.print(f"[bold green]Successfully removed audio, saved to {output_file}[/bold green]")
-    questionary.press_any_key_to_continue().ask()
+    action_result, final_output = check_output_file(output_file, "Video file")
+
+    if action_result == 'cancel':
+        console.print("[yellow]Operation cancelled.[/yellow]")
+        press_continue()
+        return
+
+    stream = ffmpeg.input(file_path).output(final_output, vcodec='copy', an=None)
+
+    if action_result == 'overwrite':
+        stream = stream.overwrite_output()
+
+    if run_command(stream, "Removing audio track...", show_progress=True):
+        console.print(f"[bold green]Successfully removed audio, saved to {final_output}[/bold green]")
+    else:
+        console.print("[bold red]Failed to remove audio.[/bold red]")
+
+    press_continue()

src/peg_this/features/batch.py

@@ -1,4 +1,3 @@
-
 import os
 import logging
 from pathlib import Path
@@ -9,36 +8,43 @@
 
 from peg_this.utils.ffmpeg_utils import run_command, has_audio_stream
 from peg_this.utils.ui_utils import get_media_files
+from peg_this.utils.validation import check_disk_space, press_continue
 
 console = Console()
 
 
 def batch_convert():
-    """Convert all media files in the directory to a specific format."""
     media_files = get_media_files()
     if not media_files:
         console.print("[bold yellow]No media files found in the current directory.[/bold yellow]")
-        questionary.press_any_key_to_continue().ask()
+        press_continue()
         return
 
+    console.print(f"[dim]Found {len(media_files)} media file(s)[/dim]")
+
     output_format = questionary.select(
         "Select output format for the batch conversion:",
-        choices=["mp4", "mkv", "mov", "avi", "webm", "mp3", "flac", "wav", "gif"],
-        use_indicator=True
+        choices=["mp4", "mkv", "mov", "avi", "webm", "mp3", "flac", "wav", "gif"]
     ).ask()
-    if not output_format: return
+    if not output_format:
+        return
 
     quality_preset = None
     if output_format in ["mp4", "mkv", "mov", "avi", "webm"]:
         quality_preset = questionary.select(
             "Select quality preset:",
-            choices=["Same as source", "High (CRF 18)", "Medium (CRF 23)", "Low (CRF 28)"],
-            use_indicator=True
+            choices=["Same as source", "High (CRF 18)", "Medium (CRF 23)", "Low (CRF 28)"]
         ).ask()
-        if not quality_preset: return
+        if not quality_preset:
+            return
+
+    # Estimate disk space needed
+    total_size = sum(os.path.getsize(f) for f in media_files if os.path.exists(f))
+    if total_size > 0 and not check_disk_space(media_files[0], multiplier=len(media_files)):
+        return
 
     confirm = questionary.confirm(
-        f"This will convert {len(media_files)} file(s) in the current directory to .{output_format}. Continue?",
+        f"This will convert {len(media_files)} file(s) to .{output_format}. Continue?",
         default=False
     ).ask()
 
@@ -48,78 +54,98 @@ def batch_convert():
 
     success_count = 0
     fail_count = 0
-
-    for file in media_files:
-        console.rule(f"Processing: {file}")
-        file_path = os.path.abspath(file)
-        is_gif = Path(file_path).suffix.lower() == '.gif'
-        has_audio = has_audio_stream(file_path)
-
-        if (is_gif or not has_audio) and output_format in ["mp3", "flac", "wav"]:
-            console.print(f"[bold yellow]Skipping {file}: Source has no audio to convert.[/bold yellow]")
-            continue
-
-        output_file = f"{Path(file_path).stem}_batch.{output_format}"
-        input_stream = ffmpeg.input(file_path)
-        output_stream = None
-        kwargs = {'y': None}
-
-        try:
-            if output_format in ["mp4", "mkv", "mov", "avi", "webm"]:
-                if quality_preset == "Same as source":
-                    kwargs['c'] = 'copy'
-                else:
-                    crf = quality_preset.split(" ")[-1][1:-1]
-                    kwargs['c:v'] = 'libx264'
-                    kwargs['crf'] = crf
-                    kwargs['pix_fmt'] = 'yuv420p'
-                    if has_audio:
-                        kwargs['c:a'] = 'aac'
-                        kwargs['b:a'] = '192k'
+    skipped_count = 0
+
+    try:
+        for i, file in enumerate(media_files):
+            console.rule(f"[{i+1}/{len(media_files)}] Processing: {file}")
+            file_path = os.path.abspath(file)
+
+            if not os.path.exists(file_path):
+                console.print(f"[yellow]Skipping {file}: File not found.[/yellow]")
+                skipped_count += 1
+                continue
+
+            is_gif = Path(file_path).suffix.lower() == '.gif'
+            has_audio = has_audio_stream(file_path)
+
+            if (is_gif or not has_audio) and output_format in ["mp3", "flac", "wav"]:
+                console.print(f"[yellow]Skipping {file}: Source has no audio to convert.[/yellow]")
+                skipped_count += 1
+                continue
+
+            output_file = f"{Path(file_path).stem}_batch.{output_format}"
+
+            # Skip if output already exists
+            if os.path.exists(output_file):
+                console.print(f"[yellow]Skipping {file}: Output already exists ({output_file})[/yellow]")
+                skipped_count += 1
+                continue
+
+            input_stream = ffmpeg.input(file_path)
+            output_stream = None
+            kwargs = {}
+
+            try:
+                if output_format in ["mp4", "mkv", "mov", "avi", "webm"]:
+                    if quality_preset == "Same as source":
+                        kwargs['c'] = 'copy'
                     else:
-                        kwargs['an'] = None
-                output_stream = input_stream.output(output_file, **kwargs)
-
-            elif output_format in ["mp3", "flac", "wav"]:
-                kwargs['vn'] = None
-                kwargs['c:a'] = 'libmp3lame' if output_format == 'mp3' else output_format
-                if output_format == 'mp3':
-                    kwargs['b:a'] = '192k' # Default bitrate for batch
-                output_stream = input_stream.output(output_file, **kwargs)
-
-            elif output_format == "gif":
-                fps = "15"
-                scale = "480"
-                palette_file = f"palette_{Path(file_path).stem}.png"
-                
-                palette_gen_stream = input_stream.video.filter('fps', fps=fps).filter('scale', w=scale, h=-1, flags='lanczos').filter('palettegen')
-                run_command(palette_gen_stream.output(palette_file, y=None), f"Generating palette for {file}...")
-
-                if not os.path.exists(palette_file):
-                    console.print(f"[bold red]Failed to generate color palette for {file}.[/bold red]")
+                        crf = quality_preset.split(" ")[-1][1:-1]
+                        kwargs['c:v'] = 'libx264'
+                        kwargs['crf'] = crf
+                        kwargs['pix_fmt'] = 'yuv420p'
+                        if has_audio:
+                            kwargs['c:a'] = 'aac'
+                            kwargs['b:a'] = '192k'
+                        else:
+                            kwargs['an'] = None
+                    output_stream = input_stream.output(output_file, **kwargs)
+
+                elif output_format in ["mp3", "flac", "wav"]:
+                    kwargs['vn'] = None
+                    kwargs['c:a'] = 'libmp3lame' if output_format == 'mp3' else output_format
+                    if output_format == 'mp3':
+                        kwargs['b:a'] = '192k'
+                    output_stream = input_stream.output(output_file, **kwargs)
+
+                elif output_format == "gif":
+                    fps = 15
+                    scale = 480
+                    palette_file = f"palette_{Path(file_path).stem}.png"
+
+                    try:
+                        palette_gen_stream = input_stream.video.filter('fps', fps=fps).filter('scale', w=scale, h=-1, flags='lanczos').filter('palettegen')
+                        run_command(palette_gen_stream.output(palette_file).overwrite_output(), f"Generating palette for {file}...")
+
+                        if not os.path.exists(palette_file):
+                            console.print(f"[red]Failed to generate color palette for {file}.[/red]")
+                            fail_count += 1
+                            continue
+
+                        palette_input = ffmpeg.input(palette_file)
+                        video_stream = input_stream.video.filter('fps', fps=fps).filter('scale', w=scale, h=-1, flags='lanczos')
+                        final_stream = ffmpeg.filter([video_stream, palette_input], 'paletteuse')
+                        output_stream = final_stream.output(output_file)
+                    finally:
+                        if os.path.exists(palette_file):
+                            os.remove(palette_file)
+
+                if output_stream and run_command(output_stream, f"Converting {file}...", show_progress=True):
+                    console.print(f"  -> [green]Successfully converted to {output_file}[/green]")
+                    success_count += 1
+                else:
+                    console.print(f"  -> [red]Failed to convert {file}.[/red]")
                     fail_count += 1
-                    continue
-
-                palette_input = ffmpeg.input(palette_file)
-                video_stream = input_stream.video.filter('fps', fps=fps).filter('scale', w=scale, h=-1, flags='lanczos')
-                final_stream = ffmpeg.filter([video_stream, palette_input], 'paletteuse')
-                output_stream = final_stream.output(output_file, y=None)
-
-            if output_stream and run_command(output_stream, f"Converting {file}...", show_progress=True):
-                console.print(f"  -> [bold green]Successfully converted to {output_file}[/bold green]")
-                success_count += 1
-            else:
-                console.print(f"  -> [bold red]Failed to convert {file}.[/bold red]")
-                fail_count += 1
 
-            if output_format == "gif" and os.path.exists(f"palette_{Path(file_path).stem}.png"):
-                os.remove(f"palette_{Path(file_path).stem}.png")
+            except Exception as e:
+                console.print(f"[red]Error processing {file}: {e}[/red]")
+                logging.error(f"Batch convert error for file {file}: {e}")
+                fail_count += 1
 
-        except Exception as e:
-            console.print(f"[bold red]An unexpected error occurred while processing {file}: {e}[/bold red]")
-            logging.error(f"Batch convert error for file {file}: {e}")
-            fail_count += 1
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Batch conversion interrupted by user.[/yellow]")
 
     console.rule("[bold green]Batch Conversion Complete[/bold green]")
-    console.print(f"Successful: {success_count} | Failed: {fail_count}")
-    questionary.press_any_key_to_continue().ask()
+    console.print(f"Successful: {success_count} | Failed: {fail_count} | Skipped: {skipped_count}")
+    press_continue()