Update dataset card

README.md

@@ -1,16 +1,18 @@
 ---
-pretty_name: Evo-DPLM Data
+pretty_name: Evolutionary MSA Data
 size_categories:
   - 100K<n<1M
 task_categories:
+  - feature-extraction
   - other
 tags:
   - biology
   - protein
-  - rna
-  - structure-prediction
-  - tar
-  - datasets
+  - msa
+  - evolutionary
+  - sequence-alignment
+  - mmseqs2
+  - archive
 configs:
   - config_name: files
     default: true
@@ -27,164 +29,176 @@ configs:
         path: parts.csv
 ---
 
-# Evo-DPLM Data
+# Evolutionary MSA Data
 
-This dataset preserves the source folder as tar shards plus split part files for any source file larger than one shard. `metadata.csv` has one row per original file and is configured as the default Dataset Viewer table.
+This repository contains precomputed evolutionary sequence-alignment data in an archive format that is practical to host and download from the Hub. The original file paths are preserved inside the tar shard, while `metadata.csv` gives a searchable index of every file.
 
-## Summary
+The dataset is meant for workflows that need ready-to-use MSA/cache files without rebuilding them from sequence databases.
 
-| | |
-|---|---:|
-| Original files | 134,906 |
-| Original payload | 19.49 GiB (20,930,421,331 bytes) |
-| Tar shards | 1 |
-| Large-file parts | 0 |
-| Archive size | 19.72 GiB (21,172,090,880 bytes) |
-| Max shard payload | 20.00 GiB |
-| Max large-file part | 20.00 GiB |
-| Metadata generated | 2026-05-25T06:39:53Z |
+## Contents
+
+| Component | Files | Size |
+|---|---:|---:|
+| `msa_cache/` | 134,898 | 19.37 GiB |
+| `mmseqs30/` | 4 | 82.32 MiB |
+| root files | 4 | 41.99 MiB |
 
-## Source Layout
+File types:
 
-| Directory | Files | Size |
-| --- | --- | --- |
-| . | 4 | 41.99 MiB |
-| mmseqs30 | 4 | 82.32 MiB |
-| msa_cache | 134,898 | 19.37 GiB |
+| Type | Files | Size |
+|---|---:|---:|
+| `.npz` | 134,898 | 19.37 GiB |
+| `.fasta` | 3 | 80.71 MiB |
+| `.parquet` | 1 | 34.33 MiB |
+| `.json` | 1 | 7.65 MiB |
+| `.tsv` | 1 | 1.61 MiB |
+| `.sh` | 1 | 806 B |
+| `.md` | 1 | 543 B |
 
-## Common File Types
+Packaging:
 
-| Extension | Files | Size |
-| --- | --- | --- |
-| .npz | 134,898 | 19.37 GiB |
-| .fasta | 3 | 80.71 MiB |
-| .parquet | 1 | 34.33 MiB |
-| .json | 1 | 7.65 MiB |
-| .tsv | 1 | 1.61 MiB |
-| .sh | 1 | 806 B |
-| .md | 1 | 543 B |
+| Item | Value |
+|---|---:|
+| Indexed files | 134,906 |
+| Original payload | 19.49 GiB |
+| Tar shards | 1 |
+| Split large-file parts | 0 |
+| Archive size | 19.72 GiB |
+| Metadata generated | 2026-05-25T06:39:53Z |
 
-## Shards
+## Layout
 
-| Shard | Files | Payload | Archive |
-| --- | --- | --- | --- |
-| shards/shard-00000.tar | 134,906 | 19.49 GiB | 19.72 GiB |
+```text
+README.md
+_MANIFEST.json
+metadata.csv
+shards.csv
+parts.csv
+shards/
+  shard-00000.tar
+```
+
+Most users only need `metadata.csv` and `shards/shard-00000.tar`. The metadata table is configured as the default Dataset Viewer table.
 
 ## Metadata
 
-`metadata.csv` columns:
+`metadata.csv` has one row per original file.
 
-| Column | Description |
+| Column | Meaning |
 |---|---|
-| `path` | Original relative path in the source folder. |
-| `storage_type` | `tar` for files inside tar shards, or `parts` for oversized files split into byte parts. |
-| `shard_path` | Tar shard containing the file when `storage_type` is `tar`. |
+| `path` | Original relative path. |
+| `storage_type` | `tar` for files stored inside a tar shard; `parts` for oversized files split into byte parts. |
+| `shard_path` | Tar shard containing the file. |
 | `member_path` | Path of the file inside the tar shard. |
-| `parts_count` | Number of part files when `storage_type` is `parts`. |
-| `part_paths` | Semicolon-separated part paths when `storage_type` is `parts`. |
-| `top_level` | First directory under the source folder. |
-| `directory` | Parent directory of the file. |
-| `filename` | File basename. |
-| `extension` | File extension, preserving compound suffixes such as `.csv.gz`. |
-| `size_bytes` | Original file size in bytes. |
-| `size_human` | Human-readable original file size. |
-| `modified_utc` | Local file modification timestamp captured during packaging. |
-
-`shards.csv` lists one row per tar shard. `parts.csv` lists one row per split large-file part. `_MANIFEST.json` contains the aggregate build summary.
-
-## Download Everything
-
-```bash
-pip install -U huggingface_hub
-hf download LiteFold/evo-dplm-data --repo-type dataset --local-dir ./evo-dplm-data
+| `parts_count` | Number of split parts, if any. |
+| `part_paths` | Semicolon-separated part paths, if any. |
+| `top_level`, `directory`, `filename`, `extension` | Path fields for filtering. |
+| `size_bytes`, `size_human`, `modified_utc` | Size and timestamp captured during packaging. |
+
+`shards.csv` lists archive shards. `parts.csv` is present for consistency with the archive format; this upload does not currently require split parts.
+
+## Python API Examples
+
+Install recent Hugging Face clients in your environment:
+
+```python
+# pip install -U huggingface_hub datasets
 ```
 
-Extract all shards:
+Set the repo id once:
 
-```bash
-mkdir -p ./data
-for shard in ./evo-dplm-data/shards/*.tar; do
-  tar -xf "$shard" -C ./data
-done
+```python
+repo_id = "LiteFold/Evolutionary"
 ```
 
-Reassemble any split large files:
+### Browse Files
 
-```bash
-python - <<'PY'
-import csv
-from pathlib import Path
+```python
+from datasets import load_dataset
 
-root = Path("./evo-dplm-data")
-out = Path("./data")
-with (root / "metadata.csv").open(newline="") as handle:
-    for row in csv.DictReader(handle):
-        if row["storage_type"] != "parts":
-            continue
-        target = out / row["path"]
-        target.parent.mkdir(parents=True, exist_ok=True)
-        with target.open("wb") as dst:
-            for part in row["part_paths"].split(";"):
-                with (root / part).open("rb") as src:
-                    while True:
-                        chunk = src.read(8 * 1024 * 1024)
-                        if not chunk:
-                            break
-                        dst.write(chunk)
-PY
+files = load_dataset(repo_id, "files", split="train")
+print(files)
+print(files[0])
 ```
 
-## Use With `datasets`
+For streaming access to the index:
 
-Use the `datasets` API to query file metadata, then use `huggingface_hub` to download the shard that contains the file.
+```python
+from datasets import load_dataset
+
+files = load_dataset(repo_id, "files", split="train", streaming=True)
+for row in files:
+    if row["extension"] == ".npz":
+        print(row["path"], row["size_human"], row["shard_path"])
+        break
+```
+
+### Extract One MSA Cache File
+
+This downloads the shard containing the selected file, then extracts only that member.
 
 ```python
+from pathlib import Path
+import tarfile
+
 from datasets import load_dataset
 from huggingface_hub import hf_hub_download
-import tarfile
 
-files = load_dataset("LiteFold/evo-dplm-data", "files", split="train")
-row = files[0]
+repo_id = "LiteFold/Evolutionary"
+out_dir = Path("./evolutionary")
 
-if row["storage_type"] == "tar":
-    shard = hf_hub_download(
-        repo_id="LiteFold/evo-dplm-data",
-        repo_type="dataset",
-        filename=row["shard_path"],
-    )
-    with tarfile.open(shard) as archive:
-        archive.extract(row["member_path"], path="./data")
-else:
-    from pathlib import Path
-
-    target = Path("./data") / row["path"]
-    target.parent.mkdir(parents=True, exist_ok=True)
-    with target.open("wb") as dst:
-        for part_path in row["part_paths"].split(";"):
-            part = hf_hub_download(
-                repo_id="LiteFold/evo-dplm-data",
-                repo_type="dataset",
-                filename=part_path,
-            )
-            with Path(part).open("rb") as src:
-                while True:
-                    chunk = src.read(8 * 1024 * 1024)
-                    if not chunk:
-                        break
-                    dst.write(chunk)
+files = load_dataset(repo_id, "files", split="train", streaming=True)
+row = next(item for item in files if item["extension"] == ".npz")
+
+shard = hf_hub_download(
+    repo_id=repo_id,
+    repo_type="dataset",
+    filename=row["shard_path"],
+)
+
+with tarfile.open(shard) as archive:
+    archive.extract(row["member_path"], path=out_dir)
+
+print(out_dir / row["path"])
 ```
 
-For streaming metadata:
+### Restore The Full Tree
+
+This downloads the repository snapshot and extracts all tar shards into a local directory.
 
 ```python
-from datasets import load_dataset
+from pathlib import Path
+import csv
+import tarfile
 
-files = load_dataset("LiteFold/evo-dplm-data", "files", split="train", streaming=True)
-for row in files:
-    print(row["path"], row["shard_path"])
-    break
+from huggingface_hub import snapshot_download
+
+repo_id = "LiteFold/Evolutionary"
+snapshot = Path(snapshot_download(repo_id=repo_id, repo_type="dataset"))
+out_dir = Path("./evolutionary")
+out_dir.mkdir(parents=True, exist_ok=True)
+
+for shard in sorted((snapshot / "shards").glob("*.tar")):
+    with tarfile.open(shard) as archive:
+        archive.extractall(out_dir)
+
+with (snapshot / "metadata.csv").open(newline="") as handle:
+    for row in csv.DictReader(handle):
+        if row["storage_type"] != "parts":
+            continue
+        target = out_dir / row["path"]
+        target.parent.mkdir(parents=True, exist_ok=True)
+        with target.open("wb") as dst:
+            for part_path in row["part_paths"].split(";"):
+                with (snapshot / part_path).open("rb") as src:
+                    while chunk := src.read(8 * 1024 * 1024):
+                        dst.write(chunk)
+
+print(out_dir)
 ```
 
 ## Notes
 
-The tar shards are uncompressed by design. This keeps packaging and random extraction simple and avoids spending CPU compressing data that is often already compressed.
+- The archive is uncompressed so individual files can be extracted directly from the tar shard.
+- The file paths are kept as they appeared in the source data directory.
+- Use `metadata.csv` as the source of truth for locating files inside shards.