Add normalized Parquet train/test DisProt protein table

README.md

@@ -1,84 +1,118 @@
 ---
+pretty_name: DisProt Protein Disorder Annotations
 license: cc-by-4.0
-pretty_name: DisProt
-size_categories:
-  - n<1K
-task_categories:
-  - other
-language:
-  - en
 tags:
-  - biology
-  - proteins
-  - intrinsic-disorder
-  - disprot
-  - annotation
-  - jsonl
+- biology
+- proteins
+- intrinsic-disorder
+- disprot
+- annotation
+- parquet
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*.parquet
+  - split: test
+    path: data/test-*.parquet
 ---
 
-# DisProt
+# DisProt Protein Disorder Annotations
 
-DisProt curated intrinsically disordered protein annotations, normalized to newline-delimited JSON with row-level provenance.
+This dataset contains a viewer-friendly protein-level Parquet table derived from the DisProt JSONL source in this repository. Each row is one DisProt protein entry. Curated disorder/function/transition regions are also available as `metadata/regions.parquet`.
 
-Processed and uploaded by the [MegaData](https://github.com/) post-download pipeline
-(internal repo). Original source: <https://disprot.org/>.
+## Splits
 
-## Statistics
+The split is deterministic by DisProt ID: `sha256(disprot_id) % 10`. Bucket `0` is `test`; buckets `1` through `9` are `train`.
 
-| | |
-|---|---|
-| Table files | 1 |
-| Total rows | 1 |
-| Total bytes | 25.58 MiB (26,821,358) |
+| Split | Rows |
+|---|---:|
+| train | 2,875 |
+| test | 324 |
+| total | 3,199 |
 
-## Tables
+## Dataset Statistics
 
-| Table | Rows | Bytes |
-|---|---:|---:|
-| `annotation_disprot_disprot_current.json.jsonl` | 1 | 25.58 MiB |
+| Field | Value |
+|---|---:|
+| Protein entries | 3,199 |
+| Curated region rows | 13,396 |
 
-## Layout
+## Usage
 
-```
-.
-├── _MANIFEST.json                 # aggregate manifest (per-table counts)
-└── tables/<source_slug>.jsonl    # normalized rows (one JSON object per line)
+```bash
+pip install datasets
 ```
 
-Each line in a `tables/*.jsonl` file is a JSON object with at least
-`dataset_id`, `row` (the raw upstream row), `row_index`, and `source_file`
-fields, so every row carries its upstream provenance.
+Load all splits:
 
-## Loading
+```python
+from datasets import load_dataset
 
-```bash
-hf download LiteFold/DisProt --repo-type dataset --local-dir ./disprot
+ds = load_dataset("LiteFold/DisProt")
+print(ds)
+print(ds["train"][0]["disprot_id"])
 ```
 
-Programmatic streaming:
+Load one split:
 
 ```python
-import json
-from pathlib import Path
-from huggingface_hub import snapshot_download
-
-local = snapshot_download(repo_id="LiteFold/DisProt", repo_type="dataset")
-for jsonl in sorted(Path(local, "tables").glob("*.jsonl")):
-    with jsonl.open() as f:
-        for line in f:
-            row = json.loads(line)
-            ...  # row["row"] is the upstream record
+from datasets import load_dataset
+
+train = load_dataset("LiteFold/DisProt", split="train")
 ```
 
-## License
+Filter proteins with high disorder content:
 
-CC BY 4.0 (DisProt).
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/DisProt", split="train")
+high_disorder = ds.filter(lambda row: row["disorder_content"] is not None and row["disorder_content"] >= 0.5)
+print(high_disorder[0])
+```
 
-## Citation
+Load the region-level metadata:
 
-> Quaglia F, et al. DisProt in 2022: improved quality and accessibility of protein intrinsic disorder annotation. Nucleic Acids Research, 50(D1):D480-D487, 2022.
+```python
+import pandas as pd
+from huggingface_hub import hf_hub_download
+
+path = hf_hub_download(
+    repo_id="LiteFold/DisProt",
+    repo_type="dataset",
+    filename="metadata/regions.parquet",
+)
+regions = pd.read_parquet(path)
+print(regions.head())
+```
 
-## Provenance
+## Key Columns
 
-Built from the local manifest entry `disprot` of `manifests/atlas_download_plan.json`.
-Pipeline source: `megadata-post normalize --dataset disprot --tables-only`.
+| Column | Description |
+|---|---|
+| `disprot_id` | DisProt protein identifier. |
+| `accession` | UniProt accession. |
+| `name` | Protein name. |
+| `organism` | Organism name. |
+| `ncbi_taxon_id` | NCBI taxonomy ID. |
+| `length` | Protein sequence length. |
+| `disorder_content` | Fraction of sequence annotated as disordered. |
+| `dataset_labels` | DisProt dataset labels. |
+| `sequence` | Protein sequence. |
+| `region_count` | Number of curated region annotations. |
+| `region_ids` | Curated region IDs. |
+| `region_starts` | Region start positions. |
+| `region_ends` | Region end positions. |
+| `region_terms` | Region term names. |
+| `evidence_codes` | Region evidence codes. |
+| `reference_ids` | Region reference IDs. |
+| `cross_refs` | Region cross-references such as PDB IDs. |
+| `feature_databases` | Feature sources such as Pfam or Gene3D. |
+| `feature_ids` | Feature IDs. |
+| `gene_names` | Gene names and synonyms. |
+| `split_bucket` | Deterministic split bucket from `sha256(disprot_id) % 10`. |
+
+## Preparation
+
+The normalization script used to create the Parquet files is included at `scripts/prepare_disprot_dataset.py`.

data/test-00000-of-00001.parquet

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

data/train-00000-of-00001.parquet

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

dataset_summary.json

@@ -0,0 +1,97 @@
+{
+  "source": "LiteFold/DisProt",
+  "entry_rows": 3199,
+  "region_rows": 13396,
+  "splits": {
+    "train": 2875,
+    "test": 324
+  },
+  "split_strategy": "deterministic sha256(disprot_id) % 10; bucket 0 is test, buckets 1-9 are train",
+  "dataset_label_counts": {
+    "NDDs-related proteins": 324,
+    "Viral proteins": 230,
+    "RNA-binding proteins": 212,
+    "Cancer-related proteins": 181,
+    "Condensates-related proteins": 181,
+    "Autophagy-related proteins": 109,
+    "Neglected tropical diseases proteins": 105,
+    "Extracellular matrix proteins": 100,
+    "Bacterial virulence-related proteins": 76,
+    "Unicellular toxins and antitoxins": 51,
+    "Age-related disorders proteins": 42
+  },
+  "top_region_terms": {
+    "disorder": 7138,
+    "protein binding": 1558,
+    "disorder to order": 834,
+    "flexible linker": 426,
+    "molecular adaptor activity": 262,
+    "phosphorylation display site": 240,
+    "molecular function regulator": 188,
+    "lipid binding": 134,
+    "molecular condensate scaffold activity": 106,
+    "order": 104,
+    "pre-molten globule": 94,
+    "RNA binding": 86,
+    "order to disorder": 79,
+    "DNA binding": 78,
+    "nucleic acid binding": 77,
+    "amyloid fibril formation": 72,
+    "molecular function inhibitor activity": 72,
+    "flexible N-terminal tail": 72,
+    "molecular function activator activity": 63,
+    "flexible C-terminal tail": 58
+  },
+  "region_namespace_counts": {
+    "Structural state": 7394,
+    "Molecular function": 3405,
+    "Disorder function": 1028,
+    "Structural transition": 965,
+    "Biological process": 542,
+    "Cellular component": 62
+  },
+  "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"
+  ],
+  "metadata_tables": [
+    "metadata/regions.parquet"
+  ]
+}

metadata/regions.parquet

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

scripts/prepare_disprot_dataset.py

@@ -0,0 +1,286 @@
+#!/usr/bin/env python3
+"""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()