Update MMSearch-Plus dataset with encrypted text fields (images unchanged)

README.md

@@ -9,6 +9,11 @@ tags:
 - Multimodal Long Context
 size_categories:
 - n<1K
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: "*.arrow"
 dataset_info:
   features:
   - name: question
@@ -64,7 +69,7 @@ Official repository for the paper "[MMSearch-Plus: Benchmarking Provenance-Aware
 
 ## Usage
 
-**⚠️ Important: Text fields in this dataset are encrypted to prevent data contamination. Images are NOT encrypted and remain accessible. Decryption of text is handled transparently by the dataset loader.**
+**⚠️ Important: This dataset is encrypted to prevent data contamination. However, decryption is handled transparently by the dataset loader.**
 
 ### Dataset Usage
 
@@ -72,13 +77,22 @@ Load the dataset with automatic decryption using your canary string:
 
 ```python
 import os
+from huggingface_hub import hf_hub_download
 from datasets import load_dataset
 
 # Set the canary string (hint: it's the name of this repo without username)
 os.environ['MMSEARCH_PLUS'] = 'your_canary_string'
 
-# Load dataset with transparent decryption
-dataset = load_dataset("Cie1/MMSearch-Plus", trust_remote_code=True)
+# Download the custom data loader script
+script_path = hf_hub_download(
+    repo_id="Cie1/MMSearch-Plus",
+    filename="mmsearch_plus.py",
+    repo_type="dataset",
+    revision="main",                # pin if needed
+)
+
+# Load dataset with transparent decryption using the custom loader
+dataset = load_dataset(script_path, trust_remote_code=True)
 
 # Explore the dataset - everything is already decrypted!
 print(f"Dataset size: {len(dataset['train'])}")

mmsearch_plus.py

@@ -1,15 +1,12 @@
-"""MMSearch-Plus dataset with transparent decryption.
-
-Note: Only text fields (question, answer, video_url, arxiv_id) are encrypted.
-Images are NOT encrypted and remain as PIL Image objects for accessibility.
-"""
+"""MMSearch-Plus dataset with transparent decryption."""
 
 import base64
 import hashlib
+import io
 import os
-from typing import Dict, Any
+from typing import Dict, Any, List
 import datasets
-from datasets import GeneratorBasedBuilder, DatasetInfo, SplitGenerator, Features, Value, Sequence, Image, Split
+from PIL import Image
 
 _CITATION = """\
 @article{tao2025mmsearch,
@@ -30,6 +27,13 @@ _HOMEPAGE = "https://mmsearch-plus.github.io/"
 
 _LICENSE = "CC BY-NC 4.0"
 
+_URLS = {
+    "train": [
+        "data-00000-of-00002.arrow",
+        "data-00001-of-00002.arrow"
+    ]
+}
+
 def derive_key(password: str, length: int) -> bytes:
     """Derive encryption key from password using SHA-256."""
     hasher = hashlib.sha256()
@@ -37,6 +41,23 @@ def derive_key(password: str, length: int) -> bytes:
     key = hasher.digest()
     return key * (length // len(key)) + key[: length % len(key)]
 
+def decrypt_image(ciphertext_b64: str, password: str) -> Image.Image:
+    """Decrypt base64-encoded encrypted image bytes back to PIL Image."""
+    if not ciphertext_b64:
+        return None
+
+    try:
+        encrypted = base64.b64decode(ciphertext_b64)
+        key = derive_key(password, len(encrypted))
+        decrypted = bytes([a ^ b for a, b in zip(encrypted, key)])
+
+        # Convert bytes back to PIL Image
+        img_buffer = io.BytesIO(decrypted)
+        image = Image.open(img_buffer)
+        return image
+    except Exception:
+        return None
+
 def decrypt_text(ciphertext_b64: str, password: str) -> str:
     """Decrypt base64-encoded ciphertext using XOR cipher with derived key."""
     if not ciphertext_b64:
@@ -50,76 +71,82 @@ def decrypt_text(ciphertext_b64: str, password: str) -> str:
     except Exception:
         return ciphertext_b64
 
-def decrypt_example(example: Dict[str, Any], canary: str) -> Dict[str, Any]:
-    """Decrypt text fields in a single example."""
-    # Decrypt text fields - matches encryption script fields
-    text_fields = ['question', 'video_url', 'arxiv_id']
-    
-    for field in text_fields:
-        if field in example and example[field]:
-            example[field] = decrypt_text(example[field], canary)
-    
-    # Handle answer field (list of strings)
-    if 'answer' in example and example['answer']:
-        decrypted_answers = []
-        for answer in example['answer']:
-            if answer:
-                decrypted_answers.append(decrypt_text(answer, canary))
-            else:
-                decrypted_answers.append(answer)
-        example['answer'] = decrypted_answers
-    
-    # Images are NOT encrypted - they remain as PIL Image objects
-    return example
-
-class MmsearchPlus(GeneratorBasedBuilder):
-    """MMSearch-Plus dataset builder with transparent decryption."""
+class MmsearchPlus(datasets.GeneratorBasedBuilder):
+    """MMSearch-Plus dataset with transparent decryption."""
 
     VERSION = datasets.Version("1.0.0")
 
     def _info(self):
-        return DatasetInfo(
+        # Define features to handle the complete dataset schema
+        features = datasets.Features({
+            "question": datasets.Value("string"),
+            "answer": datasets.Sequence(datasets.Value("string")),
+            "num_images": datasets.Value("int64"),
+            "arxiv_id": datasets.Value("string"),
+            "video_url": datasets.Value("string"),
+            "category": datasets.Value("string"),
+            "difficulty": datasets.Value("string"),
+            "subtask": datasets.Value("string"),
+            # Image fields (not encrypted, kept as PIL Images)
+            "img_1": datasets.Image(),
+            "img_2": datasets.Image(),
+            "img_3": datasets.Image(),
+            "img_4": datasets.Image(),
+            "img_5": datasets.Image(),
+            # Additional fields that might exist in the dataset
+            "choices": datasets.Sequence(datasets.Value("string")),
+            "question_zh": datasets.Value("string"),
+            "answer_zh": datasets.Sequence(datasets.Value("string")),
+            "regex": datasets.Value("string"),
+            "text_criteria": datasets.Value("string"),
+            "original_filename": datasets.Value("string"),
+            "screenshots_dir": datasets.Value("string"),
+            "time_points": datasets.Sequence(datasets.Value("string")),
+            "search_query": datasets.Value("string"),
+            "question_type": datasets.Value("string"),
+            "requires_image_understanding": datasets.Value("bool"),
+            "source": datasets.Value("string"),
+            "content_keywords": datasets.Value("string"),
+            "reasoning": datasets.Value("string"),
+            "processed_at": datasets.Value("string"),
+            "model_used": datasets.Value("string"),
+            "entry_index": datasets.Value("int64"),
+            "original_image_paths": datasets.Sequence(datasets.Value("string")),
+            "masked_image_paths": datasets.Sequence(datasets.Value("string")),
+            "is_valid": datasets.Value("bool"),
+        })
+
+        return datasets.DatasetInfo(
             description=_DESCRIPTION,
-            features=Features({
-                "question": Value("string"),
-                "answer": Sequence(Value("string")),
-                "num_images": Value("int64"),
-                "arxiv_id": Value("string"),
-                "video_url": Value("string"),
-                "category": Value("string"),
-                "difficulty": Value("string"),
-                "subtask": Value("string"),
-                "img_1": Image(),
-                "img_2": Image(),
-                "img_3": Image(),
-                "img_4": Image(),
-                "img_5": Image(),
-            }),
+            features=features,
             homepage=_HOMEPAGE,
             license=_LICENSE,
             citation=_CITATION,
         )
 
     def _split_generators(self, dl_manager):
-        # Get canary from environment variable
+        # Get canary from environment variable or kwargs
         canary = os.environ.get("MMSEARCH_PLUS")
-        
+
+        # Check if passed in the builder's initialization
+        if hasattr(self, 'canary'):
+            canary = self.canary
+
         if not canary:
             raise ValueError(
-                "\n\n⚠️  Canary string is required for decryption!\n\n"
-                "Please set the environment variable before loading:\n"
-                "    import os\n"
-                "    os.environ['MMSEARCH_PLUS'] = 'your_canary_string'\n\n"
-                "Hint: The canary is the name of this dataset repository (without the username).\n"
+                "Canary string is required for decryption. Either set the MMSEARCH_PLUS "
+                "environment variable or pass it via the dataset loading kwargs. "
+                "Example: load_dataset('path/to/dataset', trust_remote_code=True) after setting "
+                "os.environ['MMSEARCH_PLUS'] = 'your_canary_string'"
             )
-        
-        # Download arrow files
-        urls = ["data-00000-of-00002.arrow", "data-00001-of-00002.arrow"]
+
+        # Download files
+        urls = _URLS["train"]
         downloaded_files = dl_manager.download(urls)
-        
+
         return [
-            SplitGenerator(
-                name=Split.TRAIN,
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
                 gen_kwargs={
                     "filepaths": downloaded_files,
                     "canary": canary,
@@ -129,21 +156,34 @@ class MmsearchPlus(GeneratorBasedBuilder):
 
     def _generate_examples(self, filepaths, canary):
         """Generate examples with transparent decryption."""
-        import sys
-        print(f"🔓 [MMSearch-Plus] Decrypting dataset with canary: {canary[:10]}...", file=sys.stderr)
-        
         key = 0
+
         for filepath in filepaths:
-            # Load the arrow file directly
+            # Load the arrow file
             arrow_dataset = datasets.Dataset.from_file(filepath)
-            
+
             for idx in range(len(arrow_dataset)):
                 example = arrow_dataset[idx]
-                
-                # Apply decryption
-                example = decrypt_example(example, canary)
-                
+
+                # Decrypt text fields - matches encryption script fields
+                text_fields = ['question', 'video_url', 'arxiv_id']
+
+                for field in text_fields:
+                    if example.get(field):
+                        example[field] = decrypt_text(example[field], canary)
+
+                # Handle answer field (list of strings)
+                if example.get("answer"):
+                    decrypted_answers = []
+                    for answer in example["answer"]:
+                        if answer:
+                            decrypted_answers.append(decrypt_text(answer, canary))
+                        else:
+                            decrypted_answers.append(answer)
+                    example["answer"] = decrypted_answers
+
+                # Images are not encrypted - they remain as PIL Image objects
+                # No image decryption needed as per the encryption script
+
                 yield key, example
-                key += 1
-        
-        print(f"✅ [MMSearch-Plus] Decrypted {key} samples successfully!", file=sys.stderr)
+                key += 1