restructure + add files

data/processed/RQ3/plot_total_tokens_violin.py

@@ -1,15 +1,25 @@
 #!/usr/bin/env python3
 
 import csv
+import os
 from collections import defaultdict
 from pathlib import Path
 from typing import Dict, List, Tuple
 
-import matplotlib.pyplot as plt
 import numpy as np
-from matplotlib.ticker import FuncFormatter
 
-plt.rcParams["font.family"] = "Times New Roman"
+try:
+    import matplotlib.pyplot as plt
+    from matplotlib.ticker import FuncFormatter
+
+    HAS_MATPLOTLIB = True
+except ModuleNotFoundError:
+    plt = None  # type: ignore[assignment]
+    FuncFormatter = None  # type: ignore[assignment]
+    HAS_MATPLOTLIB = False
+
+if HAS_MATPLOTLIB:
+    plt.rcParams["font.family"] = "Times New Roman"
 
 MODEL_ORDER: List[str] = [
     "GPT-5",
@@ -31,6 +41,14 @@ MODEL_LABELS: Dict[str, str] = {
     "Qwen3-235b": "Qwen3-235b",
 }
 
+
+ARCH_ORDER: List[str] = [
+    "Unknown",
+    "MCP",
+    "A2A",
+    "A2A_mix",
+]
+
 MODEL_COLORS: Dict[str, str] = {
     "GPT-5": "#1f77b4",
     "GPT-4o-mini": "#ff7f0e",
@@ -54,6 +72,135 @@ STATUS_TITLES: Dict[str, str] = {
 }
 
 
+def infer_project_dir(file_path: str) -> str:
+    raw = (file_path or "").strip()
+    if not raw:
+        return ""
+    try:
+        p = Path(raw)
+        return p.parents[2].name
+    except Exception:
+        return ""
+
+
+def infer_architecture(project_dir: str) -> str:
+    name = (project_dir or "").strip()
+    if not name:
+        return "Unknown"
+    if name.endswith("-MCP"):
+        return "MCP"
+    if name.endswith("-H_A2A") or name.endswith("-H-A2A"):
+        return "A2A_mix"
+    if name.endswith("-A2A"):
+        return "A2A"
+    return "Unknown"
+
+
+def infer_base_task(project_dir: str) -> str:
+    name = (project_dir or "").strip()
+    for suffix in ("-H_A2A", "-H-A2A", "-MCP", "-A2A"):
+        if name.endswith(suffix):
+            return name[: -len(suffix)]
+    return name
+
+
+def make_project_name(base_task: str, arch: str) -> str:
+    task = (base_task or "").strip()
+    if not task:
+        return ""
+    if arch == "Unknown":
+        return task
+    if arch == "MCP":
+        return f"{task}-MCP"
+    if arch == "A2A_mix":
+        return f"{task}-H-A2A"
+    if arch == "A2A":
+        return f"{task}-A2A"
+    return f"{task}-{arch}"
+
+
+def infer_architecture_from_project_name(project_name: str) -> str:
+    name = (project_name or "").strip()
+    if not name:
+        return "Unknown"
+    if name.endswith("-MCP"):
+        return "MCP"
+    if name.endswith("-H-A2A") or name.endswith("-H_A2A"):
+        return "A2A_mix"
+    if name.endswith("-A2A"):
+        return "A2A"
+    return "Unknown"
+
+
+def base_task_from_project_name(project_name: str) -> str:
+    name = (project_name or "").strip()
+    for suffix in ("-H-A2A", "-H_A2A", "-MCP", "-A2A"):
+        if name.endswith(suffix):
+            return name[: -len(suffix)]
+    return name
+
+
+def export_violin_input_summary(
+    projects: List[Tuple[str, str, str]],
+    project_data: Dict[str, Dict[str, Dict[str, List[float]]]],
+    out_dir: Path,
+) -> None:
+    if (os.environ.get("EXPORT_VIOLIN_INPUT") or "").strip() not in {
+        "1",
+        "true",
+        "True",
+    }:
+        return
+
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out_path = out_dir / "violin_input_summary.csv"
+
+    with out_path.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerow(
+            [
+                "project",
+                "base_task",
+                "architecture",
+                "status_group",
+                "model",
+                "n",
+                "mean",
+                "median",
+                "min",
+                "max",
+            ]
+        )
+
+        for _, _, name in projects:
+            pdata = project_data.get(name, {})
+            base_task = base_task_from_project_name(name)
+            arch = infer_architecture_from_project_name(name)
+            for status in STATUS_ORDER:
+                by_model = pdata.get(status, {})
+                for model in MODEL_ORDER:
+                    vals = by_model.get(model, [])
+                    if not vals:
+                        continue
+                    arr = np.asarray(vals, dtype=float)
+                    writer.writerow(
+                        [
+                            name,
+                            base_task,
+                            arch,
+                            status,
+                            model,
+                            int(arr.size),
+                            float(np.mean(arr)),
+                            float(np.median(arr)),
+                            float(np.min(arr)),
+                            float(np.max(arr)),
+                        ]
+                    )
+
+    print(f"saved violin input summary: {out_path}")
+
+
 def _nice_step(max_val: float, target_ticks: int = 6) -> float:
     if max_val <= 0:
         return 1.0
@@ -79,21 +226,47 @@ def _token_formatter(x, pos):
     return str(int(x))
 
 
-def load_projects(summary_csv: Path) -> List[Tuple[str, str, str]]:
-    projects: List[Tuple[str, str, str]] = []
-    with summary_csv.open("r", encoding="utf-8", newline="") as f:
+def load_projects(
+    details_csv: Path,
+) -> Tuple[List[Tuple[str, str, str]], Dict[Tuple[str, str], str]]:
+    present: Dict[str, set] = defaultdict(set)
+
+    with details_csv.open("r", encoding="utf-8", newline="") as f:
         reader = csv.DictReader(f)
         for row in reader:
-            task = (row.get("task") or "").strip()
-            arch = (row.get("architecture") or "").strip()
-            if not task or not arch:
+            project_dir = infer_project_dir(row.get("file_path") or "")
+            if not project_dir:
                 continue
-            if arch == "Unknown":
-                name = task
-            else:
-                name = f"{task}-{arch}"
-            projects.append((task, arch, name))
-    return projects
+            arch = infer_architecture(project_dir)
+            base_task = infer_base_task(project_dir)
+            if not base_task:
+                continue
+
+            model = (row.get("model") or "").strip()
+            if model and model not in MODEL_ORDER:
+                continue
+
+            total_raw = row.get("total_tokens")
+            if total_raw is None or total_raw == "":
+                continue
+            try:
+                float(total_raw)
+            except ValueError:
+                continue
+
+            present[base_task].add(arch)
+
+    projects: List[Tuple[str, str, str]] = []
+    project_map: Dict[Tuple[str, str], str] = {}
+    for base_task in sorted(present.keys()):
+        for arch in ARCH_ORDER:
+            if arch not in present[base_task]:
+                continue
+            name = make_project_name(base_task, arch)
+            project_map[(base_task, arch)] = name
+            projects.append((base_task, arch, name))
+
+    return projects, project_map
 
 
 def classify_status(status_raw: str, with_retry_raw: str) -> str:
@@ -116,10 +289,14 @@ def load_total_tokens(
     with details_csv.open("r", encoding="utf-8", newline="") as f:
         reader = csv.DictReader(f)
         for row in reader:
-            task = (row.get("task") or "").strip()
-            arch = (row.get("architecture") or "").strip()
+            project_dir = infer_project_dir(row.get("file_path") or "")
+            if not project_dir:
+                continue
+            task = infer_base_task(project_dir)
+            arch = infer_architecture(project_dir)
             key = (task, arch)
-            if key not in project_map:
+            project_name = project_map.get(key) or make_project_name(task, arch)
+            if not project_name:
                 continue
 
             model = (row.get("model") or "").strip()
@@ -136,7 +313,6 @@ def load_total_tokens(
             except ValueError:
                 continue
 
-            project_name = project_map[key]
             data[project_name][status_group][model].append(total_val)
 
     return data
@@ -166,10 +342,14 @@ def load_all_token_data(
     with details_csv.open("r", encoding="utf-8", newline="") as f:
         reader = csv.DictReader(f)
         for row in reader:
-            task = (row.get("task") or "").strip()
-            arch = (row.get("architecture") or "").strip()
+            project_dir = infer_project_dir(row.get("file_path") or "")
+            if not project_dir:
+                continue
+
+            task = infer_base_task(project_dir)
+            arch = infer_architecture(project_dir)
             key = (task, arch)
-            project_name = project_map.get(key)
+            project_name = project_map.get(key) or make_project_name(task, arch)
             if not project_name:
                 continue
 
@@ -241,16 +421,24 @@ def generate_project_stats_md(
     overall_status_values: Dict[str, List[float]],
     out_dir: Path,
 ) -> None:
+    def _base_task_name(task: str) -> str:
+        suffixes = ("-H_A2A", "-H-A2A", "-MCP", "-A2A")
+        for suffix in suffixes:
+            if task.endswith(suffix):
+                return task[: -len(suffix)]
+        return task
+
     def build_series_data() -> Dict[str, Dict[str, Dict[str, List[float]]]]:
         series: Dict[str, Dict[str, Dict[str, List[float]]]] = defaultdict(
             lambda: defaultdict(lambda: defaultdict(list))
         )
         for task, arch, name in projects:
+            base_task = _base_task_name(task)
             pdata = project_data.get(name, {})
             for status in STATUS_ORDER:
                 by_model = pdata.get(status, {})
                 for model, vals in by_model.items():
-                    series[task][status][model].extend(vals)
+                    series[base_task][status][model].extend(vals)
         return series
 
     def append_status_table(
@@ -350,7 +538,7 @@ def generate_project_stats_md(
         for task in sorted(series_data.keys()):
             sdata = series_data[task]
             lines.append("")
-            lines.append(f"### {task} (aggregated across architectures)")
+            lines.append(f"### {task} (aggregated across variants)")
             append_status_table(lines, sdata, statuses)
             append_status_comparison(
                 lines,
@@ -384,184 +572,189 @@ def generate_architecture_deltas_md(
     arch_model_data: Dict[str, Dict[str, Dict[str, List[float]]]],
     out_dir: Path,
 ) -> None:
-    lines: List[str] = []
-    lines.append("# Token shifts across architectures")
-    lines.append("")
-    lines.append(
-        "Two series are reported per task (when data is available):\n"
-        "- **Pure CrewAI → MCP** (architecture labels: Unknown → MCP)\n"
-        "- **MCP → A2A → A2A_mix**\n"
-        "Each series shows the absolute change (Δ) and the relative percentage change of the mean total tokens."
-    )
+    def write_report(title: str, chain: List[str], filename: str) -> None:
+        lines: List[str] = []
+        lines.append("# Token shifts across architectures")
+        lines.append("")
+        lines.append(f"Series: **{title}**")
+        lines.append("")
+        lines.append(
+            "Each table shows the absolute change (Δ) and the relative percentage change of the mean total tokens."
+        )
+
+        def render_pair(task_arch_data: Dict[str, Dict[str, List[float]]]) -> None:
+            arch_display = {
+                "Unknown": "Pure CrewAI",
+                "MCP": "MCP",
+                "A2A": "A2A",
+                "A2A_mix": "H-A2A",
+            }
 
-    def render_chain(
-        task: str, chain: List[str], task_arch_data: Dict[str, Dict[str, List[float]]]
-    ) -> None:
-        arch_display = {
-            "Unknown": "CrewAI (Unknown)",
-            "MCP": "MCP",
-            "A2A": "A2A",
-            "A2A_mix": "A2A_mix",
-        }
-
-        is_pair = len(chain) == 2
-        if is_pair:
             header = f"| Model | {arch_display[chain[0]]} | {arch_display[chain[1]]} | Δ {arch_display[chain[1]]}-{arch_display[chain[0]]} |"
             sep = "| --- | --- | --- | --- |"
-        else:
-            header = (
-                f"| Model | {arch_display[chain[0]]} | {arch_display[chain[1]]} | Δ {arch_display[chain[1]]}-{arch_display[chain[0]]} | "
-                f"{arch_display[chain[2]]} | Δ {arch_display[chain[2]]}-{arch_display[chain[1]]} |"
-            )
-            sep = "| --- | --- | --- | --- | --- | --- |"
-
-        lines.append("")
-        lines.append(header)
-        lines.append(sep)
 
-        for model in MODEL_ORDER:
-            arch_means: Dict[str, float] = {}
-            for arch in chain:
-                vals = task_arch_data.get(arch, {}).get(model, [])
-                arch_means[arch] = float(np.mean(vals)) if vals else None
+            lines.append("")
+            lines.append(header)
+            lines.append(sep)
 
-            if is_pair:
-                row = [
-                    MODEL_LABELS.get(model, model),
-                    (
-                        "-"
-                        if arch_means[chain[0]] is None
-                        else _fmt_number(arch_means[chain[0]])
-                    ),
-                    (
-                        "-"
-                        if arch_means[chain[1]] is None
-                        else _fmt_number(arch_means[chain[1]])
-                    ),
-                    _fmt_delta(arch_means[chain[1]], arch_means[chain[0]]),
-                ]
-            else:
+            for model in MODEL_ORDER:
+                left_vals = task_arch_data.get(chain[0], {}).get(model, [])
+                right_vals = task_arch_data.get(chain[1], {}).get(model, [])
+                left_mean = float(np.mean(left_vals)) if left_vals else None
+                right_mean = float(np.mean(right_vals)) if right_vals else None
                 row = [
                     MODEL_LABELS.get(model, model),
-                    (
-                        "-"
-                        if arch_means[chain[0]] is None
-                        else _fmt_number(arch_means[chain[0]])
-                    ),
-                    (
-                        "-"
-                        if arch_means[chain[1]] is None
-                        else _fmt_number(arch_means[chain[1]])
-                    ),
-                    _fmt_delta(arch_means[chain[1]], arch_means[chain[0]]),
-                    (
-                        "-"
-                        if arch_means[chain[2]] is None
-                        else _fmt_number(arch_means[chain[2]])
-                    ),
-                    _fmt_delta(arch_means[chain[2]], arch_means[chain[1]]),
+                    "-" if left_mean is None else _fmt_number(left_mean),
+                    "-" if right_mean is None else _fmt_number(right_mean),
+                    _fmt_delta(right_mean, left_mean),
                 ]
-            lines.append("| " + " | ".join(row) + " |")
+                lines.append("| " + " | ".join(row) + " |")
 
-        # project-level
-        lines.append("")
-        lines.append("Project-level average (all models combined)")
-        lines.append("")
-        if is_pair:
+            lines.append("")
+            lines.append("Project-level average (all models combined)")
+            lines.append("")
             lines.append(
                 f"| Metric | {arch_display[chain[0]]} | {arch_display[chain[1]]} | Δ {arch_display[chain[1]]}-{arch_display[chain[0]]} |"
             )
             lines.append("| --- | --- | --- | --- |")
-        else:
+
+            def _mean_all(arch: str) -> float:
+                combined: List[float] = []
+                for vals in task_arch_data.get(arch, {}).values():
+                    combined.extend(vals)
+                return float(np.mean(combined)) if combined else None
+
+            left_all = _mean_all(chain[0])
+            right_all = _mean_all(chain[1])
             lines.append(
-                f"| Metric | {arch_display[chain[0]]} | {arch_display[chain[1]]} | Δ {arch_display[chain[1]]}-{arch_display[chain[0]]} | "
-                f"{arch_display[chain[2]]} | Δ {arch_display[chain[2]]}-{arch_display[chain[1]]} |"
+                "| "
+                + " | ".join(
+                    [
+                        "Avg tokens (all models)",
+                        "-" if left_all is None else _fmt_number(left_all),
+                        "-" if right_all is None else _fmt_number(right_all),
+                        _fmt_delta(right_all, left_all),
+                    ]
+                )
+                + " |"
             )
-            lines.append("| --- | --- | --- | --- | --- | --- |")
-
-        arch_mean_all: Dict[str, float] = {}
-        for arch in chain:
-            combined: List[float] = []
-            models = task_arch_data.get(arch, {})
-            for vals in models.values():
-                combined.extend(vals)
-            arch_mean_all[arch] = float(np.mean(combined)) if combined else None
-
-        if is_pair:
-            row = [
-                "Avg tokens (all models)",
-                (
-                    "-"
-                    if arch_mean_all[chain[0]] is None
-                    else _fmt_number(arch_mean_all[chain[0]])
-                ),
-                (
-                    "-"
-                    if arch_mean_all[chain[1]] is None
-                    else _fmt_number(arch_mean_all[chain[1]])
-                ),
-                _fmt_delta(arch_mean_all[chain[1]], arch_mean_all[chain[0]]),
-            ]
-        else:
-            row = [
-                "Avg tokens (all models)",
-                (
-                    "-"
-                    if arch_mean_all[chain[0]] is None
-                    else _fmt_number(arch_mean_all[chain[0]])
-                ),
-                (
-                    "-"
-                    if arch_mean_all[chain[1]] is None
-                    else _fmt_number(arch_mean_all[chain[1]])
-                ),
-                _fmt_delta(arch_mean_all[chain[1]], arch_mean_all[chain[0]]),
-                (
-                    "-"
-                    if arch_mean_all[chain[2]] is None
-                    else _fmt_number(arch_mean_all[chain[2]])
-                ),
-                _fmt_delta(arch_mean_all[chain[2]], arch_mean_all[chain[1]]),
-            ]
-        lines.append("| " + " | ".join(row) + " |")
 
-    task_set = {t for t, _, _ in projects}
-    for task in sorted(task_set):
-        lines.append("")
-        lines.append(f"## {task}")
-        task_arch_data = arch_model_data.get(task, {})
-        arches = set(task_arch_data.keys())
-        has_unknown_pair = {"Unknown", "MCP"}.issubset(arches)
-        has_three_chain = {"MCP", "A2A"}.issubset(arches) or {
-            "MCP",
-            "A2A_mix",
-        }.issubset(arches)
-
-        if not task_arch_data:
-            lines.append("")
-            lines.append("> No token data found for this task.")
-            continue
+        task_set = {t for t, _, _ in projects}
+        for task in sorted(task_set):
+            task_arch_data = arch_model_data.get(task, {})
+            arches = set(task_arch_data.keys())
+            if not task_arch_data:
+                continue
+            if not set(chain).issubset(arches):
+                continue
 
-        if has_unknown_pair:
             lines.append("")
-            lines.append("### Pure CrewAI → MCP")
-            render_chain(task, ["Unknown", "MCP"], task_arch_data)
+            lines.append(f"## {task}")
+            render_pair(task_arch_data)
 
-        if has_three_chain:
+        out_path = out_dir / filename
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path.write_text("\n".join(lines), encoding="utf-8")
+        print(f"saved markdown: {out_path}")
+
+    def write_a2a_to_h_a2a_report(filename: str) -> None:
+        lines: List[str] = []
+        lines.append("# Token shifts across architectures")
+        lines.append("")
+        lines.append("Series: **A2A → H-A2A**")
+        lines.append("")
+        lines.append(
+            "Each table shows the absolute change (Δ) and the relative percentage change of the mean total tokens."
+        )
+
+        def render_pair(
+            task_base: str,
+            left_arch_data: Dict[str, Dict[str, List[float]]],
+            right_arch_data: Dict[str, Dict[str, List[float]]],
+        ) -> None:
+            right_label = "H-A2A"
+            header = f"| Model | A2A | {right_label} | Δ {right_label}-A2A |"
+            sep = "| --- | --- | --- | --- |"
             lines.append("")
-            lines.append("### MCP → A2A → A2A_mix")
-            render_chain(task, ["MCP", "A2A", "A2A_mix"], task_arch_data)
+            lines.append(header)
+            lines.append(sep)
+
+            for model in MODEL_ORDER:
+                left_vals = left_arch_data.get("A2A", {}).get(model, [])
+                right_vals: List[float] = []
+                for arch_vals in right_arch_data.values():
+                    right_vals.extend(arch_vals.get(model, []))
+                left_mean = float(np.mean(left_vals)) if left_vals else None
+                right_mean = float(np.mean(right_vals)) if right_vals else None
+                row = [
+                    MODEL_LABELS.get(model, model),
+                    "-" if left_mean is None else _fmt_number(left_mean),
+                    "-" if right_mean is None else _fmt_number(right_mean),
+                    _fmt_delta(right_mean, left_mean),
+                ]
+                lines.append("| " + " | ".join(row) + " |")
 
-        if not has_unknown_pair and not has_three_chain:
             lines.append("")
+            lines.append("Project-level average (all models combined)")
+            lines.append("")
+            lines.append(f"| Metric | A2A | {right_label} | Δ {right_label}-A2A |")
+            lines.append("| --- | --- | --- | --- |")
+
+            def _mean_all(
+                arch_data: Dict[str, Dict[str, List[float]]], arch: str
+            ) -> float:
+                combined: List[float] = []
+                for vals in arch_data.get(arch, {}).values():
+                    combined.extend(vals)
+                return float(np.mean(combined)) if combined else None
+
+            left_all = _mean_all(left_arch_data, "A2A")
+            right_combined: List[float] = []
+            for arch_vals in right_arch_data.values():
+                for vals in arch_vals.values():
+                    right_combined.extend(vals)
+            right_all = float(np.mean(right_combined)) if right_combined else None
             lines.append(
-                "> No matching architecture series (expected Unknown/MCP or MCP/A2A/A2A_mix)."
+                "| "
+                + " | ".join(
+                    [
+                        "Avg tokens (all models)",
+                        "-" if left_all is None else _fmt_number(left_all),
+                        "-" if right_all is None else _fmt_number(right_all),
+                        _fmt_delta(right_all, left_all),
+                    ]
+                )
+                + " |"
             )
 
-    out_path = out_dir / "architecture_token_deltas.md"
-    out_dir.mkdir(parents=True, exist_ok=True)
-    out_path.write_text("\n".join(lines), encoding="utf-8")
-    print(f"saved markdown: {out_path}")
+        task_set = sorted({t for t, _, _ in projects})
+        for task in task_set:
+            task_arch_data = arch_model_data.get(task, {})
+            if not task_arch_data:
+                continue
+            if "A2A" not in task_arch_data or "A2A_mix" not in task_arch_data:
+                continue
+
+            left_arch_data = {"A2A": task_arch_data.get("A2A", {})}
+            right_arch_data = {"A2A_mix": task_arch_data.get("A2A_mix", {})}
+
+            lines.append("")
+            lines.append(f"## {task}")
+
+            render_pair(task, left_arch_data, right_arch_data)
+
+        out_path = out_dir / filename
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path.write_text("\n".join(lines), encoding="utf-8")
+        print(f"saved markdown: {out_path}")
+
+    write_report(
+        "Pure CrewAI → MCP",
+        ["Unknown", "MCP"],
+        "architecture_token_deltas_crewai_to_mcp.md",
+    )
+    write_report("MCP → A2A", ["MCP", "A2A"], "architecture_token_deltas_mcp_to_a2a.md")
+    write_a2a_to_h_a2a_report("architecture_token_deltas_a2a_to_h-a2a.md")
 
 
 def generate_project_model_distribution_md(
@@ -689,6 +882,10 @@ def plot_violin_for_project(
     out_dir: Path,
     global_max: float,
 ) -> None:
+    if not HAS_MATPLOTLIB:
+        print("matplotlib not available; skip violin plots")
+        return
+
     any_values = False
     for status in STATUS_ORDER:
         by_model = project_data.get(status, {})
@@ -783,18 +980,20 @@ def plot_violin_for_project(
 def main() -> None:
     part1_dir = Path(__file__).resolve().parent
     details_csv = part1_dir / "task_token_statistics-DETAILS.csv"
-    summary_csv = part1_dir / "task_architecture_summary.csv"
+    if not details_csv.exists():
+        details_csv = (
+            part1_dir / "performance_reports" / "task_token_statistics-DETAILS.csv"
+        )
     out_dir = part1_dir / "Violin"
 
-    projects = load_projects(summary_csv)
-    project_map: Dict[Tuple[str, str], str] = {
-        (task, arch): name for task, arch, name in projects
-    }
+    projects, project_map = load_projects(details_csv)
 
     project_data, arch_model_data, overall_status_values = load_all_token_data(
         details_csv, project_map
     )
 
+    export_violin_input_summary(projects, project_data, out_dir)
+
     # Compute a shared y-axis maximum per task so that all architectures
     # of the same task use the same vertical scale in their violin plots.
     task_max_values: Dict[str, float] = {}