download_data.py

import argparse
import re
from pathlib import Path

import datasets


DATASET_CONFIGS = {
    "writingprompts": {
        "hf_id": "writingprompts",
        "prompt_field": "prompt",
        "response_field": "story",
    },
    "tinystories": {
        "hf_id": "roneneldan/TinyStories",
        "prompt_field": None,
        "response_field": "text",
    },
    "redditjokes": {
        "hf_id": None,
        "prompt_field": "title",
        "response_field": "body",
    },
}


def ensure_dir(path: Path) -> None:
    path.mkdir(parents=True, exist_ok=True)


def get_columns(dataset):
    if isinstance(dataset, dict):
        for split in ("train", "validation", "test"):
            if split in dataset:
                return dataset[split].column_names
        first_split = next(iter(dataset.keys()))
        return dataset[first_split].column_names
    return dataset.column_names


def resolve_field(columns, field_name, fallbacks):
    if field_name and field_name in columns:
        return field_name
    for candidate in fallbacks:
        if candidate in columns:
            return candidate
    return None


def make_splits(dataset, seed: int):
    if isinstance(dataset, dict):
        if "train" in dataset and "validation" in dataset and "test" in dataset:
            return dataset["train"], dataset["validation"], dataset["test"]

        if "train" in dataset and "test" in dataset:
            split = dataset["train"].train_test_split(test_size=0.2, seed=seed)
            val_test = split["test"].train_test_split(test_size=0.5, seed=seed)
            return split["train"], val_test["train"], val_test["test"]

        base_split = dataset.get("train") or dataset[next(iter(dataset.keys()))]
        split = base_split.train_test_split(test_size=0.2, seed=seed)
        val_test = split["test"].train_test_split(test_size=0.5, seed=seed)
        return split["train"], val_test["train"], val_test["test"]

    if "train" in dataset and "validation" in dataset and "test" in dataset:
        return dataset["train"], dataset["validation"], dataset["test"]

    if "train" in dataset and "test" in dataset:
        split = dataset["train"].train_test_split(test_size=0.2, seed=seed)
        val_test = split["test"].train_test_split(test_size=0.5, seed=seed)
        return split["train"], val_test["train"], val_test["test"]

    split = dataset.train_test_split(test_size=0.2, seed=seed)
    val_test = split["test"].train_test_split(test_size=0.5, seed=seed)
    return split["train"], val_test["train"], val_test["test"]


def clean_text(text):
    if text is None:
        return ""
    cleaned = str(text).replace("\r", " ").replace("\n", " ").strip()
    cleaned = re.sub(r"\s+", " ", cleaned)
    return cleaned


def should_drop_deleted(text):
    lowered = text.strip().lower()
    return lowered in {"[deleted]", "[removed]"}


def normalize_records(dataset, prompt_field, response_field, source_name, include_metadata):
    def _map(example):
        prompt = clean_text(example[prompt_field]) if prompt_field else ""
        response = clean_text(example[response_field])

        record = {
            "prompt": prompt.strip(),
            "response": response.strip(),
            "source": source_name,
        }

        if include_metadata:
            metadata = {}
            for key in ("score", "author", "id", "subreddit"):
                if key in example and example[key] not in (None, ""):
                    metadata[key] = example[key]
            if metadata:
                record["metadata"] = metadata

        return record

    return dataset.map(_map, remove_columns=dataset.column_names)


def main() -> None:
    parser = argparse.ArgumentParser(description="Download datasets for QuestCrafter.")
    parser.add_argument(
        "--dataset",
        choices=DATASET_CONFIGS.keys(),
        default="redditjokes",
        help="Dataset source to download from Hugging Face or local CSV.",
    )
    parser.add_argument(
        "--output_dir",
        default="data/raw",
        help="Directory to save JSONL splits.",
    )
    parser.add_argument(
        "--local_csv",
        default=None,
        help="Path to a local CSV file (required for redditjokes).",
    )
    parser.add_argument(
        "--prompt_field",
        default=None,
        help="Optional prompt column name override.",
    )
    parser.add_argument(
        "--response_field",
        default=None,
        help="Optional response column name override.",
    )
    parser.add_argument(
        "--min_prompt_chars",
        type=int,
        default=5,
        help="Minimum prompt length (characters). Ignored if prompt field is empty.",
    )
    parser.add_argument(
        "--max_prompt_chars",
        type=int,
        default=300,
        help="Maximum prompt length (characters). Ignored if prompt field is empty.",
    )
    parser.add_argument(
        "--min_response_chars",
        type=int,
        default=20,
        help="Minimum response length (characters).",
    )
    parser.add_argument(
        "--max_response_chars",
        type=int,
        default=800,
        help="Maximum response length (characters).",
    )
    parser.add_argument(
        "--keep_deleted",
        action="store_true",
        help="Keep rows with [deleted]/[removed] responses (default: drop).",
    )
    parser.add_argument(
        "--no_metadata",
        action="store_true",
        help="Disable metadata fields in JSONL output.",
    )
    parser.add_argument("--seed", type=int, default=42, help="Random seed for splits.")
    args = parser.parse_args()

    config = DATASET_CONFIGS[args.dataset]
    if config["hf_id"]:
        dataset = datasets.load_dataset(config["hf_id"])
    else:
        if not args.local_csv:
            raise ValueError("For redditjokes, you must provide --local_csv.")
        csv_path = Path(args.local_csv)
        if not csv_path.exists():
            raise FileNotFoundError(f"CSV not found: {csv_path}")
        dataset = datasets.load_dataset("csv", data_files=str(csv_path))

    columns = get_columns(dataset)
    prompt_field = resolve_field(
        columns,
        args.prompt_field or config["prompt_field"],
        ["prompt", "title", "question", "setup", "context"],
    )
    response_field = resolve_field(
        columns,
        args.response_field or config["response_field"],
        ["response", "body", "joke", "Joke", "text", "completion", "answer"],
    )
    if response_field is None:
        raise ValueError(f"Response column not found in CSV. Columns: {columns}")

    def is_valid(example):
        prompt = clean_text(example[prompt_field]) if prompt_field else ""
        response = clean_text(example[response_field])

        if not response:
            return False
        if not args.keep_deleted and should_drop_deleted(response):
            return False

        if prompt_field:
            if len(prompt) < args.min_prompt_chars:
                return False
            if len(prompt) > args.max_prompt_chars:
                return False

        if len(response) < args.min_response_chars:
            return False
        if len(response) > args.max_response_chars:
            return False

        return True

    dataset = dataset.filter(is_valid)

    train, val, test = make_splits(dataset, args.seed)
    include_metadata = not args.no_metadata
    train = normalize_records(train, prompt_field, response_field, args.dataset, include_metadata)
    val = normalize_records(val, prompt_field, response_field, args.dataset, include_metadata)
    test = normalize_records(test, prompt_field, response_field, args.dataset, include_metadata)

    output_dir = Path(args.output_dir) / args.dataset
    ensure_dir(output_dir)

    train.to_json(output_dir / "train.jsonl", orient="records", lines=True)
    val.to_json(output_dir / "val.jsonl", orient="records", lines=True)
    test.to_json(output_dir / "test.jsonl", orient="records", lines=True)

    print(f"Saved splits to {output_dir}")


if __name__ == "__main__":
    main()