""" Base classes for the GotPsi data cleaning pipeline. Defines abstract base classes that establish the interface for cleaners, processors, and exporters. """ from abc import ABC, abstractmethod from pathlib import Path from typing import Any, Dict, List, Optional import warnings import pandas as pd from collections import defaultdict warnings.filterwarnings('ignore', message='.*empty or all-NA entries.*') from .config import Config from .errata_logger import ErrataLogger from .file_discovery_logger import FileDiscoveryLogger class BaseCleaner(ABC): """ Abstract base class for data cleaning modules. Cleaners handle specific aspects of data cleaning such as encoding normalization, delimiter standardization, etc. """ def __init__(self, config: Config, errata_logger: Optional[ErrataLogger] = None): """ Initialize cleaner with configuration. Args: config: Configuration object errata_logger: Optional errata logger for error tracking """ self.config = config self.errata_logger = errata_logger @abstractmethod def clean(self, data: Any, **kwargs) -> Any: """ Clean the input data. Args: data: Input data to clean (format varies by cleaner) **kwargs: Additional parameters Returns: Cleaned data """ pass def log_error( self, error_type: str, message: str, **kwargs ) -> None: """ Log an error to the errata logger if available. Args: error_type: Type of error message: Error message **kwargs: Additional context (file_path, row_number, etc.) """ if self.errata_logger: self.errata_logger.log_error(error_type, message, **kwargs) class BaseProcessor(ABC): """ Abstract base class for dataset-specific processors. Processors handle the complete data cleaning workflow for a specific dataset type (e.g., card tests, RV tests). """ def __init__(self, config: Config, dataset_name: str): """ Initialize processor for a dataset. Args: config: Configuration object dataset_name: Name of the dataset to process """ self.config = config self.dataset_name = dataset_name self.dataset_config = config.dataset_config(dataset_name) # Initialize errata logger errata_dir = config.logs_dir / 'errata' self.errata_logger = ErrataLogger(errata_dir, dataset_name) # Initialize file discovery logger file_discovery_dir = config.logs_dir / 'file_discovery' self.file_discovery_logger = FileDiscoveryLogger(file_discovery_dir, dataset_name) def process(self, max_files: Optional[int] = None, chunk_size: int = 100) -> pd.DataFrame: """ Process all files with parallel cleaning and chunked concatenation. Override this in subclasses that need custom post-processing (e.g., users). Args: max_files: Optional limit on number of files to process chunk_size: Number of files to process before concatenating (default: 100) Returns: Combined DataFrame """ import gc from .exceptions import ProcessorError files = self.get_file_list() if max_files: files = files[:max_files] print(f"Processing {len(files)} {self.dataset_name} files...") # Phase 1: Parallel batch cleaning use_delim = getattr(self, 'BATCH_DELIMITER_CLEAN', True) cleaned_texts = self._batch_clean_files(files, use_delimiter_cleaner=use_delim) print(f"Successfully cleaned {len(cleaned_texts)}/{len(files)} files") # Phase 2: Sequential process_file with pre-cleaned text intermediate_chunks = [] current_chunk = [] try: from tqdm import tqdm iterator = tqdm(files, desc=f"Processing {self.dataset_name} files") except ImportError: iterator = files for file_path in iterator: pre_cleaned = cleaned_texts.get(file_path) if pre_cleaned is None: continue # file failed cleaning, already logged df = self.process_file(file_path, pre_cleaned_text=pre_cleaned) if df is not None and not df.empty: current_chunk.append(df) if len(current_chunk) >= chunk_size: chunk_df = pd.concat(current_chunk, ignore_index=True) del current_chunk current_chunk = [] intermediate_chunks.append(chunk_df) gc.collect() if current_chunk: chunk_df = pd.concat(current_chunk, ignore_index=True) del current_chunk intermediate_chunks.append(chunk_df) gc.collect() if not intermediate_chunks: raise ProcessorError("No valid data processed") print(f"Combining {len(intermediate_chunks)} intermediate chunks...") # Progressive pair-wise concatenation to minimize peak memory while len(intermediate_chunks) > 1: pair_results = [] for i in range(0, len(intermediate_chunks), 2): if i + 1 < len(intermediate_chunks): pair_df = pd.concat( [intermediate_chunks[i], intermediate_chunks[i + 1]], ignore_index=True ) pair_results.append(pair_df) else: pair_results.append(intermediate_chunks[i]) intermediate_chunks = pair_results gc.collect() combined = intermediate_chunks[0] del intermediate_chunks gc.collect() # Post-processing hooks combined = self._post_process(combined) # Close errata logger self.errata_logger.close() return combined def _post_process(self, combined: pd.DataFrame) -> pd.DataFrame: """ Post-processing hook called after all files are combined. Default: removes audit columns if audit_mode is disabled. Override in subclasses for custom post-processing. """ # Remove audit columns if audit mode is disabled audit_mode = self.config.get('processing.audit_mode', False) if not audit_mode: audit_cols = ['source_file', 'source_row_number'] cols_to_drop = [col for col in audit_cols if col in combined.columns] if cols_to_drop: combined = combined.drop(columns=cols_to_drop) print(f"Audit mode disabled: Removed columns {cols_to_drop}") print() return combined def pre_validate_csv_lines( self, text: str, file_path: Optional[str] = None, ) -> str: """Remove lines with inconsistent column counts, logging each drop. Determines the modal (most common) comma count, then filters out any non-blank line that doesn't match. This replaces the silent on_bad_lines='skip' with an audited pre-filter. """ from collections import Counter lines = text.split('\n') if not lines: return text comma_counts = [] for line in lines: stripped = line.strip() if stripped: comma_counts.append(stripped.count(',')) if not comma_counts: return text modal_count = Counter(comma_counts).most_common(1)[0][0] kept = [] dropped = 0 for lineno, line in enumerate(lines, 1): stripped = line.strip() if not stripped: kept.append(line) continue if stripped.count(',') == modal_count: kept.append(line) else: dropped += 1 if dropped <= 20: preview = stripped[:120] self.errata_logger.log_error( 'bad_csv_line', f"Line {lineno}: expected {modal_count} commas, got {stripped.count(',')}: {preview!r}", file_path=file_path, line_number=lineno, scope='row', ) if dropped > 0: self.errata_logger.log_error( 'bad_csv_lines_total', f"{dropped} line(s) dropped due to inconsistent column count (expected {modal_count + 1} columns)", file_path=file_path, scope='file', ) return '\n'.join(kept) def to_numeric_logged( self, series: pd.Series, col_name: str, file_path: Optional[str] = None, ) -> pd.Series: """Convert series to numeric, logging any values that get coerced to NaN.""" coerced = pd.to_numeric(series, errors='coerce') bad_mask = coerced.isna() & series.notna() & (series.astype(str).str.strip() != '') if bad_mask.any(): bad_values = series[bad_mask].astype(str).unique()[:10] self.errata_logger.log_error( 'numeric_coercion', f"{bad_mask.sum()} non-numeric value(s) coerced to NaN in '{col_name}': {list(bad_values)}", file_path=file_path, scope='row', ) return coerced @abstractmethod def process_file(self, file_path: Path, pre_cleaned_text: Optional[str] = None) -> Optional[pd.DataFrame]: """ Process a single file. Args: file_path: Path to the raw data file pre_cleaned_text: Pre-cleaned text (from parallel batch cleaning). If None, the processor should clean the file itself. Returns: DataFrame or None if processing fails """ pass # Class attribute: subclasses set this to their glob patterns FILE_PATTERNS: List[str] = [] def get_file_list(self) -> List[Path]: """ Get list of files to process for this dataset. Checks config 'file_discovery.use_manifest': - False (default): recursive glob using FILE_PATTERNS - True: reads from manifest.json in the experiment directory Returns: List of file paths """ use_manifest = self.config.get('file_discovery.use_manifest', False) if use_manifest: experiment_dir = self.config.raw_data_dir / self.dataset_name return self.discover_files_from_manifest(experiment_dir) else: files = self.discover_files(self.FILE_PATTERNS) if not files: from .exceptions import ProcessorError raise ProcessorError( f"No {self.dataset_name} files found matching patterns " f"{self.FILE_PATTERNS} in {self.config.raw_data_dir}" ) return files def get_dataset_path(self) -> Path: """ Get the full path to the dataset directory. Returns: Path to dataset directory """ rel_path = self.dataset_config['path'] return self.config.raw_data_dir / rel_path def discover_files(self, patterns: List[str], search_root: Optional[Path] = None) -> List[Path]: """ Recursively discover files matching patterns, with deduplication. Searches the data directory recursively for files matching the given patterns. When duplicate filenames are found, keeps the larger file. Logs all discoveries and deduplication decisions. Args: patterns: List of filename patterns (e.g., ['users*.dat', 'questions*.dat']) search_root: Root directory to search (defaults to config.raw_data_dir) Returns: List of unique file paths (deduplicated) """ if search_root is None: search_root = Path(self.config.raw_data_dir) # Log search parameters self.file_discovery_logger.set_search_params(search_root, patterns) # Discover all matching files all_files = [] for pattern in patterns: matching_files = list(search_root.rglob(pattern)) all_files.extend(matching_files) # Log all discovered files print(f"File Discovery: Found {len(all_files)} file(s) matching patterns {patterns}") for file_path in all_files: self.file_discovery_logger.add_discovered_file(file_path) print(f" - {file_path.name}: {file_path.stat().st_size / (1024*1024):.2f} MB") # Deduplicate by filename (keep larger file) deduplicated_files = self._deduplicate_files(all_files) # Log selected files print(f"\nAfter deduplication: {len(deduplicated_files)} unique file(s) selected") for file_path in deduplicated_files: self.file_discovery_logger.add_selected_file(file_path) # Finalize and write log self.file_discovery_logger.finalize_and_write() print(f"File discovery log: {self.file_discovery_logger.get_log_file()}") print() return deduplicated_files def _deduplicate_files(self, files: List[Path]) -> List[Path]: """ Deduplicate files by name, keeping the larger file. Args: files: List of file paths Returns: Deduplicated list of file paths """ # Group files by name files_by_name = defaultdict(list) for file_path in files: files_by_name[file_path.name].append(file_path) # Select one file per name (largest) selected_files = [] for filename, file_list in files_by_name.items(): if len(file_list) == 1: # No duplicates, just add it selected_files.append(file_list[0]) else: # Multiple files with same name, keep largest largest_file = max(file_list, key=lambda f: f.stat().st_size) selected_files.append(largest_file) # Log the duplicate set self.file_discovery_logger.add_duplicate_set( files=file_list, selected_file=largest_file, reason=f"Largest file ({largest_file.stat().st_size} bytes)" ) # Print warning about duplicates print(f"\n⚠ Found {len(file_list)} copies of '{filename}':") for f in file_list: marker = "✓ SELECTED" if f == largest_file else " skipped" print(f" {marker}: {f} ({f.stat().st_size / (1024*1024):.2f} MB)") return sorted(selected_files) def discover_files_from_manifest(self, experiment_dir: Path) -> List[Path]: """ Discover files by reading the experiment directory's manifest.json. Args: experiment_dir: Path to the experiment directory containing manifest.json Returns: List of file paths that exist on disk Raises: ProcessorError: If no manifest-listed files exist on disk """ import json import logging from .exceptions import ProcessorError logger = logging.getLogger(__name__) manifest_path = experiment_dir / 'manifest.json' if not manifest_path.exists(): raise ProcessorError( f"No manifest.json found in {experiment_dir}. " f"Run scripts/migrate_raw_data.py first." ) manifest = json.loads(manifest_path.read_text()) found = [] missing = [] for entry in manifest.get('files', []): file_path = experiment_dir / entry['filename'] if file_path.exists(): found.append(file_path) else: missing.append(entry['filename']) logger.warning(f"Manifest-listed file not found: {file_path}") if missing: logger.warning( f"{len(missing)}/{len(manifest['files'])} manifest files missing " f"in {experiment_dir}" ) if not found: raise ProcessorError( f"No manifest-listed files found in {experiment_dir}. " f"Run scripts/download_data.py to fetch the data." ) return sorted(found) def _read_and_clean_text( self, file_path: Path, use_delimiter_cleaner: bool = True ) -> str: """ Read a file and clean its encoding and delimiters. This is the unit of work for parallel batch cleaning. Args: file_path: Path to the raw data file use_delimiter_cleaner: Whether to apply delimiter standardization Returns: Cleaned UTF-8 text string """ # Step 1: encoding clean (detect + decode + mojibake fix) text = self.encoding_cleaner.clean(file_path) # Step 2: optional delimiter standardization if use_delimiter_cleaner and hasattr(self, 'delimiter_cleaner'): text = self.delimiter_cleaner.clean(text, file_path=str(file_path)) return text def _batch_clean_files( self, files: List[Path], use_delimiter_cleaner: bool = True, max_workers: Optional[int] = None ) -> Dict[Path, str]: """ Clean all files in parallel using ThreadPoolExecutor. Encoding detection (chardet) and file I/O release the GIL, making threads effective here. Args: files: List of file paths to clean use_delimiter_cleaner: Whether to apply delimiter standardization max_workers: Max threads (defaults to min(8, len(files))) Returns: Dict mapping file path to cleaned text. Failed files are excluded. """ from concurrent.futures import ThreadPoolExecutor, as_completed if not files: return {} if max_workers is None: max_workers = min(8, len(files)) results: Dict[Path, str] = {} def clean_one(file_path: Path) -> tuple: try: text = self._read_and_clean_text(file_path, use_delimiter_cleaner) return (file_path, text, None) except Exception as e: return (file_path, None, e) with ThreadPoolExecutor(max_workers=max_workers) as executor: futures = {executor.submit(clean_one, f): f for f in files} try: from tqdm import tqdm iterator = tqdm( as_completed(futures), total=len(futures), desc="Cleaning files" ) except ImportError: iterator = as_completed(futures) for future in iterator: file_path, text, error = future.result() if error is not None: self.errata_logger.log_error( 'batch_clean_failed', f'Failed to clean file: {error}', file_path=str(file_path), scope='file' ) else: results[file_path] = text return results class BaseProfiler(ABC): """ Abstract base class for file profilers. Profilers analyze files to detect format characteristics such as encoding, delimiters, and schema. """ def __init__(self, config: Config): """ Initialize profiler with configuration. Args: config: Configuration object """ self.config = config @abstractmethod def profile(self, file_path: str | Path) -> Dict[str, Any]: """ Profile a file to detect its characteristics. Args: file_path: Path to file to profile Returns: Dictionary with profile information """ pass class BaseExporter(ABC): """ Abstract base class for data exporters. Exporters handle writing cleaned data to various formats (HDF5, Parquet, CSV). """ def __init__(self, config: Config): """ Initialize exporter with configuration. Args: config: Configuration object """ self.config = config @abstractmethod def export(self, data: pd.DataFrame, output_path: str | Path, **kwargs) -> None: """ Export data to output file. Args: data: DataFrame to export output_path: Output file path **kwargs: Format-specific parameters """ pass class BaseQualityAssessor(ABC): """ Abstract base class for data quality assessment. Quality assessors analyze cleaned data and compute quality scores and metrics. """ def __init__(self, config: Config): """ Initialize quality assessor with configuration. Args: config: Configuration object """ self.config = config @abstractmethod def assess(self, data: pd.DataFrame) -> Dict[str, Any]: """ Assess data quality and compute metrics. Args: data: DataFrame to assess Returns: Dictionary with quality metrics """ pass @abstractmethod def compute_quality_score(self, metrics: Dict[str, Any]) -> float: """ Compute overall quality score from metrics. Args: metrics: Quality metrics dictionary Returns: Quality score (0-10) """ pass