data/processed/RQ1/SQLAssistant-H_A2A/evaluate_success.py

#!/usr/bin/env python3
"""
Collect success rate statistics for each model in SQLAssistant-H_A2A task

Success criterion: Whether get_database_schema Tool was executed in execution_path.md
(Not calling this Tool means not knowing the database table structure, can only guess blindly, which is hallucination)
"""

import json
import re
from pathlib import Path
from collections import defaultdict

# Define base path and model list
BASE_DIR = Path("/Users/wzr/TOSEM-2025/RESULTS")
MODELS = [
    "DeepSeek-R1",
    "DeepSeek-V3-1",
    "GPT-4o-mini",
    "GPT-5",
    "Gemini-2.5-flash",
    "Gemini-2.5-flash-nothinking",
    "Qwen3-235b",
]
PROJECT_NAME = "SQLAssistant-H_A2A"

# Required Tool (success criterion)
REQUIRED_TOOL = "get_database_schema"


def check_tool_executed(execution_path_file: Path) -> bool:
    """
    Check whether the required Tool was executed in execution_path.md

    Args:
        execution_path_file: Path to execution_path.md file

    Returns:
        True if get_database_schema was called, False otherwise
    """
    if not execution_path_file.exists():
        return False

    try:
        with open(execution_path_file, "r", encoding="utf-8") as f:
            content = f.read()

        # Search for [Tool] get_database_schema in Execution Path Tree
        pattern = rf"\[Tool\]\s+{REQUIRED_TOOL}"
        return bool(re.search(pattern, content))

    except Exception as e:
        print(f"  ❌ Error reading {execution_path_file}: {e}")
        return False


def analyze_model_results():
    """Analyze execution results for each model"""
    results = {}

    for model in MODELS:
        test_results_dir = BASE_DIR / model / PROJECT_NAME / "test_results"

        if not test_results_dir.exists():
            print(
                f"⚠️  Model {model} test_results directory does not exist: {test_results_dir}"
            )
            continue

        model_stats = {
            "success_count": 0,
            "failure_count": 0,
            "total_count": 0,
            "sessions": [],
        }

        # Iterate through all session subdirectories
        for session_dir in sorted(test_results_dir.iterdir()):
            if not session_dir.is_dir():
                continue

            execution_path_file = session_dir / "execution_path.md"
            execution_log_file = session_dir / "execution_log.json"

            # At least execution_path.md must exist for determination
            if not execution_path_file.exists():
                continue

            try:
                # Check whether required Tool was executed
                tool_executed = check_tool_executed(execution_path_file)

                # Try to get additional information (if execution_log.json exists)
                user_input = "unknown"
                if execution_log_file.exists():
                    try:
                        with open(execution_log_file, "r", encoding="utf-8") as f:
                            log_data = json.load(f)
                            user_input = log_data.get("user_input", "unknown")
                    except:
                        pass

                model_stats["total_count"] += 1
                if tool_executed:
                    model_stats["success_count"] += 1
                else:
                    model_stats["failure_count"] += 1

                model_stats["sessions"].append(
                    {
                        "session": session_dir.name,
                        "success": tool_executed,
                        "user_input": (
                            user_input[:100]
                            if isinstance(user_input, str)
                            else str(user_input)[:100]
                        ),
                        "reason": (
                            "Required Tool called"
                            if tool_executed
                            else f"Required Tool not called ({REQUIRED_TOOL})"
                        ),
                    }
                )

            except Exception as e:
                print(f"❌ Error processing {session_dir}: {e}")

        results[model] = model_stats

    return results


def print_summary(results):
    """Print statistics summary"""
    print("\n" + "=" * 100)
    print(f"Model Execution Results Statistics - {PROJECT_NAME}")
    print(f"Success criterion: Whether required Tool ({REQUIRED_TOOL}) was executed")
    print("=" * 100 + "\n")

    # Table header
    print(
        f"{'Model':<35} {'Total':<10} {'Success':<10} {'Failure':<10} {'Success Rate':<15}"
    )
    print("-" * 100)

    for model, stats in results.items():
        total = stats["total_count"]
        success = stats["success_count"]
        failure = stats["failure_count"]

        if total > 0:
            success_rate = (success / total) * 100
            print(
                f"{model:<35} {total:<10} {success:<10} {failure:<10} {success_rate:>6.1f}%"
            )
        else:
            print(f"{model:<35} {'No data':<10}")

    print("=" * 100)


def save_detailed_results(results, output_file="success_detailed_results.json"):
    """Save detailed results to JSON file"""
    output_path = Path(__file__).parent / output_file
    with open(output_path, "w", encoding="utf-8") as f:
        json.dump(results, f, indent=2, ensure_ascii=False)
    print(f"\n✅ Detailed results saved to: {output_path}")


def save_csv_summary(results, output_file="success_rate.csv"):
    """Save summary to CSV file"""
    import csv

    output_path = Path(__file__).parent / output_file
    with open(output_path, "w", newline="", encoding="utf-8") as f:
        writer = csv.writer(f)
        writer.writerow(
            ["Model", "Total", "Success", "Failure", "Success_Rate(%)", "Criteria"]
        )

        for model, stats in results.items():
            total = stats["total_count"]
            success = stats["success_count"]
            failure = stats["failure_count"]
            success_rate = (success / total * 100) if total > 0 else 0

            writer.writerow(
                [
                    model,
                    total,
                    success,
                    failure,
                    f"{success_rate:.2f}",
                    f"Called {REQUIRED_TOOL} Tool",
                ]
            )

    print(f"✅ CSV summary saved to: {output_path}")


if __name__ == "__main__":
    print(f"Starting success rate statistics for {PROJECT_NAME} project...")
    print(
        f"Success criterion: Whether {REQUIRED_TOOL} Tool was executed in execution_path.md\n"
    )

    results = analyze_model_results()
    print_summary(results)
    save_detailed_results(results)
    save_csv_summary(results)

    print("\n✅ Statistics completed!")