#!/usr/bin/env python3 """Build the public MDU-RiskText and MDU-RiskBench Hugging Face bundle. The internal experiment JSONL files contain several redundant pipeline views. This builder publishes the complete model-facing evidence packages used by the benchmark, frozen labels and splits, while replacing internal participant IDs with stable public IDs. """ from __future__ import annotations import argparse import gzip import hashlib import io import json import re import shutil from collections import Counter from pathlib import Path from typing import Any, Iterable SETTINGS = ("video_only", "non_video_only", "all_filtered_text") SPLITS = ("train", "validation", "test") RISK_LEVELS = ( "no_observed_risk", "mild_risk", "moderate_risk", "high_risk", ) SETTING_ALIASES = {"all_privacy_filtered_text": "all_filtered_text"} BLOCKED_TEXT_PATTERNS = { "developer_home": re.compile(r"/home/[A-Za-z0-9._-]+/"), "mounted_drive": re.compile(r"/mnt/[A-Za-z]/"), "windows_user": re.compile(r"[A-Za-z]:\\\\Users\\\\[^\\\\]+\\\\"), "internal_evidence_id": re.compile(r"evidence_internal_[A-Za-z0-9_-]+"), "internal_person_id": re.compile(r"\binternal_[A-Za-z0-9_-]+\b"), "source_subset": re.compile(r"strict850|schemafix", re.I), "spreadsheet": re.compile(r"\.xlsx?\b", re.I), } def compact_json(value: Any) -> str: return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")) def sha256(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as handle: for chunk in iter(lambda: handle.read(1024 * 1024), b""): digest.update(chunk) return digest.hexdigest() def write_json(path: Path, value: Any) -> None: path.parent.mkdir(parents=True, exist_ok=True) path.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") def write_text(path: Path, value: str) -> None: path.parent.mkdir(parents=True, exist_ok=True) path.write_text(value.rstrip() + "\n", encoding="utf-8") class DeterministicGzipJsonlWriter: def __init__(self, path: Path) -> None: path.parent.mkdir(parents=True, exist_ok=True) self.raw = path.open("wb") self.gz = gzip.GzipFile(filename="", mode="wb", fileobj=self.raw, mtime=0) self.text = io.TextIOWrapper(self.gz, encoding="utf-8", newline="\n") def write(self, value: Any) -> None: self.text.write(compact_json(value) + "\n") def close(self) -> None: self.text.flush() self.text.detach() self.gz.close() self.raw.close() def __enter__(self) -> "DeterministicGzipJsonlWriter": return self def __exit__(self, *_: Any) -> None: self.close() def iter_jsonl(path: Path) -> Iterable[dict[str, Any]]: with path.open(encoding="utf-8") as handle: for line_number, line in enumerate(handle, 1): if not line.strip(): continue value = json.loads(line) if not isinstance(value, dict): raise ValueError(f"{path}:{line_number}: expected a JSON object") yield value def transform_strings(value: Any, old_id: str, public_id: str) -> Any: if isinstance(value, dict): return { key: transform_strings(item, old_id, public_id) for key, item in value.items() if key not in {"internal_debug"} } if isinstance(value, list): return [transform_strings(item, old_id, public_id) for item in value] if isinstance(value, str): value = value.replace(old_id, public_id) return SETTING_ALIASES.get(value, value) return value def public_target_label(source: dict[str, Any]) -> dict[str, Any]: risk_level = source.get("risk_level") if risk_level not in RISK_LEVELS: raise ValueError(f"unexpected target label: {risk_level!r}") counts = source.get("risk_label_counts", {}) if not isinstance(counts, dict): counts = {} return { "risk_level": risk_level, "available": True, "aggregation_method": "majority_vote_over_non_insufficient_windows", "window_label_counts": { str(key): int(value) for key, value in sorted(counts.items()) if isinstance(value, (int, float)) }, } def build_record( source: dict[str, Any], setting: str, public_id: str ) -> dict[str, Any]: old_id = source.get("sample_id") if not isinstance(old_id, str): raise ValueError("record lacks sample_id") split = source.get("split") if split not in SPLITS: raise ValueError(f"unexpected split: {split!r}") package_text = source.get("text_evidence") if not isinstance(package_text, str): raise ValueError(f"{old_id}: text_evidence is not a string") package = json.loads(package_text) package = transform_strings(package, old_id, public_id) package["sample_id"] = public_id package["benchmark_setting"] = setting return { "schema_version": "mdu_risktext.participant_record.v1", "sample_id": public_id, "split": split, "target_label": public_target_label(source.get("target_label", {})), "benchmark_setting": setting, "llm_evidence_package": package, "text_evidence": compact_json(package), } def collect_sources(paths: dict[str, Path]) -> dict[str, dict[str, dict[str, Any]]]: records: dict[str, dict[str, dict[str, Any]]] = {} for setting, path in paths.items(): setting_rows: dict[str, dict[str, Any]] = {} for row in iter_jsonl(path): sample_id = row.get("sample_id") if not isinstance(sample_id, str): raise ValueError(f"{path}: record lacks a string sample_id") if sample_id in setting_rows: raise ValueError(f"{path}: duplicate sample_id {sample_id}") setting_rows[sample_id] = row records[setting] = setting_rows base_ids = set(records["video_only"]) if len(base_ids) != 850: raise ValueError(f"expected 850 participants, found {len(base_ids)}") for setting in SETTINGS: if set(records[setting]) != base_ids: raise ValueError(f"participant mismatch for {setting}") for sample_id in base_ids: base = records["video_only"][sample_id] other = records[setting][sample_id] if base.get("split") != other.get("split"): raise ValueError(f"split mismatch for {sample_id} in {setting}") if base.get("target_label", {}).get("risk_level") != other.get( "target_label", {} ).get("risk_level"): raise ValueError(f"label mismatch for {sample_id} in {setting}") return records def make_public_id_map(internal_ids: Iterable[str]) -> dict[str, str]: return { internal_id: f"MDURT_{index:06d}" for index, internal_id in enumerate(sorted(internal_ids), 1) } def dataset_card() -> str: return """--- pretty_name: MDU-RiskText and MDU-RiskBench language: - en - zh license: other task_categories: - text-classification tags: - privacy - video-to-text - ordinal-classification - youth-digital-use - evidence-grounding configs: - config_name: video_only data_files: - split: train path: MDU-RiskText/video_only/train.jsonl.gz - split: validation path: MDU-RiskText/video_only/validation.jsonl.gz - split: test path: MDU-RiskText/video_only/test.jsonl.gz - config_name: non_video_only data_files: - split: train path: MDU-RiskText/non_video_only/train.jsonl.gz - split: validation path: MDU-RiskText/non_video_only/validation.jsonl.gz - split: test path: MDU-RiskText/non_video_only/test.jsonl.gz - config_name: all_filtered_text data_files: - split: train path: MDU-RiskText/all_filtered_text/train.jsonl.gz - split: validation path: MDU-RiskText/all_filtered_text/validation.jsonl.gz - split: test path: MDU-RiskText/all_filtered_text/test.jsonl.gz --- # MDU-RiskText and MDU-RiskBench This repository contains the public 850-participant release associated with PriVTE: Privacy-Preserving Video-to-Text Evidence Encoding for Youth Digital Use Risk Screening. ## Data products - **MDU-RiskText** contains participant-level, privacy-filtered textual evidence, the frozen ordinal target, and participant-disjoint split for all 850 participants. - **MDU-RiskBench** defines the task, label order, three headline evidence settings, participant index, evaluation protocol, and reference metric code. The frozen cohort contains 9,831 selected source videos. It is split into 593 train, 131 validation, and 126 test participants. Target counts are 226 `no_observed_risk`, 432 `mild_risk`, 172 `moderate_risk`, and 20 `high_risk`. ## Load with Hugging Face Datasets ```python from datasets import load_dataset video = load_dataset("Herrieson/MDU-RiskText", "video_only") non_video = load_dataset("Herrieson/MDU-RiskText", "non_video_only") combined = load_dataset("Herrieson/MDU-RiskText", "all_filtered_text") ``` Replace `Herrieson/MDU-RiskText` if the final dataset repository uses a different owner or name. Each row includes `sample_id`, `split`, `target_label`, `benchmark_setting`, `llm_evidence_package`, and `text_evidence`. The last field is the compact JSON string supplied to the text-only model runners. ## Headline settings | Configuration | Model-facing evidence | |---|---| | `video_only` | PriVTE evidence derived from locally processed video | | `non_video_only` | Coarsened app-category, heart-rate-bin, and questionnaire-risk text | | `all_filtered_text` | PriVTE video evidence plus the coarsened auxiliary text | ## Labels and evaluation The four risk labels are ordinal in the order listed above. `insufficient_evidence` is reserved for model abstention and is not a fifth severity. The benchmark reports exact accuracy and macro-F1, together with ordinal MAE and RMSE on non-abstained predictions and prediction coverage. ## Data construction The source cohort was collected in school-based field studies involving young participants in primary, middle, and high school settings in Beijing, Zhejiang, Inner Mongolia, and other regions. Participants completed an approximately 45-minute tablet-use session. PriVTE processes source video locally and emits ordered observable-behavior evidence with quality gates, relative stages, and evidence references. Auxiliary inputs are released only as coarse categories or risk-signal bins. Each participant contributes at most 12 videos selected uniformly over source order. Every selected file was required to be nonempty, parseable, contain a video stream of known duration, and provide at least four seconds of video. The selection protocol does not replace a failed selected file with a nearby file. ## Public record design Public sample IDs (`MDURT_######`) are consistent across all three settings. The release records contain the complete model-facing evidence used by MDU-RiskBench, but omit redundant internal preprocessing/debug copies and operational provenance fields. `MANIFEST.json` reports row counts, byte sizes, and SHA-256 hashes for every release artifact. ## Intended use The resource supports research on privacy-preserving behavioral evidence, text-only ordinal screening, evidence grounding, selective prediction, and comparison with direct-video systems. The targets are field-derived screening judgments rather than clinical diagnoses. Model outputs are intended for research analysis and human review rather than automated punitive decisions. ## License and citation See `LICENSE_DATA.md` for the dataset terms and `CITATION.cff` for citation metadata. Software scripts are released under the accompanying code license; the data terms apply to MDU-RiskText and MDU-RiskBench records. """ def mdu_risktext_readme() -> str: return """# MDU-RiskText MDU-RiskText contains all 850 participant-level textual evidence records for the three headline evidence settings. Each setting is split into train, validation, and test gzip-compressed JSONL files. Every row has the following fields: - `schema_version`: public participant-record schema version; - `sample_id`: stable public participant ID shared across settings; - `split`: `train`, `validation`, or `test`; - `target_label`: ordinal risk label and aggregated window-label counts; - `benchmark_setting`: evidence configuration name; - `llm_evidence_package`: structured model-facing JSON object; - `text_evidence`: compact serialization of that same package. The public files preserve the complete model-facing inputs. They intentionally exclude redundant internal feature blocks, source paths, source filenames, internal participant IDs, and preprocessing debug views that were not supplied to benchmark models. """ def benchmark_readme() -> str: return """# MDU-RiskBench MDU-RiskBench is the benchmark definition paired with MDU-RiskText. It contains: - `benchmark.json`: cohort, labels, settings, and metric definitions; - `participants.jsonl.gz`: the frozen 850-participant index; - `prediction.schema.json`: submission record contract; - `reference_results/`: aggregate result tables when available; - `../scripts/evaluate_predictions.py`: reference evaluator; - `../scripts/verify_release.py`: integrity and alignment validator. A prediction JSONL contains one object per participant: ```json {"sample_id":"MDURT_000001","risk_level":"mild_risk"} ``` Models may additionally output `confidence`, evidence references, rationale, and review flags; the reference evaluator uses `sample_id` and `risk_level`. """ def data_license() -> str: return """# MDU-RiskText / MDU-RiskBench Data Terms Copyright (c) 2026 PriVTE contributors. Permission is granted to use, reproduce, and redistribute the released MDU-RiskText and MDU-RiskBench files for research, education, evaluation, and non-commercial development, provided that users: 1. cite the dataset and PriVTE paper; 2. do not attempt to identify or contact participants or institutions; 3. do not combine the records with external data for re-identification; 4. do not use the data or derived systems for automated punishment, disciplinary action, eligibility denial, or individual surveillance; and 5. preserve these terms and the dataset attribution in redistributions. The data are provided as-is, without warranty. These terms cover the dataset records and benchmark metadata; separately released source code may use a different software license. """ def verify_script() -> str: return r'''#!/usr/bin/env python3 """Verify MDU-RiskText/MDU-RiskBench row alignment and file hashes.""" from __future__ import annotations import gzip import hashlib import json from collections import Counter from pathlib import Path ROOT = Path(__file__).resolve().parents[1] SETTINGS = ("video_only", "non_video_only", "all_filtered_text") SPLITS = ("train", "validation", "test") def digest(path: Path) -> str: value = hashlib.sha256() with path.open("rb") as handle: for chunk in iter(lambda: handle.read(1024 * 1024), b""): value.update(chunk) return value.hexdigest() def rows(path: Path): with gzip.open(path, "rt", encoding="utf-8") as handle: for line in handle: if line.strip(): yield json.loads(line) def main() -> None: manifest = json.loads((ROOT / "MANIFEST.json").read_text(encoding="utf-8")) for entry in manifest["files"]: path = ROOT / entry["path"] if path.stat().st_size != entry["bytes"]: raise SystemExit(f"size mismatch: {entry['path']}") if digest(path) != entry["sha256"]: raise SystemExit(f"hash mismatch: {entry['path']}") identities = {} for setting in SETTINGS: current = {} for split in SPLITS: path = ROOT / "MDU-RiskText" / setting / f"{split}.jsonl.gz" for row in rows(path): if row["split"] != split or row["benchmark_setting"] != setting: raise SystemExit(f"metadata mismatch: {path}") package = row["llm_evidence_package"] if package["sample_id"] != row["sample_id"]: raise SystemExit(f"package ID mismatch: {row['sample_id']}") if json.loads(row["text_evidence"]) != package: raise SystemExit(f"text package mismatch: {row['sample_id']}") current[row["sample_id"]] = ( split, row["target_label"]["risk_level"], ) if len(current) != 850: raise SystemExit(f"{setting}: expected 850 records, got {len(current)}") if identities and current != identities: raise SystemExit(f"cross-setting identity mismatch: {setting}") identities = current split_counts = Counter(split for split, _ in identities.values()) label_counts = Counter(label for _, label in identities.values()) expected_splits = {"train": 593, "validation": 131, "test": 126} expected_labels = { "no_observed_risk": 226, "mild_risk": 432, "moderate_risk": 172, "high_risk": 20, } if dict(split_counts) != expected_splits: raise SystemExit(f"split counts differ: {dict(split_counts)}") if dict(label_counts) != expected_labels: raise SystemExit(f"label counts differ: {dict(label_counts)}") print("Verified 850 aligned participants across 3 settings and 9 data files.") if __name__ == "__main__": main() ''' def evaluator_script() -> str: return r'''#!/usr/bin/env python3 """Evaluate MDU-RiskBench participant-level prediction JSONL.""" from __future__ import annotations import argparse import gzip import json import math from collections import Counter from pathlib import Path ORDER = { "no_observed_risk": 0, "mild_risk": 1, "moderate_risk": 2, "high_risk": 3, } ABSTAIN = "insufficient_evidence" def read_jsonl(path: Path): opener = gzip.open if path.suffix == ".gz" else open with opener(path, "rt", encoding="utf-8") as handle: for line in handle: if line.strip(): yield json.loads(line) def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--gold", type=Path, required=True) parser.add_argument("--predictions", type=Path, required=True) parser.add_argument("--output", type=Path) args = parser.parse_args() gold = { row["sample_id"]: row["target_label"]["risk_level"] for row in read_jsonl(args.gold) } pred = {row["sample_id"]: row["risk_level"] for row in read_jsonl(args.predictions)} unknown = sorted(set(pred) - set(gold)) if unknown: raise SystemExit(f"unknown prediction IDs: {unknown[:5]}") labels = list(ORDER) total = len(gold) covered = [(gold[sid], pred.get(sid)) for sid in gold if pred.get(sid) in ORDER] abstained = total - len(covered) exact = sum(actual == predicted for actual, predicted in covered) distances = [abs(ORDER[actual] - ORDER[predicted]) for actual, predicted in covered] squared = [value * value for value in distances] f1_values = [] for label in labels: tp = sum(actual == label and predicted == label for actual, predicted in covered) fp = sum(actual != label and predicted == label for actual, predicted in covered) fn = sum(actual == label and predicted != label for actual, predicted in covered) precision = tp / (tp + fp) if tp + fp else 0.0 recall = tp / (tp + fn) if tp + fn else 0.0 f1_values.append( 2 * precision * recall / (precision + recall) if precision + recall else 0.0 ) n = len(covered) report = { "gold_records": total, "prediction_records": len(pred), "covered_records": n, "abstained_or_missing_records": abstained, "coverage": n / total if total else 0.0, "selective_accuracy": exact / n if n else None, "selective_macro_f1": sum(f1_values) / len(f1_values) if n else None, "ordinal_mae": sum(distances) / n if n else None, "ordinal_rmse": math.sqrt(sum(squared) / n) if n else None, "prediction_distribution": dict(sorted(Counter(pred.values()).items())), } rendered = json.dumps(report, indent=2) + "\n" if args.output: args.output.write_text(rendered, encoding="utf-8") print(rendered, end="") if __name__ == "__main__": main() ''' def prediction_schema() -> dict[str, Any]: return { "$schema": "https://json-schema.org/draft/2020-12/schema", "title": "MDU-RiskBench prediction record", "type": "object", "required": ["sample_id", "risk_level"], "properties": { "sample_id": {"type": "string", "pattern": "^MDURT_[0-9]{6}$"}, "risk_level": { "enum": [*RISK_LEVELS, "insufficient_evidence"] }, "confidence": {"enum": ["low", "medium", "high"]}, "evidence_used": {"type": "array", "items": {"type": "string"}}, "needs_human_review": {"type": "boolean"}, }, "additionalProperties": True, } def record_schema() -> dict[str, Any]: return { "$schema": "https://json-schema.org/draft/2020-12/schema", "title": "MDU-RiskText participant record", "type": "object", "required": [ "schema_version", "sample_id", "split", "target_label", "benchmark_setting", "llm_evidence_package", "text_evidence", ], "properties": { "schema_version": {"const": "mdu_risktext.participant_record.v1"}, "sample_id": {"type": "string", "pattern": "^MDURT_[0-9]{6}$"}, "split": {"enum": list(SPLITS)}, "benchmark_setting": {"enum": list(SETTINGS)}, "target_label": { "type": "object", "required": ["risk_level", "available"], "properties": {"risk_level": {"enum": list(RISK_LEVELS)}}, }, "llm_evidence_package": {"type": "object"}, "text_evidence": {"type": "string"}, }, } def benchmark_definition() -> dict[str, Any]: return { "schema_version": "mdu_riskbench.v1", "name": "MDU-RiskBench", "paired_dataset": "MDU-RiskText v1", "task": "Text-only Youth Digital Use Risk Screening", "participant_count": 850, "selected_source_video_count": 9831, "participant_disjoint_splits": True, "split_counts": {"train": 593, "validation": 131, "test": 126}, "ordinal_labels": list(RISK_LEVELS), "abstention_label": "insufficient_evidence", "label_counts": { "no_observed_risk": 226, "mild_risk": 432, "moderate_risk": 172, "high_risk": 20, }, "headline_settings": { "video_only": "PriVTE privacy-filtered video-to-text evidence", "non_video_only": ( "coarse app-category, heart-rate-bin, and questionnaire-risk text" ), "all_filtered_text": "PriVTE evidence plus coarse auxiliary text", }, "primary_metrics": [ "accuracy", "macro_f1", "ordinal_mae", "ordinal_rmse", "coverage", ], "ordinal_metric_policy": ( "MAE and RMSE are computed on predictions in the four ordinal labels; " "insufficient_evidence is reported through coverage." ), "source_video_selection": { "maximum_selected_per_participant": 12, "selection": "uniform_over_ordered_source_inventory", "minimum_video_stream_duration_seconds": 4.0, "all_selected_files_must_pass_technical_validation": True, "replacement_after_selected_file_failure": False, }, } def citation_cff() -> str: return """cff-version: 1.2.0 message: "If you use MDU-RiskText or MDU-RiskBench, please cite this dataset and the PriVTE paper." title: "MDU-RiskText and MDU-RiskBench" type: dataset authors: - name: "PriVTE Authors" version: "1.0.0" date-released: "2026-07-28" repository-code: "https://github.com/Herrieson/privte-public" """ def write_base_files(output: Path) -> None: write_text(output / "README.md", dataset_card()) write_text(output / "LICENSE_DATA.md", data_license()) write_text(output / "CITATION.cff", citation_cff()) write_text(output / "MDU-RiskText" / "README.md", mdu_risktext_readme()) write_text(output / "MDU-RiskBench" / "README.md", benchmark_readme()) write_json(output / "MDU-RiskText" / "record.schema.json", record_schema()) write_json(output / "MDU-RiskBench" / "benchmark.json", benchmark_definition()) write_json( output / "MDU-RiskBench" / "prediction.schema.json", prediction_schema() ) write_text(output / "scripts" / "verify_release.py", verify_script()) write_text(output / "scripts" / "evaluate_predictions.py", evaluator_script()) shutil.copy2(Path(__file__).resolve(), output / "scripts" / "build_release.py") def copy_reference_results(source: Path | None, output: Path) -> None: if source is None or not source.exists(): return destination = output / "MDU-RiskBench" / "reference_results" destination.mkdir(parents=True, exist_ok=True) for name in ( "trained_video_only_baselines.csv", "trained_video_only_baselines.json", "llm_full_matrix.csv", "llm_full_matrix.json", "llm_setting_means.csv", "llm_setting_means.json", "direct_video_comparison.csv", "direct_video_comparison.json", ): candidate = source / name if candidate.exists(): shutil.copy2(candidate, destination / name) def audit_text(value: Any, context: str) -> None: rendered = compact_json(value) for name, pattern in BLOCKED_TEXT_PATTERNS.items(): match = pattern.search(rendered) if match: raise ValueError(f"{context}: blocked {name}: {match.group(0)!r}") def build(args: argparse.Namespace) -> None: output = args.output.resolve() if output.exists(): if not args.overwrite: raise SystemExit(f"output exists; pass --overwrite: {output}") shutil.rmtree(output) output.mkdir(parents=True) paths = { "video_only": args.video_only.resolve(), "non_video_only": args.non_video_only.resolve(), "all_filtered_text": args.all_filtered_text.resolve(), } records = collect_sources(paths) public_ids = make_public_id_map(records["video_only"]) writers = { (setting, split): DeterministicGzipJsonlWriter( output / "MDU-RiskText" / setting / f"{split}.jsonl.gz" ) for setting in SETTINGS for split in SPLITS } participant_writer = DeterministicGzipJsonlWriter( output / "MDU-RiskBench" / "participants.jsonl.gz" ) row_counts: Counter[tuple[str, str]] = Counter() split_counts: Counter[str] = Counter() label_counts: Counter[str] = Counter() try: for internal_id in sorted(public_ids): public_id = public_ids[internal_id] base = records["video_only"][internal_id] split = base["split"] target = public_target_label(base["target_label"]) participant_writer.write( { "sample_id": public_id, "split": split, "target_label": target, } ) split_counts[split] += 1 label_counts[target["risk_level"]] += 1 for setting in SETTINGS: record = build_record(records[setting][internal_id], setting, public_id) audit_text(record, f"{setting}/{public_id}") writers[(setting, split)].write(record) row_counts[(setting, split)] += 1 finally: participant_writer.close() for writer in writers.values(): writer.close() expected_splits = {"train": 593, "validation": 131, "test": 126} expected_labels = { "no_observed_risk": 226, "mild_risk": 432, "moderate_risk": 172, "high_risk": 20, } if dict(split_counts) != expected_splits: raise ValueError(f"unexpected split counts: {dict(split_counts)}") if dict(label_counts) != expected_labels: raise ValueError(f"unexpected label counts: {dict(label_counts)}") write_base_files(output) copy_reference_results(args.reference_results, output) files = [] for path in sorted(output.rglob("*")): if not path.is_file() or path.name == "MANIFEST.json": continue relative = path.relative_to(output).as_posix() entry: dict[str, Any] = { "path": relative, "bytes": path.stat().st_size, "sha256": sha256(path), } if path.name.endswith(".jsonl.gz"): if relative == "MDU-RiskBench/participants.jsonl.gz": entry["rows"] = 850 else: parts = path.relative_to(output / "MDU-RiskText").parts setting = parts[0] split = path.name.removesuffix(".jsonl.gz") entry["rows"] = row_counts[(setting, split)] files.append(entry) manifest = { "schema_version": "mdu_risk_huggingface_release_manifest.v1", "release_version": "1.0.0", "participant_count": 850, "selected_source_video_count": 9831, "settings": list(SETTINGS), "split_counts": expected_splits, "label_counts": expected_labels, "files": files, } write_json(output / "MANIFEST.json", manifest) print(f"Built Hugging Face release at {output}") print(f"Participants: {sum(split_counts.values())}") print(f"Compressed bundle bytes: {sum(p.stat().st_size for p in output.rglob('*') if p.is_file())}") def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser() parser.add_argument("--video-only", type=Path, required=True) parser.add_argument("--non-video-only", type=Path, required=True) parser.add_argument("--all-filtered-text", type=Path, required=True) parser.add_argument("--reference-results", type=Path) parser.add_argument("--output", type=Path, required=True) parser.add_argument("--overwrite", action="store_true") return parser.parse_args() if __name__ == "__main__": build(parse_args())