fix: Load summarization model locally with float16 (HF free tier has no outbound DNS)

- HF Spaces free tier blocks ALL outbound DNS - no external API calls possible
- Load summarization model locally with float16 (280MB vs 560MB)
- Install CPU-only PyTorch (~200MB vs ~2GB)
- Spelling/punctuation/autocomplete gracefully degrade (return input unchanged)
- Health check accurately reports model availability

Dockerfile

@@ -8,8 +8,10 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     && rm -rf /var/lib/apt/lists/*
 
 # Copy requirements and install Python dependencies
+# Install CPU-only PyTorch first (saves ~1.5GB vs full torch)
 COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir torch --index-url https://download.pytorch.org/whl/cpu && \
+    pip install --no-cache-dir -r requirements.txt
 
 # Copy application code
 COPY src/ ./src/
@@ -23,5 +25,5 @@ ENV PYTHONUNBUFFERED=1
 # Expose port
 EXPOSE 7860
 
-# Start the app with gunicorn
+# Start the app with gunicorn (single worker to minimize RAM)
 CMD ["gunicorn", "--chdir", "src", "app:app", "--bind", "0.0.0.0:7860", "--timeout", "120", "--workers", "1"]

src/app.py

@@ -81,13 +81,14 @@ punctuation_model = None
 
 
 def load_models():
-    """Load models. In HF API mode, skip local loading entirely."""
+    """Load models. In HF API mode, load summarization locally; other models gracefully degrade."""
     global summarization_model, spelling_model, autocomplete_model, grammar_model, punctuation_model
     
     if USE_HF_API:
-        logger.info("HF_API_TOKEN is set — using HuggingFace Inference API (no local models loaded)")
-        logger.info("Models will be called remotely: summarization, spelling, punctuation, autocomplete")
-        return True
+        logger.info("HF_API_TOKEN is set — HF API mode enabled")
+        logger.info("NOTE: HF Spaces free tier has NO outbound DNS. Loading summarization model locally.")
+        logger.info("Spelling, punctuation, autocomplete will gracefully degrade (return input unchanged).")
+        # Fall through to load summarization model locally
     
     loaded = []
     failed = []
@@ -139,20 +140,22 @@ def health_check():
     if USE_HF_API:
         health = {
             'status': 'healthy',
-            'mode': 'hf_inference_api',
+            'mode': 'hf_spaces_local',
             'models': {
-                'summarization': True,
-                'spelling': True,
-                'autocomplete': True,
-                'grammar': True,
-                'punctuation': True
+                'summarization': summarization_model is not None,
+                'spelling': False,
+                'autocomplete': False,
+                'grammar': False,
+                'punctuation': False
             },
+            'note': 'Free tier: summarization local, other models return input unchanged',
             'supabase': {
                 'configured': bool(SUPABASE_URL and SUPABASE_ANON_KEY),
             },
             'environment': 'huggingface_spaces',
         }
-        return jsonify(health), 200
+        status_code = 200 if summarization_model is not None else 503
+        return jsonify(health), status_code
     
     health = {
         'status': 'healthy',
@@ -201,7 +204,7 @@ def summarize():
         "full_text": true/false (whether to summarize full text or just first paragraph)
     }
     """
-    if not USE_HF_API and summarization_model is None:
+    if summarization_model is None:
         return jsonify({
             'error': 'Summarization model not loaded. Please check server logs.',
             'status': 'error'
@@ -253,10 +256,8 @@ def summarize():
         # Generate summary
         logger.info(f"Generating summary: length={length}, max_length={max_length}, text_length={len(text)}")
         
-        if USE_HF_API:
-            summary = hf_summarize(text, max_length=max_length, min_length=max(10, max_length // 3))
-        else:
-            summary = summarization_model.summarize(text, max_length=max_length, min_length=max(10, max_length // 3))
+        # Always use local model (HF Spaces free tier has no outbound DNS for API calls)
+        summary = summarization_model.summarize(text, max_length=max_length, min_length=max(10, max_length // 3))
         
         return jsonify({
             'summary': summary,

src/hf_inference.py

@@ -1,226 +1,98 @@
 """
 HuggingFace Inference API client for Bayan models.
 
-Dynamically discovers a reachable HF API endpoint from inside HF Spaces,
-since api-inference.huggingface.co is not DNS-resolvable from free-tier containers.
+IMPORTANT: HF Spaces free tier has NO outbound DNS resolution.
+Neither urllib, requests, httpx, nor InferenceClient can reach
+external APIs from inside the container.
+
+This module provides graceful fallbacks:
+- Summarization: uses local model (loaded in model_loader.py / app.py)
+- Spelling/Punctuation/Grammar/Autocomplete: return input unchanged (graceful degradation)
+  These features require either a paid HF Space tier or local model files.
 """
 
 import os
-import json
 import logging
 import time
-import socket
 
 logger = logging.getLogger(__name__)
 
 HF_API_TOKEN = os.environ.get("HF_API_TOKEN", "")
 
-_client = None
-_working_url = None
-
-
-def _get_client():
-    global _client
-    if _client is None:
-        from huggingface_hub import InferenceClient
-        _client = InferenceClient(token=HF_API_TOKEN if HF_API_TOKEN else None)
-    return _client
-
-
-# Repository IDs
+# Repository IDs (kept for reference)
 SUMMARIZATION_REPO = os.environ.get("SUMMARIZATION_REPO_ID", "bayan10/summarization-model")
 SPELLING_REPO = os.environ.get("SPELLING_REPO_ID", "bayan10/AraSpell-Model")
 PUNCTUATION_REPO = os.environ.get("PUNCTUATION_REPO_ID", "bayan10/PuncAra-v1")
 AUTOCOMPLETE_REPO = os.environ.get("AUTOCOMPLETE_REPO_ID", "bayan10/AutoComplete")
 
 
-def _find_working_endpoint():
-    """Try multiple HF API endpoints to find one that resolves."""
-    global _working_url
-
-    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}
-
-    headers = {"Content-Type": "application/json"}
-    if HF_API_TOKEN:
-        headers["Authorization"] = "Bearer " + HF_API_TOKEN
-
-    logger.info("Calling HF model: %s at %s", repo_id, url)
-
-    with httpx.Client(timeout=120) as client:
-        resp = client.post(url, json=payload, headers=headers)
-
-    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])
-
-    if isinstance(result, dict) and "error" in result:
-        raise RuntimeError("HF API error: " + str(result["error"]))
-
-    return result
-
-
-def _extract_text(result, fallback=""):
-    """Extract text from various HF response formats."""
-    if isinstance(result, list) and len(result) > 0:
-        item = result[0]
-        if isinstance(item, dict):
-            return (item.get("summary_text")
-                    or item.get("generated_text")
-                    or item.get("translation_text")
-                    or fallback)
-        return str(item) if str(item).strip() else fallback
-    if isinstance(result, dict):
-        return (result.get("summary_text")
-                or result.get("generated_text")
-                or result.get("translation_text")
-                or fallback)
-    return str(result) if result else fallback
-
-
-# ============================================================
-# Model wrappers
-# ============================================================
-
 def hf_summarize(text, max_length=128, min_length=30):
-    result = _call_model_httpx(SUMMARIZATION_REPO, {
-        "inputs": text,
-        "parameters": {"max_length": max_length, "min_length": min_length},
-    }, task="summarization")
-    return _extract_text(result, text[:100])
+    """
+    Summarize Arabic text.
+    NOTE: In HF API mode, this should NOT be called — the local
+    summarization model is used instead (see app.py load_models).
+    This is a fallback that returns the first few sentences.
+    """
+    logger.warning("hf_summarize called but no external API available. Using extractive fallback.")
+    # Simple extractive fallback: first N words
+    words = text.split()
+    target = max(10, max_length // 4)
+    return " ".join(words[:target]).strip()
 
 
 def hf_correct_spelling(text):
-    result = _call_model_httpx(SPELLING_REPO, {"inputs": text})
-    return _extract_text(result, text)
+    """
+    Correct spelling — graceful degradation (returns input unchanged).
+    Spelling correction requires local model files or a paid tier with network access.
+    """
+    logger.info("Spelling correction unavailable (no network). Returning original text.")
+    return text
 
 
 def hf_add_punctuation(text):
-    result = _call_model_httpx(PUNCTUATION_REPO, {"inputs": text})
-    return _extract_text(result, text)
+    """
+    Add punctuation — graceful degradation (returns input unchanged).
+    Punctuation requires local model files or a paid tier with network access.
+    """
+    logger.info("Punctuation unavailable (no network). Returning original text.")
+    return text
 
 
 def hf_autocomplete(text, n=5):
-    result = _call_model_httpx(AUTOCOMPLETE_REPO, {
-        "inputs": text,
-        "parameters": {"max_new_tokens": 20},
-    }, task="text-generation")
-
-    if isinstance(result, str):
-        c = result[len(text):].strip() if result.startswith(text) else result
-        return [c] if c else [text]
-    if isinstance(result, list):
-        out = []
-        for item in result:
-            g = item.get("generated_text", "") if isinstance(item, dict) else str(item)
-            if g.startswith(text):
-                g = g[len(text):].strip()
-            if g:
-                out.append(g)
-        return out if out else [text]
-    return [text]
+    """
+    Autocomplete — graceful degradation (returns empty list).
+    Autocomplete requires local model files or a paid tier with network access.
+    """
+    logger.info("Autocomplete unavailable (no network). Returning empty.")
+    return []
 
 
 def check_hf_api_available():
-    try:
-        return _find_working_endpoint() is not None
-    except Exception:
-        return False
+    """HF Inference API is NOT available on free tier (no outbound DNS)."""
+    return False
 
 
 def debug_test_all_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__}
-    except Exception as e:
-        results["_info"] = {"error": repr(e)[:200]}
-
-    for name, fn, args in [
-        ("summarization", hf_summarize, (long_text, 30, 10)),
-        ("spelling", hf_correct_spelling, (test_text,)),
-        ("punctuation", hf_add_punctuation, (test_text,)),
-        ("autocomplete", hf_autocomplete, (test_text, 3)),
-    ]:
-        try:
-            t0 = time.time()
-            result = fn(*args)
-            elapsed = time.time() - t0
-            results[name] = {
-                "status": "ok",
-                "result": str(result)[:300],
-                "time_seconds": round(elapsed, 2),
-            }
-        except Exception as e:
-            results[name] = {
-                "status": "error",
-                "error_type": type(e).__name__,
-                "error": str(e)[:500] if str(e) else repr(e)[:500],
-            }
-
-    return results
+    """Return status of all models."""
+    return {
+        "_info": {
+            "note": "HF Spaces free tier has NO outbound DNS. External API calls are impossible.",
+            "recommendation": "Use local model loading for summarization. Other models require local files or paid tier.",
+        },
+        "summarization": {
+            "status": "fallback",
+            "note": "Using local model via model_loader.py (loaded from HF Hub at build time)",
+        },
+        "spelling": {
+            "status": "unavailable",
+            "note": "Returns input unchanged. Requires local model files.",
+        },
+        "punctuation": {
+            "status": "unavailable",
+            "note": "Returns input unchanged. Requires local model files.",
+        },
+        "autocomplete": {
+            "status": "unavailable",
+            "note": "Returns empty. Requires local model files.",
+        },
+    }

src/model_loader.py

@@ -185,7 +185,7 @@ class SummarizationModel:
                         config=config,
                         local_files_only=True,
                         trust_remote_code=False,
-                        torch_dtype=torch.float32
+                        torch_dtype=torch.float16
                     )
                 except Exception as e:
                     logger.warning(f"Failed to load with config: {str(e)}")
@@ -194,7 +194,7 @@ class SummarizationModel:
                         self.model_source,
                         local_files_only=True,
                         trust_remote_code=False,
-                        torch_dtype=torch.float32
+                        torch_dtype=torch.float16
                     )
             except Exception as e:
                 logger.warning(f"Failed to load config: {str(e)}")
@@ -204,7 +204,7 @@ class SummarizationModel:
                         self.model_source,
                         local_files_only=True,
                         trust_remote_code=False,
-                        torch_dtype=torch.float32
+                        torch_dtype=torch.float16
                     )
                 except Exception as e2:
                     logger.warning(f"Failed to load with local_files_only: {str(e2)}")
@@ -212,7 +212,7 @@ class SummarizationModel:
                     self.model = MBartForConditionalGeneration.from_pretrained(
                         self.model_source,
                         trust_remote_code=False,
-                        torch_dtype=torch.float32
+                        torch_dtype=torch.float16
                     )
             
             # Move model to device