Add normalized Parquet train/test InterPro entry table

README.md

@@ -0,0 +1,198 @@
+---
+pretty_name: InterPro Entries
+license: other
+tags:
+- biology
+- protein
+- protein-family
+- protein-domain
+- interpro
+- ontology
+- parquet
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*.parquet
+  - split: test
+    path: data/test-*.parquet
+---
+
+# InterPro Entries
+
+This dataset contains a viewer-friendly Parquet table derived from the InterPro current release files in this repository. Each row is one InterPro entry from `current_release/interpro.xml.gz`.
+
+The original source release files remain in the repository. The default `datasets` configuration uses the normalized Parquet files under `data/` so that the Hugging Face Dataset Viewer and `load_dataset()` can read the entries directly.
+
+Large release artifacts such as `current_release/match_complete.xml.gz`, `current_release/protein2ipr.dat.gz`, and `current_release/sites.xml.gz` are preserved as source files but are not loaded by the default table.
+
+## Splits
+
+The split is deterministic by InterPro identifier: `sha256(interpro_id) % 10`. Bucket `0` is `test`; buckets `1` through `9` are `train`.
+
+| Split | Rows |
+|---|---:|
+| train | 46,440 |
+| test | 5,049 |
+| total | 51,489 |
+
+## Dataset Statistics
+
+| Field | Value |
+|---|---:|
+| InterPro release | `108.0` |
+| Release date | `29th January 2026` |
+| Entries | 51,489 |
+| Member database rows | 18 |
+| Entries with GO mappings | 14,799 |
+| InterPro-to-GO mapping rows | 30,200 |
+| Entries with structures | 30,172 |
+| Entries with publications | 38,194 |
+
+| Entry type | Rows |
+|---|---:|
+| Family | 27,308 |
+| Domain | 19,276 |
+| Homologous_superfamily | 3,510 |
+| Conserved_site | 768 |
+| Repeat | 395 |
+| Active_site | 133 |
+| Binding_site | 82 |
+| PTM | 17 |
+
+| GO category | Mappings |
+|---|---:|
+| molecular_function | 13,802 |
+| biological_process | 11,059 |
+| cellular_component | 5,339 |
+
+## Usage
+
+Install the Hugging Face Datasets library:
+
+```bash
+pip install datasets
+```
+
+Load all splits:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/InterPro")
+print(ds)
+
+row = ds["train"][0]
+print(row["interpro_id"], row["name"], row["entry_type"])
+```
+
+Load one split:
+
+```python
+from datasets import load_dataset
+
+train = load_dataset("LiteFold/InterPro", split="train")
+test = load_dataset("LiteFold/InterPro", split="test")
+```
+
+Stream rows without downloading the full table first:
+
+```python
+from datasets import load_dataset
+
+stream = load_dataset("LiteFold/InterPro", split="train", streaming=True)
+for row in stream.take(5):
+    print(row["interpro_id"], row["short_name"], row["protein_count"])
+```
+
+Filter entries with GO mappings:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/InterPro", split="train")
+with_go = ds.filter(lambda row: row["go_count"] > 0)
+print(with_go[0]["interpro_id"], with_go[0]["go_ids"])
+```
+
+Filter protein domains with PDB structures:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/InterPro", split="train")
+domains_with_structures = ds.filter(
+    lambda row: row["entry_type"] == "Domain" and row["structure_count"] > 0
+)
+print(domains_with_structures[0]["interpro_id"], domains_with_structures[0]["pdb_ids"][:5])
+```
+
+Load release database metadata directly:
+
+```python
+import pandas as pd
+from huggingface_hub import hf_hub_download
+
+path = hf_hub_download(
+    repo_id="LiteFold/InterPro",
+    repo_type="dataset",
+    filename="metadata/database_info.parquet",
+)
+database_info = pd.read_parquet(path)
+print(database_info)
+```
+
+## Columns
+
+| Column | Description |
+|---|---|
+| `interpro_id` | InterPro accession, such as `IPR000001`. |
+| `interpro_numeric_id` | Numeric portion of `interpro_id`. |
+| `name` | Full InterPro entry name. |
+| `short_name` | Short InterPro entry name from the XML attribute. |
+| `entry_type` | Entry class, such as `Family`, `Domain`, or `Homologous_superfamily`. |
+| `protein_count` | Number of proteins matched by the entry in the release XML. |
+| `is_llm` | Whether the entry is marked as LLM-generated in the source XML. |
+| `is_llm_reviewed` | Whether the LLM marker is reviewed in the source XML. |
+| `abstract` | Normalized text from the entry abstract. |
+| `go_ids` | GO identifiers mapped to the InterPro entry. |
+| `go_terms` | GO term names corresponding to `go_ids`. |
+| `go_categories` | GO namespaces corresponding to `go_ids`. |
+| `go_count` | Number of mapped GO terms. |
+| `member_databases` | Member databases contributing signatures. |
+| `member_accessions` | Signature accessions from member databases. |
+| `member_names` | Signature names from member databases. |
+| `member_protein_counts` | Protein counts for member signatures. |
+| `member_count` | Number of member signatures. |
+| `external_databases` | External resource database names. |
+| `external_accessions` | External resource accessions. |
+| `external_xrefs` | Combined external cross-references as `DB:ACCESSION`. |
+| `external_xref_count` | Number of external cross-references. |
+| `pdb_ids` | PDB structure identifiers. |
+| `structure_count` | Number of PDB structure links. |
+| `publication_ids` | InterPro publication identifiers. |
+| `pubmed_ids` | PubMed identifiers, when available. |
+| `publication_titles` | Publication titles. |
+| `publication_years` | Publication years, with `0` used when missing. |
+| `publication_count` | Number of publications attached to the entry. |
+| `parent_ids` | Parent InterPro entries from the XML hierarchy. |
+| `child_ids` | Child InterPro entries from the XML hierarchy. |
+| `parent_count` | Number of parents. |
+| `child_count` | Number of children. |
+| `tree_depth` | Minimum hierarchy depth from `ParentChildTreeFile.txt`, when present. |
+| `taxonomy_names` | Taxa listed in the taxonomy distribution. |
+| `taxonomy_protein_counts` | Protein counts for `taxonomy_names`. |
+| `taxonomy_count` | Number of taxonomy distribution rows. |
+| `key_species_names` | Key species names listed for the entry. |
+| `key_species_protein_counts` | Protein counts for `key_species_names`. |
+| `key_species_count` | Number of key species rows. |
+| `in_entry_list` | Whether the entry appears in `entry.list`. |
+| `entry_list_type` | Entry type from `entry.list`. |
+| `entry_list_name` | Entry name from `entry.list`. |
+| `names_dat_name` | Entry name from `names.dat`. |
+| `short_names_dat_name` | Short name from `short_names.dat`. |
+| `split_bucket` | Deterministic split bucket from `sha256(interpro_id) % 10`. |
+
+## Preparation
+
+The normalization script used to create the Parquet files is included at `scripts/prepare_interpro_dataset.py`.

data/test-00000-of-00001.parquet

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

data/train-00000-of-00001.parquet

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

dataset_summary.json

@@ -0,0 +1,119 @@
+{
+  "source": "LiteFold/InterPro",
+  "release": "108.0",
+  "release_date": "29th January 2026",
+  "last_entry": "IPR061508",
+  "entry_rows": 51489,
+  "database_info_rows": 18,
+  "entry_list_rows": 51489,
+  "names_dat_rows": 51489,
+  "short_names_dat_rows": 51489,
+  "tree_entries": 10748,
+  "interpro2go_mapping_rows": 30200,
+  "release_notes_interpro2go_mappings": 30200,
+  "splits": {
+    "train": 46440,
+    "test": 5049
+  },
+  "split_strategy": "deterministic sha256(interpro_id) % 10; bucket 0 is test, buckets 1-9 are train",
+  "entry_type_counts": {
+    "Family": 27308,
+    "Domain": 19276,
+    "Homologous_superfamily": 3510,
+    "Conserved_site": 768,
+    "Repeat": 395,
+    "Active_site": 133,
+    "Binding_site": 82,
+    "PTM": 17
+  },
+  "entries_with_go": 14799,
+  "entries_with_members": 51489,
+  "entries_with_structures": 30172,
+  "entries_with_publications": 38194,
+  "top_member_databases": {
+    "PFAM": 26620,
+    "PANTHER": 10491,
+    "NCBIFAM": 7069,
+    "CDD": 5040,
+    "PIRSF": 3223,
+    "CATHGENE3D": 2820,
+    "HAMAP": 2386,
+    "PRINTS": 1938,
+    "SSF": 1649,
+    "PROFILE": 1303,
+    "PROSITE": 1282,
+    "SMART": 1276,
+    "SFLD": 160
+  },
+  "go_category_counts": {
+    "molecular_function": 13802,
+    "biological_process": 11059,
+    "cellular_component": 5339
+  },
+  "top_external_databases": {
+    "REACTOME": 497598,
+    "METACYC": 78901,
+    "EC": 12551,
+    "GP": 6186,
+    "PROSITEDOC": 1485,
+    "IUPHAR": 185,
+    "CAZY": 116
+  },
+  "columns": [
+    "interpro_id",
+    "interpro_numeric_id",
+    "name",
+    "short_name",
+    "entry_type",
+    "protein_count",
+    "is_llm",
+    "is_llm_reviewed",
+    "abstract",
+    "go_ids",
+    "go_terms",
+    "go_categories",
+    "go_count",
+    "member_databases",
+    "member_accessions",
+    "member_names",
+    "member_protein_counts",
+    "member_count",
+    "external_databases",
+    "external_accessions",
+    "external_xrefs",
+    "external_xref_count",
+    "pdb_ids",
+    "structure_count",
+    "publication_ids",
+    "pubmed_ids",
+    "publication_titles",
+    "publication_years",
+    "publication_count",
+    "parent_ids",
+    "child_ids",
+    "parent_count",
+    "child_count",
+    "tree_depth",
+    "taxonomy_names",
+    "taxonomy_protein_counts",
+    "taxonomy_count",
+    "key_species_names",
+    "key_species_protein_counts",
+    "key_species_count",
+    "in_entry_list",
+    "entry_list_type",
+    "entry_list_name",
+    "names_dat_name",
+    "short_names_dat_name",
+    "split_bucket"
+  ],
+  "source_files_used": [
+    "current_release/interpro.xml.gz",
+    "current_release/entry.list",
+    "current_release/names.dat",
+    "current_release/short_names.dat",
+    "current_release/ParentChildTreeFile.txt",
+    "current_release/interpro2go",
+    "current_release/release_notes.txt"
+  ]
+}

metadata/database_info.parquet

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

scripts/prepare_interpro_dataset.py

@@ -0,0 +1,467 @@
+#!/usr/bin/env python3
+"""Build viewer-friendly Parquet splits for LiteFold/InterPro."""
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import hashlib
+import json
+import re
+import shutil
+import xml.etree.ElementTree as ET
+from collections import Counter
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+
+ENTRY_COLUMNS = [
+    "interpro_id",
+    "interpro_numeric_id",
+    "name",
+    "short_name",
+    "entry_type",
+    "protein_count",
+    "is_llm",
+    "is_llm_reviewed",
+    "abstract",
+    "go_ids",
+    "go_terms",
+    "go_categories",
+    "go_count",
+    "member_databases",
+    "member_accessions",
+    "member_names",
+    "member_protein_counts",
+    "member_count",
+    "external_databases",
+    "external_accessions",
+    "external_xrefs",
+    "external_xref_count",
+    "pdb_ids",
+    "structure_count",
+    "publication_ids",
+    "pubmed_ids",
+    "publication_titles",
+    "publication_years",
+    "publication_count",
+    "parent_ids",
+    "child_ids",
+    "parent_count",
+    "child_count",
+    "tree_depth",
+    "taxonomy_names",
+    "taxonomy_protein_counts",
+    "taxonomy_count",
+    "key_species_names",
+    "key_species_protein_counts",
+    "key_species_count",
+    "in_entry_list",
+    "entry_list_type",
+    "entry_list_name",
+    "names_dat_name",
+    "short_names_dat_name",
+    "split_bucket",
+]
+
+
+def normalize_text(value: str | None) -> str | None:
+    if value is None:
+        return None
+    text = re.sub(r"\s+", " ", value).strip()
+    return text or None
+
+
+def parse_int(value: str | None) -> int | None:
+    if value is None or value == "":
+        return None
+    try:
+        return int(value)
+    except ValueError:
+        return None
+
+
+def parse_bool(value: str | None) -> bool | None:
+    if value is None or value == "":
+        return None
+    lowered = value.lower()
+    if lowered == "true":
+        return True
+    if lowered == "false":
+        return False
+    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 text_of(parent: ET.Element, tag: str) -> str | None:
+    child = parent.find(tag)
+    if child is None:
+        return None
+    return normalize_text("".join(child.itertext()))
+
+
+def xref_value(db: str | None, dbkey: str | None) -> str:
+    if db and dbkey:
+        return f"{db}:{dbkey}"
+    return dbkey or db or ""
+
+
+def parse_two_column_file(path: Path) -> dict[str, str]:
+    mapping: dict[str, str] = {}
+    if not path.exists():
+        return mapping
+    with path.open("r", encoding="utf-8", errors="replace") as handle:
+        for line in handle:
+            stripped = line.rstrip("\n")
+            if not stripped:
+                continue
+            parts = stripped.split("\t", 1)
+            if len(parts) == 2 and parts[0].startswith("IPR"):
+                mapping[parts[0]] = parts[1]
+    return mapping
+
+
+def parse_entry_list(path: Path) -> dict[str, dict[str, str]]:
+    entries: dict[str, dict[str, str]] = {}
+    if not path.exists():
+        return entries
+    with path.open("r", encoding="utf-8", errors="replace") as handle:
+        header = next(handle, "").rstrip("\n").split("\t")
+        for line in handle:
+            parts = line.rstrip("\n").split("\t")
+            if len(parts) != len(header):
+                continue
+            row = dict(zip(header, parts))
+            entry_id = row.get("ENTRY_AC")
+            if entry_id:
+                entries[entry_id] = row
+    return entries
+
+
+def parse_tree_depths(path: Path) -> dict[str, int]:
+    depths: dict[str, int] = {}
+    pattern = re.compile(r"^(?P<prefix>-*)(?P<id>IPR\d+)::")
+    if not path.exists():
+        return depths
+    with path.open("r", encoding="utf-8", errors="replace") as handle:
+        for line in handle:
+            match = pattern.match(line.strip())
+            if not match:
+                continue
+            entry_id = match.group("id")
+            depth = len(match.group("prefix")) // 2
+            previous = depths.get(entry_id)
+            if previous is None or depth < previous:
+                depths[entry_id] = depth
+    return depths
+
+
+def parse_interpro2go_count(path: Path) -> int:
+    count = 0
+    if not path.exists():
+        return count
+    with path.open("r", encoding="utf-8", errors="replace") as handle:
+        for line in handle:
+            stripped = line.strip()
+            if stripped and not stripped.startswith("!"):
+                count += 1
+    return count
+
+
+def parse_release_notes(path: Path) -> dict[str, Any]:
+    notes = path.read_text(encoding="utf-8", errors="replace") if path.exists() else ""
+    release_match = re.search(r"Release\s+([0-9.]+),\s+([^\n]+)", notes)
+    last_entry_match = re.search(r"Last Entry\s+(IPR\d+)", notes)
+    go_match = re.search(r"Number of GO terms mapped to InterPro\s+-\s+([0-9]+)", notes)
+    return {
+        "release": release_match.group(1) if release_match else None,
+        "release_date": release_match.group(2).strip() if release_match else None,
+        "last_entry": last_entry_match.group(1) if last_entry_match else None,
+        "interpro_to_go_mappings": int(go_match.group(1)) if go_match else None,
+    }
+
+
+def parse_dbinfo(release: ET.Element) -> list[dict[str, Any]]:
+    rows = []
+    for item in release.findall("dbinfo"):
+        rows.append(
+            {
+                "dbname": item.attrib.get("dbname"),
+                "version": item.attrib.get("version"),
+                "entry_count": parse_int(item.attrib.get("entry_count")),
+                "file_date": item.attrib.get("file_date"),
+            }
+        )
+    return rows
+
+
+def extract_taxa(container: ET.Element | None) -> tuple[list[str], list[int]]:
+    names = []
+    counts = []
+    if container is None:
+        return names, counts
+    for taxon in container.findall("taxon_data"):
+        name = taxon.attrib.get("name")
+        count = parse_int(taxon.attrib.get("proteins_count"))
+        if name:
+            names.append(name)
+            counts.append(count if count is not None else 0)
+    return names, counts
+
+
+def interpro_row(
+    elem: ET.Element,
+    entry_list: dict[str, dict[str, str]],
+    names_dat: dict[str, str],
+    short_names_dat: dict[str, str],
+    tree_depths: dict[str, int],
+) -> dict[str, Any]:
+    entry_id = elem.attrib.get("id", "")
+    numeric_match = re.match(r"IPR(\d+)$", entry_id)
+    entry_info = entry_list.get(entry_id, {})
+
+    class_list = elem.find("class_list")
+    go_ids: list[str] = []
+    go_terms: list[str] = []
+    go_categories: list[str] = []
+    if class_list is not None:
+        for item in class_list.findall("classification"):
+            go_id = item.attrib.get("id")
+            if not go_id:
+                continue
+            go_ids.append(go_id)
+            go_terms.append(text_of(item, "description") or "")
+            go_categories.append(text_of(item, "category") or "")
+
+    member_databases: list[str] = []
+    member_accessions: list[str] = []
+    member_names: list[str] = []
+    member_protein_counts: list[int] = []
+    member_list = elem.find("member_list")
+    if member_list is not None:
+        for item in member_list.findall("db_xref"):
+            member_databases.append(item.attrib.get("db") or "")
+            member_accessions.append(item.attrib.get("dbkey") or "")
+            member_names.append(item.attrib.get("name") or "")
+            member_protein_counts.append(parse_int(item.attrib.get("protein_count")) or 0)
+
+    external_databases: list[str] = []
+    external_accessions: list[str] = []
+    external_xrefs: list[str] = []
+    external_doc_list = elem.find("external_doc_list")
+    if external_doc_list is not None:
+        for item in external_doc_list.findall("db_xref"):
+            db = item.attrib.get("db")
+            dbkey = item.attrib.get("dbkey")
+            external_databases.append(db or "")
+            external_accessions.append(dbkey or "")
+            external_xrefs.append(xref_value(db, dbkey))
+
+    pdb_ids: list[str] = []
+    structure_db_links = elem.find("structure_db_links")
+    if structure_db_links is not None:
+        for item in structure_db_links.findall("db_xref"):
+            dbkey = item.attrib.get("dbkey")
+            if dbkey:
+                pdb_ids.append(dbkey)
+
+    publication_ids: list[str] = []
+    pubmed_ids: list[str] = []
+    publication_titles: list[str] = []
+    publication_years: list[int] = []
+    pub_list = elem.find("pub_list")
+    if pub_list is not None:
+        for publication in pub_list.findall("publication"):
+            publication_ids.append(publication.attrib.get("id") or "")
+            title = text_of(publication, "title")
+            publication_titles.append(title or "")
+            year = parse_int(text_of(publication, "year"))
+            publication_years.append(year if year is not None else 0)
+            xref = publication.find("db_xref")
+            if xref is not None and xref.attrib.get("db") == "PUBMED":
+                dbkey = xref.attrib.get("dbkey")
+                if dbkey:
+                    pubmed_ids.append(dbkey)
+
+    parent_ids = []
+    parent_list = elem.find("parent_list")
+    if parent_list is not None:
+        parent_ids = [item.attrib["ipr_ref"] for item in parent_list.findall("rel_ref") if item.attrib.get("ipr_ref")]
+
+    child_ids = []
+    child_list = elem.find("child_list")
+    if child_list is not None:
+        child_ids = [item.attrib["ipr_ref"] for item in child_list.findall("rel_ref") if item.attrib.get("ipr_ref")]
+
+    taxonomy_names, taxonomy_protein_counts = extract_taxa(elem.find("taxonomy_distribution"))
+    key_species_names, key_species_protein_counts = extract_taxa(elem.find("key_species"))
+
+    abstract = elem.find("abstract")
+    abstract_text = normalize_text(" ".join(abstract.itertext())) if abstract is not None else None
+
+    return {
+        "interpro_id": entry_id,
+        "interpro_numeric_id": int(numeric_match.group(1)) if numeric_match else None,
+        "name": text_of(elem, "name"),
+        "short_name": elem.attrib.get("short_name") or None,
+        "entry_type": elem.attrib.get("type") or None,
+        "protein_count": parse_int(elem.attrib.get("protein_count")),
+        "is_llm": parse_bool(elem.attrib.get("is-llm")),
+        "is_llm_reviewed": parse_bool(elem.attrib.get("is-llm-reviewed")),
+        "abstract": abstract_text,
+        "go_ids": go_ids,
+        "go_terms": go_terms,
+        "go_categories": go_categories,
+        "go_count": len(go_ids),
+        "member_databases": member_databases,
+        "member_accessions": member_accessions,
+        "member_names": member_names,
+        "member_protein_counts": member_protein_counts,
+        "member_count": len(member_accessions),
+        "external_databases": external_databases,
+        "external_accessions": external_accessions,
+        "external_xrefs": external_xrefs,
+        "external_xref_count": len(external_xrefs),
+        "pdb_ids": pdb_ids,
+        "structure_count": len(pdb_ids),
+        "publication_ids": publication_ids,
+        "pubmed_ids": pubmed_ids,
+        "publication_titles": publication_titles,
+        "publication_years": publication_years,
+        "publication_count": len(publication_ids),
+        "parent_ids": parent_ids,
+        "child_ids": child_ids,
+        "parent_count": len(parent_ids),
+        "child_count": len(child_ids),
+        "tree_depth": tree_depths.get(entry_id),
+        "taxonomy_names": taxonomy_names,
+        "taxonomy_protein_counts": taxonomy_protein_counts,
+        "taxonomy_count": len(taxonomy_names),
+        "key_species_names": key_species_names,
+        "key_species_protein_counts": key_species_protein_counts,
+        "key_species_count": len(key_species_names),
+        "in_entry_list": entry_id in entry_list,
+        "entry_list_type": entry_info.get("ENTRY_TYPE"),
+        "entry_list_name": entry_info.get("ENTRY_NAME"),
+        "names_dat_name": names_dat.get(entry_id),
+        "short_names_dat_name": short_names_dat.get(entry_id),
+        "split_bucket": stable_bucket(entry_id),
+    }
+
+
+def parse_xml(
+    path: Path,
+    entry_list: dict[str, dict[str, str]],
+    names_dat: dict[str, str],
+    short_names_dat: dict[str, str],
+    tree_depths: dict[str, int],
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    rows: list[dict[str, Any]] = []
+    dbinfo_rows: list[dict[str, Any]] = []
+    with gzip.open(path, "rb") as handle:
+        for _, elem in ET.iterparse(handle, events=("end",)):
+            if elem.tag == "release":
+                dbinfo_rows = parse_dbinfo(elem)
+                elem.clear()
+            elif elem.tag == "interpro":
+                rows.append(interpro_row(elem, entry_list, names_dat, short_names_dat, tree_depths))
+                elem.clear()
+    return rows, dbinfo_rows
+
+
+def build_dataset(raw_dir: Path, out_dir: Path) -> dict[str, Any]:
+    current_dir = raw_dir / "current_release"
+    entry_list = parse_entry_list(current_dir / "entry.list")
+    names_dat = parse_two_column_file(current_dir / "names.dat")
+    short_names_dat = parse_two_column_file(current_dir / "short_names.dat")
+    tree_depths = parse_tree_depths(current_dir / "ParentChildTreeFile.txt")
+    release_notes = parse_release_notes(current_dir / "release_notes.txt")
+    interpro2go_count = parse_interpro2go_count(current_dir / "interpro2go")
+    rows, dbinfo_rows = parse_xml(
+        current_dir / "interpro.xml.gz",
+        entry_list=entry_list,
+        names_dat=names_dat,
+        short_names_dat=short_names_dat,
+        tree_depths=tree_depths,
+    )
+
+    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)
+    df = df.sort_values(["split_bucket", "interpro_id"], kind="mergesort")
+    train = df[df["split_bucket"].ne(0)].sort_values("interpro_id", kind="mergesort")
+    test = df[df["split_bucket"].eq(0)].sort_values("interpro_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")
+
+    dbinfo_df = pd.DataFrame.from_records(dbinfo_rows)
+    dbinfo_df.to_parquet(metadata_dir / "database_info.parquet", index=False, compression="zstd")
+
+    entry_type_counts = df["entry_type"].value_counts(dropna=False).to_dict()
+    member_database_counts = Counter(database for values in df["member_databases"] for database in values)
+    go_category_counts = Counter(category for values in df["go_categories"] for category in values)
+    external_database_counts = Counter(database for values in df["external_databases"] for database in values)
+
+    summary = {
+        "source": "LiteFold/InterPro",
+        "release": release_notes.get("release"),
+        "release_date": release_notes.get("release_date"),
+        "last_entry": release_notes.get("last_entry"),
+        "entry_rows": int(len(df)),
+        "database_info_rows": int(len(dbinfo_df)),
+        "entry_list_rows": int(len(entry_list)),
+        "names_dat_rows": int(len(names_dat)),
+        "short_names_dat_rows": int(len(short_names_dat)),
+        "tree_entries": int(len(tree_depths)),
+        "interpro2go_mapping_rows": int(interpro2go_count),
+        "release_notes_interpro2go_mappings": release_notes.get("interpro_to_go_mappings"),
+        "splits": {
+            "train": int(len(train)),
+            "test": int(len(test)),
+        },
+        "split_strategy": "deterministic sha256(interpro_id) % 10; bucket 0 is test, buckets 1-9 are train",
+        "entry_type_counts": {str(k): int(v) for k, v in entry_type_counts.items()},
+        "entries_with_go": int(df["go_count"].gt(0).sum()),
+        "entries_with_members": int(df["member_count"].gt(0).sum()),
+        "entries_with_structures": int(df["structure_count"].gt(0).sum()),
+        "entries_with_publications": int(df["publication_count"].gt(0).sum()),
+        "top_member_databases": dict(member_database_counts.most_common(20)),
+        "go_category_counts": dict(go_category_counts.most_common()),
+        "top_external_databases": dict(external_database_counts.most_common(20)),
+        "columns": ENTRY_COLUMNS,
+        "source_files_used": [
+            "current_release/interpro.xml.gz",
+            "current_release/entry.list",
+            "current_release/names.dat",
+            "current_release/short_names.dat",
+            "current_release/ParentChildTreeFile.txt",
+            "current_release/interpro2go",
+            "current_release/release_notes.txt",
+        ],
+    }
+    (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_InterPro_raw"))
+    parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_InterPro_processed"))
+    args = parser.parse_args()
+    summary = build_dataset(args.raw_dir, args.out_dir)
+    print(json.dumps(summary, indent=2))
+
+
+if __name__ == "__main__":
+    main()