scripts/cloud/process_full_corpus.py

"""Process the full 2007–2022 IMPACT corpus — one year at a time.

For each year:
  1. Download PatentsView text TSVs from S3 (~500MB-2GB/year)
  2. Extract with 7-zip (handles deflate64 that Python's zipfile can't)
  3. Join with IMPACT CSV (enriched parquet with text + viewpoints)
  4. Embed images via HF Inference Endpoint (no local GPU needed)
  5. Push enriched parquet + embeddings to HF Hub
  6. Delete local files before processing next year

Net local disk at any time: ~5-7GB (one year)
Total cloud cost estimate: ~$1.20 for all 3.61M figures (GPU endpoint)

Prerequisites:
  - p7zip installed: brew install p7zip
  - HF_TOKEN set in .env with write access to midah/patent-wireframes
  - HF Inference Endpoint running (use create_hf_endpoint.py, or pass --endpoint-url)

Usage:
    # Process all years (creates/deletes endpoint per year):
    python scripts/cloud/process_full_corpus.py --years 2007-2022

    # Single year with existing endpoint:
    python scripts/cloud/process_full_corpus.py --years 2022 \
        --endpoint-url https://your-endpoint.huggingface.cloud

    # Text enrichment only (no embedding):
    python scripts/cloud/process_full_corpus.py --years 2022 --text-only
"""

import argparse
import ast
import csv
import os
import subprocess
import tempfile
import time
from pathlib import Path

import pandas as pd
import requests
from dotenv import load_dotenv
from huggingface_hub import HfApi, hf_hub_download
from tqdm import tqdm

load_dotenv(".env")
HF_TOKEN = os.environ.get("HF_TOKEN")
HF_HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"}
OUT_REPO = "midah/patent-wireframes"

PATENTSVIEW_URLS = {
    "drawing_desc":  "https://s3.amazonaws.com/data.patentsview.org/draw-description-text/g_draw_desc_text_{year}.tsv.zip",
    "detail_desc":   "https://s3.amazonaws.com/data.patentsview.org/detail-description-text/g_detail_desc_text_{year}.tsv.zip",
    "brf_sum":       "https://s3.amazonaws.com/data.patentsview.org/brief-summary-text/g_brf_sum_text_{year}.tsv.zip",
    "claims":        "https://s3.amazonaws.com/data.patentsview.org/claims/g_claims_{year}.tsv.zip",
    "patent_meta":   "https://s3.amazonaws.com/data.patentsview.org/download/g_patent.tsv.zip",
}

CHUNK = 8 * 1024 * 1024


# ── Utilities ────────────────────────────────────────────────────────────────

def download_file(url: str, dest: Path) -> Path:
    if dest.exists() and dest.stat().st_size > 1024:
        print(f"  Cached: {dest.name}")
        return dest
    print(f"  Downloading {dest.name}...")
    r = requests.get(url, stream=True, timeout=120)
    r.raise_for_status()
    total = int(r.headers.get("content-length", 0))
    with open(dest, "wb") as f, tqdm(total=total, unit="B", unit_scale=True) as pbar:
        for chunk in r.iter_content(CHUNK):
            f.write(chunk); pbar.update(len(chunk))
    return dest


def extract_7z(zip_path: Path, out_dir: Path) -> Path | None:
    """Extract using p7zip (handles deflate64)."""
    result = subprocess.run(
        ["7za", "x", str(zip_path), f"-o{out_dir}", "-y"],
        capture_output=True, text=True,
    )
    if result.returncode != 0:
        print(f"  7za error: {result.stderr[:100]}")
        return None
    tsv_files = list(out_dir.glob("*.tsv"))
    return tsv_files[0] if tsv_files else None


def agg_text(df: pd.DataFrame, id_col: str, text_col: str) -> pd.DataFrame:
    if df.empty or text_col not in df.columns:
        return pd.DataFrame(columns=[id_col, text_col])
    return (
        df.groupby(id_col)[text_col]
        .apply(lambda x: "\n".join(x.dropna().astype(str)))
        .reset_index()
    )


# ── Text enrichment ──────────────────────────────────────────────────────────

def enrich_year(year: str, work_dir: Path) -> pd.DataFrame:
    """Download IMPACT CSV + PatentsView text, join, return enriched DataFrame."""
    api = HfApi(token=HF_TOKEN)

    # IMPACT metadata CSV
    csv_path = hf_hub_download(
        repo_id="AI4Patents/IMPACT", filename=f"{year}.csv",
        repo_type="dataset", token=HF_TOKEN, local_dir=str(work_dir),
    )
    impact = pd.read_csv(csv_path, low_memory=False)
    print(f"  IMPACT {year}: {len(impact):,} patents")

    # Explode to figure level
    rows = []
    for _, row in impact.iterrows():
        try:
            fnames = ast.literal_eval(str(row.get("file_names", "[]")))
            fig_descs = ast.literal_eval(str(row.get("fig_desc", "[]")))
        except Exception:
            fnames, fig_descs = [], []
        base = {k: v for k, v in row.items()
                if k not in ("file_names", "fig_desc")}
        if not fnames:
            rows.append({**base, "figure_number": 0, "image_filename": ""})
        else:
            for i, fn in enumerate(fnames):
                rows.append({**base, "figure_number": i, "image_filename": fn})
    df = pd.DataFrame(rows)
    df.rename(columns={"id": "patent_id", "title": "patent_title"}, inplace=True)
    print(f"  Exploded: {len(df):,} figures")

    # Download + extract PatentsView text tables
    text_tables = {}
    for tname, url_tpl in PATENTSVIEW_URLS.items():
        if tname == "patent_meta":
            url = url_tpl
        else:
            url = url_tpl.format(year=year)
        zip_dest = work_dir / url.split("/")[-1]
        try:
            download_file(url, zip_dest)
            tsv = extract_7z(zip_dest, work_dir / tname)
            if tsv:
                text_tables[tname] = pd.read_csv(tsv, sep="\t", dtype=str, low_memory=False)
                print(f"  {tname}: {len(text_tables[tname]):,} rows")
                zip_dest.unlink()  # free space immediately
        except Exception as e:
            print(f"  Skipping {tname}: {e}")

    # Join text tables
    for canonical, (tname, tcol) in {
        "drawing_description": ("drawing_desc", "draw_desc_text"),
        "detailed_description": ("detail_desc", "detail_desc_text"),
        "brief_summary": ("brf_sum", "brf_sum_text"),
        "claims": ("claims", "claims_text"),
    }.items():
        tdf = text_tables.get(tname, pd.DataFrame())
        if not tdf.empty and tcol in tdf.columns:
            tdf = tdf.rename(columns={"patent_id": "patent_id"})
            agg = agg_text(tdf, "patent_id", tcol).rename(columns={tcol: canonical})
            df = df.merge(agg, on="patent_id", how="left")
        df[canonical] = df.get(canonical, pd.Series("")).fillna("")

    # Patent metadata
    meta = text_tables.get("patent_meta", pd.DataFrame())
    if not meta.empty:
        meta_cols = ["patent_id"] + [c for c in ["patent_date","patent_type"] if c in meta.columns]
        df = df.merge(meta[meta_cols].drop_duplicates("patent_id"), on="patent_id", how="left")

    df["year"] = int(year)
    return df


# ── Embedding via HF endpoint ────────────────────────────────────────────────

def embed_year_via_endpoint(year: str, df: pd.DataFrame, endpoint_url: str,
                             zip_path: str, work_dir: Path) -> pd.DataFrame:
    """Embed all figures using the running HF Inference Endpoint."""
    import base64
    import io
    import zipfile
    import numpy as np
    from PIL import Image

    def encode_img(img_bytes):
        img = Image.open(io.BytesIO(img_bytes)).convert("RGB")
        w, h = img.size
        scale = min(224 / max(w, h), 1.0)
        if scale < 1.0:
            img = img.resize((int(w*scale), int(h*scale)), Image.LANCZOS)
        buf = io.BytesIO()
        img.save(buf, format="JPEG", quality=85)
        return base64.standard_b64encode(buf.getvalue()).decode()

    def post_batch(b64s):
        for attempt in range(4):
            try:
                r = requests.post(endpoint_url, headers={**HF_HEADERS, "Content-Type":"application/json"},
                                  json={"inputs": b64s}, timeout=60)
                if r.status_code == 200:
                    data = r.json()
                    if isinstance(data, list) and data and isinstance(data[0], list):
                        if isinstance(data[0][0], float):
                            return data
                        if isinstance(data[0][0], list):
                            return [d[0] for d in data]
            except Exception:
                pass
            time.sleep(2 ** attempt)
        return None

    all_ids, all_vecs = [], []
    batch_imgs, batch_ids = [], []

    def flush():
        if not batch_imgs:
            return
        vecs = post_batch(batch_imgs)
        if vecs:
            all_ids.extend(batch_ids)
            all_vecs.extend(vecs)
        batch_imgs.clear(); batch_ids.clear()

    with zipfile.ZipFile(zip_path) as zf:
        for _, row in tqdm(df.iterrows(), total=len(df), desc=f"Embedding {year}"):
            fn = str(row.get("image_filename",""))
            parts = fn.split("-D0")
            if len(parts) < 2:
                continue
            inner = f"{year}/{parts[0]}/{fn}"
            try:
                with zf.open(inner) as f:
                    img_bytes = f.read()
                batch_ids.append(f"{row['patent_id']}_{row['figure_number']}")
                batch_imgs.append(encode_img(img_bytes))
                if len(batch_imgs) >= 32:
                    flush()
            except Exception:
                continue
    flush()

    print(f"  Embedded: {len(all_ids):,} figures")
    if not all_ids:
        return pd.DataFrame()

    vecs = np.array(all_vecs, dtype=np.float32)
    norms = np.linalg.norm(vecs, axis=1, keepdims=True)
    vecs /= np.maximum(norms, 1e-8)
    return pd.DataFrame({"figure_id": all_ids, "embedding": list(vecs)})


# ── Year processing ──────────────────────────────────────────────────────────

def process_year_full(year: str, endpoint_url: str | None, text_only: bool):
    api = HfApi(token=HF_TOKEN)

    with tempfile.TemporaryDirectory() as tmpdir:
        work = Path(tmpdir)
        print(f"\n{'='*50}")
        print(f"Processing year {year}")
        print(f"{'='*50}")

        # Text enrichment
        df = enrich_year(year, work)

        # Save enriched parquet
        out_parquet = work / f"enriched_{year}.parquet"
        df.to_parquet(out_parquet, index=False)
        size_mb = out_parquet.stat().st_size / 1e6
        print(f"  Enriched parquet: {size_mb:.0f}MB, {len(df):,} rows")

        api.upload_file(
            path_or_fileobj=str(out_parquet),
            path_in_repo=f"data/enriched_{year}.parquet",
            repo_id=OUT_REPO, repo_type="dataset",
            commit_message=f"Add enriched parquet for {year}",
        )
        print(f"  Pushed enriched_{year}.parquet → HF")

        if text_only or not endpoint_url:
            print("  Skipping embedding (--text-only or no endpoint URL)")
            return

        # Download images zip
        print(f"  Downloading IMPACT {year} images (~4.4GB)...")
        zip_path = hf_hub_download(
            repo_id="AI4Patents/IMPACT", filename=f"{year}.zip",
            repo_type="dataset", token=HF_TOKEN, local_dir=tmpdir,
        )

        # Embed
        emb_df = embed_year_via_endpoint(year, df, endpoint_url, zip_path, work)
        if emb_df.empty:
            print("  No embeddings produced")
            return

        out_emb = work / f"embeddings_{year}_vitl14.parquet"
        emb_df.to_parquet(out_emb, index=False)
        api.upload_file(
            path_or_fileobj=str(out_emb),
            path_in_repo=f"embeddings/embeddings_{year}_vitl14.parquet",
            repo_id=OUT_REPO, repo_type="dataset",
            commit_message=f"Add CLIP embeddings for {year}",
        )
        print(f"  Pushed embeddings_{year}_vitl14.parquet → HF")
        print(f"  Year {year} complete.")


# ── CLI ──────────────────────────────────────────────────────────────────────

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--years",        default="2022",
                        help="Year or range: '2022', '2018-2022', '2007-2022'")
    parser.add_argument("--endpoint-url", default=None,
                        help="Running HF Inference Endpoint URL (skips creation)")
    parser.add_argument("--text-only",    action="store_true",
                        help="Only do text enrichment, skip embedding")
    parser.add_argument("--out-repo",     default=OUT_REPO)
    args = parser.parse_args()

    # Parse year range
    if "-" in args.years and args.years.count("-") == 1:
        start, end = args.years.split("-")
        years = [str(y) for y in range(int(start), int(end)+1)]
    else:
        years = [args.years]

    print(f"Processing years: {years}")
    print(f"Text only: {args.text_only}")
    print(f"Endpoint: {args.endpoint_url or '(none — text only)'}")

    for year in reversed(years):  # newest first
        process_year_full(year, args.endpoint_url, args.text_only)

    print("\nAll years complete.")


if __name__ == "__main__":
    main()