Sync from GitHub via hub-sync

abot-ocr.py

@@ -96,6 +96,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def post_process_text(text: str, threshold: int = 8000) -> str:
     """Trim runaway repetition loops that VLM OCR can fall into on dense pages.
 
@@ -258,6 +280,8 @@ def main(
     private: bool = False,
     shuffle: bool = False,
     seed: int = 42,
+    output_column: str = "markdown",
+    overwrite: bool = False,
     verbose: bool = False,
 ):
     """Process images from a HF dataset through the ABot-OCR model."""
@@ -286,6 +310,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -335,9 +362,9 @@ def main(
             logger.error(f"Error processing batch: {e}")
             all_markdown.extend(["[OCR FAILED]"] * len(batch_images))
 
-    # Add markdown column to dataset
-    logger.info("Adding markdown column to dataset")
-    dataset = dataset.add_column("markdown", all_markdown)
+    # Add output column to dataset
+    logger.info(f"Adding '{output_column}' column to dataset")
+    dataset = dataset.add_column(output_column, all_markdown)
 
     # Handle inference_info tracking
     logger.info("Updating inference_info...")
@@ -345,7 +372,7 @@ def main(
     inference_entry = {
         "model_id": model,
         "model_name": "ABot-OCR",
-        "column_name": "markdown",
+        "column_name": output_column,
         "timestamp": datetime.now().isoformat(),
         "batch_size": batch_size,
         "max_tokens": max_tokens,
@@ -533,6 +560,17 @@ Examples:
         default=42,
         help="Random seed for shuffling (default: 42)",
     )
+    parser.add_argument(
+        "--output-column",
+        default="markdown",
+        help="Column name for the OCR output text (default: markdown)",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--verbose",
         action="store_true",
@@ -556,5 +594,7 @@ Examples:
         private=args.private,
         shuffle=args.shuffle,
         seed=args.seed,
+        output_column=args.output_column,
+        overwrite=args.overwrite,
         verbose=args.verbose,
     )

deepseek-ocr-vllm.py

@@ -78,6 +78,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def to_pil(image: Union[Image.Image, Dict[str, Any], str]) -> Image.Image:
     """Convert various image formats to PIL Image."""
     if isinstance(image, Image.Image):
@@ -211,6 +233,8 @@ def main(
     private: bool = False,
     shuffle: bool = False,
     seed: int = 42,
+    output_column: str = "markdown",
+    overwrite: bool = False,
     config: str = None,
     create_pr: bool = False,
     verbose: bool = False,
@@ -253,6 +277,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -326,9 +353,9 @@ def main(
     processing_duration = datetime.now() - start_time
     processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
 
-    # Add markdown column to dataset
-    logger.info("Adding markdown column to dataset")
-    dataset = dataset.add_column("markdown", all_markdown)
+    # Add output column to dataset
+    logger.info(f"Adding '{output_column}' column to dataset")
+    dataset = dataset.add_column(output_column, all_markdown)
 
     # Handle inference_info tracking
     logger.info("Updating inference_info...")
@@ -336,7 +363,7 @@ def main(
     inference_entry = {
         "model_id": model,
         "model_name": "DeepSeek-OCR",
-        "column_name": "markdown",
+        "column_name": output_column,
         "timestamp": datetime.now().isoformat(),
         "prompt_mode": prompt_mode if prompt is None else "custom",
         "batch_size": batch_size,
@@ -569,6 +596,17 @@ Examples:
         default=42,
         help="Random seed for shuffling (default: 42)",
     )
+    parser.add_argument(
+        "--output-column",
+        default="markdown",
+        help="Column name for the OCR output text (default: markdown)",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--verbose",
         action="store_true",
@@ -594,6 +632,8 @@ Examples:
         private=args.private,
         shuffle=args.shuffle,
         seed=args.seed,
+        output_column=args.output_column,
+        overwrite=args.overwrite,
         config=args.config,
         create_pr=args.create_pr,
         verbose=args.verbose,

deepseek-ocr.py

@@ -76,6 +76,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def create_dataset_card(
     source_dataset: str,
     model: str,
@@ -243,6 +265,8 @@ def main(
     private: bool = False,
     shuffle: bool = False,
     seed: int = 42,
+    output_column: str = "markdown",
+    overwrite: bool = False,
 ):
     """Process images from HF dataset through DeepSeek-OCR model."""
 
@@ -294,6 +318,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -379,12 +406,12 @@ def main(
         try:
             shutil.rmtree(temp_dir)
             shutil.rmtree(temp_output_dir)
-        except:
+        except Exception:
             pass
 
-    # Add markdown column to dataset
-    logger.info("Adding markdown column to dataset")
-    dataset = dataset.add_column("markdown", all_markdown)
+    # Add output column to dataset
+    logger.info(f"Adding '{output_column}' column to dataset")
+    dataset = dataset.add_column(output_column, all_markdown)
 
     # Handle inference_info tracking
     logger.info("Updating inference_info...")
@@ -403,7 +430,7 @@ def main(
 
     # Add new inference info
     new_info = {
-        "column_name": "markdown",
+        "column_name": output_column,
         "model_id": model,
         "processing_date": datetime.now().isoformat(),
         "resolution_mode": resolution_mode,
@@ -581,6 +608,17 @@ Examples:
         default=42,
         help="Random seed for shuffling (default: 42)",
     )
+    parser.add_argument(
+        "--output-column",
+        default="markdown",
+        help="Column name for the OCR output text (default: markdown)",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
 
     args = parser.parse_args()
 
@@ -600,4 +638,6 @@ Examples:
         private=args.private,
         shuffle=args.shuffle,
         seed=args.seed,
+        output_column=args.output_column,
+        overwrite=args.overwrite,
     )

deepseek-ocr2-vllm.py

@@ -86,6 +86,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def to_pil(image: Union[Image.Image, Dict[str, Any], str]) -> Image.Image:
     """Convert various image formats to PIL Image."""
     if isinstance(image, Image.Image):
@@ -225,6 +247,7 @@ def main(
     shuffle: bool = False,
     seed: int = 42,
     output_column: str = "markdown",
+    overwrite: bool = False,
     config: str = None,
     create_pr: bool = False,
     verbose: bool = False,
@@ -267,6 +290,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -574,6 +600,12 @@ Examples:
         default="markdown",
         help="Column name for OCR output (default: markdown). Use a different name to add alongside existing OCR.",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--shuffle",
         action="store_true",
@@ -620,6 +652,7 @@ Examples:
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         config=args.config,
         create_pr=args.create_pr,
         verbose=args.verbose,

dots-mocr.py

@@ -115,6 +115,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def make_ocr_message(
     image: Union[Image.Image, Dict[str, Any], str],
     prompt: str = PROMPT_TEMPLATES["ocr"],
@@ -281,6 +303,7 @@ def main(
     prompt_mode: str = "ocr",
     custom_prompt: str = None,
     output_column: str = "markdown",
+    overwrite: bool = False,
     config: str = None,
     create_pr: bool = False,
     temperature: float = 0.1,
@@ -318,6 +341,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -665,6 +691,12 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--config",
         help="Config/subset name when pushing to Hub (for benchmarking multiple models in one repo)",
@@ -712,6 +744,7 @@ Examples:
         prompt_mode=args.prompt_mode,
         custom_prompt=args.custom_prompt,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         config=args.config,
         create_pr=args.create_pr,
         temperature=args.temperature,

falcon-ocr.py

@@ -74,6 +74,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def prepare_image(image: Union[Image.Image, Dict[str, Any], str]) -> Image.Image:
     if isinstance(image, Image.Image):
         pil_img = image
@@ -145,6 +167,7 @@ def main(
     shuffle: bool = False,
     seed: int = 42,
     output_column: str = "markdown",
+    overwrite: bool = False,
     config: str = None,
     create_pr: bool = False,
     compile: bool = True,
@@ -176,6 +199,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
         dataset = dataset.shuffle(seed=seed)
@@ -386,6 +412,12 @@ if __name__ == "__main__":
         "--output-column", default="markdown",
         help="Column name for output text (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--config",
         help="Config/subset name for Hub (for benchmarking multiple models)",
@@ -424,6 +456,7 @@ if __name__ == "__main__":
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         config=args.config,
         create_pr=args.create_pr,
         compile=not args.no_compile,

firered-ocr.py

@@ -90,6 +90,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def make_ocr_message(
     image: Union[Image.Image, Dict[str, Any], str],
     prompt: str = FIRERED_OCR_PROMPT,
@@ -242,6 +264,7 @@ def main(
     shuffle: bool = False,
     seed: int = 42,
     output_column: str = "markdown",
+    overwrite: bool = False,
     config: str = None,
     create_pr: bool = False,
 ):
@@ -268,6 +291,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -528,6 +554,12 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--config",
         help="Config/subset name when pushing to Hub (for benchmarking multiple models in one repo)",
@@ -556,6 +588,7 @@ Examples:
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         config=args.config,
         create_pr=args.create_pr,
     )

glm-ocr-v2.py

@@ -136,6 +136,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def make_ocr_message(
     image: Union[Image.Image, Dict[str, Any], str],
     task: str = "ocr",
@@ -386,6 +408,7 @@ def main(
     shuffle: bool = False,
     seed: int = 42,
     output_column: str = "markdown",
+    overwrite: bool = False,
     verbose: bool = False,
     config: str = None,
     create_pr: bool = False,
@@ -438,6 +461,11 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column.
+    # The incremental path derives batch datasets via dataset.select(...), so dropping
+    # it here (on --overwrite) also keeps those per-batch add_columns clean.
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
         dataset = dataset.shuffle(seed=seed)
@@ -955,6 +983,12 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--verbose",
         action="store_true",
@@ -999,6 +1033,7 @@ Examples:
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         verbose=args.verbose,
         config=args.config,
         create_pr=args.create_pr,

hunyuan-ocr.py

@@ -150,6 +150,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def get_prompt(
     prompt_mode: str,
     use_chinese: bool = False,
@@ -366,6 +388,7 @@ def main(
     use_chinese: bool = False,
     custom_prompt: str = None,
     output_column: str = "markdown",
+    overwrite: bool = False,
     clean_output: bool = True,
     config: str = None,
     create_pr: bool = False,
@@ -409,6 +432,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -786,6 +812,12 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--no-clean-output",
         action="store_true",
@@ -835,6 +867,7 @@ Examples:
         use_chinese=args.use_chinese_prompts,
         custom_prompt=args.custom_prompt,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         clean_output=not args.no_clean_output,
         config=args.config,
         create_pr=args.create_pr,

lfm2-extract.py

@@ -77,6 +77,28 @@ def check_cuda_availability() -> None:
     logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name()}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def load_text_arg(value: str) -> str:
     """Resolve --schema (inline text/JSON, URL, or file path) into a string."""
     text = value.strip()
@@ -116,6 +138,7 @@ def main(
     schema: str,
     text_column: str = "text",
     output_column: str = "extraction",
+    overwrite: bool = False,
     output_format: str = "json",
     split: str = "train",
     max_samples: Optional[int] = None,
@@ -142,6 +165,10 @@ def main(
 
     logger.info(f"Loading dataset: {input_dataset} (split={split})")
     dataset = load_dataset(input_dataset, split=split)
+
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     if shuffle:
         dataset = dataset.shuffle(seed=seed)
     if max_samples:
@@ -257,6 +284,12 @@ if __name__ == "__main__":
     )
     parser.add_argument("--text-column", default="text", help="Text column (default: text)")
     parser.add_argument("--output-column", default="extraction", help="Output column (default: extraction)")
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--format", dest="output_format", default="json", choices=list(FORMATS),
         help="Output format (default: json)",
@@ -279,6 +312,7 @@ if __name__ == "__main__":
         schema=args.schema,
         text_column=args.text_column,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         output_format=args.output_format,
         split=args.split,
         max_samples=args.max_samples,

lfm2-vl-extract.py

@@ -80,6 +80,28 @@ def check_cuda_availability() -> None:
     logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name()}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def load_schema_arg(value: str) -> Dict[str, str]:
     """Resolve --schema (inline JSON, URL, or file path) into a {field: description} dict."""
     text = value.strip()
@@ -152,6 +174,7 @@ def main(
     schema: str,
     image_column: str = "image",
     output_column: str = "extraction",
+    overwrite: bool = False,
     split: str = "train",
     max_samples: Optional[int] = None,
     shuffle: bool = False,
@@ -175,6 +198,10 @@ def main(
 
     logger.info(f"Loading dataset: {input_dataset} (split={split})")
     dataset = load_dataset(input_dataset, split=split)
+
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     if shuffle:
         dataset = dataset.shuffle(seed=seed)
     if max_samples:
@@ -293,6 +320,12 @@ if __name__ == "__main__":
     )
     parser.add_argument("--image-column", default="image", help="Image column (default: image)")
     parser.add_argument("--output-column", default="extraction", help="Output column (default: extraction)")
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument("--split", default="train", help="Dataset split (default: train)")
     parser.add_argument("--max-samples", type=int, help="Limit number of samples")
     parser.add_argument("--shuffle", action="store_true", help="Shuffle before sampling")
@@ -311,6 +344,7 @@ if __name__ == "__main__":
         schema=args.schema,
         image_column=args.image_column,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         split=args.split,
         max_samples=args.max_samples,
         shuffle=args.shuffle,

lift-extract.py

@@ -111,6 +111,28 @@ def check_cuda_availability() -> None:
     logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def load_schema_arg(value: str) -> Dict[str, Any]:
     """Resolve --schema (inline JSON, a URL, or a file path) into a JSON Schema dict."""
     text = value.strip()
@@ -423,6 +445,7 @@ def main(
     image_column: str = "image",
     pdf_column: Optional[str] = None,
     output_column: str = "extraction",
+    overwrite: bool = False,
     method: str = "hf",
     page_range: Optional[str] = None,
     split: str = "train",
@@ -478,6 +501,10 @@ def main(
             f"Column '{source_column}' not found. Available: {dataset.column_names}"
         )
         sys.exit(1)
+
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     if shuffle:
         dataset = dataset.shuffle(seed=seed)
     if max_samples:
@@ -704,6 +731,12 @@ Input (one document per row):
         default="extraction",
         help="Output column (default: extraction)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--method",
         choices=["hf", "vllm"],
@@ -792,6 +825,7 @@ Input (one document per row):
         image_column=args.image_column,
         pdf_column=args.pdf_column,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         method=args.method,
         page_range=args.page_range,
         split=args.split,

lighton-ocr.py

@@ -85,6 +85,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def resize_image_to_target(image: Image.Image, target_size: int = 1540) -> Image.Image:
     """
     Resize image so longest dimension is target_size while maintaining aspect ratio.
@@ -295,6 +317,7 @@ def main(
     shuffle: bool = False,
     seed: int = 42,
     output_column: str = "markdown",
+    overwrite: bool = False,
 ):
     """Process images from HF dataset through LightOnOCR model."""
 
@@ -327,6 +350,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -625,6 +651,12 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
 
     args = parser.parse_args()
 
@@ -648,4 +680,5 @@ Examples:
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
+        overwrite=args.overwrite,
     )

nanonets-ocr.py

@@ -61,6 +61,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def make_ocr_message(
     image: Union[Image.Image, Dict[str, Any], str],
     prompt: str = "Extract the text from the above document as if you were reading it naturally. Return the tables in html format. Return the equations in LaTeX representation. If there is an image in the document and image caption is not present, add a small description of the image inside the <img></img> tag; otherwise, add the image caption inside <img></img>. Watermarks should be wrapped in brackets. Ex: <watermark>OFFICIAL COPY</watermark>. Page numbers should be wrapped in brackets. Ex: <page_number>14</page_number> or <page_number>9/22</page_number>. Prefer using ☐ and ☑ for check boxes.",
@@ -208,7 +230,7 @@ def main(
     image_column: str = "image",
     batch_size: int = 32,
     model: str = "nanonets/Nanonets-OCR-s",
-    max_model_len: int = 8192,
+    max_model_len: int = 32768,
     max_tokens: int = 15000,
     gpu_memory_utilization: float = 0.8,
     hf_token: str = None,
@@ -217,6 +239,8 @@ def main(
     private: bool = False,
     shuffle: bool = False,
     seed: int = 42,
+    output_column: str = "markdown",
+    overwrite: bool = False,
     verbose: bool = False,
 ):
     """Process images from HF dataset through OCR model."""
@@ -245,6 +269,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -301,9 +328,9 @@ def main(
             # Add error placeholders for failed batch
             all_markdown.extend(["[OCR FAILED]"] * len(batch_images))
 
-    # Add markdown column to dataset
-    logger.info("Adding markdown column to dataset")
-    dataset = dataset.add_column("markdown", all_markdown)
+    # Add output column to dataset
+    logger.info(f"Adding '{output_column}' column to dataset")
+    dataset = dataset.add_column(output_column, all_markdown)
 
     # Handle inference_info tracking
     logger.info("Updating inference_info...")
@@ -311,7 +338,7 @@ def main(
     inference_entry = {
         "model_id": model,
         "model_name": "Nanonets-OCR-s",
-        "column_name": "markdown",
+        "column_name": output_column,
         "timestamp": datetime.now().isoformat(),
         "batch_size": batch_size,
         "max_tokens": max_tokens,
@@ -466,8 +493,10 @@ Examples:
     parser.add_argument(
         "--max-model-len",
         type=int,
-        default=8192,
-        help="Maximum model context length (default: 8192)",
+        default=32768,
+        help="Maximum model context length (default: 32768; must exceed --max-tokens "
+        "15000 plus the image/prompt tokens — the old 8192 default couldn't hold the "
+        "output budget). Model max is 128k, so there's ample room.",
     )
     parser.add_argument(
         "--max-tokens",
@@ -504,6 +533,17 @@ Examples:
         default=42,
         help="Random seed for shuffling (default: 42)",
     )
+    parser.add_argument(
+        "--output-column",
+        default="markdown",
+        help="Column name for the OCR output text (default: markdown)",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--verbose",
         action="store_true",
@@ -527,5 +567,7 @@ Examples:
         private=args.private,
         shuffle=args.shuffle,
         seed=args.seed,
+        output_column=args.output_column,
+        overwrite=args.overwrite,
         verbose=args.verbose,
     )

nuextract3.py

@@ -93,6 +93,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def load_template_arg(value: Optional[str]) -> Optional[Dict[str, Any]]:
     """Load a NuExtract template/JSON Schema from inline JSON, a URL, or a file path."""
     if value is None:
@@ -295,6 +317,7 @@ def main(
     shuffle: bool = False,
     seed: int = 42,
     output_column: Optional[str] = None,
+    overwrite: bool = False,
     verbose: bool = False,
     config: str = None,
     create_pr: bool = False,
@@ -332,6 +355,13 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if an output column would collide with an existing input column.
+    # With --enable-thinking the script also writes "{output_column}_reasoning".
+    out_cols = [output_column]
+    if enable_thinking:
+        out_cols.append(f"{output_column}_reasoning")
+    dataset = ensure_output_columns_free(dataset, out_cols, overwrite=overwrite)
+
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
         dataset = dataset.shuffle(seed=seed)
@@ -713,6 +743,12 @@ Examples:
         default=None,
         help="Column name for output (default: 'markdown' in OCR mode, 'extraction' in template mode)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--verbose",
         action="store_true",
@@ -743,6 +779,7 @@ Examples:
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         verbose=args.verbose,
         config=args.config,
         create_pr=args.create_pr,

numarkdown-ocr.py

@@ -75,6 +75,28 @@ def check_gpu_availability() -> int:
     return num_gpus
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def validate_and_resize_image(
     image: Image.Image,
     min_pixels: int = 100 * 28 * 28,
@@ -317,6 +339,7 @@ def main(
     temperature: float = 0.0,
     custom_prompt: Optional[str] = None,
     output_column: str = "markdown",
+    overwrite: bool = False,
     config: str = None,
     create_pr: bool = False,
     verbose: bool = False,
@@ -361,6 +384,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -700,6 +726,12 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--config",
         help="Config/subset name when pushing to Hub (for benchmarking multiple models in one repo)",
@@ -737,6 +769,7 @@ Examples:
         temperature=args.temperature,
         custom_prompt=args.custom_prompt,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         config=args.config,
         create_pr=args.create_pr,
         verbose=args.verbose,

olmocr2-vllm.py

@@ -81,6 +81,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def parse_yaml_frontmatter(text: str) -> tuple[dict, str]:
     """
     Parse YAML front matter from olmOCR output.
@@ -280,6 +302,7 @@ def main(
     output_dataset: str,
     image_column: str = "image",
     output_column: str = "markdown",
+    overwrite: bool = False,
     batch_size: int = 16,
     model: str = "allenai/olmOCR-2-7B-1025-FP8",
     max_model_len: int = 16384,
@@ -333,6 +356,9 @@ def main(
     logger.info(f"Loading dataset: {input_dataset}")
     ds = load_dataset(input_dataset, split=split)
 
+    # Fail fast if the output column would collide with an existing input column
+    ds = ensure_output_columns_free(ds, [output_column], overwrite=overwrite)
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -558,6 +584,12 @@ Examples:
         default="markdown",
         help="Column name for markdown output (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--batch-size",
         type=int,
@@ -635,6 +667,7 @@ Examples:
         output_dataset=args.output_dataset,
         image_column=args.image_column,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         batch_size=args.batch_size,
         model=args.model,
         max_model_len=args.max_model_len,

paddleocr-vl-1.5.py

@@ -101,6 +101,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def prepare_image(
     image: Union[Image.Image, Dict[str, Any], str],
 ) -> Image.Image:
@@ -282,6 +304,7 @@ def main(
     shuffle: bool = False,
     seed: int = 42,
     output_column: str = "markdown",
+    overwrite: bool = False,
     config: str = None,
     create_pr: bool = False,
     verbose: bool = False,
@@ -318,6 +341,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -641,6 +667,12 @@ Backend: Transformers batch inference (not vLLM)
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--config",
         help="Config/subset name when pushing to Hub (for benchmarking multiple models in one repo)",
@@ -671,6 +703,7 @@ Backend: Transformers batch inference (not vLLM)
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         config=args.config,
         create_pr=args.create_pr,
         verbose=args.verbose,

paddleocr-vl-1.6.py

@@ -104,6 +104,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def smart_resize(
     height: int,
     width: int,
@@ -362,6 +384,7 @@ def main(
     shuffle: bool = False,
     seed: int = 42,
     output_column: str = None,
+    overwrite: bool = False,
     config: str = None,
     create_pr: bool = False,
     verbose: bool = False,
@@ -405,6 +428,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -757,6 +783,12 @@ Examples:
         "--output-column",
         help="Column name for output (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--config",
         help="Config/subset name when pushing to Hub (for benchmarking multiple models in one repo)",
@@ -792,6 +824,7 @@ Examples:
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         config=args.config,
         create_pr=args.create_pr,
         verbose=args.verbose,

paddleocr-vl.py

@@ -93,6 +93,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def smart_resize(
     height: int,
     width: int,
@@ -337,6 +359,7 @@ def main(
     shuffle: bool = False,
     seed: int = 42,
     output_column: str = None,
+    overwrite: bool = False,
     verbose: bool = False,
 ):
     """Process images from HF dataset through PaddleOCR-VL model."""
@@ -385,6 +408,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -706,6 +732,12 @@ Examples:
         "--output-column",
         help="Column name for output (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--verbose",
         action="store_true",
@@ -732,5 +764,6 @@ Examples:
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         verbose=args.verbose,
     )

pp-doclayout.py

@@ -433,6 +433,7 @@ class DatasetRepoSink:
         create_pr: bool,
         source_id: str,
         original_dataset=None,
+        overwrite: bool = False,
     ):
         self.repo_id = repo_id
         self.hf_token = hf_token
@@ -441,6 +442,7 @@ class DatasetRepoSink:
         self.create_pr = create_pr
         self.source_id = source_id
         self.original_dataset = original_dataset
+        self.overwrite = overwrite
         # Used when original_dataset is None: row-by-row buffer.
         self._rows: List[Dict[str, Any]] = []
         # Used when original_dataset is set: ordered layouts aligned with dataset rows.
@@ -476,7 +478,16 @@ class DatasetRepoSink:
                 # Pad to keep add_column happy.
                 while len(self._layouts) < len(self.original_dataset):
                     self._layouts.append("[]")
-            ds = self.original_dataset.add_column("layout", self._layouts)
+            base = self.original_dataset
+            if "layout" in base.column_names:
+                if not self.overwrite:
+                    raise ValueError(
+                        "Output column 'layout' already exists in the input dataset; "
+                        "pass --overwrite to replace it."
+                    )
+                logger.warning("--overwrite: replacing existing column 'layout'")
+                base = base.remove_columns("layout")
+            ds = base.add_column("layout", self._layouts)
         else:
             if not self._rows:
                 logger.warning("No rows produced; nothing to push.")
@@ -891,6 +902,17 @@ def main(args: argparse.Namespace) -> None:
             seed=args.seed,
             max_samples=args.max_samples,
         )
+        # Fail fast, before minutes of inference, if the 'layout' output column would
+        # collide with an existing input column. --overwrite opts in to replacing it.
+        if original_dataset is not None and "layout" in original_dataset.column_names:
+            if not args.overwrite:
+                logger.error(
+                    "Output column 'layout' already exists in the input dataset "
+                    f"(columns: {original_dataset.column_names})."
+                )
+                logger.error("Pass --overwrite to replace it.")
+                sys.exit(1)
+            logger.warning("--overwrite: will replace existing column 'layout'")
 
     # ---------- sink ----------
     if is_bucket_url(args.output_target):
@@ -911,6 +933,7 @@ def main(args: argparse.Namespace) -> None:
             create_pr=args.create_pr,
             source_id=args.input_source,
             original_dataset=original_dataset,
+            overwrite=args.overwrite,
         )
 
     completed = sink.already_done()
@@ -1163,6 +1186,12 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="Create PR instead of direct push (dataset sink only)",
     )
+    p.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     # Bucket-sink-specific
     p.add_argument(
         "--shard-size",

qianfan-ocr.py

@@ -77,6 +77,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def extract_content_from_thinking(text: str, include_thinking: bool = False) -> str:
     """
     Extract final content from Qianfan-OCR's Layout-as-Thought output.
@@ -237,6 +259,7 @@ def main(
     include_thinking: bool = False,
     custom_prompt: str = None,
     output_column: str = "markdown",
+    overwrite: bool = False,
     config: str = None,
     create_pr: bool = False,
     verbose: bool = False,
@@ -276,6 +299,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
         dataset = dataset.shuffle(seed=seed)
@@ -588,6 +614,12 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--config",
         help="Config/subset name when pushing to Hub (for benchmarking multiple models)",
@@ -626,6 +658,7 @@ Examples:
         include_thinking=args.include_thinking,
         custom_prompt=args.custom_prompt,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         config=args.config,
         create_pr=args.create_pr,
         verbose=args.verbose,

rolm-ocr.py

@@ -61,6 +61,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def make_ocr_message(
     image: Union[Image.Image, Dict[str, Any], str],
     prompt: str = "Return the plain text representation of this document as if you were reading it naturally.\n",
@@ -209,6 +231,7 @@ def main(
     max_samples: int = None,
     private: bool = False,
     output_column: str = None,
+    overwrite: bool = False,
     shuffle: bool = False,
     seed: int = 42,
     verbose: bool = False,
@@ -243,6 +266,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -502,6 +528,12 @@ Examples:
         default=None,
         help="Name of the output column for extracted text (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--shuffle",
         action="store_true",
@@ -535,6 +567,7 @@ Examples:
         max_samples=args.max_samples,
         private=args.private,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         shuffle=args.shuffle,
         seed=args.seed,
         verbose=args.verbose,

smoldocling-ocr.py

@@ -65,6 +65,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def prepare_llm_input(
     image: Union[Image.Image, Dict[str, Any], str],
     prompt_text: str = "Convert page to Docling.",
@@ -228,6 +250,7 @@ def main(
     max_samples: int = None,
     private: bool = False,
     output_column: str = "markdown",
+    overwrite: bool = False,
     output_format: str = "markdown",
     shuffle: bool = False,
     seed: int = 42,
@@ -259,6 +282,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     # Validate output format
     if output_format not in ["markdown", "doctags"]:
         raise ValueError(
@@ -571,6 +597,12 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--output-format",
         default="markdown",
@@ -624,6 +656,7 @@ Examples:
         max_samples=args.max_samples,
         private=args.private,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         output_format=args.output_format,
         shuffle=args.shuffle,
         seed=args.seed,

unlimited-ocr-vllm.py

@@ -100,6 +100,28 @@ def check_cuda_availability():
     logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def to_pil(image: Union[Image.Image, Dict[str, Any], str]) -> Image.Image:
     """Convert various dataset image cell formats to an RGB PIL image."""
     if isinstance(image, Image.Image):
@@ -195,6 +217,7 @@ def main(
     model: str = MODEL,
     image_column: str = "image",
     output_column: str = "markdown",
+    overwrite: bool = False,
     grounding_column: Optional[str] = None,
     batch_size: int = 8,
     max_model_len: int = 32768,
@@ -228,6 +251,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
         dataset = dataset.shuffle(seed=seed)
@@ -456,6 +482,12 @@ Examples:
         default="markdown",
         help="Output column name (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--strip-grounding",
         action="store_true",
@@ -526,6 +558,7 @@ Examples:
         model=args.model,
         image_column=args.image_column,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         grounding_column=args.grounding_column,
         batch_size=args.batch_size,
         max_model_len=args.max_model_len,