Update modules/langchain_assistant/cvision_forge_v9.py

modules/langchain_assistant/cvision_forge_v9.py

@@ -13,68 +13,143 @@ import gradio as gr
 # EXTRACCIÓN SEGURA: Se elimina el token explícito para evitar bloqueos en el commit.
 # El token real debe ser configurado en la pestaña "Settings -> Variables and Secrets" de tu Space.
 HF_TOKEN = os.environ.get("HF_TOKEN", "")
-SPACE_PROVEEDOR = "JeffreyXiang/TRELLIS"
-URL_TRELLIS_BASE = "https://trellis-community-trellis.hf.space/gradio_api"
+
+# ─── TABLA DE ESPACIOS CANDIDATOS (ordenados por prioridad de disponibilidad) ────
+# Primario  → microsoft/TRELLIS.2   : Space oficial Microsoft, activo y con endpoint /image_to_3d estable.
+# Secundario→ trellis-community/TRELLIS : Fork comunitario mantenido, también activo.
+# Terciario → theseanlavery/TRELLIS-3D : Fork independiente de respaldo adicional.
+# NOTA: Si el primario devuelve CONFIG_ERROR o cae por carga, el orquestador rota automáticamente.
+ESPACIOS_TRELLIS = [
+    "microsoft/TRELLIS.2",
+    "trellis-community/TRELLIS",
+    "theseanlavery/TRELLIS-3D",
+]
 
 # ═════════════════════════════════════════════════════════════════════
 # SECCIÓN 2: NÚCLEO LOGÍSTICO Y PROCESAMIENTO MULTIMODAL (TRELLIS BACKEND)
 # 💡 Implementa el motor de inferencia oficial mediante hilos WebSockets.
+#    Usa firma de parámetros completa compatible con TRELLIS v1 y TRELLIS.2.
+#    Rota automáticamente entre Spaces si el primario está caído.
 # ═════════════════════════════════════════════════════════════════════
-def ejecutar_forja_3d(imagen_generada_flux: str):
+
+# ─── FIRMA DE PARÁMETROS COMPLETA (compatible con JeffreyXiang/TRELLIS y forks) ─
+# Confirmada mediante análisis del app.py oficial y discusiones de la comunidad HF.
+# Parámetros mínimos requeridos para el endpoint /image_to_3d en todos los forks activos:
+#   image                 → archivo de entrada (handle_file)
+#   multiimages           → lista vacía [] para modo single-image
+#   seed                  → semilla de generación (0 = determinista)
+#   ss_guidance_strength  → guía de escala estructural (recomendado: 7.5)
+#   ss_sampling_steps     → pasos de muestreo estructural (recomendado: 12)
+#   slat_guidance_strength→ guía de latente SLAT (recomendado: 3.0)
+#   slat_sampling_steps   → pasos de muestreo SLAT (recomendado: 12)
+#   multiimage_algo       → algoritmo multi-imagen (valor: "stochastic")
+PARAMS_INFERENCIA = {
+    "multiimages": [],
+    "seed": 0,
+    "ss_guidance_strength": 7.5,
+    "ss_sampling_steps": 12,
+    "slat_guidance_strength": 3.0,
+    "slat_sampling_steps": 12,
+    "multiimage_algo": "stochastic",
+}
+
+
+def _intentar_cliente_gradio(espacio: str, ruta_imagen: str) -> str | None:
+    """
+    Intenta conectar a un Space específico de TRELLIS usando el cliente oficial
+    de Gradio vía WebSockets. Retorna la ruta local del .glb si tiene éxito,
+    o None si falla (para que el orquestador pruebe el siguiente candidato).
+    """
+    try:
+        from gradio_client import Client, handle_file
+
+        print(f"[TRELLIS Engine] Conectando con el clúster: {espacio}")
+        cliente = Client(espacio, hf_token=HF_TOKEN if HF_TOKEN else None)
+
+        print(f"[TRELLIS Engine] Despachando asset a la GPU remota... Origen: {ruta_imagen}")
+        resultado = cliente.predict(
+            image=handle_file(ruta_imagen),
+            **PARAMS_INFERENCIA,
+            api_name="/image_to_3d",
+        )
+
+        # ── Normalización del resultado ──────────────────────────────────────────
+        # El cliente puede retornar: str con path local, dict con 'name', o lista
+        ruta_glb = None
+
+        if isinstance(resultado, str) and resultado.endswith(".glb"):
+            ruta_glb = resultado
+
+        elif isinstance(resultado, dict) and "name" in resultado:
+            ruta_glb = resultado["name"]
+
+        elif isinstance(resultado, list) and len(resultado) > 0:
+            primer_nodo = resultado[0]
+            if isinstance(primer_nodo, str) and primer_nodo.endswith(".glb"):
+                ruta_glb = primer_nodo
+            elif isinstance(primer_nodo, dict) and "name" in primer_nodo:
+                ruta_glb = primer_nodo["name"]
+            # Algunos forks devuelven una tupla (video_path, glb_path)
+            elif isinstance(resultado, (list, tuple)) and len(resultado) >= 2:
+                for nodo in resultado:
+                    if isinstance(nodo, str) and nodo.endswith(".glb"):
+                        ruta_glb = nodo
+                        break
+                    if isinstance(nodo, dict) and nodo.get("name", "").endswith(".glb"):
+                        ruta_glb = nodo["name"]
+                        break
+
+        if ruta_glb:
+            print(f"[TRELLIS Engine] ¡Malla .glb consolidada con éxito en {espacio}!: {ruta_glb}")
+            return ruta_glb
+
+        raise ValueError(f"Formato binario no reconocido devuelto por {espacio}: {type(resultado)} → {str(resultado)[:200]}")
+
+    except Exception as error:
+        # Distinguir errores estructurales (CONFIG_ERROR, SPACE_ERROR) de errores de red
+        mensaje_error = str(error).lower()
+        if any(kw in mensaje_error for kw in ["config_error", "invalid state", "space_error", "runtime error"]):
+            print(f"[TRELLIS Warn] Space '{espacio}' está caído o en estado inválido: {error}")
+        else:
+            print(f"[TRELLIS Warn] Falla de pipeline en '{espacio}': {error}")
+        return None
+
+
+def ejecutar_forja_3d(imagen_generada_flux: str) -> str:
     """
-    Toma la imagen nacida del motor FLUX y utiliza el cliente oficial de Gradio
-    para conectarse al clúster de TRELLIS mediante WebSockets estables.
+    Orquestador principal de inferencia 3D. Toma la imagen nacida del motor FLUX
+    (o cualquier imagen 2D válida) y utiliza el cliente oficial de Gradio para
+    conectarse a los clústeres de TRELLIS mediante WebSockets estables.
+
+    Implementa rotación automática de Spaces: si el primario falla por
+    CONFIG_ERROR u otro error estructural, prueba los candidatos secundarios
+    en orden de prioridad, garantizando máxima resiliencia del pipeline.
+
     Evita simular clics en el frontend para evadir el colapso por 'hidden tab'.
+    La firma de parámetros es la completa y validada por la comunidad HF,
+    distinta a la versión reducida de ejemplos básicos que causaba errores.
     """
-    if not HF_TOKEN:
-        print("[TRELLIS Error] No se detectó el 'HF_TOKEN' en las variables de entorno.")
-        return "ERROR: Variable de entorno 'HF_TOKEN' faltante. Configúrala en los Secrets de tu Space."
-        
     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 de FLUX para iniciar el esculpido 3D."
 
-    try:
-        from gradio_client import Client, handle_file
-        
-        print(f"[TRELLIS Engine] Conectando de forma segura con el clúster: {SPACE_PROVEEDOR}")
-        # Inicialización del cliente encapsulado con paso de credenciales seguro
-        client = Client(SPACE_PROVEEDOR, hf_token=HF_TOKEN)
-        
-        print(f"[TRELLIS Engine] Despachando asset estructural a la GPU remota... Origen: {imagen_generada_flux}")
-        
-        # Consumo del endpoint puro de inferencia remota
-        resultado = client.predict(
-            image=handle_file(imagen_generada_flux),
-            inst_num_steps=12,      # Muestreo estructural primario
-            inst_cfg=7.5,           # Guía de escala sintética
-            preprocess_image=True,  # Limpieza automática de la matriz 2D
-            api_name="/image_to_3d"  # Endpoint directo expuesto en el backend de TRELLIS
-        )
-        
-        # El cliente descarga automáticamente el .glb en la caché local del sistema
-        if resultado and isinstance(resultado, str) and resultado.endswith(".glb"):
-            print(f"[TRELLIS Engine] ¡Malla .glb consolidada con éxito!: {resultado}")
+    # ── Rotación de Spaces candidatos ───────────────────────────────────────────
+    for espacio in ESPACIOS_TRELLIS:
+        resultado = _intentar_cliente_gradio(espacio, imagen_generada_flux)
+        if resultado:
             return resultado
-            
-        # Control de flujos secundarios si la estructura devuelve diccionarios mutados
-        if isinstance(resultado, dict) and "name" in resultado:
-            print(f"[TRELLIS Engine] Malla extraída desde nodo de diccionario: {resultado['name']}")
-            return resultado["name"]
-            
-        # Desglose recursivo si la respuesta viene envuelta en colecciones
-        if isinstance(resultado, list) and len(resultado) > 0:
-            primer_nodo = resultado[0]
-            if isinstance(primer_nodo, str) and primer_nodo.endswith(".glb"):
-                return primer_nodo
-            if isinstance(primer_nodo, dict) and "name" in primer_nodo:
-                return primer_nodo["name"]
+        print(f"[TRELLIS Engine] Rotando al siguiente Space candidato...")
+        time.sleep(1.5)  # Pausa mínima entre intentos para evitar rate-limiting
+
+    # Si todos los Spaces fallaron, retornar mensaje de error estructurado
+    mensaje_final = (
+        "ERROR_PIPELINE: Todos los clústeres de TRELLIS están temporalmente no disponibles. "
+        "Spaces intentados: " + ", ".join(ESPACIOS_TRELLIS) + ". "
+        "Verifica el estado de los Spaces en https://status.huggingface.co o intenta más tarde."
+    )
+    print(f"[TRELLIS Error] {mensaje_final}")
+    return mensaje_final
 
-        raise Exception(f"El clúster remoto retornó un formato binario no reconocido: {str(resultado)}")
-        
-    except Exception as e:
-        print(f"[TRELLIS Error] Falla en pipeline con Cliente Oficial: {e}")
-        return f"ERROR_PIPELINE: {str(e)}"
 
 # ═════════════════════════════════════════════════════════════════════
 # SECCIÓN 3: COMPONENTE VISUAL Y RENDERIZADO INTERACTIVO (FRONTEND)
@@ -84,86 +159,93 @@ def obtener_html_visor(glb_url: str = None) -> str:
     """
     Construye de forma dinámica la interfaz del viewport interactivo
     utilizando Three.js para la manipulación libre de mallas.
+    Se usa como visor de respaldo cuando gr.Model3D no puede renderizar
+    una URL remota directamente (ej. assets servidos desde HF caché).
     """
     if not glb_url or "ERROR" in str(glb_url) or "TIMEOUT" in str(glb_url):
         error_msg = glb_url if glb_url else "Esperando especificaciones en el panel de control..."
         return f"""
-        <div style="width:100%; height:500px; background:#02060f; display:flex; flex-direction:column; justify-content:center; align-items:center; border:1px solid rgba(0,212,255,0.15); border-radius:8px; font-family:monospace; color:#00d4ff;">
-            <h3 style="margin:0; letter-spacing: 2px; text-shadow: 0 0 10px rgba(0,212,255,0.5);">⚔️ CVISION FORGE LAB v9.0 ⚔️</h3>
+        <div style="width:100%; height:500px; background:#02060f; display:flex; flex-direction:column;
+                    justify-content:center; align-items:center; border:1px solid rgba(0,212,255,0.15);
+                    border-radius:8px; font-family:monospace; color:#00d4ff;">
+            <h3 style="margin:0; letter-spacing:2px; text-shadow:0 0 10px rgba(0,212,255,0.5);">
+                ⚔️ CVISION FORGE LAB v9.0 ⚔️
+            </h3>
             <p style="color:rgba(255,255,255,0.5); font-size:12px; margin-top:10px;">{error_msg}</p>
         </div>
         """
-        
+
     return f"""
-    <div id="canvas-3d-container" style="width:100%; height:500px; background:#02060f; border:1px solid #00d4ff; border-radius:8px; position:relative;">
+    <div id="canvas-3d-container" style="width:100%; height:500px; background:#02060f;
+         border:1px solid #00d4ff; border-radius:8px; position:relative; overflow:hidden;">
         <script type="module">
             import * as THREE from 'https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.module.js';
             import {{ GLTFLoader }} from 'https://cdn.jsdelivr.net/npm/three@0.128.0/examples/jsm/loaders/GLTFLoader.js';
             import {{ OrbitControls }} from 'https://cdn.jsdelivr.net/npm/three@0.128.0/examples/jsm/controls/OrbitControls.js';
-            
+
             const container = document.getElementById('canvas-3d-container');
             const scene = new THREE.Scene();
             scene.background = new THREE.Color(0x02060f);
-                        
+
             const camera = new THREE.PerspectiveCamera(45, container.clientWidth / container.clientHeight, 0.1, 100);
             camera.position.set(0, 1.2, 3);
-            
+
             const renderer = new THREE.WebGLRenderer({{ antialias: true, alpha: false }});
             renderer.setSize(container.clientWidth, container.clientHeight);
             renderer.setPixelRatio(window.devicePixelRatio);
             renderer.shadowMap.enabled = true;
             container.appendChild(renderer.domElement);
-            
+
             const controls = new OrbitControls(camera, renderer.domElement);
             controls.enableDamping = true;
             controls.dampingFactor = 0.05;
-            
+
             const ambientLight = new THREE.AmbientLight(0xffffff, 0.8);
             scene.add(ambientLight);
-            
+
             const dirLight1 = new THREE.DirectionalLight(0x00d4ff, 1.0);
             dirLight1.position.set(5, 5, 5);
             scene.add(dirLight1);
-            
+
             const dirLight2 = new THREE.DirectionalLight(0xff00ff, 0.5);
             dirLight2.position.set(-5, 3, -5);
             scene.add(dirLight2);
-            
+
             const loader = new GLTFLoader();
-            const modelUrl = "{glb_url}"; 
-            
+            const modelUrl = "{glb_url}";
+
             console.log("[CVision Visor] Intentando cargar geometría desde:", modelUrl);
-            
+
             loader.load(modelUrl, (gltf) => {{
                 const model = gltf.scene;
-                
+
                 // Centrado automático del modelo dentro del visor global
                 const box = new THREE.Box3().setFromObject(model);
                 const center = box.getCenter(new THREE.Vector3());
                 const size = box.getSize(new THREE.Vector3());
-                
+
                 model.position.sub(center);
                 scene.add(model);
-                
+
                 // Ajuste dinámico de cámara según el volumen del objeto forjado
                 const maxDim = Math.max(size.x, size.y, size.z);
                 camera.position.z = maxDim * 1.8;
                 camera.lookAt(0, 0, 0);
-                
+
                 console.log("[CVision Forge Visor] Asset tridimensional acoplado y centrado.");
             }}, (xhr) => {{
                 console.log("[CVision Visor] Progreso de carga mallas: " + (xhr.loaded / xhr.total * 100) + "%");
             }}, (error) => {{
                 console.error("[CVision Forge Error] Error crítico al decodificar la estructura:", error);
             }});
-            
+
             function animate() {{
                 requestAnimationFrame(animate);
                 controls.update();
                 renderer.render(scene, camera);
             }}
             animate();
-            
+
             window.addEventListener('resize', () => {{
                 camera.aspect = container.clientWidth / container.clientHeight;
                 camera.updateProjectionMatrix();
@@ -173,124 +255,158 @@ def obtener_html_visor(glb_url: str = None) -> str:
     </div>
     """
 
+
 # ═════════════════════════════════════════════════════════════════════
 # SECCIÓN 4: ORQUESTADOR INTERNO Y ENLACE INTER-MÓDULO
 # 💡 Gestiona los flujos cruzados que consumen respuestas asíncronas en HTML.
 # ═════════════════════════════════════════════════════════════════════
-def procesar_flujo_completo(prompt):
+def procesar_flujo_completo(prompt: str) -> str:
     """
     Middleware encargado de coordinar flujos que requieran el visor embebido
     de Three.js en lugar de los componentes declarativos estándar.
+    Útil cuando el asset resultante es una URL remota de HF y no un path local.
     """
     print("[CVision Middleware] Solicitando pipeline completo para visor web...")
     ruta_glb = ejecutar_forja_3d(prompt)
     html_visor = obtener_html_visor(ruta_glb)
     return html_visor
 
+
 # ═════════════════════════════════════════════════════════════════════
 # SECCIÓN 5: INTERFAZ DECLARATIVA E INYECCIÓN DE GRADIO
 # 💡 Manejo de flujo local, bypass de flujos binarios y montaje estructural de UI.
 # ═════════════════════════════════════════════════════════════════════
-def puente_forja_y_descarga(ruta_imagen_2d):
+def puente_forja_y_descarga(ruta_imagen_2d: str) -> str | None:
     """
     Monitorea la ejecución del pipeline, extrae la malla de la caché temporal
-    y estabiliza su persistencia en el espacio local para su lectura segura.
+    y estabiliza su persistencia en el espacio local para su lectura segura
+    por parte del componente gr.Model3D de Gradio.
+
+    Maneja tres canales de retorno posibles del cliente Gradio:
+      1. Path local  → el cliente descargó el .glb en disco directamente.
+      2. URL remota  → el clúster devolvió un enlace HTTPS; se descarga aquí.
+      3. ERROR/None  → se propaga None para mostrar estado vacío en el visor.
     """
     if not ruta_imagen_2d:
         print("[CVision Error] Entrada vacía. No se suministró una matriz 2D válida.")
         return None
-        
+
     try:
         print("[CVision Forge] Lanzando pipeline de pooling asíncrono en cliente...")
         resultado_pooling = ejecutar_forja_3d(ruta_imagen_2d)
-                
-        if not resultado_pooling or "ERROR" in str(resultado_pooling) or "TIMEOUT" in str(resultado_pooling):
+
+        if not resultado_pooling or "ERROR" in str(resultado_pooling):
             print(f"[CVision Error] Interrupción detectada en el canal: {resultado_pooling}")
             return None
-                    
-        # Si el cliente oficial descargó el archivo de forma nativa en el disco local
+
+        # ── Canal 1: El cliente oficial descargó el archivo de forma nativa en disco ──
         if isinstance(resultado_pooling, str) and os.path.exists(resultado_pooling):
             print(f"[CVision Forge] Copiando asset desde la caché del cliente: {resultado_pooling}")
             ruta_estabilizada_glb = os.path.abspath("cvision_forge_output.glb")
-            
+
             # Transferencia segura del flujo de bytes local para consolidar persistencia
             with open(resultado_pooling, "rb") as f_origen:
                 datos_binarios = f_origen.read()
             with open(ruta_estabilizada_glb, "wb") as f_destino:
                 f_destino.write(datos_binarios)
-                
-            print(f"[CVision Forge] Malla consolidada localmente de forma exitosa: {ruta_estabilizada_glb}")
+
+            print(f"[CVision Forge] Malla consolidada localmente con éxito: {ruta_estabilizada_glb}")
             return ruta_estabilizada_glb
-            
-        # Canal de contingencia si el retorno muta a una URL remota de Hugging Face
+
+        # ── Canal 2: El clúster retornó una URL remota de Hugging Face ──────────────
         if isinstance(resultado_pooling, str) and resultado_pooling.startswith("http"):
             print(f"[CVision Forge] Interceptando URL remota: {resultado_pooling}")
             print("[CVision Forge] Transfiriendo flujo binario desde el clúster...")
-            
+
             cabeceras = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
-            peticion = requests.get(resultado_pooling, headers=cabeceras, stream=True, timeout=60)
-            
+            peticion = requests.get(
+                resultado_pooling,
+                headers=cabeceras,
+                stream=True,
+                timeout=90,  # Timeout ampliado para modelos pesados
+            )
+
             if peticion.status_code == 200:
                 ruta_estabilizada_glb = os.path.abspath("cvision_forge_output.glb")
                 with open(ruta_estabilizada_glb, "wb") as archivo_binario:
                     for bloque in peticion.iter_content(chunk_size=8192):
                         archivo_binario.write(bloque)
-                                
+
                 print(f"[CVision Forge] Binario remoto estabilizado con éxito: {ruta_estabilizada_glb}")
                 return ruta_estabilizada_glb
             else:
-                print(f"[CVision Error] El clúster denegó el flujo de bytes. Código HTTP: {peticion.status_code}")
+                print(
+                    f"[CVision Error] El clúster denegó el flujo de bytes. "
+                    f"Código HTTP: {peticion.status_code}"
+                )
                 return None
-                
+
     except Exception as error:
         print(f"[CVision Falla Crítica] Error en la intercepción de la malla binaria: {str(error)}")
-        
+
     return None
 
-def construir_bloque_forge():
+
+def construir_bloque_forge() -> gr.Blocks:
     """
     Inicializa el módulo estructural dentro de la interfaz global de CVision.
     Aplica la inyección visual Cybernova y conecta los listeners reactivos.
+    El bloque está aislado para evitar colisiones con otros orquestadores de la app.
     """
-    # Bloque modular aislado para evitar colisiones con otros orquestadores de la app
     with gr.Blocks(analytics_enabled=False) as forge_block:
-        gr.Markdown("### ⚔️ CVision Forge OS v9.0 — Panel de Manufactura Fotorrealista 3D ⚔️")
-                
+        gr.Markdown(
+            "### ⚔️ CVision Forge OS v9.0 — Panel de Manufactura Fotorrealista 3D ⚔️"
+        )
+
         with gr.Row():
+            # ── Panel izquierdo: entrada de la imagen 2D ─────────────────────────
             with gr.Column(scale=2):
                 gr.Markdown("#### 📥 Entrada de Matriz Estructural")
-                
+
                 input_imagen_2d = gr.Image(
                     label="Matriz Estructural de Perfil (Asset de Entrada)",
                     type="filepath",
-                    interactive=True
+                    interactive=True,
+                )
+
+                btn_forjar = gr.Button(
+                    "⚡ Iniciar Forja Tridimensional",
+                    variant="primary",
+                    size="lg",
+                )
+
+                gr.Markdown(
+                    """
+                    <div style="margin-top:20px; padding:10px; background:rgba(0,212,255,0.05);
+                                border-left:3px solid #00d4ff; font-size:11px; line-height:1.4;
+                                color:rgba(255,255,255,0.7);">
+                        <strong>⚙️ NOTA DE LOGÍSTICA:</strong> El procesamiento utiliza el motor
+                        de difusión de matrices densas de TRELLIS. El tiempo de resolución estimado
+                        oscila entre 20 y 60 segundos según la demanda del clúster de Hugging Face.
+                        El sistema rota automáticamente entre tres Spaces candidatos si el primario
+                        está bajo mantenimiento o sobrecarga.
+                    </div>
+                    """,
+                    sanitize_html=False,
                 )
-                
-                # Botón de disparo con alta prioridad de renderizado
-                btn_forjar = gr.Button("⚡ Iniciar Forja Tridimensional", variant="primary", size="lg")
-                
-                gr.Markdown("""
-                <div style="margin-top:20px; padding:10px; background:rgba(0,212,255,0.05); border-left:3px solid #00d4ff; font-size:11px; line-height:1.4; color:rgba(255,255,255,0.7);">
-                    <strong>⚙️ NOTA DE LOGÍSTICA:</strong> El procesamiento utiliza el motor de difusión de matrices densas de TRELLIS. El tiempo de resolución estimado oscila entre 20 y 45 segundos según la demanda del clúster de Hugging Face.
-                </div>
-                """, sanitize_html=False)
-                        
+
+            # ── Panel derecho: visor 3D nativo Gradio ────────────────────────────
             with gr.Column(scale=3):
                 gr.Markdown("#### 🌌 Matriz de Renderizado Tridimensional")
-                
+
                 # Visor nativo con parámetros de color acoplados a la estética Cybernova
                 visor_3d = gr.Model3D(
                     label="Forja Geométrica Realizada (Motor TRELLIS)",
                     clear_color=[0.04, 0.06, 0.1, 1.0],
-                    camera_position=[0, 0, 2]
+                    camera_position=[0, 0, 2],
                 )
-        
-        # Vinculación del evento click con animación interna de carga de Gradio
+
+        # ── Vinculación del evento click con animación interna de carga de Gradio ─
         btn_forjar.click(
             fn=puente_forja_y_descarga,
             inputs=[input_imagen_2d],
             outputs=[visor_3d],
-            api_name="solicitud_forja_3d"
+            api_name="solicitud_forja_3d",
         )
-            
+
     return forge_block