Blame for code/e5cb5ca/src/hf_jobs_launch.py

"""HF Jobs で全シャードのクレンジングを実行するランチャー。

``common_crawl_0`` 〜 ``common_crawl_18`` の各ディレクトリを1ジョブにし、次を行う。

* 入力データセット（``Podtech/abeja-cc-ja-filtered``）を ``/data`` にマウント（ダウンロード不要）
* このリポジトリの ``src/`` と UT1 ブロックリストのキャッシュを、出力用の非公開データセットへ
  ``code/<ref>/src`` と ``blocklists/ut1`` として1回だけアップロードし、各ジョブがそこから取得する
  （全ジョブが同じコード・同じリストで動くことをマニフェストで保証する）
* ``HF_TOKEN`` はシークレットとして渡す（ログに出ない）
* ``run_shard.py`` を ``--upload-repo`` 付きで実行し、出力は ``outputs/common_crawl_N/<shard>/`` へ
  シャード単位でアップロードして一時ディスクから削除する
* タイムアウトは既定の30分ではなく ``--timeout``（既定 6h）を指定する

    uv run --env-file .env python abeja-cc-ja/src/hf_jobs_launch.py --dirs 0 --limit-shards 2 --dry-run
    uv run --env-file .env python abeja-cc-ja/src/hf_jobs_launch.py --dirs 0 --limit-shards 2
    uv run --env-file .env python abeja-cc-ja/src/hf_jobs_launch.py --dirs 0-18 --policy-approver "<名前>" --policy-approved-on 2026-09-04

完了後は ``aggregate_summaries.py --repo <出力repo> --prefix outputs --expected-inputs <入力repo>`` で集約する。
"""

from __future__ import annotations

import argparse
import hashlib
import json
import os
import shlex
import subprocess
from datetime import datetime, timezone
from pathlib import Path
from typing import Any


DEFAULT_INPUT = "Podtech/abeja-cc-ja-filtered"
DEFAULT_OUTPUT = "Podtech/abeja-cc-ja-cleaned"
DEFAULT_IMAGE = "python:3.12"
DEFAULT_FLAVOR = "cpu-upgrade"
DEFAULT_TIMEOUT = "6h"
CODE_IGNORE = ["__pycache__/**", "*.pyc", ".pytest_cache/**", "test_*.py", "*.md"]


def parse_dirs(spec: str) -> list[int]:
    result: list[int] = []
    for part in spec.split(","):
        part = part.strip()
        if "-" in part:
            low, high = part.split("-", 1)
            result.extend(range(int(low), int(high) + 1))
        elif part:
            result.append(int(part))
    return sorted(set(result))


def code_ref(code_dir: Path) -> str:
    """git のコミット短縮ハッシュ（未コミット変更があれば -dirty と内容ハッシュ）。"""

    try:
        sha = subprocess.check_output(["git", "rev-parse", "--short", "HEAD"], cwd=code_dir, text=True).strip()
        dirty = subprocess.check_output(["git", "status", "--porcelain", "--", "."], cwd=code_dir, text=True).strip() != ""
    except Exception:  # noqa: BLE001
        sha, dirty = "nogit", True
    if not dirty:
        return sha
    digest = hashlib.sha256()
    for path in sorted(code_dir.rglob("*")):
        if path.is_file() and "__pycache__" not in path.parts and not path.name.startswith("test_"):
            digest.update(path.relative_to(code_dir).as_posix().encode())
            digest.update(path.read_bytes())
    return f"{sha}-dirty-{digest.hexdigest()[:8]}"


def build_job_script(output_repo: str, ref: str, dir_index: int, args: argparse.Namespace) -> str:
    input_dir = f"/data/data/common_crawl_{dir_index}"
    run_args = [
        "--input-dir", input_dir,
        "--output-root", f"/work/out/common_crawl_{dir_index}",
        "--blocklist-cache-dir", "/work/repo/blocklists/ut1",
        "--upload-repo", output_repo,
        "--upload-prefix", f"outputs/common_crawl_{dir_index}",
        "--upload-batch", str(args.upload_batch),
        "--delete-local-after-upload",
        "--skip-existing-in-repo",
    ]
    if args.limit_shards is not None:
        run_args += ["--limit-shards", str(args.limit_shards)]
    if args.policy_approver:
        run_args += ["--policy-approver", args.policy_approver]
    if args.policy_approved_on:
        run_args += ["--policy-approved-on", args.policy_approved_on]
    if args.policy_note:
        run_args += ["--policy-note", args.policy_note]
    workers_expr = str(args.workers) if args.workers else '"$(( ${CPU_CORES:-2} > 1 ? ${CPU_CORES:-2} - 1 : 1 ))"'
    snapshot = (
        "from huggingface_hub import snapshot_download; "
        f"snapshot_download({output_repo!r}, repo_type='dataset', local_dir='/work/repo', "
        f"allow_patterns=['code/{ref}/**', 'blocklists/ut1/**'])"
    )
    lines = [
        "set -euo pipefail",
        "export PIP_DISABLE_PIP_VERSION_CHECK=1 PYTHONUNBUFFERED=1",
        'pip install -q "pyarrow>=17" "huggingface_hub>=1.0" "sudachipy>=0.6" "sudachidict_core"',
        "mkdir -p /work/out && cd /work",
        f"python -c {shlex.quote(snapshot)}",
        f"ls /work/repo/code/{ref}/src >/dev/null",
        f"test -f /work/repo/blocklists/ut1/manifest.json",
        # pipefail 下で `ls | head` は SIGPIPE で失敗し得るため、件数だけを表示する
        f'echo "input shards: $(ls {input_dir} | wc -l)"',
        f"python /work/repo/code/{ref}/src/run_shard.py " + " ".join(shlex.quote(a) for a in run_args) + f" --workers {workers_expr}",
    ]
    return "\n".join(lines) + "\n"


def upload_code_and_blocklists(api, output_repo: str, code_dir: Path, ref: str, ut1_cache_dir: Path, dry_run: bool) -> dict[str, Any]:
    existing = set(api.list_repo_files(output_repo, repo_type="dataset")) if not dry_run else set()
    code_prefix = f"code/{ref}/src"
    files = sorted(p for p in code_dir.rglob("*") if p.is_file() and "__pycache__" not in p.parts and not p.name.startswith("test_") and not p.name.endswith(".pyc"))
    manifest = {
        "ref": ref,
        "uploaded_at_utc": datetime.now(timezone.utc).isoformat(),
        "files": {p.relative_to(code_dir).as_posix(): hashlib.sha256(p.read_bytes()).hexdigest() for p in files},
    }
    actions: dict[str, Any] = {"code_prefix": code_prefix, "code_files": len(files), "ref": ref}
    if dry_run:
        actions["code_upload"] = "dry-run"
    elif f"{code_prefix}/run_shard.py" in existing:
        actions["code_upload"] = "already present"
    else:
        api.upload_folder(repo_id=output_repo, repo_type="dataset", folder_path=str(code_dir), path_in_repo=code_prefix,
                          ignore_patterns=CODE_IGNORE, commit_message=f"code {ref}")
        api.upload_file(repo_id=output_repo, repo_type="dataset", path_or_fileobj=json.dumps(manifest, ensure_ascii=False, indent=2).encode("utf-8"),
                        path_in_repo=f"code/{ref}/MANIFEST.json", commit_message=f"code manifest {ref}")
        actions["code_upload"] = "uploaded"
    if not (ut1_cache_dir / "manifest.json").exists():
        raise FileNotFoundError(f"UT1 キャッシュがありません: {ut1_cache_dir}（domain_blocklist.py fetch を先に実行）")
    if dry_run:
        actions["blocklist_upload"] = "dry-run"
    elif "blocklists/ut1/manifest.json" in existing:
        actions["blocklist_upload"] = "already present"
    else:
        api.upload_folder(repo_id=output_repo, repo_type="dataset", folder_path=str(ut1_cache_dir), path_in_repo="blocklists/ut1",
                          commit_message="UT1 blocklists snapshot")
        actions["blocklist_upload"] = "uploaded"
    return actions


def main(argv: list[str] | None = None) -> None:
    source_dir = Path(__file__).resolve().parent
    project_root = source_dir.parent
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("--input-dataset", default=DEFAULT_INPUT)
    parser.add_argument("--output-repo", default=DEFAULT_OUTPUT, help="非公開で作成される出力データセット")
    parser.add_argument("--dirs", default="0-18", help="例: 0-18, 0,1,2")
    parser.add_argument("--flavor", default=DEFAULT_FLAVOR)
    parser.add_argument("--timeout", default=DEFAULT_TIMEOUT, help="例: 6h, 90m")
    parser.add_argument("--image", default=DEFAULT_IMAGE)
    parser.add_argument("--namespace", default=None, help="課金先。既定は出力リポジトリの所有者")
    parser.add_argument("--workers", type=int, default=None, help="既定はジョブ内の CPU_CORES - 1")
    parser.add_argument("--upload-batch", type=int, default=5)
    parser.add_argument("--limit-shards", type=int, default=None, help="各ディレクトリの先頭N件だけ（試運転用）")
    parser.add_argument("--policy-approver", default=None)
    parser.add_argument("--policy-approved-on", default=None)
    parser.add_argument("--policy-note", default=None)
    parser.add_argument("--code-dir", type=Path, default=source_dir)
    parser.add_argument("--ut1-cache-dir", type=Path, default=project_root / "data" / "blocklists" / "ut1")
    parser.add_argument("--dry-run", action="store_true", help="ジョブ定義とスクリプトを表示するだけで起動しない")
    parser.add_argument("--wait", action="store_true", help="全ジョブの終了を待つ")
    args = parser.parse_args(argv)

    token = os.environ.get("HF_TOKEN")
    if not token and not args.dry_run:
        raise SystemExit("HF_TOKEN が未設定です（uv run --env-file .env ...）")
    dirs = parse_dirs(args.dirs)
    ref = code_ref(args.code_dir)
    namespace = args.namespace or args.output_repo.split("/")[0]

    from huggingface_hub import HfApi, Volume

    api = HfApi(token=token)
    if not args.dry_run:
        api.create_repo(args.output_repo, repo_type="dataset", private=True, exist_ok=True)
    actions = upload_code_and_blocklists(api, args.output_repo, args.code_dir, ref, args.ut1_cache_dir, args.dry_run)
    print(json.dumps({"event": "prepared", **actions, "output_repo": args.output_repo, "private": True}, ensure_ascii=False), flush=True)

    launched: list[dict[str, Any]] = []
    for dir_index in dirs:
        script = build_job_script(args.output_repo, ref, dir_index, args)
        spec = {
            "name": f"abeja-cc-ja-clean-{dir_index}",
            "image": args.image,
            "flavor": args.flavor,
            "timeout": args.timeout,
            "namespace": namespace,
            "volumes": [{"type": "dataset", "source": args.input_dataset, "mount_path": "/data", "read_only": True}],
            "secrets": ["HF_TOKEN"],
            "labels": {"pipeline": "abeja-cc-ja-cleansing", "dir": f"common_crawl_{dir_index}", "code_ref": ref},
        }
        if args.dry_run:
            print(json.dumps({"event": "dry-run", "job": spec}, ensure_ascii=False))
            print("--- script ---\n" + script)
            continue
        job = api.run_job(
            image=args.image,
            command=["bash", "-lc", script],
            flavor=args.flavor,
            timeout=args.timeout,
            secrets={"HF_TOKEN": token},
            env={"PIPELINE_DIR": f"common_crawl_{dir_index}"},
            volumes=[Volume(type="dataset", source=args.input_dataset, mount_path="/data", read_only=True)],
            namespace=namespace,
            name=spec["name"],
            labels=spec["labels"],
        )
        launched.append({"dir": dir_index, "job_id": job.id, "url": job.url})
        print(json.dumps({"event": "launched", "dir": dir_index, "job_id": job.id, "url": job.url}), flush=True)
    if launched:
        record = project_root / "data" / f"hf_jobs_{datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%SZ')}.json"
        record.parent.mkdir(parents=True, exist_ok=True)
        record.write_text(json.dumps({"ref": ref, "output_repo": args.output_repo, "jobs": launched, "flavor": args.flavor, "timeout": args.timeout}, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
        print(json.dumps({"event": "recorded", "file": str(record)}), flush=True)
    if args.wait and launched:
        finished = api.wait_for_job(job_id=[j["job_id"] for j in launched])
        for info in (finished if isinstance(finished, list) else [finished]):
            print(json.dumps({"event": "finished", "job_id": info.id, "stage": info.status.stage, "message": info.status.message}), flush=True)


if __name__ == "__main__":
    main()