Update app.py

app.py

@@ -4,6 +4,7 @@
 import os, glob, textwrap
 from pathlib import Path
 from typing import Optional, List
+from threading import Lock  # ← para serializar la inferencia
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
@@ -18,27 +19,27 @@ from llama_cpp import Llama
 # ------------------ Helpers ------------------
 def env_int(name: str, default: int) -> int:
     try:
-        return int(os.getenv(name, "").strip() or default)
+        return int((os.getenv(name, "") or "").strip() or default)
     except Exception:
         return default
 
 def env_float(name: str, default: float) -> float:
     try:
-        return float(os.getenv(name, "").strip() or default)
+        return float((os.getenv(name, "") or "").strip() or default)
     except Exception:
         return default
 
 def env_list(name: str) -> List[str]:
-    raw = os.getenv(name, "").strip()
+    raw = (os.getenv(name, "") or "").strip()
     return [x.strip() for x in raw.split(",") if x.strip()]
 
 
 # ------------------ Config ------------------
-# ⇩⇩ modelo 3B (mejor para Spaces CPU gratis)
+# ⇩⇩ modelo 3B (más liviano para Spaces CPU gratis)
 MODEL_REPO = os.getenv("MODEL_REPO", "Qwen/Qwen2.5-3B-Instruct-GGUF")
 
 # Si defines MODEL_PATTERN lo respetamos; si no, probamos varios patrones típicos.
-PRIMARY_PATTERN = os.getenv("MODEL_PATTERN", "").strip()
+PRIMARY_PATTERN = (os.getenv("MODEL_PATTERN", "") or "").strip()
 
 # Carpeta de modelos en /data (escribible en Docker Spaces)
 MODELS_DIR = Path(os.getenv("MODELS_DIR", "/data/models"))
@@ -47,14 +48,15 @@ MODELS_DIR.mkdir(parents=True, exist_ok=True)
 # Rendimiento
 CPU_COUNT = os.cpu_count() or 2
 N_THREADS = env_int("N_THREADS", max(1, CPU_COUNT - 1))
-N_BATCH = env_int("N_BATCH", 64)
-N_CTX = env_int("N_CTX", 1536)  # 1536–2048 ok en CPU basic
+N_BATCH   = env_int("N_BATCH", 64)
+N_CTX     = env_int("N_CTX", 1536)  # 1536–2048 ok en CPU basic
+N_GPU_LAYERS = env_int("N_GPU_LAYERS", 0)
 
 # Decodificación / longitudes
-DEF_TEMPERATURE = env_float("LLM_TEMPERATURE", 0.4)  # un poco más bajo → menos alucinación
-DEF_TOP_P = env_float("LLM_TOP_P", 0.9)
-DEF_MAX_TOKENS = env_int("LLM_MAX_TOKENS", 160)
-MAX_TOKENS_CAP = env_int("LLM_MAX_TOKENS_CAP", 320)
+DEF_TEMPERATURE = env_float("LLM_TEMPERATURE", 0.4)  # más bajo → menos alucinación
+DEF_TOP_P       = env_float("LLM_TOP_P", 0.9)
+DEF_MAX_TOKENS  = env_int("LLM_MAX_TOKENS", 160)
+MAX_TOKENS_CAP  = env_int("LLM_MAX_TOKENS_CAP", 320)
 
 SYSTEM_DEFAULT = textwrap.dedent("""\
 Eres Astrohunters-Guide, un asistente en español.
@@ -65,23 +67,23 @@ Eres Astrohunters-Guide, un asistente en español.
 
 
 # CORS
-allow_all = os.getenv("ALLOW_ALL_ORIGINS", "").strip() in ("1", "true", "yes")
+allow_all = (os.getenv("ALLOW_ALL_ORIGINS", "") or "").strip().lower() in ("1","true","yes")
 CORS_ORIGINS = env_list("CORS_ORIGINS")
-if not CORS_ORIGINS:
+if not CORS_ORIGINS and not allow_all:
+    # Nota: CORSMiddleware no soporta comodines tipo *.dominio;
+    # si necesitas eso, usa ALLOW_ALL_ORIGINS=1 durante pruebas.
     CORS_ORIGINS = [
         "https://pruebas.nataliacoronel.com",
-        "https://*.nataliacoronel.com",
     ]
 
 
 # ------------------ Resolución robusta del archivo GGUF ------------------
 def resolve_model_path(repo: str, models_dir: Path, primary_pattern: str) -> str:
     """
-    Descarga sólo los archivos que necesitamos probando varios patrones comunes de Qwen 3B.
+    Descarga sólo los archivos necesarios probando varios patrones comunes de Qwen 3B.
     Devuelve la ruta al GGUF elegido o lanza FileNotFoundError.
     """
-    # Patrones preferidos (ordenados por calidad/viabilidad en CPU gratuita)
-    patterns = []
+    patterns: List[str] = []
     if primary_pattern:
         patterns.append(primary_pattern)
 
@@ -94,10 +96,7 @@ def resolve_model_path(repo: str, models_dir: Path, primary_pattern: str) -> str
         "qwen2.5-3b-instruct-q3_k_m-*.gguf",
         "qwen2.5-3b-instruct-q3_k_m.gguf",
     ]
-    # Como último recurso (no deseable porque puede bajar más de un archivo):
-    # patterns.append("*.gguf")
 
-    # 1) Intento de descarga con allow_patterns = lista de patrones
     print(f"[Boot] Descargando {repo} con patrones: {patterns}")
     snapshot_dir = snapshot_download(
         repo_id=repo,
@@ -105,36 +104,28 @@ def resolve_model_path(repo: str, models_dir: Path, primary_pattern: str) -> str
         allow_patterns=patterns,
     )
 
-    # 2) Buscar candidatos en el snapshot por prioridad
     def glob_once(pat: str) -> List[str]:
         return sorted(glob.glob(str(Path(snapshot_dir) / pat)))
 
     all_candidates: List[str] = []
     for pat in patterns:
-        cs = glob_once(pat)
-        if cs:
-            all_candidates.extend(cs)
+        all_candidates += glob_once(pat)
 
-    # Filtro por 'instruct' y '3b' primero
     def score(path: str) -> tuple:
         p = Path(path).name.lower()
-        # prioridad por quant y por coincidencia "instruct" / "3b"
+        # prioridad por quant y coincidencia instruct
         quant_order = ["q4_k_m", "q4_0", "q3_k_m", "q5_k_m", "q3_0"]
         q_idx = next((i for i, q in enumerate(quant_order) if q in p), 99)
         instruct_bonus = 0 if "instruct" in p else 50
-        size_bonus = 0  # opcional: podrías usar tamaño
-        return (instruct_bonus, q_idx, size_bonus, p)
+        return (instruct_bonus, q_idx, p)
 
     all_candidates = sorted(set(all_candidates), key=score)
     if not all_candidates:
-        # Intenta listar qué hay para debug
         existing = sorted(glob.glob(str(Path(snapshot_dir) / "*.gguf")))
         raise FileNotFoundError(
             "No se encontró ningún GGUF en el repo con los patrones probados.\n"
-            f"Repo: {repo}\n"
-            f"Snapshot: {snapshot_dir}\n"
-            f"Intentados: {patterns}\n"
-            f"Encontrados (*.gguf): {[Path(x).name for x in existing]}"
+            f"Repo: {repo}\nSnapshot: {snapshot_dir}\n"
+            f"Intentados: {patterns}\nEncontrados (*.gguf): {[Path(x).name for x in existing]}"
         )
 
     chosen = all_candidates[0]
@@ -152,10 +143,13 @@ llm = Llama(
     n_ctx=N_CTX,
     n_threads=N_THREADS,
     n_batch=N_BATCH,
-    n_gpu_layers=env_int("N_GPU_LAYERS", 0),
+    n_gpu_layers=N_GPU_LAYERS,
     verbose=False,
 )
 
+# Bloqueo global para evitar concurrencia en CPU Basic
+LLM_LOCK = Lock()
+
 
 # ------------------ Utilidades ------------------
 def fetch_url_text(url: str, max_chars: int = 6000) -> str:
@@ -183,13 +177,14 @@ def run_llm(
     top_p: Optional[float] = None,
     max_tokens: Optional[int] = None,
 ) -> str:
-    out = llm.create_chat_completion(
-        messages=messages,
-        temperature=DEF_TEMPERATURE if temperature is None else float(temperature),
-        top_p=DEF_TOP_P if top_p is None else float(top_p),
-        max_tokens=clamp_tokens(max_tokens),
-        stream=False,
-    )
+    with LLM_LOCK:  # ← serializa la llamada al modelo
+        out = llm.create_chat_completion(
+            messages=messages,
+            temperature=DEF_TEMPERATURE if temperature is None else float(temperature),
+            top_p=DEF_TOP_P if top_p is None else float(top_p),
+            max_tokens=clamp_tokens(max_tokens),
+            stream=False,
+        )
     try:
         return out["choices"][0]["message"]["content"].strip()
     except Exception:
@@ -262,7 +257,7 @@ def root():
 def run_predict(body: PredictIn):
     messages = [
         {"role": "system", "content": body.system or SYSTEM_DEFAULT},
-        {"role": "user", "content": body.prompt},
+        {"role": "user",  "content": body.prompt},
     ]
     reply = run_llm(
         messages,
@@ -278,7 +273,7 @@ def run_predict_with_url(body: PredictURLIn):
     user_msg = body.prompt if not web_ctx else f"{body.prompt}\n\n[CONTEXTO_WEB]\n{web_ctx}"
     messages = [
         {"role": "system", "content": body.system or SYSTEM_DEFAULT},
-        {"role": "user", "content": user_msg},
+        {"role": "user",  "content": user_msg},
     ]
     reply = run_llm(
         messages,