Update app/services/classifier.py

app/services/classifier.py

@@ -109,12 +109,10 @@ ALLOWED_REASON_CODES = {
 GAME_PROMPT = """
 You are a high-precision parental-control classifier.
 Primary objective: minimize false positives.
-
 Input fields:
 - suspected_game_signal: boolean
 - extracted_urls: list of urls/domains from OCR
 - ocr_text: raw OCR text from screenshot
-
 Decision policy:
 1) Return "game" only if at least one strong signal exists:
      - known game domain/platform in extracted_urls, OR
@@ -123,7 +121,6 @@ Decision policy:
 2) Return "uncertain" only when signals are conflicting and neither side is clearly dominant.
 3) Return "not_game" for weak/generic words (game, games, play) without concrete game context.
 4) Prioritize precision over recall.
-
 Output:
 Return EXACT JSON only using this schema:
 {
@@ -131,7 +128,6 @@ Return EXACT JSON only using this schema:
   "confidence": 0.0-1.0,
     "reason": "reason_code"
 }
-
 Allowed reason codes:
 - game_domain_match
 - game_ui_terms
@@ -139,7 +135,6 @@ Allowed reason codes:
 - weak_generic_terms
 - conflicting_signals
 - no_game_evidence
-
 Do not output markdown, prose, or extra keys.
 """.strip()
 
@@ -285,31 +280,30 @@ def _load_ocr_reader() -> Any | None:
     if _ocr_error is not None:
         return None
 
-    easyocr_error: str | None = None
     try:
-        import easyocr
+        from rapidocr_onnxruntime import RapidOCR
 
         _ocr_reader = {
-            "backend": "easyocr",
-            "reader": easyocr.Reader(["en"], gpu=False),
+            "backend": "rapidocr",
+            "reader": RapidOCR(),
         }
-        logger.info("ocr reader initialized backend=easyocr")
+        logger.info("ocr reader initialized backend=rapidocr")
         return _ocr_reader
     except Exception as exc:
-        easyocr_error = str(exc)
-        logger.warning("ocr easyocr init failed: %s", easyocr_error)
+        rapidocr_error = str(exc)
+        logger.warning("ocr rapidocr init failed: %s", rapidocr_error)
 
     try:
-        from rapidocr_onnxruntime import RapidOCR
+        import easyocr
 
         _ocr_reader = {
-            "backend": "rapidocr",
-            "reader": RapidOCR(),
+            "backend": "easyocr",
+            "reader": easyocr.Reader(["en","vi"], gpu=False),
         }
-        logger.info("ocr reader initialized backend=rapidocr")
+        logger.info("ocr reader initialized backend=easyocr")
         return _ocr_reader
     except Exception as exc:
-        _ocr_error = f"easyocr={easyocr_error}; rapidocr={exc}"
+        _ocr_error = f"rapidocr={rapidocr_error}; easyocr={exc}"
         logger.warning("ocr reader init failed all backends: %s", _ocr_error)
         return None
 
@@ -350,13 +344,7 @@ def _classify_game_with_llm(ocr_text: str, urls: list[str], suspected_game: bool
                     provider=provider_name,
                     token=token or None,
                 )
-                response = client.text_generation(
-                    messages=prompt_messages,
-                    max_tokens=160
-                )
-                content = ""
-                if response.choices:
-                    content = response.choices[0].message.content or ""
+                content = _run_hf_completion(client, prompt_messages, user_payload)
                 parsed = _parse_llm_json(content)
                 if parsed is None:
                     logger.warning(
@@ -388,6 +376,53 @@ def _classify_game_with_llm(ocr_text: str, urls: list[str], suspected_game: bool
     return None
 
 
+def _run_hf_completion(client: Any, prompt_messages: list[dict[str, str]], user_payload: dict[str, Any]) -> str:
+    chat_completion = getattr(client, "chat_completion", None)
+    if callable(chat_completion):
+        response = chat_completion(messages=prompt_messages, max_tokens=160)
+        return _extract_hf_response_text(response)
+
+    chat_api = getattr(client, "chat", None)
+    chat_completions = getattr(chat_api, "completions", None)
+    chat_create = getattr(chat_completions, "create", None)
+    if callable(chat_create):
+        response = chat_create(messages=prompt_messages, max_tokens=160)
+        return _extract_hf_response_text(response)
+
+    prompt = f"{GAME_PROMPT}\n\nInput JSON:\n{json.dumps(user_payload, ensure_ascii=True)}\n\nReturn exact JSON only."
+    response = client.text_generation(
+        prompt=prompt,
+        max_new_tokens=160,
+        return_full_text=False,
+    )
+    return _extract_hf_response_text(response)
+
+
+def _extract_hf_response_text(response: Any) -> str:
+    if response is None:
+        return ""
+    if isinstance(response, str):
+        return response
+    if isinstance(response, dict):
+        choices = response.get("choices") or []
+        if choices:
+            message = choices[0].get("message") or {}
+            if isinstance(message, dict):
+                return str(message.get("content") or "")
+            return str(message or "")
+        return str(response.get("generated_text") or response.get("text") or "")
+
+    choices = getattr(response, "choices", None)
+    if choices:
+        first_choice = choices[0]
+        message = getattr(first_choice, "message", None)
+        if message is not None:
+            return str(getattr(message, "content", "") or "")
+        return str(getattr(first_choice, "text", "") or "")
+
+    return str(getattr(response, "generated_text", "") or getattr(response, "text", "") or response)
+
+
 def _is_model_not_supported_error(exc: Exception) -> bool:
     text = repr(exc).lower()
     return "model_not_supported" in text or "not supported by any provider" in text
@@ -574,4 +609,4 @@ def _extract_nsfw_score(scores: list[float], labels: list[str]) -> float:
             return scores[idx]
     if len(scores) >= 2:
         return scores[1]
-    return scores[0] if scores else 0.0
+    return scores[0] if scores else 0.0