Update app.py

1. Asyncio cleanup error
2. Logging for header/footer
3. Optional DEBUG level

app.py

@@ -2,14 +2,38 @@
 GLM-OCR Hugging Face Space app with client-side header/footer fallback for MaaS.
 Works for every PDF and every image: uses API bboxes when available, else minimal band.
 """
+import logging
 import os
 import re
+import sys
 import tempfile
 import yaml
 import gradio as gr
 
 import glmocr
 
+# Log to stderr so Hugging Face / Docker show it in logs. Set GLMOCR_LOG=DEBUG for more detail.
+_log_level = os.environ.get("GLMOCR_LOG", "INFO").upper()
+logging.basicConfig(
+    level=getattr(logging, _log_level, logging.INFO),
+    format="[%(levelname)s] %(name)s: %(message)s",
+    stream=sys.stderr,
+)
+log = logging.getLogger("glmocr_app")
+
+# Suppress Python 3.13 asyncio cleanup noise (Invalid file descriptor in BaseEventLoop.__del__)
+try:
+    import asyncio
+    _orig_close = asyncio.BaseEventLoop.close
+    def _safe_close(self):
+        try:
+            _orig_close(self)
+        except (ValueError, OSError):
+            pass
+    asyncio.BaseEventLoop.close = _safe_close
+except Exception:
+    pass
+
 GLMOCR_BASE = os.path.dirname(glmocr.__file__)
 CONFIG_PATH = os.path.join(GLMOCR_BASE, "config.yaml")
 FORMATTER_PATH = os.path.join(GLMOCR_BASE, "postprocess", "result_formatter.py")
@@ -91,6 +115,7 @@ except Exception:
 
 def get_header_footer_zones(regions, norm_height=1000):
     if not regions:
+        log.debug("get_header_footer_zones: no regions")
         return None, None
     y_tops, y_bottoms = [], []
     for r in regions:
@@ -99,8 +124,12 @@ def get_header_footer_zones(regions, norm_height=1000):
             y_tops.append(bbox[1])
             y_bottoms.append(bbox[3])
     if not y_tops:
+        log.debug("get_header_footer_zones: no bboxes in regions")
         return None, None
-    return min(y_tops) / norm_height, max(y_bottoms) / norm_height
+    he_frac = min(y_tops) / norm_height
+    fs_frac = max(y_bottoms) / norm_height
+    log.debug("get_header_footer_zones: regions=%s -> header_end_frac=%.3f footer_start_frac=%.3f", len(regions), he_frac, fs_frac)
+    return he_frac, fs_frac
 
 
 def extract_zone_text_pdf(pdf_path, page_num, y_start_frac, y_end_frac):
@@ -112,13 +141,16 @@ def extract_zone_text_pdf(pdf_path, page_num, y_start_frac, y_end_frac):
         rect = fitz.Rect(0, h * y_start_frac, w, h * y_end_frac)
         text = page.get_text(clip=rect).strip()
         doc.close()
+        log.debug("extract_zone_text_pdf page=%s y=%.2f-%.2f -> %d chars", page_num, y_start_frac, y_end_frac, len(text))
         return text
-    except Exception:
+    except Exception as e:
+        log.debug("extract_zone_text_pdf failed: %s", e)
         return ""
 
 
 def ocr_zone(image_path, y_start_frac, y_end_frac):
     """Run OCR on a horizontal band of the image. Skips MaaS if crop is too small (API returns 400)."""
+    zone_name = "header" if y_end_frac < 0.5 else "footer"
     try:
         from PIL import Image
         img = Image.open(image_path).convert("RGB")
@@ -126,11 +158,17 @@ def ocr_zone(image_path, y_start_frac, y_end_frac):
         y0 = max(0, int(h * y_start_frac))
         y1 = min(h, int(h * y_end_frac))
         if y1 <= y0:
+            log.info("[%s] ocr_zone: skip (zero height band y0=%s y1=%s)", zone_name, y0, y1)
             return ""
         crop = img.crop((0, y0, w, y1))
         cw, ch = crop.size
-        if ch < MIN_CROP_HEIGHT or (cw * ch) < MIN_CROP_PIXELS:
-            return ""  # MaaS rejects very small images with 400
+        pixels = cw * ch
+        if ch < MIN_CROP_HEIGHT or pixels < MIN_CROP_PIXELS:
+            log.info(
+                "[%s] ocr_zone: skip (crop too small: %dx%d=%d pixels, need height>=%d and pixels>=%d)",
+                zone_name, cw, ch, pixels, MIN_CROP_HEIGHT, MIN_CROP_PIXELS,
+            )
+            return ""
         fd, path = tempfile.mkstemp(suffix=".jpg")
         os.close(fd)
         try:
@@ -140,14 +178,17 @@ def ocr_zone(image_path, y_start_frac, y_end_frac):
             if not isinstance(out, list):
                 out = [out]
             if out and getattr(out[0], "markdown_result", None):
-                return (out[0].markdown_result or "").strip()
+                text = (out[0].markdown_result or "").strip()
+                log.info("[%s] ocr_zone: crop %dx%d -> %d chars", zone_name, cw, ch, len(text))
+                return text
+            log.info("[%s] ocr_zone: crop %dx%d -> empty result from API", zone_name, cw, ch)
         finally:
             try:
                 os.unlink(path)
             except Exception:
                 pass
-    except Exception:
-        pass
+    except Exception as e:
+        log.warning("[%s] ocr_zone failed: %s", zone_name, e, exc_info=True)
     return ""
 
 
@@ -177,6 +218,7 @@ def run_ocr(uploaded_file):
 
         path = uploaded_file.name if hasattr(uploaded_file, "name") else str(uploaded_file)
         is_pdf = path.lower().endswith(".pdf")
+        log.info("run_ocr: path=%s is_pdf=%s", path, is_pdf)
         parser = get_parser()
 
         if is_pdf:
@@ -188,6 +230,7 @@ def run_ocr(uploaded_file):
                 pix.save(img_path)
                 page_images.append(img_path)
             doc.close()
+            log.info("run_ocr: PDF has %d pages, running MaaS on page images", len(page_images))
             results = parser.parse(page_images)
         else:
             page_images = [path]
@@ -209,6 +252,11 @@ def run_ocr(uploaded_file):
             if fs >= 1.0:
                 fs = 1.0 - DEFAULT_ZONE_FRAC  # ensure we always OCR a bottom band
 
+            log.info(
+                "run_ocr: page %d regions=%s he=%.3f fs=%.3f body_md_len=%d",
+                page_num, len(regions), he, fs, len(page_md or ""),
+            )
+
             parts = []
 
             # Always run header band (top 8–12% of page)
@@ -217,10 +265,14 @@ def run_ocr(uploaded_file):
                 hdr = ""
                 if is_pdf:
                     hdr = extract_zone_text_pdf(path, page_num, 0, he)
+                    if hdr and hdr.strip():
+                        log.info("run_ocr: page %d header from PDF extract: %d chars", page_num, len(hdr.strip()))
                 if not (hdr and hdr.strip()):
                     hdr = ocr_zone(img_path, 0, he)
                 if hdr and hdr.strip():
                     parts.append(hdr.strip())
+                elif not (hdr and hdr.strip()) and he > 0:
+                    log.info("run_ocr: page %d header empty (PDF extract + ocr_zone)", page_num)
 
             if page_md:
                 parts.append(page_md)
@@ -231,17 +283,23 @@ def run_ocr(uploaded_file):
                 ftr = ""
                 if is_pdf:
                     ftr = extract_zone_text_pdf(path, page_num, fs, 1.0)
+                    if ftr and ftr.strip():
+                        log.info("run_ocr: page %d footer from PDF extract: %d chars", page_num, len(ftr.strip()))
                 if not (ftr and ftr.strip()):
                     ftr = ocr_zone(img_path, fs, 1.0)
                 if ftr and ftr.strip():
                     parts.append(ftr.strip())
+                elif not (ftr and ftr.strip()) and fs < 1.0:
+                    log.info("run_ocr: page %d footer empty (PDF extract + ocr_zone)", page_num)
 
             if parts:
                 all_pages.append("\n\n".join(parts))
 
+        log.info("run_ocr: done, %d pages in output", len(all_pages))
         return "\n\n---\n\n".join(all_pages) if all_pages else "(No content)"
     except Exception as e:
         import traceback
+        log.exception("run_ocr failed: %s", e)
         return f"Error: {e}\n\n{traceback.format_exc()}"