Add HERBench.py (capitalized) for HF dataset loader

HuggingFace expects the loading script filename to match the dataset name.
Since the repo is DanBenAmi/HERBench, the script should be HERBench.py.

Keeping both herbench.py (lowercase) and HERBench.py (capitalized) for
compatibility.

HERBench.py

@@ -0,0 +1,194 @@
+"""
+HERBench Hugging Face Datasets loading script.
+
+Why this file exists:
+- Hugging Face Dataset Viewer auto-parses JSON files if no loading script is detected.
+- Auto-parsing uses pandas->pyarrow inference and can fail when nested fields (like `metadata`)
+  have inconsistent shapes across rows (common in multi-task benchmarks).
+- By providing a proper datasets loading script named after the repo (`herbench.py` for HERBench),
+  the Hub will use this builder instead, with an explicit, stable schema.
+
+This script ensures streaming compatibility and robust schema handling for the Dataset Viewer.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, Iterator
+
+import datasets
+
+
+_DESCRIPTION = """\
+HERBench: A Benchmark for Multi-Evidence Integration in Video Question Answering.
+
+This dataset contains multiple-choice questions grounded in long videos and designed to
+require integration of multiple temporally separated cues (high evidential requirement).
+"""
+
+_HOMEPAGE = "https://github.com/DanBenAmi/HERBench"
+_LICENSE = "CC-BY-NC-SA-4.0"
+
+_CITATION = """\
+@article{herbench2025,
+  title={HERBench: A Benchmark for Multi-Evidence Integration in Video Question Answering},
+  author={Ben-Ami, Dan and Serussi, Gabriele and Cohen, Kobi and Baskin, Chaim},
+  journal={arXiv preprint arXiv:XXXX.XXXXX},
+  year={2025}
+}
+"""
+
+_VERSION = "1.0.3"
+
+
+class HERBenchConfig(datasets.BuilderConfig):
+    """BuilderConfig for HERBench."""
+    pass
+
+
+class HERBench(datasets.GeneratorBasedBuilder):
+    """HERBench Dataset: Multi-Evidence Integration in Video QA."""
+
+    VERSION = datasets.Version(_VERSION)
+
+    BUILDER_CONFIGS = [
+        HERBenchConfig(
+            name="full",
+            version=VERSION,
+            description="Full HERBench dataset (27,936 questions; 335 videos; ~161GB).",
+        ),
+        HERBenchConfig(
+            name="lite",
+            version=VERSION,
+            description="HERBench-Lite subset (~5,600 questions; ~67 videos; ~35GB for quick prototyping).",
+        ),
+    ]
+
+    # Make the Hub viewer default to the smaller config (faster and less error-prone).
+    DEFAULT_CONFIG_NAME = "lite"
+
+    def _info(self) -> datasets.DatasetInfo:
+        """
+        Define the dataset schema with strict, stable types for all fields.
+
+        IMPORTANT: Keep features stable across all rows.
+        `metadata` in the raw JSON varies by task (different keys / nested lists).
+        To keep the schema consistent for Arrow + Dataset Viewer:
+        - Expose common metadata fields as flat, typed columns
+        - Store the full raw metadata dict as a JSON string in `metadata_json`
+        """
+        features = datasets.Features(
+            {
+                # Core fields
+                "question_id": datasets.Value("string"),
+                "video_id": datasets.Value("string"),
+                "video_path": datasets.Value("string"),
+                "question": datasets.Value("string"),
+                "choices": datasets.Sequence(datasets.Value("string")),
+                "answer": datasets.Value("string"),
+                "answer_index": datasets.Value("int32"),
+                "answer_text": datasets.Value("string"),
+                "task_type": datasets.Value("string"),
+
+                # Common metadata fields (flat, typed)
+                "source_dataset": datasets.Value("string"),
+                "duration": datasets.Value("float32"),
+                "resolution": datasets.Value("string"),
+
+                # Full raw metadata as JSON string (stable schema)
+                "metadata_json": datasets.Value("string"),
+            }
+        )
+
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            citation=_CITATION,
+            version=self.VERSION,
+        )
+
+    def _split_generators(self, dl_manager: datasets.DownloadManager):
+        """
+        Define data splits. Downloads only the JSON annotations for streaming efficiency.
+        Videos are referenced by path but not downloaded during viewer loading.
+        """
+        if self.config.name == "lite":
+            annotations_file = "data/herbench_annotations_lite.json"
+        else:
+            annotations_file = "data/herbench_annotations.json"
+
+        # Download only annotations (not videos) for Dataset Viewer efficiency
+        data_files = dl_manager.download(
+            {
+                "annotations": annotations_file,
+            }
+        )
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={"annotations_file": data_files["annotations"]},
+            )
+        ]
+
+    def _generate_examples(self, annotations_file: str) -> Iterator[tuple[int, Dict[str, Any]]]:
+        """
+        Yield examples from the annotations file with robust type handling.
+
+        This method ensures:
+        - Streaming compatibility (processes one example at a time)
+        - Stable schema (all fields have consistent types)
+        - Defensive parsing (handles missing/malformed fields gracefully)
+        """
+        with open(annotations_file, encoding="utf-8") as f:
+            annotations = json.load(f)
+
+        for idx, ann in enumerate(annotations):
+            # Extract and normalize metadata
+            md = ann.get("metadata")
+            if md is None or not isinstance(md, dict):
+                # Defensive: ensure metadata is always a dict
+                md = {}
+
+            # Extract common metadata fields with defaults
+            source_dataset = md.get("source_dataset", "unknown")
+            duration = md.get("duration", 0.0)
+            resolution = md.get("resolution", "unknown")
+
+            # Normalize numeric types to avoid Arrow type inference issues
+            try:
+                duration_f = float(duration) if duration is not None else 0.0
+            except (ValueError, TypeError):
+                duration_f = 0.0
+
+            # Normalize choices field
+            choices = ann.get("choices", [])
+            if not isinstance(choices, list):
+                choices = []
+
+            # Normalize answer_index
+            answer_index = ann.get("answer_index", 0)
+            try:
+                answer_index = int(answer_index) if answer_index is not None else 0
+            except (ValueError, TypeError):
+                answer_index = 0
+
+            yield idx, {
+                "question_id": str(ann.get("question_id", f"HER_{idx:06d}")),
+                "video_id": str(ann.get("video_id", "")),
+                "video_path": str(ann.get("video_path", "")),
+                "question": str(ann.get("question", "")),
+                "choices": [str(x) for x in choices],
+                "answer": str(ann.get("answer", "")),
+                "answer_index": answer_index,
+                "answer_text": str(ann.get("answer_text", "")),
+                "task_type": str(ann.get("task_type", "unknown")),
+                "source_dataset": str(source_dataset),
+                "duration": duration_f,
+                "resolution": str(resolution),
+                "metadata_json": json.dumps(md, ensure_ascii=False),
+            }
+
+