Upload app.py with huggingface_hub

app.py

@@ -59,22 +59,26 @@ def _counter(text: str) -> str:
     )
 
 
+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 num_candidates is None:
-        num_candidates = 3
     if structured_fallback is None:
         structured_fallback = True
-    return text, max(1, min(3, int(num_candidates))), bool(structured_fallback)
+    return text, _clamp_candidates(num_candidates), bool(structured_fallback)
 
 
 def _estimate_duration(text, num_candidates=3, structured_fallback=True, *args, **kwargs):
     if structured_fallback and infer_kind((text or "").strip()) in ("html", "data"):
         return 10
-    try:
-        candidates = int(num_candidates)
-    except (TypeError, ValueError):
-        candidates = 3
+    candidates = _clamp_candidates(num_candidates if not isinstance(num_candidates, bool) else 3)
     return min(30, max(12, 8 + len(text or "") // 200 + 4 * (candidates - 1)))
 
 
@@ -128,6 +132,12 @@ def convert(text: str | None = None, num_candidates: int | None = None, structur
     text = (text or "").strip()
     if not text:
         return EMPTY_MD, "", _status("READY / PASTE A DOCUMENT TO CONVERT")
+    if len(text) > MAX_INPUT_CHARS:
+        return (
+            f"> Input too long ({len(text):,} chars). The limit is {MAX_INPUT_CHARS:,} characters. Shorten the document and try again.",
+            "",
+            _status("ERROR / INPUT TOO LONG", "error"),
+        )
 
     try:
         result = _run_harness(text, num_candidates, structured_fallback, max_output_tokens)
@@ -150,6 +160,8 @@ def convert(text: str | None = None, num_candidates: int | None = None, structur
     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)
 
 
@@ -170,13 +182,6 @@ def gpu_convert(text: str | None = None, num_candidates: int | None = None, stru
     return _run_harness(text, num_candidates, structured_fallback, max_output_tokens)
 
 
-COUNTER_JS = """(text) => {
-  const t = (text || '').trim();
-  const words = t ? t.split(/\\s+/).length : 0;
-  const chars = (text || '').length;
-  return '<span class="p-label">PLAIN TEXT</span><span class="p-count">' + chars.toLocaleString() + ' CHARS / ' + words.toLocaleString() + ' WORDS</span>';
-}"""
-
 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.
@@ -194,9 +199,11 @@ def _api_error(message: str, error_type: str = "invalid_request_error", status:
 
 def _exception_to_error(exc: Exception) -> JSONResponse:
     message = f"{type(exc).__name__}: {exc}"
-    text = str(exc).lower()
-    if "zerogpu" in text and ("quota" in text or "limit" in text or "quota" in message.lower()):
+    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")
+    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")
     return _api_error(message, "server_error", status=500)
 
 
@@ -208,11 +215,12 @@ def _with_request_context(request: fastapi.Request, text: str, candidates: int,
             return gpu_convert(text, candidates, fallback, max_tokens)
         finally:
             LocalContext.request.reset(token)
-    return gpu_convert(text, candidates, fallback)
+    return gpu_convert(text, candidates, fallback, max_tokens)
 
 
-def _token_counts(text: str, markdown: str) -> tuple[int, int]:
-    prompt_tokens = len(tokenizer(text, add_special_tokens=True)["input_ids"])
+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
 
@@ -249,7 +257,7 @@ class _LegacyConvertBodyMiddleware:
         self.app = app
 
     async def __call__(self, scope, receive, send):
-        if scope["type"] != "http" or scope.get("method") != "POST":
+        if scope.get("type") != "http" or scope.get("method") != "POST":
             await self.app(scope, receive, send)
             return
         path = scope.get("path", "")
@@ -314,14 +322,18 @@ def _validate(body: ChatCompletionRequest | ConvertRequest, text: str | None) ->
             code="input_too_long",
         )
     candidates = getattr(body, "candidates", 3)
-    if not 1 <= int(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)
+    prompt_tokens, completion_tokens = _token_counts(text, markdown, result.get("prompt_tokens"))
     return {
         "markdown": markdown,
         "route": result.get("route", "model"),
@@ -366,8 +378,11 @@ def _extract_user_text(messages: list[ChatMessage]) -> str | None:
                     parts.append(str(part.get("text", "")))
                 elif isinstance(part, str):
                     parts.append(part)
-            return "\n".join(p for p in parts if p)
-        return None
+            joined = "\n".join(p for p in parts if p)
+            if joined:
+                return joined
+            continue
+        continue
     return None