app.py

# app.py — DeepSeek-OCR (HF Space, Gradio-only stable)
# - Gradio UI 제공 (Claude Skill은 Gradio /run/predict API로 호출)
# - deepseek_ocr.py 또는 run_dpsk_ocr_image.py를 파일경로로 직접 로드

import io, os, sys, base64, importlib.util, tempfile, traceback
from typing import Optional
from PIL import Image
import numpy as np
import gradio as gr

ROOT = os.path.dirname(__file__)

# 후보 디렉터리: 루트/DeepSeek-OCR-master, DeepSeek-OCR-main/DeepSeek-OCR-master, DeepSeek-OCR-hf 등
DIR_CANDIDATES = [
    "DeepSeek-OCR-master",
    os.path.join("DeepSeek-OCR-main", "DeepSeek-OCR-master"),
    "DeepSeek-OCR-hf",
    os.path.join("DeepSeek-OCR-main", "DeepSeek-OCR-hf"),
]

FILE_CANDIDATES = [
    "deepseek_ocr.py",           # 함수형 또는 클래스형 엔트리 기대
    "run_dpsk_ocr_image.py",     # CLI 스타일 엔트리 가능
    "run_dpsk_ocr.py",           # HF 스크립트
]

def _find_file():
    for d in DIR_CANDIDATES:
        absd = os.path.join(ROOT, d)
        if not os.path.isdir(absd):
            continue
        for fname in FILE_CANDIDATES:
            path = os.path.join(absd, fname)
            if os.path.isfile(path):
                return path
    return None

def _load_module_from_path(path: str):
    name = os.path.splitext(os.path.basename(path))[0]
    spec = importlib.util.spec_from_file_location(name, path)
    if spec is None or spec.loader is None:
        raise ImportError(f"Cannot load module from {path}")
    mod = importlib.util.module_from_spec(spec)
    sys.modules[name] = mod
    spec.loader.exec_module(mod)
    return mod

class OCRAdapter:
    def __init__(self):
        self.entry = None
        self.mode = "demo"
        self.path = _find_file()
        print(f"[Adapter] candidate path: {self.path}")
        if not self.path:
            return
        try:
            mod = _load_module_from_path(self.path)
            # 1) 함수형 엔트리: ocr_image(image, lang="auto")
            if hasattr(mod, "ocr_image"):
                self.entry = lambda img, lang="auto": mod.ocr_image(img, lang=lang)
                self.mode = "func_ocr_image"
                print("[Adapter] using ocr_image(image, lang)")
                return
            # 2) 클래스형 엔트리: DeepSeekOCR().recognize(image, lang)
            if hasattr(mod, "DeepSeekOCR"):
                inst = mod.DeepSeekOCR()
                if hasattr(inst, "recognize"):
                    self.entry = lambda img, lang="auto": inst.recognize(img, lang=lang)
                    self.mode = "class_recognize"
                    print("[Adapter] using DeepSeekOCR().recognize(image, lang)")
                    return
            # 3) 스크립트/CLI형: run() / infer() / main() — 경로 요구 가능
            for cand in ("run", "infer", "main", "predict"):
                if hasattr(mod, cand):
                    fn = getattr(mod, cand)
                    def _call(img, lang="auto", _fn=fn):
                        # 이미지가 파일경로를 요구할 수 있으므로 임시 저장
                        with tempfile.NamedTemporaryFile(suffix=".png", delete=True) as tmp:
                            img.save(tmp.name)
                            try:
                                return str(_fn(tmp.name))
                            except TypeError:
                                # 혹시 lang 등 다른 인자 구조일 경우 시도
                                return str(_fn(tmp.name, lang=lang))
                    self.entry = _call
                    self.mode = f"script_{cand}"
                    print(f"[Adapter] using {os.path.basename(self.path)}.{cand}(...) via temp file")
                    return
        except Exception as e:
            print("[Adapter] load failed:", e)
            print(traceback.format_exc())

        # fallback
        self.entry = lambda img, lang="auto": "[DEMO] 연결 성공 — 실제 추론 함수 확인 필요."
        self.mode = "demo"

    def recognize(self, image: Image.Image, lang="auto") -> str:
        return self.entry(image.convert("RGB"), lang)

ADAPTER = OCRAdapter()

def _to_pil(x) -> Image.Image:
    if isinstance(x, Image.Image):
        return x.convert("RGB")
    if isinstance(x, (bytes, bytearray)):
        return Image.open(io.BytesIO(x)).convert("RGB")
    if isinstance(x, np.ndarray):
        return Image.fromarray(x).convert("RGB")
    raise TypeError("Unsupported image type")

def _b64_to_image(image_b64: str) -> Image.Image:
    import base64
    return _to_pil(base64.b64decode(image_b64))

# ── Gradio UI (Claude Skill은 /run/predict API 사용) ──
def gradio_predict(image, lang):
    if image is None:
        return "No image provided."
    return ADAPTER.recognize(_to_pil(image), lang)

with gr.Blocks(title="DeepSeek-OCR (HF Gradio)") as demo:
    gr.Markdown("### DeepSeek-OCR (HF Space, Gradio)\n현재 모드: **" + ADAPTER.mode + "**  \n경로: " + str(ADAPTER.path))
    with gr.Row():
        img = gr.Image(type="pil", label="Input Image")
        out = gr.Textbox(label="OCR Result", lines=8)
    lang = gr.Radio(["auto","en","ko","ja","zh"], value="auto", label="Language")
    btn = gr.Button("Run OCR")
    btn.click(gradio_predict, inputs=[img, lang], outputs=[out])

# Hugging Face (sdk: gradio)는 전역 변수 `demo`를 자동 실행합니다.
# demo.queue()  # 필요시 사용 (버전별 인자 없이)