scripts/process_cardd_full.py

"""
Process full CardD dataset and export to Parquet.

Processes all 6000+ CardD 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.cardd_processor import CardDProcessor


def main():
    parser = argparse.ArgumentParser(description='Process CardD 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("CardD 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 / 'cardD_cleaned.parquet'

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

    # Create processor
    processor = CardDProcessor(config)

    # Get file count
    all_files = processor.get_file_list()
    print(f"Total files to process: {len(all_files)}")
    print()

    # Process all files
    print("Processing all CardD files...")
    print("This may take 30-60 minutes depending on system speed...")
    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"  Schema v1 files (pre 2006-06-22): {stats['schema_v1_files']:,}")
        print(f"  Schema v2 files (post 2006-06-22): {stats['schema_v2_files']:,}")
        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()

        # 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("✓ CardD 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()