| |
| """Build a flat, viewer-friendly FireProtDB table.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import math |
| import os |
| import shutil |
| import sys |
| from collections import Counter |
| from pathlib import Path |
| from typing import Any, Iterable |
|
|
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| from huggingface_hub import HfApi, HfFileSystem, hf_hub_download |
|
|
| try: |
| import orjson |
| except ImportError: |
| orjson = None |
|
|
|
|
| SOURCE_TABLE = "tables/labeled_fireprotdb_fireprotdb_search_all.jsonl.jsonl" |
| COMMON_MEASUREMENTS = { |
| "TM": "tm", |
| "DTM": "dtm", |
| "DG": "dg", |
| "DDG": "ddg", |
| "DH": "dh", |
| "DCP": "dcp", |
| "DHVH": "dhvh", |
| "CM": "cm", |
| "M": "m_value", |
| "TRYPSIN_ML": "trypsin_ml", |
| "CHYMOTRYPSIN_ML": "chymotrypsin_ml", |
| "STABILIZING": "stabilizing", |
| "DOMAINOME_FITNESS": "domainome_fitness", |
| "DOMAINOME_FITNESS_STD": "domainome_fitness_std", |
| "DOMAINOME_DDG": "domainome_ddg", |
| "DOMAINOME_DDG_STD": "domainome_ddg_std", |
| } |
|
|
|
|
| SCHEMA = pa.schema( |
| [ |
| pa.field("row_id", pa.string()), |
| pa.field("dataset_id", pa.string()), |
| pa.field("source_dataset", pa.string()), |
| pa.field("source_file", pa.string()), |
| pa.field("source_table", pa.string()), |
| pa.field("source_sha", pa.string()), |
| pa.field("row_index", pa.int64()), |
| pa.field("split", pa.string()), |
| pa.field("subject_type", pa.string()), |
| pa.field("entry_id", pa.int64()), |
| pa.field("sequence_id", pa.int64()), |
| pa.field("target_sequence_id", pa.int64()), |
| pa.field("source_sequence_length", pa.int64()), |
| pa.field("target_sequence_length", pa.int64()), |
| pa.field("protein_id", pa.int64()), |
| pa.field("protein_name", pa.string()), |
| pa.field("organism", pa.string()), |
| pa.field("isoform", pa.int64()), |
| pa.field("protein_ids", pa.string()), |
| pa.field("protein_names", pa.string()), |
| pa.field("organisms", pa.string()), |
| pa.field("isoforms", pa.string()), |
| pa.field("uniprot_accessions", pa.string()), |
| pa.field("interpro_accessions", pa.string()), |
| pa.field("ec_numbers", pa.string()), |
| pa.field("megascale_ids", pa.string()), |
| pa.field("other_references", pa.string()), |
| pa.field("mutations", pa.string()), |
| pa.field("substitutions", pa.string()), |
| pa.field("deletions", pa.string()), |
| pa.field("insertions", pa.string()), |
| pa.field("mutation_count", pa.int64()), |
| pa.field("substitution_count", pa.int64()), |
| pa.field("deletion_count", pa.int64()), |
| pa.field("insertion_count", pa.int64()), |
| pa.field("first_position", pa.int64()), |
| pa.field("first_source_aa", pa.string()), |
| pa.field("first_target_aa", pa.string()), |
| pa.field("conservation", pa.float64()), |
| pa.field("feature_types", pa.string()), |
| pa.field("pdb_ids", pa.string()), |
| pa.field("afdb_ids", pa.string()), |
| pa.field("structure_ids", pa.string()), |
| pa.field("structure_methods", pa.string()), |
| pa.field("structure_resolution_min", pa.float64()), |
| pa.field("residue_positions", pa.string()), |
| pa.field("residue_chain_names", pa.string()), |
| pa.field("residue_secondary_structures", pa.string()), |
| pa.field("residue_in_pocket_any", pa.bool_()), |
| pa.field("residue_in_tunnel_any", pa.bool_()), |
| pa.field("residue_asa_mean", pa.float64()), |
| pa.field("residue_bfactor_mean", pa.float64()), |
| pa.field("experiment_id", pa.int64()), |
| pa.field("experiment_dataset", pa.string()), |
| pa.field("ph", pa.float64()), |
| pa.field("measure", pa.string()), |
| pa.field("method", pa.string()), |
| pa.field("buffer", pa.string()), |
| pa.field("buffer_conc", pa.string()), |
| pa.field("exp_temperature", pa.float64()), |
| pa.field("ion", pa.string()), |
| pa.field("ion_conc", pa.string()), |
| pa.field("pdb_chain_mutation", pa.string()), |
| pa.field("tm", pa.float64()), |
| pa.field("dtm", pa.float64()), |
| pa.field("dg", pa.float64()), |
| pa.field("dg_text", pa.string()), |
| pa.field("ddg", pa.float64()), |
| pa.field("dh", pa.float64()), |
| pa.field("dcp", pa.float64()), |
| pa.field("dhvh", pa.float64()), |
| pa.field("cm", pa.float64()), |
| pa.field("m_value", pa.float64()), |
| pa.field("trypsin_ml", pa.float64()), |
| pa.field("chymotrypsin_ml", pa.float64()), |
| pa.field("stabilizing", pa.float64()), |
| pa.field("stabilizing_text", pa.string()), |
| pa.field("domainome_fitness", pa.float64()), |
| pa.field("domainome_fitness_std", pa.float64()), |
| pa.field("domainome_ddg", pa.float64()), |
| pa.field("domainome_ddg_std", pa.float64()), |
| pa.field("reversibility", pa.string()), |
| pa.field("state", pa.string()), |
| pa.field("measurement_types", pa.string()), |
| pa.field("measurement_datasets", pa.string()), |
| pa.field("annotation_types", pa.string()), |
| pa.field("publication_id", pa.string()), |
| pa.field("publication_type", pa.string()), |
| pa.field("publication_title", pa.string()), |
| pa.field("publication_year", pa.int64()), |
| pa.field("publication_doi", pa.string()), |
| pa.field("publication_pmid", pa.string()), |
| pa.field("publication_journal", pa.string()), |
| pa.field("publication_url", pa.string()), |
| pa.field("publication_author_count", pa.int64()), |
| pa.field("publication_authors", pa.string()), |
| pa.field("annotations_json", pa.string()), |
| pa.field("measurements_json", pa.string()), |
| pa.field("features_json", pa.string()), |
| ] |
| ) |
|
|
|
|
| STRING_DEFAULTS = {field.name for field in SCHEMA if pa.types.is_string(field.type)} |
| INT_DEFAULTS = {field.name for field in SCHEMA if pa.types.is_int64(field.type)} |
| BOOL_DEFAULTS = {field.name for field in SCHEMA if pa.types.is_boolean(field.type)} |
|
|
|
|
| def load_token() -> str | None: |
| for key in ("HF_TOKEN", "HUGGINGFACE_HUB_TOKEN"): |
| value = os.environ.get(key) |
| if value: |
| return value |
| env_path = Path(".env") |
| if env_path.exists(): |
| for line in env_path.read_text().splitlines(): |
| stripped = line.strip() |
| if not stripped or stripped.startswith("#") or "=" not in stripped: |
| continue |
| key, value = stripped.split("=", 1) |
| if key.strip() in {"HF_TOKEN", "HUGGINGFACE_HUB_TOKEN"}: |
| value = value.strip().strip('"').strip("'") |
| if value: |
| return value |
| 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 as_int(value: Any) -> int: |
| if value is None or value == "": |
| return -1 |
| try: |
| return int(value) |
| except (TypeError, ValueError): |
| return -1 |
|
|
|
|
| def as_float(value: Any) -> float | None: |
| if value is None or value == "": |
| return None |
| try: |
| numeric = float(value) |
| except (TypeError, ValueError): |
| return None |
| if math.isnan(numeric) or math.isinf(numeric): |
| return None |
| return numeric |
|
|
|
|
| def as_str(value: Any) -> str: |
| if value is None: |
| return "" |
| return str(value) |
|
|
|
|
| def compact_json(value: Any) -> str: |
| if not value: |
| return "" |
| if orjson is not None: |
| return orjson.dumps(value, option=orjson.OPT_SORT_KEYS).decode("utf-8") |
| return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")) |
|
|
|
|
| def load_json_line(line: str) -> dict[str, Any]: |
| if orjson is not None: |
| return orjson.loads(line) |
| return json.loads(line) |
|
|
|
|
| def join_unique(values: Iterable[Any], sep: str = "|") -> str: |
| seen = set() |
| out = [] |
| for value in values: |
| if value is None or value == "": |
| continue |
| text = str(value) |
| if text not in seen: |
| seen.add(text) |
| out.append(text) |
| return sep.join(out) |
|
|
|
|
| def first_value(values: list[Any]) -> Any: |
| return values[0] if values else None |
|
|
|
|
| def extract_subject(row: dict[str, Any]) -> tuple[str, dict[str, Any], dict[str, Any], dict[str, Any] | None]: |
| mutant = row.get("mutant") |
| if mutant: |
| return "mutant", mutant, mutant.get("sourceSequence") or {}, mutant.get("targetSequence") |
| sequence = row.get("sequence") or {} |
| return "sequence", sequence, sequence, None |
|
|
|
|
| def reference_groups(protein_links: list[dict[str, Any]]) -> dict[str, list[str]]: |
| grouped: dict[str, list[str]] = { |
| "UNIPROTKB": [], |
| "INTERPRO": [], |
| "EC_NUMBER": [], |
| "MEGASCALE": [], |
| "OTHER": [], |
| } |
| for link in protein_links: |
| protein = link.get("protein") or {} |
| for ref in protein.get("references") or []: |
| ref_type = as_str(ref.get("type")) |
| accession = as_str(ref.get("accession")) |
| if not accession: |
| continue |
| if ref_type in grouped: |
| grouped[ref_type].append(accession) |
| else: |
| grouped["OTHER"].append(f"{ref_type}:{accession}" if ref_type else accession) |
| return grouped |
|
|
|
|
| def mutation_strings(subject_type: str, subject: dict[str, Any]) -> dict[str, Any]: |
| if subject_type != "mutant": |
| return { |
| "mutations": "", |
| "substitutions": "", |
| "deletions": "", |
| "insertions": "", |
| "mutation_count": 0, |
| "substitution_count": 0, |
| "deletion_count": 0, |
| "insertion_count": 0, |
| "first_position": -1, |
| "first_source_aa": "", |
| "first_target_aa": "", |
| } |
|
|
| substitutions = subject.get("substitutions") or [] |
| deletions = subject.get("deletions") or [] |
| insertions = subject.get("insertions") or [] |
|
|
| sub_strings = [ |
| f"{as_str(item.get('sourceAa'))}{as_int(item.get('position'))}{as_str(item.get('targetAa'))}" |
| for item in substitutions |
| ] |
| del_strings = [f"del{as_str(item.get('aminoAcids'))}{as_int(item.get('position'))}" for item in deletions] |
| ins_strings = [f"ins{as_str(item.get('aminoAcids'))}{as_int(item.get('position'))}" for item in insertions] |
| all_mutations = sub_strings + del_strings + ins_strings |
|
|
| first_position = -1 |
| first_source_aa = "" |
| first_target_aa = "" |
| if substitutions: |
| first = substitutions[0] |
| first_position = as_int(first.get("position")) |
| first_source_aa = as_str(first.get("sourceAa")) |
| first_target_aa = as_str(first.get("targetAa")) |
| elif deletions: |
| first = deletions[0] |
| first_position = as_int(first.get("position")) |
| first_source_aa = as_str(first.get("aminoAcids")) |
| first_target_aa = "-" |
| elif insertions: |
| first = insertions[0] |
| first_position = as_int(first.get("position")) |
| first_source_aa = "-" |
| first_target_aa = as_str(first.get("aminoAcids")) |
|
|
| return { |
| "mutations": join_unique(all_mutations), |
| "substitutions": join_unique(sub_strings), |
| "deletions": join_unique(del_strings), |
| "insertions": join_unique(ins_strings), |
| "mutation_count": len(all_mutations), |
| "substitution_count": len(substitutions), |
| "deletion_count": len(deletions), |
| "insertion_count": len(insertions), |
| "first_position": first_position, |
| "first_source_aa": first_source_aa, |
| "first_target_aa": first_target_aa, |
| } |
|
|
|
|
| def feature_values(features: list[dict[str, Any]]) -> dict[str, Any]: |
| conservation = None |
| types = [] |
| for feature in features: |
| feature_type = as_str(feature.get("type")) |
| types.append(feature_type) |
| if feature_type == "CONSERVATION" and conservation is None: |
| conservation = as_float(feature.get("numValue")) |
| return { |
| "conservation": conservation, |
| "feature_types": join_unique(types), |
| "features_json": compact_json(features), |
| } |
|
|
|
|
| def structure_values(structures: list[dict[str, Any]]) -> dict[str, Any]: |
| residues = [] |
| for structure in structures: |
| residues.extend(structure.get("residues") or []) |
| asa_values = [as_float(residue.get("asa")) for residue in residues] |
| bfactor_values = [as_float(residue.get("bFactor")) for residue in residues] |
| asa_values = [value for value in asa_values if value is not None] |
| bfactor_values = [value for value in bfactor_values if value is not None] |
| resolutions = [as_float(structure.get("resolution")) for structure in structures] |
| resolutions = [value for value in resolutions if value is not None] |
| afdb_ids = [] |
| for structure in structures: |
| afdb = structure.get("afdb") |
| if isinstance(afdb, dict): |
| afdb_ids.append(afdb.get("accession") or afdb.get("id")) |
| else: |
| afdb_ids.append(afdb) |
| return { |
| "pdb_ids": join_unique(structure.get("wwpdb") for structure in structures), |
| "afdb_ids": join_unique(afdb_ids), |
| "structure_ids": join_unique(structure.get("id") for structure in structures), |
| "structure_methods": join_unique(structure.get("method") for structure in structures), |
| "structure_resolution_min": min(resolutions) if resolutions else None, |
| "residue_positions": join_unique(residue.get("seqPosition") for residue in residues), |
| "residue_chain_names": join_unique(residue.get("chainName") for residue in residues), |
| "residue_secondary_structures": join_unique(residue.get("secondaryStructure") for residue in residues), |
| "residue_in_pocket_any": any(bool(residue.get("inPocket")) for residue in residues), |
| "residue_in_tunnel_any": any(bool(residue.get("inTunnel")) for residue in residues), |
| "residue_asa_mean": sum(asa_values) / len(asa_values) if asa_values else None, |
| "residue_bfactor_mean": sum(bfactor_values) / len(bfactor_values) if bfactor_values else None, |
| } |
|
|
|
|
| def annotation_map(annotations: list[dict[str, Any]]) -> dict[str, list[Any]]: |
| values: dict[str, list[Any]] = {} |
| for annotation in annotations: |
| annotation_type = as_str(annotation.get("type")) |
| if not annotation_type: |
| continue |
| value = annotation.get("strValue") |
| if value is None: |
| value = annotation.get("numValue") |
| values.setdefault(annotation_type, []).append(value) |
| return values |
|
|
|
|
| def measurement_map(measurements: list[dict[str, Any]]) -> tuple[dict[str, list[Any]], list[str]]: |
| values: dict[str, list[Any]] = {} |
| datasets = [] |
| for measurement in measurements: |
| measurement_type = as_str(measurement.get("type")) |
| if not measurement_type: |
| continue |
| value = measurement.get("numValue") |
| if value is None: |
| value = measurement.get("strValue") |
| values.setdefault(measurement_type, []).append(value) |
| datasets.extend(measurement.get("datasets") or []) |
| return values, datasets |
|
|
|
|
| def flatten_record(obj: dict[str, Any], source_sha: str) -> dict[str, Any]: |
| row = obj.get("row") or {} |
| subject_type, subject, source_sequence, target_sequence = extract_subject(row) |
| protein_links = source_sequence.get("proteinLinks") or [] |
| first_link = protein_links[0] if protein_links else {} |
| first_protein = first_link.get("protein") or {} |
| refs = reference_groups(protein_links) |
| experiment = subject.get("experiment") or {} |
| publication = experiment.get("publication") or {} |
| annotations = experiment.get("annotations") or [] |
| measurements = experiment.get("measurements") or [] |
| features = subject.get("features") or [] |
| structures = subject.get("structures") or [] |
| ann = annotation_map(annotations) |
| meas, measurement_datasets = measurement_map(measurements) |
|
|
| flat = { |
| "row_id": f"fireprotdb:{as_int(obj.get('row_index'))}", |
| "dataset_id": as_str(obj.get("dataset_id") or "fireprotdb"), |
| "source_dataset": "LiteFold/FireProtDB", |
| "source_file": as_str(obj.get("source_file")), |
| "source_table": SOURCE_TABLE, |
| "source_sha": source_sha, |
| "row_index": as_int(obj.get("row_index")), |
| "split": "test" if stable_bucket(f"fireprotdb:{as_int(obj.get('row_index'))}") == 0 else "train", |
| "subject_type": subject_type, |
| "entry_id": as_int(subject.get("id")), |
| "sequence_id": as_int(source_sequence.get("id")), |
| "target_sequence_id": as_int((target_sequence or {}).get("id")), |
| "source_sequence_length": as_int(source_sequence.get("length")), |
| "target_sequence_length": as_int((target_sequence or {}).get("length")), |
| "protein_id": as_int(first_protein.get("id")), |
| "protein_name": as_str(first_protein.get("name")), |
| "organism": as_str(first_protein.get("organism")), |
| "isoform": as_int(first_link.get("isoform")), |
| "protein_ids": join_unique((link.get("protein") or {}).get("id") for link in protein_links), |
| "protein_names": join_unique((link.get("protein") or {}).get("name") for link in protein_links), |
| "organisms": join_unique((link.get("protein") or {}).get("organism") for link in protein_links), |
| "isoforms": join_unique(link.get("isoform") for link in protein_links), |
| "uniprot_accessions": join_unique(refs["UNIPROTKB"]), |
| "interpro_accessions": join_unique(refs["INTERPRO"]), |
| "ec_numbers": join_unique(refs["EC_NUMBER"]), |
| "megascale_ids": join_unique(refs["MEGASCALE"]), |
| "other_references": join_unique(refs["OTHER"]), |
| "experiment_id": as_int(experiment.get("id")), |
| "experiment_dataset": as_str(experiment.get("dataset")), |
| "ph": as_float(first_value(ann.get("PH", []))), |
| "measure": join_unique(ann.get("MEASURE", [])), |
| "method": join_unique(ann.get("METHOD", [])), |
| "buffer": join_unique(ann.get("BUFFER", [])), |
| "buffer_conc": join_unique(ann.get("BUFFER_CONC", [])), |
| "exp_temperature": as_float(first_value(ann.get("EXP_TEMPERATURE", []))), |
| "ion": join_unique(ann.get("ION", [])), |
| "ion_conc": join_unique(ann.get("ION_CONC", [])), |
| "pdb_chain_mutation": join_unique(ann.get("_PDB_CHAIN_MUTATION", [])), |
| "dg_text": join_unique(value for value in meas.get("DG", []) if as_float(value) is None), |
| "stabilizing_text": join_unique(value for value in meas.get("STABILIZING", []) if as_float(value) is None), |
| "reversibility": join_unique(meas.get("REVERSIBILITY", [])), |
| "state": join_unique(meas.get("STATE", [])), |
| "measurement_types": join_unique(meas.keys()), |
| "measurement_datasets": join_unique(measurement_datasets), |
| "annotation_types": join_unique(ann.keys()), |
| "publication_id": as_str(publication.get("id")), |
| "publication_type": as_str(publication.get("type")), |
| "publication_title": as_str(publication.get("title")), |
| "publication_year": as_int(publication.get("year")), |
| "publication_doi": as_str(publication.get("doi")), |
| "publication_pmid": as_str(publication.get("pmid")), |
| "publication_journal": as_str(publication.get("journal")), |
| "publication_url": as_str(publication.get("url")), |
| "publication_author_count": len(publication.get("authors") or []), |
| "publication_authors": join_unique(author.get("name") for author in publication.get("authors") or []), |
| "annotations_json": compact_json(annotations), |
| "measurements_json": compact_json(measurements), |
| } |
| for measurement_type, column in COMMON_MEASUREMENTS.items(): |
| flat[column] = as_float(first_value(meas.get(measurement_type, []))) |
| flat.update(mutation_strings(subject_type, subject)) |
| flat.update(feature_values(features)) |
| flat.update(structure_values(structures)) |
| return normalize_flat(flat) |
|
|
|
|
| def normalize_flat(flat: dict[str, Any]) -> dict[str, Any]: |
| normalized = {} |
| for field in SCHEMA: |
| value = flat.get(field.name) |
| if value is None: |
| if field.name in STRING_DEFAULTS: |
| value = "" |
| elif field.name in INT_DEFAULTS: |
| value = -1 |
| elif field.name in BOOL_DEFAULTS: |
| value = False |
| normalized[field.name] = value |
| return normalized |
|
|
|
|
| def write_chunk(writer: pq.ParquetWriter | None, path: Path, rows: list[dict[str, Any]]) -> pq.ParquetWriter | None: |
| if not rows: |
| return writer |
| table = pa.Table.from_pylist(rows, schema=SCHEMA) |
| if writer is None: |
| writer = pq.ParquetWriter(path, SCHEMA, compression="zstd", use_dictionary=True) |
| writer.write_table(table) |
| return writer |
|
|
|
|
| def iter_source(repo_id: str, token: str | None, input_file: Path | None) -> Iterable[str]: |
| if input_file: |
| with input_file.open("r", encoding="utf-8") as handle: |
| yield from handle |
| return |
| fs = HfFileSystem(token=token) |
| with fs.open(f"datasets/{repo_id}/{SOURCE_TABLE}", "rt") as handle: |
| yield from handle |
|
|
|
|
| def build_dataset(repo_id: str, raw_dir: Path, out_dir: Path, input_file: Path | None, chunk_size: int) -> dict[str, Any]: |
| token = load_token() |
| api = HfApi(token=token) |
| info = api.dataset_info(repo_id, files_metadata=True) |
| raw_dir.mkdir(parents=True, exist_ok=True) |
| manifest_path = Path( |
| hf_hub_download(repo_id=repo_id, repo_type="dataset", filename="_MANIFEST.json", local_dir=raw_dir, token=token) |
| ) |
| manifest = json.loads(manifest_path.read_text()) |
| 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) |
|
|
| train_path = data_dir / "train-00000-of-00001.parquet" |
| test_path = data_dir / "test-00000-of-00001.parquet" |
| train_writer = None |
| test_writer = None |
| train_rows: list[dict[str, Any]] = [] |
| test_rows: list[dict[str, Any]] = [] |
|
|
| total_rows = 0 |
| split_counts: Counter[str] = Counter() |
| subject_counts: Counter[str] = Counter() |
| experiment_dataset_counts: Counter[str] = Counter() |
| measurement_type_counts: Counter[str] = Counter() |
| annotation_type_counts: Counter[str] = Counter() |
| feature_type_counts: Counter[str] = Counter() |
| mutation_event_counts: Counter[str] = Counter() |
|
|
| try: |
| for line in iter_source(repo_id, token, input_file): |
| obj = load_json_line(line) |
| row = flatten_record(obj, info.sha) |
| total_rows += 1 |
| split_counts[row["split"]] += 1 |
| subject_counts[row["subject_type"]] += 1 |
| if row["experiment_dataset"]: |
| experiment_dataset_counts[row["experiment_dataset"]] += 1 |
| for item in row["measurement_types"].split("|"): |
| if item: |
| measurement_type_counts[item] += 1 |
| for item in row["annotation_types"].split("|"): |
| if item: |
| annotation_type_counts[item] += 1 |
| for item in row["feature_types"].split("|"): |
| if item: |
| feature_type_counts[item] += 1 |
| mutation_event_counts["substitutions"] += row["substitution_count"] |
| mutation_event_counts["deletions"] += row["deletion_count"] |
| mutation_event_counts["insertions"] += row["insertion_count"] |
| if row["split"] == "test": |
| test_rows.append(row) |
| else: |
| train_rows.append(row) |
| if len(train_rows) >= chunk_size: |
| train_writer = write_chunk(train_writer, train_path, train_rows) |
| train_rows.clear() |
| if len(test_rows) >= chunk_size: |
| test_writer = write_chunk(test_writer, test_path, test_rows) |
| test_rows.clear() |
| if total_rows % 100000 == 0: |
| print(f"processed {total_rows:,} rows", file=sys.stderr, flush=True) |
| train_writer = write_chunk(train_writer, train_path, train_rows) |
| test_writer = write_chunk(test_writer, test_path, test_rows) |
| finally: |
| if train_writer is not None: |
| train_writer.close() |
| if test_writer is not None: |
| test_writer.close() |
|
|
| expected_rows = int(manifest.get("total_rows") or 0) |
| if expected_rows and total_rows != expected_rows: |
| raise RuntimeError(f"Expected {expected_rows} rows from manifest, wrote {total_rows}") |
|
|
| source_table_meta = manifest["tables"][0] |
| new_manifest = { |
| "dataset_id": "fireprotdb", |
| "source_repo": repo_id, |
| "source_sha": info.sha, |
| "source_table": SOURCE_TABLE, |
| "format": "flat parquet table rows", |
| "total_rows": total_rows, |
| "split_counts": dict(sorted(split_counts.items())), |
| "split_strategy": "deterministic sha256('fireprotdb:{row_index}') % 10; bucket 0 is test, buckets 1-9 are train", |
| "columns": [field.name for field in SCHEMA], |
| "source_manifest": manifest, |
| } |
| (out_dir / "_MANIFEST.json").write_text(json.dumps(new_manifest, indent=2) + "\n", encoding="utf-8") |
| summary = { |
| "source": repo_id, |
| "source_sha": info.sha, |
| "source_table": SOURCE_TABLE, |
| "source_table_rows": int(source_table_meta["rows"]), |
| "source_table_bytes": int(source_table_meta["bytes"]), |
| "viewer_table_scope": "flat FireProtDB experiment/mutation rows", |
| "data_format": "parquet", |
| "rows": total_rows, |
| "splits": dict(sorted(split_counts.items())), |
| "subject_type_counts": dict(sorted(subject_counts.items())), |
| "experiment_dataset_counts": dict(experiment_dataset_counts.most_common()), |
| "measurement_type_counts": dict(measurement_type_counts.most_common()), |
| "annotation_type_counts": dict(annotation_type_counts.most_common()), |
| "feature_type_counts": dict(feature_type_counts.most_common()), |
| "mutation_event_counts": dict(sorted(mutation_event_counts.items())), |
| "columns": [field.name for field in SCHEMA], |
| "files": { |
| "train": str(train_path.relative_to(out_dir)), |
| "test": str(test_path.relative_to(out_dir)), |
| }, |
| } |
| (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("--repo-id", default="LiteFold/FireProtDB") |
| parser.add_argument("--raw-dir", type=Path, default=Path("LiteFold_FireProtDB_raw")) |
| parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_FireProtDB_processed")) |
| parser.add_argument("--input-file", type=Path) |
| parser.add_argument("--chunk-size", type=int, default=50000) |
| args = parser.parse_args() |
| summary = build_dataset(args.repo_id, args.raw_dir, args.out_dir, args.input_file, args.chunk_size) |
| print(json.dumps(summary, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
