ds_batch_ocr/server.py

"""vLLM server management and async inference client."""
from __future__ import annotations

import asyncio
import logging
import os
import signal
import subprocess
import threading
import time
from typing import Any, Awaitable, Dict, List, Sequence

import requests
from openai import AsyncOpenAI

from .document import encode_image

LOGGER = logging.getLogger(__name__)


def _stream_output(pipe, prefix: str) -> None:
    """Stream subprocess output to stdout with prefix."""
    try:
        for line in iter(pipe.readline, ""):
            print(f"[{prefix}] {line.rstrip()}", flush=True)
    finally:
        pipe.close()


def launch_vllm() -> subprocess.Popen:
    """Launch vLLM server as subprocess."""
    model_id = os.environ.get("MODEL_ID", "deepseek-ai/DeepSeek-OCR")
    served_name = os.environ.get("SERVED_MODEL_NAME", "deepseek-ocr")
    port = os.environ.get("PORT", "8080")
    host = os.environ.get("HOST", "0.0.0.0")

    cmd: List[str] = [
        "vllm", "serve", "--model", model_id,
        "--served-model-name", served_name,
        "--tensor-parallel-size", os.environ.get("TENSOR_PARALLEL_SIZE", "1"),
        "--max-model-len", os.environ.get("MAX_MODEL_LEN", "4096"),
        "--gpu-memory-utilization", os.environ.get("GPU_MEMORY_UTILIZATION", "0.85"),
        "--port", port,
        "--host", host,
        "--trust-remote-code",
        "--enable-chunked-prefill",
        "--no-enable-prefix-caching",
        "--mm-processor-cache-gb", os.environ.get("MM_PROCESSOR_CACHE_GB", "0"),
        "--logits-processors", os.environ.get(
            "LOGITS_PROCESSORS",
            "vllm.model_executor.models.deepseek_ocr:NGramPerReqLogitsProcessor"
        ),
    ]

    extra_args = os.environ.get("EXTRA_VLLM_ARGS")
    if extra_args:
        cmd.extend(extra_args.split())

    LOGGER.info("Launching vLLM server: %s", " ".join(cmd))
    process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1)

    # Start output streaming threads
    threads = []
    for name, pipe in [("STDOUT", process.stdout), ("STDERR", process.stderr)]:
        if pipe:
            t = threading.Thread(target=_stream_output, args=(pipe, f"vLLM {name}"), daemon=True)
            t.start()
            threads.append(t)

    process._log_threads = threads  # type: ignore
    return process


def shutdown_server(server_process: subprocess.Popen) -> None:
    """Gracefully shutdown vLLM server."""
    LOGGER.info("Shutting down vLLM server")
    server_process.send_signal(signal.SIGTERM)
    try:
        server_process.wait(timeout=30)
    except subprocess.TimeoutExpired:
        LOGGER.warning("Server did not exit in time, sending SIGKILL")
        server_process.kill()

    for thread in getattr(server_process, "_log_threads", []):
        thread.join(timeout=1)


def wait_for_server(url: str, timeout_s: int = 300, interval_s: int = 5) -> bool:
    """Wait for server health endpoint to respond."""
    deadline = time.time() + timeout_s
    while time.time() < deadline:
        try:
            if requests.get(url, timeout=5).ok:
                return True
        except Exception:
            pass
        time.sleep(interval_s)
    return False


def should_launch_server() -> bool:
    """Check if server should be auto-launched."""
    return os.environ.get("SKIP_SERVER_LAUNCH", "").lower() not in {"1", "true", "yes"}


def base_url_from_env() -> str:
    """Get vLLM base URL from environment."""
    port = os.environ.get("PORT", "8080")
    return os.environ.get("BASE_URL", f"http://127.0.0.1:{port}")


def _prepare_payload(
    image: "Image.Image",
    model_name: str,
    prompt: str,
    max_tokens: int,
    temperature: float,
) -> Dict[str, Any]:
    """Prepare OpenAI-compatible chat completion payload."""
    return {
        "model": model_name,
        "messages": [{
            "role": "user",
            "content": [
                {"type": "text", "text": prompt},
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{encode_image(image)}"}},
            ],
        }],
        "max_tokens": max_tokens,
        "temperature": temperature,
        "extra_body": {
            "skip_special_tokens": False,
            "vllm_xargs": {"ngram_size": 30, "window_size": 90, "whitelist_token_ids": "[128821,128822]"},
        },
    }


class DeepSeekClient:
    """Async batch inference client for DeepSeek OCR via vLLM."""
    
    def __init__(
        self,
        base_url: str,
        model_name: str,
        max_tokens: int,
        temperature: float,
        *,
        request_timeout: int = 120,
        max_retries: int = 3,
        retry_backoff_seconds: float = 2.0,
        max_retry_wait_seconds: float = 60.0,
    ) -> None:
        self.base_url = base_url.rstrip("/")
        self.model_name = model_name
        self.default_max_tokens = max_tokens
        self.default_temperature = temperature
        self.default_request_timeout = request_timeout
        self.max_retries = max(0, max_retries)
        self.retry_backoff_seconds = max(0.0, retry_backoff_seconds)
        self.max_retry_wait_seconds = max_retry_wait_seconds
        self._client = AsyncOpenAI(api_key="vllm", base_url=f"{self.base_url}/v1")

    async def _async_completion(self, payload: Dict[str, Any], timeout: int) -> str:
        """Execute single async completion request."""
        try:
            response = await self._client.chat.completions.create(
                model=payload["model"],
                messages=payload["messages"],
                max_tokens=payload["max_tokens"],
                temperature=payload["temperature"],
                timeout=timeout,
                extra_body=payload.get("extra_body"),
            )
        except Exception as exc:
            LOGGER.error("DeepSeek request failed: %s", exc)
            raise

        if not response.choices:
            return ""
        return getattr(response.choices[0].message, "content", "") or ""

    def infer(self, requests_data: Sequence[Dict[str, Any]]) -> List[str]:
        """Run batch inference synchronously."""
        if not requests_data:
            return []

        payloads = []
        timeouts = []
        for req in requests_data:
            payloads.append(_prepare_payload(
                image=req["image"],
                model_name=self.model_name,
                prompt=req.get("prompt", ""),
                max_tokens=req.get("max_tokens", self.default_max_tokens),
                temperature=req.get("temperature", self.default_temperature),
            ))
            timeouts.append(req.get("request_timeout") or self.default_request_timeout)

        return self._run_async(self._async_infer_batch(payloads, timeouts))

    async def _async_infer_batch(self, payloads: Sequence[Dict[str, Any]], timeouts: Sequence[int]) -> List[str]:
        """Run batch of async completions concurrently."""
        tasks = [asyncio.create_task(self._async_completion(p, t)) for p, t in zip(payloads, timeouts)]
        return await asyncio.gather(*tasks)

    @staticmethod
    def _run_async(coro: Awaitable[Any]) -> Any:
        """Run async coroutine in new event loop."""
        loop = asyncio.new_event_loop()
        try:
            asyncio.set_event_loop(loop)
            result = loop.run_until_complete(coro)
            loop.run_until_complete(loop.shutdown_asyncgens())
            return result
        finally:
            asyncio.set_event_loop(None)
            loop.close()


__all__ = [
    "launch_vllm",
    "shutdown_server", 
    "wait_for_server",
    "should_launch_server",
    "base_url_from_env",
    "DeepSeekClient",
]