GotPsi / src /processors /rv_processor.py

instNoeticSciences

claude opus 4.6

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

9deebf2 5 months ago

12.6 kB

"""
RV (Full Remote Viewing) dataset processor.
Processes remote viewing test data with dimensional attribute scoring.
Format: 24-29 columns with user, timestamps, image info, 16 attribute scores,
accuracy/relevance/form metrics, total score, keywords, and trial info.
More complex than RVQ - uses continuous scoring (0-100) instead of binary hit/miss.
"""

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 RVProcessor(BaseProcessor):
    """
    Processes RV (Full Remote Viewing) data.
    Format: 24-29 columns
    - user_id, start_time, end_time, image_filename, image_number,
    - 16 attribute scores (sr[0] through sr[15]),
    - accuracy, relevance, form, total_score,
    - keywords, trial_number, method, num_keyword_matches
    Users view a target image and describe it using dimensional attributes
    (rounded/angular, linear, etc.). Scores based on how well description
    matches the actual image attributes.
    """

    # File discovery patterns
    FILE_PATTERNS = ['rv[0-9]*.dat']

    # Attribute score column names (16 attributes)
    ATTRIBUTE_COLUMNS = [f'attr_{i:02d}' for i in range(16)]

    # Column definitions
    COLUMNS_BASE = [
        'user_id', 'start_time', 'end_time', 'image_filename', 'image_number'
    ] + ATTRIBUTE_COLUMNS + [
        'accuracy', 'relevance', 'form', 'total_score',
        'keywords', 'trial_number', 'method', 'num_keyword_matches'
    ]

    COLUMNS_UNIFIED = [
        'user_id', 'start_time', 'end_time',
        'image_filename', 'image_number'
    ] + ATTRIBUTE_COLUMNS + [
        'accuracy', 'relevance', 'form', 'total_score',
        'keywords', 'trial_number', 'method', 'num_keyword_matches',
        'file_date', 'source_file', 'source_row_number'
    ]

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

        # 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,
            'method_original': 0,
            'method_match_judges': 0,
            'method_keywords': 0
        }

    def extract_file_date(self, file_path: Path) -> Optional[datetime]:
        """
        Extract date from filename (rvYYMMDD.dat).
        Args:
            file_path: Path to file
        Returns:
            datetime object or None
        """
        match = re.search(r'rv(\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 process_file(self, file_path: Path, pre_cleaned_text: Optional[str] = None) -> Optional[pd.DataFrame]:
        """
        Process a single RV 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))

            # Parse as CSV using Python's csv module to handle variable columns
            from io import StringIO
            import csv

            reader = csv.reader(StringIO(text), skipinitialspace=True)
            rows = list(reader)

            if not rows:
                self.errata_logger.log_error(
                    'empty_file',
                    'File is empty after CSV parsing - entire file omitted',
                    file_path=str(file_path),
                    scope='file'
                )
                return None

            # Convert to DataFrame
            df = pd.DataFrame(rows)

            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

            # Check minimum column count (24)
            column_counts = df.notna().sum(axis=1)
            insufficient_cols = column_counts < 24

            if insufficient_cols.all():
                self.errata_logger.log_error(
                    'insufficient_columns',
                    'All rows have < 24 columns - entire file omitted',
                    file_path=str(file_path),
                    scope='file'
                )
                return None

            # Filter rows with insufficient columns
            if insufficient_cols.any():
                self.errata_logger.log_error(
                    'insufficient_columns',
                    f'{insufficient_cols.sum()} rows with < 24 columns',
                    file_path=str(file_path),
                    scope='row'
                )
                df = df[~insufficient_cols]

            # Assign column names based on actual column count
            max_cols = len(df.columns)
            if max_cols >= 29:
                # Drop extra columns if more than 29 (early files have extra columns)
                if max_cols > 29:
                    # Log that we're dropping extra columns from early files
                    self.errata_logger.log_error(
                        'extra_columns_dropped',
                        f'File has {max_cols} columns, dropping {max_cols - 29} extra columns from early schema',
                        file_path=str(file_path),
                        scope='row'
                    )
                    df = df.iloc[:, :29]
                df.columns = self.COLUMNS_BASE[:29]
            elif max_cols >= 24:
                df.columns = self.COLUMNS_BASE[:max_cols]
            else:
                self.errata_logger.log_error(
                    'insufficient_columns',
                    f'Max columns {max_cols} < 24 - entire file omitted',
                    file_path=str(file_path),
                    scope='file'
                )
                return None

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

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

            # Filter test users
            test_user_mask = df['user_id'].astype(str).str.contains('_test9', na=False)
            if test_user_mask.any():
                df = df[~test_user_mask]

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

            if df.empty:
                return None

            # 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]

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

            # Track method counts
            if 'method' in df.columns:
                method_counts = df['method'].value_counts()
                for method_val, count in method_counts.items():
                    if pd.notna(method_val):
                        method_val = int(method_val)
                        if method_val % 10 == 0:  # 0 or 10
                            self.stats['method_original'] += count
                        elif method_val % 10 == 3:  # 3 or 13
                            self.stats['method_match_judges'] += count
                        elif method_val == 9:
                            self.stats['method_keywords'] += count

            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()},
            )
            self.stats['files_failed'] += 1
            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
        if 'user_id' in df.columns:
            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 and clamp total_score (0-100)
        if 'total_score' in df.columns:
            df['total_score'] = self.to_numeric_logged(df['total_score'], 'total_score', str(file_path))
            # Clamp scores to 0-100 as per Perl code
            df.loc[df['total_score'] < 0, 'total_score'] = 0
            df.loc[df['total_score'] > 100, 'total_score'] = 100

        # Validate num_keyword_matches (0-5)
        if 'num_keyword_matches' in df.columns:
            df['num_keyword_matches'] = self.to_numeric_logged(df['num_keyword_matches'], 'num_keyword_matches', str(file_path))
            invalid_nwm = (df['num_keyword_matches'] < 0) | (df['num_keyword_matches'] > 5)
            if invalid_nwm.any():
                # Log but don't filter - just clamp
                self.errata_logger.log_error(
                    'num_keyword_matches_out_of_range',
                    f'{invalid_nwm.sum()} rows with num_keyword_matches not in 0-5',
                    file_path=str(file_path),
                    scope='row'
                )
                df.loc[df['num_keyword_matches'] < 0, 'num_keyword_matches'] = 0
                df.loc[df['num_keyword_matches'] > 5, 'num_keyword_matches'] = 5

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

        if 'end_time' in df.columns:
            df['end_time'] = self.temporal_parser.parse_dates_vectorized(
                df['end_time'], file_path=str(file_path)
            )

        # Convert numeric columns
        numeric_cols = [
            'image_number', 'accuracy', 'relevance', 'form', 'total_score',
            'trial_number', 'method', 'num_keyword_matches'
        ] + self.ATTRIBUTE_COLUMNS

        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()

	"""
	RV (Full Remote Viewing) dataset processor.

	Processes remote viewing test data with dimensional attribute scoring.
	Format: 24-29 columns with user, timestamps, image info, 16 attribute scores,
	accuracy/relevance/form metrics, total score, keywords, and trial info.

	More complex than RVQ - uses continuous scoring (0-100) instead of binary hit/miss.
	"""

	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 RVProcessor(BaseProcessor):
	"""
	Processes RV (Full Remote Viewing) data.

	Format: 24-29 columns
	- user_id, start_time, end_time, image_filename, image_number,
	- 16 attribute scores (sr[0] through sr[15]),
	- accuracy, relevance, form, total_score,
	- keywords, trial_number, method, num_keyword_matches

	Users view a target image and describe it using dimensional attributes
	(rounded/angular, linear, etc.). Scores based on how well description
	matches the actual image attributes.
	"""

	# File discovery patterns
	FILE_PATTERNS = ['rv[0-9]*.dat']

	# Attribute score column names (16 attributes)
	ATTRIBUTE_COLUMNS = [f'attr_{i:02d}' for i in range(16)]

	# Column definitions
	COLUMNS_BASE = [
	'user_id', 'start_time', 'end_time', 'image_filename', 'image_number'
	] + ATTRIBUTE_COLUMNS + [
	'accuracy', 'relevance', 'form', 'total_score',
	'keywords', 'trial_number', 'method', 'num_keyword_matches'
	]

	COLUMNS_UNIFIED = [
	'user_id', 'start_time', 'end_time',
	'image_filename', 'image_number'
	] + ATTRIBUTE_COLUMNS + [
	'accuracy', 'relevance', 'form', 'total_score',
	'keywords', 'trial_number', 'method', 'num_keyword_matches',
	'file_date', 'source_file', 'source_row_number'
	]

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

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

	# 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,
	'method_original': 0,
	'method_match_judges': 0,
	'method_keywords': 0
	}

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

	Args:
	file_path: Path to file

	Returns:
	datetime object or None
	"""
	match = re.search(r'rv(\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 process_file(self, file_path: Path, pre_cleaned_text: Optional[str] = None) -> Optional[pd.DataFrame]:
	"""
	Process a single RV 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))

	# Parse as CSV using Python's csv module to handle variable columns
	from io import StringIO
	import csv

	reader = csv.reader(StringIO(text), skipinitialspace=True)
	rows = list(reader)

	if not rows:
	self.errata_logger.log_error(
	'empty_file',
	'File is empty after CSV parsing - entire file omitted',
	file_path=str(file_path),
	scope='file'
	)
	return None

	# Convert to DataFrame
	df = pd.DataFrame(rows)

	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

	# Check minimum column count (24)
	column_counts = df.notna().sum(axis=1)
	insufficient_cols = column_counts < 24

	if insufficient_cols.all():
	self.errata_logger.log_error(
	'insufficient_columns',
	'All rows have < 24 columns - entire file omitted',
	file_path=str(file_path),
	scope='file'
	)
	return None

	# Filter rows with insufficient columns
	if insufficient_cols.any():
	self.errata_logger.log_error(
	'insufficient_columns',
	f'{insufficient_cols.sum()} rows with < 24 columns',
	file_path=str(file_path),
	scope='row'
	)
	df = df[~insufficient_cols]

	# Assign column names based on actual column count
	max_cols = len(df.columns)
	if max_cols >= 29:
	# Drop extra columns if more than 29 (early files have extra columns)
	if max_cols > 29:
	# Log that we're dropping extra columns from early files
	self.errata_logger.log_error(
	'extra_columns_dropped',
	f'File has {max_cols} columns, dropping {max_cols - 29} extra columns from early schema',
	file_path=str(file_path),
	scope='row'
	)
	df = df.iloc[:, :29]
	df.columns = self.COLUMNS_BASE[:29]
	elif max_cols >= 24:
	df.columns = self.COLUMNS_BASE[:max_cols]
	else:
	self.errata_logger.log_error(
	'insufficient_columns',
	f'Max columns {max_cols} < 24 - entire file omitted',
	file_path=str(file_path),
	scope='file'
	)
	return None

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

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

	# Filter test users
	test_user_mask = df['user_id'].astype(str).str.contains('_test9', na=False)
	if test_user_mask.any():
	df = df[~test_user_mask]

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

	if df.empty:
	return None

	# 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]

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

	# Track method counts
	if 'method' in df.columns:
	method_counts = df['method'].value_counts()
	for method_val, count in method_counts.items():
	if pd.notna(method_val):
	method_val = int(method_val)
	if method_val % 10 == 0: # 0 or 10
	self.stats['method_original'] += count
	elif method_val % 10 == 3: # 3 or 13
	self.stats['method_match_judges'] += count
	elif method_val == 9:
	self.stats['method_keywords'] += count

	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()},
	)
	self.stats['files_failed'] += 1
	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
	if 'user_id' in df.columns:
	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 and clamp total_score (0-100)
	if 'total_score' in df.columns:
	df['total_score'] = self.to_numeric_logged(df['total_score'], 'total_score', str(file_path))
	# Clamp scores to 0-100 as per Perl code
	df.loc[df['total_score'] < 0, 'total_score'] = 0
	df.loc[df['total_score'] > 100, 'total_score'] = 100

	# Validate num_keyword_matches (0-5)
	if 'num_keyword_matches' in df.columns:
	df['num_keyword_matches'] = self.to_numeric_logged(df['num_keyword_matches'], 'num_keyword_matches', str(file_path))
	invalid_nwm = (df['num_keyword_matches'] < 0) \| (df['num_keyword_matches'] > 5)
	if invalid_nwm.any():
	# Log but don't filter - just clamp
	self.errata_logger.log_error(
	'num_keyword_matches_out_of_range',
	f'{invalid_nwm.sum()} rows with num_keyword_matches not in 0-5',
	file_path=str(file_path),
	scope='row'
	)
	df.loc[df['num_keyword_matches'] < 0, 'num_keyword_matches'] = 0
	df.loc[df['num_keyword_matches'] > 5, 'num_keyword_matches'] = 5

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

	if 'end_time' in df.columns:
	df['end_time'] = self.temporal_parser.parse_dates_vectorized(
	df['end_time'], file_path=str(file_path)
	)

	# Convert numeric columns
	numeric_cols = [
	'image_number', 'accuracy', 'relevance', 'form', 'total_score',
	'trial_number', 'method', 'num_keyword_matches'
	] + self.ATTRIBUTE_COLUMNS

	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()