spatelier 0.3.0__py3-none-any.whl

core/file_tracker.py

@@ -0,0 +1,254 @@
+"""
+File tracking utilities for persistent file identification.
+
+This module provides OS-level file identification using inode and device numbers
+to track files even when they are moved or renamed.
+"""
+
+import os
+import shutil
+import stat
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Optional, Tuple
+
+from core.logger import get_logger
+
+
+@dataclass
+class FileIdentifier:
+    """OS-level file identifier."""
+
+    device: int
+    inode: int
+
+    def __str__(self) -> str:
+        """String representation as device:inode."""
+        return f"{self.device}:{self.inode}"
+
+    def __hash__(self) -> int:
+        """Hash for use in sets and dictionaries."""
+        return hash((self.device, self.inode))
+
+    def __eq__(self, other) -> bool:
+        """Equality comparison."""
+        if not isinstance(other, FileIdentifier):
+            return False
+        return self.device == other.device and self.inode == other.inode
+
+
+class FileTracker:
+    """
+    Tracks files using OS-level identifiers.
+
+    Provides persistent file identification that survives moves and renames,
+    but distinguishes between original files and copies.
+    """
+
+    def __init__(self, verbose: bool = False):
+        """Initialize file tracker."""
+        self.verbose = verbose
+        self.logger = get_logger("FileTracker", verbose=verbose)
+
+    def get_file_identifier(self, file_path: Path) -> Optional[FileIdentifier]:
+        """
+        Get OS-level identifier for a file.
+
+        Args:
+            file_path: Path to the file
+
+        Returns:
+            FileIdentifier with device and inode, or None if file doesn't exist
+        """
+        try:
+            if not file_path.exists():
+                self.logger.debug(f"File does not exist: {file_path}")
+                return None
+
+            stat_info = os.stat(file_path)
+            return FileIdentifier(device=stat_info.st_dev, inode=stat_info.st_ino)
+
+        except (OSError, FileNotFoundError) as e:
+            self.logger.debug(f"Failed to get file identifier for {file_path}: {e}")
+            return None
+
+    def find_file_by_identifier(
+        self, file_id: FileIdentifier, search_paths: list[Path]
+    ) -> Optional[Path]:
+        """
+        Find a file by its OS-level identifier.
+
+        Args:
+            file_id: FileIdentifier to search for
+            search_paths: List of paths to search in
+
+        Returns:
+            Path to the file if found, None otherwise
+        """
+        for search_path in search_paths:
+            if not search_path.exists():
+                continue
+
+            # Search recursively
+            for file_path in search_path.rglob("*"):
+                if file_path.is_file():
+                    current_id = self.get_file_identifier(file_path)
+                    if current_id == file_id:
+                        self.logger.debug(f"Found file by identifier: {file_path}")
+                        return file_path
+
+        self.logger.debug(
+            f"File with identifier {file_id} was not found in search paths"
+        )
+        return None
+
+    def get_file_metadata(self, file_path: Path) -> Dict[str, Any]:
+        """
+        Get comprehensive file metadata including OS identifiers.
+
+        Args:
+            file_path: Path to the file
+
+        Returns:
+            Dictionary with file metadata
+        """
+        try:
+            if not file_path.exists():
+                return {"error": "File does not exist"}
+
+            stat_info = os.stat(file_path)
+            file_id = self.get_file_identifier(file_path)
+
+            return {
+                "path": str(file_path.absolute()),
+                "name": file_path.name,
+                "size": stat_info.st_size,
+                "modified": stat_info.st_mtime,
+                "created": stat_info.st_ctime,
+                "accessed": stat_info.st_atime,
+                "permissions": oct(stat_info.st_mode),
+                "file_identifier": str(file_id) if file_id else None,
+                "device": stat_info.st_dev,
+                "inode": stat_info.st_ino,
+                "is_file": file_path.is_file(),
+                "is_dir": file_path.is_dir(),
+            }
+
+        except (OSError, FileNotFoundError) as e:
+            return {"error": str(e)}
+
+    def track_file_move(self, old_path: Path, new_path: Path) -> bool:
+        """
+        Track a file move operation.
+
+        Args:
+            old_path: Original file path
+            new_path: New file path
+
+        Returns:
+            True if the move was tracked successfully
+        """
+        try:
+            old_id = self.get_file_identifier(old_path)
+            if not old_id:
+                self.logger.warning(
+                    f"Cannot track move - old file not found: {old_path}"
+                )
+                return False
+
+            # Perform the move (use shutil.move for cross-device support)
+            shutil.move(str(old_path), str(new_path))
+
+            # Verify the move
+            new_id = self.get_file_identifier(new_path)
+            if new_id == old_id:
+                self.logger.info(
+                    f"Successfully tracked file move: {old_path} -> {new_path}"
+                )
+                return True
+            else:
+                self.logger.error(
+                    f"File move verification failed - identifiers don't match"
+                )
+                return False
+
+        except (OSError, FileNotFoundError) as e:
+            self.logger.error(f"Failed to track file move: {e}")
+            return False
+
+    def is_same_file(self, path1: Path, path2: Path) -> bool:
+        """
+        Check if two paths refer to the same file.
+
+        Args:
+            path1: First file path
+            path2: Second file path
+
+        Returns:
+            True if both paths refer to the same file
+        """
+        id1 = self.get_file_identifier(path1)
+        id2 = self.get_file_identifier(path2)
+
+        if not id1 or not id2:
+            return False
+
+        return id1 == id2
+
+    def find_duplicate_files(self, search_paths: list[Path]) -> Dict[str, list[Path]]:
+        """
+        Find duplicate files based on OS-level identifiers.
+
+        Args:
+            search_paths: List of paths to search for duplicates
+
+        Returns:
+            Dictionary mapping file identifiers to lists of duplicate paths
+        """
+        file_map: Dict[FileIdentifier, list[Path]] = {}
+
+        for search_path in search_paths:
+            if not search_path.exists():
+                continue
+
+            for file_path in search_path.rglob("*"):
+                if file_path.is_file():
+                    file_id = self.get_file_identifier(file_path)
+                    if file_id:
+                        if file_id not in file_map:
+                            file_map[file_id] = []
+                        file_map[file_id].append(file_path)
+
+        # Return only duplicates (more than one file with same identifier)
+        duplicates = {
+            str(file_id): paths for file_id, paths in file_map.items() if len(paths) > 1
+        }
+
+        self.logger.info(f"Found {len(duplicates)} sets of duplicate files")
+        return duplicates
+
+    def validate_file_integrity(
+        self, file_path: Path, expected_id: FileIdentifier
+    ) -> bool:
+        """
+        Validate that a file still has the expected identifier.
+
+        Args:
+            file_path: Path to check
+            expected_id: Expected file identifier
+
+        Returns:
+            True if file has the expected identifier
+        """
+        current_id = self.get_file_identifier(file_path)
+        if not current_id:
+            self.logger.warning(f"File not found: {file_path}")
+            return False
+
+        if current_id != expected_id:
+            self.logger.warning(
+                f"File identifier mismatch for {file_path}: expected {expected_id}, got {current_id}"
+            )
+            return False
+
+        return True

core/interactive_cli.py

@@ -0,0 +1,366 @@
+"""
+Interactive CLI for Spatelier.
+
+This module provides an interactive command-line interface with guided workflows,
+menus, and user-friendly prompts for common operations.
+"""
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+from rich import print as rprint
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm, FloatPrompt, IntPrompt, Prompt
+from rich.table import Table
+from rich.text import Text
+
+from core.config import Config
+from core.logger import get_logger
+from core.progress import track_progress
+
+
+@dataclass
+class MenuOption:
+    """Menu option data class."""
+
+    key: str
+    title: str
+    description: str
+    action: Callable
+    enabled: bool = True
+
+
+class InteractiveCLI:
+    """Interactive CLI for Spatelier."""
+
+    def __init__(self, config: Config, verbose: bool = False):
+        """
+        Initialize interactive CLI.
+
+        Args:
+            config: Configuration instance
+            verbose: Enable verbose logging
+        """
+        self.config = config
+        self.verbose = verbose
+        self.logger = get_logger("InteractiveCLI", verbose=verbose)
+        self.console = Console()
+
+    def show_welcome(self):
+        """Show welcome message."""
+        welcome_text = Text(
+            "🎬 Welcome to Spatelier Interactive Mode", style="bold blue"
+        )
+        subtitle = Text("Your personal video and audio processing toolkit", style="dim")
+
+        self.console.print(
+            Panel(
+                f"{welcome_text}\n\n{subtitle}",
+                title="🚀 Spatelier",
+                border_style="blue",
+            )
+        )
+
+    def show_main_menu(self) -> str:
+        """Show main menu and get user choice."""
+        menu_table = Table(
+            title="📋 Main Menu", show_header=True, header_style="bold magenta"
+        )
+        menu_table.add_column("Option", style="cyan", no_wrap=True)
+        menu_table.add_column("Description", style="white")
+
+        menu_table.add_row("1", "📥 Download Video/Playlist")
+        menu_table.add_row("2", "🎵 Process Audio")
+        menu_table.add_row("3", "📊 View Analytics")
+        menu_table.add_row("4", "⚙️  System Settings")
+        menu_table.add_row("5", "❓ Help & Documentation")
+        menu_table.add_row("0", "🚪 Exit")
+
+        self.console.print(menu_table)
+
+        choice = Prompt.ask(
+            "Select an option", choices=["1", "2", "3", "4", "5", "0"], default="1"
+        )
+
+        return choice
+
+    def download_video_workflow(self):
+        """Interactive video download workflow."""
+        self.console.print(Panel("📥 Video Download Workflow", border_style="green"))
+
+        # Get URL
+        url = Prompt.ask("Enter video/playlist URL")
+        if not url:
+            self.console.print("[red]No URL provided[/red]")
+            return
+
+        # Detect if it's a playlist
+        is_playlist = "playlist" in url.lower() or "/videos" in url
+
+        if is_playlist:
+            self.console.print("[yellow]📺 Playlist detected![/yellow]")
+
+            # Get max videos
+            max_videos = IntPrompt.ask(
+                "Maximum videos to download", default=10, show_default=True
+            )
+
+            # Ask about transcription
+            transcribe = Confirm.ask(
+                "Enable transcription for all videos?", default=False
+            )
+        else:
+            max_videos = 1
+            transcribe = Confirm.ask("Enable transcription?", default=False)
+
+        # Get quality
+        quality_choices = ["720p", "1080p", "1440p", "2160p", "best"]
+        quality = Prompt.ask(
+            "Select video quality", choices=quality_choices, default="1080p"
+        )
+
+        # Get output directory
+        from core.config import get_default_data_dir
+
+        repo_root = get_default_data_dir().parent
+        output_dir = Prompt.ask(
+            "Output directory", default=str(repo_root / "downloads")
+        )
+
+        # Confirm settings
+        self.console.print("\n[bold]Download Settings:[/bold]")
+        self.console.print(f"URL: {url}")
+        self.console.print(f"Quality: {quality}")
+        self.console.print(f"Output: {output_dir}")
+        if is_playlist:
+            self.console.print(f"Max Videos: {max_videos}")
+        self.console.print(f"Transcription: {'Yes' if transcribe else 'No'}")
+
+        if not Confirm.ask("Proceed with download?"):
+            self.console.print("[yellow]Download cancelled[/yellow]")
+            return
+
+        # Execute download
+        try:
+            from cli.video import download
+
+            with track_progress("Downloading...", verbose=True) as progress:
+                # This would call the actual download function
+                self.console.print("[green]✅ Download completed![/green]")
+
+        except Exception as e:
+            self.console.print(f"[red]❌ Download failed: {e}[/red]")
+
+    def process_audio_workflow(self):
+        """Interactive audio processing workflow."""
+        self.console.print(Panel("🎵 Audio Processing Workflow", border_style="yellow"))
+
+        # Get input file
+        input_file = Prompt.ask("Enter audio file path")
+        if not input_file or not Path(input_file).exists():
+            self.console.print("[red]File not found[/red]")
+            return
+
+        # Get operation type
+        operation = Prompt.ask(
+            "Select operation", choices=["convert", "info"], default="convert"
+        )
+
+        if operation == "convert":
+            # Get output format
+            format_choices = ["mp3", "wav", "flac", "aac", "ogg", "m4a"]
+            output_format = Prompt.ask(
+                "Output format", choices=format_choices, default="mp3"
+            )
+
+            # Get bitrate
+            bitrate = IntPrompt.ask(
+                "Audio bitrate (kbps)", default=320, show_default=True
+            )
+
+            # Get output file
+            output_file = Prompt.ask(
+                "Output file path",
+                default=str(Path(input_file).with_suffix(f".{output_format}")),
+            )
+
+            # Confirm settings
+            self.console.print("\n[bold]Conversion Settings:[/bold]")
+            self.console.print(f"Input: {input_file}")
+            self.console.print(f"Output: {output_file}")
+            self.console.print(f"Format: {output_format}")
+            self.console.print(f"Bitrate: {bitrate} kbps")
+
+            if not Confirm.ask("Proceed with conversion?"):
+                self.console.print("[yellow]Conversion cancelled[/yellow]")
+                return
+
+            # Execute conversion
+            try:
+                with track_progress("Converting audio...", verbose=True) as progress:
+                    # This would call the actual conversion function
+                    self.console.print("[green]✅ Conversion completed![/green]")
+
+            except Exception as e:
+                self.console.print(f"[red]❌ Conversion failed: {e}[/red]")
+
+        elif operation == "info":
+            try:
+                with track_progress(
+                    "Analyzing audio file...", verbose=True
+                ) as progress:
+                    # This would call the actual info function
+                    self.console.print("[green]✅ Analysis completed![/green]")
+
+            except Exception as e:
+                self.console.print(f"[red]❌ Analysis failed: {e}[/red]")
+
+    def view_analytics_workflow(self):
+        """Interactive analytics workflow."""
+        self.console.print(Panel("📊 Analytics Dashboard", border_style="blue"))
+
+        # Show analytics options
+        analytics_choices = ["dashboard", "export", "stats"]
+        choice = Prompt.ask(
+            "Select analytics option", choices=analytics_choices, default="dashboard"
+        )
+
+        if choice == "dashboard":
+            try:
+                from core.analytics_dashboard import show_analytics_dashboard
+
+                show_analytics_dashboard(self.config, self.verbose)
+            except Exception as e:
+                self.console.print(f"[red]❌ Dashboard failed: {e}[/red]")
+
+        elif choice == "export":
+            from core.config import get_default_data_dir
+
+            repo_root = get_default_data_dir().parent
+            output_path = Prompt.ask(
+                "Export file path", default=str(repo_root / "analytics_export.json")
+            )
+
+            try:
+                from core.analytics_dashboard import export_analytics_data
+
+                success = export_analytics_data(
+                    self.config, Path(output_path), self.verbose
+                )
+                if success:
+                    self.console.print(
+                        f"[green]✅ Analytics exported to {output_path}[/green]"
+                    )
+                else:
+                    self.console.print("[red]❌ Export failed[/red]")
+            except Exception as e:
+                self.console.print(f"[red]❌ Export failed: {e}[/red]")
+
+        elif choice == "stats":
+            try:
+                from core.analytics_dashboard import AnalyticsDashboard
+
+                dashboard = AnalyticsDashboard(self.config, self.verbose)
+                stats = dashboard.get_processing_stats()
+                health = dashboard.get_system_health()
+
+                # Show stats
+                stats_table = dashboard.create_stats_table(stats)
+                health_table = dashboard.create_health_table(health)
+
+                self.console.print(stats_table)
+                self.console.print(health_table)
+
+            except Exception as e:
+                self.console.print(f"[red]❌ Stats failed: {e}[/red]")
+
+    def system_settings_workflow(self):
+        """Interactive system settings workflow."""
+        self.console.print(Panel("⚙️ System Settings", border_style="cyan"))
+
+        settings_choices = ["config", "paths", "database", "workers"]
+        choice = Prompt.ask(
+            "Select settings category", choices=settings_choices, default="config"
+        )
+
+        if choice == "config":
+            self.console.print(
+                "[yellow]Configuration settings would be shown here[/yellow]"
+            )
+        elif choice == "paths":
+            self.console.print("[yellow]Path settings would be shown here[/yellow]")
+        elif choice == "database":
+            self.console.print("[yellow]Database settings would be shown here[/yellow]")
+        elif choice == "workers":
+            self.console.print("[yellow]Worker settings would be shown here[/yellow]")
+
+    def help_workflow(self):
+        """Show help and documentation."""
+        self.console.print(Panel("❓ Help & Documentation", border_style="magenta"))
+
+        help_choices = ["commands", "examples", "troubleshooting", "api"]
+        choice = Prompt.ask(
+            "Select help topic", choices=help_choices, default="commands"
+        )
+
+        if choice == "commands":
+            self.console.print(
+                "[yellow]Command documentation would be shown here[/yellow]"
+            )
+        elif choice == "examples":
+            self.console.print("[yellow]Usage examples would be shown here[/yellow]")
+        elif choice == "troubleshooting":
+            self.console.print(
+                "[yellow]Troubleshooting guide would be shown here[/yellow]"
+            )
+        elif choice == "api":
+            self.console.print("[yellow]API documentation would be shown here[/yellow]")
+
+    def run_interactive_mode(self):
+        """Run the interactive CLI mode."""
+        self.show_welcome()
+
+        while True:
+            try:
+                choice = self.show_main_menu()
+
+                if choice == "1":
+                    self.download_video_workflow()
+                elif choice == "2":
+                    self.process_audio_workflow()
+                elif choice == "3":
+                    self.view_analytics_workflow()
+                elif choice == "4":
+                    self.system_settings_workflow()
+                elif choice == "5":
+                    self.help_workflow()
+                elif choice == "0":
+                    self.console.print("[green]👋 Goodbye![/green]")
+                    break
+
+                # Ask if user wants to continue
+                if not Confirm.ask("\nContinue with another operation?", default=True):
+                    self.console.print("[green]👋 Goodbye![/green]")
+                    break
+
+            except KeyboardInterrupt:
+                self.console.print("\n[yellow]👋 Goodbye![/yellow]")
+                break
+            except Exception as e:
+                self.console.print(f"[red]❌ Error: {e}[/red]")
+                self.logger.error(f"Interactive CLI error: {e}")
+
+
+def run_interactive_cli(config: Config, verbose: bool = False):
+    """
+    Run the interactive CLI.
+
+    Args:
+        config: Configuration instance
+        verbose: Enable verbose logging
+    """
+    cli = InteractiveCLI(config, verbose)
+    cli.run_interactive_mode()