check_file_list.py

#!/usr/bin/env python3
"""
File List Checker Script
Checks which files from a list exist in a directory
"""

import os
import sys
import argparse
from pathlib import Path

class FileListChecker:
    def __init__(self, search_path, ignore_comments=True):
        """
        Initialize file list checker
        
        Args:
            search_path: Path to search for files
            ignore_comments: Whether to ignore lines starting with #
        """
        self.search_path = Path(search_path).resolve()
        self.ignore_comments = ignore_comments
        self.stats = {
            'total': 0,
            'found': 0,
            'missing': 0,
            'comments': 0,
            'empty': 0
        }
        
    def read_file_list(self, list_file):
        """Read and parse the file list"""
        files = []
        
        try:
            with open(list_file, 'r', encoding='utf-8') as f:
                for line_num, line in enumerate(f, 1):
                    line = line.strip()
                    
                    if not line:  # Empty line
                        self.stats['empty'] += 1
                        continue
                        
                    if self.ignore_comments and line.startswith('#'):
                        self.stats['comments'] += 1
                        continue
                        
                    # Remove any trailing comments
                    if '#' in line:
                        line = line.split('#')[0].strip()
                        
                    if line:
                        files.append(line)
                        self.stats['total'] += 1
                        
        except Exception as e:
            print(f"Error reading {list_file}: {e}", file=sys.stderr)
            sys.exit(1)
            
        return files
        
    def check_file(self, filepath):
        """Check if a file exists"""
        # Handle different path formats
        full_path = self.search_path / filepath.lstrip('/')
        
        # Try without leading / if it didn't work
        if not full_path.exists() and filepath.startswith('/'):
            full_path = self.search_path / filepath[1:]
            
        return full_path.exists()
        
    def check_files(self, list_file):
        """Check all files from the list"""
        files = self.read_file_list(list_file)
        
        print(f"\n📂 Searching in: {self.search_path}")
        print(f"📋 File list: {list_file}")
        print(f"📊 Total files to check: {len(files)}")
        print("-" * 60)
        
        found_files = []
        missing_files = []
        
        for i, filepath in enumerate(files, 1):
            exists = self.check_file(filepath)
            
            if exists:
                self.stats['found'] += 1
                found_files.append(filepath)
                status = "✅ FOUND"
            else:
                self.stats['missing'] += 1
                missing_files.append(filepath)
                status = "❌ MISSING"
                
            # Show progress every 10 files or for all if less than 100
            if len(files) <= 100 or i % 10 == 0 or i == len(files):
                print(f"[{i}/{len(files)}] {status}: {filepath[:60]}{'...' if len(filepath) > 60 else ''}")
                
        return found_files, missing_files
        
    def print_summary(self):
        """Print summary statistics"""
        print("\n" + "="*60)
        print("SUMMARY")
        print("="*60)
        print(f"📊 Statistics:")
        print(f"  • Total entries in file: {self.stats['total']}")
        print(f"  • Comments ignored: {self.stats['comments']}")
        print(f"  • Empty lines ignored: {self.stats['empty']}")
        print()
        print(f"✅ Files found: {self.stats['found']}")
        print(f"❌ Files missing: {self.stats['missing']}")
        print(f"📈 Success rate: {self.stats['found']/self.stats['total']*100:.1f}%" if self.stats['total'] > 0 else "N/A")
        print("="*60)
        
    def save_results(self, found_file, missing_file):
        """Save results to files"""
        if found_file:
            with open(found_file, 'w', encoding='utf-8') as f:
                for filepath in self.found_files:
                    f.write(f"{filepath}\n")
            print(f"✅ Found files saved to: {found_file}")
            
        if missing_file:
            with open(missing_file, 'w', encoding='utf-8') as f:
                for filepath in self.missing_files:
                    f.write(f"{filepath}\n")
            print(f"📝 Missing files saved to: {missing_file}")
            
    def verify_paths(self, list_file):
        """Verify that paths in list file are accessible"""
        files = self.read_file_list(list_file)
        invalid_paths = []
        
        for filepath in files:
            # Check if path has invalid characters or is empty
            if not filepath or '..' in filepath or '//' in filepath:
                invalid_paths.append(filepath)
                
        if invalid_paths:
            print("\n⚠️  Warning: Found potentially invalid paths:")
            for path in invalid_paths[:10]:
                print(f"  • {path}")
            if len(invalid_paths) > 10:
                print(f"  ... and {len(invalid_paths) - 10} more")
                
    def interactive_check(self, list_file):
        """Interactive mode with options"""
        self.found_files, self.missing_files = self.check_files(list_file)
        self.print_summary()
        
        while True:
            print("\nOptions:")
            print("  1. Show all found files")
            print("  2. Show all missing files")
            print("  3. Save results to files")
            print("  4. Search for missing files (case-insensitive)")
            print("  5. Exit")
            
            choice = input("\nSelect option (1-5): ").strip()
            
            if choice == '1':
                print("\n✅ FOUND FILES:")
                for i, filepath in enumerate(self.found_files, 1):
                    print(f"  {i}. {filepath}")
                    
            elif choice == '2':
                print("\n❌ MISSING FILES:")
                for i, filepath in enumerate(self.missing_files, 1):
                    print(f"  {i}. {filepath}")
                    
            elif choice == '3':
                found_out = input("Save found files to (or press Enter to skip): ").strip()
                missing_out = input("Save missing files to (or press Enter to skip): ").strip()
                self.save_results(found_out if found_out else None, 
                                 missing_out if missing_out else None)
                                 
            elif choice == '4':
                search_term = input("Enter search term: ").strip().lower()
                print(f"\n🔍 Searching for '{search_term}'...")
                found = []
                for filepath in self.missing_files:
                    if search_term in filepath.lower():
                        found.append(filepath)
                        
                if found:
                    print(f"Found {len(found)} missing files matching '{search_term}':")
                    for filepath in found:
                        # Try to find actual location
                        filename = Path(filepath).name
                        matches = list(self.search_path.rglob(f"*{filename}*"))
                        if matches:
                            print(f"  • {filepath}")
                            print(f"    → Found at: {matches[0]}")
                        else:
                            print(f"  • {filepath} (no matches found)")
                else:
                    print(f"No missing files match '{search_term}'")
                    
            elif choice == '5':
                break


def main():
    parser = argparse.ArgumentParser(
        description="Check which files from a list exist in a directory",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  %(prog)s proprietary-files.txt /path/to/vendor          # Check files in vendor
  %(prog)s -l filelist.txt /path/to/system                # Check in system
  %(prog)s --no-ignore filelist.txt /path                 # Don't ignore comments
  %(prog)s -i filelist.txt /path                          # Interactive mode
  %(prog)s -o found.txt -m missing.txt list.txt /path     # Save results
        """
    )
    
    parser.add_argument(
        'list_file',
        help='File containing list of paths to check'
    )
    
    parser.add_argument(
        'search_path',
        help='Directory to search for files'
    )
    
    parser.add_argument(
        '--no-ignore',
        action='store_true',
        help='Do not ignore lines starting with #'
    )
    
    parser.add_argument(
        '-o', '--output-found',
        metavar='FILE',
        help='Save found files to FILE'
    )
    
    parser.add_argument(
        '-m', '--output-missing',
        metavar='FILE',
        help='Save missing files to FILE'
    )
    
    parser.add_argument(
        '-i', '--interactive',
        action='store_true',
        help='Interactive mode with additional options'
    )
    
    parser.add_argument(
        '-v', '--verbose',
        action='store_true',
        help='Show detailed output for all files'
    )
    
    parser.add_argument(
        '--verify',
        action='store_true',
        help='Verify paths for potential issues'
    )
    
    args = parser.parse_args()
    
    # Create checker
    checker = FileListChecker(
        search_path=args.search_path,
        ignore_comments=not args.no_ignore
    )
    
    # Verify paths if requested
    if args.verify:
        checker.verify_paths(args.list_file)
        
    # Run in interactive mode or normal mode
    if args.interactive:
        checker.interactive_check(args.list_file)
    else:
        found, missing = checker.check_files(args.list_file)
        checker.print_summary()
        
        # Save results if requested
        if args.output_found or args.output_missing:
            checker.found_files = found
            checker.missing_files = missing
            checker.save_results(args.output_found, args.output_missing)
            
        # Show all if verbose
        if args.verbose:
            if found:
                print("\n✅ Found files:")
                for f in found:
                    print(f"  {f}")
            if missing:
                print("\n❌ Missing files:")
                for m in missing:
                    print(f"  {m}")
                    
    return 0


if __name__ == "__main__":
    try:
        sys.exit(main())
    except KeyboardInterrupt:
        print("\n\n⚠️  Interrupted by user")
        sys.exit(1)
    except Exception as e:
        print(f"\n❌ Error: {e}", file=sys.stderr)
        sys.exit(1)