#!/usr/bin/env python3 """Build viewer-friendly Parquet splits for LiteFold/GO.""" from __future__ import annotations import argparse import hashlib import json import re from collections import Counter, defaultdict from pathlib import Path import pandas as pd TERM_COLUMNS = [ "go_id", "go_numeric_id", "name", "namespace", "definition", "definition_xrefs", "comment", "synonyms", "synonym_scopes", "alt_ids", "subsets", "xrefs", "is_a_ids", "relationship_edges", "relationship_types", "relationship_target_ids", "parent_ids", "intersection_of", "union_of", "disjoint_from", "replaced_by", "consider", "property_values", "created_by", "creation_date", "is_obsolete", "in_go_basic", "split_bucket", ] def split_unquoted_comment(value: str) -> str: in_quote = False escaped = False for index, char in enumerate(value): if escaped: escaped = False continue if char == "\\": escaped = True continue if char == '"': in_quote = not in_quote continue if char == "!" and not in_quote: return value[:index].strip() return value.strip() def parse_quoted_xrefs(value: str) -> tuple[str | None, list[str]]: match = re.match(r'^"((?:[^"\\]|\\.)*)"\s*(?:\[(.*)\])?', value.strip()) if not match: return value.strip() or None, [] text = bytes(match.group(1), "utf-8").decode("unicode_escape") xrefs = [] if match.group(2): xrefs = [part.strip() for part in match.group(2).split(",") if part.strip()] return text, xrefs def parse_synonym(value: str) -> tuple[str | None, str | None]: match = re.match(r'^"((?:[^"\\]|\\.)*)"\s+([A-Z]+)', value.strip()) if not match: return value.strip() or None, None text = bytes(match.group(1), "utf-8").decode("unicode_escape") return text, match.group(2) def stable_bucket(value: str, buckets: int = 10) -> int: digest = hashlib.sha256(value.encode("utf-8")).hexdigest()[:16] return int(digest, 16) % buckets def parse_obo(path: Path) -> tuple[dict[str, list[str]], list[dict[str, list[str]]], list[dict[str, list[str]]]]: header: dict[str, list[str]] = defaultdict(list) terms: list[dict[str, list[str]]] = [] typedefs: list[dict[str, list[str]]] = [] current_type: str | None = None current: dict[str, list[str]] | None = None def flush() -> None: nonlocal current, current_type if current is None: return if current_type == "Term": terms.append(current) elif current_type == "Typedef": typedefs.append(current) current = None current_type = None with path.open("r", encoding="utf-8", errors="replace") as handle: for raw_line in handle: line = raw_line.rstrip("\n") if not line or line.startswith("!"): continue if line.startswith("[") and line.endswith("]"): flush() current_type = line.strip("[]") current = defaultdict(list) continue if ": " not in line: continue key, value = line.split(": ", 1) target = header if current is None else current target[key].append(value.strip()) flush() return dict(header), terms, typedefs def first(stanza: dict[str, list[str]], key: str) -> str | None: values = stanza.get(key) or [] return values[0] if values else None def list_values(stanza: dict[str, list[str]], key: str, strip_comment: bool = False) -> list[str]: values = stanza.get(key) or [] if strip_comment: return [split_unquoted_comment(value) for value in values] return list(values) def term_to_row(stanza: dict[str, list[str]], basic_ids: set[str]) -> dict: go_id = first(stanza, "id") or "" definition, definition_xrefs = parse_quoted_xrefs(first(stanza, "def") or "") synonyms = [] synonym_scopes = [] for value in stanza.get("synonym", []): synonym, scope = parse_synonym(value) if synonym: synonyms.append(synonym) synonym_scopes.append(scope or "") relationship_edges = list_values(stanza, "relationship", strip_comment=True) relationship_types = [] relationship_target_ids = [] for edge in relationship_edges: parts = edge.split() if len(parts) >= 2: relationship_types.append(parts[0]) relationship_target_ids.append(parts[1]) is_a_ids = [value.split()[0] for value in list_values(stanza, "is_a", strip_comment=True)] parent_ids = sorted(set(is_a_ids + relationship_target_ids)) split_bucket = stable_bucket(go_id) numeric = None match = re.match(r"GO:(\d+)$", go_id) if match: numeric = int(match.group(1)) return { "go_id": go_id, "go_numeric_id": numeric, "name": first(stanza, "name"), "namespace": first(stanza, "namespace"), "definition": definition, "definition_xrefs": definition_xrefs, "comment": " ".join(stanza.get("comment", [])) or None, "synonyms": synonyms, "synonym_scopes": synonym_scopes, "alt_ids": list_values(stanza, "alt_id"), "subsets": list_values(stanza, "subset"), "xrefs": list_values(stanza, "xref", strip_comment=True), "is_a_ids": is_a_ids, "relationship_edges": relationship_edges, "relationship_types": relationship_types, "relationship_target_ids": relationship_target_ids, "parent_ids": parent_ids, "intersection_of": list_values(stanza, "intersection_of", strip_comment=True), "union_of": list_values(stanza, "union_of", strip_comment=True), "disjoint_from": list_values(stanza, "disjoint_from", strip_comment=True), "replaced_by": list_values(stanza, "replaced_by", strip_comment=True), "consider": list_values(stanza, "consider", strip_comment=True), "property_values": list_values(stanza, "property_value"), "created_by": first(stanza, "created_by"), "creation_date": first(stanza, "creation_date"), "is_obsolete": (first(stanza, "is_obsolete") or "").lower() == "true", "in_go_basic": go_id in basic_ids, "split_bucket": split_bucket, } def typedef_to_row(stanza: dict[str, list[str]]) -> dict: definition, definition_xrefs = parse_quoted_xrefs(first(stanza, "def") or "") return { "id": first(stanza, "id"), "name": first(stanza, "name"), "namespace": first(stanza, "namespace"), "definition": definition, "definition_xrefs": definition_xrefs, "is_transitive": first(stanza, "is_transitive"), "is_metadata_tag": first(stanza, "is_metadata_tag"), "is_class_level": first(stanza, "is_class_level"), "domain": list_values(stanza, "domain", strip_comment=True), "range": list_values(stanza, "range", strip_comment=True), "holds_over_chain": list_values(stanza, "holds_over_chain", strip_comment=True), "inverse_of": list_values(stanza, "inverse_of", strip_comment=True), "transitive_over": list_values(stanza, "transitive_over", strip_comment=True), "property_values": list_values(stanza, "property_value"), } def build_dataset(raw_dir: Path, out_dir: Path) -> dict: header, terms, typedefs = parse_obo(raw_dir / "go.obo") _, basic_terms, _ = parse_obo(raw_dir / "go-basic.obo") basic_ids = {first(term, "id") for term in basic_terms if first(term, "id")} rows = [term_to_row(term, basic_ids) for term in terms] df = pd.DataFrame.from_records(rows, columns=TERM_COLUMNS) df = df.sort_values(["split_bucket", "go_id"], kind="mergesort") data_dir = out_dir / "data" data_dir.mkdir(parents=True, exist_ok=True) train = df[df["split_bucket"].ne(0)].sort_values("go_id", kind="mergesort") test = df[df["split_bucket"].eq(0)].sort_values("go_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") metadata_dir = out_dir / "metadata" metadata_dir.mkdir(parents=True, exist_ok=True) typedef_df = pd.DataFrame.from_records([typedef_to_row(item) for item in typedefs]) typedef_df.to_parquet(metadata_dir / "typedefs.parquet", index=False, compression="zstd") namespace_counts = df["namespace"].value_counts(dropna=False).to_dict() obsolete_counts = df["is_obsolete"].value_counts(dropna=False).to_dict() relation_counts = Counter(rel for rels in df["relationship_types"] for rel in rels) subset_counts = Counter(subset for subsets in df["subsets"] for subset in subsets) summary = { "source": "LiteFold/GO", "data_version": (header.get("data-version") or [None])[0], "ontology": (header.get("ontology") or [None])[0], "license": next((value for value in header.get("property_value", []) if "terms:license" in value), None), "term_rows": int(len(df)), "typedef_rows": int(len(typedef_df)), "go_basic_term_rows": int(len(basic_ids)), "terms_in_go_basic": int(df["in_go_basic"].sum()), "splits": { "train": int(len(train)), "test": int(len(test)), }, "split_strategy": "deterministic sha256(go_id) % 10; bucket 0 is test, buckets 1-9 are train", "namespace_counts": {str(k): int(v) for k, v in namespace_counts.items()}, "obsolete_counts": {str(k): int(v) for k, v in obsolete_counts.items()}, "top_relationship_types": dict(relation_counts.most_common(20)), "top_subsets": dict(subset_counts.most_common(20)), "columns": TERM_COLUMNS, } (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_GO_raw")) parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_GO_processed")) args = parser.parse_args() summary = build_dataset(args.raw_dir, args.out_dir) print(json.dumps(summary, indent=2)) if __name__ == "__main__": main()