merged

.gitignore

@@ -5,3 +5,4 @@ __pycache__/
 venv/
 .env
 .DS_Store
+.gradio_tmp/

README.md

@@ -1,5 +1,5 @@
 ---
-title: HIRO Translation
+title: Document Processing
 emoji: 🦀
 colorFrom: red
 colorTo: indigo
@@ -9,33 +9,43 @@ python_version: '3.13'
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: Patent translation demo via hiro-translation-api
+short_description: Smart Doc + patent translation via connect gateway
 ---
 
-# HIRO Translation
+# Document Processing
 
-Patent translation demo for the HIRO Translation API.
+Gradio demo with two tabs sharing one Bearer API key from the environment.
 
-- **stream** — SSE streaming (`textOriginal` / `textTranslated` per segment)
-- **fast** — single JSON with full `textTranslated`
-- Gateway (fixed): `https://connect.zhihuiya.com/hiro_translation`
-- Auth: Bearer token via **Advanced → API Key** or env `HIRO_API_KEY`
+## Tabs
+
+| Tab | Gateway | Notes |
+|-----|---------|--------|
+| **Smart Doc** | `https://connect.zhihuiya.com/rd-llm/v1/documents/doc_parsing` | Multipart upload · `output_format=both` · **10 MB** max |
+| **Translation** | `https://connect.zhihuiya.com/hiro_translation` | `stream` (SSE segments) or `fast` (single JSON) |
+
+## Auth
+
+Set under Space **Settings → Variables / Secrets** (or local env):
+
+1. `HIRO_API_KEY` (preferred)
+2. else `RD_LLM_API_KEY`
+
+No API key field in the UI.
 
 ## Files
 
 | File | Purpose |
 |------|---------|
-| `app.py` | Gradio UI |
-| `api_client.py` | HTTP client for `/translate` (camelCase request/response) |
+| `app.py` | Gradio UI (tabs + streaming translation + document parse) |
+| `api_client.py` | HTTP clients for translation + Smart Doc |
 | `requirements.txt` | Python dependencies (`requests`; Gradio is pre-installed on Spaces) |
 
 ## Local run
 
 ```bash
 pip install -r requirements.txt
-export HIRO_API_KEY="sk-..."   # optional if set in UI
+export HIRO_API_KEY="sk-..."   # or RD_LLM_API_KEY
 python app.py
 ```
 
 Check out the [Spaces config reference](https://huggingface.co/docs/hub/spaces-config-reference).
-

api_client.py

@@ -1,18 +1,34 @@
-"""HTTP client for HIRO Translation API (public connect gateway or internal stage)."""
+"""HTTP clients for HIRO Translation and Smart Doc (public connect gateway)."""
 
 from __future__ import annotations
 
 import json
 import os
+import re
 from collections.abc import Iterator
+from pathlib import Path
 from typing import Any
 
 import requests
 
-# Public gateway (matches curl examples against connect.zhihuiya.com).
+# Public gateways (matches connect.zhihuiya.com curl examples).
 DEFAULT_BASE = "https://connect.zhihuiya.com/hiro_translation"
+SMARTDOC_URL = "https://connect.zhihuiya.com/rd-llm/v1/documents/doc_parsing"
 
 API_KEY_ENV = "HIRO_API_KEY"
+API_KEY_ENV_FALLBACK = "RD_LLM_API_KEY"
+
+MAX_SMARTDOC_BYTES = 10 * 1024 * 1024
+
+
+def resolve_api_key(api_key: str | None = None) -> str:
+    """Prefer explicit key, then HIRO_API_KEY, then RD_LLM_API_KEY."""
+    if api_key is not None and str(api_key).strip():
+        return str(api_key).strip()
+    return (
+        os.environ.get(API_KEY_ENV, "").strip()
+        or os.environ.get(API_KEY_ENV_FALLBACK, "").strip()
+    )
 
 
 def lang_to_codes(lang: str) -> tuple[str, str]:
@@ -41,9 +57,15 @@ def _api_url(base_url: str, path: str) -> str:
     return f"{base_url.rstrip('/')}{path}"
 
 
-def _request_headers(api_key: str | None = None) -> dict[str, str]:
-    headers = {"Content-Type": "application/json"}
-    key = (api_key if api_key is not None else os.environ.get(API_KEY_ENV, "")).strip()
+def _request_headers(
+    api_key: str | None = None,
+    *,
+    json_body: bool = True,
+) -> dict[str, str]:
+    headers: dict[str, str] = {}
+    if json_body:
+        headers["Content-Type"] = "application/json"
+    key = resolve_api_key(api_key)
     if key:
         headers["Authorization"] = f"Bearer {key}"
     return headers
@@ -105,7 +127,6 @@ def translate_fast(
     data = r.json()
     if data.get("state") not in (None, "success") and "error" in data:
         raise RuntimeError(str(data.get("error", data)))
-    # Normalize to keys the UI already understands (snake_case aliases).
     return {
         "state": data.get("state", "success"),
         "text_original": _original_text(data, text),
@@ -162,3 +183,78 @@ def stream_translate(
                 err = resp.text[:500]
             raise RuntimeError(err)
         yield from _iter_sse_json(resp)
+
+
+def normalize_smartdoc_markdown(markdown: str) -> str:
+    """Fix gateway-escaped newlines without breaking LaTeX commands like \\neq."""
+    text = markdown
+    text = re.sub(r"\\r\\n(?![A-Za-z])", "\n", text)
+    text = re.sub(r"\\n(?![A-Za-z])", "\n", text)
+    text = re.sub(r"\\r(?![A-Za-z])", "\n", text)
+    return text
+
+
+def parse_document(
+    file_path: str,
+    *,
+    api_key: str | None = None,
+    output_format: str = "both",
+    timeout: int = 300,
+    max_bytes: int = MAX_SMARTDOC_BYTES,
+) -> dict[str, Any]:
+    """POST multipart to Smart Doc doc_parsing endpoint."""
+    path = Path(file_path)
+    if not path.is_file():
+        raise RuntimeError(f"file not found: {file_path}")
+    size = path.stat().st_size
+    if size > max_bytes:
+        raise RuntimeError(
+            f"The file must not exceed {max_bytes // (1024 * 1024)} MB"
+        )
+
+    key = resolve_api_key(api_key)
+    if not key:
+        raise RuntimeError(
+            f"API key missing. Set {API_KEY_ENV} (or {API_KEY_ENV_FALLBACK}) "
+            "under Space Settings → Variables / Secrets"
+        )
+
+    with path.open("rb") as fh:
+        files = {"file": (path.name, fh)}
+        data = {"output_format": output_format}
+        r = requests.post(
+            SMARTDOC_URL,
+            headers=_request_headers(key, json_body=False),
+            files=files,
+            data=data,
+            timeout=timeout,
+        )
+
+    try:
+        body = r.json()
+    except json.JSONDecodeError as exc:
+        raise RuntimeError(f"HTTP {r.status_code}: {r.text[:500]}") from exc
+
+    if r.status_code >= 400 or body.get("status") != "success":
+        raise RuntimeError(
+            body.get("error_msg")
+            or body.get("message")
+            or body.get("error")
+            or f"HTTP {r.status_code}"
+        )
+
+    payload = body.get("data") if isinstance(body.get("data"), dict) else body
+    markdown = payload.get("markdown") if isinstance(payload, dict) else ""
+    if not isinstance(markdown, str):
+        markdown = ""
+    results = payload.get("results") if isinstance(payload, dict) else []
+    if not isinstance(results, list):
+        results = []
+    total_pages = payload.get("total_pages") if isinstance(payload, dict) else 0
+
+    return {
+        "markdown": normalize_smartdoc_markdown(markdown),
+        "results": results,
+        "total_pages": total_pages or 0,
+        "raw": body,
+    }

app.py

@@ -1,21 +1,37 @@
 """
-Gradio demo — HIRO Translation API.
+Gradio demo — Document Processing (Smart Doc + Translation).
 
-Calls the public connect gateway by default:
-  https://connect.zhihuiya.com/hiro_translation/translate
+Tabs:
+  - Smart Doc → https://connect.zhihuiya.com/rd-llm/v1/documents/doc_parsing
+  - Translation → https://connect.zhihuiya.com/hiro_translation
 
-Set HIRO_API_KEY or paste a Bearer token in Advanced options.
+Auth: env HIRO_API_KEY, fallback RD_LLM_API_KEY (shared for both tabs).
 """
 
 from __future__ import annotations
 
 import html
 import json
+import os
 import time
+from pathlib import Path
+
+# Shared hosts often leave /tmp/gradio owned by another user → PermissionError on upload.
+_GRADIO_TMP = Path(__file__).resolve().parent / ".gradio_tmp"
+_GRADIO_TMP.mkdir(parents=True, exist_ok=True)
+os.environ.setdefault("GRADIO_TEMP_DIR", str(_GRADIO_TMP))
 
 import gradio as gr
 
-from api_client import DEFAULT_BASE, health_ok, stream_translate, translate_fast
+from api_client import (
+    DEFAULT_BASE,
+    SMARTDOC_URL,
+    health_ok,
+    parse_document,
+    resolve_api_key,
+    stream_translate,
+    translate_fast,
+)
 
 CUSTOM_CSS = """
 .gradio-container {
@@ -187,6 +203,14 @@ CUSTOM_CSS = """
 }
 
 footer { display: none !important; }
+
+.smartdoc-status {
+  font-size: 0.9rem;
+  color: var(--body-text-color-subdued);
+  margin: 0.25rem 0 0.75rem 0;
+}
+.smartdoc-status.ok { color: var(--color-accent, #047857); }
+.smartdoc-status.err { color: var(--error-text-color, #b42318); }
 """
 
 RESULTS_SHELL_HTML = """
@@ -266,21 +290,23 @@ def _has_health_endpoint(base: str) -> bool:
     return "/compute/hiro_translation_api" in base
 
 
-def check_service(api_key: str = "") -> str:
+def check_service() -> str:
     base = _resolve_base(DEFAULT_BASE)
+    key = resolve_api_key()
+    key_hint = "HIRO_API_KEY / RD_LLM_API_KEY" if not key else "API key loaded from env"
 
     if not _has_health_endpoint(base):
         return (
             f'<span class="status-pill ok">● Public gateway<br>'
-            f'<span style="opacity:0.85">Bearer auth on request · {html.escape(base)}</span>'
+            f'<span style="opacity:0.85">{html.escape(base)} · {html.escape(key_hint)}</span>'
             f"</span>"
         )
 
-    ok, msg = health_ok(base, api_key=api_key or None)
+    ok, msg = health_ok(base, api_key=key or None)
     if ok:
         return (
             f'<span class="status-pill ok">● Online<br>'
-            f'<span style="opacity:0.85">{html.escape(base)}</span></span>'
+            f'<span style="opacity:0.85">{html.escape(base)} · {html.escape(key_hint)}</span></span>'
         )
     return (
         f'<span class="status-pill err">● Unavailable<br>'
@@ -575,14 +601,14 @@ INIT_STREAM_WATCH_JS = """
 """
 
 
-def run_translation(text: str, lang: str, mode: str, api_key: str = ""):
+def run_translation(text: str, lang: str, mode: str):
     text = (text or "").strip()
     if not text:
         yield _empty_outputs()
         return
 
     base = _resolve_base(DEFAULT_BASE)
-    auth = api_key or None
+    auth = resolve_api_key() or None
     pairs: list[tuple[str, str]] = []
     t0 = time.perf_counter()
     last_progress = "0/0"
@@ -674,6 +700,44 @@ def run_translation(text: str, lang: str, mode: str, api_key: str = ""):
         yield _pack_outputs(stream_payload=payload, panel_visible=True, copy_enabled=False)
 
 
+def _file_path(file_obj) -> str | None:
+    if file_obj is None:
+        return None
+    if isinstance(file_obj, (list, tuple)):
+        return _file_path(file_obj[0]) if file_obj else None
+    if isinstance(file_obj, str):
+        return file_obj
+    return getattr(file_obj, "name", None) or getattr(file_obj, "path", None)
+
+
+def run_smartdoc(file_obj):
+    path = _file_path(file_obj)
+    if not path:
+        return (
+            '<p class="smartdoc-status err">Please select a file first</p>',
+            "*Rendered Markdown will appear here after parsing.*",
+            "[]",
+        )
+    try:
+        data = parse_document(path)
+        pages = data.get("total_pages") or 0
+        results = data.get("results") or []
+        markdown = data.get("markdown") or ""
+        status = (
+            f'<p class="smartdoc-status ok">Complete · {pages} pages · '
+            f"{len(results)} results</p>"
+        )
+        if not markdown.strip():
+            markdown = "*No Markdown content was returned.*"
+        return status, markdown, json.dumps(results, ensure_ascii=False, indent=2)
+    except Exception as exc:
+        return (
+            f'<p class="smartdoc-status err">Parsing failed: {html.escape(str(exc))}</p>',
+            "*Parsing failed. Check the status message.*",
+            "[]",
+        )
+
+
 def build_theme() -> gr.Theme:
     return gr.themes.Soft(
         primary_hue="blue",
@@ -687,91 +751,140 @@ def build_theme() -> gr.Theme:
 
 def build_ui() -> gr.Blocks:
     with gr.Blocks(
-        title="HIRO Translation",
+        title="Document Processing",
         css=CUSTOM_CSS,
         theme=build_theme(),
     ) as demo:
         with gr.Sidebar():
-            gr.HTML('<p class="main-title">HIRO Translation</p>')
+            gr.HTML('<p class="main-title">Document Processing</p>')
             gr.Markdown(
-                "Patent translation · `connect.zhihuiya.com` / `hiro-translation-api`"
+                "Smart Doc + Translation · shared Bearer key from "
+                "`HIRO_API_KEY` (fallback `RD_LLM_API_KEY`)"
             )
-
             gateway_status = gr.HTML(value=check_service())
-            refresh_btn = gr.Button("Check gateway", size="sm", variant="secondary")
+            refresh_btn = gr.Button("Refresh status", size="sm", variant="secondary")
 
-            with gr.Row():
-                source_lang = gr.Dropdown(
-                    choices=LANG_OPTIONS,
-                    value="zh",
-                    label="Source language",
+        with gr.Tabs():
+            with gr.Tab("Smart Doc"):
+                gr.Markdown(
+                    f"Upload a document for layout + OCR parsing via "
+                    f"`{SMARTDOC_URL}` · PDF / image / Office · **10 MB** max"
                 )
-                target_lang = gr.Dropdown(
-                    choices=LANG_OPTIONS,
-                    value="en",
-                    label="Target language",
-                )
-            lang = gr.Textbox(value="zh2en", visible=False)
-            mode = gr.Radio(
-                choices=["stream", "fast"],
-                value="stream",
-                label="Mode",
-                info="stream: segment streaming; fast: single full response",
-            )
-
-            with gr.Accordion("Advanced", open=False):
-                api_key = gr.Textbox(
-                    label="API Key (Bearer)",
-                    type="password",
-                    placeholder="sk-... or set HIRO_API_KEY",
+                doc_file = gr.File(
+                    label="Document",
+                    file_count="single",
+                    file_types=[
+                        ".pdf",
+                        ".png",
+                        ".jpg",
+                        ".jpeg",
+                        ".doc",
+                        ".docx",
+                        ".ppt",
+                        ".pptx",
+                        ".xls",
+                        ".xlsx",
+                        ".odt",
+                        ".odp",
+                        ".ods",
+                        ".rtf",
+                    ],
                 )
-
-            gr.Markdown("**Examples**")
-            example_btns: list[tuple[gr.Button, str, str, str]] = []
-            for i, (sample, src, tgt) in enumerate(EXAMPLES, start=1):
-                preview = sample.replace("\n", " ")[:36]
-                if len(sample) > 36:
-                    preview += "…"
-                btn = gr.Button(f"{i}. {preview}", size="sm", variant="secondary")
-                example_btns.append((btn, sample, src, tgt))
-
-        with gr.Column():
-            input_text = gr.Textbox(
-                label="Source text",
-                placeholder=(
-                    "Enter patent-related text. Supports Chinese, English, "
-                    "Japanese, Korean, and more."
-                ),
-                lines=8,
-                elem_id="input-box",
-            )
-            with gr.Row(elem_classes=["toolbar-row"]):
-                submit_btn = gr.Button("Translate", variant="primary", scale=0)
-                clear_btn = gr.Button("Clear", scale=0)
-                copy_btn = gr.Button(
-                    "Copy full translation",
-                    variant="secondary",
-                    interactive=False,
-                    scale=0,
-                    elem_id="copy-translation-btn",
+                with gr.Row(elem_classes=["toolbar-row"]):
+                    parse_btn = gr.Button("Parse Document", variant="primary", scale=0)
+                    clear_doc_btn = gr.Button("Clear", scale=0)
+                smartdoc_status = gr.HTML(
+                    value='<p class="smartdoc-status">Select a file to begin</p>'
                 )
-
-            with gr.Column(visible=False, elem_classes=["results-panel-col"]) as results_panel:
-                gr.HTML(RESULTS_SHELL_HTML, elem_id="translation-results")
-                stream_state = gr.Textbox(
-                    value=_stream_state_payload(
-                        visible_pairs=[],
-                        full="",
-                        lang="zh2en",
-                        percent=0,
-                        status="Ready",
+                with gr.Tabs():
+                    with gr.Tab("Markdown"):
+                        smartdoc_md = gr.Markdown(
+                            value="*Rendered Markdown will appear here after parsing.*",
+                            latex_delimiters=[
+                                {"left": "$$", "right": "$$", "display": True},
+                                {"left": "$", "right": "$", "display": False},
+                                {"left": "\\(", "right": "\\)", "display": False},
+                                {"left": "\\[", "right": "\\]", "display": True},
+                            ],
+                        )
+                    with gr.Tab("Results"):
+                        smartdoc_json = gr.Code(
+                            value="[]",
+                            language="json",
+                            label="Structured results",
+                            lines=22,
+                        )
+
+            with gr.Tab("Translation"):
+                with gr.Row():
+                    source_lang = gr.Dropdown(
+                        choices=LANG_OPTIONS,
+                        value="zh",
+                        label="Source language",
+                        scale=1,
+                    )
+                    target_lang = gr.Dropdown(
+                        choices=LANG_OPTIONS,
+                        value="en",
+                        label="Target language",
+                        scale=1,
+                    )
+                    mode = gr.Radio(
+                        choices=["stream", "fast"],
+                        value="stream",
+                        label="Mode",
+                        info="stream: segment streaming; fast: single full response",
+                        scale=1,
+                    )
+                lang = gr.Textbox(value="zh2en", visible=False)
+
+                gr.Markdown("**Examples**")
+                example_btns: list[tuple[gr.Button, str, str, str]] = []
+                with gr.Row():
+                    for i, (sample, src, tgt) in enumerate(EXAMPLES, start=1):
+                        preview = sample.replace("\n", " ")[:28]
+                        if len(sample) > 28:
+                            preview += "…"
+                        btn = gr.Button(f"{i}. {preview}", size="sm", variant="secondary")
+                        example_btns.append((btn, sample, src, tgt))
+
+                input_text = gr.Textbox(
+                    label="Source text",
+                    placeholder=(
+                        "Enter patent-related text. Supports Chinese, English, "
+                        "Japanese, Korean, and more."
                     ),
-                    visible=False,
-                    elem_id="hiro-stream-state",
+                    lines=8,
+                    elem_id="input-box",
                 )
-
-        refresh_btn.click(check_service, inputs=[api_key], outputs=[gateway_status])
-        api_key.change(check_service, inputs=[api_key], outputs=[gateway_status])
+                with gr.Row(elem_classes=["toolbar-row"]):
+                    submit_btn = gr.Button("Translate", variant="primary", scale=0)
+                    clear_btn = gr.Button("Clear", scale=0)
+                    copy_btn = gr.Button(
+                        "Copy full translation",
+                        variant="secondary",
+                        interactive=False,
+                        scale=0,
+                        elem_id="copy-translation-btn",
+                    )
+
+                with gr.Column(
+                    visible=False, elem_classes=["results-panel-col"]
+                ) as results_panel:
+                    gr.HTML(RESULTS_SHELL_HTML, elem_id="translation-results")
+                    stream_state = gr.Textbox(
+                        value=_stream_state_payload(
+                            visible_pairs=[],
+                            full="",
+                            lang="zh2en",
+                            percent=0,
+                            status="Ready",
+                        ),
+                        visible=False,
+                        elem_id="hiro-stream-state",
+                    )
+
+        refresh_btn.click(check_service, outputs=[gateway_status])
 
         def _combine_lang(src: str, tgt: str) -> str:
             return f"{src}2{tgt}"
@@ -791,7 +904,7 @@ def build_ui() -> gr.Blocks:
 
         submit_btn.click(
             fn=run_translation,
-            inputs=[input_text, lang, mode, api_key],
+            inputs=[input_text, lang, mode],
             outputs=[stream_state, results_panel, copy_btn],
         )
 
@@ -829,9 +942,27 @@ def build_ui() -> gr.Blocks:
             outputs=[input_text, stream_state, results_panel, copy_btn],
         )
 
+        parse_btn.click(
+            fn=run_smartdoc,
+            inputs=[doc_file],
+            outputs=[smartdoc_status, smartdoc_md, smartdoc_json],
+        )
+
+        def on_clear_doc():
+            return (
+                None,
+                '<p class="smartdoc-status">Select a file to begin</p>',
+                "*Rendered Markdown will appear here after parsing.*",
+                "[]",
+            )
+
+        clear_doc_btn.click(
+            on_clear_doc,
+            outputs=[doc_file, smartdoc_status, smartdoc_md, smartdoc_json],
+        )
+
         demo.load(
             check_service,
-            inputs=[api_key],
             outputs=[gateway_status],
             js=INIT_STREAM_WATCH_JS,
         )