scripts/prepare_mgnify_dataset.py

#!/usr/bin/env python3
"""Build a viewer-friendly file/shard index for LiteFold/Mgnify."""

from __future__ import annotations

import argparse
import hashlib
import json
import os
import re
import shutil
from collections import Counter, defaultdict
from pathlib import Path
from typing import Any

import pyarrow as pa
import pyarrow.parquet as pq
from huggingface_hub import HfApi, hf_hub_download


DATASET_ID = "mgnify_proteins"
PREFIX = "sequence_mgnify_current_release_"


INDEX_COLUMNS = [
    "file_id",
    "repo_id",
    "source_sha",
    "dataset_id",
    "source_family",
    "source_slug",
    "source_file",
    "path",
    "role",
    "shard_index",
    "part_index",
    "size_bytes",
    "compression",
    "logical_table_size_bytes",
    "split_part_count",
    "split_chunk_bytes",
    "sequence_source_shard_count",
    "sequence_source_bytes",
    "repo_file_count",
    "repo_total_bytes",
    "sequence_shard_count_total",
    "sequence_shard_bytes_total",
    "table_repo_file_count_total",
    "table_repo_bytes_total",
    "logical_table_count_total",
    "logical_table_bytes_total",
    "is_sequence_shard",
    "is_table_file",
    "is_split_part",
    "is_split_manifest",
    "is_original_table_copy",
    "download_pattern",
    "access_note",
    "split_bucket",
]


SCHEMA = pa.schema(
    [
        pa.field("file_id", pa.string()),
        pa.field("repo_id", pa.string()),
        pa.field("source_sha", pa.string()),
        pa.field("dataset_id", pa.string()),
        pa.field("source_family", pa.string()),
        pa.field("source_slug", pa.string()),
        pa.field("source_file", pa.string()),
        pa.field("path", pa.string()),
        pa.field("role", pa.string()),
        pa.field("shard_index", pa.int64()),
        pa.field("part_index", pa.int64()),
        pa.field("size_bytes", pa.int64()),
        pa.field("compression", pa.string()),
        pa.field("logical_table_size_bytes", pa.int64()),
        pa.field("split_part_count", pa.int64()),
        pa.field("split_chunk_bytes", pa.int64()),
        pa.field("sequence_source_shard_count", pa.int64()),
        pa.field("sequence_source_bytes", pa.int64()),
        pa.field("repo_file_count", pa.int64()),
        pa.field("repo_total_bytes", pa.int64()),
        pa.field("sequence_shard_count_total", pa.int64()),
        pa.field("sequence_shard_bytes_total", pa.int64()),
        pa.field("table_repo_file_count_total", pa.int64()),
        pa.field("table_repo_bytes_total", pa.int64()),
        pa.field("logical_table_count_total", pa.int64()),
        pa.field("logical_table_bytes_total", pa.int64()),
        pa.field("is_sequence_shard", pa.bool_()),
        pa.field("is_table_file", pa.bool_()),
        pa.field("is_split_part", pa.bool_()),
        pa.field("is_split_manifest", pa.bool_()),
        pa.field("is_original_table_copy", pa.bool_()),
        pa.field("download_pattern", pa.string()),
        pa.field("access_note", pa.string()),
        pa.field("split_bucket", pa.int64()),
    ]
)


def load_token() -> str | None:
    for key in ("HF_TOKEN", "HUGGINGFACE_HUB_TOKEN"):
        value = os.environ.get(key)
        if value:
            return value
    env_path = Path(".env")
    if env_path.exists():
        for line in env_path.read_text().splitlines():
            stripped = line.strip()
            if not stripped or stripped.startswith("#") or "=" not in stripped:
                continue
            key, value = stripped.split("=", 1)
            if key.strip() in {"HF_TOKEN", "HUGGINGFACE_HUB_TOKEN"}:
                value = value.strip().strip('"').strip("'")
                if value:
                    return value
    return None


def stable_bucket(value: str, buckets: int = 10) -> int:
    digest = hashlib.sha256(value.encode("utf-8")).hexdigest()[:16]
    return int(digest, 16) % buckets


def source_file_from_slug(slug: str) -> str:
    if slug.startswith(PREFIX):
        return "sequence/mgnify/current_release/" + slug[len(PREFIX) :]
    return ""


def source_family_from_slug(slug: str) -> str:
    if slug.startswith(PREFIX):
        slug = slug[len(PREFIX) :]
    for suffix in (".fasta.zst", ".fa.gz", ".tsv.gz.jsonl", ".tsv.gz"):
        if slug.endswith(suffix):
            slug = slug[: -len(suffix)]
    return slug


def compression_for_path(path: str) -> str:
    if path.endswith(".fasta.zst"):
        return "zstd"
    if path.endswith(".jsonl"):
        return "jsonl"
    if path.endswith(".json"):
        return "json"
    return ""


def parse_path(path: str) -> dict[str, Any]:
    sequence_match = re.fullmatch(r"sequences/([^/]+)/shard-(\d+)\.fasta\.zst", path)
    if sequence_match:
        source_slug = sequence_match.group(1)
        return {
            "role": "sequence_shard",
            "source_slug": source_slug,
            "source_family": source_family_from_slug(source_slug),
            "source_file": source_file_from_slug(source_slug),
            "shard_index": int(sequence_match.group(2)),
            "part_index": -1,
            "is_sequence_shard": True,
            "is_table_file": False,
            "is_split_part": False,
            "is_split_manifest": False,
            "is_original_table_copy": False,
        }

    split_manifest_match = re.fullmatch(r"tables/(.+\.jsonl)\.parts/_SPLIT_MANIFEST\.json", path)
    if split_manifest_match:
        source_slug = split_manifest_match.group(1)
        return {
            "role": "table_split_manifest",
            "source_slug": source_slug,
            "source_family": source_family_from_slug(source_slug),
            "source_file": source_file_from_slug(source_slug.removesuffix(".jsonl")),
            "shard_index": -1,
            "part_index": -1,
            "is_sequence_shard": False,
            "is_table_file": True,
            "is_split_part": False,
            "is_split_manifest": True,
            "is_original_table_copy": False,
        }

    split_part_match = re.fullmatch(r"tables/(.+\.jsonl)\.parts/part-(\d+)\.jsonl", path)
    if split_part_match:
        source_slug = split_part_match.group(1)
        return {
            "role": "table_split_part",
            "source_slug": source_slug,
            "source_family": source_family_from_slug(source_slug),
            "source_file": source_file_from_slug(source_slug.removesuffix(".jsonl")),
            "shard_index": -1,
            "part_index": int(split_part_match.group(2)),
            "is_sequence_shard": False,
            "is_table_file": True,
            "is_split_part": True,
            "is_split_manifest": False,
            "is_original_table_copy": False,
        }

    table_match = re.fullmatch(r"tables/(.+\.jsonl)", path)
    if table_match:
        source_slug = table_match.group(1)
        return {
            "role": "table_jsonl",
            "source_slug": source_slug,
            "source_family": source_family_from_slug(source_slug),
            "source_file": source_file_from_slug(source_slug.removesuffix(".jsonl")),
            "shard_index": -1,
            "part_index": -1,
            "is_sequence_shard": False,
            "is_table_file": True,
            "is_split_part": False,
            "is_split_manifest": False,
            "is_original_table_copy": False,
        }

    role = {".gitattributes": "git_attributes", "README.md": "readme"}.get(path, "other")
    return {
        "role": role,
        "source_slug": "",
        "source_family": "",
        "source_file": "",
        "shard_index": -1,
        "part_index": -1,
        "is_sequence_shard": False,
        "is_table_file": False,
        "is_split_part": False,
        "is_split_manifest": False,
        "is_original_table_copy": False,
    }


def load_split_manifests(raw_dir: Path) -> dict[str, dict[str, Any]]:
    manifests: dict[str, dict[str, Any]] = {}
    for path in raw_dir.glob("tables/*.parts/_SPLIT_MANIFEST.json"):
        manifest = json.loads(path.read_text())
        base_path = "tables/" + path.parent.name.removesuffix(".parts")
        manifests[base_path] = manifest
    return manifests


def build_dataset(repo_id: str, raw_dir: Path, out_dir: Path) -> dict[str, Any]:
    token = load_token()
    api = HfApi(token=token)
    info = api.dataset_info(repo_id, files_metadata=True)
    raw_dir.mkdir(parents=True, exist_ok=True)

    for sibling in info.siblings or []:
        path = sibling.rfilename
        if path == "README.md" or path.endswith("_SPLIT_MANIFEST.json"):
            hf_hub_download(repo_id=repo_id, repo_type="dataset", filename=path, local_dir=raw_dir, token=token)

    split_manifests = load_split_manifests(raw_dir)
    sizes = {s.rfilename: int(getattr(s, "size", 0) or 0) for s in info.siblings or []}
    source_sequence_counts: dict[str, int] = defaultdict(int)
    source_sequence_bytes: dict[str, int] = defaultdict(int)
    for path, size in sizes.items():
        parsed = parse_path(path)
        if parsed["is_sequence_shard"]:
            source_sequence_counts[parsed["source_slug"]] += 1
            source_sequence_bytes[parsed["source_slug"]] += size

    top_level_tables = {
        path: size for path, size in sizes.items() if path.startswith("tables/") and path.endswith(".jsonl") and ".parts/" not in path
    }
    logical_tables = dict(top_level_tables)
    for base_path, manifest in split_manifests.items():
        if base_path not in logical_tables:
            logical_tables[base_path] = int(manifest["original_size"])

    repo_file_count = len(sizes)
    repo_total_bytes = sum(sizes.values())
    sequence_shard_count_total = sum(1 for path in sizes if path.startswith("sequences/"))
    sequence_shard_bytes_total = sum(size for path, size in sizes.items() if path.startswith("sequences/"))
    table_repo_file_count_total = sum(1 for path in sizes if path.startswith("tables/"))
    table_repo_bytes_total = sum(size for path, size in sizes.items() if path.startswith("tables/"))
    logical_table_count_total = len(logical_tables)
    logical_table_bytes_total = sum(logical_tables.values())

    rows = []
    for path in sorted(sizes):
        if (
            path.startswith("data/")
            or path.startswith("metadata/")
            or path.startswith("scripts/")
            or path in {"_MANIFEST.json", "dataset_summary.json"}
        ):
            continue
        size = sizes[path]
        parsed = parse_path(path)
        source_slug = parsed["source_slug"]
        base_table_path = f"tables/{source_slug}" if source_slug.endswith(".jsonl") else ""
        manifest = split_manifests.get(base_table_path) or {}
        file_id = path
        download_pattern = path
        if parsed["role"] == "sequence_shard" and source_slug:
            download_pattern = f"sequences/{source_slug}/shard-*.fasta.zst"
        elif parsed["role"] in {"table_split_part", "table_split_manifest"} and source_slug:
            download_pattern = f"tables/{source_slug}.parts/part-*.jsonl"
        elif parsed["role"] == "table_jsonl" and source_slug:
            download_pattern = f"tables/{source_slug}"
        rows.append(
            {
                "file_id": file_id,
                "repo_id": repo_id,
                "source_sha": info.sha,
                "dataset_id": DATASET_ID,
                "source_family": parsed["source_family"],
                "source_slug": source_slug,
                "source_file": parsed["source_file"],
                "path": path,
                "role": parsed["role"],
                "shard_index": parsed["shard_index"],
                "part_index": parsed["part_index"],
                "size_bytes": size,
                "compression": compression_for_path(path),
                "logical_table_size_bytes": int(logical_tables.get(base_table_path, -1)) if parsed["is_table_file"] else -1,
                "split_part_count": len(manifest.get("parts", [])) if manifest else -1,
                "split_chunk_bytes": int(manifest.get("chunk_bytes", -1)) if manifest else -1,
                "sequence_source_shard_count": source_sequence_counts.get(source_slug, -1) if parsed["is_sequence_shard"] else -1,
                "sequence_source_bytes": source_sequence_bytes.get(source_slug, -1) if parsed["is_sequence_shard"] else -1,
                "repo_file_count": repo_file_count,
                "repo_total_bytes": repo_total_bytes,
                "sequence_shard_count_total": sequence_shard_count_total,
                "sequence_shard_bytes_total": sequence_shard_bytes_total,
                "table_repo_file_count_total": table_repo_file_count_total,
                "table_repo_bytes_total": table_repo_bytes_total,
                "logical_table_count_total": logical_table_count_total,
                "logical_table_bytes_total": logical_table_bytes_total,
                "is_sequence_shard": parsed["is_sequence_shard"],
                "is_table_file": parsed["is_table_file"],
                "is_split_part": parsed["is_split_part"],
                "is_split_manifest": parsed["is_split_manifest"],
                "is_original_table_copy": parsed["role"] == "table_jsonl" and base_table_path in split_manifests,
                "download_pattern": download_pattern,
                "access_note": "Default config indexes Mgnify files. Stream raw FASTA/table payloads from sequences/ and tables/ with huggingface_hub.",
                "split_bucket": stable_bucket(file_id),
            }
        )

    if out_dir.exists():
        shutil.rmtree(out_dir)
    data_dir = out_dir / "data"
    metadata_dir = out_dir / "metadata"
    data_dir.mkdir(parents=True, exist_ok=True)
    metadata_dir.mkdir(parents=True, exist_ok=True)

    train_rows = [row for row in rows if row["split_bucket"] != 0]
    test_rows = [row for row in rows if row["split_bucket"] == 0]
    pq.write_table(pa.Table.from_pylist(train_rows, schema=SCHEMA), data_dir / "train-00000-of-00001.parquet", compression="zstd")
    pq.write_table(pa.Table.from_pylist(test_rows, schema=SCHEMA), data_dir / "test-00000-of-00001.parquet", compression="zstd")
    pq.write_table(pa.Table.from_pylist(rows, schema=SCHEMA), metadata_dir / "source_files.parquet", compression="zstd")

    role_counts = Counter(row["role"] for row in rows)
    source_family_counts = Counter(row["source_family"] for row in rows if row["source_family"])
    sequence_sources = {
        source_slug: {"shards": source_sequence_counts[source_slug], "bytes": source_sequence_bytes[source_slug]}
        for source_slug in sorted(source_sequence_counts)
    }
    logical_table_sources = {
        path: {"bytes": int(size), "has_split_parts": path in split_manifests}
        for path, size in sorted(logical_tables.items())
    }
    summary = {
        "source": repo_id,
        "source_sha": info.sha,
        "viewer_table_scope": "file/shard index",
        "data_format": "parquet",
        "dataset_id": DATASET_ID,
        "index_rows": len(rows),
        "splits": {"train": len(train_rows), "test": len(test_rows)},
        "split_strategy": "default file index uses deterministic sha256(file_id) % 10; bucket 0 is test, buckets 1-9 are train",
        "repo_file_count": repo_file_count,
        "repo_total_bytes": repo_total_bytes,
        "sequence_source_count": len(sequence_sources),
        "sequence_shard_count_total": sequence_shard_count_total,
        "sequence_shard_bytes_total": sequence_shard_bytes_total,
        "table_repo_file_count_total": table_repo_file_count_total,
        "table_repo_bytes_total": table_repo_bytes_total,
        "logical_table_count_total": logical_table_count_total,
        "logical_table_bytes_total": logical_table_bytes_total,
        "role_counts": dict(sorted(role_counts.items())),
        "source_family_index_counts": dict(sorted(source_family_counts.items())),
        "sequence_sources": sequence_sources,
        "logical_table_sources": logical_table_sources,
        "columns": INDEX_COLUMNS,
    }
    (out_dir / "_MANIFEST.json").write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8")
    (out_dir / "dataset_summary.json").write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8")
    return summary


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--repo-id", default="LiteFold/Mgnify")
    parser.add_argument("--raw-dir", type=Path, default=Path("LiteFold_Mgnify_raw"))
    parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_Mgnify_processed"))
    args = parser.parse_args()
    summary = build_dataset(args.repo_id, args.raw_dir, args.out_dir)
    print(json.dumps(summary, indent=2))


if __name__ == "__main__":
    main()