Update app.py

app.py

@@ -1,124 +1,133 @@
-// VALIDACIÓN DE SEGURIDAD - Lovable debe implementar esto
-function validateHFOnly(endpoint) {
-  const allowedDomains = [
-    'api-inference.huggingface.co',
-    'huggingface.co'
-  ];
-  
-  const url = new URL(endpoint);
-  if (!allowedDomains.includes(url.hostname)) {
-    throw new Error('BLOQUEO: Intento de usar plataforma no autorizada');
-  }
-}
+# -*- coding: utf-8 -*-
+"""
+GTP-FLUX-BAT: Chat + Imágenes con Hugging Face (100% GRATIS)
+- Solo modelos HF permitidos
+- Bloqueo total a otras APIs
+- Genera imágenes con FLUX.1
+- Chat con gpt2-large
+"""
 
-// USO EN TODAS LAS LLAMADAS
-async function secureHFRequest(model, payload) {
-  const endpoint = `https://api-inference.huggingface.co/models/${model}`;
-  validateHFOnly(endpoint); // Bloquea si no es HF
-  
-  // Proceder con la solicitud...
-}// MODELOS PERMITIDOS - LISTA BLANCA
-const ALLOWED_MODELS = {
-  chat: ['gpt2', 'gpt2-medium', 'gpt2-large', 'gpt2-xl'],
-  image: [
-    'black-forest-labs/FLUX.1-dev',
-    'black-forest-labs/FLUX.1-schnell', 
-    'black-forest-labs/FLUX.1-schnell-4bit'
-  ]
-};function isHuggingFaceEndpoint(url) {
-  return url.includes('huggingface.co') && 
-         !url.includes('replicate') &&
-         !url.includes('openai') &&
-         !url.includes('stability');
-"Error: Solo usamos Hugging Face.""Modelos actuales: FLUX.1-dev, FLUX.1-schnell, FLUX.1-schnell-4bit"
-Todos gratuitos con tu token de HF."Usuario: "Genera un paisaje"
-→ GTP-FLUX-BAT detecta necesidad de imagen
-→ SOLO consulta modelos HF de la lista blanca
-→ Si falla FLUX.1-dev, intenta FLUX.1-schnell
-→ Si falla FLUX.1-schnell, intenta FLUX.1-schnell-4bit
-→ Si todos fallan: "Hugging Face no disponible, intenta más tarde"
-→ NUNCA: "Usando DALL-E..." o "Conectando a Replicate...""Crear un chatbot llamado 'GTP-FLUX-BAT' que integre conversación natural con generación automática de imágenes usando EXCLUSIVAMENTE modelos gratuitos de Hugging Face.
+import gradio as gr
+import requests
+import io
+from PIL import Image
+import os
+from urllib.parse import urlparse
 
-BLOQUEO ABSOLUTO: NO usar APIs de pago, NO usar Replicate, NO usar OpenAI, NO usar Stability AI directo, SOLO Hugging Face Inference API.
+# --- VALIDACIÓN DE SEGURIDAD ---
+def validate_hf_only(endpoint: str):
+    allowed = ["api-inference.huggingface.co", "huggingface.co"]
+    hostname = urlparse(endpoint).hostname
+    if hostname not in allowed:
+        raise ValueError("BLOQUEO: Solo se permite Hugging Face")
 
-ARQUITECTURA TÉCNICA:
+# --- MODELOS PERMITIDOS ---
+HF_CHAT_MODEL = "gpt2-large"
+HF_IMAGE_MODELS = [
+    "black-forest-labs/FLUX.1-dev",
+    "black-forest-labs/FLUX.1-schnell",
+    "black-forest-labs/FLUX.1-schnell-4bit"
+]
 
-1. **MOTOR DE CHAT (Hugging Face):**
-   - Modelo: 'gpt2-large' de Hugging Face
-   - Endpoint: https://api-inference.huggingface.co/models/gpt2-large
-
-2. **MOTORES DE IMAGEN (Hugging Face EXCLUSIVO):**
-   - PRIMARIO: 'black-forest-labs/FLUX.1-dev'
-   - SECUNDARIO: 'black-forest-labs/FLUX.1-schnell'
-   - TERCIARIO: 'black-forest-labs/FLUX.1-schnell-4bit'
-   - Endpoint: https://api-inference.huggingface.co/models/[MODELO]
+# --- GENERAR TEXTO CON HF ---
+def generate_text_hf(prompt: str, hf_token: str):
+    validate_hf_only("https://api-inference.huggingface.co")
+    url = f"https://api-inference.huggingface.co/models/{HF_CHAT_MODEL}"
+    headers = {"Authorization": f"Bearer {hf_token}"}
+    payload = {"inputs": prompt, "parameters": {"max_length": 100}}
+    try:
+        response = requests.post(url, headers=headers, json=payload, timeout=30)
+        if response.status_code == 200:
+            return response.json()[0]["generated_text"]
+    except:
+        pass
+    return "No pude generar texto. Intenta más tarde."# --- GENERAR IMAGEN CON HF (solo lista blanca) ---
+def generate_image_hf_only(prompt: str, hf_token: str):
+    validate_hf_only("https://api-inference.huggingface.co")
+    for model in HF_IMAGE_MODELS:
+        try:
+            url = f"https://api-inference.huggingface.co/models/{model}"
+            headers = {"Authorization": f"Bearer {hf_token}"}
+            payload = {
+                "inputs": prompt,
+                "parameters": {
+                    "num_inference_steps": 20,
+                    "guidance_scale": 7.5,
+                    "width": 1024,
+                    "height": 1024
+                }
+            }
+            response = requests.post(url, headers=headers, json=payload, timeout=60)
+            if response.status_code == 200:
+                return response.content  # bytes
+        except Exception as e:
+            print(f"Modelo {model} falló: {e}")
+            continue
+    raise RuntimeError("Todos los modelos de imagen HF están temporalmente no disponibles")# --- DETECCIÓN DE IMAGEN ---
+def needs_image(user_input: str) -> bool:
+    keywords = ["imagen", "genera", "dibuja", "foto", "paisaje", "retrato", "crea"]
+    return any(k in user_input.lower() for k in keywords)
 
-3. **LÓGICA DE GENERACIÓN BLOQUEADA:**
-   - SOLO usar Hugging Face Inference API
-   - NUNCA redirigir a otras plataformas
-   - Si un modelo falla, intentar el siguiente modelo de HF
-   - MOSTRAR ERROR si todos los modelos de HF fallan
+# --- RESPUESTA COMPLETA ---
+def respond_to_user(message: str, history: list, hf_token: str):
+    if not hf_token or not hf_token.startswith("hf_"):
+        return history + [(message, "Ingresa un token válido de Hugging Face.")], None
 
-CÓDIGO DE IMPLEMENTACIÓN:
+    bot_response = generate_text_hf(message, hf_token)
+    image_bytes = None
 
-const HF_CHAT_MODEL = 'gpt2-large';
-const HF_IMAGE_MODELS = [
-  'black-forest-labs/FLUX.1-dev',
-  'black-forest-labs/FLUX.1-schnell',
-  'black-forest-labs/FLUX.1-schnell-4bit'
-];
+    if needs_image(message):
+        try:
+            bot_response += "\n\nGenerando imagen..."
+            image_bytes = generate_image_hf_only(message, hf_token)
+            bot_response = bot_response.replace("Generando imagen...", "Imagen generada:")
+        except Exception as e:
+            bot_response += f"\n\n{str(e)}"
 
-// SOLO Hugging Face - BLOQUEAR otras APIs
-async function generateImageHFOnly(prompt) {
-  for (const model of HF_IMAGE_MODELS) {
-    try {
-      const response = await fetch(
-        `https://api-inference.huggingface.co/models/${model}`,
-        {
-          method: 'POST',
-          headers: {
-            'Authorization': `Bearer ${process.env.HF_TOKEN}`,
-            'Content-Type': 'application/json'
-          },
-          body: JSON.stringify({
-            inputs: prompt,
-            parameters: {
-              num_inference_steps: 20,
-              guidance_scale: 7.5,
-              width: 1024,
-              height: 1024
-            }
-          })
-        }
-      );
-      
-      if (response.ok) {
-        return await response.blob();
-      }
-    } catch (error) {
-      continue; // Intentar siguiente modelo de HF
-    }
-  }
-  throw new Error('Todos los modelos de Hugging Face están temporalmente no disponibles');
-}
+    history.append((message, bot_response))
+    return history, image_bytes# --- INTERFAZ GRADIO ---
+with gr.Blocks(title="GTP-FLUX-BAT", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # GTP-FLUX-BAT  
+    **Chat + Imágenes 100% GRATIS con Hugging Face**  
+    Modelos: `gpt2-large` + `FLUX.1-dev/schnell`  
+    **SOLO Hugging Face · Nunca Replicate/OpenAI**
+    """)
 
-INTERFAZ Y FLUJO:
+    with gr.Row():
+        token_input = gr.Textbox(
+            label="Token de Hugging Face",
+            placeholder="hf_xxxxxxxxxxxxxxxxxxxxx",
+            type="password",
+            scale=3
+        )
+        gr.Markdown("**Obtén tu token en [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens)**")
 
-- Chat conversacional natural
-- Detección automática de solicitudes de imágenes
-- Generación con modelos HF sin interacción del usuario
-- Mensajes de error específicos: 'Servicio Hugging Face no disponible'
-- Diseño unificado donde imágenes aparecen en la conversación
+    chatbot = gr.Chatbot(height=500)
+    msg = gr.Textbox(label="Tu mensaje", placeholder="Escribe aquí...", scale=4)
+    clear = gr.Button("Limpiar chat")
+    img_out = gr.Image(label="Imagen generada", height=400)
 
-VALIDACIÓN DE IMPLEMENTACIÓN:
+    # --- EVENTOS ---
+    def submit(message, history, token):
+        if not message.strip():
+            return history, None
+        new_history, img = respond_to_user(message, history, token)
+        return new_history, "", img
 
-- Verificar que TODAS las llamadas sean a 'api-inference.huggingface.co'
-- Confirmar que los modelos sean EXACTAMENTE los especificados
-- Rechazar cualquier alternativa de pago o otras plataformas
-- Usar SOLO el token de Hugging Face para autenticación
+    msg.submit(submit, [msg, chatbot, token_input], [chatbot, msg, img_out])
+    clear.click(lambda: ([], None), outputs=[chatbot, img_out])# --- MENSAJE DE INICIO ---
+    gr.Markdown("""
+    ### Instrucciones:
+    1. Pega tu **token de Hugging Face** arriba  
+    2. Escribe: _"Genera un paisaje al atardecer"_  
+    3. ¡El bot responde y genera la imagen automáticamente!  
 
-PALABRAS CLAVE BLOQUEADAS: 
-NO 'replicate', NO 'openai', NO 'stabilityai', NO 'midjourney', 
-NO 'dall-e', NO 'commercial API', SOLO 'huggingface', SOLO 'inference API'
+    **Modelos usados:**  
+    - Texto: `gpt2-large`  
+    - Imagen: `FLUX.1-dev` → `schnell` → `4bit` (solo HF)  
+    """)
 
-ESTE SISTEMA DEBE SER 100% GRATUITO USANDO EXCLUSIVAMENTE HUGGING FACE."
+# --- LANZAR ---
+if __name__ == "__main__":
+    demo.launch(share=True)