Add files using upload-large-folder tool

.gitignore

@@ -0,0 +1,5 @@
+.cache/
+__pycache__/
+*.pyc
+.venv/
+data_preview/

README.md

@@ -0,0 +1,201 @@
+---
+license: cc-by-4.0
+pretty_name: STRING v12.0
+tags:
+- biology
+- proteomics
+- protein-protein-interaction
+- graph
+- string-db
+configs:
+- config_name: protein_links
+  data_files:
+  - split: train
+    path: "data/protein_links/train-*.parquet"
+  - split: validation
+    path: "data/protein_links/validation-*.parquet"
+  - split: test
+    path: "data/protein_links/test-*.parquet"
+- config_name: protein_info
+  data_files:
+  - split: train
+    path: "data/protein_info/train-*.parquet"
+  - split: validation
+    path: "data/protein_info/validation-*.parquet"
+  - split: test
+    path: "data/protein_info/test-*.parquet"
+- config_name: protein_aliases
+  data_files:
+  - split: train
+    path: "data/protein_aliases/train-*.parquet"
+  - split: validation
+    path: "data/protein_aliases/validation-*.parquet"
+  - split: test
+    path: "data/protein_aliases/test-*.parquet"
+- config_name: protein_sequences
+  data_files:
+  - split: train
+    path: "data/protein_sequences/train-*.parquet"
+  - split: validation
+    path: "data/protein_sequences/validation-*.parquet"
+  - split: test
+    path: "data/protein_sequences/test-*.parquet"
+- config_name: species
+  data_files:
+  - split: train
+    path: "data/species/train-*.parquet"
+  - split: validation
+    path: "data/species/validation-*.parquet"
+  - split: test
+    path: "data/species/test-*.parquet"
+---
+
+# STRING v12.0
+
+This repository contains a Hugging Face-friendly packaging of the STRING v12.0 bulk download. STRING is a database of known and predicted protein associations. The raw files are kept under `v12.0/`; the scripts in `scripts/` convert them into sharded Parquet files under `data/` so the Hugging Face Data Viewer can show tables and `datasets.load_dataset` can stream or download the data.
+
+STRING v12.0 reports 59,309,604 proteins from 12,535 organisms and 27,541,372,833 interactions. The upstream data and download files are distributed under Creative Commons BY 4.0; credit STRING and describe any modifications when using this processed version.
+
+## Configs
+
+| Config | Raw source | Description |
+| --- | --- | --- |
+| `protein_links` | `protein.links.full.v12.0.txt.gz` | Protein-protein association edges with all STRING evidence channels and `combined_score`. |
+| `protein_info` | `protein.info.v12.0.txt.gz` | Protein identifiers, preferred names, sizes, and annotations. |
+| `protein_aliases` | `protein.aliases.v12.0.txt.gz` | External aliases and identifier sources for STRING proteins. |
+| `protein_sequences` | `protein.sequences.v12.0.fa.gz` | Protein amino-acid sequences parsed from FASTA. |
+| `species` | `species.v12.0.txt` | Organism metadata: taxonomy id, STRING type, compact name, official NCBI name, and domain. |
+
+## Splits
+
+The post-processing script assigns rows to `train`, `validation`, and `test` with a deterministic CRC32 hash. The default ratios are 98/1/1. Re-running with the same `--split-seed` gives the same split assignment.
+
+Split keys:
+
+| Config | Split key |
+| --- | --- |
+| `protein_links` | `protein1 + protein2` |
+| `protein_info` | `string_protein_id` |
+| `protein_aliases` | `string_protein_id + alias + source` |
+| `protein_sequences` | `string_protein_id` |
+| `species` | `taxon_id` |
+
+## Usage
+
+Install the client library:
+
+```bash
+python -m pip install datasets
+```
+
+Load the interaction table in streaming mode:
+
+```python
+from datasets import load_dataset
+
+links = load_dataset("LiteFold/STRING", "protein_links", split="train", streaming=True)
+first_row = next(iter(links))
+print(first_row)
+```
+
+Load a smaller metadata table normally:
+
+```python
+from datasets import load_dataset
+
+proteins = load_dataset("LiteFold/STRING", "protein_info", split="train")
+print(proteins[0])
+```
+
+Load local Parquet files generated before upload:
+
+```python
+from datasets import load_dataset
+
+data_files = {
+    "train": "data/protein_links/train-*.parquet",
+    "validation": "data/protein_links/validation-*.parquet",
+    "test": "data/protein_links/test-*.parquet",
+}
+links = load_dataset("parquet", data_files=data_files, split="train", streaming=True)
+```
+
+## Post-processing
+
+Install conversion dependencies:
+
+```bash
+python -m pip install -r requirements.txt
+```
+
+Create the full Parquet dataset using 32 worker processes:
+
+```bash
+python scripts/prepare_hf_dataset.py \
+  --raw-dir v12.0 \
+  --output-dir data \
+  --num-proc 32 \
+  --overwrite
+```
+
+Create a quick preview dataset before running the full conversion:
+
+```bash
+python scripts/prepare_hf_dataset.py \
+  --raw-dir v12.0 \
+  --output-dir data_preview \
+  --tables species,protein_info,protein_links \
+  --max-rows-per-table 10000 \
+  --num-proc 32 \
+  --overwrite
+```
+
+Useful options:
+
+| Option | Purpose |
+| --- | --- |
+| `--num-proc 32` | Uses 32 parser workers. |
+| `--rows-per-chunk 100000` | Controls rows parsed per worker task. Lower this if memory is tight. |
+| `--max-in-flight 32` | Bounds queued chunks to avoid unbounded RAM growth. Defaults to `--num-proc`. |
+| `--link-min-combined-score 700` | Optionally keep only higher-confidence links. |
+| `--compression zstd` | Writes compressed Parquet shards. |
+
+Validate generated local files:
+
+```bash
+python scripts/validate_hf_dataset.py --data-dir data --config protein_links --split train --streaming
+```
+
+Validate after upload:
+
+```bash
+python scripts/validate_hf_dataset.py --repo-id LiteFold/STRING --config protein_links --split train --streaming
+```
+
+## Upload
+
+After generating `data/`, upload the processed files and this dataset card:
+
+```bash
+huggingface-cli upload LiteFold/STRING README.md README.md --repo-type dataset
+huggingface-cli upload LiteFold/STRING data data --repo-type dataset
+```
+
+The repository already tracks `*.parquet` with Git LFS through `.gitattributes`.
+
+## Citation
+
+Please cite the upstream STRING database:
+
+```bibtex
+@article{szklarczyk2023string,
+  title = {The STRING database in 2023: protein-protein association networks and functional enrichment analyses for any sequenced genome of interest},
+  author = {Szklarczyk, Damian and Kirsch, Rebecca and Koutrouli, Mikaela and Nastou, Katerina and Mehryary, Farrokh and Hachilif, Radja and Gable, Annika L. and Fang, Tao and Doncheva, Nadezhda T. and Pyysalo, Sampo and Bork, Peer and Jensen, Lars J. and von Mering, Christian},
+  journal = {Nucleic Acids Research},
+  volume = {51},
+  number = {D1},
+  pages = {D638--D646},
+  year = {2023},
+  doi = {10.1093/nar/gkac1000}
+}
+```

data/processing_summary.json

@@ -0,0 +1,114 @@
+{
+  "compression": "zstd",
+  "link_min_combined_score": null,
+  "max_rows_per_table": null,
+  "num_proc": 32,
+  "output_dir": "data",
+  "raw_dir": "v12.0",
+  "rows_per_chunk": 100000,
+  "split_ratios": {
+    "test": 0.01,
+    "train": 0.98,
+    "validation": 0.01
+  },
+  "split_seed": "string-v12.0",
+  "stats": {
+    "protein_aliases": {
+      "parser": {
+        "bad_rows": 0,
+        "chunks": 6281,
+        "filtered_rows": 0,
+        "parsed_rows": 628096921
+      },
+      "rows": {
+        "test": 6279523,
+        "train": 615533987,
+        "validation": 6283411
+      },
+      "shards": {
+        "test": 6281,
+        "train": 6281,
+        "validation": 6281
+      }
+    },
+    "protein_info": {
+      "parser": {
+        "bad_rows": 0,
+        "chunks": 594,
+        "filtered_rows": 0,
+        "parsed_rows": 59309604
+      },
+      "rows": {
+        "test": 593633,
+        "train": 58123200,
+        "validation": 592771
+      },
+      "shards": {
+        "test": 594,
+        "train": 594,
+        "validation": 594
+      }
+    },
+    "protein_links": {
+      "parser": {
+        "bad_rows": 0,
+        "chunks": 275414,
+        "filtered_rows": 0,
+        "parsed_rows": 27541372832
+      },
+      "rows": {
+        "test": 275437468,
+        "train": 26990522006,
+        "validation": 275413358
+      },
+      "shards": {
+        "test": 275414,
+        "train": 275414,
+        "validation": 275414
+      }
+    },
+    "protein_sequences": {
+      "parser": {
+        "bad_rows": 0,
+        "chunks": 594,
+        "filtered_rows": 0,
+        "parsed_rows": 59309604
+      },
+      "rows": {
+        "test": 593633,
+        "train": 58123200,
+        "validation": 592771
+      },
+      "shards": {
+        "test": 594,
+        "train": 594,
+        "validation": 594
+      }
+    },
+    "species": {
+      "parser": {
+        "bad_rows": 0,
+        "chunks": 1,
+        "filtered_rows": 0,
+        "parsed_rows": 12535
+      },
+      "rows": {
+        "test": 157,
+        "train": 12261,
+        "validation": 117
+      },
+      "shards": {
+        "test": 1,
+        "train": 1,
+        "validation": 1
+      }
+    }
+  },
+  "tables": [
+    "species",
+    "protein_info",
+    "protein_aliases",
+    "protein_sequences",
+    "protein_links"
+  ]
+}

data/protein_links/test-275387.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d24dbf640ffffbd3da221ecd768d60f4912d631ae8c77428dcdc72d4de739bbb
+size 15409

data/protein_links/test-275388.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7b00698dc15d4ebaa71908e288782d0305288ebdd7cc42c0991c20a0b2ef79fc
+size 16073

data/protein_links/test-275391.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dcc03485431c5b096769712a986884b582c0f22433b54f7906d89b80eb17ae0d
+size 15737

data/protein_links/test-275393.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d473567dd9cf582112c6a2b6e0220e28ffcc5b16376617d3f199b0e5652d296b
+size 15051

data/protein_links/test-275394.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b418afb6fd1de1fdffe23b646689e16af7ddd6b526956e1653995babc410e853
+size 15450

data/protein_links/test-275395.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05f30519ca3496d4a2ebaddbec113d2ba83570195322494bfd1714e16adbc3d4
+size 15124

data/protein_links/test-275397.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3a26ed587086f9a7187dbd6c680d662670ca9cd663b049f7587853c39d9334ce
+size 15804

data/protein_links/test-275398.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5b3fb18530adf1213d9fa8b99a6aba773333d4dd64694c5ea5428efde97c4c37
+size 15322

data/protein_links/test-275399.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:78098c134977f6ed9ae879c0db5d980a543edf11f2960ec60abd43219a256599
+size 15625

data/protein_links/test-275402.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2940bd1517a114792629586bf13b27153ca0882fb5ea9e8a7e5844bb6d74d0c0
+size 16046

data/protein_links/test-275405.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b3ea3444142353c5a036c5f61057ea96fe74782fa3212dcdc5319b779e5ef409
+size 16014

data/protein_links/test-275408.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:20b0af36f0a95e3127c9d275a7640c1557930825e9d7e59dea498ee464409d5d
+size 14992

data/protein_links/test-275410.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49a5a127fc9783ed7beb6ec29aa752f84c407c1accaedf03310b097686372488
+size 12498

data/protein_links/test-275411.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b104198ddfd843c724a1222fffea95929a98f63502e48efcfa56d9d5ddc17784
+size 15148

data/protein_links/test-275413.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05544dd32d133506fbd65c9b47a30a7db19c653f5196171db99114145a19c735
+size 15585

data/protein_links/train-275395.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c12ab42380939d5e45f3bb9bf9c58deb6b8fa1e75fb1ffbeb28bdc72fa3a4111
+size 572914

data/protein_links/train-275400.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aaf6225c40e77c4a6e8901812572364ed848d89f1199fde1201161385ca0cff8
+size 592384

data/protein_links/train-275402.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:60b5a15b7400e194a587dcade8da6cbc0a04c3c1def65a177aebe0687dfc833e
+size 595059

data/protein_links/train-275403.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:44dc5b9e977bcd7cc20fe30357b94b14214765fb0a5bdccf08c65d9475d8ebf7
+size 595468

data/protein_links/train-275409.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfbf370408cf1e7b47f8646d37fabd9da539b961a2b5f2868f1d497a7714fb8f
+size 576578

data/protein_links/train-275411.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63504d6439a4cff61aeaa507d34a26afa2a62f0b935ac3fad9d3e17973869310
+size 596608

data/protein_links/train-275412.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:830a76dda467ca502ebee219948375342290438165aba7d4ee946cbf233f2220
+size 585915

data/protein_links/validation-275376.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff272a0211795e58b5ecda0f55601251c6a4236ee144689e25a2c9ff314d09dc
+size 14557

data/protein_links/validation-275384.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d4c0092634bfde1674a634e91d10e43082eb7e3fcf5196e783a67b183128dab
+size 15244

data/protein_links/validation-275387.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf11ca7fb7c6598ca2f9579cf659607ba25471e927bcaa93f9331fddbd2613bc
+size 15683

data/protein_links/validation-275389.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc5d74d47eee44f0f3773d70ea89aade6b96580557be7b817fcd5435cbb89a79
+size 15616

data/protein_links/validation-275390.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f85ba37a940c3b6426db221a112d2ef5e29fb2ab6cb0091a7c88f199a9d32891
+size 15457

data/protein_links/validation-275391.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6cc3d758af1bae53f379b4de838f935245661b73640a4a5aed08a4abc84a3c71
+size 15406

data/protein_links/validation-275393.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc4f13a48a54c94945b339b8d2c4f8bbc448743badfe7349eda5fcb8e2bacfa0
+size 15632

data/protein_links/validation-275395.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b9b0d18cf72e537cb7a7b39ae67dd2285e547353aaaa1294ea9e07a5ee9bb3d
+size 15136

data/protein_links/validation-275396.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7831a1cc949c25782654e24e433f7b4bafa2ce871b8ebacb5729f0d8bc464c3a
+size 15976

data/protein_links/validation-275399.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2997d5ac8275186c5b3c29455f1a47ab1d4f0cc78f46bc14b262d6dc5afc5009
+size 15477

data/protein_links/validation-275400.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c1664e11505f94b99ff3a696cad19d4f29e45ff60d1a98c932530281cf0daf49
+size 15732

data/protein_links/validation-275401.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:98858d1f07fab09523a46788cd0e6ab43d94ebf7e0e086bf9b0f546030be9600
+size 15654

data/protein_links/validation-275404.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a09bd288cd74380cf29a1035eeef3ecc28dfd190149b3e4534ad521956add7af
+size 15604

data/protein_links/validation-275405.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ef0e293d175aefe7b5b64b1be726a78c7cdfe9dc25cd8cb31e79f2876e44fe31
+size 15670

data/protein_links/validation-275406.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:365b8bf84ec58b2414d56e317e174b3b9ecf7c6ee25f435361e19ae8cedeafe6
+size 15652

data/protein_links/validation-275407.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f8a534c0b714067c7746e16125bcdee66be237ab36468255b9a282347d0a7305
+size 15187

data/protein_links/validation-275408.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7858860a759ed94111083b569532e459d8db2da383b0a8e6861c5c7a2db1361
+size 15042

data/protein_links/validation-275409.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68b7caabe29bf7c10e3fcbc2ddb6eaf65b2dfade7792ae528b7326d2a92dd977
+size 15077

data/protein_links/validation-275412.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2db3dd759f6ef60115d265dcb00ee3dfec500b91998e6811541cd7575e8736e5
+size 15460

data_preview/processing_summary.json

@@ -0,0 +1,114 @@
+{
+  "compression": "zstd",
+  "link_min_combined_score": null,
+  "max_rows_per_table": 1000,
+  "num_proc": 4,
+  "output_dir": "data_preview",
+  "raw_dir": "v12.0",
+  "rows_per_chunk": 250,
+  "split_ratios": {
+    "test": 0.01,
+    "train": 0.98,
+    "validation": 0.01
+  },
+  "split_seed": "string-v12.0",
+  "stats": {
+    "protein_aliases": {
+      "parser": {
+        "bad_rows": 0,
+        "chunks": 4,
+        "filtered_rows": 0,
+        "parsed_rows": 1000
+      },
+      "rows": {
+        "test": 10,
+        "train": 984,
+        "validation": 6
+      },
+      "shards": {
+        "test": 4,
+        "train": 4,
+        "validation": 3
+      }
+    },
+    "protein_info": {
+      "parser": {
+        "bad_rows": 0,
+        "chunks": 4,
+        "filtered_rows": 0,
+        "parsed_rows": 1000
+      },
+      "rows": {
+        "test": 10,
+        "train": 982,
+        "validation": 8
+      },
+      "shards": {
+        "test": 4,
+        "train": 4,
+        "validation": 3
+      }
+    },
+    "protein_links": {
+      "parser": {
+        "bad_rows": 0,
+        "chunks": 4,
+        "filtered_rows": 0,
+        "parsed_rows": 1000
+      },
+      "rows": {
+        "test": 9,
+        "train": 978,
+        "validation": 13
+      },
+      "shards": {
+        "test": 4,
+        "train": 4,
+        "validation": 3
+      }
+    },
+    "protein_sequences": {
+      "parser": {
+        "bad_rows": 0,
+        "chunks": 4,
+        "filtered_rows": 0,
+        "parsed_rows": 1000
+      },
+      "rows": {
+        "test": 10,
+        "train": 982,
+        "validation": 8
+      },
+      "shards": {
+        "test": 4,
+        "train": 4,
+        "validation": 3
+      }
+    },
+    "species": {
+      "parser": {
+        "bad_rows": 0,
+        "chunks": 4,
+        "filtered_rows": 0,
+        "parsed_rows": 1000
+      },
+      "rows": {
+        "test": 15,
+        "train": 978,
+        "validation": 7
+      },
+      "shards": {
+        "test": 3,
+        "train": 4,
+        "validation": 4
+      }
+    }
+  },
+  "tables": [
+    "species",
+    "protein_info",
+    "protein_aliases",
+    "protein_sequences",
+    "protein_links"
+  ]
+}

requirements.txt

@@ -0,0 +1,3 @@
+pyarrow>=14.0.0
+datasets>=2.19.0
+huggingface_hub>=0.23.0

scripts/prepare_hf_dataset.py

@@ -0,0 +1,763 @@
+#!/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/<config>/<split>-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())

scripts/validate_hf_dataset.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""Smoke-test generated STRING Parquet configs with the Hugging Face datasets API."""
+
+import argparse
+import glob
+import sys
+from pathlib import Path
+from typing import Dict, List
+
+
+CONFIGS = (
+    "species",
+    "protein_info",
+    "protein_aliases",
+    "protein_sequences",
+    "protein_links",
+)
+
+SPLITS = ("train", "validation", "test")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Validate local or uploaded STRING HF dataset configs.")
+    parser.add_argument(
+        "--repo-id",
+        default=None,
+        help="Optional HF dataset repo id, for example LiteFold/STRING. If omitted, validates local Parquet.",
+    )
+    parser.add_argument("--data-dir", type=Path, default=Path("data"))
+    parser.add_argument("--config", choices=CONFIGS, default="protein_links")
+    parser.add_argument("--split", default="train")
+    parser.add_argument("--streaming", action="store_true")
+    parser.add_argument("--preview-rows", type=int, default=3)
+    return parser.parse_args()
+
+
+def local_data_files(data_dir: Path, config: str) -> Dict[str, List[str]]:
+    files: Dict[str, List[str]] = {}
+    for split in SPLITS:
+        pattern = str(data_dir / config / ("%s-*.parquet" % split))
+        matches = sorted(glob.glob(pattern))
+        if matches:
+            files[split] = matches
+    if not files:
+        raise SystemExit("No local Parquet files found for config %s under %s" % (config, data_dir))
+    return files
+
+
+def main() -> int:
+    args = parse_args()
+    try:
+        from datasets import load_dataset
+    except ImportError as exc:
+        raise SystemExit(
+            "datasets is required. Install dependencies with: python -m pip install -r requirements.txt"
+        ) from exc
+
+    if args.repo_id:
+        dataset = load_dataset(args.repo_id, args.config, split=args.split, streaming=args.streaming)
+    else:
+        files = local_data_files(args.data_dir, args.config)
+        if args.split not in files:
+            raise SystemExit(
+                "Split %s is not present locally for config %s. Available splits: %s"
+                % (args.split, args.config, ", ".join(sorted(files)))
+            )
+        dataset = load_dataset("parquet", data_files=files, split=args.split, streaming=args.streaming)
+
+    print("config:", args.config)
+    print("split:", args.split)
+    print("features:", dataset.features)
+
+    if args.streaming:
+        iterator = iter(dataset)
+        for index in range(args.preview_rows):
+            try:
+                print("row[%d]:" % index, next(iterator))
+            except StopIteration:
+                break
+    else:
+        print("num_rows:", len(dataset))
+        for index in range(min(args.preview_rows, len(dataset))):
+            print("row[%d]:" % index, dataset[index])
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())