vidio-cli 0.1.0__py3-none-any.whl

vidio_cli/__init__.py

@@ -0,0 +1,3 @@
+from importlib.metadata import version
+
+__version__ = version("vidio-cli")

vidio_cli/cli.py

@@ -0,0 +1,62 @@
+"""CLI entry point for vidio - A simple ffmpeg wrapper."""
+
+import typer
+from rich.console import Console
+
+from vidio_cli import __version__
+from vidio_cli.commands import get_commands
+from vidio_cli.ffmpeg_utils import ensure_ffmpeg
+
+# Create Typer app
+app = typer.Typer(
+    help="A simple ffmpeg wrapper for common video operations",
+    add_completion=False,  # No shell completion for now
+    no_args_is_help=True,
+)
+
+console = Console()
+
+
+def version_callback(value: bool) -> None:
+    """Print the version of the package."""
+    if value:
+        console.print(f"[bold]vidio[/bold] version: {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        help="Show the version and exit.",
+        callback=version_callback,
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        "-v",
+        help="Show ffmpeg commands and other debug info.",
+    ),
+) -> None:
+    """
+    A simple CLI tool to perform common video operations using ffmpeg.
+    """
+    # Check if ffmpeg is installed
+    ensure_ffmpeg()
+
+    # Store verbose flag in context for global access
+    ctx.ensure_object(dict)
+    ctx.obj["VERBOSE"] = verbose
+
+
+# Dynamic command registration
+commands = get_commands()
+for name, register_func in commands.items():
+    register_func(app)
+
+
+if __name__ == "__main__":
+    app()

vidio_cli/commands/__init__.py

@@ -0,0 +1,36 @@
+"""Command modules for vidio-cli."""
+
+import pkgutil
+from importlib import import_module
+from pathlib import Path
+from typing import Callable
+
+
+def get_commands() -> dict[str, Callable]:
+    """
+    Dynamically discover and import all command modules in this package.
+
+    Returns:
+        A dictionary mapping command names to functions.
+    """
+    commands = {}
+
+    # Get the directory of this package
+    package_dir = Path(__file__).parent
+
+    # Find all Python modules in this package
+    for _, module_name, _ in pkgutil.iter_modules([str(package_dir)]):
+        # Skip the __init__ module
+        if module_name == "__init__":
+            continue
+
+        # Import the module
+        module = import_module(f"{__package__}.{module_name}")
+
+        # Look for a 'register' function
+        if hasattr(module, "register"):
+            # This is a valid command module, add it to the dict
+            command_name = module_name.replace("_", "-")
+            commands[command_name] = module.register
+
+    return commands

vidio_cli/commands/concat.py

@@ -0,0 +1,103 @@
+"""Command module for concatenating videos horizontally or vertically."""
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from vidio_cli.ffmpeg_utils import check_output_file, run_ffmpeg
+
+console = Console()
+
+
+def register(app: typer.Typer) -> None:
+    """
+    Register the concat command with the Typer app.
+
+    Args:
+        app: The Typer app to register the command with.
+    """
+    app.command(no_args_is_help=True)(concat)
+
+
+def concat(
+    ctx: typer.Context,
+    input_files: list[Path] = typer.Argument(
+        ...,
+        help="Input video files to concatenate",
+        exists=True,
+        dir_okay=False,
+        resolve_path=True,
+        min=2,
+    ),
+    output_file: Path = typer.Argument(
+        ...,
+        help="Output video file",
+        dir_okay=False,
+        resolve_path=True,
+    ),
+    vertical: bool = typer.Option(
+        False,
+        "--vertical",
+        help="Stack videos vertically instead of horizontally",
+    ),
+    overwrite: bool = typer.Option(
+        False,
+        "--overwrite",
+        help="Overwrite output file if it exists",
+    ),
+) -> None:
+    """
+    Concatenate multiple videos side by side (horizontally) or stacked (vertically).
+
+    Examples:
+        - Concatenate videos horizontally: vidio concat video1.mp4 video2.mp4 output.mp4
+        - Stack videos vertically: vidio concat video1.mp4 video2.mp4 output.mp4 --vertical
+    """
+    # Get verbose flag from global context
+    verbose = ctx.obj.get("VERBOSE", False) if ctx.obj else False
+
+    # Check if output file exists and if we should overwrite it
+    if not check_output_file(output_file, overwrite):
+        console.print("[yellow]Aborted.[/yellow]")
+        raise typer.Exit(code=0)
+
+    # Build the filter complex string for concatenation
+    filter_complex = ""
+
+    # Prepare inputs
+    inputs = []
+    for i, _ in enumerate(input_files):
+        inputs.extend(["-i", str(input_files[i])])
+
+    # Set the layout direction
+    layout = "vstack" if vertical else "hstack"
+
+    # Create filter_complex setting for proper scaling
+    inputs_str = "[0:v]"
+    for i in range(1, len(input_files)):
+        inputs_str += f"[{i}:v]"
+
+    filter_complex = f"{inputs_str}{layout}=inputs={len(input_files)}[v]"
+
+    # Build the ffmpeg command
+    command = [
+        "ffmpeg",
+        *inputs,
+        "-filter_complex",
+        filter_complex,
+        "-map",
+        "[v]",
+        # Map all audio streams (if present)
+        "-map",
+        "0:a?",
+        # Use the first audio stream for output
+        "-c:a",
+        "aac",
+        "-shortest",  # End when shortest input ends
+        "-y" if overwrite else "-n",  # Overwrite if specified
+        str(output_file),
+    ]
+
+    # Run the command
+    run_ffmpeg(command, verbose=verbose)

vidio_cli/commands/crop.py

@@ -0,0 +1,391 @@
+"""Command module for cropping videos."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from vidio_cli.ffmpeg_utils import check_output_file, get_video_info, run_ffmpeg
+
+console = Console()
+
+
+def register(app: typer.Typer) -> None:
+    """
+    Register the crop command with the Typer app.
+
+    Args:
+        app: The Typer app to register the command with.
+    """
+    app.command(no_args_is_help=True)(crop)
+
+
+def validate_crop_params(
+    width: int,
+    height: int,
+    x: int,
+    y: int,
+    original_width: int,
+    original_height: int,
+) -> None:
+    """
+    Validate crop parameters against original video dimensions.
+
+    Args:
+        width: Crop width
+        height: Crop height
+        x: X offset
+        y: Y offset
+        original_width: Original video width
+        original_height: Original video height
+
+    Raises:
+        typer.BadParameter: If parameters are invalid
+    """
+    if width <= 0 or height <= 0:
+        raise typer.BadParameter("Width and height must be positive")
+
+    if x < 0 or y < 0:
+        raise typer.BadParameter("X and Y offsets must be non-negative")
+
+    if x + width > original_width:
+        raise typer.BadParameter(
+            f"Crop region exceeds video width: {x} + {width} > {original_width}"
+        )
+
+    if y + height > original_height:
+        raise typer.BadParameter(
+            f"Crop region exceeds video height: {y} + {height} > {original_height}"
+        )
+
+
+def parse_preset(
+    preset: str,
+    original_width: int,
+    original_height: int,
+) -> tuple[int, int, int, int]:
+    """
+    Parse preset crop values.
+
+    Args:
+        preset: Preset name (center-square, 16:9, 9:16, 4:3, 1:1)
+        original_width: Original video width
+        original_height: Original video height
+
+    Returns:
+        tuple: (width, height, x, y)
+
+    Raises:
+        typer.BadParameter: If preset is invalid or video dimensions are invalid
+    """
+    if original_width <= 0 or original_height <= 0:
+        raise typer.BadParameter(
+            f"Invalid video dimensions: {original_width}x{original_height}"
+        )
+
+    preset = preset.lower()
+
+    if preset == "center-square" or preset == "1:1":
+        # Crop to largest centered square
+        size = min(original_width, original_height)
+        x = (original_width - size) // 2
+        y = (original_height - size) // 2
+        return size, size, x, y
+
+    elif preset == "16:9":
+        # Crop to 16:9 aspect ratio
+        target_ratio = 16 / 9
+        current_ratio = original_width / original_height
+
+        if current_ratio > target_ratio:
+            # Too wide, crop width
+            height = original_height
+            width = int(height * target_ratio)
+            x = (original_width - width) // 2
+            y = 0
+        else:
+            # Too tall, crop height
+            width = original_width
+            height = int(width / target_ratio)
+            x = 0
+            y = (original_height - height) // 2
+
+        return width, height, x, y
+
+    elif preset == "9:16":
+        # Crop to 9:16 aspect ratio (vertical/portrait)
+        target_ratio = 9 / 16
+        current_ratio = original_width / original_height
+
+        if current_ratio > target_ratio:
+            # Too wide, crop width
+            height = original_height
+            width = int(height * target_ratio)
+            x = (original_width - width) // 2
+            y = 0
+        else:
+            # Too tall, crop height
+            width = original_width
+            height = int(width / target_ratio)
+            x = 0
+            y = (original_height - height) // 2
+
+        return width, height, x, y
+
+    elif preset == "4:3":
+        # Crop to 4:3 aspect ratio
+        target_ratio = 4 / 3
+        current_ratio = original_width / original_height
+
+        if current_ratio > target_ratio:
+            # Too wide, crop width
+            height = original_height
+            width = int(height * target_ratio)
+            x = (original_width - width) // 2
+            y = 0
+        else:
+            # Too tall, crop height
+            width = original_width
+            height = int(width / target_ratio)
+            x = 0
+            y = (original_height - height) // 2
+
+        return width, height, x, y
+
+    else:
+        raise typer.BadParameter(
+            f"Unknown preset: {preset}. Valid presets: center-square, 16:9, 9:16, 4:3, 1:1"
+        )
+
+
+def crop(
+    ctx: typer.Context,
+    input_file: Path = typer.Argument(
+        ...,
+        help="Input video file to crop",
+        exists=True,
+        dir_okay=False,
+        resolve_path=True,
+    ),
+    output_file: Path = typer.Argument(
+        ...,
+        help="Output video file",
+        dir_okay=False,
+        resolve_path=True,
+    ),
+    width: Optional[int] = typer.Option(
+        None,
+        "--width",
+        "-w",
+        help="Width of the cropped region in pixels",
+        min=1,
+    ),
+    height: Optional[int] = typer.Option(
+        None,
+        "--height",
+        "-h",
+        help="Height of the cropped region in pixels",
+        min=1,
+    ),
+    x: Optional[int] = typer.Option(
+        None,
+        "--x",
+        help="X offset (left edge) of the crop region in pixels",
+        min=0,
+    ),
+    y: Optional[int] = typer.Option(
+        None,
+        "--y",
+        help="Y offset (top edge) of the crop region in pixels",
+        min=0,
+    ),
+    preset: Optional[str] = typer.Option(
+        None,
+        "--preset",
+        "-p",
+        help="Use a preset crop (center-square, 16:9, 9:16, 4:3, 1:1)",
+    ),
+    keep_aspect: bool = typer.Option(
+        True,
+        "--keep-aspect/--no-keep-aspect",
+        help="Keep aspect ratio when using width/height only",
+    ),
+    overwrite: bool = typer.Option(
+        False,
+        "--overwrite",
+        help="Overwrite output file if it exists",
+    ),
+) -> None:
+    """
+    Crop a video to a specific region.
+
+    You can specify the crop region manually with --width, --height, --x, --y,
+    or use a preset for common aspect ratios.
+
+    Examples:
+        - Crop to center square: vidio crop input.mp4 output.mp4 --preset center-square
+        - Crop to 16:9: vidio crop input.mp4 output.mp4 --preset 16:9
+        - Custom crop: vidio crop input.mp4 output.mp4 -w 1280 -h 720 --x 100 --y 50
+        - Crop from top-left: vidio crop input.mp4 output.mp4 -w 1920 -h 1080
+    """
+    # Get verbose flag from global context
+    verbose = ctx.obj.get("VERBOSE", False) if ctx.obj else False
+
+    # Check if output file exists and if we should overwrite it
+    if not check_output_file(output_file, overwrite):
+        console.print("[yellow]Aborted.[/yellow]")
+        raise typer.Exit(0)
+
+    # Get original video dimensions
+    try:
+        video_info = get_video_info(input_file, verbose)
+        video_streams = [
+            s for s in video_info.get("streams", []) if s.get("codec_type") == "video"
+        ]
+
+        if not video_streams:
+            console.print("[red]Error: No video stream found in input file[/red]")
+            console.print(
+                "[dim]The file may be corrupted or not a valid video file.[/dim]"
+            )
+            raise typer.Exit(1)
+
+        original_width = video_streams[0].get("width", 0)
+        original_height = video_streams[0].get("height", 0)
+
+        if not original_width or not original_height:
+            console.print(
+                "[red]Error: Could not determine original video dimensions[/red]"
+            )
+            console.print(
+                "[dim]The video file may be corrupted or in an unsupported format.[/dim]"
+            )
+            raise typer.Exit(1)
+
+        # Validate dimensions are reasonable
+        if original_width > 16384 or original_height > 16384:
+            console.print(
+                f"[yellow]Warning: Very large video dimensions ({original_width}x{original_height}). "
+                "Processing may be slow.[/yellow]"
+            )
+
+        if original_width < 2 or original_height < 2:
+            console.print(
+                f"[red]Error: Video dimensions too small ({original_width}x{original_height}). "
+                "Cannot crop.[/red]"
+            )
+            raise typer.Exit(1)
+
+        console.print(
+            f"[dim]Original video dimensions: {original_width}x{original_height}[/dim]"
+        )
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        console.print(f"[red]Error reading video info: {e}[/red]")
+        console.print("[dim]Make sure the input file is a valid video file.[/dim]")
+        raise typer.Exit(1)
+
+    # Determine crop parameters
+    if preset:
+        if any([width, height, x, y]):
+            console.print(
+                "[yellow]Warning: Preset specified, ignoring manual crop parameters[/yellow]"
+            )
+
+        try:
+            crop_width, crop_height, crop_x, crop_y = parse_preset(
+                preset, original_width, original_height
+            )
+            console.print(f"[blue]Using preset: {preset}[/blue]")
+        except typer.BadParameter as e:
+            console.print(f"[red]Error: {e}[/red]")
+            raise typer.Exit(1)
+
+    else:
+        # Manual crop parameters
+        if width is None or height is None:
+            console.print(
+                "[red]Error: Must specify --width and --height, or use --preset[/red]"
+            )
+            raise typer.Exit(1)
+
+        # Validate manual dimensions don't exceed video
+        if width > original_width:
+            console.print(
+                f"[red]Error: Crop width ({width}) exceeds video width ({original_width})[/red]"
+            )
+            raise typer.Exit(1)
+
+        if height > original_height:
+            console.print(
+                f"[red]Error: Crop height ({height}) exceeds video height ({original_height})[/red]"
+            )
+            raise typer.Exit(1)
+
+        crop_width = width
+        crop_height = height
+        crop_x = x if x is not None else 0
+        crop_y = y if y is not None else 0
+
+        # Default to center if no offsets specified and keep_aspect is True
+        if x is None and y is None and keep_aspect:
+            crop_x = (original_width - crop_width) // 2
+            crop_y = (original_height - crop_height) // 2
+            console.print("[dim]Centering crop region (no offsets specified)[/dim]")
+
+    # Ensure even dimensions for better codec compatibility
+    if crop_width % 2 != 0:
+        crop_width -= 1
+        console.print(
+            f"[dim]Adjusted width to {crop_width} (must be even for codec compatibility)[/dim]"
+        )
+
+    if crop_height % 2 != 0:
+        crop_height -= 1
+        console.print(
+            f"[dim]Adjusted height to {crop_height} (must be even for codec compatibility)[/dim]"
+        )
+
+    # Warn if crop dimensions are very small
+    if crop_width < 64 or crop_height < 64:
+        console.print(
+            f"[yellow]Warning: Very small crop dimensions ({crop_width}x{crop_height}). "
+            "Output quality may be poor.[/yellow]"
+        )
+
+    # Validate crop parameters
+    try:
+        validate_crop_params(
+            crop_width, crop_height, crop_x, crop_y, original_width, original_height
+        )
+    except typer.BadParameter as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+    # Show what we're doing
+    console.print(
+        f"[blue]Cropping to {crop_width}x{crop_height} at position ({crop_x}, {crop_y})[/blue]"
+    )
+
+    # Build the ffmpeg command with crop filter
+    crop_filter = f"crop={crop_width}:{crop_height}:{crop_x}:{crop_y}"
+
+    command = [
+        "ffmpeg",
+        "-i",
+        str(input_file),
+        "-vf",
+        crop_filter,
+        "-c:a",
+        "copy",  # Copy audio without re-encoding
+        "-y" if overwrite else "-n",  # Overwrite if specified
+        str(output_file),
+    ]
+
+    # Run the command
+    run_ffmpeg(command, verbose=verbose)
+
+    console.print(f"[green]✓[/green] Cropped video saved to {output_file}")