| |
| """Build viewer-friendly Parquet splits for LiteFold/DisProt.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import shutil |
| from collections import Counter |
| from pathlib import Path |
| from typing import Any |
|
|
| import pandas as pd |
|
|
|
|
| ENTRY_COLUMNS = [ |
| "disprot_id", |
| "accession", |
| "uniparc", |
| "name", |
| "organism", |
| "ncbi_taxon_id", |
| "length", |
| "disorder_content", |
| "dataset_labels", |
| "taxonomy", |
| "released", |
| "date", |
| "creator", |
| "uniref100", |
| "uniref90", |
| "uniref50", |
| "sequence", |
| "region_count", |
| "region_ids", |
| "region_starts", |
| "region_ends", |
| "region_lengths", |
| "region_terms", |
| "region_term_ids", |
| "region_namespaces", |
| "evidence_codes", |
| "reference_ids", |
| "reference_sources", |
| "curator_names", |
| "cross_refs", |
| "feature_databases", |
| "feature_ids", |
| "feature_names", |
| "feature_count", |
| "gene_names", |
| "consensus_starts", |
| "consensus_ends", |
| "consensus_types", |
| "split_bucket", |
| ] |
|
|
|
|
| REGION_COLUMNS = [ |
| "region_id", |
| "disprot_id", |
| "accession", |
| "start", |
| "end", |
| "length", |
| "term_id", |
| "term_name", |
| "term_namespace", |
| "term_ontology", |
| "evidence_code", |
| "evidence_name", |
| "ec_go", |
| "reference_id", |
| "reference_source", |
| "curator_name", |
| "curator_orcid", |
| "date", |
| "released", |
| "statement_texts", |
| "statement_types", |
| "cross_refs", |
| "uniprot_changed", |
| "version", |
| ] |
|
|
|
|
| def stable_bucket(value: str, buckets: int = 10) -> int: |
| digest = hashlib.sha256(value.encode("utf-8")).hexdigest()[:16] |
| return int(digest, 16) % buckets |
|
|
|
|
| def strings(values: list[Any]) -> list[str]: |
| return [str(value) for value in values if value is not None and value != ""] |
|
|
|
|
| def flatten_cross_refs(items: list[dict[str, Any]]) -> list[str]: |
| refs = [] |
| for item in items or []: |
| db = item.get("db") |
| ident = item.get("id") |
| if db and ident: |
| refs.append(f"{db}:{ident}") |
| elif ident: |
| refs.append(str(ident)) |
| return refs |
|
|
|
|
| def gene_names(record: dict[str, Any]) -> list[str]: |
| names = [] |
| for gene in record.get("genes") or []: |
| name = ((gene.get("name") or {}).get("value")) |
| if name: |
| names.append(name) |
| for key in ["synonyms", "orfNames", "olnNames"]: |
| for item in gene.get(key) or []: |
| value = item.get("value") if isinstance(item, dict) else item |
| if value: |
| names.append(str(value)) |
| return sorted(set(names)) |
|
|
|
|
| def feature_lists(record: dict[str, Any]) -> tuple[list[str], list[str], list[str]]: |
| databases = [] |
| ids = [] |
| names = [] |
| for database, features in (record.get("features") or {}).items(): |
| for item in features or []: |
| databases.append(database) |
| ids.append(str(item.get("id") or "")) |
| names.append(str(item.get("name") or "")) |
| return databases, ids, names |
|
|
|
|
| def consensus(record: dict[str, Any]) -> tuple[list[int], list[int], list[str]]: |
| starts = [] |
| ends = [] |
| types = [] |
| for item in ((record.get("disprot_consensus") or {}).get("full") or []): |
| if item.get("start") is not None and item.get("end") is not None: |
| starts.append(int(item["start"])) |
| ends.append(int(item["end"])) |
| types.append(str(item.get("type") or "")) |
| return starts, ends, types |
|
|
|
|
| def region_row(record: dict[str, Any], region: dict[str, Any]) -> dict[str, Any]: |
| start = region.get("start") |
| end = region.get("end") |
| statements = region.get("statement") or [] |
| return { |
| "region_id": region.get("region_id"), |
| "disprot_id": record.get("disprot_id"), |
| "accession": record.get("acc"), |
| "start": int(start) if start is not None else None, |
| "end": int(end) if end is not None else None, |
| "length": int(end) - int(start) + 1 if start is not None and end is not None else None, |
| "term_id": region.get("term_id"), |
| "term_name": region.get("term_name"), |
| "term_namespace": region.get("term_namespace") or region.get("disprot_namespace"), |
| "term_ontology": region.get("term_ontology"), |
| "evidence_code": region.get("ec_id"), |
| "evidence_name": region.get("ec_name"), |
| "ec_go": region.get("ec_go"), |
| "reference_id": region.get("reference_id"), |
| "reference_source": region.get("reference_source"), |
| "curator_name": region.get("curator_name"), |
| "curator_orcid": region.get("curator_orcid"), |
| "date": region.get("date"), |
| "released": region.get("released"), |
| "statement_texts": strings([item.get("text") for item in statements if isinstance(item, dict)]), |
| "statement_types": strings([item.get("type") for item in statements if isinstance(item, dict)]), |
| "cross_refs": flatten_cross_refs(region.get("cross_refs") or []), |
| "uniprot_changed": region.get("uniprot_changed"), |
| "version": region.get("version"), |
| } |
|
|
|
|
| def entry_row(record: dict[str, Any]) -> tuple[dict[str, Any], list[dict[str, Any]]]: |
| regions = record.get("regions") or [] |
| region_rows = [region_row(record, region) for region in regions] |
| feature_databases, feature_ids, feature_names = feature_lists(record) |
| consensus_starts, consensus_ends, consensus_types = consensus(record) |
| region_starts = [row["start"] for row in region_rows if row["start"] is not None] |
| region_ends = [row["end"] for row in region_rows if row["end"] is not None] |
| row = { |
| "disprot_id": record.get("disprot_id"), |
| "accession": record.get("acc"), |
| "uniparc": record.get("UniParc"), |
| "name": record.get("name"), |
| "organism": record.get("organism"), |
| "ncbi_taxon_id": record.get("ncbi_taxon_id"), |
| "length": record.get("length"), |
| "disorder_content": record.get("disorder_content"), |
| "dataset_labels": strings(record.get("dataset") or []), |
| "taxonomy": strings(record.get("taxonomy") or []), |
| "released": record.get("released"), |
| "date": record.get("date"), |
| "creator": record.get("creator"), |
| "uniref100": record.get("uniref100"), |
| "uniref90": record.get("uniref90"), |
| "uniref50": record.get("uniref50"), |
| "sequence": record.get("sequence"), |
| "region_count": len(region_rows), |
| "region_ids": strings([row["region_id"] for row in region_rows]), |
| "region_starts": region_starts, |
| "region_ends": region_ends, |
| "region_lengths": [row["length"] for row in region_rows if row["length"] is not None], |
| "region_terms": strings([row["term_name"] for row in region_rows]), |
| "region_term_ids": strings([row["term_id"] for row in region_rows]), |
| "region_namespaces": strings([row["term_namespace"] for row in region_rows]), |
| "evidence_codes": strings([row["evidence_code"] for row in region_rows]), |
| "reference_ids": strings([row["reference_id"] for row in region_rows]), |
| "reference_sources": strings([row["reference_source"] for row in region_rows]), |
| "curator_names": strings([row["curator_name"] for row in region_rows]), |
| "cross_refs": sorted({xref for row in region_rows for xref in row["cross_refs"]}), |
| "feature_databases": feature_databases, |
| "feature_ids": feature_ids, |
| "feature_names": feature_names, |
| "feature_count": len(feature_ids), |
| "gene_names": gene_names(record), |
| "consensus_starts": consensus_starts, |
| "consensus_ends": consensus_ends, |
| "consensus_types": consensus_types, |
| "split_bucket": stable_bucket(str(record.get("disprot_id") or record.get("acc"))), |
| } |
| return row, region_rows |
|
|
|
|
| def build_dataset(raw_dir: Path, out_dir: Path) -> dict[str, Any]: |
| source = raw_dir / "tables/annotation_disprot_disprot_current.json.jsonl" |
| wrapper = json.loads(source.read_text(encoding="utf-8")) |
| records = wrapper["row"]["data"] |
| rows = [] |
| region_rows = [] |
| for record in records: |
| row, regions = entry_row(record) |
| rows.append(row) |
| region_rows.extend(regions) |
|
|
| 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) |
|
|
| df = pd.DataFrame.from_records(rows, columns=ENTRY_COLUMNS) |
| train = df[df["split_bucket"].ne(0)].sort_values("disprot_id", kind="mergesort") |
| test = df[df["split_bucket"].eq(0)].sort_values("disprot_id", kind="mergesort") |
| train.to_parquet(data_dir / "train-00000-of-00001.parquet", index=False, compression="zstd") |
| test.to_parquet(data_dir / "test-00000-of-00001.parquet", index=False, compression="zstd") |
|
|
| region_df = pd.DataFrame.from_records(region_rows, columns=REGION_COLUMNS) |
| region_df.to_parquet(metadata_dir / "regions.parquet", index=False, compression="zstd") |
|
|
| dataset_counts = Counter(label for labels in df["dataset_labels"] for label in labels) |
| term_counts = Counter(term for terms in df["region_terms"] for term in terms) |
| namespace_counts = Counter(ns for namespaces in df["region_namespaces"] for ns in namespaces) |
| summary = { |
| "source": "LiteFold/DisProt", |
| "entry_rows": int(len(df)), |
| "region_rows": int(len(region_df)), |
| "splits": {"train": int(len(train)), "test": int(len(test))}, |
| "split_strategy": "deterministic sha256(disprot_id) % 10; bucket 0 is test, buckets 1-9 are train", |
| "dataset_label_counts": dict(dataset_counts.most_common()), |
| "top_region_terms": dict(term_counts.most_common(20)), |
| "region_namespace_counts": dict(namespace_counts.most_common()), |
| "columns": ENTRY_COLUMNS, |
| "metadata_tables": ["metadata/regions.parquet"], |
| } |
| (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("--raw-dir", type=Path, default=Path("LiteFold_DisProt_raw")) |
| parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_DisProt_processed")) |
| args = parser.parse_args() |
| summary = build_dataset(args.raw_dir, args.out_dir) |
| print(json.dumps(summary, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
