| |
| """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() |
|
|
