scripts/process_rvq_full.py

"""
Process full RVQ (Quick Remote Viewing) dataset and export to Parquet.

Processes all RVQ files and exports cleaned data.
"""

import sys
import argparse
from pathlib import Path
from datetime import datetime

sys.path.insert(0, str(Path(__file__).parent.parent))

from src.core.config import Config
from src.core.output_lock import seal_output, unlock_for_write
from src.processors.rvq_processor import RVQProcessor


def main():
    parser = argparse.ArgumentParser(description='Process RVQ dataset')
    parser.add_argument('--audit', action='store_true',
                       help='Include source_file and source_row_number columns in output')
    parser.add_argument('--data-dir',
                       help='Override raw data directory (default: data/)')
    args = parser.parse_args()

    print("="*70)
    print("RVQ (Quick Remote Viewing) Full Dataset Processing")
    print("="*70)
    print()

    start_time = datetime.now()

    # Load config
    config = Config('config/cleaning_config.yaml')

    # Override audit mode if --audit flag is provided
    if args.audit:
        config.set('processing.audit_mode', True)
        print("Audit mode: ENABLED (including source_file and source_row_number columns)")
        print()

    # Override data directory if --data-dir flag is provided
    if args.data_dir:
        config.set('directories.raw_data', args.data_dir)


    # Create output directory
    output_dir = config.output_dir / 'parquet'
    output_dir.mkdir(parents=True, exist_ok=True)

    output_file = output_dir / 'rvq_cleaned.parquet'

    print(f"Output file: {output_file}")
    print()

    # Create processor
    processor = RVQProcessor(config)

    # Get file count
    try:
        all_files = processor.get_file_list()
        print(f"Total files to process: {len(all_files)}")
        print()
    except Exception as e:
        print(f"✗ Error getting file list: {e}")
        print()
        print("Expected directory: data/rvq_release/rvq_data/")
        print("Make sure the raw data is in the correct location.")
        sys.exit(1)

    # Process all files
    print("Processing all RVQ files...")
    print("This may take some time depending on dataset size...")
    print()

    try:
        df = processor.process()

        elapsed = datetime.now() - start_time

        print()
        print("="*70)
        print("✓ Processing Complete!")
        print("="*70)
        print()

        # Show stats
        stats = processor.get_stats()
        print("Processing Statistics:")
        print(f"  Files processed: {stats['files_processed']:,}")
        print(f"  Files failed: {stats['files_failed']:,}")
        print(f"  Success rate: {stats['files_processed'] / len(all_files) * 100:.1f}%")
        print()
        print(f"  Total rows: {len(df):,}")
        print(f"  Valid rows: {stats['rows_valid']:,}")
        print()

        # Data quality metrics
        print("Data Quality:")
        completeness = df.notna().sum() / len(df)
        print(f"  Completeness (avg): {completeness.mean():.1%}")
        print(f"  Missing timestamps: {df['timestamp'].isna().sum():,} ({df['timestamp'].isna().sum() / len(df) * 100:.1f}%)")
        print()

        # Date range
        if 'timestamp' in df.columns:
            valid_ts = df['timestamp'].dropna()
            if not valid_ts.empty:
                print(f"Date range: {valid_ts.min()} to {valid_ts.max()}")
                print(f"Span: {(valid_ts.max() - valid_ts.min()).days} days")
                print()

        # User statistics
        print("User Statistics:")
        n_users = df['user_id'].nunique()
        print(f"  Unique users: {n_users:,}")
        if n_users > 0:
            print(f"  Trials per user (mean): {len(df) / n_users:.0f}")
        print()

        # Target/Response distribution
        if 'target' in df.columns and 'response' in df.columns:
            print("Target/Response Distribution:")
            print(f"  Target distribution:")
            for i in range(1, 6):
                count = (df['target'] == i).sum()
                pct = count / len(df) * 100
                print(f"    Image {i}: {count:,} ({pct:.1f}%)")
            print()
            print(f"  Response distribution:")
            for i in range(1, 6):
                count = (df['response'] == i).sum()
                pct = count / len(df) * 100
                print(f"    Image {i}: {count:,} ({pct:.1f}%)")
            print()

        # Hit rate
        if 'is_hit' in df.columns:
            total_hits = df['is_hit'].sum()
            hit_rate = total_hits / len(df) * 100
            print(f"Overall hit rate: {total_hits:,} / {len(df):,} = {hit_rate:.2f}%")
            print(f"Expected chance rate: 20.0%")
            print()

        # Performance stats
        print(f"Processing time: {elapsed}")
        print(f"Speed: {len(df) / elapsed.total_seconds():.0f} rows/second")
        print()

        # Export to Parquet
        print("Exporting to Parquet...")
        unlock_for_write(output_file)
        df.to_parquet(
            output_file,
            engine='pyarrow',
            compression='snappy',
            index=False
        )
        seal_output(output_file)

        file_size_mb = output_file.stat().st_size / (1024 * 1024)
        print(f"✓ Exported to: {output_file}")
        print(f"  File size: {file_size_mb:.1f} MB")
        print()

        # Compression ratio
        raw_size_estimate = len(df) * 200  # Rough estimate of ~200 bytes/row in CSV
        compression_ratio = raw_size_estimate / output_file.stat().st_size
        print(f"  Compression ratio: {compression_ratio:.1f}x")
        print()

        # Show errata summary
        errata_summary = processor.errata_logger.get_summary()
        print("Error Summary:")
        print(f"  Total errors: {errata_summary['total_errors']:,}")
        print(f"  Files with errors: {errata_summary['files_with_errors']:,}")
        if errata_summary['error_types']:
            print(f"  Error types:")
            for error_type, count in errata_summary['error_types'].items():
                print(f"    - {error_type}: {count:,}")
        print(f"  Errata log: {errata_summary['log_file']}")
        print()

        print("="*70)
        print("✓ RVQ Dataset Processing Complete!")
        print("="*70)

    except KeyboardInterrupt:
        print("\n\n✗ Processing interrupted by user")
        sys.exit(1)
    except Exception as e:
        print(f"\n✗ Processing failed: {e}")
        import traceback
        traceback.print_exc()
        sys.exit(1)


if __name__ == '__main__':
    main()