Update mdr_pdf_parser.py

mdr_pdf_parser.py

@@ -38,15 +38,16 @@ from PIL.ImageOps import expand as pil_expand
 from PIL import ImageDraw
 from PIL.ImageFont import load_default, FreeTypeFont
 from shapely.geometry import Polygon
-import pyclipper # Used in onnxocr/db_postprocess
+import pyclipper
 from unicodedata import category
 from alphabet_detector import AlphabetDetector
-from munch import Munch # Required by latex.py (pix2tex wrapper)
-from transformers import LayoutLMv3ForTokenClassification # Required by layout_order/layoutreader
-import onnxruntime # Required by onnxocr components
+from munch import Munch
+from transformers import LayoutLMv3ForTokenClassification
+import onnxruntime
+# --- HUGGING FACE HUB IMPORT ONLY BECAUSE RUNNING IN SPACES NOT NECESSARY IN PROD ---
+from huggingface_hub import hf_hub_download, HfHubDownloadError
 
-# --- Potentially Installable External Dependencies ---
-# Ensure these are installed or available in your environment
+# --- External Dependencies ---
 try:
     from doclayout_yolo import YOLOv10
 except ImportError:
@@ -58,14 +59,14 @@ except ImportError:
     print("Warning: Could not import LatexOCR from pix2tex.cli. LaTeX extraction will fail.")
     LatexOCR = None
 try:
-    # Dynamic import within MDRTableParser, assuming struct_eqtable.py exists or is installable
     pass # from struct_eqtable import build_model
 except ImportError:
     print("Warning: Could not import build_model from struct_eqtable. Table parsing might fail.")
 
 # --- MagicDataReadiness Core Components ---
 
-# --- MDR Utilities (downloader.py) ---
+# --- MDR Utilities ---
+
 def mdr_download_model(url: str, file_path: Path):
   """Downloads a model file from a URL to a local path."""
   try:
@@ -85,7 +86,7 @@ def mdr_download_model(url: str, file_path: Path):
     if file_path.exists(): os.remove(file_path)
     raise e
 
-# --- MDR Utilities (utils.py from doc_page_extractor internals) ---
+# --- MDR Utilities ---
 def mdr_ensure_directory(path: str) -> str:
   """Ensures a directory exists, creating it if necessary."""
   path = os.path.abspath(path)
@@ -146,79 +147,101 @@ def mdr_intersection_area(rect1: MDRRectangle, rect2: MDRRectangle) -> float:
     return p1.intersection(p2).area
   except: return 0.0
 
-# --- MDR Data Structures (ExtractedResult.py) ---
+# --- MDR Data Structures ---
 @dataclass
 class MDROcrFragment:
   """Represents a fragment of text identified by OCR."""
   order: int; text: str; rank: float; rect: MDRRectangle
+
 class MDRLayoutClass(Enum):
   """Enumeration of different layout types identified."""
   TITLE=0; PLAIN_TEXT=1; ABANDON=2; FIGURE=3; FIGURE_CAPTION=4; TABLE=5; TABLE_CAPTION=6; TABLE_FOOTNOTE=7; ISOLATE_FORMULA=8; FORMULA_CAPTION=9
+
 class MDRTableLayoutParsedFormat(Enum):
   """Enumeration for formats of parsed table content."""
   LATEX=auto(); MARKDOWN=auto(); HTML=auto()
+
 @dataclass
 class MDRBaseLayoutElement:
   """Base class for layout elements found on a page."""
   rect: MDRRectangle; fragments: list[MDROcrFragment]
+
 @dataclass
 class MDRPlainLayoutElement(MDRBaseLayoutElement):
   """Layout element for plain text, titles, captions, figures, etc."""
   cls: Literal[MDRLayoutClass.TITLE, MDRLayoutClass.PLAIN_TEXT, MDRLayoutClass.ABANDON, MDRLayoutClass.FIGURE, MDRLayoutClass.FIGURE_CAPTION, MDRLayoutClass.TABLE_CAPTION, MDRLayoutClass.TABLE_FOOTNOTE, MDRLayoutClass.FORMULA_CAPTION]
+
 @dataclass
 class MDRTableLayoutElement(MDRBaseLayoutElement):
   """Layout element specifically for tables."""
   parsed: tuple[str, MDRTableLayoutParsedFormat] | None; cls: Literal[MDRLayoutClass.TABLE] = MDRLayoutClass.TABLE
+
 @dataclass
 class MDRFormulaLayoutElement(MDRBaseLayoutElement):
   """Layout element specifically for formulas."""
   latex: str | None; cls: Literal[MDRLayoutClass.ISOLATE_FORMULA] = MDRLayoutClass.ISOLATE_FORMULA
+
 MDRLayoutElement = MDRPlainLayoutElement | MDRTableLayoutElement | MDRFormulaLayoutElement # Type alias
+
 @dataclass
 class MDRExtractionResult:
   """Holds the complete result of extracting from a single page image."""
   rotation: float; layouts: list[MDRLayoutElement]; extracted_image: Image; adjusted_image: Image | None
 
-# --- MDR Data Structures (types.py - Original script 4) ---
+# --- MDR Data Structures ---
+
 MDRProgressReportCallback: TypeAlias = Callable[[int, int], None]
+
 class MDROcrLevel(Enum): Once=auto(); OncePerLayout=auto()
+
 class MDRExtractedTableFormat(Enum): LATEX=auto(); MARKDOWN=auto(); HTML=auto(); DISABLE=auto()
+
 class MDRTextKind(Enum): TITLE=0; PLAIN_TEXT=1; ABANDON=2
+
 @dataclass
 class MDRTextSpan:
   """Represents a span of text content within a block."""
   content: str; rank: float; rect: MDRRectangle
+
 @dataclass
 class MDRBasicBlock:
   """Base class for structured blocks extracted from the document."""
   rect: MDRRectangle; texts: list[MDRTextSpan]; font_size: float # Relative font size (0-1)
+
 @dataclass
 class MDRTextBlock(MDRBasicBlock):
   """A structured block containing text content."""
   kind: MDRTextKind; has_paragraph_indentation: bool = False; last_line_touch_end: bool = False
+
 class MDRTableFormat(Enum): LATEX=auto(); MARKDOWN=auto(); HTML=auto(); UNRECOGNIZABLE=auto()
+
 @dataclass
 class MDRTableBlock(MDRBasicBlock):
   """A structured block representing a table."""
   content: str; format: MDRTableFormat; image: Image # Image clip of the table
+
 @dataclass
 class MDRFormulaBlock(MDRBasicBlock):
   """A structured block representing a formula."""
   content: str | None; image: Image # Image clip of the formula
+
 @dataclass
 class MDRFigureBlock(MDRBasicBlock):
   """A structured block representing a figure/image."""
   image: Image # Image clip of the figure
+
 MDRAssetBlock = MDRTableBlock | MDRFormulaBlock | MDRFigureBlock # Type alias
+
 MDRStructuredBlock = MDRTextBlock | MDRAssetBlock # Type alias
 
-# --- MDR Utilities (utils.py - Original script 3) ---
+# --- MDR Utilities ---
 def mdr_similarity_ratio(v1: float, v2: float) -> float:
   """Calculates the ratio of the smaller value to the larger value (0-1)."""
   if v1==0 and v2==0: return 1.0;
   if v1<0 or v2<0: return 0.0;
   v1, v2 = (v2, v1) if v1 > v2 else (v1, v2);
   return 1.0 if v2==0 else v1/v2
+
 def mdr_intersection_bounds_size(r1: MDRRectangle, r2: MDRRectangle) -> tuple[float, float]:
   """Calculates width/height of the intersection bounding box."""
   try:
@@ -228,18 +251,23 @@ def mdr_intersection_bounds_size(r1: MDRRectangle, r2: MDRRectangle) -> tuple[fl
     if inter.is_empty: return 0.0, 0.0;
     minx, miny, maxx, maxy = inter.bounds; return maxx-minx, maxy-miny
   except: return 0.0, 0.0
+
 _MDR_CJKA_PATTERN = re.compile(r"[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7a3\u0600-\u06ff]")
+
 def mdr_contains_cjka(text: str):
   """Checks if text contains Chinese, Japanese, Korean, or Arabic chars."""
   return bool(_MDR_CJKA_PATTERN.search(text)) if text else False
 
-# --- MDR Text Processing (text_matcher.py - Original script 7) ---
+# --- MDR Text Processing ---
 class _MDR_TokenPhase(Enum): Init=0; Letter=1; Character=2; Number=3; Space=4
+
 _mdr_alphabet_detector = AlphabetDetector()
+
 def _mdr_is_letter(char: str):
   if not category(char).startswith("L"): return False
   try: return _mdr_alphabet_detector.is_latin(char) or _mdr_alphabet_detector.is_cyrillic(char) or _mdr_alphabet_detector.is_greek(char) or _mdr_alphabet_detector.is_hebrew(char)
   except: return False
+
 def mdr_split_into_words(text: str):
   """Splits text into words, numbers, and individual non-alphanumeric chars."""
   if not text: return;
@@ -259,6 +287,7 @@ def mdr_split_into_words(text: str):
       if is_s: phase=_MDR_TokenPhase.Space
       else: yield char; phase=_MDR_TokenPhase.Character
   if phase in (_MDR_TokenPhase.Letter, _MDR_TokenPhase.Number): w=buf.getvalue(); yield w if w else None
+
 def mdr_check_text_similarity(t1: str, t2: str) -> tuple[float, int]:
   """Calculates word-based similarity between two texts."""
   w1, w2 = list(mdr_split_into_words(t1)), list(mdr_split_into_words(t2)); l1, l2 = len(w1), len(w2)
@@ -271,21 +300,25 @@ def mdr_check_text_similarity(t1: str, t2: str) -> tuple[float, int]:
       if not taken[i] and word1==word2: taken[i]=True; matches+=1; break
   mismatches = l2 - matches; return 1.0 - (mismatches/l2), l2
 
-# --- MDR Geometry Processing (rotation.py) ---
+# --- MDR Geometry Processing ---
 class MDRRotationAdjuster:
   """Adjusts point coordinates based on image rotation."""
+  
   def __init__(self, origin_size: tuple[int, int], new_size: tuple[int, int], rotation: float, to_origin_coordinate: bool):
     fs, ts = (new_size, origin_size) if to_origin_coordinate else (origin_size, new_size)
     self._rot = rotation if to_origin_coordinate else -rotation
     self._c_off = (fs[0]/2.0, fs[1]/2.0); self._n_off = (ts[0]/2.0, ts[1]/2.0)
+  
   def adjust(self, point: MDRPoint) -> MDRPoint:
     x, y = point[0]-self._c_off[0], point[1]-self._c_off[1]
     if x!=0 or y!=0: cos_r, sin_r = cos(self._rot), sin(self._rot); x, y = x*cos_r-y*sin_r, x*sin_r+y*cos_r
     return x+self._n_off[0], y+self._n_off[1]
+
 def mdr_normalize_vertical_rotation(rot: float) -> float:
   while rot >= pi: rot -= pi;
   while rot < 0: rot += pi;
   return rot
+
 def _mdr_get_rectangle_angles(rect: MDRRectangle) -> tuple[list[float], list[float]] | None:
   h_angs, v_angs = [], []
   for i, (p1, p2) in enumerate(rect.segments):
@@ -297,11 +330,15 @@ def _mdr_get_rectangle_angles(rect: MDRRectangle) -> tuple[list[float], list[flo
     else: v_angs.append(ang)
   if not h_angs or not v_angs: return None
   return h_angs, v_angs
+
 def _mdr_normalize_horizontal_angles(rots: list[float]) -> list[float]: return rots
+
 def _mdr_find_median(data: list[float]) -> float:
   if not data: return 0.0; s_data = sorted(data); n = len(s_data);
   return s_data[n//2] if n%2==1 else (s_data[n//2-1]+s_data[n//2])/2.0
+
 def _mdr_find_mean(data: list[float]) -> float: return sum(data)/len(data) if data else 0.0
+
 def mdr_calculate_image_rotation(frags: list[MDROcrFragment]) -> float:
   all_h, all_v = [], [];
   for f in frags:
@@ -314,6 +351,7 @@ def mdr_calculate_image_rotation(frags: list[MDROcrFragment]) -> float:
   while rot_est >= pi/2: rot_est -= pi;
   while rot_est < -pi/2: rot_est += pi;
   return rot_est
+
 def mdr_calculate_rectangle_rotation(rect: MDRRectangle) -> tuple[float, float]:
   res = _mdr_get_rectangle_angles(rect);
   if res is None: return 0.0, pi/2.0;
@@ -321,9 +359,10 @@ def mdr_calculate_rectangle_rotation(rect: MDRRectangle) -> tuple[float, float]:
   h_rots = _mdr_normalize_horizontal_angles(h_rots); v_rots = [mdr_normalize_vertical_rotation(a) for a in v_rots]
   return _mdr_find_mean(h_rots), _mdr_find_mean(v_rots)
 
-# --- MDR ONNX OCR Internals (predict_base.py) ---
+# --- MDR ONNX OCR Internals ---
 class _MDR_PredictBase:
   """Base class for ONNX model prediction components."""
+  
   def get_onnx_session(self, model_path: str, use_gpu: bool):
     try:
         sess_opts = onnxruntime.SessionOptions(); sess_opts.log_severity_level = 3
@@ -336,24 +375,32 @@ class _MDR_PredictBase:
         if use_gpu and 'CUDAExecutionProvider' not in onnxruntime.get_available_providers():
              print("  CUDAExecutionProvider not available. Check ONNXRuntime-GPU installation and CUDA setup.")
         raise e
+  
   def get_output_name(self, sess: onnxruntime.InferenceSession) -> List[str]: return [n.name for n in sess.get_outputs()]
+  
   def get_input_name(self, sess: onnxruntime.InferenceSession) -> List[str]: return [n.name for n in sess.get_inputs()]
+  
   def get_input_feed(self, names: List[str], img_np: np.ndarray) -> Dict[str, np.ndarray]: return {name: img_np for name in names}
 
-# --- MDR ONNX OCR Internals (operators.py) ---
+# --- MDR ONNX OCR Internals ---
 class _MDR_NormalizeImage:
+  
   def __init__(self, scale=None, mean=None, std=None, order='chw', **kwargs):
     self.scale = np.float32(eval(scale) if isinstance(scale, str) else (scale if scale is not None else 1.0 / 255.0))
     mean = mean if mean is not None else [0.485, 0.456, 0.406]; std = std if std is not None else [0.229, 0.224, 0.225]
     shape = (3, 1, 1) if order == 'chw' else (1, 1, 3); self.mean = np.array(mean).reshape(shape).astype('float32'); self.std = np.array(std).reshape(shape).astype('float32')
+  
   def __call__(self, data): img = data['image']; img = np.array(img) if isinstance(img, Image) else img; data['image'] = (img.astype('float32') * self.scale - self.mean) / self.std; return data
+
 class _MDR_DetResizeForTest:
+  
   def __init__(self, **kwargs):
     self.resize_type = 0; self.keep_ratio = False
     if 'image_shape' in kwargs: self.image_shape = kwargs['image_shape']; self.resize_type = 1; self.keep_ratio = kwargs.get('keep_ratio', False)
     elif 'limit_side_len' in kwargs: self.limit_side_len = kwargs['limit_side_len']; self.limit_type = kwargs.get('limit_type', 'min')
     elif 'resize_long' in kwargs: self.resize_type = 2; self.resize_long = kwargs.get('resize_long', 960)
     else: self.limit_side_len = 736; self.limit_type = 'min'
+  
   def __call__(self, data):
     img = data['image']; src_h, src_w, _ = img.shape
     if src_h + src_w < 64: img = self._pad(img)
@@ -362,21 +409,30 @@ class _MDR_DetResizeForTest:
     else: img, ratios = self._resize1(img)
     if img is None: return None
     data['image'] = img; data['shape'] = np.array([src_h, src_w, ratios[0], ratios[1]]); return data
+  
   def _pad(self, im, v=0): h,w,c=im.shape; p=np.zeros((max(32,h),max(32,w),c),np.uint8)+v; p[:h,:w,:]=im; return p
+  
   def _resize1(self, img): rh,rw=self.image_shape; oh,ow=img.shape[:2]; if self.keep_ratio: rw=ow*rh/oh; N=math.ceil(rw/32); rw=N*32; r_h,r_w=float(rh)/oh,float(rw)/ow; img=cv2.resize(img,(int(rw),int(rh))); return img,[r_h,r_w]
+  
   def _resize0(self, img): lsl=self.limit_side_len; h,w,_=img.shape; r=1.0; if self.limit_type=='max': r=float(lsl)/max(h,w) if max(h,w)>lsl else 1.0; elif self.limit_type=='min': r=float(lsl)/min(h,w) if min(h,w)<lsl else 1.0; elif self.limit_type=='resize_long': r=float(lsl)/max(h,w); else: raise Exception('Unsupported'); rh,rw=int(h*r),int(w*r); rh=max(int(round(rh/32)*32),32); rw=max(int(round(rw/32)*32),32); if int(rw)<=0 or int(rh)<=0: return None,(None,None); img=cv2.resize(img,(int(rw),int(rh))); r_h,r_w=rh/float(h),rw/float(w); return img,[r_h,r_w]
+  
   def _resize2(self, img): h,w,_=img.shape; rl=self.resize_long; r=float(rl)/max(h,w); rh,rw=int(h*r),int(w*r); ms=128; rh=(rh+ms-1)//ms*ms; rw=(rw+ms-1)//ms*ms; img=cv2.resize(img,(int(rw),int(rh))); r_h,r_w=rh/float(h),rw/float(w); return img,[r_h,r_w]
+
 class _MDR_ToCHWImage:
+  
   def __call__(self, data): img=data['image']; img=np.array(img) if isinstance(img,Image) else img; data['image']=img.transpose((2,0,1)); return data
+
 class _MDR_KeepKeys:
+  
   def __init__(self, keep_keys, **kwargs): self.keep_keys=keep_keys
+  
   def __call__(self, data): return [data[key] for key in self.keep_keys]
 
-# --- MDR ONNX OCR Internals (imaug.py) ---
 def mdr_ocr_transform(data, ops=None):
   ops = ops if ops is not None else [];
   for op in ops: data = op(data); if data is None: return None;
   return data
+
 def mdr_ocr_create_operators(op_param_list, global_config=None):
   ops = []
   for operator in op_param_list:
@@ -388,11 +444,12 @@ def mdr_ocr_create_operators(op_param_list, global_config=None):
     else: raise ValueError(f"Operator class '{op_class_name}' not found.")
   return ops
 
-# --- MDR ONNX OCR Internals (db_postprocess.py) ---
 class _MDR_DBPostProcess:
+  
   def __init__(self, thresh=0.3, box_thresh=0.7, max_candidates=1000, unclip_ratio=1.5, use_dilation=False, score_mode="fast", box_type='quad', **kwargs):
     self.thresh, self.box_thresh, self.max_cand = thresh, box_thresh, max_candidates; self.unclip_r, self.min_sz, self.score_m, self.box_t = unclip_ratio, 3, score_mode, box_type
     assert score_mode in ["slow", "fast"]; self.dila_k = np.array([[1,1],[1,1]], dtype=np.uint8) if use_dilation else None
+  
   def _polygons_from_bitmap(self, pred, bmp, dw, dh):
     h, w = bmp.shape; boxes, scores = [], []
     contours, _ = cv2.findContours((bmp*255).astype(np.uint8), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
@@ -409,6 +466,7 @@ class _MDR_DBPostProcess:
       box = np.array(box); box[:,0]=np.clip(np.round(box[:,0]/w*dw),0,dw); box[:,1]=np.clip(np.round(box[:,1]/h*dh),0,dh)
       boxes.append(box.tolist()); scores.append(score)
     return boxes, scores
+  
   def _boxes_from_bitmap(self, pred, bmp, dw, dh):
     h, w = bmp.shape; contours, _ = cv2.findContours((bmp*255).astype(np.uint8), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
     num_contours = min(len(contours), self.max_cand); boxes, scores = [], []
@@ -424,25 +482,30 @@ class _MDR_DBPostProcess:
       box = np.array(box); box[:,0]=np.clip(np.round(box[:,0]/w*dw),0,dw); box[:,1]=np.clip(np.round(box[:,1]/h*dh),0,dh)
       boxes.append(box.astype("int32")); scores.append(score)
     return np.array(boxes, dtype="int32"), scores
+  
   def _unclip(self, box, ratio):
     poly = Polygon(box); dist = poly.area*ratio/poly.length; offset = pyclipper.PyclipperOffset(); offset.AddPath(box, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
     expanded = offset.Execute(dist);
     if not expanded: raise ValueError("Unclip failed"); return np.array(expanded[0])
+  
   def _get_mini_boxes(self, contour):
     bb = cv2.minAreaRect(contour); pts = sorted(list(cv2.boxPoints(bb)), key=lambda x:x[0])
     i1,i4 = (0,1) if pts[1][1]>pts[0][1] else (1,0); i2,i3 = (2,3) if pts[3][1]>pts[2][1] else (3,2)
     box = [pts[i1], pts[i2], pts[i3], pts[i4]]; return box, min(bb[1])
+  
   def _box_score_fast(self, bmp, box):
     h,w = bmp.shape[:2]; xmin=np.clip(np.floor(box[:,0].min()).astype("int32"),0,w-1); xmax=np.clip(np.ceil(box[:,0].max()).astype("int32"),0,w-1)
     ymin=np.clip(np.floor(box[:,1].min()).astype("int32"),0,h-1); ymax=np.clip(np.ceil(box[:,1].max()).astype("int32"),0,h-1)
     mask = np.zeros((ymax-ymin+1, xmax-xmin+1), dtype=np.uint8); box[:,0]-=xmin; box[:,1]-=ymin
     cv2.fillPoly(mask, box.reshape(1,-1,2).astype("int32"), 1);
     return cv2.mean(bmp[ymin:ymax+1, xmin:xmax+1], mask)[0] if np.sum(mask)>0 else 0.0
+  
   def _box_score_slow(self, bmp, contour): # Not used if fast
     h,w = bmp.shape[:2]; contour = np.reshape(contour.copy(),(-1,2)); xmin=np.clip(np.min(contour[:,0]),0,w-1); xmax=np.clip(np.max(contour[:,0]),0,w-1)
     ymin=np.clip(np.min(contour[:,1]),0,h-1); ymax=np.clip(np.max(contour[:,1]),0,h-1); mask=np.zeros((ymax-ymin+1,xmax-xmin+1),dtype=np.uint8)
     contour[:,0]-=xmin; contour[:,1]-=ymin; cv2.fillPoly(mask, contour.reshape(1,-1,2).astype("int32"), 1);
     return cv2.mean(bmp[ymin:ymax+1, xmin:xmax+1], mask)[0] if np.sum(mask)>0 else 0.0
+  
   def __call__(self, outs_dict, shape_list):
     pred = outs_dict['maps'][:,0,:,:]; seg = pred > self.thresh; boxes_batch = []
     for batch_idx in range(pred.shape[0]):
@@ -453,8 +516,8 @@ class _MDR_DBPostProcess:
       boxes_batch.append({'points': boxes})
     return boxes_batch
 
-# --- MDR ONNX OCR Internals (predict_det.py) ---
 class _MDR_TextDetector(_MDR_PredictBase):
+  
   def __init__(self, args):
     super().__init__(); self.args = args
     pre_ops = [{'DetResizeForTest': {'limit_side_len': args.det_limit_side_len, 'limit_type': args.det_limit_type}}, {'NormalizeImage': {'std': [0.229,0.224,0.225], 'mean': [0.485,0.456,0.406], 'scale': '1./255.', 'order': 'hwc'}}, {'ToCHWImage': None}, {'KeepKeys': {'keep_keys': ['image', 'shape']}}]
@@ -463,10 +526,15 @@ class _MDR_TextDetector(_MDR_PredictBase):
     self.post_op = _MDR_DBPostProcess(**post_params)
     self.sess = self.get_onnx_session(args.det_model_dir, args.use_gpu)
     self.input_name = self.get_input_name(self.sess); self.output_name = self.get_output_name(self.sess)
+  
   def _order_pts(self, pts): r=np.zeros((4,2),dtype="float32"); s=pts.sum(axis=1); r[0]=pts[np.argmin(s)]; r[2]=pts[np.argmax(s)]; tmp=np.delete(pts,(np.argmin(s),np.argmax(s)),axis=0); d=np.diff(np.array(tmp),axis=1); r[1]=tmp[np.argmin(d)]; r[3]=tmp[np.argmax(d)]; return r
+  
   def _clip_pts(self, pts, h, w): pts[:,0]=np.clip(pts[:,0],0,w-1); pts[:,1]=np.clip(pts[:,1],0,h-1); return pts
+  
   def _filter_quad(self, boxes, shape): h,w=shape[0:2]; new_boxes=[]; for box in boxes: box=np.array(box) if isinstance(box,list) else box; box=self._order_pts(box); box=self._clip_pts(box,h,w); rw=int(np.linalg.norm(box[0]-box[1])); rh=int(np.linalg.norm(box[0]-box[3])); if rw<=3 or rh<=3: continue; new_boxes.append(box); return np.array(new_boxes)
+  
   def _filter_poly(self, boxes, shape): h,w=shape[0:2]; new_boxes=[]; for box in boxes: box=np.array(box) if isinstance(box,list) else box; box=self._clip_pts(box,h,w); if Polygon(box).area<10: continue; new_boxes.append(box); return np.array(new_boxes)
+  
   def __call__(self, img):
     ori_im = img.copy(); data = {"image": img}; data = mdr_ocr_transform(data, self.pre_op)
     if data is None: return None; img, shape_list = data;
@@ -475,25 +543,28 @@ class _MDR_TextDetector(_MDR_PredictBase):
     preds = {"maps": outputs[0]}; post_res = self.post_op(preds, shape_list); boxes = post_res[0]['points']
     return self._filter_poly(boxes, ori_im.shape) if self.args.det_box_type=='poly' else self._filter_quad(boxes, ori_im.shape)
 
-# --- MDR ONNX OCR Internals (cls_postprocess.py) ---
 class _MDR_ClsPostProcess:
+  
   def __init__(self, label_list=None, **kwargs): self.labels = label_list if label_list else {0:'0', 1:'180'}
+  
   def __call__(self, preds, label=None, *args, **kwargs):
     preds = np.array(preds) if not isinstance(preds, np.ndarray) else preds; idxs = preds.argmax(axis=1)
     return [(self.labels[idx], float(preds[i,idx])) for i,idx in enumerate(idxs)]
 
-# --- MDR ONNX OCR Internals (predict_cls.py) ---
 class _MDR_TextClassifier(_MDR_PredictBase):
+  
   def __init__(self, args):
     super().__init__(); self.shape = tuple(map(int, args.cls_image_shape.split(','))) if isinstance(args.cls_image_shape, str) else args.cls_image_shape
     self.batch_num = args.cls_batch_num; self.thresh = args.cls_thresh; self.post_op = _MDR_ClsPostProcess(label_list=args.label_list)
     self.sess = self.get_onnx_session(args.cls_model_dir, args.use_gpu); self.input_name = self.get_input_name(self.sess); self.output_name = self.get_output_name(self.sess)
+  
   def _resize_norm(self, img):
     imgC,imgH,imgW = self.shape; h,w = img.shape[:2]; r=w/float(h) if h>0 else 0; rw=int(math.ceil(imgH*r)); rw=min(rw,imgW)
     resized = cv2.resize(img,(rw,imgH)); resized = resized.astype("float32")
     if imgC==1: resized = resized/255.0; resized = resized[np.newaxis,:]
     else: resized = resized.transpose((2,0,1))/255.0
     resized -= 0.5; resized /= 0.5; padding = np.zeros((imgC,imgH,imgW),dtype=np.float32); padding[:,:,0:rw]=resized; return padding
+  
   def __call__(self, img_list):
     if not img_list: return img_list, []; img_list_cp = copy.deepcopy(img_list); num = len(img_list_cp)
     ratios = [img.shape[1]/float(img.shape[0]) if img.shape[0]>0 else 0 for img in img_list_cp]; indices = np.argsort(np.array(ratios))
@@ -509,8 +580,8 @@ class _MDR_TextClassifier(_MDR_PredictBase):
         if "180" in label and score > self.thresh: img_list[orig_idx] = cv2.rotate(img_list[orig_idx], cv2.ROTATE_180)
     return img_list, results
 
-# --- MDR ONNX OCR Internals (rec_postprocess.py) ---
 class _MDR_BaseRecLabelDecode:
+  
   def __init__(self, char_path=None, use_space=False):
     self.beg, self.end, self.rev = "sos", "eos", False; self.chars = []
     if char_path is None: self.chars = list("0123456789abcdefghijklmnopqrstuvwxyz")
@@ -521,9 +592,13 @@ class _MDR_BaseRecLabelDecode:
         if any("\u0600"<=c<="\u06FF" for c in self.chars): self.rev=True
       except FileNotFoundError: print(f"Warn: Dict not found {char_path}"); self.chars=list("0123456789abcdefghijklmnopqrstuvwxyz"); if use_space: self.chars.append(" ")
     d_char = self.add_special_char(list(self.chars)); self.dict={c:i for i,c in enumerate(d_char)}; self.character=d_char
+  
   def add_special_char(self, chars): return chars
+  
   def get_ignored_tokens(self): return []
+  
   def _reverse(self, pred): res=[]; cur=""; for c in pred: if not re.search("[a-zA-Z0-9 :*./%+-]",c): res.extend([cur,c] if cur!="" else [c]); cur="" else: cur+=c; if cur!="": res.append(cur); return "".join(res[::-1])
+  
   def decode(self, idxs, probs=None, remove_dup=False):
     res=[]; ignored=self.get_ignored_tokens(); bs=len(idxs)
     for b_idx in range(bs):
@@ -537,6 +612,7 @@ class _MDR_BaseRecLabelDecode:
       if self.rev: txt=self._reverse(txt)
       res.append((txt, float(np.mean(conf_l))))
     return res
+
 class _MDR_CTCLabelDecode(_MDR_BaseRecLabelDecode):
   def __init__(self, char_path=None, use_space=False, **kwargs): super().__init__(char_path, use_space)
   def add_special_char(self, chars): return ["blank"]+chars
@@ -545,13 +621,14 @@ class _MDR_CTCLabelDecode(_MDR_BaseRecLabelDecode):
     preds = preds[-1] if isinstance(preds,(tuple,list)) else preds; preds = np.array(preds) if not isinstance(preds,np.ndarray) else preds
     idxs=preds.argmax(axis=2); probs=preds.max(axis=2); txt=self.decode(idxs, probs, remove_dup=True); return txt
 
-# --- MDR ONNX OCR Internals (predict_rec.py) ---
 class _MDR_TextRecognizer(_MDR_PredictBase):
+
   def __init__(self, args):
     super().__init__(); shape_str=getattr(args,'rec_image_shape',"3,48,320"); self.shape=tuple(map(int,shape_str.split(',')))
     self.batch_num=getattr(args,'rec_batch_num',6); self.algo=getattr(args,'rec_algorithm','SVTR_LCNet')
     self.post_op=_MDR_CTCLabelDecode(char_path=args.rec_char_dict_path, use_space=getattr(args,'use_space_char',True))
     self.sess=self.get_onnx_session(args.rec_model_dir, args.use_gpu); self.input_name=self.get_input_name(self.sess); self.output_name=self.get_output_name(self.sess)
+  
   def _resize_norm(self, img, max_r):
     imgC,imgH,imgW = self.shape; h,w = img.shape[:2];
     if h==0 or w==0: return np.zeros((imgC,imgH,imgW),dtype=np.float32)
@@ -561,6 +638,7 @@ class _MDR_TextRecognizer(_MDR_PredictBase):
     if len(resized.shape)==2: resized=resized[:,:,np.newaxis]
     resized=resized.transpose((2,0,1))/255.0; resized-=0.5; resized/=0.5
     padding=np.zeros((imgC,imgH,imgW),dtype=np.float32); padding[:,:,0:tw]=resized; return padding
+  
   def __call__(self, img_list):
     if not img_list: return []; num=len(img_list); ratios=[img.shape[1]/float(img.shape[0]) if img.shape[0]>0 else 0 for img in img_list]
     indices=np.argsort(np.array(ratios)); results=[["",0.0]]*num; batch_n=self.batch_num
@@ -574,8 +652,9 @@ class _MDR_TextRecognizer(_MDR_PredictBase):
       for i in range(len(rec_out)): results[indices[start+i]]=rec_out[i]
     return results
 
-# --- MDR ONNX OCR System (predict_system.py) ---
+# --- MDR ONNX OCR System ---
 class _MDR_TextSystem:
+  
   def __init__(self, args):
     class ArgsObject: # Helper to access dict args with dot notation
         def __init__(self, **entries): self.__dict__.update(entries)
@@ -587,11 +666,13 @@ class _MDR_TextSystem:
     self.drop_score = getattr(args, 'drop_score', 0.5)
     self.classifier = _MDR_TextClassifier(args) if self.use_cls else None
     self.crop_idx = 0; self.save_crop = getattr(args, 'save_crop_res', False); self.crop_dir = getattr(args, 'crop_res_save_dir', "./output/mdr_crop_res")
+  
   def _sort_boxes(self, boxes):
     if boxes is None or len(boxes)==0: return []
     def key(box): min_y=min(p[1] for p in box); min_x=min(p[0] for p in box); return (min_y, min_x)
     try: return list(sorted(boxes, key=key))
     except: return list(boxes) # Fallback
+  
   def __call__(self, img, classify=True):
     ori_im = img.copy(); boxes = self.detector(img)
     if boxes is None or len(boxes)==0: return [], []
@@ -613,12 +694,13 @@ class _MDR_TextSystem:
         if score >= self.drop_score: final_boxes.append(box); final_rec.append(res)
     if self.save_crop: self._save_crops(crops, rec_res)
     return final_boxes, final_rec
+  
   def _save_crops(self, crops, recs):
       mdr_ensure_directory(self.crop_dir); num = len(crops)
       for i in range(num): txt, score = recs[i]; safe=re.sub(r'\W+', '_', txt)[:20]; fname=f"crop_{self.crop_idx+i}_{safe}_{score:.2f}.jpg"; cv2.imwrite(os.path.join(self.crop_dir, fname), crops[i])
       self.crop_idx += num
 
-# --- MDR ONNX OCR Utilities (onnxocr/utils.py) ---
+# --- MDR ONNX OCR Utilities ---
 def mdr_get_rotated_crop(img, points):
   """Crops and perspective-transforms a quadrilateral region."""
   pts = np.array(points, dtype="float32"); assert len(pts)==4
@@ -630,14 +712,17 @@ def mdr_get_rotated_crop(img, points):
   dh, dw = dst.shape[0:2]
   if dh>0 and dw>0 and dh*1.0/dw >= 1.5: dst = cv2.rotate(dst, cv2.ROTATE_90_CLOCKWISE)
   return dst
+
 def mdr_get_min_area_crop(img, points):
   """Crops the minimum area rectangle containing the points."""
   bb = cv2.minAreaRect(np.array(points).astype(np.int32)); box_pts = cv2.boxPoints(bb)
   return mdr_get_rotated_crop(img, box_pts)
 
-# --- MDR Layout Processing (overlap.py) ---
+# --- MDR Layout Processing ---
 _MDR_INCLUDES_MIN_RATE = 0.99
+
 class _MDR_OverlapMatrixContext:
+  
   def __init__(self, layouts: list[MDRLayoutElement]):
     length = len(layouts); self.polys: list[Polygon|None] = []
     for l in layouts:
@@ -651,6 +736,7 @@ class _MDR_OverlapMatrixContext:
         p2 = self.polys[j];
         if p2 is None: continue
         r_ij = self._rate(p1, p2); r_ji = self._rate(p2, p1); self.matrix[i][j]=r_ij; self.matrix[j][i]=r_ji
+  
   def _rate(self, p1: Polygon, p2: Polygon) -> float: # Rate p1 covers p2
       try: inter = p1.intersection(p2);
       except: return 0.0
@@ -659,9 +745,11 @@ class _MDR_OverlapMatrixContext:
       _, _, px1, py1 = p2.bounds; pw, ph = px1-p2.bounds[0], py1-p2.bounds[1]
       if pw < 1e-6 or ph < 1e-6: return 0.0
       wr = min(iw/pw, 1.0); hr = min(ih/ph, 1.0); return (wr+hr)/2.0
+  
   def others(self, idx: int):
     for i, r in enumerate(self.matrix[idx]):
       if i != idx and i not in self.removed: yield r
+  
   def includes(self, idx: int): # Layouts included BY idx
     for i, r in enumerate(self.matrix[idx]):
       if i != idx and i not in self.removed and r >= _MDR_INCLUDES_MIN_RATE:
@@ -723,8 +811,9 @@ def mdr_merge_fragments_into_lines(orig_frags: list[MDROcrFragment]) -> list[MDR
   for i, f in enumerate(merged): f.order = i
   return merged
 
-# --- MDR Layout Processing (ocr_corrector.py) ---
+# --- MDR Layout Processing ---
 _MDR_CORRECTION_MIN_OVERLAP = 0.5
+
 def mdr_correct_layout_fragments(ocr_engine: 'MDROcrEngine', source_img: Image, layout: MDRLayoutElement):
   if not layout.fragments: return;
   try:
@@ -759,9 +848,12 @@ def mdr_correct_layout_fragments(ocr_engine: 'MDROcrEngine', source_img: Image,
   final = [n if n.rank >= o.rank else o for o, n in matched]; final.extend(unmatched_orig); final.extend(unmatched_new)
   layout.fragments = final; layout.fragments.sort(key=lambda f: (f.rect.lt[1], f.rect.lt[0]))
 
-# --- MDR OCR Engine (ocr.py) ---
+# --- MDR OCR Engine ---
+
 _MDR_OCR_MODELS = {"det": ("ppocrv4","det","det.onnx"), "cls": ("ppocrv4","cls","cls.onnx"), "rec": ("ppocrv4","rec","rec.onnx"), "keys": ("ch_ppocr_server_v2.0","ppocr_keys_v1.txt")}
+
 _MDR_OCR_URL_BASE = "https://huggingface.co/moskize/OnnxOCR/resolve/main/"
+
 @dataclass
 class _MDR_ONNXParams: # Simplified container
     use_gpu: bool; det_model_dir: str; cls_model_dir: str; rec_model_dir: str; rec_char_dict_path: str
@@ -772,14 +864,17 @@ class _MDR_ONNXParams: # Simplified container
 
 class MDROcrEngine:
   """Handles OCR detection and recognition using ONNX models."""
+  
   def __init__(self, device: Literal["cpu", "cuda"], model_dir_path: str):
     self._device = device; self._model_dir = mdr_ensure_directory(model_dir_path)
     self._text_system: _MDR_TextSystem | None = None; self._onnx_params: _MDR_ONNXParams | None = None
     self._ensure_models(); self._get_system() # Init on creation
+  
   def _ensure_models(self):
     for key, parts in _MDR_OCR_MODELS.items():
         fp = Path(self._model_dir) / Path(*parts)
         if not fp.exists(): print(f"Downloading MDR OCR model: {fp.name}..."); url = _MDR_OCR_URL_BASE + "/".join(parts); mdr_download_model(url, fp)
+  
   def _get_system(self) -> _MDR_TextSystem | None:
     if self._text_system is None:
         paths = {k: str(Path(self._model_dir)/Path(*p)) for k,p in _MDR_OCR_MODELS.items()}
@@ -787,6 +882,7 @@ class MDROcrEngine:
         try: self._text_system = _MDR_TextSystem(self._onnx_params); print(f"MDR OCR System initialized.")
         except Exception as e: print(f"ERROR initializing MDR OCR System: {e}"); self._text_system = None
     return self._text_system
+  
   def find_text_fragments(self, image_np: np.ndarray) -> Generator[MDROcrFragment, None, None]:
     """Finds and recognizes text fragments in a NumPy image (BGR)."""
     system = self._get_system()
@@ -799,22 +895,26 @@ class MDROcrEngine:
       if not txt or mdr_is_whitespace(txt) or conf < 0.1: continue
       pts = [(float(p[0]), float(p[1])) for p in box_pts]
       if len(pts)==4: r=MDRRectangle(lt=pts[0], rt=pts[1], rb=pts[2], lb=pts[3]); if r.is_valid and r.area>1: yield MDROcrFragment(order=-1, text=txt, rank=float(conf), rect=r)
+  
   def _preprocess(self, img: np.ndarray) -> np.ndarray:
     if len(img.shape)==3 and img.shape[2]==4: a=img[:,:,3]/255.0; bg=(255,255,255); new=np.zeros_like(img[:,:,:3]); [setattr(new[:,:,i], 'flags.writeable', True) for i in range(3)]; [np.copyto(new[:,:,i], (bg[i]*(1-a)+img[:,:,i]*a)) for i in range(3)]; img=new.astype(np.uint8)
     elif len(img.shape)==2: img=cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
     elif not (len(img.shape)==3 and img.shape[2]==3): raise ValueError("Unsupported image format")
     return img
 
-# --- MDR Layout Reading Internals (layoutreader.py) ---
+# --- MDR Layout Reading Internals ---
 _MDR_MAX_LEN = 510; _MDR_CLS_ID = 0; _MDR_SEP_ID = 2; _MDR_PAD_ID = 1
+
 def mdr_boxes_to_reader_inputs(boxes: List[List[int]], max_len=_MDR_MAX_LEN) -> Dict[str, torch.Tensor]:
     t_boxes = boxes[:max_len]; i_boxes = [[0,0,0,0]] + t_boxes + [[0,0,0,0]]
     i_ids = [_MDR_CLS_ID] + [_MDR_PAD_ID]*len(t_boxes) + [_MDR_SEP_ID]
     a_mask = [1]*len(i_ids); pad_len = (max_len+2) - len(i_ids)
     if pad_len > 0: i_boxes.extend([[0,0,0,0]]*pad_len); i_ids.extend([_MDR_PAD_ID]*pad_len); a_mask.extend([0]*pad_len)
     return {"bbox": torch.tensor([i_boxes]), "input_ids": torch.tensor([i_ids]), "attention_mask": torch.tensor([a_mask])}
+
 def mdr_prepare_reader_inputs(inputs: Dict[str, torch.Tensor], model: LayoutLMv3ForTokenClassification) -> Dict[str, torch.Tensor]:
     return {k: v.to(model.device) if isinstance(v, torch.Tensor) else v for k, v in inputs.items()}
+
 def mdr_parse_reader_logits(logits: torch.Tensor, length: int) -> List[int]:
     if length == 0: return []; rel_logits = logits[1:length+1, :length]; orders = rel_logits.argmax(dim=1).tolist()
     while True:
@@ -830,14 +930,17 @@ def mdr_parse_reader_logits(logits: torch.Tensor, length: int) -> List[int]:
                     orders[idx] = rel_logits[idx, :].argmax().item(); rel_logits[idx, order] = orig_logit
     return orders
 
-# --- MDR Layout Reading Engine (layout_order.py) ---
+# --- MDR Layout Reading Engine ---
 @dataclass
 class _MDR_ReaderBBox: layout_index: int; fragment_index: int; virtual: bool; order: int; value: tuple[float, float, float, float]
+
 class MDRLayoutReader:
   """Determines reading order of layout elements using LayoutLMv3."""
+  
   def __init__(self, model_path: str):
     self._model_path = model_path; self._model: LayoutLMv3ForTokenClassification | None = None
     self._device = "cuda" if torch.cuda.is_available() else "cpu"
+  
   def _get_model(self) -> LayoutLMv3ForTokenClassification | None:
     if self._model is None:
       cache = mdr_ensure_directory(self._model_path); name = "microsoft/layoutlmv3-base"; h_path = os.path.join(cache, "models--hantian--layoutreader")
@@ -847,6 +950,7 @@ class MDRLayoutReader:
         self._model.to(self._device); self._model.eval(); print(f"MDR LayoutReader loaded on {self._device}.")
       except Exception as e: print(f"ERROR loading MDR LayoutReader: {e}"); self._model = None
     return self._model
+  
   def determine_reading_order(self, layouts: list[MDRLayoutElement], size: tuple[int, int]) -> list[MDRLayoutElement]:
     w, h = size;
     if w<=0 or h<=0 or not layouts: return layouts;
@@ -873,6 +977,7 @@ class MDRLayoutReader:
     if len(orders) != len(bbox_list): print("MDR LayoutReader order mismatch"); return layouts # Fallback
     for i, order_idx in enumerate(orders): bbox_list[i].order = order_idx
     return self._apply_order(layouts, bbox_list)
+  
   def _prepare_bboxes(self, layouts: list[MDRLayoutElement], w: int, h: int) -> list[_MDR_ReaderBBox] | None:
     line_h = self._estimate_line_h(layouts); bbox_list = []
     for i, l in enumerate(layouts):
@@ -880,6 +985,7 @@ class MDRLayoutReader:
       else: bbox_list.extend(self._gen_virtual(l, i, line_h, w, h))
     if len(bbox_list) > _MDR_MAX_LEN: print(f"Too many boxes ({len(bbox_list)}>{_MDR_MAX_LEN})"); return None
     bbox_list.sort(key=lambda b: (b.value[1], b.value[0])); return bbox_list
+  
   def _apply_order(self, layouts: list[MDRLayoutElement], bbox_list: list[_MDR_ReaderBBox]) -> list[MDRLayoutElement]:
     layout_map = defaultdict(list); [layout_map[b.layout_index].append(b) for b in bbox_list]
     layout_orders = [(idx, self._median([b.order for b in bboxes])) for idx, bboxes in layout_map.items() if bboxes]
@@ -893,9 +999,11 @@ class MDRLayoutReader:
         else: frags.sort(key=lambda f: (f.rect.lt[1], f.rect.lt[0]))
         for frag in frags: frag.order = nfo; nfo += 1
     return sorted_layouts
+  
   def _estimate_line_h(self, layouts: list[MDRLayoutElement]) -> float:
     heights = [f.rect.size[1] for l in layouts for f in l.fragments if f.rect.size[1]>0]
     return self._median(heights) if heights else 15.0
+  
   def _gen_virtual(self, l: MDRLayoutElement, l_idx: int, line_h: float, pw: int, ph: int) -> Generator[_MDR_ReaderBBox, None, None]:
     x0,y0,x1,y1 = l.rect.wrapper; lh,lw = y1-y0,x1-x0
     if lh<=0 or lw<=0 or line_h<=0: yield _MDR_ReaderBBox(l_idx,-1,True,-1,(x0,y0,x1,y1)); return
@@ -910,16 +1018,19 @@ class MDRLayoutReader:
       ly0,ly1 = max(0,min(ph,cur_y)), max(0,min(ph,cur_y+act_line_h)); lx0,lx1 = max(0,min(pw,x0)), max(0,min(pw,x1))
       if ly1>ly0 and lx1>lx0: yield _MDR_ReaderBBox(l_idx,-1,True,-1,(lx0,ly0,lx1,ly1))
       cur_y += act_line_h
+  
   def _median(self, nums: list[float|int]) -> float:
     if not nums: return 0.0; s_nums = sorted(nums); n = len(s_nums)
     return float(s_nums[n//2]) if n%2==1 else float((s_nums[n//2-1]+s_nums[n//2])/2.0)
 
-# --- MDR LaTeX Extractor (latex.py) ---
+# --- MDR LaTeX Extractor ---
 class MDRLatexExtractor:
   """Extracts LaTeX from formula images using pix2tex."""
+  
   def __init__(self, model_path: str):
     self._model_path = model_path; self._model: LatexOCR | None = None
     self._device = "cuda" if torch.cuda.is_available() else "cpu"
+  
   def extract(self, image: Image) -> str | None:
     if LatexOCR is None: return None;
     image = mdr_expand_image(image, 0.1); model = self._get_model()
@@ -927,6 +1038,7 @@ class MDRLatexExtractor:
     try:
         with torch.no_grad(): img_rgb = image.convert('RGB') if image.mode!='RGB' else image; latex = model(img_rgb); return latex if latex else None
     except Exception as e: print(f"MDR LaTeX error: {e}"); return None
+  
   def _get_model(self) -> LatexOCR | None:
     if self._model is None and LatexOCR is not None:
       mdr_ensure_directory(self._model_path); wp, rp, cp = Path(self._model_path)/"weights.pth", Path(self._model_path)/"image_resizer.pth", Path(self._model_path)/"config.yaml"
@@ -935,19 +1047,23 @@ class MDRLatexExtractor:
       try: args = Munch({"config":str(cp), "checkpoint":str(wp), "device":self._device, "no_cuda":self._device=="cpu", "no_resize":False, "temperature":0.0}); self._model = LatexOCR(args); print(f"MDR LaTeX loaded on {self._device}.")
       except Exception as e: print(f"ERROR initializing MDR LatexOCR: {e}"); self._model = None
     return self._model
+  
   def _download(self):
     tag = "v0.0.1"; base = f"https://github.com/lukas-blecher/LaTeX-OCR/releases/download/{tag}/"; files = {"weights.pth": base+"weights.pth", "image_resizer.pth": base+"image_resizer.pth"}
     mdr_ensure_directory(self._model_path); [mdr_download_model(url, Path(self._model_path)/name) for name, url in files.items() if not (Path(self._model_path)/name).exists()]
 
-# --- MDR Table Parser (table.py) ---
+# --- MDR Table Parser ---
 MDRTableOutputFormat = Literal["latex", "markdown", "html"]
+
 class MDRTableParser:
   """Parses table structure/content from images using StructTable model."""
+  
   def __init__(self, device: Literal["cpu", "cuda"], model_path: str):
     self._model: Any | None = None; self._model_path = mdr_ensure_directory(model_path)
     self._device = device if torch.cuda.is_available() and device=="cuda" else "cpu"
     self._disabled = self._device == "cpu"
     if self._disabled: print("Warning: MDR Table parsing requires CUDA. Disabled.")
+  
   def parse_table_image(self, image: Image, format: MDRTableLayoutParsedFormat) -> str | None:
     if self._disabled: return None;
     fmt: MDRTableOutputFormat | None = None
@@ -962,6 +1078,7 @@ class MDRTableParser:
         with torch.no_grad(): results = model([img_rgb], output_format=fmt)
         return results[0] if results else None
     except Exception as e: print(f"MDR Table parsing error: {e}"); return None
+  
   def _get_model(self):
     if self._model is None and not self._disabled:
       try:
@@ -974,23 +1091,31 @@ class MDRTableParser:
       except Exception as e: print(f"ERROR loading MDR StructTable: {e}"); self._model=None
     return self._model
 
-# --- MDR Image Optimizer (raw_optimizer.py) ---
+# --- MDR Image Optimizer ---
 _MDR_TINY_ROTATION = 0.005
+
 @dataclass
 class _MDR_RotationContext: to_origin: MDRRotationAdjuster; to_new: MDRRotationAdjuster; fragment_origin_rectangles: list[MDRRectangle]
+
 class MDRImageOptimizer:
   """Handles image rotation detection and coordinate adjustments."""
+  
   def __init__(self, raw_image: Image, adjust_points: bool):
     self._raw = raw_image; self._image = raw_image; self._adjust_points = adjust_points
     self._fragments: list[MDROcrFragment] = []; self._rotation: float = 0.0; self._rot_ctx: _MDR_RotationContext | None = None
+  
   @property
   def image(self) -> Image: return self._image
+  
   @property
   def adjusted_image(self) -> Image | None: return self._image if self._rot_ctx is not None else None
+  
   @property
   def rotation(self) -> float: return self._rotation
+  
   @property
   def image_np(self) -> np.ndarray: img_rgb = np.array(self._raw.convert("RGB")); return cv2.cvtColor(img_rgb, cv2.COLOR_RGB2BGR)
+  
   def receive_fragments(self, fragments: list[MDROcrFragment]):
     self._fragments = fragments;
     if not fragments: return;
@@ -1005,12 +1130,13 @@ class MDRImageOptimizer:
         to_new=MDRRotationAdjuster(orig_sz, new_sz, self._rotation, False),
         to_origin=MDRRotationAdjuster(orig_sz, new_sz, self._rotation, True))
     adj = self._rot_ctx.to_new; [setattr(f, 'rect', MDRRectangle(lt=adj.adjust(r.lt), rt=adj.adjust(r.rt), lb=adj.adjust(r.lb), rb=adj.adjust(r.rb))) for f in fragments if (r:=f.rect)]
+  
   def finalize_layout_coords(self, layouts: list[MDRLayoutElement]):
     if self._rot_ctx is None or self._adjust_points: return
     if len(self._fragments) == len(self._rot_ctx.fragment_origin_rectangles): [setattr(f, 'rect', orig_r) for f, orig_r in zip(self._fragments, self._rot_ctx.fragment_origin_rectangles)]
     adj = self._rot_ctx.to_origin; [setattr(l, 'rect', MDRRectangle(lt=adj.adjust(r.lt), rt=adj.adjust(r.rt), lb=adj.adjust(r.lb), rb=adj.adjust(r.rb))) for l in layouts if (r:=l.rect)]
 
-# --- MDR Image Clipping (clipper.py) ---
+# --- MDR Image Clipping ---
 def mdr_clip_from_image(image: Image, rect: MDRRectangle, wrap_w: float = 0.0, wrap_h: float = 0.0) -> Image:
   """Clips a potentially rotated rectangle from an image."""
   try:
@@ -1026,18 +1152,21 @@ def mdr_clip_from_image(image: Image, rect: MDRRectangle, wrap_w: float = 0.0, w
     out_w, out_h = ceil(avg_w+wrap_w), ceil(avg_h+wrap_h)
     return image.transform((out_w, out_h), PILTransform.AFFINE, p_mat, PILResampling.BICUBIC, fillcolor=(255,255,255))
   except Exception as e: print(f"MDR Clipping error: {e}"); return new_image("RGB", (10,10), (255,255,255))
+
 def mdr_clip_layout(res: MDRExtractionResult, layout: MDRLayoutElement, wrap_w: float = 0.0, wrap_h: float = 0.0) -> Image:
   """Clips a layout region from the MDRExtractionResult image."""
   img = res.adjusted_image if res.adjusted_image else res.extracted_image
   return mdr_clip_from_image(img, layout.rect, wrap_w, wrap_h)
 
-# --- MDR Debug Plotting (plot.py) ---
+# --- MDR Debug Plotting ---
 _MDR_FRAG_COLOR = (0x49, 0xCF, 0xCB, 200); _MDR_LAYOUT_COLORS = { MDRLayoutClass.TITLE: (0x0A,0x12,0x2C,255), MDRLayoutClass.PLAIN_TEXT: (0x3C,0x67,0x90,255), MDRLayoutClass.ABANDON: (0xC0,0xBB,0xA9,180), MDRLayoutClass.FIGURE: (0x5B,0x91,0x3C,255), MDRLayoutClass.FIGURE_CAPTION: (0x77,0xB3,0x54,255), MDRLayoutClass.TABLE: (0x44,0x17,0x52,255), MDRLayoutClass.TABLE_CAPTION: (0x81,0x75,0xA0,255), MDRLayoutClass.TABLE_FOOTNOTE: (0xEF,0xB6,0xC9,255), MDRLayoutClass.ISOLATE_FORMULA: (0xFA,0x38,0x27,255), MDRLayoutClass.FORMULA_CAPTION: (0xFF,0x9D,0x24,255) }; _MDR_DEFAULT_COLOR = (0x80,0x80,0x80,255); _MDR_RGBA = tuple[int,int,int,int]
+
 def mdr_plot_layout(image: Image, layouts: Iterable[MDRLayoutElement]) -> None:
   """Draws layout and fragment boxes onto an image for debugging."""
   if not layouts: return;
   try: l_font, f_font = load_default(size=25), load_default(size=15); draw = ImageDraw.Draw(image, mode="RGBA")
   except Exception as e: print(f"MDR Plot init error: {e}"); return
+  
   def _draw_num(pos: MDRPoint, num: int, font: FreeTypeFont, color: _MDR_RGBA):
     try: x,y=pos; txt=str(num); txt_pos=(round(x)+3, round(y)+1); bbox=draw.textbbox(txt_pos,txt,font=font); bg_rect=(bbox[0]-2,bbox[1]-1,bbox[2]+2,bbox[3]+1); bg_color=(color[0],color[1],color[2],180); draw.rectangle(bg_rect,fill=bg_color); draw.text(txt_pos,txt,font=font,fill=(255,255,255,255))
     except Exception as e: print(f"MDR Draw num error: {e}")
@@ -1049,26 +1178,65 @@ def mdr_plot_layout(image: Image, layouts: Iterable[MDRLayoutElement]) -> None:
       try: draw.polygon([p for p in f.rect], outline=_MDR_FRAG_COLOR, width=1)
       except Exception as e: print(f"MDR Fragment draw error: {e}")
 
-# --- MDR Extraction Engine (DocExtractor.py) ---
+# --- MDR Extraction Engine ---
 class MDRExtractionEngine:
   """Core engine for extracting structured information from a document image."""
+  
   def __init__(self, model_dir_path: str, device: Literal["cpu", "cuda"]="cpu", ocr_for_each_layouts: bool=True, extract_formula: bool=True, extract_table_format: MDRTableLayoutParsedFormat|None=None):
-    self._model_dir = model_dir_path; self._device = device if torch.cuda.is_available() else "cpu"
+    self._model_dir = model_dir_path # Base directory for all models
+    self._device = device if torch.cuda.is_available() else "cpu"
     self._ocr_each = ocr_for_each_layouts; self._ext_formula = extract_formula; self._ext_table = extract_table_format
     self._yolo: YOLOv10 | None = None
-    self._ocr_engine = MDROcrEngine(device=self._device, model_dir_path=os.path.join(model_dir_path, "onnx_ocr"))
-    self._table_parser = MDRTableParser(device=self._device, model_path=os.path.join(model_dir_path, "struct_eqtable"))
-    self._latex_extractor = MDRLatexExtractor(model_path=os.path.join(model_dir_path, "latex"))
-    self._layout_reader = MDRLayoutReader(model_path=os.path.join(model_dir_path, "layoutreader"))
+    # Initialize sub-modules, passing the main model_dir_path
+    self._ocr_engine = MDROcrEngine(device=self._device, model_dir_path=os.path.join(self._model_dir, "onnx_ocr"))
+    self._table_parser = MDRTableParser(device=self._device, model_path=os.path.join(self._model_dir, "struct_eqtable"))
+    self._latex_extractor = MDRLatexExtractor(model_path=os.path.join(self._model_dir, "latex"))
+    self._layout_reader = MDRLayoutReader(model_path=os.path.join(self._model_dir, "layoutreader"))
     print(f"MDR Extraction Engine initialized on device: {self._device}")
+
+  # --- MODIFIED _get_yolo_model METHOD for HF ---
   def _get_yolo_model(self) -> YOLOv10 | None:
+    """Loads the YOLOv10 layout detection model using hf_hub_download."""
     if self._yolo is None and YOLOv10 is not None:
-        bp = Path(self._model_dir)/"yolo"; mdr_ensure_directory(str(bp)); url = "https://huggingface.co/opendatalab/PDF-Extract-Kit-1.0/resolve/main/models/Layout/YOLO/doclayout_yolo_ft.pt"; name = "doclayout_yolo_ft.pt"; mp = bp/name
-        if not mp.exists(): print(f"Downloading MDR YOLO model..."); mdr_download_model(url, mp)
-        try: self._yolo = YOLOv10(str(mp)); print("MDR YOLOv10 loaded.")
-        except Exception as e: print(f"ERROR loading MDR YOLOv10: {e}"); self._yolo = None
-    elif YOLOv10 is None: print("MDR YOLOv10 unavailable.")
+        repo_id = "juliozhao/DocLayout-YOLO-DocStructBench"
+        filename = "doclayout_yolo_docstructbench_imgsz1024.pt"
+        # Use a subdirectory within the main model dir for YOLO cache via HF Hub
+        yolo_cache_dir = Path(self._model_dir) / "yolo_hf_cache"
+        mdr_ensure_directory(str(yolo_cache_dir)) # Ensure cache dir exists
+
+        print(f"Attempting to load YOLO model '{filename}' from repo '{repo_id}'...")
+        print(f"Hugging Face Hub cache directory for YOLO: {yolo_cache_dir}")
+
+        try:
+            # Download the model file using huggingface_hub, caching it
+            yolo_model_filepath = hf_hub_download(
+                repo_id=repo_id,
+                filename=filename,
+                cache_dir=yolo_cache_dir, # Cache within our designated structure
+                local_files_only=False, # Allow download
+                force_download=False,   # Use cache if available
+            )
+            print(f"YOLO model file path: {yolo_model_filepath}")
+
+            # Load the model using the downloaded file path
+            self._yolo = YOLOv10(yolo_model_filepath)
+            print("MDR YOLOv10 model loaded successfully.")
+
+        except HfHubDownloadError as e:
+            print(f"ERROR: Failed to download YOLO model from Hugging Face Hub: {e}")
+            self._yolo = None
+        except FileNotFoundError as e: # Catch if hf_hub_download fails finding file
+             print(f"ERROR: YOLO model file not found via Hugging Face Hub: {e}")
+             self._yolo = None
+        except Exception as e:
+            print(f"ERROR: Failed to load YOLOv10 model from {yolo_model_filepath}: {e}")
+            self._yolo = None
+
+    elif YOLOv10 is None:
+        print("MDR YOLOv10 class not available. Layout detection skipped.")
+
     return self._yolo
+      
   def analyze_image(self, image: Image, adjust_points: bool=False) -> MDRExtractionResult:
     """Analyzes a single page image to extract layout and content."""
     print("  Engine: Analyzing image..."); optimizer = MDRImageOptimizer(image, adjust_points)
@@ -1088,6 +1256,7 @@ class MDRExtractionEngine:
     print("  Engine: Finalizing coords..."); optimizer.finalize_layout_coords(layouts)
     print("  Engine: Analysis complete.")
     return MDRExtractionResult(rotation=optimizer.rotation, layouts=layouts, extracted_image=image, adjusted_image=optimizer.adjusted_image)
+      
   def _run_yolo_detection(self, img: Image, yolo: YOLOv10) -> Generator[MDRLayoutElement, None, None]:
     img_rgb = img.convert("RGB"); res = yolo.predict(source=img_rgb, imgsz=1024, conf=0.2, device=self._device, verbose=False)
     if not res or not hasattr(res[0], 'boxes') or res[0].boxes is None: return
@@ -1101,6 +1270,7 @@ class MDRExtractionEngine:
             if cls == MDRLayoutClass.TABLE: yield MDRTableLayoutElement(cls=cls, rect=rect, fragments=[], parsed=None)
             elif cls == MDRLayoutClass.ISOLATE_FORMULA: yield MDRFormulaLayoutElement(cls=cls, rect=rect, fragments=[], latex=None)
             elif cls in MDRPlainLayoutElement.__annotations__['cls'].__args__: yield MDRPlainLayoutElement(cls=cls, rect=rect, fragments=[])
+  
   def _match_fragments_to_layouts(self, frags: list[MDROcrFragment], layouts: list[MDRLayoutElement]) -> list[MDRLayoutElement]:
     if not frags or not layouts: return layouts
     layout_polys = [(Polygon(l.rect) if l.rect.is_valid else None) for l in layouts]
@@ -1120,11 +1290,13 @@ class MDRExtractionEngine:
             layouts[best_idx].fragments.append(frag)
     for l in layouts: l.fragments.sort(key=lambda f: (f.rect.lt[1], f.rect.lt[0]))
     return layouts
+  
   def _run_ocr_correction(self, img: Image, layouts: list[MDRLayoutElement]):
     for i, l in enumerate(layouts):
         if l.cls == MDRLayoutClass.FIGURE: continue
         try: mdr_correct_layout_fragments(self._ocr_engine, img, l)
         except Exception as e: print(f"  Engine: OCR correction error layout {i}: {e}")
+  
   def _parse_special_layouts(self, layouts: list[MDRLayoutElement], optimizer: MDRImageOptimizer):
     img_to_clip = optimizer.image
     for l in layouts:
@@ -1135,25 +1307,33 @@ class MDRExtractionEngine:
             try: t_img = mdr_clip_from_image(img_to_clip, l.rect); parsed = self._table_parser.parse_table_image(t_img, self._ext_table) if t_img.width>1 and t_img.height>1 else None
             except Exception as e: print(f"  Engine: Table parse error: {e}"); parsed = None
             if parsed: l.parsed = (parsed, self._ext_table)
+  
   def _should_keep_layout(self, l: MDRLayoutElement) -> bool:
     if l.fragments and not all(mdr_is_whitespace(f.text) for f in l.fragments): return True
     return l.cls in [MDRLayoutClass.FIGURE, MDRLayoutClass.TABLE, MDRLayoutClass.ISOLATE_FORMULA]
 
-# --- MDR Page Section Linking (section.py) ---
+# --- MDR Page Section Linking ---
 class _MDR_LinkedShape:
   """Internal helper for managing layout linking across pages."""
+  
   def __init__(self, layout: MDRLayoutElement): self.layout=layout; self.pre:list[MDRLayoutElement|None]=[None,None]; self.nex:list[MDRLayoutElement|None]=[None,None]
+  
   @property
   def distance2(self) -> float: x,y=self.layout.rect.lt; return x*x+y*y
+
 class MDRPageSection:
   """Represents a page's layouts for framework detection via linking."""
+  
   def __init__(self, page_index: int, layouts: Iterable[MDRLayoutElement]):
     self._page_index = page_index; self._shapes = [_MDR_LinkedShape(l) for l in layouts]; self._shapes.sort(key=lambda s: (s.layout.rect.lt[1], s.layout.rect.lt[0]))
+  
   @property
   def page_index(self) -> int: return self._page_index
+  
   def find_framework_elements(self) -> list[MDRLayoutElement]:
     """Identifies framework layouts based on links to other pages."""
     return [s.layout for s in self._shapes if any(s.pre) or any(s.nex)]
+  
   def link_to_next(self, next_section: 'MDRPageSection', offset: int) -> None:
     """Links matching shapes between this section and the next."""
     if offset not in (1,2): return
@@ -1169,6 +1349,7 @@ class MDRPageSection:
         r2_rel = self._relative_rect(orig_n_pt, s2.layout.rect); ovr = self._symmetric_iou(r1_rel, r2_rel)
         if ovr > max_ovr: max_ovr, best_s2 = ovr, s2
       if max_ovr >= 0.80 and best_s2 is not None: s1.nex[offset-1] = best_s2.layout; best_s2.pre[offset-1] = s1.layout # Link both ways
+
   def _shapes_match(self, s1: _MDR_LinkedShape, s2: _MDR_LinkedShape) -> bool:
     l1, l2 = s1.layout, s2.layout; sz1, sz2 = l1.rect.size, l2.rect.size; thresh = 0.90
     if mdr_similarity_ratio(sz1[0], sz2[0]) < thresh or mdr_similarity_ratio(sz1[1], sz2[1]) < thresh: return False
@@ -1183,10 +1364,12 @@ class MDRPageSection:
       if max_sim > 0.75: matches += 1; if best_j != -1: used_f2[best_j] = True
     max_c = max(c1, c2); rate_frags = matches / max_c
     return self._check_match_threshold(rate_frags, max_c, (0.0, 0.45, 0.45, 0.6, 0.8, 0.95))
+  
   def _fragment_sim(self, l1: MDRLayoutElement, l2: MDRLayoutElement, f1: MDROcrFragment, f2: MDROcrFragment) -> float:
       r1_rel = self._relative_rect(l1.rect.lt, f1.rect); r2_rel = self._relative_rect(l2.rect.lt, f2.rect)
       geom_sim = self._symmetric_iou(r1_rel, r2_rel); text_sim, _ = mdr_check_text_similarity(f1.text, f2.text)
       return (geom_sim + text_sim) / 2.0
+      
   def _find_origin_pair(self, matches_matrix: list[list[_MDR_LinkedShape]], next_shapes: list[_MDR_LinkedShape]) -> tuple[_MDR_LinkedShape, _MDR_LinkedShape] | None:
       best_pair, min_dist2 = None, float('inf')
       for i, s1 in enumerate(self._shapes):
@@ -1194,10 +1377,13 @@ class MDRPageSection:
           if not match_list: continue
           for s2 in match_list: dist2 = s1.distance2 + s2.distance2; if dist2 < min_dist2: min_dist2, best_pair = dist2, (s1, s2)
       return best_pair
+      
   def _check_match_threshold(self, rate: float, count: int, thresholds: Sequence[float]) -> bool:
       if not thresholds: return False; idx = min(count, len(thresholds)-1); return rate >= thresholds[idx]
+          
   def _relative_rect(self, origin: MDRPoint, rect: MDRRectangle) -> MDRRectangle:
       ox, oy = origin; r=rect; return MDRRectangle(lt=(r.lt[0]-ox, r.lt[1]-oy), rt=(r.rt[0]-ox, r.rt[1]-oy), lb=(r.lb[0]-ox, r.lb[1]-oy), rb=(r.rb[0]-ox, r.rb[1]-oy))
+      
   def _symmetric_iou(self, r1: MDRRectangle, r2: MDRRectangle) -> float:
       try: p1, p2 = Polygon(r1), Polygon(r2);
       except: return 0.0
@@ -1207,21 +1393,26 @@ class MDRPageSection:
       if inter.is_empty or inter.area < 1e-6: return 0.0
       union_area = union.area; return inter.area / union_area if union_area > 1e-6 else 1.0
 
-# --- MDR Document Iterator (document.py) ---
+# --- MDR Document Iterator ---
 _MDR_CONTEXT_PAGES = 2 # Look behind/ahead pages for context
+
 @dataclass
 class MDRProcessingParams:
   """Parameters for processing a document."""
   pdf: str | FitzDocument; page_indexes: Iterable[int] | None; report_progress: MDRProgressReportCallback | None
+    
 class MDRDocumentIterator:
   """Iterates through document pages, handles context, and calls the extraction engine."""
+    
   def __init__(self, device: Literal["cpu", "cuda"], model_dir_path: str, ocr_level: MDROcrLevel, extract_formula: bool, extract_table_format: MDRTableLayoutParsedFormat | None, debug_dir_path: str | None):
     self._debug_dir = debug_dir_path
     self._engine = MDRExtractionEngine(device=device, model_dir_path=model_dir_path, ocr_for_each_layouts=(ocr_level==MDROcrLevel.OncePerLayout), extract_formula=extract_formula, extract_table_format=extract_table_format)
+  
   def iterate_sections(self, params: MDRProcessingParams) -> Generator[tuple[int, MDRExtractionResult, list[MDRLayoutElement]], None, None]:
     """Yields page index, extraction result, and content layouts for each requested page."""
     for res, sec in self._process_and_link_sections(params):
       framework = set(sec.find_framework_elements()); content = [l for l in res.layouts if l not in framework]; yield sec.page_index, res, content
+        
   def _process_and_link_sections(self, params: MDRProcessingParams) -> Generator[tuple[MDRExtractionResult, MDRPageSection], None, None]:
     queue: list[tuple[MDRExtractionResult, MDRPageSection]] = []
     for page_idx, res in self._run_extraction_on_pages(params):
@@ -1232,6 +1423,7 @@ class MDRDocumentIterator:
       queue.append((res, cur_sec))
       if len(queue) > _MDR_CONTEXT_PAGES: yield queue.pop(0)
     for res, sec in queue: yield res, sec
+        
   def _run_extraction_on_pages(self, params: MDRProcessingParams) -> Generator[tuple[int, MDRExtractionResult], None, None]:
     if self._debug_dir: mdr_ensure_directory(self._debug_dir)
     doc, should_close = None, False
@@ -1254,6 +1446,7 @@ class MDRDocumentIterator:
         except Exception as e: print(f"  Iterator: Page {page_idx+1} processing error: {e}")
     finally:
       if should_close and doc: doc.close()
+          
   def _get_page_ranges(self, doc: FitzDocument, idxs: Iterable[int]|None) -> tuple[Sequence[int], Sequence[int]]:
     count = doc.page_count;
     if idxs is None: all_p = list(range(count)); return all_p, all_p
@@ -1261,19 +1454,22 @@ class MDRDocumentIterator:
     for i in idxs:
       if 0<=i<count: enable.add(i); [scan.add(j) for j in range(max(0, i-_MDR_CONTEXT_PAGES), min(count, i+_MDR_CONTEXT_PAGES+1))]
     return sorted(list(scan)), sorted(list(enable))
+      
   def _render_page_image(self, page: FitzPage, dpi: int) -> Image:
     mat = FitzMatrix(dpi/72.0, dpi/72.0); pix = page.get_pixmap(matrix=mat, alpha=False)
     return frombytes("RGB", (pix.width, pix.height), pix.samples)
+      
   def _save_debug_plot(self, img: Image, idx: int, res: MDRExtractionResult, path: str):
     try: plot_img = res.adjusted_image.copy() if res.adjusted_image else img.copy(); mdr_plot_layout(plot_img, res.layouts); plot_img.save(os.path.join(path, f"mdr_plot_page_{idx+1}.png"))
     except Exception as e: print(f"  Iterator: Plot generation error page {idx+1}: {e}")
 
-# --- MagicDataReadiness Main Processor (PDFPageExtractor.py) ---
+# --- MagicDataReadiness Main Processor ---
 class MagicPDFProcessor:
   """
   Main class for processing PDF documents to extract structured data blocks
   using the MagicDataReadiness pipeline.
   """
+    
   def __init__(self, device: Literal["cpu", "cuda"]="cuda", model_dir_path: str="./mdr_models", ocr_level: MDROcrLevel=MDROcrLevel.Once, extract_formula: bool=True, extract_table_format: MDRExtractedTableFormat|None=None, debug_dir_path: str|None=None):
     """
     Initializes the MagicPDFProcessor.
@@ -1436,7 +1632,7 @@ if __name__ == '__main__':
     print(" MagicDataReadiness PDF Processor - Example Usage")
     print("="*60)
 
-    # --- 1. Configuration (!!! MODIFY THESE PATHS !!!) ---
+    # --- 1. Configuration (!!! MODIFY THESE PATHS WHEN OUTSIDE HF !!!) ---
     # Directory where models are stored or will be downloaded
     # IMPORTANT: Create this directory or ensure it's writable!
     MDR_MODEL_DIRECTORY = "./mdr_pipeline_models"
@@ -1449,7 +1645,7 @@ if __name__ == '__main__':
     MDR_DEBUG_DIRECTORY = "./mdr_debug_output"
 
     # Specify device ('cuda' or 'cpu').
-    MDR_DEVICE = "cuda"
+    MDR_DEVICE = "cpu"
 
     # Specify desired table format
     MDR_TABLE_FORMAT = MDRExtractedTableFormat.MARKDOWN