Update app.py

app.py

@@ -2,28 +2,30 @@ import os
 import tempfile
 import subprocess
 import streamlit as st
-from transformers import AutoTokenizer
 from huggingface_hub import InferenceClient
 
-st.set_page_config(page_title="Python to C++17 Translator", layout="wide")
+# Configuración de la página
+st.set_page_config(page_title="Python to C++17 Translator", page_icon="⚙️", layout="wide")
 
+# Inicializar estado del chat
 if "messages" not in st.session_state:
     st.session_state.messages = []
 
+# Sidebar para configuración
 with st.sidebar:
-    st.header("Configuracion del Modelo")
+    st.header("Configuración del Modelo")
     selected_model = st.selectbox(
         "Selecciona el modelo de Hugging Face:",
         [
+            "Qwen/Qwen2.5-Coder-32B-Instruct", # Actualmente el mejor modelo gratuito para código
             "Qwen/CodeQwen1.5-7B-Chat",
-            "meta-llama/CodeLlama-13b-Instruct-hf",
-            "bigcode/starcoder2-15b"
+            "meta-llama/CodeLlama-13b-Instruct-hf"
         ],
         index=0
     )
     
     st.markdown("---")
-    st.markdown("### Entorno de Ejecucion")
+    st.markdown("### Entorno de Ejecución")
     st.code("g++ -O3 -std=c++17", language="bash")
     
     if st.button("Limpiar Historial"):
@@ -40,7 +42,7 @@ def get_system_prompt() -> str:
     )
 
 def extract_cpp_code(response_text: str) -> str:
-    """Extrae el codigo C++ limpiando los bloques de markdown."""
+    """Extrae el código C++ limpiando los bloques de markdown."""
     if "```cpp" in response_text:
         code = response_text.split("```cpp")[1].split("```")[0]
     elif "```c++" in response_text:
@@ -52,7 +54,7 @@ def extract_cpp_code(response_text: str) -> str:
     return code.strip()
 
 def compile_and_run_cpp(cpp_code: str) -> str:
-    """Compila y ejecuta el codigo C++ en el entorno Linux de HF Spaces."""
+    """Compila y ejecuta el código C++ en el entorno Linux de HF Spaces."""
     with tempfile.TemporaryDirectory() as tmpdir:
         cpp_file = os.path.join(tmpdir, "optimized.cpp")
         exe_file = os.path.join(tmpdir, "optimized_bin")
@@ -60,86 +62,78 @@ def compile_and_run_cpp(cpp_code: str) -> str:
         with open(cpp_file, "w") as f:
             f.write(cpp_code)
         
-        # Compilacion estricta con C++17 (HF Spaces usa Debian/Ubuntu con g++ disponible)
         compile_cmd = ["g++", "-O3", "-std=c++17", cpp_file, "-o", exe_file]
         
         try:
             # Compilar
             comp_process = subprocess.run(compile_cmd, capture_output=True, text=True, check=True)
-            
             # Ejecutar
             run_process = subprocess.run([exe_file], capture_output=True, text=True, timeout=10)
             
             output = run_process.stdout
             if run_process.stderr:
                 output += f"\nWarnings/Errors:\n{run_process.stderr}"
-            return output if output else "Ejecucion completada sin salida (stdout vacío)."
+            return output if output else "Ejecución completada sin salida (stdout vacío)."
             
         except subprocess.CalledProcessError as e:
-            return f"Error de Compilacion:\n{e.stderr}"
+            return f"⚠️ Error de Compilación:\n{e.stderr}"
         except subprocess.TimeoutExpired:
-            return "Timeout: La ejecucion excedio los 10 segundos."
+            return "⏳ Timeout: La ejecución excedió los 10 segundos."
 
-st.title("Python ➔ C++ Auto-Translator")
-st.markdown("Pega tu codigo de Python en el chat. El sistema generarala traduccion a C++17 y la ejecutara automaticamente.")
+st.title("🐍 Python ➔ ⚙️ C++17 Auto-Translator")
+st.markdown("Pega tu código de Python en el chat. El sistema generará la traducción a C++17 y la ejecutará automáticamente.")
 
+# Renderizar el historial de mensajes
 for msg in st.session_state.messages:
     with st.chat_message(msg["role"]):
         if msg["role"] == "user":
             st.code(msg["content"], language="python")
         else:
             st.code(msg["content"]["code"], language="cpp")
-            with st.expander("Ver salida de ejecucion"):
+            with st.expander("Ver salida de ejecución"):
                 st.text(msg["content"]["output"])
 
-if prompt := st.chat_input("Escribe o pega tu codigo Python aqui..."):
-    # Añadir input del usuario al estado y mostrarlo
+# Manejo de nuevo input en el chat
+if prompt := st.chat_input("Escribe o pega tu código Python aquí..."):
     st.session_state.messages.append({"role": "user", "content": prompt})
     with st.chat_message("user"):
         st.code(prompt, language="python")
 
-    # Preparar el cliente de Hugging Face
     hf_token = os.getenv("HF_TOKEN")
+    if not hf_token:
+        st.error("⚠️ ERROR CRÍTICO: No se encontró el HF_TOKEN. Ve a Settings -> Variables and secrets y configúralo.")
+        st.stop()
+
     client = InferenceClient(model=selected_model, token=hf_token)
-    tokenizer = AutoTokenizer.from_pretrained(selected_model)
 
     messages_for_hf = [
         {"role": "system", "content": get_system_prompt()},
         {"role": "user", "content": f"Translate this Python code to C++:\n\n{prompt}"}
     ]
 
-    # Convertir al formato de chat específico del modelo
-    try:
-        formatted_prompt = tokenizer.apply_chat_template(messages_for_hf, tokenize=False, add_generation_prompt=True)
-    except Exception:
-        # Fallback por si el tokenizador no soporta apply_chat_template directamente
-        formatted_prompt = f"{get_system_prompt()}\n\nUser: Translate this Python code to C++:\n{prompt}\n\nAssistant:"
-
-    # Generar respuesta del asistente
     with st.chat_message("assistant"):
-        with st.spinner("Traduciendo a C++17..."):
+        with st.spinner("Conectando con la API y traduciendo a C++17..."):
             try:
-                # Generacion (sin streaming complejo en UI para facilitar la extraccion y compilacion inmediata)
-                response = client.text_generation(
-                    formatted_prompt, 
-                    max_new_tokens=3000,
-                    temperature=0.1, # Baja temperatura para codigo más determinista
-                    return_full_text=False
+                # Usamos la nueva API de chat (más estable, no requiere Tokenizer local)
+                response = client.chat_completion(
+                    messages=messages_for_hf,
+                    max_tokens=3000,
+                    temperature=0.1
                 )
                 
-                clean_cpp = extract_cpp_code(response)
+                generated_text = response.choices[0].message.content
+                clean_cpp = extract_cpp_code(generated_text)
                 st.code(clean_cpp, language="cpp")
                 
                 st.markdown("---")
-                st.markdown("**Ejecutando binario...**")
+                st.markdown("⚡ **Ejecutando binario...**")
                 
                 with st.spinner("Compilando y ejecutando..."):
                     execution_output = compile_and_run_cpp(clean_cpp)
                     
-                with st.expander("Salida de ejecucion (stdout)", expanded=True):
+                with st.expander("Salida de ejecución (stdout)", expanded=True):
                     st.text(execution_output)
                     
-                # Guardar en el historial
                 st.session_state.messages.append({
                     "role": "assistant", 
                     "content": {
@@ -149,4 +143,4 @@ if prompt := st.chat_input("Escribe o pega tu codigo Python aqui..."):
                 })
 
             except Exception as e:
-                st.error(f"Error al conectar con Hugging Face API: {str(e)}")
+                st.error(f"Error detallado de la API: {type(e).__name__} - {str(e)}")