| |
| import argparse, csv, json, os, random, re, sys, threading, time |
| from concurrent.futures import ThreadPoolExecutor, as_completed |
| import requests |
| from requests.adapters import HTTPAdapter |
| from urllib3.util.retry import Retry |
| from lxml import etree |
|
|
| BASE = "https://digitallibrary.un.org" |
| OUT = os.environ.get("UNSC_CORPUS_ROOT", ".") |
| PROXY_FILE = os.environ.get("UNSC_PROXY_FILE", "proxies.txt") |
| MARC_NS = {"m": "http://www.loc.gov/MARC21/slim"} |
|
|
| CATEGORIES = { |
| "resolutions": {"p": "191:S/RES", "pdfs": True}, |
| "presidential_statements": {"p": "191:S/PRST", "pdfs": True}, |
| "verbatim_debates": {"p": "191:S/PV", "pdfs": True}, |
| "voting_data": {"p": '981:"Security Council"', "cc": "Voting Data", |
| "pdfs": False, "voting": True}, |
| } |
| YEAR_START = 1946 |
| YEAR_END = 2026 |
| RG = 200 |
| REQ_RETRY_PROXIES = 5 |
|
|
| _print_lock = threading.Lock() |
|
|
|
|
| def log(msg): |
| with _print_lock: |
| print(f"[{time.strftime('%H:%M:%S')}] {msg}", flush=True) |
|
|
|
|
| class ProxyPool: |
|
|
| MIN_INTERVAL = 0.40 |
| MAX_INTERVAL = 2.00 |
| PENALTY = 12.0 |
|
|
| def __init__(self, path): |
| self.sessions = [] |
| for line in open(path): |
| line = line.strip() |
| if not line: |
| continue |
| ip, port, user, pw = line.split(":") |
| url = f"http://{user}:{pw}@{ip}:{port}" |
| s = requests.Session() |
| retry = Retry(total=2, backoff_factor=1.0, |
| status_forcelist=[500, 502, 503, 504], |
| allowed_methods=["GET"]) |
| s.mount("https://", HTTPAdapter(max_retries=retry, pool_maxsize=4)) |
| s.proxies = {"http": url, "https": url} |
| self.sessions.append(s) |
| if not self.sessions: |
| raise SystemExit("no proxies loaded") |
| self._lock = threading.Lock() |
| self._next_start = 0.0 |
| self._penalty_until = 0.0 |
| self._interval = self.MIN_INTERVAL |
| self._ok_streak = 0 |
| self._n429 = 0 |
| log(f"loaded {len(self.sessions)} proxies") |
|
|
| def _throttle(self): |
| with self._lock: |
| now = time.time() |
| start = max(now, self._next_start, self._penalty_until) |
| self._next_start = start + self._interval |
| wait = start - time.time() |
| if wait > 0: |
| time.sleep(wait) |
|
|
| def _on_ok(self): |
| with self._lock: |
| self._ok_streak += 1 |
| if self._ok_streak >= 20 and self._interval > self.MIN_INTERVAL: |
| self._interval = max(self.MIN_INTERVAL, self._interval * 0.85) |
| self._ok_streak = 0 |
|
|
| def _penalize(self): |
| with self._lock: |
| self._penalty_until = time.time() + self.PENALTY |
| self._interval = min(self.MAX_INTERVAL, self._interval * 1.5) |
| self._ok_streak = 0 |
| self._n429 += 1 |
|
|
| def get(self, url, params=None, timeout=90, attempts=8): |
| last = None |
| for _ in range(attempts): |
| self._throttle() |
| s = random.choice(self.sessions) |
| try: |
| r = s.get(url, params=params, timeout=timeout) |
| if r.status_code == 429: |
| self._penalize() |
| last = requests.HTTPError("429") |
| continue |
| r.raise_for_status() |
| self._on_ok() |
| return r |
| except Exception as e: |
| last = e |
| continue |
| raise last |
|
|
|
|
| def sub(field, code): |
| el = field.find(f"m:subfield[@code='{code}']", MARC_NS) |
| return el.text.strip() if el is not None and el.text else None |
|
|
|
|
| def subs(field, code): |
| return [e.text.strip() for e in field.findall(f"m:subfield[@code='{code}']", MARC_NS) |
| if e.text and e.text.strip()] |
|
|
|
|
| def parse_record(rec): |
| def cf(tag): |
| el = rec.find(f"m:controlfield[@tag='{tag}']", MARC_NS) |
| return el.text.strip() if el is not None and el.text else None |
|
|
| def df(tag): |
| return rec.findall(f"m:datafield[@tag='{tag}']", MARC_NS) |
|
|
| out = {"record_id": cf("001")} |
| f191 = df("191") |
| out["symbol"] = sub(f191[0], "a") if f191 else None |
|
|
| f245 = df("245") |
| if f245: |
| out["title"] = " ".join(filter(None, [sub(f245[0], "a"), sub(f245[0], "b"), |
| sub(f245[0], "c")])) or None |
| f239 = df("239") |
| out["descriptive_title"] = sub(f239[0], "a") if f239 else None |
|
|
| out["date"] = None |
| for tag in ("269", "992", "260"): |
| f = df(tag) |
| if f: |
| v = sub(f[0], "c") if tag == "260" else sub(f[0], "a") |
| if v: |
| out["date"] = v |
| break |
|
|
| out["body"] = [b for f in df("710") for b in [sub(f, "a")] if b] + \ |
| [b for f in df("711") for b in [sub(f, "a")] if b] |
| out["subjects"] = sorted({s for f in df("650") for s in subs(f, "a")}) |
|
|
| out["agenda"] = [] |
| for f in df("991"): |
| item = {k: sub(f, k) for k in ("a", "b", "c", "d")} |
| if any(item.values()): |
| out["agenda"].append(item) |
|
|
| out["related"] = [sub(f, "a") for f in df("993") if sub(f, "a")] |
| f791 = df("791") |
| out["resolution"] = sub(f791[0], "a") if f791 else None |
|
|
| f996 = df("996") |
| if f996: |
| f = f996[0] |
| out["vote_outcome"] = sub(f, "a") |
| tally = {"yes": sub(f, "b"), "no": sub(f, "c"), "abstain": sub(f, "d"), |
| "nonvoting": sub(f, "e"), "total": sub(f, "f")} |
| if any(tally.values()): |
| out["vote_tally"] = {k: (int(v) if v and v.isdigit() else v) |
| for k, v in tally.items()} |
| votes = [{"iso": sub(f, "c"), "vote": sub(f, "d"), "country": sub(f, "e")} |
| for f in df("967")] |
| if votes: |
| out["votes"] = votes |
|
|
| files = {} |
| for f in df("856"): |
| url = sub(f, "u") |
| if not url or not url.lower().endswith(".pdf"): |
| continue |
| m = re.search(r"-([A-Z]{2})\.pdf$", url) |
| files[m.group(1) if m else (sub(f, "y") or "NA")] = url |
| out["files"] = files |
| return out |
|
|
|
|
| def parse_page(xml): |
| try: |
| root = etree.fromstring(xml) |
| except etree.XMLSyntaxError: |
| root = etree.fromstring(xml, etree.XMLParser(recover=True)) |
| return root.findall("m:record", MARC_NS) |
|
|
|
|
| def build_params(cfg, p_expr, **extra): |
| params = {"p": p_expr} |
| if cfg.get("cc"): |
| params["cc"] = cfg["cc"] |
| params.update(extra) |
| return params |
|
|
|
|
| def get_count(pool, cfg, p_expr, tries=6): |
| for _ in range(tries): |
| r = pool.get(f"{BASE}/search", params=build_params(cfg, p_expr, rg=1, ln="en"), |
| timeout=60) |
| m = re.search(r"<strong>([0-9,]+)</strong>\s*records found", r.text, re.I) |
| if m: |
| return int(m.group(1).replace(",", "")) |
| if re.search(r"\b0\s+records found", r.text, re.I): |
| return 0 |
| time.sleep(2) |
| raise RuntimeError(f"could not read count for query: {p_expr}") |
|
|
|
|
| def harvest_year(pool, cat, cfg, mdir, year): |
| p_year = f'{cfg["p"]} and year:{year}' |
| try: |
| yc = get_count(pool, cfg, p_year) |
| except Exception as e: |
| log(f"[{cat}] {year}: COUNT FAILED ({e})") |
| return year, -1, [] |
| if yc <= 0: |
| return year, yc, [] |
| y_ids, recs_out = set(), [] |
| jrec, page_i = 1, 0 |
| while len(y_ids) < yc: |
| page_i += 1 |
| raw = os.path.join(mdir, f"{year}_p{page_i:02d}.xml") |
| if os.path.exists(raw) and os.path.getsize(raw) > 200: |
| xml = open(raw, "rb").read() |
| else: |
| r = pool.get(f"{BASE}/search", |
| params=build_params(cfg, p_year, of="xm", rg=RG, |
| jrec=jrec, so="a", sf="year"), |
| timeout=90) |
| xml = r.content |
| with open(raw, "wb") as fh: |
| fh.write(xml) |
| before = len(y_ids) |
| for rec in parse_page(xml): |
| parsed = parse_record(rec) |
| rid = parsed.get("record_id") |
| if rid in y_ids: |
| continue |
| y_ids.add(rid) |
| recs_out.append(parsed) |
| if len(y_ids) == before: |
| break |
| jrec += RG |
| return year, yc, recs_out |
|
|
|
|
| def supplemental_fill(pool, cat, cfg, mdir, seen, records, grand_total): |
| sort_keys = [("year", "a"), ("year", "d"), ("title", "a"), ("title", "d"), |
| ("author", "a"), ("author", "d"), ("005", "a"), ("005", "d"), |
| ("245", "a"), ("260", "d")] |
| log(f"[{cat}] supplemental fill: have {len(records)}/{grand_total}, paging full set") |
| plateau = 0 |
| round_i = 0 |
| while len(records) < grand_total and plateau < 1: |
| round_i += 1 |
| before_round = len(records) |
| for sf, so in sort_keys: |
| for jrec in range(1, grand_total + 1, RG): |
| try: |
| r = pool.get(f"{BASE}/search", |
| params=build_params(cfg, cfg["p"], of="xm", rg=RG, |
| jrec=jrec, so=so, sf=sf), |
| timeout=90) |
| except Exception: |
| continue |
| raw = os.path.join(mdir, f"supp_{sf}_{so}_{jrec:05d}.xml") |
| with open(raw, "wb") as fh: |
| fh.write(r.content) |
| for rec in parse_page(r.content): |
| parsed = parse_record(rec) |
| rid = parsed.get("record_id") |
| if rid in seen: |
| continue |
| seen.add(rid) |
| records.append(parsed) |
| if len(records) >= grand_total: |
| break |
| gained = len(records) - before_round |
| log(f"[{cat}] supplemental round {round_i}: +{gained} (now {len(records)}/{grand_total})") |
| plateau = plateau + 1 if gained == 0 else 0 |
| return records |
|
|
|
|
| def harvest_metadata(pool, cat, cfg, workers): |
| cdir = os.path.join(OUT, cat, "metadata") |
| mdir = os.path.join(cdir, "marcxml") |
| os.makedirs(mdir, exist_ok=True) |
|
|
| grand_total = get_count(pool, cfg, cfg["p"]) |
| log(f"[{cat}] grand total reported: {grand_total}") |
|
|
| years = list(range(YEAR_START, YEAR_END + 1)) |
| seen, records, year_sum, incomplete = set(), [], 0, [] |
|
|
| with ThreadPoolExecutor(max_workers=workers) as ex: |
| futs = {ex.submit(harvest_year, pool, cat, cfg, mdir, y): y for y in years} |
| done = 0 |
| failed_years = [] |
| for fut in as_completed(futs): |
| year, yc, recs = fut.result() |
| done += 1 |
| if yc == -1: |
| failed_years.append(year) |
| continue |
| if yc == 0: |
| continue |
| year_sum += yc |
| got = 0 |
| for parsed in recs: |
| rid = parsed.get("record_id") |
| if rid in seen: |
| continue |
| seen.add(rid) |
| records.append(parsed) |
| got += 1 |
| n_year = len({r["record_id"] for r in recs}) |
| if n_year != yc: |
| incomplete.append((year, n_year, yc)) |
| if done % 10 == 0 or n_year != yc: |
| log(f"[{cat}] {year}: {n_year}/{yc}" |
| f"{' INCOMPLETE' if n_year != yc else ''} " |
| f"(cum {len(records)}, {done}/{len(years)} yrs)") |
|
|
| if grand_total > 0 and len(records) < grand_total: |
| supplemental_fill(pool, cat, cfg, mdir, seen, records, grand_total) |
|
|
| jsonl_path = os.path.join(cdir, "records.jsonl") |
| with open(jsonl_path, "w") as fh: |
| for rec in sorted(records, key=lambda r: (r.get("date") or "", r.get("symbol") or "")): |
| fh.write(json.dumps(rec, ensure_ascii=False) + "\n") |
| log(f"[{cat}] wrote {len(records)} unique records -> {jsonl_path}") |
| log(f"[{cat}] sum-of-year-counts={year_sum}, grand_total={grand_total}, " |
| f"unique_collected={len(records)}") |
| if incomplete: |
| log(f"[{cat}] WARNING incomplete years: {incomplete}") |
| if failed_years: |
| log(f"[{cat}] WARNING count-failed years (rerun to fill): {sorted(failed_years)}") |
| return records |
|
|
|
|
| def write_voting_csvs(records): |
| vdir = os.path.join(OUT, "voting_data") |
| os.makedirs(vdir, exist_ok=True) |
| with open(os.path.join(vdir, "roll_call.csv"), "w", newline="") as fh: |
| w = csv.writer(fh) |
| w.writerow(["record_id", "resolution", "date", "country_iso", "country", "vote"]) |
| for rec in records: |
| for v in rec.get("votes", []): |
| w.writerow([rec.get("record_id"), rec.get("resolution"), |
| rec.get("date"), v.get("iso"), v.get("country"), v.get("vote")]) |
| with open(os.path.join(vdir, "summary.csv"), "w", newline="") as fh: |
| w = csv.writer(fh) |
| w.writerow(["record_id", "resolution", "date", "yes", "no", "abstain", |
| "nonvoting", "total", "outcome", "title"]) |
| for rec in records: |
| t = rec.get("vote_tally") or {} |
| w.writerow([rec.get("record_id"), rec.get("resolution"), rec.get("date"), |
| t.get("yes"), t.get("no"), t.get("abstain"), t.get("nonvoting"), |
| t.get("total"), rec.get("vote_outcome"), rec.get("title")]) |
| log("[voting_data] wrote roll_call.csv & summary.csv") |
|
|
|
|
| def safe_name(symbol): |
| return re.sub(r"[^A-Za-z0-9.]+", "_", symbol).strip("_") |
|
|
|
|
| def download_pdfs(pool, cat, records, langs, workers): |
| pdir = os.path.join(OUT, cat, "pdfs") |
| os.makedirs(pdir, exist_ok=True) |
| err_path = os.path.join(OUT, cat, "pdf_errors.log") |
|
|
| tasks = [] |
| for rec in records: |
| sym = rec.get("symbol") or rec.get("record_id") |
| for lang in langs: |
| url = (rec.get("files") or {}).get(lang) |
| if not url: |
| continue |
| fpath = os.path.join(pdir, f"{safe_name(sym)}-{lang}.pdf") |
| if os.path.exists(fpath) and os.path.getsize(fpath) > 1000: |
| continue |
| tasks.append((sym, lang, url, fpath)) |
|
|
| log(f"[{cat}] {len(tasks)} PDFs to fetch ({len(langs)} lang(s))") |
| counts = {"got": 0, "fail": 0} |
| lock = threading.Lock() |
|
|
| def one(task): |
| sym, lang, url, fpath = task |
| try: |
| r = pool.get(url, timeout=120) |
| if not r.content.startswith(b"%PDF"): |
| raise ValueError("not a PDF") |
| with open(fpath, "wb") as fh: |
| fh.write(r.content) |
| with lock: |
| counts["got"] += 1 |
| if counts["got"] % 250 == 0: |
| log(f"[{cat}] pdf {counts['got']}/{len(tasks)}") |
| except Exception as e: |
| with lock: |
| counts["fail"] += 1 |
| with open(err_path, "a") as fh: |
| fh.write(f"{sym}\t{lang}\t{url}\t{e}\n") |
|
|
| with ThreadPoolExecutor(max_workers=workers) as ex: |
| list(ex.map(one, tasks)) |
| log(f"[{cat}] PDFs done: got {counts['got']}, failed {counts['fail']}") |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--only", nargs="*", choices=list(CATEGORIES)) |
| ap.add_argument("--langs", nargs="*", default=["EN"]) |
| ap.add_argument("--no-pdfs", action="store_true") |
| ap.add_argument("--meta-only", action="store_true") |
| ap.add_argument("--pdfs-only", action="store_true", |
| help="skip metadata harvest; download PDFs from existing records.jsonl") |
| ap.add_argument("--workers", type=int, default=6) |
| args = ap.parse_args() |
|
|
| cats = args.only or list(CATEGORIES) |
| pool = ProxyPool(PROXY_FILE) |
| os.makedirs(OUT, exist_ok=True) |
|
|
| for cat in cats: |
| cfg = CATEGORIES[cat] |
| log(f"===== {cat} =====") |
| if args.pdfs_only: |
| path = os.path.join(OUT, cat, "metadata", "records.jsonl") |
| records = [json.loads(l) for l in open(path)] if os.path.exists(path) else [] |
| log(f"[{cat}] loaded {len(records)} records from {path}") |
| else: |
| records = harvest_metadata(pool, cat, cfg, args.workers) |
| if cfg.get("voting"): |
| write_voting_csvs(records) |
| if cfg.get("pdfs") and not args.no_pdfs and not args.meta_only: |
| download_pdfs(pool, cat, records, args.langs, args.workers) |
|
|
| log("ALL DONE") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
