Add persona pool methodology and crisis references

metadata/v3/data_sources/cite_tendencies.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""Add per-item Wikipedia citations to tendencies_by_language.yaml.
+
+For each snake_case tendency we attempt three lookups in order:
+
+  1. The target-language Wikipedia opensearch API for the snake_case label
+     converted to plain words (e.g. "tahdig_perfection" -> "tahdig").
+  2. English Wikipedia opensearch for the same query.
+  3. Mark `lookup_status: not_found` and leave the citation slot empty.
+
+Writes the enriched file to tendencies_by_language_cited.yaml — preserves
+the existing tendencies_by_language.yaml as-is (no in-place mutation).
+
+Wikipedia opensearch is rate-limited; we sleep 0.5s between calls and
+honour Retry-After on 429s.
+"""
+from __future__ import annotations
+
+import json
+import re
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+import requests
+import yaml
+
+PERSONA_DIR = Path(__file__).resolve().parent.parent  # persona/
+REPO_ROOT = PERSONA_DIR.parent  # kyiv/
+SRC = PERSONA_DIR / "data" / "tendencies_by_language.yaml"
+DEST = PERSONA_DIR / "data" / "tendencies_by_language_cited.yaml"
+LOG = REPO_ROOT / "logs" / f"cite_tendencies_{int(time.time())}.log"
+
+WIKIPEDIA_OPENSEARCH = "https://{lang}.wikipedia.org/w/api.php"
+HEADERS = {"User-Agent": "uncgpt-persona-pool/0.2 (research; uncgpt citations)"}
+SLEEP_BETWEEN_CALLS = 0.4
+
+_session = requests.Session()
+
+
+def log(msg: str) -> None:
+    line = f"[{time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())}] {msg}"
+    print(line, flush=True)
+    LOG.parent.mkdir(parents=True, exist_ok=True)
+    with LOG.open("a", encoding="utf-8") as fh:
+        fh.write(line + "\n")
+
+
+def _query_terms_from_snake(label: str) -> list[str]:
+    """Produce a few search queries from a snake_case identifier.
+
+    Examples:
+      tahdig_perfection -> ["tahdig perfection", "tahdig"]
+      poetry_recitation_hafez -> ["poetry recitation hafez", "hafez", "poetry"]
+      pub_quiz_nights -> ["pub quiz nights", "pub quiz"]
+    """
+    base = label.replace("_", " ")
+    tokens = [t for t in re.split(r"\s+", base) if t]
+    queries: list[str] = [base]
+    if len(tokens) > 1:
+        # Try the most-distinctive token last (typically a culture-marked noun)
+        queries.append(" ".join(tokens[:-1]))
+        queries.append(tokens[-1])
+        if len(tokens) > 2:
+            queries.append(" ".join(tokens[:2]))
+    # Deduplicate while preserving order
+    seen = set()
+    out = []
+    for q in queries:
+        ql = q.strip()
+        if ql and ql.lower() not in seen:
+            seen.add(ql.lower())
+            out.append(ql)
+    return out
+
+
+def _wikipedia_search(lang: str, query: str, *, attempt_cap: int = 3) -> Optional[dict]:
+    """Try Wikipedia opensearch in the given language. Return the top hit dict
+    {title, url} or None if no result."""
+    params = {
+        "action": "opensearch",
+        "search": query,
+        "limit": 1,
+        "namespace": 0,
+        "format": "json",
+    }
+    url = WIKIPEDIA_OPENSEARCH.format(lang=lang)
+    for attempt in range(attempt_cap):
+        try:
+            resp = _session.get(url, params=params, headers=HEADERS, timeout=(8, 12))
+        except requests.RequestException as e:
+            if attempt >= attempt_cap - 1:
+                log(f"  ERROR {lang} '{query}': {e}")
+                return None
+            time.sleep(1.0 * (attempt + 1))
+            continue
+        if resp.status_code == 429:
+            retry = float(resp.headers.get("Retry-After", "4"))
+            time.sleep(min(retry + 0.5, 15))
+            continue
+        if not resp.ok:
+            return None
+        data = resp.json()
+        # opensearch returns [query, [titles], [descs], [urls]]
+        if len(data) >= 4 and data[1] and data[3]:
+            return {"title": data[1][0], "url": data[3][0]}
+        return None
+    return None
+
+
+def cite_one(label: str, lang: str) -> dict:
+    """Return a citation dict for one tendency label."""
+    queries = _query_terms_from_snake(label)
+    for q in queries:
+        hit = _wikipedia_search(lang, q)
+        time.sleep(SLEEP_BETWEEN_CALLS)
+        if hit:
+            return {
+                "label": label,
+                "wikipedia_url": hit["url"],
+                "wikipedia_title": hit["title"],
+                "lookup_lang": lang,
+                "lookup_query": q,
+                "lookup_status": "found_native",
+            }
+    # Fall back to English Wikipedia
+    for q in queries:
+        hit = _wikipedia_search("en", q)
+        time.sleep(SLEEP_BETWEEN_CALLS)
+        if hit:
+            return {
+                "label": label,
+                "wikipedia_url": hit["url"],
+                "wikipedia_title": hit["title"],
+                "lookup_lang": "en",
+                "lookup_query": q,
+                "lookup_status": "found_english_fallback",
+            }
+    return {
+        "label": label,
+        "wikipedia_url": None,
+        "wikipedia_title": None,
+        "lookup_lang": None,
+        "lookup_query": queries[0] if queries else label,
+        "lookup_status": "not_found",
+    }
+
+
+def main() -> int:
+    data = yaml.safe_load(SRC.read_text(encoding="utf-8"))
+    generic = list(data.get("generic", []))
+    languages = data.get("languages", {})
+
+    cited_generic: list[dict] = []
+    cited_languages: dict[str, list[dict]] = {}
+
+    log(f"--- generic ({len(generic)} items) ---")
+    for label in generic:
+        rec = cite_one(label, "en")
+        cited_generic.append(rec)
+        status = rec["lookup_status"]
+        log(f"  {label:<35} -> {status}")
+
+    for lang, items in languages.items():
+        log(f"--- {lang} ({len(items)} items) ---")
+        cited_languages[lang] = []
+        for label in items:
+            rec = cite_one(label, lang)
+            cited_languages[lang].append(rec)
+            log(f"  {lang}:{label:<35} -> {rec['lookup_status']}")
+
+    out = {
+        "license": data.get("license", "CC0"),
+        "license_url": data.get("license_url"),
+        "source": data.get("source"),
+        "citation_methodology": (
+            "Each item snake_case label was queried against Wikipedia opensearch "
+            "in the target language. On miss we fall back to English Wikipedia. "
+            "Items that resolved to a native-language article are tagged "
+            "lookup_status=found_native; English fallbacks are flagged "
+            "lookup_status=found_english_fallback; items with no Wikipedia "
+            "match in either language are flagged lookup_status=not_found for "
+            "board review (rename or replace with a citable variant)."
+        ),
+        "generic": cited_generic,
+        "languages": cited_languages,
+    }
+    DEST.write_text(
+        yaml.safe_dump(out, allow_unicode=True, sort_keys=False, width=140),
+        encoding="utf-8",
+    )
+
+    # Summary report
+    from collections import Counter
+
+    counter = Counter()
+    for item in cited_generic:
+        counter[item["lookup_status"]] += 1
+    for items in cited_languages.values():
+        for item in items:
+            counter[item["lookup_status"]] += 1
+    total = sum(counter.values())
+    log("--- summary ---")
+    for status, count in counter.most_common():
+        log(f"  {status}: {count}/{total} ({100*count/total:.1f}%)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())