#!/usr/bin/env python3 """Convert raw STRING downloads into Hugging Face Data Viewer-friendly Parquet. The converter streams the raw files, assigns rows to deterministic train/validation/test splits, and writes sharded Parquet files under: data//-00000.parquet It is designed for very large STRING files: chunks are parsed in a bounded process pool and written incrementally, so the complete dataset is never loaded into memory. """ import argparse import gzip import io import json import logging import shutil import subprocess import sys import time import zlib from concurrent.futures import FIRST_COMPLETED, ProcessPoolExecutor, wait from contextlib import contextmanager from pathlib import Path from typing import Dict, Iterator, List, Mapping, Optional, Sequence, Set, Tuple TABLE_ORDER = ( "species", "protein_info", "protein_aliases", "protein_sequences", "protein_links", ) RAW_FILES = { "species": "species.v12.0.txt", "protein_info": "protein.info.v12.0.txt.gz", "protein_aliases": "protein.aliases.v12.0.txt.gz", "protein_sequences": "protein.sequences.v12.0.fa.gz", "protein_links": "protein.links.full.v12.0.txt.gz", } COLUMNS = { "species": ( "taxon_id", "string_type", "string_name_compact", "official_name_ncbi", "domain", ), "protein_info": ( "string_protein_id", "taxon_id", "preferred_name", "protein_size", "annotation", ), "protein_aliases": ( "string_protein_id", "taxon_id", "alias", "source", ), "protein_sequences": ( "string_protein_id", "taxon_id", "sequence", "sequence_length", ), "protein_links": ( "protein1", "protein2", "taxon_id", "neighborhood", "neighborhood_transferred", "fusion", "cooccurence", "homology", "coexpression", "coexpression_transferred", "experiments", "experiments_transferred", "database", "database_transferred", "textmining", "textmining_transferred", "combined_score", ), } TYPE_NAMES = { "species": ( "int32", "string", "string", "string", "string", ), "protein_info": ( "string", "int32", "string", "int32", "string", ), "protein_aliases": ( "string", "int32", "string", "string", ), "protein_sequences": ( "string", "int32", "string", "int32", ), "protein_links": ( "string", "string", "int32", "int16", "int16", "int16", "int16", "int16", "int16", "int16", "int16", "int16", "int16", "int16", "int16", "int16", "int16", ), } def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser( description="Post-process STRING v12.0 raw files into sharded Parquet configs." ) parser.add_argument("--raw-dir", type=Path, default=Path("v12.0")) parser.add_argument("--output-dir", type=Path, default=Path("data")) parser.add_argument( "--tables", default="all", help="Comma-separated table list, or 'all'. Valid tables: %s" % ", ".join(TABLE_ORDER), ) parser.add_argument("--num-proc", type=int, default=32) parser.add_argument( "--max-in-flight", type=int, default=None, help="Maximum parser chunks queued at once. Defaults to --num-proc.", ) parser.add_argument( "--rows-per-chunk", type=int, default=100_000, help="Rows sent to one worker at a time. Lower this if RAM is tight.", ) parser.add_argument("--train-ratio", type=float, default=0.98) parser.add_argument("--validation-ratio", type=float, default=0.01) parser.add_argument("--test-ratio", type=float, default=0.01) parser.add_argument( "--split-seed", default="string-v12.0", help="Stable salt used by the row hash split assignment.", ) parser.add_argument( "--link-min-combined-score", type=int, default=None, help="Optional filter for protein_links. Keeps rows with combined_score >= this value.", ) parser.add_argument( "--max-rows-per-table", type=int, default=None, help="Optional raw-row cap per table, useful for creating a small preview dataset.", ) parser.add_argument( "--compression", default="zstd", choices=("zstd", "snappy", "gzip", "brotli", "none"), help="Parquet compression codec.", ) parser.add_argument( "--decompressor", default="auto", choices=("auto", "python", "gzip", "pigz"), help="How to stream .gz files. auto uses pigz when installed, otherwise Python gzip.", ) parser.add_argument( "--decompressor-proc", type=int, default=4, help="Threads passed to pigz when --decompressor is pigz/auto and pigz is available.", ) parser.add_argument( "--overwrite", action="store_true", help="Delete existing output subdirectories for selected tables before writing.", ) parser.add_argument("--log-every", type=int, default=25) return parser.parse_args() def resolve_tables(value: str) -> List[str]: if value == "all": return list(TABLE_ORDER) selected = [item.strip() for item in value.split(",") if item.strip()] unknown = sorted(set(selected) - set(TABLE_ORDER)) if unknown: raise ValueError("Unknown table(s): %s" % ", ".join(unknown)) return selected def split_cutoffs(train_ratio: float, validation_ratio: float, test_ratio: float) -> Tuple[int, int]: total = train_ratio + validation_ratio + test_ratio if abs(total - 1.0) > 1e-9: raise ValueError("Split ratios must sum to 1.0, got %.8f" % total) train_cutoff = int(train_ratio * (2**32)) validation_cutoff = int((train_ratio + validation_ratio) * (2**32)) return train_cutoff, validation_cutoff def seed_crc(seed: str) -> int: return zlib.crc32(seed.encode("utf-8")) & 0xFFFFFFFF def assign_split(key: str, seed_value: int, cutoffs: Tuple[int, int]) -> str: value = zlib.crc32(key.encode("utf-8"), seed_value) & 0xFFFFFFFF if value < cutoffs[0]: return "train" if value < cutoffs[1]: return "validation" return "test" def taxon_from_protein_id(protein_id: str) -> int: return int(protein_id.split(".", 1)[0]) @contextmanager def open_text(path: Path, decompressor: str, decompressor_proc: int) -> Iterator[io.TextIOBase]: if path.suffix != ".gz": with path.open("rt", encoding="utf-8", newline="") as handle: yield handle return if decompressor == "pigz" and not shutil.which("pigz"): raise RuntimeError("Requested --decompressor pigz, but pigz is not installed") use_pigz = decompressor == "pigz" or (decompressor == "auto" and shutil.which("pigz")) use_gzip_cmd = decompressor == "gzip" if use_pigz: cmd = ["pigz", "-dc", "-p", str(max(1, decompressor_proc)), str(path)] elif use_gzip_cmd: cmd = ["gzip", "-cd", str(path)] else: with gzip.open(path, "rt", encoding="utf-8", newline="") as handle: yield handle return proc = subprocess.Popen(cmd, stdout=subprocess.PIPE) assert proc.stdout is not None handle = io.TextIOWrapper(proc.stdout, encoding="utf-8", newline="") try: yield handle finally: handle.close() return_code = proc.wait() if return_code != 0: raise RuntimeError("Decompressor failed with exit code %s: %s" % (return_code, " ".join(cmd))) def iter_text_chunks( path: Path, rows_per_chunk: int, max_rows: Optional[int], decompressor: str, decompressor_proc: int, ) -> Iterator[Tuple[int, List[str]]]: with open_text(path, decompressor, decompressor_proc) as handle: header = next(handle, None) if header is None: return chunk: List[str] = [] chunk_id = 0 seen = 0 for line in handle: if max_rows is not None and seen >= max_rows: break chunk.append(line) seen += 1 if len(chunk) >= rows_per_chunk: yield chunk_id, chunk chunk_id += 1 chunk = [] if chunk: yield chunk_id, chunk def iter_fasta_records( path: Path, max_rows: Optional[int], decompressor: str, decompressor_proc: int, ) -> Iterator[Tuple[str, str]]: yielded = 0 protein_id: Optional[str] = None parts: List[str] = [] with open_text(path, decompressor, decompressor_proc) as handle: for raw_line in handle: line = raw_line.strip() if not line: continue if line.startswith(">"): if protein_id is not None: yield protein_id, "".join(parts) yielded += 1 if max_rows is not None and yielded >= max_rows: return protein_id = line[1:].split(None, 1)[0] parts = [] else: parts.append(line) if protein_id is not None and (max_rows is None or yielded < max_rows): yield protein_id, "".join(parts) def iter_sequence_chunks( path: Path, rows_per_chunk: int, max_rows: Optional[int], decompressor: str, decompressor_proc: int, ) -> Iterator[Tuple[int, List[Tuple[str, str]]]]: chunk: List[Tuple[str, str]] = [] chunk_id = 0 for record in iter_fasta_records(path, max_rows, decompressor, decompressor_proc): chunk.append(record) if len(chunk) >= rows_per_chunk: yield chunk_id, chunk chunk_id += 1 chunk = [] if chunk: yield chunk_id, chunk def empty_buckets(table: str) -> Dict[str, List[List[object]]]: width = len(COLUMNS[table]) return { "train": [[] for _ in range(width)], "validation": [[] for _ in range(width)], "test": [[] for _ in range(width)], } def append_row(bucket: List[List[object]], values: Sequence[object]) -> None: for index, value in enumerate(values): bucket[index].append(value) def parse_species_line(line: str) -> Tuple[str, Tuple[object, ...]]: fields = line.rstrip("\n").split("\t") if len(fields) != 5: raise ValueError("expected 5 fields") taxon_id = int(fields[0]) return str(taxon_id), (taxon_id, fields[1], fields[2], fields[3], fields[4]) def parse_protein_info_line(line: str) -> Tuple[str, Tuple[object, ...]]: fields = line.rstrip("\n").split("\t", 3) if len(fields) != 4: raise ValueError("expected 4 fields") protein_id = fields[0] taxon_id = taxon_from_protein_id(protein_id) return protein_id, (protein_id, taxon_id, fields[1], int(fields[2]), fields[3]) def parse_alias_line(line: str) -> Tuple[str, Tuple[object, ...]]: fields = line.rstrip("\n").split("\t", 2) if len(fields) != 3: raise ValueError("expected 3 fields") protein_id = fields[0] taxon_id = taxon_from_protein_id(protein_id) key = "%s\t%s\t%s" % (protein_id, fields[1], fields[2]) return key, (protein_id, taxon_id, fields[1], fields[2]) def parse_link_line(line: str, min_combined_score: Optional[int]) -> Optional[Tuple[str, Tuple[object, ...]]]: fields = line.rstrip("\n").split() if len(fields) != 16: raise ValueError("expected 16 fields") combined_score = int(fields[15]) if min_combined_score is not None and combined_score < min_combined_score: return None protein1 = fields[0] protein2 = fields[1] taxon_id = taxon_from_protein_id(protein1) scores = tuple(int(value) for value in fields[2:15]) key = "%s\t%s" % (protein1, protein2) return key, (protein1, protein2, taxon_id) + scores + (combined_score,) def process_text_chunk( table: str, chunk_id: int, lines: Sequence[str], seed_value: int, cutoffs: Tuple[int, int], min_combined_score: Optional[int], ) -> Dict[str, object]: buckets = empty_buckets(table) bad_rows = 0 filtered_rows = 0 parsed_rows = 0 for line in lines: if not line.strip(): continue try: if table == "species": parsed = parse_species_line(line) elif table == "protein_info": parsed = parse_protein_info_line(line) elif table == "protein_aliases": parsed = parse_alias_line(line) elif table == "protein_links": parsed = parse_link_line(line, min_combined_score) else: raise ValueError("unsupported text table %s" % table) except Exception: bad_rows += 1 continue if parsed is None: filtered_rows += 1 continue key, values = parsed split = assign_split(key, seed_value, cutoffs) append_row(buckets[split], values) parsed_rows += 1 return { "table": table, "chunk_id": chunk_id, "buckets": buckets, "parsed_rows": parsed_rows, "bad_rows": bad_rows, "filtered_rows": filtered_rows, } def process_sequence_chunk( chunk_id: int, records: Sequence[Tuple[str, str]], seed_value: int, cutoffs: Tuple[int, int], ) -> Dict[str, object]: table = "protein_sequences" buckets = empty_buckets(table) bad_rows = 0 parsed_rows = 0 for protein_id, sequence in records: try: taxon_id = taxon_from_protein_id(protein_id) except Exception: bad_rows += 1 continue values = (protein_id, taxon_id, sequence, len(sequence)) split = assign_split(protein_id, seed_value, cutoffs) append_row(buckets[split], values) parsed_rows += 1 return { "table": table, "chunk_id": chunk_id, "buckets": buckets, "parsed_rows": parsed_rows, "bad_rows": bad_rows, "filtered_rows": 0, } def import_arrow(): try: import pyarrow as pa import pyarrow.parquet as pq except ImportError as exc: raise SystemExit( "pyarrow is required. Install dependencies with: python -m pip install -r requirements.txt" ) from exc return pa, pq def arrow_type(pa, type_name: str): if type_name == "string": return pa.string() if type_name == "int16": return pa.int16() if type_name == "int32": return pa.int32() raise ValueError("unsupported type %s" % type_name) def arrow_schema(pa, table: str): return pa.schema( [pa.field(name, arrow_type(pa, type_name)) for name, type_name in zip(COLUMNS[table], TYPE_NAMES[table])] ) class ParquetSink: def __init__(self, output_dir: Path, compression: str): self.output_dir = output_dir self.compression = None if compression == "none" else compression self.pa, self.pq = import_arrow() self.schemas = {table: arrow_schema(self.pa, table) for table in TABLE_ORDER} self.shard_counts: Dict[str, Dict[str, int]] = { table: {"train": 0, "validation": 0, "test": 0} for table in TABLE_ORDER } self.row_counts: Dict[str, Dict[str, int]] = { table: {"train": 0, "validation": 0, "test": 0} for table in TABLE_ORDER } def write_buckets(self, table: str, buckets: Mapping[str, Sequence[Sequence[object]]]) -> None: table_dir = self.output_dir / table table_dir.mkdir(parents=True, exist_ok=True) for split in ("train", "validation", "test"): column_lists = buckets[split] row_count = len(column_lists[0]) if column_lists else 0 if row_count == 0: continue data = {name: column_lists[index] for index, name in enumerate(COLUMNS[table])} arrow_table = self.pa.Table.from_pydict(data, schema=self.schemas[table]) shard_id = self.shard_counts[table][split] output_path = table_dir / ("%s-%05d.parquet" % (split, shard_id)) self.pq.write_table( arrow_table, output_path, compression=self.compression, use_dictionary=True, write_statistics=True, ) self.shard_counts[table][split] += 1 self.row_counts[table][split] += row_count def prepare_output_dirs(output_dir: Path, tables: Sequence[str], overwrite: bool) -> None: output_dir.mkdir(parents=True, exist_ok=True) for table in tables: table_dir = output_dir / table if not table_dir.exists(): continue if not overwrite: raise SystemExit( "Output directory already exists: %s. Re-run with --overwrite or choose another --output-dir." % table_dir ) shutil.rmtree(table_dir) def handle_result(result: Mapping[str, object], sink: ParquetSink, stats: Dict[str, Dict[str, int]]) -> None: table = str(result["table"]) sink.write_buckets(table, result["buckets"]) # type: ignore[arg-type] stats[table]["parsed_rows"] += int(result["parsed_rows"]) stats[table]["bad_rows"] += int(result["bad_rows"]) stats[table]["filtered_rows"] += int(result["filtered_rows"]) stats[table]["chunks"] += 1 def drain_one( pending: Set[object], sink: ParquetSink, stats: Dict[str, Dict[str, int]], ) -> Set[object]: done, still_pending = wait(pending, return_when=FIRST_COMPLETED) for future in done: handle_result(future.result(), sink, stats) return set(still_pending) def drain_all( pending: Set[object], sink: ParquetSink, stats: Dict[str, Dict[str, int]], ) -> None: while pending: pending = drain_one(pending, sink, stats) def chunk_iterator( table: str, path: Path, rows_per_chunk: int, max_rows: Optional[int], decompressor: str, decompressor_proc: int, ) -> Iterator[Tuple[int, object]]: if max_rows is not None and decompressor == "auto": decompressor = "python" if table == "protein_sequences": yield from iter_sequence_chunks(path, rows_per_chunk, max_rows, decompressor, decompressor_proc) else: yield from iter_text_chunks(path, rows_per_chunk, max_rows, decompressor, decompressor_proc) def process_table( executor: ProcessPoolExecutor, sink: ParquetSink, table: str, raw_path: Path, args: argparse.Namespace, seed_value: int, cutoffs: Tuple[int, int], stats: Dict[str, Dict[str, int]], ) -> None: logging.info("Processing %s from %s", table, raw_path) started = time.time() pending: Set[object] = set() max_in_flight = args.max_in_flight or args.num_proc for chunk_id, chunk in chunk_iterator( table, raw_path, args.rows_per_chunk, args.max_rows_per_table, args.decompressor, args.decompressor_proc, ): if table == "protein_sequences": future = executor.submit(process_sequence_chunk, chunk_id, chunk, seed_value, cutoffs) else: future = executor.submit( process_text_chunk, table, chunk_id, chunk, seed_value, cutoffs, args.link_min_combined_score, ) pending.add(future) if len(pending) >= max_in_flight: pending = drain_one(pending, sink, stats) submitted = chunk_id + 1 if args.log_every and submitted % args.log_every == 0: logging.info("%s: submitted %d chunks", table, submitted) drain_all(pending, sink, stats) elapsed = time.time() - started logging.info( "Finished %s in %.1fs: %s rows, %s bad rows, %s filtered rows", table, elapsed, stats[table]["parsed_rows"], stats[table]["bad_rows"], stats[table]["filtered_rows"], ) def write_summary( output_dir: Path, tables: Sequence[str], args: argparse.Namespace, sink: ParquetSink, stats: Mapping[str, Mapping[str, int]], ) -> None: summary = { "raw_dir": str(args.raw_dir), "output_dir": str(args.output_dir), "tables": list(tables), "num_proc": args.num_proc, "rows_per_chunk": args.rows_per_chunk, "split_ratios": { "train": args.train_ratio, "validation": args.validation_ratio, "test": args.test_ratio, }, "split_seed": args.split_seed, "link_min_combined_score": args.link_min_combined_score, "max_rows_per_table": args.max_rows_per_table, "compression": args.compression, "stats": { table: { "parser": dict(stats[table]), "rows": dict(sink.row_counts[table]), "shards": dict(sink.shard_counts[table]), } for table in tables }, } path = output_dir / "processing_summary.json" path.write_text(json.dumps(summary, indent=2, sort_keys=True) + "\n", encoding="utf-8") logging.info("Wrote %s", path) def main() -> int: logging.basicConfig( level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s", datefmt="%H:%M:%S", ) args = parse_args() tables = resolve_tables(args.tables) if args.num_proc < 1: raise SystemExit("--num-proc must be >= 1") if args.rows_per_chunk < 1: raise SystemExit("--rows-per-chunk must be >= 1") if args.max_in_flight is not None and args.max_in_flight < 1: raise SystemExit("--max-in-flight must be >= 1") cutoffs = split_cutoffs(args.train_ratio, args.validation_ratio, args.test_ratio) seed_value = seed_crc(args.split_seed) for table in tables: raw_path = args.raw_dir / RAW_FILES[table] if not raw_path.exists(): raise SystemExit("Missing raw file for %s: %s" % (table, raw_path)) prepare_output_dirs(args.output_dir, tables, args.overwrite) sink = ParquetSink(args.output_dir, args.compression) try: sink.pa.set_cpu_count(args.num_proc) except AttributeError: pass stats: Dict[str, Dict[str, int]] = { table: {"chunks": 0, "parsed_rows": 0, "bad_rows": 0, "filtered_rows": 0} for table in TABLE_ORDER } logging.info("Using %d worker processes", args.num_proc) with ProcessPoolExecutor(max_workers=args.num_proc) as executor: for table in tables: raw_path = args.raw_dir / RAW_FILES[table] process_table(executor, sink, table, raw_path, args, seed_value, cutoffs, stats) write_summary(args.output_dir, tables, args, sink, stats) return 0 if __name__ == "__main__": sys.exit(main())