Datasets:

Quivr
/

CRAG

import os
import hashlib
import bz2
import json
import subprocess
from typing import Dict, List, Optional, Any
import pandas as pd
import numpy as np
from multiprocessing import Pool, cpu_count
from sklearn.model_selection import StratifiedKFold


def get_cache_path(file_path: str, required_fields: List[str]) -> str:
    """
    Generate a unique cache file path based on input file and fields.
    Args:
        file_path: Path to the input JSONL file
        required_fields: List of field names to extract
    Returns:
        Path to the cache file
    """
    # Create a unique hash based on the file path and fields
    fields_str = ",".join(sorted(required_fields))
    hash_input = f"{fields_str}"
    hash_str = hashlib.md5(hash_input.encode()).hexdigest()[:10]

    # Get the directory of the input file
    base_dir = os.path.dirname(file_path)
    # Get filename from file path
    file_name = os.path.basename(file_path).split(".")[0]
    cache_name = f"{file_name}_cache_{hash_str}.parquet"
    return os.path.join(base_dir, cache_name)


def read_jsonl_fields_fast(
    file_path: str, required_fields: List[str], use_cache: bool = True
) -> pd.DataFrame:
    """
    Quickly extract specific fields from a compressed JSONL file using string operations.
    Results are cached in parquet format for faster subsequent reads.
    Args:
        file_path: Path to the JSONL file (can be bz2 compressed)
        required_fields: List of field names to extract from each JSON object
        use_cache: Whether to use/create cache file (default: True)
    Returns:
        DataFrame containing the requested fields
    """
    cache_path = get_cache_path(file_path, required_fields)
    print(f"Cache path: {cache_path}")
    # Try to load from cache first
    if use_cache and os.path.exists(cache_path):
        return pd.read_parquet(cache_path)

    # If no cache exists, process the file
    records = []
    patterns = [f'"{field}":' for field in required_fields]

    with bz2.open(file_path, "rt") as file:
        for line in file:
            if not line.strip():
                continue

            result = {}
            for field, pattern in zip(required_fields, patterns):
                try:
                    # Find the field in the line
                    start_idx = line.find(pattern)
                    if start_idx == -1:
                        continue

                    # Move to the start of the value
                    start_idx += len(pattern)
                    while start_idx < len(line) and line[start_idx].isspace():
                        start_idx += 1

                    # Handle different value types
                    if start_idx >= len(line):
                        continue

                    if line[start_idx] == '"':
                        # String value
                        start_idx += 1
                        end_idx = line.find('"', start_idx)
                        value = line[start_idx:end_idx]
                    elif line[start_idx] == "{" or line[start_idx] == "[":
                        # Skip nested objects/arrays
                        continue
                    else:
                        # Number, boolean, or null
                        end_idx = line.find(",", start_idx)
                        if end_idx == -1:
                            end_idx = line.find("}", start_idx)
                        value = line[start_idx:end_idx].strip()
                        # Convert to appropriate type
                        if value == "true":
                            value = True
                        elif value == "false":
                            value = False
                        elif value == "null":
                            value = None
                        else:
                            try:
                                value = float(value) if "." in value else int(value)
                            except ValueError:
                                continue

                    result[field] = value
                except Exception:
                    continue

            if result:
                records.append(result)

    # Convert to DataFrame
    df = pd.DataFrame.from_records(records)

    # Convert columns to appropriate types
    for col in df.columns:
        # If the column contains any strings, convert the whole column to strings
        if (
            df[col].dtype == object
            and df[col].apply(lambda x: isinstance(x, str)).any()
        ):
            df[col] = df[col].astype(str)
        # You can add more type conversions here if needed

    # Save cache if enabled
    if use_cache:
        df.to_parquet(cache_path)

    return df


def process_answer_types(df: pd.DataFrame) -> pd.DataFrame:
    """
    Process the answer field to create a new answer_type field.
    Args:
        df: Input DataFrame with 'answer' column
    Returns:
        DataFrame with new 'answer_type' column
    """
    # Create a copy to avoid modifying the original
    df = df.copy()

    # Print unique answers to debug
    print("Unique answers in dataset:")
    print(df["answer"].unique())

    # Create answer_type column with case-insensitive matching
    conditions = [
        df["answer"].str.lower() == "invalid question",
        df["answer"].str.lower() == "i don't know",  # Try exact match
    ]
    choices = ["invalid", "no_answer"]
    df["answer_type"] = np.select(conditions, choices, default="valid")

    # Print distribution to verify
    print("\nAnswer type distribution:")
    print(df["answer_type"].value_counts())

    return df


def create_stratified_subsets(
    df: pd.DataFrame,
    n_subsets: int,
    stratify_columns: List[str] = [
        "domain",
        "answer_type",
        "question_type",
        "static_or_dynamic",
    ],
    output_path: str = "subsets.json",
    force_compute: bool = False,
) -> Dict[str, Any]:
    """
    Create stratified subsets of the dataset and save them to a JSON file.
    Each subset gets a unique ID based on its indices.
    Args:
        df: Input DataFrame
        n_subsets: Number of subsets to create
        stratify_columns: Columns to use for stratification
        output_path: Path to save/load the JSON output
        force_compute: If True, always compute subsets even if file exists
    Returns:
        Dictionary containing the subsets information
    """
    # Check if file exists and we can use it
    if not force_compute and os.path.exists(output_path):
        try:
            with open(output_path, "r") as f:
                subsets_data = json.load(f)

            # Validate the loaded data has the expected structure
            if (
                subsets_data.get("metadata", {}).get("n_subsets") == n_subsets
                and subsets_data.get("metadata", {}).get("stratify_columns")
                == stratify_columns
            ):
                print(f"Loading existing subsets from {output_path}")
                return subsets_data
            else:
                print("Existing subsets file has different parameters, recomputing...")
        except Exception as e:
            print(f"Error loading existing subsets file: {e}, recomputing...")

    # Create a combined category for stratification
    df["strat_category"] = df[stratify_columns].astype(str).agg("_".join, axis=1)

    # Initialize the subsetter
    skf = StratifiedKFold(n_splits=n_subsets, shuffle=True, random_state=42)

    # Create subsets
    subsets_info = []
    for subset_idx, (_, subset_indices) in enumerate(
        skf.split(df, df["strat_category"])
    ):
        # Sort indices for consistent hashing
        sorted_indices = sorted(subset_indices.tolist())

        # Create a deterministic ID from the indices
        subset_id = hashlib.md5(str(sorted_indices).encode()).hexdigest()[:8]

        # Calculate statistics for this subset
        stats = {}
        subset_df = df.iloc[subset_indices]
        for col in stratify_columns:
            stats[col] = subset_df[col].value_counts().to_dict()

        subsets_info.append(
            {
                "index": subset_idx,
                "statistics": stats,
                "indices": sorted_indices,
                "size": len(subset_indices),
            }
        )

    # Add global statistics
    global_stats = {}
    for col in stratify_columns:
        global_stats[col] = df[col].value_counts().to_dict()

    output_data = {
        "metadata": {
            "n_subsets": n_subsets,
            "total_samples": len(df),
            "stratify_columns": stratify_columns,
            "global_statistics": global_stats,
        },
        "subsets": subsets_info,
    }

    # Save to JSON
    with open(output_path, "w") as f:
        json.dump(output_data, f, indent=2)

    return output_data


def write_subset(
    input_file: str, indices: List[int], output_file: str, compress: bool = True
) -> None:
    """Write a single subset to a file using awk and jq."""
    indices_set = set(i + 1 for i in indices)
    nr_conditions = " || ".join(f"NR == {i}" for i in sorted(indices_set))

    # Add alt_ans field handling to awk script
    awk_script = f"""
    {{ 
        if ({nr_conditions}) {{ 
            print 
        }} 
    }}"""

    if input_file.endswith(".bz2"):
        # Use awk to filter lines and jq to remove "alt_ans"
        if compress:
            cmd = f"bzcat '{input_file}' | awk '{awk_script}' | jq 'del(.alt_ans)' | bzip2 > '{output_file}'"
        else:
            cmd = f"bzcat '{input_file}' | awk '{awk_script}' | jq 'del(.alt_ans)' > '{output_file}'"
    else:
        if compress:
            cmd = f"awk '{awk_script}' '{input_file}' | jq 'del(.alt_ans)' | bzip2 > '{output_file}'"
        else:
            cmd = f"awk '{awk_script}' '{input_file}' | jq 'del(.alt_ans)' > '{output_file}'"

    print(f"Process {os.getpid()} - Starting subset to {output_file}")
    try:
        result = subprocess.run(
            cmd,
            shell=True,
            check=True,
            stderr=subprocess.PIPE,
            stdout=subprocess.PIPE,
            text=True,
        )
        print(f"Process {os.getpid()} - Finished subset to {output_file}")

        if os.path.exists(output_file) and os.path.getsize(output_file) > 0:
            print(
                f"Process {os.getpid()} - Successfully created {output_file} "
                f"({os.path.getsize(output_file)} bytes)"
            )
        else:
            raise Exception(f"Output file {output_file} is empty or doesn't exist")

    except subprocess.CalledProcessError as e:
        print(f"Error executing command: {e.stderr}")
        print(f"Command output: {e.stdout}")
        raise
    except Exception as e:
        print(f"Error: {str(e)}")
        raise


def subset_jsonl_file(
    input_file: str,
    subsets_file: str,
    output_dir: Optional[str] = None,
    compress: bool = True,
    n_processes: Optional[int] = None,
    overwrite: bool = False,
) -> None:
    """
    subset a large JSONL file into multiple files using sed for maximum performance.
    Args:
        input_file: Path to input JSONL file (can be bz2 compressed)
        subsets_file: Path to JSON file containing subset indices
        output_dir: Directory to save subset files (defaults to input file directory)
        compress: Whether to compress output files with bz2
        n_processes: Number of processes to use (defaults to min(n_subsets, cpu_count))
        overwrite: If False, skip existing output files (default: False)
    """
    # Load subsets information
    with open(subsets_file, "r") as f:
        subsets_data = json.load(f)

    # Determine optimal number of processes
    n_subsets = len(subsets_data["subsets"])
    if n_processes is None:
        n_processes = min(n_subsets, cpu_count())

    if output_dir is None:
        output_dir = os.path.dirname(input_file)
    os.makedirs(output_dir, exist_ok=True)

    base_name = os.path.splitext(os.path.basename(input_file))[0]
    if base_name.endswith(".jsonl"):
        base_name = os.path.splitext(base_name)[0]

    # Prepare arguments for parallel processing
    write_args = []
    skipped_files = []
    for subset in subsets_data["subsets"]:
        subset_idx = subset["index"]
        output_name = f"{base_name}_subset_{subset_idx+1}.jsonl"
        if compress:
            output_name += ".bz2"
        output_path = os.path.join(output_dir, output_name)

        # Skip if file exists and overwrite is False
        if not overwrite and os.path.exists(output_path):
            skipped_files.append(output_path)
            continue

        write_args.append((input_file, subset["indices"], output_path, compress))

    if skipped_files:
        print(f"Skipping {len(skipped_files)} existing files:")
        for file in skipped_files:
            print(f"  - {file}")

    if write_args:
        print(f"Processing {len(write_args)} subsets using {n_processes} processes")
        with Pool(processes=n_processes) as pool:
            pool.starmap(write_subset, write_args)
    else:
        print("No files to process - all files exist and overwrite=False")

	import os
	import hashlib
	import bz2
	import json
	import subprocess
	from typing import Dict, List, Optional, Any
	import pandas as pd
	import numpy as np
	from multiprocessing import Pool, cpu_count
	from sklearn.model_selection import StratifiedKFold


	def get_cache_path(file_path: str, required_fields: List[str]) -> str:
	"""
	Generate a unique cache file path based on input file and fields.

	Args:
	file_path: Path to the input JSONL file
	required_fields: List of field names to extract

	Returns:
	Path to the cache file
	"""
	# Create a unique hash based on the file path and fields
	fields_str = ",".join(sorted(required_fields))
	hash_input = f"{fields_str}"
	hash_str = hashlib.md5(hash_input.encode()).hexdigest()[:10]

	# Get the directory of the input file
	base_dir = os.path.dirname(file_path)
	# Get filename from file path
	file_name = os.path.basename(file_path).split(".")[0]
	cache_name = f"{file_name}_cache_{hash_str}.parquet"
	return os.path.join(base_dir, cache_name)


	def read_jsonl_fields_fast(
	file_path: str, required_fields: List[str], use_cache: bool = True
	) -> pd.DataFrame:
	"""
	Quickly extract specific fields from a compressed JSONL file using string operations.
	Results are cached in parquet format for faster subsequent reads.

	Args:
	file_path: Path to the JSONL file (can be bz2 compressed)
	required_fields: List of field names to extract from each JSON object
	use_cache: Whether to use/create cache file (default: True)

	Returns:
	DataFrame containing the requested fields
	"""
	cache_path = get_cache_path(file_path, required_fields)
	print(f"Cache path: {cache_path}")
	# Try to load from cache first
	if use_cache and os.path.exists(cache_path):
	return pd.read_parquet(cache_path)

	# If no cache exists, process the file
	records = []
	patterns = [f'"{field}":' for field in required_fields]

	with bz2.open(file_path, "rt") as file:
	for line in file:
	if not line.strip():
	continue

	result = {}
	for field, pattern in zip(required_fields, patterns):
	try:
	# Find the field in the line
	start_idx = line.find(pattern)
	if start_idx == -1:
	continue

	# Move to the start of the value
	start_idx += len(pattern)
	while start_idx < len(line) and line[start_idx].isspace():
	start_idx += 1

	# Handle different value types
	if start_idx >= len(line):
	continue

	if line[start_idx] == '"':
	# String value
	start_idx += 1
	end_idx = line.find('"', start_idx)
	value = line[start_idx:end_idx]
	elif line[start_idx] == "{" or line[start_idx] == "[":
	# Skip nested objects/arrays
	continue
	else:
	# Number, boolean, or null
	end_idx = line.find(",", start_idx)
	if end_idx == -1:
	end_idx = line.find("}", start_idx)
	value = line[start_idx:end_idx].strip()
	# Convert to appropriate type
	if value == "true":
	value = True
	elif value == "false":
	value = False
	elif value == "null":
	value = None
	else:
	try:
	value = float(value) if "." in value else int(value)
	except ValueError:
	continue

	result[field] = value
	except Exception:
	continue

	if result:
	records.append(result)

	# Convert to DataFrame
	df = pd.DataFrame.from_records(records)

	# Convert columns to appropriate types
	for col in df.columns:
	# If the column contains any strings, convert the whole column to strings
	if (
	df[col].dtype == object
	and df[col].apply(lambda x: isinstance(x, str)).any()
	):
	df[col] = df[col].astype(str)
	# You can add more type conversions here if needed

	# Save cache if enabled
	if use_cache:
	df.to_parquet(cache_path)

	return df


	def process_answer_types(df: pd.DataFrame) -> pd.DataFrame:
	"""
	Process the answer field to create a new answer_type field.

	Args:
	df: Input DataFrame with 'answer' column

	Returns:
	DataFrame with new 'answer_type' column
	"""
	# Create a copy to avoid modifying the original
	df = df.copy()

	# Print unique answers to debug
	print("Unique answers in dataset:")
	print(df["answer"].unique())

	# Create answer_type column with case-insensitive matching
	conditions = [
	df["answer"].str.lower() == "invalid question",
	df["answer"].str.lower() == "i don't know", # Try exact match
	]
	choices = ["invalid", "no_answer"]
	df["answer_type"] = np.select(conditions, choices, default="valid")

	# Print distribution to verify
	print("\nAnswer type distribution:")
	print(df["answer_type"].value_counts())

	return df


	def create_stratified_subsets(
	df: pd.DataFrame,
	n_subsets: int,
	stratify_columns: List[str] = [
	"domain",
	"answer_type",
	"question_type",
	"static_or_dynamic",
	],
	output_path: str = "subsets.json",
	force_compute: bool = False,
	) -> Dict[str, Any]:
	"""
	Create stratified subsets of the dataset and save them to a JSON file.
	Each subset gets a unique ID based on its indices.

	Args:
	df: Input DataFrame
	n_subsets: Number of subsets to create
	stratify_columns: Columns to use for stratification
	output_path: Path to save/load the JSON output
	force_compute: If True, always compute subsets even if file exists

	Returns:
	Dictionary containing the subsets information
	"""
	# Check if file exists and we can use it
	if not force_compute and os.path.exists(output_path):
	try:
	with open(output_path, "r") as f:
	subsets_data = json.load(f)

	# Validate the loaded data has the expected structure
	if (
	subsets_data.get("metadata", {}).get("n_subsets") == n_subsets
	and subsets_data.get("metadata", {}).get("stratify_columns")
	== stratify_columns
	):
	print(f"Loading existing subsets from {output_path}")
	return subsets_data
	else:
	print("Existing subsets file has different parameters, recomputing...")
	except Exception as e:
	print(f"Error loading existing subsets file: {e}, recomputing...")

	# Create a combined category for stratification
	df["strat_category"] = df[stratify_columns].astype(str).agg("_".join, axis=1)

	# Initialize the subsetter
	skf = StratifiedKFold(n_splits=n_subsets, shuffle=True, random_state=42)

	# Create subsets
	subsets_info = []
	for subset_idx, (_, subset_indices) in enumerate(
	skf.split(df, df["strat_category"])
	):
	# Sort indices for consistent hashing
	sorted_indices = sorted(subset_indices.tolist())

	# Create a deterministic ID from the indices
	subset_id = hashlib.md5(str(sorted_indices).encode()).hexdigest()[:8]

	# Calculate statistics for this subset
	stats = {}
	subset_df = df.iloc[subset_indices]
	for col in stratify_columns:
	stats[col] = subset_df[col].value_counts().to_dict()

	subsets_info.append(
	{
	"index": subset_idx,
	"statistics": stats,
	"indices": sorted_indices,
	"size": len(subset_indices),
	}
	)

	# Add global statistics
	global_stats = {}
	for col in stratify_columns:
	global_stats[col] = df[col].value_counts().to_dict()

	output_data = {
	"metadata": {
	"n_subsets": n_subsets,
	"total_samples": len(df),
	"stratify_columns": stratify_columns,
	"global_statistics": global_stats,
	},
	"subsets": subsets_info,
	}

	# Save to JSON
	with open(output_path, "w") as f:
	json.dump(output_data, f, indent=2)

	return output_data


	def write_subset(
	input_file: str, indices: List[int], output_file: str, compress: bool = True
	) -> None:
	"""Write a single subset to a file using awk and jq."""
	indices_set = set(i + 1 for i in indices)
	nr_conditions = " \|\| ".join(f"NR == {i}" for i in sorted(indices_set))

	# Add alt_ans field handling to awk script
	awk_script = f"""
	{{
	if ({nr_conditions}) {{
	print
	}}
	}}"""

	if input_file.endswith(".bz2"):
	# Use awk to filter lines and jq to remove "alt_ans"
	if compress:
	cmd = f"bzcat '{input_file}' \| awk '{awk_script}' \| jq 'del(.alt_ans)' \| bzip2 > '{output_file}'"
	else:
	cmd = f"bzcat '{input_file}' \| awk '{awk_script}' \| jq 'del(.alt_ans)' > '{output_file}'"
	else:
	if compress:
	cmd = f"awk '{awk_script}' '{input_file}' \| jq 'del(.alt_ans)' \| bzip2 > '{output_file}'"
	else:
	cmd = f"awk '{awk_script}' '{input_file}' \| jq 'del(.alt_ans)' > '{output_file}'"

	print(f"Process {os.getpid()} - Starting subset to {output_file}")
	try:
	result = subprocess.run(
	cmd,
	shell=True,
	check=True,
	stderr=subprocess.PIPE,
	stdout=subprocess.PIPE,
	text=True,
	)
	print(f"Process {os.getpid()} - Finished subset to {output_file}")

	if os.path.exists(output_file) and os.path.getsize(output_file) > 0:
	print(
	f"Process {os.getpid()} - Successfully created {output_file} "
	f"({os.path.getsize(output_file)} bytes)"
	)
	else:
	raise Exception(f"Output file {output_file} is empty or doesn't exist")

	except subprocess.CalledProcessError as e:
	print(f"Error executing command: {e.stderr}")
	print(f"Command output: {e.stdout}")
	raise
	except Exception as e:
	print(f"Error: {str(e)}")
	raise


	def subset_jsonl_file(
	input_file: str,
	subsets_file: str,
	output_dir: Optional[str] = None,
	compress: bool = True,
	n_processes: Optional[int] = None,
	overwrite: bool = False,
	) -> None:
	"""
	subset a large JSONL file into multiple files using sed for maximum performance.

	Args:
	input_file: Path to input JSONL file (can be bz2 compressed)
	subsets_file: Path to JSON file containing subset indices
	output_dir: Directory to save subset files (defaults to input file directory)
	compress: Whether to compress output files with bz2
	n_processes: Number of processes to use (defaults to min(n_subsets, cpu_count))
	overwrite: If False, skip existing output files (default: False)
	"""
	# Load subsets information
	with open(subsets_file, "r") as f:
	subsets_data = json.load(f)

	# Determine optimal number of processes
	n_subsets = len(subsets_data["subsets"])
	if n_processes is None:
	n_processes = min(n_subsets, cpu_count())

	if output_dir is None:
	output_dir = os.path.dirname(input_file)
	os.makedirs(output_dir, exist_ok=True)

	base_name = os.path.splitext(os.path.basename(input_file))[0]
	if base_name.endswith(".jsonl"):
	base_name = os.path.splitext(base_name)[0]

	# Prepare arguments for parallel processing
	write_args = []
	skipped_files = []
	for subset in subsets_data["subsets"]:
	subset_idx = subset["index"]
	output_name = f"{base_name}_subset_{subset_idx+1}.jsonl"
	if compress:
	output_name += ".bz2"
	output_path = os.path.join(output_dir, output_name)

	# Skip if file exists and overwrite is False
	if not overwrite and os.path.exists(output_path):
	skipped_files.append(output_path)
	continue

	write_args.append((input_file, subset["indices"], output_path, compress))

	if skipped_files:
	print(f"Skipping {len(skipped_files)} existing files:")
	for file in skipped_files:
	print(f" - {file}")

	if write_args:
	print(f"Processing {len(write_args)} subsets using {n_processes} processes")
	with Pool(processes=n_processes) as pool:
	pool.starmap(write_subset, write_args)
	else:
	print("No files to process - all files exist and overwrite=False")