Update arrow files

decrypt_after_load.py

@@ -35,6 +35,8 @@ from datasets import load_dataset, load_from_disk, Dataset
 from PIL import Image
 from typing import Dict, Any
 import os
+import multiprocessing
+
 
 def derive_key(password: str, length: int) -> bytes:
     """Derive encryption key from password using SHA-256."""
@@ -105,72 +107,95 @@ def decrypt_sample(sample: Dict[str, Any], canary: str) -> Dict[str, Any]:
 
     return decrypted_sample
 
-def decrypt_dataset(encrypted_dataset: Dataset, canary: str, output_path: str = None) -> Dataset:
+def decrypt_dataset(
+    encrypted_dataset: Dataset,
+    canary: str,
+    output_path: str = None,
+    num_proc: int = None,
+    batch_size: int = 1000,
+) -> Dataset:
     """
     Decrypt an already-loaded dataset object.
-    
+
     Args:
         encrypted_dataset: Already loaded Dataset object to decrypt
         canary: Canary string used for encryption
         output_path: Path to save decrypted dataset (optional)
-    
-    Returns:
-        Decrypted Dataset object
+        num_proc: Number of processes for parallel decryption (defaults to CPU count)
+        batch_size: Batch size for Dataset.map
     """
     if not isinstance(encrypted_dataset, Dataset):
         raise TypeError(f"Expected Dataset object, got {type(encrypted_dataset)}")
     
+    if num_proc is None:
+        # Leave 1 core free so your machine stays responsive
+        cpu_count = multiprocessing.cpu_count()
+        num_proc = max(1, cpu_count - 1)
+
     print(f"📊 Dataset contains {len(encrypted_dataset)} samples")
     print(f"🔧 Features: {list(encrypted_dataset.features.keys())}")
     print(f"🔑 Using canary string: {canary}")
+    print(f"🧵 Using {num_proc} processes, batch_size={batch_size}")
 
-    # Decrypt the dataset using map function for efficiency
-    print(f"🔄 Decrypting dataset...")
-    
+    # Vectorized batch decryption (column-wise)
     def decrypt_batch(batch):
-        """Decrypt a batch of samples."""
-        # Get the number of samples in the batch
-        num_samples = len(batch[list(batch.keys())[0]])
-        
-        # Process each sample in the batch
-        decrypted_batch = {key: [] for key in batch.keys()}
-        
-        for i in range(num_samples):
-            # Extract single sample from batch
-            sample = {key: batch[key][i] for key in batch.keys()}
-            
-            # Decrypt sample
-            decrypted_sample = decrypt_sample(sample, canary)
-            
-            # Add to decrypted batch
-            for key in decrypted_batch.keys():
-                decrypted_batch[key].append(decrypted_sample.get(key))
+        decrypted_batch = dict(batch)  # shallow copy
         
+        text_fields = ['question', 'video_url', 'arxiv_id']
+        for field in text_fields:
+            if field in batch:
+                decrypted_batch[field] = [
+                    decrypt_text(x, canary) if x else x
+                    for x in batch[field]
+                ]
+
+        # answer: list[list[str]]
+        if 'answer' in batch:
+            decrypted_answers = []
+            for answers in batch['answer']:
+                if answers:
+                    decrypted_answers.append([
+                        decrypt_text(a, canary) if a else a
+                        for a in answers
+                    ])
+                else:
+                    decrypted_answers.append(answers)
+            decrypted_batch['answer'] = decrypted_answers
+
+        # Images are kept as-is (not encrypted)
         return decrypted_batch
-    
-    # Apply decryption with batching
+
+    print("🔄 Decrypting dataset with multiprocessing...")
     decrypted_dataset = encrypted_dataset.map(
         decrypt_batch,
         batched=True,
-        batch_size=50,
-        desc="Decrypting samples"
+        batch_size=batch_size,
+        num_proc=num_proc,
+        desc="Decrypting samples",
     )
 
-    print(f"✅ Decryption completed!")
+    print("✅ Decryption completed!")
     print(f"📝 Decrypted {len(decrypted_dataset)} samples")
-    print(f"🔓 Text fields decrypted: question, answer, video_url, arxiv_id")
-    print(f"🖼️ Images: kept as-is (not encrypted in current version)")
-    print(f"📋 Metadata preserved: category, difficulty, subtask, etc.")
+    print("🔓 Text fields decrypted: question, answer, video_url, arxiv_id")
+    print("🖼️ Images: kept as-is (not encrypted in current version)")
+    print("📋 Metadata preserved: category, difficulty, subtask, etc.")
 
-    # Save if output path provided
     if output_path:
         print(f"💾 Saving decrypted dataset to: {output_path}")
         decrypted_dataset.save_to_disk(output_path)
-        print(f"✅ Saved successfully!")
+        print("✅ Saved successfully!")
     
     return decrypted_dataset
 
-def decrypt_mmsearch_plus(dataset_path: str, canary: str, output_path: str = None, from_hub: bool = False):
+
+def decrypt_mmsearch_plus(
+    dataset_path: str,
+    canary: str,
+    output_path: str = None,
+    from_hub: bool = False,
+    num_proc: int = None,
+    batch_size: int = 1000,
+):
     """
     Load and decrypt the MMSearch-Plus dataset.
     
@@ -179,6 +204,8 @@ def decrypt_mmsearch_plus(dataset_path: str, canary: str, output_path: str = Non
         canary: Canary string used for encryption
         output_path: Path to save decrypted dataset (optional)
         from_hub: Whether to load from HuggingFace Hub (default: auto-detect)
+        num_proc: Number of processes for parallel decryption
+        batch_size: Batch size for Dataset.map
     """
     # Auto-detect if loading from hub (contains "/" and doesn't exist locally)
     if not from_hub:
@@ -187,17 +214,21 @@ def decrypt_mmsearch_plus(dataset_path: str, canary: str, output_path: str = Non
     # Load the encrypted dataset
     if from_hub:
         print(f"🔓 Loading encrypted dataset from HuggingFace Hub: {dataset_path}")
-        # Load from HuggingFace Hub without trust_remote_code
         encrypted_dataset = load_dataset(dataset_path, split='train')
     else:
         print(f"🔓 Loading encrypted dataset from local path: {dataset_path}")
-        # Check if path exists
         if not Path(dataset_path).exists():
             raise ValueError(f"Dataset path does not exist: {dataset_path}")
         encrypted_dataset = load_from_disk(dataset_path)
 
-    # Use decrypt_dataset to handle the actual decryption
-    return decrypt_dataset(encrypted_dataset, canary, output_path)
+    return decrypt_dataset(
+        encrypted_dataset,
+        canary,
+        output_path=output_path,
+        num_proc=num_proc,
+        batch_size=batch_size,
+    )
+
 
 def main():
     parser = argparse.ArgumentParser(
@@ -266,4 +297,3 @@ Examples:
 
 if __name__ == "__main__":
     main()
-