fix: DNS endpoint discovery - test multiple HF hostnames to find reachable one

src/hf_inference.py

@@ -1,21 +1,22 @@
 """
 HuggingFace Inference API client for Bayan models.
 
-Uses huggingface_hub.InferenceClient._inner_post with RequestParameters
-(v1.19.0) for internal routing inside HF Spaces.
+Dynamically discovers a reachable HF API endpoint from inside HF Spaces,
+since api-inference.huggingface.co is not DNS-resolvable from free-tier containers.
 """
 
 import os
 import json
 import logging
 import time
+import socket
 
 logger = logging.getLogger(__name__)
 
 HF_API_TOKEN = os.environ.get("HF_API_TOKEN", "")
-HF_API_BASE = "https://api-inference.huggingface.co/models/"
 
 _client = None
+_working_url = None
 
 
 def _get_client():
@@ -33,45 +34,66 @@ PUNCTUATION_REPO = os.environ.get("PUNCTUATION_REPO_ID", "bayan10/PuncAra-v1")
 AUTOCOMPLETE_REPO = os.environ.get("AUTOCOMPLETE_REPO_ID", "bayan10/AutoComplete")
 
 
-def _call_model(repo_id, payload, task=""):
-    """
-    Call HF model via InferenceClient._inner_post with RequestParameters.
-    
-    RequestParameters(url, task, model, json, data, headers)
-    """
-    from huggingface_hub.inference._common import RequestParameters
+def _find_working_endpoint():
+    """Try multiple HF API endpoints to find one that resolves."""
+    global _working_url
 
-    client = _get_client()
+    if _working_url:
+        return _working_url
+
+    # Candidate API endpoints
+    candidates = [
+        "https://router.huggingface.co/hf-inference/models/",
+        "https://api-inference.huggingface.co/models/",
+        "https://api.huggingface.co/models/",
+        "https://huggingface.co/api/models/",
+    ]
+
+    for url in candidates:
+        # Extract hostname from URL
+        hostname = url.split("//")[1].split("/")[0]
+        try:
+            socket.getaddrinfo(hostname, 443)
+            logger.info("DNS resolved for: %s", hostname)
+            _working_url = url
+            return url
+        except socket.gaierror:
+            logger.warning("DNS failed for: %s", hostname)
+            continue
+
+    logger.error("No HF API endpoint is reachable!")
+    return None
+
+
+def _call_model_httpx(repo_id, payload, task=""):
+    """Call HF model using httpx (same transport as InferenceClient)."""
+    import httpx
+
+    base_url = _find_working_endpoint()
+    if not base_url:
+        raise RuntimeError("No reachable HF API endpoint found")
+
+    url = base_url + repo_id
 
     if "options" not in payload:
         payload["options"] = {"wait_for_model": True}
 
-    url = HF_API_BASE + repo_id
-    logger.info("Calling HF model: %s (url=%s, task=%s)", repo_id, url, task)
+    headers = {"Content-Type": "application/json"}
+    if HF_API_TOKEN:
+        headers["Authorization"] = "Bearer " + HF_API_TOKEN
 
-    rp = RequestParameters(
-        url=url,
-        task=task,
-        model=repo_id,
-        json=payload,
-        data=None,
-        headers={},
-    )
+    logger.info("Calling HF model: %s at %s", repo_id, url)
 
-    response = client._inner_post(rp)
+    with httpx.Client(timeout=120) as client:
+        resp = client.post(url, json=payload, headers=headers)
 
-    # Parse response
-    if isinstance(response, bytes):
-        result = json.loads(response.decode("utf-8"))
-    elif isinstance(response, str):
-        result = json.loads(response)
-    else:
-        result = response
+    if resp.status_code != 200:
+        raise RuntimeError(f"HF API error (HTTP {resp.status_code}): {resp.text[:300]}")
 
+    result = resp.json()
     logger.info("HF result for %s: type=%s preview=%s",
                 repo_id, type(result).__name__, str(result)[:200])
 
-    # Check for API errors in response
     if isinstance(result, dict) and "error" in result:
         raise RuntimeError("HF API error: " + str(result["error"]))
 
@@ -101,7 +123,7 @@ def _extract_text(result, fallback=""):
 # ============================================================
 
 def hf_summarize(text, max_length=128, min_length=30):
-    result = _call_model(SUMMARIZATION_REPO, {
+    result = _call_model_httpx(SUMMARIZATION_REPO, {
         "inputs": text,
         "parameters": {"max_length": max_length, "min_length": min_length},
     }, task="summarization")
@@ -109,17 +131,17 @@ def hf_summarize(text, max_length=128, min_length=30):
 
 
 def hf_correct_spelling(text):
-    result = _call_model(SPELLING_REPO, {"inputs": text}, task="text2text-generation")
+    result = _call_model_httpx(SPELLING_REPO, {"inputs": text})
     return _extract_text(result, text)
 
 
 def hf_add_punctuation(text):
-    result = _call_model(PUNCTUATION_REPO, {"inputs": text}, task="text2text-generation")
+    result = _call_model_httpx(PUNCTUATION_REPO, {"inputs": text})
     return _extract_text(result, text)
 
 
 def hf_autocomplete(text, n=5):
-    result = _call_model(AUTOCOMPLETE_REPO, {
+    result = _call_model_httpx(AUTOCOMPLETE_REPO, {
         "inputs": text,
         "parameters": {"max_new_tokens": 20},
     }, task="text-generation")
@@ -141,17 +163,38 @@ def hf_autocomplete(text, n=5):
 
 def check_hf_api_available():
     try:
-        return _get_client() is not None
+        return _find_working_endpoint() is not None
     except Exception:
         return False
 
 
 def debug_test_all_models():
-    """Test all HF models."""
+    """Test DNS resolution + all HF models."""
     results = {}
     test_text = "هذا نص تجريبي للاختبار"
     long_text = (test_text + " ") * 5
 
+    # DNS diagnostics
+    dns_results = {}
+    hostnames = [
+        "router.huggingface.co",
+        "api-inference.huggingface.co",
+        "api.huggingface.co",
+        "huggingface.co",
+        "hf.co",
+        "google.com",
+        "pypi.org",
+    ]
+    for hostname in hostnames:
+        try:
+            addrs = socket.getaddrinfo(hostname, 443)
+            dns_results[hostname] = "OK (" + addrs[0][4][0] + ")"
+        except socket.gaierror as e:
+            dns_results[hostname] = "FAIL: " + str(e)
+
+    results["_dns"] = dns_results
+    results["_working_endpoint"] = _find_working_endpoint() or "NONE"
+
     try:
         import huggingface_hub
         results["_info"] = {"hf_hub_version": huggingface_hub.__version__}