peg-this 3.0.0__py3-none-any.whl → 3.0.1__py3-none-any.whl

peg_this/peg_this.py

@@ -1,44 +1,118 @@
+
 import os
-import ffmpeg
+import subprocess
 import json
 from pathlib import Path
 import sys
-import random
 import logging
-import tkinter as tk
-from tkinter import filedialog, messagebox
-from PIL import Image, ImageTk
-import questionary
-from rich.console import Console
-from rich.table import Table
-from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn
 
+# --- Dependency Check ---
+try:
+    import questionary
+    from rich.console import Console
+    from rich.table import Table
+    from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn
+except ImportError:
+    print("Error: Required libraries 'questionary' and 'rich' are not installed.")
+    print("Please install them by running: pip install questionary rich")
+    sys.exit(1)
+
+try:
+    import ffmpeg
+except ImportError:
+    print("Error: The 'ffmpeg-python' library is not installed.")
+    print("Please install it by running: pip install ffmpeg-python")
+    sys.exit(1)
+
+try:
+    import tkinter as tk
+    from tkinter import filedialog, messagebox
+    from PIL import Image, ImageTk
+except ImportError:
+    tk = None
+# --- End Dependency Check ---
+
+
+# --- Global Configuration ---
 # Configure logging
 log_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), "ffmpeg_log.txt")
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s',
     handlers=[
-        logging.FileHandler(log_file),
+        logging.FileHandler(log_file, mode='w') # Overwrite log on each run
     ]
 )
 
+# Initialize Rich Console
 console = Console()
+# --- End Global Configuration ---
 
 
-def run_command(stream, description="Processing...", show_progress=False):
-    """Runs a command using ffmpeg-python, with an optional progress bar."""
+def check_ffmpeg_ffprobe():
+    """
+    Checks if ffmpeg and ffprobe executables are available in the system's PATH.
+    ffmpeg-python requires this.
+    """
+    try:
+        # The library does this internally, but we can provide a clearer error message.
+        subprocess.check_call(['ffmpeg', '-version'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        subprocess.check_call(['ffprobe', '-version'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    except FileNotFoundError:
+        console.print("[bold red]Error: ffmpeg and ffprobe not found.[/bold red]")
+        console.print("Please install FFmpeg and ensure its location is in your system's PATH.")
+        sys.exit(1)
+
+
+def run_command(stream_spec, description="Processing...", show_progress=False):
+    """
+    Runs an ffmpeg command using ffmpeg-python.
+    - For simple commands, it runs directly.
+    - For commands with a progress bar, it generates the ffmpeg arguments,
+      runs them as a subprocess, and parses stderr to show progress,
+      mimicking the logic from the original script for accuracy.
+    """
     console.print(f"[bold cyan]{description}[/bold cyan]")
+    
+    # Get the full command arguments from the ffmpeg-python stream object
+    args = stream_spec.get_args()
+    full_command = ['ffmpeg'] + args
+    logging.info(f"Executing command: {' '.join(full_command)}")
 
     if not show_progress:
         try:
-            out, err = ffmpeg.run(stream, capture_stdout=True, capture_stderr=True)
+            # Use ffmpeg.run() for simple, non-progress tasks. It's cleaner.
+            out, err = ffmpeg.run(stream_spec, capture_stdout=True, capture_stderr=True, quiet=True)
+            logging.info("Command successful (no progress bar).")
             return out.decode('utf-8')
         except ffmpeg.Error as e:
+            error_message = e.stderr.decode('utf-8')
             console.print("[bold red]An error occurred:[/bold red]")
-            console.print(e.stderr.decode('utf-8'))
+            console.print(error_message)
+            logging.error(f"ffmpeg error:{error_message}")
             return None
     else:
+        # For the progress bar, we must run ffmpeg as a subprocess and parse stderr.
+        duration = 0
+        try:
+            # Find the primary input file from the command arguments to probe it.
+            input_file_path = None
+            for i, arg in enumerate(full_command):
+                if arg == '-i' and i + 1 < len(full_command):
+                    # This is a robust way to find the first input file.
+                    input_file_path = full_command[i+1]
+                    break
+            
+            if input_file_path:
+                probe_info = ffmpeg.probe(input_file_path)
+                duration = float(probe_info['format']['duration'])
+            else:
+                logging.warning("Could not find input file in command to determine duration for progress bar.")
+
+        except (ffmpeg.Error, KeyError) as e:
+            console.print(f"[bold yellow]Warning: Could not determine video duration for progress bar.[/bold yellow]")
+            logging.warning(f"Could not probe for duration: {e}")
+
         with Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
@@ -47,23 +121,38 @@ def run_command(stream, description="Processing...", show_progress=False):
             console=console,
         ) as progress:
             task = progress.add_task(description, total=100)
-            process = ffmpeg.run_async(stream, pipe_stdout=True, pipe_stderr=True)
-
-            # The following progress bar is a simulation, as ffmpeg-python does not directly expose progress.
-            # A more accurate progress bar would require parsing ffmpeg's stderr.
-            while process.poll() is None:
-                progress.update(task, advance=0.5)
-                # A more sophisticated implementation could read from process.stderr
-                # and parse the progress information.
-                import time
-                time.sleep(0.1)
+            
+            # Run the command as a subprocess to capture stderr in real-time
+            process = subprocess.Popen(
+                full_command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                universal_newlines=True,
+                encoding='utf-8'
+            )
 
+            for line in process.stderr:
+                logging.debug(f"ffmpeg stderr: {line.strip()}")
+                if "time=" in line and duration > 0:
+                    try:
+                        time_str = line.split("time=")[1].split(" ")[0].strip()
+                        h, m, s_parts = time_str.split(':')
+                        s = float(s_parts)
+                        elapsed_time = int(h) * 3600 + int(m) * 60 + s
+                        percent_complete = (elapsed_time / duration) * 100
+                        progress.update(task, completed=min(percent_complete, 100))
+                    except Exception:
+                        pass # Ignore any parsing errors
+
+            process.wait()
             progress.update(task, completed=100)
-            out, err = process.communicate()
+            
             if process.returncode != 0:
-                console.print(f"[bold red]An error occurred during processing.[/bold red]")
-                console.print(err.decode('utf-8'))
+                # The error was already logged line-by-line, but we can add a final message.
+                console.print(f"[bold red]An error occurred during processing. Check {log_file} for details.[/bold red]")
                 return None
+        
+        logging.info("Command successful (with progress bar).")
         return "Success"
 
 
@@ -75,235 +164,236 @@ def get_media_files():
 
 
 def select_media_file():
-    """Display a menu to select a media file, or open a file picker if none are found."""
+    """Display a menu to select a media file, or open a file picker."""
     media_files = get_media_files()
     if not media_files:
         console.print("[bold yellow]No media files found in this directory.[/bold yellow]")
         if tk and questionary.confirm("Would you like to select a file from another location?").ask():
             root = tk.Tk()
-            root.withdraw()  # Hide the main window
+            root.withdraw()
             file_path = filedialog.askopenfilename(
                 title="Select a media file",
-                filetypes=[
-                    ("Media Files", "*.mkv *.mp4 *.avi *.mov *.webm *.flv *.wmv *.mp3 *.flac *.wav *.ogg *.gif"),
-                    ("All Files", "*.*")
-                ]
+                filetypes=[("Media Files", "*.mkv *.mp4 *.avi *.mov *.webm *.flv *.wmv *.mp3 *.flac *.wav *.ogg *.gif"), ("All Files", "*.*")]
             )
-            return file_path
-        else:
-            return None
+            return file_path if file_path else None
+        return None
 
-    file = questionary.select(
-        "Select a media file to process:",
-        choices=media_files + [questionary.Separator(), "Back"],
-        use_indicator=True
-    ).ask()
-
-    return file if file != "Back" else None
+    choices = media_files + [questionary.Separator(), "Back"]
+    file = questionary.select("Select a media file to process:", choices=choices, use_indicator=True).ask()
+    
+    # Return the absolute path to prevent "file not found" errors
+    return os.path.abspath(file) if file and file != "Back" else None
 
 
 def inspect_file(file_path):
-    """Show detailed information about the selected media file."""
+    """Show detailed information about the selected media file using ffprobe."""
+    console.print(f"Inspecting {os.path.basename(file_path)}...")
     try:
         info = ffmpeg.probe(file_path)
     except ffmpeg.Error as e:
         console.print("[bold red]An error occurred while inspecting the file:[/bold red]")
         console.print(e.stderr.decode('utf-8'))
+        logging.error(f"ffprobe error:{e.stderr.decode('utf-8')}")
+        questionary.press_any_key_to_continue().ask()
         return
 
     format_info = info.get('format', {})
-
     table = Table(title=f"File Information: {os.path.basename(file_path)}", show_header=True, header_style="bold magenta")
     table.add_column("Property", style="dim")
     table.add_column("Value")
 
-    size_bytes = int(format_info.get('size', 0))
-    size_mb = size_bytes / (1024 * 1024)
+    size_mb = float(format_info.get('size', 0)) / (1024 * 1024)
     duration_sec = float(format_info.get('duration', 0))
+    bit_rate_kbps = float(format_info.get('bit_rate', 0)) / 1000
 
     table.add_row("Size", f"{size_mb:.2f} MB")
     table.add_row("Duration", f"{duration_sec:.2f} seconds")
     table.add_row("Format", format_info.get('format_long_name', 'N/A'))
-    table.add_row("Bitrate", f"{float(format_info.get('bit_rate', 0)) / 1000:.0f} kb/s")
-
+    table.add_row("Bitrate", f"{bit_rate_kbps:.0f} kb/s")
     console.print(table)
 
-    video_streams = [s for s in info.get('streams', []) if s.get('codec_type') == 'video']
-    if video_streams:
-        video_table = Table(title="Video Streams", show_header=True, header_style="bold cyan")
-        video_table.add_column("Stream")
-        video_table.add_column("Codec")
-        video_table.add_column("Resolution")
-        video_table.add_column("Frame Rate")
-        for s in video_streams:
-            video_table.add_row(
-                f"#{s.get('index')}",
-                s.get('codec_name'),
-                f"{s.get('width')}x{s.get('height')}",
-                s.get('r_frame_rate')
-            )
-        console.print(video_table)
-
-    audio_streams = [s for s in info.get('streams', []) if s.get('codec_type') == 'audio']
-    if audio_streams:
-        audio_table = Table(title="Audio Streams", show_header=True, header_style="bold green")
-        audio_table.add_column("Stream")
-        audio_table.add_column("Codec")
-        audio_table.add_column("Sample Rate")
-        audio_table.add_column("Channels")
-        for s in audio_streams:
-            audio_table.add_row(
-                f"#{s.get('index')}",
-                s.get('codec_name'),
-                f"{s.get('sample_rate')} Hz",
-                str(s.get('channels'))
-            )
-        console.print(audio_table)
+    for stream_type in ['video', 'audio']:
+        streams = [s for s in info.get('streams', []) if s.get('codec_type') == stream_type]
+        if streams:
+            stream_table = Table(title=f"{stream_type.capitalize()} Streams", show_header=True, header_style=f"bold {'cyan' if stream_type == 'video' else 'green'}")
+            stream_table.add_column("Stream")
+            stream_table.add_column("Codec")
+            if stream_type == 'video':
+                stream_table.add_column("Resolution")
+                stream_table.add_column("Frame Rate")
+            else:
+                stream_table.add_column("Sample Rate")
+                stream_table.add_column("Channels")
+            
+            for s in streams:
+                if stream_type == 'video':
+                    stream_table.add_row(f"#{s.get('index')}", s.get('codec_name'), f"{s.get('width')}x{s.get('height')}", s.get('r_frame_rate'))
+                else:
+                    stream_table.add_row(f"#{s.get('index')}", s.get('codec_name'), f"{s.get('sample_rate')} Hz", str(s.get('channels')))
+            console.print(stream_table)
 
     questionary.press_any_key_to_continue().ask()
 
 
+def has_audio_stream(file_path):
+    """Check if the media file has an audio stream."""
+    try:
+        probe = ffmpeg.probe(file_path, select_streams='a')
+        return 'streams' in probe and len(probe['streams']) > 0
+    except ffmpeg.Error:
+        return False
+
+
+def convert_file(file_path):
+    """Convert the file to a different format."""
+    is_gif = Path(file_path).suffix.lower() == '.gif'
+    has_audio = has_audio_stream(file_path)
+
+    output_format = questionary.select("Select the output format:", choices=["mp4", "mkv", "mov", "avi", "webm", "mp3", "flac", "wav", "gif"], use_indicator=True).ask()
+    if not output_format: return
+
+    if (is_gif or not has_audio) and output_format in ["mp3", "flac", "wav"]:
+        console.print("[bold red]Error: Source has no audio to convert.[/bold red]")
+        questionary.press_any_key_to_continue().ask()
+        return
+
+    output_file = f"{Path(file_path).stem}_converted.{output_format}"
+    
+    input_stream = ffmpeg.input(file_path)
+    output_stream = None
+    kwargs = {'y': None}
+
+    if output_format in ["mp4", "mkv", "mov", "avi", "webm"]:
+        quality = questionary.select("Select quality preset:", choices=["Same as source", "High (CRF 18)", "Medium (CRF 23)", "Low (CRF 28)"], use_indicator=True).ask()
+        if not quality: return
+
+        if quality == "Same as source":
+            kwargs['c'] = 'copy'
+        else:
+            crf = quality.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
+        if output_format == 'mp3':
+            bitrate = questionary.select("Select audio bitrate:", choices=["128k", "192k", "256k", "320k"]).ask()
+            if not bitrate: return
+            kwargs['c:a'] = 'libmp3lame'
+            kwargs['b:a'] = bitrate
+        else:
+            kwargs['c:a'] = output_format
+        output_stream = input_stream.output(output_file, **kwargs)
+
+    elif output_format == "gif":
+        fps = questionary.text("Enter frame rate (e.g., 15):", default="15").ask()
+        if not fps: return
+        scale = questionary.text("Enter width in pixels (e.g., 480):", default="480").ask()
+        if not scale: return
+        
+        palette_file = f"palette_{Path(file_path).stem}.png"
+        
+        # Correctly chain filters for palette generation using explicit w/h arguments
+        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), "Generating color palette...")
+
+        if not os.path.exists(palette_file):
+            console.print("[bold red]Failed to generate color palette for GIF.[/bold red]")
+            questionary.press_any_key_to_continue().ask()
+            return
+
+        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 to {output_format}...", show_progress=True):
+        console.print(f"[bold green]Successfully converted to {output_file}[/bold green]")
+    else:
+        console.print("[bold red]Conversion failed.[/bold red]")
+
+    if output_format == "gif" and os.path.exists(f"palette_{Path(file_path).stem}.png"):
+        os.remove(f"palette_{Path(file_path).stem}.png")
+        
+    questionary.press_any_key_to_continue().ask()
+
+
 def trim_video(file_path):
     """Cut a video by specifying start and end times."""
-    start_time = questionary.text("Enter start time (HH:MM:SS):").ask()
+    start_time = questionary.text("Enter start time (HH:MM:SS or seconds):").ask()
     if not start_time: return
-    end_time = questionary.text("Enter end time (HH:MM:SS):").ask()
+    end_time = questionary.text("Enter end time (HH:MM:SS or seconds):").ask()
     if not end_time: return
 
     output_file = f"{Path(file_path).stem}_trimmed{Path(file_path).suffix}"
-    stream = ffmpeg.input(file_path, ss=start_time, to=end_time).output(output_file, c='copy')
+    
+    stream = ffmpeg.input(file_path, ss=start_time, to=end_time).output(output_file, c='copy', y=None)
+    
     run_command(stream, "Trimming video...", show_progress=True)
     console.print(f"[bold green]Successfully trimmed to {output_file}[/bold green]")
     questionary.press_any_key_to_continue().ask()
 
+
 def extract_audio(file_path):
     """Extract the audio track from a video file."""
-    audio_format = questionary.select(
-        "Select audio format:",
-        choices=[
-            questionary.Choice("MP3 (lossy)", {"codec": "libmp3lame", "ext": "mp3", "q": 2}),
-            questionary.Choice("FLAC (lossless)", {"codec": "flac", "ext": "flac"}),
-            questionary.Choice("WAV (uncompressed)", {"codec": "pcm_s16le", "ext": "wav"})
-        ],
-        use_indicator=True
-    ).ask()
+    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()
+        return
 
+    audio_format = questionary.select("Select audio format:", choices=["mp3", "flac", "wav"], use_indicator=True).ask()
     if not audio_format: return
 
-    output_file = f"{Path(file_path).stem}_audio.{audio_format['ext']}"
-    stream = ffmpeg.input(file_path).output(output_file, vn=None, acodec=audio_format['codec'], **({'q:a': audio_format['q']} if 'q' in audio_format else {}))
-    run_command(stream, f"Extracting audio to {audio_format['ext'].upper()}...", show_progress=True)
+    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()
 
+
 def remove_audio(file_path):
     """Create a silent version of a video."""
     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)
+    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()
 
 
-def batch_convert():
-    """Convert all media files in the directory to a specific format."""
-    output_format = questionary.select(
-        "Select output format for the batch conversion:",
-        choices=["mp4", "mkv", "mov", "avi", "webm", "flv", "wmv", "mp3", "flac", "wav", "ogg", "m4a", "aac", "gif"],
-        use_indicator=True
-    ).ask()
-
-    if not output_format: return
-
-    quality = "copy"
-    if output_format in ["mp4", "webm", "avi", "wmv"]:
-        quality = questionary.select(
-            "Select quality preset:",
-            choices=["Same as source (lossless if possible)", "High Quality (CRF 18)", "Medium Quality (CRF 23)", "Low Quality (CRF 28)"],
-            use_indicator=True
-        ).ask()
-        if not quality: return
-
-    confirm = questionary.confirm(
-        f"This will attempt to convert ALL media files in the current directory to .{output_format}. Are you sure?",
-        default=False
-    ).ask()
-
-    if not confirm:
-        console.print("[bold yellow]Batch conversion cancelled.[/bold yellow]")
-        return
-
-    media_files = get_media_files()
-
-    for file in media_files:
-        is_gif = Path(file).suffix.lower() == '.gif'
-        has_audio = has_audio_stream(file)
-
-        if is_gif and output_format in ["mp3", "flac", "wav", "ogg", "m4a", "aac"]:
-            console.print(f"[bold yellow]Skipping {file}: Cannot convert a GIF to an audio format.[/bold yellow]")
-            continue
-
-        if not has_audio and output_format in ["mp3", "flac", "wav", "ogg", "m4a", "aac"]:
-            console.print(f"[bold yellow]Skipping {file}: No audio stream found.[/bold yellow]")
-            continue
-
-        output_file = f"{Path(file).stem}_batch.{output_format}"
-        stream = ffmpeg.input(file)
-
-        if output_format in ["mp4", "webm", "avi", "wmv"]:
-            if quality == "Same as source (lossless if possible)":
-                stream = stream.output(output_file, c='copy')
-            else:
-                crf = quality.split(" ")[-1][1:-1]
-                audio_kwargs = {'c:a': 'aac', 'b:a': '192k'} if has_audio else {'an': None}
-                stream = stream.output(output_file, **{'c:v': 'libx264', 'crf': crf, 'pix_fmt': 'yuv420p'}, **audio_kwargs)
-        elif output_format in ["mp3", "m4a", "aac"]:
-            stream = stream.output(output_file, vn=None, acodec='libmp3lame', **{'b:a': '192k'})
-        elif output_format in ["flac", "wav", "ogg"]:
-            stream = stream.output(output_file, vn=None, acodec=output_format)
-        elif output_format == "gif":
-            fps = "15"
-            scale = "480"
-            palette_file = f"palette_{Path(file).stem}.png"
-            palette_stream = ffmpeg.input(file).filter('fps', fps=fps).filter('scale', size=f"{scale}:-1", flags='lanczos').output(palette_file, y=None)
-            run_command(palette_stream, f"Generating color palette for {file}...")
-            stream = ffmpeg.input(file).overlay(ffmpeg.input(palette_file).filter('paletteuse')).output(output_file, y=None)
-
-
-        if run_command(stream, f"Converting {file}...", show_progress=True):
-            console.print(f"  -> Saved as {output_file}")
-        else:
-            console.print(f"[bold red]Failed to convert {file}.[/bold red]")
-
-        if output_format == "gif" and os.path.exists(f"palette_{Path(file).stem}.png"):
-            os.remove(f"palette_{Path(file).stem}.png")
-
-    console.print("\n[bold green]Batch conversion finished.[/bold green]")
-    questionary.press_any_key_to_continue().ask()
-
 def crop_video(file_path):
     """Visually crop a video by selecting an area."""
-    logging.info(f"Starting crop_video for {file_path}")
     if not tk:
-        logging.error("Cannot perform cropping: tkinter/Pillow is not installed.")
-        console.print("[bold red]Cannot perform cropping: tkinter/Pillow is not installed.[/bold red]")
+        console.print("[bold red]Cannot perform visual cropping: tkinter & Pillow are not installed.[/bold red]")
         return
 
+    preview_frame = f"preview_{Path(file_path).stem}.jpg"
     try:
-        info = ffmpeg.probe(file_path)
-        duration = float(info['streams'][0].get('duration', '0'))
+        # Extract a frame from the middle of the video for preview
+        probe = ffmpeg.probe(file_path)
+        duration = float(probe['format']['duration'])
         mid_point = duration / 2
         
-        preview_frame = "preview.jpg"
-        stream = ffmpeg.input(file_path, ss=mid_point).output(preview_frame, vframes=1, qv=2, y=None)
-        run_command(stream, "Extracting a frame for preview...")
+        # Corrected frame extraction command with `-q:v`
+        run_command(
+            ffmpeg.input(file_path, ss=mid_point).output(preview_frame, vframes=1, **{'q:v': 2}, y=None),
+            "Extracting a frame for preview..."
+        )
 
         if not os.path.exists(preview_frame):
-            logging.error(f"Could not extract preview frame. File not found: {preview_frame}")
             console.print("[bold red]Could not extract a frame from the video.[/bold red]")
             return
-        logging.info(f"Successfully extracted preview frame to {preview_frame}")
 
+        # --- Tkinter GUI for Cropping ---
         root = tk.Tk()
         root.title("Crop Video - Drag to select area, close window to confirm")
         root.attributes("-topmost", True)
@@ -320,145 +410,180 @@ def crop_video(file_path):
 
         def on_press(event):
             nonlocal rect_id
-            rect_coords['x1'] = event.x
-            rect_coords['y1'] = event.y
+            rect_coords['x1'], rect_coords['y1'] = event.x, event.y
             rect_id = canvas.create_rectangle(0, 0, 1, 1, outline='red', width=2)
 
         def on_drag(event):
-            nonlocal rect_id
-            rect_coords['x2'] = event.x
-            rect_coords['y2'] = event.y
+            rect_coords['x2'], rect_coords['y2'] = event.x, event.y
             canvas.coords(rect_id, rect_coords['x1'], rect_coords['y1'], rect_coords['x2'], rect_coords['y2'])
 
-        def on_release(event):
-            pass
-        
         canvas.bind("<ButtonPress-1>", on_press)
         canvas.bind("<B1-Motion>", on_drag)
-        canvas.bind("<ButtonRelease-1>", on_release)
-
-        messagebox.showinfo("Instructions", "Click and drag on the image to draw a cropping rectangle.\nClose this window when you are satisfied with the selection.", parent=root)
         
+        messagebox.showinfo("Instructions", "Click and drag to draw a cropping rectangle.\nClose this window when you are done.", parent=root)
         root.mainloop()
 
-        os.remove(preview_frame)
+        # --- Cropping Logic ---
+        crop_w = abs(rect_coords['x2'] - rect_coords['x1'])
+        crop_h = abs(rect_coords['y2'] - rect_coords['y1'])
+        crop_x = min(rect_coords['x1'], rect_coords['x2'])
+        crop_y = min(rect_coords['y1'], rect_coords['y2'])
 
-        x1, y1, x2, y2 = rect_coords['x1'], rect_coords['y1'], rect_coords['x2'], rect_coords['y2']
-        
-        crop_x = min(x1, x2)
-        crop_y = min(y1, y2)
-        crop_w = abs(x2 - x1)
-        crop_h = abs(y2 - y1)
-
-        if crop_w == 0 or crop_h == 0:
-            console.print("[bold yellow]Cropping cancelled as no area was selected.[/bold yellow]")
+        if crop_w < 2 or crop_h < 2: # Avoid tiny, invalid crops
+            console.print("[bold yellow]Cropping cancelled as no valid area was selected.[/bold yellow]")
             return
 
         console.print(f"Selected crop area: [bold]width={crop_w} height={crop_h} at (x={crop_x}, y={crop_y})[/bold]")
 
         output_file = f"{Path(file_path).stem}_cropped{Path(file_path).suffix}"
-        stream = ffmpeg.input(file_path).filter('crop', crop_w, crop_h, crop_x, crop_y).output(output_file, **{'c:a': 'copy'})
+        
+        input_stream = ffmpeg.input(file_path)
+        video_stream = input_stream.video.filter('crop', w=crop_w, h=crop_h, x=crop_x, y=crop_y)
+        
+        kwargs = {'y': None} # Overwrite output
+        # Check for audio and copy it if it exists
+        if has_audio_stream(file_path):
+            audio_stream = input_stream.audio
+            kwargs['c:a'] = 'copy'
+            stream = ffmpeg.output(video_stream, audio_stream, output_file, **kwargs)
+        else:
+            stream = ffmpeg.output(video_stream, output_file, **kwargs)
+
         run_command(stream, "Applying crop to video...", show_progress=True)
         console.print(f"[bold green]Successfully cropped video and saved to {output_file}[/bold green]")
-        questionary.press_any_key_to_continue().ask()
-    except Exception as e:
-        logging.exception(f"An error occurred in crop_video for file: {file_path}")
-        console.print(f"[bold red]An error occurred during the crop operation. Check {log_file} for details.[/bold red]")
+
+    finally:
+        if os.path.exists(preview_frame):
+            os.remove(preview_frame)
         questionary.press_any_key_to_continue().ask()
 
-def has_audio_stream(file_path):
-    """Check if the media file has an audio stream."""
-    try:
-        info = ffmpeg.probe(file_path)
-        return any(s for s in info.get('streams', []) if s.get('codec_type') == 'audio')
-    except ffmpeg.Error as e:
-        logging.error(f"Error checking for audio stream in {file_path}: {e.stderr.decode('utf-8')}")
-    return False
 
-def convert_file(file_path):
-    """Convert the file to a different format."""
-    is_gif = Path(file_path).suffix.lower() == '.gif'
-    has_audio = has_audio_stream(file_path)
 
-    output_format = questionary.select(
-        "Select the output format:",
-        choices=["mp4", "mkv", "mov", "avi", "webm", "flv", "wmv", "mp3", "flac", "wav", "ogg", "m4a", "aac", "gif"],
-        use_indicator=True
-    ).ask()
 
-    if not output_format:
-        return
 
-    if is_gif and output_format in ["mp3", "flac", "wav", "ogg", "m4a", "aac"]:
-        console.print("[bold red]Error: Cannot convert a GIF (no audio) to an audio format.[/bold red]")
-        questionary.press_any_key_to_continue().ask()
-        return
-        
-    if not has_audio and output_format in ["mp3", "flac", "wav", "ogg", "m4a", "aac"]:
-        console.print("[bold red]Error: The source file has no audio stream to convert.[/bold red]")
+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()
         return
 
-    output_file = f"{Path(file_path).stem}_converted.{output_format}"
-    stream = ffmpeg.input(file_path)
+    output_format = questionary.select(
+        "Select output format for the batch conversion:",
+        choices=["mp4", "mkv", "mov", "avi", "webm", "mp3", "flac", "wav", "gif"],
+        use_indicator=True
+    ).ask()
+    if not output_format: return
 
-    if output_format in ["mp4", "webm", "avi", "wmv"]:
-        quality = questionary.select(
+    quality_preset = None
+    if output_format in ["mp4", "mkv", "mov", "avi", "webm"]:
+        quality_preset = questionary.select(
             "Select quality preset:",
-            choices=["Same as source (lossless if possible)", "High Quality (CRF 18)", "Medium Quality (CRF 23)", "Low Quality (CRF 28)"],
+            choices=["Same as source", "High (CRF 18)", "Medium (CRF 23)", "Low (CRF 28)"],
             use_indicator=True
         ).ask()
+        if not quality_preset: return
 
-        if not quality: return
+    confirm = questionary.confirm(
+        f"This will convert {len(media_files)} file(s) in the current directory to .{output_format}. Continue?",
+        default=False
+    ).ask()
 
-        if quality == "Same as source (lossless if possible)":
-            stream = stream.output(output_file, c='copy')
-        else:
-            crf = quality.split(" ")[-1][1:-1]
-            audio_kwargs = {'c:a': 'aac', 'b:a': '192k'} if has_audio else {'an': None}
-            stream = stream.output(output_file, **{'c:v': 'libx264', 'crf': crf, 'pix_fmt': 'yuv420p'}, **audio_kwargs)
+    if not confirm:
+        console.print("[bold yellow]Batch conversion cancelled.[/bold yellow]")
+        return
 
-    elif output_format in ["mp3", "m4a", "aac"]:
-        bitrate = questionary.select("Select audio bitrate:", choices=["128k", "192k", "256k", "320k"]).ask()
-        if not bitrate: return
-        stream = stream.output(output_file, vn=None, acodec='libmp3lame', **{'b:a': bitrate})
+    success_count = 0
+    fail_count = 0
 
-    elif output_format in ["flac", "wav", "ogg"]:
-        stream = stream.output(output_file, vn=None, acodec=output_format)
+    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)
 
-    elif output_format == "gif":
-        fps = questionary.text("Enter frame rate (e.g., 15):", default="15").ask()
-        if not fps: return
-        scale = questionary.text("Enter width in pixels (e.g., 480):", default="480").ask()
-        if not scale: return
-        
-        palette_file = "palette.png"
-        palette_stream = ffmpeg.input(file_path).filter('fps', fps=fps).filter('scale', size=f"{scale}:-1", flags='lanczos').output(palette_file, y=None)
-        run_command(palette_stream, "Generating color palette...")
-        stream = ffmpeg.input(file_path).overlay(ffmpeg.input(palette_file).filter('paletteuse')).output(output_file, y=None)
+        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
 
-    if run_command(stream, f"Converting to {output_format}...", show_progress=True):
-        console.print(f"[bold green]Successfully converted to {output_file}[/bold green]")
-    else:
-        console.print("[bold red]Conversion failed. Please check the logs for more details.[/bold red]")
+        output_file = f"{Path(file_path).stem}_batch.{output_format}"
+        input_stream = ffmpeg.input(file_path)
+        output_stream = None
+        kwargs = {'y': None}
 
-    if output_format == "gif" and os.path.exists("palette.png"):
-        os.remove("palette.png")
-        
+        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'
+                    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]")
+                    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"[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
+
+    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()
 
 
 def action_menu(file_path):
     """Display the menu of actions for a selected file."""
     while True:
-        console.rule(f"[bold]Actions for: {file_path}[/bold]")
+        console.rule(f"[bold]Actions for: {os.path.basename(file_path)}[/bold]")
         action = questionary.select(
             "Choose an action:",
             choices=[
                 "Inspect File Details",
                 "Convert",
                 "Trim Video",
-                "Crop Video",
+                "Crop Video (Visual)",
                 "Extract Audio",
                 "Remove Audio",
                 questionary.Separator(),
@@ -474,21 +599,97 @@ def action_menu(file_path):
             "Inspect File Details": inspect_file,
             "Convert": convert_file,
             "Trim Video": trim_video,
-            "Crop Video": crop_video,
+            "Crop Video (Visual)": crop_video,
             "Extract Audio": extract_audio,
             "Remove Audio": remove_audio,
         }
-        actions[action](file_path)
+        # Ensure we have a valid action before calling
+        if action in actions:
+            actions[action](file_path)
+
+
+def join_videos():
+    """Join multiple videos into a single file after standardizing their resolutions and sample rates."""
+    console.print("[bold cyan]Select videos to join (in order). Press Enter when done.[/bold cyan]")
+    
+    media_files = get_media_files()
+    video_files = [f for f in media_files if Path(f).suffix.lower() in [".mp4", ".mkv", ".mov", ".avi", ".webm"]]
+
+    if len(video_files) < 2:
+        console.print("[bold yellow]Not enough video files in the directory to join.[/bold yellow]")
+        questionary.press_any_key_to_continue().ask()
+        return
+
+    selected_videos = questionary.checkbox("Select at least two videos to join in order:", choices=video_files).ask()
+
+    if not selected_videos or len(selected_videos) < 2:
+        console.print("[bold yellow]Joining cancelled. At least two videos must be selected.[/bold yellow]")
+        return
+
+    console.print("Videos will be joined in this order:")
+    for i, video in enumerate(selected_videos):
+        console.print(f"  {i+1}. {video}")
+
+    output_file = questionary.text("Enter the output file name:", default="joined_video.mp4").ask()
+    if not output_file: return
+
+    try:
+        first_video_path = os.path.abspath(selected_videos[0])
+        probe = ffmpeg.probe(first_video_path)
+        video_info = next(s for s in probe['streams'] if s['codec_type'] == 'video')
+        audio_info = next(s for s in probe['streams'] if s['codec_type'] == 'audio')
+        
+        target_width = video_info['width']
+        target_height = video_info['height']
+        target_sar = video_info.get('sample_aspect_ratio', '1:1')
+        target_sample_rate = audio_info['sample_rate']
+
+    except Exception as e:
+        console.print(f"[bold red]Could not probe first video for target parameters: {e}[/bold red]")
+        return
+
+    console.print(f"Standardizing all videos to: {target_width}x{target_height} resolution and {target_sample_rate} Hz audio.")
+
+    processed_streams = []
+    for video_file in selected_videos:
+        stream = ffmpeg.input(os.path.abspath(video_file))
+        v = (
+            stream.video
+            .filter('scale', w=target_width, h=target_height, force_original_aspect_ratio='decrease')
+            .filter('pad', w=target_width, h=target_height, x='(ow-iw)/2', y='(oh-ih)/2')
+            .filter('setsar', sar=target_sar.replace(':','/'))
+            .filter('setpts', 'PTS-STARTPTS')
+        )
+        a = (
+            stream.audio
+            .filter('aresample', sample_rate=target_sample_rate)
+            .filter('asetpts', 'PTS-STARTPTS')
+        )
+        processed_streams.append(v)
+        processed_streams.append(a)
+
+    joined = ffmpeg.concat(*processed_streams, v=1, a=1).node
+    output_stream = ffmpeg.output(joined[0], joined[1], output_file, **{'c:v': 'libx264', 'crf': 23, 'c:a': 'aac', 'b:a': '192k', 'y': None})
+
+    if run_command(output_stream, "Joining and re-encoding videos...", show_progress=True):
+        console.print(f"[bold green]Successfully joined videos into {output_file}[/bold green]")
+    else:
+        console.print("[bold red]Failed to join videos.[/bold red]")
+    
+    questionary.press_any_key_to_continue().ask()
+
 
 def main_menu():
     """Display the main menu."""
+    check_ffmpeg_ffprobe()
     while True:
         console.rule("[bold magenta]ffmPEG-this[/bold magenta]")
         choice = questionary.select(
             "What would you like to do?",
             choices=[
-                "Select a Media File to Process",
-                "Batch Convert All Videos to a Format",
+                "Process a Single Media File",
+                "Join Multiple Videos",
+                "Batch Convert All Media in Directory",
                 "Exit"
             ],
             use_indicator=True
@@ -497,24 +698,23 @@ def main_menu():
         if choice is None or choice == "Exit":
             console.print("[bold]Goodbye![/bold]")
             break
-        elif choice == "Select a Media File to Process":
+        elif choice == "Process a Single Media File":
             selected_file = select_media_file()
             if selected_file:
                 action_menu(selected_file)
-        elif choice == "Batch Convert All Videos to a Format":
+        elif choice == "Join Multiple Videos":
+            join_videos()
+        elif choice == "Batch Convert All Media in Directory":
             batch_convert()
 
 
-def main():
+if __name__ == "__main__":
     try:
         main_menu()
-    except KeyboardInterrupt:
+    except (KeyboardInterrupt, EOFError):
         logging.info("Operation cancelled by user.")
-        console.print("\n[bold]Operation cancelled by user. Goodbye![/bold]")
+        console.print("[bold]Operation cancelled. Goodbye![/bold]")
     except Exception as e:
         logging.exception("An unexpected error occurred.")
         console.print(f"[bold red]An unexpected error occurred: {e}[/bold red]")
         console.print(f"Details have been logged to {log_file}")
-
-if __name__ == "__main__":
-    main()

{peg_this-3.0.0.dist-info → peg_this-3.0.1.dist-info}/METADATA

@@ -1,34 +1,42 @@
 Metadata-Version: 2.4
 Name: peg_this
-Version: 3.0.0
-Summary: A powerful tool for converting, manipulating, and inspecting media files using FFmpeg.
+Version: 3.0.1
+Summary: A powerful, intuitive command-line video editor suite, built on FFmpeg.
 Author-email: Hariharen S S <thisishariharen@gmail.com>
+Project-URL: Homepage, https://github.com/hariharen9/ffmpeg-this
+Project-URL: Bug Tracker, https://github.com/hariharen9/ffmpeg-this/issues
+Project-URL: Releases, https://github.com/hariharen9/ffmpeg-this/releases
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
+Classifier: Topic :: Multimedia :: Video :: Conversion
+Classifier: Topic :: Multimedia :: Video :: Non-Linear Editor
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: ffmpeg-python
-Requires-Dist: questionary
-Requires-Dist: rich
-Requires-Dist: Pillow
+Requires-Dist: ffmpeg-python==0.2.0
+Requires-Dist: questionary>=2.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: Pillow>=9.0.0
 Dynamic: license-file
 
 # 🎬 ffmPEG-this
 
+> Your Video editor within CLI 🚀
+
 A powerful and user-friendly batch script for converting, manipulating, and inspecting media files using the power of FFmpeg. This script provides a simple command-line menu to perform common audio and video tasks without needing to memorize complex FFmpeg commands.
 
 ## ✨ Features
 
-- **Action-Oriented Menu:** Select a file, then choose from a list of available actions.
-- **File Inspection:** View detailed information about a media file, including resolution, duration, size, and stream details.
-- **Lossless Conversion:** Change a file's container format (e.g., **MKV to MP4, , MP4 to GIF** etc.) without re-encoding, preserving the original quality.
-- **Lossy Conversion:** Re-encode video to reduce file size, with simple quality presets.
-- **Video Trimming:** Cut a video by specifying a start and end time.
-- **Audio Extraction:** Extract the audio from a video file into formats like MP3, FLAC, or WAV.
-- **Audio Removal:** Create a silent version of a video by removing its audio track.
-- **Batch Conversion:** Convert all video files in the directory to a specific format in one go.
+- **Inspect Media Properties**: View detailed information about video and audio streams, including codecs, resolution, frame rate, bitrates, and more.
+- **Convert & Transcode**: Convert videos and audio to a wide range of popular formats (MP4, MKV, WebM, MP3, FLAC, WAV, GIF) with simple quality presets.
+- **Join Videos (Concatenate)**: Combine two or more videos into a single file. The tool automatically handles differences in resolution and audio sample rates for a seamless join.
+- **Trim (Cut) Videos**: Easily cut a video to a specific start and end time without re-encoding for fast, lossless clips.
+- **Visually Crop Videos**: An interactive tool that shows you a frame of the video, allowing you to click and drag to select the exact area you want to crop.
+- **Extract Audio**: Rip the audio track from any video file into MP3, FLAC, or WAV.
+- **Remove Audio**: Create a silent version of your video by stripping out all audio streams.
+- **Batch Conversion**: Convert all media files in the current directory to a specified format in one go.
+
 
 ## 🚀 Usage
 

peg_this-3.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+peg_this/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+peg_this/peg_this.py,sha256=khAYs2cz5zzxrq2onEt7YNcHjS9xcNJv_dvpXQD-RVg,30150
+peg_this-3.0.1.dist-info/licenses/LICENSE,sha256=WL1MklYSco7KZvDjbf191tIKOxWQdekqda7dDJc6Wn8,1067
+peg_this-3.0.1.dist-info/METADATA,sha256=HhoqodFFu5cKBkuezJ7gDAEPlXwkOn_Z-TbC8L7oyZc,3527
+peg_this-3.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+peg_this-3.0.1.dist-info/entry_points.txt,sha256=9GVTFuE1w_wgY-Tz3--wI5j52BAKrt4atphVD8ioHhQ,52
+peg_this-3.0.1.dist-info/top_level.txt,sha256=kSS5jZg3KN2kJqYZwMvQnI4gvlFxsUNzIm3QJsbKFdc,9
+peg_this-3.0.1.dist-info/RECORD,,

peg_this-3.0.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-peg_this/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-peg_this/peg_this.py,sha256=aDGeEMBWxfr_jt0Fn0xdwVa6KzS9bcBvXoDfNQ2B7Ao,21508
-peg_this-3.0.0.dist-info/licenses/LICENSE,sha256=WL1MklYSco7KZvDjbf191tIKOxWQdekqda7dDJc6Wn8,1067
-peg_this-3.0.0.dist-info/METADATA,sha256=OMOLRyxRv5zs7xtbMZferx0RjWVs448zQrPemgepgZY,2902
-peg_this-3.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-peg_this-3.0.0.dist-info/entry_points.txt,sha256=9GVTFuE1w_wgY-Tz3--wI5j52BAKrt4atphVD8ioHhQ,52
-peg_this-3.0.0.dist-info/top_level.txt,sha256=kSS5jZg3KN2kJqYZwMvQnI4gvlFxsUNzIm3QJsbKFdc,9
-peg_this-3.0.0.dist-info/RECORD,,