Upload 2 files

app.py

@@ -12,6 +12,7 @@ import sys
 import tempfile
 import threading
 import time
+import traceback
 import uuid
 import zipfile
 from pathlib import Path
@@ -641,7 +642,10 @@ MODEL = AutoModel.from_pretrained(
 torch.set_grad_enabled(False)
 print("Unlimited-OCR model ready.", flush=True)
 
-app = Server(title="Unlimited-OCR Hugging Face Space")
+app = Server(debug=True, title="Unlimited-OCR Hugging Face Space")
+# Hugging Face's Gradio hot-reload launcher looks for the conventional `demo`
+# symbol. Keep both names pointing at the same Server instance.
+demo = app
 _MODEL_LOCK = threading.Lock()
 _THREAD_CONTEXT = threading.local()
 _ACTIVE_REQUESTS: dict[str, threading.Event] = {}
@@ -726,7 +730,19 @@ def _run_model_worker(
         except GenerationCancelled:
             emit("cancelled", None)
         except BaseException as exc:
-            emit("error", exc)
+            error_traceback = traceback.format_exc()
+            print(
+                f"[OCR ERROR] request={settings.request_id} "
+                f"pages={settings.page_indices}: {exc}\n{error_traceback}",
+                flush=True,
+            )
+            emit(
+                "error",
+                {
+                    "message": str(exc) or exc.__class__.__name__,
+                    "exception_type": exc.__class__.__name__,
+                },
+            )
         finally:
             ring_window = getattr(MODEL.config, "_ring_window", None)
             if ring_window is not None:
@@ -759,6 +775,12 @@ def run_ocr_batch(
 ) -> Iterator[dict[str, Any]]:
     """Run one ZeroGPU batch and stream UI events through Gradio's SSE queue."""
 
+    print(
+        f"[OCR START] request={request_id} batch={batch_number}/{total_batches} "
+        f"session={session_id} pages={page_indices} mode={mode} "
+        f"max_tokens={max_tokens}",
+        flush=True,
+    )
     session_dir = _session_dir(session_id)
     pages = _read_metadata(session_dir).get("pages") or []
     if not _SAFE_REQUEST_ID.fullmatch(request_id):
@@ -837,9 +859,22 @@ def run_ocr_batch(
             elif kind == "final":
                 final_output = str(value or "")
             elif kind == "error":
+                if isinstance(value, dict):
+                    error_message = value.get("message") or "Unknown inference error"
+                    exception_type = value.get("exception_type") or "Error"
+                else:
+                    error_message = str(value) or "Unknown inference error"
+                    exception_type = type(value).__name__
                 yield {
                     "event": "error",
-                    "data": {"message": f"Hugging Face inference failed: {value}"},
+                    "data": {
+                        "message": (
+                            f"Hugging Face inference failed "
+                            f"({exception_type}): {error_message}"
+                        ),
+                        "request_id": request_id,
+                        "batch": batch_number,
+                    },
                 }
                 return
             elif kind == "cancelled":
@@ -887,6 +922,12 @@ def run_ocr_batch(
                 "mapped_pages": len(pairs),
             },
         }
+        print(
+            f"[OCR DONE] request={request_id} batch={batch_number}/{total_batches} "
+            f"characters={len(raw_output)} mapped_pages={len(pairs)} "
+            f"latency={latency:.3f}s",
+            flush=True,
+        )
     finally:
         cancel.set()
         if worker.is_alive():

index.html

@@ -327,6 +327,14 @@
         requestAnimationFrame(() => { state.rawScrollScheduled = false; viewer.scrollTop = viewer.scrollHeight; });
       }
     }
+    function appendStreamDiagnostic(message) {
+      const output = $('#rawOutput');
+      const text = String(message || 'Unknown streaming error');
+      if (output.textContent && !output.textContent.endsWith('\n')) output.appendChild(document.createTextNode('\n'));
+      output.appendChild(document.createTextNode(`\n===== STREAM ERROR =====\n${text}\n`));
+      output.parentElement.scrollTop = output.parentElement.scrollHeight;
+      console.error('[Unlimited-OCR stream]', text);
+    }
     function semanticColor(label) {
       const key = String(label || 'box').trim().toLowerCase();
       if (colors[key]) return colors[key];
@@ -766,30 +774,53 @@
         $('#latencyText').textContent = `${data.elapsed_seconds}s`; $('#downloadButton').disabled = false; renderAllPages(); selectPage(state.currentPage);
       }
       if (name === 'cancelled') { setRunning(false); setStatus('STOPPED'); }
-      if (name === 'error') { setRunning(false); setStatus('ERROR', 'error'); showToast(data.message || 'Streaming failed'); }
+      if (name === 'error') {
+        const detail = data.message || 'Streaming failed';
+        setRunning(false); setStatus('ERROR', 'error'); appendStreamDiagnostic(detail); showToast(detail);
+      }
     }
     async function consumeGradioJob(eventId, signal) {
       const response = await fetch(`/gradio_api/call/run_ocr_batch/${encodeURIComponent(eventId)}`, {signal});
-      if (!response.ok) { const data = await response.json().catch(() => ({})); throw new Error(data.detail || `Gradio HTTP ${response.status}`); }
-      const reader = response.body.getReader(); const decoder = new TextDecoder(); let buffer = ''; let lastPayload = '';
+      if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        let detail = body; try { const parsed = JSON.parse(body); detail = parsed.detail || parsed.error || body; } catch (_) {}
+        throw new Error(`Gradio result HTTP ${response.status}${detail ? `: ${detail}` : ''} [job ${eventId}]`);
+      }
+      if (!response.body) throw new Error(`Gradio returned an empty stream [job ${eventId}]`);
+      const reader = response.body.getReader(); const decoder = new TextDecoder(); let buffer = ''; let lastPayload = ''; let completed = false;
       while (true) {
         const {value, done} = await reader.read(); buffer += decoder.decode(value || new Uint8Array(), {stream: !done}).replace(/\r\n/g, '\n');
         let boundary;
         while ((boundary = buffer.indexOf('\n\n')) >= 0) {
           const block = buffer.slice(0, boundary); buffer = buffer.slice(boundary + 2); let name = 'message'; const dataLines = [];
           for (const line of block.split('\n')) { if (line.startsWith('event:')) name = line.slice(6).trim(); if (line.startsWith('data:')) dataLines.push(line.slice(5).trimStart()); }
-          if (name === 'error') throw new Error(dataLines.join('\n') || 'ZeroGPU job failed');
+          if (name === 'error') {
+            const rawError = dataLines.join('\n'); let detail = rawError;
+            try { const parsedError = JSON.parse(rawError); detail = parsedError.message || parsedError.error || parsedError.detail || rawError; } catch (_) {}
+            throw new Error(`${detail || 'ZeroGPU job failed without an error payload'} [job ${eventId}]`);
+          }
           if (dataLines.length && (name === 'generating' || name === 'complete')) {
-            const parsed = JSON.parse(dataLines.join('\n')); const update = Array.isArray(parsed) ? parsed[0] : parsed; const signature = JSON.stringify(update);
-            if (update && update.event && signature !== lastPayload) { lastPayload = signature; processEvent(update.event, update.data || {}); if (update.event === 'error') throw new Error((update.data && update.data.message) || 'OCR failed'); }
+            let parsed;
+            try { parsed = JSON.parse(dataLines.join('\n')); }
+            catch (error) { throw new Error(`Invalid Gradio SSE JSON: ${error.message} [job ${eventId}]`); }
+            if (name === 'complete') completed = true;
+            const update = Array.isArray(parsed) ? parsed[0] : parsed; const signature = JSON.stringify(update);
+            if (update && update.event && signature !== lastPayload) {
+              lastPayload = signature;
+              if (update.event === 'error') throw new Error(`${(update.data && update.data.message) || 'OCR failed'} [job ${eventId}]`);
+              processEvent(update.event, update.data || {});
+            }
           }
         }
         if (done) break;
       }
+      if (!completed) throw new Error(`Gradio stream closed before the job completed [job ${eventId}]`);
     }
     async function callZeroGpuBatch(args, signal) {
       const response = await fetch('/gradio_api/call/run_ocr_batch', {method:'POST', headers:{'Content-Type':'application/json'}, body:JSON.stringify({data:args}), signal});
-      const data = await response.json().catch(() => ({})); if (!response.ok || !data.event_id) throw new Error(data.detail || `Unable to queue ZeroGPU job (${response.status})`);
+      const body = await response.text().catch(() => ''); let data = {};
+      try { data = JSON.parse(body); } catch (_) {}
+      if (!response.ok || !data.event_id) throw new Error(`${data.detail || data.error || body || `Unable to queue ZeroGPU job (${response.status})`} [queue HTTP ${response.status}]`);
       await consumeGradioJob(data.event_id, signal);
     }
     async function startGeneration() {
@@ -815,7 +846,10 @@
         }
         if (state.running) processEvent('done', {completed_pages:Object.keys(state.results).length, selected_pages:pageIndices.length, elapsed_seconds:Math.round((performance.now() - startedAt) / 100) / 10});
       } catch (error) {
-        if (error.name !== 'AbortError') { setStatus('STREAM ERROR', 'error'); showToast(error.message); }
+        if (error.name !== 'AbortError') {
+          const detail = error && error.message ? error.message : String(error);
+          setStatus('STREAM ERROR', 'error'); appendStreamDiagnostic(detail); showToast(detail);
+        }
         setRunning(false);
       }
     }