peg-this 3.0.2__py3-none-any.whl → 4.1.0__py3-none-any.whl

peg_this/features/crop.py

@@ -0,0 +1,207 @@
+import os
+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, warn_reencode, press_continue
+)
+
+try:
+    import tkinter as tk
+    from tkinter import messagebox
+    from PIL import Image, ImageTk
+except ImportError:
+    tk = None
+
+console = Console()
+
+
+def crop_video(file_path):
+    if not tk:
+        console.print("[bold red]Cannot perform visual cropping: tkinter & Pillow are not installed.[/bold red]")
+        console.print("[dim]Install them with: pip install tk Pillow[/dim]")
+        press_continue()
+        return
+
+    if not validate_input_file(file_path):
+        press_continue()
+        return
+
+    preview_frame = f"preview_{Path(file_path).stem}.jpg"
+    try:
+        probe = ffmpeg.probe(file_path)
+        duration = float(probe['format'].get('duration', 0))
+
+        if duration <= 0:
+            console.print("[bold red]Error: Could not determine video duration.[/bold red]")
+            press_continue()
+            return
+
+        mid_point = duration / 2
+
+        run_command(
+            ffmpeg.input(file_path, ss=mid_point).output(preview_frame, vframes=1, **{'q:v': 2}).overwrite_output(),
+            "Extracting a frame for preview..."
+        )
+
+        if not os.path.exists(preview_frame):
+            console.print("[bold red]Could not extract a frame from the video.[/bold red]")
+            press_continue()
+            return
+
+        root = tk.Tk()
+        root.title("Crop Video - Drag to select area, close window to confirm")
+        root.attributes("-topmost", True)
+
+        img = Image.open(preview_frame)
+        img_tk = ImageTk.PhotoImage(img)
+
+        canvas = tk.Canvas(root, width=img.width, height=img.height, cursor="cross")
+        canvas.pack()
+        canvas.create_image(0, 0, anchor=tk.NW, image=img_tk)
+
+        rect_coords = {"x1": 0, "y1": 0, "x2": 0, "y2": 0}
+        rect_id = None
+
+        def on_press(event):
+            nonlocal rect_id
+            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):
+            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'])
+
+        canvas.bind("<ButtonPress-1>", on_press)
+        canvas.bind("<B1-Motion>", on_drag)
+
+        messagebox.showinfo("Instructions", "Click and drag to draw a cropping rectangle.\nClose this window when you are done.", parent=root)
+        root.mainloop()
+
+        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'])
+
+        if crop_w < 2 or crop_h < 2:
+            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}"
+        action_result, final_output = check_output_file(output_file, "Video file")
+
+        if action_result == 'cancel':
+            console.print("[yellow]Operation cancelled.[/yellow]")
+            return
+
+        warn_reencode("Video cropping")
+
+        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)
+
+        if has_audio_stream(file_path):
+            audio_stream = input_stream.audio
+            stream = ffmpeg.output(video_stream, audio_stream, final_output, **{'c:a': 'copy'})
+        else:
+            stream = ffmpeg.output(video_stream, final_output)
+
+        if action_result == 'overwrite':
+            stream = stream.overwrite_output()
+
+        if run_command(stream, "Applying crop to video...", show_progress=True):
+            console.print(f"[bold green]Successfully cropped video and saved to {final_output}[/bold green]")
+        else:
+            console.print("[bold red]Video cropping failed.[/bold red]")
+
+    except Exception as e:
+        console.print(f"[bold red]An error occurred: {e}[/bold red]")
+    finally:
+        if os.path.exists(preview_frame):
+            os.remove(preview_frame)
+        press_continue()
+
+
+def crop_image(file_path):
+    if not tk:
+        console.print("[bold red]Cannot perform visual cropping: tkinter & Pillow are not installed.[/bold red]")
+        console.print("[dim]Install them with: pip install tk Pillow[/dim]")
+        press_continue()
+        return
+
+    if not validate_input_file(file_path):
+        press_continue()
+        return
+
+    try:
+        root = tk.Tk()
+        root.title("Crop Image - Drag to select area, close window to confirm")
+        root.attributes("-topmost", True)
+
+        img = Image.open(file_path)
+
+        max_width = root.winfo_screenwidth() - 100
+        max_height = root.winfo_screenheight() - 100
+        img.thumbnail((max_width, max_height), Image.Resampling.LANCZOS)
+
+        img_tk = ImageTk.PhotoImage(img)
+
+        canvas = tk.Canvas(root, width=img.width, height=img.height, cursor="cross")
+        canvas.pack()
+        canvas.create_image(0, 0, anchor=tk.NW, image=img_tk)
+
+        rect_coords = {"x1": 0, "y1": 0, "x2": 0, "y2": 0}
+        rect_id = None
+
+        def on_press(event):
+            nonlocal rect_id
+            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):
+            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'])
+
+        canvas.bind("<ButtonPress-1>", on_press)
+        canvas.bind("<B1-Motion>", on_drag)
+
+        messagebox.showinfo("Instructions", "Click and drag to draw a cropping rectangle.\nClose this window when you are done.", parent=root)
+        root.mainloop()
+
+        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'])
+
+        if crop_w < 2 or crop_h < 2:
+            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}"
+        action_result, final_output = check_output_file(output_file, "Image file")
+
+        if action_result == 'cancel':
+            console.print("[yellow]Operation cancelled.[/yellow]")
+            return
+
+        stream = ffmpeg.input(file_path).filter('crop', w=crop_w, h=crop_h, x=crop_x, y=crop_y).output(final_output)
+
+        if action_result == 'overwrite':
+            stream = stream.overwrite_output()
+
+        if run_command(stream, "Applying crop to image..."):
+            console.print(f"[bold green]Successfully cropped image and saved to {final_output}[/bold green]")
+        else:
+            console.print("[bold red]Image cropping failed.[/bold red]")
+
+    except Exception as e:
+        console.print(f"[bold red]An error occurred during cropping: {e}[/bold red]")
+    finally:
+        press_continue()

peg_this/features/inspect.py

@@ -0,0 +1,110 @@
+import os
+import logging
+
+import ffmpeg
+import questionary
+from rich.console import Console
+from rich.table import Table
+
+from peg_this.utils.validation import validate_input_file, press_continue
+
+console = Console()
+
+
+def inspect_file(file_path):
+    if not validate_input_file(file_path):
+        press_continue()
+        return
+
+    console.print(f"Inspecting [bold]{os.path.basename(file_path)}[/bold]...")
+
+    try:
+        info = ffmpeg.probe(file_path)
+    except ffmpeg.Error as e:
+        error_msg = e.stderr.decode('utf-8') if e.stderr else "Unknown error"
+        console.print("[bold red]An error occurred while inspecting the file:[/bold red]")
+        console.print(f"[dim]{error_msg}[/dim]")
+        logging.error(f"ffprobe error: {error_msg}")
+        press_continue()
+        return
+
+    format_info = info.get('format', {})
+
+    if not format_info:
+        console.print("[bold red]Error: Could not read file format information.[/bold red]")
+        press_continue()
+        return
+
+    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")
+
+    try:
+        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
+    except (ValueError, TypeError):
+        size_mb = 0
+        duration_sec = 0
+        bit_rate_kbps = 0
+
+    table.add_row("Size", f"{size_mb:.2f} MB")
+    table.add_row("Duration", f"{duration_sec:.2f} seconds" if duration_sec > 0 else "N/A")
+    table.add_row("Format", format_info.get('format_long_name', 'N/A'))
+    table.add_row("Bitrate", f"{bit_rate_kbps:.0f} kb/s" if bit_rate_kbps > 0 else "N/A")
+    console.print(table)
+
+    streams = info.get('streams', [])
+
+    for stream_type in ['video', 'audio', 'subtitle']:
+        type_streams = [s for s in streams if s.get('codec_type') == stream_type]
+        if type_streams:
+            if stream_type == 'video':
+                color = 'cyan'
+            elif stream_type == 'audio':
+                color = 'green'
+            else:
+                color = 'yellow'
+
+            stream_table = Table(title=f"{stream_type.capitalize()} Streams", show_header=True, header_style=f"bold {color}")
+            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")
+            elif stream_type == 'audio':
+                stream_table.add_column("Sample Rate")
+                stream_table.add_column("Channels")
+            else:
+                stream_table.add_column("Language")
+
+            for s in type_streams:
+                if stream_type == 'video':
+                    width = s.get('width', '?')
+                    height = s.get('height', '?')
+                    stream_table.add_row(
+                        f"#{s.get('index')}",
+                        s.get('codec_name', 'N/A'),
+                        f"{width}x{height}",
+                        s.get('r_frame_rate', 'N/A')
+                    )
+                elif stream_type == 'audio':
+                    stream_table.add_row(
+                        f"#{s.get('index')}",
+                        s.get('codec_name', 'N/A'),
+                        f"{s.get('sample_rate', 'N/A')} Hz",
+                        str(s.get('channels', 'N/A'))
+                    )
+                else:
+                    tags = s.get('tags', {})
+                    lang = tags.get('language', 'N/A')
+                    stream_table.add_row(
+                        f"#{s.get('index')}",
+                        s.get('codec_name', 'N/A'),
+                        lang
+                    )
+
+            console.print(stream_table)
+
+    press_continue()

peg_this/features/join.py

@@ -0,0 +1,137 @@
+import os
+from pathlib import Path
+
+import ffmpeg
+import questionary
+from rich.console import Console
+
+from peg_this.utils.ffmpeg_utils import run_command
+from peg_this.utils.ui_utils import get_media_files
+from peg_this.utils.validation import (
+    check_output_file, check_has_audio_stream, warn_reencode, press_continue
+)
+
+console = Console()
+
+
+def join_videos():
+    console.print("[bold cyan]Select videos to join (in order).[/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 (need at least 2).[/bold yellow]")
+        press_continue()
+        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]")
+        press_continue()
+        return
+
+    console.print("\n[cyan]Videos will be joined in this order:[/cyan]")
+    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
+
+    action_result, final_output = check_output_file(output_file, "Video file")
+    if action_result == 'cancel':
+        console.print("[yellow]Operation cancelled.[/yellow]")
+        press_continue()
+        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'), None)
+
+        if not video_info:
+            console.print("[bold red]Error: First video has no video stream.[/bold red]")
+            press_continue()
+            return
+
+        target_width = video_info['width']
+        target_height = video_info['height']
+        target_sar = video_info.get('sample_aspect_ratio', '1:1')
+
+        # Check for audio stream (optional)
+        audio_info = next((s for s in probe['streams'] if s['codec_type'] == 'audio'), None)
+        has_audio = audio_info is not None
+        target_sample_rate = audio_info['sample_rate'] if audio_info else '44100'
+
+    except Exception as e:
+        console.print(f"[bold red]Could not probe first video: {e}[/bold red]")
+        press_continue()
+        return
+
+    # Check if all videos have audio (if first one does)
+    if has_audio:
+        for video in selected_videos[1:]:
+            if not check_has_audio_stream(os.path.abspath(video)):
+                console.print(f"[yellow]Warning: '{video}' has no audio stream.[/yellow]")
+                if not questionary.confirm("Continue anyway? (silent sections will be added)", default=True).ask():
+                    return
+
+    console.print(f"\n[dim]Standardizing to: {target_width}x{target_height} @ {target_sample_rate} Hz[/dim]")
+    warn_reencode("Joining videos")
+
+    processed_streams = []
+    for video_file in selected_videos:
+        abs_path = os.path.abspath(video_file)
+        stream = ffmpeg.input(abs_path)
+
+        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')
+        )
+        processed_streams.append(v)
+
+        if has_audio:
+            if check_has_audio_stream(abs_path):
+                a = (
+                    stream.audio
+                    .filter('aresample', sample_rate=target_sample_rate)
+                    .filter('asetpts', 'PTS-STARTPTS')
+                )
+            else:
+                # Generate silent audio for videos without audio
+                a = ffmpeg.input('anullsrc', f='lavfi', t=1).filter('aresample', sample_rate=target_sample_rate)
+            processed_streams.append(a)
+
+    if has_audio:
+        joined = ffmpeg.concat(*processed_streams, v=1, a=1).node
+        output_stream = ffmpeg.output(
+            joined[0], joined[1], final_output,
+            **{'c:v': 'libx264', 'crf': 23, 'c:a': 'aac', 'b:a': '192k'}
+        )
+    else:
+        joined = ffmpeg.concat(*processed_streams, v=1, a=0).node
+        output_stream = ffmpeg.output(
+            joined[0], final_output,
+            **{'c:v': 'libx264', 'crf': 23}
+        )
+
+    if action_result == 'overwrite':
+        output_stream = output_stream.overwrite_output()
+
+    try:
+        if run_command(output_stream, "Joining and re-encoding videos...", show_progress=True):
+            console.print(f"[bold green]Successfully joined videos into {final_output}[/bold green]")
+        else:
+            console.print("[bold red]Failed to join videos.[/bold red]")
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Operation cancelled by user.[/yellow]")
+
+    press_continue()