add extract_and_upload.py

extract_and_upload.py

@@ -0,0 +1,353 @@
+"""
+Stage 3 — Extract text dari PDF + upload ke HF Hub (bukan full PDF).
+
+Jauh lebih kecil & cepat karena upload text aja.
+
+Output:
+  texts_2025/{venue}/{idx}_{slug}.txt   — extracted text
+  texts_2025/all_papers.jsonl           — satu file metadata + full text
+
+Usage:
+  python3 extract_and_upload.py
+  python3 extract_and_upload.py --workers 16
+  python3 extract_and_upload.py --skip-upload  # extract aja, jangan upload
+"""
+
+import argparse
+import json
+import os
+import re
+import sys
+import threading
+import time
+from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+import fitz  # PyMuPDF
+
+try:
+    from huggingface_hub import create_repo, upload_file, repo_exists
+    HAS_HF = True
+except ImportError:
+    HAS_HF = False
+
+# ─── CONFIG ──────────────────────────────────────────────────────────────────
+
+DEFAULT_PAPERS_DIR = Path("papers_2025")
+DEFAULT_OUT_DIR    = Path("texts_2025")
+DEFAULT_REPO_ID    = "fassabilf/ir2025-papers-text"
+DEFAULT_WORKERS    = 8
+DEFAULT_STATE_FILE = Path(".extract_state.json")
+
+print_lock = threading.Lock()
+
+
+def log(msg: str):
+    with print_lock:
+        print(msg, flush=True)
+
+
+# ─── STATE ───────────────────────────────────────────────────────────────────
+
+def load_state(path: Path) -> set[str]:
+    if path.exists():
+        try:
+            return set(json.loads(path.read_text()))
+        except Exception:
+            return set()
+    return set()
+
+
+def save_state(path: Path, done: set[str]):
+    path.write_text(json.dumps(sorted(done), ensure_ascii=False, indent=2))
+
+
+# ─── EXTRACT ─────────────────────────────────────────────────────────────────
+
+def clean_text(text: str) -> str:
+    """Bersihin whitespace berlebih tanpa merusak struktur paragraf."""
+    text = re.sub(r'\r\n|\r', '\n', text)
+    text = re.sub(r'\n{4,}', '\n\n\n', text)
+    text = re.sub(r' {3,}', '  ', text)
+    text = re.sub(r'(\S)\n(\S)', r'\1 \2', text)  # gabung hyphenated word
+    return text.strip()
+
+
+def _extract_worker(args) -> dict:
+    """
+    Worker function (module-level = bisa di-pickle untuk ProcessPoolExecutor).
+    args = (pdf_path_str, out_dir_str)
+    Return dict dengan hasil, BUKAN return value langsung (hindari pickle error).
+    """
+    pdf_path_str, out_dir_str = args
+    import re as _re
+
+    try:
+        doc = fitz.open(pdf_path_str)
+        text = ""
+        for page in doc:
+            text += page.get_text("text") + "\n"
+        doc.close()
+
+        # Clean text inline
+        text = _re.sub(r'\r\n|\r', '\n', text)
+        text = _re.sub(r'\n{4,}', '\n\n\n', text)
+        text = _re.sub(r' {3,}', '  ', text)
+        text = _re.sub(r'(\S)\n(\S)', r'\1 \2', text)
+        text = text.strip()
+
+        if not text or len(text) < 100:
+            return {"ok": False, "msg": f"text terlalu pendek ({len(text)} chars)", "text": ""}
+
+        # Save txt
+        out_dir = Path(out_dir_str)
+        rel = str(Path(pdf_path_str).relative_to(out_dir.parent / "papers_2025"))
+        txt_path = out_dir / Path(rel).with_suffix(".txt")
+        txt_path.parent.mkdir(parents=True, exist_ok=True)
+        txt_path.write_text(text, encoding="utf-8")
+
+        return {"ok": True, "msg": f"{len(text)} chars", "text": text}
+
+    except Exception as e:
+        return {"ok": False, "msg": f"{type(e).__name__}: {e}", "text": ""}
+
+
+def extract_one(pdf_path: Path, out_dir: Path) -> tuple[bool, str, str]:
+    """Wrapper untuk backward compatibility."""
+    r = _extract_worker((str(pdf_path), str(out_dir)))
+    return r["ok"], r["msg"], r["text"]
+
+
+def run_extraction(
+    pdf_files: list[Path],
+    out_dir: Path,
+    state_file: Path,
+    workers: int,
+) -> list[dict]:
+    """Extract parallel."""
+    done_set = load_state(state_file)
+    to_do = [p for p in pdf_files if str(p) not in done_set and p.exists()]
+    missing = len([p for p in pdf_files if str(p) not in done_set]) - len(to_do)
+
+    results = []
+    total = len(to_do)
+    if missing:
+        log(f"Skip {missing} file missing (gak kedownload)")
+
+    if not total:
+        log("Semua file sudah di-extract.")
+        return results
+
+    done = 0
+    # Gunakan ProcessPoolExecutor — segfault di PyMuPDF gak akan bunuh main process
+    with ProcessPoolExecutor(max_workers=workers) as ex:
+        future_map = {
+            ex.submit(_extract_worker, (str(p), str(out_dir))): p for p in to_do
+        }
+        for future in as_completed(future_map):
+            pdf_path = future_map[future]
+            try:
+                result = future.result(timeout=120)  # timeout 2 menit per PDF
+                ok, msg, full_text = result["ok"], result["msg"], result["text"]
+            except Exception as e:
+                ok, msg, full_text = False, f"worker crash: {type(e).__name__}: {e}", ""
+
+            done += 1
+            venue = pdf_path.parent.name
+            fname = pdf_path.name[:55]
+            marker = "✓" if ok else "✗"
+            log(f"  [{done:5d}/{total}] {marker} [{venue}] {fname}")
+            if not ok:
+                log(f"           {msg}")
+
+            if ok:
+                done_set.add(str(pdf_path))
+                if done % 10 == 0:
+                    save_state(state_file, done_set)
+
+            results.append({
+                "path": str(pdf_path),
+                "venue": venue,
+                "filename": pdf_path.name,
+                "ok": ok,
+                "msg": msg,
+                "text": full_text,
+            })
+
+    save_state(state_file, done_set)
+    return results
+
+
+# ─── BUILD JSONL ─────────────────────────────────────────────────────────────
+
+def build_jsonl(results: list[dict], out_dir: Path, metadata_map: dict):
+    """Buat satu file all_papers.jsonl dengan metadata + full text."""
+    jsonl_path = out_dir / "all_papers.jsonl"
+    count = 0
+
+    with open(jsonl_path, "w", encoding="utf-8") as f:
+        for r in results:
+            if not r["ok"] or not r["text"]:
+                continue
+            key = r["filename"]  # cocokin pake filename
+            meta = metadata_map.get(key, {})
+            entry = {
+                "venue": r["venue"],
+                "filename": r["filename"],
+                "title": meta.get("title", ""),
+                "authors": meta.get("authors", []),
+                "year": meta.get("year", 2025),
+                "doi": meta.get("doi", ""),
+                "abstract": meta.get("abstract", ""),
+                "full_text": r["text"][:50000],  # limit 50k char per paper
+            }
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+            count += 1
+
+    return jsonl_path, count
+
+
+# ─── UPLOAD ──────────────────────────────────────────────────────────────────
+
+def upload_text_files(out_dir: Path, repo_id: str, token: str, workers: int):
+    """Upload folder teks ke HF Hub dataset."""
+    if not HAS_HF:
+        log("[SKIP] huggingface_hub tidak terinstall.")
+        return
+
+    # Upload jsonl dulu (paling penting)
+    jsonl = out_dir / "all_papers.jsonl"
+    if jsonl.exists():
+        log(f"Upload {jsonl.name} ...")
+        upload_file(
+            path_or_fileobj=str(jsonl),
+            path_in_repo="all_papers.jsonl",
+            repo_id=repo_id,
+            repo_type="dataset",
+            token=token,
+            commit_message="add all_papers.jsonl",
+        )
+        log("  ✓ all_papers.jsonl uploaded")
+
+    # Upload .txt per venue
+    txt_files = sorted(out_dir.rglob("*.txt"))
+    total = len(txt_files)
+    log(f"\nUpload {total} file teks ...")
+
+    done = 0
+    with ThreadPoolExecutor(max_workers=workers) as ex:
+        future_map = {}
+        for p in txt_files:
+            rel = str(p.relative_to(out_dir))
+            future_map[
+                ex.submit(
+                    upload_file,
+                    path_or_fileobj=str(p),
+                    path_in_repo=rel,
+                    repo_id=repo_id,
+                    repo_type="dataset",
+                    token=token,
+                    commit_message=f"add {rel}",
+                )
+            ] = (p, rel)
+
+        for future in as_completed(future_map):
+            p, rel = future_map[future]
+            try:
+                future.result()
+                done += 1
+                if done % 50 == 0:
+                    log(f"  [{done}/{total}]")
+            except Exception as e:
+                log(f"  ✗ {rel}: {e}")
+                done += 1
+
+    log(f"Upload selesai: {done}/{total}")
+
+
+# ─── MAIN ────────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description="Extract text PDF + upload ke HF")
+    parser.add_argument("--papers-dir", default=str(DEFAULT_PAPERS_DIR))
+    parser.add_argument("--out-dir", default=str(DEFAULT_OUT_DIR))
+    parser.add_argument("--workers", type=int, default=DEFAULT_WORKERS)
+    parser.add_argument("--state-file", default=str(DEFAULT_STATE_FILE))
+    parser.add_argument("--repo-id", default=DEFAULT_REPO_ID)
+    parser.add_argument("--token-file", default=None)
+    parser.add_argument("--skip-upload", action="store_true")
+    parser.add_argument("--skip-extract", action="store_true")
+    args = parser.parse_args()
+
+    papers_dir = Path(args.papers_dir)
+    out_dir = Path(args.out_dir)
+    state_file = Path(args.state_file)
+
+    if not papers_dir.exists():
+        print(f"[ERROR] Folder tidak ditemukan: {papers_dir}")
+        sys.exit(1)
+
+    # Cari semua PDF
+    pdf_files = sorted(papers_dir.rglob("*.pdf"))
+    print(f"Total PDF  : {len(pdf_files)}")
+
+    # Load metadata map untuk jsonl
+    metadata_map = {}
+    meta_json = papers_dir.parent / "papers_metadata.json"
+    if meta_json.exists():
+        with open(meta_json) as f:
+            all_meta = json.load(f)
+        for m in all_meta:
+            # buat key dari title (mirip safe_filename)
+            clean = "".join(c if c.isalnum() or c in " -_" else "" for c in m.get("title", ""))
+            slug = clean.strip().replace(" ", "_")[:60]
+            for i in range(1, 9999):
+                key = f"{i:03d}_{slug}.pdf"
+                if key not in metadata_map:
+                    metadata_map[key] = m
+                    break
+
+    # Extract
+    results = []
+    if not args.skip_extract:
+        print(f"Extract text — {args.workers} workers")
+        print(f"Output     : {out_dir.resolve()}\n")
+        t0 = time.time()
+        results = run_extraction(pdf_files, out_dir, state_file, workers=args.workers)
+        elapsed = time.time() - t0
+
+        ok_n = sum(1 for r in results if r["ok"])
+        fail_n = len(results) - ok_n
+        print(f"\nExtract selesai: {ok_n}/{len(results)} ({elapsed:.0f}s)")
+
+        # Build JSONL
+        if ok_n > 0:
+            jsonl_path, count = build_jsonl(results, out_dir, metadata_map)
+            size_mb = jsonl_path.stat().st_size / (1024 * 1024)
+            print(f"JSONL        : {count} papers, {size_mb:.1f} MB")
+    else:
+        print("[SKIP] Extract")
+
+    # Upload
+    if not args.skip_upload:
+        token = os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_HUB_TOKEN")
+        if args.token_file:
+            token = Path(args.token_file).read_text().strip()
+        if not token:
+            print("\n[ERROR] HF_TOKEN tidak ditemukan.")
+            sys.exit(1)
+
+        if not repo_exists(args.repo_id, repo_type="dataset", token=token):
+            create_repo(args.repo_id, repo_type="dataset", token=token)
+            print(f"Repo dibuat: https://huggingface.co/datasets/{args.repo_id}")
+        else:
+            print(f"Repo: https://huggingface.co/datasets/{args.repo_id}")
+
+        upload_text_files(out_dir, args.repo_id, token, workers=args.workers)
+        print(f"\nDone: https://huggingface.co/datasets/{args.repo_id}")
+    else:
+        print("[SKIP] Upload")
+
+
+if __name__ == "__main__":
+    main()