html table debugged

Author: fbkaragoz

docker-compose.yml

@@ -5,6 +5,7 @@ services:
   ocr-model:
     build: ./ocr-model
     runtime: nvidia
+    ipc: host
     restart: unless-stopped
     environment:
       - NVIDIA_VISIBLE_DEVICES=all

ocr-model/Dockerfile

@@ -1,4 +1,4 @@
-FROM vllm/vllm-openai:latest
+FROM vllm/vllm-openai:cu129-nightly
 ENTRYPOINT ["python3", "-m", "vllm.entrypoints.openai.api_server"]
 CMD [ \
     "--model", "deepseek-ai/DeepSeek-OCR-2", \

ocr_pipeline/services/startup.py

@@ -53,7 +53,7 @@ async def wait_for_model_server() -> bool:
                     )
                     await asyncio.sleep(interval)
                     continue
-            except (httpx.ConnectError, httpx.ReadTimeout, httpx.ConnectTimeout) as exc:
+            except httpx.HTTPError as exc:
                 model_readiness.error = f"connection failed ({type(exc).__name__})"
                 logger.info(
                     "Model server not reachable yet (%s)", model_readiness.error

ocr_pipeline/services/text_cleaner.py

@@ -1,3 +1,4 @@
+import html
 import re
 import unicodedata
 
@@ -43,6 +44,15 @@ class TextCleaner:
 
     # End-of-line soft hyphens: "word-\n" or "word- \n" followed by continuation
     _HYPHEN_RE = re.compile(r"(\w)- ?\n(\w)")
+    _TABLE_RE = re.compile(r"<table\b[^>]*>.*?</table>", re.IGNORECASE | re.DOTALL)
+    _ROW_RE = re.compile(r"<tr\b[^>]*>(.*?)</tr>", re.IGNORECASE | re.DOTALL)
+    _CELL_RE = re.compile(r"<t[dh]\b[^>]*>(.*?)</t[dh]>", re.IGNORECASE | re.DOTALL)
+    _BR_RE = re.compile(r"<br\s*/?>", re.IGNORECASE)
+    _PARA_END_RE = re.compile(r"</(?:p|div|h[1-6])\s*>", re.IGNORECASE)
+    _HTML_TAG_RE = re.compile(
+        r"</?(?:center|div|span|html|body|table|thead|tbody|tfoot|tr|td|th|p|br|h[1-6])\b[^>]*>",
+        re.IGNORECASE,
+    )
 
     def clean(self, text: str, strip_refs: bool = False) -> str:
         """Full cleaning pipeline."""
@@ -53,6 +63,7 @@ def clean(self, text: str, strip_refs: bool = False) -> str:
         text = self._strip_ref_blocks(text)
         text = self._strip_model_tokens(text)
         text = self._strip_artifacts(text)
+        text = self._html_to_text(text)
         text = self._rejoin_hyphens(text)
         text = self._normalize_whitespace(text)
         text = self._fix_common_ocr_issues(text)
@@ -96,6 +107,30 @@ def _strip_artifacts(self, text: str) -> str:
             text = pattern.sub("", text)
         return text
 
+    def _html_to_text(self, text: str) -> str:
+        """Convert occasional model-emitted HTML into readable plain text."""
+        text = self._TABLE_RE.sub(lambda match: self._table_to_text(match.group(0)), text)
+        text = self._BR_RE.sub("\n", text)
+        text = self._PARA_END_RE.sub("\n", text)
+        text = self._HTML_TAG_RE.sub("", text)
+        return html.unescape(text)
+
+    def _table_to_text(self, table: str) -> str:
+        rows: list[str] = []
+
+        for row_match in self._ROW_RE.finditer(table):
+            cells: list[str] = []
+            for cell_match in self._CELL_RE.finditer(row_match.group(1)):
+                cell = self._HTML_TAG_RE.sub("", cell_match.group(1))
+                cell = html.unescape(cell)
+                cell = re.sub(r"\s+", " ", cell).strip()
+                if cell:
+                    cells.append(cell)
+            if cells:
+                rows.append(" | ".join(cells))
+
+        return "\n".join(rows)
+
     def _normalize_whitespace(self, text: str) -> str:
         # Replace multiple blank lines with a single blank line
         text = re.sub(r"\n{3,}", "\n\n", text)

ocr_pipeline/static/js/app.js

@@ -120,6 +120,7 @@ function opencrApp() {
     toasts: [],
 
     _stream: new RunStream(),
+    _runPollTimer: null,
 
     async init() {
       await Promise.all([
@@ -194,12 +195,18 @@ function opencrApp() {
 
     async refreshSelectedRun() {
       if (!this.selectedRunId) return;
-      try { this.selectedRun = await API.getRun(this.selectedRunId); }
+      try {
+        this.selectedRun = await API.getRun(this.selectedRunId);
+        if (!['queued', 'processing'].includes(this.selectedRun.status)) {
+          this.stopRunPolling();
+        }
+      }
       catch (e) { this.toast(`Failed to refresh run: ${e.message}`, 'error'); }
     },
 
     async selectRun(runId) {
       this._stream.disconnect();
+      this.stopRunPolling();
       if (!runId) {
         this.activeView = 'documents';
         this.selectedRunId = null;
@@ -216,17 +223,18 @@ function opencrApp() {
         const firstCompleted = (this.selectedRun.documents || []).find(d => d.status === 'completed');
         if (firstCompleted) await this.openDocument(firstCompleted.document_id);
         else this.inspector = emptyInspector();
-        if (['queued', 'processing'].includes(this.selectedRun.status)) this.connectStream(runId);
+        if (['queued', 'processing'].includes(this.selectedRun.status)) {
+          this.connectStream(runId);
+          this.startRunPolling();
+        }
       } catch (e) {
         this.toast(`Failed to load run: ${e.message}`, 'error');
       }
     },
 
     connectStream(runId) {
       this._stream.connect(runId, async (event) => {
-        if (event.type === 'page_complete' || event.type === 'document_complete') {
-          await this.refreshSelectedRun();
-        }
+        await this.refreshSelectedRun();
         if (event.type === 'run_complete' || event.type === 'run_failed') {
           await Promise.all([this.refreshSelectedRun(), this.refreshRuns(), this.refreshMetrics()]);
           const completed = event.type === 'run_complete';
@@ -236,6 +244,21 @@ function opencrApp() {
       });
     },
 
+    startRunPolling() {
+      this.stopRunPolling();
+      this._runPollTimer = setInterval(async () => {
+        if (!this.selectedRunId) return this.stopRunPolling();
+        await Promise.all([this.refreshSelectedRun(), this.refreshRuns(), this.refreshMetrics()]);
+      }, 2000);
+    },
+
+    stopRunPolling() {
+      if (this._runPollTimer) {
+        clearInterval(this._runPollTimer);
+        this._runPollTimer = null;
+      }
+    },
+
     async openDocument(documentId) {
       if (!this.selectedRunId || !documentId) return;
       this.inspector.documentId = documentId;

tests/test_gpu_first_runtime.py

@@ -1,8 +1,12 @@
+import asyncio
 from pathlib import Path
 from typing import get_args
 
+import httpx
+
 from ocr_pipeline.config import Settings, settings
 from ocr_pipeline.models.schemas import HealthResponse
+from ocr_pipeline.services import startup
 from ocr_pipeline.services.startup import ModelReadiness
 
 
@@ -31,3 +35,26 @@ def test_local_backend_dependency_file_is_removed():
     repo_root = Path(__file__).parents[1]
 
     assert not (repo_root / "requirements-local.txt").exists()
+
+
+def test_model_readiness_treats_read_error_as_waiting(monkeypatch):
+    class DroppingAsyncClient:
+        def __init__(self, *args, **kwargs):
+            pass
+
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, *args):
+            return None
+
+        async def get(self, url):
+            raise httpx.ReadError("connection dropped")
+
+    monkeypatch.setattr(startup.httpx, "AsyncClient", DroppingAsyncClient)
+    monkeypatch.setattr(startup.settings, "model_ready_timeout", 0.001)
+    monkeypatch.setattr(startup.settings, "model_ready_interval", 0.001)
+    monkeypatch.setattr(startup, "model_readiness", ModelReadiness())
+
+    assert asyncio.run(startup.wait_for_model_server()) is False
+    assert startup.model_readiness.error == "connection failed (ReadError)"

tests/test_text_cleaner.py

@@ -74,6 +74,30 @@ def test_strips_null_bytes(self, cleaner):
         assert "HelloWorld" in result
 
 
+class TestHtmlCleanup:
+    def test_converts_html_table_to_plain_text_rows(self, cleaner):
+        text = (
+            "<table><tr><td>Köre almagan yiğittin,</td><td>Göremeyen yiğidin,</td></tr>"
+            "<tr><td>Kökiregi tüyilsin.</td><td>Göğsü duralsın.</td></tr></table>"
+        )
+
+        result = cleaner.clean(text)
+
+        assert result == (
+            "Köre almagan yiğittin, | Göremeyen yiğidin,\n"
+            "Kökiregi tüyilsin. | Göğsü duralsın."
+        )
+        assert "<table" not in result
+        assert "<td" not in result
+
+    def test_unescapes_html_entities(self, cleaner):
+        text = "&quot;Yüzü de ak dana, Şarifulla&#x27;nın giydiği"
+
+        result = cleaner.clean(text)
+
+        assert result == '"Yüzü de ak dana, Şarifulla\'nın giydiği'
+
+
 class TestWhitespaceNormalization:
     def test_multiple_blank_lines(self, cleaner):
         text = "Line 1\n\n\n\n\nLine 2"