> Make dataset viewer‑ready: preview/dev Parquet, scripts, README, .gitignore

- Add tiny preview/dev manifests with shapes, paths, and checksums:
- manifests/preview.jsonl (embeds 8×8 correlation_matrix), manifests/dev.jsonl (metadata-only)
- Parquet mirrors: manifests/preview.parquet, manifests/dev.parquet
- Add precomputed 8×8 tiles for preview: preview/<parc>__<subject>__corr8x8.json
- Add helper scripts:
- scripts/enrich_manifests.py (shapes from sidecars, checksums from manifest.jsonl, embed 8×8 for
preview)
- scripts/jsonl_to_parquet.py (JSONL → Parquet)
- scripts/scan_to_manifest.py (scan data/ to build metadata-only manifests)
- scripts/make_preview.py (generate 8×8 tiles from .mat using SciPy/mat73)
- Add parcellations.json (parcellation → ROI count)
- Update README:
- YAML tags for discoverability
- Modern datasets usage via data_files (no Python dataset script)
- Preview vs dev behavior, variable fallbacks (correlation_matrix|corr|A; features_timeseries|
timeseries|X)
- Integrity/checksums and script docs
- Add .gitignore to exclude .venv, caches, editor files
- Preserve existing on‑disk layout; large arrays remain in repo and are referenced by relative paths

.gitignore

@@ -0,0 +1,22 @@
+# Python virtual environments
+.venv/
+venv/
+
+# Python cache and build
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+
+# OS/editor cruft
+.DS_Store
+Thumbs.db
+.idea/
+.vscode/
+
+# Jupyter
+.ipynb_checkpoints/
+
+# Parquet conversion caches (if any)
+*.parquet.tmp

README.md

@@ -1,5 +1,13 @@
-
-# PPMI Connectivity Graphs — HF Staging (Derivatives)
+---
+tags:
+  - neuroscience
+  - connectomics
+  - timeseries
+  - matlab
+  - functional-connectivity
+---
+
+# PPMI Connectivity Graphs — HF Staging (Derivatives)
 
 This dataset ships **ready-to-use functional brain connectivity graphs** derived from the PPMI cohort in a BIDS-ish *derivatives* layout. For each subject and parcellation, we include:
 - **ROI time-series** (`*_desc-timeseries_parc-<name>.mat`)
@@ -26,7 +34,7 @@ provenance/                   # author notes, dataset summaries, exclusions
 
 ````
 
-## Quick start (Python)
+## Quick start (Python)
 ```python
 from huggingface_hub import snapshot_download
 from pathlib import Path
@@ -40,8 +48,104 @@ cm = loadmat(root / f"data/parc-{parc}/{pid}/{pid}_desc-correlation_matrix_parc-
 # common variable names (fallback-friendly)
 X = next((ts.get(k) for k in ["features_timeseries","timeseries","X"] if k in ts), None)   # (nodes × time)
 A = next((cm.get(k) for k in ["correlation_matrix","corr","A"] if k in cm), None)          # (nodes × nodes)
-print("Timeseries:", None if X is None else X.shape, "  Connectivity:", None if A is None else A.shape)
-````
+print("Timeseries:", None if X is None else X.shape, "  Connectivity:", None if A is None else A.shape)
+````
+
+## Use with `datasets` (viewer‑ready, no scripts)
+
+You can explore a tiny, fast preview split directly via the `datasets` library. The preview embeds a small 8×8 top‑left
+slice of the correlation matrix so the Hugging Face viewer renders rows/columns quickly. Paths to the full on‑disk
+arrays are included for downstream loading.
+
+```python
+from datasets import load_dataset
+
+# Tiny viewer-ready preview (embeds small 8×8 matrices). One split named "train".
+ds = load_dataset(
+    "pakkinlau/multi-modal-derived-brain-network",
+    data_files="manifests/preview.parquet",
+    split="train",
+)
+row = ds[0]
+print(row["parcellation"], row["subject"])      # e.g., 'AAL116', 'sub-control3351'
+print(row["corr_shape"], row["ts_shape"])      # e.g., [116, 116], [116]
+corr8 = row["correlation_matrix"]               # 8×8 nested list (for display)
+
+# Light dev slice (metadata+paths only). Stream to avoid downloads in CI.
+dev = load_dataset(
+    "pakkinlau/multi-modal-derived-brain-network",
+    data_files="manifests/dev.parquet",
+    split="train",
+    streaming=True,
+)
+for ex in dev.take(3):
+    _ = (ex["parcellation"], ex["subject"], ex["corr_path"])  # no embedded arrays
+```
+
+To access the full arrays, load from the returned `corr_path` / `ts_path` using SciPy or `mat73` with variable name fallbacks:
+
+```python
+from pathlib import Path
+from scipy.io import loadmat
+
+root = Path(ds.cache_files[0]["filename"]).parents[2]  # dataset snapshot root (one way to locate)
+row = ds[0]
+cm = loadmat(root / row["corr_path"])                  # correlation matrix (.mat)
+ts = loadmat(root / row["ts_path"])                    # timeseries (.mat)
+A = next((cm.get(k) for k in ["correlation_matrix","corr","A"] if k in cm), None)
+X = next((ts.get(k) for k in ["features_timeseries","timeseries","X"] if k in ts), None)
+```
+
+### Preview vs. dev vs. full
+
+- preview: tiny split meant for the HF viewer, includes 8×8 `correlation_matrix` as a nested list plus shapes and file paths (see `manifests/preview.parquet`).
+- dev: small metadata‑only slice across 1–2 parcellations; yields `parcellation`, `subject`, shapes, and file paths (see `manifests/dev.parquet`).
+- full arrays: kept in‑repo under `data/` and referenced by the manifests; load them locally using the variable fallbacks above.
+
+If you use our main analysis repo, you can also load pairs via its adapters (if installed):
+
+```python
+from brain_graph.data import hf_pair  # provided by the main repo
+# hf_pair(parcellation, subject, root=Path(...)) returns (timeseries, correlation) arrays
+X, A = hf_pair("AAL116", "sub-control3351", root=Path("/path/to/local/snapshot"))
+```
+
+### Parcellations
+
+- AAL116 — 116 ROIs
+- harvard48 — 48 ROIs
+- kmeans100 — 100 ROIs
+- schaefer100 — 100 ROIs
+- ward100 — 100 ROIs
+
+### File layout
+
+```
+data/
+  parc-<parc>/
+    sub-<id>/
+      <id>_desc-timeseries_parc-<parc>.mat
+      <id>_desc-correlation_matrix_parc-<parc>.mat
+      *.json   # sidecars
+manifests/
+  manifest.jsonl         # machine inventory (sha256, bytes, target_rel per file)
+  preview.jsonl          # tiny viewer split (subject+paths+8x8)
+  preview.parquet        # Parquet version (fast viewer)
+  dev.jsonl              # optional light split (metadata+paths only)
+  dev.parquet            # Parquet version (fast viewer)
+```
+
+### Integrity & Checksums
+
+Rows in the preview/dev manifests include `*_sha256` and `*_bytes` for both `corr_path` and `ts_path`, derived from `manifests/manifest.jsonl`.
+You can verify a local copy by recomputing SHA‑256 and matching the values.
+
+### Scripts (optional)
+
+- `scripts/enrich_manifests.py`: Enrich preview/dev JSONL with shapes (from sidecars), embedded 8×8 tiles (from `preview/`), and checksums (from `manifests/manifest.jsonl`).
+- `scripts/jsonl_to_parquet.py`: Convert any JSONL to Parquet with a stable schema.
+- `scripts/scan_to_manifest.py`: Scan `data/` to produce a metadata-only JSONL (parcellation, subject, shapes, paths, checksums). Useful for making new dev slices.
+- `scripts/make_preview.py`: Generate 8×8 correlation previews from `.mat` files for rows in a manifest. Requires SciPy or `mat73` locally.
 
 ## Cohort & Metadata
 

dataset_infos.json

@@ -0,0 +1,28 @@
+{
+  "default": {
+    "description": "Multi-modal derived brain network dataset (PPMI connectivity graphs) organized in a BIDS-ish derivatives layout.\n\nThis builder exposes a tiny, fast \"preview\" split for interactive exploration on huggingface.co and quick local smoke tests. The preview embeds a downsampled correlation matrix (e.g., 8×8) for each row so the viewer can render a small numeric table. It also includes metadata (parcellation, subject) and array shapes. The heavy arrays remain on disk under the repository (not moved or renamed) and can be accessed via the provided file paths.\n\nVariable name fallbacks when reading .mat files mirror the main repository conventions:\n  - timeseries: features_timeseries | timeseries | X\n  - correlation: correlation_matrix | corr | A\n\nFor larger slices (optional \"dev\" split), only metadata and file paths are exposed to keep the viewer light.",
+    "citation": "Please cite the PPMI and derivative providers as listed in CITATION.cff of this dataset repository.",
+    "homepage": "https://huggingface.co/datasets/pakkinlau/multi-modal-derived-brain-network",
+    "license": null,
+    "features": {
+      "parcellation": {"dtype": "string", "id": null, "_type": "Value"},
+      "subject": {"dtype": "string", "id": null, "_type": "Value"},
+      "corr_shape": {"feature": {"dtype": "int32", "id": null, "_type": "Value"}, "length": -1, "_type": "Sequence"},
+      "ts_shape": {"feature": {"dtype": "int32", "id": null, "_type": "Value"}, "length": -1, "_type": "Sequence"},
+      "corr_path": {"dtype": "string", "id": null, "_type": "Value"},
+      "ts_path": {"dtype": "string", "id": null, "_type": "Value"},
+      "correlation_matrix": {"feature": {"feature": {"dtype": "float32", "id": null, "_type": "Value"}, "length": -1, "_type": "Sequence"}, "length": -1, "_type": "Sequence"}
+    },
+    "post_processed": null,
+    "supervised_keys": null,
+    "task_templates": null,
+    "builder_name": "MMDN",
+    "config_name": "default",
+    "version": {"version_str": "1.0.0", "major": 1, "minor": 0, "patch": 0},
+    "splits": {},
+    "download_checksums": {},
+    "download_size": 0,
+    "dataset_size": 0,
+    "size_in_bytes": 0
+  }
+}

dataset_mmdn.py

@@ -0,0 +1,270 @@
+import json
+import os
+from typing import Dict, Iterable, Iterator, List, Optional, Tuple
+
+import datasets
+
+
+_CITATION = """\
+Please cite the PPMI and derivative providers as listed in CITATION.cff of this dataset repository.
+"""
+
+
+_DESCRIPTION = """\
+Multi-modal derived brain network dataset (PPMI connectivity graphs) organized in a BIDS-ish derivatives layout.
+
+This builder exposes a tiny, fast "preview" split for interactive exploration on huggingface.co and quick local
+smoke tests. The preview embeds a downsampled correlation matrix (e.g., 8×8) for each row so the viewer can render a
+small numeric table. It also includes metadata (parcellation, subject) and array shapes. The heavy arrays remain on
+disk under the repository (not moved or renamed) and can be accessed via the provided file paths.
+
+Variable name fallbacks when reading .mat files mirror the main repository conventions:
+  - timeseries: features_timeseries | timeseries | X
+  - correlation: correlation_matrix | corr | A
+
+For larger slices (optional "dev" split), only metadata and file paths are exposed to keep the viewer light.
+"""
+
+
+_HOMEPAGE = "https://huggingface.co/datasets/pakkinlau/multi-modal-derived-brain-network"
+
+
+class MMDNConfig(datasets.BuilderConfig):
+    def __init__(self, **kwargs):
+        super().__init__(version=datasets.Version("1.0.0"), **kwargs)
+
+
+class MMDN(datasets.GeneratorBasedBuilder):
+    BUILDER_CONFIGS = [
+        MMDNConfig(name="default", description="MMDN with preview (embedded tiny arrays) and optional dev metadata split"),
+    ]
+    DEFAULT_CONFIG_NAME = "default"
+
+    def _info(self) -> datasets.DatasetInfo:
+        # Features include a superset so both preview (with embedded small matrices) and dev (metadata-only) work.
+        features = datasets.Features(
+            {
+                "parcellation": datasets.Value("string"),
+                "subject": datasets.Value("string"),
+                # Shapes as [n, n] and [n, t]
+                "corr_shape": datasets.Sequence(datasets.Value("int32")),
+                "ts_shape": datasets.Sequence(datasets.Value("int32")),
+                # File paths (relative to repo root)
+                "corr_path": datasets.Value("string"),
+                "ts_path": datasets.Value("string"),
+                # Tiny preview matrix (downsampled 8x8 top-left). For non-preview, this can be an empty list.
+                "correlation_matrix": datasets.Sequence(datasets.Sequence(datasets.Value("float32"))),
+            }
+        )
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            citation=_CITATION,
+            homepage=_HOMEPAGE,
+        )
+
+    def _split_generators(self, dl_manager: datasets.DownloadManager):
+        base_dir = os.path.abspath(os.path.dirname(__file__))
+
+        def _maybe(path: str) -> Optional[str]:
+            ap = os.path.join(base_dir, path)
+            return ap if os.path.exists(ap) else None
+
+        preview_manifest = _maybe(os.path.join("manifests", "preview.jsonl"))
+        dev_manifest = _maybe(os.path.join("manifests", "dev.jsonl"))
+
+        splits = []
+        if preview_manifest:
+            splits.append(
+                datasets.SplitGenerator(name=datasets.Split("preview"), gen_kwargs={"manifest_path": preview_manifest, "embed_preview": True})
+            )
+        if dev_manifest:
+            splits.append(
+                datasets.SplitGenerator(name=datasets.Split("dev"), gen_kwargs={"manifest_path": dev_manifest, "embed_preview": False})
+            )
+        # If no manifest is found, raise a helpful error.
+        if not splits:
+            raise FileNotFoundError(
+                "No manifests found. Expected manifests/preview.jsonl (and optionally manifests/dev.jsonl) in the dataset repo."
+            )
+        return splits
+
+    def _generate_examples(self, manifest_path: str, embed_preview: bool) -> Iterator[Tuple[str, Dict]]:
+        base_dir = os.path.abspath(os.path.dirname(__file__))
+        with open(manifest_path, "r", encoding="utf-8") as f:
+            for idx, line in enumerate(f):
+                if not line.strip():
+                    continue
+                row = json.loads(line)
+
+                parcellation = row.get("parcellation")
+                subject = row.get("subject")
+                corr_rel = row.get("corr_path")
+                ts_rel = row.get("ts_path")
+                corr_path = os.path.join(base_dir, corr_rel) if corr_rel else None
+                ts_path = os.path.join(base_dir, ts_rel) if ts_rel else None
+
+                corr_shape, ts_shape = self._inspect_shapes(corr_path, ts_path)
+                # Fallback: infer shapes from JSON sidecars if .mat loaders are unavailable
+                if corr_shape is None and corr_path:
+                    corr_shape = self._infer_corr_shape_from_sidecar(corr_path)
+                if ts_shape is None and ts_path:
+                    ts_shape = self._infer_ts_shape_from_sidecar(ts_path)
+
+                preview_matrix: List[List[float]] = []
+                if embed_preview:
+                    # Prefer precomputed tiny preview JSON if present, else try reading from .mat
+                    preview_json = self._preview_json_for(parcellation, subject)
+                    if preview_json and os.path.exists(preview_json):
+                        try:
+                            with open(preview_json, "r", encoding="utf-8") as pj:
+                                arr = json.load(pj)
+                            if isinstance(arr, list) and (not arr or isinstance(arr[0], list)):
+                                # ensure float32 conversion
+                                preview_matrix = [[float(x) for x in row] for row in arr]
+                        except Exception:
+                            preview_matrix = []
+                    elif corr_path and os.path.exists(corr_path):
+                        small = self._read_correlation_small(corr_path, size=8)
+                        if small is not None:
+                            preview_matrix = [[float(x) for x in row] for row in small.tolist()]
+
+                example = {
+                    "parcellation": parcellation,
+                    "subject": subject,
+                    "corr_shape": list(corr_shape) if corr_shape else [],
+                    "ts_shape": list(ts_shape) if ts_shape else [],
+                    "corr_path": corr_rel or "",
+                    "ts_path": ts_rel or "",
+                    "correlation_matrix": preview_matrix,
+                }
+                # Unique key: combine split index + subject + parcellation
+                key = f"{idx:06d}-{parcellation}-{subject}"
+                yield key, example
+
+    # --- Helpers ---
+    @staticmethod
+    def _try_import_mat_modules():
+        try:
+            import scipy.io as sio  # type: ignore
+        except Exception as e:  # pragma: no cover
+            sio = None
+        try:
+            import mat73  # type: ignore
+        except Exception:
+            mat73 = None
+        return sio, mat73
+
+    def _load_mat(self, path: str) -> Optional[Dict]:
+        sio, mat73 = self._try_import_mat_modules()
+        if sio is not None:
+            try:
+                return sio.loadmat(path, squeeze_me=True, simplify_cells=True)  # type: ignore[arg-type]
+            except NotImplementedError:
+                pass
+            except Exception:
+                # Keep trying fallbacks
+                pass
+        if mat73 is not None:
+            try:
+                return mat73.loadmat(path)  # type: ignore[attr-defined]
+            except Exception:
+                pass
+        return None
+
+    def _pick_var(self, d: Dict, candidates: List[str]) -> Optional[Tuple[str, object]]:
+        for k in candidates:
+            if k in d:
+                return k, d[k]
+        # Some loaders store keys lower/upper differently; try case-insensitive match
+        lower_map = {k.lower(): k for k in d.keys()}
+        for k in candidates:
+            if k.lower() in lower_map:
+                real_k = lower_map[k.lower()]
+                return real_k, d[real_k]
+        return None
+
+    def _inspect_shapes(self, corr_path: Optional[str], ts_path: Optional[str]) -> Tuple[Optional[Tuple[int, int]], Optional[Tuple[int, int]]]:
+        import numpy as np  # local import to avoid hard dependency at import time
+
+        corr_shape: Optional[Tuple[int, int]] = None
+        ts_shape: Optional[Tuple[int, int]] = None
+
+        if corr_path and os.path.exists(corr_path):
+            data = self._load_mat(corr_path)
+            if isinstance(data, dict):
+                pick = self._pick_var(data, ["correlation_matrix", "corr", "A"])
+                if pick is not None:
+                    _, arr = pick
+                    try:
+                        a = np.asarray(arr)
+                        if a.ndim >= 2:
+                            corr_shape = (int(a.shape[-2]), int(a.shape[-1]))
+                    except Exception:
+                        pass
+
+        if ts_path and os.path.exists(ts_path):
+            data = self._load_mat(ts_path)
+            if isinstance(data, dict):
+                pick = self._pick_var(data, ["features_timeseries", "timeseries", "X"])
+                if pick is not None:
+                    _, arr = pick
+                    try:
+                        a = np.asarray(arr)
+                        if a.ndim >= 2:
+                            ts_shape = (int(a.shape[-2]), int(a.shape[-1]))
+                    except Exception:
+                        pass
+
+        return corr_shape, ts_shape
+
+    def _read_correlation_small(self, corr_path: str, size: int = 8):
+        import numpy as np
+
+        data = self._load_mat(corr_path)
+        if not isinstance(data, dict):
+            return None
+        pick = self._pick_var(data, ["correlation_matrix", "corr", "A"])
+        if pick is None:
+            return None
+        _, arr = pick
+        a = np.asarray(arr)
+        if a.ndim < 2:
+            return None
+        n = min(size, a.shape[-1])
+        return a[:n, :n].astype("float32")
+
+    # --- Sidecar & preview helpers ---
+    def _infer_corr_shape_from_sidecar(self, corr_path: str) -> Optional[Tuple[int, int]]:
+        sidecar = os.path.splitext(corr_path)[0] + ".json"
+        if os.path.exists(sidecar):
+            try:
+                with open(sidecar, "r", encoding="utf-8") as f:
+                    meta = json.load(f)
+                n = meta.get("NodeCount")
+                if isinstance(n, int) and n > 0:
+                    return (n, n)
+            except Exception:
+                return None
+        return None
+
+    def _infer_ts_shape_from_sidecar(self, ts_path: str) -> Optional[Tuple[int, int]]:
+        sidecar = os.path.splitext(ts_path)[0] + ".json"
+        if os.path.exists(sidecar):
+            try:
+                with open(sidecar, "r", encoding="utf-8") as f:
+                    meta = json.load(f)
+                n = meta.get("NodeCount")
+                if isinstance(n, int) and n > 0:
+                    # length T unknown; return partial shape (n only) as (n, 0) isn't informative in the table
+                    return (n,)
+            except Exception:
+                return None
+        return None
+
+    def _preview_json_for(self, parcellation: Optional[str], subject: Optional[str]) -> Optional[str]:
+        if not parcellation or not subject:
+            return None
+        base_dir = os.path.abspath(os.path.dirname(__file__))
+        # filename pattern: preview/<parc>__<subject>__corr8x8.json
+        return os.path.join(base_dir, "preview", f"{parcellation}__{subject}__corr8x8.json")

manifests/dev.jsonl

@@ -0,0 +1,20 @@
+{"parcellation": "AAL116", "subject": "sub-control100890", "corr_path": "data/parc-AAL116/sub-control100890/sub-control100890_desc-correlation_matrix_parc-AAL116.mat", "ts_path": "data/parc-AAL116/sub-control100890/sub-control100890_desc-timeseries_parc-AAL116.mat", "correlation_matrix": [], "corr_shape": [116, 116], "ts_shape": [116], "corr_sha256": "b5a8e599c82655729c8e6bbc82b3606ce153b16a1d5f588f9f7701396997f3f8", "corr_bytes": 54008, "ts_sha256": "e4d1bcca61e5619ea3f7ccd4321ee0d7e89dfcae87a10f7334bcf3b1a8562801", "ts_bytes": 111544}
+{"parcellation": "AAL116", "subject": "sub-control3351", "corr_path": "data/parc-AAL116/sub-control3351/sub-control3351_desc-correlation_matrix_parc-AAL116.mat", "ts_path": "data/parc-AAL116/sub-control3351/sub-control3351_desc-timeseries_parc-AAL116.mat", "correlation_matrix": [], "corr_shape": [116, 116], "ts_shape": [116], "corr_sha256": "53161c1ea79258bd8243b9fb923fbfb0f6c8427da8c60634e623b4c1cad73deb", "corr_bytes": 107832, "ts_sha256": "5cf79c9700df2a1875496e4edb00aa988f65de3bb6186736df7216469452f661", "ts_bytes": 195064}
+{"parcellation": "AAL116", "subject": "sub-control3353", "corr_path": "data/parc-AAL116/sub-control3353/sub-control3353_desc-correlation_matrix_parc-AAL116.mat", "ts_path": "data/parc-AAL116/sub-control3353/sub-control3353_desc-timeseries_parc-AAL116.mat", "correlation_matrix": [], "corr_shape": [116, 116], "ts_shape": [116], "corr_sha256": "cb1078bd58bd9592345baf4eca5a40baaac147c04c0ff5115699cd32b1ff3c52", "corr_bytes": 107832, "ts_sha256": "c7981fc037569f3ba0c7a5dfe063d20acc1c9aa4b46c536a64bcdd51357c703c", "ts_bytes": 195064}
+{"parcellation": "AAL116", "subject": "sub-control3361", "corr_path": "data/parc-AAL116/sub-control3361/sub-control3361_desc-correlation_matrix_parc-AAL116.mat", "ts_path": "data/parc-AAL116/sub-control3361/sub-control3361_desc-timeseries_parc-AAL116.mat", "correlation_matrix": [], "corr_shape": [116, 116], "ts_shape": [116], "corr_sha256": "3351f8fa7d0010a6a9e0fd82e25d1ec73dd02d80ba265636a45f70f176a97ac0", "corr_bytes": 107832, "ts_sha256": "ae71cda75e50e852e76c887a36f49e675935f75077d1d2a307c9de55c64d15d3", "ts_bytes": 195064}
+{"parcellation": "AAL116", "subject": "sub-control3368", "corr_path": "data/parc-AAL116/sub-control3368/sub-control3368_desc-correlation_matrix_parc-AAL116.mat", "ts_path": "data/parc-AAL116/sub-control3368/sub-control3368_desc-timeseries_parc-AAL116.mat", "correlation_matrix": [], "corr_shape": [116, 116], "ts_shape": [116], "corr_sha256": "8224800cccb76bb8359301ed796ec82bfae89f24b3ea687d78d037dd29389a7f", "corr_bytes": 107832, "ts_sha256": "9b35dff833ad03818a818cf955fc0be356f866f17c75e1f4967c3f154ad61884", "ts_bytes": 195064}
+{"parcellation": "AAL116", "subject": "sub-control3369", "corr_path": "data/parc-AAL116/sub-control3369/sub-control3369_desc-correlation_matrix_parc-AAL116.mat", "ts_path": "data/parc-AAL116/sub-control3369/sub-control3369_desc-timeseries_parc-AAL116.mat", "correlation_matrix": [], "corr_shape": [116, 116], "ts_shape": [116], "corr_sha256": "c3890df08542e5a9ba1099f371891e800da49cb363146ba501ec59f1be9008d1", "corr_bytes": 107832, "ts_sha256": "0e5ed2bf747586e64ba2b4fa4b133f66f9cc0b4de0d092e411aaff06444de24c", "ts_bytes": 195064}
+{"parcellation": "AAL116", "subject": "sub-control3389", "corr_path": "data/parc-AAL116/sub-control3389/sub-control3389_desc-correlation_matrix_parc-AAL116.mat", "ts_path": "data/parc-AAL116/sub-control3389/sub-control3389_desc-timeseries_parc-AAL116.mat", "correlation_matrix": [], "corr_shape": [116, 116], "ts_shape": [116], "corr_sha256": "ca06dd9688835389d32da2488b72166e8a2b45463389096988b4c2d390167b6d", "corr_bytes": 107832, "ts_sha256": "5b88301afa26bafed64379a86e18920b432d2bf34c542372a5e8d91e139046ea", "ts_bytes": 195064}
+{"parcellation": "AAL116", "subject": "sub-control3390", "corr_path": "data/parc-AAL116/sub-control3390/sub-control3390_desc-correlation_matrix_parc-AAL116.mat", "ts_path": "data/parc-AAL116/sub-control3390/sub-control3390_desc-timeseries_parc-AAL116.mat", "correlation_matrix": [], "corr_shape": [116, 116], "ts_shape": [116], "corr_sha256": "e912704c743652a821453564e750aa319689eba477c3e233f275c20629c41d59", "corr_bytes": 107832, "ts_sha256": "904f98cd34215954d250dc7bdeb84e9ce058f232fadf1fa80bb0ca9c976fda90", "ts_bytes": 195064}
+{"parcellation": "AAL116", "subject": "sub-control3554", "corr_path": "data/parc-AAL116/sub-control3554/sub-control3554_desc-correlation_matrix_parc-AAL116.mat", "ts_path": "data/parc-AAL116/sub-control3554/sub-control3554_desc-timeseries_parc-AAL116.mat", "correlation_matrix": [], "corr_shape": [116, 116], "ts_shape": [116], "corr_sha256": "9734f6a05cfe7e58afb6442ace4027ee5e8cf4c4e73c3134a9c6aadc6697c381", "corr_bytes": 107832, "ts_sha256": "d37af2fbad08109ee6038720bd8c7833181217a83fee6050e9e3145acea99675", "ts_bytes": 195064}
+{"parcellation": "AAL116", "subject": "sub-control3563", "corr_path": "data/parc-AAL116/sub-control3563/sub-control3563_desc-correlation_matrix_parc-AAL116.mat", "ts_path": "data/parc-AAL116/sub-control3563/sub-control3563_desc-timeseries_parc-AAL116.mat", "correlation_matrix": [], "corr_shape": [116, 116], "ts_shape": [116], "corr_sha256": "6c006c23d03f9015ffbc5a80a9d1059b2c4e5f15f6ddf8e029c17729f2d5691d", "corr_bytes": 107832, "ts_sha256": "35ea4713f2f3688a2f3436444f768bd1c92c50f1162337a4efe7b50035822a9a", "ts_bytes": 195064}
+{"parcellation": "harvard48", "subject": "sub-control100890", "corr_path": "data/parc-harvard48/sub-control100890/sub-control100890_desc-correlation_matrix_parc-harvard48.mat", "ts_path": "data/parc-harvard48/sub-control100890/sub-control100890_desc-timeseries_parc-harvard48.mat", "correlation_matrix": [], "corr_shape": [48, 48], "ts_shape": [48], "corr_sha256": "961e2a4902b7da5e93f21c38133901fd90e7b45d994f97e7608d6e0b4c78bab5", "corr_bytes": 9400, "ts_sha256": "6fa7aa85599afdad615a4dac99e7379fa36434245e36724b8f1a9be39ccb5d40", "ts_bytes": 46264}
+{"parcellation": "harvard48", "subject": "sub-control3351", "corr_path": "data/parc-harvard48/sub-control3351/sub-control3351_desc-correlation_matrix_parc-harvard48.mat", "ts_path": "data/parc-harvard48/sub-control3351/sub-control3351_desc-timeseries_parc-harvard48.mat", "correlation_matrix": [], "corr_shape": [48, 48], "ts_shape": [48], "corr_sha256": "9aa5083bddeb70b5cc443747592e117099c3143c64a497e28956d7fb189a2f8b", "corr_bytes": 18616, "ts_sha256": "69061d32f407981d5f2b2d397f839fdf2ec5b92db084deb4823b00cadadddda1", "ts_bytes": 80824}
+{"parcellation": "harvard48", "subject": "sub-control3353", "corr_path": "data/parc-harvard48/sub-control3353/sub-control3353_desc-correlation_matrix_parc-harvard48.mat", "ts_path": "data/parc-harvard48/sub-control3353/sub-control3353_desc-timeseries_parc-harvard48.mat", "correlation_matrix": [], "corr_shape": [48, 48], "ts_shape": [48], "corr_sha256": "0d002f8841c3797777125eb0bfb596bf9f3a7ff8578b72294c51587993764558", "corr_bytes": 18616, "ts_sha256": "a71134fd48f7e37d3a54d7bbac403be9d15ee1373d79433df81e77cfd112133d", "ts_bytes": 80824}
+{"parcellation": "harvard48", "subject": "sub-control3361", "corr_path": "data/parc-harvard48/sub-control3361/sub-control3361_desc-correlation_matrix_parc-harvard48.mat", "ts_path": "data/parc-harvard48/sub-control3361/sub-control3361_desc-timeseries_parc-harvard48.mat", "correlation_matrix": [], "corr_shape": [48, 48], "ts_shape": [48], "corr_sha256": "ab29455503565d79544739058fd68b5b9dd6a1e33d851a306971a236496e4f43", "corr_bytes": 18616, "ts_sha256": "fa49afc42bb68cc5be4abccdad4f68e4c9fda5cb60882a50cee590638432d18a", "ts_bytes": 80824}
+{"parcellation": "harvard48", "subject": "sub-control3368", "corr_path": "data/parc-harvard48/sub-control3368/sub-control3368_desc-correlation_matrix_parc-harvard48.mat", "ts_path": "data/parc-harvard48/sub-control3368/sub-control3368_desc-timeseries_parc-harvard48.mat", "correlation_matrix": [], "corr_shape": [48, 48], "ts_shape": [48], "corr_sha256": "3a46d0ccb1f0aea97149f6fdd7705b43ce0fdc3a41c04ca121beed3d520d448e", "corr_bytes": 18616, "ts_sha256": "469e25a40796537b6125c02433587742a87f819fa01423bb1ad9bd556a68cf63", "ts_bytes": 80824}
+{"parcellation": "harvard48", "subject": "sub-control3369", "corr_path": "data/parc-harvard48/sub-control3369/sub-control3369_desc-correlation_matrix_parc-harvard48.mat", "ts_path": "data/parc-harvard48/sub-control3369/sub-control3369_desc-timeseries_parc-harvard48.mat", "correlation_matrix": [], "corr_shape": [48, 48], "ts_shape": [48], "corr_sha256": "ae98f24e9a2d030cab9f7d478a128e99df62029ebb6c7f932d58d9125da01963", "corr_bytes": 18616, "ts_sha256": "446c2e6cd18b26b0f94b10407157d4f097c4e17d832fcad5e1fa8c1477c9bd25", "ts_bytes": 80824}
+{"parcellation": "harvard48", "subject": "sub-control3389", "corr_path": "data/parc-harvard48/sub-control3389/sub-control3389_desc-correlation_matrix_parc-harvard48.mat", "ts_path": "data/parc-harvard48/sub-control3389/sub-control3389_desc-timeseries_parc-harvard48.mat", "correlation_matrix": [], "corr_shape": [48, 48], "ts_shape": [48], "corr_sha256": "c20903f80abb0021f2a90835d0ae0a460c2abc07b355865c3db59d4d66f6d431", "corr_bytes": 18616, "ts_sha256": "216f352a7b0657dcb699164b3a5d12331588f1af89b2afa22441831c6c854b06", "ts_bytes": 80824}
+{"parcellation": "harvard48", "subject": "sub-control3390", "corr_path": "data/parc-harvard48/sub-control3390/sub-control3390_desc-correlation_matrix_parc-harvard48.mat", "ts_path": "data/parc-harvard48/sub-control3390/sub-control3390_desc-timeseries_parc-harvard48.mat", "correlation_matrix": [], "corr_shape": [48, 48], "ts_shape": [48], "corr_sha256": "610c27c459e6857f0ca162cecc0b86f91bb1b4acffca0c7ed2ee8b64f71f461a", "corr_bytes": 18616, "ts_sha256": "dd41a8e1003116edb8c00b1e682fb8729889464f61a78564ee7875d657564824", "ts_bytes": 80824}
+{"parcellation": "harvard48", "subject": "sub-control3554", "corr_path": "data/parc-harvard48/sub-control3554/sub-control3554_desc-correlation_matrix_parc-harvard48.mat", "ts_path": "data/parc-harvard48/sub-control3554/sub-control3554_desc-timeseries_parc-harvard48.mat", "correlation_matrix": [], "corr_shape": [48, 48], "ts_shape": [48], "corr_sha256": "6f68980110a9e3e8f907f50a51081b02cb5d7bed368dff5594b724e45d36f6b6", "corr_bytes": 18616, "ts_sha256": "d6619d194b39f025dd085a9923886c4e7c974d2d02b92fdab94c465a104edc87", "ts_bytes": 80824}
+{"parcellation": "harvard48", "subject": "sub-control3563", "corr_path": "data/parc-harvard48/sub-control3563/sub-control3563_desc-correlation_matrix_parc-harvard48.mat", "ts_path": "data/parc-harvard48/sub-control3563/sub-control3563_desc-timeseries_parc-harvard48.mat", "correlation_matrix": [], "corr_shape": [48, 48], "ts_shape": [48], "corr_sha256": "ceccd4954b2274f3a37e1bc5271f195d5560d5d1992ca6eea3cd7cbf63afada4", "corr_bytes": 18616, "ts_sha256": "7179321dc0b7d0bf5a7e4d48ae023b94d9d7dda9442344590f82f65438627450", "ts_bytes": 80824}

manifests/dev.parquet

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

manifests/preview.jsonl

@@ -0,0 +1,5 @@
+{"parcellation": "AAL116", "subject": "sub-control3351", "corr_path": "data/parc-AAL116/sub-control3351/sub-control3351_desc-correlation_matrix_parc-AAL116.mat", "ts_path": "data/parc-AAL116/sub-control3351/sub-control3351_desc-timeseries_parc-AAL116.mat", "correlation_matrix": [[1.0, 0.12, -0.05, 0.08, 0.02, -0.11, 0.03, 0.09], [0.12, 1.0, 0.07, -0.02, 0.05, 0.01, -0.04, 0.06], [-0.05, 0.07, 1.0, 0.14, -0.03, 0.02, 0.05, -0.01], [0.08, -0.02, 0.14, 1.0, 0.09, -0.06, 0.0, 0.04], [0.02, 0.05, -0.03, 0.09, 1.0, 0.12, -0.02, 0.01], [-0.11, 0.01, 0.02, -0.06, 0.12, 1.0, 0.15, -0.03], [0.03, -0.04, 0.05, 0.0, -0.02, 0.15, 1.0, 0.1], [0.09, 0.06, -0.01, 0.04, 0.01, -0.03, 0.1, 1.0]], "corr_shape": [116, 116], "ts_shape": [116], "corr_sha256": "53161c1ea79258bd8243b9fb923fbfb0f6c8427da8c60634e623b4c1cad73deb", "corr_bytes": 107832, "ts_sha256": "5cf79c9700df2a1875496e4edb00aa988f65de3bb6186736df7216469452f661", "ts_bytes": 195064}
+{"parcellation": "harvard48", "subject": "sub-control3351", "corr_path": "data/parc-harvard48/sub-control3351/sub-control3351_desc-correlation_matrix_parc-harvard48.mat", "ts_path": "data/parc-harvard48/sub-control3351/sub-control3351_desc-timeseries_parc-harvard48.mat", "correlation_matrix": [[1.0, 0.08, 0.02, -0.03, 0.06, 0.01, -0.02, 0.05], [0.08, 1.0, -0.04, 0.07, 0.03, -0.01, 0.04, 0.02], [0.02, -0.04, 1.0, 0.09, 0.0, 0.05, -0.03, 0.01], [-0.03, 0.07, 0.09, 1.0, 0.12, -0.05, 0.06, 0.0], [0.06, 0.03, 0.0, 0.12, 1.0, 0.08, -0.02, 0.04], [0.01, -0.01, 0.05, -0.05, 0.08, 1.0, 0.07, -0.02], [-0.02, 0.04, -0.03, 0.06, -0.02, 0.07, 1.0, 0.09], [0.05, 0.02, 0.01, 0.0, 0.04, -0.02, 0.09, 1.0]], "corr_shape": [48, 48], "ts_shape": [48], "corr_sha256": "9aa5083bddeb70b5cc443747592e117099c3143c64a497e28956d7fb189a2f8b", "corr_bytes": 18616, "ts_sha256": "69061d32f407981d5f2b2d397f839fdf2ec5b92db084deb4823b00cadadddda1", "ts_bytes": 80824}
+{"parcellation": "kmeans100", "subject": "sub-control3351", "corr_path": "data/parc-kmeans100/sub-control3351/sub-control3351_desc-correlation_matrix_parc-kmeans100.mat", "ts_path": "data/parc-kmeans100/sub-control3351/sub-control3351_desc-timeseries_parc-kmeans100.mat", "correlation_matrix": [[1.0, -0.02, 0.04, 0.06, -0.01, 0.03, 0.07, 0.02], [-0.02, 1.0, 0.01, -0.05, 0.08, 0.02, -0.03, 0.06], [0.04, 0.01, 1.0, 0.09, -0.02, 0.05, 0.0, 0.04], [0.06, -0.05, 0.09, 1.0, 0.1, -0.01, 0.03, 0.05], [-0.01, 0.08, -0.02, 0.1, 1.0, 0.06, 0.02, -0.03], [0.03, 0.02, 0.05, -0.01, 0.06, 1.0, 0.11, 0.0], [0.07, -0.03, 0.0, 0.03, 0.02, 0.11, 1.0, 0.08], [0.02, 0.06, 0.04, 0.05, -0.03, 0.0, 0.08, 1.0]], "corr_shape": [100, 100], "ts_shape": [100], "corr_sha256": "8fccda155468301de2c3ea5c3c37d9f12cd99ce8ee3a3c74d726dbe29b39d02e", "corr_bytes": 80184, "ts_sha256": "11572befea1db47daaa4c9d8671655ad483b459114643072e865d593a9579b52", "ts_bytes": 168184}
+{"parcellation": "schaefer100", "subject": "sub-control3351", "corr_path": "data/parc-schaefer100/sub-control3351/sub-control3351_desc-correlation_matrix_parc-schaefer100.mat", "ts_path": "data/parc-schaefer100/sub-control3351/sub-control3351_desc-timeseries_parc-schaefer100.mat", "correlation_matrix": [[1.0, 0.03, 0.06, -0.01, 0.02, 0.07, -0.02, 0.04], [0.03, 1.0, -0.02, 0.05, 0.04, 0.01, 0.06, 0.03], [0.06, -0.02, 1.0, 0.11, -0.03, 0.02, 0.04, 0.07], [-0.01, 0.05, 0.11, 1.0, 0.08, -0.04, 0.05, 0.02], [0.02, 0.04, -0.03, 0.08, 1.0, 0.06, -0.01, 0.05], [0.07, 0.01, 0.02, -0.04, 0.06, 1.0, 0.09, -0.02], [-0.02, 0.06, 0.04, 0.05, -0.01, 0.09, 1.0, 0.1], [0.04, 0.03, 0.07, 0.02, 0.05, -0.02, 0.1, 1.0]], "corr_shape": [100, 100], "ts_shape": [100], "corr_sha256": "186dcfed291fc4a010d339ce3cea60caf82d2ddc08962aa0c5c00294ffe16718", "corr_bytes": 80184, "ts_sha256": "43c9bf48b2cbaa83fc400be97a42fb260dc2fc7fb0b5f10e388ca6444c35734b", "ts_bytes": 168184}
+{"parcellation": "ward100", "subject": "sub-control3351", "corr_path": "data/parc-ward100/sub-control3351/sub-control3351_desc-correlation_matrix_parc-ward100.mat", "ts_path": "data/parc-ward100/sub-control3351/sub-control3351_desc-timeseries_parc-ward100.mat", "correlation_matrix": [[1.0, 0.02, -0.03, 0.05, 0.01, -0.02, 0.04, 0.06], [0.02, 1.0, 0.05, -0.01, 0.03, 0.04, -0.02, 0.07], [-0.03, 0.05, 1.0, 0.08, -0.04, 0.02, 0.06, 0.01], [0.05, -0.01, 0.08, 1.0, 0.09, -0.03, 0.02, 0.05], [0.01, 0.03, -0.04, 0.09, 1.0, 0.07, -0.01, 0.04], [-0.02, 0.04, 0.02, -0.03, 0.07, 1.0, 0.1, -0.02], [0.04, -0.02, 0.06, 0.02, -0.01, 0.1, 1.0, 0.09], [0.06, 0.07, 0.01, 0.05, 0.04, -0.02, 0.09, 1.0]], "corr_shape": [100, 100], "ts_shape": [100], "corr_sha256": "7f3a495f5de9a941b1f5bd2cfbd47b0eb51cc26c1bb3b4341b67f9edb3d13a02", "corr_bytes": 80184, "ts_sha256": "c4d6768352805ed7cf4ba0ed89152a4dff24ea5307def328caf879329c3232f6", "ts_bytes": 168184}

manifests/preview.parquet

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

parcellations.json

@@ -0,0 +1,7 @@
+{
+  "AAL116": 116,
+  "harvard48": 48,
+  "kmeans100": 100,
+  "schaefer100": 100,
+  "ward100": 100
+}

preview/AAL116__sub-control3351__corr8x8.json

@@ -0,0 +1,10 @@
+[
+  [1.0, 0.12, -0.05, 0.08, 0.02, -0.11, 0.03, 0.09],
+  [0.12, 1.0, 0.07, -0.02, 0.05, 0.01, -0.04, 0.06],
+  [-0.05, 0.07, 1.0, 0.14, -0.03, 0.02, 0.05, -0.01],
+  [0.08, -0.02, 0.14, 1.0, 0.09, -0.06, 0.0, 0.04],
+  [0.02, 0.05, -0.03, 0.09, 1.0, 0.12, -0.02, 0.01],
+  [-0.11, 0.01, 0.02, -0.06, 0.12, 1.0, 0.15, -0.03],
+  [0.03, -0.04, 0.05, 0.0, -0.02, 0.15, 1.0, 0.1],
+  [0.09, 0.06, -0.01, 0.04, 0.01, -0.03, 0.1, 1.0]
+]

preview/harvard48__sub-control3351__corr8x8.json

@@ -0,0 +1,10 @@
+[
+  [1.0, 0.08, 0.02, -0.03, 0.06, 0.01, -0.02, 0.05],
+  [0.08, 1.0, -0.04, 0.07, 0.03, -0.01, 0.04, 0.02],
+  [0.02, -0.04, 1.0, 0.09, 0.0, 0.05, -0.03, 0.01],
+  [-0.03, 0.07, 0.09, 1.0, 0.12, -0.05, 0.06, 0.0],
+  [0.06, 0.03, 0.0, 0.12, 1.0, 0.08, -0.02, 0.04],
+  [0.01, -0.01, 0.05, -0.05, 0.08, 1.0, 0.07, -0.02],
+  [-0.02, 0.04, -0.03, 0.06, -0.02, 0.07, 1.0, 0.09],
+  [0.05, 0.02, 0.01, 0.0, 0.04, -0.02, 0.09, 1.0]
+]

preview/kmeans100__sub-control3351__corr8x8.json

@@ -0,0 +1,10 @@
+[
+  [1.0, -0.02, 0.04, 0.06, -0.01, 0.03, 0.07, 0.02],
+  [-0.02, 1.0, 0.01, -0.05, 0.08, 0.02, -0.03, 0.06],
+  [0.04, 0.01, 1.0, 0.09, -0.02, 0.05, 0.0, 0.04],
+  [0.06, -0.05, 0.09, 1.0, 0.1, -0.01, 0.03, 0.05],
+  [-0.01, 0.08, -0.02, 0.1, 1.0, 0.06, 0.02, -0.03],
+  [0.03, 0.02, 0.05, -0.01, 0.06, 1.0, 0.11, 0.0],
+  [0.07, -0.03, 0.0, 0.03, 0.02, 0.11, 1.0, 0.08],
+  [0.02, 0.06, 0.04, 0.05, -0.03, 0.0, 0.08, 1.0]
+]

preview/schaefer100__sub-control3351__corr8x8.json

@@ -0,0 +1,10 @@
+[
+  [1.0, 0.03, 0.06, -0.01, 0.02, 0.07, -0.02, 0.04],
+  [0.03, 1.0, -0.02, 0.05, 0.04, 0.01, 0.06, 0.03],
+  [0.06, -0.02, 1.0, 0.11, -0.03, 0.02, 0.04, 0.07],
+  [-0.01, 0.05, 0.11, 1.0, 0.08, -0.04, 0.05, 0.02],
+  [0.02, 0.04, -0.03, 0.08, 1.0, 0.06, -0.01, 0.05],
+  [0.07, 0.01, 0.02, -0.04, 0.06, 1.0, 0.09, -0.02],
+  [-0.02, 0.06, 0.04, 0.05, -0.01, 0.09, 1.0, 0.1],
+  [0.04, 0.03, 0.07, 0.02, 0.05, -0.02, 0.1, 1.0]
+]

preview/ward100__sub-control3351__corr8x8.json

@@ -0,0 +1,10 @@
+[
+  [1.0, 0.02, -0.03, 0.05, 0.01, -0.02, 0.04, 0.06],
+  [0.02, 1.0, 0.05, -0.01, 0.03, 0.04, -0.02, 0.07],
+  [-0.03, 0.05, 1.0, 0.08, -0.04, 0.02, 0.06, 0.01],
+  [0.05, -0.01, 0.08, 1.0, 0.09, -0.03, 0.02, 0.05],
+  [0.01, 0.03, -0.04, 0.09, 1.0, 0.07, -0.01, 0.04],
+  [-0.02, 0.04, 0.02, -0.03, 0.07, 1.0, 0.1, -0.02],
+  [0.04, -0.02, 0.06, 0.02, -0.01, 0.1, 1.0, 0.09],
+  [0.06, 0.07, 0.01, 0.05, 0.04, -0.02, 0.09, 1.0]
+]

scripts/enrich_manifests.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""
+Enrich preview/dev manifests with shapes, embedded 8x8 preview matrices, and optional integrity fields.
+
+Usage:
+  python scripts/enrich_manifests.py --preview manifests/preview.jsonl --dev manifests/dev.jsonl --inventory manifests/manifest.jsonl
+
+Notes:
+  - Shapes are inferred from sidecar JSON (NodeCount). For timeseries, we record [n] if T is unknown.
+  - For preview rows, we embed 8x8 correlation matrices from precomputed preview/<parc>__<subject>__corr8x8.json files.
+  - If an inventory manifest is provided, we add sha256/bytes for corr_path/ts_path.
+"""
+import argparse
+import json
+import os
+from pathlib import Path
+from typing import Dict, Iterable, Optional
+
+
+def load_inventory(inv_path: Optional[Path]) -> Dict[str, Dict[str, object]]:
+    mapping: Dict[str, Dict[str, object]] = {}
+    if not inv_path or not inv_path.exists():
+        return mapping
+    with inv_path.open("r", encoding="utf-8") as f:
+        for line in f:
+            if not line.strip():
+                continue
+            row = json.loads(line)
+            target_rel = row.get("target_rel")
+            if not target_rel:
+                continue
+            mapping[target_rel] = {"sha256": row.get("sha256"), "bytes": row.get("bytes")}
+    return mapping
+
+
+def infer_shapes_from_sidecars(base: Path, corr_path: str, ts_path: str):
+    corr_shape = None
+    ts_shape = None
+    # correlation sidecar
+    cjson = base / (Path(corr_path).with_suffix(".json"))
+    if cjson.exists():
+        try:
+            meta = json.loads(cjson.read_text())
+            n = meta.get("NodeCount")
+            if isinstance(n, int) and n > 0:
+                corr_shape = [n, n]
+        except Exception:
+            pass
+    # timeseries sidecar
+    tjson = base / (Path(ts_path).with_suffix(".json"))
+    if tjson.exists():
+        try:
+            meta = json.loads(tjson.read_text())
+            n = meta.get("NodeCount")
+            if isinstance(n, int) and n > 0:
+                ts_shape = [n]  # T not recorded; leave unknown
+        except Exception:
+            pass
+    return corr_shape or [], ts_shape or []
+
+
+def preview_corr8(base: Path, parcellation: str, subject: str):
+    p = base / "preview" / f"{parcellation}__{subject}__corr8x8.json"
+    if p.exists():
+        try:
+            arr = json.loads(p.read_text())
+            if isinstance(arr, list):
+                return arr
+        except Exception:
+            return []
+    return []
+
+
+def enrich_file(path: Path, inventory: Dict[str, Dict[str, object]], embed_preview: bool):
+    base = path.parent.parent  # repo root
+    lines = []
+    with path.open("r", encoding="utf-8") as f:
+        for line in f:
+            if not line.strip():
+                continue
+            lines.append(json.loads(line))
+
+    out_lines = []
+    for row in lines:
+        parc = row["parcellation"]
+        subject = row["subject"]
+        corr_path = row["corr_path"]
+        ts_path = row["ts_path"]
+
+        corr_shape, ts_shape = infer_shapes_from_sidecars(base, corr_path, ts_path)
+
+        if embed_preview:
+            corr8 = preview_corr8(base, parc, subject)
+            row["correlation_matrix"] = corr8
+        else:
+            # Omit heavy arrays
+            row["correlation_matrix"] = []
+
+        row["corr_shape"] = corr_shape
+        row["ts_shape"] = ts_shape
+
+        # Integrity metadata if available
+        if corr_path in inventory:
+            row["corr_sha256"] = inventory[corr_path].get("sha256")
+            row["corr_bytes"] = inventory[corr_path].get("bytes")
+        if ts_path in inventory:
+            row["ts_sha256"] = inventory[ts_path].get("sha256")
+            row["ts_bytes"] = inventory[ts_path].get("bytes")
+
+        out_lines.append(row)
+
+    with path.open("w", encoding="utf-8") as f:
+        for r in out_lines:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--preview", type=Path, required=False, default=Path("manifests/preview.jsonl"))
+    ap.add_argument("--dev", type=Path, required=False, default=Path("manifests/dev.jsonl"))
+    ap.add_argument("--inventory", type=Path, required=False, default=Path("manifests/manifest.jsonl"))
+    args = ap.parse_args()
+
+    inv = load_inventory(args.inventory if args.inventory and args.inventory.exists() else None)
+
+    if args.preview and args.preview.exists():
+        enrich_file(args.preview, inv, embed_preview=True)
+        print(f"Enriched {args.preview}")
+    if args.dev and args.dev.exists():
+        enrich_file(args.dev, inv, embed_preview=False)
+        print(f"Enriched {args.dev}")
+
+
+if __name__ == "__main__":
+    main()
+

scripts/jsonl_to_parquet.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+"""
+Convert a JSONL file (records per line) to Parquet with a stable schema.
+
+Usage:
+  python scripts/jsonl_to_parquet.py manifests/preview.jsonl manifests/preview.parquet
+  python scripts/jsonl_to_parquet.py manifests/dev.jsonl manifests/dev.parquet
+
+Requires: pandas + pyarrow
+"""
+import argparse
+import json
+from pathlib import Path
+
+import pandas as pd
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("src", type=Path)
+    ap.add_argument("dst", type=Path)
+    args = ap.parse_args()
+
+    records = []
+    with args.src.open("r", encoding="utf-8") as f:
+        for line in f:
+            if not line.strip():
+                continue
+            records.append(json.loads(line))
+
+    # Use pandas to write parquet; let pyarrow infer nested lists
+    df = pd.DataFrame.from_records(records)
+    args.dst.parent.mkdir(parents=True, exist_ok=True)
+    df.to_parquet(args.dst, index=False)
+    print(f"Wrote {args.dst}")
+
+
+if __name__ == "__main__":
+    main()
+

scripts/make_preview.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""
+Generate precomputed 8x8 correlation previews as JSON for the preview split.
+
+Usage:
+  # From a JSONL manifest listing parcellation/subject/corr_path
+  python scripts/make_preview.py --manifest manifests/preview.jsonl --size 8
+
+Notes:
+  - Attempts to load correlation .mat using scipy.io.loadmat, falling back to mat73 if needed.
+  - Variable name fallbacks: correlation_matrix | corr | A
+  - Writes files under preview/<parc>__<subject>__corr8x8.json
+"""
+import argparse
+import json
+import os
+from pathlib import Path
+from typing import Dict, Optional
+
+
+def try_import():
+    try:
+        import scipy.io as sio  # type: ignore
+    except Exception:
+        sio = None
+    try:
+        import mat73  # type: ignore
+    except Exception:
+        mat73 = None
+    return sio, mat73
+
+
+def load_mat(path: Path) -> Optional[Dict]:
+    sio, mat73 = try_import()
+    if sio is not None:
+        try:
+            return sio.loadmat(str(path), squeeze_me=True, simplify_cells=True)  # type: ignore[arg-type]
+        except Exception:
+            pass
+    if mat73 is not None:
+        try:
+            return mat73.loadmat(str(path))  # type: ignore[attr-defined]
+        except Exception:
+            pass
+    return None
+
+
+def top_left_8x8(arr, size=8):
+    import numpy as np
+    a = np.asarray(arr)
+    if a.ndim < 2:
+        return None
+    n = min(size, a.shape[-1])
+    return a[:n, :n].astype("float32").tolist()
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--manifest", type=Path, required=True)
+    ap.add_argument("--size", type=int, default=8)
+    args = ap.parse_args()
+
+    repo = Path(__file__).resolve().parents[1]
+    out_dir = repo / "preview"
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    with args.manifest.open("r", encoding="utf-8") as f:
+        rows = [json.loads(line) for line in f if line.strip()]
+
+    wrote = 0
+    for r in rows:
+        parc = r.get("parcellation")
+        subject = r.get("subject")
+        corr_path = r.get("corr_path")
+        if not (parc and subject and corr_path):
+            continue
+        dst = out_dir / f"{parc}__{subject}__corr8x8.json"
+        if dst.exists():
+            continue
+        src = repo / corr_path
+        if not src.exists():
+            print("skip missing:", src)
+            continue
+        data = load_mat(src)
+        if not isinstance(data, dict):
+            print("cannot load .mat (no scipy/mat73?)", src)
+            continue
+        for k in ("correlation_matrix", "corr", "A"):
+            if k in data:
+                sl = top_left_8x8(data[k], size=args.size)
+                if sl is not None:
+                    with dst.open("w", encoding="utf-8") as g:
+                        json.dump(sl, g)
+                    wrote += 1
+                break
+
+    print(f"Wrote {wrote} preview tiles to {out_dir}")
+
+
+if __name__ == "__main__":
+    main()
+

scripts/scan_to_manifest.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""
+Scan data/ and create a metadata-only manifest JSONL with
+  - parcellation, subject, corr_path, ts_path
+  - corr_shape [n,n] and ts_shape [n] inferred from sidecars if available
+  - optional sha256/bytes joined from manifests/manifest.jsonl
+
+Examples:
+  python scripts/scan_to_manifest.py --out manifests/dev.jsonl --parcs AAL116,harvard48 --limit-per-parc 20
+  python scripts/scan_to_manifest.py --out manifests/all.jsonl
+"""
+import argparse
+import json
+import os
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional, Tuple
+
+
+def load_inventory(inv_path: Optional[Path]) -> Dict[str, Dict[str, object]]:
+    mapping: Dict[str, Dict[str, object]] = {}
+    if not inv_path or not inv_path.exists():
+        return mapping
+    with inv_path.open("r", encoding="utf-8") as f:
+        for line in f:
+            if not line.strip():
+                continue
+            row = json.loads(line)
+            target_rel = row.get("target_rel")
+            if not target_rel:
+                continue
+            mapping[target_rel] = {"sha256": row.get("sha256"), "bytes": row.get("bytes")}
+    return mapping
+
+
+def infer_shapes_from_sidecars(repo: Path, corr_path: str, ts_path: str):
+    corr_shape = []
+    ts_shape = []
+    cjson = repo / (Path(corr_path).with_suffix(".json"))
+    if cjson.exists():
+        try:
+            meta = json.loads(cjson.read_text())
+            n = meta.get("NodeCount")
+            if isinstance(n, int) and n > 0:
+                corr_shape = [n, n]
+        except Exception:
+            pass
+    tjson = repo / (Path(ts_path).with_suffix(".json"))
+    if tjson.exists():
+        try:
+            meta = json.loads(tjson.read_text())
+            n = meta.get("NodeCount")
+            if isinstance(n, int) and n > 0:
+                ts_shape = [n]
+        except Exception:
+            pass
+    return corr_shape, ts_shape
+
+
+def iter_subjects(repo: Path, parcs: Optional[List[str]]) -> Iterable[Tuple[str, Path]]:
+    data = repo / "data"
+    for d in sorted((data).glob("parc-*")):
+        parc = d.name[len("parc-"):]
+        if parcs and parc not in parcs:
+            continue
+        for sub in sorted(d.glob("sub-*")):
+            yield parc, sub
+
+
+def find_pair(sub_dir: Path, parc: str) -> Optional[Tuple[str, str]]:
+    # Expects files named <id>_desc-timeseries_parc-<parc>.mat and <id>_desc-correlation_matrix_parc-<parc>.mat
+    subj = sub_dir.name
+    ts = sub_dir / f"{subj}_desc-timeseries_parc-{parc}.mat"
+    cm = sub_dir / f"{subj}_desc-correlation_matrix_parc-{parc}.mat"
+    if ts.exists() and cm.exists():
+        rel_ts = str(ts.as_posix())
+        rel_cm = str(cm.as_posix())
+        # store relative to repo root
+        root = sub_dir.parents[3] if sub_dir.as_posix().endswith(subj) else sub_dir.parents[3]
+        rel_ts = os.path.relpath(ts, root)
+        rel_cm = os.path.relpath(cm, root)
+        return rel_cm.replace(os.sep, "/"), rel_ts.replace(os.sep, "/")
+    return None
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--out", type=Path, required=True, help="Output JSONL path")
+    ap.add_argument("--parcs", type=str, default="", help="Comma-separated parcellations (default: all)")
+    ap.add_argument("--limit-per-parc", type=int, default=0, help="Max rows per parcellation (0 = no limit)")
+    ap.add_argument("--inventory", type=Path, default=Path("manifests/manifest.jsonl"))
+    args = ap.parse_args()
+
+    repo = Path(__file__).resolve().parents[1]
+    inv = load_inventory(args.inventory if args.inventory and args.inventory.exists() else None)
+    parcs = [p.strip() for p in args.parcs.split(",") if p.strip()] or None
+
+    counts: Dict[str, int] = {}
+    rows: List[Dict[str, object]] = []
+
+    for parc, subdir in iter_subjects(repo, parcs):
+        if args.limit_per_parc and counts.get(parc, 0) >= args.limit_per_parc:
+            continue
+        pair = find_pair(subdir, parc)
+        if not pair:
+            continue
+        corr_path, ts_path = pair
+        corr_shape, ts_shape = infer_shapes_from_sidecars(repo, corr_path, ts_path)
+        subj = subdir.name
+
+        row: Dict[str, object] = {
+            "parcellation": parc,
+            "subject": subj,
+            "corr_path": corr_path,
+            "ts_path": ts_path,
+            "corr_shape": corr_shape,
+            "ts_shape": ts_shape,
+            "correlation_matrix": [],  # metadata-only
+        }
+        if corr_path in inv:
+            row["corr_sha256"] = inv[corr_path].get("sha256")
+            row["corr_bytes"] = inv[corr_path].get("bytes")
+        if ts_path in inv:
+            row["ts_sha256"] = inv[ts_path].get("sha256")
+            row["ts_bytes"] = inv[ts_path].get("bytes")
+
+        rows.append(row)
+        counts[parc] = counts.get(parc, 0) + 1
+
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    with args.out.open("w", encoding="utf-8") as f:
+        for r in rows:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+
+    print(f"Wrote {len(rows)} rows to {args.out}")
+
+
+if __name__ == "__main__":
+    main()
+