Refactor dependencies and clean up whitespace in paddleocr-vl.py

paddleocr-vl.py

@@ -2,7 +2,7 @@
 # requires-python = ">=3.11"
 # dependencies = [
 #     "datasets",
-#     "huggingface-hub[hf_transfer]",
+#     "huggingface-hub",
 #     "pillow",
 #     "vllm",
 #     "tqdm",
@@ -97,19 +97,19 @@ def smart_resize(
 ) -> tuple[int, int]:
     """
     PaddleOCR-VL's intelligent resize logic.
-    
+
     Rescales the image so that:
     1. Both dimensions are divisible by 'factor' (28)
     2. Total pixels are within [min_pixels, max_pixels]
     3. Aspect ratio is maintained as closely as possible
-    
+
     Args:
         height: Original image height
         width: Original image width
         factor: Dimension divisibility factor (default: 28)
         min_pixels: Minimum total pixels (default: 100,880)
         max_pixels: Maximum total pixels (default: 1,003,520)
-    
+
     Returns:
         Tuple of (new_height, new_width)
     """
@@ -126,10 +126,10 @@ def smart_resize(
             f"Extreme aspect ratio detected: {max(height, width) / min(height, width):.1f}"
         )
         # Continue anyway, but warn about potential issues
-    
+
     h_bar = round(height / factor) * factor
     w_bar = round(width / factor) * factor
-    
+
     if h_bar * w_bar > max_pixels:
         beta = math.sqrt((height * width) / max_pixels)
         h_bar = math.floor(height / beta / factor) * factor
@@ -138,7 +138,7 @@ def smart_resize(
         beta = math.sqrt(min_pixels / (height * width))
         h_bar = math.ceil(height * beta / factor) * factor
         w_bar = math.ceil(width * beta / factor) * factor
-    
+
     return h_bar, w_bar
 
 
@@ -149,7 +149,7 @@ def make_ocr_message(
 ) -> List[Dict]:
     """
     Create chat message for PaddleOCR-VL processing.
-    
+
     PaddleOCR-VL expects a specific format with the task prefix after the image.
     """
     # Convert to PIL Image if needed
@@ -164,7 +164,7 @@ def make_ocr_message(
 
     # Convert to RGB
     pil_img = pil_img.convert("RGB")
-    
+
     # Apply smart resize if requested
     if apply_smart_resize:
         original_size = pil_img.size
@@ -207,7 +207,7 @@ def create_dataset_card(
 ) -> str:
     """Create a dataset card documenting the OCR process."""
     task_description = TASK_DESCRIPTIONS[task_mode]
-    
+
     return f"""---
 tags:
 - ocr
@@ -334,59 +334,59 @@ def main(
     output_column: str = None,
 ):
     """Process images from HF dataset through PaddleOCR-VL model."""
-    
+
     # Check CUDA availability first
     check_cuda_availability()
-    
+
     # Track processing start time
     start_time = datetime.now()
-    
+
     # Enable HF_TRANSFER for faster downloads
     os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
-    
+
     # Login to HF if token provided
     HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
     if HF_TOKEN:
         login(token=HF_TOKEN)
-    
+
     # Validate task mode
     if task_mode not in TASK_MODES:
         raise ValueError(
             f"Invalid task_mode '{task_mode}'. Choose from: {list(TASK_MODES.keys())}"
         )
-    
+
     # Auto-generate output column name based on task mode
     if output_column is None:
         output_column = f"paddleocr_{task_mode}"
-    
+
     logger.info(f"Using task mode: {task_mode} - {TASK_DESCRIPTIONS[task_mode]}")
     logger.info(f"Output will be written to column: {output_column}")
-    
+
     # Load dataset
     logger.info(f"Loading dataset: {input_dataset}")
     dataset = load_dataset(input_dataset, split=split)
-    
+
     # Validate image column
     if image_column not in dataset.column_names:
         raise ValueError(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
-    
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
         dataset = dataset.shuffle(seed=seed)
-    
+
     # Limit samples if requested
     if max_samples:
         dataset = dataset.select(range(min(max_samples, len(dataset))))
         logger.info(f"Limited to {len(dataset)} samples")
-    
+
     # Initialize vLLM model
     model_name = "PaddlePaddle/PaddleOCR-VL"
     logger.info(f"Initializing vLLM with {model_name}")
     logger.info("This may take a minute on first run (model is only 0.9B)...")
-    
+
     llm = LLM(
         model=model_name,
         trust_remote_code=True,
@@ -394,20 +394,20 @@ def main(
         gpu_memory_utilization=gpu_memory_utilization,
         limit_mm_per_prompt={"image": 1},
     )
-    
+
     # Sampling parameters - deterministic for OCR
     sampling_params = SamplingParams(
         temperature=temperature,
         max_tokens=max_tokens,
     )
-    
+
     logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
     if apply_smart_resize:
         logger.info("Smart resize enabled (PaddleOCR-VL's adaptive resolution)")
-    
+
     # Process images in batches
     all_outputs = []
-    
+
     for batch_indices in tqdm(
         partition_all(batch_size, range(len(dataset))),
         total=(len(dataset) + batch_size - 1) // batch_size,
@@ -415,35 +415,37 @@ def main(
     ):
         batch_indices = list(batch_indices)
         batch_images = [dataset[i][image_column] for i in batch_indices]
-        
+
         try:
             # Create messages for batch with task-specific prefix
             batch_messages = [
-                make_ocr_message(img, task_mode=task_mode, apply_smart_resize=apply_smart_resize)
+                make_ocr_message(
+                    img, task_mode=task_mode, apply_smart_resize=apply_smart_resize
+                )
                 for img in batch_images
             ]
-            
+
             # Process with vLLM
             outputs = llm.chat(batch_messages, sampling_params)
-            
+
             # Extract outputs
             for output in outputs:
                 text = output.outputs[0].text.strip()
                 all_outputs.append(text)
-        
+
         except Exception as e:
             logger.error(f"Error processing batch: {e}")
             # Add error placeholders for failed batch
             all_outputs.extend([f"[{task_mode.upper()} ERROR]"] * len(batch_images))
-    
+
     # Calculate processing time
     processing_duration = datetime.now() - start_time
     processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
-    
+
     # Add output column to dataset
     logger.info(f"Adding '{output_column}' column to dataset")
     dataset = dataset.add_column(output_column, all_outputs)
-    
+
     # Handle inference_info tracking (for multi-model comparisons)
     inference_entry = {
         "model_id": model_name,
@@ -456,31 +458,35 @@ def main(
         "max_tokens": max_tokens,
         "smart_resize": apply_smart_resize,
     }
-    
+
     if "inference_info" in dataset.column_names:
         # Append to existing inference info
         logger.info("Updating existing inference_info column")
-        
+
         def update_inference_info(example):
             try:
-                existing_info = json.loads(example["inference_info"]) if example["inference_info"] else []
+                existing_info = (
+                    json.loads(example["inference_info"])
+                    if example["inference_info"]
+                    else []
+                )
             except (json.JSONDecodeError, TypeError):
                 existing_info = []
-            
+
             existing_info.append(inference_entry)
             return {"inference_info": json.dumps(existing_info)}
-        
+
         dataset = dataset.map(update_inference_info)
     else:
         # Create new inference_info column
         logger.info("Creating new inference_info column")
         inference_list = [json.dumps([inference_entry])] * len(dataset)
         dataset = dataset.add_column("inference_info", inference_list)
-    
+
     # Push to hub
     logger.info(f"Pushing to {output_dataset}")
     dataset.push_to_hub(output_dataset, private=private, token=HF_TOKEN)
-    
+
     # Create and push dataset card
     logger.info("Creating dataset card")
     card_content = create_dataset_card(
@@ -498,12 +504,14 @@ def main(
         image_column=image_column,
         split=split,
     )
-    
+
     card = DatasetCard(card_content)
     card.push_to_hub(output_dataset, token=HF_TOKEN)
-    
+
     logger.info("✅ PaddleOCR-VL processing complete!")
-    logger.info(f"Dataset available at: https://huggingface.co/datasets/{output_dataset}")
+    logger.info(
+        f"Dataset available at: https://huggingface.co/datasets/{output_dataset}"
+    )
     logger.info(f"Processing time: {processing_time_str}")
     logger.info(f"Task mode: {task_mode} - {TASK_DESCRIPTIONS[task_mode]}")
 
@@ -533,21 +541,27 @@ if __name__ == "__main__":
         print("\n2. Table extraction:")
         print("   uv run paddleocr-vl.py docs tables-extracted --task-mode table")
         print("\n3. Formula recognition:")
-        print("   uv run paddleocr-vl.py papers formulas --task-mode formula --batch-size 32")
+        print(
+            "   uv run paddleocr-vl.py papers formulas --task-mode formula --batch-size 32"
+        )
         print("\n4. Chart analysis:")
         print("   uv run paddleocr-vl.py diagrams charts-analyzed --task-mode chart")
         print("\n5. Test with small sample:")
         print("   uv run paddleocr-vl.py dataset test --max-samples 10 --shuffle")
         print("\n6. Running on HF Jobs:")
         print("   hf jobs uv run --flavor l4x1 \\")
-        print("     -e HF_TOKEN=$(python3 -c \"from huggingface_hub import get_token; print(get_token())\") \\")
+        print(
+            '     -e HF_TOKEN=$(python3 -c "from huggingface_hub import get_token; print(get_token())") \\'
+        )
         print("     -e HF_HUB_ENABLE_HF_TRANSFER=1 \\")
-        print("     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl.py \\")
+        print(
+            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl.py \\"
+        )
         print("       input-dataset output-dataset --task-mode ocr")
         print("\n" + "=" * 80)
         print("\nFor full help, run: uv run paddleocr-vl.py --help")
         sys.exit(0)
-    
+
     parser = argparse.ArgumentParser(
         description="Document processing using PaddleOCR-VL (0.9B task-specific model)",
         formatter_class=argparse.RawDescriptionHelpFormatter,
@@ -578,7 +592,7 @@ Examples:
   uv run paddleocr-vl.py images output --no-smart-resize
         """,
     )
-    
+
     parser.add_argument("input_dataset", help="Input dataset ID from Hugging Face Hub")
     parser.add_argument("output_dataset", help="Output dataset ID for Hugging Face Hub")
     parser.add_argument(
@@ -652,9 +666,9 @@ Examples:
         "--output-column",
         help="Column name for output (default: paddleocr_[task_mode])",
     )
-    
+
     args = parser.parse_args()
-    
+
     main(
         input_dataset=args.input_dataset,
         output_dataset=args.output_dataset,
@@ -673,4 +687,4 @@ Examples:
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
-    )
+    )