#!/usr/bin/env python3 """Build viewer-friendly Parquet splits for LiteFold/IEDB.""" from __future__ import annotations import argparse import hashlib import json from collections import Counter from pathlib import Path from zipfile import ZipFile import pyarrow as pa import pyarrow.parquet as pq from lxml import etree ASSAY_TAGS = {"BCell", "TCell", "MhcBinding", "MhcLigandElution"} ASSAY_ID_TAG = { "BCell": "BCellId", "TCell": "TCellId", "MhcBinding": "MhcBindingId", "MhcLigandElution": "MhcLigandElutionId", } FIELDS = [ ("xml_file", pa.string()), ("reference_id", pa.string()), ("date_last_updated", pa.string()), ("pubmed_id", pa.string()), ("article_year", pa.int64()), ("article_title", pa.string()), ("journal_title", pa.string()), ("authors", pa.string()), ("epitope_id", pa.string()), ("epitope_name", pa.string()), ("epitope_structure_type", pa.string()), ("epitope_chemical_type", pa.string()), ("linear_sequence", pa.string()), ("linear_sequence_length", pa.int64()), ("discontinuous_residues", pa.string()), ("starting_position", pa.int64()), ("ending_position", pa.int64()), ("source_organism_id", pa.string()), ("source_molecule_genbank_id", pa.string()), ("reference_region", pa.string()), ("epitope_structure_defines", pa.string()), ("epitope_evidence_code", pa.string()), ("assay_category", pa.string()), ("assay_id", pa.string()), ("assay_type_id", pa.string()), ("assay_location_of_data", pa.string()), ("qualitative_measurement", pa.string()), ("is_positive", pa.bool_()), ("quantitative_measurement", pa.string()), ("host_organism_id", pa.string()), ("host_sex", pa.string()), ("host_age", pa.string()), ("disease_state", pa.string()), ("mhc_allele_id", pa.string()), ("mhc_allele_types_present", pa.string()), ("cell_type", pa.string()), ("cell_tissue_type", pa.string()), ("cell_culture_conditions", pa.string()), ("antigen_evidence_code", pa.string()), ("immunogen_evidence_code", pa.string()), ("assay_comments", pa.string()), ("split_bucket", pa.int64()), ] SCHEMA = pa.schema(FIELDS) def local_name(elem: etree._Element) -> str: tag = elem.tag if not isinstance(tag, str): return "" return etree.QName(tag).localname def text_content(elem: etree._Element | None) -> str | None: if elem is None: return None text = " ".join(part.strip() for part in elem.itertext() if part and part.strip()) return text or None def direct_child(elem: etree._Element | None, name: str) -> etree._Element | None: if elem is None: return None for child in elem: if local_name(child) == name: return child return None def direct_text(elem: etree._Element | None, name: str) -> str | None: return text_content(direct_child(elem, name)) def first_descendant(elem: etree._Element | None, name: str) -> etree._Element | None: if elem is None: return None for child in elem.iter(): if child is not elem and local_name(child) == name: return child return None def first_desc_text(elem: etree._Element | None, name: str) -> str | None: return text_content(first_descendant(elem, name)) def all_desc_text(elem: etree._Element | None, name: str) -> list[str]: if elem is None: return [] values = [] for child in elem.iter(): if child is not elem and local_name(child) == name: value = text_content(child) if value: values.append(value) return values def int_or_none(value: str | None) -> int | None: if value is None: return None try: return int(value) except ValueError: return None def positive_flag(value: str | None) -> bool | None: if not value: return None lower = value.lower() if "negative" in lower: return False if "positive" in lower: return True 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_for_row(row: dict) -> str: key = row.get("epitope_id") or row.get("reference_id") or row.get("assay_id") or row["xml_file"] return "test" if row["split_bucket"] == 0 else "train" def cleanup(elem: etree._Element) -> None: elem.clear() parent = elem.getparent() while parent is not None and elem.getprevious() is not None: del parent[0] def parse_epitope_structure(elem: etree._Element) -> dict: structure = next((child for child in elem if isinstance(child.tag, str)), None) return { "epitope_structure_type": local_name(structure) if structure is not None else None, "epitope_chemical_type": first_desc_text(structure, "ChemicalType"), "linear_sequence": first_desc_text(structure, "LinearSequence"), "discontinuous_residues": first_desc_text(structure, "DiscontinuousResidues"), "starting_position": int_or_none(first_desc_text(structure, "StartingPosition")), "ending_position": int_or_none(first_desc_text(structure, "EndingPosition")), "source_organism_id": first_desc_text(structure, "SourceOrganismId"), "source_molecule_genbank_id": first_desc_text(structure, "GenBankId"), } def parse_authors(author_parent: etree._Element) -> str | None: authors = [] for author in author_parent: if local_name(author) != "Author": continue first = direct_text(author, "ForeName") last = direct_text(author, "LastName") name = " ".join(part for part in [first, last] if part) if name: authors.append(name) return "; ".join(authors) or None def parse_assay(elem: etree._Element, category: str) -> dict: assay_info = first_descendant(elem, "AssayInformation") immunization = first_descendant(elem, "Immunization") host = first_descendant(immunization, "HostOrganism") mhc = first_descendant(elem, "MhcAllele") effector = first_descendant(elem, "EffectorCells") antigen = first_descendant(elem, "Antigen") return { "assay_category": category, "assay_id": direct_text(elem, ASSAY_ID_TAG[category]), "assay_type_id": first_desc_text(assay_info, "AssayTypeId"), "assay_location_of_data": direct_text(elem, "LocationOfData"), "qualitative_measurement": first_desc_text(assay_info, "QualitativeMeasurement"), "quantitative_measurement": first_desc_text(assay_info, "QuantitativeMeasurement"), "host_organism_id": first_desc_text(host, "OrganismId"), "host_sex": first_desc_text(host, "Sex"), "host_age": first_desc_text(host, "Age"), "disease_state": first_desc_text(immunization, "DiseaseState"), "mhc_allele_id": first_desc_text(mhc, "MhcAlleleId"), "mhc_allele_types_present": "; ".join(all_desc_text(elem, "MhcAlleleTypesPresent")) or None, "cell_type": first_desc_text(effector, "CellType"), "cell_tissue_type": first_desc_text(effector, "CellTissueType"), "cell_culture_conditions": first_desc_text(effector, "CellCultureConditions"), "antigen_evidence_code": first_desc_text(antigen, "AntigenEvidenceCode"), "immunogen_evidence_code": first_desc_text(immunization, "ImmunogenEvidenceCode"), "assay_comments": direct_text(elem, "AssayComments"), } def path_is_top_epitope(path: list[str]) -> bool: return len(path) >= 4 and path[-4:] == ["References", "Reference", "Epitopes", "Epitope"] def flush_batch(rows: list[dict], writer: pq.ParquetWriter) -> int: if not rows: return 0 table = pa.Table.from_pylist(rows, schema=SCHEMA) writer.write_table(table) count = len(rows) rows.clear() return count def build_dataset(zip_path: Path, out_dir: Path, batch_size: int, limit_files: int | None = None) -> dict: data_dir = out_dir / "data" data_dir.mkdir(parents=True, exist_ok=True) train_path = data_dir / "train-00000-of-00001.parquet" test_path = data_dir / "test-00000-of-00001.parquet" train_writer = pq.ParquetWriter(train_path, SCHEMA, compression="zstd") test_writer = pq.ParquetWriter(test_path, SCHEMA, compression="zstd") train_rows: list[dict] = [] test_rows: list[dict] = [] summary_counts = Counter() assay_category_counts = Counter() qualitative_counts = Counter() chemical_type_counts = Counter() structure_type_counts = Counter() parse_errors: list[dict] = [] references = set() epitopes = set() with ZipFile(zip_path) as zf: infos = [info for info in zf.infolist() if info.filename.endswith(".xml")] if limit_files is not None: infos = infos[:limit_files] summary_counts["xml_files"] = len(infos) summary_counts["zip_uncompressed_xml_bytes"] = sum(info.file_size for info in infos) summary_counts["zip_compressed_xml_bytes"] = sum(info.compress_size for info in infos) for index, info in enumerate(infos, start=1): if index % 1000 == 0: print(f"parsed {index}/{len(infos)} files; rows={summary_counts['assay_rows']}", flush=True) reference = {"xml_file": info.filename} epitope: dict | None = None path: list[str] = [] try: with zf.open(info) as handle: context = etree.iterparse( handle, events=("start", "end"), recover=True, huge_tree=True, ) for event, elem in context: name = local_name(elem) if event == "start": path.append(name) if name == "Epitope" and path_is_top_epitope(path): epitope = {} continue if name == "ReferenceId" and path[-2:] == ["Reference", "ReferenceId"]: reference["reference_id"] = text_content(elem) elif name == "DateLastUpdated" and path[-2:] == ["Reference", "DateLastUpdated"]: reference["date_last_updated"] = text_content(elem) elif name == "PubmedId" and path[-2:] == ["Article", "PubmedId"]: reference["pubmed_id"] = text_content(elem) elif name == "ArticleYear" and path[-2:] == ["Article", "ArticleYear"]: reference["article_year"] = int_or_none(text_content(elem)) elif name == "ArticleTitle" and path[-2:] == ["Article", "ArticleTitle"]: reference["article_title"] = text_content(elem) elif name == "Title" and path[-2:] == ["Journal", "Title"]: reference["journal_title"] = text_content(elem) elif name == "Authors" and path[-2:] == ["Article", "Authors"]: reference["authors"] = parse_authors(elem) if epitope is not None and "Assays" not in path: if name == "EpitopeId" and path[-2:] == ["Epitope", "EpitopeId"]: epitope["epitope_id"] = text_content(elem) elif name == "EpitopeName" and path[-2:] == ["Epitope", "EpitopeName"]: epitope["epitope_name"] = text_content(elem) elif name == "ReferenceRegion" and path[-2:] == ["Epitope", "ReferenceRegion"]: epitope["reference_region"] = text_content(elem) elif name == "EpitopeStructureDefines" and path[-2:] == ["Epitope", "EpitopeStructureDefines"]: epitope["epitope_structure_defines"] = text_content(elem) elif name == "EpitopeEvidenceCode" and path[-2:] == ["Epitope", "EpitopeEvidenceCode"]: epitope["epitope_evidence_code"] = text_content(elem) elif name == "EpitopeStructure" and path[-2:] == ["Epitope", "EpitopeStructure"]: epitope.update(parse_epitope_structure(elem)) if name in ASSAY_TAGS: row = {field_name: None for field_name, _ in FIELDS} row.update(reference) if epitope: row.update(epitope) row.update(parse_assay(elem, name)) sequence = row.get("linear_sequence") row["linear_sequence_length"] = len(sequence) if sequence else None row["is_positive"] = positive_flag(row.get("qualitative_measurement")) key = row.get("epitope_id") or row.get("reference_id") or row.get("assay_id") or row["xml_file"] row["split_bucket"] = stable_bucket(str(key)) split = split_for_row(row) if split == "test": test_rows.append(row) else: train_rows.append(row) summary_counts["assay_rows"] += 1 assay_category_counts[row["assay_category"]] += 1 if row.get("qualitative_measurement"): qualitative_counts[row["qualitative_measurement"]] += 1 if row.get("epitope_chemical_type"): chemical_type_counts[row["epitope_chemical_type"]] += 1 if row.get("epitope_structure_type"): structure_type_counts[row["epitope_structure_type"]] += 1 if row.get("reference_id"): references.add(row["reference_id"]) if row.get("epitope_id"): epitopes.add(row["epitope_id"]) cleanup(elem) summary_counts["train_rows"] += flush_batch(train_rows, train_writer) if len(train_rows) >= batch_size else 0 summary_counts["test_rows"] += flush_batch(test_rows, test_writer) if len(test_rows) >= batch_size else 0 if name == "Epitope" and epitope is not None and path_is_top_epitope(path): epitope = None cleanup(elem) if path: path.pop() except Exception as exc: parse_errors.append({"xml_file": info.filename, "error": f"{type(exc).__name__}: {exc}"}) summary_counts["parse_error_files"] += 1 summary_counts["train_rows"] += flush_batch(train_rows, train_writer) summary_counts["test_rows"] += flush_batch(test_rows, test_writer) train_writer.close() test_writer.close() summary = { "source": "LiteFold/IEDB", "source_file": zip_path.name, "xml_files": int(summary_counts["xml_files"]), "parse_error_files": int(summary_counts["parse_error_files"]), "assay_rows": int(summary_counts["assay_rows"]), "unique_references_with_assays": len(references), "unique_epitopes_with_assays": len(epitopes), "splits": { "train": int(summary_counts["train_rows"]), "test": int(summary_counts["test_rows"]), }, "split_strategy": "deterministic sha256(epitope_id) % 10; bucket 0 is test, buckets 1-9 are train; reference_id/assay_id/file used as fallback", "zip_uncompressed_xml_bytes": int(summary_counts["zip_uncompressed_xml_bytes"]), "zip_compressed_xml_bytes": int(summary_counts["zip_compressed_xml_bytes"]), "assay_category_counts": dict(assay_category_counts), "top_qualitative_measurements": dict(qualitative_counts.most_common(20)), "top_epitope_chemical_types": dict(chemical_type_counts.most_common(20)), "top_epitope_structure_types": dict(structure_type_counts.most_common(20)), "columns": [name for name, _ in FIELDS], "parse_errors": parse_errors[:100], } (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("--zip-path", type=Path, default=Path("LiteFold_IEDB_raw/iedb_export.zip")) parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_IEDB_processed")) parser.add_argument("--batch-size", type=int, default=50_000) parser.add_argument("--limit-files", type=int) args = parser.parse_args() summary = build_dataset(args.zip_path, args.out_dir, args.batch_size, args.limit_files) print(json.dumps(summary, indent=2)) if __name__ == "__main__": main()