| |
| """Collect candidate GitHub issue threads about deploying AI apps. |
| |
| Read-only GitHub REST API (search + issues + comments). Token from `gh auth token`. |
| Steps: |
| 1. one search query per (repo, title term): `repo:R is:issue "term" in:title created:>=since` |
| 2. local filters (see filters.py) -> keep_filter True/False |
| 3. per-repo cap (best-match order) and global per-author cap |
| 4. fetch issue + comments for kept threads, compute metrics |
| Outputs (in ../raw/, local only, never published): |
| search_hits.jsonl all search hits (title, url, repo, filter decision; no body) |
| threads.jsonl kept threads with body/comment text truncated (for coding only) |
| Logins are never written: only sha256(salt + login). |
| Usage: python3 -I scripts/collect.py [config.json] [out_dir] (defaults: scripts/repos.json, raw/) |
| """ |
| import json, os, re, subprocess, sys, time, hashlib, urllib.request, urllib.parse |
| from datetime import datetime |
|
|
| HERE = os.path.dirname(os.path.abspath(__file__)) |
| sys.path.insert(0, HERE) |
| import filters |
|
|
| ROOT = os.path.dirname(HERE) |
| CFG_PATH = sys.argv[1] if len(sys.argv) > 1 else os.path.join(HERE, "repos.json") |
| RAW = sys.argv[2] if len(sys.argv) > 2 else os.path.join(ROOT, "raw") |
| os.makedirs(RAW, exist_ok=True) |
| CFG = json.load(open(CFG_PATH)) |
| SALT_PATH = os.path.join(ROOT, "raw", "salt.txt") |
| SALT = open(SALT_PATH).read().strip() |
| TOKEN = subprocess.run(["gh", "auth", "token"], capture_output=True, text=True).stdout.strip() |
|
|
|
|
| def ahash(login): |
| return hashlib.sha256((SALT + (login or "")).encode()).hexdigest()[:16] |
|
|
|
|
| def get(url, params=None): |
| if params: |
| url += "?" + urllib.parse.urlencode(params) |
| for attempt in range(5): |
| req = urllib.request.Request(url, headers={ |
| "Authorization": f"Bearer {TOKEN}", |
| "Accept": "application/vnd.github+json", |
| "X-GitHub-Api-Version": "2022-11-28", |
| "User-Agent": "hal9-research-pilot"}) |
| try: |
| with urllib.request.urlopen(req, timeout=60) as r: |
| return json.load(r) |
| except urllib.error.HTTPError as e: |
| if e.code in (403, 429): |
| time.sleep(30 * (attempt + 1)); continue |
| if e.code == 422: |
| print("422", url, file=sys.stderr); return None |
| raise |
| return None |
|
|
|
|
| def ts(s): |
| return datetime.fromisoformat(s.replace("Z", "+00:00")) if s else None |
|
|
|
|
| def hours(a, b): |
| return round((b - a).total_seconds() / 3600, 1) if a and b else None |
|
|
|
|
| def search(): |
| hits = {} |
| for r in CFG["repos"]: |
| for term in r["title_terms"]: |
| q = f'repo:{r["repo"]} is:issue "{term}" in:title created:>={CFG["since"]}' |
| items, total = [], None |
| for page in range(1, CFG.get("pages", 1) + 1): |
| res = get("https://api.github.com/search/issues", {"q": q, "per_page": 100, "page": page}) |
| time.sleep(2.2) |
| if not res: |
| break |
| total = res.get("total_count") |
| items += res.get("items", []) |
| if len(items) >= min(total, 1000) or not res.get("items"): |
| break |
| for rank, it in enumerate(items): |
| if "pull_request" in it: |
| continue |
| u = it["html_url"] |
| h = hits.setdefault(u, {"url": u, "repo": r["repo"], "group": r["group"], |
| "title": it["title"], "created_at": it["created_at"], |
| "author_hash": ahash(it["user"]["login"]), |
| "body": (it.get("body") or "")[:6000], |
| "terms": [], "best_rank": rank, "_item": it}) |
| h["terms"].append(term) |
| h["best_rank"] = min(h["best_rank"], rank) |
| print(f'{r["repo"]:50s} {term:20s} {total}', file=sys.stderr) |
| return list(hits.values()) |
|
|
|
|
| def main(): |
| hits = search() |
| for h in hits: |
| h["keep_filter"], h["filter_reason"] = filters.keep(h) |
| |
| kept, per_author = [], {} |
| by_repo = {} |
| for h in hits: |
| if h["keep_filter"]: |
| by_repo.setdefault(h["repo"], []).append(h) |
| repo_cap = {r["repo"]: r["cap"] for r in CFG["repos"] if "cap" in r} |
| for repo, lst in by_repo.items(): |
| lst.sort(key=lambda h: (-len(h["terms"]), h["best_rank"])) |
| n = 0 |
| for h in lst: |
| if n >= repo_cap.get(repo, CFG["per_repo_cap"]): |
| h["cap"] = "repo_cap"; continue |
| if per_author.get(h["author_hash"], 0) >= CFG["per_author_cap"]: |
| h["cap"] = "author_cap"; continue |
| per_author[h["author_hash"]] = per_author.get(h["author_hash"], 0) + 1 |
| h["cap"] = "kept"; n += 1 |
| kept.append(h) |
| with open(os.path.join(RAW, "search_hits.jsonl"), "w") as f: |
| for h in hits: |
| f.write(json.dumps({k: v for k, v in h.items() if k not in ("body", "_item")}) + "\n") |
| print(f"hits={len(hits)} pass_filter={sum(h['keep_filter'] for h in hits)} kept={len(kept)}", file=sys.stderr) |
|
|
| tpath = os.path.join(RAW, "threads.jsonl") |
| done = set() |
| if os.path.exists(tpath): |
| done = {json.loads(l)["url"] for l in open(tpath)} |
| out = open(tpath, "a") |
| for h in kept: |
| if h["url"] in done: |
| continue |
| owner_repo, num = h["repo"], h["url"].rsplit("/", 1)[1] |
| api = f"https://api.github.com/repos/{owner_repo}/issues/{num}" |
| iss = h["_item"] |
| coms = (get(api + "/comments", {"per_page": 100}) or []) if iss["comments"] else [] |
| author = iss["user"]["login"] |
| created = ts(iss["created_at"]) |
| first_other = next((c for c in coms if c["user"]["login"] != author |
| and not c["user"]["login"].endswith("[bot]") |
| and c["user"].get("type") != "Bot"), None) |
| rec = { |
| "source": "github_issues", "repo": owner_repo, "group": h["group"], |
| "url": iss["html_url"], "created_at": iss["created_at"], "title": iss["title"], |
| "n_comments": iss["comments"], "n_reactions": iss.get("reactions", {}).get("total_count", 0), |
| "state": iss["state"], "state_reason": iss.get("state_reason"), |
| "closed_at": iss.get("closed_at"), |
| "labels": [l["name"] for l in iss.get("labels", [])], |
| "time_to_first_response_h": hours(created, ts(first_other["created_at"])) if first_other else None, |
| "time_to_close_h": hours(created, ts(iss.get("closed_at"))), |
| "author_hash": ahash(author), "terms": h["terms"], |
| "body": (iss.get("body") or "")[:6000], |
| "comments": [{"by_author": c["user"]["login"] == author, |
| "is_bot": c["user"]["login"].endswith("[bot]") or c["user"].get("type") == "Bot", |
| "assoc": c.get("author_association"), |
| "body": (c.get("body") or "")[:1500]} for c in coms], |
| } |
| out.write(json.dumps(rec) + "\n"); out.flush() |
| out.close() |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
