Update modules/langchain_assistant/cvision_forge_v9.py

modules/langchain_assistant/cvision_forge_v9.py

@@ -22,59 +22,18 @@ SPACE_TRELLIS = "trellis-community/TRELLIS"
 
 # ═════════════════════════════════════════════════════════════════════
 # SECCIÓN 2: NÚCLEO LOGÍSTICO Y PROCESAMIENTO MULTIMODAL (TRELLIS BACKEND)
-# 💡 Motor de inferencia vía gradio_client con monkey-patch quirúrgico para
-#    corregir bug confirmado en gradio_client ≤ 2.5.0:
-#
-#    BUG: utils.construct_args() itera sobre parameters_info del servidor.
-#    Cuando el Space tiene gr.State(False) como input, el servidor serializa
-#    ese parámetro como el valor booleano False en la lista de parameters_info.
-#    La línea 1327 del client.py hace: "parameter_name" in False
-#    → TypeError: argument of type 'bool' is not iterable
-#
-#    FIX: patching construct_args para filtrar entradas no-dict antes de iterar.
-#    Esto es seguro: los parámetros gr.State son inyectados automáticamente por
-#    el servidor y no deben ser enviados por el cliente de todas formas.
+# 💡 Motor de inferencia ultra-robusto mediante HTTP Nativo y Server-Sent Events (SSE).
+#    BYPASS DE SEGURIDAD: Se elimina por completo la dependencia de gradio_client.
+#    Evita de forma definitiva los errores de tipo 'bool is not iterable' y
+#    los cuellos de botella síncronos en los hilos visuales de la interfaz.
 # ═════════════════════════════════════════════════════════════════════
-def _aplicar_patch_gradio_client():
-    """
-    Aplica el monkey-patch a gradio_client.utils.construct_args para corregir
-    el bug con gr.State(bool) que causa 'argument of type bool is not iterable'.
-    Idempotente: solo parchea si aún no fue aplicado.
-    """
-    try:
-        import gradio_client.utils as gc_utils
-        from enum import Enum
-        
-        # Guardia de idempotencia para evitar re-parcheos cíclicos en caliente
-        if getattr(gc_utils, '_cvision_patch_applied', False):
-            print("[CVision Patch] Memoria de control detectada: El parche ya está activo.")
-            return True
-            
-        _original_construct_args = gc_utils.construct_args
-        
-        def _construct_args_patched(parameters_info, args, kwargs):
-            """
-            Versión parcheada de construct_args que filtra entradas no-dict
-            en parameters_info antes de procesarlas de forma interna.
-            """
-            if parameters_info is not None:
-                # Sanitización en tiempo de ejecución de las matrices booleanas inyectadas
-                parameters_info = [
-                    p for p in parameters_info if isinstance(p, dict)
-                ]
-            return _original_construct_args(parameters_info, args, kwargs)
-            
-        gc_utils.construct_args = _construct_args_patched
-        gc_utils._cvision_patch_applied = True
-        print("[CVision Patch] ✅ construct_args parcheado correctamente en el núcleo Gradio.")
-        return True
-    except Exception as e:
-        print(f"[CVision Patch] ⚠️ No se pudo inyectar el parche en las librerías del sistema: {e}")
-        return False
-
-# Firma de parámetros verificada y mapeada con precisión milimétrica del endpoint /generate_and_extract_glb
+import os
+import time
+import json
+import requests
+
+# Firma de parámetros verificada con precisión milimétrica por ingeniería inversa
 PARAMS_INFERENCIA_TRELLIS = {
-    "multiimages":            [],            # Lista vacía obligatoria para activar el modo single-image
     "seed":                   0,             # Semilla determinista para consistencia estructural
     "ss_guidance_strength":   7.5,           # Fuerza de la guía para la estructura dispersa
     "ss_sampling_steps":      12,            # Pasos de muestreo en la etapa de dispersión
@@ -87,84 +46,126 @@ PARAMS_INFERENCIA_TRELLIS = {
 
 def ejecutar_forja_3d(imagen_generada_flux: str) -> str:
     """
-    Toma la imagen nacida del motor FLUX (o cualquier imagen 2D válida) y
-    utiliza el cliente oficial de Gradio para conectarse al clúster de
-    TRELLIS mediante WebSockets estables.
+    Toma una imagen 2D local, la convierte a un formato aceptado por el clúster,
+    y ejecuta un handshake HTTP puro contra la pasarela SSE de trellis-community.
     
-    EXPANSIÓN DE CONTROL: Se inyectan políticas de re-intento masivo y un 
-    parámetro de timeout extendido para neutralizar las caídas de lectura de ZeroGPU.
+    Bypass definitivo: Consume la sub-ruta real /gradio_api/call/ sin pasar
+    por los hilos visuales del frontend, eliminando bloqueos de pestañas.
     """
     if not imagen_generada_flux or not str(imagen_generada_flux).strip():
         print("[TRELLIS Error] No se suministró una ruta de imagen válida.")
         return "ERROR: No se detectó ninguna imagen válida para iniciar el esculpido 3D."
-        
-    # Validamos e inyectamos el parche de seguridad perimetral sobre el cliente
-    _aplicar_patch_gradio_client()
+
+    # Configuración de URLs dinámicas basadas en la pasarela real descubierta
+    base_space_url = "https://trellis-community-trellis.hf.space"
+    endpoint_inicializar = f"{base_space_url}/gradio_api/call/generate_and_extract_glb"
     
-    intentos_maximos = 3
-    retraso_entre_intentos = 5
+    cabeceras = {
+        "Content-Type": "application/json",
+        "Accept": "application/json"
+    }
+    if HF_TOKEN:
+        cabeceras["Authorization"] = f"Bearer {HF_TOKEN}"
+
+    print(f"[TRELLIS Engine] Estableciendo bypass de red directo hacia: {endpoint_inicializar}")
     
-    for intento_actual in range(1, intentos_maximos + 1):
-        try:
-            from gradio_client import Client, handle_file
-            
-            print(f"[TRELLIS Engine] Conectando con el clúster remoto: {SPACE_TRELLIS} (Intento {intento_actual}/{intentos_maximos})")
-            
-            # CONTROL DE TIMEOUT: Inicializamos el cliente forzando un canal tolerante a altas latencias
-            cliente = Client(
-                SPACE_TRELLIS,
-                hf_token=HF_TOKEN if HF_TOKEN else None,
-            )
+    try:
+        # Paso 1: Intentar subir el archivo local a la caché temporal de Hugging Face
+        print(f"[TRELLIS Engine] Preparando carga del asset binario local: {imagen_generada_flux}")
+        endpoint_upload = f"{base_space_url}/upload"
+        
+        with open(imagen_generada_flux, "rb") as f_archivo:
+            ficheros = {"files": (os.path.basename(imagen_generada_flux), f_archivo, "image/png")}
+            cabeceras_upload = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
+            res_upload = requests.post(endpoint_upload, headers=cabeceras_upload, files=ficheros, timeout=60)
             
-            print(f"[TRELLIS Engine] Despachando asset a la GPU remota... Origen: {imagen_generada_flux}")
+        if res_upload.status_code != 200:
+            raise ConnectionError(f"Falla al depositar imagen en el servidor remoto. Código HTTP: {res_upload.status_code}")
             
-            # Ejecución asíncrona enviando los parámetros empaquetados
-            # Nota: Si tu entorno soporta configuración de timeout por llamada, la encapsulamos internamente
-            resultado = cliente.predict(
-                image=handle_file(imagen_generada_flux),
-                **PARAMS_INFERENCIA_TRELLIS,
-                api_name="/generate_and_extract_glb",
-            )
+        url_remota_temporal = res_upload.json()[0]
+        print(f"[TRELLIS Engine] Asset cargado con éxito en el búfer remoto: {url_remota_temporal}")
+
+        # Paso 2: Estructurar el Payload idéntico al capturado en el radar del navegador
+        # Mapeamos la lista de argumentos exactos que espera recibir la firma del backend de TRELLIS
+        lista_datos = [
+            {"path": url_remota_temporal},             # Imagen pre-cargada en la caché
+            PARAMS_INFERENCIA_TRELLIS["seed"],
+            PARAMS_INFERENCIA_TRELLIS["ss_guidance_strength"],
+            PARAMS_INFERENCIA_TRELLIS["ss_sampling_steps"],
+            PARAMS_INFERENCIA_TRELLIS["slat_guidance_strength"],
+            PARAMS_INFERENCIA_TRELLIS["slat_sampling_steps"],
+            PARAMS_INFERENCIA_TRELLIS["multiimage_algo"],
+            PARAMS_INFERENCIA_TRELLIS["mesh_simplify"],
+            PARAMS_INFERENCIA_TRELLIS["texture_size"]
+        ]
+        
+        payload = {"data": lista_datos}
+
+        # Paso 3: Lanzar Handshake Inicial para obtener el Event ID del stream SSE
+        respuesta_inicial = requests.post(endpoint_inicializar, headers=cabeceras, json=payload, timeout=45)
+        
+        if respuesta_inicial.status_code != 200:
+            raise ConnectionError(f"La pasarela denegó el acceso estructural. HTTP: {respuesta_inicial.status_code}")
             
-            print(f"[TRELLIS Engine] Respuesta en crudo capturada con éxito en el intento {intento_actual}.")
+        datos_handshake = respuesta_inicial.json()
+        event_id = datos_handshake.get("event_id")
+        
+        if not event_id:
+            raise ValueError(f"El clúster no asignó un identificador de flujo. Respuesta: {datos_handshake}")
             
-            # ── NORMALIZACIÓN Y PARSEO DEL RETORNO EXTENSO ──────────────────────────────
-            ruta_glb = None
-            if isinstance(resultado, (list, tuple)):
-                print(f"[TRELLIS Engine] Analizando colección indexada de salida (Nodos detectados: {len(resultado)})")
-                for idx in [2, 1, 3, 0]:
-                    if idx < len(resultado):
-                        nodo = resultado[idx]
-                        if isinstance(nodo, str) and nodo.endswith(".glb"):
-                            ruta_glb = nodo
-                            break
-                        if isinstance(nodo, dict) and str(nodo.get("name", "")).endswith(".glb"):
-                            ruta_glb = nodo["name"]
-                            break
-                            
-            if not ruta_glb and isinstance(resultado, str) and resultado.endswith(".glb"):
-                ruta_glb = resultado
-                
-            if ruta_glb:
-                print(f"[TRELLIS Engine] ¡Malla .glb consolidada con éxito!: {ruta_glb}")
-                return ruta_glb
+        print(f"[TRELLIS Engine] Handshake Exitoso. Event ID de Canal Asignado: {event_id}")
+
+        # Paso 4: Escuchar el Stream en vivo (SSE) para capturar el momento exacto en que termina la forja
+        endpoint_stream = f"{endpoint_inicializar}/{event_id}"
+        print(f"[TRELLIS Engine] Abriendo escucha del búfer de eventos en sub-ruta: {endpoint_stream}")
+        
+        # Conectamos con stream=True para procesar los paquetes en caliente sin agotar la RAM
+        respuesta_stream = requests.get(endpoint_stream, headers=cabeceras, stream=True, timeout=300)
+        
+        ruta_glb_final = None
+        
+        for linea in respuesta_stream.iter_lines():
+            if not linea:
+                continue
                 
-            raise ValueError(f"Formato binario no reconocido en el retorno del clúster.")
-            
-        except Exception as error:
-            error_str = str(error)
-            print(f"[TRELLIS Error] Incidencia en intento {intento_actual}: {error_str}")
+            linea_decodificada = linea.decode("utf-8").strip()
             
-            # Si el error es de tipo Timeout o lectura de socket, esperamos antes de re-intentar el pipeline
-            if "timed out" in error_str.lower() or "read operation" in error_str.lower():
-                if intento_actual < intentos_maximos:
-                    print(f"[TRELLIS Engine] Re-estabilizando canales de red. Esperando {retraso_entre_intentos}s...")
-                    time.sleep(retraso_entre_intentos)
+            # Buscamos las líneas de datos transmitidas por el protocolo SSE
+            if linea_decodificada.startswith("data:"):
+                contenido_json_raw = linea_decodificada[5:].strip()
+                
+                try:
+                    bloque_datos = json.loads(contenido_json_raw)
+                    
+                    # Gradio transmite eventos intermedios (ej. 'process_generating'). Los ignoramos hasta ver el final.
+                    if isinstance(bloque_datos, list) and len(bloque_datos) > 0:
+                        # Buscamos en la colección de salida el nodo que contenga el archivo estructurado .glb
+                        for nodo in bloque_datos:
+                            if isinstance(nodo, dict) and "name" in nodo and str(nodo["name"]).endswith(".glb"):
+                                ruta_glb_final = nodo["name"]
+                                break
+                            if isinstance(nodo, str) and nodo.endswith(".glb"):
+                                ruta_glb_final = nodo
+                                break
+                        if ruta_glb_final:
+                            break
+                except json.JSONDecodeError:
+                    # Líneas de control o texto plano del stream. Se ignoran con seguridad.
                     continue
+
+        if ruta_glb_final:
+            # Si el retorno es un path relativo del servidor, construimos la descarga estática absoluta
+            if not ruta_glb_final.startswith("http"):
+                ruta_glb_final = f"{base_space_url}/file={ruta_glb_final}"
+                
+            print(f"[TRELLIS Engine] ¡Malla .glb localizada en el clúster exitosamente!: {ruta_glb_final}")
+            return ruta_glb_final
             
-            return f"ERROR_PIPELINE: {error_str}"
-            
-    return "ERROR_PIPELINE: Excedidos todos los intentos de control de lectura por alta latencia."
+        raise TimeoutError("El flujo SSE de Hugging Face se cerró sin transmitir la geometría final.")
+
+    except Exception as error:
+        print(f"[TRELLIS Error] Falla crítica en bypass de red por HTTP: {error}")
+        return f"ERROR_PIPELINE: {str(error)}"
 
 
 # ═════════════════════════════════════════════════════════════════════