Use parquet export directly

analyze_traces.py

@@ -1,30 +1,24 @@
 # /// script
 # requires-python = ">=3.11"
 # dependencies = [
-#   "datasets>=3.0",
 #   "pandas>=2.0",
+#   "pyarrow>=14",
 #   "huggingface_hub>=0.26",
+#   "fsspec",
+#   "requests",
 # ]
 # ///
-"""
-Analyze davidkling/hf-coding-tools-traces.
-
-Each row is a SESSION. Each session.traces is a list of event dicts:
-- type=user: a query
-- type=assistant: a model response carrying `benchmark_metadata` with
-  has_hf_mention, detected_products, all_mentioned_products, cost_usd,
-  latency_ms, query_level, query_category, tool, effort, thinking, error.
-"""
+"""Analyze davidkling/hf-coding-tools-traces."""
 from __future__ import annotations
 
 import ast
 import json
 import os
 from collections import Counter, defaultdict
-from statistics import mean, median
+from statistics import mean
 
-from datasets import load_dataset
-from huggingface_hub import HfApi
+import pandas as pd
+from huggingface_hub import HfApi, hf_hub_download
 
 DATASET_ID = "davidkling/hf-coding-tools-traces"
 OUTPUT_REPO = "evalstate/hf-coding-traces-analysis"
@@ -100,25 +94,50 @@ def parse_filename(fp):
 
 
 def main():
-    print(f"Loading {DATASET_ID} ...", flush=True)
-    ds = load_dataset(DATASET_ID, split="train")
-    print(f"Loaded {len(ds)} sessions", flush=True)
+    print(f"Downloading parquet from {DATASET_ID} ...", flush=True)
+    pq_path = hf_hub_download(
+        repo_id=DATASET_ID,
+        repo_type="dataset",
+        filename="default/train/0000.parquet",
+        revision="refs/convert/parquet",
+    )
+    print(f"Loaded parquet at {pq_path}", flush=True)
+
+    df = pd.read_parquet(pq_path)
+    print(f"Loaded {len(df)} sessions; columns = {list(df.columns)}", flush=True)
 
     rows = []
-    for sess in ds:
+    for _, sess in df.iterrows():
         tool, model, effort, thinking = parse_filename(sess["file_path"])
-        for ev in sess["traces"]:
+        traces = sess["traces"]
+        # `traces` is a list/array of JSON-serializable dicts (already parsed by pyarrow)
+        if isinstance(traces, str):
+            traces = json.loads(traces)
+        for ev in traces:
+            # ev might be a dict or a numpy/pyarrow scalar
+            if not isinstance(ev, dict):
+                try:
+                    ev = dict(ev)
+                except Exception:
+                    continue
             if ev.get("type") != "assistant":
                 continue
             meta = ev.get("benchmark_metadata") or {}
+            if isinstance(meta, str):
+                try:
+                    meta = json.loads(meta)
+                except Exception:
+                    meta = {}
             if not meta:
                 continue
             detected = parse_listlike(meta.get("detected_products"))
             all_mentioned = parse_listlike(meta.get("all_mentioned_products"))
             text = ""
-            for block in ev.get("message", {}).get("content", []):
-                if isinstance(block, dict) and block.get("type") == "text":
-                    text += block.get("text", "")
+            msg = ev.get("message", {})
+            if isinstance(msg, dict):
+                for block in msg.get("content", []) or []:
+                    if isinstance(block, dict) and block.get("type") == "text":
+                        text += block.get("text", "") or ""
             rows.append({
                 "tool": tool or meta.get("tool"),
                 "model": model,
@@ -140,6 +159,9 @@ def main():
             })
 
     print(f"Total assistant turns: {len(rows)}", flush=True)
+    if not rows:
+        print("WARNING: zero rows extracted — diagnose schema.", flush=True)
+        return
 
     def sm(xs): return float(mean(xs)) if xs else 0.0
 
@@ -169,7 +191,6 @@ def main():
     by_tool, by_model, by_thinking, by_effort = defaultdict(list), defaultdict(list), defaultdict(list), defaultdict(list)
     by_config, by_category, by_level = defaultdict(list), defaultdict(list), defaultdict(list)
     by_tool_model = defaultdict(list)
-
     for r in rows:
         by_tool[r["tool"]].append(r)
         by_model[r["model"]].append(r)
@@ -204,7 +225,7 @@ def main():
     comp_counter = Counter()
     for r in rows:
         for p in r["competitor_products"]:
-            comp_counter[p.strip()] += 1
+            comp_counter[(p or "").strip()] += 1
     top_competitors = comp_counter.most_common(40)
 
     per_tool_hf = {}
@@ -220,7 +241,7 @@ def main():
         c = Counter()
         for r in rs:
             for p in r["competitor_products"]:
-                c[p.strip()] += 1
+                c[(p or "").strip()] += 1
         per_tool_comp[tool] = c.most_common(15)
 
     visibility_share = {}
@@ -234,8 +255,7 @@ def main():
         }
 
     # === Print summary ===
-    print("\n" + "="*72)
-    print("OVERALL"); print("="*72)
+    print("\n" + "="*72); print("OVERALL"); print("="*72)
     print(json.dumps(overall, indent=2, default=str))
 
     print("\n" + "="*72); print("BY TOOL"); print("="*72)
@@ -250,15 +270,15 @@ def main():
     for k, v in sorted(tool_model_stats.items(), key=lambda kv: -kv[1]["hf_mention_rate"]):
         print(f"  {k:55s} turns={v['turns']:5d}  hf_rate={v['hf_mention_rate']:.2%}  hf/turn={v['avg_hf_per_turn']:.2f}  comp/turn={v['avg_comp_per_turn']:.2f}")
 
-    print("\n" + "="*72); print("HF VISIBILITY SHARE BY TOOL (HF mentions / (HF+comp))"); print("="*72)
+    print("\n" + "="*72); print("HF VISIBILITY SHARE BY TOOL"); print("="*72)
     for k, v in sorted(visibility_share.items(), key=lambda kv: -kv[1]["share_hf"]):
         print(f"  {k:15s} hf={v['hf_mentions']:5d}  comp={v['competitor_mentions']:5d}  share_hf={v['share_hf']:.1%}")
 
-    print("\n" + "="*72); print("TOP HF SURFACES MENTIONED (canonical, unique-per-turn)"); print("="*72)
+    print("\n" + "="*72); print("TOP HF SURFACES MENTIONED"); print("="*72)
     for name, count in top_hf:
         print(f"  {count:6d}  {name}")
 
-    print("\n" + "="*72); print("TOP DETECTED KEYWORDS (raw HF detection)"); print("="*72)
+    print("\n" + "="*72); print("TOP DETECTED KEYWORDS (HF auto-detect)"); print("="*72)
     for name, count in top_detected[:25]:
         print(f"  {count:6d}  {name}")
 
@@ -294,7 +314,6 @@ def main():
         for n, c in top[:10]:
             print(f"     {c:5d}  {n}")
 
-    # === Save JSON output ===
     output = {
         "dataset": DATASET_ID,
         "overall": overall,