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

peg_this/features/convert.py

@@ -1,4 +1,3 @@
-
 import os
 from pathlib import Path
 
@@ -7,32 +6,52 @@ 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, validate_positive_integer, press_continue
+)
 
 console = Console()
 
 
 def convert_file(file_path):
-    """Convert the file to a different format."""
+    if not validate_input_file(file_path):
+        press_continue()
+        return
+
     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
+    output_format = questionary.select(
+        "Select the output format:",
+        choices=["mp4", "mkv", "mov", "avi", "webm", "mp3", "flac", "wav", "gif"]
+    ).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()
+        press_continue()
         return
 
     output_file = f"{Path(file_path).stem}_converted.{output_format}"
-    
+    action_result, final_output = check_output_file(output_file, "Output file")
+
+    if action_result == 'cancel':
+        console.print("[yellow]Operation cancelled.[/yellow]")
+        press_continue()
+        return
+
     input_stream = ffmpeg.input(file_path)
     output_stream = None
-    kwargs = {'y': None}
+    kwargs = {}
 
     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
+        quality = questionary.select(
+            "Select quality preset:",
+            choices=["Same as source", "High (CRF 18)", "Medium (CRF 23)", "Low (CRF 28)"]
+        ).ask()
+        if not quality:
+            return
 
         if quality == "Same as source":
             kwargs['c'] = 'copy'
@@ -46,73 +65,101 @@ def convert_file(file_path):
                 kwargs['b:a'] = '192k'
             else:
                 kwargs['an'] = None
-        output_stream = input_stream.output(output_file, **kwargs)
+        output_stream = input_stream.output(final_output, **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
+            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)
+        output_stream = input_stream.output(final_output, **kwargs)
 
     elif output_format == "gif":
         fps = questionary.text("Enter frame rate (e.g., 15):", default="15").ask()
-        if not fps: return
+        if not fps:
+            return
+        fps_val = validate_positive_integer(fps, "Frame rate")
+        if not fps_val:
+            press_continue()
+            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()
+        if not scale:
+            return
+        scale_val = validate_positive_integer(scale, "Width")
+        if not scale_val:
+            press_continue()
             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)
+        palette_file = f"palette_{Path(file_path).stem}.png"
 
-    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]")
+        try:
+            palette_gen_stream = input_stream.video.filter('fps', fps=fps_val).filter('scale', w=scale_val, h=-1, flags='lanczos').filter('palettegen')
+            run_command(palette_gen_stream.output(palette_file).overwrite_output(), "Generating color palette...")
+
+            if not os.path.exists(palette_file):
+                console.print("[bold red]Failed to generate color palette for GIF.[/bold red]")
+                press_continue()
+                return
+
+            palette_input = ffmpeg.input(palette_file)
+            video_stream = input_stream.video.filter('fps', fps=fps_val).filter('scale', w=scale_val, h=-1, flags='lanczos')
+            final_stream = ffmpeg.filter([video_stream, palette_input], 'paletteuse')
+            output_stream = final_stream.output(final_output)
+
+        finally:
+            if os.path.exists(palette_file):
+                os.remove(palette_file)
+
+    if output_stream:
+        if action_result == 'overwrite':
+            output_stream = output_stream.overwrite_output()
+
+        if run_command(output_stream, f"Converting to {output_format}...", show_progress=True):
+            console.print(f"[bold green]Successfully converted to {final_output}[/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()
+    press_continue()
 
 
 def convert_image(file_path):
-    """Convert an image to a different format."""
+    if not validate_input_file(file_path):
+        press_continue()
+        return
+
     output_format = questionary.select(
         "Select the output format:",
-        choices=["jpg", "png", "webp", "bmp", "tiff"],
-        use_indicator=True
+        choices=["jpg", "png", "webp", "bmp", "tiff"]
     ).ask()
-    if not output_format: return
+    if not output_format:
+        return
 
     output_file = f"{Path(file_path).stem}_converted.{output_format}"
-    kwargs = {'y': None}
-    
-    # For JPG and WEBP, allow quality selection
+    action_result, final_output = check_output_file(output_file, "Image file")
+
+    if action_result == 'cancel':
+        console.print("[yellow]Operation cancelled.[/yellow]")
+        press_continue()
+        return
+
+    kwargs = {}
+
     if output_format in ['jpg', 'webp']:
         quality_preset = questionary.select(
             "Select quality preset:",
-            choices=["High (95%)", "Medium (80%)", "Low (60%)"],
-            use_indicator=True
+            choices=["High (95%)", "Medium (80%)", "Low (60%)"]
         ).ask()
-        if not quality_preset: return
+        if not quality_preset:
+            return
 
         quality_map = {"High (95%)": "95", "Medium (80%)": "80", "Low (60%)": "60"}
         quality = quality_map[quality_preset]
@@ -123,103 +170,140 @@ def convert_image(file_path):
         elif output_format == 'webp':
             kwargs['quality'] = quality
 
-    stream = ffmpeg.input(file_path).output(output_file, **kwargs)
-    
+    stream = ffmpeg.input(file_path).output(final_output, **kwargs)
+
+    if action_result == 'overwrite':
+        stream = stream.overwrite_output()
+
     if run_command(stream, f"Converting to {output_format.upper()}..."):
-        console.print(f"[bold green]Successfully converted image to {output_file}[/bold green]")
+        console.print(f"[bold green]Successfully converted image to {final_output}[/bold green]")
     else:
         console.print("[bold red]Image conversion failed.[/bold red]")
-    
-    questionary.press_any_key_to_continue().ask()
+
+    press_continue()
 
 
 def resize_image(file_path):
-    """Resize an image to new dimensions."""
+    if not validate_input_file(file_path):
+        press_continue()
+        return
+
     console.print("Enter new dimensions. Use [bold]-1[/bold] for one dimension to preserve aspect ratio.")
     width = questionary.text("Enter new width (e.g., 1280 or -1):").ask()
-    if not width: return
+    if not width:
+        return
     height = questionary.text("Enter new height (e.g., 720 or -1):").ask()
-    if not height: return
+    if not height:
+        return
 
-    try:
-        if int(width) == -1 and int(height) == -1:
-            console.print("[bold red]Error: Width and Height cannot both be -1.[/bold red]")
-            questionary.press_any_key_to_continue().ask()
-            return
-    except ValueError:
-        console.print("[bold red]Error: Invalid dimensions. Please enter numbers.[/bold red]")
-        questionary.press_any_key_to_continue().ask()
+    width_val = validate_positive_integer(width, "Width")
+    height_val = validate_positive_integer(height, "Height")
+
+    if width_val is None or height_val is None:
+        press_continue()
+        return
+
+    if width_val == -1 and height_val == -1:
+        console.print("[bold red]Error: Width and Height cannot both be -1.[/bold red]")
+        press_continue()
         return
 
     output_file = f"{Path(file_path).stem}_resized{Path(file_path).suffix}"
-    
-    stream = ffmpeg.input(file_path).filter('scale', w=width, h=height).output(output_file, y=None)
-    
+    action_result, final_output = check_output_file(output_file, "Image file")
+
+    if action_result == 'cancel':
+        console.print("[yellow]Operation cancelled.[/yellow]")
+        press_continue()
+        return
+
+    stream = ffmpeg.input(file_path).filter('scale', w=width_val, h=height_val).output(final_output)
+
+    if action_result == 'overwrite':
+        stream = stream.overwrite_output()
+
     if run_command(stream, "Resizing image..."):
-        console.print(f"[bold green]Successfully resized image to {output_file}[/bold green]")
+        console.print(f"[bold green]Successfully resized image to {final_output}[/bold green]")
     else:
         console.print("[bold red]Image resizing failed.[/bold red]")
-        
-    questionary.press_any_key_to_continue().ask()
+
+    press_continue()
 
 
 def rotate_image(file_path):
-    """Rotate an image."""
+    if not validate_input_file(file_path):
+        press_continue()
+        return
+
     rotation = questionary.select(
         "Select rotation:",
-        choices=[
-            "90 degrees clockwise",
-            "90 degrees counter-clockwise",
-            "180 degrees"
-        ],
-        use_indicator=True
+        choices=["90 degrees clockwise", "90 degrees counter-clockwise", "180 degrees"]
     ).ask()
-    if not rotation: return
+    if not rotation:
+        return
 
     output_file = f"{Path(file_path).stem}_rotated{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]")
+        press_continue()
+        return
+
     stream = ffmpeg.input(file_path)
     if rotation == "90 degrees clockwise":
         stream = stream.filter('transpose', 1)
     elif rotation == "90 degrees counter-clockwise":
         stream = stream.filter('transpose', 2)
     elif rotation == "180 degrees":
-        # Apply 90-degree rotation twice for 180 degrees
         stream = stream.filter('transpose', 2).filter('transpose', 2)
 
-    output_stream = stream.output(output_file, y=None)
-    
+    output_stream = stream.output(final_output)
+
+    if action_result == 'overwrite':
+        output_stream = output_stream.overwrite_output()
+
     if run_command(output_stream, "Rotating image..."):
-        console.print(f"[bold green]Successfully rotated image and saved to {output_file}[/bold green]")
+        console.print(f"[bold green]Successfully rotated image and saved to {final_output}[/bold green]")
     else:
         console.print("[bold red]Image rotation failed.[/bold red]")
-        
-    questionary.press_any_key_to_continue().ask()
+
+    press_continue()
 
 
 def flip_image(file_path):
-    """Flip an image horizontally or vertically."""
+    if not validate_input_file(file_path):
+        press_continue()
+        return
+
     flip_direction = questionary.select(
         "Select flip direction:",
-        choices=["Horizontal", "Vertical"],
-        use_indicator=True
+        choices=["Horizontal", "Vertical"]
     ).ask()
-    if not flip_direction: return
+    if not flip_direction:
+        return
 
     output_file = f"{Path(file_path).stem}_flipped{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]")
+        press_continue()
+        return
+
     stream = ffmpeg.input(file_path)
     if flip_direction == "Horizontal":
         stream = stream.filter('hflip')
     else:
         stream = stream.filter('vflip')
 
-    output_stream = stream.output(output_file, y=None)
-    
+    output_stream = stream.output(final_output)
+
+    if action_result == 'overwrite':
+        output_stream = output_stream.overwrite_output()
+
     if run_command(output_stream, "Flipping image..."):
-        console.print(f"[bold green]Successfully flipped image and saved to {output_file}[/bold green]")
+        console.print(f"[bold green]Successfully flipped image and saved to {final_output}[/bold green]")
     else:
         console.print("[bold red]Image flipping failed.[/bold red]")
-        
-    questionary.press_any_key_to_continue().ask()
 
+    press_continue()

peg_this/features/crop.py

@@ -1,4 +1,3 @@
-
 import os
 from pathlib import Path
 
@@ -7,6 +6,9 @@ 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
@@ -19,29 +21,38 @@ console = Console()
 
 
 def crop_video(file_path):
-    """Visually crop a video by selecting an area."""
     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:
-        # Extract a frame from the middle of the video for preview
         probe = ffmpeg.probe(file_path)
-        duration = float(probe['format']['duration'])
+        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
-        
-        # 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),
+            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
 
-        # --- Tkinter GUI for Cropping ---
         root = tk.Tk()
         root.title("Crop Video - Drag to select area, close window to confirm")
         root.attributes("-topmost", True)
@@ -67,65 +78,77 @@ def crop_video(file_path):
 
         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()
 
-        # --- 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'])
 
-        if crop_w < 2 or crop_h < 2: # Avoid tiny, invalid crops
+        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)
-        
-        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)
+            stream = ffmpeg.output(video_stream, audio_stream, final_output, **{'c:a': 'copy'})
         else:
-            stream = ffmpeg.output(video_stream, output_file, **kwargs)
+            stream = ffmpeg.output(video_stream, final_output)
+
+        if action_result == 'overwrite':
+            stream = stream.overwrite_output()
 
-        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]")
+        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)
-        questionary.press_any_key_to_continue().ask()
+        press_continue()
 
 
 def crop_image(file_path):
-    """Visually crop an image by selecting an area."""
     if not tk:
         console.print("[bold red]Cannot perform visual cropping: tkinter & Pillow are not installed.[/bold red]")
-        console.print("Please install them with: [bold]pip install tk Pillow[/bold]")
-        questionary.press_any_key_to_continue().ask()
+        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:
-        # --- Tkinter GUI for Cropping ---
         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")
@@ -146,11 +169,10 @@ def crop_image(file_path):
 
         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()
 
-        # --- 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'])
@@ -158,21 +180,28 @@ def crop_image(file_path):
 
         if crop_w < 2 or crop_h < 2:
             console.print("[bold yellow]Cropping cancelled as no valid area was selected.[/bold yellow]")
-            questionary.press_any_key_to_continue().ask()
             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', w=crop_w, h=crop_h, x=crop_x, y=crop_y).output(output_file, y=None)
+        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 {output_file}[/bold green]")
+            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:
-        questionary.press_any_key_to_continue().ask()
+        press_continue()