GotPsi / src /processors /cardd_processor.py

instNoeticSciences

claude opus 4.6

Flatten history: re-sanitized (128-bit hash) GotPsi public dataset

9deebf2 5 months ago

17.8 kB

"""
CardD (Card Draw Test) dataset processor.
Processes ESP card drawing test data with two schema versions:
- Old format (pre 2006-06-22): 14-15 columns, combined Markov bits
- New format (post 2006-06-22): 15-16 columns, separate Markov bits, optional image_filename
"""

from pathlib import Path
from typing import List, Dict, Any, Optional
from datetime import datetime
import pandas as pd
import re

from ..core.base_classes import BaseProcessor
from ..core.config import Config
from ..core.exceptions import ProcessorError
from ..cleaners.encoding_cleaner import EncodingCleaner
from ..cleaners.delimiter_cleaner import DelimiterCleaner
from ..cleaners.temporal_parser import TemporalParser


class CardDProcessor(BaseProcessor):
    """
    Processes CardD (Card Draw Test) data.
    Schema versions:
    - v1 (pre 2006-06-22): Markov bits combined in single 32-bit word
    - v2 (post 2006-06-22): Markov bits in separate words
    """

    # File discovery patterns
    FILE_PATTERNS = ['cardD*.dat']

    # Schema change date
    SCHEMA_CHANGE_DATE = datetime(2006, 6, 22)

    # Column definitions
    COLUMNS_OLD = [
        'user_id', 'target_bit', 'cards_done', 'cards_hit',
        'markov_stages', 'markov_output', 'markov_prob',
        'markov_bits_combined',  # Single word with both chains
        'card_number', 'is_hit', 'run_hits', 'trial_number',
        'timestamp', 'target_image', 'extra'
    ]

    COLUMNS_NEW = [
        'user_id', 'target_bit', 'cards_done', 'cards_hit',
        'markov_stages', 'markov_output', 'markov_prob',
        'markov_bits_main', 'markov_bits_aux',  # Separate words
        'card_number', 'is_hit', 'run_hits', 'trial_number',
        'timestamp', 'image_filename', 'target_image', 'extra'
    ]

    COLUMNS_UNIFIED = [
        'user_id', 'target_bit', 'cards_done', 'cards_hit',
        'markov_stages', 'markov_output', 'markov_prob',
        'markov_bits_main', 'markov_bits_aux',
        'card_number', 'is_hit', 'run_hits', 'trial_number',
        'timestamp', 'image_filename', 'target_image',
        'file_date', 'schema_version', 'source_file', 'source_row_number'
    ]

    def __init__(self, config: Config):
        """
        Initialize CardD processor.
        Args:
            config: Configuration object
        """
        super().__init__(config, 'cardd')

        # Initialize cleaners
        self.encoding_cleaner = EncodingCleaner(config, self.errata_logger)
        self.delimiter_cleaner = DelimiterCleaner(config, self.errata_logger)
        self.temporal_parser = TemporalParser(config, self.errata_logger)

        # Statistics
        self.stats = {
            'files_processed': 0,
            'files_failed': 0,
            'rows_total': 0,
            'rows_valid': 0,
            'rows_invalid': 0,
            'schema_v1_files': 0,
            'schema_v2_files': 0
        }

    def extract_file_date(self, file_path: Path) -> Optional[datetime]:
        """
        Extract date from filename (cardDYYMMDD.dat).
        Args:
            file_path: Path to file
        Returns:
            datetime object or None
        """
        match = re.search(r'cardD(\d{6})\.dat', file_path.name)
        if not match:
            return None

        date_str = match.group(1)
        return self.temporal_parser.extract_date_from_filename(file_path.name)

    def detect_schema_version(self, file_path: Path, df: pd.DataFrame) -> tuple:
        """
        Detect schema version based on file date and column count distribution.
        Checks first, middle, and last rows to detect mixed schemas.
        Args:
            file_path: Path to file
            df: DataFrame with raw data (no headers)
        Returns:
            Tuple of (primary_version, is_mixed)
            - primary_version: 'v1' or 'v2'
            - is_mixed: True if file contains both schemas
        """
        file_date = self.extract_file_date(file_path)

        # Make schema change date timezone-aware for comparison
        schema_change_aware = self.temporal_parser.timezone.localize(self.SCHEMA_CHANGE_DATE)

        # Check column count distribution across sample rows
        sample_indices = [0, len(df) // 2, len(df) - 1] if len(df) > 2 else [0]
        column_counts = []

        for idx in sample_indices:
            if idx < len(df):
                # Count non-null columns in this row
                col_count = df.iloc[idx].notna().sum()
                column_counts.append(col_count)

        unique_counts = set(column_counts)
        is_mixed = len(unique_counts) > 1

        # Determine primary version
        max_col_count = max(column_counts)

        if file_date and file_date >= schema_change_aware:
            primary_version = 'v2'
        elif max_col_count >= 15:  # v2 has >= 15 columns (separate Mbits0 and Mbits1)
            primary_version = 'v2'
        else:
            primary_version = 'v1'

        return primary_version, is_mixed

    def unpack_markov_bits_old(self, combined: int, n_stages: int) -> tuple:
        """
        Unpack combined Markov bits (old format).
        In old format, both main and aux chains stored in one 32-bit word:
        - Main chain: lower n_stages bits
        - Aux chain: next n_stages bits
        Args:
            combined: Combined 32-bit value
            n_stages: Number of Markov stages
        Returns:
            Tuple of (main_bits, aux_bits)
        """
        mask = (1 << n_stages) - 1
        main_bits = combined & mask
        aux_bits = (combined >> n_stages) & mask
        return main_bits, aux_bits

    def _process_mixed_schema_file(self, df: pd.DataFrame, file_path: Path) -> Optional[pd.DataFrame]:
        """
        Process a file with mixed schema versions (row-by-row).
        Args:
            df: Raw DataFrame with no headers
            file_path: Source file path
        Returns:
            Processed DataFrame or None
        """
        processed_rows = []
        file_date = self.extract_file_date(file_path)

        for idx, row in df.iterrows():
            try:
                # Count non-null columns to detect schema
                col_count = row.notna().sum()

                # Determine schema for this row
                if col_count >= 15:
                    # v2 schema (new format with separate Markov bits)
                    schema = 'v2'
                    columns = self.COLUMNS_NEW[:col_count]
                elif col_count >= 14:
                    # v1 schema (old format with combined Markov bits)
                    schema = 'v1'
                    columns = self.COLUMNS_OLD[:col_count]
                else:
                    # Insufficient columns, skip row
                    continue

                # Create dict for this row
                row_dict = {}
                for i, col_name in enumerate(columns):
                    if i < len(row):
                        row_dict[col_name] = row.iloc[i]

                # Handle old format: unpack combined Markov bits
                if schema == 'v1' and 'markov_bits_combined' in row_dict:
                    try:
                        n_stages = int(row_dict.get('markov_stages', 0))
                        combined = int(row_dict['markov_bits_combined'])
                        main_bits, aux_bits = self.unpack_markov_bits_old(combined, n_stages)
                        row_dict['markov_bits_main'] = main_bits
                        row_dict['markov_bits_aux'] = aux_bits
                        del row_dict['markov_bits_combined']
                    except (ValueError, TypeError):
                        # Skip row if unpacking fails
                        continue

                # Add metadata
                row_dict['file_date'] = file_date
                row_dict['schema_version'] = schema

                # Add audit columns (source file and row numbers)
                row_dict['source_file'] = file_path.name
                row_dict['source_row_number'] = idx + 1

                # Remove 'extra' column if present
                if 'extra' in row_dict:
                    del row_dict['extra']

                processed_rows.append(row_dict)

            except Exception as e:
                import traceback
                self.errata_logger.log_error(
                    'row_processing_failed',
                    f'Row {idx}: {type(e).__name__}: {e}',
                    file_path=str(file_path),
                    scope='row',
                    line_number=idx,
                    context={'traceback': traceback.format_exc()},
                )
                continue

        if not processed_rows:
            return None

        # Create DataFrame from processed rows
        result_df = pd.DataFrame(processed_rows)

        # Validate and clean
        result_df = self.validate_dataframe(result_df, file_path)

        # Ensure all unified columns exist AFTER validation
        for col in self.COLUMNS_UNIFIED:
            if col not in result_df.columns:
                result_df[col] = None

        # Reorder to unified schema
        result_df = result_df[self.COLUMNS_UNIFIED]

        return result_df

    def process_file(self, file_path: Path, pre_cleaned_text: Optional[str] = None) -> Optional[pd.DataFrame]:
        """
        Process a single CardD file.
        Args:
            file_path: Path to file
            pre_cleaned_text: Pre-cleaned text from parallel batch cleaning.
                If None, cleans the file inline (backward compat).
        Returns:
            DataFrame or None if processing fails
        """
        try:
            # Use pre-cleaned text if available, otherwise clean inline
            if pre_cleaned_text is not None:
                text = pre_cleaned_text
            else:
                text = self.encoding_cleaner.clean(file_path)
                text = self.delimiter_cleaner.clean(text, file_path=str(file_path))

            # Pre-validate lines so bad rows are logged before being removed
            text = self.pre_validate_csv_lines(text, file_path=str(file_path))

            from io import BytesIO
            df = pd.read_csv(BytesIO(text.encode('utf-8')), header=None, on_bad_lines='skip', engine='pyarrow')

            if df.empty:
                self.errata_logger.log_error(
                    'empty_file',
                    'File is empty or has no valid rows - entire file omitted',
                    file_path=str(file_path),
                    scope='file'
                )
                return None

            # Detect schema version and check for mixed schemas
            schema_version, is_mixed = self.detect_schema_version(file_path, df)

            if is_mixed:
                self.errata_logger.log_error(
                    'mixed_schema_detected',
                    f'File contains mixed schema versions (v1 and v2)',
                    file_path=str(file_path),
                    scope='row'
                )
                # Process row-by-row for mixed schema files
                return self._process_mixed_schema_file(df, file_path)

            # Single schema processing (original logic)
            column_count = len(df.columns)

            # Assign column names
            if schema_version == 'v1':
                if column_count >= 14:
                    df.columns = self.COLUMNS_OLD[:column_count]
                    self.stats['schema_v1_files'] += 1
                else:
                    self.errata_logger.log_error(
                        'insufficient_columns',
                        f'Too few columns: {column_count} - entire file omitted',
                        file_path=str(file_path),
                        scope='file'
                    )
                    return None
            else:  # v2
                if column_count >= 15:
                    df.columns = self.COLUMNS_NEW[:column_count]
                    self.stats['schema_v2_files'] += 1
                else:
                    self.errata_logger.log_error(
                        'insufficient_columns',
                        f'Too few columns: {column_count} - entire file omitted',
                        file_path=str(file_path),
                        scope='file'
                    )
                    return None

            # Unpack Markov bits for old format
            if schema_version == 'v1' and 'markov_bits_combined' in df.columns:
                df[['markov_bits_main', 'markov_bits_aux']] = df.apply(
                    lambda row: pd.Series(
                        self.unpack_markov_bits_old(
                            row['markov_bits_combined'],
                            row['markov_stages']
                        )
                    ),
                    axis=1
                )
                df = df.drop(columns=['markov_bits_combined'])

            # Add metadata
            file_date = self.extract_file_date(file_path)
            df['file_date'] = file_date
            df['schema_version'] = schema_version

            # Add audit columns (source file and row numbers)
            df['source_file'] = file_path.name
            df['source_row_number'] = range(1, len(df) + 1)

            # Remove 'extra' column if present (not needed in unified schema)
            if 'extra' in df.columns:
                df = df.drop(columns=['extra'])

            # Validate and clean
            df = self.validate_dataframe(df, file_path)

            # Ensure all unified columns exist AFTER validation
            for col in self.COLUMNS_UNIFIED:
                if col not in df.columns:
                    df[col] = None

            # Reorder to unified schema
            df = df[self.COLUMNS_UNIFIED]

            self.stats['files_processed'] += 1
            self.stats['rows_valid'] += len(df)
            return df

        except Exception as e:
            import traceback
            self.errata_logger.log_error(
                'file_processing_failed',
                f'{type(e).__name__}: {e} - entire file omitted',
                file_path=str(file_path),
                scope='file',
                context={'traceback': traceback.format_exc()},
            )
            return None

    def validate_dataframe(self, df: pd.DataFrame, file_path: Path) -> pd.DataFrame:
        """
        Validate and clean DataFrame.
        Args:
            df: Input DataFrame
            file_path: Source file path
        Returns:
            Cleaned DataFrame
        """
        initial_count = len(df)
        valid_mask = pd.Series([True] * len(df), index=df.index)


        # Validate user_id length
        long_users = df['user_id'].str.len() > 64
        if long_users.any():
            valid_mask &= ~long_users
            self.errata_logger.log_error(
                'user_id_too_long',
                f'{long_users.sum()} rows with user_id > 64 chars',
                file_path=str(file_path),
                scope='row'
            )

        # Validate card_number range (0-4)
        if 'card_number' in df.columns:
            df['card_number'] = self.to_numeric_logged(df['card_number'], 'card_number', str(file_path))
            invalid_card = (df['card_number'] < 0) | (df['card_number'] > 4)
            if invalid_card.any():
                valid_mask &= ~invalid_card
                self.errata_logger.log_error(
                    'card_number_out_of_range',
                    f'{invalid_card.sum()} rows with card_number not in 0-4',
                    file_path=str(file_path),
                    scope='row'
                )

        # Validate trial_number (must be >= 1, no upper limit since trperrun is configurable)
        if 'trial_number' in df.columns:
            df['trial_number'] = self.to_numeric_logged(df['trial_number'], 'trial_number', str(file_path))
            invalid_trial = (df['trial_number'] < 1)
            if invalid_trial.any():
                valid_mask &= ~invalid_trial
                self.errata_logger.log_error(
                    'trial_number_invalid',
                    f'{invalid_trial.sum()} rows with trial_number < 1',
                    file_path=str(file_path),
                    scope='row'
                )

        # Validate cards_done/cards_hit
        for col in ['cards_done', 'cards_hit']:
            if col in df.columns:
                df[col] = self.to_numeric_logged(df[col], col, str(file_path))
                invalid = (df[col] < 0) | (df[col] > 5)
                if invalid.any():
                    valid_mask &= ~invalid

        # Parse timestamps
        if 'timestamp' in df.columns:
            df['timestamp'] = self.temporal_parser.parse_dates_vectorized(
                df['timestamp'], file_path=str(file_path)
            )

        # Convert numeric columns
        numeric_cols = [
            'target_bit', 'cards_done', 'cards_hit', 'markov_stages',
            'markov_output', 'markov_prob', 'markov_bits_main', 'markov_bits_aux',
            'card_number', 'is_hit', 'run_hits', 'trial_number'
        ]

        for col in numeric_cols:
            if col in df.columns:
                df[col] = self.to_numeric_logged(df[col], col, str(file_path))

        # Filter to valid rows
        df_valid = df[valid_mask].copy()

        invalid_count = initial_count - len(df_valid)
        if invalid_count > 0:
            self.errata_logger.log_file_summary(
                str(file_path),
                'partial',
                initial_count,
                len(df_valid),
                invalid_count
            )

        return df_valid

    def get_stats(self) -> Dict[str, Any]:
        """Get processing statistics."""
        return self.stats.copy()

	"""
	CardD (Card Draw Test) dataset processor.

	Processes ESP card drawing test data with two schema versions:
	- Old format (pre 2006-06-22): 14-15 columns, combined Markov bits
	- New format (post 2006-06-22): 15-16 columns, separate Markov bits, optional image_filename
	"""

	from pathlib import Path
	from typing import List, Dict, Any, Optional
	from datetime import datetime
	import pandas as pd
	import re

	from ..core.base_classes import BaseProcessor
	from ..core.config import Config
	from ..core.exceptions import ProcessorError
	from ..cleaners.encoding_cleaner import EncodingCleaner
	from ..cleaners.delimiter_cleaner import DelimiterCleaner
	from ..cleaners.temporal_parser import TemporalParser


	class CardDProcessor(BaseProcessor):
	"""
	Processes CardD (Card Draw Test) data.

	Schema versions:
	- v1 (pre 2006-06-22): Markov bits combined in single 32-bit word
	- v2 (post 2006-06-22): Markov bits in separate words
	"""

	# File discovery patterns
	FILE_PATTERNS = ['cardD*.dat']

	# Schema change date
	SCHEMA_CHANGE_DATE = datetime(2006, 6, 22)

	# Column definitions
	COLUMNS_OLD = [
	'user_id', 'target_bit', 'cards_done', 'cards_hit',
	'markov_stages', 'markov_output', 'markov_prob',
	'markov_bits_combined', # Single word with both chains
	'card_number', 'is_hit', 'run_hits', 'trial_number',
	'timestamp', 'target_image', 'extra'
	]

	COLUMNS_NEW = [
	'user_id', 'target_bit', 'cards_done', 'cards_hit',
	'markov_stages', 'markov_output', 'markov_prob',
	'markov_bits_main', 'markov_bits_aux', # Separate words
	'card_number', 'is_hit', 'run_hits', 'trial_number',
	'timestamp', 'image_filename', 'target_image', 'extra'
	]

	COLUMNS_UNIFIED = [
	'user_id', 'target_bit', 'cards_done', 'cards_hit',
	'markov_stages', 'markov_output', 'markov_prob',
	'markov_bits_main', 'markov_bits_aux',
	'card_number', 'is_hit', 'run_hits', 'trial_number',
	'timestamp', 'image_filename', 'target_image',
	'file_date', 'schema_version', 'source_file', 'source_row_number'
	]

	def __init__(self, config: Config):
	"""
	Initialize CardD processor.

	Args:
	config: Configuration object
	"""
	super().__init__(config, 'cardd')

	# Initialize cleaners
	self.encoding_cleaner = EncodingCleaner(config, self.errata_logger)
	self.delimiter_cleaner = DelimiterCleaner(config, self.errata_logger)
	self.temporal_parser = TemporalParser(config, self.errata_logger)

	# Statistics
	self.stats = {
	'files_processed': 0,
	'files_failed': 0,
	'rows_total': 0,
	'rows_valid': 0,
	'rows_invalid': 0,
	'schema_v1_files': 0,
	'schema_v2_files': 0
	}

	def extract_file_date(self, file_path: Path) -> Optional[datetime]:
	"""
	Extract date from filename (cardDYYMMDD.dat).

	Args:
	file_path: Path to file

	Returns:
	datetime object or None
	"""
	match = re.search(r'cardD(\d{6})\.dat', file_path.name)
	if not match:
	return None

	date_str = match.group(1)
	return self.temporal_parser.extract_date_from_filename(file_path.name)

	def detect_schema_version(self, file_path: Path, df: pd.DataFrame) -> tuple:
	"""
	Detect schema version based on file date and column count distribution.

	Checks first, middle, and last rows to detect mixed schemas.

	Args:
	file_path: Path to file
	df: DataFrame with raw data (no headers)

	Returns:
	Tuple of (primary_version, is_mixed)
	- primary_version: 'v1' or 'v2'
	- is_mixed: True if file contains both schemas
	"""
	file_date = self.extract_file_date(file_path)

	# Make schema change date timezone-aware for comparison
	schema_change_aware = self.temporal_parser.timezone.localize(self.SCHEMA_CHANGE_DATE)

	# Check column count distribution across sample rows
	sample_indices = [0, len(df) // 2, len(df) - 1] if len(df) > 2 else [0]
	column_counts = []

	for idx in sample_indices:
	if idx < len(df):
	# Count non-null columns in this row
	col_count = df.iloc[idx].notna().sum()
	column_counts.append(col_count)

	unique_counts = set(column_counts)
	is_mixed = len(unique_counts) > 1

	# Determine primary version
	max_col_count = max(column_counts)

	if file_date and file_date >= schema_change_aware:
	primary_version = 'v2'
	elif max_col_count >= 15: # v2 has >= 15 columns (separate Mbits0 and Mbits1)
	primary_version = 'v2'
	else:
	primary_version = 'v1'

	return primary_version, is_mixed

	def unpack_markov_bits_old(self, combined: int, n_stages: int) -> tuple:
	"""
	Unpack combined Markov bits (old format).

	In old format, both main and aux chains stored in one 32-bit word:
	- Main chain: lower n_stages bits
	- Aux chain: next n_stages bits

	Args:
	combined: Combined 32-bit value
	n_stages: Number of Markov stages

	Returns:
	Tuple of (main_bits, aux_bits)
	"""
	mask = (1 << n_stages) - 1
	main_bits = combined & mask
	aux_bits = (combined >> n_stages) & mask
	return main_bits, aux_bits

	def _process_mixed_schema_file(self, df: pd.DataFrame, file_path: Path) -> Optional[pd.DataFrame]:
	"""
	Process a file with mixed schema versions (row-by-row).

	Args:
	df: Raw DataFrame with no headers
	file_path: Source file path

	Returns:
	Processed DataFrame or None
	"""
	processed_rows = []
	file_date = self.extract_file_date(file_path)

	for idx, row in df.iterrows():
	try:
	# Count non-null columns to detect schema
	col_count = row.notna().sum()

	# Determine schema for this row
	if col_count >= 15:
	# v2 schema (new format with separate Markov bits)
	schema = 'v2'
	columns = self.COLUMNS_NEW[:col_count]
	elif col_count >= 14:
	# v1 schema (old format with combined Markov bits)
	schema = 'v1'
	columns = self.COLUMNS_OLD[:col_count]
	else:
	# Insufficient columns, skip row
	continue

	# Create dict for this row
	row_dict = {}
	for i, col_name in enumerate(columns):
	if i < len(row):
	row_dict[col_name] = row.iloc[i]

	# Handle old format: unpack combined Markov bits
	if schema == 'v1' and 'markov_bits_combined' in row_dict:
	try:
	n_stages = int(row_dict.get('markov_stages', 0))
	combined = int(row_dict['markov_bits_combined'])
	main_bits, aux_bits = self.unpack_markov_bits_old(combined, n_stages)
	row_dict['markov_bits_main'] = main_bits
	row_dict['markov_bits_aux'] = aux_bits
	del row_dict['markov_bits_combined']
	except (ValueError, TypeError):
	# Skip row if unpacking fails
	continue

	# Add metadata
	row_dict['file_date'] = file_date
	row_dict['schema_version'] = schema

	# Add audit columns (source file and row numbers)
	row_dict['source_file'] = file_path.name
	row_dict['source_row_number'] = idx + 1

	# Remove 'extra' column if present
	if 'extra' in row_dict:
	del row_dict['extra']

	processed_rows.append(row_dict)

	except Exception as e:
	import traceback
	self.errata_logger.log_error(
	'row_processing_failed',
	f'Row {idx}: {type(e).__name__}: {e}',
	file_path=str(file_path),
	scope='row',
	line_number=idx,
	context={'traceback': traceback.format_exc()},
	)
	continue

	if not processed_rows:
	return None

	# Create DataFrame from processed rows
	result_df = pd.DataFrame(processed_rows)

	# Validate and clean
	result_df = self.validate_dataframe(result_df, file_path)

	# Ensure all unified columns exist AFTER validation
	for col in self.COLUMNS_UNIFIED:
	if col not in result_df.columns:
	result_df[col] = None

	# Reorder to unified schema
	result_df = result_df[self.COLUMNS_UNIFIED]

	return result_df

	def process_file(self, file_path: Path, pre_cleaned_text: Optional[str] = None) -> Optional[pd.DataFrame]:
	"""
	Process a single CardD file.

	Args:
	file_path: Path to file
	pre_cleaned_text: Pre-cleaned text from parallel batch cleaning.
	If None, cleans the file inline (backward compat).

	Returns:
	DataFrame or None if processing fails
	"""
	try:
	# Use pre-cleaned text if available, otherwise clean inline
	if pre_cleaned_text is not None:
	text = pre_cleaned_text
	else:
	text = self.encoding_cleaner.clean(file_path)
	text = self.delimiter_cleaner.clean(text, file_path=str(file_path))

	# Pre-validate lines so bad rows are logged before being removed
	text = self.pre_validate_csv_lines(text, file_path=str(file_path))

	from io import BytesIO
	df = pd.read_csv(BytesIO(text.encode('utf-8')), header=None, on_bad_lines='skip', engine='pyarrow')

	if df.empty:
	self.errata_logger.log_error(
	'empty_file',
	'File is empty or has no valid rows - entire file omitted',
	file_path=str(file_path),
	scope='file'
	)
	return None

	# Detect schema version and check for mixed schemas
	schema_version, is_mixed = self.detect_schema_version(file_path, df)

	if is_mixed:
	self.errata_logger.log_error(
	'mixed_schema_detected',
	f'File contains mixed schema versions (v1 and v2)',
	file_path=str(file_path),
	scope='row'
	)
	# Process row-by-row for mixed schema files
	return self._process_mixed_schema_file(df, file_path)

	# Single schema processing (original logic)
	column_count = len(df.columns)

	# Assign column names
	if schema_version == 'v1':
	if column_count >= 14:
	df.columns = self.COLUMNS_OLD[:column_count]
	self.stats['schema_v1_files'] += 1
	else:
	self.errata_logger.log_error(
	'insufficient_columns',
	f'Too few columns: {column_count} - entire file omitted',
	file_path=str(file_path),
	scope='file'
	)
	return None
	else: # v2
	if column_count >= 15:
	df.columns = self.COLUMNS_NEW[:column_count]
	self.stats['schema_v2_files'] += 1
	else:
	self.errata_logger.log_error(
	'insufficient_columns',
	f'Too few columns: {column_count} - entire file omitted',
	file_path=str(file_path),
	scope='file'
	)
	return None

	# Unpack Markov bits for old format
	if schema_version == 'v1' and 'markov_bits_combined' in df.columns:
	df[['markov_bits_main', 'markov_bits_aux']] = df.apply(
	lambda row: pd.Series(
	self.unpack_markov_bits_old(
	row['markov_bits_combined'],
	row['markov_stages']
	)
	),
	axis=1
	)
	df = df.drop(columns=['markov_bits_combined'])

	# Add metadata
	file_date = self.extract_file_date(file_path)
	df['file_date'] = file_date
	df['schema_version'] = schema_version

	# Add audit columns (source file and row numbers)
	df['source_file'] = file_path.name
	df['source_row_number'] = range(1, len(df) + 1)

	# Remove 'extra' column if present (not needed in unified schema)
	if 'extra' in df.columns:
	df = df.drop(columns=['extra'])

	# Validate and clean
	df = self.validate_dataframe(df, file_path)

	# Ensure all unified columns exist AFTER validation
	for col in self.COLUMNS_UNIFIED:
	if col not in df.columns:
	df[col] = None

	# Reorder to unified schema
	df = df[self.COLUMNS_UNIFIED]

	self.stats['files_processed'] += 1
	self.stats['rows_valid'] += len(df)
	return df

	except Exception as e:
	import traceback
	self.errata_logger.log_error(
	'file_processing_failed',
	f'{type(e).__name__}: {e} - entire file omitted',
	file_path=str(file_path),
	scope='file',
	context={'traceback': traceback.format_exc()},
	)
	return None

	def validate_dataframe(self, df: pd.DataFrame, file_path: Path) -> pd.DataFrame:
	"""
	Validate and clean DataFrame.

	Args:
	df: Input DataFrame
	file_path: Source file path

	Returns:
	Cleaned DataFrame
	"""
	initial_count = len(df)
	valid_mask = pd.Series([True] * len(df), index=df.index)


	# Validate user_id length
	long_users = df['user_id'].str.len() > 64
	if long_users.any():
	valid_mask &= ~long_users
	self.errata_logger.log_error(
	'user_id_too_long',
	f'{long_users.sum()} rows with user_id > 64 chars',
	file_path=str(file_path),
	scope='row'
	)

	# Validate card_number range (0-4)
	if 'card_number' in df.columns:
	df['card_number'] = self.to_numeric_logged(df['card_number'], 'card_number', str(file_path))
	invalid_card = (df['card_number'] < 0) \| (df['card_number'] > 4)
	if invalid_card.any():
	valid_mask &= ~invalid_card
	self.errata_logger.log_error(
	'card_number_out_of_range',
	f'{invalid_card.sum()} rows with card_number not in 0-4',
	file_path=str(file_path),
	scope='row'
	)

	# Validate trial_number (must be >= 1, no upper limit since trperrun is configurable)
	if 'trial_number' in df.columns:
	df['trial_number'] = self.to_numeric_logged(df['trial_number'], 'trial_number', str(file_path))
	invalid_trial = (df['trial_number'] < 1)
	if invalid_trial.any():
	valid_mask &= ~invalid_trial
	self.errata_logger.log_error(
	'trial_number_invalid',
	f'{invalid_trial.sum()} rows with trial_number < 1',
	file_path=str(file_path),
	scope='row'
	)

	# Validate cards_done/cards_hit
	for col in ['cards_done', 'cards_hit']:
	if col in df.columns:
	df[col] = self.to_numeric_logged(df[col], col, str(file_path))
	invalid = (df[col] < 0) \| (df[col] > 5)
	if invalid.any():
	valid_mask &= ~invalid

	# Parse timestamps
	if 'timestamp' in df.columns:
	df['timestamp'] = self.temporal_parser.parse_dates_vectorized(
	df['timestamp'], file_path=str(file_path)
	)

	# Convert numeric columns
	numeric_cols = [
	'target_bit', 'cards_done', 'cards_hit', 'markov_stages',
	'markov_output', 'markov_prob', 'markov_bits_main', 'markov_bits_aux',
	'card_number', 'is_hit', 'run_hits', 'trial_number'
	]

	for col in numeric_cols:
	if col in df.columns:
	df[col] = self.to_numeric_logged(df[col], col, str(file_path))

	# Filter to valid rows
	df_valid = df[valid_mask].copy()

	invalid_count = initial_count - len(df_valid)
	if invalid_count > 0:
	self.errata_logger.log_file_summary(
	str(file_path),
	'partial',
	initial_count,
	len(df_valid),
	invalid_count
	)

	return df_valid

	def get_stats(self) -> Dict[str, Any]:
	"""Get processing statistics."""
	return self.stats.copy()