Add viewer-friendly GOA Parquet sample and source manifest

README.md

@@ -0,0 +1,148 @@
+---
+pretty_name: Gene Ontology Annotation UniProt Sample
+license: other
+tags:
+- biology
+- gene-ontology
+- goa
+- uniprot
+- protein-annotation
+- gaf
+- gpa
+- parquet
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*.parquet
+  - split: test
+    path: data/test-*.parquet
+---
+
+# Gene Ontology Annotation UniProt
+
+This dataset contains the original GOA UniProt source files plus a viewer-friendly Parquet sample/index table. The source `goa_uniprot_all.gaf.gz` and `goa_uniprot_all.gpa.gz` files are very large, so the default Dataset Viewer table contains the first 50,000 parsed annotation rows from each source file, along with a source-file manifest in `metadata/source_files.parquet`.
+
+Use the original compressed files for complete GOA coverage. Use the default Parquet table for quick inspection, schema discovery, examples, and Dataset Viewer previews.
+
+## Splits
+
+The split is deterministic by `annotation_id`: `sha256(annotation_id) % 10`. Bucket `0` is `test`; buckets `1` through `9` are `train`.
+
+| Split | Rows |
+|---|---:|
+| train | 89,958 |
+| test | 10,042 |
+| total | 100,000 |
+
+## Source Files
+
+| File | Size |
+|---|---:|
+| `goa_uniprot_all.gaf.gz` | 15,387,303,487 bytes |
+| `goa_uniprot_all.gpa.gz` | 9,462,421,263 bytes |
+
+## Usage
+
+```bash
+pip install datasets
+```
+
+Load the viewer table:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/GOA")
+print(ds)
+print(ds["train"][0])
+```
+
+Load one split:
+
+```python
+from datasets import load_dataset
+
+train = load_dataset("LiteFold/GOA", split="train")
+test = load_dataset("LiteFold/GOA", split="test")
+```
+
+Stream rows:
+
+```python
+from datasets import load_dataset
+
+stream = load_dataset("LiteFold/GOA", split="train", streaming=True)
+for row in stream.take(5):
+    print(row["db_object_id"], row["go_id"], row["evidence_code"])
+```
+
+Filter the sample for molecular-function GAF rows:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/GOA", split="train")
+mf = ds.filter(lambda row: row["source_format"] == "GAF" and row["aspect"] == "F")
+print(mf[0])
+```
+
+Download the source manifest:
+
+```python
+import pandas as pd
+from huggingface_hub import hf_hub_download
+
+path = hf_hub_download(
+    repo_id="LiteFold/GOA",
+    repo_type="dataset",
+    filename="metadata/source_files.parquet",
+)
+source_files = pd.read_parquet(path)
+print(source_files)
+```
+
+Download the full raw files when needed:
+
+```python
+from huggingface_hub import hf_hub_download
+
+gaf_path = hf_hub_download(
+    repo_id="LiteFold/GOA",
+    repo_type="dataset",
+    filename="goa_uniprot_all.gaf.gz",
+)
+```
+
+## Columns
+
+| Column | Description |
+|---|---|
+| `annotation_id` | Stable SHA-256 ID for the sampled annotation row. |
+| `source_file` | Source file: GAF or GPA. |
+| `source_format` | Parsed source format, `GAF` or `GPA`. |
+| `source_row_number` | Row number within the source annotation stream. |
+| `db` | Source database. |
+| `db_object_id` | Annotated object identifier. |
+| `db_object_symbol` | GAF object symbol, when available. |
+| `qualifier` | Raw qualifier field. |
+| `qualifiers` | Qualifier field split on `|`. |
+| `go_id` | GO identifier. |
+| `db_references` | References split on `|`. |
+| `evidence_code` | GO or ECO evidence code. |
+| `with_from` | With/from field split on `|`. |
+| `aspect` | GAF aspect: `F`, `P`, or `C`; missing for GPA rows. |
+| `db_object_name` | GAF object name, when available. |
+| `db_object_synonyms` | GAF synonyms split on `|`. |
+| `db_object_type` | GAF object type, when available. |
+| `taxon_ids` | GAF taxon IDs split on `|`. |
+| `interacting_taxon_id` | GPA interacting taxon ID, when available. |
+| `date` | Annotation date. |
+| `assigned_by` | Annotation provider. |
+| `annotation_extension` | Annotation extension field. |
+| `gene_product_form_id` | Gene product form identifier. |
+| `split_bucket` | Deterministic split bucket from `sha256(annotation_id) % 10`. |
+
+## Preparation
+
+The normalization script used to create the Parquet files is included at `scripts/prepare_goa_dataset.py`.

data/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27cb6f509ee3fbe8bb400914ce823a7c0d2ffd3ff13600f630b3f860c15fb269
+size 722964

data/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f4dc08f8b26284d39f626c77d238250c7fbeb2fa7ab6d1c25081c39a63216228
+size 4944988

dataset_summary.json

@@ -0,0 +1,116 @@
+{
+  "source": "LiteFold/GOA",
+  "source_sha": "653d63a17c44418628790e65f3253cccec8f37f8",
+  "viewer_table_scope": "sample/index",
+  "sample_rows_per_annotation_file": 50000,
+  "annotation_sample_rows": 100000,
+  "splits": {
+    "train": 89958,
+    "test": 10042
+  },
+  "split_strategy": "deterministic sha256(annotation_id) % 10; bucket 0 is test, buckets 1-9 are train",
+  "source_files": [
+    {
+      "repo_id": "LiteFold/GOA",
+      "filename": ".gitattributes",
+      "size_bytes": 2504,
+      "source_sha": "653d63a17c44418628790e65f3253cccec8f37f8"
+    },
+    {
+      "repo_id": "LiteFold/GOA",
+      "filename": "goa_uniprot_all.gaf.gz",
+      "size_bytes": 15387303487,
+      "source_sha": "653d63a17c44418628790e65f3253cccec8f37f8"
+    },
+    {
+      "repo_id": "LiteFold/GOA",
+      "filename": "goa_uniprot_all.gpa.gz",
+      "size_bytes": 9462421263,
+      "source_sha": "653d63a17c44418628790e65f3253cccec8f37f8"
+    }
+  ],
+  "source_metadata": [
+    {
+      "filename": "goa_uniprot_all.gaf.gz",
+      "sampled_rows": 50000,
+      "header_metadata": {
+        "gaf-version": "2.2",
+        "date-generated": "2026-04-10 11:33",
+        "generated-by": "UniProt",
+        "go-version": "http://purl.obolibrary.org/obo/go/releases/2026-04-06/extensions/go-plus.ofn"
+      }
+    },
+    {
+      "filename": "goa_uniprot_all.gpa.gz",
+      "sampled_rows": 50000,
+      "header_metadata": {
+        "gpa-version": "1.1",
+        "Columns": "",
+        "DB": "Reference(s)       required  1 or greater  6",
+        "Generated": "2026-04-10 14:56",
+        "GO-version": "http://purl.obolibrary.org/obo/go/releases/2026-04-06/extensions/go-plus.ofn"
+      }
+    }
+  ],
+  "format_counts": {
+    "GAF": 50000,
+    "GPA": 50000
+  },
+  "aspect_counts": {
+    "missing": 50000,
+    "F": 21511,
+    "P": 15246,
+    "C": 13243
+  },
+  "top_evidence_codes": {
+    "IEA": 49621,
+    "ECO:0000265": 25858,
+    "ECO:0007826": 23687,
+    "ECO:0000314": 387,
+    "IBA": 297,
+    "ISS": 26,
+    "ECO:0000250": 23,
+    "ECO:0000305": 19,
+    "IDA": 13,
+    "ECO:0000315": 13,
+    "IPI": 11,
+    "IMP": 9,
+    "HDA": 7,
+    "ECO:0000303": 6,
+    "ND": 5,
+    "EXP": 3,
+    "ECO:0000304": 3,
+    "ISM": 3,
+    "ISA": 2,
+    "ECO:0000266": 2
+  },
+  "db_counts": {
+    "UniProtKB": 100000
+  },
+  "columns": [
+    "annotation_id",
+    "source_file",
+    "source_format",
+    "source_row_number",
+    "db",
+    "db_object_id",
+    "db_object_symbol",
+    "qualifier",
+    "qualifiers",
+    "go_id",
+    "db_references",
+    "evidence_code",
+    "with_from",
+    "aspect",
+    "db_object_name",
+    "db_object_synonyms",
+    "db_object_type",
+    "taxon_ids",
+    "interacting_taxon_id",
+    "date",
+    "assigned_by",
+    "annotation_extension",
+    "gene_product_form_id",
+    "split_bucket"
+  ]
+}

metadata/source_files.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2bf2a687c6614e31c3559ba5224654915d39af67cbf41f2c31bf3bcf097b78f
+size 3119

scripts/prepare_goa_dataset.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""Build viewer-friendly sample/index Parquet splits for LiteFold/GOA."""
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import hashlib
+import json
+import os
+import shutil
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+import requests
+from huggingface_hub import HfApi, hf_hub_url
+
+
+ANNOTATION_COLUMNS = [
+    "annotation_id",
+    "source_file",
+    "source_format",
+    "source_row_number",
+    "db",
+    "db_object_id",
+    "db_object_symbol",
+    "qualifier",
+    "qualifiers",
+    "go_id",
+    "db_references",
+    "evidence_code",
+    "with_from",
+    "aspect",
+    "db_object_name",
+    "db_object_synonyms",
+    "db_object_type",
+    "taxon_ids",
+    "interacting_taxon_id",
+    "date",
+    "assigned_by",
+    "annotation_extension",
+    "gene_product_form_id",
+    "split_bucket",
+]
+
+
+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 split_pipe(value: str | None) -> list[str]:
+    if not value:
+        return []
+    return [part for part in value.split("|") if part]
+
+
+def make_annotation_id(parts: list[str], source_file: str, row_number: int) -> str:
+    seed = "|".join([source_file, str(row_number), *parts])
+    return hashlib.sha256(seed.encode("utf-8")).hexdigest()
+
+
+def parse_gaf(parts: list[str], source_file: str, row_number: int) -> dict[str, Any] | None:
+    if len(parts) < 17:
+        return None
+    annotation_id = make_annotation_id(parts, source_file, row_number)
+    return {
+        "annotation_id": annotation_id,
+        "source_file": source_file,
+        "source_format": "GAF",
+        "source_row_number": row_number,
+        "db": parts[0],
+        "db_object_id": parts[1],
+        "db_object_symbol": parts[2],
+        "qualifier": parts[3] or None,
+        "qualifiers": split_pipe(parts[3]),
+        "go_id": parts[4],
+        "db_references": split_pipe(parts[5]),
+        "evidence_code": parts[6],
+        "with_from": split_pipe(parts[7]),
+        "aspect": parts[8] or None,
+        "db_object_name": parts[9] or None,
+        "db_object_synonyms": split_pipe(parts[10]),
+        "db_object_type": parts[11] or None,
+        "taxon_ids": split_pipe(parts[12]),
+        "interacting_taxon_id": None,
+        "date": parts[13] or None,
+        "assigned_by": parts[14] or None,
+        "annotation_extension": parts[15] or None,
+        "gene_product_form_id": parts[16] or None,
+        "split_bucket": stable_bucket(annotation_id),
+    }
+
+
+def parse_gpa(parts: list[str], source_file: str, row_number: int) -> dict[str, Any] | None:
+    if len(parts) < 12:
+        return None
+    annotation_id = make_annotation_id(parts, source_file, row_number)
+    return {
+        "annotation_id": annotation_id,
+        "source_file": source_file,
+        "source_format": "GPA",
+        "source_row_number": row_number,
+        "db": parts[0],
+        "db_object_id": parts[1],
+        "db_object_symbol": None,
+        "qualifier": parts[2] or None,
+        "qualifiers": split_pipe(parts[2]),
+        "go_id": parts[3],
+        "db_references": split_pipe(parts[4]),
+        "evidence_code": parts[5],
+        "with_from": split_pipe(parts[6]),
+        "aspect": None,
+        "db_object_name": None,
+        "db_object_synonyms": [],
+        "db_object_type": None,
+        "taxon_ids": [],
+        "interacting_taxon_id": parts[7] or None,
+        "date": parts[8] or None,
+        "assigned_by": parts[9] or None,
+        "annotation_extension": parts[10] or None,
+        "gene_product_form_id": parts[11] or None,
+        "split_bucket": stable_bucket(annotation_id),
+    }
+
+
+def stream_rows(repo_id: str, filename: str, token: str | None, limit: int) -> tuple[list[dict[str, Any]], dict[str, str]]:
+    url = hf_hub_url(repo_id=repo_id, filename=filename, repo_type="dataset")
+    headers = {"Authorization": f"Bearer {token}"} if token else {}
+    rows: list[dict[str, Any]] = []
+    metadata: dict[str, str] = {}
+    row_number = 0
+    parser = parse_gaf if filename.endswith(".gaf.gz") else parse_gpa
+
+    with requests.get(url, headers=headers, stream=True, timeout=60) as response:
+        response.raise_for_status()
+        with gzip.GzipFile(fileobj=response.raw) as handle:
+            for raw in handle:
+                line = raw.decode("utf-8", errors="replace").rstrip("\n")
+                if not line:
+                    continue
+                if line.startswith("!"):
+                    if ":" in line:
+                        key, value = line.lstrip("!").split(":", 1)
+                        metadata[key.strip()] = value.strip()
+                    continue
+                if line.startswith("gpa-version:"):
+                    metadata["gpa-version"] = line.split(":", 1)[1].strip()
+                    continue
+                row_number += 1
+                parsed = parser(line.split("\t"), filename, row_number)
+                if parsed is not None:
+                    rows.append(parsed)
+                if len(rows) >= limit:
+                    break
+    return rows, metadata
+
+
+def build_dataset(repo_id: str, out_dir: Path, sample_rows_per_file: int) -> dict[str, Any]:
+    token = load_token()
+    api = HfApi(token=token)
+    info = api.dataset_info(repo_id, files_metadata=True)
+
+    source_files = []
+    for sibling in sorted(info.siblings or [], key=lambda item: item.rfilename):
+        source_files.append(
+            {
+                "repo_id": repo_id,
+                "filename": sibling.rfilename,
+                "size_bytes": int(getattr(sibling, "size", 0) or 0),
+                "source_sha": info.sha,
+            }
+        )
+
+    annotation_rows: list[dict[str, Any]] = []
+    source_metadata: list[dict[str, Any]] = []
+    for filename in ["goa_uniprot_all.gaf.gz", "goa_uniprot_all.gpa.gz"]:
+        rows, metadata = stream_rows(repo_id, filename, token, sample_rows_per_file)
+        annotation_rows.extend(rows)
+        source_metadata.append({"filename": filename, "sampled_rows": len(rows), "header_metadata": metadata})
+
+    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(annotation_rows, columns=ANNOTATION_COLUMNS)
+    df = df.sort_values(["split_bucket", "annotation_id"], kind="mergesort")
+    train = df[df["split_bucket"].ne(0)].sort_values("annotation_id", kind="mergesort")
+    test = df[df["split_bucket"].eq(0)].sort_values("annotation_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")
+
+    pd.DataFrame.from_records(source_files).to_parquet(metadata_dir / "source_files.parquet", index=False)
+
+    format_counts = df["source_format"].value_counts().to_dict()
+    aspect_counts = df["aspect"].fillna("missing").value_counts().to_dict()
+    evidence_counts = df["evidence_code"].value_counts().head(20).to_dict()
+    db_counts = df["db"].value_counts().to_dict()
+    summary = {
+        "source": repo_id,
+        "source_sha": info.sha,
+        "viewer_table_scope": "sample/index",
+        "sample_rows_per_annotation_file": int(sample_rows_per_file),
+        "annotation_sample_rows": int(len(df)),
+        "splits": {"train": int(len(train)), "test": int(len(test))},
+        "split_strategy": "deterministic sha256(annotation_id) % 10; bucket 0 is test, buckets 1-9 are train",
+        "source_files": source_files,
+        "source_metadata": source_metadata,
+        "format_counts": {str(k): int(v) for k, v in format_counts.items()},
+        "aspect_counts": {str(k): int(v) for k, v in aspect_counts.items()},
+        "top_evidence_codes": {str(k): int(v) for k, v in evidence_counts.items()},
+        "db_counts": {str(k): int(v) for k, v in db_counts.items()},
+        "columns": ANNOTATION_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("--repo-id", default="LiteFold/GOA")
+    parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_GOA_processed"))
+    parser.add_argument("--sample-rows-per-file", type=int, default=50000)
+    args = parser.parse_args()
+    summary = build_dataset(args.repo_id, args.out_dir, args.sample_rows_per_file)
+    print(json.dumps(summary, indent=2))
+
+
+if __name__ == "__main__":
+    main()