validate_dataset.py

#!/usr/bin/env python3
"""
African Civil Service Capacity — Validation & Diagnostic Plots
==============================================================
Checks plausibility of generated CSV files and produces summary plots.
"""

import os
import sys
import glob as globmod
import numpy as np
import pandas as pd
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt

DATA_DIR = os.path.join(os.path.dirname(__file__), "data")
PLOT_DIR = os.path.join(DATA_DIR, "plots")

REQUIRED_COLUMNS = [
    "record_id", "country", "year", "region_type", "sector", "grade_level",
    "population_millions", "total_posts", "vacancy_rate", "filled_posts",
    "degree_rate", "degree_holders", "training_hours_annual",
    "training_participation_rate", "retention_rate", "avg_salary_usd",
    "wage_bill_pct_gdp", "performance_eval_rate", "digital_literacy_rate",
    "capacity_score", "capacity_class",
]

EXPECTED_COUNTRIES = {
    "South Africa", "Kenya", "Nigeria", "Ghana", "Tanzania", "Uganda",
    "Rwanda", "Ethiopia", "Senegal", "DRC", "Mozambique", "Botswana",
}
EXPECTED_REGIONS = {"capital", "urban", "rural", "remote"}
EXPECTED_CLASSES = {"high", "moderate", "low", "critical"}
EXPECTED_GRADES = {"Junior", "Mid_Level", "Senior", "Director", "Executive"}
EXPECTED_SECTORS = {
    "Health", "Education", "Finance", "Infrastructure", "Agriculture",
    "Security", "Justice", "Social_Services", "Administration", "ICT",
}

RANGE_CHECKS = {
    "vacancy_rate": (0.05, 0.60),
    "degree_rate": (0.10, 0.80),
    "training_participation_rate": (0.20, 0.95),
    "retention_rate": (0.50, 0.98),
    "performance_eval_rate": (0.15, 0.95),
    "digital_literacy_rate": (0.10, 0.90),
    "capacity_score": (0.0, 1.0),
    "wage_bill_pct_gdp": (0.0, 0.20),
    "population_millions": (0.1, 300.0),
    "avg_salary_usd": (20, 5000),
}


def check_columns(df, filepath):
    missing = set(REQUIRED_COLUMNS) - set(df.columns)
    extra = set(df.columns) - set(REQUIRED_COLUMNS)
    errors = []
    if missing:
        errors.append(f"  Missing columns: {missing}")
    if extra:
        errors.append(f"  Extra columns: {extra}")
    return errors


def check_ranges(df, filepath):
    errors = []
    for col, (lo, hi) in RANGE_CHECKS.items():
        if col in df.columns:
            below = (df[col] < lo).sum()
            above = (df[col] > hi).sum()
            if below:
                errors.append(f"  {col}: {below} values below {lo}")
            if above:
                errors.append(f"  {col}: {above} values above {hi}")
    return errors


def check_categorical(df, filepath):
    errors = []
    checks = [
        ("country", EXPECTED_COUNTRIES),
        ("region_type", EXPECTED_REGIONS),
        ("capacity_class", EXPECTED_CLASSES),
        ("grade_level", EXPECTED_GRADES),
        ("sector", EXPECTED_SECTORS),
    ]
    for col, expected in checks:
        if col in df.columns:
            actual = set(df[col].unique())
            unexpected = actual - expected
            if unexpected:
                errors.append(f"  {col}: unexpected values {unexpected}")
    return errors


def check_consistency(df, filepath):
    errors = []
    if "filled_posts" in df.columns and "total_posts" in df.columns:
        bad = (df["filled_posts"] > df["total_posts"]).sum()
        if bad:
            errors.append(f"  filled_posts > total_posts in {bad} rows")
    if "degree_holders" in df.columns and "filled_posts" in df.columns:
        bad = (df["degree_holders"] > df["filled_posts"]).sum()
        if bad:
            errors.append(f"  degree_holders > filled_posts in {bad} rows")
    if "capacity_class" in df.columns and "capacity_score" in df.columns:
        for label, lo, hi in [("high", 0.65, 1.01), ("moderate", 0.50, 0.65),
                               ("low", 0.35, 0.50), ("critical", 0.0, 0.35)]:
            mask = df["capacity_class"] == label
            if mask.any():
                scores = df.loc[mask, "capacity_score"]
                out = ((scores < lo) | (scores >= hi)).sum()
                if out:
                    errors.append(f"  capacity_class '{label}': {out} scores outside [{lo:.2f}, {hi:.2f})")
    return errors


def print_summary(df, scenario_name):
    print(f"\n{'='*60}")
    print(f"  {scenario_name} — {len(df)} records")
    print(f"{'='*60}")
    print(f"  Countries: {sorted(df['country'].unique())}")
    print(f"  Years: {sorted(df['year'].unique())}")
    print(f"  Capacity classes: {df['capacity_class'].value_counts().to_dict()}")
    print(f"  vacancy_rate:   mean={df['vacancy_rate'].mean():.4f}  std={df['vacancy_rate'].std():.4f}")
    print(f"  degree_rate:    mean={df['degree_rate'].mean():.4f}  std={df['degree_rate'].std():.4f}")
    print(f"  training_hrs:   mean={df['training_hours_annual'].mean():.1f}  std={df['training_hours_annual'].std():.1f}")
    print(f"  capacity_score: mean={df['capacity_score'].mean():.4f}  std={df['capacity_score'].std():.4f}")
    print(f"  retention_rate: mean={df['retention_rate'].mean():.4f}  std={df['retention_rate'].std():.4f}")
    print(f"  digital_lit:    mean={df['digital_literacy_rate'].mean():.4f}  std={df['digital_literacy_rate'].std():.4f}")
    print(f"  wage_bill_pct:  mean={df['wage_bill_pct_gdp'].mean():.4f}  std={df['wage_bill_pct_gdp'].std():.4f}")
    print()


def make_plots(dfs, names):
    os.makedirs(PLOT_DIR, exist_ok=True)
    fig, axes = plt.subplots(2, 3, figsize=(18, 10))
    fig.suptitle("African Civil Service Capacity — Scenario Comparison", fontsize=14)

    metrics = [
        ("vacancy_rate", "Vacancy Rate"),
        ("degree_rate", "Degree Rate"),
        ("training_hours_annual", "Training Hours (Annual)"),
        ("capacity_score", "Capacity Score"),
        ("retention_rate", "Retention Rate"),
        ("digital_literacy_rate", "Digital Literacy Rate"),
    ]
    colors = ["#2196F3", "#4CAF50", "#FF9800"]
    for ax, (col, title) in zip(axes.flat, metrics):
        for df, name, c in zip(dfs, names, colors):
            ax.hist(df[col], bins=40, alpha=0.45, label=name, color=c, density=True)
        ax.set_title(title)
        ax.legend(fontsize=8)
        ax.set_xlabel(col)
        ax.set_ylabel("Density")
    plt.tight_layout()
    path = os.path.join(PLOT_DIR, "scenario_comparison.png")
    plt.savefig(path, dpi=150)
    plt.close()
    print(f"Saved plot: {path}")

    fig, axes = plt.subplots(1, 3, figsize=(18, 5))
    fig.suptitle("Capacity Class Distribution by Scenario", fontsize=14)
    for ax, df, name in zip(axes, dfs, names):
        counts = df["capacity_class"].value_counts().reindex(
            ["critical", "low", "moderate", "high"]).fillna(0)
        counts.plot.bar(ax=ax, color=["#d32f2f", "#FF9800", "#FFC107", "#4CAF50"])
        ax.set_title(name)
        ax.set_ylabel("Count")
        ax.tick_params(axis='x', rotation=0)
    plt.tight_layout()
    path = os.path.join(PLOT_DIR, "capacity_class_distribution.png")
    plt.savefig(path, dpi=150)
    plt.close()
    print(f"Saved plot: {path}")

    fig, axes = plt.subplots(1, 3, figsize=(18, 5))
    fig.suptitle("Vacancy Rate by Country", fontsize=14)
    for ax, df, name in zip(axes, dfs, names):
        df.boxplot(column="vacancy_rate", by="country", ax=ax, rot=45, fontsize=7)
        ax.set_title(name)
        ax.set_ylabel("Vacancy Rate")
    plt.tight_layout()
    path = os.path.join(PLOT_DIR, "vacancy_by_country.png")
    plt.savefig(path, dpi=150)
    plt.close()
    print(f"Saved plot: {path}")

    fig, axes = plt.subplots(1, 3, figsize=(18, 5))
    fig.suptitle("Capacity Score by Country", fontsize=14)
    for ax, df, name in zip(axes, dfs, names):
        df.boxplot(column="capacity_score", by="country", ax=ax, rot=45, fontsize=7)
        ax.set_title(name)
        ax.set_ylabel("Capacity Score")
    plt.tight_layout()
    path = os.path.join(PLOT_DIR, "capacity_by_country.png")
    plt.savefig(path, dpi=150)
    plt.close()
    print(f"Saved plot: {path}")


def main():
    csv_files = sorted(globmod.glob(os.path.join(DATA_DIR, "*.csv")))
    if not csv_files:
        print("ERROR: No CSV files found in", DATA_DIR)
        sys.exit(1)

    all_dfs = []
    all_names = []
    total_errors = 0

    for fpath in csv_files:
        name = os.path.splitext(os.path.basename(fpath))[0]
        df = pd.read_csv(fpath)
        all_dfs.append(df)
        all_names.append(name)

        print(f"\n>>> Validating {fpath} ({len(df)} rows)")
        errors = []
        errors += check_columns(df, fpath)
        errors += check_ranges(df, fpath)
        errors += check_categorical(df, fpath)
        errors += check_consistency(df, fpath)

        if errors:
            print("  FAILURES:")
            for e in errors:
                print(e)
            total_errors += len(errors)
        else:
            print("  All checks passed.")

        print_summary(df, name)

    make_plots(all_dfs, all_names)

    print(f"\n{'='*60}")
    if total_errors == 0:
        print("ALL VALIDATION CHECKS PASSED")
    else:
        print(f"VALIDATION COMPLETE — {total_errors} issue(s) found")
    print(f"{'='*60}")
    sys.exit(0 if total_errors == 0 else 1)


if __name__ == "__main__":
    main()