#!/usr/bin/env python3 from __future__ import annotations import argparse import glob import json import os from pathlib import Path from collections import Counter, defaultdict import tarfile from typing import BinaryIO import re class MultiFileReader: def __init__(self, paths: list[Path]): self.paths = paths self.index = 0 self.current: BinaryIO | None = None self._open_next() def _open_next(self) -> None: if self.current is not None: self.current.close() if self.index >= len(self.paths): self.current = None return self.current = self.paths[self.index].open("rb") self.index += 1 def read(self, size: int = -1) -> bytes: if self.current is None: return b"" chunks: list[bytes] = [] remaining = size while self.current is not None: data = self.current.read(remaining if remaining >= 0 else -1) if data: chunks.append(data) if remaining >= 0: remaining -= len(data) if remaining <= 0: break else: self._open_next() if remaining == 0: break return b"".join(chunks) def close(self) -> None: if self.current is not None: self.current.close() self.current = None def load_split_maps(split_dir: Path) -> dict[str, str]: split_map: dict[str, str] = {} standard = split_dir / "standard.json" if not standard.exists(): return split_map data = json.loads(standard.read_text()) for split_name, ids in data.items(): for episode_id in ids: split_map[str(episode_id)] = split_name return split_map def is_gmail_payload(payload: dict) -> bool: goal = str(payload.get("goal_info", "")).lower() activity = str(payload.get("current_activity", "")).lower() # Match Gmail, but do not confuse the package with Google Play Services # (`com.google.android.gms`). The official Gmail package is # `com.google.android.gm`. gmail_package = re.search(r"(^|[^a-z0-9_.])com\.google\.android\.gm([^a-z0-9_.]|$)", activity) gmail_word = re.search(r"\bgmail\b", " ".join([goal, activity])) is not None return bool(gmail_package or gmail_word) def member_domain(name: str) -> str: parts = name.split("/") if len(parts) >= 2 and parts[0] == "processed": return parts[1] return "unknown" def scan(args: argparse.Namespace) -> None: part_re = re.compile(r"a\.tar\.part-\d{3}$") parts = [Path(p) for p in sorted(glob.glob(args.parts_glob)) if part_re.search(Path(p).name)] if not parts: raise SystemExit(f"No tar parts matched: {args.parts_glob}") out = Path(args.out) out.parent.mkdir(parents=True, exist_ok=True) stats_path = Path(args.stats_out) if args.stats_out else out.with_suffix(".stats.json") split_map = load_split_maps(Path(args.split_dir)) counts = Counter() gmail_episodes: dict[str, dict] = {} goals = Counter() activities = Counter() domains = Counter() split_counts = Counter() reader = MultiFileReader(parts) try: with tarfile.open(fileobj=reader, mode="r|") as tf, out.open("w") as fout: for member in tf: if not member.isfile() or not member.name.endswith("_payload.txt"): continue counts["payload_total"] += 1 domain = member_domain(member.name) counts[f"payload_domain:{domain}"] += 1 if args.domain and domain != args.domain: continue f = tf.extractfile(member) if f is None: counts["payload_no_file"] += 1 continue try: payload = json.loads(f.read().decode("utf-8")) except Exception: counts["payload_json_error"] += 1 continue if not is_gmail_payload(payload): continue episode_id = str(payload.get("episode_id", "")) step_id = int(payload.get("step_id", -1)) split = split_map.get(episode_id, "unknown") record = { "tar_member": member.name, "domain": domain, "episode_id": episode_id, "step_id": step_id, "split": split, "goal_info": payload.get("goal_info", ""), "current_activity": payload.get("current_activity", ""), "action_text": payload.get("action_text", ""), "ex_action_type": payload.get("ex_action_type"), "touch_x": payload.get("touch_x"), "touch_y": payload.get("touch_y"), "lift_x": payload.get("lift_x"), "lift_y": payload.get("lift_y"), "type_text": payload.get("type_text", ""), "image_height": payload.get("image_height"), "image_width": payload.get("image_width"), } fout.write(json.dumps(record, ensure_ascii=False) + "\n") counts["gmail_payload_total"] += 1 domains[domain] += 1 split_counts[split] += 1 goals[str(payload.get("goal_info", ""))] += 1 activities[str(payload.get("current_activity", ""))] += 1 ep = gmail_episodes.setdefault( episode_id, { "episode_id": episode_id, "domain": domain, "split": split, "goal_info": payload.get("goal_info", ""), "steps": 0, "min_step": step_id, "max_step": step_id, }, ) ep["steps"] += 1 ep["min_step"] = min(ep["min_step"], step_id) ep["max_step"] = max(ep["max_step"], step_id) if args.max_matches and counts["gmail_payload_total"] >= args.max_matches: break finally: reader.close() episodes_path = out.with_name(out.stem + "_episodes.jsonl") with episodes_path.open("w") as f: for ep in sorted(gmail_episodes.values(), key=lambda x: (x["split"], x["episode_id"])): f.write(json.dumps(ep, ensure_ascii=False) + "\n") stats = { "parts": [str(p) for p in parts], "part_count": len(parts), "counts": dict(counts), "gmail_episode_count": len(gmail_episodes), "domains": dict(domains), "split_counts": dict(split_counts), "top_goals": goals.most_common(50), "top_activities": activities.most_common(50), "episodes_manifest": str(episodes_path), } stats_path.write_text(json.dumps(stats, ensure_ascii=False, indent=2) + "\n") print(json.dumps(stats, ensure_ascii=False, indent=2)) def main() -> None: p = argparse.ArgumentParser() p.add_argument("--parts-glob", default="/data/gmail_aitw/raw/aitw_parts/a.tar.part-*") p.add_argument("--split-dir", default="/data/gmail_aitw/manifests/official") p.add_argument("--domain", default="google_apps") p.add_argument("--out", default="/data/gmail_aitw/manifests/gmail_payloads.jsonl") p.add_argument("--stats-out", default="") p.add_argument("--max-matches", type=int, default=0) scan(p.parse_args()) if __name__ == "__main__": main()