| |
| """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() |
|
|
