| |
| """ |
| Independent validation pass over the generated ICSThreatQA Hugging Face |
| table. Re-derives the dataset from the original .xlsx files and compares it |
| against the checked-in CSV/Parquet outputs, then reports data-quality |
| findings without silently modifying anything. |
| |
| Usage: |
| python scripts/validate_dataset.py |
| |
| Exit code is non-zero only for an *actual* data error (missing file, missing |
| column, unexpected row-count drift, duplicate IDs, CSV/Parquet mismatch, or |
| non-deterministic regeneration). Duplicate questions/rows that genuinely |
| exist in the original benchmark, and the known trailing-blank-row formatting |
| artifact in factual.xlsx, are reported but do NOT fail validation. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import sys |
| from pathlib import Path |
|
|
| import pandas as pd |
|
|
| SCRIPT_DIR = Path(__file__).resolve().parent |
| sys.path.insert(0, str(SCRIPT_DIR)) |
| import prepare_dataset as prep |
|
|
| RELEASE_DIR = SCRIPT_DIR.parent |
| DATA_DIR = RELEASE_DIR / "data" |
| CSV_PATH = DATA_DIR / "icsthreatqa.csv" |
| PARQUET_PATH = DATA_DIR / "icsthreatqa.parquet" |
|
|
| EXPECTED_TOTAL = 620 |
|
|
|
|
| def section(title: str) -> None: |
| print() |
| print(f"--- {title} ---") |
|
|
|
|
| def main() -> int: |
| errors: list[str] = [] |
| notes: list[str] = [] |
|
|
| if not CSV_PATH.exists(): |
| print(f"VALIDATION FAILED: {CSV_PATH} not found. Run prepare_dataset.py first.") |
| return 1 |
| if not PARQUET_PATH.exists(): |
| print(f"VALIDATION FAILED: {PARQUET_PATH} not found. Run prepare_dataset.py first.") |
| return 1 |
|
|
| csv_df = pd.read_csv(CSV_PATH, dtype=str, keep_default_na=False) |
| parquet_df = pd.read_parquet(PARQUET_PATH).astype(str) |
|
|
| |
| |
| |
| |
| section("Deterministic regeneration") |
| frames = [] |
| per_category_counts = {} |
| try: |
| for category, (filename, prefix) in prep.CATEGORIES.items(): |
| df = prep.load_category(category, filename, prefix) |
| per_category_counts[category] = len(df) |
| frames.append(df) |
| rebuilt = pd.concat(frames, ignore_index=True) |
| except prep.ValidationError as e: |
| errors.append(f"Could not regenerate dataset from raw files: {e}") |
| rebuilt = None |
|
|
| if rebuilt is not None: |
| rebuilt_str = rebuilt.astype(str) |
| if rebuilt_str.equals(csv_df.reset_index(drop=True)): |
| print("OK: regenerating from raw .xlsx files reproduces the checked-in CSV exactly.") |
| else: |
| errors.append( |
| "Regenerating from raw .xlsx files does NOT match the checked-in CSV. " |
| "The dataset may be stale relative to the source files." |
| ) |
|
|
| |
| |
| |
| section("Record counts") |
| total = len(csv_df) |
| print(f"Total QA records: {total}") |
| for cat, n in per_category_counts.items(): |
| print(f" {cat}: {n}") |
|
|
| if total != EXPECTED_TOTAL: |
| notes.append( |
| f"Total record count is {total}, not the {EXPECTED_TOTAL} pairs described " |
| f"in the project README. Verified against raw .xlsx row counts (see below); " |
| f"this is reported as a discrepancy, not corrected." |
| ) |
| print( |
| f"NOTE: expected {EXPECTED_TOTAL} per README, found {total}. " |
| f"Not auto-corrected -- see report." |
| ) |
| else: |
| print(f"Matches expected total of {EXPECTED_TOTAL}.") |
|
|
| |
| |
| |
| section("Missing values") |
| missing_q = (csv_df["question"].str.strip() == "").sum() |
| missing_a = (csv_df["answer"].str.strip() == "").sum() |
| print(f"Missing/empty questions: {missing_q}") |
| print(f"Missing/empty answers: {missing_a}") |
| if missing_q or missing_a: |
| errors.append(f"Found missing question/answer fields: {missing_q} / {missing_a}") |
|
|
| |
| |
| |
| section("Duplicate analysis (informational -- originals are preserved)") |
| dup_questions_overall = csv_df["question"].duplicated().sum() |
| print(f"Duplicate questions (exact text, across entire dataset): {dup_questions_overall}") |
| for cat in per_category_counts: |
| sub = csv_df[csv_df["question_type"] == cat] |
| d = sub["question"].duplicated().sum() |
| if d: |
| print(f" within {cat}: {d} duplicate question(s) -- present in original {cat}.xlsx") |
|
|
| dup_full_rows = csv_df.duplicated(subset=["question", "answer", "question_type"]).sum() |
| print(f"Duplicate full rows (question+answer+category): {dup_full_rows}") |
| notes.append( |
| f"{dup_questions_overall} duplicate question(s) and {dup_full_rows} duplicate " |
| f"full row(s) exist in the original benchmark workbooks and were intentionally " |
| f"preserved (not deduplicated)." |
| ) |
|
|
| dup_ids = csv_df["id"].duplicated().sum() |
| print(f"Duplicate stable IDs: {dup_ids}") |
| if dup_ids: |
| errors.append(f"Found {dup_ids} duplicate stable ID(s) -- this IS an error.") |
|
|
| |
| |
| |
| section("Category values") |
| valid_categories = set(prep.CATEGORIES.keys()) |
| found_categories = set(csv_df["question_type"].unique()) |
| print(f"question_type values found: {sorted(found_categories)}") |
| if found_categories - valid_categories: |
| errors.append(f"Unexpected question_type value(s): {found_categories - valid_categories}") |
| if valid_categories - found_categories: |
| errors.append(f"Missing expected question_type value(s): {valid_categories - found_categories}") |
|
|
| |
| |
| |
| section("CSV / Parquet equality") |
| parquet_df_filled = parquet_df.fillna("") |
| if csv_df.reset_index(drop=True).equals(parquet_df_filled.reset_index(drop=True)): |
| print("OK: CSV and Parquet contain identical data.") |
| else: |
| errors.append("CSV and Parquet outputs do not contain identical data.") |
|
|
| |
| |
| |
| section("Summary") |
| if notes: |
| print("Notes (non-fatal, documented discrepancies / known duplicates):") |
| for n in notes: |
| print(f" - {n}") |
| if errors: |
| print("\nERRORS (actual data-quality problems):") |
| for e in errors: |
| print(f" - {e}") |
| print("\nVALIDATION FAILED.") |
| return 1 |
|
|
| print("\nVALIDATION PASSED (with the documented notes above, if any).") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
