pass5 apply script 92bd124f

code/pass5/92bd124f/abeja_pass5.py

@@ -0,0 +1,299 @@
+"""abeja-cc-ja 第5パス: 金融アフィリエイト・EC 商品ページ・未対応区分（秘密情報、機密・流出、非同意性的、海賊版、Web 定型、キーワード詰め込み）の除去、
+IP アドレスと認証情報値のマスキング、完全一致重複の除去（計画があれば）。入力 outputs_decontam/<dir>/<shard>/<shard>.parquet（url, content, perplexity）。
+
+    python tools/abeja_pass5.py --calibrate --files a.parquet,b.parquet            # ローカル較正（規則別の件数と例）
+    python tools/abeja_pass5.py --repo Podtech/abeja-cc-ja-cleaned --source-prefix outputs_decontam --dir common_crawl_0 --output-root /work/out/common_crawl_0 --upload-repo ... --upload-prefix outputs_v5
+"""
+from __future__ import annotations
+
+import argparse
+import collections
+import hashlib
+import json
+import os
+import re
+import shutil
+import time
+import traceback
+from concurrent.futures import ProcessPoolExecutor
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+VERSION = "abeja-pass5/2026-09-09"
+EXCLUDE_GENRES_DEFAULT = "diary_blog,affiliate,game,entertainment,ec_product"   # ユーザー指示（2026-09-09）: other 以外の 5 ジャンル（日記ブログ／投資・美容・健康のアフィリエイト／ゲーム／芸能／EC）を除外
+CTA = ["口座開設", "公式サイト", "今なら", "キャンペーン", "キャッシュバック", "おすすめ", "ランキング", "比較", "申し込み", "申込", "限定", "最短", "無料", "詳しくはこちら", "こちらから", "登録はこちら", "特典", "ボーナス", "紹介コード", "招待コード", "アフィリエイト", "提携", "口コミ", "評判", "デメリット", "メリット"]
+VERTICALS = {
+    "fx": ["FX", "外国為替証拠金", "為替差益", "スワップポイント", "通貨ペア", "ロスカット", "pips", "証拠金", "スプレッド", "レバレッジ", "ドル円", "米ドル/円", "海外FX", "自動売買", "デイトレード", "スキャルピング"],
+    "crypto": ["仮想通貨", "暗号資産", "ビットコイン", "BTC", "イーサリアム", "アルトコイン", "取引所", "ウォレット", "マイニング", "NFT", "エアドロップ", "草コイン", "ステーキング", "DeFi"],
+    "fund": ["投資信託", "NISA", "iDeCo", "つみたて", "積立投資", "信託報酬", "インデックスファンド", "米国株", "高配当", "証券口座", "楽天証券", "SBI証券", "資産運用", "ロボアド"],
+    "loan": ["カードローン", "キャッシング", "消費者金融", "借入", "即日融資", "審査", "借り換え", "おまとめ", "無利息", "プロミス", "アコム", "アイフル", "闇金", "ソフト闇金", "後払い", "現金化"],
+    "realestate": ["不動産投資", "ワンルーム", "利回り", "家賃収入", "マンション投資", "サブリース", "不動産クラウドファンディング", "太陽光投資"],
+    "beauty": ["脱毛", "美白", "シミ", "しわ", "たるみ", "毛穴", "エステ", "美容液", "化粧水", "サプリ", "ダイエット", "痩せ", "酵素", "プロテイン", "育毛", "薄毛", "AGA", "バストアップ", "ホワイトニング", "医療脱毛", "全身脱毛", "クリニック", "二重整形", "ヒアルロン酸"],
+    "jobs": ["転職エージェント", "転職サイト", "求人", "年収", "未経験", "派遣", "退職代行", "プログラミングスクール", "資格講座"],
+    "dating": ["婚活", "マッチングアプリ", "出会い", "結婚相談所", "パパ活", "セフレ"],
+    "utility": ["ウォーターサーバー", "マットレス", "光回線", "格安SIM", "ポケットWiFi", "引越し業者", "買取", "車査定", "太陽光", "宅配クリーニング", "食材宅配", "ハウスクリーニング"],
+}
+# 縦割りごとの「強い語」（これが 1 語以上含まれないと判定しない）。無ければ全語が強い語
+STRONG_TERMS = {
+    "loan": {"カードローン", "キャッシング", "消費者金融", "即日融資", "無利息", "プロミス", "アコム", "アイフル", "闇金", "ソフト闇金", "後払い", "現金化", "おまとめ"},
+    "jobs": {"転職エージェント", "転職サイト", "退職代行", "プログラミングスクール", "資格講座", "派遣"},
+    "realestate": {"不動産投資", "サブリース", "不動産クラウドファンディング", "太陽光投資", "家賃収入", "マンション投資"},
+    "fund": {"投資信託", "NISA", "iDeCo", "つみたて", "積立投資", "信託報酬", "インデックスファンド", "証券口座", "楽天証券", "SBI証券", "ロボアド"},
+    "crypto": {"仮想通貨", "暗号資産", "ビットコイン", "BTC", "イーサリアム", "アルトコイン", "エアドロップ", "草コイン", "ステーキング", "DeFi", "NFT"},
+    "utility": {"ウォーターサーバー", "光回線", "格安SIM", "ポケットWiFi", "車査定", "宅配クリーニング", "食材宅配", "ハウスクリーニング", "引越し業者"},
+    "beauty": {"脱毛", "医療脱毛", "全身脱毛", "美容液", "サプリ", "育毛", "薄毛", "AGA", "バストアップ", "ホワイトニング", "二重整形", "ヒアルロン酸", "酵素", "プロテイン"},
+}
+# (必要な語数, 必要な CTA 語数)。FX はユーザー指示（2026-09-09）で 1 語でも対象
+RULE_MIN = {"fx": (1, 2), "crypto": (2, 2), "fund": (2, 2), "loan": (2, 2), "realestate": (2, 3), "beauty": (2, 3), "jobs": (2, 3), "dating": (2, 3), "utility": (2, 3)}
+EC_CUES = ["カートに入れる", "カートに追加", "買い物かご", "在庫あり", "在庫なし", "送料無料", "税込", "税抜", "円（税込）", "円(税込)", "販売価格", "定価", "ポイント還元", "商品説明", "商品番号", "商品コード", "型番", "JAN", "数量", "ご注文", "お届け", "配送", "返品", "ギフト", "ラッピング", "メーカー希望小売価格", "セール", "アウトレット", "お気に入りに追加", "再入荷", "レビューを書く", "お客様の声", "SOLD OUT", "売り切れ", "入荷待ち"]
+EC_HOST = re.compile(r"rakuten\.co\.jp|amazon\.co\.jp|shopping\.yahoo\.co\.jp|store\.shopping|mercari|zozo|yodobashi|biccamera|kakaku\.com|monotaro|askul|dmm\.com|/item/|/products?/|/goods/|/shop/|shop\.|store\.|cart|/product-", re.I)
+PIRACY_SITES = ["漫画村", "漫画バンク", "anitube", "kissanime", "nyaa", "13dl", "manga1000", "manga1001", "hitomi.la", "rawdevart", "mangaraw", "torrent", "トレント", "海賊版", "違法アップロード", "違法ダウンロード"]
+PIRACY_CUES = ["無料で読める", "全巻無料", "無料視聴", "無料で見る", "zip", "rar", "ダウンロード", "raw", "字幕付き 無料", "見放題 違法"]
+NONCONSENT = ["盗撮", "隠し撮り", "リベンジポルノ", "流出動画", "流出画像", "流出した動画", "ハメ撮り", "無修正流出", "個人撮影"]
+WEAK_PIRACY = {"torrent", "トレント"}
+SEXUAL_TERMS_FILE = "abeja-cc-ja/src/wordlists/cooccurrence/ja_sexual_terms.txt"
+CONFIDENTIAL = re.compile(r"社外秘|部外秘|関係者外秘|Confidential\s*[-–:]?\s*(?:Do not distribute|Internal use only)|INTERNAL USE ONLY|STRICTLY CONFIDENTIAL", re.I)
+CRED_DUMP_LINE = re.compile(r"^[^\s@]+@[^\s@]+\.[a-z]{2,}\s*[:|;,\t ]\s*\S{6,}\s*$", re.I | re.M)
+SECRET_STRONG = re.compile(r"-----BEGIN (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z_\-]{35}|gh[pousr]_[A-Za-z0-9]{36,}|xox[baprs]-[0-9A-Za-z\-]{10,}|sk_live_[0-9a-zA-Z]{24,}")
+SECRET_KV = re.compile(r"(?i)\b(api[_-]?key|secret[_-]?key|access[_-]?token|client[_-]?secret|auth[_-]?token)\b\s*[:=]\s*['\"]?([A-Za-z0-9_\-]{20,})")
+PASSWORD_KV = re.compile(r"(?i)(password|passwd|pwd|パスワード|暗証番号)\s*[:=：]\s*['\"]?(?!\*+|●+|●|\*|x+\b|半角|英数|例|ここ)([^\s'\"、。，,]{6,32})")
+BOILER = ["Cookieを使用", "Cookie を使用", "クッキーを使用", "Cookieの使用に同意", "cookieの利用に同意", "ページが見つかりません", "お探しのページ", "404 Not Found", "JavaScriptを有効", "JavaScript を有効", "JavaScriptが無効", "ブラウザの設定", "アクセスが集中", "メンテナンス中", "ページは移動", "削除された可能性"]
+IPV4 = re.compile(r"(?<![\d.])((?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))(?![\d.])")
+_AUTO = None; _SEX = None; _ENC = None
+
+
+def _boundary_ok(low: str, st: int, end: int, term: str) -> bool:
+    if not term.isascii(): return True
+    return not ((st > 0 and low[st - 1].isalnum()) or (end + 1 < len(low) and low[end + 1].isalnum()))
+
+
+def _init(cfg: dict) -> None:
+    global _AUTO, _SEX, _ENC
+    import ahocorasick
+    a = ahocorasick.Automaton()
+    groups = {f"v:{k}": v for k, v in VERTICALS.items()}; groups["cta"] = CTA; groups["ec"] = EC_CUES; groups["pir_site"] = PIRACY_SITES; groups["pir_cue"] = PIRACY_CUES; groups["noncons"] = NONCONSENT; groups["boiler"] = BOILER
+    index: dict[str, set] = collections.defaultdict(set)
+    for g, terms in groups.items():
+        for t in terms: index[t.casefold()].add(g)
+    for t, gs in index.items(): a.add_word(t, (t, tuple(gs)))
+    a.make_automaton(); _AUTO = a
+    sex = ahocorasick.Automaton()
+    for t in cfg.get("sexual_terms") or []: sex.add_word(t.casefold(), t)
+    sex.make_automaton(); _SEX = sex if cfg.get("sexual_terms") else None
+    if cfg.get("count_tokens"):
+        import tiktoken; _ENC = tiktoken.get_encoding("o200k_harmony")
+
+
+def scan(text: str) -> dict[str, set]:
+    low = text.casefold(); found: dict[str, set] = collections.defaultdict(set)
+    for end, (term, gs) in _AUTO.iter(low):
+        st = end - len(term) + 1
+        if not _boundary_ok(low, st, end, term): continue
+        for g in gs: found[g].add(term)
+    return found
+
+
+def keyword_stuffing(text: str) -> tuple[bool, str]:
+    t = re.sub(r"\s+", "", text)
+    if len(t) < 600: return False, ""
+    c = collections.Counter(t[i:i + 4] for i in range(0, len(t) - 3))
+    g, n = c.most_common(1)[0]
+    if n >= 25 and n * 4 / len(t) >= 0.12 and re.search(r"[^\W\d_]", g): return True, f"{g}×{n}"
+    return False, ""
+
+
+def decide(url: str, text: str) -> tuple[list[str], dict, str, dict]:
+    """(除去理由の一覧, 詳細, マスキング後の本文, マスキング件数)"""
+    reasons: list[str] = []; info: dict = {}; f = scan(text)
+    cta = f.get("cta", set())
+    for k in VERTICALS:
+        vt = f.get(f"v:{k}", set())
+        strong = vt & STRONG_TERMS.get(k, vt)
+        min_terms, min_cta = RULE_MIN.get(k, (2, 3))
+        if len(vt) >= min_terms and strong and len(cta) >= min_cta:
+            reasons.append(f"affiliate_{k}"); info[f"affiliate_{k}"] = {"terms": sorted(vt)[:6], "cta": sorted(cta)[:6]}
+    ec = f.get("ec", set()); host = bool(EC_HOST.search(url or ""))
+    if len(ec) >= 6 or (host and len(ec) >= 3): reasons.append("ec_product"); info["ec_product"] = {"cues": sorted(ec)[:8], "host": host}
+    ps, pc = f.get("pir_site", set()), f.get("pir_cue", set())
+    strong_ps = ps - WEAK_PIRACY
+    if len(ps) >= 2 or (strong_ps and pc) or (ps and len(pc) >= 2): reasons.append("piracy"); info["piracy"] = {"sites": sorted(ps)[:4], "cues": sorted(pc)[:4]}
+    nc = f.get("noncons", set())
+    if nc and _SEX is not None:
+        low = text.casefold(); sex_hits = {t for _, t in _SEX.iter(low)} - set(NONCONSENT) - {"性的", "性", "エロ"}
+        if len(sex_hits) >= 2: reasons.append("nonconsensual_sexual"); info["nonconsensual_sexual"] = {"terms": sorted(nc)[:4], "sexual": sorted(sex_hits)[:4]}
+    if SECRET_STRONG.search(text): reasons.append("secret_key"); info["secret_key"] = SECRET_STRONG.search(text).group(0)[:12] + "…"
+    dump = CRED_DUMP_LINE.findall(text)
+    if len(dump) >= 5: reasons.append("credential_dump"); info["credential_dump"] = {"lines": len(dump)}
+    m = CONFIDENTIAL.search(text)
+    if m: reasons.append("confidential_marker"); info["confidential_marker"] = m.group(0)
+    b = f.get("boiler", set())
+    if len(text) < 1000 and len(b) >= 2: reasons.append("web_boilerplate"); info["web_boilerplate"] = sorted(b)[:5]
+    ks, kinfo = keyword_stuffing(text)
+    if ks: reasons.append("keyword_stuffing"); info["keyword_stuffing"] = kinfo
+    masks: dict[str, int] = {}; out = text
+    if not reasons:
+        out, n = IPV4.subn(lambda mm: mm.group(1) if mm.group(1).startswith(("10.", "127.", "192.168.", "0.", "255.")) or re.match(r"172\.(1[6-9]|2\d|3[01])\.", mm.group(1)) else "<IP>", out)
+        if n: masks["ip"] = n
+        out, n = SECRET_KV.subn(lambda mm: f"{mm.group(1)}=<SECRET>", out)
+        if n: masks["secret_kv"] = n
+        out, n = PASSWORD_KV.subn(lambda mm: f"{mm.group(1)}: <SECRET>", out)
+        if n: masks["password"] = n
+    return reasons, info, out, masks
+
+
+def _fetch(repo: str, path_in_repo: str, local_dir: Path, attempts: int = 6) -> Path:
+    from huggingface_hub import hf_hub_download
+    for k in range(attempts):
+        try: return Path(hf_hub_download(repo, path_in_repo, repo_type="dataset", token=os.environ.get("HF_TOKEN"), local_dir=str(local_dir)))
+        except Exception as e:  # noqa: BLE001
+            if k == attempts - 1: raise
+            time.sleep(20 * (k + 1))
+
+
+def process_shard(task: dict) -> dict:
+    import pyarrow as pa, pyarrow.parquet as pq
+    started = time.perf_counter(); shard = task["shard"]
+    try:
+        _init(task["cfg"])
+        local = _fetch(task["repo"], task["path"], Path(task["staging_dir"])) if task.get("repo") else Path(task["path"])
+        out_dir = Path(task["output_root"]) / shard; out_dir.mkdir(parents=True, exist_ok=True)
+        genre_of: dict[str, str] = {}
+        if task.get("features_path"):
+            fl = _fetch(task["repo"], task["features_path"], Path(task["staging_dir"])) if task.get("repo") else Path(task["features_path"])
+            ft = pq.read_table(fl, columns=["content_sha1", "genre"]); genre_of = dict(zip(ft.column("content_sha1").to_pylist(), ft.column("genre").to_pylist()))
+            if task.get("repo"): Path(fl).unlink(missing_ok=True)
+        exclude_genres = set(task["cfg"].get("exclude_genres") or [])
+        pf = pq.ParquetFile(local); codec = pf.metadata.row_group(0).column(0).compression if pf.metadata.num_row_groups else "SNAPPY"
+        writer = pq.ParquetWriter(out_dir / f"{shard}.parquet", pf.schema_arrow, compression=codec.lower() if codec != "UNCOMPRESSED" else None)
+        dedup: set = set(task.get("dedup_rows") or []); reasons_c = collections.Counter(); masks_c = collections.Counter(); rows_in = 0; written = 0; tok_removed = 0; masked_docs = 0
+        removed_f = (out_dir / "pass5_removed.jsonl").open("w", encoding="utf-8"); sha_list = []
+        try:
+            for batch in pf.iter_batches(batch_size=2048):
+                d = batch.to_pydict(); n = batch.num_rows; keep_idx = []; new_content = list(d["content"])
+                for i in range(n):
+                    row = rows_in + i; url = d["url"][i] or ""; text = d["content"][i] or ""
+                    if row in dedup:
+                        reasons, info = ["exact_duplicate"], {"exact_duplicate": task.get("dedup_info", {}).get(row)}; out = text; masks = {}
+                    else:
+                        reasons, info, out, masks = decide(url, text)
+                        g = genre_of.get(hashlib.sha1(text.encode("utf-8")).hexdigest()) if genre_of else None
+                        if g in exclude_genres:
+                            reasons.append(f"genre_{g}"); info[f"genre_{g}"] = True; out = text; masks = {}
+                        elif genre_of and g is None: reasons_c["_features_unmatched"] += 1
+                    if reasons:
+                        for r in reasons: reasons_c[r] += 1
+                        reasons_c["_removed"] += 1
+                        if _ENC is not None: tok_removed += len(_ENC.encode(text, disallowed_special=()))
+                        removed_f.write(json.dumps({"row_index": row, "reasons": reasons, "info": info, "url": url, "content": text, "perplexity": d.get("perplexity", [None] * n)[i]}, ensure_ascii=False, default=str) + "\n")
+                    else:
+                        keep_idx.append(i); new_content[i] = out
+                        if masks: masked_docs += 1; masks_c.update(masks)
+                        sha_list.append(hashlib.sha1(out.encode("utf-8")).digest())
+                if keep_idx:
+                    cols = {}
+                    for name in pf.schema_arrow.names:
+                        vals = new_content if name == "content" else d[name]
+                        cols[name] = pa.array([vals[i] for i in keep_idx], type=pf.schema_arrow.field(name).type)
+                    kept = pa.record_batch(cols, schema=pf.schema_arrow); writer.write_batch(kept); written += kept.num_rows
+                rows_in += n
+        finally:
+            writer.close(); removed_f.close()
+        pq.write_table(pa.table({"sha1": pa.array(sha_list, pa.binary(20))}), out_dir / "pass5_sha1.parquet")
+        check = pq.ParquetFile(out_dir / f"{shard}.parquet"); assert check.metadata.num_rows == written == rows_in - reasons_c["_removed"], "row count mismatch"
+        summary = {"version": VERSION, "dir": task["config"], "shard": shard, "rows_in": rows_in, "rows_removed": reasons_c.pop("_removed", 0), "rows_out": written, "features_unmatched": reasons_c.pop("_features_unmatched", 0), "features_rows": len(genre_of), "removed_by_reason": dict(reasons_c),
+                   "masked_docs": masked_docs, "masks": dict(masks_c), "tokens_removed": tok_removed if _ENC is not None else None, "dedup_rows_planned": len(dedup), "compression": codec, "seconds": round(time.perf_counter() - started, 1), "finished_at_utc": datetime.now(timezone.utc).isoformat()}
+        (out_dir / "pass5_summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+        if task.get("repo"): Path(local).unlink(missing_ok=True)
+        return summary
+    except Exception as error:  # noqa: BLE001
+        return {"shard": shard, "error": repr(error), "traceback": traceback.format_exc()}
+
+
+def upload_batch(api: Any, repo: str, prefix: str, output_root: Path, shards: list[str], delete_local: bool) -> None:
+    for attempt in range(8):
+        try:
+            for sh in shards:
+                api.upload_folder(repo_id=repo, repo_type="dataset", folder_path=str(output_root / sh), path_in_repo=f"{prefix}/{sh}", commit_message=f"{Path(prefix).name} {sh}")
+            break
+        except Exception as e:  # noqa: BLE001
+            if attempt == 7: raise
+            time.sleep(60 * (attempt + 1) + 30)
+    if delete_local:
+        for sh in shards: shutil.rmtree(output_root / sh, ignore_errors=True)
+
+
+def calibrate(files: list[str], cfg: dict, limit: int | None, features: list[str] | None = None) -> None:
+    import pyarrow.parquet as pq
+    _init(cfg); c = collections.Counter(); ex = collections.defaultdict(list); n = 0; masks_c = collections.Counter(); hosts = collections.defaultdict(collections.Counter); excl = set(cfg.get("exclude_genres") or [])
+    for fi, f in enumerate(files):
+        pf = pq.ParquetFile(f); genre_of = {}
+        if features:
+            ft = pq.read_table(features[fi], columns=["content_sha1", "genre"]); genre_of = dict(zip(ft.column("content_sha1").to_pylist(), ft.column("genre").to_pylist()))
+        for batch in pf.iter_batches(batch_size=2048, columns=["url", "content"]):
+            for url, text in zip(batch.column("url").to_pylist(), batch.column("content").to_pylist()):
+                n += 1; reasons, info, out, masks = decide(url or "", text or "")
+                g = genre_of.get(hashlib.sha1((text or "").encode("utf-8")).hexdigest()) if genre_of else None
+                if g in excl: reasons.append(f"genre_{g}"); info[f"genre_{g}"] = True
+                for r in reasons:
+                    c[r] += 1; hosts[r][re.sub(r"^https?://([^/]+).*", r"\1", url or "")] += 1
+                    if len(ex[r]) < 4: ex[r].append((url[:60], json.dumps(info.get(r), ensure_ascii=False)[:100], (text or "")[:120].replace("\n", " ")))
+                if reasons: c["_removed"] += 1
+                masks_c.update(masks)
+                if limit and n >= limit: break
+            if limit and n >= limit: break
+    only_genre = sum(1 for _ in [])  # placeholder
+    print(json.dumps({"docs": n, "removed": c.pop("_removed", 0), "by_reason": dict(c), "masks": dict(masks_c)}, ensure_ascii=False))
+    for r, lst in ex.items():
+        print(f"== {r} ({c[r]}, {c[r]/n:.3%}) hosts {hosts[r].most_common(3)}")
+        for e in lst: print("   ", e[0], "|", e[1], "|", e[2])
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--calibrate", action="store_true"); parser.add_argument("--files", default=""); parser.add_argument("--limit", type=int, default=None)
+    parser.add_argument("--repo", default=None); parser.add_argument("--source-prefix", default="outputs_decontam"); parser.add_argument("--dir", default=None)
+    parser.add_argument("--output-root", type=Path, default=None); parser.add_argument("--staging-dir", type=Path, default=Path("/work/staging")); parser.add_argument("--plan", default=None, help="dedup 計画 parquet（dir, shard, row_index, kept_shard, kept_row_index）")
+    parser.add_argument("--sexual-terms", default=None); parser.add_argument("--count-tokens", action="store_true"); parser.add_argument("--limit-shards", type=int, default=None)
+    parser.add_argument("--features-prefix", default=None, help="第2パス出力の接頭辞（<dir>/<shard>/features.parquet からジャンルを引く）"); parser.add_argument("--features-files", default="", help="較正用: --files と同順の features.parquet")
+    parser.add_argument("--exclude-genres", default=EXCLUDE_GENRES_DEFAULT)
+    parser.add_argument("--upload-repo", default=None); parser.add_argument("--upload-prefix", default="outputs_v5"); parser.add_argument("--upload-batch", type=int, default=10); parser.add_argument("--skip-existing-in-repo", action="store_true")
+    parser.add_argument("--workers", type=int, default=max(1, int(os.environ.get("CPU_CORES") or os.cpu_count() or 2) - 1))
+    args = parser.parse_args(argv)
+    sexual = [l.strip() for l in open(args.sexual_terms, encoding="utf-8") if l.strip() and not l.startswith("#")] if args.sexual_terms else []
+    cfg = {"sexual_terms": sexual, "count_tokens": args.count_tokens, "exclude_genres": [g for g in args.exclude_genres.split(",") if g]}
+    if args.calibrate:
+        calibrate([f for f in args.files.split(",") if f], cfg, args.limit, [f for f in args.features_files.split(",") if f] or None); return
+    from huggingface_hub import HfApi
+    api = HfApi(token=os.environ.get("HF_TOKEN"))
+    shards = sorted({e.path.split("/")[-1] for e in api.list_repo_tree(args.repo, path_in_repo=f"{args.source_prefix}/{args.dir}", repo_type="dataset", recursive=False)})
+    if args.limit_shards: shards = shards[: args.limit_shards]
+    existing = set()
+    if args.skip_existing_in_repo and args.upload_repo:
+        try: existing = {e.path.split("/")[-1] for e in api.list_repo_tree(args.upload_repo, path_in_repo=f"{args.upload_prefix}/{args.dir}", repo_type="dataset", recursive=False)}
+        except Exception: existing = set()
+    plan: dict[str, dict[int, Any]] = {}
+    if args.plan:
+        import pyarrow.parquet as pq
+        t = pq.read_table(args.plan).filter(pq.compute.equal(pq.read_table(args.plan).column("dir"), args.dir)) if False else pq.read_table(args.plan)
+        import pyarrow.compute as pc
+        t = t.filter(pc.equal(t.column("dir"), args.dir))
+        for sh, row, ks, kr in zip(t.column("shard").to_pylist(), t.column("row_index").to_pylist(), t.column("kept_shard").to_pylist(), t.column("kept_row_index").to_pylist()):
+            plan.setdefault(sh, {})[int(row)] = {"kept_shard": ks, "kept_row_index": kr}
+    tasks = [{"repo": args.repo, "path": f"{args.source_prefix}/{args.dir}/{sh}/{sh}.parquet", "features_path": f"{args.features_prefix}/{args.dir}/{sh}/features.parquet" if args.features_prefix else None, "shard": sh, "config": args.dir, "output_root": str(args.output_root), "staging_dir": str(args.staging_dir), "cfg": cfg,
+              "dedup_rows": list(plan.get(sh, {}).keys()), "dedup_info": plan.get(sh, {})} for sh in shards if sh not in existing]
+    print(json.dumps({"event": "start", "dir": args.dir, "shards": len(shards), "skipped_existing": len(shards) - len(tasks), "dedup_rows": sum(len(v) for v in plan.values())}), flush=True)
+    pending = []; failed = []
+    with ProcessPoolExecutor(max_workers=args.workers) as ex:
+        for s in ex.map(process_shard, tasks):
+            if "error" in s: failed.append(s["shard"]); print(json.dumps({"event": "error", **s}, ensure_ascii=False)[:600], flush=True); continue
+            print(json.dumps({"event": "done", **{k: v for k, v in s.items() if k not in ("version", "finished_at_utc", "compression")}}, ensure_ascii=False), flush=True)
+            if args.upload_repo:
+                pending.append(s["shard"])
+                if len(pending) >= args.upload_batch: upload_batch(api, args.upload_repo, f"{args.upload_prefix}/{args.dir}", args.output_root, pending, True); pending = []
+    if args.upload_repo and pending: upload_batch(api, args.upload_repo, f"{args.upload_prefix}/{args.dir}", args.output_root, pending, True)
+    print(json.dumps({"event": "finish", "dir": args.dir, "shards": len(tasks), "failed": failed}), flush=True)
+
+
+if __name__ == "__main__":
+    main()