079project 8.0.0 → 9.1.0

package/test_automatic/generate_daily_qa.py

@@ -0,0 +1,645 @@
+import csv
+import random
+import re
+from collections import Counter
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, List, Tuple
+
+
+BASE_DIR = Path(__file__).resolve().parent
+QUESTION_CSV = BASE_DIR / "question.csv"
+ANSWER_CSV = BASE_DIR / "answer.csv"
+
+
+STOPWORDS = {
+    "a","an","the","and","or","but","so","to","of","in","on","at","for","from","with","without",
+    "is","are","was","were","be","been","being","do","does","did","can","could","would","should",
+    "i","me","my","mine","you","your","yours","we","our","ours","they","their","theirs","he","his","she","her",
+    "it","its","this","that","these","those","there","here","as","if","then","than","also","just","really","very",
+    "what","how","when","where","why","who","which",
+}
+
+
+def word_tokens(text: str) -> List[str]:
+    return [t for t in re.findall(r"[A-Za-z']+", text.lower()) if t]
+
+
+def info_tokens(text: str) -> List[str]:
+    toks = [t for t in word_tokens(text) if t not in STOPWORDS]
+    return toks
+
+
+@dataclass(frozen=True)
+class QA:
+    question: str
+    answer: str
+    category: str
+
+
+def pick(rng: random.Random, items: List[str]) -> str:
+    return items[rng.randrange(len(items))]
+
+
+def fmt_list(items: List[str], start: int = 1) -> str:
+    # Important: test_automatic.cjs parses CSV line-by-line, so cells must not contain embedded newlines.
+    # Keep lists on a single physical line.
+    return " ".join([f"{i}. {v.strip().rstrip('.')}." for i, v in enumerate(items, start=start)])
+
+
+def message(text: str) -> str:
+    # Keep messages realistic: one or two short sentences.
+    text = re.sub(r"[\r\n]+", " ", text)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
+
+def sanitize_cell(text: str) -> str:
+    return message(str(text or ""))
+
+
+def qa_check_in(rng: random.Random) -> QA:
+    context = pick(rng, [
+        "before my morning shift",
+        "after a stressful day at work",
+        "while I'm waiting for an appointment",
+        "on a quiet Sunday evening",
+        "during a rainy afternoon",
+    ])
+    detail = pick(rng, [
+        "I slept poorly and feel a bit off",
+        "I'm excited but slightly nervous",
+        "I'm drained and need a reset",
+        "I'm doing okay, just distracted",
+    ])
+    q = (
+        f"Write a friendly check-in text I can send to a friend {context}. "
+        f"Include one specific detail ({detail}) and end with one simple question that invites a reply."
+    )
+    opener = pick(rng, [
+        "Hey! Just checking in",
+        "Hi—quick check-in",
+        "Hey, thinking of you",
+        "Hi there—hope you're doing okay",
+    ])
+    a = message(
+        f"{opener}. {detail}. How are you doing today?"
+    )
+    return QA(q, a, "social")
+
+
+def qa_decline_invite(rng: random.Random) -> QA:
+    who = pick(rng, ["coworker", "close friend", "neighbor", "cousin"])
+    event = pick(rng, ["dinner", "a birthday get-together", "drinks", "a weekend trip", "a movie night"])
+    reason = pick(rng, [
+        "I already have plans",
+        "I need a quiet night to rest",
+        "I'm trying to keep my budget tight this week",
+        "I'm not feeling 100%",
+    ])
+    alt = pick(rng, ["next Tuesday", "next weekend", "Thursday evening", "sometime next week"])
+    q = (
+        f"Draft a polite text to decline a {who}'s invitation to {event}. "
+        f"Be warm, give a short reason ({reason}) without oversharing, and suggest {alt} instead."
+    )
+    thanks = pick(rng, [
+        "Thanks for inviting me!",
+        "That sounds fun—thanks for asking!",
+        "I really appreciate the invite!",
+    ])
+    a = message(
+        f"{thanks} I can't make {event} this time because {reason}. "
+        f"If you're free, I'd love to try {alt} instead."
+    )
+    return QA(q, a, "social")
+
+
+def qa_apology(rng: random.Random) -> QA:
+    situation = pick(rng, [
+        "I snapped in a group chat",
+        "I interrupted someone repeatedly",
+        "I made a joke that landed badly",
+        "I sounded dismissive in a meeting",
+    ])
+    repair = pick(rng, [
+        "offer to talk and listen",
+        "ask how I can make it right",
+        "promise a concrete change",
+        "acknowledge impact clearly",
+    ])
+    q = (
+        f"{situation}. Write a sincere apology message that takes responsibility, "
+        f"does not make excuses, and includes a repair step (" + repair + ")."
+    )
+    fix = pick(rng, [
+        "If you're open to it, I'd like to listen and make it right.",
+        "I'd like to understand how it landed and do better.",
+        "If you'd be willing, I'd like to talk and repair this.",
+    ])
+    a = message(
+        f"I'm sorry—{situation}. That was on me, and I can see how it could have felt disrespectful. {fix}"
+    )
+    return QA(q, a, "communication")
+
+
+def qa_late_reply(rng: random.Random) -> QA:
+    delay = pick(rng, ["two days", "a few hours", "since yesterday", "all morning"])
+    reason = pick(rng, [
+        "traveling",
+        "in back-to-back meetings",
+        "away from my phone",
+        "handling something urgent",
+        "thinking it through before replying",
+        "offline for a bit",
+    ])
+    q = (
+        f"I forgot to reply for {delay} because {reason}. "
+        "Give me a natural one-sentence message that apologizes briefly and moves the conversation forward."
+    )
+    a = message(
+        f"Sorry for the slow reply—I was {reason} and just saw this. "
+        "What would you like to do next?"
+    )
+    return QA(q, a, "communication")
+
+
+def qa_day_plan(rng: random.Random) -> QA:
+    day = pick(rng, ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"])
+    fixed = pick(rng, [
+        "a 9:30 AM meeting, a 1:00 PM dentist appointment, and a 4:00 PM deadline",
+        "two 30-minute meetings and one 2-hour deep work block",
+        "school pickup at 3:15 PM and a gym session in the evening",
+        "a 10:00 AM presentation and errands that take about 90 minutes",
+    ])
+    top_goal = pick(rng, [
+        "finish a draft report",
+        "clean up my inbox",
+        "study for an exam",
+        "ship a small feature",
+        "organize my finances",
+    ])
+    q = (
+        f"Help me plan my {day}. I have {fixed}. My top goal is to {top_goal}. "
+        "Give me a realistic schedule with time blocks, one short break, and one buffer block for surprises."
+    )
+    a = (
+        f"A realistic {day} plan: "
+        + fmt_list([
+            f"Fixed blocks: {fixed} (put these on the calendar first).",
+            f"Focus block: 60–90 minutes on '{top_goal}' when you feel most alert.",
+            "Break: 10 minutes (water + short walk + no phone).",
+            "Admin/messages: 30 minutes in one batch, not all day.",
+            "Buffer: 20 minutes near the end for surprises.",
+        ])
+    )
+    return QA(q, a, "planning")
+
+
+def qa_focus_setup(rng: random.Random) -> QA:
+    distract = pick(rng, ["Slack pings", "phone scrolling", "too many browser tabs", "a noisy room"])
+    task = pick(rng, ["writing a report", "studying", "coding", "doing budgeting"])
+    duration = pick(rng, ["20 minutes", "30 minutes", "45 minutes"])
+    q = (
+        f"I keep losing focus because of {distract}. I need {duration} of focused work for {task}. "
+        "Give me a setup checklist with 6 concrete actions I can do in 3 minutes before I start."
+    )
+    a = (
+        f"3-minute setup for {duration} of {task}: "
+        + fmt_list([
+            f"Mute {distract} (or set 'Do Not Disturb').",
+            "Close unrelated tabs/apps; keep only what you need.",
+            "Put phone out of reach (drawer or another room).",
+            f"Set a timer for {duration}.",
+            f"Write one outcome: 'After {duration}, I will have ____ for {task}.'",
+            "Start with a 2-minute easy step (outline, rename file, open notes).",
+        ])
+    )
+    return QA(q, a, "productivity")
+
+
+def qa_anxiety(rng: random.Random) -> QA:
+    when = pick(rng, ["a meeting", "a phone call", "a presentation", "an interview"])
+    minutes = pick(rng, ["5", "8", "10", "12"])
+    q = (
+        f"I feel anxious before {when}. I have {minutes} minutes right now. "
+        "Give me a short routine: one breathing pattern, one body posture tip, and one grounding phrase I can say to myself."
+    )
+    phrase = pick(rng, [
+        "I can handle the first minute calmly.",
+        "Slow is smooth; smooth is fast.",
+        "One step at a time—start with hello.",
+    ])
+    a = (
+        f"Quick routine for {when} (about {minutes} minutes): "
+        + fmt_list([
+            "Breathing: inhale 4, exhale 6, repeat for 2 minutes.",
+            "Posture: feet flat, shoulders down, relax your jaw.",
+            f"Grounding phrase: '{phrase}'",
+        ])
+    )
+    return QA(q, a, "wellbeing")
+
+
+def qa_sleep(rng: random.Random) -> QA:
+    cause = pick(rng, ["scrolling my phone", "late caffeine", "worrying about work", "irregular bedtimes"])
+    q = (
+        f"My sleep has been inconsistent because of {cause}. "
+        "Give me a realistic 4-step bedtime routine I can follow for 7 days, plus one rule to make it easier to stick to."
+    )
+    routines = [
+        [
+            "Set a wind-down alarm 45 minutes before bed.",
+            "Dim lights; prep tomorrow basics (clothes, bag, water).",
+            "Do 5 minutes stretching or light reading.",
+            "Lights out at the same time; cool, dark room.",
+        ],
+        [
+            "Finish caffeine/food earlier in the evening.",
+            "Take a warm shower or wash up.",
+            "Write a 3-line brain-dump (worries + next steps).",
+            "Go to bed on schedule; no snooze scrolling.",
+        ],
+    ]
+    rule_by_cause = {
+        "scrolling my phone": "Rule: keep the phone outside the bedroom.",
+        "late caffeine": "Rule: no caffeine after 2 PM.",
+        "worrying about work": "Rule: write tomorrow's top 3 tasks before bed.",
+        "irregular bedtimes": "Rule: keep bedtime within a 30-minute window.",
+    }
+    chosen = pick(rng, routines)
+    a = (
+        f"Bedtime routine (for '{cause}'): "
+        + fmt_list(chosen)
+        + " " + rule_by_cause.get(cause, "Rule: no screens for the last 30 minutes.")
+    )
+    return QA(q, a, "wellbeing")
+
+
+def qa_food_recipe(rng: random.Random) -> QA:
+    pantry = pick(rng, [
+        ("chicken", "rice", "frozen vegetables"),
+        ("pasta", "canned tomatoes", "garlic"),
+        ("eggs", "spinach", "toast"),
+        ("beans", "rice", "salsa"),
+        ("oats", "milk", "berries"),
+    ])
+    constraint = pick(rng, ["under 25 minutes", "one pan", "low-sugar", "high-protein", "budget-friendly"])
+    q = (
+        f"I have {pantry[0]}, {pantry[1]}, and {pantry[2]}. "
+        f"Give me a simple dinner plan that is {constraint}. "
+        "Include 5 steps and one flavor tip (salt/acid/spice/herbs)."
+    )
+    tip = pick(rng, [
+        "Finish with lemon or vinegar for brightness.",
+        "Add garlic/chili at the end for aroma.",
+        "Use a pinch of sugar to balance acidity (tiny amount).",
+        "Toast spices briefly in oil to deepen flavor.",
+    ])
+    a = (
+        f"Dinner using {pantry[0]}, {pantry[1]}, {pantry[2]} ({constraint}): "
+        + fmt_list([
+            "Prep: rinse/cut ingredients; preheat pan.",
+            f"Cook {pantry[1]} (or warm it if already cooked).",
+            f"Cook {pantry[0]} first, then add {pantry[2]}.",
+            "Season with salt and pepper; add sauce if you have one.",
+            "Combine, heat through, and taste-adjust.",
+        ])
+        + f"\nFlavor tip: {tip}"
+    )
+    return QA(q, a, "food")
+
+
+def qa_budget(rng: random.Random) -> QA:
+    income = pick(rng, [1900, 2600, 3200, 4500])
+    rent = pick(rng, [700, 900, 1200, 1600])
+    goal = pick(rng, ["build an emergency fund", "pay down debt", "save $200", "stop overspending on food"])
+    q = (
+        f"Help me create a simple monthly budget. Take-home pay: ${income}. Rent: ${rent}. Goal: {goal}. "
+        "Give 6 categories with suggested amounts and one rule for tracking that won't take more than 2 minutes per day."
+    )
+    # Rough categories (not financial advice; just practical buckets)
+    remaining = max(income - rent, 0)
+    food = int(remaining * 0.22)
+    transport = int(remaining * 0.12)
+    utilities = int(remaining * 0.10)
+    savings = int(remaining * 0.18)
+    personal = int(remaining * 0.18)
+    buffer = max(remaining - (food + transport + utilities + savings + personal), 0)
+    a = (
+        "Example categories: "
+        + fmt_list([
+            f"Rent: ${rent}",
+            f"Food: ${food}",
+            f"Transport: ${transport}",
+            f"Utilities/internet: ${utilities}",
+            f"Savings/goal: ${savings}",
+            f"Personal/misc + buffer: ${personal + buffer}",
+        ])
+        + " Tracking rule: once per day, log only today's total spending into 3 buckets (food / transport / misc)."
+    )
+    return QA(q, a, "finance")
+
+
+def qa_device_security(rng: random.Random) -> QA:
+    device = pick(rng, ["phone", "laptop"]) 
+    risk = pick(rng, ["phishing emails", "stolen device", "weak passwords", "untrusted downloads"])
+    q = (
+        f"Give me a simple security checklist for my {device}. My biggest concern is {risk}. "
+        "List 7 actions in priority order, and keep each action under 10 words."
+    )
+    base = [
+        "Update the operating system.",
+        "Enable a strong screen lock.",
+        "Turn on two-factor authentication.",
+        "Use a password manager.",
+        "Remove unused apps/extensions.",
+        "Review app permissions.",
+        "Back up important data automatically.",
+    ]
+    risk_specific = {
+        "phishing emails": "Verify senders; never type passwords from links.",
+        "stolen device": "Enable Find My Device and remote wipe.",
+        "weak passwords": "Replace reused passwords with long unique ones.",
+        "untrusted downloads": "Install only from trusted stores; scan files.",
+    }
+    # Make the list slightly different each time but still sensible.
+    rng.shuffle(base)
+    base[0] = "Update the operating system."  # always first
+    base.insert(2, risk_specific.get(risk, "Be cautious with links and attachments."))
+    # Cap to 7 items after insertion
+    a = fmt_list(base[:7])
+    return QA(q, a, "tech")
+
+
+def qa_relationship(rng: random.Random) -> QA:
+    situation = pick(rng, [
+        "we argue about chores",
+        "we misunderstand tone over text",
+        "we don't schedule time together",
+        "I feel unheard in conversations",
+    ])
+    q = (
+        f"In my relationship, {situation}. I want to communicate better without blaming. "
+        "Give me 3 exact phrases I can say, and one weekly habit we can try for 15 minutes."
+    )
+    a = (
+        "Phrases you can use: "
+        + fmt_list([
+            "'When X happens, I feel Y, and I need Z.'",
+            "'Can we solve this as a team—what's your view?'",
+            "'What would make this easier for you this week?'",
+        ])
+        + " Weekly habit: a 15-minute check-in (no phones) to plan chores, one fun thing, and one stress point."
+    )
+    return QA(q, a, "relationships")
+
+
+def qa_interview(rng: random.Random) -> QA:
+    role = pick(rng, ["data analyst", "software engineer", "project manager", "teacher", "designer"])
+    q = (
+        f"I'm interviewing for a {role} role. I want answers that sound human, not scripted. "
+        "Give me 5 common questions and a short example answer for each (2–3 sentences)."
+    )
+    a = (
+        "Common questions + example answers:\n"
+        "1. Tell me about yourself — I'm a " + role + " who enjoys solving practical problems and working with others; recently I focused on improving a process and measuring results.\n"
+        "2. Why this role — I like the mix of ownership and collaboration, and I want to do work that has clear impact.\n"
+        "3. Strength — I'm good at breaking messy problems into steps and communicating progress.\n"
+        "4. Challenge — I used to take on too much; now I clarify priorities early and set realistic deadlines.\n"
+        "5. Conflict — I ask for specifics, align on the goal, and propose a small next step everyone can agree on."
+    )
+    return QA(q, a, "work")
+
+
+def qa_customer_support(rng: random.Random) -> QA:
+    issue = pick(rng, [
+        "a package is late",
+        "I was charged twice",
+        "an item arrived damaged",
+        "I need to cancel a subscription",
+    ])
+    tone = pick(rng, ["polite", "firm but calm", "short and direct"])
+    q = (
+        f"Write a {tone} message to customer support: {issue}. "
+        "Include order/account placeholders, what I want, and a reasonable deadline for response."
+    )
+    a = (
+        "Hello Support Team. I'm contacting you about [Order #] / [Account Email]. "
+        f"Issue: {issue}. Please [refund/replace/cancel] and confirm the resolution. "
+        "If possible, I'd appreciate an update within 2 business days. Thank you, [Name]."
+    )
+    return QA(q, a, "admin")
+
+
+def qa_exercise_plan(rng: random.Random) -> QA:
+    goal = pick(rng, ["build stamina", "reduce back stiffness", "lose a little fat", "get stronger"])
+    constraint = pick(rng, ["no equipment", "a small apartment", "10 minutes per day", "3 days per week"])
+    level = pick(rng, ["beginner", "returning after a break", "not very fit"])
+    q = (
+        f"I want to {goal} and I'm {level}. Constraint: {constraint}. "
+        "Give me a simple plan for the next 7 days with exact exercises, reps/time, and one recovery tip."
+    )
+    plan_a = [
+        "Day 1: 3 rounds — 8 squats, 6 push-ups (knees ok), 20s plank.",
+        "Day 2: 20–30 min walk + 5 min stretching.",
+        "Day 3: 3 rounds — 10 lunges each side, 8 towel rows, 20s side plank.",
+        "Day 4: Easy walk + gentle mobility (hips/shoulders).",
+        "Day 5: Repeat Day 1; add 1–2 reps if easy.",
+        "Day 6: Intervals — 1 min brisk / 1 min easy for 12 minutes.",
+        "Day 7: Rest + 10 minutes stretching.",
+    ]
+    plan_b = [
+        "Day 1: 10 minutes — brisk walk + 2 minutes stretching.",
+        "Day 2: 3 rounds — 8 glute bridges, 8 bird-dogs each side, 20s plank.",
+        "Day 3: Easy walk + shoulder/hip mobility.",
+        "Day 4: 3 rounds — 10 squats, 8 incline push-ups, 20s side plank.",
+        "Day 5: Easy walk + 5 minutes stretching.",
+        "Day 6: Repeat the strength day you liked most.",
+        "Day 7: Rest day + short gentle walk.",
+    ]
+    chosen = pick(rng, [plan_a, plan_b])
+    recovery = pick(rng, [
+        "Stop 1–2 reps before failure and keep form clean.",
+        "If pain (sharp) shows up, stop and scale down.",
+        "Sleep and hydration matter more than perfect workouts.",
+    ])
+    a = (
+        f"7-day plan for '{goal}' ({level}, constraint: {constraint}): "
+        + fmt_list(chosen)
+        + f" Recovery tip: {recovery}"
+    )
+    return QA(q, a, "fitness")
+
+
+def qa_study_plan(rng: random.Random) -> QA:
+    subject = pick(rng, ["English vocabulary", "math basics", "a certification exam", "typing", "public speaking"])
+    time = pick(rng, ["45 minutes", "30 minutes", "60 minutes", "25 minutes"])
+    horizon = pick(rng, ["2 weeks", "10 days", "one month"])
+    weakness = pick(rng, ["I forget quickly", "I get distracted", "I don't know what to practice", "I cram at the end"])
+    q = (
+        f"Help me study {subject} for {horizon}. I can do {time} per day. Weakness: {weakness}. "
+        "Give a daily structure, a review method, and one way to measure progress weekly."
+    )
+    structure_variants = [
+        [
+            "5 min setup: pick one topic and open materials.",
+            f"{time} practice: do problems/drills first, then check.",
+            "10 min review: write mistakes + fixes in a list.",
+        ],
+        [
+            f"10 min review: spaced repetition or yesterday's errors.",
+            f"{time} focus: 2 x 15 minutes practice with a 2-minute break.",
+            "5 min summary: write 3 bullet takeaways.",
+        ],
+    ]
+    chosen = pick(rng, structure_variants)
+    metric = pick(rng, [
+        "a weekly 10-minute timed quiz",
+        "a list of your top 10 recurring mistakes",
+        "words/minute or accuracy (for typing)",
+        "one recorded 2-minute practice (for speaking)",
+    ])
+    a = (
+        f"Daily structure for {subject} ({horizon}): "
+        + fmt_list(chosen)
+        + " Review method: revisit the same items after 1 day, 3 days, and 7 days."
+        + f" Weekly measure: track {metric} and note what improved."
+    )
+    return QA(q, a, "study")
+
+
+def qa_travel_packing(rng: random.Random) -> QA:
+    trip = pick(rng, ["3-day trip", "5-day trip", "weekend trip"])
+    weather = pick(rng, ["cold and rainy", "hot and humid", "mild with wind", "snowy"])
+    style = pick(rng, ["carry-on only", "one backpack", "minimal packing"])
+    q = (
+        f"I'm going on a {trip} and the weather will be {weather}. I want {style}. "
+        "Give me a packing checklist grouped by clothes, toiletries, tech, and documents, plus 2 'don't forget' items."
+    )
+    extra = {
+        "cold and rainy": "Don't forget: a compact umbrella and warm socks.",
+        "hot and humid": "Don't forget: sunscreen and a light hat.",
+        "mild with wind": "Don't forget: a windbreaker and lip balm.",
+        "snowy": "Don't forget: gloves and a warm beanie.",
+    }
+    a = (
+        f"Packing checklist ({trip}, {weather}, {style}): "
+        "Clothes: 2–3 tops, 1–2 bottoms, underwear/socks, outer layer, comfortable shoes. "
+        "Toiletries: toothbrush, deodorant, small liquids, meds, comb. "
+        "Tech: charger, power bank, headphones, adapter (if needed). "
+        "Documents: ID/passport, cards, reservations, emergency contact. "
+        + extra.get(weather, "Don't forget: water bottle and a zip bag for liquids.")
+    )
+    return QA(q, a, "travel")
+
+
+GENERATORS: List[Callable[[random.Random], QA]] = [
+    qa_check_in,
+    qa_decline_invite,
+    qa_apology,
+    qa_late_reply,
+    qa_day_plan,
+    qa_focus_setup,
+    qa_anxiety,
+    qa_sleep,
+    qa_food_recipe,
+    qa_budget,
+    qa_device_security,
+    qa_relationship,
+    qa_interview,
+    qa_customer_support,
+    qa_exercise_plan,
+    qa_study_plan,
+    qa_travel_packing,
+]
+
+
+def generate_dataset(count: int, seed: int) -> List[QA]:
+    rng = random.Random(seed)
+
+    qas: List[QA] = []
+    seen_questions = set()
+    answer_counts: Counter[str] = Counter()
+
+    # Heuristics: keep diversity high
+    max_same_answer = 10
+    min_question_words = 16
+    min_info_tokens = 9
+
+    # Try multiple attempts to fill
+    attempts = 0
+    while len(qas) < count:
+        attempts += 1
+        if attempts > count * 50:
+            raise RuntimeError("Unable to generate enough diverse QAs; relax constraints.")
+
+        # Randomize generator choice so we don't get stuck on one template.
+        gen = pick(rng, GENERATORS)
+        qa = gen(rng)
+
+        q = re.sub(r"\s+", " ", qa.question).strip()
+        a = qa.answer.strip()
+
+        if q in seen_questions:
+            continue
+
+        if len(word_tokens(q)) < min_question_words:
+            continue
+
+        if len(info_tokens(q)) < min_info_tokens:
+            continue
+
+        if answer_counts[a] >= max_same_answer:
+            continue
+
+        seen_questions.add(q)
+        answer_counts[a] += 1
+        qas.append(QA(q, a, qa.category))
+
+    return qas
+
+
+def write_csv(qas: List[QA], question_path: Path, answer_path: Path) -> None:
+    question_path.parent.mkdir(parents=True, exist_ok=True)
+
+    with question_path.open("w", encoding="utf-8", newline="") as f:
+        w = csv.writer(f, quoting=csv.QUOTE_ALL)
+        w.writerow(["question"])
+        for qa in qas:
+            w.writerow([sanitize_cell(qa.question)])
+
+    with answer_path.open("w", encoding="utf-8", newline="") as f:
+        w = csv.writer(f, quoting=csv.QUOTE_ALL)
+        w.writerow(["answer"])
+        for qa in qas:
+            w.writerow([sanitize_cell(qa.answer)])
+
+
+def print_stats(qas: List[QA]) -> None:
+    q_lens = [len(info_tokens(qa.question)) for qa in qas]
+    a_counts = Counter([qa.answer for qa in qas])
+    top_a = a_counts.most_common(5)
+    cat_counts = Counter([qa.category for qa in qas])
+
+    print("QAs:", len(qas))
+    print("Categories:", dict(cat_counts))
+    print("InfoTokens: min/avg/max =",
+          min(q_lens),
+          round(sum(q_lens) / len(q_lens), 2),
+          max(q_lens))
+    print("Unique answers:", len(a_counts))
+    print("Most repeated answers:")
+    for ans, n in top_a:
+        print(" ", n, "x |", ans.splitlines()[0][:90])
+
+
+def main() -> None:
+    qas = generate_dataset(count=400, seed=79079)
+    write_csv(qas, QUESTION_CSV, ANSWER_CSV)
+    print_stats(qas)
+    print("Wrote:", QUESTION_CSV)
+    print("Wrote:", ANSWER_CSV)
+
+
+if __name__ == "__main__":
+    main()