Upload scrpt27.py with huggingface_hub

scrpt27.py

@@ -20,6 +20,7 @@ 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')
@@ -28,6 +29,7 @@ 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")
@@ -39,31 +41,35 @@ def parse_arguments():
     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_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
@@ -73,7 +79,8 @@ class MagicModel:
         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")
+            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:
@@ -106,6 +113,7 @@ class MagicModel:
             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]
@@ -134,17 +142,18 @@ def process_single_pdf(input_file, output_folder, gpu_id, config, timeout, use_b
             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")
+                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
@@ -153,7 +162,7 @@ def process_single_pdf(input_file, output_folder, gpu_id, config, timeout, use_b
         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']
@@ -172,26 +181,22 @@ def process_single_pdf(input_file, output_folder, gpu_id, config, timeout, use_b
             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"  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
-        try:
-            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")
+        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")
 
-        except Exception as e:
-            with open(log_file_path, 'a') as log_file:
-                log_file.write(f"Error in classify function for {input_file}: {str(e)}\n")
-            return input_file, f"Classification Error: {str(e)}", None
-        
         image_writer = DiskReaderWriter(output_subfolder)
         with open(log_file_path, 'a') as log_file:
             log_file.write(f"Image writer initialized: {image_writer}\n")
@@ -203,7 +208,7 @@ def process_single_pdf(input_file, output_folder, gpu_id, config, timeout, use_b
         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")
@@ -212,81 +217,58 @@ def process_single_pdf(input_file, output_folder, gpu_id, config, timeout, use_b
         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")
-        try:
-            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")
-        except Exception as e:
-            with open(log_file_path, 'a') as log_file:
-                log_file.write(f"Error in pipe_analyze for {input_file}: {str(e)}\n")
-            return input_file, f"pipe_analyze Error: {str(e)}", None
+        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")
-        
+            log_file.write(
+                f"parse_type after OCR check (expected: str): {parse_type}\n")
+
         # Process the PDF using the model
-        try:
-            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")
-        except Exception as e:
-            with open(log_file_path, 'a') as log_file:
-                log_file.write(f"Error in model processing for {input_file}: {str(e)}\n")
-            return input_file, f"Model Processing Error: {str(e)}", None
+        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")
 
-        try:
-            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")
-        except Exception as e:
-            with open(log_file_path, 'a') as log_file:
-                log_file.write(f"Error in pipe_mk_markdown for {input_file}: {str(e)}\n")
-                log_file.write(f"  parse_result (expected: dict): {parse_result}\n")
-            return input_file, f"pipe_mk_markdown Error: {str(e)}", None
+        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")
 
-        try:
-            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")
-        except Exception as e:
-            with open(log_file_path, 'a') as log_file:
-                log_file.write(f"Error in pipe_mk_uni_format for {input_file}: {str(e)}\n")
-                log_file.write(f"  parse_result (expected: dict): {parse_result}\n")
-            return input_file, f"pipe_mk_uni_format Error: {str(e)}", None
-        
         # 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
-        try:
-            do_parse(input_file, parse_type, output_subfolder, draw_bbox=True)
-        except Exception as e:
-            with open(log_file_path, 'a') as log_file:
-                log_file.write(f"Error in do_parse for {input_file}: {str(e)}\n")
-            return input_file, f"do_parse Error: {str(e)}", None
-        
+        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")
-        
+            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,
@@ -296,7 +278,7 @@ def process_single_pdf(input_file, output_folder, gpu_id, config, timeout, use_b
             "classification": classification_results,
             "is_text_pdf": is_text_pdf
         }
-        
+
         return input_file, "Success", result
 
     except ValueError as ve:
@@ -310,15 +292,22 @@ def process_single_pdf(input_file, output_folder, gpu_id, config, timeout, use_b
         return input_file, "Timeout", None
 
     except Exception as e:
-        with open(log_file_path, 'a') as log_file:
-            log_file.write(f"Error occurred: {str(e)}\n")
-        return input_file, f"Error: {str(e)}", None
+        # 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:
@@ -326,6 +315,7 @@ def process_pdf_batch(batch, output_folder, gpu_id, config, timeout, use_bf16, m
         results.append(result)
     return results
 
+
 def write_to_jsonl(results, output_file):
     with open(output_file, 'a') as f:
         for result in results:
@@ -333,6 +323,7 @@ def write_to_jsonl(results, output_file):
                 json.dump(result[2], f)
                 f.write('\n')
 
+
 def get_gpu_memory_usage(gpu_id):
     if gpu_id < 0:
         return 0, 0  # CPU mode
@@ -340,18 +331,19 @@ def get_gpu_memory_usage(gpu_id):
     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.")
@@ -359,20 +351,20 @@ def main():
         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:
@@ -382,16 +374,18 @@ def main():
             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)
+                    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")
+                        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
@@ -404,24 +398,25 @@ def main():
                         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")
-    
+        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")
@@ -431,5 +426,6 @@ def main():
         for pdf, status, _ in [result for result in results if result[1] != "Success"]:
             summary.write(f"  - {pdf}: {status}\n")
 
+
 if __name__ == '__main__':
     main()