data_processing.py

#!/usr/bin/env python3
"""
Phase 3: Data Processing for Aging Fly Cell Atlas (AFCA)
========================================================

Processes the H5AD files into HuggingFace-compatible parquet files:
- Expression matrix (sparse -> dense conversion with chunking)
- Sample metadata (cell-level information)
- Feature metadata (gene information)
- Dimensionality reduction projections (PCA, UMAP, t-SNE)
- Unstructured metadata (all additional data)

Processing Strategy:
- Process head and body datasets separately to avoid OOM
- Use chunking for large expression matrices
- Optimize data types for efficiency
- Apply pandas index bug fixes
- Save intermediate results to avoid data loss
- CLI interface for selective processing

Requirements:
- Memory-efficient processing for 566K × 16K matrices
- Sparse matrix handling for efficiency
- Proper data type optimization
"""

import logging
import json
import time
from pathlib import Path
from typing import Dict, Any, Optional, List, Set
import shutil
import gc
import os
import psutil

import numpy as np
import pandas as pd
import scanpy as sc
from scipy import sparse
import pyarrow.parquet as pq
import typer
from typing_extensions import Annotated
import warnings

# Configure scanpy
sc.settings.verbosity = 3
sc.settings.set_figure_params(dpi=80, facecolor='white')

# Setup logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

app = typer.Typer(help="Process Aging Fly Cell Atlas data into HuggingFace format")

def get_memory_usage() -> float:
    """Get current memory usage in GB"""
    return psutil.virtual_memory().used / (1024**3)

def log_memory_status(stage: str) -> None:
    """Log current memory status"""
    memory_gb = get_memory_usage()
    available_gb = psutil.virtual_memory().available / (1024**3)
    logger.info(f"{stage} - Memory: {memory_gb:.1f}GB used, {available_gb:.1f}GB available")

def make_json_serializable(obj: Any) -> Any:
    """Convert numpy arrays and other non-serializable objects for JSON"""
    if isinstance(obj, np.ndarray):
        return obj.tolist()
    elif isinstance(obj, dict):
        return {k: make_json_serializable(v) for k, v in obj.items()}
    elif isinstance(obj, (list, tuple)):
        return [make_json_serializable(i) for i in obj]
    elif isinstance(obj, (np.integer, np.floating)):
        return obj.item()
    else:
        return obj

def log_memory_usage(stage: str, adata: sc.AnnData) -> None:
    """Log memory usage and dataset info"""
    memory_mb = adata.X.data.nbytes / 1024**2 if sparse.issparse(adata.X) else adata.X.nbytes / 1024**2
    logger.info(f"{stage}: Shape {adata.shape}, Memory: {memory_mb:.1f}MB")

def save_stage_result(output_dir: Path, tissue: str, stage: str, result: Dict[str, Any]) -> None:
    """Save intermediate results for each stage"""
    result_file = output_dir / f"{tissue}_{stage}_result.json"
    with open(result_file, 'w') as f:
        json.dump(result, f, indent=2)
    logger.info(f"💾 Saved {stage} result for {tissue}")

def load_stage_result(output_dir: Path, tissue: str, stage: str) -> Optional[Dict[str, Any]]:
    """Load existing stage result if available"""
    result_file = output_dir / f"{tissue}_{stage}_result.json"
    if result_file.exists():
        with open(result_file, 'r') as f:
            result = json.load(f)
        logger.info(f"📖 Loaded existing {stage} result for {tissue}")
        return result
    return None

def get_completed_stages(output_dir: Path, tissue: str) -> Set[str]:
    """Get list of completed stages for a tissue"""
    stages = {'expression', 'sample_metadata', 'feature_metadata', 'projections', 'unstructured'}
    completed = set()
    
    for stage in stages:
        if load_stage_result(output_dir, tissue, stage) is not None:
            completed.add(stage)
    
    if completed:
        logger.info(f"🔄 Found completed stages for {tissue}: {', '.join(sorted(completed))}")
    
    return completed

def fix_pandas_index_column_bug(parquet_file: Path) -> bool:
    """
    Fix the pandas __index_level_0__ bug in parquet files
    
    This is a known bug in pandas/PyArrow where pandas saves the index as an extra 
    '__index_level_0__' column when writing to parquet format. 
    This is a known upstream issue with no planned fix
    
    References:
    - https://github.com/pandas-dev/pandas/issues/51664
    - https://github.com/pola-rs/polars/issues/7291

    Args:
        parquet_file: Path to the parquet file to fix
        
    Returns:
        bool: True if fix was applied successfully, False otherwise
    """
    logger.info(f"🔧 Checking for pandas __index_level_0__ bug in {parquet_file.name}")
    
    try:
        # Check if the bug exists
        pf = pq.ParquetFile(parquet_file)
        schema_names = pf.schema_arrow.names
        
        if '__index_level_0__' not in schema_names:
            logger.info("✅ No __index_level_0__ column found - file is clean")
            return True
            
        logger.warning(f"🐛 Found pandas __index_level_0__ bug - fixing...")
        logger.info(f"   Current columns: {len(schema_names)} (expected: {len(schema_names)-1})")
        
        # Create backup
        backup_file = parquet_file.with_suffix('.backup.parquet')
        if not backup_file.exists():
            shutil.copy2(parquet_file, backup_file)
            logger.info(f"📦 Backup created: {backup_file.name}")
        
        # Apply fix using PyArrow
        table = pq.read_table(parquet_file)
        
        # Filter out the problematic column
        columns_to_keep = [name for name in table.column_names if name != '__index_level_0__']
        clean_table = table.select(columns_to_keep)
        
        # Write clean table to temporary file first
        temp_file = parquet_file.with_suffix('.temp.parquet')
        pq.write_table(clean_table, temp_file, compression='snappy')
        
        # Verify the fix
        temp_pf = pq.ParquetFile(temp_file)
        temp_schema_names = temp_pf.schema_arrow.names
        
        if '__index_level_0__' not in temp_schema_names:
            # Replace original with fixed version
            shutil.move(temp_file, parquet_file)
            logger.info(f"✅ Fixed pandas __index_level_0__ bug")
            logger.info(f"   Column count: {len(schema_names)} → {len(temp_schema_names)}")
            return True
        else:
            # Fix failed, clean up
            temp_file.unlink()
            logger.error("❌ Fix verification failed")
            return False
            
    except Exception as e:
        logger.error(f"❌ Error fixing pandas index bug: {e}")
        return False

def process_expression_matrix(adata: sc.AnnData, tissue: str, output_dir: Path, 
                            aggressive_chunking: bool = False) -> Dict[str, Any]:
    """
    Process and save expression matrix with chunking to avoid OOM
    
    Strategy:
    - Check sparsity and memory requirements
    - Use aggressive chunking for body dataset
    - Convert to float32 for efficiency
    - More frequent garbage collection
    """
    logger.info(f"Starting expression matrix processing for {tissue}...")
    log_memory_usage(f"Expression matrix ({tissue})", adata)
    log_memory_status("Before expression processing")
    
    # Calculate memory requirements for dense conversion
    dense_memory_gb = (adata.n_obs * adata.n_vars * 4) / (1024**3)  # float32 = 4 bytes
    sparsity = 1.0 - (adata.X.nnz / (adata.n_obs * adata.n_vars))
    
    logger.info(f"Dense conversion would require: {dense_memory_gb:.2f}GB")
    logger.info(f"Current sparsity: {sparsity:.2%}")
    
    output_file = output_dir / f"aging_fly_{tissue}_expression.parquet"
    
    # Determine chunk size based on tissue and available memory  
    available_memory_gb = psutil.virtual_memory().available / (1024**3)
    
    if tissue == 'body' or aggressive_chunking:
        # More aggressive chunking for body dataset
        chunk_size = min(2000, max(500, int(available_memory_gb * 100)))  # Scale with available memory
        logger.warning(f"🚨 Using aggressive chunking for {tissue} (chunk_size={chunk_size})")
    else:
        chunk_size = 5000
    
    logger.info(f"Processing expression matrix in chunks (size: {chunk_size})...")
    chunks = []
    
    for i in range(0, adata.n_obs, chunk_size):
        end_idx = min(i + chunk_size, adata.n_obs)
        chunk = adata[i:end_idx, :].copy()
        
        if sparse.issparse(chunk.X):
            chunk_dense = chunk.X.toarray().astype(np.float32)
        else:
            chunk_dense = chunk.X.astype(np.float32)
        
        chunk_df = pd.DataFrame(
            chunk_dense,
            index=chunk.obs_names,
            columns=chunk.var_names
        )
        chunks.append(chunk_df)
        
        chunk_num = i//chunk_size + 1
        total_chunks = (adata.n_obs-1)//chunk_size + 1
        logger.info(f"Processed chunk {chunk_num}/{total_chunks}")
        
        # More aggressive cleanup for body dataset
        del chunk, chunk_dense
        if tissue == 'body' or aggressive_chunking:
            gc.collect()  # Force GC every chunk
        
        # Memory check for body dataset
        if tissue == 'body':
            current_memory_gb = get_memory_usage()
            if current_memory_gb > 24:  # Warning at 24GB
                logger.warning(f"⚠️  High memory usage: {current_memory_gb:.1f}GB")
                # Force garbage collection
                gc.collect()
    
    # Combine chunks
    logger.info("Combining chunks...")
    log_memory_status("Before combining chunks")
    
    expression_df = pd.concat(chunks, axis=0)
    del chunks  # Free memory immediately
    gc.collect()
    
    log_memory_status("After combining chunks")
    
    # Save with compression
    logger.info(f"Saving expression matrix: {expression_df.shape}")
    expression_df.to_parquet(output_file, compression='snappy')
    
    # Apply pandas __index_level_0__ bug fix
    fix_success = fix_pandas_index_column_bug(output_file)
    
    stats = {
        'file': str(output_file),
        'shape': list(expression_df.shape),
        'memory_gb': dense_memory_gb,
        'sparsity_percent': sparsity * 100,
        'dtype': str(expression_df.dtypes.iloc[0]),
        'pandas_index_bug_fixed': fix_success,
        'chunk_size_used': chunk_size,
        'aggressive_chunking': aggressive_chunking
    }
    
    logger.info(f"✅ Expression matrix saved: {expression_df.shape}")
    del expression_df
    gc.collect()
    log_memory_status("After expression processing")
    return stats

def process_sample_metadata(adata: sc.AnnData, tissue: str, output_dir: Path) -> Dict[str, Any]:
    """Process and save sample (cell) metadata"""
    logger.info(f"Processing sample metadata for {tissue}...")
    
    sample_metadata = adata.obs.copy()
    
    # Verify critical columns exist
    critical_cols = ['age', 'sex', 'afca_annotation', 'afca_annotation_broad']
    missing_cols = [col for col in critical_cols if col not in sample_metadata.columns]
    
    if missing_cols:
        logger.warning(f"Missing critical columns: {missing_cols}")
    else:
        logger.info("✅ All critical metadata columns present")
    
    # Add tissue column
    sample_metadata['tissue'] = tissue
    
    # Add standardized age column if needed
    if 'age_numeric' not in sample_metadata.columns and 'age' in sample_metadata.columns:
        # Convert age to numeric
        sample_metadata['age_numeric'] = pd.to_numeric(sample_metadata['age'], errors='coerce')
        logger.info("Added numeric age column")
    
    # Optimize data types
    for col in sample_metadata.columns:
        if sample_metadata[col].dtype == 'object':
            # Convert categorical strings to category type for efficiency
            if sample_metadata[col].nunique() < len(sample_metadata) * 0.5:
                sample_metadata[col] = sample_metadata[col].astype('category')
    
    output_file = output_dir / f"aging_fly_{tissue}_sample_metadata.parquet"
    sample_metadata.to_parquet(output_file, compression='snappy')
    
    stats = {
        'file': str(output_file),
        'shape': list(sample_metadata.shape),
        'columns': list(sample_metadata.columns),
        'missing_columns': missing_cols,
        'age_groups': sample_metadata['age'].value_counts().to_dict() if 'age' in sample_metadata.columns else {},
        'cell_types': sample_metadata['afca_annotation'].value_counts().head(10).to_dict() if 'afca_annotation' in sample_metadata.columns else {},
        'sex_distribution': sample_metadata['sex'].value_counts().to_dict() if 'sex' in sample_metadata.columns else {}
    }
    
    logger.info(f"✅ Sample metadata saved: {sample_metadata.shape}")
    return stats

def process_feature_metadata(adata: sc.AnnData, tissue: str, output_dir: Path) -> Dict[str, Any]:
    """Process and save feature (gene) metadata"""
    logger.info(f"Processing feature metadata for {tissue}...")
    
    feature_metadata = adata.var.copy()
    
    # Ensure gene IDs are present
    if 'gene_ids' not in feature_metadata.columns:
        feature_metadata['gene_ids'] = feature_metadata.index
        logger.info("Added gene_ids column from index")
    
    # Check for gene symbols and other annotations
    symbol_cols = [col for col in feature_metadata.columns if 'symbol' in col.lower()]
    if symbol_cols:
        logger.info(f"Gene symbol columns found: {symbol_cols}")
    
    output_file = output_dir / f"aging_fly_{tissue}_feature_metadata.parquet"
    feature_metadata.to_parquet(output_file, compression='snappy')
    
    stats = {
        'file': str(output_file),
        'shape': list(feature_metadata.shape),
        'columns': list(feature_metadata.columns),
        'has_symbols': len(symbol_cols) > 0,
        'symbol_columns': symbol_cols
    }
    
    logger.info(f"✅ Feature metadata saved: {feature_metadata.shape}")
    return stats

def process_projections(adata: sc.AnnData, tissue: str, output_dir: Path) -> Dict[str, Any]:
    """Process and save all dimensionality reduction projections"""
    logger.info(f"Processing dimensionality reduction projections for {tissue}...")
    
    projection_stats = {}
    available_projections = list(adata.obsm.keys())
    logger.info(f"Available projections: {available_projections}")
    
    for proj_name in available_projections:
        if proj_name.startswith('X_'):
            proj_data = adata.obsm[proj_name]
            
            # Convert to DataFrame
            proj_df = pd.DataFrame(
                proj_data,
                index=adata.obs_names,
                columns=[f"{proj_name.split('_')[1].upper()}{i+1}" for i in range(proj_data.shape[1])]
            )
            
            # Save projection
            output_file = output_dir / f"aging_fly_{tissue}_projection_{proj_name}.parquet"
            proj_df.to_parquet(output_file, compression='snappy')
            
            projection_stats[proj_name] = {
                'file': str(output_file),
                'shape': list(proj_df.shape),
                'dimensions': proj_data.shape[1]
            }
            
            logger.info(f"✅ Saved {proj_name}: {proj_df.shape}")
        else:
            logger.info(f"Skipping non-projection: {proj_name}")
    
    return projection_stats

def process_unstructured_metadata(adata: sc.AnnData, tissue: str, output_dir: Path) -> Dict[str, Any]:
    """Process and save unstructured metadata (uns)"""
    logger.info(f"Processing unstructured metadata for {tissue}...")
    
    try:
        # Make data JSON serializable
        unstructured_data = make_json_serializable(adata.uns)
        
        output_file = output_dir / f"aging_fly_{tissue}_unstructured_metadata.json"
        
        with open(output_file, 'w') as f:
            json.dump(unstructured_data, f, indent=2)
        
        # Count keys and estimate size
        key_count = len(unstructured_data) if isinstance(unstructured_data, dict) else 0
        file_size_mb = output_file.stat().st_size / (1024**2)
        
        stats = {
            'file': str(output_file),
            'key_count': key_count,
            'file_size_mb': round(file_size_mb, 2),
            'top_keys': list(unstructured_data.keys())[:10] if isinstance(unstructured_data, dict) else []
        }
        
        logger.info(f"✅ Unstructured metadata saved: {key_count} keys, {file_size_mb:.1f}MB")
        return stats
        
    except Exception as e:
        logger.error(f"Failed to process unstructured metadata: {e}")
        return {'error': str(e)}

def process_single_dataset(data_file: Path, tissue: str, output_dir: Path,
                          skip_stages: Set[str] = None, aggressive_chunking: bool = False) -> Dict[str, Any]:
    """Process a single H5AD dataset (head or body) with stage resumption"""
    logger.info(f"\n🧬 Processing {tissue.upper()} dataset: {data_file}")
    
    if skip_stages is None:
        skip_stages = set()
    
    # Check for existing results
    completed_stages = get_completed_stages(output_dir, tissue)
    stages_to_skip = skip_stages.union(completed_stages)
    
    if stages_to_skip:
        logger.info(f"⏭️  Skipping stages: {', '.join(sorted(stages_to_skip))}")
    
    # Processing results tracking
    processing_results = {
        'dataset_info': {
            'tissue': tissue,
            'file': str(data_file),
            'processing_time': None,
            'timestamp': time.strftime('%Y-%m-%d %H:%M:%S'),
            'aggressive_chunking': aggressive_chunking
        }
    }
    
    # Load existing results
    for stage in ['expression', 'sample_metadata', 'feature_metadata', 'projections', 'unstructured']:
        if stage in completed_stages:
            existing_result = load_stage_result(output_dir, tissue, stage)
            if existing_result:
                processing_results[stage] = existing_result
    
    # Load data only if we need to process something
    stages_needed = {'expression', 'sample_metadata', 'feature_metadata', 'projections', 'unstructured'} - stages_to_skip
    
    if not stages_needed:
        logger.info(f"✅ All stages already completed for {tissue}")
        return processing_results
    
    logger.info(f"Loading {tissue} data from {data_file}...")
    log_memory_status("Before loading data")
    
    try:
        adata = sc.read_h5ad(data_file)
        logger.info(f"✅ {tissue.capitalize()} data loaded: {adata.shape}")
        processing_results['dataset_info']['shape'] = list(adata.shape)
        log_memory_usage(f"Initial ({tissue})", adata)
        log_memory_status("After loading data")
    except Exception as e:
        logger.error(f"Failed to load {tissue} data: {e}")
        return {'error': str(e)}
    
    start_time = time.time()
    
    try:
        # Task 3.1: Expression Matrix
        if 'expression' not in stages_to_skip:
            logger.info(f"\n🧬 Task 3.1: Processing {tissue} Expression Matrix")
            result = process_expression_matrix(adata, tissue, output_dir, aggressive_chunking)
            processing_results['expression'] = result
            save_stage_result(output_dir, tissue, 'expression', result)
        
        # Task 3.2: Sample Metadata
        if 'sample_metadata' not in stages_to_skip:
            logger.info(f"\n📊 Task 3.2: Processing {tissue} Sample Metadata")
            result = process_sample_metadata(adata, tissue, output_dir)
            processing_results['sample_metadata'] = result
            save_stage_result(output_dir, tissue, 'sample_metadata', result)
        
        # Task 3.3: Feature Metadata
        if 'feature_metadata' not in stages_to_skip:
            logger.info(f"\n🧪 Task 3.3: Processing {tissue} Feature Metadata")
            result = process_feature_metadata(adata, tissue, output_dir)
            processing_results['feature_metadata'] = result
            save_stage_result(output_dir, tissue, 'feature_metadata', result)
        
        # Task 3.4: Dimensionality Reductions
        if 'projections' not in stages_to_skip:
            logger.info(f"\n📈 Task 3.4: Processing {tissue} Projections")
            result = process_projections(adata, tissue, output_dir)
            processing_results['projections'] = result
            save_stage_result(output_dir, tissue, 'projections', result)
        
        # Task 3.5: Unstructured Metadata
        if 'unstructured' not in stages_to_skip:
            logger.info(f"\n📋 Task 3.5: Processing {tissue} Unstructured Metadata")
            result = process_unstructured_metadata(adata, tissue, output_dir)
            processing_results['unstructured'] = result
            save_stage_result(output_dir, tissue, 'unstructured', result)
        
        # Calculate processing time
        processing_time = time.time() - start_time
        processing_results['dataset_info']['processing_time'] = f"{processing_time:.1f}s"
        
        logger.info(f"\n✅ {tissue.capitalize()} Processing Complete!")
        logger.info(f"⏱️  Processing time: {processing_time:.1f}s")
        
        # Save overall result
        overall_result_file = output_dir / f"{tissue}_overall_result.json"
        with open(overall_result_file, 'w') as f:
            json.dump(processing_results, f, indent=2)
        logger.info(f"💾 Saved overall result for {tissue}")
        
        # Clean up memory
        del adata
        gc.collect()
        log_memory_status("After cleanup")
        
        return processing_results
        
    except Exception as e:
        logger.error(f"{tissue.capitalize()} processing failed: {e}")
        processing_results['error'] = str(e)
        
        # Save partial results even on error
        error_result_file = output_dir / f"{tissue}_error_result.json"
        with open(error_result_file, 'w') as f:
            json.dump(processing_results, f, indent=2)
        logger.info(f"💾 Saved partial results despite error")
        
        # Clean up memory even on error
        del adata
        gc.collect()
        
        return processing_results

def combine_metadata_files(output_dir: Path, tissues: List[str]) -> None:
    """Combine metadata files from different tissues"""
    logger.info("\n🔗 Combining metadata files across tissues...")
    
    # Combine sample metadata
    sample_dfs = []
    for tissue in tissues:
        sample_file = output_dir / f"aging_fly_{tissue}_sample_metadata.parquet"
        if sample_file.exists():
            df = pd.read_parquet(sample_file)
            sample_dfs.append(df)
            logger.info(f"Loaded {tissue} sample metadata: {df.shape}")
    
    if sample_dfs:
        combined_sample_df = pd.concat(sample_dfs, axis=0, ignore_index=False)
        combined_file = output_dir / "aging_fly_combined_sample_metadata.parquet"
        combined_sample_df.to_parquet(combined_file, compression='snappy')
        logger.info(f"✅ Combined sample metadata saved: {combined_sample_df.shape}")
    
    # Feature metadata should be identical, so just copy one
    for tissue in tissues:
        feature_file = output_dir / f"aging_fly_{tissue}_feature_metadata.parquet"
        if feature_file.exists():
            combined_feature_file = output_dir / "aging_fly_combined_feature_metadata.parquet"
            shutil.copy2(feature_file, combined_feature_file)
            logger.info(f"✅ Combined feature metadata copied from {tissue}")
            break

@app.command()
def process(
    tissue: Annotated[str, typer.Argument(help="Which tissue to process: 'head', 'body', or 'both'")] = "both",
    skip_expression: Annotated[bool, typer.Option(help="Skip expression matrix processing")] = False,
    skip_metadata: Annotated[bool, typer.Option(help="Skip metadata processing")] = False,
    skip_projections: Annotated[bool, typer.Option(help="Skip projection processing")] = False,
    aggressive_chunking: Annotated[bool, typer.Option(help="Use aggressive chunking (for low memory)")] = False,
    data_dir: Annotated[str, typer.Option(help="Data directory path")] = "data",
    output_dir: Annotated[str, typer.Option(help="Output directory path")] = "processed"
) -> None:
    """Process Aging Fly Cell Atlas data into HuggingFace format"""
    
    start_time = time.time()
    logger.info("=== Phase 3: Aging Fly Cell Atlas Data Processing Started ===")
    
    # Validate tissue parameter
    valid_tissues = {'head', 'body', 'both'}
    if tissue not in valid_tissues:
        logger.error(f"Invalid tissue '{tissue}'. Must be one of: {', '.join(valid_tissues)}")
        raise typer.Exit(1)
    
    # Setup paths
    data_path = Path(data_dir)
    output_path = Path(output_dir)
    output_path.mkdir(exist_ok=True)
    
    head_file = data_path / "afca_head.h5ad"
    body_file = data_path / "afca_body.h5ad"
    
    # Determine which datasets to process
    datasets_to_process = []
    if tissue in ['head', 'both']:
        if head_file.exists():
            datasets_to_process.append(('head', head_file))
        else:
            logger.warning(f"Head file not found: {head_file}")
    
    if tissue in ['body', 'both']:
        if body_file.exists():
            datasets_to_process.append(('body', body_file))
        else:
            logger.warning(f"Body file not found: {body_file}")
    
    if not datasets_to_process:
        logger.error("No valid datasets found to process")
        raise typer.Exit(1)
    
    # Setup skip stages
    skip_stages = set()
    if skip_expression:
        skip_stages.add('expression')
    if skip_metadata:
        skip_stages.update(['sample_metadata', 'feature_metadata', 'unstructured'])
    if skip_projections:
        skip_stages.add('projections')
    
    # Process datasets
    all_results = {}
    
    for tissue_name, data_file in datasets_to_process:
        logger.info(f"\n{'='*60}")
        logger.info(f"Processing {tissue_name.upper()} dataset")
        logger.info(f"{'='*60}")
        
        # Use aggressive chunking for body by default, or if explicitly requested
        use_aggressive = aggressive_chunking or (tissue_name == 'body')
        
        results = process_single_dataset(data_file, tissue_name, output_path, 
                                       skip_stages, use_aggressive)
        all_results[tissue_name] = results
        
        # Force garbage collection between datasets
        gc.collect()
        log_memory_status(f"After processing {tissue_name}")
    
    # Generate summary
    generate_summary(output_path, all_results, start_time)

@app.command()
def summary(
    output_dir: Annotated[str, typer.Option(help="Output directory path")] = "processed"
) -> None:
    """Generate summary from existing results without reprocessing"""
    
    output_path = Path(output_dir)
    if not output_path.exists():
        logger.error(f"Output directory not found: {output_path}")
        raise typer.Exit(1)
    
    logger.info("📊 Generating summary from existing results...")
    
    # Load existing results
    all_results = {}
    for tissue in ['head', 'body']:
        overall_result_file = output_path / f"{tissue}_overall_result.json"
        if overall_result_file.exists():
            with open(overall_result_file, 'r') as f:
                all_results[tissue] = json.load(f)
            logger.info(f"✅ Loaded {tissue} results")
        else:
            logger.warning(f"⚠️  No results found for {tissue}")
    
    if not all_results:
        logger.error("No existing results found")
        raise typer.Exit(1)
    
    generate_summary(output_path, all_results, time.time())

def generate_summary(output_path: Path, all_results: Dict[str, Any], start_time: float) -> None:
    """Generate processing summary"""
    
    # Combine metadata files if both tissues processed
    tissues = list(all_results.keys())
    if len(tissues) > 1:
        combine_metadata_files(output_path, tissues)
    
    # Calculate total processing time
    total_processing_time = time.time() - start_time
    
    summary = {
        'processing_info': {
            'total_time': f"{total_processing_time:.1f}s",
            'timestamp': time.strftime('%Y-%m-%d %H:%M:%S'),
            'datasets_processed': len(tissues)
        },
        'results': all_results
    }
    
    summary_file = output_path / "phase3_processing_summary.json"
    with open(summary_file, 'w') as f:
        json.dump(summary, f, indent=2)
    
    logger.info(f"\n✅ Processing Summary Generated!")
    logger.info(f"⏱️  Total time: {total_processing_time:.1f}s")
    logger.info(f"📄 Summary saved: {summary_file}")
    
    # List all created files
    logger.info("\n📁 Created Files:")
    for file_path in sorted(output_path.glob("aging_fly_*.parquet")):
        size_mb = file_path.stat().st_size / (1024**2)
        logger.info(f"  {file_path.name} ({size_mb:.1f}MB)")
    
    for file_path in sorted(output_path.glob("aging_fly_*.json")):
        size_mb = file_path.stat().st_size / (1024**2)
        logger.info(f"  {file_path.name} ({size_mb:.1f}MB)")
    
    # Calculate total cells if available
    total_cells = 0
    for tissue_result in all_results.values():
        if 'dataset_info' in tissue_result and 'shape' in tissue_result['dataset_info']:
            total_cells += tissue_result['dataset_info']['shape'][0]
    
    if total_cells > 0:
        logger.info(f"\n🎉 Total cells processed: {total_cells:,}")

if __name__ == "__main__":
    app()