Datasets:
Download scripts/prepare_interpro_dataset.py from LiteFold/InterPro: direct link, hf CLI and curl.
- Browser
- Download file 17.3 kB
-
https://huggingface.co/datasets/LiteFold/InterPro/resolve/main/scripts/prepare_interpro_dataset.py
- Command line
-
hf download hf://datasets/LiteFold/InterPro/scripts/prepare_interpro_dataset.py
-
curl -L -o prepare_interpro_dataset.py https://huggingface.co/datasets/LiteFold/InterPro/resolve/main/scripts/prepare_interpro_dataset.py
17.3 kB
| #!/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() | |