app.py

import gradio as gr
from transformers import GPT2LMHeadModel, GPT2Tokenizer, BartForConditionalGeneration, BartTokenizer
import torch

# Configurar el dispositivo (CPU)
device = torch.device("cpu")

# Cargar el modelo y tokenizer para autocompletar código
print("Cargando modelo code-autocomplete-gpt2-base...")
model_name = "shibing624/code-autocomplete-gpt2-base"
tokenizer = GPT2Tokenizer.from_pretrained(model_name)
model = GPT2LMHeadModel.from_pretrained(model_name)

# Mover modelo a CPU y ponerlo en modo evaluación
model.to(device)
model.eval()

# Configurar pad_token si no existe
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

# Cargar BART para simplificación de texto
print("Cargando modelo BART para simplificación...")
bart_model_name = "facebook/bart-base"
bart_tokenizer = BartTokenizer.from_pretrained(bart_model_name)
bart_model = BartForConditionalGeneration.from_pretrained(bart_model_name)

# Mover BART a CPU y ponerlo en modo evaluación
bart_model.to(device)
bart_model.eval()

def autocomplete_text(input_text, max_tokens=5):
    """
    Autocompleta texto común en español basado en el inicio de palabras
    
    Args:
        input_text (str): Texto inicial a completar
        max_tokens (int): Número máximo de tokens a generar
    
    Returns:
        str: Solo la parte nueva generada (sin el input original)
    """
    if not input_text.strip():
        return "Por favor, ingresa algún texto para completar."
    
    # Diccionario de autocompletado común en español
    common_completions = {
        'h': ['hola', 'hacer', 'historia', 'hermano', 'hospital', 'habitación'],
        'ho': ['hola', 'hombre', 'hospital', 'hoy', 'hogar'],
        'hol': ['hola'],
        'c': ['casa', 'comer', 'coche', 'computadora', 'ciudad', 'cambiar'],
        'ca': ['casa', 'carro', 'cambiar', 'caminar', 'calor'],
        'cas': ['casa', 'casi'],
        'com': ['comer', 'computadora', 'comprar', 'completar'],
        'comp': ['computadora', 'comprar', 'completar', 'comprimir'],
        'compu': ['computadora'],
        'g': ['gracias', 'grande', 'gente', 'guitarra', 'ganar'],
        'gr': ['gracias', 'grande', 'grupo'],
        'gra': ['gracias', 'grande'],
        'graci': ['gracias'],
        'b': ['bien', 'bueno', 'beber', 'buscar', 'bailar'],
        'bi': ['bien', 'bicicleta'],
        'bu': ['bueno', 'buscar'],
        'bue': ['bueno', 'buenos'],
        'buen': ['bueno', 'buenos'],
        'm': ['muy', 'madre', 'mesa', 'música', 'mañana'],
        'mu': ['muy', 'música', 'mujer', 'mundo'],
        'muy': ['muy'],
        't': ['trabajo', 'tiempo', 'teléfono', 'también', 'tener'],
        'tr': ['trabajo', 'tres', 'transporte'],
        'tra': ['trabajo', 'transporte'],
        'trab': ['trabajo'],
        'trabaj': ['trabajo'],
        'p': ['por', 'para', 'persona', 'programa', 'problema'],
        'po': ['por', 'poder'],
        'pr': ['programa', 'problema', 'primero'],
        'pro': ['programa', 'problema', 'proceso'],
        'prog': ['programa'],
        'progr': ['programa'],
        'progra': ['programa'],
        'program': ['programa'],
        'e': ['escribir', 'estudiar', 'escuela', 'entender', 'español'],
        'es': ['escribir', 'estudiar', 'escuela', 'español', 'estar'],
        'esc': ['escribir', 'escuela'],
        'escr': ['escribir'],
        'escri': ['escribir'],
        'escrib': ['escribir'],
        'escribi': ['escribir'],
        'a': ['aplicación', 'agua', 'amigo', 'aprender', 'ayuda'],
        'ap': ['aplicación', 'aprender', 'ayuda'],
        'apl': ['aplicación'],
        'apli': ['aplicación'],
        'aplic': ['aplicación'],
        'aplica': ['aplicación'],
        'aplicaci': ['aplicación'],
        'aplicacio': ['aplicación'],
        'aplicacion': ['aplicación'],
        'v': ['ver', 'venir', 'vida', 'viaje', 'ventana'],
        've': ['ver', 'venir', 'ventana'],
        'ven': ['venir', 'ventana'],
        'veni': ['venir'],
        'd': ['de', 'día', 'decir', 'dinero', 'diferente'],
        'di': ['día', 'dinero', 'diferente'],
        'dia': ['día'],
        'n': ['no', 'necesitar', 'noche', 'número', 'nuevo'],
        'nu': ['número', 'nuevo'],
        'nue': ['nuevo'],
        'nuev': ['nuevo'],
        's': ['sí', 'ser', 'sistema', 'salir', 'semana'],
        'si': ['sí', 'sistema', 'siempre'],
        'sis': ['sistema'],
        'sist': ['sistema'],
        'siste': ['sistema'],
        'sistem': ['sistema'],
        'l': ['la', 'lo', 'lugar', 'llamar', 'leer'],
        'lu': ['lugar'],
        'lug': ['lugar'],
        'luga': ['lugar'],
        'r': ['rápido', 'recordar', 'respuesta', 'resultado', 'realizar'],
        'ra': ['rápido'],
        'rap': ['rápido'],
        'rapi': ['rápido'],
        'rapid': ['rápido'],
        'rapido': ['rápido']
    }
    
    input_lower = input_text.lower().strip()
    
    # Buscar coincidencias exactas primero
    if input_lower in common_completions:
        suggestions = common_completions[input_lower]
        # Filtrar para mostrar solo las que son diferentes al input
        filtered_suggestions = [word for word in suggestions if word != input_lower]
        if filtered_suggestions:
            # Retornar la primera sugerencia sin el input original
            best_match = filtered_suggestions[0]
            return best_match[len(input_lower):]
    
    # Si no hay coincidencia exacta, buscar palabras que empiecen con el input
    matching_words = []
    for word_list in common_completions.values():
        for word in word_list:
            if word.startswith(input_lower) and word != input_lower:
                matching_words.append(word)
    
    if matching_words:
        # Ordenar por longitud (más cortas primero) y tomar la primera
        matching_words.sort(key=len)
        best_match = matching_words[0]
        return best_match[len(input_lower):]
    
    # Si no encuentra coincidencias en el diccionario, usar el modelo GPT-2
    try:
        # Tokenizar el texto de entrada
        inputs = tokenizer.encode(input_text, return_tensors="pt", padding=True)
        inputs = inputs.to(device)
        
        # Generar texto
        with torch.no_grad():
            outputs = model.generate(
                inputs,
                max_new_tokens=max_tokens,
                num_return_sequences=1,
                temperature=0.7,
                do_sample=True,
                pad_token_id=tokenizer.eos_token_id,
                eos_token_id=tokenizer.eos_token_id,
                attention_mask=torch.ones_like(inputs)
            )
        
        # Decodificar el resultado completo
        generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
        
        # Extraer solo la parte nueva (sin el input original)
        new_text = generated_text[len(input_text):].strip()
        
        if not new_text:
            return "No se encontraron sugerencias."
        
        return new_text
        
    except Exception as e:
        return f"Error al generar sugerencias: {str(e)}"

def simplify_text(input_text, max_length=150):
    """
    Simplifica texto complejo usando BART
    
    Args:
        input_text (str): Texto complejo a simplificar
        max_length (int): Longitud máxima del texto simplificado
    
    Returns:
        str: Texto simplificado con palabras más sencillas
    """
    if not input_text.strip():
        return "Por favor, ingresa algún texto para simplificar."
    
    try:
        # Crear un prompt para guiar la simplificación
        prompt = f"Simplify this text using easier words: {input_text}"
        
        # Tokenizar el texto
        inputs = bart_tokenizer.encode(prompt, return_tensors="pt", max_length=512, truncation=True)
        inputs = inputs.to(device)
        
        # Generar texto simplificado
        with torch.no_grad():
            outputs = bart_model.generate(
                inputs,
                max_length=max_length,
                min_length=20,
                num_return_sequences=1,
                temperature=0.7,
                do_sample=True,
                early_stopping=True,
                no_repeat_ngram_size=2,
                pad_token_id=bart_tokenizer.pad_token_id,
                eos_token_id=bart_tokenizer.eos_token_id
            )
        
        # Decodificar el resultado
        simplified_text = bart_tokenizer.decode(outputs[0], skip_special_tokens=True)
        
        # Limpiar el texto (remover el prompt si aparece)
        if simplified_text.startswith("Simplify this text using easier words:"):
            simplified_text = simplified_text.replace("Simplify this text using easier words:", "").strip()
        
        if not simplified_text:
            return "No se pudo simplificar el texto."
        
        return simplified_text
        
    except Exception as e:
        return f"Error al simplificar texto: {str(e)}"

def create_autocomplete_interface():
    """
    Crea la interfaz con autocompletar y simplificación dentro de gr.Blocks()
    """
    
    with gr.Blocks(title="Asistente de Texto") as demo:
        
        gr.Markdown("# 🤖 Asistente de Texto")
        gr.Markdown("Herramientas para autocompletar palabras y simplificar textos complejos.")
        
        with gr.Tab("Autocompletar"):
            with gr.Row():
                with gr.Column():
                    input_textbox = gr.Textbox(
                        label="Texto a completar",
                        placeholder="Escribe 'h' para ver 'hola'...",
                        lines=3,
                        max_lines=5
                    )
                    
                    generate_btn = gr.Button("Completar Texto", variant="primary")
                    
                with gr.Column():
                    output_textbox = gr.Textbox(
                        label="Sugerencia de completado",
                        placeholder="Aquí aparecerá la sugerencia...",
                        lines=3,
                        max_lines=5,
                        interactive=False
                    )
            
            # Conectar el botón con la función
            generate_btn.click(
                fn=autocomplete_text,
                inputs=[input_textbox],
                outputs=[output_textbox]
            )
            
            # También permitir Enter para generar
            input_textbox.submit(
                fn=autocomplete_text,
                inputs=[input_textbox],
                outputs=[output_textbox]
            )
            
        # Nueva pestaña para simplificar texto
        with gr.Tab("Simplificar Texto"):
            with gr.Row():
                with gr.Column():
                    text_input = gr.Textbox(
                        label="Texto complejo a simplificar",
                        placeholder="Ingresa aquí el texto difícil de entender...",
                        lines=6,
                        max_lines=12
                    )
                    
                    simplify_btn = gr.Button("Simplificar Texto", variant="secondary")
                    
                with gr.Column():
                    simplified_output = gr.Textbox(
                        label="Texto simplificado",
                        placeholder="Aquí aparecerá el texto más fácil de entender...",
                        lines=6,
                        max_lines=12,
                        interactive=False
                    )
            
            # Conectar el botón de simplificar
            simplify_btn.click(
                fn=simplify_text,
                inputs=[text_input],
                outputs=[simplified_output]
            )
            
            # También permitir Enter para simplificar
            text_input.submit(
                fn=simplify_text,
                inputs=[text_input],
                outputs=[simplified_output]
            )
            
        # Pestaña adicional con ejemplos
        with gr.Tab("Ejemplos"):
            gr.Markdown("""
            ### Ejemplos de Autocompletado de Palabras:
            
            **Entrada:** "h"
            **Salida:** "ola" (completa "hola")
            
            **Entrada:** "gra"
            **Salida:** "cias" (completa "gracias")
            
            **Entrada:** "compu"
            **Salida:** "tadora" (completa "computadora")
            
            **Entrada:** "prog"
            **Salida:** "rama" (completa "programa")
            
            **Entrada:** "escrib"
            **Salida:** "ir" (completa "escribir")
            
            ---
            
            ### Ejemplos de Simplificación de Texto:
            
            **Texto complejo:** "La implementación de algoritmos de machine learning requiere una comprensión profunda de estructuras de datos y técnicas de optimización."
            **Texto simple:** "Para usar inteligencia artificial necesitas entender bien cómo organizar datos y mejorar programas."
            
            **Texto complejo:** "El protocolo de comunicación asíncrona permite la transmisión de datos sin sincronización temporal."
            **Texto simple:** "Este método permite enviar información sin esperar a que termine el envío anterior."
            """)
    
    return demo

# Crear y lanzar la aplicación
if __name__ == "__main__":
    print("Iniciando aplicación de asistente de texto y código...")
    
    # Crear la interfaz
    app = create_autocomplete_interface()
    
    # Lanzar la aplicación
    app.launch(
        share=False,  # Cambiar a True si quieres compartir públicamente
        server_name="0.0.0.0",  # Permite acceso desde otras máquinas en la red local
        server_port=7860,  # Puerto por defecto de Gradio
        show_error=True,
        debug=False
    )