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

peg_this/features/inspect.py

@@ -1,4 +1,3 @@
-
 import os
 import logging
 
@@ -7,54 +6,105 @@ 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):
-    """Show detailed information about the selected media file using ffprobe."""
-    console.print(f"Inspecting {os.path.basename(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(e.stderr.decode('utf-8'))
-        logging.error(f"ffprobe error:{e.stderr.decode('utf-8')}")
-        questionary.press_any_key_to_continue().ask()
+        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")
 
-    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
+    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")
+    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")
+    table.add_row("Bitrate", f"{bit_rate_kbps:.0f} kb/s" if bit_rate_kbps > 0 else "N/A")
     console.print(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'}")
+    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")
-            else:
+            elif stream_type == 'audio':
                 stream_table.add_column("Sample Rate")
                 stream_table.add_column("Channels")
-            
-            for s in streams:
+            else:
+                stream_table.add_column("Language")
+
+            for s in type_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'))
+                    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:
-                    stream_table.add_row(f"#{s.get('index')}", s.get('codec_name'), f"{s.get('sample_rate')} Hz", str(s.get('channels')))
+                    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)
 
-    questionary.press_any_key_to_continue().ask()
+    press_continue()

peg_this/features/join.py

@@ -1,4 +1,3 @@
-
 import os
 from pathlib import Path
 
@@ -8,76 +7,131 @@ 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():
-    """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]")
-    
+    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.[/bold yellow]")
-        questionary.press_any_key_to_continue().ask()
+        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()
+    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("Videos will be joined in this order:")
+    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
+    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')
-        audio_info = next(s for s in probe['streams'] if s['codec_type'] == 'audio')
-        
+        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')
-        target_sample_rate = audio_info['sample_rate']
+
+        # 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 for target parameters: {e}[/bold red]")
+        console.print(f"[bold red]Could not probe first video: {e}[/bold red]")
+        press_continue()
         return
 
-    console.print(f"Standardizing all videos to: {target_width}x{target_height} resolution and {target_sample_rate} Hz audio.")
+    # 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:
-        stream = ffmpeg.input(os.path.abspath(video_file))
+        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('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]")
+        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:
-        console.print("[bold red]Failed to join videos.[/bold red]")
-    
-    questionary.press_any_key_to_continue().ask()
+        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()