spatelier 0.3.0__py3-none-any.whl

cli/cli_utils.py

@@ -0,0 +1,282 @@
+"""
+Utility CLI commands.
+
+This module provides command-line interfaces for utility operations.
+"""
+
+from pathlib import Path
+from typing import List, Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from core.config import Config
+from core.decorators import handle_errors, time_operation
+from core.logger import get_logger
+from utils.helpers import format_file_size, get_file_hash, get_file_size, get_file_type
+
+# Create the utils CLI app
+app = typer.Typer(
+    name="utils",
+    help="Utility commands",
+    rich_markup_mode="rich",
+)
+
+console = Console()
+
+
+@app.command()
+def hash(
+    file_path: Path = typer.Argument(..., help="File to hash"),
+    algorithm: str = typer.Option("sha256", "--algorithm", "-a", help="Hash algorithm"),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Enable verbose output"
+    ),
+):
+    """
+    Calculate hash of a file.
+    """
+    config = Config()
+    logger = get_logger("utils-hash", verbose=verbose)
+
+    try:
+        if not file_path.exists():
+            console.print(
+                Panel(
+                    f"[red]✗[/red] File not found: {file_path}",
+                    title="Error",
+                    border_style="red",
+                )
+            )
+            raise typer.Exit(1)
+
+        hash_value = get_file_hash(file_path, algorithm)
+
+        console.print(
+            Panel(
+                f"File: {file_path}\n"
+                f"Algorithm: {algorithm.upper()}\n"
+                f"Hash: {hash_value}",
+                title="File Hash",
+                border_style="green",
+            )
+        )
+
+    except Exception as e:
+        logger.error(f"Hash calculation failed: {e}")
+        console.print(
+            Panel(
+                f"[red]✗[/red] Hash calculation failed: {str(e)}",
+                title="Error",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(1)
+
+
+@app.command()
+def info(
+    file_path: Path = typer.Argument(..., help="File to analyze"),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Enable verbose output"
+    ),
+):
+    """
+    Display detailed information about a file.
+    """
+    config = Config()
+    logger = get_logger("utils-info", verbose=verbose)
+
+    try:
+        if not file_path.exists():
+            console.print(
+                Panel(
+                    f"[red]✗[/red] File not found: {file_path}",
+                    title="Error",
+                    border_style="red",
+                )
+            )
+            raise typer.Exit(1)
+
+        # Get file information
+        file_size = get_file_size(file_path)
+        file_type = get_file_type(file_path)
+        file_hash = get_file_hash(file_path)
+
+        # Create info table
+        table = Table(title=f"File Information: {file_path.name}")
+        table.add_column("Property", style="cyan")
+        table.add_column("Value", style="magenta")
+
+        table.add_row("File Path", str(file_path))
+        table.add_row("File Name", file_path.name)
+        table.add_row("File Size", format_file_size(file_size))
+        table.add_row("File Type", file_type)
+        table.add_row("Extension", file_path.suffix)
+        table.add_row("SHA256", file_hash)
+
+        console.print(table)
+
+    except Exception as e:
+        logger.error(f"File analysis failed: {e}")
+        console.print(
+            Panel(
+                f"[red]✗[/red] File analysis failed: {str(e)}",
+                title="Error",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(1)
+
+
+@app.command()
+def find(
+    directory: Path = typer.Argument(..., help="Directory to search"),
+    pattern: str = typer.Option("*", "--pattern", "-p", help="File pattern to match"),
+    file_types: Optional[List[str]] = typer.Option(
+        None, "--type", "-t", help="File types to filter by"
+    ),
+    recursive: bool = typer.Option(
+        True, "--recursive", "-r", help="Search recursively"
+    ),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Enable verbose output"
+    ),
+):
+    """
+    Find files matching pattern in directory.
+    """
+    config = Config()
+    logger = get_logger("utils-find", verbose=verbose)
+
+    try:
+        if not directory.exists():
+            console.print(
+                Panel(
+                    f"[red]✗[/red] Directory not found: {directory}",
+                    title="Error",
+                    border_style="red",
+                )
+            )
+            raise typer.Exit(1)
+
+        from utils.helpers import find_files
+
+        files = find_files(directory, pattern, recursive, file_types)
+
+        if not files:
+            console.print(
+                Panel(
+                    f"[yellow]⚠[/yellow] No files found matching pattern: {pattern}",
+                    title="No Files",
+                    border_style="yellow",
+                )
+            )
+            return
+
+        # Create results table
+        table = Table(title=f"Found {len(files)} files")
+        table.add_column("File", style="cyan")
+        table.add_column("Size", style="magenta")
+        table.add_column("Type", style="green")
+
+        for file_path in files[:50]:  # Limit to first 50 results
+            file_size = get_file_size(file_path)
+            file_type = get_file_type(file_path)
+            table.add_row(
+                str(file_path.relative_to(directory)),
+                format_file_size(file_size),
+                file_type,
+            )
+
+        console.print(table)
+
+        if len(files) > 50:
+            console.print(f"\n... and {len(files) - 50} more files")
+
+    except Exception as e:
+        logger.error(f"File search failed: {e}")
+        console.print(
+            Panel(
+                f"[red]✗[/red] File search failed: {str(e)}",
+                title="Error",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(1)
+
+
+@app.command()
+def config(
+    show: bool = typer.Option(False, "--show", "-s", help="Show current configuration"),
+    edit: bool = typer.Option(False, "--edit", "-e", help="Edit configuration file"),
+    reset: bool = typer.Option(
+        False, "--reset", "-r", help="Reset to default configuration"
+    ),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Enable verbose output"
+    ),
+):
+    """
+    Manage configuration settings.
+    """
+    config = Config()
+    logger = get_logger("utils-config", verbose=verbose)
+
+    try:
+        if show:
+            # Show current configuration
+            table = Table(title="Current Configuration")
+            table.add_column("Setting", style="cyan")
+            table.add_column("Value", style="magenta")
+
+            table.add_row("Video Format", config.video.default_format)
+            table.add_row("Video Quality", config.video.quality)
+            table.add_row("Video Output Dir", str(config.video.output_dir))
+            table.add_row("Audio Format", config.audio.default_format)
+            table.add_row("Audio Bitrate", str(config.audio.bitrate))
+            table.add_row("Audio Output Dir", str(config.audio.output_dir))
+            table.add_row("Log Level", config.log_level)
+
+            console.print(table)
+
+        elif edit:
+            # Edit configuration file
+            config_path = config.get_default_config_path()
+            console.print(
+                Panel(
+                    f"[yellow]⚠[/yellow] Configuration editing not yet implemented.\n"
+                    f"Config file: {config_path}",
+                    title="Not Implemented",
+                    border_style="yellow",
+                )
+            )
+
+        elif reset:
+            # Reset configuration
+            config_path = config.get_default_config_path()
+            if config_path.exists():
+                config_path.unlink()
+
+            config.ensure_default_config()
+            console.print(
+                Panel(
+                    f"[green]✓[/green] Configuration reset to defaults\n"
+                    f"Config file: {config_path}",
+                    title="Reset Complete",
+                    border_style="green",
+                )
+            )
+
+    except Exception as e:
+        logger.error(f"Configuration management failed: {e}")
+        console.print(
+            Panel(
+                f"[red]✗[/red] Configuration management failed: {str(e)}",
+                title="Error",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(1)

cli/error_handlers.py

@@ -0,0 +1,122 @@
+"""
+Common error handlers for CLI commands.
+
+This module provides standardized error handling patterns
+for all CLI commands to ensure consistency.
+"""
+
+from pathlib import Path
+from typing import Any, Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+
+def handle_cli_error(
+    error: Exception, context: str = "", show_traceback: bool = False
+) -> None:
+    """
+    Standardized error handler for CLI commands.
+
+    Args:
+        error: The exception that occurred
+        context: Additional context about the operation
+        show_traceback: Whether to show full traceback
+    """
+    error_msg = str(error)
+
+    # Create standardized error message
+    if context:
+        title = f"Error in {context}"
+    else:
+        title = "Error"
+
+    # Format error message
+    if show_traceback:
+        console.print(
+            Panel(
+                f"[red]✗[/red] {error_msg}\n\nTraceback:\n{error.__traceback__}",
+                title=title,
+                border_style="red",
+            )
+        )
+    else:
+        console.print(
+            Panel(f"[red]✗[/red] {error_msg}", title=title, border_style="red")
+        )
+
+    # Exit with error code
+    raise typer.Exit(1)
+
+
+def handle_file_not_found(file_path: Path, operation: str = "access") -> None:
+    """
+    Handle file not found errors with consistent messaging.
+
+    Args:
+        file_path: The file that was not found
+        operation: The operation being performed (access, read, write, etc.)
+    """
+    handle_cli_error(
+        FileNotFoundError(f"File not found: {file_path}"), context=f"File {operation}"
+    )
+
+
+def handle_directory_not_found(dir_path: Path, operation: str = "access") -> None:
+    """
+    Handle directory not found errors with consistent messaging.
+
+    Args:
+        dir_path: The directory that was not found
+        operation: The operation being performed (access, read, write, etc.)
+    """
+    handle_cli_error(
+        FileNotFoundError(f"Directory not found: {dir_path}"),
+        context=f"Directory {operation}",
+    )
+
+
+def handle_permission_error(file_path: Path, operation: str = "access") -> None:
+    """
+    Handle permission errors with consistent messaging.
+
+    Args:
+        file_path: The file/directory with permission issues
+        operation: The operation being performed
+    """
+    handle_cli_error(
+        PermissionError(f"Permission denied: {file_path}"), context=f"File {operation}"
+    )
+
+
+def handle_validation_error(message: str, field: str = "") -> None:
+    """
+    Handle validation errors with consistent messaging.
+
+    Args:
+        message: The validation error message
+        field: The field that failed validation
+    """
+    context = f"Validation error for {field}" if field else "Validation error"
+    handle_cli_error(ValueError(message), context=context)
+
+
+def handle_not_implemented(feature: str) -> None:
+    """
+    Handle not implemented features with consistent messaging.
+
+    Args:
+        feature: The feature that is not implemented
+    """
+    console.print(
+        Panel(
+            f"[yellow]⚠[/yellow] {feature} is not yet implemented.\n"
+            f"This feature is planned for a future release.",
+            title="Not Implemented",
+            border_style="yellow",
+        )
+    )
+    raise typer.Exit(0)  # Exit with success since this is expected

cli/files.py

@@ -0,0 +1,299 @@
+"""
+File tracking demonstration and CLI commands.
+
+This module demonstrates OS-level file tracking capabilities
+and provides CLI commands for file management.
+"""
+
+import shutil
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from core.config import Config
+from core.file_tracker import FileIdentifier, FileTracker
+
+console = Console()
+app = typer.Typer(name="files", help="File tracking and management")
+
+
+@app.command()
+def track(
+    file_path: str = typer.Argument(..., help="Path to file to track"),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Enable verbose output"
+    ),
+):
+    """
+    🔍 Track a file using OS-level identifiers.
+
+    Shows the OS-level file identifier (device:inode) that persists
+    even when files are moved or renamed.
+    """
+    config = Config()
+    tracker = FileTracker(verbose=verbose)
+
+    file_path_obj = Path(file_path)
+
+    if not file_path_obj.exists():
+        console.print(
+            Panel(
+                f"[red]✗[/red] File not found: {file_path}",
+                title="Error",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(1)
+
+    # Get file identifier
+    file_id = tracker.get_file_identifier(file_path_obj)
+    metadata = tracker.get_file_metadata(file_path_obj)
+
+    if file_id:
+        console.print(
+            Panel(
+                f"[green]✓[/green] File tracked successfully!\n"
+                f"File: {metadata['name']}\n"
+                f"Path: {metadata['path']}\n"
+                f"Size: {metadata['size']:,} bytes\n"
+                f"OS Identifier: {file_id}\n"
+                f"Device: {metadata['device']}\n"
+                f"Inode: {metadata['inode']}\n"
+                f"Modified: {metadata['modified']}",
+                title="File Tracking Info",
+                border_style="green",
+            )
+        )
+    else:
+        console.print(
+            Panel(
+                f"[red]✗[/red] Failed to get file identifier",
+                title="Error",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(1)
+
+
+@app.command()
+def find(
+    file_id: str = typer.Argument(..., help="File identifier (device:inode)"),
+    search_path: Optional[str] = typer.Option(None, "--path", "-p", help="Search path"),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Enable verbose output"
+    ),
+):
+    """
+    🔍 Find a file by its OS-level identifier.
+
+    Searches for a file using its device:inode identifier,
+    useful when files have been moved.
+    """
+    config = Config()
+    tracker = FileTracker(verbose=verbose)
+
+    try:
+        device, inode = file_id.split(":")
+        file_id_obj = FileIdentifier(device=int(device), inode=int(inode))
+    except ValueError:
+        console.print(
+            Panel(
+                f"[red]✗[/red] Invalid file identifier format. Use 'device:inode' (e.g., '16777234:19668159')",
+                title="Error",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(1)
+
+    # Set search paths
+    if search_path:
+        search_paths = [Path(search_path)]
+    else:
+        # Default search paths
+        search_paths = [
+            Path.home(),
+            Path("/tmp"),
+            Path("/var/tmp"),
+        ]
+
+    # Find the file
+    found_path = tracker.find_file_by_identifier(file_id_obj, search_paths)
+
+    if found_path:
+        metadata = tracker.get_file_metadata(found_path)
+        console.print(
+            Panel(
+                f"[green]✓[/green] File found!\n"
+                f"File: {metadata['name']}\n"
+                f"Path: {metadata['path']}\n"
+                f"Size: {metadata['size']:,} bytes\n"
+                f"Modified: {metadata['modified']}",
+                title="File Found",
+                border_style="green",
+            )
+        )
+    else:
+        console.print(
+            Panel(
+                f"[red]✗[/red] File with identifier {file_id} was not found in search paths",
+                title="File Not Found",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(1)
+
+
+@app.command()
+def duplicates(
+    search_path: str = typer.Argument(..., help="Path to search for duplicates"),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Enable verbose output"
+    ),
+):
+    """
+    🔍 Find duplicate files based on OS-level identifiers.
+
+    Identifies files that have the same device:inode identifier,
+    which means they are hard links to the same file.
+    """
+    config = Config()
+    tracker = FileTracker(verbose=verbose)
+
+    search_path_obj = Path(search_path)
+
+    if not search_path_obj.exists():
+        console.print(
+            Panel(
+                f"[red]✗[/red] Search path not found: {search_path}",
+                title="Error",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(1)
+
+    # Find duplicates
+    duplicates = tracker.find_duplicate_files([search_path_obj])
+
+    if duplicates:
+        table = Table(title="Duplicate Files Found")
+        table.add_column("File Identifier", style="cyan")
+        table.add_column("Count", style="magenta")
+        table.add_column("Paths", style="white")
+
+        for file_id, paths in duplicates.items():
+            table.add_row(file_id, str(len(paths)), "\n".join(str(p) for p in paths))
+
+        console.print(table)
+
+        console.print(
+            Panel(
+                f"Found {len(duplicates)} sets of duplicate files\n"
+                f"Total duplicate files: {sum(len(paths) for paths in duplicates.values())}",
+                title="Duplicate Summary",
+                border_style="yellow",
+            )
+        )
+    else:
+        console.print(
+            Panel(
+                "[green]✓[/green] No duplicate files found",
+                title="No Duplicates",
+                border_style="green",
+            )
+        )
+
+
+@app.command()
+def demo(
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Enable verbose output"
+    ),
+):
+    """
+    🎯 Demonstrate file tracking capabilities.
+
+    Creates test files and demonstrates how OS-level identifiers
+    persist through moves but change with copies.
+    """
+    config = Config()
+    tracker = FileTracker(verbose=verbose)
+
+    console.print(
+        Panel(
+            "[blue]Creating demonstration files...[/blue]",
+            title="File Tracking Demo",
+            border_style="blue",
+        )
+    )
+
+    # Create test files
+    test_dir = Path("file_tracking_demo")
+    test_dir.mkdir(exist_ok=True)
+
+    original_file = test_dir / "original.txt"
+    original_file.write_text("This is the original file content.")
+
+    # Get original identifier
+    original_id = tracker.get_file_identifier(original_file)
+    original_metadata = tracker.get_file_metadata(original_file)
+
+    console.print(f"[green]Original file created:[/green] {original_file}")
+    console.print(f"[green]Original identifier:[/green] {original_id}")
+
+    # Copy the file (creates new inode)
+    copied_file = test_dir / "copied.txt"
+    import shutil
+
+    shutil.copy2(original_file, copied_file)
+    copied_id = tracker.get_file_identifier(copied_file)
+
+    console.print(f"[yellow]Copied file created:[/yellow] {copied_file}")
+    console.print(f"[yellow]Copied identifier:[/yellow] {copied_id}")
+    console.print(f"[yellow]Same identifier?[/yellow] {original_id == copied_id}")
+
+    # Move the original file (preserves inode)
+    moved_file = test_dir / "moved.txt"
+    shutil.move(str(original_file), str(moved_file))
+    moved_id = tracker.get_file_identifier(moved_file)
+
+    console.print(f"[blue]Moved file:[/blue] {moved_file}")
+    console.print(f"[blue]Moved identifier:[/blue] {moved_id}")
+    console.print(f"[blue]Same as original?[/blue] {original_id == moved_id}")
+
+    # Create summary table
+    table = Table(title="File Tracking Demonstration Results")
+    table.add_column("Operation", style="cyan")
+    table.add_column("File", style="green")
+    table.add_column("Identifier", style="magenta")
+    table.add_column("Same as Original?", style="yellow")
+
+    table.add_row("Original", str(original_file), str(original_id), "N/A")
+    table.add_row(
+        "Copy", str(copied_file), str(copied_id), str(original_id == copied_id)
+    )
+    table.add_row("Move", str(moved_file), str(moved_id), str(original_id == moved_id))
+
+    console.print(table)
+
+    # Cleanup
+    console.print(f"[red]Cleaning up demo files...[/red]")
+    import shutil
+
+    shutil.rmtree(test_dir)
+
+    console.print(
+        Panel(
+            "[green]✓[/green] Demonstration completed!\n\n"
+            "[bold]Key Insights:[/bold]\n"
+            "• Moving files preserves the OS identifier\n"
+            "• Copying files creates a new identifier\n"
+            "• This allows tracking files even when moved\n"
+            "• Database can store device:inode for persistent tracking",
+            title="Demo Complete",
+            border_style="green",
+        )
+    )