Upload teste_app.py

teste_app.py

@@ -0,0 +1,245 @@
+# -*- coding: utf-8 -*-
+import os
+import json
+import base64
+import tempfile
+from concurrent.futures import ThreadPoolExecutor
+
+import gradio as gr
+from openai import OpenAI
+from playwright.sync_api import sync_playwright
+
+GROQ_KEY = os.environ.get("GROQ_KEY", "")
+
+# Modelo de vision de Groq (si cambia el nombre, ajustalo aqui).
+VISION_MODEL = "meta-llama/llama-4-scout-17b-16e-instruct"
+# Respaldo solo-texto si la vision falla.
+TEXT_MODEL = "llama-3.3-70b-versatile"
+
+_groq = OpenAI(api_key=GROQ_KEY, base_url="https://api.groq.com/openai/v1") if GROQ_KEY else None
+
+# Playwright (API sync) debe correr en un hilo SIN loop asyncio. Usamos un
+# executor propio para garantizarlo.
+_executor = ThreadPoolExecutor(max_workers=1)
+
+
+def _interactuar(pagina):
+    """Best-effort: rellena inputs/selects visibles y pulsa un boton de accion
+    real, para que el Tester vea la app DESPUES de usarla, no solo al cargar.
+    Devuelve el texto del primer error de Gradio detectado en el DOM tras el
+    clic, o "" si no se detecto ninguno."""
+    try:
+        inputs = pagina.locator("input[type=text], input[type=number], input:not([type]), textarea").all()
+        for inp in inputs[:6]:
+            try:
+                if not inp.is_visible():
+                    continue
+                tipo = inp.get_attribute("type") or "text"
+                inp.fill("5" if tipo == "number" else "prueba")
+            except Exception:
+                continue
+    except Exception:
+        pass
+    try:
+        selects = pagina.locator("select").all()
+        for sel in selects[:4]:
+            try:
+                if not sel.is_visible():
+                    continue
+                opciones = sel.locator("option").all()
+                if len(opciones) > 1:
+                    valor = opciones[1].get_attribute("value")
+                    if valor is not None:
+                        sel.select_option(valor)
+            except Exception:
+                continue
+    except Exception:
+        pass
+
+    error_detectado = ""
+    try:
+        for btn in pagina.locator("button").all():
+            try:
+                if not btn.is_visible():
+                    continue
+                texto_btn = (btn.inner_text() or "").strip().lower()
+                if any(p in texto_btn for p in ["clear", "limpiar", "borrar", "flag"]):
+                    continue
+                btn.click(timeout=3000)
+                pagina.wait_for_timeout(3000)
+                try:
+                    pagina.wait_for_load_state("networkidle", timeout=8000)
+                except Exception:
+                    pass
+                error_detectado = _detectar_error_gradio(pagina)
+                break
+            except Exception:
+                continue
+    except Exception:
+        pass
+    return error_detectado
+
+
+def _detectar_error_gradio(pagina):
+    """Busca en el DOM senales explicitas de error que Gradio muestra tras
+    fallar un event handler: el toast rojo de error, o un componente Label
+    cuyo contenido literal es 'Error' / 'error'. No depende del LLM."""
+    try:
+        # Toast de error de Gradio (aparece en la esquina al fallar un evento).
+        toasts = pagina.locator(".toast-body.error, [class*='toast'][class*='error']").all()
+        for t in toasts:
+            try:
+                if t.is_visible():
+                    txt = (t.inner_text() or "").strip()
+                    return txt or "Gradio mostro un toast de error tras la accion."
+            except Exception:
+                continue
+    except Exception:
+        pass
+    try:
+        # Componente Label/salida cuyo unico contenido es literalmente "Error".
+        candidatos = pagina.locator("text=/^Error$/i").all()
+        for c in candidatos:
+            try:
+                if c.is_visible():
+                    return "Un componente de salida muestra literalmente 'Error' tras la accion."
+            except Exception:
+                continue
+    except Exception:
+        pass
+    return ""
+
+
+def _abrir_y_capturar(url):
+    """Abre la URL, interactua con la app (rellena+clic), y devuelve
+    (texto_visible, ruta_captura, error_dom) DESPUES de esa interaccion.
+    error_dom es "" si no se detecto ningun error explicito de Gradio, o el
+    texto del error si si se detecto."""
+    with sync_playwright() as p:
+        navegador = p.chromium.launch(args=["--no-sandbox", "--disable-dev-shm-usage"])
+        pagina = navegador.new_page(viewport={"width": 1280, "height": 1600})
+        pagina.goto(url, wait_until="domcontentloaded", timeout=45000)
+        try:
+            pagina.wait_for_selector(".gradio-container, gradio-app, #root", timeout=15000)
+        except Exception:
+            pass
+        pagina.wait_for_timeout(2500)
+        error_dom = _interactuar(pagina)
+        pagina.wait_for_timeout(1000)
+        texto = pagina.inner_text("body")[:6000]
+        ruta = os.path.join(tempfile.gettempdir(), "captura.png")
+        pagina.screenshot(path=ruta, full_page=True)
+        navegador.close()
+    return texto, ruta, error_dom
+
+
+def _abrir_seguro(url):
+    return _executor.submit(_abrir_y_capturar, url).result()
+
+
+def _img_b64(ruta):
+    with open(ruta, "rb") as f:
+        return base64.b64encode(f.read()).decode("utf-8")
+
+
+SYSTEM = (
+    "Eres un tester de control de calidad de webs y apps, estricto y desconfiado. "
+    "Te dan el OBJETIVO de una pagina, el texto visible y una captura tomada "
+    "DESPUES de rellenar campos y pulsar un boton de accion real (no es la "
+    "primera carga). Marca ok=false si: la pagina esta en blanco; el texto o "
+    "la captura muestran la palabra 'Error', un traceback, un mensaje en rojo, "
+    "o un recuadro/toast de error; falta alguna seccion pedida en el objetivo; "
+    "o la accion principal (el boton) no parece haber producido ningun "
+    "resultado visible. Ante la duda entre 'parece que funciona' y 'no estoy "
+    "seguro', responde ok=false: es preferible un falso negativo a aprobar "
+    "una app rota. "
+    'Responde SOLO JSON: {"ok": true/false, "problemas": ["..."], "resumen": "..."}'
+)
+
+
+def _juzgar(objetivo, texto, ruta_img):
+    if _groq is None:
+        return '{"ok": false, "problemas": ["Falta GROQ_KEY en los secrets"], "resumen": "Sin clave"}'
+    base = f"OBJETIVO:\n{objetivo}\n\nTEXTO VISIBLE EN LA PAGINA:\n{texto}"
+    # 1) Intento con vision (incluye la captura)
+    try:
+        b64 = _img_b64(ruta_img)
+        resp = _groq.chat.completions.create(
+            model=VISION_MODEL,
+            messages=[
+                {"role": "system", "content": SYSTEM},
+                {"role": "user", "content": [
+                    {"type": "text", "text": base},
+                    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}},
+                ]},
+            ],
+            temperature=0,
+        )
+        return resp.choices[0].message.content
+    except Exception:
+        pass
+    # 2) Respaldo solo-texto
+    try:
+        resp = _groq.chat.completions.create(
+            model=TEXT_MODEL,
+            messages=[
+                {"role": "system", "content": SYSTEM},
+                {"role": "user", "content": base},
+            ],
+            temperature=0,
+        )
+        return resp.choices[0].message.content
+    except Exception as e:
+        return '{"ok": false, "problemas": ["Error del modelo: ' + str(e)[:120] + '"], "resumen": "Fallo al juzgar"}'
+
+
+def probar(url, objetivo):
+    url = (url or "").strip()
+    if not url:
+        return "Pon una URL.", None
+    if not url.startswith("http"):
+        url = "https://" + url
+    try:
+        texto, ruta, error_dom = _abrir_seguro(url)
+    except Exception as e:
+        return f"No se pudo abrir la pagina: {e}", None
+
+    # Veto programatico: si el DOM muestra un error explicito de Gradio tras
+    # la interaccion, NO PASA sin importar lo que opine el LLM de vision.
+    if error_dom:
+        salida = (
+            f"### NO PASA\n\n"
+            f"La pagina mostro un error real al usarla (no solo al cargar).\n\n"
+            f"- {error_dom}"
+        )
+        return salida, ruta
+
+    veredicto = _juzgar(objetivo or "La pagina debe cargar sin errores y verse completa.", texto, ruta)
+    try:
+        limpio = veredicto.replace("```json", "").replace("```", "").strip()
+        d = json.loads(limpio)
+        estado = "PASA" if d.get("ok") else "NO PASA"
+        problemas = "\n".join(f"- {x}" for x in d.get("problemas", []))
+        salida = f"### {estado}\n\n{d.get('resumen','')}\n\n{problemas}".strip()
+    except Exception:
+        # No se pudo interpretar el veredicto del LLM como JSON valido.
+        # Por seguridad, NO se asume PASA: se marca como fallo explicito.
+        salida = (
+            f"### NO PASA\n\n"
+            f"El Tester no pudo interpretar su propio veredicto como JSON valido "
+            f"(respuesta cruda no concluyente).\n\n"
+            f"- Respuesta del modelo: {str(veredicto)[:300]}"
+        )
+    return salida, ruta
+
+
+with gr.Blocks(title="Forja Tester") as demo:
+    gr.Markdown("# Forja Tester\nAbre una app en un navegador real, la mira y dice si funciona.")
+    url_in = gr.Textbox(label="URL de la app a probar")
+    obj_in = gr.Textbox(label="Que deberia hacer / contener", lines=3)
+    btn = gr.Button("Probar", variant="primary")
+    out = gr.Markdown()
+    img = gr.Image(label="Lo que vio el navegador")
+    btn.click(probar, [url_in, obj_in], [out, img], api_name="probar")
+
+demo.launch(server_name="0.0.0.0", server_port=7860)