import os import json import shutil import argparse import logging import multiprocessing as mp from concurrent.futures import ProcessPoolExecutor, as_completed import torch import psutil import numpy as np from tqdm import tqdm from magic_pdf.pipe.UNIPipe import UNIPipe from magic_pdf.libs.commons import read_file from magic_pdf.libs.config_reader import get_device from magic_pdf.tools.common import do_parse from magic_pdf.libs.pdf_image_tools import cut_image from magic_pdf.rw.DiskReaderWriter import DiskReaderWriter from magic_pdf.filter.pdf_meta_scan import pdf_meta_scan from magic_pdf.filter.pdf_classify_by_type import classify import fitz # PyMuPDF import time import signal import traceback # Set up logging logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) # Minimum batch size MIN_BATCH_SIZE = 1 def parse_arguments(): parser = argparse.ArgumentParser(description="Process multiple PDFs using Magic PDF") parser.add_argument("--input", default="input", help="Input folder containing PDF files") parser.add_argument("--output", default="output", help="Output folder for processed files") parser.add_argument("--config", default="magic-pdf.template.json", help="Path to configuration file") parser.add_argument("--timeout", type=int, default=240, help="Timeout for processing each PDF (in seconds)") parser.add_argument("--max-workers", type=int, default=None, help="Maximum number of worker processes") parser.add_argument("--use-bf16", action="store_true", help="Use bfloat16 precision for model inference") parser.add_argument("--initial-batch-size", type=int, default=1, help="Initial batch size for processing") return parser.parse_args() def load_config(config_path): with open(config_path, 'r') as f: return json.load(f) def get_available_memory(gpu_id): return torch.cuda.get_device_properties(gpu_id).total_memory - torch.cuda.memory_allocated(gpu_id) def extract_images(pdf_path, output_folder): doc = fitz.open(pdf_path) pdf_name = os.path.splitext(os.path.basename(pdf_path))[0] images_folder = os.path.join(output_folder, 'images') os.makedirs(images_folder, exist_ok=True) for page_num, page in enumerate(doc): for img_index, img in enumerate(page.get_images(full=True)): xref = img[0] base_image = doc.extract_image(xref) image_bytes = base_image["image"] image_ext = base_image["ext"] image_filename = f'{pdf_name}_{page_num + 1:03d}_{img_index + 1:03d}.{image_ext}' image_path = os.path.join(images_folder, image_filename) with open(image_path, "wb") as image_file: image_file.write(image_bytes) doc.close() class MagicModel: def __init__(self, config): self.config = config def process_pdf(self, pdf_data, parse_type, layout_info, log_file_path): processed_pages = [] with open(log_file_path, 'a') as log_file: log_file.write(f"Entering process_pdf\n") log_file.write(f" parse_type: {parse_type}, (expected: str)\n") log_file.write( f" layout_info (length: {len(layout_info)}), (expected: list of dicts): {layout_info}\n") for page_index, page_info in enumerate(layout_info): try: with open(log_file_path, 'a') as log_file: log_file.write(f"Processing page {page_index}\n") log_file.write(f" Page info (expected: dict): {page_info}\n") processed_page = self.process_page(page_info, parse_type) processed_pages.append(processed_page) except Exception as e: with open(log_file_path, 'a') as log_file: log_file.write(f"Error processing page {page_index} in process_pdf: {str(e)}\n") log_file.write(f"Page info (expected: dict): {page_info}\n") with open(log_file_path, 'a') as log_file: log_file.write(f"Exiting process_pdf\n") return { "processed_pages": processed_pages, "parse_type": parse_type, } def process_page(self, page_info, parse_type): with open(log_file_path, 'a') as log_file: log_file.write(f"Entering process_page\n") log_file.write(f" page_info (expected: dict): {page_info}\n") log_file.write(f" parse_type (expected: str): {parse_type}\n") result = { "page_no": page_info.get("page_info", {}).get("page_no", "unknown"), "content": "Processed page content", "parse_type": parse_type } with open(log_file_path, 'a') as log_file: log_file.write(f"Exiting process_page\n") return result def process_single_pdf(input_file, output_folder, gpu_id, config, timeout, use_bf16, model, log_file_path): start_time = time.time() pdf_name = os.path.splitext(os.path.basename(input_file))[0] output_subfolder = os.path.join(output_folder, pdf_name, 'auto') os.makedirs(output_subfolder, exist_ok=True) def timeout_handler(signum, frame): raise TimeoutError("PDF processing timed out") try: signal.signal(signal.SIGALRM, timeout_handler) signal.alarm(timeout) if gpu_id >= 0: torch.cuda.set_device(gpu_id) if use_bf16 and torch.cuda.is_bf16_supported(): torch.set_default_dtype(torch.bfloat16) else: torch.set_default_dtype(torch.float32) torch.set_default_device(f'cuda:{gpu_id}') else: if use_bf16: torch.set_default_dtype(torch.bfloat16) else: torch.set_default_dtype(torch.float32) torch.set_default_device('cpu') pdf_data = read_file(input_file, 'rb') # Perform PDF metadata scan metadata = pdf_meta_scan(pdf_data) with open(log_file_path, 'a') as log_file: log_file.write(f"Processing PDF: {input_file}\n") log_file.write(f"Metadata (expected: dict): {json.dumps(metadata, indent=2)}\n") # Check if metadata indicates the PDF should be dropped if metadata.get("_need_drop", False): with open(log_file_path, 'a') as log_file: log_file.write( f"Dropping PDF {input_file}: {metadata.get('_drop_reason', 'Unknown reason')}\n") return input_file, "Dropped", None # Check if all required fields are present in metadata required_fields = ['total_page', 'page_width_pts', 'page_height_pts', 'image_info_per_page', 'text_len_per_page', 'imgs_per_page', 'text_layout_per_page', 'invalid_chars'] for field in required_fields: if field not in metadata: raise ValueError(f"Required field '{field}' not found in metadata for {input_file}") # Extract required fields for classify function total_page = metadata['total_page'] page_width = metadata['page_width_pts'] page_height = metadata['page_height_pts'] img_sz_list = metadata['image_info_per_page'] text_len_list = metadata['text_len_per_page'] img_num_list = metadata['imgs_per_page'] text_layout_list = metadata['text_layout_per_page'] invalid_chars = metadata['invalid_chars'] with open(log_file_path, 'a') as log_file: log_file.write(f"Classify parameters:\n") log_file.write(f" total_page (expected: int): {total_page}\n") log_file.write(f" page_width (expected: int): {page_width}\n") log_file.write(f" page_height (expected: int): {page_height}\n") log_file.write(f" img_sz_list (expected: list of lists): {img_sz_list[:5]}...\n") log_file.write(f" text_len_list (expected: list of ints): {text_len_list[:5]}...\n") log_file.write(f" img_num_list (expected: list of ints): {img_num_list[:5]}...\n") log_file.write( f" text_layout_list (expected: list of strs): {text_layout_list[:5]}...\n") log_file.write(f" invalid_chars (expected: bool): {invalid_chars}\n") # Classify PDF is_text_pdf, classification_results = classify( total_page, page_width, page_height, img_sz_list[:total_page], text_len_list[:total_page], img_num_list[:total_page], text_layout_list[:len(text_layout_list)], invalid_chars ) with open(log_file_path, 'a') as log_file: log_file.write(f"Classification Results:\n") log_file.write(f" is_text_pdf (expected: bool): {is_text_pdf}\n") log_file.write( f" classification_results (expected: dict): {classification_results}\n") image_writer = DiskReaderWriter(output_subfolder) with open(log_file_path, 'a') as log_file: log_file.write(f"Image writer initialized: {image_writer}\n") # Create jso_useful_key as a dictionary model_json = [] # Or load your model data here jso_useful_key = {"_pdf_type": "", "model_list": model_json} unipipe = UNIPipe(pdf_data, jso_useful_key, image_writer) with open(log_file_path, 'a') as log_file: log_file.write(f"UNIPipe initialized: {unipipe}\n") parse_type = unipipe.pipe_classify() with open(log_file_path, 'a') as log_file: log_file.write(f"pipe_classify result (expected: str): {parse_type}\n") # Add detailed logging for pipe_analyze inputs and output with open(log_file_path, 'a') as log_file: log_file.write(f"Detailed pipe_analyze Inputs for {input_file}:\n") log_file.write(f" parse_type (expected: str): {parse_type}\n") layout_info = unipipe.pipe_analyze() with open(log_file_path, 'a') as log_file: log_file.write( f"pipe_analyze Results (expected: list of dicts, length: {len(layout_info)}): {layout_info}\n") # Use OCR if it's not classified as a text PDF if not is_text_pdf: parse_type = 'ocr' with open(log_file_path, 'a') as log_file: log_file.write( f"parse_type after OCR check (expected: str): {parse_type}\n") # Process the PDF using the model parse_result = model.process_pdf(pdf_data, parse_type, layout_info, log_file_path) with open(log_file_path, 'a') as log_file: log_file.write(f"Model process_pdf result (expected: dict): {parse_result}\n") markdown_content = unipipe.pipe_mk_markdown(parse_result) with open(log_file_path, 'a') as log_file: log_file.write( f"pipe_mk_markdown result (expected: str, length: {len(markdown_content)}): {markdown_content}\n") uni_format = unipipe.pipe_mk_uni_format(parse_result) with open(log_file_path, 'a') as log_file: log_file.write(f"pipe_mk_uni_format result (expected: dict): {uni_format}\n") # Write markdown content with open(os.path.join(output_subfolder, f'{pdf_name}.md'), 'w', encoding='utf-8') as f: f.write(markdown_content) # Write middle.json with open(os.path.join(output_subfolder, 'middle.json'), 'w', encoding='utf-8') as f: json.dump(parse_result, f, ensure_ascii=False, indent=2) # Write model.json with open(os.path.join(output_subfolder, 'model.json'), 'w', encoding='utf-8') as f: json.dump(uni_format, f, ensure_ascii=False, indent=2) # Copy original PDF shutil.copy(input_file, os.path.join(output_subfolder, f'{pdf_name}.pdf')) # Generate layout.pdf and spans.pdf do_parse(input_file, parse_type, output_subfolder, draw_bbox=True) # Extract images extract_images(input_file, output_subfolder) processing_time = time.time() - start_time with open(log_file_path, 'a') as log_file: log_file.write( f"Successfully processed {input_file} on GPU {gpu_id} in {processing_time:.2f} seconds\n") # Prepare result for JSONL output result = { "file_name": pdf_name, "processing_time": processing_time, "parse_type": parse_type, "metadata": metadata, "classification": classification_results, "is_text_pdf": is_text_pdf } return input_file, "Success", result except ValueError as ve: with open(log_file_path, 'a') as log_file: log_file.write(f"Metadata error: {str(ve)}\n") return input_file, f"Metadata Error: {str(ve)}", None except TimeoutError: with open(log_file_path, 'a') as log_file: log_file.write(f"Processing timed out after {timeout} seconds\n") return input_file, "Timeout", None except Exception as e: # Save full traceback to a file traceback_file = os.path.join(output_folder, 'traceback.txt') with open(traceback_file, 'w') as f: f.write(traceback.format_exc()) # Print error message and traceback location to CLI print(f"Error occurred: {e}") print(f"Full traceback saved to: {traceback_file}") exit(1) # Terminate the script finally: signal.alarm(0) # Cancel the alarm if gpu_id >= 0: torch.cuda.empty_cache() def process_pdf_batch(batch, output_folder, gpu_id, config, timeout, use_bf16, model, log_file_path): results = [] for pdf_file in batch: result = process_single_pdf(pdf_file, output_folder, gpu_id, config, timeout, use_bf16, model, log_file_path) results.append(result) return results def write_to_jsonl(results, output_file): with open(output_file, 'a') as f: for result in results: if result[2]: # Check if result is not None json.dump(result[2], f) f.write('\n') def get_gpu_memory_usage(gpu_id): if gpu_id < 0: return 0, 0 # CPU mode total_memory = torch.cuda.get_device_properties(gpu_id).total_memory allocated_memory = torch.cuda.memory_allocated(gpu_id) return allocated_memory, total_memory def main(): mp.set_start_method('spawn', force=True) args = parse_arguments() config = load_config(args.config) input_folder = args.input output_folder = args.output os.makedirs(output_folder, exist_ok=True) pdf_files = [os.path.join(input_folder, f) for f in os.listdir(input_folder) if f.endswith('.pdf')] num_gpus = torch.cuda.device_count() if num_gpus == 0: print("No GPUs available. Using CPU.") num_gpus = 1 gpu_ids = [-1] else: gpu_ids = list(range(num_gpus)) num_workers = args.max_workers or min(num_gpus, os.cpu_count()) main_jsonl = os.path.join(output_folder, 'processing_results.jsonl') temp_jsonl = os.path.join(output_folder, 'temp_results.jsonl') log_file_path = os.path.join(output_folder, 'processing_log.txt') # Enable deterministic mode torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False # Load the model model = MagicModel(config) results = [] with ProcessPoolExecutor(max_workers=num_workers) as executor: for gpu_id in gpu_ids: batch_size = args.initial_batch_size pdf_index = 0 oom_occurred = False while pdf_index < len(pdf_files): batch = pdf_files[pdf_index:pdf_index + batch_size] try: future = executor.submit(process_pdf_batch, batch, output_folder, gpu_id, config, args.timeout, args.use_bf16, model, log_file_path) batch_results = future.result() results.extend(batch_results) for result in batch_results: write_to_jsonl([result], temp_jsonl) # Print VRAM usage allocated, total = get_gpu_memory_usage(gpu_id) with open(log_file_path, 'a') as log_file: log_file.write( f"GPU {gpu_id} - Batch size: {batch_size}, VRAM usage: {allocated / 1024 ** 3:.2f}GB / {total / 1024 ** 3:.2f}GB\n") # If successful and OOM hasn't occurred yet, increase batch size if not oom_occurred: batch_size += 1 pdf_index += len(batch) except torch.cuda.OutOfMemoryError: # If OOM occurs, reduce batch size oom_occurred = True batch_size = max(MIN_BATCH_SIZE, batch_size - 1) with open(log_file_path, 'a') as log_file: log_file.write(f"OOM error occurred. Reducing batch size to {batch_size}\n") torch.cuda.empty_cache() continue # After processing each batch, move temp JSONL to main JSONL if os.path.exists(temp_jsonl): with open(temp_jsonl, 'r') as temp, open(main_jsonl, 'a') as main: shutil.copyfileobj(temp, main) os.remove(temp_jsonl) # Clear GPU cache after each batch if gpu_id >= 0: torch.cuda.empty_cache() success_count = sum(1 for _, status, _ in results if status == "Success") timeout_count = sum(1 for _, status, _ in results if status == "Timeout") error_count = len(results) - success_count - timeout_count with open(log_file_path, 'a') as log_file: log_file.write( f"Processed {len(results)} PDFs. {success_count} succeeded, {timeout_count} timed out, {error_count} failed.\n") with open(os.path.join(output_folder, 'processing_summary.txt'), 'w') as summary: summary.write(f"Total PDFs processed: {len(results)}\n") summary.write(f"Successful: {success_count}\n") summary.write(f"Timed out: {timeout_count}\n") summary.write(f"Failed: {error_count}\n\n") summary.write("Failed PDFs:\n") for pdf, status, _ in [result for result in results if result[1] != "Success"]: summary.write(f" - {pdf}: {status}\n") if __name__ == '__main__': main()