app.py

import html
import json
import os
import time
import uuid
from pathlib import Path

os.environ["GRADIO_SSR_MODE"] = "false"

import fastapi
import spaces
import torch
import gradio as gr
from fastapi.responses import JSONResponse, StreamingResponse
from gradio import Server
from gradio.context import LocalContext
from pydantic import BaseModel
from transformers import AutoModelForCausalLM, AutoTokenizer

try:
    from gradio.route_utils import Request as GradioRequest
except ImportError:
    GradioRequest = None

from pasita import infer_kind, convert_to_markdown

MODEL_ID = "OpceanAI/PASITA"
MODEL_CARD = "https://huggingface.co/OpceanAI/PASITA"
MAX_INPUT_CHARS = 60_000

tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
tokenizer.padding_side = "left"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
model = AutoModelForCausalLM.from_pretrained(MODEL_ID, dtype="auto").to(DEVICE)
model.eval()

EMPTY_MD = "No output yet. Paste text on the left, then press Convert."

DETAILS_EMPTY = "Run details will appear here: route, numbers kept, coverage and time."

GLYPH = (
    '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" '
    'stroke-linecap="round" aria-hidden="true">'
    '<path d="M9 4 7 20M17 4l-2 16M4 9h16M3 15h16"/></svg>'
)


def _status(text: str, state: str = "ready", detail: str = "") -> str:
    detail_html = f'<span class="p-detail">{html.escape(detail)}</span>' if detail else ""
    role = 'role="alert"' if state == "error" else 'role="status" aria-live="polite"'
    return (
        f'<div class="p-status {state}" {role}><span class="p-dot"></span>'
        f'<span class="p-text">{html.escape(text)}</span>{detail_html}</div>'
    )


def _details_md(result: dict | None, seconds: float, error: str | None = None) -> str:
    if error is not None:
        return f"Could not convert.\n\n{error}\n\nShorten very long inputs and try again."
    if result is None:
        return DETAILS_EMPTY
    metrics = result["metrics"]
    routes = {
        "model": "PASITA + rerank",
        "structured": "HTML/table converter",
        "passthrough": "Source passthrough",
    }
    lines = [
        f"**Route:** {routes.get(result.get('route'), result.get('route'))}",
        f"**Numbers kept:** {metrics['numbers_matched']} of {metrics['numbers_in']}",
    ]
    missing = metrics.get("missing_number_keys") or []
    if missing:
        shown = ", ".join(f"`{x}`" for x in missing[:10])
        more = f" (+{len(missing) - 10} more)" if len(missing) > 10 else ""
        lines.append(f"**Missing numbers:** {shown}{more} (check the output)")
    lines += [
        f"**Content coverage:** {metrics['content_overlap']:.0%}",
        f"**Time:** {seconds:.1f}s",
        f"**Candidates:** {len(result.get('candidates', []))}",
    ]
    return "\n\n".join(lines)


def _prune_downloads(max_age_seconds: int = 3600) -> None:
    try:
        from gradio.utils import get_cache_folder

        now = time.time()
        for path in Path(get_cache_folder()).glob("pasita-*.md"):
            try:
                if now - path.stat().st_mtime > max_age_seconds:
                    path.unlink()
            except OSError:
                pass
    except Exception:
        pass


def _write_download(markdown: str | None) -> str | None:
    if not markdown or not markdown.strip():
        return None
    try:
        from gradio.utils import get_cache_folder

        _prune_downloads()
        folder = Path(get_cache_folder())
        folder.mkdir(parents=True, exist_ok=True)
        path = folder / f"pasita-{uuid.uuid4().hex[:12]}.md"
        path.write_text(markdown, encoding="utf-8")
        return str(path)
    except Exception:
        return None


def _counter(text: str) -> str:
    text = text or ""
    words = len(text.split())
    return (
        '<span class="p-label">PLAIN TEXT</span>'
        f'<span class="p-count">{len(text):,} CHARS / {words:,} WORDS</span>'
    )


def _clamp_candidates(num_candidates: int | None) -> int:
    if num_candidates is None:
        return 3
    try:
        return max(1, min(3, int(num_candidates)))
    except (TypeError, ValueError):
        return 3


def _normalize(text: str | None, num_candidates: int | None, structured_fallback: bool | None) -> tuple[str, int, bool]:
    text = (text or "").strip()
    if structured_fallback is None:
        structured_fallback = True
    return text, _clamp_candidates(num_candidates), bool(structured_fallback)


def _estimate_duration(text, num_candidates=3, structured_fallback=True, max_output_tokens=None, *args, **kwargs):
    text = text or ""
    if structured_fallback and infer_kind(text.strip()) in ("html", "data"):
        return 15
    candidates = _clamp_candidates(num_candidates if not isinstance(num_candidates, bool) else 3)
    try:
        cap = max(16, min(512, int(max_output_tokens))) if max_output_tokens is not None else 512
    except (TypeError, ValueError):
        cap = 512
    extra = max(0, cap - 210) // 100
    return min(30, max(15, 12 + len(text) // 200 + 4 * (candidates - 1) + extra))


def _run_harness(text: str | None, num_candidates: int | None, structured_fallback: bool | None, max_new_cap: int | None = None) -> dict:
    text, num_candidates, structured_fallback = _normalize(text, num_candidates, structured_fallback)
    if not text:
        raise ValueError("Paste a document to convert.")
    hard_cap = 512
    if max_new_cap is not None:
        try:
            hard_cap = max(16, min(512, int(max_new_cap)))
        except (TypeError, ValueError):
            hard_cap = 512
    started = time.perf_counter()
    result = convert_to_markdown(
        model,
        tokenizer,
        text,
        num_candidates=num_candidates,
        do_sample=True,
        temperature=0.3,
        top_p=0.95,
        seed=0,
        use_cache=True,
        max_new_tokens="auto",
        hard_cap=hard_cap,
        structured_fallback=structured_fallback,
        skip_model_for_structured=True,
    )
    result["elapsed"] = time.perf_counter() - started
    return result


@spaces.GPU(duration=_estimate_duration)
def _gpu_infer(text: str | None = None, num_candidates: int | None = None, structured_fallback: bool | None = None, max_output_tokens: int | None = None) -> dict:
    """Run the PASITA harness on the GPU worker and return the full result dict."""
    return _run_harness(text, num_candidates, structured_fallback, max_output_tokens)


def _friendly_error(exc: Exception) -> tuple[str, str, str, str, None]:
    err_type = type(exc).__name__
    text_lower = str(exc).lower()
    if "zerogpu" in text_lower and any(k in text_lower for k in ("quota", "exhausted", "insufficient", "limit")):
        plain = "The GPU quota ran out. Wait a bit or sign in, then try again."
    elif any(k in text_lower for k in ("illegal duration", "task aborted", "queue is full", "queue full")):
        plain = "The GPU was too busy. Shorten the input or try again in a bit."
    else:
        plain = f"Something failed on the server ({err_type}). Try again."
    return (
        f"> Could not convert.\n>\n> {plain}",
        "",
        _status(f"ERROR / {err_type}", "error"),
        _details_md(None, 0.0, error=f"{plain} Technical detail: {err_type}: {exc}"),
        None,
    )


def convert(text: str | None = None, num_candidates: int | None = None, structured_fallback: bool | None = None, max_output_tokens: int | None = None) -> tuple[str, str, str, str, str | None]:
    """Convert a plain-text document into faithful GitHub-Flavored Markdown.

    PASITA samples the document several times, every candidate is post-processed and
    scored for number fidelity, content coverage and GFM validity, and the best one is
    returned. Inputs detected as HTML or delimited data are converted deterministically,
    and a run that loses source numbers falls back to a faithful passthrough of the input.

    Args:
        text: The document to convert, for example OCR output, pasted HTML, meeting notes or a report.
        num_candidates: How many PASITA samples to generate and rerank, from 1 to 3.
        structured_fallback: Use the deterministic converter for HTML and delimited data.
        max_output_tokens: Optional cap on generated tokens. When omitted, the length is chosen automatically.
    Returns:
        A tuple of the rendered Markdown, the raw Markdown, a status line, run details
        and a download path for the Markdown file (or None).
    """
    text = (text or "").strip()
    if not text:
        return EMPTY_MD, "", _status("READY / PASTE A DOCUMENT TO CONVERT"), DETAILS_EMPTY, None
    if len(text) > MAX_INPUT_CHARS:
        message = f"Input too long ({len(text):,} chars). The limit is {MAX_INPUT_CHARS:,} characters."
        return (
            f"> {message} Shorten the document and try again.",
            "",
            _status("ERROR / INPUT TOO LONG", "error"),
            _details_md(None, 0.0, error=message),
            None,
        )

    try:
        result = _gpu_infer(text, num_candidates, structured_fallback, max_output_tokens)
        metrics = result["metrics"]
        numbers = f"{metrics['numbers_matched']}/{metrics['numbers_in']} NUMBERS"
        overlap = f"{metrics['content_overlap']:.0%} CONTENT"
        routes = {
            "model": "PASITA + RERANK",
            "structured": "HTML/TABLE CONVERTER",
            "passthrough": "SOURCE PASSTHROUGH",
        }
        source_label = routes.get(result.get("route"), "PASITA + RERANK")
        taken = result["seconds"] if result["seconds"] else result["elapsed"]
        detail = f"{source_label} / {numbers} / {overlap} / {taken:.1f}S"
        if result.get("strategy", {}).get("truncated_input"):
            detail += " / INPUT TRUNCATED TO 2048 TOKENS"
        return result["markdown"], result["markdown"], _status("DONE", "ready", detail), _details_md(result, taken), _write_download(result["markdown"])
    except Exception as exc:
        return _friendly_error(exc)


@spaces.GPU(duration=_estimate_duration)
def gpu_convert(text: str | None = None, num_candidates: int | None = None, structured_fallback: bool | None = None, max_output_tokens: int | None = None) -> dict:
    """Convert a document and return the full conversion result.

    Same pipeline as the UI conversion. Used by the /v1 OpenAI-style API routes.

    Args:
        text: The document to convert.
        num_candidates: How many PASITA samples to generate and rerank, from 1 to 3.
        structured_fallback: Use the deterministic converter for HTML and delimited data.
        max_output_tokens: Optional cap on generated tokens. When omitted, the length is chosen automatically.
    Returns:
        The full result dict: markdown, route, metrics, timing and candidate info.
    """
    return _run_harness(text, num_candidates, structured_fallback, max_output_tokens)


API_DESCRIPTION = """
OpenAI-style REST API for [PASITA](https://huggingface.co/OpceanAI/PASITA), an 88M
from-scratch model that turns plain text into faithful Markdown. No API key is required.
Works with the OpenAI SDK by pointing `base_url` at `/v1`. The Gradio API and the MCP
server stay available at `?view=api`.

Honored request fields: `model`, `messages`, `stream`, `stream_options.include_usage`,
`max_tokens` (upper bound), `candidates` (1-3), `structured_fallback`. Sampling
temperature is fixed at 0.3 because that is the measured recipe; other OpenAI fields
are accepted but ignored.
""".strip()


def _api_error(message: str, error_type: str = "invalid_request_error", status: int = 400, code: str | None = None, headers: dict | None = None) -> JSONResponse:
    return JSONResponse(
        status_code=status,
        content={"error": {"message": message, "type": error_type, "param": None, "code": code}},
        headers=headers,
    )


def _exception_to_error(exc: Exception) -> JSONResponse:
    message = f"{type(exc).__name__}: {exc}"
    text = message.lower()
    if "zerogpu" in text and any(k in text for k in ("quota", "exhausted", "insufficient", "limit")):
        return _api_error(str(exc), "rate_limit_error", status=429, code="gpu_quota_exceeded", headers={"Retry-After": "60"})
    if any(k in text for k in ("illegal duration", "task aborted", "queue is full", "queue full")):
        return _api_error(str(exc), "rate_limit_error", status=429, code="gpu_busy", headers={"Retry-After": "30"})
    return _api_error(message, "server_error", status=500)


def _with_request_context(request: fastapi.Request, text: str, candidates: int, fallback: bool, max_tokens: int | None = None) -> dict:
    if GradioRequest is not None:
        gr_request = GradioRequest(request=request, session_hash="api")
        token = LocalContext.request.set(gr_request)
        try:
            return gpu_convert(text, candidates, fallback, max_tokens)
        finally:
            LocalContext.request.reset(token)
    return gpu_convert(text, candidates, fallback, max_tokens)


def _token_counts(text: str, markdown: str, prompt_tokens: int | None = None) -> tuple[int, int]:
    if not prompt_tokens:
        prompt_tokens = len(tokenizer(text, add_special_tokens=True)["input_ids"])
    completion_tokens = len(tokenizer(markdown, add_special_tokens=False)["input_ids"])
    return prompt_tokens, completion_tokens


class ChatMessage(BaseModel):
    role: str = "user"
    content: str | list | None = None


class ChatCompletionRequest(BaseModel):
    model: str | None = "pasita-v1"
    messages: list[ChatMessage]
    stream: bool = False
    stream_options: dict | None = None
    max_tokens: int | None = None
    candidates: int = 3
    structured_fallback: bool = True


class ConvertRequest(BaseModel):
    text: str
    candidates: int = 3
    structured_fallback: bool = True
    max_tokens: int | None = None


server = Server(title="PASITA API", version="1.0.0", description=API_DESCRIPTION)


_V2_CONVERT_PATHS = frozenset({"/gradio_api/call/v2/convert", "/gradio_api/call/v2/convert/"})
_V1_CONVERT_PATHS = frozenset({"/gradio_api/call/convert", "/gradio_api/call/convert/"})
_QUEUE_JOIN_PATHS = frozenset({"/gradio_api/queue/join", "/gradio_api/queue/join/"})
_CONVERT_API_NAMES = frozenset({"convert", "convert_1"})


def _is_convert_fn(scope, fn_index) -> bool:
    try:
        app = scope.get("app")
        if app is None or not hasattr(app, "get_blocks"):
            return False
        blocks = app.get_blocks()
        fns = getattr(blocks, "fns", None)
        if not fns or not isinstance(fn_index, int) or isinstance(fn_index, bool):
            return False
        if not 0 <= fn_index < len(fns):
            return False
        return getattr(fns[fn_index], "api_name", None) in _CONVERT_API_NAMES
    except Exception:
        return False
_CONVERT_PARAMS = (("text", ""), ("num_candidates", 3), ("structured_fallback", True), ("max_output_tokens", None))


def _clean_candidates(value) -> int:
    try:
        ivalue = int(value)
    except (TypeError, ValueError):
        return 3
    return ivalue if 1 <= ivalue <= 3 else 3


def _clean_flag(value) -> bool:
    if value is None or value == "":
        return True
    if isinstance(value, bool):
        return value
    if isinstance(value, (int, float)):
        return bool(value)
    if isinstance(value, str):
        lowered = value.strip().lower()
        if lowered in ("true", "1", "yes", "on"):
            return True
        if lowered in ("false", "0", "no", "off"):
            return False
    return True


def _clean_convert_value(name: str, value):
    if name == "num_candidates":
        return _clean_candidates(value)
    if name == "structured_fallback":
        return _clean_flag(value)
    if name == "max_output_tokens":
        if value is None or value == "":
            return None
        try:
            ivalue = int(value)
        except (TypeError, ValueError):
            return None
        return max(16, min(512, ivalue))
    return value


class _LegacyConvertBodyMiddleware:
    def __init__(self, app):
        self.app = app

    async def __call__(self, scope, receive, send):
        if scope.get("type") != "http" or scope.get("method") != "POST":
            await self.app(scope, receive, send)
            return
        path = scope.get("path", "")
        is_v2 = path in _V2_CONVERT_PATHS
        is_v1 = path in _V1_CONVERT_PATHS
        is_queue = path in _QUEUE_JOIN_PATHS
        if not (is_v2 or is_v1 or is_queue):
            await self.app(scope, receive, send)
            return
        body = b""
        while True:
            message = await receive()
            body += message.get("body", b"")
            if not message.get("more_body"):
                break
        try:
            parsed = json.loads(body.decode("utf-8")) if body else None
        except Exception:
            parsed = None
        if isinstance(parsed, dict):
            if is_queue and not _is_convert_fn(scope, parsed.get("fn_index")):
                pass
            else:
                if is_v2 and "data" in parsed and "text" not in parsed:
                    data = parsed.get("data")
                    if isinstance(data, list):
                        named: dict = {}
                        for (name, _default), value in zip(_CONVERT_PARAMS, data):
                            named[name] = value
                        for key in ("session_hash", "event_id", "fn_index", "trigger_id", "batched"):
                            if key in parsed:
                                named[key] = parsed[key]
                        parsed = named
                if is_v2:
                    for name, default in _CONVERT_PARAMS:
                        if name in parsed and (parsed[name] is None or parsed[name] == ""):
                            parsed[name] = default
                    for name in ("num_candidates", "structured_fallback", "max_output_tokens"):
                        if name in parsed:
                            parsed[name] = _clean_convert_value(name, parsed[name])
                elif isinstance(parsed.get("data"), list):
                    data = list(parsed["data"])
                    while len(data) < len(_CONVERT_PARAMS):
                        data.append(None)
                    cleaned = []
                    for (name, default), value in zip(_CONVERT_PARAMS, data):
                        if value is None or value == "":
                            cleaned.append(default if name != "text" else "")
                        else:
                            cleaned.append(_clean_convert_value(name, value))
                    parsed = dict(parsed)
                    parsed["data"] = cleaned
                body = json.dumps(parsed, default=str).encode("utf-8")

        async def receive_once():
            return {"type": "http.request", "body": body, "more_body": False}

        headers = [(k, v) for k, v in scope.get("headers", []) if k.lower() != b"content-length"]
        headers.append((b"content-length", str(len(body)).encode("latin-1")))
        scope["headers"] = headers
        await self.app(scope, receive_once, send)


server.add_middleware(_LegacyConvertBodyMiddleware)

try:
    from fastapi.middleware.cors import CORSMiddleware

    server.add_middleware(
        CORSMiddleware,
        allow_origins=["*"],
        allow_methods=["GET", "POST", "OPTIONS"],
        allow_headers=["*"],
    )
except Exception:
    pass


@server.exception_handler(fastapi.exceptions.RequestValidationError)
async def validation_error_handler(request: fastapi.Request, exc: fastapi.exceptions.RequestValidationError):
    issues = "; ".join(f"{'.'.join(str(l) for l in e.get('loc', []))}: {e.get('msg', '')}" for e in exc.errors()[:3])
    return _api_error(f"Invalid request body: {issues}", status=400)


@server.get("/v1/models")
def list_models() -> dict:
    return {
        "object": "list",
        "data": [{"id": "pasita-v1", "object": "model", "created": 1760000000, "owned_by": "OpceanAI"}],
    }


@server.get("/v1/health")
def health() -> dict:
    return {"status": "ok", "model": "pasita-v1"}


def _validate(body: ChatCompletionRequest | ConvertRequest, text: str | None) -> JSONResponse | None:
    if text is None or not text.strip():
        return _api_error("No input text was provided.", code="empty_input")
    if len(text) > MAX_INPUT_CHARS:
        return _api_error(
            f"The document is too long ({len(text):,} chars). The limit is {MAX_INPUT_CHARS:,} characters.",
            code="input_too_long",
        )
    candidates = getattr(body, "candidates", 3)
    try:
        candidates = int(candidates)
    except (TypeError, ValueError):
        return _api_error("candidates must be between 1 and 3.", code="invalid_candidates")
    if not 1 <= candidates <= 3:
        return _api_error("candidates must be between 1 and 3.", code="invalid_candidates")
    return None


def _result_payload(result: dict, text: str, started: float) -> dict:
    markdown = result["markdown"]
    prompt_tokens, completion_tokens = _token_counts(text, markdown, result.get("prompt_tokens"))
    return {
        "markdown": markdown,
        "route": result.get("route", "model"),
        "metrics": result["metrics"],
        "candidates": len(result.get("candidates", [])),
        "seconds": round(result["seconds"] or result["elapsed"], 2),
        "usage": {
            "prompt_tokens": prompt_tokens,
            "completion_tokens": completion_tokens,
            "total_tokens": prompt_tokens + completion_tokens,
        },
        "elapsed": round(time.perf_counter() - started, 2),
    }


@server.post("/v1/convert", response_model=None)
def v1_convert(body: ConvertRequest, request: fastapi.Request) -> dict | JSONResponse:
    error = _validate(body, body.text)
    if error is not None:
        return error
    started = time.perf_counter()
    try:
        result = _with_request_context(request, body.text.strip(), int(body.candidates), bool(body.structured_fallback), body.max_tokens)
    except Exception as exc:
        return _exception_to_error(exc)
    payload = _result_payload(result, body.text.strip(), started)
    payload.update({"id": f"conv-{uuid.uuid4().hex[:24]}", "object": "pasita.conversion", "created": int(time.time()), "model": "pasita-v1"})
    return payload


def _extract_user_text(messages: list[ChatMessage]) -> str | None:
    for message in reversed(messages):
        if message.role != "user":
            continue
        content = message.content
        if isinstance(content, str):
            return content
        if isinstance(content, list):
            parts = []
            for part in content:
                if isinstance(part, dict) and part.get("type") == "text":
                    parts.append(str(part.get("text", "")))
                elif isinstance(part, str):
                    parts.append(part)
            joined = "\n".join(p for p in parts if p)
            if joined:
                return joined
            continue
        continue
    return None


def reset() -> tuple[str, str, str, str, str | None, str]:
    return EMPTY_MD, "", _status("READY"), DETAILS_EMPTY, None, _counter("")


@server.post("/v1/chat/completions", response_model=None)
def chat_completions(body: ChatCompletionRequest, request: fastapi.Request) -> dict | JSONResponse | StreamingResponse:
    text = _extract_user_text(body.messages)
    error = _validate(body, text)
    if error is not None:
        return error

    started = time.perf_counter()
    try:
        result = _with_request_context(request, text.strip(), int(body.candidates), bool(body.structured_fallback), body.max_tokens)
    except Exception as exc:
        return _exception_to_error(exc)

    payload = _result_payload(result, text.strip(), started)
    completion_id = f"chatcmpl-{uuid.uuid4().hex[:24]}"
    created = int(time.time())
    markdown = payload["markdown"]

    if body.stream:
        include_usage = bool((body.stream_options or {}).get("include_usage"))

        def sse():
            def chunk(delta, finish=None, usage=None):
                data = {
                    "id": completion_id,
                    "object": "chat.completion.chunk",
                    "created": created,
                    "model": "pasita-v1",
                    "choices": [{"index": 0, "delta": delta, "finish_reason": finish}],
                }
                if usage is not None:
                    data["usage"] = usage
                return f"data: {json.dumps(data, ensure_ascii=False)}\n\n"

            yield chunk({"role": "assistant", "content": ""})
            yield chunk({"content": markdown})
            yield chunk({}, finish="stop", usage=payload["usage"] if include_usage else None)
            yield "data: [DONE]\n\n"

        return StreamingResponse(
            sse(),
            media_type="text/event-stream",
            headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
        )

    return {
        "id": completion_id,
        "object": "chat.completion",
        "created": created,
        "model": "pasita-v1",
        "choices": [
            {
                "index": 0,
                "message": {"role": "assistant", "content": markdown},
                "logprobs": None,
                "finish_reason": "stop",
            }
        ],
        "usage": payload["usage"],
        "pasita": {
            "route": payload["route"],
            "metrics": payload["metrics"],
            "candidates": payload["candidates"],
            "seconds": payload["seconds"],
        },
    }


PAINT_JS = """(text, num_candidates, structured_fallback) => {
  const n = Number(num_candidates) || 1;
  const label = n > 1 ? 'PASITA ' + n + ' SAMPLES / RERANK' : 'PASITA SAMPLE / RERANK';
  return ['Converting…', '',
    '<div class="p-status busy"><span class="p-dot"></span><span class="p-text">CONVERTING</span><span class="p-detail">' + label + '</span></div>',
    'Checking drafts…', null];
}"""


def _failed(*args) -> tuple[str, str, str, str, None]:
    message = "The request did not complete. Check your connection and try again."
    return (
        EMPTY_MD,
        "",
        _status("ERROR / CONNECTION LOST", "error"),
        _details_md(None, 0.0, error=message),
        None,
    )

COUNTER_JS = """(text) => {
  const t = (text || '').trim();
  const words = t ? t.split(/\\s+/).length : 0;
  const chars = (text || '').length;
  const cls = chars > 60000 ? 'p-count over' : (chars > 50000 ? 'p-count warn' : 'p-count');
  return '<span class="p-label">PLAIN TEXT</span><span class="' + cls + '">' + chars.toLocaleString() + ' CHARS / ' + words.toLocaleString() + ' WORDS</span>';
}"""


HEADER = f"""
<header class="p-head">
  <div class="p-brand">
    <span class="p-glyph">{GLYPH}</span>
    <h1 class="p-name">PASITA</h1>
    <span class="p-tag">/ 88M FROM SCRATCH</span>
    <span class="sr-only">Convert plain text, HTML and notes to Markdown</span>
  </div>
  <div class="p-actions">
    <a class="p-btn" href="{MODEL_CARD}" target="_blank" rel="noopener">MODEL CARD</a>
  </div>
</header>
"""

FOOTER = f"""
<footer class="p-foot">
  <span>PASITA v1 converts plain text to Markdown, in Spanish and English. It works best on medium and long documents. Limit 60,000 characters per conversion.</span>
  <span>
    <a href="{MODEL_CARD}" target="_blank" rel="noopener">MODEL</a> /
    <a href="/docs" target="_blank" rel="noopener">API DOCS</a> /
    <a href="?view=api" target="_blank" rel="noopener">GRADIO API</a> /
    RUNS ON ZEROGPU
  </span>
</footer>
"""

EXAMPLES = [
    [
        """RESUMEN MENSUAL DE OPERACIONES: MARZO 2026

Resumen ejecutivo
Los pedidos gestionados alcanzaron 18.420 unidades, un 6,1% más que en febrero. El tiempo medio de preparación bajó a 2,4 horas.

Detalle por almacén
Madrid: 8.120 pedidos (+7,4%)
Barcelona: 5.480 pedidos (+3,9%)
Lisboa: 4.820 pedidos (+6,7%)

Incidencias
Se registraron 96 incidencias de embalaje, el 0,52% del total. La previsión para abril es de 19.100 pedidos."""
    ],
    [
        """Team sync, 2026-08-14
Attendees: Ana, Marc, Priya, Tom

Decisions
1. Ship the new onboarding flow on Sept 2.
2. Postpone the pricing experiment to Q4.
3. Marc owns the migration checklist; due Aug 22.

Open questions
- Do we need a second staging cluster?
- Who signs off on the SOC2 evidence?"""
    ],
    [
        """<h2>Shipping policy</h2><p>Orders placed before 2:00 PM CET ship the same business day.</p><ul><li>Standard delivery: 3 to 5 business days</li><li>Express delivery: 1 business day</li><li>Free shipping over 49 EUR</li></ul><p>Returns are accepted within 30 days with the original packaging.</p>"""
    ],
    [
        """year,region,revenue,growth
2019,North America,5120.4,4.1%
2019,Europe,4380.9,3.7%
2019,Latin America,2105.2,2.9%
2020,North America,4875.6,-4.8%
2020,Europe,4210.3,-3.9%
2020,Latin America,1988.1,-5.6%
2021,North America,5402.7,10.8%
2021,Europe,4605.5,9.4%
2021,Latin America,2240.8,12.7%
2022,North America,5610.2,3.8%
2022,Europe,4720.6,2.5%
2022,Latin America,2385.4,6.5%
2023,North America,5894.9,5.1%
2023,Europe,4903.7,3.9%
2023,Latin America,2560.3,7.3%"""
    ],
]

CSS = """@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap');

:root, .gradio-container {
  --bg:#0a0a0b; --panel:#101013; --panel-2:#16161a; --obsidian:#0d0d10;
  --ink:#f4f4f5; --muted:#a1a1aa; --muted-2:#8e8e96;
  --gold:#e8b34c; --green:#4cc38a; --red:#f87171;
  --hair:rgba(255,255,255,0.09); --hair-soft:rgba(255,255,255,0.06);
  --panel-hover:rgba(255,255,255,0.05);
  --font-display:"Inter", system-ui, sans-serif;
  --font-mono:"JetBrains Mono", ui-monospace, monospace;

  --body-background-fill:var(--bg);
  --background-fill-primary:var(--panel);
  --background-fill-secondary:var(--panel-2);
  --block-background-fill:transparent;
  --block-border-color:transparent;
  --block-border-width:0px;
  --block-radius:12px;
  --border-color-primary:var(--hair);
  --body-text-color:var(--ink);
  --body-text-color-subdued:var(--muted);
  --input-background-fill:transparent;
  --input-border-color:transparent;
  --input-radius:8px;
  --color-accent:var(--gold);
  --color-accent-soft:rgba(232,179,76,0.12);
  --button-primary-background-fill:#fafafa;
  --button-primary-background-fill-hover:#e4e4e7;
  --button-primary-text-color:#0a0a0b;
  --button-secondary-background-fill:transparent;
  --button-secondary-text-color:var(--muted);
  --button-secondary-border-color:var(--hair);
  --button-large-radius:8px;
  --button-small-radius:8px;
  --checkbox-background-color-selected:var(--gold);
  --checkbox-border-color-focus:var(--gold);
  --shadow-drop:none; --shadow-drop-lg:none;
  --font:var(--font-display); --font-mono:var(--font-mono);
}

body, .gradio-container {
  background: var(--bg) !important;
  color: var(--ink);
  font-family: var(--font-display);
  font-variant-numeric: tabular-nums;
  -webkit-font-smoothing: antialiased;
}
.gradio-container { max-width: 1200px !important; margin: 0 auto; padding: 0 20px 26px; }
footer[aria-label="Gradio footer navigation"] { display: none !important; }
:focus-visible { outline: 2px solid var(--gold) !important; outline-offset: 2px; }

.p-head {
  display: flex; align-items: center; justify-content: space-between; gap: 16px;
  padding: 20px 0 14px; border-bottom: 1px solid var(--hair-soft); margin-bottom: 20px;
}
.p-brand { display: flex; align-items: center; gap: 10px; }
.p-glyph { display: inline-flex; width: 20px; height: 20px; color: var(--gold); }
.p-glyph svg { width: 100%; height: 100%; }
.p-name { font-weight: 600; letter-spacing: 0.12em; font-size: 0.95rem; margin: 0; }
.sr-only { position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0, 0, 0, 0); white-space: nowrap; border: 0; }
.p-tag { font-family: var(--font-mono); font-size: 0.62rem; letter-spacing: 0.12em; color: var(--muted-2); margin-top: 2px; }
.p-actions { display: flex; align-items: center; gap: 10px; }
.p-btn {
  font-family: var(--font-mono); font-size: 0.72rem; letter-spacing: 0.08em;
  color: var(--ink); text-decoration: none; padding: 0 16px; min-height: 44px;
  display: inline-flex; align-items: center; border-radius: 8px;
  background: var(--panel); border: 1px solid var(--hair);
  transition: background .2s ease, color .2s ease, border-color .2s ease;
}
.p-btn:hover { background: var(--panel-2); border-color: rgba(255,255,255,0.22); }

.p-status {
  display: flex; align-items: center; gap: 9px; margin: -6px 0 16px;
  font-family: var(--font-mono); font-size: 11px; letter-spacing: 0.06em;
  text-transform: uppercase; color: var(--muted); min-height: 20px;
  font-variant-numeric: tabular-nums;
}
.p-dot { width: 7px; height: 7px; border-radius: 50%; background: rgba(255,255,255,0.2); flex-shrink: 0; }
.p-status.ready .p-dot { background: var(--green); }
.p-status.busy .p-dot { background: var(--gold); animation: p-pulse 1.1s ease-in-out infinite; }
.p-status.error { color: var(--red); }
.p-status.error .p-dot { background: var(--red); }
.p-detail { margin-left: auto; color: var(--muted-2); }
@keyframes p-pulse { 0%,100% { opacity: 1; } 50% { opacity: 0.35; } }

#p-shell { gap: 16px; align-items: stretch; }
.p-panel {
  background: var(--panel); border: 1px solid var(--hair); border-radius: 12px;
  padding: 14px 14px 12px; min-width: 0;
}
.p-label { font-family: var(--font-mono); font-size: 0.66rem; letter-spacing: 0.12em; text-transform: uppercase; color: var(--muted); }
.p-count { float: right; font-family: var(--font-mono); font-size: 0.66rem; letter-spacing: 0.02em; color: var(--muted-2); font-variant-numeric: tabular-nums; }
.p-count.warn { color: var(--gold); }
.p-count.over { color: var(--red); }

.p-out-head { display: flex; align-items: center; justify-content: space-between; gap: 12px; margin-bottom: 10px; }
#p-dl { font-family: var(--font-mono) !important; font-size: 0.7rem !important; letter-spacing: 0.08em; min-height: 40px; }

#p-text, #p-text > div { background: transparent !important; border: 0 !important; box-shadow: none !important; }
#p-text textarea {
  background: transparent !important; border: 0 !important; color: var(--ink) !important;
  font-family: var(--font-display) !important; font-size: 0.94rem; line-height: 1.65;
  min-height: 400px; padding: 12px 2px 0;
}
#p-text textarea::placeholder { color: var(--muted-2) !important; }

#p-run, #p-clear { font-family: var(--font-mono) !important; font-size: 0.75rem !important; letter-spacing: 0.1em; min-height: 46px; }
#p-run { flex: 2; font-weight: 500; }
#p-clear { flex: 1; background: transparent !important; color: var(--muted) !important; border: 1px solid var(--hair) !important; }
#p-clear:hover { color: var(--ink) !important; border-color: rgba(255,255,255,0.25) !important; }

#p-examples .label { font-family: var(--font-mono) !important; font-size: 0.66rem !important; letter-spacing: 0.12em; text-transform: uppercase; color: var(--muted) !important; }
#p-examples .label svg { display: none; }
#p-examples .gallery-item {
  background: var(--panel-2) !important; border: 1px solid var(--hair) !important; border-radius: 8px !important;
  color: var(--muted) !important; font-size: 12px !important; min-height: 44px; padding: 8px 14px !important;
  text-align: left; transition: background .2s ease, color .2s ease, border-color .2s ease;
}
#p-examples .gallery-item:hover { border-color: rgba(255,255,255,0.25) !important; color: var(--ink) !important; }

#p-tabs .tab-container[role="tablist"] {
  display: inline-flex; gap: 2px; background: var(--panel-2); border: 1px solid var(--hair);
  border-radius: 10px; padding: 3px; margin-bottom: 12px;
}
#p-tabs .tab-container[role="tablist"] button {
  appearance: none; border: 0 !important; background: transparent !important; border-radius: 7px !important;
  padding: 7px 14px !important; font-family: var(--font-mono) !important; font-size: 12px !important;
  letter-spacing: 0.08em; text-transform: uppercase; color: var(--muted) !important; min-height: 44px;
}
#p-tabs .tab-container[role="tablist"] button.selected,
#p-tabs .tab-container[role="tablist"] button[aria-selected="true"] {
  background: rgba(255,255,255,0.09) !important; color: var(--gold) !important;
}
#p-tabs .tab-container::after,
#p-tabs .tab-container button.selected::after { content: none !important; }

#p-rendered { min-height: 360px; font-size: 0.94rem; line-height: 1.7; color: var(--ink); }
#p-rendered .prose { font-size: 0.94rem; line-height: 1.7; }
#p-rendered h1, #p-rendered h2, #p-rendered h3, #p-rendered h4 { color: var(--ink); font-weight: 600; line-height: 1.3; margin: 1.2em 0 0.5em; letter-spacing: -0.01em; }
#p-rendered h1 { font-size: 1.45em; }
#p-rendered h2 { font-size: 1.22em; }
#p-rendered h3 { font-size: 1.08em; }
#p-rendered p { margin: 0 0 0.85em; }
#p-rendered ul, #p-rendered ol { margin: 0 0 0.85em; padding-left: 1.5em; }
#p-rendered li { margin: 0.22em 0; }
#p-rendered li::marker { color: var(--muted-2); }
#p-rendered a { color: var(--gold); text-decoration: underline; text-underline-offset: 2px; }
#p-rendered a:hover { color: #f2c578; }
#p-rendered blockquote { margin: 0 0 0.85em; padding: 2px 0 2px 14px; border-left: 2px solid var(--hair); color: var(--muted); }
#p-rendered hr { border: 0; border-top: 1px solid var(--hair); margin: 1.2em 0; }
#p-rendered code { font-family: var(--font-mono); font-size: 0.82em; background: var(--panel-2); border: 1px solid var(--hair); border-radius: 6px; padding: 1px 5px; }
#p-rendered pre { margin: 0 0 0.85em; padding: 14px 16px; background: var(--obsidian); border: 1px solid var(--hair); border-radius: 8px; overflow-x: auto; }
#p-rendered pre code { background: none; border: 0; padding: 0; font-size: 0.82em; line-height: 1.6; }
#p-rendered table { border-collapse: collapse; margin: 0 0 0.85em; font-size: 0.9em; display: block; overflow-x: auto; }
#p-rendered th, #p-rendered td { border: 1px solid var(--hair); padding: 6px 11px; text-align: left; font-variant-numeric: tabular-nums; }
#p-rendered th { background: var(--panel-2); color: var(--ink); font-weight: 600; }

#p-source {
  background: var(--obsidian) !important; border: 1px solid var(--hair-soft) !important;
  border-radius: 8px !important; font-family: var(--font-mono) !important; min-height: 360px;
}
#p-source label[data-testid="block-label"] { display: none; }
#p-source .cm-editor { background: transparent !important; }
#p-source .cm-content, #p-source .cm-scroller { color: var(--ink) !important; caret-color: var(--gold) !important; }
#p-source .cm-gutters { background: transparent !important; color: var(--muted-2) !important; border-right: 1px solid var(--hair-soft) !important; }

#p-settings { background: transparent !important; border: 1px solid var(--hair-soft) !important; border-radius: 8px !important; margin-top: 4px; }
#p-settings > .label-wrap { font-family: var(--font-mono) !important; font-size: 0.68rem !important; letter-spacing: 0.1em; text-transform: uppercase; color: var(--muted) !important; }
#p-settings > .label-wrap .icon { color: var(--muted-2) !important; }
#p-settings .info-text { font-size: 0.72rem !important; color: var(--muted-2) !important; }

#p-candidates .wrap { display: inline-flex; gap: 2px; background: var(--panel-2); border: 1px solid var(--hair); border-radius: 10px; padding: 3px; }
#p-candidates label { border-radius: 7px; padding: 7px 16px; margin: 0 !important; cursor: pointer; transition: background .2s ease, color .2s ease; }
#p-candidates label span { font-family: var(--font-mono) !important; font-size: 12px !important; letter-spacing: 0.06em; color: var(--muted) !important; font-variant-numeric: tabular-nums; }
#p-candidates label.selected { background: rgba(255,255,255,0.09) !important; }
#p-candidates label.selected span { color: var(--gold) !important; }
#p-candidates input[type="radio"] { accent-color: var(--gold); }

.p-foot {
  display: flex; flex-wrap: wrap; justify-content: space-between; gap: 14px;
  margin-top: 22px; padding-top: 16px; border-top: 1px solid var(--hair-soft);
  font-family: var(--font-mono); font-size: 0.68rem; letter-spacing: 0.04em; line-height: 1.7; color: var(--muted-2);
}
.p-foot a { color: var(--muted); text-decoration: none; }
.p-foot a:hover { color: var(--gold); }

@media (max-width: 820px) {
  .gradio-container { padding: 0 14px 20px; }
  #p-shell { flex-direction: column !important; }
  .p-tag { display: none; }
  #p-text textarea { min-height: 220px; }
  #p-rendered, #p-source { min-height: 240px; }
  .p-status { flex-wrap: wrap; }
  .p-detail { margin-left: 0; width: 100%; }
  .p-foot { flex-direction: column; gap: 8px; }
  #p-runrow { position: sticky; bottom: 0; background: var(--panel); padding: 8px 0; z-index: 5; }
  #p-examples .gallery-item { min-height: 48px; }
}

@media print {
  body, .gradio-container { background: #fff !important; color: #000 !important; }
  #p-shell { display: block !important; }
  #p-text, #p-settings, #p-examples, #p-runrow, .p-actions { display: none !important; }
  .p-panel { border: 0 !important; background: transparent !important; }
  .p-head { border-bottom: 1px solid #000 !important; }
  #p-rendered, #p-rendered .prose { color: #000 !important; }
  #p-rendered a { color: #000 !important; }
  #p-rendered th { background: transparent !important; }
  #p-rendered code, #p-rendered pre { background: #f4f4f5 !important; border-color: #ccc !important; }
  #p-source .cm-content { color: #000 !important; }
  .p-status, .p-foot { display: none !important; }
}

@media (prefers-reduced-motion: reduce) {
  *, *::before, *::after { animation: none !important; transition: none !important; }
}
"""

theme = gr.themes.Base(
    primary_hue=gr.themes.colors.orange,
    neutral_hue=gr.themes.colors.gray,
    font=[gr.themes.GoogleFont("Inter"), "system-ui", "sans-serif"],
    font_mono=[gr.themes.GoogleFont("JetBrains Mono"), "ui-monospace", "monospace"],
)

with gr.Blocks(title="PASITA: plain text to Markdown") as demo:
    gr.HTML(HEADER)
    status = gr.HTML(_status("READY"), elem_id="p-status")

    with gr.Row(elem_id="p-shell"):
        with gr.Column(scale=1, min_width=320, elem_classes=["p-panel"]):
            label_in = gr.HTML(_counter(""))
            text_in = gr.Textbox(
                label="Input document",
                show_label=False,
                container=False,
                placeholder="Paste OCR output, pasted HTML, meeting notes, a report or an article... (SHIFT + ENTER to convert)",
                lines=20,
                max_lines=26,
                elem_id="p-text",
            )
            with gr.Accordion("SETTINGS", open=False, elem_id="p-settings"):
                candidates = gr.Radio(
                    choices=[1, 2, 3],
                    value=3,
                    type="value",
                    label="PASITA CANDIDATES",
                    info="More samples improve the reranker. 3 is the measured default.",
                    elem_id="p-candidates",
                )
                structured = gr.Checkbox(
                    value=True,
                    label="DETERMINISTIC CONVERTER FOR HTML AND TABLES",
                    info="PASITA does not handle raw HTML or data dumps at this size.",
                )
            with gr.Row(elem_id="p-runrow"):
                run = gr.Button("CONVERT TO MARKDOWN", variant="primary", elem_id="p-run")
                clear = gr.Button("CLEAR", elem_id="p-clear")
        with gr.Column(scale=1, min_width=320, elem_classes=["p-panel"]):
            with gr.Tabs(elem_id="p-tabs"):
                with gr.Tab("RENDERED", elem_id="p-tab-rendered"):
                    md_out = gr.Markdown(EMPTY_MD, buttons=["copy"], height=520, elem_id="p-rendered")
                with gr.Tab("SOURCE", elem_id="p-tab-source"):
                    source = gr.Code(
                        value="", language="markdown", buttons=["copy", "download"],
                        wrap_lines=True, lines=24, max_lines=24, elem_id="p-source",
                    )
                with gr.Tab("DETAILS", elem_id="p-tab-details"):
                    details = gr.Markdown(DETAILS_EMPTY, elem_id="p-details")
            with gr.Row(elem_classes=["p-out-head"]):
                out_label = gr.HTML('<span class="p-label">MARKDOWN</span>')
                dl = gr.DownloadButton("DOWNLOAD .MD", size="sm", elem_id="p-dl")

    gr.Examples(
        examples=EXAMPLES,
        example_labels=["ES REPORT", "EN MEETING", "HTML", "CSV"],
        inputs=[text_in],
        outputs=[md_out, source, status, details, dl],
        fn=convert,
        cache_examples=True,
        cache_mode="lazy",
        examples_per_page=4,
        label="EXAMPLES",
        elem_id="p-examples",
    )
    gr.HTML(FOOTER)

    run.click(
        None,
        inputs=[text_in, candidates, structured],
        outputs=[md_out, source, status, details, dl],
        js=PAINT_JS,
        show_progress="hidden",
        queue=False,
    ).then(
        convert,
        inputs=[text_in, candidates, structured],
        outputs=[md_out, source, status, details, dl],
        api_name="convert",
        show_progress="minimal",
    ).failure(
        _failed,
        inputs=None,
        outputs=[md_out, source, status, details, dl],
        show_progress="hidden",
        api_visibility="undocumented",
    )
    text_in.submit(
        None,
        inputs=[text_in, candidates, structured],
        outputs=[md_out, source, status, details, dl],
        js=PAINT_JS,
        show_progress="hidden",
        queue=False,
    ).then(
        convert,
        inputs=[text_in, candidates, structured],
        outputs=[md_out, source, status, details, dl],
        api_visibility="undocumented",
        show_progress="minimal",
    ).failure(
        _failed,
        inputs=None,
        outputs=[md_out, source, status, details, dl],
        show_progress="hidden",
        api_visibility="undocumented",
    )
    text_in.change(None, inputs=[text_in], outputs=[label_in], js=COUNTER_JS, api_visibility="undocumented")
    clear.click(reset, inputs=None, outputs=[md_out, source, status, details, dl, label_in], api_visibility="undocumented")

demo.queue()
demo.launch(_app=server, theme=theme, css=CSS, mcp_server=True)